@unlinearity/cli-wechat-bridge 1.1.3 → 1.1.5

package/dist/companion/local-companion-start.js

@@ -16,7 +16,7 @@ const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".
 const DEFAULT_WAIT_TIMEOUT_MS = 15_000;
 const DEFAULT_ADAPTER = "codex";
 function log(adapter, message) {
-    process.stderr.write(`[wechat-${adapter}-start] ${message}\n`);
+    process.stderr.write(`[wechat-${adapter}] ${message}\n`);
 }
 export function normalizeComparablePath(cwd) {
     const normalized = path.resolve(cwd);
@@ -61,7 +61,8 @@ export function decideLaunchAction(input) {
     if (input.sessionStartMode === "new" &&
         (input.requestedAdapter === "claude" ||
             input.requestedAdapter === "opencode" ||
-            input.requestedAdapter === "pi")) {
+            input.requestedAdapter === "pi" ||
+            input.requestedAdapter === "codex")) {
         return {
             kind: "start_bridge",
             message: `Starting a fresh ${input.requestedAdapter} session for ${input.requestedCwd}...`,
@@ -106,22 +107,35 @@ export function parseCliArgs(argv) {
         }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
+            const helpAdapter = adapter;
+            const commandName = `wechat-${helpAdapter}`;
+            const adapterLabel = {
+                codex: "Codex",
+                claude: "Claude Code",
+                opencode: "OpenCode",
+                pi: "Pi",
+            }[helpAdapter];
             process.stdout.write([
-                "Usage: wechat-codex-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...codex args]",
-                "       wechat-claude-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...claude args]",
-                "       wechat-opencode-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...opencode args]",
-                "       wechat-pi-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...pi args]",
-                "       local-companion-start [--adapter <codex|claude|opencode|pi>] [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...cli args]",
+                `Usage: ${commandName} [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [--session-start-mode <restore|new>] [...${helpAdapter} args]`,
                 "",
-                "Starts a bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
-                "Claude, OpenCode, and Pi launchers start a fresh CLI session by default.",
-                "Use --session-start-mode restore to explicitly restore the previous session.",
-                "All adapters are companion-bound: closing the companion/panel also stops the bridge.",
+                "Ensures the WeChat runtime for the current directory, then opens or reuses the visible CLI.",
+                "If a same-workspace daemon is running, the command delegates to that daemon.",
+                helpAdapter === "codex"
+                    ? "Codex restores the current session by default."
+                    : `${adapterLabel} starts a fresh session by default.`,
+                helpAdapter === "codex"
+                    ? "Use --session-start-mode new to explicitly start a fresh session."
+                    : "Use --session-start-mode restore to explicitly restore the previous session.",
+                "Use --doctor to check the selected adapter and workspace without starting it.",
+                "Without a daemon, the transient runtime is companion-bound and stops when the visible CLI closes.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
             ].join("\n"));
             process.exit(0);
         }
+        if (arg === "--doctor") {
+            continue;
+        }
         if (arg === "--adapter") {
             if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
@@ -375,6 +389,12 @@ async function ensureBridgeReady(options) {
     await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
     return { shouldOpenVisibleClient: true };
 }
+// The daemon's ensure_slot can legitimately take a while: opening a visible
+// client waits up to 15s for it to connect, and codex waits another 15s for
+// the visible thread — all serialized per adapter. The default 2s IPC timeout
+// would expire on nearly every cold start, so delegation uses a generous
+// deadline and falls back to a local bridge when the daemon cannot deliver.
+const ENSURE_SLOT_DELEGATION_TIMEOUT_MS = 45_000;
 export async function tryDelegateToDaemon(options, deps = {}) {
     const readEndpoint = deps.readEndpoint ?? readDaemonEndpoint;
     const isEndpointAlive = deps.isEndpointAlive ?? isDaemonEndpointAlive;
@@ -400,9 +420,14 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         openVisible: true,
         sessionStartMode: options.sessionStartMode,
         reuseExistingVisible: options.adapter !== "pi" || options.sessionStartMode !== "new",
-    });
+    }, { timeoutMs: ENSURE_SLOT_DELEGATION_TIMEOUT_MS });
     if (!response.ok) {
-        throw new Error(response.error);
+        // A daemon that cannot answer in time (or at all) must not abort the
+        // launch: fall back to a local companion-bound bridge so the user still
+        // gets a working terminal instead of an error for work the daemon may
+        // still complete.
+        log(options.adapter, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
+        return false;
     }
     log(options.adapter, `Delegated to running wechat-daemon for ${options.cwd}.`);
     return true;
@@ -414,6 +439,7 @@ export async function runVisibleClient(options, runners = {}) {
         return await (runners.codexRemoteClient ?? runCodexRemoteClient)({
             cwd: options.cwd,
             cliArgs: options.cliArgs,
+            sessionStartMode: options.sessionStartMode,
         });
     }
     return await (runners.localCompanion ?? runLocalCompanion)({
@@ -431,6 +457,11 @@ export async function ensureCompanionStartWechatCredentials(adapter, ensureCrede
     });
 }
 export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
+    if (argv.includes("--doctor")) {
+        const { runDoctorCheck } = await import("../utils/doctor.js");
+        await runDoctorCheck(argv, { mode: "bridge" });
+        return 0;
+    }
     const options = parseCliArgs(argv);
     await ensureCompanionStartWechatCredentials(options.adapter);
     if (await tryDelegateToDaemon(options)) {

package/dist/companion/local-companion.js

@@ -23,9 +23,9 @@ function parseCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
-                "Usage: local-companion --adapter <codex|claude|opencode|pi> [--cwd <path>] [...cli args]",
+                "Internal companion usage: local-companion --adapter <codex|claude|opencode|pi> [--cwd <path>] [...cli args]",
                 "",
-                'Starts the visible local companion and connects it to the matching running bridge for the current directory.',
+                "Connects a visible local CLI to the matching bridge runtime for the current directory.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
             ].join("\n"));
