});

}

function renderRemoteSetup(params: { tdlibSha256?: string; tdlibUrl?: string }) {

const tdlibSha256 = JSON.stringify(params.tdlibSha256 ?? "");

const tdlibUrl = JSON.stringify(params.tdlibUrl ?? "");

export function renderRemoteSetup(params: { tdlibSha256?: string; tdlibUrl?: string }) {

const tdlibSha256 = shellQuote(params.tdlibSha256 ?? "");

const tdlibUrl = shellQuote(params.tdlibUrl ?? "");

return `#!/usr/bin/env bash

set -euo pipefail

root=${REMOTE_ROOT}

`;

}

function renderSelectDesktopChat(params: { chatTitle: string }) {

export function renderSelectDesktopChat(params: { chatTitle: string }) {

return `#!/usr/bin/env bash

set -euo pipefail

chat_title=${JSON.stringify(params.chatTitle)}

chat_title=${shellQuote(params.chatTitle)}

export DISPLAY="\${DISPLAY:-:99}"

win="$(wmctrl -l | awk 'tolower($0) ~ /telegram/ {print $1; exit}')"

test -n "$win"

`;

}

function renderRemoteProbe(params: {

export function renderRemoteProbe(params: {

expect: string[];

outputPath?: string;

sutUsername: string;

for (const expected of params.expect) {

args.push("--expect", expected);

}

const escapedArgs = args.map((arg) => JSON.stringify(arg)).join(" ");

const escapedArgs = args.map(shellQuote).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)}

export TELEGRAM_USER_DRIVER_SUT_USERNAME=${shellQuote(params.sutUsername)}

python3 "$root/user-driver.py" ${escapedArgs}

`;

}

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}

export TELEGRAM_USER_DRIVER_SUT_USERNAME=${shellQuote(params.sutUsername)}

EOF

`,

);

root,

inspect,

`set -euo pipefail

pid_file=${JSON.stringify(session.recorder.pidFile)}

pid_file=${shellQuote(session.recorder.pidFile)}

if [ -s "$pid_file" ]; then

pid="$(cat "$pid_file")"

kill -INT "$pid" >/dev/null 2>&1 || true

recordProbeVideo,

REMOTE_SETUP_COMMAND_TIMEOUT_MS,

renderLaunchDesktop,

renderRemoteProbe,

renderRemoteSetup,

renderSelectDesktopChat,

runCommand,

startLocalSut,

waitForLog,

expect(script).not.toContain('cat "$root/telegram-desktop.log"');

});

it("shell-quotes generated remote setup and chat literals", () => {

const payload = "name $(touch /tmp/openclaw-proof-injected) `touch /tmp/also-injected`";

expect(renderRemoteSetup({ tdlibSha256: payload, tdlibUrl: payload })).toContain(

`tdlib_url='${payload}'`,

);

expect(renderSelectDesktopChat({ chatTitle: payload })).toContain(`chat_title='${payload}'`);

});

posixIt("does not expand generated remote probe arguments in the shell", () => {

const root = makeTempDir();

const fakePython = path.join(root, "python3");

const scriptPath = path.join(root, "remote-probe.sh");

const argvPath = path.join(root, "argv.json");

const injectedPath = path.join(root, "injected");

const payload = `literal ' $(touch ${injectedPath})`;

writeExecutable(

fakePython,

`#!/usr/bin/env node

import fs from "node:fs";

fs.writeFileSync(process.env.OPENCLAW_TEST_ARGV_PATH, JSON.stringify(process.argv.slice(1)));

`,

);

writeExecutable(

scriptPath,

renderRemoteProbe({

expect: [payload],

sutUsername: payload,

text: payload,

timeoutMs: 1000,

}),

);

const result = spawnSync("bash", [scriptPath], {

cwd: root,

encoding: "utf8",

env: {

...process.env,

OPENCLAW_TEST_ARGV_PATH: argvPath,

PATH: `${root}${path.delimiter}${process.env.PATH ?? ""}`,

},

});

expect(result.status).toBe(0);

expect(fs.existsSync(injectedPath)).toBe(false);

expect(JSON.parse(fs.readFileSync(argvPath, "utf8"))).toContain(payload);

});

posixIt("kills timed-out command process groups when the leader exits first", async () => {

const root = makeTempDir();

const scriptPath = path.join(root, "trap-term.mjs");