@cjhyy/code-shell-chat 0.8.0

package/dist/lark.js

@@ -0,0 +1,184 @@
+import * as lark from "@larksuiteoapi/node-sdk";
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { dispatchSafely, waitForAbort } from "./lifecycle.js";
+import { OutgoingDeliveryTracker, outgoingAttachments, safeAttachmentName } from "./media.js";
+export class LarkAdapter {
+    channel = "lark";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.lark;
+    client;
+    ws;
+    delivery = new OutgoingDeliveryTracker();
+    constructor(config) {
+        const credentials = {
+            appId: config.appId,
+            appSecret: config.appSecret,
+            ...(config.domain ? { domain: config.domain } : {}),
+        };
+        this.client = new lark.Client(credentials);
+        this.ws = new lark.WSClient({ ...credentials, autoReconnect: true });
+    }
+    async run(handler, signal) {
+        const dispatcher = new lark.EventDispatcher({}).register({
+            "im.message.receive_v1": async (event) => {
+                const messageId = event.message.message_id;
+                const content = parseLarkContent(event.message.content);
+                const text = event.message.message_type === "text" ? (content.text ?? "") : "";
+                const attachment = messageId && event.message.message_type !== "text"
+                    ? this.toAttachment(messageId, event.message.message_type, content)
+                    : undefined;
+                const sender = event.sender.sender_id?.open_id ??
+                    event.sender.sender_id?.user_id ??
+                    event.sender.sender_id?.union_id;
+                if ((!text && !attachment) || !sender)
+                    return;
+                // dispatchSafely so a rejected delivery never escapes the Lark event
+                // dispatcher callback as an unhandled rejection.
+                await dispatchSafely(handler, {
+                    channel: this.channel,
+                    target: event.message.chat_id,
+                    senderId: sender,
+                    text,
+                    ...(event.message.message_id ? { messageId: event.message.message_id } : {}),
+                    ...(attachment ? { attachments: [attachment] } : {}),
+                });
+            },
+        });
+        signal.addEventListener("abort", () => this.ws.close({ force: true }), { once: true });
+        await this.ws.start({ eventDispatcher: dispatcher });
+        await waitForAbort(signal);
+    }
+    async send(target, message) {
+        const attachments = outgoingAttachments(message, this.capabilities.outbound.attachments);
+        const payload = message.button
+            ? {
+                msg_type: "interactive",
+                content: JSON.stringify({
+                    config: { wide_screen_mode: true },
+                    elements: [
+                        { tag: "div", text: { tag: "plain_text", content: message.text } },
+                        {
+                            tag: "action",
+                            actions: [
+                                {
+                                    tag: "button",
+                                    type: "primary",
+                                    text: { tag: "plain_text", content: message.button.text },
+                                    url: message.button.url,
+                                },
+                            ],
+                        },
+                    ],
+                }),
+            }
+            : { msg_type: "text", content: JSON.stringify({ text: message.text }) };
+        await this.delivery.run(message, () => [
+            ...(message.text || message.button ? [() => this.createMessage(target, payload)] : []),
+            ...attachments.map((attachment) => () => this.sendAttachment(target, attachment)),
+        ]);
+    }
+    toAttachment(messageId, messageType, content) {
+        const key = content.image_key ?? content.file_key;
+        if (!key || !["image", "file", "audio", "media"].includes(messageType))
+            return undefined;
+        const kind = messageType === "image"
+            ? "image"
+            : messageType === "audio"
+                ? "audio"
+                : messageType === "media"
+                    ? "video"
+                    : "file";
+        const name = safeAttachmentName(content.file_name, `lark-${messageId}${kind === "image" ? ".jpg" : kind === "audio" ? ".opus" : kind === "video" ? ".mp4" : ""}`);
+        return {
+            id: `${messageId}:${key}`,
+            kind,
+            name,
+            ...(kind === "image"
+                ? { mimeType: "image/jpeg" }
+                : kind === "audio"
+                    ? { mimeType: "audio/ogg" }
+                    : kind === "video"
+                        ? { mimeType: "video/mp4" }
+                        : {}),
+            load: (signal) => this.loadMessageResource(messageId, key, messageType === "image" ? "image" : "file", signal),
+        };
+    }
+    async loadMessageResource(messageId, fileKey, type, signal) {
+        if (signal?.aborted)
+            throw signal.reason;
+        const resource = await this.client.im.v1.messageResource.get({
+            path: { message_id: messageId, file_key: fileKey },
+            params: { type },
+        });
+        const chunks = [];
+        let total = 0;
+        for await (const raw of resource.getReadableStream()) {
+            if (signal?.aborted)
+                throw signal.reason;
+            const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+            total += chunk.byteLength;
+            if (total > 10 * 1024 * 1024)
+                throw new Error("飞书附件超过大小限制");
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks, total);
+    }
+    async sendAttachment(target, attachment) {
+        if (attachment.kind === "image") {
+            const uploaded = await this.client.im.v1.image.create({
+                data: { image_type: "message", image: Buffer.from(attachment.data) },
+            });
+            if (!uploaded?.image_key)
+                throw new Error("飞书图片上传未返回 image_key");
+            await this.createMessage(target, {
+                msg_type: "image",
+                content: JSON.stringify({ image_key: uploaded.image_key }),
+            });
+            return;
+        }
+        const extension = attachment.name.toLowerCase().match(/\.([a-z0-9]+)$/)?.[1];
+        const fileType = attachment.kind === "audio" && ["opus", "ogg"].includes(extension ?? "")
+            ? "opus"
+            : attachment.kind === "video" && extension === "mp4"
+                ? "mp4"
+                : extension === "pdf"
+                    ? "pdf"
+                    : ["doc", "docx"].includes(extension ?? "")
+                        ? "doc"
+                        : ["xls", "xlsx"].includes(extension ?? "")
+                            ? "xls"
+                            : ["ppt", "pptx"].includes(extension ?? "")
+                                ? "ppt"
+                                : "stream";
+        const uploaded = await this.client.im.v1.file.create({
+            data: {
+                file_type: fileType,
+                file_name: attachment.name,
+                file: Buffer.from(attachment.data),
+            },
+        });
+        if (!uploaded?.file_key)
+            throw new Error("飞书文件上传未返回 file_key");
+        const msgType = fileType === "opus" ? "audio" : fileType === "mp4" ? "media" : "file";
+        await this.createMessage(target, {
+            msg_type: msgType,
+            content: JSON.stringify({ file_key: uploaded.file_key }),
+        });
+    }
+    async createMessage(target, payload) {
+        const result = await this.client.im.v1.message.create({
+            params: { receive_id_type: "chat_id" },
+            data: { receive_id: target, ...payload },
+        });
+        if (result.code !== 0)
+            throw new Error(`飞书发送失败：${result.msg ?? result.code}`);
+    }
+}
+function parseLarkContent(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === "string"));
+    }
+    catch {
+        return {};
+    }
+}

