@unlinearity/cli-wechat-bridge 1.1.6 → 1.2.0

package/dist/channels/wecom/wecom-transport.js

@@ -0,0 +1,314 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
+import fs from "node:fs";
+import path from "node:path";
+import { generateReqId, WSAuthFailureError, WSClient, WSReconnectExhaustedError, } from "@wecom/aibot-node-sdk";
+import { tryClaimChannelInboundMessage } from "../../core/inbound-message-claims.js";
+import { downloadWecomInboundAttachments, } from "./wecom-media.js";
+import { parseWecomInboundFrame, toWecomChannelInboundMessage, } from "./wecom-message.js";
+import { WECOM_INBOUND_MESSAGE_CLAIMS_DIR, } from "./wecom-config.js";
+const WECOM_TEXT_MAX_BYTES = 20_480;
+const WECOM_TEXT_CHUNK_BYTES = 18_000;
+const WECOM_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+const WECOM_VIDEO_MAX_BYTES = 10 * 1024 * 1024;
+const WECOM_VOICE_MAX_BYTES = 2 * 1024 * 1024;
+const WECOM_FILE_MAX_BYTES = 20 * 1024 * 1024;
+function createDefaultClient(account, logger) {
+    return new WSClient({
+        botId: account.botId,
+        secret: account.secret,
+        maxReconnectAttempts: 10,
+        maxAuthFailureAttempts: 5,
+        heartbeatInterval: 30_000,
+        maxReplyQueueSize: 500,
+        logger: {
+            debug: (message, ...args) => logger.log?.(`[wecom-sdk] ${message} ${args.join(" ")}`.trim()),
+            info: (message, ...args) => logger.log?.(`[wecom-sdk] ${message} ${args.join(" ")}`.trim()),
+            warn: (message, ...args) => logger.log?.(`[wecom-sdk] WARN: ${message} ${args.join(" ")}`.trim()),
+            error: (message, ...args) => logger.error?.(`[wecom-sdk] ${message} ${args.join(" ")}`.trim()),
+        },
+    });
+}
+function splitUtf8Text(text, maxBytes = WECOM_TEXT_CHUNK_BYTES) {
+    if (Buffer.byteLength(text, "utf-8") <= maxBytes) {
+        return [text];
+    }
+    const chunks = [];
+    let current = "";
+    let bytes = 0;
+    for (const character of text) {
+        const nextBytes = Buffer.byteLength(character, "utf-8");
+        if (current && bytes + nextBytes > maxBytes) {
+            chunks.push(current);
+            current = "";
+            bytes = 0;
+        }
+        current += character;
+        bytes += nextBytes;
+    }
+    if (current) {
+        chunks.push(current);
+    }
+    return chunks;
+}
+function getChatType(target) {
+    return target.metadata?.chatType === "group" ? "group" : "direct";
+}
+function getReplyFrame(target) {
+    return target.opaqueRef
+        ? { headers: { req_id: target.opaqueRef } }
+        : null;
+}
+function inferMimeType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const known = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".gif": "image/gif",
+        ".amr": "audio/amr",
+        ".mp4": "video/mp4",
+        ".pdf": "application/pdf",
+        ".txt": "text/plain",
+    };
+    return known[ext] || "application/octet-stream";
+}
+function resolveOutboundMedia(attachment) {
+    const fileName = attachment.fileName || path.basename(attachment.path);
+    const size = fs.statSync(attachment.path).size;
+    const mimeType = attachment.mimeType || inferMimeType(attachment.path);
+    if (attachment.kind === "image" &&
+        size <= WECOM_IMAGE_MAX_BYTES &&
+        ["image/jpeg", "image/png", "image/gif"].includes(mimeType)) {
+        return { type: "image", maxBytes: WECOM_IMAGE_MAX_BYTES, fileName };
+    }
+    if (attachment.kind === "voice" &&
+        size <= WECOM_VOICE_MAX_BYTES &&
+        path.extname(fileName).toLowerCase() === ".amr") {
+        return { type: "voice", maxBytes: WECOM_VOICE_MAX_BYTES, fileName };
+    }
+    if (attachment.kind === "video" &&
+        size <= WECOM_VIDEO_MAX_BYTES &&
+        path.extname(fileName).toLowerCase() === ".mp4") {
+        return { type: "video", maxBytes: WECOM_VIDEO_MAX_BYTES, fileName };
+    }
+    return { type: "file", maxBytes: WECOM_FILE_MAX_BYTES, fileName };
+}
+export class WecomTransport {
+    account;
+    client;
+    logger;
+    claimsDir;
+    attachmentsDir;
+    fetchImpl;
+    streamStates = new Map();
+    inboundChains = new Map();
+    outputChain = Promise.resolve();
+    authenticated = false;
+    started = false;
+    onMessage = null;
+    onUnauthorized = null;
+    onFatal = null;
+    onConnected = null;
+    constructor(options) {
+        this.account = options.account;
+        this.logger = options.logger ?? {};
+        this.claimsDir = options.claimsDir ?? WECOM_INBOUND_MESSAGE_CLAIMS_DIR;
+        this.attachmentsDir = options.attachmentsDir;
+        this.fetchImpl = options.fetchImpl;
+        this.client = (options.clientFactory ?? createDefaultClient)(this.account, this.logger);
+        this.attachClientEvents();
+    }
+    attachClientEvents() {
+        this.client.on("authenticated", () => {
+            this.authenticated = true;
+            this.logger.log?.("wecom_authenticated");
+            void this.onConnected?.();
+        });
+        this.client.on("disconnected", (reason) => {
+            this.authenticated = false;
+            this.logger.log?.(`wecom_disconnected: reason=${reason}`);
+        });
+        this.client.on("reconnecting", (attempt) => {
+            this.logger.log?.(`wecom_reconnecting: attempt=${attempt}`);
+        });
+        this.client.on("event.disconnected_event", () => {
+            const error = new Error("The WeCom bot was connected by another process. This connection was stopped to avoid a reconnect loop.");
+            this.authenticated = false;
+            this.client.disconnect();
+            void this.onFatal?.(error);
+        });
+        this.client.on("error", (error) => {
+            this.logger.error?.(`wecom_transport_error: ${error.message}`);
+            if (error instanceof WSAuthFailureError ||
+                error instanceof WSReconnectExhaustedError) {
+                void this.onFatal?.(error);
+            }
+        });
+        this.client.on("message", (frame) => {
+            void this.handleInboundFrame(frame).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.logger.error?.(`wecom_inbound_failed: ${message}`);
+            });
+        });
+    }
+    setHandlers(handlers) {
+        this.onMessage = handlers.onMessage;
+        this.onUnauthorized = handlers.onUnauthorized ?? null;
+        this.onFatal = handlers.onFatal ?? null;
+        this.onConnected = handlers.onConnected ?? null;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.client.connect();
+    }
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        this.started = false;
+        this.authenticated = false;
+        this.streamStates.clear();
+        this.client.disconnect();
+    }
+    get isConnected() {
+        return this.authenticated && this.client.isConnected;
+    }
+    async waitUntilConnected(timeoutMs = 15_000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (this.isConnected) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        throw new Error("Timed out waiting for WeCom WebSocket authentication.");
+    }
+    async handleInboundFrame(frame) {
+        const parsed = parseWecomInboundFrame(frame);
+        if (!parsed) {
+            return;
+        }
+        if (parsed.senderId !== this.account.operatorUserId) {
+            await this.onUnauthorized?.(parsed.senderId, parsed.chatType);
+            return;
+        }
+        if (!tryClaimChannelInboundMessage(`${this.account.botId}|${parsed.id}`, {
+            claimsDir: this.claimsDir,
+        })) {
+            this.logger.log?.(`wecom_duplicate_skipped: msgid=${parsed.id}`);
+            return;
+        }
+        const queueKey = `${this.account.botId}:${parsed.conversationId}`;
+        const previous = this.inboundChains.get(queueKey) ?? Promise.resolve();
+        const deliver = async () => {
+            const downloaded = await downloadWecomInboundAttachments(parsed, {
+                attachmentsDir: this.attachmentsDir,
+                fetchImpl: this.fetchImpl,
+            });
+            const text = [parsed.text, ...downloaded.failureNotes]
+                .filter(Boolean)
+                .join("\n")
+                .trim();
+            await this.onMessage?.(toWecomChannelInboundMessage({ ...parsed, text }, downloaded.attachments, this.account.botId));
+        };
+        const next = previous.then(deliver, deliver);
+        this.inboundChains.set(queueKey, next);
+        try {
+            await next;
+        }
+        finally {
+            if (this.inboundChains.get(queueKey) === next) {
+                this.inboundChains.delete(queueKey);
+            }
+        }
+    }
+    queueOutput(action) {
+        const run = this.outputChain.then(action);
+        this.outputChain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async sendActiveText(target, text) {
+        for (const chunk of splitUtf8Text(text)) {
+            if (Buffer.byteLength(chunk, "utf-8") > WECOM_TEXT_MAX_BYTES) {
+                throw new Error("WeCom text chunk exceeds the 20480-byte platform limit.");
+            }
+            await this.client.sendMessage(target.recipientId, {
+                msgtype: "markdown",
+                markdown: { content: chunk },
+            });
+        }
+    }
+    async sendText(target, text, kind) {
+        const normalized = text.trim();
+        if (!normalized) {
+            return true;
+        }
+        return this.queueOutput(async () => {
+            if (!this.isConnected) {
+                throw new Error("WeCom WebSocket is not connected.");
+            }
+            const chunks = splitUtf8Text(normalized);
+            const replyFrame = getReplyFrame(target);
+            const canUseStream = Boolean(replyFrame) && (kind === "thinking" || kind === "final_reply");
+            if (!canUseStream) {
+                await this.sendActiveText(target, normalized);
+                return true;
+            }
+            const reqId = target.opaqueRef;
+            const state = this.streamStates.get(reqId) ?? {
+                streamId: generateReqId("stream"),
+                finished: false,
+            };
+            this.streamStates.set(reqId, state);
+            try {
+                if (kind === "thinking") {
+                    const result = await this.client.replyStreamNonBlocking(replyFrame, state.streamId, chunks[0], false);
+                    return result !== "skipped";
+                }
+                await this.client.replyStream(replyFrame, state.streamId, chunks[0], true);
+                state.finished = true;
+                this.streamStates.delete(reqId);
+                for (const chunk of chunks.slice(1)) {
+                    await this.sendActiveText(target, chunk);
+                }
+                return true;
+            }
+            catch (error) {
+                if (kind !== "final_reply") {
+                    throw error;
+                }
+                this.streamStates.delete(reqId);
+                this.logger.log?.(`wecom_stream_fallback: reqid=${reqId} chat_type=${getChatType(target)}`);
+                await this.sendActiveText(target, normalized);
+                return true;
+            }
+        });
+    }
+    async sendAttachment(target, attachment) {
+        await this.queueOutput(async () => {
+            if (!this.isConnected) {
+                throw new Error("WeCom WebSocket is not connected.");
+            }
+            const media = resolveOutboundMedia(attachment);
+            const buffer = fs.readFileSync(attachment.path);
+            if (buffer.length > media.maxBytes) {
+                throw new Error(`${media.type} attachment exceeds the ${Math.round(media.maxBytes / 1024 / 1024)} MB WeCom limit`);
+            }
+            const uploaded = await this.client.uploadMedia(buffer, {
+                type: media.type,
+                filename: media.fileName,
+            });
+            await this.client.sendMediaMessage(target.recipientId, media.type, uploaded.media_id, media.type === "video"
+                ? { title: media.fileName, description: "" }
+                : undefined);
+        });
+    }
+}

