cli-wechat-bridge 1.1.2 → 1.1.4

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);
@@ -38,7 +38,7 @@ export function formatRestartUnhealthyMessage(cwd) {
     return `Detected unhealthy companion state for ${cwd}. Restarting bridge...`;
 }
 export function defaultSessionStartMode(adapter) {
-    return adapter === "claude" || adapter === "opencode" ? "new" : "restore";
+    return adapter === "codex" ? "restore" : "new";
 }
 export function decideLaunchAction(input) {
     if (input.lockShouldAutoReclaim) {
@@ -59,7 +59,10 @@ export function decideLaunchAction(input) {
         };
     }
     if (input.sessionStartMode === "new" &&
-        (input.requestedAdapter === "claude" || input.requestedAdapter === "opencode")) {
+        (input.requestedAdapter === "claude" ||
+            input.requestedAdapter === "opencode" ||
+            input.requestedAdapter === "pi" ||
+            input.requestedAdapter === "codex")) {
         return {
             kind: "start_bridge",
             message: `Starting a fresh ${input.requestedAdapter} session for ${input.requestedCwd}...`,
@@ -95,6 +98,7 @@ export function parseCliArgs(argv) {
     let cwd = process.cwd();
     let profile;
     let timeoutMs = DEFAULT_WAIT_TIMEOUT_MS;
+    let sessionStartMode;
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -103,22 +107,38 @@ 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]",
-                "       local-companion-start [--adapter <codex|claude|opencode>] [--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 and OpenCode launchers start a fresh CLI session by default.",
-                "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.",
+                `Deprecated alias: ${commandName}-start.`,
                 "",
             ].join("\n"));
             process.exit(0);
         }
+        if (arg === "--doctor") {
+            continue;
+        }
         if (arg === "--adapter") {
-            if (!next || !["codex", "claude", "opencode"].includes(next)) {
+            if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
             }
             adapter = next;
@@ -153,6 +173,14 @@ export function parseCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--session-start-mode") {
+            if (!next || !["restore", "new"].includes(next)) {
+                throw new Error(`Invalid session start mode: ${next ?? "(missing)"}`);
+            }
+            sessionStartMode = next;
+            i += 1;
+            continue;
+        }
         cliArgs.push(arg);
     }
     return {
@@ -160,7 +188,7 @@ export function parseCliArgs(argv) {
         cwd,
         profile,
         timeoutMs,
-        sessionStartMode: defaultSessionStartMode(adapter),
+        sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
     };
 }
@@ -203,7 +231,10 @@ async function stopExistingBridge(lock, requestedAdapter) {
     if (!(await waitForProcessExit(pid, 10_000))) {
         throw new Error(`Timed out waiting for existing bridge pid=${pid} to exit.`);
     }
-    if (lock.adapter === "codex" || lock.adapter === "claude" || lock.adapter === "opencode") {
+    if (lock.adapter === "codex" ||
+        lock.adapter === "claude" ||
+        lock.adapter === "opencode" ||
+        lock.adapter === "pi") {
         clearLocalCompanionEndpoint(cwd, undefined, { adapter: lock.adapter });
     }
     else {
@@ -359,6 +390,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;
@@ -383,10 +420,15 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         cliArgs: options.cliArgs,
         openVisible: true,
         sessionStartMode: options.sessionStartMode,
-        reuseExistingVisible: true,
-    });
+        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;
@@ -398,6 +440,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)({
@@ -415,6 +458,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,16 +23,16 @@ function parseCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
-                "Usage: local-companion --adapter <codex|claude|opencode> [--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"));
             process.exit(0);
         }
         if (arg === "--adapter") {
-            if (!next || !["codex", "claude", "opencode"].includes(next)) {
+            if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
             }
             adapter = next;
@@ -58,7 +58,7 @@ function parseCliArgs(argv) {
         cliArgs.push(arg);
     }
     if (!adapter) {
-        throw new Error("Missing required --adapter <codex|claude|opencode>");
+        throw new Error("Missing required --adapter <codex|claude|opencode|pi>");
     }
     return { adapter, cwd, sessionStartMode, cliArgs };
 }
@@ -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/pi-tui-bridge-extension.js

