@unlinearity/cli-wechat-bridge 1.1.5 → 1.1.6

package/dist/bridge/wechat-bridge.js

@@ -4,18 +4,21 @@ import { resolveDefaultAdapterCommand, } from "./bridge-adapters.js";
 import { delay } from "./bridge-adapters.shared.js";
 import { t } from "../i18n/index.js";
 import { BridgeController } from "./bridge-controller.js";
-import { forwardWechatFinalReply } from "./bridge-final-reply.js";
 import { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "./bridge-session-resume.js";
-import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "./wechat-forwarding.js";
+import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isWechatContextUnavailableError, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, shouldSuppressCodexLocalThreadNotice, } from "../channels/wechat/wechat-forwarding.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
 import { getProcessRecordByPid, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
+import { toChannelInboundMessage } from "../channels/wechat/channel-message.js";
+import { routeBridgeMessage } from "../core/bridge-message-router.js";
+import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
+import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
 import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatThinkingForWechat, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
+import { getPendingWechatMessagesFile, PendingWechatMessageStore, } from "../channels/wechat/wechat-outbound-queue.js";
 import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.js";
 import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, } from "../daemon/daemon-link.js";
-import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix, listBindings, loadEmojiBindings, parseEmojiBindingsCommand, removeBinding, resolveEmojiCommand, setBinding, } from "../daemon/emoji-bindings.js";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
@@ -270,6 +273,7 @@ async function main() {
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,
     });
