@unlinearity/cli-wechat-bridge 1.1.3 → 1.1.5

package/dist/daemon/wechat-daemon.js

@@ -12,7 +12,8 @@ import { forwardWechatFinalReply } from "../bridge/bridge-final-reply.js";
 import { readBridgeLockFile, } from "../bridge/bridge-state.js";
 import { getProcessRecordByPid, isWechatDaemonCommandLine, killProcessTreeSync, listWechatDaemonProcesses, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "../bridge/bridge-process-reaper.js";
 import { buildOneTimeCode, buildWechatInboundPrompt, formatApprovalMessage, formatDuration, formatMirroredUserInputMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatSessionSwitchMessage, formatTaskFailedMessage, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "../bridge/bridge-utils.js";
-import { formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/wechat-bridge.js";
+import { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "../bridge/bridge-session-resume.js";
+import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/wechat-forwarding.js";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureChannelDataDir, migrateLegacyChannelFiles, } from "../wechat/channel-config.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix, listBindings, loadEmojiBindings, parseEmojiBindingsCommand, removeBinding, resolveEmojiCommand, setBinding, } from "./emoji-bindings.js";
@@ -26,8 +27,6 @@ const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".
 const DAEMON_HOST = "127.0.0.1";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
-const WECHAT_SEND_MAX_ATTEMPTS = 3;
-const WECHAT_SEND_RETRY_BASE_MS = 750;
 const SINGLE_BRIDGE_STOP_TIMEOUT_MS = 10_000;
 const SINGLE_BRIDGE_FORCE_STOP_TIMEOUT_MS = 3_000;
 const SINGLE_BRIDGE_STOP_POLL_MS = 250;
@@ -52,9 +51,6 @@ function computePollRetryDelayMs(consecutiveFailures) {
     const exponent = Math.min(normalizedFailures - 1, 5);
     return Math.min(POLL_RETRY_MAX_MS, POLL_RETRY_BASE_MS * 2 ** exponent);
 }
-function computeWechatSendRetryDelayMs(attempt) {
-    return WECHAT_SEND_RETRY_BASE_MS * attempt;
-}
 function isDaemonAdapterKind(value) {
     return value === "codex" || value === "claude" || value === "opencode" || value === "pi";
 }
@@ -155,12 +151,16 @@ export function defaultDaemonSessionStartMode(adapter) {
     return adapter === "codex" ? "restore" : "new";
 }
 export function resolveDaemonSessionStartMode(params) {
-    if (params.reuseExistingVisible && params.visibleConnected) {
-        return "restore";
-    }
+    // An explicit --session-start-mode wins over visible-client reuse: the user
+    // asked for a fresh (or restored) session on purpose, so silently degrading
+    // "new" back to "restore" because a window happens to be connected would
+    // ignore the request.
     if (params.explicitSessionStartMode) {
         return params.explicitSessionStartMode;
     }
+    if (params.reuseExistingVisible && params.visibleConnected) {
+        return "restore";
+    }
     if (params.adapter === "codex") {
         return "restore";
     }
@@ -483,6 +483,8 @@ class WechatDaemon {
     authorizedUserId;
     transport;
     slots = new Map();
+    // Per-adapter serialization chains for ensureSlot (see ensureSlot comment).
+    slotEnsureChains = new Map();
     startedAt = new Date().toISOString();
     bridgeStartedAtMs = Date.now();
     backlogNoticeSent = false;
@@ -638,14 +640,12 @@ class WechatDaemon {
                 }
                 catch (error) {
                     const errorText = error instanceof Error ? error.message : String(error);
-                    const isUserFacingShellRejection = error instanceof Error && error.name === "ShellCommandRejectedError";
                     logError(errorText);
-                    appendDaemonLog(`${isUserFacingShellRejection ? "inbound_rejected" : "inbound_error"}: ${errorText}`);
+                    appendDaemonLog(`inbound_error: ${errorText}`);
                     await this.queueWechatMessage(message.senderId, formatUserFacingInboundError({
                         adapter: this.activeAdapter ?? "codex",
                         cwd: this.cwd,
                         errorText,
-                        isUserFacingShellRejection,
                     }), "inbound_error");
                 }
             }
@@ -657,6 +657,32 @@ class WechatDaemon {
         }
         await this.shutdownPromise;
     }
+    /**
+     * Remove a slot whose runtime reported a fatal (terminal) error. The dead
+     * runtime would otherwise stay in the slot map forever: every later message
+     * would fail against it ("adapter is not running") with no path back to a
+     * working adapter short of a manual /reset or daemon restart. After removal,
+     * the next switch directive (/codex etc.) rebuilds the adapter from scratch.
+     */
+    disposeDeadSlot(slot) {
+        if (this.slots.get(slot.adapter) !== slot) {
+            return; // Already replaced by a newer ensureSlot run.
+        }
+        this.slots.delete(slot.adapter);
+        if (this.activeAdapter === slot.adapter) {
+            this.activeAdapter = null;
+        }
+        appendDaemonLog(`dead_slot_disposed: adapter=${slot.adapter}`);
+        void (async () => {
+            try {
+                await slot.runtime.dispose();
+            }
+            catch {
+                // Best effort: the runtime already reported a fatal error.
+            }
+            slot.controller.clearLocalClientEndpoint();
+        })();
+    }
     async cleanup() {
         appendDaemonLog("shutdown_started");
         for (const slot of this.slots.values()) {
@@ -721,6 +747,19 @@ class WechatDaemon {
         }
     }
     async ensureSlot(adapter, options = {}) {
+        // Serialize per-adapter ensureSlot runs. The IPC handler, the WeChat poll
+        // loop, and startup can all call this concurrently; without serialization
+        // two callers would both observe an empty slot map, create two runtimes,
+        // and the second slots.set would orphan the first (duplicate PTY child,
+        // double visible client, endpoint files overwriting each other).
+        const tail = this.slotEnsureChains.get(adapter) ?? Promise.resolve();
+        const run = tail.then(() => this.runEnsureSlot(adapter, options), 
+        // A rejected predecessor must not block this run — start fresh either way.
+        () => this.runEnsureSlot(adapter, options));
+        this.slotEnsureChains.set(adapter, run.then(() => undefined, () => undefined));
+        return run;
+    }
+    async runEnsureSlot(adapter, options = {}) {
         const previousActiveAdapter = this.activeAdapter ?? undefined;
         let slot = this.slots.get(adapter);
         let created = false;
@@ -765,7 +804,8 @@ class WechatDaemon {
             reuseExistingVisible: options.reuseExistingVisible !== false,
         });
         if (!created &&
-            options.reuseExistingVisible === false &&
+            (options.reuseExistingVisible === false ||
+                options.sessionStartMode === "new") &&
             sessionStartMode === "new" &&
             (adapter === "claude" || adapter === "opencode" || adapter === "pi") &&
             visibleConnected) {
@@ -853,6 +893,10 @@ class WechatDaemon {
             }),
             pendingConfirmations: [],
             pendingUserInput: null,
+            resumeCoordinator: new ResumeSessionCoordinator({
+                adapter,
+                runtime,
+            }),
             activeTask: null,
             lastOutputAt: 0,
         };
@@ -952,14 +996,19 @@ class WechatDaemon {
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatApprovalMessage(pending, adapterState)), "approval_required");
                 }));
                 break;
