nexting-cc-bridge 0.8.3

package/dist/cli.js

@@ -0,0 +1,742 @@
+#!/usr/bin/env node
+// nexting-cc-bridge — entry point.
+//   nexting-cc-bridge start      run the bridge (reads config from ~/.nexting/cc-bridge.json or env)
+//   nexting-cc-bridge once       print one discovery snapshot as JSON and exit (debug)
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import net from "node:net";
+import { fileURLToPath } from "node:url";
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID, randomBytes } from "node:crypto";
+import http from "node:http";
+import https from "node:https";
+import { startBridge, VERSION } from "./bridge.js";
+import { startSelfUpdate, maybeSelfUpdate } from "./self-update.js";
+import { discoverSessions } from "./scanner.js";
+import { addPinclawPathBlock, stripPinclawBlock } from "./install-util.js";
+import { sessionIdFromArgs } from "./cli-args.js";
+const CONFIG = path.join(os.homedir(), ".nexting", "cc-bridge.json");
+// §2.6 bridge-token-authed logout endpoints (revoke server-side on terminal teardown).
+const CC_LOGOUT_URL = "https://api.nexting.ai/api/v1/cc-bridge/logout";
+const CODEX_LOGOUT_URL = "https://api.nexting.ai/api/v1/codex-bridge/logout";
+const HUB_SOCK = path.join(os.homedir(), ".nexting", "cc-hub.sock");
+const SHIM_DIR = path.join(os.homedir(), ".nexting", "bin");
+const SHIM = path.join(SHIM_DIR, "claude");
+const PLIST = path.join(os.homedir(), "Library", "LaunchAgents", "ai.nexting.cc-bridge.plist");
+const RC_FILES = [".zshrc", ".bashrc", ".bash_profile"];
+/** Write the launchd plist that keeps the hub daemon running, and (re)load it. */
+function setupLaunchdHub() {
+    const node = process.execPath;
+    const cli = fileURLToPath(import.meta.url);
+    const nodeDir = path.dirname(node);
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>ai.nexting.cc-bridge</string>
+  <key>ProgramArguments</key><array><string>${node}</string><string>${cli}</string><string>hub</string></array>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${nodeDir}:/usr/bin:/bin:/usr/sbin:/sbin</string></dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${path.join(os.homedir(), ".nexting", "cc-bridge.log")}</string>
+  <key>StandardErrorPath</key><string>${path.join(os.homedir(), ".nexting", "cc-bridge.err.log")}</string>
+</dict>
+</plist>
+`;
+    fs.mkdirSync(path.dirname(PLIST), { recursive: true });
+    fs.writeFileSync(PLIST, plist);
+    spawnSync("launchctl", ["unload", PLIST], { stdio: "ignore" });
+    spawnSync("launchctl", ["load", PLIST], { stdio: "ignore" });
+}
+/** Connect to the hub socket; if no hub is running, spawn one (detached) and wait
+ * for it to come up. Returns when the socket is connectable. */
+async function ensureHubRunning() {
+    const tryConnect = () => new Promise((resolve) => {
+        const s = net.connect(HUB_SOCK);
+        s.on("connect", () => {
+            s.end();
+            resolve(true);
+        });
+        s.on("error", () => resolve(false));
+    });
+    if (await tryConnect())
+        return;
+    // Spawn the hub daemon detached so it outlives this shell.
+    const self = fileURLToPath(import.meta.url);
+    const child = spawn(process.execPath, [self, "hub"], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    for (let i = 0; i < 50; i++) {
+        await new Promise((r) => setTimeout(r, 200));
+        if (await tryConnect())
+            return;
+    }
+    throw new Error("hub did not start in time");
+}
+/** Lazily generate a stable 32-hex bridgeId in `cfg` (mutated in place) and
+ * persist it back to `file` if it was absent. The bridgeId is always file-backed
+ * (env-var token overrides do not affect it). Returns the resolved bridgeId. */
+function ensureBridgeId(cfg, file) {
+    if (typeof cfg.bridgeId === "string" && cfg.bridgeId)
+        return cfg.bridgeId;
+    const bridgeId = randomBytes(16).toString("hex");
+    cfg.bridgeId = bridgeId;
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify(cfg, null, 2));
+    }
+    catch {
+        /* best-effort persist; the id is still returned for this run */
+    }
+    return bridgeId;
+}
+// Last-resort pinned IPs for the primary control-plane host, dialed with SNI+Host
+// when DNS fails (the dominant China outage: flaky residential `getaddrinfo
+// ENOTFOUND`). The bridge prefers the live cached IP first, then these.
+const PINNED_IPS = ["157.230.249.229"]; // api.nexting.ai → DigitalOcean
+/** Build the China-resilience knobs for `startBridge` from a config file:
+ * an optional preferred-endpoint list (e.g. a Cloudflare-proxied
+ * `bridge.nexting.ai`), raw-IP fallbacks (cached-good first, then pinned), and a
+ * persist-on-connect callback that caches the last-known-good peer IP so the
+ * next cold start survives a DNS outage. */
+function buildNet(file, cfg, url) {
+    // Explicit config wins. Otherwise, for the default `api.nexting.ai` ingress,
+    // PREFER the Cloudflare-proxied `bridge.nexting.ai` (China→CF-edge→origin is
+    // far more stable than China→US-direct) and fall back to the direct host. CF
+    // is strictly additive here: if it ever fails, the dial escalates to the
+    // direct endpoint, then the raw-IP fallbacks. Ships to every user via
+    // self-update; non-default custom URLs are left untouched.
+    let endpoints = Array.isArray(cfg.endpoints)
+        ? cfg.endpoints.filter((e) => typeof e === "string" && e)
+        : undefined;
+    if ((!endpoints || !endpoints.length) && url.includes("api.nexting.ai")) {
+        endpoints = [url.replace("api.nexting.ai", "bridge.nexting.ai"), url];
+    }
+    const fallbackIps = Array.from(new Set([
+        typeof cfg.cachedIp === "string" ? cfg.cachedIp : "",
+        ...PINNED_IPS,
+    ].filter(Boolean)));
+    let lastPersisted = typeof cfg.cachedIp === "string" ? cfg.cachedIp : "";
+    const engineEnv = cfg.engineEnv && typeof cfg.engineEnv === "object"
+        ? Object.fromEntries(Object.entries(cfg.engineEnv).filter(([, v]) => typeof v === "string"))
+        : undefined;
+    return {
+        endpoints: endpoints && endpoints.length ? endpoints : undefined,
+        fallbackIps,
+        engineEnv: engineEnv && Object.keys(engineEnv).length ? engineEnv : undefined,
+        onConnectedIp: (ip) => {
+            if (!ip || ip === lastPersisted)
+                return;
+            lastPersisted = ip;
+            try {
+                let j = {};
+                try {
+                    j = JSON.parse(fs.readFileSync(file, "utf8"));
+                }
+                catch {
+                    /* new/absent config */
+                }
+                j.cachedIp = ip;
+                fs.mkdirSync(path.dirname(file), { recursive: true });
+                fs.writeFileSync(file, JSON.stringify(j, null, 2));
+            }
+            catch {
+                /* best-effort cache */
+            }
+        },
+    };
+}
+function loadConfig() {
+    let cfg = {};
+    try {
+        cfg = JSON.parse(fs.readFileSync(CONFIG, "utf8"));
+    }
+    catch {
+        /* fall back to env */
+    }
+    const url = process.env.NEXTING_CC_URL ??
+        cfg.url ??
+        "wss://api.nexting.ai/cc-bridge/connect";
+    const token = process.env.NEXTING_CC_TOKEN ?? cfg.token ?? "";
+    const bridgeId = ensureBridgeId(cfg, CONFIG);
+    return {
+        url,
+        token,
+        bridgeId,
+        net: buildNet(CONFIG, cfg, url),
+        e2eEnabled: cfg.e2eEnabled === true,
+    };
+}
+const CODEX_CONFIG = path.join(os.homedir(), ".nexting", "codex-bridge.json");
+const CODEX_PLIST = path.join(os.homedir(), "Library", "LaunchAgents", "ai.nexting.codex-bridge.plist");
+/** Write the launchd plist that keeps the codex-bridge daemon running, and (re)load it. */
+function setupLaunchdCodex() {
+    const node = process.execPath;
+    const cli = fileURLToPath(import.meta.url);
+    const nodeDir = path.dirname(node);
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>ai.nexting.codex-bridge</string>
+  <key>ProgramArguments</key><array><string>${node}</string><string>${cli}</string><string>codex-start</string></array>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${nodeDir}:/usr/bin:/bin:/usr/sbin:/sbin</string></dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${path.join(os.homedir(), ".nexting", "codex-bridge.log")}</string>
+  <key>StandardErrorPath</key><string>${path.join(os.homedir(), ".nexting", "codex-bridge.err.log")}</string>
+</dict>
+</plist>
+`;
+    fs.mkdirSync(path.dirname(CODEX_PLIST), { recursive: true });
+    fs.writeFileSync(CODEX_PLIST, plist);
+    spawnSync("launchctl", ["unload", CODEX_PLIST], { stdio: "ignore" });
+    spawnSync("launchctl", ["load", CODEX_PLIST], { stdio: "ignore" });
+}
+function loadCodexConfig() {
+    let cfg = {};
+    try {
+        cfg = JSON.parse(fs.readFileSync(CODEX_CONFIG, "utf8"));
+    }
+    catch {
+        /* env fallback */
+    }
+    const url = process.env.NEXTING_CODEX_URL ??
+        cfg.url ??
+        "wss://api.nexting.ai/codex-bridge/connect";
+    const token = process.env.NEXTING_CODEX_TOKEN ?? cfg.token ?? "";
+    const bridgeId = ensureBridgeId(cfg, CODEX_CONFIG);
+    return {
+        url,
+        token,
+        bridgeId,
+        net: buildNet(CODEX_CONFIG, cfg, url),
+        e2eEnabled: cfg.e2eEnabled === true,
+    };
+}
+/** Remove `token` + `bridgeId` from the bridge config JSON (keep `url`). Used by
+ * logout/uninstall so the next launch does not auto-reconnect. Best-effort. */
+function clearTokenAndBridgeId(file) {
+    let cfg = {};
+    try {
+        cfg = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return; // no config file → nothing to clear
+    }
+    delete cfg.token;
+    delete cfg.bridgeId;
+    try {
+        fs.writeFileSync(file, JSON.stringify(cfg, null, 2));
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/** Best-effort POST to a §2.6 bridge-authed logout endpoint with a short timeout.
+ * Network/HTTP failure is swallowed — it MUST NOT block local teardown. */
+async function bestEffortLogout(endpoint, token, bridgeId) {
+    if (!token || !bridgeId)
+        return;
+    await new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            resolve();
+        };
+        try {
+            const body = JSON.stringify({ token, bridgeId });
+            const u = new URL(endpoint);
+            const lib = u.protocol === "http:" ? http : https;
+            const req = lib.request({
+                method: "POST",
+                hostname: u.hostname,
+                port: u.port || undefined,
+                path: u.pathname + u.search,
+                headers: {
+                    "content-type": "application/json",
+                    "content-length": Buffer.byteLength(body),
+                },
+                timeout: 4000,
+            }, (res) => {
+                res.on("data", () => { });
+                res.on("end", finish);
+            });
+            req.on("error", finish);
+            req.on("timeout", () => {
+                req.destroy();
+                finish();
+            });
+            req.write(body);
+            req.end();
+        }
+        catch {
+            finish();
+        }
+    });
+}
+async function main() {
+    const cmd = process.argv[2] ?? "start";
+    if (cmd === "once") {
+        const sessions = await discoverSessions();
+        console.log(JSON.stringify(sessions, null, 2));
+        return;
+    }
+    // Mirror the user's terminal Claude egress into the bridge's engineEnv so a
+    // phone-spawned engine exits from the SAME residential IP / timezone / locale
+    // as their terminal. Critical for region-locked users (e.g. CN): a mismatched
+    // exit IP on the same account is an account-ban risk. Re-run after rotating
+    // the proxy. PARSES the shell rc statically (never sources it — sourcing an
+    // interactive rc with a prompt framework / network checks can hang): reads a
+    // `CLAUDE_PROXY="..."` line, or assembles it from
+    // `CLAUDE_PROXY_{USER,PASS,HOST,PORT}`.
+    if (cmd === "sync-proxy") {
+        const readRc = () => {
+            for (const f of [".zshrc", ".bashrc", ".zprofile", ".bash_profile"]) {
+                try {
+                    return fs.readFileSync(path.join(os.homedir(), f), "utf8");
+                }
+                catch {
+                    /* try next */
+                }
+            }
+            return "";
+        };
+        const rc = readRc();
+        const grab = (name) => rc.match(new RegExp(`${name}=["']?([^"'\\n]+)`))?.[1]?.trim() ?? "";
+        let proxy = grab("CLAUDE_PROXY");
+        if (!proxy || proxy.includes("$")) {
+            // Assemble from components (CLAUDE_PROXY is often `...${USER}:${PASS}@...`).
+            const u = grab("CLAUDE_PROXY_USER"), pw = grab("CLAUDE_PROXY_PASS"), host = grab("CLAUDE_PROXY_HOST"), port = grab("CLAUDE_PROXY_PORT");
+            proxy =
+                u && pw && host && port ? `http://${u}:${pw}@${host}:${port}` : "";
+        }
+        if (!proxy) {
+            console.error("No CLAUDE_PROXY (or CLAUDE_PROXY_{USER,PASS,HOST,PORT}) found in your shell rc. Set it (the proxy your terminal `claude` uses) and re-run, or edit engineEnv in ~/.nexting/{cc,codex}-bridge.json by hand.");
+            process.exit(1);
+        }
+        const engineEnv = {
+            https_proxy: proxy,
+            http_proxy: proxy,
+            all_proxy: proxy,
+            no_proxy: "localhost,127.0.0.1,::1",
+            TZ: grab("CLAUDE_TZ") || "America/New_York",
+            LANG: grab("CLAUDE_LANG") || "en_US.UTF-8",
+            LC_ALL: grab("CLAUDE_LANG") || "en_US.UTF-8",
+        };
+        for (const file of [CONFIG, CODEX_CONFIG]) {
+            let cfg = {};
+            try {
+                cfg = JSON.parse(fs.readFileSync(file, "utf8"));
+            }
+            catch {
+                /* create */
+            }
+            cfg.engineEnv = engineEnv;
+            try {
+                fs.mkdirSync(path.dirname(file), { recursive: true });
+                fs.writeFileSync(file, JSON.stringify(cfg, null, 2));
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        const host = proxy.replace(/^[a-z]+:\/\/[^@/]*@/i, "").replace(/\/.*$/, "");
+        console.log(`✓ engineEnv synced to both bridges (proxy host ${host}, TZ ${engineEnv.TZ}). Restart: launchctl kickstart -k gui/$(id -u)/ai.nexting.cc-bridge`);
+        return;
+    }
+    if (cmd === "codex-once") {
+        const { discoverCodexSessions } = await import("./scanner.js");
+        console.log(JSON.stringify(await discoverCodexSessions(), null, 2));
+        return;
+    }
+    if (cmd === "codex-run") {
+        const { url, token, bridgeId, net, e2eEnabled } = loadCodexConfig();
+        if (!token) {
+            console.error("No token. Run the Codex installer (curl -fsSL https://nexting.ai/install-codex | bash) or set NEXTING_CODEX_TOKEN.");
+            process.exit(1);
+        }
+        const resumeIdx = process.argv.indexOf("--resume");
+        const sessionId = resumeIdx >= 0 ? (process.argv[resumeIdx + 1] ?? "new") : "new";
+        const cwd = process.cwd();
+        console.log(`[codex-bridge] live shell → ${url}  (session=${sessionId}, cwd=${cwd})`);
+        console.log("输入文字回车发送给 Codex；手机可同时接入这个会话。Ctrl-C 退出。\n");
+        const handle = startBridge({
+            url,
+            token,
+            bridgeId,
+            ...net,
+            engine: "codex",
+            localShell: { sessionId, cwd },
+            onTerminalRevoke: () => clearTokenAndBridgeId(CODEX_CONFIG),
+            e2eEnabled,
+        });
+        const quit = () => {
+            handle.stop();
+            process.exit(0);
+        };
+        process.on("SIGINT", quit);
+        process.on("SIGTERM", quit);
+        return;
+    }
+    if (cmd === "codex-start") {
+        // Background daemon that launchd keeps alive. Connects to the cloud and
+        // pushes Codex session snapshots so they appear on the phone.
+        const { url, token, bridgeId, net, e2eEnabled } = loadCodexConfig();
+        if (!token) {
+            console.error("No token. Run the Codex installer (curl -fsSL https://nexting.ai/install-codex | bash) or set NEXTING_CODEX_TOKEN.");
+            process.exit(1);
+        }
+        console.log(`[codex-bridge] starting → ${url}`);
+        const codexUpdateDeps = {
+            currentVersion: VERSION,
+            label: "ai.nexting.codex-bridge",
+            log: (m) => console.log(`[codex-bridge] ${m}`),
+        };
+        const handle = startBridge({
+            url,
+            token,
+            bridgeId,
+            ...net,
+            engine: "codex",
+            onTerminalRevoke: () => clearTokenAndBridgeId(CODEX_CONFIG),
+            e2eEnabled,
+            onUpdateSignal: () => {
+                if ((process.env.NEXTING_NO_SELF_UPDATE ?? "").trim() === "1")
+                    return;
+                void maybeSelfUpdate(codexUpdateDeps, { relaunch: true });
+            },
+        });
+        // Same self-update loop as the cc hub, but kicks the codex daemon label.
+        const selfUpdate = startSelfUpdate(codexUpdateDeps);
+        const quit = () => {
+            selfUpdate.stop();
+            handle.stop();
+            process.exit(0);
+        };
+        process.on("SIGINT", quit);
+        process.on("SIGTERM", quit);
+        return;
+    }
+    if (cmd === "codex-install") {
+        // Codex has no shim; just keep a background daemon alive that connects to
+        // the cloud and pushes your Codex session snapshots (phone-visible + attachable).
+        setupLaunchdCodex();
+        console.log("✓ Nexting Codex connected. Your Codex sessions now appear on your phone.\n  Live co-control a folder: nexting-cc-bridge codex-run   ·   Remove: nexting-cc-bridge codex-uninstall");
+        return;
+    }
+    if (cmd === "codex-logout") {
+        // §6.2: best-effort server-side revoke, THEN clear config, THEN unload daemon.
+        const { token, bridgeId } = loadCodexConfig();
+        await bestEffortLogout(CODEX_LOGOUT_URL, token, bridgeId);
+        clearTokenAndBridgeId(CODEX_CONFIG);
+        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/ai.nexting.codex-bridge`], { stdio: "ignore" });
+        spawnSync("launchctl", ["unload", CODEX_PLIST], { stdio: "ignore" });
+        console.log("✓ Logged out. This Mac will no longer connect. Re-run the installer to reconnect.");
+        return;
+    }
+    if (cmd === "codex-uninstall") {
+        // §6.4: best-effort server-side revoke + clear config FIRST.
+        const { token, bridgeId } = loadCodexConfig();
+        await bestEffortLogout(CODEX_LOGOUT_URL, token, bridgeId);
+        clearTokenAndBridgeId(CODEX_CONFIG);
+        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/ai.nexting.codex-bridge`], { stdio: "ignore" });
+        spawnSync("launchctl", ["unload", CODEX_PLIST], { stdio: "ignore" });
+        try {
+            fs.unlinkSync(CODEX_PLIST);
+        }
+        catch {
+            /* gone */
+        }
+        console.log("✓ Nexting Codex removed. This Mac is disconnected from your account.");
+        return;
+    }
+    if (cmd === "start") {
+        const { url, token, bridgeId, net, e2eEnabled } = loadConfig();
+        if (!token) {
+            console.error("No token. Run the installer (curl -fsSL https://nexting.ai/install-cc | bash) or set NEXTING_CC_TOKEN.");
+            process.exit(1);
+        }
+        console.log(`[cc-bridge] starting → ${url}`);
+        const handle = startBridge({
+            url,
+            token,
+            bridgeId,
+            ...net,
+            onTerminalRevoke: () => clearTokenAndBridgeId(CONFIG),
+            e2eEnabled,
+        });
+        process.on("SIGINT", () => {
+            handle.stop();
+            process.exit(0);
+        });
+        process.on("SIGTERM", () => {
+            handle.stop();
+            process.exit(0);
+        });
+        return;
+    }
+    if (cmd === "run") {
+        const { url, token, bridgeId, net, e2eEnabled } = loadConfig();
+        if (!token) {
+            console.error("No token. Run the installer (curl -fsSL https://nexting.ai/install-cc | bash) or set NEXTING_CC_TOKEN.");
+            process.exit(1);
+        }
+        // nexting-cc-bridge run            → 新会话（手机可接入）
+        // nexting-cc-bridge run --resume X → 续接已有（未在终端开着的）会话
+        const resumeIdx = process.argv.indexOf("--resume");
+        const sessionId = resumeIdx >= 0 ? (process.argv[resumeIdx + 1] ?? "new") : "new";
+        const cwd = process.cwd();
+        console.log(`[cc-bridge] live shell → ${url}  (session=${sessionId}, cwd=${cwd})`);
+        console.log("输入文字回车发送给 Claude Code；手机可同时接入这个会话。Ctrl-C 退出。\n");
+        const handle = startBridge({
+            url,
+            token,
+            bridgeId,
+            ...net,
+            localShell: { sessionId, cwd },
+            onTerminalRevoke: () => clearTokenAndBridgeId(CONFIG),
+            e2eEnabled,
+        });
+        const quit = () => {
+            handle.stop();
+            process.exit(0);
+        };
+        process.on("SIGINT", quit);
+        process.on("SIGTERM", quit);
+        return;
+    }
+    if (cmd === "mirror") {
+        const { url, token, bridgeId, net, e2eEnabled } = loadConfig();
+        if (!token) {
+            console.error("No token. Run the installer (curl -fsSL https://nexting.ai/install-cc | bash) or set NEXTING_CC_TOKEN.");
+            process.exit(1);
+        }
+        // nexting-cc-bridge mirror [-- <claude args>]
+        // Runs claude in a pty (native TUI in your terminal) AND mirrors it to the phone.
+        const sep = process.argv.indexOf("--");
+        const args = sep >= 0 ? process.argv.slice(sep + 1) : [];
+        const { resolveClaudeBin } = await import("./bridge.js");
+        const command = resolveClaudeBin();
+        const cwd = process.cwd();
+        console.log(`[cc-bridge] mirror → ${url}  (claude=${command}, cwd=${cwd})  手机可镜像+键入。Ctrl-C 退出。`);
+        const handle = startBridge({
+            url,
+            token,
+            bridgeId,
+            ...net,
+            mirror: { command, args, cwd },
+            onTerminalRevoke: () => clearTokenAndBridgeId(CONFIG),
+            e2eEnabled,
+        });
+        const quit = () => {
+            handle.stop();
+            process.exit(0);
+        };
+        process.on("SIGINT", quit);
+        process.on("SIGTERM", quit);
+        return;
+    }
+    if (cmd === "hub") {
+        const { url, token, bridgeId, net, e2eEnabled } = loadConfig();
+        if (!token) {
+            console.error("No token. Run the installer (curl -fsSL https://nexting.ai/install-cc | bash) or set NEXTING_CC_TOKEN.");
+            process.exit(1);
+        }
+        console.log(`[cc-bridge] hub → ${url}  socket=${HUB_SOCK}`);
+        const ccUpdateDeps = {
+            currentVersion: VERSION,
+            label: "ai.nexting.cc-bridge",
+            log: (m) => console.log(`[cc-bridge] ${m}`),
+        };
+        const handle = startBridge({
+            url,
+            token,
+            bridgeId,
+            ...net,
+            hub: { socketPath: HUB_SOCK },
+            onTerminalRevoke: () => clearTokenAndBridgeId(CONFIG),
+            e2eEnabled,
+            // Cloud push-update: jump on a published release at connect time instead
+            // of waiting for the periodic check. Respects the dev opt-out.
+            onUpdateSignal: () => {
+                if ((process.env.NEXTING_NO_SELF_UPDATE ?? "").trim() === "1")
+                    return;
+                void maybeSelfUpdate(ccUpdateDeps, { relaunch: true });
+            },
+        });
+        // Keep the installed bridge current (ask_user, binding, push features only
+        // take effect on the new version). Startup check may relaunch this daemon.
+        const selfUpdate = startSelfUpdate(ccUpdateDeps);
+        const quit = () => {
+            selfUpdate.stop();
+            handle.stop();
+            process.exit(0);
+        };
+        process.on("SIGINT", quit);
+        process.on("SIGTERM", quit);
+        return;
+    }
+    if (cmd === "term") {
+        // A wrapped `claude` that registers with the local hub (what the `claude`
+        // shim calls). Your terminal stays native; the hub multiplexes it to phone.
+        const sep = process.argv.indexOf("--");
+        let args = sep >= 0 ? process.argv.slice(sep + 1) : [];
+        // Resolve the claude session id so the phone can map this live pty to a
+        // session (and inject into it). If the user didn't pin one, inject a fresh
+        // --session-id so claude uses a known id from the start.
+        let sessionId = sessionIdFromArgs(args);
+        if (!sessionId) {
+            sessionId = randomUUID();
+            args = [...args, "--session-id", sessionId];
+        }
+        const { resolveClaudeBin } = await import("./bridge.js");
+        const { startShell } = await import("./shell.js");
+        const { realSpawnPty } = await import("./pty-spawn.js");
+        const { realHubConnect } = await import("./hub-server.js");
+        const { StringDecoder } = await import("node:string_decoder");
+        const command = resolveClaudeBin();
+        const cwd = process.cwd();
+        const termId = `${process.pid}-${cwd.replace(/[^a-zA-Z0-9]/g, "-")}`;
+        try {
+            await ensureHubRunning();
+        }
+        catch (e) {
+            console.error(`[cc-bridge] ${e.message}; running claude直接`);
+            // Fall back to plain claude so the user is never blocked.
+            const c = spawn(command, args, { stdio: "inherit" });
+            c.on("exit", (code) => process.exit(code ?? 0));
+            return;
+        }
+        const cols = process.stdout.columns || 80;
+        const rows = process.stdout.rows || 24;
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        const exitTerm = () => {
+            if (process.stdin.isTTY)
+                process.stdin.setRawMode(false);
+            process.exit(0);
+        };
+        const shell = startShell({
+            spawnPty: realSpawnPty,
+            connect: () => realHubConnect(HUB_SOCK),
+            termId,
+            command,
+            args,
+            cwd,
+            cols,
+            rows,
+            sessionId,
+            onLocal: (d) => process.stdout.write(d),
+            onExit: exitTerm,
+        });
+        // Decode stdin through a StringDecoder so a multi-byte UTF-8 char (a CJK glyph
+        // is 3 bytes; IME paste/fast typing emits them) split across two `data` events
+        // is buffered and reassembled instead of each half becoming U+FFFD. ASCII /
+        // control bytes (escape sequences) are <0x80 so they never buffer — no latency.
+        const stdinDecoder = new StringDecoder("utf8");
+        process.stdin.on("data", (b) => shell.writeInput(stdinDecoder.write(b)));
+        process.stdout.on("resize", () => shell.resize(process.stdout.columns || 80, process.stdout.rows || 24));
+        const quit = () => {
+            shell.stop();
+            exitTerm();
+        };
+        process.on("SIGINT", quit);
+        process.on("SIGTERM", quit);
+        return;
+    }
+    if (cmd === "install") {
+        // Install the `claude` shim (→ ~/.nexting/bin/claude, put first on PATH) so a
+        // plain `claude` transparently runs through the phone-controllable hub: a
+        // terminal session is born controllable and mirrors to your phone. The shim
+        // self-resolves the REAL claude and honors NEXTING_CC_DISABLE=1 as an escape
+        // hatch; `uninstall` removes it + the PATH block.
+        fs.mkdirSync(SHIM_DIR, { recursive: true });
+        // Copy the packaged shim (../shim/claude relative to dist/cli.js) into place.
+        const shimSrc = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "shim", "claude");
+        try {
+            fs.copyFileSync(shimSrc, SHIM);
+        }
+        catch {
+            console.error(`✗ shim not found at ${shimSrc}`);
+            process.exit(1);
+        }
+        fs.chmodSync(SHIM, 0o755);
+        // Put the shim dir on PATH via the user's shell rc(s). Always ensure zsh
+        // (macOS default); touch bash files only if they already exist.
+        const zshrc = path.join(os.homedir(), ".zshrc");
+        for (const rc of [".zshrc", ".bashrc", ".bash_profile"]) {
+            const p = path.join(os.homedir(), rc);
+            if (!fs.existsSync(p) && p !== zshrc)
+                continue; // don't create bash files
+            let txt = "";
+            try {
+                txt = fs.readFileSync(p, "utf8");
+            }
+            catch {
+                /* new file */
+            }
+            const out = addPinclawPathBlock(txt);
+            if (out !== txt)
+                fs.writeFileSync(p, out);
+        }
+        setupLaunchdHub();
+        console.log("✓ Nexting connected. `claude` now mirrors to your phone and is phone-controllable.\n" +
+            "  Open a NEW terminal (or `source ~/.zshrc`).\n" +
+            "  - Bypass once: NEXTING_CC_DISABLE=1 claude\n" +
+            "  - Start Codex sync: nexting-cc-bridge codex-install\n" +
+            "  - Remove: nexting-cc-bridge uninstall");
+        return;
+    }
+    if (cmd === "logout") {
+        // §6.1: best-effort server-side revoke, THEN clear config, THEN unload daemon.
+        const { token, bridgeId } = loadConfig();
+        await bestEffortLogout(CC_LOGOUT_URL, token, bridgeId);
+        clearTokenAndBridgeId(CONFIG);
+        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/ai.nexting.cc-bridge`], { stdio: "ignore" });
+        spawnSync("launchctl", ["unload", PLIST], { stdio: "ignore" });
+        console.log("✓ Logged out. This Mac will no longer connect. Re-run the installer to reconnect.");
+        return;
+    }
+    if (cmd === "uninstall") {
+        // §6.3: best-effort server-side revoke + clear config FIRST.
+        const { token, bridgeId } = loadConfig();
+        await bestEffortLogout(CC_LOGOUT_URL, token, bridgeId);
+        clearTokenAndBridgeId(CONFIG);
+        spawnSync("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/ai.nexting.cc-bridge`], { stdio: "ignore" });
+        spawnSync("launchctl", ["unload", PLIST], { stdio: "ignore" });
+        for (const f of [SHIM, PLIST]) {
+            try {
+                fs.unlinkSync(f);
+            }
+            catch {
+                /* gone */
+            }
+        }
+        for (const rc of RC_FILES) {
+            const p = path.join(os.homedir(), rc);
+            try {
+                const txt = fs.readFileSync(p, "utf8");
+                const out = stripPinclawBlock(txt);
+                if (out !== txt)
+                    fs.writeFileSync(p, out);
+            }
+            catch {
+                /* none */
+            }
+        }
+        console.log("✓ Nexting removed. `claude` is back to normal. This Mac is disconnected from your account.");
+        return;
+    }
+    console.error(`Unknown command: ${cmd}. Use "start", "hub", "term", "install", "uninstall", "logout", "run", "mirror", "once", "codex-run", "codex-once", "codex-start", "codex-install", "codex-uninstall", or "codex-logout".`);
+    process.exit(1);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});