telecodex 0.1.0

package/dist/telegram/attachments.js

@@ -0,0 +1,67 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { getAppHome } from "../runtime/appPaths.js";
+export async function telegramImageMessageToCodexInput(input) {
+    const source = selectImageSource(input.message);
+    if (!source)
+        return null;
+    const file = await input.bot.api.getFile(source.fileId);
+    if (!file.file_path) {
+        throw new Error("Telegram did not return a downloadable file_path.");
+    }
+    const url = `https://api.telegram.org/file/bot${input.config.telegramBotToken}/${file.file_path}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download the Telegram image: HTTP ${response.status}`);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const directory = path.join(getAppHome(), "attachments");
+    await mkdir(directory, { recursive: true });
+    const localPath = path.join(directory, `${input.chatId}-${input.messageThreadId ?? "root"}-${Date.now()}-${randomUUID()}${extensionFor(source, file.file_path)}`);
+    await writeFile(localPath, bytes);
+    const caption = input.message.caption?.trim();
+    return [
+        {
+            type: "text",
+            text: caption || "Continue based on this image.",
+        },
+        {
+            type: "local_image",
+            path: localPath,
+        },
+    ];
+}
+function selectImageSource(message) {
+    if (message.photo?.length) {
+        const sorted = [...message.photo].sort((left, right) => imageScore(right) - imageScore(left));
+        const photo = sorted[0];
+        return photo ? { fileId: photo.file_id } : null;
+    }
+    const document = message.document;
+    if (!document?.file_id)
+        return null;
+    if (!document.mime_type?.startsWith("image/"))
+        return null;
+    return {
+        fileId: document.file_id,
+        ...(document.file_name ? { fileName: document.file_name } : {}),
+        ...(document.mime_type ? { mimeType: document.mime_type } : {}),
+    };
+}
+function imageScore(photo) {
+    return photo.file_size ?? (photo.width ?? 0) * (photo.height ?? 0);
+}
+function extensionFor(source, filePath) {
+    const fromName = source.fileName ? path.extname(source.fileName) : "";
+    if (fromName)
+        return fromName;
+    const fromPath = path.extname(filePath);
+    if (fromPath)
+        return fromPath;
+    if (source.mimeType === "image/png")
+        return ".png";
+    if (source.mimeType === "image/webp")
+        return ".webp";
+    return ".jpg";
+}

package/dist/telegram/delivery.js

