clawdbot 2026.1.4-1

package/dist/cli/nodes-screen.js

@@ -0,0 +1,37 @@
+import { randomUUID } from "node:crypto";
+import * as os from "node:os";
+import * as path from "node:path";
+import { writeBase64ToFile } from "./nodes-camera.js";
+function asRecord(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function parseScreenRecordPayload(value) {
+    const obj = asRecord(value);
+    const format = asString(obj.format);
+    const base64 = asString(obj.base64);
+    if (!format || !base64) {
+        throw new Error("invalid screen.record payload");
+    }
+    return {
+        format,
+        base64,
+        durationMs: typeof obj.durationMs === "number" ? obj.durationMs : undefined,
+        fps: typeof obj.fps === "number" ? obj.fps : undefined,
+        screenIndex: typeof obj.screenIndex === "number" ? obj.screenIndex : undefined,
+        hasAudio: typeof obj.hasAudio === "boolean" ? obj.hasAudio : undefined,
+    };
+}
+export function screenRecordTempPath(opts) {
+    const tmpDir = opts.tmpDir ?? os.tmpdir();
+    const id = opts.id ?? randomUUID();
+    const ext = opts.ext.startsWith(".") ? opts.ext : `.${opts.ext}`;
+    return path.join(tmpDir, `clawdbot-screen-record-${id}${ext}`);
+}
+export async function writeScreenRecordToFile(filePath, base64) {
+    return writeBase64ToFile(filePath, base64);
+}

package/dist/cli/parse-duration.js

@@ -0,0 +1,20 @@
+export function parseDurationMs(raw, opts) {
+    const trimmed = String(raw ?? "")
+        .trim()
+        .toLowerCase();
+    if (!trimmed)
+        throw new Error("invalid duration (empty)");
+    const m = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(trimmed);
+    if (!m)
+        throw new Error(`invalid duration: ${raw}`);
+    const value = Number(m[1]);
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`invalid duration: ${raw}`);
+    }
+    const unit = (m[2] ?? opts?.defaultUnit ?? "ms");
+    const multiplier = unit === "ms" ? 1 : unit === "s" ? 1000 : unit === "m" ? 60_000 : 3_600_000;
+    const ms = Math.round(value * multiplier);
+    if (!Number.isFinite(ms))
+        throw new Error(`invalid duration: ${raw}`);
+    return ms;
+}

package/dist/cli/ports.js

