@unlinearity/cli-wechat-bridge 1.1.5 → 1.2.0

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

@@ -0,0 +1,32 @@
+// 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 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,12 @@
+#!/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 { runWecomSetup } from "./setup.js";
+runWecomSetup().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/channels/wecom/setup.js

@@ -0,0 +1,182 @@
+#!/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 crypto from "node:crypto";
+import readline from "node:readline";
+import { Writable } from "node:stream";
+import { WSClient, } from "@wecom/aibot-node-sdk";
+import { loadStoredWecomAccount, resolveWecomAccount, saveWecomAccount, } from "./wecom-config.js";
+const PAIRING_TIMEOUT_MS = 10 * 60 * 1000;
+function ask(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function askSecret(prompt) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return ask(prompt);
+    }
+    let muted = false;
+    const output = new Writable({
+        write(chunk, _encoding, callback) {
+            if (!muted) {
+                process.stdout.write(chunk);
+            }
+            callback();
+        },
+    });
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output,
+        terminal: true,
+    });
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            muted = false;
+            rl.close();
+            process.stdout.write("\n");
+            resolve(answer.trim());
+        });
+        muted = true;
+    });
+}
+export function createWecomPairingCode() {
+    return crypto.randomInt(0, 1_000_000).toString().padStart(6, "0");
+}
+export function isWecomPairingMessage(frame, code) {
+    const body = frame.body;
+    return Boolean(body &&
+        body.chattype === "single" &&
+        body.from?.userid &&
+        body.msgtype === "text" &&
+        body.text?.content?.trim() === `/pair ${code}`);
+}
+function createSetupClient(botId, secret) {
+    return new WSClient({
+        botId,
+        secret,
+        maxReconnectAttempts: 3,
+        maxAuthFailureAttempts: 2,
+        heartbeatInterval: 30_000,
+    });
+}
+export async function pairWecomOperator(options) {
+    const log = options.log ?? console.log;
+    const code = options.code ?? createWecomPairingCode();
+    const client = (options.clientFactory ?? createSetupClient)(options.botId, options.secret);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error, operatorUserId) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            client.disconnect();
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({
+                version: 1,
+                botId: options.botId,
+                secret: options.secret,
+                operatorUserId: operatorUserId,
+                pairedAt: new Date().toISOString(),
+            });
+        };
+        const timer = setTimeout(() => {
+            finish(new Error("WeCom operator pairing timed out."));
+        }, options.timeoutMs ?? PAIRING_TIMEOUT_MS);
+        timer.unref?.();
+        client.on("authenticated", () => {
+            log("WeCom authentication succeeded.");
+            log(`Send /pair ${code} to the bot in a direct chat within 10 minutes.`);
+        });
+        client.on("message", (frame) => {
+            if (isWecomPairingMessage(frame, code)) {
+                finish(undefined, frame.body.from.userid);
+            }
+        });
+        client.on("event.disconnected_event", () => {
+            finish(new Error("Another process connected the same WeCom bot during pairing."));
+        });
+        client.on("error", (error) => {
+            finish(error);
+        });
+        client.connect();
+    });
+}
+async function validateWecomAccount(account, options = {}) {
+    const client = (options.clientFactory ?? createSetupClient)(account.botId, account.secret);
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            client.disconnect();
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        const timer = setTimeout(() => finish(new Error("WeCom credential validation timed out.")), options.timeoutMs ?? 15_000);
+        client.on("authenticated", () => finish());
+        client.on("error", (error) => finish(error));
+        client.on("event.disconnected_event", () => finish(new Error("Another process is already using this WeCom bot.")));
+        client.connect();
+    });
+}
+export async function ensureWecomAccount(options = {}) {
+    const existing = resolveWecomAccount();
+    if (existing) {
+        return existing;
+    }
+    options.log?.("No paired WeCom account found. Starting setup...");
+    return (options.setup ?? (() => runWecomSetup([])))();
+}
+export async function runWecomSetup(argv = process.argv.slice(2)) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        console.log("Usage: wecom-setup [--check]");
+        console.log("");
+        console.log("Pairs one WeCom operator with the local CLI bridge.");
+        console.log("Bot credentials may also be supplied through WECOM_BOT_ID and WECOM_BOT_SECRET.");
+        process.exit(0);
+    }
+    const resolved = resolveWecomAccount();
+    if (argv.includes("--check")) {
+        if (!resolved) {
+            throw new Error("No complete WeCom credentials are configured.");
+        }
+        await validateWecomAccount(resolved);
+        console.log(`WeCom credentials are valid. Paired operator: ${resolved.operatorUserId}`);
+        return resolved;
+    }
+    const stored = loadStoredWecomAccount();
+    const botId = process.env.WECOM_BOT_ID?.trim() ||
+        await ask(`Bot ID${stored?.botId ? ` [${stored.botId}]` : ""}: `) || stored?.botId || "";
+    const secret = process.env.WECOM_BOT_SECRET?.trim() ||
+        await askSecret(`Bot Secret${stored?.secret ? " [press Enter to keep saved value]" : ""}: `) ||
+        stored?.secret || "";
+    if (!botId || !secret) {
+        throw new Error("Bot ID and Bot Secret are required.");
+    }
+    const account = await pairWecomOperator({ botId, secret });
+    saveWecomAccount(account);
+    console.log("WeCom operator pairing completed.");
+    console.log("Start from a project directory with wecom-codex, wecom-claude, wecom-opencode, wecom-pi, or wecom-daemon.");
+    return account;
+}

