@lapage/codex-telegram-bridge 0.1.0 → 0.1.1

package/dist/telegram-bridge.js

@@ -1,6 +1,11 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+import { tmpdir } from 'node:os';
 import { Bot } from 'grammy';
 import { CodexSession } from './codex-session.js';
-import { chunkText, formatTelegramMarkdown, isCodexWorking, latestCodexResponse, latestCompletedCodexResponse, plainTelegramText } from './text.js';
+import { formatTelegramMarkdownChunks, safePlainTelegramChunks, safePlainTelegramText } from './text.js';
+const attachmentTmpDir = join(tmpdir(), 'codex-telegram-bridge');
 export class TelegramCodexBridge {
     config;
     bot;
@@ -8,24 +13,23 @@ export class TelegramCodexBridge {
     activeChatId = null;
     outputBuffer = '';
     lastOutputAt = null;
-    flushTimer = null;
-    pollTimer = null;
-    lastPaneResponse = '';
-    lastSentResponse = '';
-    lastSnapshotSentAt = 0;
-    streamMessageId = null;
-    lastStreamText = '';
-    lastStreamEditAt = 0;
+    turnActive = false;
+    renderItems = new Map();
+    renderOrder = 0;
+    renderMessageIds = [];
     typingTimer = null;
     sendQueue = Promise.resolve();
     constructor(config) {
         this.config = config;
         this.bot = new Bot(config.token);
         this.codex = new CodexSession(config);
+        this.codex.on('itemCompleted', (item) => void this.handleCodexItemCompleted(item));
+        this.codex.on('turnCompleted', () => void this.handleCodexTurnCompleted());
+        this.codex.on('error', (message) => console.error('Codex app-server:', message));
+        this.codex.on('exit', (code, signal) => console.error('Codex app-server exited:', code ?? signal ?? 'unknown'));
     }
     async start() {
         await this.codex.start();
-        this.startPollingOutput();
         this.bot.on('message', async (context) => this.handleMessage(context));
         this.bot.catch((error) => {
             console.error('Telegram bot error:', error.message);
@@ -33,13 +37,8 @@ export class TelegramCodexBridge {
         this.bot.start();
     }
     async stop() {
-        this.stopPollingOutput();
         this.stopTypingIndicator();
         await this.codex.stop();
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
         await this.bot.stop();
     }
     async handleMessage(context) {
@@ -53,24 +52,123 @@ export class TelegramCodexBridge {
             return;
         }
         this.activeChatId = chatId;
-        const text = context.message?.text ?? '';
-        if (!text.trim()) {
-            await context.reply('Send text to forward it to Codex.');
+        const text = context.message?.text ?? context.message?.caption ?? '';
+        const attachmentSources = this.extractAttachmentSources(context);
+        if (!text.trim() && attachmentSources.length === 0) {
+            await context.reply('Send text or an attachment to forward it to Codex.');
             return;
         }
-        if (await this.handleCommand(context, text.trim())) {
+        if (context.message?.text && await this.handleCommand(context, text.trim())) {
             return;
         }
         if (!this.codex.isRunning) {
             await this.codex.start();
         }
-        await this.codex.waitUntilReady(Boolean(this.lastOutputAt));
-        await this.codex.sendText(text);
+        this.resetTurnRenderState();
+        this.turnActive = true;
         const streamMessage = await context.reply('Codex is working…');
-        this.streamMessageId = streamMessage.message_id;
-        this.lastStreamText = 'Codex is working…';
-        this.lastStreamEditAt = Date.now();
+        this.renderMessageIds = [streamMessage.message_id];
         this.startTypingIndicator();
+        const attachments = await this.downloadAttachments(attachmentSources);
+        await this.codex.sendText(text, attachments);
+    }
+    extractAttachmentSources(context) {
+        const message = context.message;
+        if (!message) {
+            return [];
+        }
+        const sources = [];
+        const photo = message.photo?.at(-1);
+        if (photo) {
+            sources.push({
+                fileId: photo.file_id,
+                originalName: `telegram-photo-${photo.file_unique_id}.jpg`,
+                mimeType: 'image/jpeg',
+                kind: 'image',
+            });
+        }
+        if (message.document) {
+            const mimeType = message.document.mime_type;
+            sources.push({
+                fileId: message.document.file_id,
+                originalName: message.document.file_name ?? `telegram-document-${message.document.file_unique_id}${extensionForMime(mimeType)}`,
+                mimeType,
+                kind: mimeType?.startsWith('image/') ? 'image' : 'file',
+            });
+        }
+        if (message.video) {
+            sources.push({
+                fileId: message.video.file_id,
+                originalName: message.video.file_name ?? `telegram-video-${message.video.file_unique_id}.mp4`,
+                mimeType: message.video.mime_type,
+                kind: 'file',
+            });
+        }
+        if (message.animation) {
+            sources.push({
+                fileId: message.animation.file_id,
+                originalName: message.animation.file_name ?? `telegram-animation-${message.animation.file_unique_id}.mp4`,
+                mimeType: message.animation.mime_type,
+                kind: 'file',
+            });
+        }
+        if (message.audio) {
+            sources.push({
+                fileId: message.audio.file_id,
+                originalName: message.audio.file_name ?? `telegram-audio-${message.audio.file_unique_id}${extensionForMime(message.audio.mime_type)}`,
+                mimeType: message.audio.mime_type,
+                kind: 'file',
+            });
+        }
+        if (message.voice) {
+            sources.push({
+                fileId: message.voice.file_id,
+                originalName: `telegram-voice-${message.voice.file_unique_id}.ogg`,
+                mimeType: message.voice.mime_type,
+                kind: 'file',
+            });
+        }
+        return sources;
+    }
+    async downloadAttachments(sources) {
+        if (sources.length === 0) {
+            return [];
+        }
+        await mkdir(attachmentTmpDir, { recursive: true });
+        const attachments = [];
+        for (const source of sources) {
+            try {
+                attachments.push(await this.downloadAttachment(source));
+            }
+            catch (error) {
+                console.error('Telegram attachment download failed:', telegramErrorSummary(error));
+            }
+        }
+        return attachments;
+    }
+    async downloadAttachment(source) {
+        const file = await this.bot.api.getFile(source.fileId);
+        if (!file.file_path) {
+            throw new Error(`Telegram did not return file_path for ${source.originalName}`);
+        }
+        const token = this.config.token;
+        const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Download failed with ${response.status} ${response.statusText}`);
+        }
+        const data = Buffer.from(await response.arrayBuffer());
+        const safeName = safeFileName(source.originalName);
+        const extension = extname(safeName) || extensionForMime(source.mimeType);
+        const fileName = `${randomUUID()}${extension}`;
+        const path = join(attachmentTmpDir, fileName);
+        await writeFile(path, data);
+        return {
+            path,
+            name: basename(safeName),
+            mimeType: source.mimeType,
+            kind: source.kind,
+        };
     }
     async handleCommand(context, text) {
         switch (text) {
@@ -82,41 +180,26 @@ export class TelegramCodexBridge {
                 await context.reply(this.statusText());
                 return true;
             case '/flush':
-                await this.readNewOutput(true);
-                await this.flushOutput(true);
+                await this.renderTurnCache(true);
                 return true;
             case '/interrupt':
                 await this.codex.interrupt();
-                await context.reply('Sent Ctrl-C to Codex.');
+                await context.reply('Sent interrupt to Codex.');
                 return true;
             case '/restart':
                 await this.codex.restart();
                 this.resetSnapshots();
-                this.stopTypingIndicator();
-                await context.reply('Restarted Codex.');
+                await context.reply('Restarted Codex app-server.');
                 return true;
             case '/stop':
                 await this.codex.stop();
                 this.stopTypingIndicator();
-                await context.reply('Stopped Codex. Send any message to start it again.');
+                await context.reply('Stopped Codex app-server. Send any message to start it again.');
                 return true;
             default:
                 return false;
         }
     }
-    startPollingOutput() {
-        this.stopPollingOutput();
-        this.pollTimer = setInterval(() => {
-            void this.readNewOutput();
-            void this.refreshCodexRunningState();
-        }, this.config.pollIntervalMs);
-    }
-    stopPollingOutput() {
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-    }
     startTypingIndicator() {
         if (!this.activeChatId) {
             return;
@@ -139,117 +222,106 @@ export class TelegramCodexBridge {
         }
         await this.bot.api.sendChatAction(this.activeChatId, 'typing').catch(() => undefined);
     }
-    async readNewOutput(force = false) {
-        if (!this.activeChatId || !await this.codex.exists()) {
+    async handleCodexItemCompleted(item) {
+        if (!this.turnActive) {
             return;
         }
-        const pane = await this.codex.capturePane();
-        const response = force ? latestCompletedCodexResponse(pane) : latestCodexResponse(pane);
-        const working = isCodexWorking(pane);
-        if (this.streamMessageId && response) {
-            await this.editStreamMessage(response, !working || force);
-            if (!working || force) {
-                this.stopTypingIndicator();
-            }
-        }
-        if (working && !force) {
-            return;
-        }
-        if (!response || (!force && response === this.lastPaneResponse)) {
+        const rendered = renderCompletedItem(item);
+        if (!rendered) {
             return;
         }
-        this.lastPaneResponse = response;
-        if (!force && !this.shouldSendResponse(response)) {
-            return;
-        }
-        this.lastSentResponse = response;
-        this.lastSnapshotSentAt = Date.now();
-        this.outputBuffer = response;
         this.lastOutputAt = new Date();
-        if (!this.streamMessageId) {
-            this.scheduleFlush();
-        }
+        this.renderItems.set(rendered.id, rendered);
+        this.outputBuffer = this.renderCachedText();
+        await this.renderTurnCache(false);
     }
-    async refreshCodexRunningState() {
-        const exists = await this.codex.exists();
-        if (!exists && this.codex.isRunning) {
-            this.outputBuffer = '[Codex tmux session exited]';
-            this.scheduleFlush();
-        }
-    }
-    shouldSendResponse(response) {
-        if (response === this.lastSentResponse) {
-            return false;
-        }
-        return true;
-    }
-    scheduleFlush() {
-        if (this.flushTimer) {
+    async handleCodexTurnCompleted() {
+        if (!this.turnActive) {
             return;
         }
-        this.flushTimer = setTimeout(async () => {
-            this.flushTimer = null;
-            await this.flushOutput(false);
-        }, this.config.flushIntervalMs);
+        await this.renderTurnCache(true);
+        this.turnActive = false;
+        this.outputBuffer = '';
+        this.resetTurnRenderState();
+        this.stopTypingIndicator();
     }
-    async flushOutput(force) {
+    async renderTurnCache(force) {
         if (!this.activeChatId) {
             return;
         }
-        const trimmed = this.outputBuffer.trimEnd();
-        if (!trimmed) {
+        const text = this.renderCachedText();
+        if (!text) {
             if (force) {
-                await this.queueTelegramSend(() => this.bot.api.sendMessage(this.activeChatId, 'No buffered output.'));
+                await this.queueTelegramSend(() => this.bot.api.sendMessage(this.activeChatId, 'No completed output yet.'));
             }
-            this.outputBuffer = '';
             return;
         }
-        this.outputBuffer = '';
-        for (const chunk of chunkText(trimmed, this.config.maxTelegramChars)) {
-            await this.sendFormattedMessage(chunk);
+        const markdownChunks = formatTelegramMarkdownChunks(text, this.config.maxTelegramChars);
+        const fallbackChunks = safePlainTelegramChunks(text, this.config.maxTelegramChars);
+        for (let index = 0; index < markdownChunks.length; index += 1) {
+            const markdown = markdownChunks[index];
+            const fallback = fallbackChunks[index] ?? safePlainTelegramText(markdown);
+            const messageId = this.renderMessageIds[index];
+            if (messageId) {
+                const edited = await this.editFormattedMarkdown(messageId, markdown, fallback);
+                if (!edited) {
+                    const sent = await this.sendFormattedMarkdownAndReturn(markdown, fallback);
+                    if (sent) {
+                        this.renderMessageIds[index] = sent.message_id;
+                    }
+                }
+            }
+            else {
+                const sent = await this.sendFormattedMarkdownAndReturn(markdown, fallback);
+                if (sent) {
+                    this.renderMessageIds[index] = sent.message_id;
+                }
+            }
         }
+        this.renderMessageIds = this.renderMessageIds.slice(0, markdownChunks.length);
     }
-    async editStreamMessage(text, force) {
-        if (!this.activeChatId || !this.streamMessageId) {
-            return;
-        }
-        const trimmed = text.trim();
-        if (!trimmed || trimmed === this.lastStreamText) {
-            return;
-        }
-        const now = Date.now();
-        if (!force && !this.isMeaningfulStreamChange(trimmed, now)) {
-            return;
-        }
-        const [chunk] = chunkText(trimmed, this.config.maxTelegramChars);
-        await this.editFormattedMessage(chunk);
-        this.lastStreamText = trimmed;
-        this.lastStreamEditAt = now;
+    renderCachedText() {
+        return [...this.renderItems.values()]
+            .sort((first, second) => first.order - second.order)
+            .map((item) => item.text)
+            .filter(Boolean)
+            .join('\n\n')
+            .trim();
     }
-    async sendFormattedMessage(text) {
+    async sendFormattedMarkdownAndReturn(markdown, fallback) {
         if (!this.activeChatId) {
-            return;
+            return null;
         }
-        const markdown = formatTelegramMarkdown(text);
         const chatId = this.activeChatId;
         const sent = await this.queueTelegramSend(() => this.bot.api.sendMessage(chatId, markdown, { parse_mode: 'MarkdownV2' }))
-            .then(() => true)
-            .catch(() => false);
-        if (!sent) {
-            await this.queueTelegramSend(() => this.bot.api.sendMessage(chatId, plainTelegramText(text)));
+            .catch((error) => {
+            console.error('Telegram Markdown send failed:', telegramErrorSummary(error));
+            return null;
+        });
+        if (sent) {
+            return sent;
         }
+        return this.queueTelegramSend(() => this.bot.api.sendMessage(chatId, fallback)).catch(() => null);
     }
-    async editFormattedMessage(text) {
-        if (!this.activeChatId || !this.streamMessageId) {
-            return;
+    async editFormattedMarkdown(messageId, markdown, fallback) {
+        if (!this.activeChatId) {
+            return false;
         }
-        const markdown = formatTelegramMarkdown(text);
-        const edited = await this.bot.api.editMessageText(this.activeChatId, this.streamMessageId, markdown, {
+        const edited = await this.bot.api.editMessageText(this.activeChatId, messageId, markdown, {
             parse_mode: 'MarkdownV2',
-        }).then(() => true).catch(() => false);
-        if (!edited) {
-            await this.bot.api.editMessageText(this.activeChatId, this.streamMessageId, plainTelegramText(text)).catch(() => undefined);
+        }).then(() => true).catch((error) => {
+            if (isTelegramMessageNotModified(error)) {
+                return true;
+            }
+            console.error('Telegram Markdown edit failed:', telegramErrorSummary(error));
+            return false;
+        });
+        if (edited) {
+            return true;
         }
+        return this.bot.api.editMessageText(this.activeChatId, messageId, fallback)
+            .then(() => true)
+            .catch(() => false);
     }
     queueTelegramSend(operation) {
         const run = async () => {
@@ -260,23 +332,15 @@ export class TelegramCodexBridge {
         this.sendQueue = next.then(() => undefined, () => undefined);
         return next;
     }
-    isMeaningfulStreamChange(nextText, now) {
-        if (now - this.lastStreamEditAt < this.config.streamEditIntervalMs) {
-            return false;
-        }
-        if (nextText.length < this.lastStreamText.length) {
-            return true;
-        }
-        return nextText.length - this.lastStreamText.length >= this.config.streamMinChangeChars;
-    }
     statusText() {
         return [
             `Codex: ${this.codex.isRunning ? 'running' : 'stopped'}`,
-            `tmux: ${this.config.tmuxSession}`,
+            'Transport: stdio app-server',
             `CWD: ${this.config.codexCwd}`,
-            `Command: ${[this.config.codexCommand, ...this.config.codexArgs].join(' ')}`,
-            `Submit key: ${this.config.codexSubmitKey}`,
-            `Submit delay: ${this.config.codexSubmitDelayMs}ms`,
+            `Command: ${this.config.codexCommand} app-server --stdio`,
+            `Approval policy: ${this.config.codexApprovalPolicy}`,
+            `Sandbox: ${this.config.codexSandbox}`,
+            `Completed items: ${this.renderItems.size}`,
             `Buffered chars: ${this.outputBuffer.length}`,
             `Last output: ${this.lastOutputAt?.toISOString() ?? 'none'}`,
         ].join('\n');
@@ -285,24 +349,55 @@ export class TelegramCodexBridge {
         return [
             'Telegram ↔ Codex bridge commands:',
             '/status - show bridge status',
-            '/flush - send buffered Codex output now',
-            '/interrupt - send Ctrl-C to Codex',
-            '/restart - restart Codex session',
-            '/stop - stop Codex session',
+            '/flush - send completed Codex output now',
+            '/interrupt - interrupt the active Codex turn',
+            '/restart - restart Codex app-server',
+            '/stop - stop Codex app-server',
             '',
-            'Any other text is sent directly to the Codex CLI.',
+            'Any other text is sent directly to Codex app-server.',
         ].join('\n');
     }
     resetSnapshots() {
-        this.lastPaneResponse = '';
-        this.lastSentResponse = '';
-        this.lastSnapshotSentAt = 0;
+        this.outputBuffer = '';
         this.lastOutputAt = null;
-        this.streamMessageId = null;
-        this.lastStreamText = '';
-        this.lastStreamEditAt = 0;
+        this.resetTurnRenderState();
         this.stopTypingIndicator();
     }
+    resetTurnRenderState() {
+        this.turnActive = false;
+        this.renderItems.clear();
+        this.renderOrder = 0;
+        this.renderMessageIds = [];
+    }
+}
+function renderCompletedItem(item) {
+    const id = typeof item.id === 'string' ? item.id : `${item.type ?? 'item'}-${Date.now()}`;
+    const order = completedAtMs(item) ?? Date.now();
+    switch (item.type) {
+        case 'agentMessage': {
+            const text = typeof item.text === 'string' ? item.text.trim() : '';
+            return text ? { id, order, text } : null;
+        }
+        case 'commandExecution': {
+            const command = typeof item.command === 'string' ? compactCommand(item.command) : 'command';
+            const status = typeof item.status === 'string' ? item.status : 'completed';
+            const exitCode = typeof item.exitCode === 'number' ? `, exit ${item.exitCode}` : '';
+            const duration = typeof item.durationMs === 'number' ? `, ${Math.round(item.durationMs / 100) / 10}s` : '';
+            return {
+                id,
+                order,
+                text: [`🔧 Ran \`${command}\``, `Status: ${status}${exitCode}${duration}`].join('\n'),
+            };
+        }
+        case 'mcpToolCall': {
+            const server = typeof item.server === 'string' ? item.server : 'mcp';
+            const tool = typeof item.tool === 'string' ? item.tool : 'tool';
+            const status = typeof item.status === 'string' ? item.status : 'completed';
+            return { id, order, text: `🔌 Tool \`${server}/${tool}\`\nStatus: ${status}` };
+        }
+        default:
+            return null;
+    }
 }
 async function retryTelegramOperation(operation) {
     try {
@@ -329,6 +424,51 @@ function telegramRetryAfterMs(error) {
     }
     return null;
 }
+function telegramErrorSummary(error) {
+    const description = error.description;
+    if (description) {
+        return description;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function isTelegramMessageNotModified(error) {
+    return /message is not modified/i.test(telegramErrorSummary(error));
+}
+function compactCommand(command) {
+    return command.replace(/\s+/g, ' ').slice(0, 160);
+}
+function safeFileName(name) {
+    return basename(name).replace(/[^a-zA-Z0-9._-]/g, '-').replace(/-+/g, '-');
+}
+function extensionForMime(mimeType) {
+    switch (mimeType) {
+        case 'image/jpeg':
+            return '.jpg';
+        case 'image/png':
+            return '.png';
+        case 'image/webp':
+            return '.webp';
+        case 'image/gif':
+            return '.gif';
+        case 'application/pdf':
+            return '.pdf';
+        case 'video/mp4':
+            return '.mp4';
+        case 'audio/mpeg':
+            return '.mp3';
+        case 'audio/ogg':
+            return '.ogg';
+        default:
+            return '';
+    }
+}
+function completedAtMs(item) {
+    const value = item.completedAtMs;
+    return typeof value === 'number' ? value : null;
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }