@cjhyy/code-shell-chat 0.8.0

package/dist/teams.js

@@ -0,0 +1,193 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { ActivityTypes, CloudAdapter, ConfigurationBotFrameworkAuthentication, TurnContext, } from "botbuilder";
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { formatOutgoingMarkdown, waitForAbort } from "./lifecycle.js";
+import { mediaKind, outgoingAttachments, remoteAttachment, safeAttachmentName } from "./media.js";
+import { readRequestBody, sendResponse } from "./webhook.js";
+export class TeamsAdapter {
+    channel = "teams";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.teams;
+    combinesTextAndAttachmentsAtomically = true;
+    webhookPath = "/webhooks/teams";
+    adapter;
+    appId;
+    contexts = new Map();
+    references = new Map();
+    statePath;
+    constructor(config) {
+        this.appId = config.appId;
+        this.statePath = config.statePath;
+        const authentication = new ConfigurationBotFrameworkAuthentication({
+            MicrosoftAppType: config.appType ?? "MultiTenant",
+            MicrosoftAppId: config.appId,
+            MicrosoftAppPassword: config.appPassword,
+            ...(config.tenantId ? { MicrosoftAppTenantId: config.tenantId } : {}),
+        });
+        this.adapter = new CloudAdapter(authentication);
+        this.loadReferences();
+    }
+    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);
+        let body;
+        try {
+            body = JSON.parse(raw.toString("utf8"));
+        }
+        catch {
+            sendResponse(response, 400, "Invalid JSON");
+            return;
+        }
+        await this.adapter.process({ method: request.method, headers: request.headers, body }, new BotFrameworkResponse(response), async (context) => {
+            const activity = context.activity;
+            const target = activity.conversation?.id;
+            const senderId = activity.from?.id;
+            if (activity.type !== ActivityTypes.Message || !target || !senderId)
+                return;
+            const text = activity.text
+                ? TurnContext.removeRecipientMention(activity).trim() || activity.text
+                : "";
+            const attachments = (activity.attachments ?? []).flatMap((attachment, index) => {
+                const contentType = attachment.contentType?.toLowerCase() ?? "";
+                if (contentType.startsWith("application/vnd.microsoft.card.") ||
+                    contentType === "text/html") {
+                    return [];
+                }
+                const downloadInfo = contentType === "application/vnd.microsoft.teams.file.download.info" &&
+                    attachment.content &&
+                    typeof attachment.content === "object"
+                    ? attachment.content
+                    : undefined;
+                const url = downloadInfo?.downloadUrl ?? attachment.contentUrl;
+                if (!url)
+                    return [];
+                const mimeType = downloadInfo?.fileType && downloadInfo.fileType.includes("/")
+                    ? downloadInfo.fileType
+                    : contentType === "application/vnd.microsoft.teams.file.download.info"
+                        ? undefined
+                        : attachment.contentType;
+                const id = downloadInfo?.uniqueId ?? `${activity.id ?? target}:${index}`;
+                return [
+                    remoteAttachment({
+                        id,
+                        kind: mediaKind(mimeType, attachment.name),
+                        name: safeAttachmentName(attachment.name, `teams-${id}`),
+                        mimeType,
+                        url,
+                    }),
+                ];
+            });
+            if (!text && attachments.length === 0)
+                return;
+            this.references.set(target, TurnContext.getConversationReference(activity));
+            this.saveReferences();
+            this.contexts.set(target, context);
+            try {
+                await handler({
+                    channel: this.channel,
+                    target,
+                    senderId,
+                    text,
+                    ...(activity.id ? { messageId: activity.id } : {}),
+                    ...(attachments.length > 0 ? { attachments } : {}),
+                });
+            }
+            finally {
+                this.contexts.delete(target);
+            }
+        });
+    }
+    async send(target, message) {
+        const context = this.contexts.get(target);
+        const text = formatOutgoingMarkdown(message.text, message.button);
+        const outgoing = outgoingAttachments(message, this.capabilities.outbound.attachments);
+        const maximum = this.capabilities.outbound.maxAttachmentBytes ?? 1024 * 1024;
+        if (outgoing.some((attachment) => attachment.data.byteLength > maximum)) {
+            throw new Error(`Teams 内联图片不能超过 ${maximum} 字节`);
+        }
+        const attachments = outgoing.map((attachment) => ({
+            contentType: attachment.mimeType,
+            contentUrl: `data:${attachment.mimeType};base64,${Buffer.from(attachment.data).toString("base64")}`,
+            name: safeAttachmentName(attachment.name),
+        }));
+        const activity = {
+            type: ActivityTypes.Message,
+            text,
+            ...(attachments.length > 0 ? { attachments } : {}),
+        };
+        if (context) {
+            await context.sendActivity(activity);
+            return;
+        }
+        const reference = this.references.get(target);
+        if (!reference)
+            throw new Error(`Teams 会话 ${target} 尚无 conversation reference`);
+        await this.adapter.continueConversationAsync(this.appId, reference, async (turn) => {
+            await turn.sendActivity(activity);
+        });
+    }
+    loadReferences() {
+        if (!this.statePath)
+            return;
+        try {
+            const parsed = JSON.parse(readFileSync(this.statePath, "utf-8"));
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                return;
+            for (const [target, reference] of Object.entries(parsed).slice(0, 1_000)) {
+                if (target && reference && typeof reference === "object" && !Array.isArray(reference)) {
+                    this.references.set(target, reference);
+                }
+            }
+        }
+        catch {
+            // First run, malformed legacy state, or an unavailable home directory.
+        }
+    }
+    saveReferences() {
+        if (!this.statePath)
+            return;
+        const entries = [...this.references.entries()].slice(-1_000);
+        mkdirSync(dirname(this.statePath), { recursive: true, mode: 0o700 });
+        const temporary = `${this.statePath}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${JSON.stringify(Object.fromEntries(entries))}\n`, {
+            encoding: "utf-8",
+            mode: 0o600,
+        });
+        renameSync(temporary, this.statePath);
+        if (process.platform !== "win32")
+            chmodSync(this.statePath, 0o600);
+    }
+}
+class BotFrameworkResponse {
+    response;
+    socket;
+    constructor(response) {
+        this.response = response;
+        this.socket = response.socket;
+    }
+    status(code) {
+        this.response.statusCode = code;
+        return this;
+    }
+    header(name, value) {
+        this.response.setHeader(name, String(value));
+        return this;
+    }
+    send(...args) {
+        const body = args.at(-1);
+        if (body !== undefined) {
+            this.response.write(typeof body === "string" ? body : JSON.stringify(body));
+        }
+        return this;
+    }
+    end(...args) {
+        this.response.end(...args);
+        return this;
+    }
+}