package/dist/channels/wecom/wecom-channel-port.js

@@ -0,0 +1,45 @@
+import { forwardWecomFinalReply } from "./bridge-final-reply.js";
+import { formatWecomVisibleText } from "./wecom-message.js";
+export class WecomChannelPort {
+    channelId = "wecom";
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    sendText(target, text, kind) {
+        return this.deps.sendText?.(target, text, kind) ??
+            this.deps.transport.sendText(target, text, kind);
+    }
+    sendAttachment(target, attachment) {
+        return this.deps.sendAttachment?.(target, attachment) ??
+            this.deps.transport.sendAttachment(target, attachment);
+    }
+    async send(output) {
+        if (output.target.channelId !== this.channelId) {
+            throw new Error(`WeCom channel cannot send to ${output.target.channelId}.`);
+        }
+        const prefix = (text) => formatWecomVisibleText(this.deps.prefixText?.(output.adapter, text) ?? text);
+        if (output.kind === "final_reply") {
+            await forwardWecomFinalReply({
+                adapter: output.adapter ?? "codex",
+                rawText: output.text ?? "",
+                target: output.target,
+                onEmptyVisibleReply: (rawText) => {
+                    this.deps.onEmptyVisibleReply?.(output.adapter, rawText);
+                },
+                sender: {
+                    sendText: (text) => this.sendText(output.target, prefix(text), "final_reply"),
+                    sendAttachment: (attachment) => this.sendAttachment(output.target, attachment),
+                },
+            });
+            return true;
+        }
+        if (output.attachment) {
+            await this.sendAttachment(output.target, output.attachment);
+        }
+        if (output.text?.trim()) {
+            return this.sendText(output.target, prefix(output.text), output.kind);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,72 @@
+// 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 { CHANNEL_DATA_DIR, ensureChannelDataDir, } from "../../wechat/channel-config.js";
+export const WECOM_DATA_DIR = path.join(CHANNEL_DATA_DIR, "wecom");
+export const WECOM_CREDENTIALS_FILE = path.join(WECOM_DATA_DIR, "account.json");
+export const WECOM_INBOUND_ATTACHMENTS_DIR = path.join(WECOM_DATA_DIR, "inbound-attachments");
+export const WECOM_INBOUND_MESSAGE_CLAIMS_DIR = path.join(WECOM_DATA_DIR, "inbound-message-claims");
+export function ensureWecomDataDir() {
+    ensureChannelDataDir();
+    fs.mkdirSync(WECOM_DATA_DIR, { recursive: true });
+}
+export function loadStoredWecomAccount(filePath = WECOM_CREDENTIALS_FILE) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (parsed.version !== 1 ||
+            typeof parsed.botId !== "string" ||
+            !parsed.botId.trim() ||
+            typeof parsed.secret !== "string" ||
+            !parsed.secret.trim() ||
+            typeof parsed.operatorUserId !== "string" ||
+            !parsed.operatorUserId.trim() ||
+            typeof parsed.pairedAt !== "string") {
+            return null;
+        }
+        return {
+            version: 1,
+            botId: parsed.botId.trim(),
+            secret: parsed.secret.trim(),
+            operatorUserId: parsed.operatorUserId.trim(),
+            pairedAt: parsed.pairedAt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveWecomAccount(env = process.env, stored = loadStoredWecomAccount()) {
+    const botId = env.WECOM_BOT_ID?.trim() || stored?.botId || "";
+    const secret = env.WECOM_BOT_SECRET?.trim() || stored?.secret || "";
+    const operatorUserId = env.WECOM_OPERATOR_USER_ID?.trim() || stored?.operatorUserId || "";
+    if (!botId || !secret || !operatorUserId) {
+        return null;
+    }
+    return {
+        version: 1,
+        botId,
+        secret,
+        operatorUserId,
+        pairedAt: stored?.pairedAt || new Date().toISOString(),
+    };
+}
+export function saveWecomAccount(account, filePath = WECOM_CREDENTIALS_FILE) {
+    if (filePath === WECOM_CREDENTIALS_FILE) {
+        ensureWecomDataDir();
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tempPath, JSON.stringify(account, null, 2), "utf-8");
+    try {
+        fs.chmodSync(tempPath, 0o600);
+    }
+    catch {
+        // Best effort on Windows.
+    }
+    fs.renameSync(tempPath, filePath);
+}

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

@@ -0,0 +1,106 @@
+import { buildWecomInboundPrompt, formatWecomVisibleText, } from "./wecom-message.js";
+import { truncatePreview } from "../../core/text-utils.js";
+export 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";
+}
+/** ChannelDriver over the official WeCom smart-bot WebSocket transport. */
+export class WecomChannelDriver {
+    id = "wecom";
+    displayName = "WeCom";
+    operatorDescription = "the paired WeCom operator";
+    capabilities = {
+        streamingReplies: true,
+        outboundAttachments: true,
+        multiConversation: true,
+        pushInbound: true,
+    };
+    transport;
+    accountId;
+    operatorId;
+    logError;
+    constructor(options) {
+        this.transport = options.transport;
+        this.accountId = options.accountId;
+        this.operatorId = options.operatorId;
+        this.logError = options.logError;
+    }
+    defaultConversation() {
+        return this.directConversation(this.operatorId);
+    }
+    directConversation(senderId) {
+        return {
+            channelId: "wecom",
+            accountId: this.accountId,
+            conversationId: senderId,
+            recipientId: senderId,
+            metadata: { chatType: "direct" },
+        };
+    }
+    start(handlers) {
+        this.transport.setHandlers({
+            onMessage: async (message) => {
+                await handlers.onInboundMessage(message);
+            },
+            onUnauthorized: handlers.onUnauthorizedSender
+                ? async (senderId, chatType) => {
+                    await handlers.onUnauthorizedSender(senderId, chatType);
+                }
+                : undefined,
+            onFatal: handlers.onChannelFatal
+                ? async (error) => {
+                    await handlers.onChannelFatal(error);
+                }
+                : undefined,
+            onConnected: handlers.onChannelConnected
+                ? async () => {
+                    await handlers.onChannelConnected();
+                }
+                : undefined,
+        });
+        this.transport.start();
+    }
+    waitUntilReady() {
+        return this.transport.waitUntilConnected();
+    }
+    async sendText(params) {
+        const { target, text, context, log } = params;
+        const startedAtMs = Date.now();
+        log(`wecom_send_started: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
+        try {
+            await this.transport.sendText(target, formatWecomVisibleText(text), toWecomOutputKind(context));
+            log(`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);
+            log(`wecom_send_failed: context=${context} recipient=${target.recipientId} error=${truncatePreview(message, 400)}`);
+            this.logError(`Failed to send WeCom ${context}: ${message}`);
+            return {
+                status: "target_stale",
+                error,
+                target,
+            };
+        }
+    }
+    buildInboundPrompt(text, attachments) {
+        return buildWecomInboundPrompt(text, attachments);
+    }
+    formatVisibleText(text) {
+        return formatWecomVisibleText(text);
+    }
+}

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

@@ -0,0 +1,147 @@
+// 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 { decryptFile } from "@wecom/aibot-node-sdk";
+import { WECOM_INBOUND_ATTACHMENTS_DIR } from "./wecom-config.js";
+const DEFAULT_INBOUND_LIMIT_MB = {
+    image: 20,
+    file: 50,
+    video: 50,
+};
+const INBOUND_LIMIT_ENV_KEYS = {
+    image: "WECOM_MAX_INBOUND_IMAGE_MB",
+    file: "WECOM_MAX_INBOUND_FILE_MB",
+    video: "WECOM_MAX_INBOUND_VIDEO_MB",
+};
+function resolvePositiveMb(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function getWecomInboundLimitBytes(kind, env = process.env) {
+    return Math.floor(resolvePositiveMb(env[INBOUND_LIMIT_ENV_KEYS[kind]], DEFAULT_INBOUND_LIMIT_MB[kind]) * 1024 * 1024);
+}
+function sanitizeFileName(value, fallback) {
+    const name = value.trim().replace(/\\/g, "/").split("/").pop() || fallback;
+    const cleaned = Array.from(name)
+        .map((character) => (character.charCodeAt(0) < 32 ? "_" : character))
+        .join("")
+        .replace(/[<>:"/\\|?*]+/g, "_")
+        .replace(/^\.+/, "")
+        .slice(0, 180);
+    return cleaned || fallback;
+}
+function parseContentDispositionFileName(value) {
+    if (!value) {
+        return undefined;
+    }
+    const utf8 = value.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+    if (utf8) {
+        try {
+            return decodeURIComponent(utf8.trim());
+        }
+        catch {
+            return utf8.trim();
+        }
+    }
+    return value.match(/filename="?([^";]+)"?/i)?.[1]?.trim();
+}
+function extensionFor(kind, mimeType) {
+    const normalized = mimeType.split(";")[0]?.trim().toLowerCase() || "";
+    const known = {
+        "image/jpeg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "video/mp4": ".mp4",
+        "application/pdf": ".pdf",
+        "text/plain": ".txt",
+    };
+    return known[normalized] || (kind === "image" ? ".jpg" : kind === "video" ? ".mp4" : ".bin");
+}
+async function readResponseWithLimit(response, maxBytes) {
+    const declaredLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > maxBytes + 64) {
+        throw new Error(`attachment exceeds the configured ${maxBytes}-byte limit`);
+    }
+    if (!response.body) {
+        return Buffer.alloc(0);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const next = await reader.read();
+        if (next.done) {
+            break;
+        }
+        total += next.value.byteLength;
+        if (total > maxBytes + 64) {
+            await reader.cancel().catch(() => undefined);
+            throw new Error(`attachment exceeds the configured ${maxBytes}-byte limit`);
+        }
+        chunks.push(next.value);
+    }
+    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total);
+}
+export async function downloadWecomAttachment(descriptor, options) {
+    const maxBytes = getWecomInboundLimitBytes(descriptor.kind, options.env);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 60_000);
+    try {
+        const response = await (options.fetchImpl ?? fetch)(descriptor.url, {
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`download returned HTTP ${response.status}`);
+        }
+        const encrypted = await readResponseWithLimit(response, maxBytes);
+        const decrypted = descriptor.aesKey ? decryptFile(encrypted, descriptor.aesKey) : encrypted;
+        if (decrypted.length > maxBytes) {
+            throw new Error(`attachment exceeds the configured ${maxBytes}-byte limit`);
+        }
+        const mimeType = response.headers.get("content-type")?.split(";")[0]?.trim();
+        const headerName = parseContentDispositionFileName(response.headers.get("content-disposition"));
+        const fallbackName = `${descriptor.kind}-${options.index + 1}${extensionFor(descriptor.kind, mimeType || "")}`;
+        const fileName = sanitizeFileName(descriptor.fileName || headerName || fallbackName, fallbackName);
+        const day = new Date().toISOString().slice(0, 10);
+        const directory = path.join(options.attachmentsDir ?? WECOM_INBOUND_ATTACHMENTS_DIR, day);
+        fs.mkdirSync(directory, { recursive: true });
+        const safeMessageId = options.messageId.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 80);
+        const filePath = path.join(directory, `${safeMessageId}-${options.index + 1}-${fileName}`);
+        fs.writeFileSync(filePath, decrypted);
+        return {
+            kind: descriptor.kind,
+            path: filePath,
+            fileName,
+            mimeType,
+            sizeBytes: decrypted.length,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function downloadWecomInboundAttachments(parsed, options = {}) {
+    const attachments = [];
+    const failureNotes = [];
+    for (let index = 0; index < parsed.attachments.length; index += 1) {
+        const descriptor = parsed.attachments[index];
+        try {
+            attachments.push(await downloadWecomAttachment(descriptor, {
+                ...options,
+                messageId: parsed.id,
+                index,
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failureNotes.push(`[WeCom attachment unavailable: ${descriptor.kind}; ${message}]`);
+        }
+    }
+    return { attachments, failureNotes };
+}