+    const pendingWechatMessages = new PendingWechatMessageStore(getPendingWechatMessagesFile(options.cwd));
     const resumeCoordinator = new ResumeSessionCoordinator({
         adapter: options.adapter,
         runtime: adapter,
@@ -295,48 +299,89 @@ async function main() {
         attachmentSendChain = run.then(() => undefined, () => undefined);
         return run;
     };
-    const queueWechatMessage = (senderId, text, context = "message") => {
-        return queueWechatTextAction(async () => {
-            for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
-                try {
-                    await transport.sendText(senderId, text);
-                    return true;
+    const sendWechatMessageNow = async (senderId, text, context = "message") => {
+        const startedAtMs = Date.now();
+        stateStore.appendLog(`wechat_send_started: context=${context} recipient=${senderId} chars=${Array.from(text).length}`);
+        for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
+            try {
+                await transport.sendText(senderId, text);
+                stateStore.appendLog(`wechat_send_completed: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
+                return { status: "sent" };
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === "AbortError") {
+                    stateStore.appendLog(`wechat_send_timeout: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
                 }
-                catch (err) {
+                if (isWechatContextUnavailableError(err)) {
                     if (isWechatContextTokenStaleError(err)) {
                         transport.clearCachedContextToken(senderId);
-                        const hint = "WeChat conversation context is stale. Ask the WeChat owner to send any message first, then local terminal replies can sync back to WeChat.";
-                        logError(`Failed to send WeChat ${context}: ${hint}`);
-                        stateStore.appendLog(formatWechatContextTokenStaleLogEntry({
+                    }
+                    const hint = "WeChat conversation context is stale or unavailable. Ask the WeChat owner to send any message first, then local terminal replies can sync back to WeChat.";
+                    logError(`Failed to send WeChat ${context}: ${hint}`);
+                    stateStore.appendLog(isWechatContextTokenStaleError(err)
+                        ? formatWechatContextTokenStaleLogEntry({
                             context,
                             recipientId: senderId,
                             error: err,
-                        }));
-                        return false;
-                    }
-                    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({
+                        })
+                        : formatWechatSendFailureLogEntry({
                             context,
                             recipientId: senderId,
-                            attempt,
-                            delayMs,
                             error: err,
                         }));
-                        await delay(delayMs);
-                        continue;
-                    }
-                    logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
-                    stateStore.appendLog(formatWechatSendFailureLogEntry({
+                    return { status: "context_unavailable", error: 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,
                     }));
-                    return false;
+                    await delay(delayMs);
+                    continue;
                 }
+                logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
+                stateStore.appendLog(formatWechatSendFailureLogEntry({
+                    context,
+                    recipientId: senderId,
+                    error: err,
+                }));
+                return { status: "failed" };
+            }
+        }
+        return { status: "failed" };
+    };
+    const queueWechatMessage = (senderId, text, context = "message") => {
+        return queueWechatTextAction(async () => {
+            const result = await sendWechatMessageNow(senderId, text, context);
+            if (result.status === "context_unavailable") {
+                const pending = pendingWechatMessages.enqueue(senderId, text, context);
+                if (pending) {
+                    stateStore.appendLog(`wechat_send_queued: id=${pending.id} context=${context} recipient=${senderId} pending=${pendingWechatMessages.list().length}`);
+                }
+            }
+            return result.status === "sent";
+        });
+    };
+    const flushPendingWechatMessages = () => {
+        return queueWechatTextAction(async () => {
+            for (const pending of pendingWechatMessages.list()) {
+                const result = await sendWechatMessageNow(pending.recipientId, pending.text, pending.context);
+                if (result.status === "sent") {
+                    pendingWechatMessages.remove(pending.id);
+                    stateStore.appendLog(`wechat_pending_sent: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
+                    continue;
+                }
+                if (result.status === "context_unavailable") {
+                    break;
+                }
+                stateStore.appendLog(`wechat_pending_retryable_failure: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
+                break;
             }
-            return false;
         });
     };
     const trackWechatForwardTask = (task) => {
@@ -583,10 +628,6 @@ async function main() {
         else if (options.adapter === "pi") {
             log("For source-mode debugging, open the visible Pi client with: npm run pi:companion");
         }
-        loadEmojiBindings();
-        // Keep the standalone bridge's WeChat welcome brief: command and emoji
-        // reference material belongs to /status and /bindings, which users can
-        // request on demand. The daemon sends its own, fuller welcome.
         const welcomeText = t("bridge.welcome", {
             adapter: options.adapter,
             cwd: options.cwd,
@@ -634,6 +675,9 @@ async function main() {
                 log(`WeChat long poll recovered after ${recoveredFailures} transient error(s).`);
                 stateStore.appendLog(`poll_recovered: failures=${recoveredFailures}`);
             }
+            if (pollResult.messages.length > 0 && pendingWechatMessages.list().length > 0) {
+                await flushPendingWechatMessages();
+            }
             if (pollResult.ignoredBacklogCount > 0) {
                 stateStore.incrementIgnoredBacklog(pollResult.ignoredBacklogCount);
                 stateStore.appendLog(`ignored_startup_backlog: count=${pollResult.ignoredBacklogCount}`);
@@ -720,6 +764,21 @@ function syncSharedSessionState(stateStore, adapter) {
 }
 function wireAdapterEvents(params) {
     const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
+    const channelPort = new WechatChannelPort({
+        sendText: (recipientId, text, context) => queueWechatMessage(recipientId, text, context),
+        sendImage: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendImage(filePath, { recipientId })),
+        sendFile: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId })),
+        sendVoice: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendVoice(filePath, recipientId)),
+        sendVideo: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendVideo(filePath, { recipientId })),
+        onEmptyVisibleReply: (adapter, rawText) => {
+            stateStore.appendLog(`empty_visible_final_reply: adapter=${adapter ?? options.adapter} raw=${truncatePreview(rawText)}`);
+        },
+        onTextSent: (_adapter, text) => {
+            stateStore.appendLog(`final_reply_sent: chars=${Array.from(text).length}`);
+        },
+    });
+    let lastFinalReplyAtMs = 0;
+    let eventForwardChain = Promise.resolve();
     adapter.setEventSink((event) => {
         syncSharedSessionState();
         syncLocalClientEndpoint();
@@ -732,56 +791,52 @@ function wireAdapterEvents(params) {
             stateStore.clearPendingUserInput();
         }
         const authorizedUserId = stateStore.getState().authorizedUserId;
-        switch (event.type) {
-            case "stdout":
-            case "stderr":
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    outputBatcher.push(event.text);
+        eventForwardChain = eventForwardChain
+            .then(() => forwardBridgeEvent(event, {
+            stdout: (next) => {
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
+                    outputBatcher.push(next.text);
                 }
-                break;
-            case "final_reply":
-                stateStore.appendLog(`final_reply: ${truncatePreview(event.text)}`);
+            },
+            stderr: (next) => {
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
+                    outputBatcher.push(next.text);
+                }
+            },
+            finalReply: (next) => {
+                lastFinalReplyAtMs = Date.now();
+                stateStore.appendLog(`final_reply: ${truncatePreview(next.text)}`);
                 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: 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 })),
+                    await channelPort.send({
+                        target: {
+                            channelId: "wechat",
+                            conversationId: authorizedUserId,
+                            recipientId: authorizedUserId,
                         },
+                        kind: "final_reply",
+                        text: next.text,
+                        adapter: options.adapter,
                     });
                 }));
-                break;
-            case "status":
-                if (event.message) {
-                    log(`${event.status}: ${event.message}`);
-                    stateStore.appendLog(`${event.status}: ${event.message}`);
+            },
+            status: (next) => {
+                if (next.message) {
+                    log(`${next.status}: ${next.message}`);
+                    stateStore.appendLog(`${next.status}: ${next.message}`);
                 }
                 void maybeDrainDeferredInboundMessages();
-                break;
-            case "notice":
-                stateStore.appendLog(`${event.level}_notice: ${truncatePreview(event.text)}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
+            },
+            notice: (next) => {
+                stateStore.appendLog(`${next.level}_notice: ${truncatePreview(next.text)}`);
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type, { text: next.text })) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, event.text, "notice");
+                        await queueWechatMessage(authorizedUserId, next.text, "notice");
                     }));
                 }
-                break;
-            case "thinking":
-                if (event.text) {
-                    const thinkingPreview = formatThinkingForWechat(event.text, 500);
+            },
+            thinking: (next) => {
+                if (next.text) {
+                    const thinkingPreview = formatThinkingForWechat(next.text, 500);
                     if (thinkingPreview) {
                         stateStore.appendLog(`thinking: ${thinkingPreview}`);
                         trackWechatForwardTask((async () => {
@@ -789,99 +844,98 @@ function wireAdapterEvents(params) {
                         })());
                     }
                 }
-                break;
-            case "approval_required":
+            },
+            approvalRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    const pending = toPendingApproval(event.request);
+                    const pending = toPendingApproval(next.request);
                     stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
                     await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
                 }));
-                break;
-            case "user_input_required":
+            },
+            userInputRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    const pending = toPendingUserInput(event.request);
+                    const pending = toPendingUserInput(next.request);
                     stateStore.setPendingUserInput(pending);
                     stateStore.appendLog(`User input requested: questions=${pending.questions.length}`);
                     await queueWechatMessage(authorizedUserId, formatUserInputRequestMessage(pending, adapterState), "user_input_required");
                 }));
-                break;
-            case "mirrored_user_input":
-                stateStore.appendLog(`mirrored_local_input: ${truncatePreview(event.text)}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
+            },
+            mirroredUserInput: (next) => {
+                stateStore.appendLog(`mirrored_local_input: ${truncatePreview(next.text)}`);
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type, { text: next.text })) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, event.text), "mirrored_user_input");
+                        await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, next.text), "mirrored_user_input");
                     }));
                 }
