opencode-telegram-bot 1.1.0 → 1.1.2

package/README.md

@@ -131,6 +131,26 @@ You:   [tap "Bug fix"]
 Bot:   Answered: Bug fix
 ```
 
+### Permission Requests
+
+When the OpenCode agent needs permission to perform an action (e.g. edit a file, run a bash command, access an external directory), the bot forwards the request to Telegram with inline buttons:
+
+```
+Bot:   Permission: edit
+       `src/app.ts`
+       [Allow once]  [Always allow]
+       [Reject]
+
+You:   [tap "Allow once"]
+Bot:   Allowed (once): edit
+```
+
+- **Allow once** -- approve this single request
+- **Always allow** -- approve and create a permanent allow rule in OpenCode's config
+- **Reject** -- deny the request
+
+If the bot restarts while a permission request is pending, it automatically re-sends the buttons on startup. Orphan permission requests (from sessions the bot doesn't know about) are automatically rejected to unblock the session.
+
 The bot also registers these commands in Telegram's command menu (the `/` button), plus any OpenCode server commands discovered at startup.
 
 ### Verbose Mode
@@ -280,7 +300,7 @@ You:  [tap "Auth refactoring"]
 Bot:  Switched to session: Auth refactoring
 ```
 
-The `/sessions` list only shows sessions created by the Telegram bot, not sessions from other OpenCode clients (like the TUI). You cannot delete the currently active session -- use `/new` first.
+The `/sessions` list shows sessions created by the Telegram bot. At the bottom of the list, a **"Show all sessions"** button lets you discover sessions created by other OpenCode clients (like the TUI via `opencode attach`). Tapping an external session adopts it and switches to it. You cannot delete the currently active session -- use `/new` first.
 
 ## Session Persistence
 
@@ -299,6 +319,7 @@ The bot is designed to survive restarts and failures:
 
 - **Drop pending updates** -- On startup, stale Telegram updates are discarded so old button clicks and messages from a previous run are not replayed.
 - **Pending question recovery** -- If the bot restarts while the agent is waiting for a question answer, the question is re-sent to Telegram on startup so the session can be unblocked.
+- **Pending permission recovery** -- If the bot restarts while the agent is waiting for a permission approval, the permission request is re-sent to Telegram. Orphan requests (from unknown sessions) are automatically rejected.
 - **Global error handler** -- Unhandled errors in Telegram update handlers are logged instead of crashing the process.
 - **Handler timeout** -- Telegraf's handler timeout is set to 10 minutes (up from 90 seconds) to accommodate long-running LLM responses.
 

package/dist/app.d.ts

@@ -26,6 +26,10 @@ interface OpencodeClientLike {
         reply: (params: any, options?: any) => Promise<any>;
         reject: (params: any, options?: any) => Promise<any>;
     };
+    permission: {
+        list: (params?: any, options?: any) => Promise<any>;
+        reply: (params: any, options?: any) => Promise<any>;
+    };
     app: {
         agents: (params?: any, options?: any) => Promise<any>;
     };

package/dist/index.js

@@ -20054,6 +20054,8 @@ async function startTelegram(options) {
     const chatModelSearchResults = new Map();
     // Map of questionId -> pending question context (for forwarding OpenCode questions to Telegram)
     const pendingQuestions = new Map();
+    // Map of requestId -> pending permission context (for forwarding OpenCode permission requests to Telegram)
+    const pendingPermissions = new Map();
     /**
      * Save the chat-to-session mapping and known session IDs to disk.
      */
@@ -20686,6 +20688,42 @@ async function startTelegram(options) {
                         }
                     }
                 }
