@unlinearity/cli-wechat-bridge 1.1.6 → 1.2.1

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 };
+}

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

@@ -0,0 +1,149 @@
+function appendMixedContent(items, textParts, attachments) {
+    for (const item of items ?? []) {
+        if (item.msgtype === "text" && item.text?.content) {
+            textParts.push(item.text.content);
+        }
+        else if (item.msgtype === "image" && item.image?.url) {
+            attachments.push({
+                kind: "image",
+                url: item.image.url,
+                aesKey: item.image.aeskey,
+            });
+        }
+    }
+}
+function appendQuote(quote, textParts, attachments) {
+    if (!quote) {
+        return;
+    }
+    const quotedText = quote.text?.content || quote.voice?.content;
+    if (quotedText) {
+        textParts.push(`[Quoted message]\n${quotedText}`);
+    }
+    if (quote.image?.url) {
+        attachments.push({
+            kind: "image",
+            url: quote.image.url,
+            aesKey: quote.image.aeskey,
+        });
+    }
+    if (quote.file?.url) {
+        attachments.push({
+            kind: "file",
+            url: quote.file.url,
+            aesKey: quote.file.aeskey,
+        });
+    }
+    const quotedVideo = quote.video;
+    if (quotedVideo?.url) {
+        attachments.push({
+            kind: "video",
+            url: quotedVideo.url,
+            aesKey: quotedVideo.aeskey,
+        });
+    }
+    appendMixedContent(quote.mixed?.msg_item, textParts, attachments);
+}
+export function parseWecomInboundFrame(frame) {
+    const body = frame.body;
+    if (!body?.msgid || !body.from?.userid || !frame.headers?.req_id) {
+        return null;
+    }
+    const textParts = [];
+    const attachments = [];
+    if (body.msgtype === "text" && body.text?.content) {
+        textParts.push(body.text.content);
+    }
+    else if (body.msgtype === "voice" && body.voice?.content) {
+        textParts.push(body.voice.content);
+    }
+    else if (body.msgtype === "mixed") {
+        appendMixedContent(body.mixed?.msg_item, textParts, attachments);
+    }
+    else if (body.msgtype === "image" && body.image?.url) {
+        attachments.push({
+            kind: "image",
+            url: body.image.url,
+            aesKey: body.image.aeskey,
+        });
+    }
+    else if (body.msgtype === "file" && body.file?.url) {
+        attachments.push({
+            kind: "file",
+            url: body.file.url,
+            aesKey: body.file.aeskey,
+        });
+    }
+    else if (body.msgtype === "video" && body.video?.url) {
+        attachments.push({
+            kind: "video",
+            url: body.video.url,
+            aesKey: body.video.aeskey,
+        });
+    }
+    appendQuote(body.quote, textParts, attachments);
+    const isGroup = body.chattype === "group" && Boolean(body.chatid);
+    const timestampMs = typeof body.create_time === "number" && body.create_time > 0
+        ? body.create_time * 1000
+        : Date.now();
+    return {
+        id: body.msgid,
+        reqId: frame.headers.req_id,
+        senderId: body.from.userid,
+        conversationId: isGroup ? body.chatid : body.from.userid,
+        chatType: isGroup ? "group" : "direct",
+        text: textParts.join("\n").trim(),
+        createdAt: new Date(timestampMs).toISOString(),
+        attachments,
+    };
+}
+export function toWecomChannelInboundMessage(parsed, attachments, accountId) {
+    return {
+        id: parsed.id,
+        conversation: {
+            channelId: "wecom",
+            accountId,
+            conversationId: parsed.conversationId,
+            recipientId: parsed.conversationId,
+            opaqueRef: parsed.reqId,
+            metadata: {
+                chatType: parsed.chatType,
+                messageId: parsed.id,
+            },
+        },
+        senderId: parsed.senderId,
+        text: parsed.text,
+        attachments,
+        createdAt: parsed.createdAt,
+        metadata: {
+            chatType: parsed.chatType,
+            reqId: parsed.reqId,
+        },
+    };
+}
+export function buildWecomInboundPrompt(text, attachments = []) {
+    const normalizedText = text.trim();
+    if (attachments.length === 0) {
+        return normalizedText;
+    }
+    const lines = [
+        "[WeCom inbound attachments — ACTION REQUIRED]",
+        "Use the local attachment paths below when the user asks you to inspect or process them.",
+    ];
+    attachments.forEach((attachment, index) => {
+        const metadata = [
+            `kind=${attachment.kind}`,
+            attachment.fileName ? `name=${attachment.fileName}` : "",
+            typeof attachment.sizeBytes === "number" ? `bytes=${attachment.sizeBytes}` : "",
+        ].filter(Boolean);
+        lines.push(`${index + 1}. ${metadata.join(" ")} path=${attachment.path}`);
+    });
+    return [normalizedText || "Received WeCom attachment(s).", lines.join("\n")]
+        .filter(Boolean)
+        .join("\n\n");
+}
+export function formatWecomVisibleText(text) {
+    return text
+        .replace(/\bWeChat\b/g, "WeCom")
+        .replace(/\bwechat-(codex|claude|opencode|pi|daemon|setup)\b/g, "wecom-$1");
+}