-                break;
-            case "session_switched":
-                if (event.source === "local") {
+            },
+            sessionSwitched: (next) => {
+                if (next.source === "local")
                     resumeCoordinator.clear();
-                }
-                stateStore.appendLog(`session_switched: ${event.sessionId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardSessionSwitchEvent(event.reason) &&
-                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                stateStore.appendLog(`session_switched: ${next.sessionId} source=${next.source} reason=${next.reason}`);
+                if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
-                            adapter: options.adapter,
-                            sessionId: event.sessionId,
-                            source: event.source,
-                            reason: event.reason,
-                        }), "session_switched");
+                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.sessionId, source: next.source, reason: next.reason }), "session_switched");
                     }));
                 }
-                break;
-            case "thread_switched":
-                if (event.source === "local") {
+            },
+            threadSwitched: (next) => {
+                if (next.source === "local")
                     resumeCoordinator.clear();
+                stateStore.appendLog(`thread_switched: ${next.threadId} source=${next.source} reason=${next.reason}`);
+                if (shouldSuppressCodexLocalThreadNotice({
+                    adapter: options.adapter,
+                    source: next.source,
+                    activeTurnOrigin: adapter.getState().activeTurnOrigin,
+                    lastFinalReplyAtMs,
+                })) {
+                    return;
                 }
-                stateStore.appendLog(`thread_switched: ${event.threadId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardSessionSwitchEvent(event.reason) &&
-                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
-                            adapter: options.adapter,
-                            sessionId: event.threadId,
-                            source: event.source,
-                            reason: event.reason,
-                        }), "thread_switched");
+                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.threadId, source: next.source, reason: next.reason }), "thread_switched");
                     }));
                 }
                 void maybeDrainDeferredInboundMessages();
-                break;
-            case "task_complete":
+            },
+            taskComplete: () => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
                     clearActiveTask();
                     await maybeDrainDeferredInboundMessages();
                 }));
