cli-wechat-bridge 1.1.1 → 1.1.3

package/dist/bridge/wechat-bridge.js

@@ -46,7 +46,7 @@ export function formatUserFacingBridgeFatalError(message) {
     return `Bridge error: ${message.replace(/\s+Recent app-server log:.*$/s, "").trim()}`;
 }
 export function shouldForwardBridgeEventToWechat(adapter, eventType, options = {}) {
-    if (adapter !== "opencode") {
+    if (adapter !== "opencode" && adapter !== "pi") {
         return true;
     }
     switch (eventType) {
@@ -55,7 +55,7 @@ export function shouldForwardBridgeEventToWechat(adapter, eventType, options = {
         case "thread_switched":
             return false;
         case "notice":
-            return /^OpenCode local draft:\s*/i.test(options.text ?? "");
+            return adapter === "pi" || /^OpenCode local draft:\s*/i.test(options.text ?? "");
         case "mirrored_user_input":
             return true;
         default:
@@ -159,7 +159,7 @@ export function parseCliArgs(argv) {
         const next = argv[i + 1];
         switch (arg) {
             case "--adapter":
-                if (!next || !["codex", "claude", "opencode", "shell"].includes(next)) {
+                if (!next || !["codex", "claude", "opencode", "pi", "shell"].includes(next)) {
                     throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
                 }
                 adapter = next;
@@ -212,7 +212,7 @@ export function parseCliArgs(argv) {
         }
     }
     if (!adapter) {
-        throw new Error("Missing required --adapter <codex|claude|opencode|shell>");
+        throw new Error("Missing required --adapter <codex|claude|opencode|pi|shell>");
     }
     const defaultCommand = resolveDefaultAdapterCommand(adapter);
     return {
@@ -226,12 +226,13 @@ export function parseCliArgs(argv) {
 }
 function printUsageAndExit() {
     process.stdout.write([
-        "Usage: wechat-bridge --adapter <codex|claude|opencode|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
+        "Usage: wechat-bridge --adapter <codex|claude|opencode|pi|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
         "",
         "Examples:",
         "  wechat-bridge-codex",
         "  wechat-bridge-claude --cwd ~/work/my-project",
         "  wechat-bridge-opencode --cwd ~/work/my-project",
+        "  wechat-bridge-pi --cwd ~/work/my-project",
         "  wechat-bridge-shell --cmd pwsh   # headless shell executor for non-interactive commands/scripts",
         "  wechat-bridge-shell --cmd bash   # headless shell executor for non-interactive commands/scripts",
         "  wechat-bridge-codex --lifecycle companion_bound",
@@ -266,7 +267,9 @@ async function main() {
     }
     const transport = new WeChatTransport({ log, logError });
     // 非阻塞地检查更新（不影响启动速度，也避免首次登录时打断二维码输出）
-    setTimeout(async () => {
+    // unref：不能让这个延迟检查把 event loop 挂活（如 --doctor 或快速退出场景），
+    // 否则会与强制退出 teardown 竞态。
+    const updateCheckTimer = setTimeout(async () => {
         try {
             const versionInfo = await checkForUpdate();
             if (versionInfo?.hasUpdate) {
@@ -277,6 +280,7 @@ async function main() {
             // 静默失败，不影响正常使用
         }
     }, 3000); // 延迟3秒，确保不影响启动
+    updateCheckTimer.unref?.();
     const stateStore = new BridgeStateStore({
         ...options,
         authorizedUserId: credentials.userId,
@@ -338,6 +342,7 @@ async function main() {
     let lastOutputAt = 0;
     let lastHeartbeatAt = 0;
     let consecutivePollFailures = 0;
+    let backlogNoticeSent = false;
     const queueWechatTextAction = (action) => {
         const run = textSendChain.then(action);
         textSendChain = run.then(() => undefined, () => undefined);
@@ -661,6 +666,13 @@ async function main() {
             if (pollResult.ignoredBacklogCount > 0) {
                 stateStore.incrementIgnoredBacklog(pollResult.ignoredBacklogCount);
                 stateStore.appendLog(`ignored_startup_backlog: count=${pollResult.ignoredBacklogCount}`);
+                if (!backlogNoticeSent) {
+                    backlogNoticeSent = true;
+                    await queueWechatMessage(stateStore.getState().authorizedUserId, t("bridge.backlogIgnored", {
+                        count: pollResult.ignoredBacklogCount,
+                        graceSeconds: Math.round(MESSAGE_START_GRACE_MS / 1000),
+                    }), "notice");
+                }
             }
             for (const message of pollResult.messages) {
                 if (!ensureRuntimeOwnership()) {
@@ -1111,9 +1123,9 @@ async function handleInboundMessage(params) {
         return null;
     }
     if (adapterState.status === "busy") {
-        if ((options.adapter === "codex" || options.adapter === "opencode") &&
+        if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
             adapterState.activeTurnOrigin === "local") {
-            await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
+            await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
             return null;
         }
         await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);

package/dist/commands/check-update.js

@@ -7,12 +7,23 @@ async function main() {
     console.log(`Checking for updates...`);
     const versionInfo = await checkForUpdate(true); // 强制检查
     if (!versionInfo) {
-        console.log(`ERROR: Unable to check for updates, please check your network connection`);
-        process.exit(1);
+        console.error(`ERROR: Unable to check for updates.`);
+        console.error(`Could not read the latest version from the npm registry or GitHub.`);
+        console.error(`Possible causes:`);
+        console.error(`  - No network connection`);
+        console.error(`  - A proxy is required but not configured (set HTTP_PROXY/HTTPS_PROXY and NODE_USE_ENV_PROXY=1)`);
+        console.error(`  - The npm registry or GitHub API are temporarily unavailable`);
+        console.error(`\nCheck the latest release manually:`);
+        console.error(`  https://github.com/UNLINEARITY/CLI-WeChat-Bridge/releases`);
+        // 不使用 process.exit():强制退出会打断 fetch 底层 handle 的关闭流程,
+        // 在 Windows + Node 24 上触发 libuv 的 UV_HANDLE_CLOSING 断言崩溃。
+        // 设置 exitCode 后让事件循环自然退出。
+        process.exitCode = 1;
+        return;
     }
     if (!versionInfo.hasUpdate) {
         console.log(`OK: Already up to date (v${versionInfo.latest})`);
-        process.exit(0);
+        return;
     }
     console.log(`[New Version Available] v${versionInfo.latest}`);
     console.log(`Current version: v${versionInfo.current}\n`);
@@ -26,5 +37,5 @@ async function main() {
 }
 main().catch((error) => {
     console.error(`Error checking for updates: ${error.message}`);
-    process.exit(1);
+    process.exitCode = 1;
 });

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

@@ -7,7 +7,11 @@ function normalizeEndpoint(value) {
         return null;
     }
     const record = value;
-    const kind = record.kind === "codex" || record.kind === "claude" || record.kind === "opencode" || record.kind === "shell"
+    const kind = record.kind === "codex" ||
+        record.kind === "claude" ||
+        record.kind === "opencode" ||
+        record.kind === "pi" ||
+        record.kind === "shell"
         ? record.kind
         : "codex";
     const sharedSessionId = typeof record.sharedSessionId === "string"
@@ -118,6 +122,7 @@ export function clearLocalCompanionEndpoint(cwd, instanceId, options = {}) {
                 getWorkspaceAdapterEndpointFile(cwd, "codex"),
                 getWorkspaceAdapterEndpointFile(cwd, "claude"),
                 getWorkspaceAdapterEndpointFile(cwd, "opencode"),
+                getWorkspaceAdapterEndpointFile(cwd, "pi"),
                 getWorkspaceAdapterEndpointFile(cwd, "shell"),
             ];
         for (const filePath of files) {

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

@@ -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,9 @@ export function decideLaunchAction(input) {
         };
     }
     if (input.sessionStartMode === "new" &&
-        (input.requestedAdapter === "claude" || input.requestedAdapter === "opencode")) {
+        (input.requestedAdapter === "claude" ||
+            input.requestedAdapter === "opencode" ||
+            input.requestedAdapter === "pi")) {
         return {
             kind: "start_bridge",
             message: `Starting a fresh ${input.requestedAdapter} session for ${input.requestedCwd}...`,
@@ -95,6 +97,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];
@@ -107,10 +110,12 @@ export function parseCliArgs(argv) {
                 "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]",
+                "       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]",
                 "",
                 "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.",
+                "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.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
@@ -118,7 +123,7 @@ export function parseCliArgs(argv) {
             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;
@@ -153,6 +158,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 +173,7 @@ export function parseCliArgs(argv) {
         cwd,
         profile,
         timeoutMs,
-        sessionStartMode: defaultSessionStartMode(adapter),
+        sessionStartMode: sessionStartMode ?? defaultSessionStartMode(adapter),
         cliArgs,
     };
 }
@@ -203,7 +216,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 {
@@ -283,6 +299,11 @@ function startBridgeInBackground(options) {
         stdio: "ignore",
         windowsHide: true,
     });
+    // A detached background spawn must still handle its own 'error' event
+    // (e.g. ENOENT), otherwise it surfaces as an unhandled exception.
+    child.on("error", () => {
+        /* best effort: background bridge failed to detach */
+    });
     child.unref();
 }
 async function waitForEndpoint(cwd, adapter, timeoutMs) {
@@ -378,7 +399,7 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         cliArgs: options.cliArgs,
         openVisible: true,
         sessionStartMode: options.sessionStartMode,
-        reuseExistingVisible: true,
+        reuseExistingVisible: options.adapter !== "pi" || options.sessionStartMode !== "new",
     });
     if (!response.ok) {
         throw new Error(response.error);

package/dist/companion/local-companion.js

@@ -23,7 +23,7 @@ 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]",
+                "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.',
                 "Unknown arguments are forwarded to the visible CLI client.",
@@ -32,7 +32,7 @@ function parseCliArgs(argv) {
             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 };
 }

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" });
+    });
+}