opencode-gateway 0.2.2 → 0.2.4

package/dist/telegram/client.js

@@ -1,179 +0,0 @@
-import { formatError } from "../utils/error";
-export class TelegramApiError extends Error {
-    retryable;
-    constructor(message, retryable) {
-        super(message);
-        this.retryable = retryable;
-        this.name = "TelegramApiError";
-    }
-}
-export class TelegramBotClient {
-    botToken;
-    constructor(botToken) {
-        this.botToken = botToken;
-    }
-    async getUpdates(offset, timeoutSeconds) {
-        return this.call("getUpdates", {
-            offset,
-            timeout: timeoutSeconds,
-            allowed_updates: ["message", "callback_query"],
-        });
-    }
-    async getMe() {
-        return this.call("getMe", {});
-    }
-    async getChat(chatId) {
-        return this.call("getChat", {
-            chat_id: chatId,
-        });
-    }
-    async getFile(fileId) {
-        return this.call("getFile", {
-            file_id: fileId,
-        });
-    }
-    async downloadFile(remotePath, localPath) {
-        let response;
-        try {
-            response = await fetch(`https://api.telegram.org/file/bot${this.botToken}/${remotePath}`);
-        }
-        catch (error) {
-            throw new TelegramApiError(`Telegram file download failed: ${formatError(error)}`, true);
-        }
-        if (!response.ok) {
-            throw new TelegramApiError(`Telegram file download failed (${response.status}): ${response.statusText}`, isRetryableError(response.status, response.status));
-        }
-        await Bun.write(localPath, await response.bytes());
-    }
-    async sendMessage(chatId, text, messageThreadId) {
-        await this.call("sendMessage", {
-            chat_id: chatId,
-            text,
-            message_thread_id: parseMessageThreadId(messageThreadId),
-        });
-    }
-    async sendInteractiveMessage(chatId, text, messageThreadId, replyMarkup) {
-        return await this.call("sendMessage", {
-            chat_id: chatId,
-            text,
-            message_thread_id: parseMessageThreadId(messageThreadId),
-            reply_markup: replyMarkup,
-        });
-    }
-    async sendPhoto(chatId, filePath, caption, messageThreadId, mimeType) {
-        const form = new FormData();
-        form.set("chat_id", chatId);
-        setOptionalFormField(form, "caption", caption);
-        setOptionalFormField(form, "message_thread_id", formatMessageThreadId(messageThreadId));
-        form.set("photo", Bun.file(filePath, { type: mimeType }));
-        await this.callMultipart("sendPhoto", form);
-    }
-    async sendDocument(chatId, filePath, caption, messageThreadId, mimeType) {
-        const form = new FormData();
-        form.set("chat_id", chatId);
-        setOptionalFormField(form, "caption", caption);
-        setOptionalFormField(form, "message_thread_id", formatMessageThreadId(messageThreadId));
-        form.set("document", Bun.file(filePath, { type: mimeType }));
-        await this.callMultipart("sendDocument", form);
-    }
-    async sendChatAction(chatId, action, messageThreadId) {
-        await this.call("sendChatAction", {
-            chat_id: chatId,
-            action,
-            message_thread_id: parseMessageThreadId(messageThreadId),
-        });
-    }
-    async sendMessageDraft(chatId, draftId, text, messageThreadId) {
-        if (!Number.isSafeInteger(draftId) || draftId === 0) {
-            throw new Error(`invalid Telegram draft id: ${draftId}`);
-        }
-        await this.call("sendMessageDraft", {
-            chat_id: chatId,
-            draft_id: draftId,
-            text,
-            message_thread_id: parseMessageThreadId(messageThreadId),
-        });
-    }
-    async answerCallbackQuery(callbackQueryId, text) {
-        await this.call("answerCallbackQuery", {
-            callback_query_id: callbackQueryId,
-            text,
-        });
-    }
-    async call(method, body) {
-        let response;
-        try {
-            response = await fetch(`https://api.telegram.org/bot${this.botToken}/${method}`, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify(stripUndefined(body)),
-            });
-        }
-        catch (error) {
-            throw new TelegramApiError(`Telegram ${method} request failed: ${formatError(error)}`, true);
-        }
-        const payload = (await response.json());
-        if (payload.ok) {
-            return payload.result;
-        }
-        const description = payload.description ?? `HTTP ${response.status}`;
-        const errorCode = payload.error_code ?? response.status;
-        throw new TelegramApiError(`Telegram ${method} failed (${errorCode}): ${description}`, isRetryableError(errorCode, response.status));
-    }
-    async callMultipart(method, body) {
-        let response;
-        try {
-            response = await fetch(`https://api.telegram.org/bot${this.botToken}/${method}`, {
-                method: "POST",
-                body,
-            });
-        }
-        catch (error) {
-            throw new TelegramApiError(`Telegram ${method} request failed: ${formatError(error)}`, true);
-        }
-        const payload = (await response.json());
-        if (payload.ok) {
-            return payload.result;
-        }
-        const description = payload.description ?? `HTTP ${response.status}`;
-        const errorCode = payload.error_code ?? response.status;
-        throw new TelegramApiError(`Telegram ${method} failed (${errorCode}): ${description}`, isRetryableError(errorCode, response.status));
-    }
-}
-function parseMessageThreadId(value) {
-    if (value == null) {
-        return undefined;
-    }
-    const normalized = value.trim();
-    if (normalized.length === 0 || normalized === "undefined") {
-        return undefined;
-    }
-    const parsed = Number.parseInt(normalized, 10);
-    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-        throw new Error(`invalid Telegram topic id: ${value}`);
-    }
-    return parsed;
-}
-function formatMessageThreadId(value) {
-    const parsed = parseMessageThreadId(value);
-    return parsed === undefined ? null : String(parsed);
-}
-function stripUndefined(body) {
-    return Object.fromEntries(Object.entries(body).filter((entry) => entry[1] !== undefined));
-}
-function setOptionalFormField(form, key, value) {
-    if (value != null && value.trim().length > 0) {
-        form.set(key, value);
-    }
-}
-function isRetryableError(errorCode, httpStatus) {
-    if (errorCode === 401 || errorCode === 403 || errorCode === 404) {
-        return false;
-    }
-    if (httpStatus >= 500 || httpStatus === 429) {
-        return true;
-    }
-    return errorCode !== 400;
-}