@@ -0,0 +1,140 @@
+import { GrammyError } from "grammy";
+import { renderPlainChunksForTelegram } from "./renderer.js";
+import { splitTelegramHtml } from "./splitMessage.js";
+export async function sendHtmlMessage(bot, input, logger) {
+    return retryTelegramCall(() => bot.api.sendMessage(input.chatId, input.text, {
+        ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
+        parse_mode: "HTML",
+        link_preview_options: { is_disabled: true },
+    }), logger, "telegram send rate limited", {
+        chatId: input.chatId,
+        messageThreadId: input.messageThreadId,
+    });
+}
+export async function sendHtmlChunks(bot, input, logger) {
+    const messages = [];
+    for (const chunk of splitTelegramHtml(input.text)) {
+        messages.push(await sendHtmlMessage(bot, { ...input, text: chunk }, logger));
+    }
+    return messages;
+}
+export async function sendPlainChunks(bot, input, logger) {
+    const messages = [];
+    for (const chunk of renderPlainChunksForTelegram(input.text)) {
+        messages.push(await sendHtmlMessage(bot, { ...input, text: chunk }, logger));
+    }
+    return messages;
+}
+export async function sendTypingAction(bot, input, logger) {
+    await retryTelegramCall(() => bot.api.sendChatAction(input.chatId, "typing", {
+        ...(input.messageThreadId == null ? {} : { message_thread_id: input.messageThreadId }),
+    }), logger, "telegram chat action rate limited", {
+        chatId: input.chatId,
+        messageThreadId: input.messageThreadId,
+    });
+}
+export async function replaceOrSendHtmlChunks(bot, input, logger) {
+    const [first, ...rest] = input.chunks;
+    let firstMessageId = input.messageId;
+    if (first) {
+        let firstDelivered = false;
+        if (input.messageId != null) {
+            try {
+                await editHtmlMessage(bot, {
+                    chatId: input.chatId,
+                    messageId: input.messageId,
+                    text: first,
+                }, logger);
+                firstDelivered = true;
+            }
+            catch (error) {
+                if (isMessageNotModifiedError(error)) {
+                    firstDelivered = true;
+                }
+                else {
+                    logger?.warn("telegram final edit failed, falling back to send", {
+                        chatId: input.chatId,
+                        messageThreadId: input.messageThreadId,
+                        messageId: input.messageId,
+                        error,
+                    });
+                }
+            }
+        }
+        if (!firstDelivered) {
+            const message = await sendHtmlMessage(bot, {
+                chatId: input.chatId,
+                messageThreadId: input.messageThreadId,
+                text: first,
+            }, logger);
+            firstMessageId = message.message_id;
+        }
+    }
+    for (const chunk of rest) {
+        await sendHtmlMessage(bot, {
+            chatId: input.chatId,
+            messageThreadId: input.messageThreadId,
+            text: chunk,
+        }, logger);
+    }
+    return firstMessageId ?? null;
+}
+export async function editHtmlMessage(bot, input, logger) {
+    await retryTelegramCall(() => bot.api.editMessageText(input.chatId, input.messageId, input.text, {
+        parse_mode: "HTML",
+        link_preview_options: { is_disabled: true },
+    }), logger, "telegram edit rate limited", {
+        chatId: input.chatId,
+        messageId: input.messageId,
+    });
+}
+export function isMessageNotModifiedError(error) {
+    return error instanceof GrammyError && descriptionOf(error)?.toLowerCase().includes("message is not modified") === true;
+}
+export function shouldFallbackToNewMessage(error) {
+    if (!(error instanceof GrammyError))
+        return false;
+    const description = descriptionOf(error)?.toLowerCase();
+    if (!description)
+        return false;
+    return description.includes("message to edit not found") || description.includes("message can't be edited");
+}
+function retryAfterMs(error) {
+    if (error instanceof GrammyError) {
+        const retryAfter = error.parameters?.retry_after;
+        if (typeof retryAfter === "number" && Number.isFinite(retryAfter) && retryAfter > 0) {
+            return retryAfter * 1000;
+        }
+        const match = descriptionOf(error)?.match(/retry after\s+(\d+)/i);
+        if (match) {
+            return Number(match[1]) * 1000;
+        }
+    }
+    return null;
+}
+function descriptionOf(error) {
+    return typeof error.description === "string" ? error.description : null;
+}
+export async function retryTelegramCall(operation, logger, message, context) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const waitMs = retryAfterMs(error);
+            if (waitMs == null || attempt >= 5) {
+                throw error;
+            }
+            logger?.warn(message, {
+                ...context,
+                attempt: attempt + 1,
+                retryAfterMs: waitMs,
+                error,
+            });
+            await sleep(waitMs + 250);
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/telegram/messageBuffer.js

