cli-wechat-bridge 1.1.6 → 1.1.8

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

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

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

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

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

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

package/dist/channels/wecom/setup.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env bun
+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,66 @@
+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-media.js

@@ -0,0 +1,141 @@
+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");
+}