opencode-telegram-bot 1.1.1 → 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
@@ -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 {
@@ -21545,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();
@@ -21976,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.1",
+  "version": "1.1.2",
   "type": "module",
   "description": "Telegram bot that forwards messages to an OpenCode agent",
   "main": "./dist/index.js",