@@ -0,0 +1,97 @@
+import { execFileSync } from "node:child_process";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function parseLsofOutput(output) {
+    const lines = output.split(/\r?\n/).filter(Boolean);
+    const results = [];
+    let current = {};
+    for (const line of lines) {
+        if (line.startsWith("p")) {
+            if (current.pid)
+                results.push(current);
+            current = { pid: Number.parseInt(line.slice(1), 10) };
+        }
+        else if (line.startsWith("c")) {
+            current.command = line.slice(1);
+        }
+    }
+    if (current.pid)
+        results.push(current);
+    return results;
+}
+export function listPortListeners(port) {
+    try {
+        const out = execFileSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-FpFc"], { encoding: "utf-8" });
+        return parseLsofOutput(out);
+    }
+    catch (err) {
+        const status = err.status;
+        const code = err.code;
+        if (code === "ENOENT") {
+            throw new Error("lsof not found; required for --force");
+        }
+        if (status === 1)
+            return []; // no listeners
+        throw err instanceof Error ? err : new Error(String(err));
+    }
+}
+export function forceFreePort(port) {
+    const listeners = listPortListeners(port);
+    for (const proc of listeners) {
+        try {
+            process.kill(proc.pid, "SIGTERM");
+        }
+        catch (err) {
+            throw new Error(`failed to kill pid ${proc.pid}${proc.command ? ` (${proc.command})` : ""}: ${String(err)}`);
+        }
+    }
+    return listeners;
+}
+function killPids(listeners, signal) {
+    for (const proc of listeners) {
+        try {
+            process.kill(proc.pid, signal);
+        }
+        catch (err) {
+            throw new Error(`failed to kill pid ${proc.pid}${proc.command ? ` (${proc.command})` : ""}: ${String(err)}`);
+        }
+    }
+}
+export async function forceFreePortAndWait(port, opts = {}) {
+    const timeoutMs = Math.max(opts.timeoutMs ?? 1500, 0);
+    const intervalMs = Math.max(opts.intervalMs ?? 100, 1);
+    const sigtermTimeoutMs = Math.min(Math.max(opts.sigtermTimeoutMs ?? 600, 0), timeoutMs);
+    const killed = forceFreePort(port);
+    if (killed.length === 0) {
+        return { killed, waitedMs: 0, escalatedToSigkill: false };
+    }
+    let waitedMs = 0;
+    const triesSigterm = intervalMs > 0 ? Math.ceil(sigtermTimeoutMs / intervalMs) : 0;
+    for (let i = 0; i < triesSigterm; i++) {
+        if (listPortListeners(port).length === 0) {
+            return { killed, waitedMs, escalatedToSigkill: false };
+        }
+        await sleep(intervalMs);
+        waitedMs += intervalMs;
+    }
+    if (listPortListeners(port).length === 0) {
+        return { killed, waitedMs, escalatedToSigkill: false };
+    }
+    const remaining = listPortListeners(port);
+    killPids(remaining, "SIGKILL");
+    const remainingBudget = Math.max(timeoutMs - waitedMs, 0);
+    const triesSigkill = intervalMs > 0 ? Math.ceil(remainingBudget / intervalMs) : 0;
+    for (let i = 0; i < triesSigkill; i++) {
+        if (listPortListeners(port).length === 0) {
+            return { killed, waitedMs, escalatedToSigkill: true };
+        }
+        await sleep(intervalMs);
+        waitedMs += intervalMs;
+    }
+    const still = listPortListeners(port);
+    if (still.length === 0) {
+        return { killed, waitedMs, escalatedToSigkill: true };
+    }
+    throw new Error(`port ${port} still has listeners after --force: ${still.map((p) => p.pid).join(", ")}`);
+}

package/dist/cli/program.js