+                else if (ev.type === "permission.asked" && ev.properties) {
+                    const permSessionId = ev.properties.sessionID;
+                    if (permSessionId === sessionId) {
+                        const requestId = ev.properties.id;
+                        const permission = ev.properties.permission;
+                        const patterns = (ev.properties.patterns || []);
+                        if (requestId) {
+                            pendingPermissions.set(requestId, {
+                                chatId: chatId.toString(),
+                                sessionId,
+                                permission,
+                                patterns,
+                            });
+                            console.log(`[Telegram] Permission request ${requestId} (${permission}) for chat ${chatId}`);
+                            let msg = `Permission: *${permission}*`;
+                            if (patterns.length > 0) {
+                                msg += "\n`" + patterns.join("`, `") + "`";
+                            }
+                            const keyboard = [
+                                [
+                                    { text: "Allow once", callback_data: `perm_once:${requestId}` },
+                                    { text: "Always allow", callback_data: `perm_always:${requestId}` },
+                                ],
+                                [
+                                    { text: "Reject", callback_data: `perm_reject:${requestId}` },
+                                ],
+                            ];
+                            await bot.telegram.sendMessage(chatId, msg, {
+                                parse_mode: "Markdown",
+                                reply_markup: {
+                                    inline_keyboard: keyboard,
+                                },
+                            });
+                        }
+                    }
+                }
             }
         }
         finally {
@@ -20923,7 +20961,13 @@ async function startTelegram(options) {
         try {
             const sessions = await getKnownSessions();
             if (sessions.length === 0) {
-                await ctx.reply("No sessions found.");
+                await ctx.reply("No sessions found.\n\nYou can discover sessions created outside this bot:", {
+                    reply_markup: {
+                        inline_keyboard: [
+                            [{ text: "Show all sessions", callback_data: "sessions:all" }],
+                        ],
+                    },
+                });
                 return;
             }
             const activeSession = sessions.find((session) => session.id === activeSessionId);
@@ -20932,25 +20976,33 @@ async function startTelegram(options) {
                 msgLines.push(`Current session: ${activeSession.title}`);
             }
             const otherSessions = sessions.filter((session) => session.id !== activeSessionId);
-            if (otherSessions.length === 0) {
+            const keyboard = [];
+            if (otherSessions.length > 0) {
+                msgLines.push("Tap a session to switch or delete.");
+                otherSessions.forEach((session) => {
+                    keyboard.push([
+                        {
+                            text: session.title,
+                            callback_data: `switch:${session.id}`,
+                        },
+                        {
+                            text: "Delete",
+                            callback_data: `delete:${session.id}`,
+                        },
+                    ]);
+                });
+            }
+            else {
                 msgLines.push("This is your only session.");
-                await ctx.reply(msgLines.join("\n"));
-                return;
             }
-            msgLines.push("Tap a session to switch or delete.");
-            const keyboard = [];
-            otherSessions.forEach((session) => {
-                keyboard.push([
-                    {
-                        text: session.title,
-                        callback_data: `switch:${session.id}`,
-                    },
-                    {
-                        text: "Delete",
-                        callback_data: `delete:${session.id}`,
-                    },
-                ]);
-            });
+            // Always show "Show all sessions" button to discover sessions
+            // created outside the Telegram bot (e.g. via opencode TUI)
+            keyboard.push([
+                {
+                    text: "Show all sessions",
+                    callback_data: "sessions:all",
+                },
+            ]);
             await ctx.reply(msgLines.join("\n"), {
                 reply_markup: {
                     inline_keyboard: keyboard,
@@ -21110,6 +21162,83 @@ async function startTelegram(options) {
             await answerAndEdit(ctx, "Failed to delete session.");
         }
     });
+    // Handle "Show all sessions" button - list sessions not tracked by the bot
+    bot.action("sessions:all", async (ctx) => {
+        const chatId = getChatIdFromContext(ctx);
+        if (!chatId)
+            return;
+        try {
+            // Delete the button message
+            try {
+                await ctx.deleteMessage();
+            }
+            catch {
+                // Ignore if already deleted
+            }
+            await ctx.answerCbQuery();
+            const list = await client.session.list({});
+            const allSessions = (list.data || [])
+                .filter((s) => !knownSessionIds.has(s.id) && !s.parentID)
+                .sort((a, b) => b.time.updated - a.time.updated);
+            if (allSessions.length === 0) {
+                await ctx.reply("No other sessions found.");
+                return;
+            }
+            const keyboard = [];
+            allSessions.forEach((session) => {
+                keyboard.push([
+                    {
+                        text: session.title,
+                        callback_data: `adopt:${session.id}`,
+                    },
+                ]);
+            });
+            await ctx.reply("Sessions created outside this bot.\nTap to adopt and switch:", {
+                reply_markup: {
+                    inline_keyboard: keyboard,
+                },
+            });
+        }
+        catch (err) {
+            console.error("[Telegram] Error listing all sessions:", err);
+            await ctx.reply("Failed to list sessions.");
+        }
+    });
+    // Handle adopt button - adopt an external session and switch to it
+    bot.action(/^adopt:(.+)$/, async (ctx) => {
+        const chatId = getChatIdFromContext(ctx);
+        const sessionId = ctx.match?.[1];
+        if (!chatId || !sessionId)
+            return;
+        try {
+            // Verify the session still exists on the server
+            const list = await client.session.list({});
+            const allSessions = (list.data || []);
+            const match = allSessions.find((s) => s.id === sessionId);
+            if (!match) {
+                await answerAndEdit(ctx, "Session not found. It may have been deleted.");
+                return;
+            }
+            // Delete the button message
+            try {
+                await ctx.deleteMessage();
+            }
+            catch {
+                // Ignore if already deleted
+            }
+            await ctx.answerCbQuery();
+            // Adopt: add to known sessions and switch to it
+            knownSessionIds.add(match.id);
+            chatSessions.set(chatId, match.id);
+            saveSessions();
+            console.log(`[Telegram] Adopted and switched chat ${chatId} to session ${match.id}`);
+            await ctx.reply(`Adopted and switched to session: ${match.title}`);
+        }
+        catch (err) {
+            console.error("[Telegram] Error adopting session:", err);
+            await answerAndEdit(ctx, "Failed to adopt session.");
+        }
+    });
     // Handle /verbose command - toggle verbose mode for this chat
     // Usage: /verbose, /verbose on, /verbose off
     bot.command("verbose", (ctx) => {
@@ -21454,6 +21583,36 @@ async function startTelegram(options) {
             await answerAndEdit(ctx, "Failed to dismiss question.");
         }
     });
+    // Handle permission reply callbacks (from OpenCode permission.asked events)
+    bot.action(/^perm_(once|always|reject):(.+)$/, async (ctx) => {
+        const action = ctx.match?.[1];
+        const requestId = ctx.match?.[2];
+        if (!action || !requestId)
+            return;
+        console.log(`[Telegram] Permission ${action} callback for ${requestId}`);
+        const pending = pendingPermissions.get(requestId);
+        if (!pending) {
+            await answerAndEdit(ctx, "This permission request has expired or was already answered.");
+            return;
+        }
+        try {
+            await client.permission.reply({
+                requestID: requestId,
+                reply: action,
+            });
+            pendingPermissions.delete(requestId);
+            const labels = {
+                once: "Allowed (once)",
+                always: "Always allowed",
+                reject: "Rejected",
+            };
+            await answerAndEdit(ctx, `${labels[action]}: ${pending.permission}`);
+        }
+        catch (err) {
+            console.error("[Telegram] Error replying to permission:", err);
+            await answerAndEdit(ctx, "Failed to respond to permission request.");
+        }
+    });
     // Handle /usage command - show token and cost usage for current session
     bot.command("usage", async (ctx) => {
         const chatId = ctx.chat.id.toString();
@@ -21885,6 +22044,65 @@ async function startTelegram(options) {
     catch (err) {
         console.warn("[Telegram] Failed to check for pending questions:", err);
     }
+    // Check for pending permission requests left over from previous bot runs.
+    try {
+        const pendingPermResult = await client.permission.list({});
+        if (pendingPermResult.data && pendingPermResult.data.length > 0) {
+            console.log(`[Telegram] Found ${pendingPermResult.data.length} pending permission(s) from previous run`);
+            for (const pp of pendingPermResult.data) {
+                const requestId = pp.id;
+                const permSessionId = pp.sessionID;
+                const permission = pp.permission;
+                const patterns = (pp.patterns || []);
+                const chatId = sessionToChatId(permSessionId);
+                if (!chatId || !requestId) {
+                    // No matching chat — reject the stale permission to unblock the session
+                    console.log(`[Telegram] Rejecting orphan pending permission ${requestId} (no matching chat)`);
+                    try {
+                        await client.permission.reply({ requestID: requestId, reply: "reject" });
+                    }
+                    catch (err) {
+                        console.warn(`[Telegram] Failed to reject orphan permission ${requestId}:`, err);
+                    }
+                    continue;
+                }
+                pendingPermissions.set(requestId, {
+                    chatId,
+                    sessionId: permSessionId,
+                    permission,
+                    patterns,
+                });
+                const numericChatId = Number(chatId);
+                let msg = `Permission: *${permission}*`;
+                if (patterns.length > 0) {
+                    msg += "\n`" + patterns.join("`, `") + "`";
+                }
+                msg += "\n_(resumed from previous session)_";
+                const keyboard = [
+                    [
+                        { text: "Allow once", callback_data: `perm_once:${requestId}` },
+                        { text: "Always allow", callback_data: `perm_always:${requestId}` },
+                    ],
+                    [
+                        { text: "Reject", callback_data: `perm_reject:${requestId}` },
+                    ],
+                ];
+                try {
+                    await bot.telegram.sendMessage(numericChatId, msg, {
+                        parse_mode: "Markdown",
+                        reply_markup: { inline_keyboard: keyboard },
+                    });
+                }
+                catch (err) {
+                    console.warn(`[Telegram] Failed to re-send permission to chat ${chatId}:`, err);
+                }
+                console.log(`[Telegram] Re-forwarded pending permission ${requestId} to chat ${chatId}`);
+            }
+        }
+    }
+    catch (err) {
+        console.warn("[Telegram] Failed to check for pending permissions:", err);
+    }
     if (options.launch !== false) {
         try {
             // Start the bot — launch() returns a promise that resolves only

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-telegram-bot",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "description": "Telegram bot that forwards messages to an OpenCode agent",
   "main": "./dist/index.js",