package/dist/telegram.d.ts

@@ -0,0 +1,33 @@
+import type { ChannelAdapter, ChannelMessageHandler, OutgoingMessage } from "./channel.js";
+export interface TelegramAdapterConfig {
+    botToken: string;
+    apiBaseUrl?: string;
+}
+export interface TelegramAdapterOptions {
+    fetch?: typeof fetch;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    log?: (message: string) => void;
+    now?: () => number;
+    maxMessageAgeMs?: number;
+}
+export declare class TelegramAdapter implements ChannelAdapter {
+    private readonly config;
+    readonly channel = "telegram";
+    readonly capabilities: import("./channel.js").ChannelCapabilities;
+    private readonly delivery;
+    readonly supportsOutgoingAttachments = true;
+    private readonly fetchFn;
+    private readonly sleepFn;
+    private readonly log;
+    private readonly now;
+    private readonly maxMessageAgeMs;
+    private readonly apiBaseUrl;
+    constructor(config: TelegramAdapterConfig, opts?: TelegramAdapterOptions);
+    run(handler: ChannelMessageHandler, signal: AbortSignal): Promise<void>;
+    send(target: string, message: OutgoingMessage): Promise<void>;
+    private call;
+    private callMultipart;
+    private readResponse;
+    private downloadFile;
+    private redact;
+}

package/dist/telegram.js