package/dist/lifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { ChannelMessage, ChannelMessageHandler } from "./channel.js";
+export declare function waitForAbort(signal: AbortSignal): Promise<void>;
+export declare function formatOutgoingMarkdown(text: string, button?: {
+    text: string;
+    url: string;
+}): string;
+export declare function dispatchSafely(handler: ChannelMessageHandler, message: ChannelMessage): Promise<void>;

package/dist/lifecycle.js

@@ -0,0 +1,16 @@
+export async function waitForAbort(signal) {
+    if (signal.aborted)
+        return;
+    await new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+}
+export function formatOutgoingMarkdown(text, button) {
+    return button ? `${text}\n\n[${button.text.replaceAll("]", "\\]")}](${button.url})` : text;
+}
+export async function dispatchSafely(handler, message) {
+    try {
+        await handler(message);
+    }
+    catch (error) {
+        console.error(`[chat] ${message.channel} 消息处理失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/line.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ChannelMessageHandler, OutgoingMessage, WebhookChannelAdapter } from "./channel.js";
+export interface LineAdapterConfig {
+    channelSecret: string;
+    channelAccessToken: string;
+}
+export declare class LineAdapter implements WebhookChannelAdapter {
+    private readonly config;
+    private readonly fetchFn;
+    readonly channel = "line";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    readonly webhookPath = "/webhooks/line";
+    constructor(config: LineAdapterConfig, 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>;
+}

package/dist/line.js

@@ -0,0 +1,123 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { waitForAbort } from "./lifecycle.js";
+import { remoteAttachment, safeAttachmentName } from "./media.js";
+import { readRequestBody, sendResponse } from "./webhook.js";
+export class LineAdapter {
+    config;
+    fetchFn;
+    channel = "line";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.line;
+    webhookPath = "/webhooks/line";
+    constructor(config, fetchFn = fetch) {
+        this.config = config;
+        this.fetchFn = fetchFn;
+    }
+    run(_handler, signal) {
+        return waitForAbort(signal);
+    }
+    async handleWebhook(request, response, handler, maxBodyBytes) {
+        if (request.method !== "POST") {
+            sendResponse(response, 405, "Method not allowed");
+            return;
+        }
+        const raw = await readRequestBody(request, maxBodyBytes);
+        if (!verifyLineSignature(raw, request.headers["x-line-signature"], this.config.channelSecret)) {
+            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.events ?? []).flatMap((event) => {
+            const target = event.source?.groupId ?? event.source?.roomId ?? event.source?.userId;
+            const senderId = event.source?.userId;
+            if (event.type !== "message" || !event.message || !target || !senderId)
+                return [];
+            const { id, type } = event.message;
+            const mediaKind = type === "image"
+                ? "image"
+                : type === "audio"
+                    ? "audio"
+                    : type === "video"
+                        ? "video"
+                        : type === "file"
+                            ? "file"
+                            : undefined;
+            const attachment = id && mediaKind
+                ? remoteAttachment({
+                    id,
+                    kind: mediaKind,
+                    name: safeAttachmentName(event.message.fileName, `line-${id}${mediaKind === "image" ? ".jpg" : mediaKind === "video" ? ".mp4" : ""}`),
+                    mimeType: mediaKind === "image"
+                        ? "image/jpeg"
+                        : mediaKind === "video"
+                            ? "video/mp4"
+                            : undefined,
+                    size: event.message.fileSize,
+                    url: `https://api-data.line.me/v2/bot/message/${encodeURIComponent(id)}/content`,
+                    headers: { authorization: `Bearer ${this.config.channelAccessToken}` },
+                    fetch: this.fetchFn,
+                })
+                : undefined;
+            const text = type === "text" ? (event.message.text ?? "") : "";
+            if (!text && !attachment)
+                return [];
+            return [
+                {
+                    channel: this.channel,
+                    target,
+                    senderId,
+                    text,
+                    ...(id ? { messageId: id } : {}),
+                    ...(attachment ? { attachments: [attachment] } : {}),
+                },
+            ];
+        });
+        await Promise.all(messages.map((message) => handler(message)));
+        sendResponse(response, 200, "OK");
+    }
+    async send(target, message) {
+        const messages = [{ type: "text", text: message.text }];
+        if (message.button) {
+            messages.push({
+                type: "template",
+                altText: message.button.text,
+                template: {
+                    type: "buttons",
+                    text: "配对入口 10 分钟内有效",
+                    actions: [{ type: "uri", label: message.button.text, uri: message.button.url }],
+                },
+            });
+        }
+        const response = await this.fetchFn("https://api.line.me/v2/bot/message/push", {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${this.config.channelAccessToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ to: target, messages }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok)
+            throw new Error(`LINE 发送失败（HTTP ${response.status}）`);
+    }
+}
+function verifyLineSignature(body, header, secret) {
+    if (typeof header !== "string")
+        return false;
+    const expected = createHmac("sha256", secret).update(body).digest();
+    let actual;
+    try {
+        actual = Buffer.from(header, "base64");
+    }
+    catch {
+        return false;
+    }
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}

