@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/channel-telegram/dist/coalescing-message-writer.js

@@ -0,0 +1,56 @@
+/** Serializes Telegram edits and collapses queued snapshots to the latest text. */
+export class CoalescingMessageWriter {
+    write;
+    onError;
+    pending;
+    draining;
+    closed = false;
+    constructor(write, onError) {
+        this.write = write;
+        this.onError = onError;
+    }
+    enqueue(text) {
+        if (this.closed)
+            return;
+        this.pending = text;
+        if (this.draining)
+            return;
+        let resolveDrain;
+        this.draining = new Promise((resolve) => {
+            resolveDrain = resolve;
+        });
+        queueMicrotask(() => void this.drain(resolveDrain));
+    }
+    async flush() {
+        while (this.draining || this.pending !== undefined) {
+            if (!this.draining)
+                this.enqueue(this.pending);
+            await this.draining;
+        }
+    }
+    close() {
+        this.closed = true;
+        this.pending = undefined;
+    }
+    async drain(resolveDrain) {
+        try {
+            while (this.pending !== undefined) {
+                const text = this.pending;
+                this.pending = undefined;
+                try {
+                    await this.write(text);
+                }
+                catch (error) {
+                    this.onError?.(error);
+                }
+            }
+        }
+        finally {
+            this.draining = undefined;
+            resolveDrain();
+            if (this.pending !== undefined)
+                this.enqueue(this.pending);
+        }
+    }
+}
+//# sourceMappingURL=coalescing-message-writer.js.map

package/node_modules/@codebridge/channel-telegram/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./telegram-api.js";
+export * from "./telegram-bridge.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@codebridge/channel-telegram/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./telegram-api.js";
+export * from "./telegram-bridge.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/channel-telegram/dist/telegram-api.d.ts

@@ -0,0 +1,62 @@
+export interface TelegramUser {
+    id: number;
+    is_bot?: boolean;
+    username?: string;
+    first_name?: string;
+}
+export interface TelegramMessageEntity {
+    type: string;
+    offset: number;
+    length: number;
+    user?: TelegramUser;
+}
+export interface TelegramChat {
+    id: number;
+    type: "private" | "group" | "supergroup" | "channel";
+}
+export interface TelegramMessage {
+    message_id: number;
+    message_thread_id?: number;
+    from?: TelegramUser;
+    chat: TelegramChat;
+    text?: string;
+    caption?: string;
+    entities?: TelegramMessageEntity[];
+    caption_entities?: TelegramMessageEntity[];
+}
+export interface TelegramUpdate {
+    update_id: number;
+    message?: TelegramMessage;
+}
+interface TelegramApiOptions {
+    token: string;
+    fetch?: typeof globalThis.fetch;
+    baseUrl?: string;
+}
+export interface TelegramBotCommand {
+    command: string;
+    description: string;
+}
+export declare function rawTelegramChatId(chatId: string): string;
+export declare function chunkTelegramText(text: string, maxLength?: number): string[];
+export declare class TelegramApi {
+    private readonly options;
+    private readonly fetchImpl;
+    private readonly baseUrl;
+    constructor(options: TelegramApiOptions);
+    getMe(): Promise<TelegramUser>;
+    getUpdates(offset: number, timeout: number, signal?: AbortSignal): Promise<TelegramUpdate[]>;
+    setMyCommands(commands: TelegramBotCommand[]): Promise<true>;
+    sendMessage(chatId: string, text: string, topicId?: string, entities?: TelegramMessageEntity[]): Promise<{
+        message_id: number;
+    }>;
+    editMessage(chatId: string, messageId: number, text: string): Promise<{
+        message_id: number;
+    }>;
+    sendDocument(chatId: string, fileName: string, content: Uint8Array, topicId?: string): Promise<{
+        message_id: number;
+    }>;
+    private request;
+}
+export {};
+//# sourceMappingURL=telegram-api.d.ts.map

package/node_modules/@codebridge/channel-telegram/dist/telegram-api.js