@@ -0,0 +1,263 @@
+import { BUILTIN_CHANNEL_CAPABILITIES } from "./channel.js";
+import { OutgoingDeliveryTracker, outgoingAttachments } from "./media.js";
+const DEFAULT_MAX_MESSAGE_AGE_MS = 5 * 60_000;
+export class TelegramAdapter {
+    config;
+    channel = "telegram";
+    capabilities = BUILTIN_CHANNEL_CAPABILITIES.telegram;
+    delivery = new OutgoingDeliveryTracker();
+    supportsOutgoingAttachments = true;
+    fetchFn;
+    sleepFn;
+    log;
+    now;
+    maxMessageAgeMs;
+    apiBaseUrl;
+    constructor(config, opts = {}) {
+        this.config = config;
+        this.fetchFn = opts.fetch ?? fetch;
+        this.sleepFn = opts.sleep ?? abortableDelay;
+        this.log = opts.log ?? (() => undefined);
+        this.now = opts.now ?? Date.now;
+        this.maxMessageAgeMs = opts.maxMessageAgeMs ?? DEFAULT_MAX_MESSAGE_AGE_MS;
+        this.apiBaseUrl = config.apiBaseUrl?.replace(/\/$/, "") ?? "https://api.telegram.org";
+    }
+    async run(handler, signal) {
+        let offset;
+        let retryMs = 1_000;
+        while (!signal.aborted) {
+            try {
+                const updates = await this.call("getUpdates", {
+                    offset,
+                    timeout: 30,
+                    allowed_updates: ["message"],
+                }, signal);
+                retryMs = 1_000;
+                for (const update of updates) {
+                    const nextOffset = Math.max(offset ?? 0, update.update_id + 1);
+                    if (isStale(update, this.now(), this.maxMessageAgeMs)) {
+                        offset = nextOffset;
+                        continue;
+                    }
+                    const message = toChannelMessage(update, (fileId, signal) => this.downloadFile(fileId, signal));
+                    if (!message) {
+                        offset = nextOffset;
+                        continue;
+                    }
+                    try {
+                        await handler(message);
+                        // Commit the platform cursor only after ChatGateway has durably
+                        // accepted the delivery. A full/broken inbox is retried by Telegram.
+                        offset = nextOffset;
+                    }
+                    catch (error) {
+                        this.log(`Telegram update ${update.update_id} 处理失败，${retryMs}ms 后重试：${this.redact(formatError(error))}`);
+                        // Back off before re-polling. The offset is intentionally NOT
+                        // advanced, so getUpdates returns the same pending batch instantly;
+                        // without a delay the loop would hot-spin and hammer the API (and
+                        // spam the log) until Telegram rate-limits us. Mirror the outer
+                        // error path's backoff so a persistently-full inbox settles down.
+                        await this.sleepFn(retryMs, signal).catch(() => undefined);
+                        retryMs = Math.min(retryMs * 2, 30_000);
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                if (signal.aborted)
+                    return;
+                this.log(`Telegram long polling 失败，${retryMs}ms 后重试：${this.redact(formatError(error))}`);
+                await this.sleepFn(retryMs, signal).catch(() => undefined);
+                retryMs = Math.min(retryMs * 2, 30_000);
+            }
+        }
+    }
+    async send(target, message) {
+        const attachments = outgoingAttachments(message, this.capabilities.outbound.attachments);
+        await this.delivery.run(message, () => [
+            ...(message.text || message.button
+                ? [
+                    () => this.call("sendMessage", {
+                        chat_id: target,
+                        text: message.text,
+                        ...(message.button
+                            ? {
+                                reply_markup: {
+                                    inline_keyboard: [
+                                        [{ text: message.button.text, url: message.button.url }],
+                                    ],
+                                },
+                            }
+                            : {}),
+                    }, AbortSignal.timeout(15_000)).then(() => undefined),
+                ]
+                : []),
+            ...attachments.map((attachment) => async () => {
+                if (attachment.kind === "image" &&
+                    !["image/png", "image/jpeg", "image/gif", "image/webp"].includes(attachment.mimeType)) {
+                    throw new Error("Telegram 待发送图片的类型不受支持");
+                }
+                const media = telegramOutboundMethod(attachment.kind, attachment.mimeType);
+                const form = new FormData();
+                const bytes = new Uint8Array(attachment.data.byteLength);
+                bytes.set(attachment.data);
+                form.set("chat_id", target);
+                form.set(media.field, new Blob([bytes], { type: attachment.mimeType }), attachment.name);
+                await this.callMultipart(media.method, form, AbortSignal.timeout(30_000));
+            }),
+        ]);
+    }
+    async call(method, body, signal) {
+        const response = await this.fetchFn(`${this.apiBaseUrl}/bot${this.config.botToken}/${method}`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+            signal,
+        });
+        return this.readResponse(method, response);
+    }
+    async callMultipart(method, body, signal) {
+        const response = await this.fetchFn(`${this.apiBaseUrl}/bot${this.config.botToken}/${method}`, {
+            method: "POST",
+            body,
+            signal,
+        });
+        return this.readResponse(method, response);
+    }
+    async readResponse(method, response) {
+        let result;
+        try {
+            result = (await response.json());
+        }
+        catch {
+            throw new Error(`Telegram ${method} 返回无效 JSON（HTTP ${response.status}）`);
+        }
+        if (!response.ok || !result.ok) {
+            throw new Error(result.description ?? `Telegram ${method} 失败（HTTP ${response.status}）`);
+        }
+        return result.result;
+    }
+    async downloadFile(fileId, signal) {
+        const file = await this.call("getFile", { file_id: fileId }, signal ?? AbortSignal.timeout(30_000));
+        if (!file.file_path)
+            throw new Error("Telegram getFile 未返回文件路径");
+        const response = await this.fetchFn(`${this.apiBaseUrl}/file/bot${this.config.botToken}/${file.file_path}`, { signal: signal ?? AbortSignal.timeout(30_000) });
+        if (!response.ok)
+            throw new Error(`Telegram 文件下载失败（HTTP ${response.status}）`);
+        return readBoundedResponse(response, 10 * 1024 * 1024);
+    }
+    redact(message) {
+        return message.split(this.config.botToken).join("[REDACTED]");
+    }
+}
+function telegramOutboundMethod(kind, mimeType) {
+    if (kind === "audio")
+        return { method: "sendAudio", field: "audio" };
+    if (kind === "video")
+        return { method: "sendVideo", field: "video" };
+    if (kind === "file" || mimeType === "image/webp") {
+        return { method: "sendDocument", field: "document" };
+    }
+    return mimeType === "image/gif"
+        ? { method: "sendAnimation", field: "animation" }
+        : { method: "sendPhoto", field: "photo" };
+}
+function isStale(update, now, maxAgeMs) {
+    const sentAtSeconds = update.message?.date;
+    return typeof sentAtSeconds === "number" && now - sentAtSeconds * 1_000 > maxAgeMs;
+}
+function toChannelMessage(update, download) {
+    const message = update.message;
+    if (!message)
+        return undefined;
+    const sender = message.from?.id ?? message.sender_chat?.id;
+    if (sender === undefined)
+        return undefined;
+    const attachments = telegramAttachments(message, download);
+    const text = message.text ?? message.caption ?? "";
+    if (!text && attachments.length === 0)
+        return undefined;
+    return {
+        channel: "telegram",
+        target: String(message.chat.id),
+        senderId: String(sender),
+        text,
+        ...(attachments.length > 0 ? { attachments } : {}),
+        ...(message.message_id === undefined ? {} : { messageId: String(message.message_id) }),
+    };
+}
+function telegramAttachments(message, download) {
+    const specs = [];
+    const photo = [...(message.photo ?? [])].sort((a, b) => (b.file_size ?? (b.width ?? 0) * (b.height ?? 0)) -
+        (a.file_size ?? (a.width ?? 0) * (a.height ?? 0)))[0];
+    if (photo)
+        specs.push({ media: photo, kind: "image", fallback: "telegram-photo.jpg" });
+    if (message.document)
+        specs.push({ media: message.document, kind: "file", fallback: "telegram-file" });
+    if (message.audio)
+        specs.push({ media: message.audio, kind: "audio", fallback: "telegram-audio" });
+    if (message.voice)
+        specs.push({ media: message.voice, kind: "audio", fallback: "telegram-voice.ogg" });
+    if (message.video)
+        specs.push({ media: message.video, kind: "video", fallback: "telegram-video.mp4" });
+    return specs.map(({ media, kind, fallback }) => ({
+        id: media.file_unique_id ?? media.file_id,
+        kind,
+        name: media.file_name ?? fallback,
+        ...(media.mime_type
+            ? { mimeType: media.mime_type }
+            : kind === "image"
+                ? { mimeType: "image/jpeg" }
+                : {}),
+        ...(media.file_size === undefined ? {} : { size: media.file_size }),
+        load: (signal) => download(media.file_id, signal),
+    }));
+}
+async function readBoundedResponse(response, maxBytes) {
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > maxBytes)
+        throw new Error("Telegram 附件超过大小限制");
+    if (!response.body) {
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.byteLength > maxBytes)
+            throw new Error("Telegram 附件超过大小限制");
+        return bytes;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > maxBytes) {
+            await reader.cancel();
+            throw new Error("Telegram 附件超过大小限制");
+        }
+        chunks.push(value);
+    }
+    const output = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        output.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return output;
+}
+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();
+        }
+    });
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/webhook.d.ts

