@unlinearity/cli-wechat-bridge 1.0.3 → 1.0.4

package/dist/bridge/bridge-adapters.shared.js

@@ -8,6 +8,8 @@ import { attachLocalCompanionMessageListener, buildLocalCompanionToken, clearLoc
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { buildClaudeFailureMessage, buildClaudeHookSettings, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeResumeConversationId, findInjectedClaudePromptIndex, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.js";
 import { detectCliApproval, isHighRiskShellCommand, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { coerceWebSocketMessageData, describeUnknownError, getCodexRpcRequestId, getLocalCompanionCommandName, getNotificationThreadId, getNotificationTurnId, getSharedSessionIdFromAdapterState, isRecentIsoTimestamp, isRecord, normalizeCodexRpcError, quotePosixCommandArg, quoteWindowsCommandArg, } from "./bridge-adapter-common.js";
+export { coerceWebSocketMessageData, describeUnknownError, getCodexRpcRequestId, getLocalCompanionCommandName, getNotificationThreadId, getNotificationTurnId, getSharedSessionIdFromAdapterState, isRecentIsoTimestamp, isRecord, normalizeCodexRpcError, quotePosixCommandArg, quoteWindowsCommandArg, } from "./bridge-adapter-common.js";
 export const DEFAULT_COLS = 120;
 export const DEFAULT_ROWS = 30;
 export const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -39,101 +41,6 @@ export const OPENCODE_SERVER_READY_TIMEOUT_MS = 10_000;
 export const OPENCODE_SSE_RECONNECT_DELAY_MS = 2_000;
 export const OPENCODE_SESSION_IDLE_SETTLE_MS = 1_500;
 export const OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS = 12_000;
-export function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function getCodexRpcRequestId(value) {
-    return typeof value === "string" || typeof value === "number" ? value : null;
-}
-export function getNotificationThreadId(params) {
-    if (!isRecord(params)) {
-        return null;
-    }
-    if (typeof params.threadId === "string") {
-        return params.threadId;
-    }
-    if (isRecord(params.thread) && typeof params.thread.id === "string") {
-        return params.thread.id;
-    }
-    return null;
-}
-export function getNotificationTurnId(params) {
-    if (!isRecord(params)) {
-        return null;
-    }
-    if (typeof params.turnId === "string") {
-        return params.turnId;
-    }
-    if (isRecord(params.turn) && typeof params.turn.id === "string") {
-        return params.turn.id;
-    }
-    return null;
-}
-export function describeUnknownError(error) {
-    if (error instanceof Error && error.message) {
-        return error.message;
-    }
-    return String(error);
-}
-export function normalizeCodexRpcError(error) {
-    if (isRecord(error)) {
-        const message = typeof error.message === "string"
-            ? error.message
-            : typeof error.code === "number"
-                ? `RPC error ${error.code}`
-                : "";
-        const data = typeof error.data === "string"
-            ? error.data
-            : typeof error.details === "string"
-                ? error.details
-                : "";
-        const combined = [message, data].filter(Boolean).join(": ");
-        if (combined) {
-            return combined;
-        }
-    }
-    return describeUnknownError(error);
-}
-export function getLocalCompanionCommandName(kind) {
-    switch (kind) {
-        case "codex":
-            return "wechat-codex";
-        case "claude":
-            return "wechat-claude";
-        case "opencode":
-            return "wechat-opencode";
-        default:
-            return "local companion";
-    }
-}
-export function getSharedSessionIdFromAdapterState(state) {
-    return state.sharedSessionId ?? state.sharedThreadId;
-}
-export function quoteWindowsCommandArg(value) {
-    return `"${value.replace(/"/g, '""')}"`;
-}
-export function quotePosixCommandArg(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-export function isRecentIsoTimestamp(timestamp, maxAgeMs) {
-    const parsedMs = Date.parse(timestamp);
-    if (!Number.isFinite(parsedMs)) {
-        return false;
-    }
-    return parsedMs >= Date.now() - maxAgeMs;
-}
-export function coerceWebSocketMessageData(data) {
-    if (typeof data === "string") {
-        return data;
-    }
-    if (data instanceof ArrayBuffer) {
-        return Buffer.from(data).toString("utf8");
-    }
-    if (ArrayBuffer.isView(data)) {
-        return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
-    }
-    return null;
-}
 export function buildCodexCliArgs(remoteUrl, options = {}) {
     assertNoReservedExtraCliArgs(options.extraCliArgs ?? [], ["--remote", "--remote-auth-token-env"], "Codex remote connection");
     const args = [];
@@ -196,7 +103,7 @@ export function shouldIncludeClaudeNoAltScreen(command) {
     if (cached !== undefined) {
         return cached;
     }
-    let supported = false;
+    let supported;
     try {
         const probe = spawnSync(spawnTarget.file, [...spawnTarget.args, "--help"], {
             cwd: process.cwd(),
@@ -660,7 +567,7 @@ export function escapePowerShellString(text) {
     return text.replace(/`/g, "``").replace(/"/g, '`"');
 }
 export function escapePosixShellString(text) {
-    return `'${text.replace(/'/g, `'\"'\"'`)}'`;
+    return `'${text.replace(/'/g, `'"'"'`)}'`;
 }
 export function buildShellProfileCommand(profilePath, family) {
     const resolved = path.resolve(profilePath);

package/dist/bridge/bridge-final-reply.js

@@ -1,10 +1,25 @@
 import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, } from "./bridge-utils.js";
+export const OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE = "OpenCode 没有产生可发送到微信的可见回复。请查看本地终端输出，或重试这条消息。";
 export async function forwardWechatFinalReply(params) {
-    const { adapter, rawText, sender } = params;
+    const { adapter, rawText, sender, onEmptyVisibleReply } = params;
     const parsed = parseWechatFinalReply(rawText);
-    const visibleText = formatFinalReplyMessage(adapter, sanitizeWechatFinalReplyText(adapter, parsed.visibleText)).trim();
+    const sanitizedText = sanitizeWechatFinalReplyText(adapter, parsed.visibleText);
+    const visibleText = formatFinalReplyMessage(adapter, sanitizedText).trim();
     if (visibleText) {
-        await sender.sendText(visibleText);
+        const sent = await sender.sendText(visibleText);
+        if (sent === false) {
+            return;
+        }
+    }
+    else if (adapter === "opencode" && parsed.visibleText.trim()) {
+        onEmptyVisibleReply?.({
+            adapter,
+            rawVisibleText: parsed.visibleText,
+        });
+        const sent = await sender.sendText(OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE);
+        if (sent === false) {
+            return;
+        }
     }
     for (const attachment of parsed.attachments) {
         try {

package/dist/bridge/bridge-state.js

@@ -3,6 +3,14 @@ import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, ensureWorkspaceChannelDir, ensureCha
 import { buildInstanceId } from "./bridge-utils.js";
 const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;
 const ORPHAN_LOCK_RECLAIM_POLL_MS = 100;
+export function resolveRestorableSharedSessionId(persisted, options) {
+    if (!persisted ||
+        persisted.cwd !== options.cwd ||
+        persisted.adapter !== options.adapter) {
+        return undefined;
+    }
+    return persisted.sharedSessionId ?? persisted.sharedThreadId;
+}
 function cloneState(state) {
     return JSON.parse(JSON.stringify(state));
 }
@@ -162,9 +170,7 @@ export class BridgeStateStore {
         };
         this.acquireLock();
         const persisted = this.readStateFile();
-        const persistedSharedSessionId = persisted?.cwd === options.cwd
-            ? persisted.sharedSessionId ?? persisted.sharedThreadId
-            : undefined;
+        const persistedSharedSessionId = resolveRestorableSharedSessionId(persisted, options);
         const persistedResumeConversationId = options.adapter === "claude" &&
             persisted?.cwd === options.cwd &&
             typeof persisted.resumeConversationId === "string"

package/dist/bridge/bridge-utils.js

@@ -101,6 +101,7 @@ export function stripAnsi(text) {
 }
 export function normalizeOutput(text) {
     return stripAnsi(text)
+        // eslint-disable-next-line no-control-regex
         .replace(/\u0000/g, "")
         .replace(/\r\n/g, "\n")
         .replace(/\r/g, "\n");
@@ -132,6 +133,9 @@ export function parseSystemCommand(text) {
         return null;
     }
     const [rawCommand, ...rest] = trimmed.split(/\s+/);
+    if (!rawCommand) {
+        return null;
+    }
     const command = rawCommand.toLowerCase();
     const argument = rest.join(" ").trim();
     switch (command) {
@@ -227,7 +231,11 @@ export function parseWechatFinalReply(text) {
         return extractInlineWechatAttachments(normalized);
     }
     const attachments = [];
-    const lines = match[1]
+    const attachmentBlock = match[1];
+    if (attachmentBlock === undefined) {
+        return extractInlineWechatAttachments(normalized);
+    }
+    const lines = attachmentBlock
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
@@ -240,7 +248,11 @@ export function parseWechatFinalReply(text) {
             return extractInlineWechatAttachments(normalized);
         }
         const kind = parsed[1];
-        const attachmentPath = resolveWechatAttachmentPath(parsed[2]);
+        const rawPath = parsed[2];
+        if (!rawPath) {
+            return extractInlineWechatAttachments(normalized);
+        }
+        const attachmentPath = resolveWechatAttachmentPath(rawPath);
         if (!attachmentPath) {
             return extractInlineWechatAttachments(normalized);
         }
@@ -407,7 +419,11 @@ export function getInteractiveShellCommandRejectionMessage(command) {
     if (!tokens.length) {
         return null;
     }
-    const executable = normalizeShellExecutableToken(tokens[0]);
+    const firstToken = tokens[0];
+    if (!firstToken) {
+        return null;
+    }
+    const executable = normalizeShellExecutableToken(firstToken);
     const args = tokens.slice(1);
     const lowerArgs = args.map((arg) => arg.toLowerCase());
     if (!executable) {
@@ -419,7 +435,7 @@ export function getInteractiveShellCommandRejectionMessage(command) {
     switch (executable) {
         case "python":
         case "python3":
-        case "py":
+        case "py": {
             if (!args.length) {
                 return buildInteractiveShellCommandMessage(executable, 'Try "python script.py" or "python -c \\"...\\"" instead.');
             }
@@ -438,6 +454,7 @@ export function getInteractiveShellCommandRejectionMessage(command) {
             return hasScriptLikeArg(args)
                 ? null
                 : buildInteractiveShellCommandMessage(executable, 'Try "python script.py" or "python -c \\"...\\"" instead.');
+        }
         case "node":
             if (!args.length || lowerArgs.includes("-i") || lowerArgs.includes("--interactive")) {
                 return buildInteractiveShellCommandMessage(executable, 'Try "node script.js" or "node -e \\"...\\"" instead.');
@@ -725,6 +742,9 @@ function stripInlineOpenCodeReasoningPrefix(text) {
     }
     return current;
 }
+function isOpenCodeReasoningResidue(text) {
+    return !text.replace(/[\s"'“”‘’`.,!?;:()[\]{}<>…。！？；：（）【】《》、，-]/g, "");
+}
 export function sanitizeWechatFinalReplyText(adapter, text) {
     const normalized = adapter === "opencode"
         ? cleanupVisibleWechatReplyText(stripInlineOpenCodeReasoningPrefix(text))
@@ -775,7 +795,8 @@ export function sanitizeWechatFinalReplyText(adapter, text) {
         return cleaned;
     }
     const tail = cleanupVisibleWechatReplyText(keptLines.slice(tailStartIndex).join("\n"));
-    return tail || cleaned;
+    const resolved = tail || cleaned;
+    return isOpenCodeReasoningResidue(resolved) ? "" : resolved;
 }
 function extractInlineWechatAttachments(text) {
     const sanitized = text
@@ -946,7 +967,7 @@ function parseSingleUserInputAnswer(question, rawValue) {
         };
     }
     const separatorIndex = trimmed.indexOf("|");
-    let selection = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex).trim() : trimmed;
+    const selection = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex).trim() : trimmed;
     let note = separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1).trim() : "";
     const answers = [];
     if (selection) {
@@ -956,7 +977,6 @@ function parseSingleUserInputAnswer(question, rawValue) {
         }
         else if (question.isOther) {
             note = note ? `${selection}; ${note}` : selection;
-            selection = "";
         }
         else {
             return {
@@ -986,6 +1006,11 @@ export function parsePendingUserInputAnswerCommand(raw, pending) {
     const answers = {};
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return {
+                error: "No pending user input question was found.",
+            };
+        }
         const parsed = parseSingleUserInputAnswer(question, input);
         if ("error" in parsed) {
             return parsed;
@@ -1068,6 +1093,9 @@ export function formatUserInputRequestMessage(pending, adapterState) {
     lines.push("");
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return lines.join("\n");
+        }
         if (question.options?.length) {
             lines.push("Reply with /answer <option number or exact label>.");
             if (question.isOther) {
@@ -1090,6 +1118,9 @@ export function formatUserInputRequestMessage(pending, adapterState) {
 export function formatPendingUserInputReminder(pending) {
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return "Codex is waiting for user input. Reply with /answer and your response, or use /stop to interrupt.";
+        }
         return `Codex is waiting for user input for ${question.header}. Reply with /answer and your response, or use /stop to interrupt.`;
     }
     return `Codex is waiting for answers to ${pending.questions.length} questions. Reply with /answer questionId=value; questionId2=value, or use /stop to interrupt.`;

package/dist/bridge/claude-hooks.js

@@ -108,7 +108,7 @@ function summarizeClaudePlan(plan) {
     const description = lines.find((line) => !/^#+\s+/.test(line) &&
         !/^[-*]\s+/.test(line) &&
         !/^\d+\.\s+/.test(line));
-    return truncatePreview([heading, description].filter(Boolean).join(" - ") || lines[0], 180);
+    return truncatePreview([heading, description].filter(Boolean).join(" - ") || lines[0] || "(empty plan)", 180);
 }
 function summarizeClaudeToolInput(toolName, toolInput) {
     if (!toolInput) {
@@ -214,7 +214,7 @@ export function extractClaudeTranscriptFinalReply(rawTranscript) {
         if (!line) {
             continue;
         }
-        let parsed = null;
+        let parsed;
         try {
             parsed = JSON.parse(line);
         }

package/dist/bridge/wechat-bridge.js

@@ -14,6 +14,8 @@ import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.j
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
+const WECHAT_SEND_MAX_ATTEMPTS = 3;
+const WECHAT_SEND_RETRY_BASE_MS = 750;
 function log(message) {
     process.stderr.write(`[wechat-bridge] ${message}\n`);
 }
@@ -73,6 +75,21 @@ export function formatUserFacingInboundError(params) {
 export function formatWechatSendFailureLogEntry(params) {
     return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
 }
+function formatWechatSendRetryLogEntry(params) {
+    return `wechat_send_retry: context=${params.context} recipient=${params.recipientId} attempt=${params.attempt} delay_ms=${params.delayMs} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+function isRetryableWechatSendError(error) {
+    const classification = classifyWechatTransportError(error);
+    if (classification.retryable) {
+        return true;
+    }
+    const details = describeWechatTransportError(error);
+    return /^Error: sendmessage failed:/i.test(details) &&
+        !/errcode=-14\b.*session timeout/i.test(details);
+}
+function computeWechatSendRetryDelayMs(attempt) {
+    return WECHAT_SEND_RETRY_BASE_MS * attempt;
+}
 export function shouldWatchParentProcess(options) {
     return (options.startupParentPid > 1 &&
         (options.attachedToTerminal || options.lifecycle === "companion_bound"));
@@ -271,6 +288,7 @@ async function main() {
     stateStore.appendLog(`Cleared stale companion endpoint for ${options.cwd} before adapter start.`);
     let textSendChain = Promise.resolve();
     let attachmentSendChain = Promise.resolve();
+    const pendingWechatForwardTasks = new Set();
     let activeTask = null;
     const deferredInboundMessages = [];
     let drainingDeferredInboundMessages = false;
@@ -288,14 +306,53 @@ async function main() {
         return run;
     };
     const queueWechatMessage = (senderId, text, context = "message") => {
-        return queueWechatTextAction(() => transport.sendText(senderId, text)).catch((err) => {
-            logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
-            stateStore.appendLog(formatWechatSendFailureLogEntry({
-                context,
-                recipientId: senderId,
-                error: err,
-            }));
+        return queueWechatTextAction(async () => {
+            for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
+                try {
+                    await transport.sendText(senderId, text);
+                    return true;
+                }
+                catch (err) {
+                    if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(err)) {
+                        const delayMs = computeWechatSendRetryDelayMs(attempt);
+                        logError(`Failed to send WeChat ${context} (attempt ${attempt}). Retrying in ${formatDuration(delayMs)}. ${describeWechatTransportError(err)}`);
+                        stateStore.appendLog(formatWechatSendRetryLogEntry({
+                            context,
+                            recipientId: senderId,
+                            attempt,
+                            delayMs,
+                            error: err,
+                        }));
+                        await delay(delayMs);
+                        continue;
+                    }
+                    logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
+                    stateStore.appendLog(formatWechatSendFailureLogEntry({
+                        context,
+                        recipientId: senderId,
+                        error: err,
+                    }));
+                    return false;
+                }
+            }
+            return false;
+        });
+    };
+    const trackWechatForwardTask = (task) => {
+        const tracked = task
+            .catch((error) => {
+            logError(`WeChat forward task failed: ${describeWechatTransportError(error)}`);
+            stateStore.appendLog(`wechat_forward_failed: error=${truncatePreview(describeWechatTransportError(error), 400)}`);
+        })
+            .finally(() => {
+            pendingWechatForwardTasks.delete(tracked);
         });
+        pendingWechatForwardTasks.add(tracked);
+    };
+    const waitForPendingWechatForwardTasks = async () => {
+        while (pendingWechatForwardTasks.size > 0) {
+            await Promise.allSettled([...pendingWechatForwardTasks]);
+        }
     };
     const outputBatcher = new OutputBatcher(async (text) => {
         await queueWechatMessage(stateStore.getState().authorizedUserId, text);
@@ -377,6 +434,7 @@ async function main() {
         }
         try {
             await outputBatcher.flushNow();
+            await waitForPendingWechatForwardTasks();
         }
         catch {
             // Best effort flush.
@@ -384,6 +442,7 @@ async function main() {
         try {
             await textSendChain;
             await attachmentSendChain;
+            await waitForPendingWechatForwardTasks();
         }
         catch {
             // Best effort flush.
@@ -458,6 +517,7 @@ async function main() {
             outputBatcher,
             queueWechatAttachmentAction,
             queueWechatMessage,
+            trackWechatForwardTask,
             maybeDrainDeferredInboundMessages,
             getActiveTask: () => activeTask,
             clearActiveTask: () => {
@@ -622,7 +682,7 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, updateLastOutputAt, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
+    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, updateLastOutputAt, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
     adapter.setEventSink((event) => {
         syncSharedSessionState();
         syncLocalClientEndpoint();
@@ -642,19 +702,28 @@ function wireAdapterEvents(params) {
                 break;
             case "final_reply":
                 stateStore.appendLog(`final_reply: ${truncatePreview(event.text)}`);
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await forwardWechatFinalReply({
                         adapter: options.adapter,
                         rawText: event.text,
+                        onEmptyVisibleReply: ({ rawVisibleText }) => {
+                            stateStore.appendLog(`empty_visible_final_reply: adapter=${options.adapter} raw=${truncatePreview(rawVisibleText)}`);
+                        },
                         sender: {
-                            sendText: (text) => queueWechatMessage(authorizedUserId, text, "final_reply"),
+                            sendText: async (text) => {
+                                const sent = await queueWechatMessage(authorizedUserId, text, "final_reply");
+                                if (sent) {
+                                    stateStore.appendLog(`final_reply_sent: chars=${Array.from(text).length}`);
+                                }
+                                return sent;
+                            },
                             sendImage: (imagePath) => queueWechatAttachmentAction(() => transport.sendImage(imagePath, { recipientId: authorizedUserId })),
                             sendFile: (filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId: authorizedUserId })),
                             sendVoice: (voicePath) => queueWechatAttachmentAction(() => transport.sendVoice(voicePath, authorizedUserId)),
                             sendVideo: (videoPath) => queueWechatAttachmentAction(() => transport.sendVideo(videoPath, { recipientId: authorizedUserId })),
                         },
                     });
-                });
+                }));
                 break;
             case "status":
                 if (event.message) {
@@ -667,56 +736,56 @@ function wireAdapterEvents(params) {
                 updateLastOutputAt();
                 stateStore.appendLog(`${event.level}_notice: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, event.text, "notice");
-                    });
+                    }));
                 }
                 break;
             case "approval_required":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     const pending = toPendingApproval(event.request);
                     stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
                     await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
-                });
+                }));
                 break;
             case "mirrored_user_input":
                 stateStore.appendLog(`mirrored_local_input: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, event.text), "mirrored_user_input");
-                    });
+                    }));
                 }
                 break;
             case "session_switched":
                 stateStore.appendLog(`session_switched: ${event.sessionId} source=${event.source} reason=${event.reason}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
                             sessionId: event.sessionId,
                             source: event.source,
                             reason: event.reason,
                         }), "session_switched");
-                    });
+                    }));
                 }
                 break;
             case "thread_switched":
                 stateStore.appendLog(`thread_switched: ${event.threadId} source=${event.source} reason=${event.reason}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
                             sessionId: event.threadId,
                             source: event.source,
                             reason: event.reason,
                         }), "thread_switched");
-                    });
+                    }));
                 }
                 void maybeDrainDeferredInboundMessages();
                 break;
             case "task_complete":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     if (options.adapter === "shell") {
                         const summary = buildCompletionSummary({
@@ -729,25 +798,25 @@ function wireAdapterEvents(params) {
                     }
                     clearActiveTask();
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "task_failed":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     clearActiveTask();
                     await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, event.message), "task_failed");
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "fatal_error":
                 logError(event.message);
                 stateStore.appendLog(`fatal_error: ${event.message}`);
                 stateStore.clearPendingConfirmation();
                 clearActiveTask();
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(event.message), "fatal_error");
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "shutdown_requested":
                 stateStore.appendLog(`shutdown_requested: ${event.reason}`);
@@ -774,6 +843,7 @@ async function handleInboundMessage(params) {
     const systemCommand = parseWechatControlCommand(message.text, {
         adapter: options.adapter,
         hasPendingConfirmation: Boolean(state.pendingConfirmation),
+        hasPendingUserInput: Boolean(state.pendingUserInput),
     });
     if (message.senderId !== state.authorizedUserId) {
         await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");

package/dist/companion/codex-remote-client.js

@@ -13,6 +13,9 @@ export function parseCliArgs(argv) {
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
+        if (!arg) {
+            continue;
+        }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([

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

@@ -87,6 +87,9 @@ export function parseCliArgs(argv) {
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
+        if (!arg) {
+            continue;
+        }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
@@ -173,7 +176,9 @@ async function stopExistingBridge(lock, requestedAdapter) {
     catch (error) {
         if (isPidAlive(pid)) {
             const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to stop existing bridge pid=${pid}: ${message}`);
+            throw new Error(`Failed to stop existing bridge pid=${pid}: ${message}`, {
+                cause: error,
+            });
         }
     }
     if (!(await waitForProcessExit(pid, 10_000))) {

package/dist/companion/local-companion.js

@@ -16,6 +16,9 @@ function parseCliArgs(argv) {
     const cliArgs = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
+        if (!arg) {
+            continue;
+        }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([

package/dist/utils/version-checker.js

@@ -37,7 +37,7 @@ export async function fetchLatestVersion() {
         }
         // 按版本号排序，返回最新的
         versionTags.sort((a, b) => compareVersions(b, a));
-        return versionTags[0];
+        return versionTags[0] ?? null;
     }
     catch (error) {
         // 如果 git 命令失败，静默返回 null