-                break;
-            case "task_failed":
+            },
+            taskFailed: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
                     clearActiveTask();
-                    await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, event.message), "task_failed");
+                    await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, next.message), "task_failed");
                     await maybeDrainDeferredInboundMessages();
                 }));
-                break;
-            case "fatal_error":
-                logError(event.message);
-                stateStore.appendLog(`fatal_error: ${event.message}`);
+            },
+            fatalError: (next) => {
+                logError(next.message);
+                stateStore.appendLog(`fatal_error: ${next.message}`);
                 stateStore.clearPendingConfirmation();
                 stateStore.clearPendingUserInput();
                 clearActiveTask();
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(event.message), "fatal_error");
+                    await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(next.message), "fatal_error");
                     await maybeDrainDeferredInboundMessages();
                 }));
-                break;
-            case "shutdown_requested":
-                stateStore.appendLog(`shutdown_requested: ${event.reason}`);
-                requestShutdown(event.message, event.exitCode ?? 0);
-                break;
-        }
+            },
+            shutdownRequested: (next) => {
+                stateStore.appendLog(`shutdown_requested: ${next.reason}`);
+                requestShutdown(next.message, next.exitCode ?? 0);
+            },
+        }))
+            .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            logError(`Bridge event handling failed: ${message}`);
+            stateStore.appendLog(`event_forward_failed: ${message}`);
+        });
     });
 }
 function formatInboundMessagePreview(message) {
@@ -896,44 +950,13 @@ function formatInboundMessagePreview(message) {
     return "(empty)";
 }
 async function handleInboundMessage(params) {
-    let { message, } = params;
+    const { message, } = params;
     const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, deferInboundMessage, } = params;
     const state = stateStore.getState();
     if (message.senderId !== state.authorizedUserId) {
         await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
         return null;
     }
-    // Emoji resolution: rewrite message text if it starts with a bound emoji
-    const emojiMatch = resolveEmojiCommand(message.text);
-    if (emojiMatch) {
-        const rewritten = emojiMatch.remainder
-            ? `${emojiMatch.command} ${emojiMatch.remainder}`
-            : emojiMatch.command;
-        message = { ...message, text: rewritten };
-    }
-    // Emoji binding management commands
-    const bindingsCmd = parseEmojiBindingsCommand(message.text);
-    if (bindingsCmd) {
-        switch (bindingsCmd.type) {
-            case "list":
-                await queueWechatMessage(message.senderId, formatBindingsListMessage(listBindings()));
-                break;
-            case "bind":
-                setBinding(bindingsCmd.emoji, bindingsCmd.command);
-                await queueWechatMessage(message.senderId, `Bound ${bindingsCmd.emoji} → ${bindingsCmd.command}`);
-                break;
-            case "unbind": {
-                const removed = removeBinding(bindingsCmd.emoji);
-                await queueWechatMessage(message.senderId, removed ? `Unbound ${bindingsCmd.emoji}` : `No binding found for ${bindingsCmd.emoji}`);
-                break;
-            }
-        }
-        return null;
-    }
-    if (isBindCommandPrefix(message.text)) {
-        await queueWechatMessage(message.senderId, formatBindCommandUsage());
-        return null;
-    }
     const systemCommand = parseWechatControlCommand(message.text, {
         adapter: options.adapter,
         hasPendingConfirmation: Boolean(state.pendingConfirmation),
@@ -1056,40 +1079,54 @@ async function handleInboundMessage(params) {
             };
         }
     }
-    if (state.pendingConfirmation) {
-        await queueWechatMessage(message.senderId, formatPendingApprovalReminder(state.pendingConfirmation, adapter.getState()));
-        return null;
-    }
-    if (state.pendingUserInput) {
-        await queueWechatMessage(message.senderId, formatPendingUserInputReminder(state.pendingUserInput));
-        return null;
-    }
     const adapterState = adapter.getState();
-    if (shouldDeferCodexInboundMessage({
-        adapter: options.adapter,
-        status: adapterState.status,
-        activeTurnOrigin: adapterState.activeTurnOrigin,
-        hasPendingConfirmation: Boolean(state.pendingConfirmation),
-        hasSystemCommand: Boolean(systemCommand),
-    })) {
-        await deferInboundMessage(message);
-        return null;
-    }
-    if (adapterState.status === "busy") {
-        if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
-            adapterState.activeTurnOrigin === "local") {
-            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.`);
-        return null;
-    }
-    return dispatchInboundWechatText({
-        message,
-        options,
-        stateStore,
-        adapter,
+    const routeResult = await routeBridgeMessage({
+        message: toChannelInboundMessage(message),
+        authorized: true,
+        command: null,
+        adapterState,
+        hasPendingApproval: Boolean(state.pendingConfirmation),
+        hasPendingUserInput: Boolean(state.pendingUserInput),
+        shouldDefer: shouldDeferCodexInboundMessage({
+            adapter: options.adapter,
+            status: adapterState.status,
+            activeTurnOrigin: adapterState.activeTurnOrigin,
+            hasPendingConfirmation: Boolean(state.pendingConfirmation),
+            hasSystemCommand: Boolean(systemCommand),
+        }),
+        onUnauthorized: async () => undefined,
+        handleCommand: async () => false,
+        remindPendingApproval: async () => {
+            await queueWechatMessage(message.senderId, formatPendingApprovalReminder(stateStore.getState().pendingConfirmation, adapter.getState()));
+        },
+        remindPendingUserInput: async () => {
+            const pendingUserInput = stateStore.getState().pendingUserInput;
+            await queueWechatMessage(message.senderId, pendingUserInput
+                ? formatPendingUserInputReminder(pendingUserInput)
+                : `${options.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`);
+        },
+        remindBusy: async () => {
+            const currentState = adapter.getState();
+            if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
+                currentState.activeTurnOrigin === "local") {
+                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;
+            }
+            await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+        },
+        defer: async () => {
+            await deferInboundMessage(message);
+        },
+        dispatch: async () => {
+            return await dispatchInboundWechatText({
+                message,
+                options,
+                stateStore,
+                adapter,
+            });
+        },
     });
+    return routeResult.kind === "dispatched" ? routeResult.result : null;
 }
 async function dispatchInboundWechatText(params) {
     const { message, options, stateStore, adapter } = params;

package/dist/bridge/wechat-forwarding.js

@@ -1,58 +1,2 @@
-import { truncatePreview } from "./bridge-utils.js";
-import { classifyWechatTransportError, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
-export const WECHAT_SEND_MAX_ATTEMPTS = 3;
-const WECHAT_SEND_RETRY_BASE_MS = 750;
-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" && adapter !== "pi") {
-        return true;
-    }
-    switch (eventType) {
-        case "stdout":
-        case "stderr":
-        case "thread_switched":
-            return false;
-        case "notice":
-            return adapter === "pi" || /^OpenCode local draft:\s*/i.test(options.text ?? "");
-        case "mirrored_user_input":
-            return true;
-        default:
-            return true;
-    }
-}
-export function formatUserFacingInboundError(params) {
-    const { adapter, cwd, errorText } = params;
-    if (adapter === "opencode" &&
-        /opencode companion is not connected/i.test(errorText)) {
-        return cwd
-            ? `OpenCode is not connected for workspace:\n${cwd}\nRun "wechat-opencode" in that directory to recreate or reconnect the visible terminal.`
-            : 'OpenCode is not connected. Run "wechat-opencode" in this directory, then retry.';
-    }
-    return `Bridge error: ${errorText}`;
-}
-export function formatWechatSendFailureLogEntry(params) {
-    return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
-}
-export function formatWechatContextTokenStaleLogEntry(params) {
-    return `wechat_context_token_stale: context=${params.context} recipient=${params.recipientId} action=wechat_message_required error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
-}
-export 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)}`;
-}
-export function isRetryableWechatSendError(error) {
-    if (isWechatContextTokenStaleError(error)) {
-        return false;
-    }
-    const classification = classifyWechatTransportError(error);
-    if (classification.retryable) {
-        return true;
-    }
-    const details = describeWechatTransportError(error);
-    return /^(?:Error|WechatApiResponseError): sendmessage failed:/i.test(details) &&
-        !/errcode=-14\b.*session timeout/i.test(details);
-}
-export function computeWechatSendRetryDelayMs(attempt) {
-    return WECHAT_SEND_RETRY_BASE_MS * attempt;
-}
+/** @deprecated Import from ../channels/wechat/wechat-forwarding.ts instead. */
+export * from "../channels/wechat/wechat-forwarding.js";

package/dist/bridge/wechat-outbound-queue.js

@@ -0,0 +1,2 @@
+/** @deprecated Import from ../channels/wechat/wechat-outbound-queue.ts instead. */
+export * from "../channels/wechat/wechat-outbound-queue.js";