cli-wechat-bridge 1.1.6 → 1.1.7

package/dist/daemon/wechat-daemon.js

@@ -17,12 +17,17 @@ import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureChannelDataD
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix, listBindings, loadEmojiBindings, parseEmojiBindingsCommand, removeBinding, resolveEmojiCommand, setBinding, } from "./emoji-bindings.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, describeWechatTransportError, isWechatContextTokenStaleError, WeChatTransport, } 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 { 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 { clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, readLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
 import { attachDaemonRequestListener, buildDaemonToken, clearDaemonEndpoint, DAEMON_PROTOCOL_VERSION, isPidAlive, readDaemonEndpoint, sendDaemonRequest, sendDaemonResponse, writeDaemonEndpoint, } from "./daemon-link.js";
 const MODULE_FILE = fileURLToPath(import.meta.url);
@@ -40,11 +45,15 @@ const DAEMON_TAKEOVER_STOP_POLL_MS = 250;
 const VISIBLE_CLIENT_CONNECT_TIMEOUT_MS = 15_000;
 const VISIBLE_CLIENT_CONNECT_POLL_MS = 250;
 const DAEMON_ADAPTERS = ["codex", "claude", "opencode", "pi"];
+function getCliChannelId(argv = process.argv.slice(2)) {
+    const index = argv.indexOf("--channel");
+    return index >= 0 && argv[index + 1] === "wecom" ? "wecom" : "wechat";
+}
 function log(message) {
-    process.stderr.write(`[wechat-daemon] ${message}\n`);
+    process.stderr.write(`[${getCliChannelId()}-daemon] ${message}\n`);
 }
 function logError(message) {
-    process.stderr.write(`[wechat-daemon] ERROR: ${message}\n`);
+    process.stderr.write(`[${getCliChannelId()}-daemon] ERROR: ${message}\n`);
 }
 function appendDaemonLog(message) {
     ensureChannelDataDir();
@@ -55,6 +64,48 @@ function computePollRetryDelayMs(consecutiveFailures) {
     const exponent = Math.min(normalizedFailures - 1, 5);
     return Math.min(POLL_RETRY_MAX_MS, POLL_RETRY_BASE_MS * 2 ** exponent);
 }
+function toWecomOutputKind(context) {
+    switch (context) {
+        case "notice":
+        case "thinking":
+        case "final_reply":
+        case "approval_required":
+        case "user_input_required":
+        case "task_failed":
+        case "fatal_error":
+            return context;
+        case "mirrored_user_input":
+            return "mirrored_input";
+        default:
+            return "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 isDaemonAdapterKind(value) {
     return value === "codex" || value === "claude" || value === "opencode" || value === "pi";
 }
@@ -76,6 +127,7 @@ export function parseDaemonCliArgs(argv) {
     let profile;
     let initialAdapter;
     let openVisible = true;
+    let channelId = "wechat";
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (!arg) {
@@ -84,10 +136,10 @@ export function parseDaemonCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
-                "Usage: wechat-daemon [--cwd <path>] [--adapter <codex|claude|opencode|pi>] [--profile <name-or-path>] [--no-open]",
+                `Usage: ${channelId}-daemon [--cwd <path>] [--adapter <codex|claude|opencode|pi>] [--profile <name-or-path>] [--no-open]`,
                 "",
-                "Keeps one WeChat connection alive and switches between Codex, Claude Code, OpenCode, and Pi from WeChat.",
-                "Send /codex, /claude, /opencode, or /pi in WeChat to switch the active terminal.",
+                `Keeps one ${channelId === "wecom" ? "WeCom" : "WeChat"} connection alive and switches between Codex, Claude Code, OpenCode, and Pi.`,
+                `Send /codex, /claude, /opencode, or /pi in ${channelId === "wecom" ? "WeCom" : "WeChat"} to switch the active terminal.`,
                 "",
             ].join("\n"));
             process.exit(0);
@@ -100,6 +152,14 @@ export function parseDaemonCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--channel") {
+            if (!next || (next !== "wechat" && next !== "wecom")) {
+                throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
+            }
+            channelId = next;
+            i += 1;
+            continue;
+        }
         if (arg === "--adapter") {
             if (!isDaemonAdapterKind(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
@@ -122,7 +182,13 @@ export function parseDaemonCliArgs(argv) {
         }
         throw new Error(`Unknown argument: ${arg}`);
     }
-    return { cwd, profile, initialAdapter, openVisible };
+    return {
+        cwd,
+        profile,
+        initialAdapter,
+        openVisible,
+        ...(channelId === "wecom" ? { channelId } : {}),
+    };
 }
 export function parseDaemonSwitchCommand(text) {
     const normalized = text.trim().toLowerCase();
@@ -221,7 +287,7 @@ export function buildVisibleClientLaunchArgs(params) {
 export function buildWindowsVisibleClientLaunchCommand(params) {
     return [
         "start",
-        quoteWindowsCommandArg(`wechat-${params.adapter}`),
+        quoteWindowsCommandArg(`${params.channelId ?? "wechat"}-${params.adapter}`),
         "/D",
         quoteWindowsCommandArg(params.cwd),
         quoteWindowsCommandArg(process.execPath),
@@ -269,6 +335,7 @@ function openVisibleClient(params) {
                 adapter: params.adapter,
                 cwd: params.cwd,
                 args,
+                channelId: params.channelId,
             }),
         ];
         const child = spawn(command, launchArgs, {
@@ -289,7 +356,7 @@ function openVisibleClient(params) {
             pid: child.pid,
         };
     }
-    const title = `wechat-${params.adapter}`;
+    const title = `${params.channelId ?? "wechat"}-${params.adapter}`;
     const fullArgs = [process.execPath, ...args];
     if (process.platform === "darwin") {
         const cmdLine = fullArgs.map(shellQuotePosix).join(" ");
@@ -486,6 +553,10 @@ class WechatDaemon {
     profile;
     authorizedUserId;
     transport;
+    channelId;
+    wecomTransport;
+    currentInboundConversation = null;
+    handlingInboundMessage = false;
     slots = new Map();
     // Per-adapter serialization chains for ensureSlot (see ensureSlot comment).
     slotEnsureChains = new Map();
@@ -506,7 +577,19 @@ class WechatDaemon {
         this.profile = params.profile;
         this.authorizedUserId = params.authorizedUserId;
         this.transport = params.transport;
-        this.pendingWechatMessages = new PendingWechatMessageStore(getPendingWechatMessagesFile(this.cwd));
+        this.channelId = params.channelId ?? "wechat";
+        this.wecomTransport = params.wecomTransport ?? null;
+        if (this.channelId === "wecom") {
+            this.currentInboundConversation = {
+                channelId: "wecom",
+                conversationId: params.authorizedUserId,
+                recipientId: params.authorizedUserId,
+                metadata: { chatType: "direct" },
+            };
+        }
+        this.pendingWechatMessages = new PendingWechatMessageStore(this.channelId === "wechat"
+            ? getPendingWechatMessagesFile(this.cwd)
+            : getPendingChannelMessagesFile(this.cwd, this.channelId));
     }
     async startIpcServer() {
         this.endpointToken = buildDaemonToken();
@@ -554,6 +637,7 @@ class WechatDaemon {
                     token: this.endpointToken,
                     cwd: this.cwd,
                     startedAt: this.startedAt,
+                    channelId: this.channelId,
                 });
                 resolve();
             });
@@ -562,6 +646,7 @@ class WechatDaemon {
     getStatus() {
         return {
             cwd: this.cwd,
+            channelId: this.channelId,
             activeAdapter: this.activeAdapter ?? undefined,
             startedAt: this.startedAt,
             slots: Array.from(this.slots.values()).map((slot) => {
@@ -590,10 +675,52 @@ class WechatDaemon {
     }
     async runPollLoop() {
         let consecutivePollFailures = 0;
-        log("WeChat daemon is ready.");
+        if (this.wecomTransport) {
+            this.wecomTransport.setHandlers({
+                onMessage: async (channelMessage) => {
+                    if (this.shutdownPromise) {
+                        return;
+                    }
+                    this.currentInboundConversation = channelMessage.conversation;
+                    this.handlingInboundMessage = true;
+                    try {
+                        if (this.pendingWechatMessages.list().length > 0) {
+                            await this.flushPendingWechatMessages();
+                        }
+                        await this.handleInboundMessage(toLegacyInboundWechatMessage(channelMessage));
+                    }
+                    finally {
+                        this.handlingInboundMessage = false;
+                    }
+                },
+                onUnauthorized: async (senderId, chatType) => {
+                    appendDaemonLog(`wecom_unauthorized: sender=${senderId} chat_type=${chatType}`);
+                    if (chatType === "direct") {
+                        await this.wecomTransport.sendText({
+                            channelId: "wecom",
+                            conversationId: senderId,
+                            recipientId: senderId,
+                            metadata: { chatType: "direct" },
+                        }, "Unauthorized.", "notice");
+                    }
+                },
+                onFatal: async (error) => {
+                    appendDaemonLog(`wecom_fatal_error: ${error.message}`);
+                    await this.shutdown();
+                },
+                onConnected: async () => {
+                    if (this.pendingWechatMessages.list().length > 0) {
+                        await this.flushPendingWechatMessages();
+                    }
+                },
+            });
+            this.wecomTransport.start();
+            await this.wecomTransport.waitUntilConnected();
+        }
+        log(`${this.channelId === "wecom" ? "WeCom" : "WeChat"} daemon is ready.`);
         log(`Working directory: ${this.cwd}`);
-        log("Switch from WeChat with /codex, /claude, /opencode, or /pi.");
-        appendDaemonLog(`started: cwd=${this.cwd}`);
+        log(`Switch from ${this.channelId === "wecom" ? "WeCom" : "WeChat"} with /codex, /claude, /opencode, or /pi.`);
+        appendDaemonLog(`started: channel=${this.channelId} cwd=${this.cwd}`);
         const activeSlot = this.getActiveSlot();
         const welcomeText = t("daemon.welcome", {
             cwd: this.cwd,
@@ -601,6 +728,13 @@ class WechatDaemon {
             bindings: formatBindingsListMessage(listBindings()),
         });
         await this.queueWechatMessage(this.authorizedUserId, welcomeText);
+        if (this.channelId === "wecom") {
+            while (!this.shutdownPromise) {
+                await delay(1_000);
+            }
+            await this.shutdownPromise;
+            return;
+        }
         while (!this.shutdownPromise) {
             let pollResult;
             try {
@@ -705,6 +839,12 @@ class WechatDaemon {
         await this.waitForPendingWechatForwardTasks();
         await this.textSendChain.catch(() => undefined);
         await this.attachmentSendChain.catch(() => undefined);
+        try {
+            this.wecomTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         for (const slot of this.slots.values()) {
             try {
                 await slot.runtime.dispose();
@@ -736,7 +876,7 @@ class WechatDaemon {
                 return { shuttingDown: true };
             case "ensure_slot":
                 if (!isSameWorkspaceCwd(request.cwd, this.cwd)) {
-                    throw new Error(`wechat-daemon is bound to ${this.cwd}; requested cwd was ${request.cwd}.`);
+                    throw new Error(`${this.channelId}-daemon is bound to ${this.cwd}; requested cwd was ${request.cwd}.`);
                 }
                 return await this.ensureSlot(request.adapter, {
                     profile: request.profile,
@@ -828,6 +968,7 @@ class WechatDaemon {
                 cwd: this.cwd,
                 sessionStartMode,
                 cliArgs: options.cliArgs,
+                channelId: this.channelId,
                 onError: (error) => {
                     appendDaemonLog(`visible_client_open_error: adapter=${adapter} error=${truncatePreview(error.message, 400)}`);
                 },
@@ -937,6 +1078,16 @@ class WechatDaemon {
         slot.controller.syncLocalClientEndpoint();
     }
     createWechatChannelPort(adapter) {
+        if (this.channelId === "wecom") {
+            return new WecomChannelPort({
+                transport: this.wecomTransport,
+                sendText: (target, text, kind) => this.queueWechatMessage(this.authorizedUserId, text, toWechatSendContext(kind), target),
+                prefixText: (currentAdapter, text) => prefixDaemonAdapterMessage(currentAdapter ?? adapter, text),
+                onEmptyVisibleReply: (currentAdapter, rawText) => {
+                    appendDaemonLog(`empty_visible_final_reply: adapter=${currentAdapter ?? adapter} raw=${truncatePreview(rawText)}`);
+                },
+            });
+        }
         return new WechatChannelPort({
             sendText: (recipientId, text, context) => this.queueWechatMessage(recipientId, text, context),
             sendImage: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendImage(filePath, { recipientId })),
@@ -981,11 +1132,15 @@ class WechatDaemon {
                 appendDaemonLog(`final_reply: adapter=${slot.adapter} text=${truncatePreview(next.text)}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                     await channelPort.send({
-                        target: {
-                            channelId: "wechat",
-                            conversationId: this.authorizedUserId,
-                            recipientId: this.authorizedUserId,
-                        },
+                        target: this.channelId === "wecom"
+                            ? slot.activeConversation ??
+                                slot.lastConversation ??
+                                this.currentInboundConversation
+                            : {
+                                channelId: "wechat",
+                                conversationId: this.authorizedUserId,
+                                recipientId: this.authorizedUserId,
+                            },
                         kind: "final_reply",
                         text: next.text,
                         adapter: slot.adapter,
@@ -1064,6 +1219,7 @@ class WechatDaemon {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
                     slot.activeTask = null;
+                    slot.activeConversation = undefined;
                 }));
             },
             taskFailed: (next) => {
@@ -1071,6 +1227,7 @@ class WechatDaemon {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
                     slot.activeTask = null;
+                    slot.activeConversation = undefined;
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatTaskFailedMessage(slot.adapter, next.message)), "task_failed");
                 }));
             },
@@ -1080,6 +1237,7 @@ class WechatDaemon {
                 slot.pendingConfirmations = [];
                 slot.pendingUserInput = null;
                 slot.activeTask = null;
+                slot.activeConversation = undefined;
                 this.disposeDeadSlot(slot);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserFacingBridgeFatalError(next.message)), "fatal_error");
@@ -1094,9 +1252,17 @@ class WechatDaemon {
             appendDaemonLog(`event_forward_failed: adapter=${slot.adapter} message=${message}`);
         });
     }
+    bindCurrentWecomConversation(slot) {
+        if (this.channelId !== "wecom" || !slot || !this.currentInboundConversation) {
+            return;
+        }
+        slot.lastConversation = this.currentInboundConversation;
+    }
     async handleInboundMessage(message) {
         if (message.senderId !== this.authorizedUserId) {
-            await this.queueWechatMessage(message.senderId, "Unauthorized. This daemon only accepts messages from the configured WeChat owner.");
+            await this.queueWechatMessage(message.senderId, this.channelId === "wecom"
+                ? "Unauthorized. This daemon only accepts messages from the paired WeCom operator."
+                : "Unauthorized. This daemon only accepts messages from the configured WeChat owner.");
             return;
         }
         const emojiMatch = resolveEmojiCommand(message.text);
@@ -1108,6 +1274,7 @@ class WechatDaemon {
                     reuseExistingVisible: true,
                 });
                 if (result.activated) {
+                    this.bindCurrentWecomConversation(this.getActiveSlot());
                     message = { ...message, text: emojiMatch.remainder };
                 }
                 else {
@@ -1134,6 +1301,7 @@ class WechatDaemon {
                 await this.queueWechatMessage(message.senderId, `Could not activate terminal: ${switchDirective.adapter}.\n${detail}`);
                 return;
             }
+            this.bindCurrentWecomConversation(this.getActiveSlot());
             if (switchDirective.remainder) {
                 message = { ...message, text: switchDirective.remainder };
             }
@@ -1143,7 +1311,7 @@ class WechatDaemon {
             }
         }
         if (message.text.trim().toLowerCase() === "/daemon-stop") {
-            await this.queueWechatMessage(message.senderId, "Stopping wechat-daemon...");
+            await this.queueWechatMessage(message.senderId, `Stopping ${this.channelId}-daemon...`);
             setTimeout(() => {
                 void this.shutdown().finally(() => process.exit(0));
             }, 0);
@@ -1163,7 +1331,9 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, formatNoActiveAdapterMessage());
             return;
         }
+        this.bindCurrentWecomConversation(slot);
         const routeCurrentMessage = async (currentSlot, command) => {
+            const previousTask = currentSlot.activeTask;
             await routeBridgeMessage({
                 message: toChannelInboundMessage(message),
                 authorized: true,
@@ -1192,6 +1362,13 @@ class WechatDaemon {
                     await this.dispatchInboundWechatText(message, currentSlot);
                 },
             });
+            if (this.channelId === "wecom" &&
+                this.currentInboundConversation &&
+                currentSlot.activeTask &&
+                currentSlot.activeTask !== previousTask) {
+                currentSlot.activeConversation = this.currentInboundConversation;
+                currentSlot.lastConversation = this.currentInboundConversation;
+            }
         };
         const command = parseWechatControlCommand(message.text, {
             adapter: slot.adapter,
@@ -1215,6 +1392,7 @@ class WechatDaemon {
             return;
         }
         slot = this.getActiveSlot() ?? slot;
+        this.bindCurrentWecomConversation(slot);
         await routeCurrentMessage(slot, null);
     }
     async handleEmojiBindingsCommand(senderId, cmd) {
@@ -1244,7 +1422,7 @@ class WechatDaemon {
                 return;
             case "resume": {
                 if (!isWechatResumeEnabled(activeSlot.adapter)) {
-                    await this.queueWechatMessage(message.senderId, `WeChat /resume is disabled for ${activeSlot.adapter} in daemon mode. Use /resume directly inside the visible terminal; WeChat will follow that local session.`);
+                    await this.queueWechatMessage(message.senderId, `${this.channelId === "wecom" ? "WeCom" : "WeChat"} /resume is disabled for ${activeSlot.adapter} in daemon mode. Use /resume directly inside the visible terminal; the remote channel will follow that local session.`);
                     return;
                 }
                 try {
@@ -1408,7 +1586,9 @@ class WechatDaemon {
             inputPreview: truncatePreview(preview, 180),
         };
         appendDaemonLog(`forwarded_input: adapter=${slot.adapter} text=${truncatePreview(preview)}`);
-        await slot.runtime.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
+        await slot.runtime.sendInput(this.channelId === "wecom"
+            ? buildWecomInboundPrompt(message.text, message.attachments)
+            : buildWechatInboundPrompt(message.text, message.attachments));
     }
     queueWechatTextAction(action) {
         const run = this.textSendChain.then(action);
@@ -1420,7 +1600,37 @@ class WechatDaemon {
         this.attachmentSendChain = run.then(() => undefined, () => undefined);
         return run;
     }
-    async sendWechatMessageNow(senderId, text, context = "message") {
+    async sendWechatMessageNow(senderId, text, context = "message", targetOverride) {
+        if (this.channelId === "wecom") {
+            const activeSlot = this.getActiveSlot();
+            const target = targetOverride ??
+                (senderId === this.authorizedUserId
+                    ? (this.handlingInboundMessage
+                        ? this.currentInboundConversation
+                        : null) ??
+                        activeSlot?.activeConversation ??
+                        activeSlot?.lastConversation ??
+                        this.currentInboundConversation
+                    : {
+                        channelId: "wecom",
+                        conversationId: senderId,
+                        recipientId: senderId,
+                        metadata: { chatType: "direct" },
+                    });
+            const startedAtMs = Date.now();
+            appendDaemonLog(`wecom_send_started: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
+            try {
+                await this.wecomTransport.sendText(target, formatWecomVisibleText(text), toWecomOutputKind(context));
+                appendDaemonLog(`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);
+                appendDaemonLog(`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();
         appendDaemonLog(`wechat_send_started: context=${context} recipient=${senderId} chars=${Array.from(text).length}`);
         for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
@@ -1467,11 +1677,11 @@ class WechatDaemon {
         }
         return { status: "failed" };
     }
-    queueWechatMessage(senderId, text, context = "message") {
+    queueWechatMessage(senderId, text, context = "message", targetOverride) {
         return this.queueWechatTextAction(async () => {
-            const result = await this.sendWechatMessageNow(senderId, text, context);
+            const result = await this.sendWechatMessageNow(senderId, text, context, targetOverride);
             if (result.status === "context_unavailable") {
-                const pending = this.pendingWechatMessages.enqueue(senderId, text, context);
+                const pending = this.pendingWechatMessages.enqueue(senderId, text, context, result.target);
                 if (pending) {
                     appendDaemonLog(`wechat_send_queued: id=${pending.id} context=${context} recipient=${senderId} pending=${this.pendingWechatMessages.list().length}`);
                 }
@@ -1482,7 +1692,7 @@ class WechatDaemon {
     flushPendingWechatMessages() {
         return this.queueWechatTextAction(async () => {
             for (const pending of this.pendingWechatMessages.list()) {
-                const result = await this.sendWechatMessageNow(pending.recipientId, pending.text, pending.context);
+                const result = await this.sendWechatMessageNow(pending.recipientId, pending.text, pending.context, pending.target);
                 if (result.status === "sent") {
                     this.pendingWechatMessages.remove(pending.id);
                     appendDaemonLog(`wechat_pending_sent: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
@@ -1793,7 +2003,9 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     return { action: "stopped", lock, forced };
 }
 export async function runDaemon(options) {
-    migrateLegacyChannelFiles((message) => log(message));
+    if ((options.channelId ?? "wechat") === "wechat") {
+        migrateLegacyChannelFiles((message) => log(message));
+    }
     loadEmojiBindings();
     await cleanupDaemonBeforeStart({ cwd: options.cwd });
     const cleanupResult = await cleanupSingleBridgeBeforeDaemon();
@@ -1809,19 +2021,36 @@ export async function runDaemon(options) {
     if (reapedOpencodePids.length > 0) {
         log(`Cleaned ${reapedOpencodePids.length} orphaned OpenCode process(es): ${reapedOpencodePids.join(", ")}`);
     }
-    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 daemon = new WechatDaemon({
         cwd: options.cwd,
         profile: options.profile,
         authorizedUserId: credentials.userId,
         transport: new WeChatTransport({ log, logError }),
+        channelId: options.channelId,
+        wecomTransport: wecomAccount
+            ? new WecomTransport({
+                account: wecomAccount,
+                logger: {
+                    log: (message) => log(message),
+                    error: (message) => logError(message),
+                },
+            })
+            : null,
     });
     if (cleanupResult.action === "stopped" && isDaemonAdapterKind(cleanupResult.lock.adapter)) {
         daemon.takenOverAdapter = cleanupResult.lock.adapter;
@@ -1871,7 +2100,7 @@ export async function main(argv = process.argv.slice(2)) {
         process.exit(1);
     }
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     void main();
 }

package/dist/i18n/messages-en.js

@@ -59,6 +59,7 @@ export const messages = {
     "doctor.label.codePage": "Console code page",
     "doctor.codePage.nonAsciiWarning": "{codePage} (not UTF-8 and the data directory path contains non-ASCII characters; hook scripts from older versions break in this environment — upgrade to the latest release)",
     "doctor.label.connectivity": "WeChat connectivity",
+    "doctor.label.wecomConnectivity": "WeCom connectivity",
     "doctor.connectivity.ok": "reachable ({baseUrl})",
     "doctor.connectivity.unreachable": "cannot reach {baseUrl} (check network and firewall)",
     "doctor.connectivity.proxyHint": "cannot reach {baseUrl}. Proxy {proxy} detected, but Node fetch ignores proxy environment variables by default; if your network requires the proxy, set NODE_USE_ENV_PROXY=1 and retry.",
@@ -82,6 +83,7 @@ export const messages = {
     "doctor.dataDirMissing": "(will be created on first run)",
     "doctor.credentialsFound": "found",
     "doctor.credentialsMissing": "not found (run wechat-setup first)",
+    "doctor.credentialsMissingWecom": "not found (run wecom-setup first)",
     "doctor.mode.bridge": "standalone bridge",
     "doctor.mode.generic": "generic",
     "doctor.notSpecified": "(not specified)",

package/dist/i18n/messages-zh.js

@@ -59,6 +59,7 @@ export const messages = {
     "doctor.label.codePage": "控制台代码页",
     "doctor.codePage.nonAsciiWarning": "{codePage}（非 UTF-8，且数据目录路径含非 ASCII 字符；旧版本的 hook 脚本在此环境下会乱码失效，请升级到最新版本）",
     "doctor.label.connectivity": "微信服务可达性",
+    "doctor.label.wecomConnectivity": "企业微信服务可达性",
     "doctor.connectivity.ok": "可达 ({baseUrl})",
     "doctor.connectivity.unreachable": "无法访问 {baseUrl}（检查网络与防火墙）",
     "doctor.connectivity.proxyHint": "无法访问 {baseUrl}。检测到代理 {proxy}，但 Node fetch 默认不使用代理环境变量；若必须经代理出网，请设置 NODE_USE_ENV_PROXY=1 后重试。",
@@ -82,6 +83,7 @@ export const messages = {
     "doctor.dataDirMissing": "(首次运行会创建)",
     "doctor.credentialsFound": "已找到",
     "doctor.credentialsMissing": "未找到 (先运行 wechat-setup)",
+    "doctor.credentialsMissingWecom": "未找到 (先运行 wecom-setup)",
     "doctor.mode.bridge": "独立桥接",
     "doctor.mode.generic": "通用",
     "doctor.notSpecified": "(未指定)",