package/dist/telegram/media.js

@@ -1,65 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import { basename, extname, join } from "node:path";
-import { inferLocalFileMimeType } from "../media/mime";
-export class TelegramInboundMediaStore {
-    client;
-    mediaRootPath;
-    constructor(client, mediaRootPath) {
-        this.client = client;
-        this.mediaRootPath = mediaRootPath;
-    }
-    async materializeInboundMessage(message, sourceKind, externalId) {
-        return {
-            deliveryTarget: message.deliveryTarget,
-            sender: message.sender,
-            text: message.text,
-            attachments: await Promise.all(message.attachments.map((attachment, index) => this.materializeAttachment(attachment, sourceKind, externalId, index))),
-            mailboxKey: message.mailboxKey,
-        };
-    }
-    async materializeAttachment(attachment, sourceKind, externalId, ordinal) {
-        switch (attachment.kind) {
-            case "image":
-                return await this.materializeImageAttachment(attachment, sourceKind, externalId, ordinal);
-        }
-    }
-    async materializeImageAttachment(attachment, sourceKind, externalId, ordinal) {
-        const file = await this.client.getFile(attachment.fileId);
-        const remotePath = file.file_path?.trim();
-        if (!remotePath) {
-            throw new Error(`Telegram file ${attachment.fileId} did not include file_path`);
-        }
-        const fileName = normalizeOptionalFileName(attachment.fileName) ??
-            normalizeOptionalFileName(basename(remotePath)) ??
-            `telegram-image-${ordinal + 1}${extensionFromRemotePath(remotePath)}`;
-        const localPath = join(this.mediaRootPath, "telegram", sanitizePathSegment(sourceKind), sanitizePathSegment(externalId), `${ordinal}-${sanitizePathSegment(fileName)}`);
-        await mkdir(join(this.mediaRootPath, "telegram", sanitizePathSegment(sourceKind), sanitizePathSegment(externalId)), {
-            recursive: true,
-        });
-        await this.client.downloadFile(remotePath, localPath);
-        return {
-            kind: "image",
-            mimeType: attachment.mimeType ?? (await inferLocalFileMimeType(localPath)),
-            fileName,
-            localPath,
-        };
-    }
-}
-function sanitizePathSegment(value) {
-    return (value
-        .trim()
-        .replace(/[^a-zA-Z0-9._-]+/g, "_")
-        .replace(/^_+|_+$/g, "")
-        .slice(0, 120) || "file");
-}
-function normalizeOptionalFileName(value) {
-    if (value === null) {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}
-function extensionFromRemotePath(remotePath) {
-    const extension = extname(remotePath);
-    return extension.length === 0 ? ".bin" : extension;
-}

package/dist/telegram/normalize.js

@@ -1,119 +0,0 @@
-export function buildTelegramAllowlist(config) {
-    return {
-        allowedChats: new Set(config.allowedChats),
-        allowedUsers: new Set(config.allowedUsers),
-    };
-}
-export function normalizeTelegramUpdate(update, allowlist, mailboxRouter) {
-    if (update.callback_query) {
-        return normalizeTelegramCallbackQuery(update.callback_query, allowlist);
-    }
-    const message = update.message;
-    if (!message) {
-        return ignored("unsupported update type");
-    }
-    if (!message.from) {
-        return ignored("message sender is missing");
-    }
-    if (message.from.is_bot === true) {
-        return ignored("message sender is a bot");
-    }
-    const chatId = String(message.chat.id);
-    const userId = String(message.from.id);
-    if (!isAllowed(chatId, userId, allowlist)) {
-        return ignored("message is not allowlisted");
-    }
-    const deliveryTarget = {
-        channel: "telegram",
-        target: chatId,
-        topic: message.message_thread_id === undefined ? null : String(message.message_thread_id),
-    };
-    const attachments = extractAttachments(message.photo, message.document);
-    const text = normalizeOptionalText(message.text ?? message.caption ?? null);
-    if (text === null && attachments.length === 0) {
-        return ignored("message has no supported content");
-    }
-    return {
-        kind: "message",
-        chatType: message.chat.type,
-        message: {
-            mailboxKey: mailboxRouter?.resolve(deliveryTarget) ?? null,
-            deliveryTarget,
-            sender: `telegram:${userId}`,
-            text,
-            attachments,
-        },
-    };
-}
-function normalizeTelegramCallbackQuery(callbackQuery, allowlist) {
-    const message = callbackQuery.message;
-    if (!message) {
-        return ignored("callback query message is missing");
-    }
-    const chatId = String(message.chat.id);
-    const userId = String(callbackQuery.from.id);
-    if (!isAllowed(chatId, userId, allowlist)) {
-        return ignored("callback query is not allowlisted");
-    }
-    return {
-        kind: "callbackQuery",
-        callbackQuery: {
-            callbackQueryId: callbackQuery.id,
-            sender: `telegram:${userId}`,
-            deliveryTarget: {
-                channel: "telegram",
-                target: chatId,
-                topic: message.message_thread_id === undefined ? null : String(message.message_thread_id),
-            },
-            messageId: message.message_id,
-            data: normalizeOptionalText(callbackQuery.data ?? null),
-        },
-    };
-}
-function extractAttachments(photo, document) {
-    const photoAttachment = selectLargestPhoto(photo);
-    if (photoAttachment !== null) {
-        return [photoAttachment];
-    }
-    if (document?.mime_type?.startsWith("image/") === true) {
-        return [
-            {
-                kind: "image",
-                fileId: document.file_id,
-                fileUniqueId: document.file_unique_id ?? null,
-                mimeType: document.mime_type,
-                fileName: normalizeOptionalText(document.file_name ?? null),
-            },
-        ];
-    }
-    return [];
-}
-function selectLargestPhoto(photo) {
-    if (!Array.isArray(photo) || photo.length === 0) {
-        return null;
-    }
-    const largest = photo[photo.length - 1];
-    return {
-        kind: "image",
-        fileId: largest.file_id,
-        fileUniqueId: largest.file_unique_id ?? null,
-        mimeType: null,
-        fileName: null,
-    };
-}
-function isAllowed(chatId, userId, allowlist) {
-    return allowlist.allowedChats.has(chatId) || allowlist.allowedUsers.has(userId);
-}
-function ignored(reason) {
-    return {
-        kind: "ignore",
-        reason,
-    };
-}
-function normalizeOptionalText(value) {
-    if (value === null) {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}

package/dist/telegram/poller.js

@@ -1,97 +0,0 @@
-import { formatError } from "../utils/error";
-import { TelegramApiError } from "./client";
-import { buildTelegramAllowlist, normalizeTelegramUpdate } from "./normalize";
-import { recordTelegramChatType, recordTelegramPollFailure, recordTelegramPollSuccess } from "./state";
-export class TelegramPollingService {
-    client;
-    mailbox;
-    store;
-    logger;
-    config;
-    mailboxRouter;
-    mediaStore;
-    questions;
-    allowlist;
-    running = false;
-    constructor(client, mailbox, store, logger, config, mailboxRouter, mediaStore, questions) {
-        this.client = client;
-        this.mailbox = mailbox;
-        this.store = store;
-        this.logger = logger;
-        this.config = config;
-        this.mailboxRouter = mailboxRouter;
-        this.mediaStore = mediaStore;
-        this.questions = questions;
-        this.allowlist = buildTelegramAllowlist(config);
-    }
-    start() {
-        if (this.running) {
-            return;
-        }
-        this.running = true;
-        void this.runLoop().finally(() => {
-            this.running = false;
-        });
-    }
-    isRunning() {
-        return this.running;
-    }
-    async runLoop() {
-        let offset = this.store.getTelegramUpdateOffset();
-        let retryDelayMs = 1_000;
-        for (;;) {
-            try {
-                const updates = await this.client.getUpdates(offset, this.config.pollTimeoutSeconds);
-                recordTelegramPollSuccess(this.store, Date.now());
-                for (const update of updates) {
-                    const nextOffset = update.update_id + 1;
-                    const normalized = normalizeTelegramUpdate(update, this.allowlist, this.mailboxRouter);
-                    if (normalized.kind === "ignore") {
-                        this.logger.log("info", `ignoring telegram update ${update.update_id}: ${normalized.reason}`);
-                        offset = this.advanceOffset(nextOffset);
-                        continue;
-                    }
-                    if (this.store.hasMailboxEntry("telegram_update", String(update.update_id))) {
-                        offset = this.advanceOffset(nextOffset);
-                        continue;
-                    }
-                    if (normalized.kind === "callbackQuery") {
-                        await this.questions.handleTelegramCallbackQuery(normalized.callbackQuery);
-                        offset = this.advanceOffset(nextOffset);
-                        continue;
-                    }
-                    recordTelegramChatType(this.store, normalized.message.deliveryTarget.target, normalized.chatType, Date.now());
-                    await this.mailbox.enqueueInboundMessage(await this.mediaStore.materializeInboundMessage(normalized.message, "telegram_update", String(update.update_id)), "telegram_update", String(update.update_id));
-                    offset = this.advanceOffset(nextOffset);
-                }
-                retryDelayMs = 1_000;
-            }
-            catch (error) {
-                recordTelegramPollFailure(this.store, formatTelegramPollerError(error), Date.now());
-                if (isPermanentTelegramFailure(error)) {
-                    this.logger.log("error", formatTelegramPollerError(error));
-                    return;
-                }
-                this.logger.log("warn", formatTelegramPollerError(error));
-                await sleep(retryDelayMs);
-                retryDelayMs = Math.min(retryDelayMs * 2, 15_000);
-            }
-        }
-    }
-    advanceOffset(offset) {
-        const recordedAtMs = Date.now();
-        this.store.putTelegramUpdateOffset(offset, recordedAtMs);
-        return offset;
-    }
-}
-function isPermanentTelegramFailure(error) {
-    return error instanceof TelegramApiError && !error.retryable;
-}
-function formatTelegramPollerError(error) {
-    return `telegram poller failure: ${formatError(error)}`;
-}
-function sleep(durationMs) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, durationMs);
-    });
-}