@@ -0,0 +1,272 @@
+import { editHtmlMessage, isMessageNotModifiedError, replaceOrSendHtmlChunks, sendHtmlMessage, sendTypingAction, shouldFallbackToNewMessage, } from "./delivery.js";
+import { renderMarkdownForTelegram, renderPlainChunksForTelegram, renderPlainForTelegram } from "./renderer.js";
+const ACTIVITY_PULSE_INTERVAL_MS = 4_000;
+export class MessageBuffer {
+    bot;
+    updateIntervalMs;
+    logger;
+    states = new Map();
+    constructor(bot, updateIntervalMs, logger) {
+        this.bot = bot;
+        this.updateIntervalMs = updateIntervalMs;
+        this.logger = logger;
+    }
+    async create(key, input) {
+        const previous = this.states.get(key);
+        if (previous) {
+            if (previous.timer)
+                clearTimeout(previous.timer);
+            this.stopActivityPulse(previous);
+            this.states.delete(key);
+        }
+        const message = await sendHtmlMessage(this.bot, {
+            chatId: input.chatId,
+            messageThreadId: input.messageThreadId,
+            text: "Codex is working...",
+        }, this.logger);
+        const state = {
+            chatId: input.chatId,
+            messageThreadId: input.messageThreadId,
+            messageId: message.message_id,
+            text: "",
+            progressLines: [],
+            planText: "",
+            reasoningSummaryText: "",
+            toolOutputText: "",
+            timer: null,
+            activityTimer: null,
+            activityInFlight: false,
+            lastSentText: "",
+            queue: Promise.resolve(),
+        };
+        this.states.set(key, state);
+        this.startActivityPulse(state);
+        return message.message_id;
+    }
+    has(key) {
+        return this.states.has(key);
+    }
+    setReplyDraft(key, text) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        state.text = text;
+        this.scheduleFlush(key, state);
+    }
+    note(key, line) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        const normalized = line.trim();
+        if (!normalized)
+            return;
+        const existingIndex = state.progressLines.findIndex((entry) => entry === normalized);
+        if (existingIndex >= 0) {
+            state.progressLines.splice(existingIndex, 1);
+        }
+        state.progressLines.push(normalized);
+        if (state.progressLines.length > 8) {
+            state.progressLines.splice(0, state.progressLines.length - 8);
+        }
+        this.scheduleFlush(key, state);
+    }
+    setPlan(key, text) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        state.planText = text.trim();
+        this.scheduleFlush(key, state);
+    }
+    setReasoningSummary(key, text) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        state.reasoningSummaryText = text.trim();
+        this.scheduleFlush(key, state);
+    }
+    setToolOutput(key, text) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        state.toolOutputText = truncateTail(text.replace(/\r/g, "").trim(), 2000);
+        this.scheduleFlush(key, state);
+    }
+    rename(from, to) {
+        const state = this.states.get(from);
+        if (!state)
+            return;
+        this.states.delete(from);
+        this.states.set(to, state);
+    }
+    async complete(key, finalMarkdown) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        if (state.timer)
+            clearTimeout(state.timer);
+        this.stopActivityPulse(state);
+        await this.enqueue(state, async () => {
+            const text = (finalMarkdown ?? state.text).trim();
+            const chunks = text
+                ? renderMarkdownForTelegram(text)
+                : renderPlainChunksForTelegram("Codex finished, but returned no text to send.");
+            await this.replaceWithChunks(state, chunks);
+            this.states.delete(key);
+        });
+    }
+    async fail(key, message) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        if (state.timer)
+            clearTimeout(state.timer);
+        this.stopActivityPulse(state);
+        await this.enqueue(state, async () => {
+            await this.replaceWithChunks(state, renderPlainChunksForTelegram(`Codex error: ${message}`));
+            this.states.delete(key);
+        });
+    }
+    async flush(key) {
+        const state = this.states.get(key);
+        if (!state)
+            return;
+        await this.enqueue(state, async () => {
+            const latest = this.states.get(key);
+            if (!latest)
+                return;
+            const text = renderPlainForTelegram(truncateForEdit(composePendingText(latest)));
+            if (text === latest.lastSentText)
+                return;
+            await this.safeEdit(latest, text);
+        });
+    }
+    scheduleFlush(key, state) {
+        if (state.timer)
+            return;
+        state.timer = setTimeout(() => {
+            state.timer = null;
+            void this.flush(key);
+        }, this.updateIntervalMs);
+    }
+    async safeEdit(state, text) {
+        try {
+            await editHtmlMessage(this.bot, {
+                chatId: state.chatId,
+                messageId: state.messageId,
+                text,
+            }, this.logger);
+            state.lastSentText = text;
+        }
+        catch (error) {
+            if (isMessageNotModifiedError(error)) {
+                state.lastSentText = text;
+                return;
+            }
+            if (shouldFallbackToNewMessage(error)) {
+                const message = await sendHtmlMessage(this.bot, {
+                    chatId: state.chatId,
+                    messageThreadId: state.messageThreadId,
+                    text,
+                }, this.logger);
+                state.messageId = message.message_id;
+                state.lastSentText = text;
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger?.warn("telegram edit failed", {
+                message,
+                chatId: state.chatId,
+                messageThreadId: state.messageThreadId,
+                messageId: state.messageId,
+            });
+            process.stderr.write(`[telegram edit failed] ${message}\n`);
+        }
+    }
+    startActivityPulse(state) {
+        void this.sendActivityPulse(state);
+        const timer = setInterval(() => {
+            void this.sendActivityPulse(state);
+        }, ACTIVITY_PULSE_INTERVAL_MS);
+        timer.unref?.();
+        state.activityTimer = timer;
+    }
+    stopActivityPulse(state) {
+        if (!state.activityTimer)
+            return;
+        clearInterval(state.activityTimer);
+        state.activityTimer = null;
+    }
+    async sendActivityPulse(state) {
+        if (state.activityInFlight)
+            return;
+        state.activityInFlight = true;
+        try {
+            await sendTypingAction(this.bot, {
+                chatId: state.chatId,
+                messageThreadId: state.messageThreadId,
+            }, this.logger);
+        }
+        catch (error) {
+            this.logger?.warn("telegram chat action failed", {
+                chatId: state.chatId,
+                messageThreadId: state.messageThreadId,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            state.activityInFlight = false;
+        }
+    }
+    async replaceWithChunks(state, chunks) {
+        const messageId = await replaceOrSendHtmlChunks(this.bot, {
+            chatId: state.chatId,
+            messageThreadId: state.messageThreadId,
+            messageId: state.messageId,
+            chunks,
+        }, this.logger);
+        if (messageId != null) {
+            state.messageId = messageId;
+        }
+        const [first] = chunks;
+        if (first) {
+            state.lastSentText = first;
+        }
+    }
+    async enqueue(state, work) {
+        const run = state.queue.then(work, work);
+        state.queue = run.catch(() => undefined);
+        await run;
+    }
+}
+function truncateForEdit(text) {
+    if (text.length <= 3800)
+        return text || "Codex is working...";
+    return `${text.slice(0, 3800)}\n\n...`;
+}
+function composePendingText(state) {
+    const sections = ["Codex is working..."];
+    if (state.planText) {
+        sections.push(`[Plan]\n${state.planText}`);
+    }
+    const reasoningSummary = state.reasoningSummaryText.trim();
+    if (reasoningSummary) {
+        sections.push(`[Reasoning Summary]\n${reasoningSummary}`);
+    }
+    if (state.progressLines.length > 0) {
+        sections.push(`[Progress]\n${state.progressLines.join("\n")}`);
+    }
+    const toolOutput = state.toolOutputText.trim();
+    if (toolOutput) {
+        sections.push(`[Tool Output]\n${toolOutput}`);
+    }
+    const replyDraft = state.text.trim();
+    if (replyDraft) {
+        sections.push(`[Draft Reply]\n${replyDraft}`);
+    }
+    return sections.join("\n\n");
+}
+function truncateTail(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(text.length - maxLength);
+}

package/dist/telegram/renderer.js

@@ -0,0 +1,146 @@
+import MarkdownIt from "markdown-it";
+import { splitTelegramHtml, splitTelegramText } from "./splitMessage.js";
+const md = new MarkdownIt({
+    html: false,
+    linkify: true,
+    breaks: true,
+});
+export function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+export function renderMarkdownForTelegram(markdown) {
+    const tokens = md.parse(markdown, {});
+    const html = renderTokens(tokens).replace(/\n{3,}/g, "\n\n").trim();
+    return splitTelegramHtml(html || escapeHtml(markdown || ""));
+}
+export function renderPlainForTelegram(text) {
+    return escapeHtml(text.trim() || " ");
+}
+export function renderPlainChunksForTelegram(text) {
+    return splitTelegramText(renderPlainForTelegram(text));
+}
+function renderTokens(tokens) {
+    let out = "";
+    const orderedStack = [];
+    for (const token of tokens) {
+        switch (token.type) {
+            case "heading_open":
+                out += "<b>";
+                break;
+            case "heading_close":
+                out += "</b>\n\n";
+                break;
+            case "paragraph_open":
+                break;
+            case "paragraph_close":
+                out += "\n\n";
+                break;
+            case "inline":
+                out += renderInline(token.children ?? []);
+                break;
+            case "bullet_list_open":
+                break;
+            case "bullet_list_close":
+                out += "\n";
+                break;
+            case "ordered_list_open":
+                orderedStack.push({ index: Number(token.attrGet("start") ?? "1") });
+                break;
+            case "ordered_list_close":
+                orderedStack.pop();
+                out += "\n";
+                break;
+            case "list_item_open": {
+                const current = orderedStack.at(-1);
+                if (current) {
+                    out += `${current.index}. `;
+                    current.index += 1;
+                }
+                else {
+                    out += "- ";
+                }
+                break;
+            }
+            case "list_item_close":
+                out += "\n";
+                break;
+            case "blockquote_open":
+                out += "<blockquote>";
+                break;
+            case "blockquote_close":
+                out += "</blockquote>\n\n";
+                break;
+            case "fence":
+            case "code_block":
+                out += `<pre><code>${escapeHtml(token.content)}</code></pre>\n\n`;
+                break;
+            case "hr":
+                out += "\n---\n\n";
+                break;
+            case "softbreak":
+            case "hardbreak":
+                out += "\n";
+                break;
+            case "text":
+                out += escapeHtml(token.content);
+                break;
+            default:
+                break;
+        }
+    }
+    return out;
+}
+function renderInline(tokens) {
+    let out = "";
+    for (const token of tokens) {
+        switch (token.type) {
+            case "text":
+                out += escapeHtml(token.content);
+                break;
+            case "code_inline":
+                out += `<code>${escapeHtml(token.content)}</code>`;
+                break;
+            case "strong_open":
+                out += "<b>";
+                break;
+            case "strong_close":
+                out += "</b>";
+                break;
+            case "em_open":
+                out += "<i>";
+                break;
+            case "em_close":
+                out += "</i>";
+                break;
+            case "s_open":
+                out += "<s>";
+                break;
+            case "s_close":
+                out += "</s>";
+                break;
+            case "link_open": {
+                const href = token.attrGet("href");
+                out += href ? `<a href="${escapeHtml(href)}">` : "";
+                break;
+            }
+            case "link_close":
+                out += "</a>";
+                break;
+            case "softbreak":
+            case "hardbreak":
+                out += "\n";
+                break;
+            case "html_inline":
+                out += escapeHtml(token.content);
+                break;
+            default:
+                if (token.children)
+                    out += renderInline(token.children);
+                break;
+        }
+    }
+    return out;
+}