jishushell 0.0.1 → 0.4.2

package/dist/control.js

@@ -0,0 +1,1359 @@
+/**
+ * JishuShell process control — start / stop / restart / doctor
+ *
+ * Supports three run modes (detected automatically):
+ *   systemd  — /etc/systemd/system/jishushell.service exists
+ *   launchd  — ~/Library/LaunchAgents/com.jishushell.panel.plist exists (macOS)
+ *   process  — PID file at ~/.jishushell/jishushell.pid (fallback)
+ */
+import { execSync, execFileSync, spawn } from "child_process";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, openSync, closeSync, } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { checkAndReport, checkAndReportHeartbeat } from "./services/telemetry/index.js";
+import { homedir, networkInterfaces } from "os";
+import * as http from "http";
+import * as https from "https";
+import { JISHUSHELL_HOME, getPanelConfig, getNomadToken, getNomadAddr, INSTANCES_DIR } from "./config.js";
+import { isInitialized, initPassword } from "./auth.js";
+import { runDoctorChecks } from "./doctor.js";
+import { loadNomadToken } from "./services/setup-manager.js";
+import { readdirSync, statSync } from "fs";
+// ── Paths ──────────────────────────────────────────────────────────────────
+const PID_FILE = join(JISHUSHELL_HOME, "jishushell.pid");
+const LOG_FILE = join(JISHUSHELL_HOME, "jishushell.log");
+const SYSTEMD_SERVICE = "/etc/systemd/system/jishushell.service";
+const LAUNCHD_PLIST = join(homedir(), "Library/LaunchAgents/com.jishushell.panel.plist");
+// Locate the actual cli.js at runtime — works for both dev and global-install.
+const __filename = fileURLToPath(import.meta.url);
+// In production dist/cli.js; in dev the file is src/control.ts → dist/control.js → ../../dist/cli.js
+const CLI_PATH = join(dirname(__filename), "cli.js");
+// ── ANSI colours (stripped when not a TTY) ─────────────────────────────────
+const isTTY = process.stdout.isTTY ?? false;
+const c = {
+    bold: (s) => isTTY ? `\x1b[1m${s}\x1b[0m` : s,
+    green: (s) => isTTY ? `\x1b[32m${s}\x1b[0m` : s,
+    yellow: (s) => isTTY ? `\x1b[33m${s}\x1b[0m` : s,
+    red: (s) => isTTY ? `\x1b[31m${s}\x1b[0m` : s,
+    cyan: (s) => isTTY ? `\x1b[36m${s}\x1b[0m` : s,
+    dim: (s) => isTTY ? `\x1b[2m${s}\x1b[0m` : s,
+};
+function log(msg) { process.stdout.write(msg + "\n"); }
+export function detectRunMode() {
+    if (process.platform !== "darwin") {
+        // Check systemd availability
+        if (existsSync(SYSTEMD_SERVICE)) {
+            try {
+                execSync("systemctl --version 2>/dev/null", { stdio: "ignore", timeout: 2000 });
+                return "systemd";
+            }
+            catch { }
+        }
+    }
+    else {
+        if (existsSync(LAUNCHD_PLIST))
+            return "launchd";
+    }
+    return "process";
+}
+// ── Panel port resolution ──────────────────────────────────────────────────
+// Reads from panel.json; falls back to the DEFAULT_PORT env var, then 8090.
+function getPanelPort() {
+    try {
+        const cfg = getPanelConfig();
+        const p = parseInt(String(cfg.panel_port ?? ""), 10);
+        if (p > 0 && p < 65536)
+            return p;
+    }
+    catch { }
+    const env = parseInt(process.env.JISHUSHELL_PORT ?? "", 10);
+    if (env > 0 && env < 65536)
+        return env;
+    return 8090;
+}
+// ── Process state helpers ──────────────────────────────────────────────────
+/**
+ * Read PID file and check whether the process is still alive.
+ * Returns the PID if alive, null otherwise (stale file or missing).
+ */
+function readAlivePid() {
+    try {
+        const raw = readFileSync(PID_FILE, "utf-8").trim();
+        const pid = parseInt(raw, 10);
+        if (!Number.isInteger(pid) || pid <= 0)
+            return null;
+        // kill -0 checks existence without actually sending a signal
+        process.kill(pid, 0);
+        // Verify cmdline to avoid signaling a reused PID
+        try {
+            const cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf-8");
+            if (!cmdline.includes("jishushell") && !cmdline.includes("cli.js"))
+                return null;
+        }
+        catch { /* /proc not available (macOS) — skip verification */ }
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+function writePid(pid) {
+    mkdirSync(dirname(PID_FILE), { recursive: true });
+    writeFileSync(PID_FILE, String(pid) + "\n", { mode: 0o600 });
+}
+function removePidFile() {
+    try {
+        unlinkSync(PID_FILE);
+    }
+    catch { }
+}
+// ── Port availability check ────────────────────────────────────────────────
+function isPortListening(port) {
+    try {
+        if (process.platform === "darwin") {
+            const out = execFileSync("lsof", ["-iTCP:" + port, "-sTCP:LISTEN", "-t"], {
+                encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+            });
+            return out.trim().length > 0;
+        }
+        const out = execFileSync("ss", ["-tlnp"], {
+            encoding: "utf-8", timeout: 3000, stdio: ["pipe", "pipe", "pipe"],
+        });
+        return new RegExp(`[:\\s]${port}\\s`).test(out);
+    }
+    catch {
+        return false;
+    }
+}
+/** Poll until port is no longer listening (used after stop). */
+async function waitForPortFree(port, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isPortListening(port))
+            return;
+        await new Promise((r) => setTimeout(r, 300));
+    }
+}
+/** Poll until port is listening (used after start). */
+async function waitForPortOpen(port, timeoutMs = 8000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (isPortListening(port))
+            return true;
+        await new Promise((r) => setTimeout(r, 400));
+    }
+    return false;
+}
+// ── HTTP health probe ──────────────────────────────────────────────────────
+function httpGet(url, timeoutMs = 3000) {
+    return new Promise((resolve, reject) => {
+        const req = http.get(url, { timeout: timeoutMs }, (res) => {
+            let body = "";
+            res.on("data", (d) => { body += d; });
+            res.on("end", () => resolve({ status: res.statusCode ?? 0, body }));
+        });
+        req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+        req.on("error", reject);
+    });
+}
+// ── systemd mode ──────────────────────────────────────────────────────────
+function systemdExec(action) {
+    // Always use sudo for systemd service management to avoid polkit prompts.
+    // Fall back to non-sudo if sudo is not available (e.g. macOS rootless).
+    let useSudo = true;
+    try {
+        execSync("sudo -n true 2>/dev/null", { stdio: "ignore", timeout: 3000 });
+    }
+    catch {
+        useSudo = false;
+    }
+    if (useSudo) {
+        execFileSync("sudo", ["systemctl", action, "jishushell"], { stdio: "inherit", timeout: 15000 });
+    }
+    else {
+        execFileSync("systemctl", [action, "jishushell"], { stdio: "inherit", timeout: 15000 });
+    }
+}
+function systemdStatus() {
+    try {
+        return execSync("systemctl is-active jishushell 2>/dev/null", {
+            encoding: "utf-8", timeout: 3000,
+        }).trim();
+    }
+    catch (e) {
+        // execSync throws when exit code != 0; "inactive" / "failed" / "activating"
+        // all exit non-zero, so read stdout from the error object.
+        if (e?.stdout)
+            return e.stdout.trim();
+        return "unknown";
+    }
+}
+/** Reset a failed unit before starting so `systemctl start` succeeds. */
+function systemdResetFailed() {
+    try {
+        execFileSync("sudo", ["systemctl", "reset-failed", "jishushell"], { stdio: "ignore", timeout: 5000 });
+    }
+    catch {
+        try {
+            execFileSync("systemctl", ["reset-failed", "jishushell"], { stdio: "ignore", timeout: 5000 });
+        }
+        catch { }
+    }
+}
+// ── launchd mode ──────────────────────────────────────────────────────────
+function launchctlExec(action) {
+    const label = "com.jishushell.panel";
+    if (action === "start") {
+        try {
+            execFileSync("launchctl", ["load", "-w", LAUNCHD_PLIST], { stdio: "ignore", timeout: 10000 });
+        }
+        catch { }
+    }
+    execFileSync("launchctl", [action, label], { stdio: "inherit", timeout: 10000 });
+}
+// ── process mode ──────────────────────────────────────────────────────────
+function processStart(port) {
+    mkdirSync(dirname(LOG_FILE), { recursive: true });
+    const logFd = openSync(LOG_FILE, "a");
+    const child = spawn(process.execPath, [CLI_PATH, "--port", String(port)], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: {
+            PATH: process.env.PATH,
+            HOME: process.env.HOME,
+            USER: process.env.USER,
+            LANG: process.env.LANG,
+            NODE_ENV: "production",
+            JISHUSHELL_HOME: process.env.JISHUSHELL_HOME || "",
+            JISHUSHELL_PORT: process.env.JISHUSHELL_PORT || "",
+            JISHUSHELL_JWT_SECRET: process.env.JISHUSHELL_JWT_SECRET || "",
+            JISHUSHELL_AES_KEY: process.env.JISHUSHELL_AES_KEY || "",
+            NOMAD_ADDR: process.env.NOMAD_ADDR || "",
+            NOMAD_TOKEN: process.env.NOMAD_TOKEN || "",
+        },
+    });
+    child.unref();
+    closeSync(logFd);
+    writePid(child.pid);
+}
+async function processStop() {
+    const pid = readAlivePid();
+    if (pid === null) {
+        removePidFile();
+        throw new Error("No running process found (PID file missing or stale).");
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch (e) {
+        if (e.code === "EPERM") {
+            throw new Error(`Permission denied to stop PID ${pid}. Try: sudo jishushell stop`);
+        }
+        removePidFile();
+        throw e;
+    }
+    // Wait for graceful exit (up to 5s), then SIGKILL
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 300));
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            removePidFile();
+            return;
+        } // exited
+    }
+    // Escalate
+    try {
+        process.kill(pid, "SIGKILL");
+    }
+    catch { }
+    removePidFile();
+}
+/** Find and SIGTERM all processes occupying a TCP port. Returns true if any PIDs were found. */
+function killPortProcess(port) {
+    try {
+        let pids = [];
+        if (process.platform === "darwin") {
+            const out = execSync(`lsof -ti:${port} 2>/dev/null`, {
+                encoding: "utf-8", timeout: 3000,
+            });
+            pids = out.trim().split("\n").filter(Boolean).map(Number).filter(n => n > 1);
+        }
+        else {
+            const out = execSync("ss -tlnp 2>/dev/null", { encoding: "utf-8", timeout: 3000 });
+            const lines = out.split("\n").filter(l => l.includes(`:${port} `));
+            for (const line of lines) {
+                for (const m of line.matchAll(/pid=(\d+)/g)) {
+                    const n = parseInt(m[1], 10);
+                    if (n > 1)
+                        pids.push(n);
+                }
+            }
+        }
+        pids = [...new Set(pids)];
+        if (pids.length === 0)
+            return false;
+        for (const pid of pids) {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch { }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Public API ─────────────────────────────────────────────────────────────
+export async function startPanel(port) {
+    const resolvedPort = port ?? getPanelPort();
+    const mode = detectRunMode();
+    // Guard: already running?
+    if (isPortListening(resolvedPort)) {
+        log(c.yellow(`! JishuShell is already running on port ${resolvedPort}`));
+        log(c.dim(`  Run ${c.bold("jishushell stop")} first, or ${c.bold("jishushell restart")}`));
+        return;
+    }
+    log(c.dim(`  run mode: ${mode}  |  port: ${resolvedPort}`));
+    switch (mode) {
+        case "systemd":
+            systemdResetFailed();
+            systemdExec("start");
+            break;
+        case "launchd":
+            launchctlExec("start");
+            break;
+        case "process":
+            if (readAlivePid() !== null) {
+                log(c.yellow("! Process already tracked in PID file but port is not listening."));
+                log(c.dim("  Removing stale PID file and starting fresh…"));
+                removePidFile();
+            }
+            processStart(resolvedPort);
+            break;
+    }
+    log(c.dim("  Waiting for panel to start…"));
+    const ok = await waitForPortOpen(resolvedPort, 10000);
+    if (ok) {
+        log(c.green(`✓ JishuShell started  →  http://localhost:${resolvedPort}`));
+    }
+    else {
+        log(c.yellow(`! Port ${resolvedPort} still not listening after 10s.`));
+        if (mode === "process") {
+            log(c.dim(`  Check logs: ${LOG_FILE}`));
+        }
+        else {
+            log(c.dim(`  Check logs: journalctl -u jishushell -n 50`));
+        }
+    }
+}
+export async function stopPanel() {
+    const port = getPanelPort();
+    const mode = detectRunMode();
+    log(c.dim(`  run mode: ${mode}`));
+    switch (mode) {
+        case "systemd":
+            systemdExec("stop");
+            break;
+        case "launchd":
+            launchctlExec("stop");
+            break;
+        case "process":
+            await processStop();
+            break;
+    }
+    log(c.dim("  Waiting for port to be released…"));
+    await waitForPortFree(port, 5000);
+    log(c.green("✓ JishuShell stopped"));
+}
+export async function restartPanel(port) {
+    const mode = detectRunMode();
+    const resolvedPort = port ?? getPanelPort();
+    log(c.dim(`  run mode: ${mode}  |  port: ${resolvedPort}`));
+    if (mode === "systemd") {
+        // systemd restart handles stop+start atomically
+        systemdResetFailed();
+        systemdExec("restart");
+        log(c.dim("  Waiting for panel to start…"));
+        const ok = await waitForPortOpen(resolvedPort, 10000);
+        if (ok) {
+            log(c.green(`✓ JishuShell restarted  →  http://localhost:${resolvedPort}`));
+        }
+        else {
+            log(c.yellow("! Panel did not come back up within 10s."));
+            log(c.dim("  Check: journalctl -u jishushell -n 50"));
+        }
+        return;
+    }
+    // ── Non-systemd: guarantee a clean stop before starting ──────────────────
+    log(c.dim("  Stopping…"));
+    // Step 1: graceful stop via mode-specific mechanism
+    if (mode === "launchd") {
+        try {
+            launchctlExec("stop");
+        }
+        catch { }
+    }
+    else {
+        // process mode: use PID file when available
+        if (readAlivePid() !== null) {
+            try {
+                await processStop();
+            }
+            catch { /* stale PID or permission — fall through to port kill */ }
+        }
+        else {
+            removePidFile();
+        }
+    }
+    // Step 2: if port is still occupied (orphaned process / slow shutdown), force-kill by port
+    if (isPortListening(resolvedPort)) {
+        log(c.dim(`  Port ${resolvedPort} still occupied — killing remaining process…`));
+        if (killPortProcess(resolvedPort)) {
+            await waitForPortFree(resolvedPort, 5000);
+        }
+    }
+    // Step 3: hard guard — must have a free port before starting
+    if (isPortListening(resolvedPort)) {
+        throw new Error(`Port ${resolvedPort} is still occupied after stop. Try \`jishushell stop\` first.`);
+    }
+    log(c.green("✓ stopped"));
+    log(c.dim("  Starting…"));
+    await startPanel(resolvedPort);
+}
+function row(item) {
+    const icon = item.ok
+        ? c.green("✓")
+        : item.warn
+            ? c.yellow("!")
+            : c.red("✗");
+    const label = item.ok
+        ? c.green(item.label.padEnd(22))
+        : item.warn
+            ? c.yellow(item.label.padEnd(22))
+            : c.red(item.label.padEnd(22));
+    return `  ${icon}  ${label}  ${c.dim(item.detail)}`;
+}
+// ── Password prompt helper (no echo) ─────────────────────────────────────
+function readPassword(prompt) {
+    return new Promise((resolve, reject) => {
+        process.stdout.write(prompt);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            let input = "";
+            const onData = (buf) => {
+                const char = buf.toString("utf-8");
+                if (char === "\r" || char === "\n") {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.stdin.off("data", onData);
+                    process.stdout.write("\n");
+                    resolve(input);
+                }
+                else if (char === "\u0003") { // Ctrl+C
+                    process.stdin.setRawMode(false);
+                    process.stdout.write("\n");
+                    reject(new Error("Interrupted"));
+                }
+                else if (char === "\u007f" || char === "\b") { // Backspace
+                    if (input.length > 0)
+                        input = input.slice(0, -1);
+                }
+                else if (char >= " ") {
+                    input += char;
+                }
+            };
+            process.stdin.on("data", onData);
+        }
+        else {
+            // Non-TTY (piped): read one line without echo concern
+            let input = "";
+            process.stdin.resume();
+            process.stdin.setEncoding("utf-8");
+            const onData = (chunk) => {
+                const nl = chunk.indexOf("\n");
+                if (nl >= 0) {
+                    input += chunk.slice(0, nl);
+                    process.stdin.off("data", onData);
+                    process.stdin.pause();
+                    resolve(input.replace(/\r$/, "").trim());
+                }
+                else {
+                    input += chunk;
+                }
+            };
+            process.stdin.on("data", onData);
+        }
+    });
+}
+// ── Local IP helper ────────────────────────────────────────────────────────
+function getLocalIP() {
+    try {
+        for (const list of Object.values(networkInterfaces())) {
+            for (const iface of list ?? []) {
+                if (!iface.internal && iface.family === "IPv4")
+                    return iface.address;
+            }
+        }
+    }
+    catch { }
+    return "127.0.0.1";
+}
+// ── onboard ────────────────────────────────────────────────────────────────
+export async function runOnboard(opts = {}) {
+    log("");
+    log(c.bold(c.cyan("  JishuShell Onboard")));
+    log(c.dim("  ─────────────────────────────────────────"));
+    log("");
+    // 1. Require install to have been completed
+    const cfg = getPanelConfig();
+    if (!cfg.service_manager) {
+        log(c.red("  ✗  JishuShell is not installed yet."));
+        log(c.dim("  Run ") + c.bold("jishushell install") + c.dim(" first."));
+        log("");
+        process.exit(1);
+    }
+    // 2. Require panel to be running
+    const port = getPanelPort();
+    if (!isPortListening(port)) {
+        log(c.yellow(`  !  Panel is not running on port ${port}.`));
+        log(c.dim("  Start it with: ") + c.bold("jishushell start"));
+        log("");
+        process.exit(1);
+    }
+    // 3. Already initialized?
+    const initialized = isInitialized();
+    if (initialized && !opts.force) {
+        const ip = getLocalIP();
+        log(c.green("  ✓  JishuShell is already onboarded."));
+        log("");
+        log(`  Panel:  ${c.bold(c.cyan(`http://${ip}:${port}`))}`);
+        log(`  Local:  ${c.bold(c.cyan(`http://localhost:${port}`))}`);
+        log("");
+        log(c.dim("  Tip: ") + c.bold("jishushell onboard --force") + c.dim(" resets the admin password."));
+        log("");
+        return;
+    }
+    if (initialized) {
+        log(c.yellow("  !  Resetting admin password (--force)."));
+    }
+    else {
+        log("  " + c.bold("Welcome!") + " Set your admin password to start using JishuShell.");
+    }
+    log("");
+    // 4. Password prompt loop
+    let password = "";
+    for (;;) {
+        try {
+            password = await readPassword("  Password (≥8 chars): ");
+        }
+        catch {
+            log(c.yellow("  Interrupted."));
+            process.exit(1);
+        }
+        if (password.length < 8) {
+            log(c.red("  ✗  Minimum 8 characters. Try again."));
+            continue;
+        }
+        let confirm = "";
+        try {
+            confirm = await readPassword("  Confirm password:    ");
+        }
+        catch {
+            log(c.yellow("  Interrupted."));
+            process.exit(1);
+        }
+        if (password !== confirm) {
+            log(c.red("  ✗  Passwords do not match. Try again."));
+            continue;
+        }
+        break;
+    }
+    // 5. Persist
+    await initPassword(password);
+    // 6. Success
+    const ip = getLocalIP();
+    log("");
+    log(c.bold(c.green("  ✓  Onboarding complete!")));
+    log("");
+    log(`  Open your browser:  ${c.bold(c.cyan(`http://${ip}:${port}`))}`);
+    log(`  Or locally:         ${c.bold(c.cyan(`http://localhost:${port}`))}`);
+    log("");
+    log(c.dim("  Log in with your password, then configure your LLM provider in Settings."));
+    log("");
+}
+// ── doctor（委托 src/doctor.ts）──────────────────────────────────────────────────────────────
+export async function runDoctor(opts = {}) {
+    return runDoctorChecks(opts);
+}
+// ── Nomad API helpers (CLI-side, no server dependency) ─────────────────────
+function nomadHeaders() {
+    const token = getNomadToken();
+    return token ? { "X-Nomad-Token": token } : {};
+}
+async function nomadFetch(path) {
+    const addr = getNomadAddr();
+    try {
+        const res = await fetch(`${addr}${path}`, {
+            headers: nomadHeaders(),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return null;
+        return res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function nomadDelete(path) {
+    const addr = getNomadAddr();
+    try {
+        const res = await fetch(`${addr}${path}`, {
+            method: "DELETE",
+            headers: nomadHeaders(),
+            signal: AbortSignal.timeout(10000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function listInstanceIds() {
+    if (!existsSync(INSTANCES_DIR))
+        return [];
+    try {
+        return readdirSync(INSTANCES_DIR).filter(name => {
+            try {
+                return statSync(join(INSTANCES_DIR, name)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function readInstanceMeta(id) {
+    const metaPath = join(INSTANCES_DIR, id, "instance.json");
+    try {
+        if (existsSync(metaPath))
+            return JSON.parse(readFileSync(metaPath, "utf-8"));
+    }
+    catch { }
+    return null;
+}
+// ── status ─────────────────────────────────────────────────────────────────
+export async function showStatus() {
+    loadNomadToken();
+    const port = getPanelPort();
+    const mode = detectRunMode();
+    const nomadAddr = getNomadAddr();
+    log("");
+    log(c.bold(c.cyan("  JishuShell Status")));
+    log(c.dim("  ─────────────────────────────────────────────────────"));
+    log("");
+    // ── 1. Panel / CLI ──────────────────────────────────────────────────────
+    log(`  ${c.bold("Panel (CLI)")}`);
+    const panelListening = isPortListening(port);
+    const pid = readAlivePid();
+    if (panelListening) {
+        log(`    ${c.green("●")} ${c.green("running")}  →  port :${port}`);
+    }
+    else {
+        log(`    ${c.red("○")} ${c.red("stopped")}`);
+    }
+    log(`    ${c.dim("run mode:")} ${mode}`);
+    if (mode === "systemd") {
+        const svcStatus = systemdStatus();
+        log(`    ${c.dim("systemd:")} ${svcStatus === "active" ? c.green(svcStatus) : c.yellow(svcStatus)}`);
+    }
+    else if (mode === "process" && pid !== null) {
+        log(`    ${c.dim("pid:")} ${pid}`);
+    }
+    log(`    ${c.dim("url:")} http://localhost:${port}`);
+    log("");
+    // ── 2. Docker ──────────────────────────────────────────────────────────
+    log(`  ${c.bold("Docker")}`);
+    let dockerOk = false;
+    let dockerDetail = "daemon unreachable";
+    try {
+        execFileSync("docker", ["info"], { stdio: "ignore", timeout: 5000 });
+        const ver = execSync("docker --version 2>/dev/null", { encoding: "utf-8", timeout: 3000 }).trim();
+        dockerOk = true;
+        dockerDetail = ver.replace("Docker version ", "").split(",")[0];
+    }
+    catch {
+        try {
+            execFileSync("sudo", ["-n", "docker", "info"], { stdio: "ignore", timeout: 5000 });
+            dockerOk = true;
+            dockerDetail = "running (via sudo — re-login to activate docker group)";
+        }
+        catch { }
+    }
+    if (dockerOk) {
+        log(`    ${c.green("●")} ${c.green("running")}  ${c.dim(dockerDetail)}`);
+    }
+    else {
+        log(`    ${c.red("○")} ${c.red("stopped")}  ${c.dim(dockerDetail)}`);
+    }
+    log("");
+    // ── 3. Nomad ───────────────────────────────────────────────────────────
+    log(`  ${c.bold("Nomad")}`);
+    const nomadAgent = await nomadFetch("/v1/agent/self");
+    const nomadRunning = nomadAgent !== null;
+    if (nomadRunning) {
+        const version = nomadAgent?.config?.Version?.Version || nomadAgent?.member?.Tags?.version || "";
+        log(`    ${c.green("●")} ${c.green("running")}  →  ${nomadAddr}${version ? "  " + c.dim("v" + version) : ""}`);
+    }
+    else {
+        log(`    ${c.red("○")} ${c.red("stopped")}  ${c.dim("(" + nomadAddr + " unreachable)")}`);
+    }
+    log("");
+    // ── 4. Nomad Jobs (instances) ───────────────────────────────────────────
+    const instanceIds = listInstanceIds();
+    log(`  ${c.bold("Nomad Jobs")}  ${c.dim("(" + instanceIds.length + " instance" + (instanceIds.length !== 1 ? "s" : "") + ")")}`);
+    if (instanceIds.length === 0) {
+        log(`    ${c.dim("(no instances created)")}`);
+    }
+    else if (!nomadRunning) {
+        log(`    ${c.dim("(Nomad not reachable — cannot query job status)")}`);
+        for (const id of instanceIds) {
+            const meta = readInstanceMeta(id);
+            log(`    ${c.dim("??")}  ${(meta?.name || id).padEnd(20)}  ${c.dim(id)}`);
+        }
+    }
+    else {
+        for (const id of instanceIds) {
+            const meta = readInstanceMeta(id);
+            const jobId = `jishushell-${id}`;
+            const jobData = await nomadFetch(`/v1/job/${jobId}`);
+            const allocsData = await nomadFetch(`/v1/job/${jobId}/allocations`);
+            let statusStr = "unknown";
+            let statusColor = c.dim;
+            if (!jobData) {
+                statusStr = "not submitted";
+                statusColor = c.dim;
+            }
+            else {
+                const jobStatus = jobData.Status || "";
+                const clientStatus = allocsData
+                    ?.slice()
+                    .sort((a, b) => b.CreateTime - a.CreateTime)[0]
+                    ?.ClientStatus ?? "";
+                if (clientStatus === "running") {
+                    statusStr = "running";
+                    statusColor = c.green;
+                }
+                else if (clientStatus === "pending") {
+                    statusStr = "pending";
+                    statusColor = c.yellow;
+                }
+                else if (clientStatus === "failed") {
+                    statusStr = "failed";
+                    statusColor = c.red;
+                }
+                else if (clientStatus === "complete") {
+                    statusStr = "complete";
+                    statusColor = c.dim;
+                }
+                else if (jobStatus === "dead") {
+                    statusStr = "stopped";
+                    statusColor = c.dim;
+                }
+                else if (jobStatus === "running") {
+                    statusStr = "pending alloc";
+                    statusColor = c.yellow;
+                }
+                else {
+                    statusStr = jobStatus || "unknown";
+                }
+            }
+            // Gateway port
+            let portInfo = "";
+            const runtime = meta?.runtime;
+            if (runtime) {
+                const envPort = runtime.env?.OPENCLAW_GATEWAY_PORT;
+                const argsPort = (() => {
+                    const args = runtime.args || [];
+                    for (let i = 0; i < args.length - 1; i++) {
+                        if (args[i] === "--port")
+                            return args[i + 1];
+                    }
+                    return null;
+                })();
+                const gp = envPort || argsPort;
+                if (gp)
+                    portInfo = c.dim(`  gateway :${gp}`);
+            }
+            const dot = statusStr === "running" ? c.green("●")
+                : statusStr === "pending" || statusStr === "pending alloc" ? c.yellow("●")
+                    : statusStr === "failed" ? c.red("●")
+                        : c.dim("○");
+            const nameField = (meta?.name || id).padEnd(20);
+            const statusField = statusColor(statusStr.padEnd(14));
+            log(`    ${dot}  ${nameField}  ${statusField}${portInfo}`);
+        }
+    }
+    log("");
+}
+// ── stopWithJobs ────────────────────────────────────────────────────────────
+// Stop all Nomad jobs (instances) then stop the panel.
+// Does NOT stop the Docker daemon or Nomad itself.
+export async function stopWithJobs() {
+    loadNomadToken();
+    const instanceIds = listInstanceIds();
+    if (instanceIds.length > 0) {
+        log(c.dim(`  Stopping ${instanceIds.length} Nomad job(s)…`));
+        const nomadAddr = getNomadAddr();
+        const nomadRunning = (await nomadFetch("/v1/agent/self")) !== null;
+        if (!nomadRunning) {
+            log(c.yellow("  ! Nomad is not reachable — skipping job cleanup"));
+        }
+        else {
+            const results = await Promise.allSettled(instanceIds.map(async (id) => {
+                const jobId = `jishushell-${id}`;
+                const meta = readInstanceMeta(id);
+                const name = meta?.name || id;
+                const ok = await nomadDelete(`/v1/job/${jobId}?purge=false`);
+                if (ok) {
+                    log(`    ${c.green("✓")} stopped job: ${name}`);
+                }
+                else {
+                    log(`    ${c.dim("–")} job not found or already stopped: ${name}`);
+                }
+            }));
+            void results; // errors already logged per-job
+        }
+        log("");
+    }
+    log(c.dim("  Stopping JishuShell panel…"));
+    await stopPanel();
+}
+// ── reset ───────────────────────────────────────────────────────────────────
+// Purge all Nomad jobs and reset JishuShell to a clean configuration state.
+export async function resetAll(opts = {}) {
+    loadNomadToken();
+    log("");
+    log(c.bold(c.yellow("  ⚠  JishuShell Reset")));
+    log(c.dim("  ─────────────────────────────────────────────────────"));
+    log("");
+    log("  This will:");
+    log(`    ${c.dim("•")} Purge all Nomad jobs (stop & remove all instances from Nomad scheduler)`);
+    log(`    ${c.dim("•")} Stop the JishuShell panel`);
+    log(`    ${c.dim("•")} Delete panel configuration (panel.json)`);
+    log(`    ${c.dim("•")} Delete auth credentials`);
+    log("");
+    log(`  ${c.bold(c.yellow("Instance data directories are kept — this is not a data wipe."))}`);
+    log(`  ${c.dim("Re-run")} ${c.bold("jishushell install")} ${c.dim("then")} ${c.bold("jishushell onboard")} ${c.dim("to restore the panel.")}`);
+    log("");
+    if (!opts.yes) {
+        if (!process.stdin.isTTY) {
+            log(c.red("  ✗  Reset requires interactive confirmation. Pass --yes to skip."));
+            log("");
+            process.exit(1);
+        }
+        const answer = await new Promise((resolve) => {
+            process.stdout.write(`  Type ${c.bold("RESET")} to continue, or press Enter to cancel: `);
+            let buf = "";
+            const onData = (chunk) => {
+                const str = chunk.toString("utf-8");
+                const nl = str.indexOf("\n");
+                if (nl >= 0) {
+                    buf += str.slice(0, nl);
+                    process.stdin.off("data", onData);
+                    process.stdin.pause();
+                    process.stdout.write("\n");
+                    resolve(buf.trim());
+                }
+                else {
+                    buf += str;
+                }
+            };
+            process.stdin.resume();
+            process.stdin.on("data", onData);
+        });
+        if (answer !== "RESET") {
+            log(c.dim("  Cancelled."));
+            log("");
+            return;
+        }
+    }
+    log("");
+    // 1. Purge all Nomad jobs
+    const instanceIds = listInstanceIds();
+    if (instanceIds.length > 0) {
+        log(c.dim(`  Purging ${instanceIds.length} Nomad job(s)…`));
+        const nomadRunning = (await nomadFetch("/v1/agent/self")) !== null;
+        if (!nomadRunning) {
+            log(c.yellow("  ! Nomad unreachable — skipping job purge"));
+        }
+        else {
+            for (const id of instanceIds) {
+                const jobId = `jishushell-${id}`;
+                const meta = readInstanceMeta(id);
+                const name = meta?.name || id;
+                const ok = await nomadDelete(`/v1/job/${jobId}?purge=true`);
+                if (ok) {
+                    log(`    ${c.green("✓")} purged: ${name}`);
+                }
+                else {
+                    log(`    ${c.dim("–")} not found (already gone): ${name}`);
+                }
+            }
+        }
+    }
+    // 2. Stop the panel
+    const port = getPanelPort();
+    if (isPortListening(port)) {
+        log(c.dim("  Stopping panel…"));
+        try {
+            await stopPanel();
+        }
+        catch {
+            // best-effort
+        }
+    }
+    // 3. Remove panel config and auth
+    const PANEL_CONFIG = join(JISHUSHELL_HOME, "panel.json");
+    const AUTH_FILE = join(JISHUSHELL_HOME, "auth.json");
+    const JWT_FILE = join(JISHUSHELL_HOME, "jwt-secret");
+    for (const f of [PANEL_CONFIG, AUTH_FILE, JWT_FILE]) {
+        try {
+            if (existsSync(f)) {
+                unlinkSync(f);
+                log(`    ${c.green("✓")} removed: ${f}`);
+            }
+        }
+        catch (e) {
+            log(`    ${c.yellow("!")} could not remove ${f}: ${e.message}`);
+        }
+    }
+    log("");
+    log(c.bold(c.green("  ✓  Reset complete.")));
+    log("");
+    log(`  To reinstall:  ${c.bold("jishushell install")}`);
+    log(`  To onboard:    ${c.bold("jishushell onboard")}  ${c.dim("(after starting the panel)")}`);
+    log("");
+}
+async function _legacyDoctorBody() {
+    const items = [];
+    // ── 1. Node.js version ────────────────────────────────────────
+    const nodeMajor = parseInt(process.version.replace("v", "").split(".")[0], 10);
+    items.push({
+        label: "Node.js",
+        ok: nodeMajor >= 22,
+        warn: nodeMajor >= 18 && nodeMajor < 22,
+        detail: nodeMajor >= 22
+            ? process.version
+            : `${process.version} — requires >=22 (run: nvm install 22)`,
+    });
+    // ── 2. Docker daemon ──────────────────────────────────────────
+    let dockerOk = false;
+    let dockerDetail = "not found";
+    try {
+        execFileSync("docker", ["info"], { stdio: "ignore", timeout: 6000 });
+        const ver = execSync("docker --version 2>/dev/null", { encoding: "utf-8", timeout: 3000 }).trim();
+        dockerOk = true;
+        dockerDetail = ver.replace("Docker version ", "").split(",")[0];
+    }
+    catch {
+        // docker group not active — try sudo
+        try {
+            execFileSync("sudo", ["-n", "docker", "info"], { stdio: "ignore", timeout: 6000 });
+            dockerOk = true;
+            dockerDetail = "running (accessible via sudo — re-login to activate docker group)";
+        }
+        catch {
+            dockerDetail = "daemon not reachable — run: sudo systemctl start docker";
+        }
+    }
+    items.push({ label: "Docker", ok: dockerOk, detail: dockerDetail });
+    // ── 3. Nomad ──────────────────────────────────────────────────
+    let nomadRunning = false;
+    let nomadDetail = "port 4646 not listening";
+    try {
+        const listening = execSync("ss -tlnp 2>/dev/null | grep ':4646 '", {
+            encoding: "utf-8", timeout: 3000,
+        }).trim().length > 0;
+        if (listening) {
+            nomadRunning = true;
+            // Quickly check token validity
+            const nomadAddr = process.env.NOMAD_ADDR || "http://127.0.0.1:4646";
+            const token = getNomadToken();
+            try {
+                const result = await httpGet(`${nomadAddr}/v1/agent/self`, 3000);
+                if (result.status === 200) {
+                    nomadDetail = "running, ACL token valid";
+                }
+                else if (result.status === 403) {
+                    nomadDetail = "running, but ACL token invalid/expired";
+                    nomadRunning = false;
+                }
+                else {
+                    nomadDetail = `running (HTTP ${result.status})`;
+                }
+                void token; // suppress unused warning
+            }
+            catch {
+                nomadDetail = "running (could not verify ACL token)";
+            }
+        }
+    }
+    catch {
+        // ss failed, fall back
+        try {
+            const out = execSync(`netstat -tlnp 2>/dev/null | grep ':4646 '`, {
+                encoding: "utf-8", timeout: 3000,
+            });
+            nomadRunning = out.trim().length > 0;
+            if (nomadRunning)
+                nomadDetail = "running";
+        }
+        catch { }
+    }
+    items.push({ label: "Nomad", ok: nomadRunning, detail: nomadDetail });
+    // ── 4. OpenClaw npm package ───────────────────────────────────
+    const oclawBin = join(JISHUSHELL_HOME, "packages/openclaw/bin/openclaw");
+    const oclawPkg = join(JISHUSHELL_HOME, "packages/openclaw/lib/node_modules/openclaw/package.json");
+    let oclawOk = false;
+    let oclawDetail = `not found at ${oclawBin}`;
+    if (existsSync(oclawBin)) {
+        try {
+            const pkg = JSON.parse(readFileSync(oclawPkg, "utf-8"));
+            oclawOk = true;
+            oclawDetail = `v${pkg.version}`;
+        }
+        catch {
+            oclawOk = true;
+            oclawDetail = "installed (version unknown)";
+        }
+    }
+    items.push({ label: "OpenClaw pkg", ok: oclawOk, warn: true, detail: oclawDetail });
+    // ── 5. OpenClaw Docker image ──────────────────────────────────
+    const imageTag = getPanelConfig().openclaw_image || "openclaw";
+    let imageOk = false;
+    let imageDetail = `${imageTag} not found locally`;
+    if (dockerOk) {
+        try {
+            execFileSync("docker", ["image", "inspect", imageTag], { stdio: "ignore", timeout: 5000 });
+            imageOk = true;
+            imageDetail = imageTag;
+        }
+        catch {
+            try {
+                // maybe using sudo docker
+                execFileSync("sudo", ["-n", "docker", "image", "inspect", imageTag], { stdio: "ignore", timeout: 5000 });
+                imageOk = true;
+                imageDetail = imageTag;
+            }
+            catch { }
+        }
+    }
+    else {
+        imageDetail = "Docker not accessible — cannot check";
+        imageOk = false;
+    }
+    items.push({ label: "OpenClaw image", ok: imageOk, warn: true, detail: imageDetail });
+    // ── 6. JishuShell panel ───────────────────────────────────────
+    const port = getPanelPort();
+    let panelRunning = false;
+    let panelDetail = `not reachable on port ${port}`;
+    try {
+        const res = await httpGet(`http://localhost:${port}/api/auth/status`, 3000);
+        panelRunning = res.status > 0;
+        try {
+            const body = JSON.parse(res.body);
+            const initialized = body.initialized ?? false;
+            panelDetail = initialized
+                ? `running on :${port} (configured)`
+                : `running on :${port} — ${c.yellow("visit http://localhost:" + port + " to set up password")}`;
+        }
+        catch {
+            panelDetail = `running on :${port} (HTTP ${res.status})`;
+        }
+    }
+    catch {
+        panelDetail = `not reachable on :${port}`;
+    }
+    items.push({ label: "Panel", ok: panelRunning, warn: true, detail: panelDetail });
+    // ── 7. Run mode ───────────────────────────────────────────────
+    const mode = detectRunMode();
+    const modeDetails = {
+        systemd: `systemd (${SYSTEMD_SERVICE})`,
+        launchd: `launchd (${LAUNCHD_PLIST})`,
+        process: `process mode (PID file: ${PID_FILE})`,
+    };
+    const pidAlive = readAlivePid();
+    const modeDetail = mode === "process"
+        ? pidAlive ? `${modeDetails.process} — PID ${pidAlive}` : `${modeDetails.process} — no PID`
+        : modeDetails[mode];
+    items.push({ label: "Run mode", ok: true, warn: false, detail: modeDetail });
+    // ── 8. panel.json config ──────────────────────────────────────
+    let cfgOk = false;
+    let cfgDetail = "~/.jishushell/panel.json not found";
+    try {
+        const cfg = getPanelConfig();
+        cfgOk = Object.keys(cfg).length > 0;
+        cfgDetail = cfgOk
+            ? `service_manager=${cfg.service_manager ?? "process"}, port=${cfg.panel_port ?? 8090}`
+            : "empty or corrupted";
+    }
+    catch {
+        cfgDetail = "corrupted — run: jishushell install --force";
+    }
+    items.push({ label: "Config", ok: cfgOk, warn: !cfgOk, detail: cfgDetail });
+    // ── Print results ─────────────────────────────────────────────
+    log("");
+    for (const item of items)
+        log(row(item));
+    log("");
+    const failures = items.filter((i) => !i.ok && !i.warn);
+    const warns = items.filter((i) => !i.ok && i.warn);
+    if (failures.length === 0 && warns.length === 0) {
+        log(c.bold(c.green("  ✓  All checks passed!")));
+    }
+    else {
+        if (failures.length > 0) {
+            log(c.bold(c.red(`  ✗  ${failures.length} critical issue(s) detected`)));
+        }
+        if (warns.length > 0) {
+            log(c.bold(c.yellow(`  !  ${warns.length} warning(s)`)));
+        }
+        log("");
+        log(c.dim("  Tip: run ") + c.bold("jishushell install") + c.dim(" to fix missing components"));
+    }
+    log("");
+    return failures.length === 0;
+}
+/**
+ * Fetch the latest published version of jishushell from the npm registry and
+ * compare it with the current package version.
+ * Uses a 30-second TTL cache so repeated API calls in the same process are cheap.
+ */
+let _updateCache = null;
+const UPDATE_CACHE_TTL = 30_000;
+/** Resolve the npm registry URL from panel.json, npm config, or the default. */
+function getNpmRegistryUrl() {
+    // 1. panel.json override
+    const panelReg = getPanelConfig().npm_registry;
+    if (typeof panelReg === "string" && panelReg.trim())
+        return panelReg.trim().replace(/\/+$/, "");
+    // 2. npm config (respects .npmrc)
+    try {
+        const nodeBinDir = dirname(process.execPath);
+        const npmBin = join(nodeBinDir, "npm");
+        const reg = execFileSync(npmBin, ["config", "get", "registry"], { encoding: "utf-8", timeout: 5000 }).trim();
+        if (reg && reg !== "undefined")
+            return reg.replace(/\/+$/, "");
+    }
+    catch { /* fall through */ }
+    // 3. default
+    return "https://registry.npmjs.org";
+}
+export async function checkUpdate() {
+    if (_updateCache && Date.now() - _updateCache.ts < UPDATE_CACHE_TTL) {
+        return _updateCache.info;
+    }
+    // Read current version from package.json next to this file
+    let currentVersion = "0.0.0";
+    try {
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "../package.json");
+        const raw = readFileSync(pkgPath, "utf-8");
+        currentVersion = JSON.parse(raw).version ?? "0.0.0";
+    }
+    catch { /* keep default */ }
+    let latestVersion = currentVersion;
+    let hasUpdate = false;
+    try {
+        const registryUrl = getNpmRegistryUrl();
+        const metaUrl = new URL(`/jishushell/latest`, registryUrl);
+        const transport = metaUrl.protocol === "https:" ? https : http;
+        latestVersion = await new Promise((resolve, reject) => {
+            const req = transport.get(metaUrl, { headers: { accept: "application/json" }, timeout: 8000 }, (res) => {
+                let body = "";
+                res.on("data", (d) => (body += d));
+                res.on("end", () => {
+                    try {
+                        resolve(JSON.parse(body).version ?? currentVersion);
+                    }
+                    catch {
+                        reject(new Error("parse error"));
+                    }
+                });
+            });
+            req.on("error", reject);
+            req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+        });
+        // Simple semver compare: split on "." and compare each part numerically
+        const parse = (v) => v.replace(/^v/, "").split(".").map(Number);
+        const [cMaj, cMin, cPat] = parse(currentVersion);
+        const [lMaj, lMin, lPat] = parse(latestVersion);
+        hasUpdate =
+            lMaj > cMaj ||
+                (lMaj === cMaj && lMin > cMin) ||
+                (lMaj === cMaj && lMin === cMin && lPat > cPat);
+    }
+    catch { /* network unavailable — return no-update */ }
+    const info = { hasUpdate, currentVersion, latestVersion };
+    _updateCache = { ts: Date.now(), info };
+    // Piggyback telemetry on update checks (fire-and-forget, deduplicated internally)
+    checkAndReport();
+    checkAndReportHeartbeat();
+    return info;
+}
+/**
+ * Install the latest version of jishushell via npm then restart the panel.
+ * Resolves npm from the same bin directory as the running Node.js executable
+ * so it works even when PATH does not include nvm's bin dir (e.g. systemd).
+ */
+export async function runUpdate() {
+    log("");
+    log(c.bold("  Updating JishuShell…"));
+    const { currentVersion, latestVersion } = await checkUpdate();
+    log(c.dim(`  current: ${currentVersion}  →  latest: ${latestVersion}`));
+    // Build childEnv FIRST — both npm and the restart command need node in PATH.
+    // nvm-managed node lives in a user-specific bin dir that systemd strips from PATH.
+    const nodeBinDir = dirname(process.execPath);
+    const childEnv = {
+        ...process.env,
+        PATH: `${nodeBinDir}${process.env.PATH ? `:${process.env.PATH}` : ""}`,
+    };
+    const npmBin = join(nodeBinDir, "npm");
+    log(c.dim(`  Running: ${npmBin} install -g jishushell …`));
+    try {
+        const out = execFileSync(npmBin, ["install", "-g", "jishushell", "--registry", getNpmRegistryUrl() + "/"], { encoding: "utf-8", timeout: 120_000, stdio: ["ignore", "pipe", "pipe"], env: childEnv });
+        if (out)
+            log(c.dim(out.trim()));
+    }
+    catch (err) {
+        const detail = err.stderr ? err.stderr.trim() : err.message;
+        log(c.red(`  ✗  npm install failed: ${detail}`));
+        throw new Error(detail || err.message);
+    }
+    log(c.green("  ✓  Package updated."));
+    // Invalidate version cache
+    _updateCache = null;
+    // kills this process.  Using `sleep 2` gives ~2 s for the reply to flush.
+    // We invoke node directly (not jishushell shebang script) to avoid PATH issues.
+    log(c.dim("  Scheduling panel restart in 2 s…"));
+    const restartChild = spawn("sh", ["-c", `sleep 2 && exec ${JSON.stringify(process.execPath)} ${JSON.stringify(CLI_PATH)} restart`], { detached: true, stdio: "ignore", env: childEnv });
+    restartChild.unref();
+    log(c.green("  ✓  Restart scheduled — panel will reconnect shortly."));
+}
+// ── pairing helpers ─────────────────────────────────────────────────────────
+// These functions run `openclaw pairing` commands inside the instance container
+// via `docker exec`, so users don't need to do `docker exec` manually.
+async function resolvePairingInstance(instanceId) {
+    loadNomadToken();
+    const ids = listInstanceIds();
+    if (ids.length === 0) {
+        log(c.red("  ✗  No instances found."));
+        return null;
+    }
+    // If --instance was given, validate it; otherwise auto-detect when exactly one instance is running.
+    let targetId = instanceId ?? null;
+    if (!targetId) {
+        if (ids.length === 1) {
+            targetId = ids[0];
+        }
+        else {
+            // Find currently running instances via Nomad
+            const runningIds = [];
+            for (const id of ids) {
+                try {
+                    const allocsData = await nomadFetch(`/v1/job/openclaw-${id}/allocations`);
+                    const running = allocsData?.some((a) => a.ClientStatus === "running");
+                    if (running)
+                        runningIds.push(id);
+                }
+                catch { /* skip */ }
+            }
+            if (runningIds.length === 1) {
+                targetId = runningIds[0];
+            }
+            else if (runningIds.length === 0) {
+                log(c.red("  ✗  No running instances found. Start an instance first."));
+                return null;
+            }
+            else {
+                log(c.red(`  ✗  Multiple running instances: ${runningIds.join(", ")}`));
+                log(c.dim("     Use --instance <id> to specify one."));
+                return null;
+            }
+        }
+    }
+    else if (!ids.includes(targetId)) {
+        log(c.red(`  ✗  Instance "${targetId}" not found.`));
+        return null;
+    }
+    // Get alloc ID from Nomad to build container name
+    let containerName = null;
+    try {
+        const allocsData = await nomadFetch(`/v1/job/openclaw-${targetId}/allocations`);
+        const runningAlloc = allocsData
+            ?.filter((a) => a.ClientStatus === "running")
+            .sort((a, b) => b.CreateTime - a.CreateTime)[0];
+        if (runningAlloc?.ID) {
+            containerName = `gateway-${runningAlloc.ID}`;
+        }
+    }
+    catch { /* fall through */ }
+    if (!containerName) {
+        log(c.red(`  ✗  Instance "${targetId}" is not running.`));
+        return null;
+    }
+    return { id: targetId, containerName };
+}
+export async function runPairingList(opts = {}) {
+    const target = await resolvePairingInstance(opts.instanceId);
+    if (!target)
+        return false;
+    log("");
+    log(c.bold(c.cyan(`  Pairing requests for instance: ${target.id}`)));
+    log(c.dim("  ─────────────────────────────────────────────────────"));
+    const { execFileSync: efs } = await import("child_process");
+    try {
+        const out = efs("docker", ["exec", target.containerName, "openclaw", "pairing", "list"], {
+            encoding: "utf-8", timeout: 15_000,
+        });
+        log(out.trim() ? out.trim() : "  (no pending requests)");
+    }
+    catch (e) {
+        const msg = (e.stdout || "") + (e.stderr || e.message || "");
+        log(msg.trim() || c.red("  ✗  Failed to list pairing requests."));
+        return false;
+    }
+    log("");
+    return true;
+}
+export async function runPairingApprove(opts) {
+    const target = await resolvePairingInstance(opts.instanceId);
+    if (!target)
+        return false;
+    const cmd = ["exec", target.containerName, "openclaw", "pairing", "approve", opts.channel, opts.code];
+    if (opts.notify)
+        cmd.push("--notify");
+    log("");
+    log(c.bold(`  Approving pairing code ${c.cyan(opts.code)} on channel ${c.cyan(opts.channel)}…`));
+    const { execFileSync: efs } = await import("child_process");
+    try {
+        const out = efs("docker", cmd, { encoding: "utf-8", timeout: 15_000 });
+        log(c.green(`  ✓  ${out.trim()}`));
+    }
+    catch (e) {
+        const msg = ((e.stdout || "") + (e.stderr || e.message || "")).trim();
+        log(c.red(`  ✗  ${msg || "Approval failed"}`));
+        return false;
+    }
+    log("");
+    return true;
+}
+//# sourceMappingURL=control.js.map