@cjhyy/code-shell-chat 0.8.0

package/dist/wecom.d.ts

@@ -0,0 +1,16 @@
+import type { ChannelAdapter, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+export interface WeComAdapterConfig {
+    botId: string;
+    secret: string;
+}
+export declare class WeComAdapter implements ChannelAdapter {
+    readonly channel = "wecom";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    private readonly client;
+    private readonly delivery;
+    constructor(config: WeComAdapterConfig);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private dispatchMedia;
+    private downloadable;
+}

package/dist/wecom.js

@@ -0,0 +1,149 @@
+import { WSClient, } from "@wecom/aibot-node-sdk";
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { dispatchSafely, formatOutgoingMarkdown, waitForAbort } from "./lifecycle.js";
+import { OutgoingDeliveryTracker, outgoingAttachments, safeAttachmentName } from "./media.js";
+export class WeComAdapter {
+    channel = "wecom";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.wecom;
+    client;
+    delivery = new OutgoingDeliveryTracker();
+    constructor(config) {
+        this.client = new WSClient({
+            botId: config.botId,
+            secret: config.secret,
+            maxReconnectAttempts: -1,
+            maxAuthFailureAttempts: 5,
+        });
+    }
+    async run(handler, signal) {
+        const onMessage = (frame) => {
+            const message = frame.body;
+            if (!message?.text?.content)
+                return;
+            void dispatchSafely(handler, {
+                channel: this.channel,
+                target: message.chatid ?? message.from.userid,
+                senderId: message.from.userid,
+                text: message.text.content,
+                ...(frame.headers?.req_id
+                    ? { messageId: frame.headers.req_id }
+                    : {}),
+            });
+        };
+        const onImage = (frame) => this.dispatchMedia(frame, handler);
+        const onMixed = (frame) => this.dispatchMedia(frame, handler);
+        const onVoice = (frame) => this.dispatchMedia(frame, handler);
+        const onFile = (frame) => this.dispatchMedia(frame, handler);
+        const onVideo = (frame) => this.dispatchMedia(frame, handler);
+        this.client.on("message.text", onMessage);
+        this.client.on("message.image", onImage);
+        this.client.on("message.mixed", onMixed);
+        this.client.on("message.voice", onVoice);
+        this.client.on("message.file", onFile);
+        this.client.on("message.video", onVideo);
+        this.client.connect();
+        try {
+            await waitForAbort(signal);
+        }
+        finally {
+            this.client.off("message.text", onMessage);
+            this.client.off("message.image", onImage);
+            this.client.off("message.mixed", onMixed);
+            this.client.off("message.voice", onVoice);
+            this.client.off("message.file", onFile);
+            this.client.off("message.video", onVideo);
+            this.client.disconnect();
+        }
+    }
+    async send(target, message) {
+        const attachments = outgoingAttachments(message, this.capabilities.outbound.attachments);
+        await this.delivery.run(message, () => [
+            ...(message.text || message.button
+                ? [
+                    () => this.client
+                        .sendMessage(target, {
+                        msgtype: "markdown",
+                        markdown: { content: formatOutgoingMarkdown(message.text, message.button) },
+                    })
+                        .then(() => undefined),
+                ]
+                : []),
+            ...attachments.map((attachment) => async () => {
+                const type = attachment.kind === "image" ? "image" : attachment.kind === "video" ? "video" : "file";
+                const uploaded = await this.client.uploadMedia(Buffer.from(attachment.data), {
+                    type,
+                    filename: safeAttachmentName(attachment.name),
+                });
+                await this.client.sendMediaMessage(target, type, uploaded.media_id, type === "video" ? { title: attachment.name } : undefined);
+            }),
+        ]);
+    }
+    dispatchMedia(frame, handler) {
+        const message = frame.body;
+        if (!message?.from?.userid)
+            return;
+        const attachments = [];
+        let text = "";
+        if (message.msgtype === "image") {
+            const image = message.image;
+            if (image?.url)
+                attachments.push(this.downloadable(message.msgid, "image", image.url, image.aeskey));
+        }
+        else if (message.msgtype === "file") {
+            const file = message.file;
+            if (file?.url)
+                attachments.push(this.downloadable(message.msgid, "file", file.url, file.aeskey));
+        }
+        else if (message.msgtype === "video") {
+            const video = message.video;
+            if (video?.url)
+                attachments.push(this.downloadable(message.msgid, "video", video.url, video.aeskey));
+        }
+        else if (message.msgtype === "voice") {
+            // The current WeCom AI Bot protocol exposes voice transcription but no
+            // downloadable voice URL, so preserve the useful text without claiming
+            // an inbound audio attachment.
+            text = message.voice?.content ?? "";
+        }
+        else if (message.msgtype === "mixed") {
+            for (const [index, item] of message.mixed?.msg_item.entries() ?? []) {
+                if (item.msgtype === "text")
+                    text += item.text?.content ?? "";
+                if (item.msgtype === "image" && item.image?.url) {
+                    attachments.push(this.downloadable(`${message.msgid}:${index}`, "image", item.image.url, item.image.aeskey));
+                }
+            }
+        }
+        if (!text && attachments.length === 0)
+            return;
+        void dispatchSafely(handler, {
+            channel: this.channel,
+            target: message.chatid ?? message.from.userid,
+            senderId: message.from.userid,
+            text,
+            messageId: message.msgid,
+            ...(attachments.length > 0 ? { attachments } : {}),
+        });
+    }
+    downloadable(id, kind, url, aesKey) {
+        return {
+            id,
+            kind,
+            name: `wecom-${id}${kind === "image" ? ".jpg" : kind === "video" ? ".mp4" : ""}`,
+            ...(kind === "image"
+                ? { mimeType: "image/jpeg" }
+                : kind === "video"
+                    ? { mimeType: "video/mp4" }
+                    : {}),
+            load: async (signal) => {
+                if (signal?.aborted)
+                    throw signal.reason;
+                const downloaded = await this.client.downloadFile(url, aesKey);
+                if (downloaded.buffer.byteLength > 10 * 1024 * 1024) {
+                    throw new Error("企业微信附件超过大小限制");
+                }
+                return downloaded.buffer;
+            },
+        };
+    }
+}

package/dist/whatsapp.d.ts

@@ -0,0 +1,27 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ChannelMessageHandler, OutgoingMessage, WebhookChannelAdapter } from "./channel.js";
+export interface WhatsAppAdapterConfig {
+    accessToken: string;
+    appSecret: string;
+    verifyToken: string;
+    phoneNumberId: string;
+    apiVersion?: string;
+}
+export declare class WhatsAppAdapter implements WebhookChannelAdapter {
+    private readonly fetchFn;
+    readonly channel = "whatsapp";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    readonly webhookPath = "/webhooks/whatsapp";
+    private readonly config;
+    private readonly delivery;
+    constructor(config: WhatsAppAdapterConfig, fetchFn?: typeof fetch);
+    run(_handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    handleWebhook(request: IncomingMessage, response: ServerResponse, handler: ChannelMessageHandler, maxBodyBytes: number): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private textPayload;
+    private postPayload;
+    private uploadMedia;
+    private inboundMedia;
+    private downloadMedia;
+    private handleVerification;
+}

package/dist/whatsapp.js

@@ -0,0 +1,218 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { waitForAbort } from "./lifecycle.js";
+import { downloadRemoteAttachment, OutgoingDeliveryTracker, outgoingAttachments, safeAttachmentName, } from "./media.js";
+import { readRequestBody, sendResponse } from "./webhook.js";
+export class WhatsAppAdapter {
+    fetchFn;
+    channel = "whatsapp";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.whatsapp;
+    webhookPath = "/webhooks/whatsapp";
+    config;
+    delivery = new OutgoingDeliveryTracker();
+    constructor(config, fetchFn = fetch) {
+        this.fetchFn = fetchFn;
+        this.config = { ...config, apiVersion: config.apiVersion ?? "v25.0" };
+    }
+    run(_handler, signal) {
+        return waitForAbort(signal);
+    }
+    async handleWebhook(request, response, handler, maxBodyBytes) {
+        if (request.method === "GET") {
+            this.handleVerification(request, response);
+            return;
+        }
+        if (request.method !== "POST") {
+            sendResponse(response, 405, "Method not allowed");
+            return;
+        }
+        const raw = await readRequestBody(request, maxBodyBytes);
+        if (!verifyMetaSignature(raw, request.headers["x-hub-signature-256"], this.config.appSecret)) {
+            sendResponse(response, 401, "Invalid signature");
+            return;
+        }
+        let body;
+        try {
+            body = JSON.parse(raw.toString("utf8"));
+        }
+        catch {
+            sendResponse(response, 400, "Invalid JSON");
+            return;
+        }
+        const messages = (body.entry ?? []).flatMap((entry) => (entry.changes ?? []).flatMap((change) => (change.value?.messages ?? []).flatMap((message) => {
+            if (!message.from)
+                return [];
+            const media = this.inboundMedia(message);
+            const text = message.text?.body ?? media?.caption ?? "";
+            if (!text && !media?.attachment)
+                return [];
+            return [
+                {
+                    channel: this.channel,
+                    target: message.from,
+                    senderId: message.from,
+                    text,
+                    ...(message.id ? { messageId: message.id } : {}),
+                    ...(media?.attachment ? { attachments: [media.attachment] } : {}),
+                },
+            ];
+        })));
+        await Promise.all(messages.map((message) => handler(message)));
+        sendResponse(response, 200, "OK");
+    }
+    async send(target, message) {
+        const attachments = outgoingAttachments(message, this.capabilities.outbound.attachments);
+        if (attachments.length > 0) {
+            await this.delivery.run(message, async () => {
+                const uploaded = await Promise.all(attachments.map(async (attachment) => ({
+                    attachment,
+                    mediaId: await this.uploadMedia(attachment),
+                })));
+                let textAssigned = false;
+                const steps = [];
+                if (message.button || (message.text && uploaded[0]?.attachment.kind === "audio")) {
+                    steps.push(() => this.postPayload(this.textPayload(target, message)));
+                    textAssigned = true;
+                }
+                for (const [index, item] of uploaded.entries()) {
+                    const kind = item.attachment.kind === "file" ? "document" : item.attachment.kind;
+                    const media = { id: item.mediaId };
+                    if (!textAssigned && index === 0 && message.text && kind !== "audio") {
+                        media.caption = message.text;
+                        textAssigned = true;
+                    }
+                    if (kind === "document")
+                        media.filename = item.attachment.name;
+                    const payload = {
+                        messaging_product: "whatsapp",
+                        to: target,
+                        type: kind,
+                        [kind]: media,
+                    };
+                    steps.push(() => this.postPayload(payload));
+                }
+                if (!textAssigned && message.text) {
+                    steps.push(() => this.postPayload(this.textPayload(target, message)));
+                }
+                return steps;
+            });
+            return;
+        }
+        await this.postPayload(this.textPayload(target, message));
+    }
+    textPayload(target, message) {
+        const payload = message.button
+            ? {
+                messaging_product: "whatsapp",
+                to: target,
+                type: "interactive",
+                interactive: {
+                    type: "cta_url",
+                    body: { text: message.text },
+                    action: {
+                        name: "cta_url",
+                        parameters: { display_text: message.button.text, url: message.button.url },
+                    },
+                },
+            }
+            : {
+                messaging_product: "whatsapp",
+                to: target,
+                type: "text",
+                text: { body: message.text },
+            };
+        return payload;
+    }
+    async postPayload(payload) {
+        const response = await this.fetchFn(`https://graph.facebook.com/${this.config.apiVersion}/${this.config.phoneNumberId}/messages`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.config.accessToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok)
+            throw new Error(`WhatsApp 发送失败（HTTP ${response.status}）`);
+    }
+    async uploadMedia(attachment) {
+        const form = new FormData();
+        form.set("messaging_product", "whatsapp");
+        form.set("file", new Blob([new Uint8Array(attachment.data)], { type: attachment.mimeType }), safeAttachmentName(attachment.name));
+        const response = await this.fetchFn(`https://graph.facebook.com/${this.config.apiVersion}/${this.config.phoneNumberId}/media`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${this.config.accessToken}` },
+            body: form,
+            signal: AbortSignal.timeout(30_000),
+        });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok || !body.id) {
+            throw new Error(body.error?.message ?? `WhatsApp 媒体上传失败（HTTP ${response.status}）`);
+        }
+        return body.id;
+    }
+    inboundMedia(message) {
+        const kindByType = {
+            image: "image",
+            audio: "audio",
+            video: "video",
+            document: "file",
+        };
+        const kind = message.type ? kindByType[message.type] : undefined;
+        if (!kind)
+            return undefined;
+        const media = message[message.type];
+        if (!media?.id)
+            return undefined;
+        const mediaId = media.id;
+        const name = safeAttachmentName("filename" in media ? media.filename : undefined, `whatsapp-${mediaId}${kind === "image" ? ".jpg" : kind === "video" ? ".mp4" : ""}`);
+        return {
+            caption: media.caption,
+            attachment: {
+                id: mediaId,
+                kind,
+                name,
+                ...(media.mime_type ? { mimeType: media.mime_type } : {}),
+                load: (signal) => this.downloadMedia(mediaId, signal),
+            },
+        };
+    }
+    async downloadMedia(mediaId, signal) {
+        const metadataResponse = await this.fetchFn(`https://graph.facebook.com/${this.config.apiVersion}/${encodeURIComponent(mediaId)}`, {
+            headers: { authorization: `Bearer ${this.config.accessToken}` },
+            signal: signal
+                ? AbortSignal.any([signal, AbortSignal.timeout(15_000)])
+                : AbortSignal.timeout(15_000),
+        });
+        const metadata = (await metadataResponse.json().catch(() => ({})));
+        if (!metadataResponse.ok || !metadata.url)
+            throw new Error("WhatsApp 媒体下载地址不可用");
+        return downloadRemoteAttachment(this.fetchFn, metadata.url, {
+            headers: { authorization: `Bearer ${this.config.accessToken}` },
+            ...(signal ? { signal } : {}),
+        });
+    }
+    handleVerification(request, response) {
+        const url = new URL(request.url ?? "/", "http://localhost");
+        if (url.searchParams.get("hub.mode") !== "subscribe" ||
+            !safeStringEqual(url.searchParams.get("hub.verify_token"), this.config.verifyToken)) {
+            sendResponse(response, 403, "Verification failed");
+            return;
+        }
+        sendResponse(response, 200, url.searchParams.get("hub.challenge") ?? "");
+    }
+}
+function verifyMetaSignature(body, header, secret) {
+    if (typeof header !== "string" || !header.startsWith("sha256="))
+        return false;
+    const expected = createHmac("sha256", secret).update(body).digest("hex");
+    return safeStringEqual(header.slice(7), expected);
+}
+function safeStringEqual(left, right) {
+    if (left === null)
+        return false;
+    const a = Buffer.from(left);
+    const b = Buffer.from(right);
+    return a.length === b.length && timingSafeEqual(a, b);
+}

