cli-wechat-bridge 1.1.5 → 1.1.7

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

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

@@ -0,0 +1,308 @@
+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/companion/codex-remote-client.js

@@ -9,6 +9,7 @@ import { CODEX_VISIBLE_CONTROL_HOST, parseCodexVisibleSwitchRequest, sendCodexVi
 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) {
@@ -388,7 +389,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));