@@ -0,0 +1,26 @@
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import type { ChannelMessageHandler, WebhookChannelAdapter } from "./channel.js";
+export interface WebhookIngressConfig {
+    host: string;
+    port: number;
+    maxBodyBytes: number;
+    healthPath?: string;
+    readyPath?: string;
+    requestTimeoutMs?: number;
+}
+export interface WebhookRegistration {
+    adapter: WebhookChannelAdapter;
+    handler: ChannelMessageHandler;
+}
+export declare class WebhookIngressServer {
+    private readonly config;
+    private readonly registrations;
+    private readonly health;
+    private server?;
+    constructor(config: WebhookIngressConfig, registrations: WebhookRegistration[], health?: () => Record<string, unknown>);
+    run(signal: AbortSignal): Promise<void>;
+}
+export declare class WebhookBodyTooLargeError extends Error {
+}
+export declare function readRequestBody(request: IncomingMessage, maxBytes: number): Promise<Buffer>;
+export declare function sendResponse(response: ServerResponse, status: number, body?: string, contentType?: string): void;

package/dist/webhook.js

@@ -0,0 +1,91 @@
+import { createServer } from "node:http";
+export class WebhookIngressServer {
+    config;
+    registrations;
+    health;
+    server;
+    constructor(config, registrations, health = () => ({ status: "ready" })) {
+        this.config = config;
+        this.registrations = registrations;
+        this.health = health;
+    }
+    async run(signal) {
+        const routes = new Map(this.registrations.map((registration) => [registration.adapter.webhookPath, registration]));
+        this.server = createServer((request, response) => {
+            const pathname = new URL(request.url ?? "/", "http://localhost").pathname;
+            if (request.method === "GET" && pathname === (this.config.healthPath ?? "/healthz")) {
+                request.resume();
+                sendJson(response, 200, { status: "ok", ...this.health() });
+                return;
+            }
+            if (request.method === "GET" && pathname === (this.config.readyPath ?? "/readyz")) {
+                request.resume();
+                const body = this.health();
+                sendJson(response, body.status === "ready" ? 200 : 503, body);
+                return;
+            }
+            const registration = routes.get(pathname);
+            if (!registration) {
+                sendResponse(response, 404, "Not found");
+                return;
+            }
+            void registration.adapter
+                .handleWebhook(request, response, registration.handler, this.config.maxBodyBytes)
+                .catch((error) => {
+                if (response.headersSent) {
+                    response.end();
+                    return;
+                }
+                sendResponse(response, error instanceof WebhookBodyTooLargeError ? 413 : 500, error instanceof WebhookBodyTooLargeError ? "Payload too large" : "Webhook error");
+            });
+        });
+        this.server.requestTimeout = this.config.requestTimeoutMs ?? 15_000;
+        await listen(this.server, this.config.host, this.config.port);
+        const address = this.server.address();
+        console.log(`[chat] webhook ingress：http://${address.address}:${address.port}`);
+        if (signal.aborted)
+            await close(this.server);
+        else {
+            await new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+            await close(this.server);
+        }
+    }
+}
+function sendJson(response, status, body) {
+    sendResponse(response, status, JSON.stringify(body), "application/json; charset=utf-8");
+}
+export class WebhookBodyTooLargeError extends Error {
+}
+export async function readRequestBody(request, maxBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > maxBytes) {
+            request.resume();
+            throw new WebhookBodyTooLargeError();
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+export function sendResponse(response, status, body = "", contentType = "text/plain; charset=utf-8") {
+    response.statusCode = status;
+    response.setHeader("content-type", contentType);
+    response.end(body);
+}
+function listen(server, host, port) {
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+}
+function close(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+    });
+}

package/dist/wechat-login.d.ts

@@ -0,0 +1,21 @@
+import { type WechatQrLoginOptions, type WechatQrLoginResult } from "./wechat.js";
+export interface CodeShellWechatLoginOptions {
+    configPath?: string;
+    credentialsDir?: string;
+    signal?: AbortSignal;
+    onQrCode?: WechatQrLoginOptions["onQrCode"];
+    onStatus?: WechatQrLoginOptions["onStatus"];
+    requestVerificationCode?: WechatQrLoginOptions["requestVerificationCode"];
+    /** Test/integration seam; normal callers use Tencent's QR login implementation. */
+    login?: (options: WechatQrLoginOptions) => Promise<WechatQrLoginResult>;
+}
+export interface CodeShellWechatLoginResult {
+    accountId: string;
+    configPath: string;
+}
+/**
+ * Complete the personal-WeChat QR flow and persist both the owner-only token
+ * and the matching CodeShell gateway configuration. Shared by the CLI and the
+ * Desktop Link page so both entry points produce exactly the same files.
+ */
+export declare function loginCodeShellWechat(options?: CodeShellWechatLoginOptions): Promise<CodeShellWechatLoginResult>;