package/package.json

@@ -0,0 +1,123 @@
+{
+  "name": "@cjhyy/code-shell-chat",
+  "version": "0.8.0",
+  "description": "A standalone, transport-agnostic multi-channel chat gateway for Node.js and Bun.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./codeshell": {
+      "types": "./dist/codeshell.d.ts",
+      "import": "./dist/codeshell.js"
+    },
+    "./factory": {
+      "types": "./dist/adapter-factory.d.ts",
+      "import": "./dist/adapter-factory.js"
+    },
+    "./telegram": {
+      "types": "./dist/telegram.d.ts",
+      "import": "./dist/telegram.js"
+    },
+    "./discord": {
+      "types": "./dist/discord.d.ts",
+      "import": "./dist/discord.js"
+    },
+    "./slack": {
+      "types": "./dist/slack.d.ts",
+      "import": "./dist/slack.js"
+    },
+    "./lark": {
+      "types": "./dist/lark.d.ts",
+      "import": "./dist/lark.js"
+    },
+    "./dingtalk": {
+      "types": "./dist/dingtalk.d.ts",
+      "import": "./dist/dingtalk.js"
+    },
+    "./wecom": {
+      "types": "./dist/wecom.d.ts",
+      "import": "./dist/wecom.js"
+    },
+    "./wechat": {
+      "types": "./dist/wechat.d.ts",
+      "import": "./dist/wechat.js"
+    },
+    "./matrix": {
+      "types": "./dist/matrix.d.ts",
+      "import": "./dist/matrix.js"
+    },
+    "./mattermost": {
+      "types": "./dist/mattermost.d.ts",
+      "import": "./dist/mattermost.js"
+    },
+    "./line": {
+      "types": "./dist/line.d.ts",
+      "import": "./dist/line.js"
+    },
+    "./whatsapp": {
+      "types": "./dist/whatsapp.d.ts",
+      "import": "./dist/whatsapp.js"
+    },
+    "./teams": {
+      "types": "./dist/teams.d.ts",
+      "import": "./dist/teams.js"
+    }
+  },
+  "bin": {
+    "code-shell-chat": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun run clean && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test src",
+    "dev": "bun run src/cli.ts",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cjhyy/codeshell.git",
+    "directory": "packages/chat"
+  },
+  "engines": {
+    "node": ">=20.10"
+  },
+  "keywords": [
+    "chat",
+    "gateway",
+    "bot",
+    "telegram",
+    "discord",
+    "slack",
+    "lark",
+    "wechat"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@larksuiteoapi/node-sdk": "1.71.0",
+    "@slack/socket-mode": "2.0.7",
+    "@slack/web-api": "7.19.0",
+    "@wecom/aibot-node-sdk": "1.0.7",
+    "botbuilder": "4.23.3",
+    "dingtalk-stream": "2.1.6-beta.1",
+    "discord.js": "14.26.5",
+    "qrcode": "1.5.4",
+    "qrcode-terminal": "0.12.0",
+    "ws": "8.21.0"
+  },
+  "devDependencies": {
+    "@types/qrcode": "1.5.6",
+    "@types/ws": "8.18.1"
+  }
+}