-            case "user_input_required":
+            case "user_input_required": {
+                // Mirror the pending request synchronously, before the async WeChat
+                // send (which retries with backoff). Otherwise a fast user reply can
+                // race past the still-unwritten mirror and be dispatched as plain
+                // input into a CLI that is waiting for a structured form answer.
+                const pending = toPendingUserInput(event.request);
+                slot.pendingUserInput = pending;
+                appendDaemonLog(`user_input_required: adapter=${slot.adapter} questions=${pending.questions.length}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                    const pending = toPendingUserInput(event.request);
-                    slot.pendingUserInput = pending;
-                    appendDaemonLog(`user_input_required: adapter=${slot.adapter} questions=${pending.questions.length}`);
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserInputRequestMessage(pending, adapterState)), "user_input_required");
                 }));
                 break;
+            }
             case "mirrored_user_input":
                 appendDaemonLog(`mirrored_local_input: adapter=${slot.adapter} text=${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(slot.adapter, event.type, { text: event.text })) {
@@ -969,8 +1018,12 @@ class WechatDaemon {
                 }
                 break;
             case "session_switched":
+                if (event.source === "local") {
+                    slot.resumeCoordinator.clear();
+                }
                 appendDaemonLog(`session_switched: adapter=${slot.adapter} session=${event.sessionId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(event.reason) &&
+                    shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
                     this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                         await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatSessionSwitchMessage({
                             adapter: slot.adapter,
@@ -982,8 +1035,12 @@ class WechatDaemon {
                 }
                 break;
             case "thread_switched":
+                if (event.source === "local") {
+                    slot.resumeCoordinator.clear();
+                }
                 appendDaemonLog(`thread_switched: adapter=${slot.adapter} thread=${event.threadId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(event.reason) &&
+                    shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
                     this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                         await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatSessionSwitchMessage({
                             adapter: slot.adapter,
@@ -1015,6 +1072,7 @@ class WechatDaemon {
                 slot.pendingConfirmations = [];
                 slot.pendingUserInput = null;
                 slot.activeTask = null;
+                this.disposeDeadSlot(slot);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserFacingBridgeFatalError(event.message)), "fatal_error");
                 }));
@@ -1120,6 +1178,15 @@ class WechatDaemon {
         }
         slot = this.getActiveSlot() ?? slot;
         const adapterState = slot.runtime.getState();
+        if (adapterState.status === "awaiting_input") {
+            // Belt-and-braces with the pendingUserInput mirror above: the adapter
+            // state is authoritative even when the mirror was cleared or the WeChat
+            // notification is still queued.
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, slot.pendingUserInput
+                ? formatPendingUserInputReminder(slot.pendingUserInput)
+                : `${slot.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`));
+            return;
+        }
         if (adapterState.status === "busy" || adapterState.status === "awaiting_approval") {
             await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`));
             return;
@@ -1151,9 +1218,37 @@ class WechatDaemon {
             case "status":
                 await this.queueWechatMessage(message.senderId, formatDaemonStatus(this.getStatus()));
                 return;
-            case "resume":
-                await this.queueWechatMessage(message.senderId, `WeChat /resume is disabled in daemon mode. Use /resume directly inside the visible ${activeSlot.adapter} terminal; WeChat will follow that local session.`);
+            case "resume": {
+                if (!isWechatResumeEnabled(activeSlot.adapter)) {
+                    await this.queueWechatMessage(message.senderId, `WeChat /resume is disabled for ${activeSlot.adapter} in daemon mode. Use /resume directly inside the visible terminal; WeChat will follow that local session.`);
+                    return;
+                }
+                try {
+                    let resumeSlot = activeSlot;
+                    if (activeSlot.adapter === "codex" && command.target) {
+                        const visible = await this.ensureSlot("codex", {
+                            openVisible: true,
+                            reuseExistingVisible: true,
+                        });
+                        if (!visible.activated) {
+                            throw new Error(formatDaemonSwitchResultDetail(visible));
+                        }
+                        resumeSlot = this.slots.get("codex") ?? activeSlot;
+                    }
+                    if (command.target) {
+                        await resumeSlot.outputBatcher.flushNow();
+                    }
+                    const result = await resumeSlot.resumeCoordinator.execute(command.target);
+                    if (result.kind === "resumed") {
+                        resumeSlot.activeTask = null;
+                    }
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(resumeSlot.adapter, result.message));
+                }
+                catch (error) {
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, error instanceof Error ? error.message : String(error)));
+                }
                 return;
+            }
             case "new_session":
                 if (!activeSlot.runtime.createSession) {
                     await this.queueWechatMessage(message.senderId, `/new is not available in ${activeSlot.adapter} mode.`);
@@ -1163,6 +1258,7 @@ class WechatDaemon {
                 activeSlot.outputBatcher.clear();
                 activeSlot.pendingConfirmations = [];
                 activeSlot.pendingUserInput = null;
+                activeSlot.resumeCoordinator.clear();
                 await activeSlot.runtime.createSession();
                 appendDaemonLog(`new_session: adapter=${activeSlot.adapter}`);
                 return;
@@ -1178,6 +1274,7 @@ class WechatDaemon {
                 activeSlot.outputBatcher.clear();
                 activeSlot.pendingConfirmations = [];
                 activeSlot.pendingUserInput = null;
+                activeSlot.resumeCoordinator.clear();
                 await activeSlot.runtime.reset();
                 appendDaemonLog(`reset: adapter=${activeSlot.adapter}`);
                 await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "Worker session has been reset."));
@@ -1231,28 +1328,42 @@ class WechatDaemon {
         await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, count > 1 ? `${count} approvals denied.` : "Approval denied."));
     }
     async answerPendingUserInput(message, activeSlot, raw) {
-        const pending = activeSlot.pendingUserInput;
+        // Mirror the /confirm and /deny behavior: search every slot for a pending
+        // user-input request so the answer reaches the adapter that asked, even
+        // when the user has since switched the active adapter.
+        const slot = this.resolvePendingUserInputSlot(activeSlot);
+        if (!slot) {
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "No pending user input request."));
+            return;
+        }
+        const pending = slot.pendingUserInput;
         if (!pending) {
             await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "No pending user input request."));
             return;
         }
         const parsed = parsePendingUserInputAnswerCommand(raw, pending);
         if ("error" in parsed) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, parsed.error));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, parsed.error));
             return;
         }
-        const submitted = await activeSlot.runtime.submitUserInput(parsed.answers);
+        const submitted = await slot.runtime.submitUserInput(parsed.answers);
         if (!submitted) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "The worker could not apply this answer."));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "The worker could not apply this answer."));
             return;
         }
-        activeSlot.pendingUserInput = null;
-        activeSlot.activeTask = {
+        slot.pendingUserInput = null;
+        slot.activeTask = {
             startedAt: Date.now(),
             inputPreview: parsed.preview,
         };
-        appendDaemonLog(`user_input_answered: adapter=${activeSlot.adapter} preview=${parsed.preview}`);
-        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "Answer submitted. Continuing..."));
+        appendDaemonLog(`user_input_answered: adapter=${slot.adapter} preview=${parsed.preview}`);
+        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "Answer submitted. Continuing..."));
+    }
+    resolvePendingUserInputSlot(activeSlot) {
+        if (activeSlot.pendingUserInput) {
+            return activeSlot;
+        }
+        return (Array.from(this.slots.values()).find((slot) => slot.pendingUserInput !== null) ?? null);
     }
     resolvePendingApprovalSlot(activeSlot) {
         if (activeSlot.pendingConfirmations.length > 0) {
@@ -1260,13 +1371,6 @@ class WechatDaemon {
         }
         return (Array.from(this.slots.values()).find((slot) => slot.pendingConfirmations.length > 0) ?? null);
     }
-    countPendingApprovals() {
-        let count = 0;
-        for (const slot of this.slots.values()) {
-            count += slot.pendingConfirmations.length;
-        }
-        return count;
-    }
     getActiveSlot() {
         if (!this.activeAdapter) {
             return null;
@@ -1658,27 +1762,35 @@ export async function runDaemon(options) {
         daemon.takenOverAdapter = cleanupResult.lock.adapter;
     }
     await daemon.startIpcServer();
-    await daemon.runInitialAdapter(options);
-    let shutdownInProgress = false;
-    const handleSignal = (signal) => {
-        if (shutdownInProgress) {
-            log(`Received ${signal} during shutdown, forcing exit.`);
-            process.exit(1);
-        }
-        shutdownInProgress = true;
-        log(`Received ${signal}. Stopping daemon.`);
-        void daemon.shutdown().finally(() => process.exit(0));
-    };
-    process.on("SIGINT", () => handleSignal("SIGINT"));
-    process.on("SIGTERM", () => handleSignal("SIGTERM"));
-    process.on("SIGHUP", () => handleSignal("SIGHUP"));
-    if (process.platform === "win32") {
-        process.on("SIGBREAK", () => handleSignal("SIGBREAK"));
+    try {
+        await daemon.runInitialAdapter(options);
+        let shutdownInProgress = false;
+        const handleSignal = (signal) => {
+            if (shutdownInProgress) {
+                log(`Received ${signal} during shutdown, forcing exit.`);
+                process.exit(1);
+            }
+            shutdownInProgress = true;
+            log(`Received ${signal}. Stopping daemon.`);
+            void daemon.shutdown().finally(() => process.exit(0));
+        };
+        process.on("SIGINT", () => handleSignal("SIGINT"));
+        process.on("SIGTERM", () => handleSignal("SIGTERM"));
+        process.on("SIGHUP", () => handleSignal("SIGHUP"));
+        if (process.platform === "win32") {
+            process.on("SIGBREAK", () => handleSignal("SIGBREAK"));
+        }
+        process.on("exit", () => {
+            clearDaemonEndpoint();
+        });
+        await daemon.runPollLoop();
+    }
+    catch (error) {
+        // Abnormal exit (poll loop failure, initial adapter failure): dispose the
+        // slot runtimes so adapter child processes are not stranded as orphans.
+        await daemon.shutdown().catch(() => undefined);
+        throw error;
     }
-    process.on("exit", () => {
-        clearDaemonEndpoint();
-    });
-    await daemon.runPollLoop();
 }
 export async function main(argv = process.argv.slice(2)) {
     if (argv.includes("--doctor")) {

package/dist/i18n/index.js

@@ -5,9 +5,6 @@ const catalogs = {
     en: enMessages,
 };
 let currentLocale = "zh";
-export function getLocale() {
-    return currentLocale;
-}
 export function setLocale(locale) {
     currentLocale = locale;
 }

package/dist/i18n/messages-en.js

@@ -1,6 +1,6 @@
 export const messages = {
     // === Bridge welcome & control ===
-    "bridge.welcome": "WeChat Bridge ready ({adapter}).\nCWD: {cwd}\n\nCommands: /stop, /confirm, /deny, /status, /new\n{bindings}\n\nManage: /bind [emoji] cmd, /unbind [emoji], /bindings",
+    "bridge.welcome": "WeChat Bridge ready ({adapter}).\nCWD: {cwd}",
     "bridge.stopped": "Bridge stopped.",
     "bridge.interrupt.sent": "Interrupt signal sent.",
     "bridge.interrupt.notBusy": "No active task to interrupt.",
@@ -66,7 +66,6 @@ export const messages = {
     "doctor.clock.ok": "~{skewSeconds}s skew vs server time",
     "doctor.clock.skewWarning": "~{skewSeconds}s skew vs server time (large skew makes the bridge treat fresh messages as pre-start backlog — sync the system clock)",
     "doctor.label.nodePty": "node-pty",
-    "doctor.label.shell": "shell",
     "doctor.label.dataDir": "Data dir",
     "doctor.label.credentials": "Credentials",
     "doctor.label.mode": "Mode",
@@ -79,7 +78,6 @@ export const messages = {
     "doctor.winBuildConpty": "(ConPTY requires build 18309+)",
     "doctor.nodePty.loaded": "loaded",
     "doctor.nodePty.fix": "Fix: {fix}",
-    "doctor.adapterCli.shellNative": "uses the local shell; no other adapter CLI is checked.",
     "doctor.adapterCli.notFound": "not found{optional}",
     "doctor.dataDirMissing": "(will be created on first run)",
     "doctor.credentialsFound": "found",
@@ -88,6 +86,7 @@ export const messages = {
     "doctor.mode.generic": "generic",
     "doctor.notSpecified": "(not specified)",
     "doctor.none": "none",
+    "doctor.endpoint.corrupted": "endpoint file exists but cannot be parsed; it will be replaced on the next successful write",
     "doctor.unknown": "unknown",
     "doctor.yes": "yes",
     "doctor.no": "no",

package/dist/i18n/messages-zh.js

@@ -1,6 +1,6 @@
 export const messages = {
     // === 桥接欢迎 & 控制 ===
-    "bridge.welcome": "微信桥接就绪 ({adapter})。\n工作目录: {cwd}\n\n命令: /stop, /confirm, /deny, /status, /new\n{bindings}\n\n管理: /bind [表情] 命令, /unbind [表情], /bindings",
+    "bridge.welcome": "微信桥接就绪 ({adapter})。\n工作目录: {cwd}",
     "bridge.stopped": "桥接已停止。",
     "bridge.interrupt.sent": "已发送中断信号。",
     "bridge.interrupt.notBusy": "没有正在执行的任务可中断。",
@@ -66,7 +66,6 @@ export const messages = {
     "doctor.clock.ok": "与服务器时间偏差约 {skewSeconds}s",
     "doctor.clock.skewWarning": "与服务器时间偏差约 {skewSeconds}s（偏差过大会导致桥接启动后的消息被当作积压忽略，请校准系统时间）",
     "doctor.label.nodePty": "node-pty",
-    "doctor.label.shell": "shell",
     "doctor.label.dataDir": "数据目录",
     "doctor.label.credentials": "凭据",
     "doctor.label.mode": "模式",
@@ -79,7 +78,6 @@ export const messages = {
     "doctor.winBuildConpty": "(ConPTY 需要 build 18309+)",
     "doctor.nodePty.loaded": "已加载",
     "doctor.nodePty.fix": "修复: {fix}",
-    "doctor.adapterCli.shellNative": "使用本机 shell，无需检查其它适配器 CLI。",
     "doctor.adapterCli.notFound": "未找到{optional}",
     "doctor.dataDirMissing": "(首次运行会创建)",
     "doctor.credentialsFound": "已找到",
@@ -88,6 +86,7 @@ export const messages = {
     "doctor.mode.generic": "通用",
     "doctor.notSpecified": "(未指定)",
     "doctor.none": "无",
+    "doctor.endpoint.corrupted": "endpoint 文件存在但无法解析；下次成功写入时将被替换",
     "doctor.unknown": "未知",
     "doctor.yes": "是",
     "doctor.no": "否",

package/dist/utils/atomic-file.js

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+import { ensureChannelDataDir } from "../wechat/channel-config.js";
+/**
+ * Write JSON atomically via temp file + rename, so a crash mid-write cannot
+ * leave a truncated or half-written file behind. Cross-process readers (the
+ * daemon, launchers, companions) either see the previous complete file or the
+ * new complete file — never a torn write.
+ */
+export function writeJsonFileAtomic(filePath, value) {
+    ensureChannelDataDir();
+    const data = JSON.stringify(value, null, 2);
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tempPath, data, "utf-8");
+    fs.renameSync(tempPath, filePath);
+}

package/dist/utils/doctor.js

@@ -7,7 +7,7 @@ import { normalizeBridgeLockPayload, shouldAutoReclaimBridgeLock, } from "../bri
 import { readLocalCompanionEndpoint as readWorkspaceEndpoint, } from "../companion/local-companion-link.js";
 import { isDaemonEndpointAlive, } from "../daemon/daemon-link.js";
 import { t } from "../i18n/index.js";
-import { DEFAULT_BASE_URL, resolveChannelDataDir } from "../wechat/channel-config.js";
+import { DEFAULT_BASE_URL, getWorkspaceAdapterEndpointFile, getWorkspaceChannelPaths, resolveChannelDataDir, } from "../wechat/channel-config.js";
 const STATE_OK = "[ok]";
 const STATE_WARN = "[warn]";
 const STATE_FAIL = "[fail]";
@@ -174,8 +174,7 @@ function isBridgeAdapterKind(value) {
     return (value === "codex" ||
         value === "claude" ||
         value === "opencode" ||
-        value === "pi" ||
-        value === "shell");
+        value === "pi");
 }
 export function parseDoctorCliArgs(argv, mode = "generic", fallbackCwd = process.cwd()) {
     let cwd = fallbackCwd;
@@ -417,8 +416,6 @@ function chooseCliChecks(options) {
                 return [{ name: "opencode", label: "OpenCode", optional: false }];
             case "pi":
                 return [{ name: "pi", label: "Pi", optional: false }];
-            case "shell":
-                return [];
             default:
                 return [];
         }
@@ -432,11 +429,6 @@ function chooseCliChecks(options) {
 }
 function appendCliLines(lines, options, deps) {
     const clis = chooseCliChecks(options);
-    if (options.mode === "bridge" && options.adapter === "shell") {
-        section(lines, msg("section.adapterCli"));
-        lines.push(row(STATE_OK, msg("label.shell"), msg("adapterCli.shellNative")));
-        return;
-    }
     if (clis.length === 0) {
         return;
     }
@@ -519,6 +511,18 @@ async function appendEndpointSummary(lines, label, endpoint, options, lock, deps
         lines.push(detail(msg("issue", { issue })));
     }
 }
+function endpointFileState(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return "missing";
+    }
+    try {
+        JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return "readable";
+    }
+    catch {
+        return "corrupted";
+    }
+}
 async function appendWorkspaceEndpointLines(lines, options, lock, deps) {
     const adapters = chooseEndpointAdapters(options, lock);
     const seenEndpoints = new Set();
@@ -527,12 +531,20 @@ async function appendWorkspaceEndpointLines(lines, options, lock, deps) {
         if (endpoint) {
             seenEndpoints.add(`${endpoint.kind}:${endpoint.instanceId}:${endpoint.port}`);
         }
+        else if (endpointFileState(getWorkspaceAdapterEndpointFile(options.cwd, adapter)) ===
+            "corrupted") {
+            // A torn or otherwise unparsable endpoint file must not read as a
+            // healthy "none" — surface it so the operator knows to clear it.
+            lines.push(row(STATE_WARN, msg("label.workspaceEndpoint", { adapter }), msg("endpoint.corrupted")));
+            continue;
+        }
         await appendEndpointSummary(lines, msg("label.workspaceEndpoint", { adapter }), endpoint, { ...options, adapter }, lock, deps);
     }
     const legacyEndpoint = deps.readLocalCompanionEndpoint(options.cwd);
     const legacyLabel = msg("label.legacyEndpoint");
     if (!legacyEndpoint) {
-        lines.push(row(STATE_OK, legacyLabel, msg("none")));
+        const legacyFileState = endpointFileState(getWorkspaceChannelPaths(options.cwd).endpointFile);
+        lines.push(row(legacyFileState === "corrupted" ? STATE_WARN : STATE_OK, legacyLabel, legacyFileState === "corrupted" ? msg("endpoint.corrupted") : msg("none")));
         return;
     }
     const legacyKey = `${legacyEndpoint.kind}:${legacyEndpoint.instanceId}:${legacyEndpoint.port}`;

package/dist/wechat/channel-config.js

@@ -16,7 +16,6 @@ export const CHANNEL_DATA_DIR = resolveChannelDataDir();
 export const CREDENTIALS_FILE = path.join(CHANNEL_DATA_DIR, "account.json");
 export const SYNC_BUF_FILE = path.join(CHANNEL_DATA_DIR, "sync_buf.txt");
 export const CONTEXT_CACHE_FILE = path.join(CHANNEL_DATA_DIR, "context_tokens.json");
-export const BRIDGE_STATE_FILE = path.join(CHANNEL_DATA_DIR, "bridge-state.json");
 export const BRIDGE_LOG_FILE = path.join(CHANNEL_DATA_DIR, "bridge.log");
 // Hard cap for bridge.log. Long-running daemons otherwise grow it without bound.
 export const BRIDGE_LOG_MAX_BYTES = 5 * 1024 * 1024; // 5 MiB
@@ -48,7 +47,6 @@ export function appendBoundedLog(filePath, line) {
 }
 export const BRIDGE_LOCK_FILE = path.join(CHANNEL_DATA_DIR, "bridge.lock.json");
 export const DAEMON_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "daemon-endpoint.json");
-export const CODEX_PANEL_ENDPOINT_FILE = path.join(CHANNEL_DATA_DIR, "codex-panel-endpoint.json");
 export const WORKSPACES_DIR = path.join(CHANNEL_DATA_DIR, "workspaces");
 export const INBOUND_MESSAGE_CLAIMS_DIR = path.join(CHANNEL_DATA_DIR, "inbound-message-claims");
 export const INBOUND_ATTACHMENTS_DIR = path.join(CHANNEL_DATA_DIR, "inbound-attachments");

package/dist/wechat/setup.js

@@ -166,17 +166,11 @@ function printPostLoginHelp(log) {
     log("This WeChat account is now authorized for the bridge.");
     log("");
     log("Start from any project directory with one of:");
-    log("  wechat-codex-start");
-    log("  wechat-claude-start");
-    log("  wechat-opencode-start");
-    log("  wechat-pi-start");
-    log("  wechat-bridge-shell");
-    log("");
-    log("Manual two-terminal mode is also available:");
-    log("  wechat-bridge-codex  +  wechat-codex");
-    log("  wechat-bridge-claude +  wechat-claude");
-    log("  wechat-bridge-opencode + wechat-opencode");
-    log("  wechat-bridge-pi + wechat-pi");
+    log("  wechat-codex");
+    log("  wechat-claude");
+    log("  wechat-opencode");
+    log("  wechat-pi");
+    log("  wechat-daemon");
     log("");
     log("Run wechat-setup again any time you need to refresh the login.");
 }