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";

export const COMMAND_STDOUT_MAX_CHARS = 1024 * 1024;

export const COMMAND_STDERR_TAIL_CHARS = 256 * 1024;

export const COMMAND_FAILURE_STDOUT_TAIL_CHARS = 64 * 1024;

const REMOTE_ROOT = "/tmp/openclaw-telegram-user-crabbox";

const CREDENTIAL_SCRIPT = fileURLToPath(new URL("./telegram-user-credential.ts", import.meta.url));

const LOG_READY_TAIL_BYTES = readPositiveInt(

return `'${value.replaceAll("'", "'\\''")}'`;

}

type AppendCommandStdoutResult = { ok: true; value: string } | { ok: false; message: string };

function appendCommandText(current: string, chunk: Buffer): string {

return current + chunk.toString("utf8");

}

export function appendCommandTextTail(current: string, chunk: Buffer, maxChars: number): string {

const next = appendCommandText(current, chunk);

return next.length > maxChars ? next.slice(-maxChars) : next;

}

export function appendCommandStdout(

current: string,

chunk: Buffer,

maxChars = COMMAND_STDOUT_MAX_CHARS,

): AppendCommandStdoutResult {

const next = appendCommandText(current, chunk);

if (next.length > maxChars) {

return { ok: false, message: `command stdout exceeded ${maxChars} characters` };

}

return { ok: true, value: next };

}

export function appendCommandStderrTail(

current: string,

chunk: Buffer,

maxChars = COMMAND_STDERR_TAIL_CHARS,

): string {

return appendCommandTextTail(current, chunk, maxChars);

}

function commandFailureOutput(stdout: string, stderr: string): string {

const stdoutTail =

stdout.length > COMMAND_FAILURE_STDOUT_TAIL_CHARS

? `\n[stdout truncated to last ${COMMAND_FAILURE_STDOUT_TAIL_CHARS} characters]\n${stdout.slice(

-COMMAND_FAILURE_STDOUT_TAIL_CHARS,

)}`

: stdout;

return `${stdoutTail}${stderr}`;

}

function runCommand(params: {

args: string[];

command: string;

cwd: string;

env?: NodeJS.ProcessEnv;

outputFile?: string;

stdio?: "inherit" | "pipe";

stdin?: string;

}) {

return new Promise<CommandResult>((resolve, reject) => {

if (params.outputFile) {

fs.writeFileSync(params.outputFile, "");

}

const child = spawn(params.command, params.args, {

cwd: params.cwd,

env: params.env ?? process.env,

stdio: ["pipe", "pipe", "pipe"],

});

let stdout = "";

let stderr = "";

let stdoutLimitError: string | null = null;

child.stdout.on("data", (chunk: Buffer) => {

const text = chunk.toString();

stdout += text;

if (params.outputFile) {

fs.appendFileSync(params.outputFile, text);

stdout = appendCommandTextTail(stdout, chunk, COMMAND_FAILURE_STDOUT_TAIL_CHARS);

} else if (params.stdio === "inherit") {

stdout = appendCommandTextTail(stdout, chunk, COMMAND_FAILURE_STDOUT_TAIL_CHARS);

} else {

const appended = appendCommandStdout(stdout, chunk);

if (!appended.ok) {

stdoutLimitError = appended.message;

child.kill("SIGKILL");

} else {

stdout = appended.value;

}

}

if (params.stdio === "inherit") {

process.stdout.write(text);

}

});

child.stderr.on("data", (chunk: Buffer) => {

const text = chunk.toString();

stderr += text;

if (params.outputFile) {

fs.appendFileSync(params.outputFile, text);

}

stderr = appendCommandStderrTail(stderr, chunk);

if (params.stdio === "inherit") {

process.stderr.write(text);

}

});

child.on("error", reject);

child.on("close", (code, signal) => {

if (stdoutLimitError) {

reject(new Error(`${params.command} ${params.args.join(" ")} failed: ${stdoutLimitError}`));

return;

}

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}`,

`${params.command} ${params.args.join(" ")} failed with ${detail}\n${commandFailureOutput(

stdout,

stderr,

)}`,

),

);

});

args: string[];

command: string;

cwd: string;

outputFile?: string;

stdio?: "inherit" | "pipe";

}) {

let lastError: unknown;

});

}

async function sshRun(root: string, inspect: CrabboxInspect, remoteCommand: string) {

async function sshRun(

root: string,

inspect: CrabboxInspect,

remoteCommand: string,

options: { outputFile?: string } = {},

) {

const ssh = sshArgs(inspect);

return await runRemoteCommand({

command: "ssh",

args: [...ssh.base, ssh.target, remoteCommand],

cwd: root,

outputFile: options.outputFile,

stdio: "inherit",

});

}

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}`);

await sshRun(root, session.crabbox.inspect, command, { outputFile: logPath });

return { command: opts.remoteCommand, log: path.relative(root, logPath), status: "pass" };

}

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}`);

await sshRun(root, session.crabbox.inspect, renderProofViewCommand(link), {

outputFile: logPath,

});

return {

crop: TELEGRAM_PROOF_CROP,

geometry: TELEGRAM_PROOF_WINDOW,