package/dist/matrix.d.ts

@@ -0,0 +1,21 @@
+import type { ChannelAdapter, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+export interface MatrixAdapterConfig {
+    homeserverUrl: string;
+    accessToken: string;
+    botUserId?: string;
+}
+export declare class MatrixAdapter implements ChannelAdapter {
+    private readonly config;
+    private readonly fetchFn;
+    readonly channel = "matrix";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    private readonly delivery;
+    constructor(config: MatrixAdapterConfig, fetchFn?: typeof fetch);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private sendRoomMessage;
+    private uploadAttachment;
+    private toMessages;
+    private matrixAttachment;
+    private call;
+}

package/dist/matrix.js

@@ -0,0 +1,208 @@
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { downloadRemoteAttachment, OutgoingDeliveryTracker, outgoingAttachments, safeAttachmentName, } from "./media.js";
+export class MatrixAdapter {
+    config;
+    fetchFn;
+    channel = "matrix";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.matrix;
+    delivery = new OutgoingDeliveryTracker();
+    constructor(config, fetchFn = fetch) {
+        this.config = config;
+        this.fetchFn = fetchFn;
+    }
+    async run(handler, signal) {
+        let since;
+        let retryMs = 1_000;
+        while (!signal.aborted) {
+            try {
+                const query = new URLSearchParams({ timeout: "30000" });
+                if (since)
+                    query.set("since", since);
+                const sync = await this.call(`/_matrix/client/v3/sync?${query}`, {
+                    method: "GET",
+                    signal,
+                });
+                retryMs = 1_000;
+                for (const message of this.toMessages(sync)) {
+                    await handler(message);
+                }
+                // Matrix tokens acknowledge the whole sync batch. Advance only after
+                // every accepted event has reached the durable inbox.
+                since = sync.next_batch ?? since;
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                await abortableDelay(retryMs, signal);
+                retryMs = Math.min(retryMs * 2, 30_000);
+                if (error instanceof MatrixRateLimitError && error.retryAfterMs) {
+                    retryMs = Math.max(retryMs, error.retryAfterMs);
+                }
+            }
+        }
+    }
+    async send(target, message) {
+        const attachments = outgoingAttachments(message, this.capabilities.outbound.attachments);
+        const body = message.button ? `${message.text}\n\n${message.button.text}` : message.text;
+        await this.delivery.run(message, () => [
+            ...(body
+                ? [
+                    () => this.sendRoomMessage(target, {
+                        msgtype: "m.text",
+                        body,
+                        ...(message.button
+                            ? {
+                                format: "org.matrix.custom.html",
+                                formatted_body: `${escapeHtml(message.text).replaceAll("\n", "<br>")}<br><br><a href="${escapeHtml(message.button.url)}">${escapeHtml(message.button.text)}</a>`,
+                            }
+                            : {}),
+                    }).then(() => undefined),
+                ]
+                : []),
+            ...attachments.map((attachment) => async () => {
+                const contentUri = await this.uploadAttachment(attachment);
+                await this.sendRoomMessage(target, {
+                    msgtype: attachment.kind === "image"
+                        ? "m.image"
+                        : attachment.kind === "audio"
+                            ? "m.audio"
+                            : attachment.kind === "video"
+                                ? "m.video"
+                                : "m.file",
+                    body: attachment.name,
+                    filename: attachment.name,
+                    url: contentUri,
+                    info: { mimetype: attachment.mimeType, size: attachment.data.byteLength },
+                });
+            }),
+        ]);
+    }
+    sendRoomMessage(target, content) {
+        return this.call(`/_matrix/client/v3/rooms/${encodeURIComponent(target)}/send/m.room.message/${crypto.randomUUID()}`, {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(content),
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    async uploadAttachment(attachment) {
+        const query = new URLSearchParams({ filename: safeAttachmentName(attachment.name) });
+        const result = await this.call(`/_matrix/media/v3/upload?${query}`, {
+            method: "POST",
+            headers: { "content-type": attachment.mimeType },
+            body: new Uint8Array(attachment.data),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!result.content_uri)
+            throw new Error("Matrix 媒体上传未返回 content_uri");
+        return result.content_uri;
+    }
+    toMessages(sync) {
+        const messages = [];
+        const now = Date.now();
+        for (const [roomId, room] of Object.entries(sync.rooms?.join ?? {})) {
+            for (const event of room.timeline?.events ?? []) {
+                const content = event.content;
+                if (event.type !== "m.room.message" ||
+                    !content?.msgtype ||
+                    !event.sender ||
+                    event.sender === this.config.botUserId ||
+                    (event.origin_server_ts !== undefined && now - event.origin_server_ts > 5 * 60_000)) {
+                    continue;
+                }
+                const kind = content.msgtype === "m.image"
+                    ? "image"
+                    : content.msgtype === "m.audio"
+                        ? "audio"
+                        : content.msgtype === "m.video"
+                            ? "video"
+                            : content.msgtype === "m.file"
+                                ? "file"
+                                : undefined;
+                const attachment = kind && content.url
+                    ? this.matrixAttachment(event.event_id ?? `${roomId}:${content.url}`, kind, {
+                        ...content,
+                        url: content.url,
+                    })
+                    : undefined;
+                const text = content.msgtype === "m.text" ? (content.body ?? "") : "";
+                if (!text && !attachment)
+                    continue;
+                messages.push({
+                    channel: "matrix",
+                    target: roomId,
+                    senderId: event.sender,
+                    text,
+                    ...(event.event_id ? { messageId: event.event_id } : {}),
+                    ...(attachment ? { attachments: [attachment] } : {}),
+                });
+            }
+        }
+        return messages;
+    }
+    matrixAttachment(id, kind, content) {
+        const url = matrixMediaUrl(this.config.homeserverUrl, content.url);
+        return {
+            id,
+            kind,
+            name: safeAttachmentName(content.filename ?? content.body, `matrix-${id}`),
+            ...(content.info?.mimetype ? { mimeType: content.info.mimetype } : {}),
+            ...(content.info?.size !== undefined ? { size: content.info.size } : {}),
+            load: (signal) => downloadRemoteAttachment(this.fetchFn, url, {
+                headers: { authorization: `Bearer ${this.config.accessToken}` },
+                ...(signal ? { signal } : {}),
+                allowPrivateNetwork: true,
+            }),
+        };
+    }
+    async call(path, init) {
+        const response = await this.fetchFn(`${this.config.homeserverUrl}${path}`, {
+            ...init,
+            headers: {
+                authorization: `Bearer ${this.config.accessToken}`,
+                ...init.headers,
+            },
+        });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok) {
+            if (response.status === 429) {
+                throw new MatrixRateLimitError(body.error ?? "Matrix 请求过于频繁", body.retry_after_ms);
+            }
+            throw new Error(body.error ?? `Matrix 请求失败（HTTP ${response.status}）`);
+        }
+        return body;
+    }
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+class MatrixRateLimitError extends Error {
+    retryAfterMs;
+    constructor(message, retryAfterMs) {
+        super(message);
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+function matrixMediaUrl(homeserverUrl, mxc) {
+    if (!mxc.startsWith("mxc://"))
+        throw new Error("Matrix 媒体 URI 无效");
+    const path = mxc.slice("mxc://".length).split("/").map(encodeURIComponent).join("/");
+    return `${homeserverUrl}/_matrix/client/v1/media/download/${path}`;
+}
+async function abortableDelay(ms, signal) {
+    if (signal.aborted)
+        return;
+    await new Promise((resolve) => {
+        const timer = setTimeout(done, ms);
+        signal.addEventListener("abort", done, { once: true });
+        function done() {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", done);
+            resolve();
+        }
+    });
+}

package/dist/mattermost.d.ts

@@ -0,0 +1,18 @@
+import type { ChannelAdapter, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+export interface MattermostAdapterConfig {
+    serverUrl: string;
+    botToken: string;
+    botUserId?: string;
+}
+export declare class MattermostAdapter implements ChannelAdapter {
+    private readonly config;
+    private readonly fetchFn;
+    readonly channel = "mattermost";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    readonly combinesTextAndAttachmentsAtomically = true;
+    constructor(config: MattermostAdapterConfig, fetchFn?: typeof fetch);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private connect;
+    private onMessage;
+}