@@ -0,0 +1,72 @@
+export function rawTelegramChatId(chatId) {
+    if (!chatId.startsWith("telegram:")) {
+        throw new Error(`不是 Telegram chat id：${chatId}`);
+    }
+    return chatId.slice("telegram:".length);
+}
+export function chunkTelegramText(text, maxLength = 4096) {
+    if (!text)
+        return [];
+    const chunks = [];
+    for (let offset = 0; offset < text.length; offset += maxLength) {
+        chunks.push(text.slice(offset, offset + maxLength));
+    }
+    return chunks;
+}
+export class TelegramApi {
+    options;
+    fetchImpl;
+    baseUrl;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+        this.baseUrl = options.baseUrl ?? "https://api.telegram.org";
+    }
+    getMe() {
+        return this.request("getMe", {});
+    }
+    getUpdates(offset, timeout, signal) {
+        return this.request("getUpdates", { offset, timeout }, signal);
+    }
+    setMyCommands(commands) {
+        return this.request("setMyCommands", { commands });
+    }
+    sendMessage(chatId, text, topicId, entities) {
+        return this.request("sendMessage", {
+            chat_id: rawTelegramChatId(chatId),
+            text,
+            ...(topicId ? { message_thread_id: Number(topicId) } : {}),
+            ...(entities?.length ? { entities } : {}),
+        });
+    }
+    editMessage(chatId, messageId, text) {
+        return this.request("editMessageText", {
+            chat_id: rawTelegramChatId(chatId),
+            message_id: messageId,
+            text,
+        });
+    }
+    async sendDocument(chatId, fileName, content, topicId) {
+        const form = new FormData();
+        form.set("chat_id", rawTelegramChatId(chatId));
+        if (topicId)
+            form.set("message_thread_id", topicId);
+        form.set("document", new Blob([content]), fileName);
+        return this.request("sendDocument", form);
+    }
+    async request(method, body, signal) {
+        const isForm = body instanceof FormData;
+        const response = await this.fetchImpl(`${this.baseUrl}/bot${this.options.token}/${method}`, {
+            method: "POST",
+            headers: isForm ? undefined : { "Content-Type": "application/json" },
+            body: isForm ? body : JSON.stringify(body),
+            signal,
+        });
+        const payload = (await response.json().catch(() => null));
+        if (!response.ok || !payload?.ok || payload.result === undefined) {
+            throw new Error(payload?.description ?? `Telegram API ${method} failed: ${response.status}`);
+        }
+        return payload.result;
+    }
+}
+//# sourceMappingURL=telegram-api.js.map

package/node_modules/@codebridge/channel-telegram/dist/telegram-bridge.d.ts

@@ -0,0 +1,64 @@
+import { type AppConfig, type ChannelSessionIngress } from "@codebridge/core";
+import { type TelegramBotCommand, type TelegramMessageEntity, type TelegramUpdate } from "./telegram-api.js";
+export declare const TELEGRAM_BOT_COMMANDS: TelegramBotCommand[];
+interface TelegramTransport {
+    getMe(): Promise<{
+        username?: string;
+        first_name?: string;
+    }>;
+    setMyCommands?(commands: TelegramBotCommand[]): Promise<true>;
+    getUpdates(offset: number, timeout: number, signal?: AbortSignal): Promise<TelegramUpdate[]>;
+    sendMessage(chatId: string, text: string, topicId?: string, entities?: TelegramMessageEntity[]): Promise<{
+        message_id: number;
+    }>;
+    editMessage(chatId: string, messageId: number, text: string): Promise<{
+        message_id: number;
+    }>;
+    sendDocument(chatId: string, fileName: string, content: Uint8Array, topicId?: string): Promise<{
+        message_id: number;
+    }>;
+}
+export interface TelegramBridgeOptions {
+    config: AppConfig;
+    dataDir: string;
+    onLog?: (message: string) => void;
+    api?: TelegramTransport;
+    sessionIngress?: ChannelSessionIngress;
+}
+export declare class TelegramBridge {
+    private readonly options;
+    private config;
+    private readonly orchestrator;
+    private readonly api;
+    private readonly offsetPath;
+    private pollAbort?;
+    private pollTask?;
+    private readonly activeReplies;
+    private readonly mentionRegistry;
+    private readonly sessionWatchers;
+    private readonly instanceId;
+    private offset;
+    private sessionIngress?;
+    constructor(options: TelegramBridgeOptions);
+    updateConfig(config: AppConfig): void;
+    setSessionIngress(ingress: ChannelSessionIngress): void;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    handleUpdate(update: TelegramUpdate): Promise<void>;
+    sendOutboundMarkdown(chatId: string, markdown: string, topicId?: string): Promise<void>;
+    sendOutboundFile(chatId: string, rawPath: string, topicId?: string): Promise<string>;
+    sendOutboundMention(chatId: string, ref: string, text: string, topicId?: string): Promise<void>;
+    private poll;
+    /** Start a fresh provider session (same effect as /new) when the bound one is idle or its context is too full. */
+    private rotateStaleSession;
+    private buildFullSlot;
+    private ensureSessionWatcher;
+    private recoverDeliveries;
+    private submitAndStream;
+    private runLegacyAgent;
+    private sendText;
+    private readOffset;
+    private writeOffset;
+}
+export {};
+//# sourceMappingURL=telegram-bridge.d.ts.map