package/dist/commands/check-update.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env bun
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import { checkForUpdate, getCurrentVersion, } from "../utils/version-checker.js";
 async function main() {
     const currentVersion = await getCurrentVersion();

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

@@ -1,14 +1,21 @@
 #!/usr/bin/env node
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import crypto from "node:crypto";
 import { spawn } from "node:child_process";
 import net from "node:net";
 import path from "node:path";
 import { assertNoReservedExtraCliArgs, buildCliEnvironment, buildCodexCliArgs, resolveSpawnTarget, } from "../bridge/bridge-adapters.shared.js";
 import { killProcessTreeSync } from "../bridge/bridge-process-reaper.js";
-import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleSwitchRequest, sendCodexVisibleSwitchResponse, } from "./codex-visible-client-link.js";
+import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleControlRequest, sendCodexVisibleShutdownResponse, sendCodexVisibleSwitchResponse, } from "./codex-visible-client-link.js";
 import { clearLocalCompanionOccupancy, readLocalCompanionEndpoint, updateCodexVisibleControl, updateLocalCompanionOccupancy, } from "./local-companion-link.js";
 import { migrateLegacyChannelFiles } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV } from "../runtime/runtime-types.js";
+import { isDirectModuleRun } from "../core/direct-run.js";
 const CODEX_VISIBLE_SWITCH_SETTLE_MS = 500;
 const CODEX_VISIBLE_CHILD_STOP_TIMEOUT_MS = 2_000;
 function log(message) {
@@ -301,11 +308,20 @@ export class CodexVisibleClientSupervisor {
                     socket.destroy();
                     return;
                 }
-                const request = parseCodexVisibleSwitchRequest(parsed);
+                const request = parseCodexVisibleControlRequest(parsed);
                 if (!request || request.token !== this.controlToken) {
                     socket.destroy();
                     return;
                 }
+                if (request.type === "shutdown") {
+                    sendCodexVisibleShutdownResponse(socket, {
+                        type: "shutdown_result",
+                        id: request.id,
+                        ok: true,
+                    });
+                    void this.shutdownFromControl();
+                    return;
+                }
                 void this.switchThread(request.threadId).then(() => {
                     sendCodexVisibleSwitchResponse(socket, {
                         type: "switch_thread_result",
@@ -339,6 +355,17 @@ export class CodexVisibleClientSupervisor {
         this.controlServer = server;
         this.controlPort = address.port;
     }
+    async shutdownFromControl() {
+        await this.switchChain.catch(() => undefined);
+        if (this.runSettled) {
+            return;
+        }
+        const child = this.child;
+        if (child) {
+            await this.stopChild(child);
+        }
+        this.finishRun(undefined, 0);
+    }
     async closeControlServer() {
         const server = this.controlServer;
         this.controlServer = null;
@@ -388,7 +415,7 @@ async function main() {
     const exitCode = await runCodexRemoteClient(options);
     process.exit(exitCode);
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     main().catch((error) => {
         log(error instanceof Error ? error.message : String(error));

package/dist/companion/codex-visible-client-link.js

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import crypto from "node:crypto";
 import net from "node:net";
 import { readLocalCompanionEndpoint, } from "./local-companion-link.js";
@@ -23,12 +29,37 @@ export function parseCodexVisibleSwitchRequest(value) {
         threadId: value.threadId,
     };
 }
+export function parseCodexVisibleControlRequest(value) {
+    const switchRequest = parseCodexVisibleSwitchRequest(value);
+    if (switchRequest) {
+        return switchRequest;
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    if (value.type !== "shutdown" ||
+        typeof value.id !== "string" ||
+        typeof value.token !== "string") {
+        return null;
+    }
+    return {
+        type: "shutdown",
+        id: value.id,
+        token: value.token,
+    };
+}
 export function sendCodexVisibleSwitchResponse(socket, response) {
     if (socket.destroyed || socket.writableEnded) {
         return;
     }
     socket.end(`${JSON.stringify(response)}\n`);
 }
+export function sendCodexVisibleShutdownResponse(socket, response) {
+    if (socket.destroyed || socket.writableEnded) {
+        return;
+    }
+    socket.end(`${JSON.stringify(response)}\n`);
+}
 function resolveCodexControlEndpoint(cwd, instanceId) {
     const endpoint = readLocalCompanionEndpoint(cwd, { adapter: "codex" });
     if (!endpoint || endpoint.kind !== "codex" || endpoint.instanceId !== instanceId) {
@@ -120,3 +151,79 @@ export async function requestCodexVisibleThreadSwitch(params) {
         });
     });
 }
+export async function requestCodexVisibleClientShutdown(params) {
+    const endpoint = resolveCodexControlEndpoint(params.cwd, params.instanceId);
+    const requestId = crypto.randomUUID();
+    const timeoutMs = params.timeoutMs ?? 5_000;
+    await new Promise((resolve, reject) => {
+        const socket = net.connect({
+            host: CODEX_VISIBLE_CONTROL_HOST,
+            port: endpoint.codexControlPort,
+        });
+        let buffer = "";
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.destroy();
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        socket.setEncoding("utf8");
+        socket.setTimeout(timeoutMs);
+        socket.once("connect", () => {
+            const request = {
+                type: "shutdown",
+                id: requestId,
+                token: endpoint.codexControlToken,
+            };
+            socket.write(`${JSON.stringify(request)}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 65_536) {
+                finish(new Error("The visible Codex client returned an oversized shutdown response."));
+                return;
+            }
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                finish(new Error("The visible Codex client returned an invalid shutdown response."));
+                return;
+            }
+            if (!isRecord(parsed) || parsed.type !== "shutdown_result" || parsed.id !== requestId) {
+                finish(new Error("The visible Codex client returned an unexpected shutdown response."));
+                return;
+            }
+            if (parsed.ok !== true) {
+                finish(new Error(typeof parsed.error === "string"
+                    ? parsed.error
+                    : "The visible Codex client could not shut down."));
+                return;
+            }
+            finish();
+        });
+        socket.once("timeout", () => {
+            finish(new Error("Timed out waiting for the visible Codex client to shut down."));
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("close", () => {
+            if (!settled) {
+                finish(new Error("The visible Codex client closed the shutdown connection."));
+            }
+        });
+    });
+}

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

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import crypto from "node:crypto";
 import fs from "node:fs";
 import { ensureWorkspaceChannelDir, getWorkspaceAdapterEndpointFile, getWorkspaceChannelPaths, } from "../wechat/channel-config.js";