mirror of
https://github.com/openclaw/openclaw.git
synced 2026-05-18 10:14:45 +00:00
2194 lines
69 KiB
JavaScript
2194 lines
69 KiB
JavaScript
#!/usr/bin/env -S node --import tsx
|
|
|
|
import { type ChildProcess, spawn, type SpawnOptionsWithoutStdio } from "node:child_process";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
|
|
type CommandResult = {
|
|
stderr: string;
|
|
stdout: string;
|
|
};
|
|
|
|
type JsonObject = Record<string, unknown>;
|
|
|
|
type PreviewCrop = "telegram-window";
|
|
|
|
type CrabboxInspect = {
|
|
host?: string;
|
|
id?: string;
|
|
slug?: string;
|
|
sshKey?: string;
|
|
sshPort?: string;
|
|
sshUser?: string;
|
|
state?: string;
|
|
};
|
|
|
|
type Options = {
|
|
crabboxClass: string;
|
|
command:
|
|
| "finish"
|
|
| "probe"
|
|
| "publish"
|
|
| "run"
|
|
| "screenshot"
|
|
| "send"
|
|
| "start"
|
|
| "status"
|
|
| "view";
|
|
crabboxBin: string;
|
|
desktopChatTitle: string;
|
|
dryRun: boolean;
|
|
envFile?: string;
|
|
expect: string[];
|
|
gatewayPort: number;
|
|
idleTimeout: string;
|
|
keepBox: boolean;
|
|
leaseId?: string;
|
|
mockResponseText: string;
|
|
mockPort: number;
|
|
outputDir: string;
|
|
messageId?: string;
|
|
previewCrop?: PreviewCrop;
|
|
previewFps: number;
|
|
previewCropWidth: number;
|
|
previewWidth: number;
|
|
provider: string;
|
|
publishFullArtifacts: boolean;
|
|
publishPr?: number;
|
|
publishRepo: string;
|
|
publishSummary?: string;
|
|
recordFps: number;
|
|
recordSeconds: number;
|
|
remoteCommand: string[];
|
|
sessionFile?: string;
|
|
sutUsername?: string;
|
|
target: string;
|
|
tdlibSha256?: string;
|
|
tdlibUrl?: string;
|
|
text: string;
|
|
timeoutMs: number;
|
|
ttl: string;
|
|
userDriverScript: string;
|
|
};
|
|
|
|
type LocalSut = {
|
|
configPath: string;
|
|
drained: {
|
|
drained: number;
|
|
pendingAfter?: number;
|
|
pendingBefore?: number;
|
|
webhookUrlSet: boolean;
|
|
};
|
|
mock: ChildProcess;
|
|
mockLog: string;
|
|
requestLog: string;
|
|
stateDir: string;
|
|
tempRoot: string;
|
|
workspace: string;
|
|
gateway: ChildProcess;
|
|
gatewayLog: string;
|
|
};
|
|
|
|
type SessionFile = {
|
|
command: "telegram-user-crabbox-session";
|
|
createdAt: string;
|
|
crabbox: {
|
|
class: string;
|
|
createdLease: boolean;
|
|
id: string;
|
|
inspect: CrabboxInspect;
|
|
provider: string;
|
|
target: string;
|
|
};
|
|
credential: {
|
|
groupId: string;
|
|
leaseFile: string;
|
|
sutUsername: string;
|
|
testerUserId: string;
|
|
testerUsername: string;
|
|
};
|
|
localRoot: string;
|
|
localSut: {
|
|
gatewayLog: string;
|
|
gatewayPid: number;
|
|
mockLog: string;
|
|
mockPid: number;
|
|
requestLog: string;
|
|
stateDir: string;
|
|
tempRoot: string;
|
|
workspace: string;
|
|
};
|
|
outputDir: string;
|
|
recorder: {
|
|
log: string;
|
|
pidFile: string;
|
|
remoteVideo: string;
|
|
};
|
|
remoteRoot: string;
|
|
};
|
|
|
|
const DEFAULT_SKILL_DIR = "~/.codex/skills/custom/telegram-e2e-bot-to-bot";
|
|
const DEFAULT_CONVEX_ENV_FILE = `${DEFAULT_SKILL_DIR}/convex.local.env`;
|
|
const DEFAULT_USER_DRIVER = "scripts/e2e/telegram-user-driver.py";
|
|
const DEFAULT_OUTPUT_ROOT = ".artifacts/qa-e2e/telegram-user-crabbox";
|
|
const REMOTE_ROOT = "/tmp/openclaw-telegram-user-crabbox";
|
|
const CREDENTIAL_SCRIPT = fileURLToPath(new URL("./telegram-user-credential.ts", import.meta.url));
|
|
const TELEGRAM_PROOF_VIEW = {
|
|
cropWidth: 520,
|
|
height: 1000,
|
|
width: 650,
|
|
x: 635,
|
|
y: 40,
|
|
};
|
|
|
|
function usageText() {
|
|
return [
|
|
"Usage:",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts [probe] [--text /status] [--expect OpenClaw]",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts start [--tdlib-url <url>]",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts send --session <session.json> --text <text>",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts run --session <session.json> -- <remote command>",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts view --session <session.json> --message-id <id>",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts screenshot --session <session.json>",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts status --session <session.json>",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts finish --session <session.json>",
|
|
" node --import tsx scripts/e2e/telegram-user-crabbox-proof.ts publish --session <session.json> --pr <number>",
|
|
"",
|
|
"Useful options:",
|
|
" --class <name> Crabbox machine class. Default: standard.",
|
|
" --desktop-chat-title <name> Telegram Desktop chat to select before recording.",
|
|
" --id <cbx_id> Reuse an existing Crabbox desktop lease.",
|
|
" --keep-box Leave the Crabbox lease running for VNC debugging.",
|
|
" --mock-response-file <path> Text returned by the mock model.",
|
|
" --output-dir <path> Artifact directory under the repo.",
|
|
" --message-id <id> Telegram message id for proof-view deep link.",
|
|
" --preview-crop telegram-window Create a side-by-side friendly Telegram-window GIF.",
|
|
" --preview-crop-width <pixels> Cropped preview GIF width. Default: 520.",
|
|
" --preview-fps <fps> Motion GIF frames per second. Default: 24.",
|
|
" --preview-width <pixels> Motion GIF width. Default: 1920.",
|
|
" --pr <number> Pull request number for publish.",
|
|
" --record-fps <fps> Desktop recording frames per second. Default: 24.",
|
|
" --record-seconds <seconds> Desktop video duration. Default: 35.",
|
|
" --repo <owner/name> GitHub repo for publish. Default: openclaw/openclaw.",
|
|
" --session <path> Session file from start. Default: <output-dir>/session.json.",
|
|
" --summary <text> Artifact publish summary.",
|
|
" --full-artifacts Publish all session artifacts. Default publishes only the motion GIF.",
|
|
" --tdlib-sha256 <hex> Expected SHA-256 for --tdlib-url. Defaults to <url>.sha256.",
|
|
" --tdlib-url <url> Linux tdlib archive containing libtdjson.so.",
|
|
" --dry-run Validate local inputs and print the plan.",
|
|
].join("\n");
|
|
}
|
|
|
|
function usage(): never {
|
|
throw new Error(usageText());
|
|
}
|
|
|
|
function expandHome(value: string) {
|
|
if (value === "~") {
|
|
return os.homedir();
|
|
}
|
|
if (value.startsWith("~/")) {
|
|
return path.join(os.homedir(), value.slice(2));
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function trimToValue(value: string | undefined) {
|
|
const trimmed = value?.trim();
|
|
return trimmed && trimmed.length > 0 ? trimmed : undefined;
|
|
}
|
|
|
|
function parsePositiveInteger(value: string, label: string) {
|
|
const parsed = Number(value);
|
|
if (!Number.isInteger(parsed) || parsed < 1) {
|
|
throw new Error(`${label} must be a positive integer.`);
|
|
}
|
|
return parsed;
|
|
}
|
|
|
|
function parseArgs(argv: string[]): Options {
|
|
argv = argv[0] === "--" ? argv.slice(1) : argv;
|
|
const commands = new Set([
|
|
"finish",
|
|
"probe",
|
|
"publish",
|
|
"run",
|
|
"screenshot",
|
|
"send",
|
|
"start",
|
|
"status",
|
|
"view",
|
|
]);
|
|
const command = commands.has(argv[0] ?? "") ? (argv.shift() as Options["command"]) : "probe";
|
|
const stamp = new Date().toISOString().replace(/[:.]/gu, "-");
|
|
const opts: Options = {
|
|
crabboxClass: "standard",
|
|
command,
|
|
crabboxBin: trimToValue(process.env.OPENCLAW_TELEGRAM_USER_CRABBOX_BIN) ?? "crabbox",
|
|
desktopChatTitle:
|
|
trimToValue(process.env.OPENCLAW_TELEGRAM_USER_DESKTOP_CHAT_TITLE) ?? "OpenClaw Testing",
|
|
dryRun: false,
|
|
expect: ["OpenClaw"],
|
|
gatewayPort: 19_879,
|
|
idleTimeout: "60m",
|
|
keepBox: false,
|
|
mockResponseText: "OPENCLAW_E2E_OK",
|
|
mockPort: 19_882,
|
|
outputDir: path.join(DEFAULT_OUTPUT_ROOT, stamp),
|
|
previewCropWidth: TELEGRAM_PROOF_VIEW.cropWidth,
|
|
previewFps: 24,
|
|
previewWidth: 1920,
|
|
provider: process.env.OPENCLAW_TELEGRAM_USER_CRABBOX_PROVIDER?.trim() || "aws",
|
|
publishFullArtifacts: false,
|
|
publishRepo: "openclaw/openclaw",
|
|
recordFps: 24,
|
|
recordSeconds: 35,
|
|
remoteCommand: [],
|
|
target: "linux",
|
|
text: "/status",
|
|
timeoutMs: 90_000,
|
|
ttl: "120m",
|
|
userDriverScript:
|
|
trimToValue(process.env.OPENCLAW_TELEGRAM_USER_DRIVER_SCRIPT) ?? DEFAULT_USER_DRIVER,
|
|
};
|
|
const commandSeparator = argv.indexOf("--");
|
|
if (command === "run" && commandSeparator >= 0) {
|
|
opts.remoteCommand = argv.slice(commandSeparator + 1);
|
|
argv = argv.slice(0, commandSeparator);
|
|
}
|
|
let expectWasPassed = false;
|
|
for (let index = 0; index < argv.length; index += 1) {
|
|
const arg = argv[index];
|
|
const readValue = () => {
|
|
const value = argv[index + 1];
|
|
if (!value || value.startsWith("--")) {
|
|
usage();
|
|
}
|
|
index += 1;
|
|
return value;
|
|
};
|
|
if (arg === "--class") {
|
|
opts.crabboxClass = readValue();
|
|
} else if (arg === "--crabbox-bin") {
|
|
opts.crabboxBin = readValue();
|
|
} else if (arg === "--desktop-chat-title") {
|
|
opts.desktopChatTitle = readValue();
|
|
} else if (arg === "--dry-run") {
|
|
opts.dryRun = true;
|
|
} else if (arg === "--env-file") {
|
|
opts.envFile = readValue();
|
|
} else if (arg === "--expect") {
|
|
if (!expectWasPassed) {
|
|
opts.expect = [];
|
|
expectWasPassed = true;
|
|
}
|
|
opts.expect.push(readValue());
|
|
} else if (arg === "--gateway-port") {
|
|
opts.gatewayPort = parsePositiveInteger(readValue(), "--gateway-port");
|
|
} else if (arg === "--id") {
|
|
opts.leaseId = readValue();
|
|
} else if (arg === "--idle-timeout") {
|
|
opts.idleTimeout = readValue();
|
|
} else if (arg === "--keep-box") {
|
|
opts.keepBox = true;
|
|
} else if (arg === "--mock-port") {
|
|
opts.mockPort = parsePositiveInteger(readValue(), "--mock-port");
|
|
} else if (arg === "--mock-response-file") {
|
|
opts.mockResponseText = fs.readFileSync(resolveRepoPath(process.cwd(), readValue()), "utf8");
|
|
} else if (arg === "--message-id") {
|
|
opts.messageId = String(parsePositiveInteger(readValue(), "--message-id"));
|
|
} else if (arg === "--output-dir") {
|
|
opts.outputDir = readValue();
|
|
} else if (arg === "--preview-crop") {
|
|
const value = readValue();
|
|
if (value !== "telegram-window") {
|
|
throw new Error("--preview-crop must be telegram-window.");
|
|
}
|
|
opts.previewCrop = value;
|
|
} else if (arg === "--preview-crop-width") {
|
|
opts.previewCropWidth = parsePositiveInteger(readValue(), "--preview-crop-width");
|
|
} else if (arg === "--preview-fps") {
|
|
opts.previewFps = parsePositiveInteger(readValue(), "--preview-fps");
|
|
} else if (arg === "--preview-width") {
|
|
opts.previewWidth = parsePositiveInteger(readValue(), "--preview-width");
|
|
} else if (arg === "--provider") {
|
|
opts.provider = readValue();
|
|
} else if (arg === "--pr") {
|
|
opts.publishPr = parsePositiveInteger(readValue(), "--pr");
|
|
} else if (arg === "--repo") {
|
|
opts.publishRepo = readValue();
|
|
} else if (arg === "--record-seconds") {
|
|
opts.recordSeconds = parsePositiveInteger(readValue(), "--record-seconds");
|
|
} else if (arg === "--session") {
|
|
opts.sessionFile = readValue();
|
|
} else if (arg === "--summary") {
|
|
opts.publishSummary = readValue();
|
|
} else if (arg === "--full-artifacts") {
|
|
opts.publishFullArtifacts = true;
|
|
} else if (arg === "--record-fps") {
|
|
opts.recordFps = parsePositiveInteger(readValue(), "--record-fps");
|
|
} else if (arg === "--sut-username") {
|
|
opts.sutUsername = readValue().replace(/^@/u, "");
|
|
} else if (arg === "--target") {
|
|
opts.target = readValue();
|
|
} else if (arg === "--tdlib-sha256") {
|
|
opts.tdlibSha256 = readValue().toLowerCase();
|
|
} else if (arg === "--tdlib-url") {
|
|
opts.tdlibUrl = readValue();
|
|
} else if (arg === "--text") {
|
|
opts.text = readValue();
|
|
} else if (arg === "--timeout-ms") {
|
|
opts.timeoutMs = parsePositiveInteger(readValue(), "--timeout-ms");
|
|
} else if (arg === "--ttl") {
|
|
opts.ttl = readValue();
|
|
} else if (arg === "--user-driver-script") {
|
|
opts.userDriverScript = readValue();
|
|
} else if (arg === "--help" || arg === "-h") {
|
|
console.log(usageText());
|
|
process.exit(0);
|
|
} else {
|
|
throw new Error(`Unknown argument: ${arg}`);
|
|
}
|
|
}
|
|
if (command === "run" && opts.remoteCommand.length === 0) {
|
|
throw new Error("run requires a remote command after --.");
|
|
}
|
|
if (
|
|
["finish", "publish", "run", "screenshot", "send", "status", "view"].includes(command) &&
|
|
!opts.sessionFile
|
|
) {
|
|
throw new Error(`${command} requires --session.`);
|
|
}
|
|
if (command === "view" && !opts.messageId) {
|
|
throw new Error("view requires --message-id.");
|
|
}
|
|
if (command === "publish" && !opts.publishPr) {
|
|
throw new Error("publish requires --pr.");
|
|
}
|
|
return opts;
|
|
}
|
|
|
|
function repoRoot() {
|
|
const cwd = process.cwd();
|
|
if (
|
|
!fs.existsSync(path.join(cwd, "package.json")) ||
|
|
!fs.existsSync(path.join(cwd, "scripts/e2e/mock-openai-server.mjs"))
|
|
) {
|
|
throw new Error("Run from the OpenClaw repo root.");
|
|
}
|
|
return cwd;
|
|
}
|
|
|
|
function resolveRepoPath(root: string, value: string) {
|
|
const resolved = path.isAbsolute(value) ? value : path.resolve(root, value);
|
|
const relative = path.relative(root, resolved);
|
|
if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
|
|
throw new Error(`Output path must stay inside the repo: ${value}`);
|
|
}
|
|
return resolved;
|
|
}
|
|
|
|
function readJsonFile(filePath: string): JsonObject {
|
|
try {
|
|
return JSON.parse(fs.readFileSync(expandHome(filePath), "utf8")) as JsonObject;
|
|
} catch (error) {
|
|
if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
|
|
return {};
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
function requireString(source: JsonObject, key: string) {
|
|
const value = source[key];
|
|
if (typeof value === "number") {
|
|
return String(value);
|
|
}
|
|
if (typeof value === "string" && value.trim()) {
|
|
return value.trim();
|
|
}
|
|
throw new Error(`Missing ${key}.`);
|
|
}
|
|
|
|
function optionalString(source: JsonObject, key: string) {
|
|
const value = source[key];
|
|
return typeof value === "string" && value.trim() ? value.trim() : undefined;
|
|
}
|
|
|
|
function mockServerEnv(params: { mockPort: number; mockResponseText: string; requestLog: string }) {
|
|
return {
|
|
...process.env,
|
|
MOCK_PORT: String(params.mockPort),
|
|
MOCK_REQUEST_LOG: params.requestLog,
|
|
SUCCESS_MARKER: params.mockResponseText,
|
|
};
|
|
}
|
|
|
|
function gatewayEnv(params: { configPath: string; stateDir: string; sutToken: string }) {
|
|
return {
|
|
...process.env,
|
|
OPENAI_API_KEY: "sk-openclaw-e2e-mock",
|
|
OPENCLAW_CONFIG_PATH: params.configPath,
|
|
OPENCLAW_STATE_DIR: params.stateDir,
|
|
TELEGRAM_BOT_TOKEN: params.sutToken,
|
|
};
|
|
}
|
|
|
|
function shellQuote(value: string) {
|
|
return `'${value.replaceAll("'", "'\\''")}'`;
|
|
}
|
|
|
|
function runCommand(params: {
|
|
args: string[];
|
|
command: string;
|
|
cwd: string;
|
|
env?: NodeJS.ProcessEnv;
|
|
stdio?: "inherit" | "pipe";
|
|
stdin?: string;
|
|
}) {
|
|
return new Promise<CommandResult>((resolve, reject) => {
|
|
const child = spawn(params.command, params.args, {
|
|
cwd: params.cwd,
|
|
env: params.env ?? process.env,
|
|
stdio: ["pipe", "pipe", "pipe"],
|
|
});
|
|
let stdout = "";
|
|
let stderr = "";
|
|
child.stdout.on("data", (chunk: Buffer) => {
|
|
const text = chunk.toString();
|
|
stdout += text;
|
|
if (params.stdio === "inherit") {
|
|
process.stdout.write(text);
|
|
}
|
|
});
|
|
child.stderr.on("data", (chunk: Buffer) => {
|
|
const text = chunk.toString();
|
|
stderr += text;
|
|
if (params.stdio === "inherit") {
|
|
process.stderr.write(text);
|
|
}
|
|
});
|
|
child.on("error", reject);
|
|
child.on("close", (code, signal) => {
|
|
if (code === 0) {
|
|
resolve({ stdout, stderr });
|
|
return;
|
|
}
|
|
const detail = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
|
|
reject(
|
|
new Error(
|
|
`${params.command} ${params.args.join(" ")} failed with ${detail}\n${stdout}${stderr}`,
|
|
),
|
|
);
|
|
});
|
|
if (params.stdin) {
|
|
child.stdin.end(params.stdin);
|
|
} else {
|
|
child.stdin.end();
|
|
}
|
|
});
|
|
}
|
|
|
|
function spawnLogged(command: string, args: string[], options: SpawnOptionsWithoutStdio) {
|
|
const child = spawn(command, args, {
|
|
...options,
|
|
detached: true,
|
|
stdio: ["ignore", "pipe", "pipe"],
|
|
});
|
|
child.stdout.setEncoding("utf8");
|
|
child.stderr.setEncoding("utf8");
|
|
let output = "";
|
|
const capture = (chunk: string) => {
|
|
output = `${output}${chunk}`.slice(-12000);
|
|
};
|
|
child.stdout.on("data", capture);
|
|
child.stderr.on("data", capture);
|
|
return {
|
|
child,
|
|
get output() {
|
|
return output;
|
|
},
|
|
};
|
|
}
|
|
|
|
function waitForOutput(
|
|
child: ChildProcess,
|
|
pattern: RegExp,
|
|
output: () => string,
|
|
label: string,
|
|
timeoutMs: number,
|
|
) {
|
|
return new Promise<void>((resolve, reject) => {
|
|
const timeout = setTimeout(() => {
|
|
reject(
|
|
new Error(`${label} did not become ready within ${timeoutMs}ms\n${output().slice(-4000)}`),
|
|
);
|
|
}, timeoutMs);
|
|
const onData = () => {
|
|
if (pattern.test(output())) {
|
|
cleanup();
|
|
resolve();
|
|
}
|
|
};
|
|
const onExit = (code: number | null) => {
|
|
cleanup();
|
|
reject(
|
|
new Error(
|
|
`${label} exited before ready with code ${code ?? "unknown"}\n${output().slice(-4000)}`,
|
|
),
|
|
);
|
|
};
|
|
const cleanup = () => {
|
|
clearTimeout(timeout);
|
|
child.stdout?.off("data", onData);
|
|
child.stderr?.off("data", onData);
|
|
child.off("exit", onExit);
|
|
};
|
|
child.stdout?.on("data", onData);
|
|
child.stderr?.on("data", onData);
|
|
child.on("exit", onExit);
|
|
onData();
|
|
});
|
|
}
|
|
|
|
function killTree(child: ChildProcess | undefined) {
|
|
if (!child || child.killed || child.exitCode !== null) {
|
|
return;
|
|
}
|
|
if (!child.pid) {
|
|
return;
|
|
}
|
|
try {
|
|
process.kill(-child.pid, "SIGTERM");
|
|
} catch {
|
|
child.kill("SIGTERM");
|
|
}
|
|
}
|
|
|
|
function killPidTree(pid: number | undefined) {
|
|
if (!pid) {
|
|
return;
|
|
}
|
|
try {
|
|
process.kill(-pid, "SIGTERM");
|
|
} catch {
|
|
try {
|
|
process.kill(pid, "SIGTERM");
|
|
} catch {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function spawnDaemon(params: {
|
|
args: string[];
|
|
command: string;
|
|
cwd: string;
|
|
env: NodeJS.ProcessEnv;
|
|
logPath: string;
|
|
}) {
|
|
const log = fs.openSync(params.logPath, "a");
|
|
const child = spawn(params.command, params.args, {
|
|
cwd: params.cwd,
|
|
detached: true,
|
|
env: params.env,
|
|
stdio: ["ignore", log, log],
|
|
});
|
|
child.unref();
|
|
fs.closeSync(log);
|
|
return child.pid;
|
|
}
|
|
|
|
async function waitForLog(logPath: string, pattern: RegExp, label: string, timeoutMs: number) {
|
|
const started = Date.now();
|
|
while (Date.now() - started < timeoutMs) {
|
|
const text = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "";
|
|
if (pattern.test(text)) {
|
|
return;
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, 500));
|
|
}
|
|
const text = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "";
|
|
throw new Error(`${label} did not become ready within ${timeoutMs}ms\n${text.slice(-4000)}`);
|
|
}
|
|
|
|
async function telegram(token: string, method: string, body: JsonObject = {}) {
|
|
const response = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
body: JSON.stringify(body),
|
|
});
|
|
const payload = (await response.json()) as JsonObject;
|
|
if (!response.ok || payload.ok !== true) {
|
|
throw new Error(
|
|
optionalString(payload, "description") ?? `${method} failed with HTTP ${response.status}`,
|
|
);
|
|
}
|
|
return payload.result;
|
|
}
|
|
|
|
async function drainSutUpdates(sutToken: string) {
|
|
const before = telegramResultObject(await telegram(sutToken, "getWebhookInfo"), "getWebhookInfo");
|
|
const rawUpdates = await telegram(sutToken, "getUpdates", {
|
|
allowed_updates: ["message", "edited_message"],
|
|
timeout: 0,
|
|
});
|
|
if (!Array.isArray(rawUpdates)) {
|
|
throw new Error("getUpdates returned an invalid payload.");
|
|
}
|
|
const updates = rawUpdates;
|
|
if (updates.length) {
|
|
const last = updates.at(-1);
|
|
if (
|
|
last &&
|
|
typeof last === "object" &&
|
|
"update_id" in last &&
|
|
typeof last.update_id === "number"
|
|
) {
|
|
await telegram(sutToken, "getUpdates", { offset: last.update_id + 1, timeout: 0 });
|
|
}
|
|
}
|
|
const after = telegramResultObject(await telegram(sutToken, "getWebhookInfo"), "getWebhookInfo");
|
|
return {
|
|
drained: updates.length,
|
|
pendingAfter:
|
|
typeof after.pending_update_count === "number" ? after.pending_update_count : undefined,
|
|
pendingBefore:
|
|
typeof before.pending_update_count === "number" ? before.pending_update_count : undefined,
|
|
webhookUrlSet: typeof before.url === "string" && before.url.length > 0,
|
|
};
|
|
}
|
|
|
|
async function sutIdentity(sutToken: string) {
|
|
const result = telegramResultObject(await telegram(sutToken, "getMe"), "getMe");
|
|
const username = requireString(result, "username").replace(/^@/u, "");
|
|
return { id: requireString(result, "id"), username };
|
|
}
|
|
|
|
function telegramResultObject(value: unknown, label: string): JsonObject {
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
|
throw new Error(`${label} returned an invalid payload.`);
|
|
}
|
|
return value as JsonObject;
|
|
}
|
|
|
|
function writeSutConfig(params: {
|
|
gatewayPort: number;
|
|
groupId: string;
|
|
mockPort: number;
|
|
outputDir: string;
|
|
testerId: string;
|
|
}) {
|
|
const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-tg-crabbox-sut-"));
|
|
const stateDir = path.join(tempRoot, "state");
|
|
const workspace = path.join(tempRoot, "workspace");
|
|
fs.mkdirSync(stateDir, { recursive: true });
|
|
fs.mkdirSync(workspace, { recursive: true });
|
|
const configPath = path.join(tempRoot, "openclaw.json");
|
|
const config = {
|
|
agents: {
|
|
defaults: {
|
|
model: { primary: "openai/gpt-5.5" },
|
|
models: { "openai/gpt-5.5": { params: { openaiWsWarmup: false, transport: "sse" } } },
|
|
},
|
|
list: [
|
|
{
|
|
default: true,
|
|
id: "main",
|
|
model: { primary: "openai/gpt-5.5" },
|
|
name: "Main",
|
|
workspace,
|
|
},
|
|
],
|
|
},
|
|
channels: {
|
|
telegram: {
|
|
allowFrom: [params.testerId],
|
|
botToken: { id: "TELEGRAM_BOT_TOKEN", provider: "default", source: "env" },
|
|
commands: { native: true, nativeSkills: false },
|
|
dmPolicy: "allowlist",
|
|
enabled: true,
|
|
groupAllowFrom: [params.testerId],
|
|
groupPolicy: "allowlist",
|
|
groups: {
|
|
[params.groupId]: {
|
|
allowFrom: [params.testerId],
|
|
groupPolicy: "allowlist",
|
|
requireMention: false,
|
|
},
|
|
},
|
|
replyToMode: "first",
|
|
},
|
|
},
|
|
gateway: { auth: { mode: "none" }, bind: "loopback", mode: "local", port: params.gatewayPort },
|
|
messages: { groupChat: { visibleReplies: "automatic" } },
|
|
models: {
|
|
providers: {
|
|
openai: {
|
|
api: "openai-responses",
|
|
apiKey: { id: "OPENAI_API_KEY", provider: "default", source: "env" },
|
|
baseUrl: `http://127.0.0.1:${params.mockPort}/v1`,
|
|
models: [
|
|
{ api: "openai-responses", contextWindow: 128000, id: "gpt-5.5", name: "gpt-5.5" },
|
|
],
|
|
request: { allowPrivateNetwork: true },
|
|
},
|
|
},
|
|
},
|
|
plugins: {
|
|
allow: ["telegram", "openai"],
|
|
enabled: true,
|
|
entries: { openai: { enabled: true }, telegram: { enabled: true } },
|
|
},
|
|
};
|
|
fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
|
|
return { configPath, stateDir, tempRoot, workspace };
|
|
}
|
|
|
|
async function startLocalSut(params: {
|
|
gatewayPort: number;
|
|
groupId: string;
|
|
mockResponseText: string;
|
|
mockPort: number;
|
|
outputDir: string;
|
|
sutToken: string;
|
|
testerId: string;
|
|
repoRoot: string;
|
|
}) {
|
|
const drained = await drainSutUpdates(params.sutToken);
|
|
const config = writeSutConfig(params);
|
|
const requestLog = path.join(params.outputDir, "mock-openai-requests.ndjson");
|
|
const mock = spawnLogged("node", ["scripts/e2e/mock-openai-server.mjs"], {
|
|
cwd: params.repoRoot,
|
|
env: mockServerEnv({ ...params, requestLog }),
|
|
});
|
|
await waitForOutput(
|
|
mock.child,
|
|
/mock-openai listening/u,
|
|
() => mock.output,
|
|
"mock-openai",
|
|
10_000,
|
|
);
|
|
const gateway = spawnLogged(
|
|
"pnpm",
|
|
["openclaw", "gateway", "--port", String(params.gatewayPort)],
|
|
{
|
|
cwd: params.repoRoot,
|
|
env: gatewayEnv({ ...config, sutToken: params.sutToken }),
|
|
},
|
|
);
|
|
await waitForOutput(gateway.child, /\[gateway\] ready/u, () => gateway.output, "gateway", 60_000);
|
|
return {
|
|
...config,
|
|
drained,
|
|
gateway: gateway.child,
|
|
get gatewayLog() {
|
|
return gateway.output;
|
|
},
|
|
mock: mock.child,
|
|
get mockLog() {
|
|
return mock.output;
|
|
},
|
|
requestLog,
|
|
};
|
|
}
|
|
|
|
async function startLocalSutDaemon(params: {
|
|
gatewayPort: number;
|
|
groupId: string;
|
|
mockResponseText: string;
|
|
mockPort: number;
|
|
outputDir: string;
|
|
sutToken: string;
|
|
testerId: string;
|
|
repoRoot: string;
|
|
}) {
|
|
const drained = await drainSutUpdates(params.sutToken);
|
|
const config = writeSutConfig(params);
|
|
const requestLog = path.join(params.outputDir, "mock-openai-requests.ndjson");
|
|
const mockLog = path.join(params.outputDir, "mock-openai.log");
|
|
const gatewayLog = path.join(params.outputDir, "gateway.log");
|
|
const mockPid = spawnDaemon({
|
|
command: "node",
|
|
args: ["scripts/e2e/mock-openai-server.mjs"],
|
|
cwd: params.repoRoot,
|
|
env: mockServerEnv({ ...params, requestLog }),
|
|
logPath: mockLog,
|
|
});
|
|
if (!mockPid) {
|
|
throw new Error("mock-openai did not start.");
|
|
}
|
|
await waitForLog(mockLog, /mock-openai listening/u, "mock-openai", 10_000);
|
|
|
|
const gatewayPid = spawnDaemon({
|
|
command: "pnpm",
|
|
args: ["openclaw", "gateway", "--port", String(params.gatewayPort)],
|
|
cwd: params.repoRoot,
|
|
env: gatewayEnv({ ...config, sutToken: params.sutToken }),
|
|
logPath: gatewayLog,
|
|
});
|
|
if (!gatewayPid) {
|
|
throw new Error("gateway did not start.");
|
|
}
|
|
await waitForLog(gatewayLog, /\[gateway\] ready/u, "gateway", 60_000);
|
|
return {
|
|
...config,
|
|
drained,
|
|
gatewayLog,
|
|
gatewayPid,
|
|
mockLog,
|
|
mockPid,
|
|
requestLog,
|
|
};
|
|
}
|
|
|
|
function extractLeaseId(output: string) {
|
|
return output.match(/\b(?:cbx_[a-f0-9]+|tbx_[A-Za-z0-9_-]+)\b/u)?.[0];
|
|
}
|
|
|
|
async function warmupCrabbox(opts: Options, root: string) {
|
|
const result = await runCommand({
|
|
command: opts.crabboxBin,
|
|
args: [
|
|
"warmup",
|
|
"--provider",
|
|
opts.provider,
|
|
"--target",
|
|
opts.target,
|
|
"--desktop",
|
|
"--browser",
|
|
"--class",
|
|
opts.crabboxClass,
|
|
"--idle-timeout",
|
|
opts.idleTimeout,
|
|
"--ttl",
|
|
opts.ttl,
|
|
],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
const leaseId = extractLeaseId(`${result.stdout}\n${result.stderr}`);
|
|
if (!leaseId) {
|
|
throw new Error("Crabbox warmup did not print a lease id.");
|
|
}
|
|
return leaseId;
|
|
}
|
|
|
|
async function createMotionPreview(params: {
|
|
motionGifPath: string;
|
|
motionVideoPath: string;
|
|
opts: Options;
|
|
root: string;
|
|
videoPath: string;
|
|
}) {
|
|
const preview = await runCommand({
|
|
command: params.opts.crabboxBin,
|
|
args: [
|
|
"media",
|
|
"preview",
|
|
"--input",
|
|
params.videoPath,
|
|
"--output",
|
|
params.motionGifPath,
|
|
"--fps",
|
|
String(params.opts.previewFps),
|
|
"--width",
|
|
String(params.opts.previewWidth),
|
|
"--trimmed-video-output",
|
|
params.motionVideoPath,
|
|
"--json",
|
|
],
|
|
cwd: params.root,
|
|
stdio: "inherit",
|
|
});
|
|
return JSON.parse(preview.stdout) as JsonObject;
|
|
}
|
|
|
|
function previewCrop(opts: Options) {
|
|
return opts.previewCrop === "telegram-window"
|
|
? { ...TELEGRAM_PROOF_VIEW, cropWidth: opts.previewCropWidth }
|
|
: undefined;
|
|
}
|
|
|
|
async function createCroppedMotionPreview(params: {
|
|
crop: typeof TELEGRAM_PROOF_VIEW;
|
|
croppedGifPath: string;
|
|
croppedVideoPath: string;
|
|
opts: Options;
|
|
root: string;
|
|
videoPath: string;
|
|
}) {
|
|
const crop = `crop=${params.crop.width}:${params.crop.height}:${params.crop.x}:${params.crop.y}`;
|
|
const scale = `scale=${params.crop.cropWidth}:-2:flags=lanczos`;
|
|
await runCommand({
|
|
command: "ffmpeg",
|
|
args: [
|
|
"-y",
|
|
"-hide_banner",
|
|
"-loglevel",
|
|
"warning",
|
|
"-i",
|
|
params.videoPath,
|
|
"-vf",
|
|
`${crop},${scale}`,
|
|
"-pix_fmt",
|
|
"yuv420p",
|
|
params.croppedVideoPath,
|
|
],
|
|
cwd: params.root,
|
|
stdio: "inherit",
|
|
});
|
|
await runCommand({
|
|
command: "ffmpeg",
|
|
args: [
|
|
"-y",
|
|
"-hide_banner",
|
|
"-loglevel",
|
|
"warning",
|
|
"-i",
|
|
params.videoPath,
|
|
"-filter_complex",
|
|
`${crop},fps=${params.opts.previewFps},${scale},split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse`,
|
|
params.croppedGifPath,
|
|
],
|
|
cwd: params.root,
|
|
stdio: "inherit",
|
|
});
|
|
return {
|
|
crop,
|
|
fps: params.opts.previewFps,
|
|
outputWidth: params.crop.cropWidth,
|
|
};
|
|
}
|
|
|
|
async function inspectCrabbox(opts: Options, root: string, leaseId: string) {
|
|
const result = await runCommand({
|
|
command: opts.crabboxBin,
|
|
args: [
|
|
"inspect",
|
|
"--provider",
|
|
opts.provider,
|
|
"--target",
|
|
opts.target,
|
|
"--id",
|
|
leaseId,
|
|
"--json",
|
|
],
|
|
cwd: root,
|
|
});
|
|
return JSON.parse(result.stdout) as CrabboxInspect;
|
|
}
|
|
|
|
function sshArgs(inspect: CrabboxInspect) {
|
|
if (!inspect.host || !inspect.sshKey || !inspect.sshUser) {
|
|
throw new Error("Crabbox inspect output is missing SSH details.");
|
|
}
|
|
return {
|
|
base: [
|
|
"-i",
|
|
inspect.sshKey,
|
|
"-p",
|
|
inspect.sshPort ?? "22",
|
|
"-o",
|
|
"IdentitiesOnly=yes",
|
|
"-o",
|
|
"BatchMode=yes",
|
|
"-o",
|
|
"StrictHostKeyChecking=accept-new",
|
|
"-o",
|
|
"ConnectTimeout=15",
|
|
],
|
|
scpBase: [
|
|
"-i",
|
|
inspect.sshKey,
|
|
"-P",
|
|
inspect.sshPort ?? "22",
|
|
"-o",
|
|
"IdentitiesOnly=yes",
|
|
"-o",
|
|
"BatchMode=yes",
|
|
"-o",
|
|
"StrictHostKeyChecking=accept-new",
|
|
"-o",
|
|
"ConnectTimeout=15",
|
|
],
|
|
target: `${inspect.sshUser}@${inspect.host}`,
|
|
};
|
|
}
|
|
|
|
async function scpToRemote(root: string, inspect: CrabboxInspect, local: string, remote: string) {
|
|
const ssh = sshArgs(inspect);
|
|
await runCommand({
|
|
command: "scp",
|
|
args: [...ssh.scpBase, local, `${ssh.target}:${remote}`],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
}
|
|
|
|
async function scpFromRemote(root: string, inspect: CrabboxInspect, remote: string, local: string) {
|
|
const ssh = sshArgs(inspect);
|
|
await runCommand({
|
|
command: "scp",
|
|
args: [...ssh.scpBase, `${ssh.target}:${remote}`, local],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
}
|
|
|
|
async function sshRun(root: string, inspect: CrabboxInspect, remoteCommand: string) {
|
|
const ssh = sshArgs(inspect);
|
|
return await runCommand({
|
|
command: "ssh",
|
|
args: [...ssh.base, ssh.target, remoteCommand],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
}
|
|
|
|
function renderRemoteSetup(params: { tdlibSha256?: string; tdlibUrl?: string }) {
|
|
const tdlibSha256 = JSON.stringify(params.tdlibSha256 ?? "");
|
|
const tdlibUrl = JSON.stringify(params.tdlibUrl ?? "");
|
|
return `#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
root=${REMOTE_ROOT}
|
|
tdlib_sha256=${tdlibSha256}
|
|
tdlib_url=${tdlibUrl}
|
|
mkdir -p "$root"
|
|
tar -xzf "$root/state.tgz" -C "$root"
|
|
sudo apt-get update -y
|
|
sudo DEBIAN_FRONTEND=noninteractive apt-get install -y curl git cmake g++ make zlib1g-dev libssl-dev python3 ffmpeg scrot xz-utils tar wmctrl xdotool x11-utils libopengl0 libxcb-cursor0 libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-randr0 libxcb-render-util0 libxcb-shape0 libxcb-xfixes0 libxcb-xinerama0 libxkbcommon-x11-0 >/tmp/openclaw-telegram-apt.log
|
|
if ! command -v python3 >/dev/null 2>&1; then
|
|
echo "python3 is required" >&2
|
|
exit 127
|
|
fi
|
|
if [ ! -x "$root/Telegram/Telegram" ]; then
|
|
curl -fL https://telegram.org/dl/desktop/linux -o "$root/telegram.tar.xz"
|
|
tar -xJf "$root/telegram.tar.xz" -C "$root"
|
|
fi
|
|
if ! ldconfig -p | grep -q libtdjson.so; then
|
|
if [ -n "$tdlib_url" ]; then
|
|
curl -fL "$tdlib_url" -o "$root/tdlib-linux.tgz"
|
|
if [ -z "$tdlib_sha256" ]; then
|
|
curl -fL "$tdlib_url.sha256" -o "$root/tdlib-linux.tgz.sha256"
|
|
tdlib_sha256="$(awk '{print $1; exit}' "$root/tdlib-linux.tgz.sha256")"
|
|
fi
|
|
printf '%s %s\\n' "$tdlib_sha256" "$root/tdlib-linux.tgz" | sha256sum -c -
|
|
mkdir -p "$root/tdlib-linux"
|
|
tar -xzf "$root/tdlib-linux.tgz" -C "$root/tdlib-linux"
|
|
lib="$(find "$root/tdlib-linux" -name libtdjson.so -type f | head -n 1)"
|
|
test -n "$lib"
|
|
sudo install -m 0755 "$lib" /usr/local/lib/libtdjson.so
|
|
else
|
|
rm -rf "$root/td" "$root/td-build"
|
|
git clone --depth 1 --branch v1.8.0 https://github.com/tdlib/td.git "$root/td"
|
|
cmake -S "$root/td" -B "$root/td-build" -DCMAKE_BUILD_TYPE=Release -DTD_ENABLE_JNI=OFF
|
|
cmake --build "$root/td-build" --target tdjson -j "$(nproc)"
|
|
sudo cmake --install "$root/td-build"
|
|
fi
|
|
sudo ldconfig
|
|
fi
|
|
TELEGRAM_USER_DRIVER_STATE_DIR="$root/user-driver" python3 "$root/user-driver.py" status --json --timeout-ms 60000 >"$root/status.json"
|
|
`;
|
|
}
|
|
|
|
function renderLaunchDesktop() {
|
|
return `#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
root=${REMOTE_ROOT}
|
|
export DISPLAY="\${DISPLAY:-:99}"
|
|
pkill -f "$root/Telegram/Telegram" >/dev/null 2>&1 || true
|
|
nohup "$root/Telegram/Telegram" -workdir "$root/desktop" >"$root/telegram-desktop.log" 2>&1 &
|
|
pid=$!
|
|
sleep 8
|
|
if ! kill -0 "$pid" >/dev/null 2>&1; then
|
|
cat "$root/telegram-desktop.log" >&2
|
|
exit 1
|
|
fi
|
|
if ! wmctrl -l | grep -i telegram >/dev/null 2>&1; then
|
|
cat "$root/telegram-desktop.log" >&2
|
|
exit 1
|
|
fi
|
|
`;
|
|
}
|
|
|
|
function renderSelectDesktopChat(params: { chatTitle: string }) {
|
|
return `#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
chat_title=${JSON.stringify(params.chatTitle)}
|
|
export DISPLAY="\${DISPLAY:-:99}"
|
|
win="$(wmctrl -l | awk 'tolower($0) ~ /telegram/ {print $1; exit}')"
|
|
test -n "$win"
|
|
left=520
|
|
top=170
|
|
xdotool windowactivate --sync "$win"
|
|
xdotool windowsize "$win" 980 720
|
|
xdotool windowmove "$win" "$left" "$top"
|
|
sleep 1
|
|
xdotool mousemove "$((left + 180))" "$((top + 50))" click 1
|
|
xdotool key ctrl+a BackSpace
|
|
xdotool type --delay 5 -- "$chat_title"
|
|
sleep 2
|
|
xdotool mousemove "$((left + 150))" "$((top + 120))" click 1
|
|
sleep 1
|
|
`;
|
|
}
|
|
|
|
function renderRemoteProbe(params: {
|
|
expect: string[];
|
|
outputPath?: string;
|
|
sutUsername: string;
|
|
text: string;
|
|
timeoutMs: number;
|
|
}) {
|
|
const args = [
|
|
"probe",
|
|
"--text",
|
|
params.text,
|
|
"--timeout-ms",
|
|
String(params.timeoutMs),
|
|
"--output",
|
|
params.outputPath ?? `${REMOTE_ROOT}/probe.json`,
|
|
"--json",
|
|
];
|
|
for (const expected of params.expect) {
|
|
args.push("--expect", expected);
|
|
}
|
|
const escapedArgs = args.map((arg) => JSON.stringify(arg)).join(" ");
|
|
return `#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
root=${REMOTE_ROOT}
|
|
export TELEGRAM_USER_DRIVER_STATE_DIR="$root/user-driver"
|
|
export TELEGRAM_USER_DRIVER_SUT_USERNAME=${JSON.stringify(params.sutUsername)}
|
|
python3 "$root/user-driver.py" ${escapedArgs}
|
|
`;
|
|
}
|
|
|
|
async function writeExecutable(filePath: string, content: string) {
|
|
fs.writeFileSync(filePath, content);
|
|
fs.chmodSync(filePath, 0o700);
|
|
}
|
|
|
|
async function prepareRemoteState(params: { localRoot: string; opts: Options; root: string }) {
|
|
const stateArchive = path.join(params.localRoot, "remote-state.tgz");
|
|
const userDriverScript = expandHome(params.opts.userDriverScript);
|
|
if (!fs.existsSync(userDriverScript)) {
|
|
throw new Error(`Missing user driver script: ${params.opts.userDriverScript}`);
|
|
}
|
|
await runCommand({
|
|
command: "cp",
|
|
args: [userDriverScript, path.join(params.localRoot, "user-driver.py")],
|
|
cwd: params.root,
|
|
});
|
|
await runCommand({
|
|
command: "tar",
|
|
args: [
|
|
"-C",
|
|
params.localRoot,
|
|
"-czf",
|
|
stateArchive,
|
|
"user-driver",
|
|
"desktop",
|
|
"user-driver.py",
|
|
],
|
|
cwd: params.root,
|
|
});
|
|
return stateArchive;
|
|
}
|
|
|
|
async function leaseCredential(params: { localRoot: string; opts: Options; root: string }) {
|
|
const userDriverDir = path.join(params.localRoot, "user-driver");
|
|
const desktopWorkdir = path.join(params.localRoot, "desktop");
|
|
const leaseFile = path.join(params.localRoot, "lease.json");
|
|
const payloadFile = path.join(params.localRoot, "payload.json");
|
|
const args = [
|
|
CREDENTIAL_SCRIPT,
|
|
"lease-restore",
|
|
"--user-driver-dir",
|
|
userDriverDir,
|
|
"--desktop-workdir",
|
|
desktopWorkdir,
|
|
"--lease-file",
|
|
leaseFile,
|
|
"--payload-output",
|
|
payloadFile,
|
|
];
|
|
if (params.opts.envFile) {
|
|
args.push("--env-file", params.opts.envFile);
|
|
}
|
|
const result = await runCommand({
|
|
command: "node",
|
|
args: ["--import", "tsx", ...args],
|
|
cwd: params.root,
|
|
stdio: "inherit",
|
|
});
|
|
const acquired = JSON.parse(result.stdout || "{}") as JsonObject;
|
|
const payload = readJsonFile(payloadFile);
|
|
return {
|
|
acquired,
|
|
desktopWorkdir,
|
|
groupId: requireString(payload, "groupId"),
|
|
leaseFile,
|
|
payloadFile,
|
|
sutToken: requireString(payload, "sutToken"),
|
|
testerUserId: requireString(payload, "testerUserId"),
|
|
testerUsername: requireString(payload, "testerUsername"),
|
|
userDriverDir,
|
|
};
|
|
}
|
|
|
|
async function releaseCredential(root: string, opts: Options, leaseFile: string) {
|
|
if (!fs.existsSync(leaseFile)) {
|
|
return;
|
|
}
|
|
const args = [CREDENTIAL_SCRIPT, "release", "--lease-file", leaseFile];
|
|
if (opts.envFile) {
|
|
args.push("--env-file", opts.envFile);
|
|
}
|
|
await runCommand({
|
|
command: "node",
|
|
args: ["--import", "tsx", ...args],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
}
|
|
|
|
async function stopCrabbox(root: string, opts: Options, leaseId: string) {
|
|
await runCommand({
|
|
command: opts.crabboxBin,
|
|
args: ["stop", "--provider", opts.provider, leaseId],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
}
|
|
|
|
function buildTargetText(text: string, sutUsername: string) {
|
|
if (!text.startsWith("/")) {
|
|
return text.replaceAll("{sut}", sutUsername);
|
|
}
|
|
if (/^\/\S+@\w+/u.test(text)) {
|
|
return text;
|
|
}
|
|
const [command, ...rest] = text.split(/\s+/u);
|
|
return [`${command}@${sutUsername}`, ...rest].join(" ").trim();
|
|
}
|
|
|
|
function summarizeProbe(probePath: string) {
|
|
const probe = readJsonFile(probePath);
|
|
const reply = probe.reply;
|
|
const sent = probe.sent;
|
|
const messageId = (value: unknown) => {
|
|
if (!value || typeof value !== "object") {
|
|
return undefined;
|
|
}
|
|
if ("messageId" in value) {
|
|
return value.messageId;
|
|
}
|
|
if ("id" in value) {
|
|
return value.id;
|
|
}
|
|
return undefined;
|
|
};
|
|
return {
|
|
ok: probe.ok === true,
|
|
replyMessageId: messageId(reply),
|
|
sentMessageId: messageId(sent),
|
|
};
|
|
}
|
|
|
|
function writeReport(params: {
|
|
croppedMotionGifPath?: string;
|
|
croppedMotionVideoPath?: string;
|
|
motionGifPath?: string;
|
|
motionVideoPath?: string;
|
|
outputDir: string;
|
|
screenshotPath?: string;
|
|
status: "pass" | "fail";
|
|
summaryPath: string;
|
|
videoPath?: string;
|
|
}) {
|
|
const reportPath = path.join(params.outputDir, "telegram-user-crabbox-proof.md");
|
|
fs.writeFileSync(
|
|
reportPath,
|
|
[
|
|
"# Telegram User Crabbox Proof",
|
|
"",
|
|
`Status: ${params.status}`,
|
|
`Summary: ${path.basename(params.summaryPath)}`,
|
|
params.videoPath ? `Video: ${path.basename(params.videoPath)}` : "Video: missing",
|
|
params.motionVideoPath
|
|
? `Motion video: ${path.basename(params.motionVideoPath)}`
|
|
: "Motion video: missing",
|
|
params.motionGifPath
|
|
? `Motion GIF: ${path.basename(params.motionGifPath)}`
|
|
: "Motion GIF: missing",
|
|
params.croppedMotionVideoPath
|
|
? `Cropped motion video: ${path.basename(params.croppedMotionVideoPath)}`
|
|
: undefined,
|
|
params.croppedMotionGifPath
|
|
? `Cropped motion GIF: ${path.basename(params.croppedMotionGifPath)}`
|
|
: undefined,
|
|
params.screenshotPath
|
|
? `Screenshot: ${path.basename(params.screenshotPath)}`
|
|
: "Screenshot: missing",
|
|
"",
|
|
]
|
|
.filter((line) => line !== undefined)
|
|
.join("\n"),
|
|
);
|
|
return reportPath;
|
|
}
|
|
|
|
function sessionPath(root: string, opts: Options, outputDir: string) {
|
|
return opts.sessionFile
|
|
? resolveRepoPath(root, opts.sessionFile)
|
|
: path.join(outputDir, "session.json");
|
|
}
|
|
|
|
function writeSession(pathname: string, session: SessionFile) {
|
|
fs.mkdirSync(path.dirname(pathname), { recursive: true });
|
|
fs.writeFileSync(pathname, `${JSON.stringify(session, null, 2)}\n`, { mode: 0o600 });
|
|
fs.chmodSync(pathname, 0o600);
|
|
}
|
|
|
|
function readSession(root: string, opts: Options, outputDir: string) {
|
|
const pathname = sessionPath(root, opts, outputDir);
|
|
if (!fs.existsSync(pathname)) {
|
|
throw new Error(`Missing session file: ${path.relative(root, pathname)}`);
|
|
}
|
|
const session = readJsonFile(pathname) as SessionFile;
|
|
if (session.command !== "telegram-user-crabbox-session") {
|
|
throw new Error(`Invalid Telegram Crabbox session file: ${path.relative(root, pathname)}`);
|
|
}
|
|
return {
|
|
path: pathname,
|
|
session,
|
|
};
|
|
}
|
|
|
|
async function writeRemoteSessionScripts(params: {
|
|
inspect: CrabboxInspect;
|
|
localRoot: string;
|
|
opts: Options;
|
|
root: string;
|
|
stateArchive: string;
|
|
sutUsername: string;
|
|
}) {
|
|
const setupScript = path.join(params.localRoot, "remote-setup.sh");
|
|
const launchScript = path.join(params.localRoot, "launch-desktop.sh");
|
|
const selectChatScript = path.join(params.localRoot, "select-desktop-chat.sh");
|
|
await writeExecutable(
|
|
setupScript,
|
|
renderRemoteSetup({ tdlibSha256: params.opts.tdlibSha256, tdlibUrl: params.opts.tdlibUrl }),
|
|
);
|
|
await writeExecutable(launchScript, renderLaunchDesktop());
|
|
await writeExecutable(
|
|
selectChatScript,
|
|
renderSelectDesktopChat({ chatTitle: params.opts.desktopChatTitle }),
|
|
);
|
|
|
|
await sshRun(params.root, params.inspect, `rm -rf ${REMOTE_ROOT} && mkdir -p ${REMOTE_ROOT}`);
|
|
await scpToRemote(params.root, params.inspect, params.stateArchive, `${REMOTE_ROOT}/state.tgz`);
|
|
await scpToRemote(params.root, params.inspect, setupScript, `${REMOTE_ROOT}/remote-setup.sh`);
|
|
await scpToRemote(params.root, params.inspect, launchScript, `${REMOTE_ROOT}/launch-desktop.sh`);
|
|
await scpToRemote(
|
|
params.root,
|
|
params.inspect,
|
|
selectChatScript,
|
|
`${REMOTE_ROOT}/select-desktop-chat.sh`,
|
|
);
|
|
await sshRun(params.root, params.inspect, `bash ${REMOTE_ROOT}/remote-setup.sh`);
|
|
await sshRun(params.root, params.inspect, `bash ${REMOTE_ROOT}/launch-desktop.sh`);
|
|
await sshRun(params.root, params.inspect, `bash ${REMOTE_ROOT}/select-desktop-chat.sh`);
|
|
await sshRun(
|
|
params.root,
|
|
params.inspect,
|
|
`cat >${REMOTE_ROOT}/env.sh <<'EOF'
|
|
export TELEGRAM_USER_DRIVER_STATE_DIR=${REMOTE_ROOT}/user-driver
|
|
export TELEGRAM_USER_DRIVER_SUT_USERNAME=${params.sutUsername}
|
|
EOF
|
|
`,
|
|
);
|
|
}
|
|
|
|
async function startRemoteRecording(root: string, inspect: CrabboxInspect, opts: Options) {
|
|
const command = `set -euo pipefail
|
|
export DISPLAY="\${DISPLAY:-:99}"
|
|
root=${REMOTE_ROOT}
|
|
video="$root/session.mp4"
|
|
log="$root/ffmpeg.log"
|
|
pid_file="$root/ffmpeg.pid"
|
|
rm -f "$video" "$log" "$pid_file"
|
|
size="$(xdpyinfo | awk '/dimensions:/ {size=$2} END {if (!size) exit 1; print size}')"
|
|
nohup ffmpeg -y -hide_banner -loglevel warning -f x11grab -framerate ${opts.recordFps} -video_size "$size" -i "$DISPLAY" -pix_fmt yuv420p "$video" >"$log" 2>&1 &
|
|
echo $! >"$pid_file"`;
|
|
await sshRun(root, inspect, command);
|
|
return {
|
|
log: `${REMOTE_ROOT}/ffmpeg.log`,
|
|
pidFile: `${REMOTE_ROOT}/ffmpeg.pid`,
|
|
remoteVideo: `${REMOTE_ROOT}/session.mp4`,
|
|
};
|
|
}
|
|
|
|
async function stopRemoteRecording(root: string, inspect: CrabboxInspect, session: SessionFile) {
|
|
await sshRun(
|
|
root,
|
|
inspect,
|
|
`set -euo pipefail
|
|
pid_file=${JSON.stringify(session.recorder.pidFile)}
|
|
if [ -s "$pid_file" ]; then
|
|
pid="$(cat "$pid_file")"
|
|
kill -INT "$pid" >/dev/null 2>&1 || true
|
|
for _ in $(seq 1 20); do
|
|
kill -0 "$pid" >/dev/null 2>&1 || exit 0
|
|
sleep 0.5
|
|
done
|
|
kill -TERM "$pid" >/dev/null 2>&1 || true
|
|
fi`,
|
|
);
|
|
}
|
|
|
|
async function startSession(root: string, opts: Options, outputDir: string) {
|
|
const localRoot = path.join(outputDir, ".session");
|
|
fs.rmSync(localRoot, { force: true, recursive: true });
|
|
fs.mkdirSync(localRoot, { mode: 0o700, recursive: true });
|
|
|
|
const convexEnvFile = expandHome(opts.envFile ?? DEFAULT_CONVEX_ENV_FILE);
|
|
const hasConvexEnv =
|
|
trimToValue(process.env.OPENCLAW_QA_CONVEX_SITE_URL) &&
|
|
trimToValue(process.env.OPENCLAW_QA_CONVEX_SECRET_CI);
|
|
if (!hasConvexEnv && !fs.existsSync(convexEnvFile)) {
|
|
throw new Error(`Missing Convex env file: ${opts.envFile ?? DEFAULT_CONVEX_ENV_FILE}`);
|
|
}
|
|
await runCommand({ command: opts.crabboxBin, args: ["--version"], cwd: root });
|
|
if (opts.dryRun) {
|
|
return {
|
|
command: "telegram-user-crabbox-session",
|
|
crabboxClass: opts.crabboxClass,
|
|
outputDir,
|
|
provider: opts.provider,
|
|
target: opts.target,
|
|
tdlibSha256: opts.tdlibSha256,
|
|
tdlibUrl: opts.tdlibUrl,
|
|
};
|
|
}
|
|
|
|
const credential = await leaseCredential({ localRoot, opts, root });
|
|
const sut = opts.sutUsername
|
|
? { id: "", username: opts.sutUsername }
|
|
: await sutIdentity(credential.sutToken);
|
|
const stateArchive = await prepareRemoteState({ localRoot, opts, root });
|
|
let leaseId = opts.leaseId;
|
|
let createdLease = false;
|
|
if (!leaseId) {
|
|
leaseId = await warmupCrabbox(opts, root);
|
|
createdLease = true;
|
|
}
|
|
const inspect = await inspectCrabbox(opts, root, leaseId);
|
|
let localSut: Awaited<ReturnType<typeof startLocalSutDaemon>> | undefined;
|
|
try {
|
|
await writeRemoteSessionScripts({
|
|
inspect,
|
|
localRoot,
|
|
opts,
|
|
root,
|
|
stateArchive,
|
|
sutUsername: sut.username,
|
|
});
|
|
localSut = await startLocalSutDaemon({
|
|
gatewayPort: opts.gatewayPort,
|
|
groupId: credential.groupId,
|
|
mockResponseText: opts.mockResponseText,
|
|
mockPort: opts.mockPort,
|
|
outputDir,
|
|
repoRoot: root,
|
|
sutToken: credential.sutToken,
|
|
testerId: credential.testerUserId,
|
|
});
|
|
const recorder = await startRemoteRecording(root, inspect, opts);
|
|
const session: SessionFile = {
|
|
command: "telegram-user-crabbox-session",
|
|
createdAt: new Date().toISOString(),
|
|
crabbox: {
|
|
class: opts.crabboxClass,
|
|
createdLease,
|
|
id: leaseId,
|
|
inspect,
|
|
provider: opts.provider,
|
|
target: opts.target,
|
|
},
|
|
credential: {
|
|
groupId: credential.groupId,
|
|
leaseFile: credential.leaseFile,
|
|
sutUsername: sut.username,
|
|
testerUserId: credential.testerUserId,
|
|
testerUsername: credential.testerUsername,
|
|
},
|
|
localRoot,
|
|
localSut,
|
|
outputDir,
|
|
recorder,
|
|
remoteRoot: REMOTE_ROOT,
|
|
};
|
|
const pathname = sessionPath(root, opts, outputDir);
|
|
writeSession(pathname, session);
|
|
return {
|
|
session: path.relative(root, pathname),
|
|
status: "pass",
|
|
telegram: {
|
|
groupId: credential.groupId,
|
|
sutUsername: sut.username,
|
|
testerUserId: credential.testerUserId,
|
|
testerUsername: credential.testerUsername,
|
|
},
|
|
webvnc: `${opts.crabboxBin} webvnc --provider ${opts.provider} --target ${opts.target} --id ${leaseId} --open`,
|
|
commands: {
|
|
send: `pnpm qa:telegram-user:crabbox -- send --session ${path.relative(root, pathname)} --text '/status'`,
|
|
view: `pnpm qa:telegram-user:crabbox -- view --session ${path.relative(root, pathname)} --message-id <message-id>`,
|
|
run: `pnpm qa:telegram-user:crabbox -- run --session ${path.relative(root, pathname)} -- bash -lc 'source ${REMOTE_ROOT}/env.sh && python3 ${REMOTE_ROOT}/user-driver.py transcript --limit 20 --json'`,
|
|
finish: `pnpm qa:telegram-user:crabbox -- finish --session ${path.relative(root, pathname)} --preview-crop telegram-window`,
|
|
},
|
|
};
|
|
} catch (error) {
|
|
killPidTree(localSut?.gatewayPid);
|
|
killPidTree(localSut?.mockPid);
|
|
await releaseCredential(root, opts, credential.leaseFile).catch(() => {});
|
|
if (leaseId && createdLease) {
|
|
await stopCrabbox(root, opts, leaseId).catch(() => {});
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
async function sendSessionProbe(root: string, opts: Options, outputDir: string) {
|
|
const { session } = readSession(root, opts, outputDir);
|
|
const stamp = new Date().toISOString().replace(/[:.]/gu, "-");
|
|
const targetText = buildTargetText(opts.text, session.credential.sutUsername);
|
|
const remoteProbe = `${REMOTE_ROOT}/probe-${stamp}.json`;
|
|
const probeScript = path.join(session.localRoot, `remote-probe-${stamp}.sh`);
|
|
await writeExecutable(
|
|
probeScript,
|
|
renderRemoteProbe({
|
|
expect: opts.expect,
|
|
outputPath: remoteProbe,
|
|
sutUsername: session.credential.sutUsername,
|
|
text: targetText,
|
|
timeoutMs: opts.timeoutMs,
|
|
}),
|
|
);
|
|
await scpToRemote(root, session.crabbox.inspect, probeScript, `${REMOTE_ROOT}/remote-probe.sh`);
|
|
await sshRun(root, session.crabbox.inspect, `bash ${REMOTE_ROOT}/remote-probe.sh`);
|
|
const localProbe = path.join(session.outputDir, `probe-${stamp}.json`);
|
|
await scpFromRemote(root, session.crabbox.inspect, remoteProbe, localProbe);
|
|
return {
|
|
probe: path.relative(root, localProbe),
|
|
status: "pass",
|
|
summary: summarizeProbe(localProbe),
|
|
text: targetText,
|
|
};
|
|
}
|
|
|
|
async function runSessionCommand(root: string, opts: Options, outputDir: string) {
|
|
const { session } = readSession(root, opts, outputDir);
|
|
const command = opts.remoteCommand.map(shellQuote).join(" ");
|
|
const result = await sshRun(root, session.crabbox.inspect, command);
|
|
const logPath = path.join(
|
|
session.outputDir,
|
|
`remote-command-${new Date().toISOString().replace(/[:.]/gu, "-")}.log`,
|
|
);
|
|
fs.writeFileSync(logPath, `${result.stdout}${result.stderr}`);
|
|
return { command: opts.remoteCommand, log: path.relative(root, logPath), status: "pass" };
|
|
}
|
|
|
|
async function screenshotSession(root: string, opts: Options, outputDir: string) {
|
|
const { session } = readSession(root, opts, outputDir);
|
|
const screenshotPath = path.join(
|
|
session.outputDir,
|
|
`telegram-user-crabbox-${new Date().toISOString().replace(/[:.]/gu, "-")}.png`,
|
|
);
|
|
await runCommand({
|
|
command: opts.crabboxBin,
|
|
args: [
|
|
"screenshot",
|
|
"--provider",
|
|
session.crabbox.provider,
|
|
"--target",
|
|
session.crabbox.target,
|
|
"--id",
|
|
session.crabbox.id,
|
|
"--output",
|
|
screenshotPath,
|
|
],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
return { screenshot: path.relative(root, screenshotPath), status: "pass" };
|
|
}
|
|
|
|
async function statusSession(root: string, opts: Options, outputDir: string) {
|
|
const { path: pathname, session } = readSession(root, opts, outputDir);
|
|
const inspect = await inspectCrabbox(opts, root, session.crabbox.id);
|
|
return {
|
|
crabbox: {
|
|
id: session.crabbox.id,
|
|
slug: inspect.slug,
|
|
state: inspect.state,
|
|
},
|
|
session: path.relative(root, pathname),
|
|
status: "pass",
|
|
webvnc: `${opts.crabboxBin} webvnc --provider ${session.crabbox.provider} --target ${session.crabbox.target} --id ${session.crabbox.id} --open`,
|
|
};
|
|
}
|
|
|
|
function telegramPrivatePostLink(groupId: string, messageId: string) {
|
|
if (!/^-100\d+$/u.test(groupId)) {
|
|
throw new Error(`Telegram privatepost links require a -100 group id, got ${groupId}.`);
|
|
}
|
|
return `tg://privatepost?channel=${groupId.slice(4)}&post=${messageId}`;
|
|
}
|
|
|
|
function renderProofViewCommand(link: string) {
|
|
return `set -euo pipefail
|
|
export DISPLAY="\${DISPLAY:-:99}"
|
|
root=${REMOTE_ROOT}
|
|
win="$(wmctrl -lxG | awk 'tolower($0) ~ /telegramdesktop/ {print $1; exit}')"
|
|
if [ -z "$win" ]; then
|
|
echo "Telegram Desktop window not found." >&2
|
|
exit 1
|
|
fi
|
|
wmctrl -ir "$win" -b remove,maximized_vert,maximized_horz,fullscreen
|
|
wmctrl -ir "$win" -e 0,${TELEGRAM_PROOF_VIEW.x},${TELEGRAM_PROOF_VIEW.y},${TELEGRAM_PROOF_VIEW.width},${TELEGRAM_PROOF_VIEW.height}
|
|
telegram="$root/Telegram/Telegram"
|
|
test -x "$telegram"
|
|
set +e
|
|
timeout 5 "$telegram" -workdir "$root/desktop" ${shellQuote(link)}
|
|
status="$?"
|
|
set -e
|
|
if [ "$status" -ne 0 ] && [ "$status" -ne 124 ]; then
|
|
exit "$status"
|
|
fi
|
|
sleep 1
|
|
wmctrl -lxG | awk 'tolower($0) ~ /telegramdesktop/'`;
|
|
}
|
|
|
|
async function viewSession(root: string, opts: Options, outputDir: string) {
|
|
const { session } = readSession(root, opts, outputDir);
|
|
const messageId = opts.messageId;
|
|
if (!messageId) {
|
|
throw new Error("view requires --message-id.");
|
|
}
|
|
const link = telegramPrivatePostLink(session.credential.groupId, messageId);
|
|
const result = await sshRun(root, session.crabbox.inspect, renderProofViewCommand(link));
|
|
const logPath = path.join(
|
|
session.outputDir,
|
|
`proof-view-${new Date().toISOString().replace(/[:.]/gu, "-")}.log`,
|
|
);
|
|
fs.writeFileSync(logPath, `${result.stdout}${result.stderr}`);
|
|
return {
|
|
geometry: TELEGRAM_PROOF_VIEW,
|
|
link,
|
|
log: path.relative(root, logPath),
|
|
status: "pass",
|
|
};
|
|
}
|
|
|
|
async function finishSession(root: string, opts: Options, outputDir: string) {
|
|
const { path: pathname, session } = readSession(root, opts, outputDir);
|
|
const summary: JsonObject = {
|
|
artifacts: {},
|
|
finishedAt: new Date().toISOString(),
|
|
session: path.relative(root, pathname),
|
|
startedAt: session.createdAt,
|
|
status: "fail",
|
|
};
|
|
const videoPath = path.join(session.outputDir, "telegram-user-crabbox-session.mp4");
|
|
const motionVideoPath = path.join(session.outputDir, "telegram-user-crabbox-session-motion.mp4");
|
|
const motionGifPath = path.join(session.outputDir, "telegram-user-crabbox-session-motion.gif");
|
|
const croppedMotionVideoPath = path.join(
|
|
session.outputDir,
|
|
"telegram-user-crabbox-session-motion-telegram-window.mp4",
|
|
);
|
|
const croppedMotionGifPath = path.join(
|
|
session.outputDir,
|
|
"telegram-user-crabbox-session-motion-telegram-window.gif",
|
|
);
|
|
const screenshotPath = path.join(session.outputDir, "telegram-user-crabbox-session.png");
|
|
const desktopLogPath = path.join(session.outputDir, "telegram-desktop.log");
|
|
const statusPath = path.join(session.outputDir, "status.json");
|
|
const ffmpegLogPath = path.join(session.outputDir, "ffmpeg.log");
|
|
const crop = previewCrop(opts);
|
|
try {
|
|
await stopRemoteRecording(root, session.crabbox.inspect, session);
|
|
await scpFromRemote(root, session.crabbox.inspect, session.recorder.remoteVideo, videoPath);
|
|
await scpFromRemote(
|
|
root,
|
|
session.crabbox.inspect,
|
|
`${REMOTE_ROOT}/telegram-desktop.log`,
|
|
desktopLogPath,
|
|
).catch(() => {});
|
|
await scpFromRemote(
|
|
root,
|
|
session.crabbox.inspect,
|
|
`${REMOTE_ROOT}/status.json`,
|
|
statusPath,
|
|
).catch(() => {});
|
|
await scpFromRemote(root, session.crabbox.inspect, session.recorder.log, ffmpegLogPath).catch(
|
|
() => {},
|
|
);
|
|
summary.mediaPreview = await createMotionPreview({
|
|
motionGifPath,
|
|
motionVideoPath,
|
|
opts,
|
|
root,
|
|
videoPath,
|
|
});
|
|
if (crop) {
|
|
summary.croppedMediaPreview = await createCroppedMotionPreview({
|
|
crop,
|
|
croppedGifPath: croppedMotionGifPath,
|
|
croppedVideoPath: croppedMotionVideoPath,
|
|
opts,
|
|
root,
|
|
videoPath: motionVideoPath,
|
|
});
|
|
}
|
|
await runCommand({
|
|
command: opts.crabboxBin,
|
|
args: [
|
|
"screenshot",
|
|
"--provider",
|
|
session.crabbox.provider,
|
|
"--target",
|
|
session.crabbox.target,
|
|
"--id",
|
|
session.crabbox.id,
|
|
"--output",
|
|
screenshotPath,
|
|
],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
summary.artifacts = {
|
|
desktopLog: path.relative(root, desktopLogPath),
|
|
ffmpegLog: path.relative(root, ffmpegLogPath),
|
|
previewGif: path.relative(root, motionGifPath),
|
|
...(crop
|
|
? {
|
|
previewGifCropped: path.relative(root, croppedMotionGifPath),
|
|
trimmedVideoCropped: path.relative(root, croppedMotionVideoPath),
|
|
}
|
|
: {}),
|
|
screenshot: path.relative(root, screenshotPath),
|
|
status: path.relative(root, statusPath),
|
|
trimmedVideo: path.relative(root, motionVideoPath),
|
|
video: path.relative(root, videoPath),
|
|
};
|
|
summary.status = "pass";
|
|
} finally {
|
|
killPidTree(session.localSut.gatewayPid);
|
|
killPidTree(session.localSut.mockPid);
|
|
await releaseCredential(root, opts, session.credential.leaseFile).catch((error: unknown) => {
|
|
summary.credentialReleaseError = error instanceof Error ? error.message : String(error);
|
|
});
|
|
if (session.crabbox.createdLease && !opts.keepBox) {
|
|
await stopCrabbox(root, opts, session.crabbox.id).catch((error: unknown) => {
|
|
summary.crabboxStopError = error instanceof Error ? error.message : String(error);
|
|
});
|
|
}
|
|
if (opts.keepBox) {
|
|
summary.keepBox = true;
|
|
summary.webvnc = `${opts.crabboxBin} webvnc --provider ${session.crabbox.provider} --target ${session.crabbox.target} --id ${session.crabbox.id} --open`;
|
|
}
|
|
fs.rmSync(session.localRoot, { force: true, recursive: true });
|
|
const summaryPath = path.join(session.outputDir, "telegram-user-crabbox-session-summary.json");
|
|
fs.writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
|
|
const reportPath = writeReport({
|
|
croppedMotionGifPath: crop ? croppedMotionGifPath : undefined,
|
|
croppedMotionVideoPath: crop ? croppedMotionVideoPath : undefined,
|
|
motionGifPath,
|
|
motionVideoPath,
|
|
outputDir: session.outputDir,
|
|
screenshotPath,
|
|
status: summary.status === "pass" ? "pass" : "fail",
|
|
summaryPath,
|
|
videoPath,
|
|
});
|
|
summary.report = path.relative(root, reportPath);
|
|
fs.writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
|
|
console.log(JSON.stringify({ reportPath, status: summary.status, summaryPath }, null, 2));
|
|
}
|
|
if (summary.status !== "pass") {
|
|
process.exitCode = 1;
|
|
}
|
|
}
|
|
|
|
async function publishSessionArtifacts(root: string, opts: Options, outputDir: string) {
|
|
const { session } = readSession(root, opts, outputDir);
|
|
const motionGifPath = path.join(session.outputDir, "telegram-user-crabbox-session-motion.gif");
|
|
const croppedMotionGifPath = path.join(
|
|
session.outputDir,
|
|
"telegram-user-crabbox-session-motion-telegram-window.gif",
|
|
);
|
|
const publishGifPath = fs.existsSync(croppedMotionGifPath) ? croppedMotionGifPath : motionGifPath;
|
|
const publishDir = opts.publishFullArtifacts
|
|
? session.outputDir
|
|
: path.join(session.outputDir, "publish-gif-only");
|
|
if (!opts.publishFullArtifacts) {
|
|
if (!fs.existsSync(publishGifPath)) {
|
|
throw new Error(
|
|
`Missing motion GIF. Run finish first: ${path.relative(root, motionGifPath)}`,
|
|
);
|
|
}
|
|
fs.rmSync(publishDir, { force: true, recursive: true });
|
|
fs.mkdirSync(publishDir, { recursive: true });
|
|
fs.copyFileSync(
|
|
publishGifPath,
|
|
path.join(publishDir, "telegram-user-crabbox-session-motion.gif"),
|
|
);
|
|
}
|
|
await runCommand({
|
|
command: opts.crabboxBin,
|
|
args: [
|
|
"artifacts",
|
|
"publish",
|
|
"--pr",
|
|
String(opts.publishPr),
|
|
"--repo",
|
|
opts.publishRepo,
|
|
"--dir",
|
|
publishDir,
|
|
"--summary",
|
|
opts.publishSummary ??
|
|
(opts.publishFullArtifacts
|
|
? "Telegram real-user Crabbox session artifacts"
|
|
: "Telegram real-user Crabbox session motion GIF"),
|
|
"--template",
|
|
"openclaw",
|
|
...(opts.dryRun ? ["--dry-run"] : []),
|
|
],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
return {
|
|
artifactMode: opts.publishFullArtifacts
|
|
? "full"
|
|
: publishGifPath === croppedMotionGifPath
|
|
? "gif-only-cropped"
|
|
: "gif-only",
|
|
publishDir: path.relative(root, publishDir),
|
|
status: "pass",
|
|
};
|
|
}
|
|
|
|
async function main() {
|
|
const opts = parseArgs(process.argv.slice(2));
|
|
const root = repoRoot();
|
|
const outputDir = resolveRepoPath(root, opts.outputDir);
|
|
fs.mkdirSync(outputDir, { recursive: true });
|
|
opts.outputDir = outputDir;
|
|
|
|
if (opts.command === "start") {
|
|
console.log(JSON.stringify(await startSession(root, opts, outputDir), null, 2));
|
|
return;
|
|
}
|
|
if (opts.command === "send") {
|
|
console.log(JSON.stringify(await sendSessionProbe(root, opts, outputDir), null, 2));
|
|
return;
|
|
}
|
|
if (opts.command === "run") {
|
|
console.log(JSON.stringify(await runSessionCommand(root, opts, outputDir), null, 2));
|
|
return;
|
|
}
|
|
if (opts.command === "screenshot") {
|
|
console.log(JSON.stringify(await screenshotSession(root, opts, outputDir), null, 2));
|
|
return;
|
|
}
|
|
if (opts.command === "status") {
|
|
console.log(JSON.stringify(await statusSession(root, opts, outputDir), null, 2));
|
|
return;
|
|
}
|
|
if (opts.command === "view") {
|
|
console.log(JSON.stringify(await viewSession(root, opts, outputDir), null, 2));
|
|
return;
|
|
}
|
|
if (opts.command === "finish") {
|
|
await finishSession(root, opts, outputDir);
|
|
return;
|
|
}
|
|
if (opts.command === "publish") {
|
|
console.log(JSON.stringify(await publishSessionArtifacts(root, opts, outputDir), null, 2));
|
|
return;
|
|
}
|
|
|
|
const localRoot = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-telegram-crabbox-"));
|
|
const summary: JsonObject = {
|
|
artifacts: {},
|
|
crabbox: { provider: opts.provider, target: opts.target },
|
|
outputDir,
|
|
startedAt: new Date().toISOString(),
|
|
status: "fail",
|
|
};
|
|
|
|
let credential: Awaited<ReturnType<typeof leaseCredential>> | undefined;
|
|
let leaseId = opts.leaseId;
|
|
let createdLease = false;
|
|
let localSut: LocalSut | undefined;
|
|
|
|
try {
|
|
const convexEnvFile = expandHome(opts.envFile ?? DEFAULT_CONVEX_ENV_FILE);
|
|
const hasConvexEnv =
|
|
trimToValue(process.env.OPENCLAW_QA_CONVEX_SITE_URL) &&
|
|
trimToValue(process.env.OPENCLAW_QA_CONVEX_SECRET_CI);
|
|
if (!hasConvexEnv && !fs.existsSync(convexEnvFile)) {
|
|
throw new Error(`Missing Convex env file: ${opts.envFile ?? DEFAULT_CONVEX_ENV_FILE}`);
|
|
}
|
|
await runCommand({ command: opts.crabboxBin, args: ["--version"], cwd: root });
|
|
if (opts.dryRun) {
|
|
summary.status = "pass";
|
|
summary.plan = {
|
|
command: "telegram-user-crabbox-proof",
|
|
crabboxClass: opts.crabboxClass,
|
|
outputDir,
|
|
provider: opts.provider,
|
|
target: opts.target,
|
|
tdlibSha256: opts.tdlibSha256,
|
|
tdlibUrl: opts.tdlibUrl,
|
|
text: opts.text,
|
|
};
|
|
return;
|
|
}
|
|
|
|
credential = await leaseCredential({ localRoot, opts, root });
|
|
const sut = opts.sutUsername
|
|
? { id: "", username: opts.sutUsername }
|
|
: await sutIdentity(credential.sutToken);
|
|
const targetText = buildTargetText(opts.text, sut.username);
|
|
summary.telegram = {
|
|
groupId: credential.groupId,
|
|
sutUsername: sut.username,
|
|
testerUserId: credential.testerUserId,
|
|
testerUsername: credential.testerUsername,
|
|
text: targetText,
|
|
};
|
|
|
|
const stateArchive = await prepareRemoteState({
|
|
localRoot,
|
|
opts,
|
|
root,
|
|
});
|
|
if (!leaseId) {
|
|
leaseId = await warmupCrabbox(opts, root);
|
|
createdLease = true;
|
|
}
|
|
summary.crabbox = {
|
|
createdLease,
|
|
id: leaseId,
|
|
provider: opts.provider,
|
|
target: opts.target,
|
|
};
|
|
const inspect = await inspectCrabbox(opts, root, leaseId);
|
|
summary.crabbox = {
|
|
createdLease,
|
|
id: leaseId,
|
|
provider: opts.provider,
|
|
slug: inspect.slug,
|
|
state: inspect.state,
|
|
target: opts.target,
|
|
};
|
|
|
|
const setupScript = path.join(localRoot, "remote-setup.sh");
|
|
const launchScript = path.join(localRoot, "launch-desktop.sh");
|
|
const selectChatScript = path.join(localRoot, "select-desktop-chat.sh");
|
|
const probeScript = path.join(localRoot, "remote-probe.sh");
|
|
await writeExecutable(
|
|
setupScript,
|
|
renderRemoteSetup({ tdlibSha256: opts.tdlibSha256, tdlibUrl: opts.tdlibUrl }),
|
|
);
|
|
await writeExecutable(launchScript, renderLaunchDesktop());
|
|
await writeExecutable(
|
|
selectChatScript,
|
|
renderSelectDesktopChat({ chatTitle: opts.desktopChatTitle }),
|
|
);
|
|
await writeExecutable(
|
|
probeScript,
|
|
renderRemoteProbe({
|
|
expect: opts.expect,
|
|
sutUsername: sut.username,
|
|
text: targetText,
|
|
timeoutMs: opts.timeoutMs,
|
|
}),
|
|
);
|
|
|
|
await sshRun(root, inspect, `rm -rf ${REMOTE_ROOT} && mkdir -p ${REMOTE_ROOT}`);
|
|
await scpToRemote(root, inspect, stateArchive, `${REMOTE_ROOT}/state.tgz`);
|
|
await scpToRemote(root, inspect, setupScript, `${REMOTE_ROOT}/remote-setup.sh`);
|
|
await scpToRemote(root, inspect, launchScript, `${REMOTE_ROOT}/launch-desktop.sh`);
|
|
await scpToRemote(root, inspect, selectChatScript, `${REMOTE_ROOT}/select-desktop-chat.sh`);
|
|
await scpToRemote(root, inspect, probeScript, `${REMOTE_ROOT}/remote-probe.sh`);
|
|
await sshRun(root, inspect, `bash ${REMOTE_ROOT}/remote-setup.sh`);
|
|
|
|
const sutRuntime = await startLocalSut({
|
|
gatewayPort: opts.gatewayPort,
|
|
groupId: credential.groupId,
|
|
mockResponseText: opts.mockResponseText,
|
|
mockPort: opts.mockPort,
|
|
outputDir,
|
|
repoRoot: root,
|
|
sutToken: credential.sutToken,
|
|
testerId: credential.testerUserId,
|
|
});
|
|
localSut = sutRuntime;
|
|
summary.localSut = {
|
|
drained: sutRuntime.drained,
|
|
gatewayPort: opts.gatewayPort,
|
|
mockPort: opts.mockPort,
|
|
requestLog: path.relative(root, sutRuntime.requestLog),
|
|
};
|
|
|
|
await sshRun(root, inspect, `bash ${REMOTE_ROOT}/launch-desktop.sh`);
|
|
await sshRun(root, inspect, `bash ${REMOTE_ROOT}/select-desktop-chat.sh`);
|
|
const videoPath = path.join(outputDir, "telegram-user-crabbox-proof.mp4");
|
|
const recording = spawn(
|
|
opts.crabboxBin,
|
|
[
|
|
"artifacts",
|
|
"video",
|
|
"--provider",
|
|
opts.provider,
|
|
"--target",
|
|
opts.target,
|
|
"--id",
|
|
leaseId,
|
|
"--duration",
|
|
`${opts.recordSeconds}s`,
|
|
"--output",
|
|
videoPath,
|
|
],
|
|
{ cwd: root, stdio: "inherit" },
|
|
);
|
|
await new Promise((resolve) => setTimeout(resolve, 3_000));
|
|
await sshRun(root, inspect, `bash ${REMOTE_ROOT}/remote-probe.sh`);
|
|
const recordCode = await new Promise<number | null>((resolve) => recording.on("exit", resolve));
|
|
if (recordCode !== 0) {
|
|
throw new Error(`Crabbox recording failed with exit code ${recordCode ?? "unknown"}.`);
|
|
}
|
|
const motionVideoPath = path.join(outputDir, "telegram-user-crabbox-proof-motion.mp4");
|
|
const motionGifPath = path.join(outputDir, "telegram-user-crabbox-proof-motion.gif");
|
|
summary.mediaPreview = await createMotionPreview({
|
|
motionGifPath,
|
|
motionVideoPath,
|
|
opts,
|
|
root,
|
|
videoPath,
|
|
});
|
|
|
|
const screenshotPath = path.join(outputDir, "telegram-user-crabbox-proof.png");
|
|
await runCommand({
|
|
command: opts.crabboxBin,
|
|
args: [
|
|
"screenshot",
|
|
"--provider",
|
|
opts.provider,
|
|
"--target",
|
|
opts.target,
|
|
"--id",
|
|
leaseId,
|
|
"--output",
|
|
screenshotPath,
|
|
],
|
|
cwd: root,
|
|
stdio: "inherit",
|
|
});
|
|
const probePath = path.join(outputDir, "probe.json");
|
|
const statusPath = path.join(outputDir, "status.json");
|
|
const desktopLogPath = path.join(outputDir, "telegram-desktop.log");
|
|
await scpFromRemote(root, inspect, `${REMOTE_ROOT}/probe.json`, probePath);
|
|
await scpFromRemote(root, inspect, `${REMOTE_ROOT}/status.json`, statusPath);
|
|
await scpFromRemote(root, inspect, `${REMOTE_ROOT}/telegram-desktop.log`, desktopLogPath);
|
|
summary.artifacts = {
|
|
desktopLog: path.relative(root, desktopLogPath),
|
|
probe: path.relative(root, probePath),
|
|
previewGif: path.relative(root, motionGifPath),
|
|
screenshot: path.relative(root, screenshotPath),
|
|
status: path.relative(root, statusPath),
|
|
trimmedVideo: path.relative(root, motionVideoPath),
|
|
video: path.relative(root, videoPath),
|
|
};
|
|
summary.probe = summarizeProbe(probePath);
|
|
summary.status = "pass";
|
|
} finally {
|
|
killTree(localSut?.gateway);
|
|
killTree(localSut?.mock);
|
|
if (credential) {
|
|
await releaseCredential(root, opts, credential.leaseFile).catch((error: unknown) => {
|
|
summary.credentialReleaseError = error instanceof Error ? error.message : String(error);
|
|
});
|
|
}
|
|
if (leaseId && createdLease && !opts.keepBox) {
|
|
await stopCrabbox(root, opts, leaseId).catch((error: unknown) => {
|
|
summary.crabboxStopError = error instanceof Error ? error.message : String(error);
|
|
});
|
|
}
|
|
if (opts.keepBox && leaseId) {
|
|
summary.keepBox = true;
|
|
summary.webvnc = `${opts.crabboxBin} webvnc --provider ${opts.provider} --target ${opts.target} --id ${leaseId} --open`;
|
|
}
|
|
summary.finishedAt = new Date().toISOString();
|
|
const summaryPath = path.join(outputDir, "telegram-user-crabbox-proof-summary.json");
|
|
fs.writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
|
|
const artifacts = summary.artifacts;
|
|
const screenshotPath =
|
|
artifacts &&
|
|
typeof artifacts === "object" &&
|
|
"screenshot" in artifacts &&
|
|
typeof artifacts.screenshot === "string"
|
|
? path.join(root, artifacts.screenshot)
|
|
: undefined;
|
|
const motionGifPath =
|
|
artifacts &&
|
|
typeof artifacts === "object" &&
|
|
"previewGif" in artifacts &&
|
|
typeof artifacts.previewGif === "string"
|
|
? path.join(root, artifacts.previewGif)
|
|
: undefined;
|
|
const motionVideoPath =
|
|
artifacts &&
|
|
typeof artifacts === "object" &&
|
|
"trimmedVideo" in artifacts &&
|
|
typeof artifacts.trimmedVideo === "string"
|
|
? path.join(root, artifacts.trimmedVideo)
|
|
: undefined;
|
|
const videoPath =
|
|
artifacts &&
|
|
typeof artifacts === "object" &&
|
|
"video" in artifacts &&
|
|
typeof artifacts.video === "string"
|
|
? path.join(root, artifacts.video)
|
|
: undefined;
|
|
const reportPath = writeReport({
|
|
motionGifPath,
|
|
motionVideoPath,
|
|
outputDir,
|
|
screenshotPath,
|
|
status: summary.status === "pass" ? "pass" : "fail",
|
|
summaryPath,
|
|
videoPath,
|
|
});
|
|
summary.report = path.relative(root, reportPath);
|
|
fs.writeFileSync(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
|
|
fs.rmSync(localRoot, { force: true, recursive: true });
|
|
console.log(JSON.stringify({ outputDir, reportPath, status: summary.status }, null, 2));
|
|
}
|
|
|
|
if (summary.status !== "pass") {
|
|
process.exitCode = 1;
|
|
}
|
|
}
|
|
|
|
main().catch((error: unknown) => {
|
|
console.error(error instanceof Error ? error.message : String(error));
|
|
process.exit(1);
|
|
});
|