@@ -73,7 +73,7 @@ function readMatchingEndpoint(options) {
         adapter: options.adapter,
     });
     if (!endpoint || endpoint.kind !== options.adapter) {
-        throw new Error(`No active ${options.adapter} bridge endpoint was found for ${options.cwd}. Start "wechat-bridge-${options.adapter}" in that directory first.`);
+        throw new Error(`No active ${options.adapter} runtime was found for ${options.cwd}. Run "wechat-${options.adapter}" in that directory to recreate it.`);
     }
     return endpoint;
 }
@@ -241,6 +241,9 @@ export async function runLocalCompanion(options) {
                 case "resolve_approval":
                     sendResponse(socket, message.id, true, await adapter.resolveApproval(message.payload.action));
                     break;
+                case "submit_user_input":
+                    sendResponse(socket, message.id, true, await adapter.submitUserInput(message.payload.answers));
+                    break;
                 case "dispose":
                     sendResponse(socket, message.id, true);
                     await closeCompanion(0, "bridge_dispose");

package/dist/companion/opencode-tui-bridge-plugin.js

@@ -0,0 +1,73 @@
+import net from "node:net";
+const ROUTE_POLL_INTERVAL_MS = 100;
+const MAX_BUFFER_SIZE = 1024 * 1024;
+function extractSessionId(route) {
+    if (route.name === "session" && typeof route.params?.sessionID === "string") {
+        return route.params.sessionID;
+    }
+    if (route.type === "session" && typeof route.sessionID === "string") {
+        return route.sessionID;
+    }
+    return null;
+}
+export default {
+    id: "cli-wechat-bridge.session-route",
+    tui: async (api, options) => {
+        const port = Number(options?.port);
+        const token = typeof options?.token === "string" ? options.token : "";
+        if (!Number.isInteger(port) || port <= 0 || !token) {
+            return;
+        }
+        const socket = net.connect({ host: "127.0.0.1", port });
+        let connected = false;
+        let lastSessionId;
+        let queuedFrame = null;
+        const writeFrame = (frame) => {
+            if (socket.destroyed) {
+                return;
+            }
+            if (!connected) {
+                queuedFrame = frame;
+                return;
+            }
+            socket.write(`${JSON.stringify(frame)}\n`);
+        };
+        const publishRoute = () => {
+            const sessionId = extractSessionId(api.route.current);
+            if (sessionId === lastSessionId) {
+                return;
+            }
+            lastSessionId = sessionId;
+            writeFrame({
+                type: "route_state",
+                sessionId,
+                observedAt: new Date().toISOString(),
+            });
+        };
+        socket.setEncoding("utf8");
+        socket.on("connect", () => {
+            socket.setNoDelay(true);
+            socket.write(`${JSON.stringify({ type: "hello", token })}\n`);
+            connected = true;
+            publishRoute();
+            if (queuedFrame) {
+                socket.write(`${JSON.stringify(queuedFrame)}\n`);
+                queuedFrame = null;
+            }
+        });
+        socket.on("data", (chunk) => {
+            if (chunk.length > MAX_BUFFER_SIZE) {
+                socket.destroy();
+            }
+        });
+        socket.on("error", () => {
+            // Keep the native TUI usable if the bridge-side observer disappears.
+        });
+        const timer = setInterval(publishRoute, ROUTE_POLL_INTERVAL_MS);
+        timer.unref?.();
+        api.lifecycle.onDispose(() => {
+            clearInterval(timer);
+            socket.destroy();
+        });
+    },
+};

package/dist/companion/pi-tui-bridge-extension.js

@@ -1,4 +1,6 @@
+import fs from "node:fs";
 import net from "node:net";
+import path from "node:path";
 const BRIDGE_HOST = "127.0.0.1";
 const INTERNAL_NEW_COMMAND = "__cli_bridge_new";
 const INTERNAL_SWITCH_COMMAND = "__cli_bridge_switch";
@@ -110,8 +112,36 @@ export default function piTuiBridgeExtension(pi) {
                 return;
             }
             try {
+                if (!context.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                let request;
+                try {
+                    request = JSON.parse(parsed.value);
+                }
+                catch {
+                    throw new Error("The Pi session switch request is malformed.");
+                }
+                if (typeof request.sessionPath !== "string" ||
+                    typeof request.sessionId !== "string" ||
+                    typeof request.cwd !== "string" ||
+                    !fs.existsSync(request.sessionPath)) {
+                    throw new Error("The requested Pi session is no longer available.");
+                }
+                const firstLine = fs
+                    .readFileSync(request.sessionPath, "utf8")
+                    .split(/\r?\n/)
+                    .find((line) => line.trim());
+                const header = firstLine ? JSON.parse(firstLine) : null;
+                if (!isRecord(header) ||
+                    header.type !== "session" ||
+                    header.id !== request.sessionId ||
+                    typeof header.cwd !== "string" ||
+                    path.resolve(header.cwd) !== path.resolve(request.cwd)) {
+                    throw new Error("The requested Pi session no longer matches this workspace.");
+                }
                 let sessionState = {};
-                const result = await context.switchSession(parsed.value, {
+                const result = await context.switchSession(request.sessionPath, {
                     withSession: async (nextContext) => {
                         writeSessionState(nextContext, "resume");
                         sessionState = {
@@ -157,8 +187,17 @@ export default function piTuiBridgeExtension(pi) {
             }
             else if (command.type === "switch_session" &&
                 typeof command.id === "string" &&
-                typeof command.sessionPath === "string") {
-                pi.sendUserMessage(`/${INTERNAL_SWITCH_COMMAND} ${command.id} ${command.sessionPath}`, { expandPromptTemplates: true });
+                typeof command.sessionPath === "string" &&
+                typeof command.sessionId === "string" &&
+                typeof command.cwd === "string") {
+                if (!latestContext?.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                pi.sendUserMessage(`/${INTERNAL_SWITCH_COMMAND} ${command.id} ${JSON.stringify({
+                    sessionPath: command.sessionPath,
+                    sessionId: command.sessionId,
+                    cwd: command.cwd,
+                })}`, { expandPromptTemplates: true });
             }
         }
         catch (error) {

package/dist/daemon/daemon-link.js

@@ -65,8 +65,12 @@ export function isPidAlive(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        // EPERM means the OS found the pid but denied access (e.g. a Windows
+        // process running under another privilege level). The process exists, so
+        // it must be treated as alive — returning false here would let callers
+        // delete a live daemon's endpoint file and break its singleton.
+        return error instanceof Error && error.code === "EPERM";
     }
 }
 export function sendDaemonResponse(socket, id, response) {
@@ -170,6 +174,11 @@ export async function sendDaemonRequest(endpoint, payload, options = {}) {
         socket.once("error", () => {
             finish({ ok: false, error: "Daemon endpoint is not reachable." });
         });
+        socket.once("close", () => {
+            // The daemon may die or be taken over mid-request; without this the
+            // caller waits out the full timeout for a socket that is already gone.
+            finish({ ok: false, error: "Daemon connection closed before a response." });
+        });
     });
 }
 export async function isDaemonEndpointAlive(endpoint, options = {}) {
@@ -177,5 +186,18 @@ export async function isDaemonEndpointAlive(endpoint, options = {}) {
         return false;
     }
     const response = await sendDaemonRequest(endpoint, { command: "status" }, options);
-    return response.ok;
+    if (response.ok) {
+        return true;
+    }
+    // A momentarily busy daemon (e.g. a synchronous session-directory scan
+    // blocking its event loop) can miss the short status deadline. Retry once
+    // before declaring it dead: a false negative makes callers delete a live
+    // daemon's endpoint file and break its singleton.
+    const timedOut = (response.error ?? "").includes("Timed out");
+    if (!timedOut) {
+        return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    const retry = await sendDaemonRequest(endpoint, { command: "status" }, options);
+    return retry.ok;
 }