@@ -0,0 +1,406 @@
+import chalk from "chalk";
+import { Command } from "commander";
+import { agentCommand } from "../commands/agent.js";
+import { configureCommand } from "../commands/configure.js";
+import { doctorCommand } from "../commands/doctor.js";
+import { healthCommand } from "../commands/health.js";
+import { onboardCommand } from "../commands/onboard.js";
+import { sendCommand } from "../commands/send.js";
+import { sessionsCommand } from "../commands/sessions.js";
+import { setupCommand } from "../commands/setup.js";
+import { statusCommand } from "../commands/status.js";
+import { updateCommand } from "../commands/update.js";
+import { readConfigFileSnapshot } from "../config/config.js";
+import { danger, setVerbose } from "../globals.js";
+import { loginWeb, logoutWeb } from "../provider-web.js";
+import { defaultRuntime } from "../runtime.js";
+import { VERSION } from "../version.js";
+import { registerBrowserCli } from "./browser-cli.js";
+import { registerCanvasCli } from "./canvas-cli.js";
+import { registerCronCli } from "./cron-cli.js";
+import { createDefaultDeps } from "./deps.js";
+import { registerDnsCli } from "./dns-cli.js";
+import { registerGatewayCli } from "./gateway-cli.js";
+import { registerHooksCli } from "./hooks-cli.js";
+import { registerModelsCli } from "./models-cli.js";
+import { registerNodesCli } from "./nodes-cli.js";
+import { forceFreePort } from "./ports.js";
+import { registerTuiCli } from "./tui-cli.js";
+export { forceFreePort };
+export function buildProgram() {
+    const program = new Command();
+    const PROGRAM_VERSION = VERSION;
+    const TAGLINE = "Send, receive, and auto-reply on WhatsApp (web) and Telegram (bot).";
+    program.name("clawdbot").description("").version(PROGRAM_VERSION);
+    const formatIntroLine = (version, rich = true) => {
+        const base = `📡 clawdbot ${version} — ${TAGLINE}`;
+        return rich && chalk.level > 0
+            ? `${chalk.bold.cyan("📡 clawdbot")} ${chalk.white(version)} ${chalk.gray("—")} ${chalk.green(TAGLINE)}`
+            : base;
+    };
+    program.configureHelp({
+        optionTerm: (option) => chalk.yellow(option.flags),
+        subcommandTerm: (cmd) => chalk.green(cmd.name()),
+    });
+    program.configureOutput({
+        writeOut: (str) => {
+            const colored = str
+                .replace(/^Usage:/gm, chalk.bold.cyan("Usage:"))
+                .replace(/^Options:/gm, chalk.bold.cyan("Options:"))
+                .replace(/^Commands:/gm, chalk.bold.cyan("Commands:"));
+            process.stdout.write(colored);
+        },
+        writeErr: (str) => process.stderr.write(str),
+        outputError: (str, write) => write(chalk.red(str)),
+    });
+    if (process.argv.includes("-V") ||
+        process.argv.includes("--version") ||
+        process.argv.includes("-v")) {
+        console.log(PROGRAM_VERSION);
+        process.exit(0);
+    }
+    program.addHelpText("beforeAll", `\n${formatIntroLine(PROGRAM_VERSION)}\n`);
+    program.hook("preAction", async (_thisCommand, actionCommand) => {
+        if (actionCommand.name() === "doctor")
+            return;
+        const snapshot = await readConfigFileSnapshot();
+        if (snapshot.legacyIssues.length === 0)
+            return;
+        const issues = snapshot.legacyIssues
+            .map((issue) => `- ${issue.path}: ${issue.message}`)
+            .join("\n");
+        defaultRuntime.error(danger(`Legacy config entries detected. Run "clawdbot doctor" (or ask your agent) to migrate.\n${issues}`));
+        process.exit(1);
+    });
+    const examples = [
+        [
+            "clawdbot login --verbose",
+            "Link personal WhatsApp Web and show QR + connection logs.",
+        ],
+        [
+            'clawdbot send --to +15555550123 --message "Hi" --json',
+            "Send via your web session and print JSON result.",
+        ],
+        ["clawdbot gateway --port 18789", "Run the WebSocket Gateway locally."],
+        [
+            "clawdbot gateway --force",
+            "Kill anything bound to the default gateway port, then start it.",
+        ],
+        ["clawdbot gateway ...", "Gateway control via WebSocket."],
+        [
+            'clawdbot agent --to +15555550123 --message "Run summary" --deliver',
+            "Talk directly to the agent using the Gateway; optionally send the WhatsApp reply.",
+        ],
+        [
+            'clawdbot send --provider telegram --to @mychat --message "Hi"',
+            "Send via your Telegram bot.",
+        ],
+    ];
+    const fmtExamples = examples
+        .map(([cmd, desc]) => `  ${chalk.green(cmd)}\n    ${chalk.gray(desc)}`)
+        .join("\n");
+    program.addHelpText("afterAll", `\n${chalk.bold.cyan("Examples:")}\n${fmtExamples}\n`);
+    program
+        .command("setup")
+        .description("Initialize ~/.clawdbot/clawdbot.json and the agent workspace")
+        .option("--workspace <dir>", "Agent workspace directory (default: ~/clawd; stored as agent.workspace)")
+        .option("--wizard", "Run the interactive onboarding wizard", false)
+        .option("--non-interactive", "Run the wizard without prompts", false)
+        .option("--mode <mode>", "Wizard mode: local|remote")
+        .option("--remote-url <url>", "Remote Gateway WebSocket URL")
+        .option("--remote-token <token>", "Remote Gateway token (optional)")
+        .action(async (opts) => {
+        try {
+            if (opts.wizard) {
+                await onboardCommand({
+                    workspace: opts.workspace,
+                    nonInteractive: Boolean(opts.nonInteractive),
+                    mode: opts.mode,
+                    remoteUrl: opts.remoteUrl,
+                    remoteToken: opts.remoteToken,
+                }, defaultRuntime);
+                return;
+            }
+            await setupCommand({ workspace: opts.workspace }, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("onboard")
+        .description("Interactive wizard to set up the gateway, workspace, and skills")
+        .option("--workspace <dir>", "Agent workspace directory (default: ~/clawd)")
+        .option("--non-interactive", "Run without prompts", false)
+        .option("--mode <mode>", "Wizard mode: local|remote")
+        .option("--auth-choice <choice>", "Auth: oauth|apiKey|minimax|skip")
+        .option("--anthropic-api-key <key>", "Anthropic API key")
+        .option("--gateway-port <port>", "Gateway port")
+        .option("--gateway-bind <mode>", "Gateway bind: loopback|lan|tailnet|auto")
+        .option("--gateway-auth <mode>", "Gateway auth: off|token|password")
+        .option("--gateway-token <token>", "Gateway token (token auth)")
+        .option("--gateway-password <password>", "Gateway password (password auth)")
+        .option("--remote-url <url>", "Remote Gateway WebSocket URL")
+        .option("--remote-token <token>", "Remote Gateway token (optional)")
+        .option("--tailscale <mode>", "Tailscale: off|serve|funnel")
+        .option("--tailscale-reset-on-exit", "Reset tailscale serve/funnel on exit")
+        .option("--install-daemon", "Install gateway daemon")
+        .option("--skip-skills", "Skip skills setup")
+        .option("--skip-health", "Skip health check")
+        .option("--node-manager <name>", "Node manager for skills: npm|pnpm|bun")
+        .option("--json", "Output JSON summary", false)
+        .action(async (opts) => {
+        try {
+            await onboardCommand({
+                workspace: opts.workspace,
+                nonInteractive: Boolean(opts.nonInteractive),
+                mode: opts.mode,
+                authChoice: opts.authChoice,
+                anthropicApiKey: opts.anthropicApiKey,
+                gatewayPort: typeof opts.gatewayPort === "string"
+                    ? Number.parseInt(opts.gatewayPort, 10)
+                    : undefined,
+                gatewayBind: opts.gatewayBind,
+                gatewayAuth: opts.gatewayAuth,
+                gatewayToken: opts.gatewayToken,
+                gatewayPassword: opts.gatewayPassword,
+                remoteUrl: opts.remoteUrl,
+                remoteToken: opts.remoteToken,
+                tailscale: opts.tailscale,
+                tailscaleResetOnExit: Boolean(opts.tailscaleResetOnExit),
+                installDaemon: Boolean(opts.installDaemon),
+                skipSkills: Boolean(opts.skipSkills),
+                skipHealth: Boolean(opts.skipHealth),
+                nodeManager: opts.nodeManager,
+                json: Boolean(opts.json),
+            }, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("configure")
+        .alias("config")
+        .description("Interactive wizard to update models, providers, skills, and gateway")
+        .action(async () => {
+        try {
+            await configureCommand(defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("doctor")
+        .description("Health checks + quick fixes for the gateway and providers")
+        .action(async () => {
+        try {
+            await doctorCommand(defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("update")
+        .description("Audit and modernize the local configuration")
+        .action(async () => {
+        try {
+            await updateCommand(defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("login")
+        .description("Link your personal WhatsApp via QR (web provider)")
+        .option("--verbose", "Verbose connection logs", false)
+        .option("--provider <provider>", "Provider alias (default: whatsapp)")
+        .action(async (opts) => {
+        setVerbose(Boolean(opts.verbose));
+        try {
+            const provider = opts.provider ?? "whatsapp";
+            await loginWeb(Boolean(opts.verbose), provider);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(`Web login failed: ${String(err)}`));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("logout")
+        .description("Clear cached WhatsApp Web credentials")
+        .option("--provider <provider>", "Provider alias (default: whatsapp)")
+        .action(async (opts) => {
+        try {
+            void opts.provider; // placeholder for future multi-provider; currently web only.
+            await logoutWeb(defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(danger(`Logout failed: ${String(err)}`));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("send")
+        .description("Send a message (WhatsApp Web, Telegram bot, Discord, Slack, Signal, iMessage)")
+        .requiredOption("-t, --to <number>", "Recipient: E.164 for WhatsApp/Signal, Telegram chat id/@username, Discord channel/user, or iMessage handle/chat_id")
+        .requiredOption("-m, --message <text>", "Message body")
+        .option("--media <path-or-url>", "Attach media (image/audio/video/document). Accepts local paths or URLs.")
+        .option("--gif-playback", "Treat video media as GIF playback (WhatsApp only).", false)
+        .option("--provider <provider>", "Delivery provider: whatsapp|telegram|discord|slack|signal|imessage (default: whatsapp)")
+        .option("--dry-run", "Print payload and skip sending", false)
+        .option("--json", "Output result as JSON", false)
+        .option("--verbose", "Verbose logging", false)
+        .addHelpText("after", `
+Examples:
+  clawdbot send --to +15555550123 --message "Hi"
+  clawdbot send --to +15555550123 --message "Hi" --media photo.jpg
+  clawdbot send --to +15555550123 --message "Hi" --dry-run      # print payload only
+  clawdbot send --to +15555550123 --message "Hi" --json         # machine-readable result`)
+        .action(async (opts) => {
+        setVerbose(Boolean(opts.verbose));
+        const deps = createDefaultDeps();
+        try {
+            await sendCommand(opts, deps, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("agent")
+        .description("Talk directly to the configured agent (no chat send; optional delivery)")
+        .requiredOption("-m, --message <text>", "Message body for the agent")
+        .option("-t, --to <number>", "Recipient number in E.164 used to derive the session key")
+        .option("--session-id <id>", "Use an explicit session id")
+        .option("--thinking <level>", "Thinking level: off | minimal | low | medium | high")
+        .option("--verbose <on|off>", "Persist agent verbose level for the session")
+        .option("--provider <provider>", "Delivery provider: whatsapp|telegram|discord|slack|signal|imessage (default: whatsapp)")
+        .option("--deliver", "Send the agent's reply back to the selected provider (requires --to)", false)
+        .option("--json", "Output result as JSON", false)
+        .option("--timeout <seconds>", "Override agent command timeout (seconds, default 600 or config value)")
+        .addHelpText("after", `
+Examples:
+  clawdbot agent --to +15555550123 --message "status update"
+  clawdbot agent --session-id 1234 --message "Summarize inbox" --thinking medium
+  clawdbot agent --to +15555550123 --message "Trace logs" --verbose on --json
+  clawdbot agent --to +15555550123 --message "Summon reply" --deliver
+`)
+        .action(async (opts) => {
+        const verboseLevel = typeof opts.verbose === "string" ? opts.verbose.toLowerCase() : "";
+        setVerbose(verboseLevel === "on");
+        // Build default deps (keeps parity with other commands; future-proofing).
+        void createDefaultDeps();
+        try {
+            await agentCommand(opts, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    registerCanvasCli(program);
+    registerGatewayCli(program);
+    registerModelsCli(program);
+    registerNodesCli(program);
+    registerTuiCli(program);
+    registerCronCli(program);
+    registerDnsCli(program);
+    registerHooksCli(program);
+    program
+        .command("status")
+        .description("Show web session health and recent session recipients")
+        .option("--json", "Output JSON instead of text", false)
+        .option("--deep", "Probe providers (WhatsApp Web + Telegram + Discord + Slack + Signal)", false)
+        .option("--timeout <ms>", "Probe timeout in milliseconds", "10000")
+        .option("--verbose", "Verbose logging", false)
+        .addHelpText("after", `
+Examples:
+  clawdbot status                   # show linked account + session store summary
+  clawdbot status --json            # machine-readable output
+  clawdbot status --deep            # run provider probes (WA + Telegram + Discord + Slack + Signal)
+  clawdbot status --deep --timeout 5000 # tighten probe timeout`)
+        .action(async (opts) => {
+        setVerbose(Boolean(opts.verbose));
+        const timeout = opts.timeout
+            ? Number.parseInt(String(opts.timeout), 10)
+            : undefined;
+        if (timeout !== undefined && (Number.isNaN(timeout) || timeout <= 0)) {
+            defaultRuntime.error("--timeout must be a positive integer (milliseconds)");
+            defaultRuntime.exit(1);
+            return;
+        }
+        try {
+            await statusCommand({
+                json: Boolean(opts.json),
+                deep: Boolean(opts.deep),
+                timeoutMs: timeout,
+            }, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("health")
+        .description("Fetch health from the running gateway")
+        .option("--json", "Output JSON instead of text", false)
+        .option("--timeout <ms>", "Connection timeout in milliseconds", "10000")
+        .option("--verbose", "Verbose logging", false)
+        .action(async (opts) => {
+        setVerbose(Boolean(opts.verbose));
+        const timeout = opts.timeout
+            ? Number.parseInt(String(opts.timeout), 10)
+            : undefined;
+        if (timeout !== undefined && (Number.isNaN(timeout) || timeout <= 0)) {
+            defaultRuntime.error("--timeout must be a positive integer (milliseconds)");
+            defaultRuntime.exit(1);
+            return;
+        }
+        try {
+            await healthCommand({
+                json: Boolean(opts.json),
+                timeoutMs: timeout,
+            }, defaultRuntime);
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+    program
+        .command("sessions")
+        .description("List stored conversation sessions")
+        .option("--json", "Output as JSON", false)
+        .option("--verbose", "Verbose logging", false)
+        .option("--store <path>", "Path to session store (default: resolved from config)")
+        .option("--active <minutes>", "Only show sessions updated within the past N minutes")
+        .addHelpText("after", `
+Examples:
+  clawdbot sessions                 # list all sessions
+  clawdbot sessions --active 120    # only last 2 hours
+  clawdbot sessions --json          # machine-readable output
+  clawdbot sessions --store ./tmp/sessions.json
+
+Shows token usage per session when the agent reports it; set agent.contextTokens to see % of your model window.`)
+        .action(async (opts) => {
+        setVerbose(Boolean(opts.verbose));
+        await sessionsCommand({
+            json: Boolean(opts.json),
+            store: opts.store,
+            active: opts.active,
+        }, defaultRuntime);
+    });
+    registerBrowserCli(program);
+    return program;
+}

package/dist/cli/prompt.js

@@ -0,0 +1,19 @@
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+import { isVerbose, isYes } from "../globals.js";
+export async function promptYesNo(question, defaultYes = false) {
+    // Simple Y/N prompt honoring global --yes and verbosity flags.
+    if (isVerbose() && isYes())
+        return true; // redundant guard when both flags set
+    if (isYes())
+        return true;
+    const rl = readline.createInterface({ input, output });
+    const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+    const answer = (await rl.question(`${question}${suffix}`))
+        .trim()
+        .toLowerCase();
+    rl.close();
+    if (!answer)
+        return defaultYes;
+    return answer.startsWith("y");
+}

package/dist/cli/tui-cli.js

@@ -0,0 +1,35 @@
+import { defaultRuntime } from "../runtime.js";
+import { runTui } from "../tui/tui.js";
+export function registerTuiCli(program) {
+    program
+        .command("tui")
+        .description("Open a terminal UI connected to the Gateway")
+        .option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)")
+        .option("--token <token>", "Gateway token (if required)")
+        .option("--password <password>", "Gateway password (if required)")
+        .option("--session <key>", 'Session key (default: "main", or "global" when scope is global)')
+        .option("--deliver", "Deliver assistant replies", false)
+        .option("--thinking <level>", "Thinking level override")
+        .option("--timeout-ms <ms>", "Agent timeout in ms", "30000")
+        .option("--history-limit <n>", "History entries to load", "200")
+        .action(async (opts) => {
+        try {
+            const timeoutMs = Number.parseInt(String(opts.timeoutMs ?? "30000"), 10);
+            const historyLimit = Number.parseInt(String(opts.historyLimit ?? "200"), 10);
+            await runTui({
+                url: opts.url,
+                token: opts.token,
+                password: opts.password,
+                session: opts.session,
+                deliver: Boolean(opts.deliver),
+                thinking: opts.thinking,
+                timeoutMs: Number.isNaN(timeoutMs) ? undefined : timeoutMs,
+                historyLimit: Number.isNaN(historyLimit) ? undefined : historyLimit,
+            });
+        }
+        catch (err) {
+            defaultRuntime.error(String(err));
+            defaultRuntime.exit(1);
+        }
+    });
+}

package/dist/cli/wait.js

@@ -0,0 +1,8 @@
+export function waitForever() {
+    // Keep event loop alive via an unref'ed interval plus a pending promise.
+    const interval = setInterval(() => { }, 1_000_000);
+    interval.unref();
+    return new Promise(() => {
+        /* never resolve */
+    });
+}