@@ -0,0 +1,256 @@
+import net from "node:net";
+const BRIDGE_HOST = "127.0.0.1";
+const INTERNAL_NEW_COMMAND = "__cli_bridge_new";
+const INTERNAL_SWITCH_COMMAND = "__cli_bridge_switch";
+const MAX_BUFFER_SIZE = 8 * 1024 * 1024;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function extractAssistantText(message) {
+    if (!isRecord(message) || message.role !== "assistant") {
+        return "";
+    }
+    if (typeof message.content === "string") {
+        return message.content.trim();
+    }
+    if (!Array.isArray(message.content)) {
+        return "";
+    }
+    return message.content
+        .filter((block) => isRecord(block))
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n")
+        .trim();
+}
+function parseControlArgs(args) {
+    const trimmed = args.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const separatorIndex = trimmed.indexOf(" ");
+    if (separatorIndex < 0) {
+        return { id: trimmed };
+    }
+    return {
+        id: trimmed.slice(0, separatorIndex),
+        value: trimmed.slice(separatorIndex + 1),
+    };
+}
+export default function piTuiBridgeExtension(pi) {
+    const bridgePort = Number(process.env.CLI_BRIDGE_PI_TUI_PORT ?? "");
+    const bridgeToken = process.env.CLI_BRIDGE_PI_TUI_TOKEN ?? "";
+    if (!Number.isInteger(bridgePort) || bridgePort <= 0 || !bridgeToken) {
+        return;
+    }
+    const socket = net.connect({ host: BRIDGE_HOST, port: bridgePort });
+    let buffer = "";
+    let connected = false;
+    const queuedFrames = [];
+    const queuedCommands = [];
+    let latestContext = null;
+    const writeFrame = (frame) => {
+        if (socket.destroyed) {
+            return;
+        }
+        if (!connected) {
+            queuedFrames.push(frame);
+            return;
+        }
+        socket.write(`${JSON.stringify(frame)}\n`);
+    };
+    const writeSessionState = (context, reason) => {
+        writeFrame({
+            type: "session_state",
+            sessionId: context.sessionManager.getSessionId(),
+            sessionFile: context.sessionManager.getSessionFile(),
+            reason,
+        });
+    };
+    pi.registerCommand(INTERNAL_NEW_COMMAND, {
+        description: "Internal CLI WeChat Bridge session command",
+        handler: async (args, context) => {
+            const parsed = parseControlArgs(args);
+            if (!parsed) {
+                return;
+            }
+            try {
+                let sessionState = {};
+                const result = await context.newSession({
+                    withSession: async (nextContext) => {
+                        writeSessionState(nextContext, "new");
+                        sessionState = {
+                            sessionId: nextContext.sessionManager.getSessionId(),
+                            sessionFile: nextContext.sessionManager.getSessionFile(),
+                        };
+                    },
+                });
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: true,
+                    data: { ...result, ...sessionState },
+                });
+            }
+            catch (error) {
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+    });
+    pi.registerCommand(INTERNAL_SWITCH_COMMAND, {
+        description: "Internal CLI WeChat Bridge session command",
+        handler: async (args, context) => {
+            const parsed = parseControlArgs(args);
+            if (!parsed?.value) {
+                return;
+            }
+            try {
+                let sessionState = {};
+                const result = await context.switchSession(parsed.value, {
+                    withSession: async (nextContext) => {
+                        writeSessionState(nextContext, "resume");
+                        sessionState = {
+                            sessionId: nextContext.sessionManager.getSessionId(),
+                            sessionFile: nextContext.sessionManager.getSessionFile(),
+                        };
+                    },
+                });
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: true,
+                    data: { ...result, ...sessionState },
+                });
+            }
+            catch (error) {
+                writeFrame({
+                    type: "response",
+                    id: parsed.id,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        },
+    });
+    const executeCommand = (command) => {
+        try {
+            if (command.type === "prompt" && typeof command.text === "string") {
+                if (!latestContext?.isIdle()) {
+                    throw new Error("Pi TUI is already processing a turn.");
+                }
+                pi.sendUserMessage(command.text);
+                writeFrame({ type: "response", id: command.id, success: true });
+            }
+            else if (command.type === "abort") {
+                latestContext?.abort();
+                writeFrame({ type: "response", id: command.id, success: true });
+            }
+            else if (command.type === "new_session" && typeof command.id === "string") {
+                pi.sendUserMessage(`/${INTERNAL_NEW_COMMAND} ${command.id}`, {
+                    expandPromptTemplates: true,
+                });
+            }
+            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 });
+            }
+        }
+        catch (error) {
+            writeFrame({
+                type: "response",
+                id: command.id,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+    const dispatchCommand = (command) => {
+        if (!latestContext) {
+            queuedCommands.push(command);
+            return;
+        }
+        executeCommand(command);
+    };
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+        socket.setNoDelay(true);
+        socket.write(`${JSON.stringify({ type: "hello", token: bridgeToken })}\n`);
+        connected = true;
+        for (const frame of queuedFrames.splice(0)) {
+            writeFrame(frame);
+        }
+    });
+    socket.on("data", (chunk) => {
+        buffer += chunk;
+        if (buffer.length > MAX_BUFFER_SIZE) {
+            buffer = "";
+            socket.destroy();
+            return;
+        }
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(line);
+                if (isRecord(parsed)) {
+                    dispatchCommand(parsed);
+                }
+            }
+            catch {
+                // Ignore malformed bridge commands and keep the native TUI alive.
+            }
+        }
+    });
+    socket.on("error", () => {
+        // The visible TUI remains usable if the bridge side disappears.
+    });
+    pi.on("session_start", (event, context) => {
+        latestContext = context;
+        writeSessionState(context, typeof event.reason === "string" ? event.reason : "startup");
+        for (const command of queuedCommands.splice(0)) {
+            executeCommand(command);
+        }
+    });
+    pi.on("input", (event, context) => {
+        latestContext = context;
+        if (event.source === "interactive" && typeof event.text === "string") {
+            writeFrame({ type: "local_input", text: event.text });
+        }
+    });
+    pi.on("message_end", (event, context) => {
+        latestContext = context;
+        const text = extractAssistantText(event.message);
+        if (!text) {
+            return;
+        }
+        const message = isRecord(event.message) ? event.message : {};
+        writeFrame({
+            type: "assistant_message",
+            text,
+            stopReason: message.stopReason,
+            errorMessage: message.errorMessage,
+        });
+    });
+    pi.on("agent_start", (_event, context) => {
+        latestContext = context;
+        writeFrame({ type: "agent_start" });
+    });
+    pi.on("agent_settled", (_event, context) => {
+        latestContext = context;
+        writeSessionState(context, "settled");
+        writeFrame({ type: "agent_settled" });
+    });
+}

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;
 }