package/dist/telegram/runtime.js

@@ -1,133 +0,0 @@
-import { formatUnixMsAsUtc } from "../tools/time";
-import { formatError } from "../utils/error";
-import { readTelegramHealthSnapshot, recordTelegramProbeFailure, recordTelegramProbeSuccess, recordTelegramSendFailure, } from "./state";
-export class GatewayTelegramRuntime {
-    client;
-    delivery;
-    store;
-    logger;
-    config;
-    polling;
-    opencodeEvents;
-    constructor(client, delivery, store, logger, config, polling, opencodeEvents) {
-        this.client = client;
-        this.delivery = delivery;
-        this.store = store;
-        this.logger = logger;
-        this.config = config;
-        this.polling = polling;
-        this.opencodeEvents = opencodeEvents;
-    }
-    isEnabled() {
-        return this.config.enabled;
-    }
-    isPolling() {
-        return this.polling?.isRunning() ?? false;
-    }
-    allowlistMode() {
-        return this.config.enabled ? "explicit" : "disabled";
-    }
-    start() {
-        this.polling?.start();
-    }
-    async status() {
-        const snapshot = readTelegramHealthSnapshot(this.store);
-        if (!this.config.enabled || this.client === null) {
-            return {
-                ...snapshot,
-                enabled: false,
-                polling: false,
-                allowlistMode: "disabled",
-                allowedChatsCount: 0,
-                allowedUsersCount: 0,
-                liveProbe: "disabled",
-                liveProbeError: null,
-                liveBotId: null,
-                liveBotUsername: null,
-                streamingEnabled: false,
-                opencodeEventStreamConnected: this.opencodeEvents.isConnected(),
-                lastEventStreamError: this.opencodeEvents.lastStreamError(),
-            };
-        }
-        try {
-            const bot = await this.client.getMe();
-            const recordedAtMs = Date.now();
-            recordTelegramProbeSuccess(this.store, bot, recordedAtMs);
-            return buildEnabledStatus(this.config, readTelegramHealthSnapshot(this.store), this.isPolling(), "ok", null, bot, this.opencodeEvents);
-        }
-        catch (error) {
-            const message = formatError(error);
-            const recordedAtMs = Date.now();
-            recordTelegramProbeFailure(this.store, message, recordedAtMs);
-            this.logger.log("warn", `telegram live probe failed: ${message}`);
-            return buildEnabledStatus(this.config, readTelegramHealthSnapshot(this.store), this.isPolling(), "failed", message, null, this.opencodeEvents);
-        }
-    }
-    async sendTest(chatId, topic, text, mode) {
-        const normalizedChatId = normalizeRequiredField(chatId, "chat_id");
-        const normalizedTopic = normalizeOptionalField(topic);
-        const body = normalizeOptionalField(text) ?? defaultTestMessage();
-        if (!this.config.enabled || this.client === null) {
-            throw new Error("telegram is not enabled");
-        }
-        try {
-            const sentAtMs = Date.now();
-            const result = await this.delivery.sendTest({
-                channel: "telegram",
-                target: normalizedChatId,
-                topic: normalizedTopic,
-            }, body, mode);
-            if (!result.delivered) {
-                throw new Error("telegram test delivery produced no final message");
-            }
-            return {
-                chatId: normalizedChatId,
-                topic: normalizedTopic,
-                text: body,
-                sentAtMs,
-                mode: result.mode,
-            };
-        }
-        catch (error) {
-            const message = formatError(error);
-            recordTelegramSendFailure(this.store, message, Date.now());
-            this.logger.log("warn", `telegram_send_test failed: ${message}`);
-            throw error;
-        }
-    }
-}
-function buildEnabledStatus(config, snapshot, polling, liveProbe, liveProbeError, bot, opencodeEvents) {
-    return {
-        ...snapshot,
-        enabled: true,
-        polling,
-        allowlistMode: "explicit",
-        allowedChatsCount: config.allowedChats.length,
-        allowedUsersCount: config.allowedUsers.length,
-        liveProbe,
-        liveProbeError,
-        liveBotId: bot ? String(bot.id) : null,
-        liveBotUsername: bot?.username ?? null,
-        streamingEnabled: true,
-        opencodeEventStreamConnected: opencodeEvents.isConnected(),
-        lastEventStreamError: opencodeEvents.lastStreamError(),
-    };
-}
-function normalizeRequiredField(value, field) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new Error(`${field} must not be empty`);
-    }
-    return trimmed;
-}
-function normalizeOptionalField(value) {
-    if (value === null) {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length === 0 ? null : trimmed;
-}
-function defaultTestMessage() {
-    const recordedAtMs = Date.now();
-    return `opencode-gateway telegram_send_test at ${formatUnixMsAsUtc(recordedAtMs)}`;
-}