cli-wechat-bridge 1.1.6 → 1.1.7

package/dist/bridge/wechat-bridge.js

@@ -13,10 +13,15 @@ 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 { isDirectModuleRun } from "../core/direct-run.js";
 import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
+import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { WecomChannelPort } from "../channels/wecom/wecom-channel-port.js";
+import { WecomTransport } from "../channels/wecom/wecom-transport.js";
+import { buildWecomInboundPrompt, formatWecomVisibleText, } from "../channels/wecom/wecom-message.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 { getPendingChannelMessagesFile, 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";
 const POLL_RETRY_BASE_MS = 1_000;
@@ -105,6 +110,7 @@ export function parseCliArgs(argv) {
     let profile;
     let lifecycle = "persistent";
     let sessionStartMode = "restore";
+    let channelId = "wechat";
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         const next = argv[i + 1];
@@ -151,6 +157,13 @@ export function parseCliArgs(argv) {
                 sessionStartMode = next;
                 i += 1;
                 break;
+            case "--channel":
+                if (!next || (next !== "wechat" && next !== "wecom")) {
+                    throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
+                }
+                channelId = next;
+                i += 1;
+                break;
             case "--shutdown-on-parent-exit":
                 lifecycle = "companion_bound";
                 break;
@@ -173,6 +186,51 @@ export function parseCliArgs(argv) {
         profile,
         lifecycle,
         sessionStartMode,
+        channelId,
+    };
+}
+function toWecomOutputKind(context) {
+    const known = new Set([
+        "status",
+        "notice",
+        "thinking",
+        "final_reply",
+        "approval_required",
+        "user_input_required",
+        "mirrored_input",
+        "task_failed",
+        "fatal_error",
+    ]);
+    return known.has(context)
+        ? context
+        : context === "mirrored_user_input"
+            ? "mirrored_input"
+            : "notice";
+}
+function toWechatSendContext(kind) {
+    if (kind === "mirrored_input") {
+        return "mirrored_user_input";
+    }
+    if (kind === "status") {
+        return "message";
+    }
+    return kind;
+}
+function toLegacyInboundWechatMessage(message) {
+    return {
+        senderId: message.senderId,
+        sender: message.senderId,
+        sessionId: message.conversation.conversationId,
+        text: message.text,
+        attachments: message.attachments.map((attachment) => ({
+            kind: attachment.kind === "image" ? "image" : "file",
+            path: attachment.path,
+            fileName: attachment.fileName || path.basename(attachment.path),
+            sizeBytes: attachment.sizeBytes ?? 0,
+        })),
+        contextToken: message.conversation.opaqueRef,
+        createdAt: message.createdAt,
+        createdAtMs: Date.parse(message.createdAt),
     };
 }
 function printUsageAndExit() {
@@ -180,7 +238,7 @@ function printUsageAndExit() {
         "Internal bridge runtime usage:",
         "  npm run bridge -- --adapter <codex|claude|opencode|pi> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
         "",
-        "This entry is internal. Users should run wechat-codex, wechat-claude, wechat-opencode, wechat-pi, or wechat-daemon.",
+        "This entry is internal. Users should run a wechat-* or wecom-* launcher.",
         "",
     ].join("\n"));
     process.exit(0);
@@ -194,21 +252,37 @@ async function main() {
     const options = parseCliArgs(process.argv.slice(2));
     const daemonEndpoint = readDaemonEndpoint();
     if (daemonEndpoint && await isDaemonEndpointAlive(daemonEndpoint, { timeoutMs: 500 })) {
-        throw new Error(`wechat-daemon is already running (pid=${daemonEndpoint.pid}, cwd=${daemonEndpoint.cwd}). Stop it before starting a standalone bridge.`);
+        throw new Error(`${daemonEndpoint.channelId ?? "wechat"}-daemon is already running (pid=${daemonEndpoint.pid}, cwd=${daemonEndpoint.cwd}). Stop it before starting a standalone bridge.`);
     }
     if (daemonEndpoint) {
         clearDaemonEndpoint(daemonEndpoint.pid);
         log(`Cleared stale wechat-daemon endpoint for pid=${daemonEndpoint.pid}.`);
     }
-    const credentials = await ensureWechatCredentials({
-        requireUserId: true,
-        validateExisting: true,
-        log,
-    });
+    const wecomAccount = options.channelId === "wecom"
+        ? await ensureWecomAccount({ log })
+        : null;
+    const credentials = wecomAccount
+        ? { userId: wecomAccount.operatorUserId }
+        : await ensureWechatCredentials({
+            requireUserId: true,
+            validateExisting: true,
+            log,
+        });
     if (!credentials.userId) {
-        throw new Error("Saved WeChat credentials are missing userId.");
+        throw new Error(options.channelId === "wecom"
+            ? "Saved WeCom credentials are missing operatorUserId."
+            : "Saved WeChat credentials are missing userId.");
     }
     const transport = new WeChatTransport({ log, logError });
+    const wecomTransport = wecomAccount
+        ? new WecomTransport({
+            account: wecomAccount,
+            logger: {
+                log: (message) => log(message),
+                error: (message) => logError(message),
+            },
+        })
+        : null;
     // 非阻塞地检查更新（不影响启动速度，也避免首次登录时打断二维码输出）
     // unref：不能让这个延迟检查把 event loop 挂活（如 --doctor 或快速退出场景），
     // 否则会与强制退出 teardown 竞态。
@@ -227,6 +301,7 @@ async function main() {
     const stateStore = new BridgeStateStore({
         ...options,
         authorizedUserId: credentials.userId,
+        channelId: options.channelId,
     });
     const reapedPeerPids = await reapPeerBridgeProcesses({
         logger: (message) => stateStore.appendLog(message),
@@ -273,7 +348,9 @@ async function main() {
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,
     });
-    const pendingWechatMessages = new PendingWechatMessageStore(getPendingWechatMessagesFile(options.cwd));
+    const pendingWechatMessages = new PendingWechatMessageStore(options.channelId === "wechat"
+        ? getPendingWechatMessagesFile(options.cwd)
+        : getPendingChannelMessagesFile(options.cwd, options.channelId));
     const resumeCoordinator = new ResumeSessionCoordinator({
         adapter: options.adapter,
         runtime: adapter,
@@ -285,6 +362,15 @@ async function main() {
     let attachmentSendChain = Promise.resolve();
     const pendingWechatForwardTasks = new Set();
     let activeTask = null;
+    let currentWecomConversation = null;
+    let activeWecomConversation = null;
+    let lastWecomConversation = {
+        channelId: "wecom",
+        accountId: wecomAccount?.botId,
+        conversationId: credentials.userId,
+        recipientId: credentials.userId,
+        metadata: { chatType: "direct" },
+    };
     const deferredInboundMessages = [];
     let drainingDeferredInboundMessages = false;
     let consecutivePollFailures = 0;
@@ -299,7 +385,34 @@ async function main() {
         attachmentSendChain = run.then(() => undefined, () => undefined);
         return run;
     };
-    const sendWechatMessageNow = async (senderId, text, context = "message") => {
+    const sendWechatMessageNow = async (senderId, text, context = "message", targetOverride) => {
+        if (options.channelId === "wecom") {
+            const target = targetOverride ??
+                (senderId === credentials.userId
+                    ? currentWecomConversation ??
+                        activeWecomConversation ??
+                        lastWecomConversation
+                    : {
+                        channelId: "wecom",
+                        accountId: wecomAccount?.botId,
+                        conversationId: senderId,
+                        recipientId: senderId,
+                        metadata: { chatType: "direct" },
+                    });
+            const startedAtMs = Date.now();
+            stateStore.appendLog(`wecom_send_started: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
+            try {
+                await wecomTransport.sendText(target, formatWecomVisibleText(text), toWecomOutputKind(context));
+                stateStore.appendLog(`wecom_send_completed: context=${context} recipient=${target.recipientId} elapsed_ms=${Date.now() - startedAtMs}`);
+                return { status: "sent" };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                stateStore.appendLog(`wecom_send_failed: context=${context} recipient=${target.recipientId} error=${truncatePreview(message, 400)}`);
+                logError(`Failed to send WeCom ${context}: ${message}`);
+                return { status: "context_unavailable", error, target };
+            }
+        }
         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) {
@@ -355,11 +468,11 @@ async function main() {
         }
         return { status: "failed" };
     };
-    const queueWechatMessage = (senderId, text, context = "message") => {
+    const queueWechatMessage = (senderId, text, context = "message", targetOverride) => {
         return queueWechatTextAction(async () => {
-            const result = await sendWechatMessageNow(senderId, text, context);
+            const result = await sendWechatMessageNow(senderId, text, context, targetOverride);
             if (result.status === "context_unavailable") {
-                const pending = pendingWechatMessages.enqueue(senderId, text, context);
+                const pending = pendingWechatMessages.enqueue(senderId, text, context, result.target);
                 if (pending) {
                     stateStore.appendLog(`wechat_send_queued: id=${pending.id} context=${context} recipient=${senderId} pending=${pendingWechatMessages.list().length}`);
                 }
@@ -370,7 +483,7 @@ async function main() {
     const flushPendingWechatMessages = () => {
         return queueWechatTextAction(async () => {
             for (const pending of pendingWechatMessages.list()) {
-                const result = await sendWechatMessageNow(pending.recipientId, pending.text, pending.context);
+                const result = await sendWechatMessageNow(pending.recipientId, pending.text, pending.context, pending.target);
                 if (result.status === "sent") {
                     pendingWechatMessages.remove(pending.id);
                     stateStore.appendLog(`wechat_pending_sent: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
@@ -427,6 +540,10 @@ async function main() {
         drainingDeferredInboundMessages = true;
         try {
             stateStore.appendLog(`draining_deferred_inbound_input: remaining=${deferredInboundMessages.length} text=${truncatePreview(nextDeferred.message.text)}`);
+            if (nextDeferred.channelMessage) {
+                activeWecomConversation = nextDeferred.channelMessage.conversation;
+                lastWecomConversation = nextDeferred.channelMessage.conversation;
+            }
             const nextTask = await dispatchInboundWechatText({
                 message: nextDeferred.message,
                 options,
@@ -515,6 +632,12 @@ async function main() {
         catch {
             // Best effort shutdown.
         }
+        try {
+            wecomTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         controller.clearLocalClientEndpoint();
         stateStore.releaseLock();
     };
@@ -594,6 +717,7 @@ async function main() {
             maybeDrainDeferredInboundMessages,
             clearActiveTask: () => {
                 activeTask = null;
+                activeWecomConversation = null;
             },
             syncSharedSessionState: () => {
                 syncSharedSessionState(stateStore, adapter);
@@ -602,6 +726,8 @@ async function main() {
                 controller.syncLocalClientEndpoint();
             },
             requestShutdown,
+            wecomTransport,
+            getWecomTarget: () => activeWecomConversation ?? lastWecomConversation,
         });
         await adapter.start();
         if (!ensureRuntimeOwnership()) {
@@ -609,13 +735,98 @@ async function main() {
         }
         syncSharedSessionState(stateStore, adapter);
         controller.syncLocalClientEndpoint();
-        stateStore.appendLog(`Bridge started with adapter=${options.adapter} command=${options.command} cwd=${options.cwd}`);
-        log(`WeChat bridge is ready for adapter "${options.adapter}".`);
+        stateStore.appendLog(`Bridge started with channel=${options.channelId} adapter=${options.adapter} command=${options.command} cwd=${options.cwd}`);
+        if (wecomTransport) {
+            wecomTransport.setHandlers({
+                onMessage: async (channelMessage) => {
+                    if (shutdownPromise || !ensureRuntimeOwnership()) {
+                        return;
+                    }
+                    currentWecomConversation = channelMessage.conversation;
+                    lastWecomConversation = channelMessage.conversation;
+                    try {
+                        if (pendingWechatMessages.list().length > 0) {
+                            await flushPendingWechatMessages();
+                        }
+                        const message = toLegacyInboundWechatMessage(channelMessage);
+                        stateStore.touchActivity(message.createdAt);
+                        let nextTask = null;
+                        try {
+                            nextTask = await handleInboundMessage({
+                                message,
+                                channelMessage,
+                                options,
+                                stateStore,
+                                adapter,
+                                resumeCoordinator,
+                                queueWechatMessage,
+                                outputBatcher,
+                                clearActiveTask: () => {
+                                    activeTask = null;
+                                    activeWecomConversation = null;
+                                },
+                                deferInboundMessage: async (nextMessage) => {
+                                    deferredInboundMessages.push({
+                                        message: nextMessage,
+                                        channelMessage,
+                                    });
+                                    stateStore.appendLog(`deferred_inbound_input: position=${deferredInboundMessages.length} text=${truncatePreview(nextMessage.text)}`);
+                                    await queueWechatMessage(nextMessage.senderId, formatDeferredCodexInboundQueueMessage(deferredInboundMessages.length));
+                                },
+                            });
+                        }
+                        catch (error) {
+                            const errorText = error instanceof Error ? error.message : String(error);
+                            logError(errorText);
+                            stateStore.appendLog(`inbound_error: ${errorText}`);
+                            await queueWechatMessage(message.senderId, formatUserFacingInboundError({
+                                adapter: options.adapter,
+                                cwd: options.cwd,
+                                errorText,
+                            }), "inbound_error");
+                        }
+                        if (nextTask) {
+                            activeTask = nextTask;
+                            activeWecomConversation = channelMessage.conversation;
+                        }
+                        syncSharedSessionState(stateStore, adapter);
+                        await maybeDrainDeferredInboundMessages();
+                    }
+                    finally {
+                        currentWecomConversation = null;
+                    }
+                },
+                onUnauthorized: async (senderId, chatType) => {
+                    stateStore.appendLog(`wecom_unauthorized: sender=${senderId} chat_type=${chatType}`);
+                    if (chatType === "direct") {
+                        await wecomTransport.sendText({
+                            channelId: "wecom",
+                            accountId: wecomAccount.botId,
+                            conversationId: senderId,
+                            recipientId: senderId,
+                            metadata: { chatType: "direct" },
+                        }, "Unauthorized.", "notice");
+                    }
+                },
+                onFatal: async (error) => {
+                    stateStore.appendLog(`wecom_fatal_error: ${error.message}`);
+                    requestShutdown(error.message, 1);
+                },
+                onConnected: async () => {
+                    if (pendingWechatMessages.list().length > 0) {
+                        await flushPendingWechatMessages();
+                    }
+                },
+            });
+            wecomTransport.start();
+            await wecomTransport.waitUntilConnected();
+        }
+        log(`${options.channelId === "wecom" ? "WeCom" : "WeChat"} bridge is ready for adapter "${options.adapter}".`);
         log(`Working directory: ${options.cwd}`);
         if (options.profile) {
             log(`Profile: ${options.profile}`);
         }
-        log(`Authorized WeChat user: ${credentials.userId}`);
+        log(`Authorized ${options.channelId === "wecom" ? "WeCom" : "WeChat"} user: ${credentials.userId}`);
         if (options.adapter === "codex") {
             log("For source-mode debugging, open the visible Codex client with: npm run codex:panel");
         }
@@ -633,6 +844,12 @@ async function main() {
             cwd: options.cwd,
         });
         await queueWechatMessage(credentials.userId, welcomeText);
+        if (options.channelId === "wecom") {
+            while (!shutdownPromise && ensureRuntimeOwnership()) {
+                await delay(1_000);
+            }
+            return;
+        }
         while (true) {
             if (shutdownPromise) {
                 // Shutdown (e.g. SIGINT) was requested while we were awaiting the
@@ -763,20 +980,28 @@ 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}`);
-        },
-    });
+    const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, getWecomTarget, } = params;
+    const channelPort = options.channelId === "wecom"
+        ? new WecomChannelPort({
+            transport: wecomTransport,
+            sendText: (target, text, kind) => queueWechatMessage(stateStore.getState().authorizedUserId, text, toWechatSendContext(kind), target),
+            onEmptyVisibleReply: (adapter, rawText) => {
+                stateStore.appendLog(`empty_visible_final_reply: adapter=${adapter ?? options.adapter} raw=${truncatePreview(rawText)}`);
+            },
+        })
+        : 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) => {
@@ -808,11 +1033,13 @@ function wireAdapterEvents(params) {
                 stateStore.appendLog(`final_reply: ${truncatePreview(next.text)}`);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await channelPort.send({
-                        target: {
-                            channelId: "wechat",
-                            conversationId: authorizedUserId,
-                            recipientId: authorizedUserId,
-                        },
+                        target: options.channelId === "wecom"
+                            ? getWecomTarget()
+                            : {
+                                channelId: "wechat",
+                                conversationId: authorizedUserId,
+                                recipientId: authorizedUserId,
+                            },
                         kind: "final_reply",
                         text: next.text,
                         adapter: options.adapter,
@@ -840,7 +1067,9 @@ function wireAdapterEvents(params) {
                     if (thinkingPreview) {
                         stateStore.appendLog(`thinking: ${thinkingPreview}`);
                         trackWechatForwardTask((async () => {
-                            await queueWechatMessage(authorizedUserId, `思考: ${thinkingPreview}`, "thinking");
+                            await queueWechatMessage(authorizedUserId, options.channelId === "wecom"
+                                ? `Processing: ${thinkingPreview}`
+                                : `思考: ${thinkingPreview}`, "thinking");
                         })());
                     }
                 }
@@ -950,11 +1179,13 @@ function formatInboundMessagePreview(message) {
     return "(empty)";
 }
 async function handleInboundMessage(params) {
-    const { message, } = params;
+    const { message, channelMessage, } = 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.");
+        await queueWechatMessage(message.senderId, options.channelId === "wecom"
+            ? "Unauthorized. This bridge only accepts messages from the paired WeCom operator."
+            : "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
         return null;
     }
     const systemCommand = parseWechatControlCommand(message.text, {
@@ -968,7 +1199,7 @@ async function handleInboundMessage(params) {
             return null;
         case "resume": {
             if (!isWechatResumeEnabled(options.adapter)) {
-                await queueWechatMessage(message.senderId, `WeChat /resume is disabled in ${options.adapter} mode. Use /resume directly inside "wechat-${options.adapter}"; WeChat will follow the active local session.`);
+                await queueWechatMessage(message.senderId, `${options.channelId === "wecom" ? "WeCom" : "WeChat"} /resume is disabled in ${options.adapter} mode. Use /resume directly inside "${options.channelId}-${options.adapter}"; the remote channel will follow the active local session.`);
                 return null;
             }
             try {
@@ -1081,7 +1312,7 @@ async function handleInboundMessage(params) {
     }
     const adapterState = adapter.getState();
     const routeResult = await routeBridgeMessage({
-        message: toChannelInboundMessage(message),
+        message: channelMessage ?? toChannelInboundMessage(message),
         authorized: true,
         command: null,
         adapterState,
@@ -1136,10 +1367,12 @@ async function dispatchInboundWechatText(params) {
         inputPreview: truncatePreview(preview, 180),
     };
     stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(preview)}`);
-    await adapter.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
+    await adapter.sendInput(options.channelId === "wecom"
+        ? buildWecomInboundPrompt(message.text, message.attachments)
+        : buildWechatInboundPrompt(message.text, message.attachments));
     return activeTask;
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     main().catch((err) => {
         logError(describeWechatTransportError(err));

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

@@ -4,7 +4,10 @@ import path from "node:path";
 import { getWorkspaceChannelPaths } from "../../wechat/channel-config.js";
 import { writeJsonFileAtomic } from "../../utils/atomic-file.js";
 export function getPendingWechatMessagesFile(cwd) {
-    return path.join(getWorkspaceChannelPaths(cwd).workspaceDir, "pending-wechat-messages.json");
+    return getPendingChannelMessagesFile(cwd, "wechat");
+}
+export function getPendingChannelMessagesFile(cwd, channelId) {
+    return path.join(getWorkspaceChannelPaths(cwd).workspaceDir, `pending-${channelId}-messages.json`);
 }
 function readPendingMessages(filePath) {
     try {
@@ -38,9 +41,12 @@ export class PendingWechatMessageStore {
         this.messages = readPendingMessages(filePath);
     }
     list() {
-        return this.messages.map((message) => ({ ...message }));
+        return this.messages.map((message) => ({
+            ...message,
+            target: message.target ? { ...message.target } : undefined,
+        }));
     }
-    enqueue(recipientId, text, context) {
+    enqueue(recipientId, text, context, target) {
         const normalizedRecipientId = recipientId.trim();
         const normalizedText = text.trim();
         if (!normalizedRecipientId || !normalizedText) {
@@ -52,6 +58,7 @@ export class PendingWechatMessageStore {
             text: normalizedText,
             context,
             queuedAt: new Date().toISOString(),
+            target: target ? { ...target } : undefined,
         };
         this.messages.push(message);
         this.persist();

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

@@ -0,0 +1,26 @@
+import path from "node:path";
+import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, } from "../../bridge/bridge-utils.js";
+export async function forwardWecomFinalReply(params) {
+    const parsed = parseWechatFinalReply(params.rawText);
+    const sanitized = sanitizeWechatFinalReplyText(params.adapter, parsed.visibleText);
+    const visibleText = formatFinalReplyMessage(params.adapter, sanitized).trim();
+    if (visibleText) {
+        await params.sender.sendText(visibleText);
+    }
+    else if (params.adapter === "opencode" && parsed.visibleText.trim()) {
+        params.onEmptyVisibleReply?.(parsed.visibleText);
+        await params.sender.sendText("OpenCode did not produce a visible reply. Check the local terminal output or retry the message.");
+    }
+    for (const attachment of parsed.attachments) {
+        try {
+            await params.sender.sendAttachment({
+                kind: attachment.kind,
+                path: attachment.path,
+            });
+        }
+        catch (error) {
+            const errorText = error instanceof Error ? error.message : String(error);
+            await params.sender.sendText(`Failed to send ${attachment.kind} attachment ${path.basename(attachment.path)}: ${errorText}`);
+        }
+    }
+}

package/dist/channels/wecom/setup-cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runWecomSetup } from "./setup.js";
+runWecomSetup().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});