opencode-telegram-bot 1.0.5 → 1.0.7

package/README.md

@@ -99,21 +99,20 @@ These are handled directly by the Telegram bot:
 |---|---|
 | `/start` | Welcome message |
 | `/new` | Start a new conversation |
-| `/sessions` | List all sessions with their IDs |
-| `/switch <id>` | Switch to a different session (prefix match supported) |
+| `/sessions` | List sessions with inline buttons |
 | `/title <text>` | Rename the current session |
-| `/delete <id>` | Delete a session from the server |
 | `/export` | Export the current session as a markdown file |
 | `/export full` | Export with all details (thinking, costs, steps) |
 | `/verbose` | Toggle verbose mode (show thinking and tool calls in chat) |
 | `/verbose on\|off` | Explicitly enable/disable verbose mode |
 | `/model` | Show current model and usage hints |
 | `/model <keyword>` | Search models by keyword |
-| `/model <number>` | Switch to a model from the last search |
 | `/model default` | Reset to the default model |
 | `/usage` | Show token and cost usage for this session |
 | `/help` | Show available commands |
 
+The bot also registers these commands in Telegram's command menu (the `/` button), plus any OpenCode server commands discovered at startup (excluding hidden ones like `/init` and `/review`).
+
 ### Verbose Mode
 
 By default, the bot only shows the assistant's final text response. Use `/verbose` to toggle verbose mode (or `/verbose on|off` to set it explicitly), which also displays:
@@ -141,13 +140,11 @@ Use `/model` to search and switch models without typing long names:
 ```
 You:  /model sonnet
 Bot:  Models matching "sonnet":
-      1. claude-sonnet-4-5 (google-vertex-anthropic)
-      2. claude-sonnet-4 (anthropic)
-
-      Use /model <number> to select.
+      Tap a model to select.
 
-You:  /model 1
+You:  [tap "claude-sonnet-4-5 (google-vertex-anthropic)"]
 Bot:  Switched to claude-sonnet-4-5 (google-vertex-anthropic)
+
 ```
 
 Other commands:
@@ -219,21 +216,17 @@ Bot:  [agent response about tests - new session auto-titled "Fix the broken test
 
 You:  /sessions
 Bot:  Your sessions:
-       [active] Fix the broken tests - 2 min ago (abc12345)
-       Auth refactoring - 1 hour ago (def67890)
-      Use /switch <id> to switch sessions.
-
-You:  /switch def6
-Bot:  Switched to session: Auth refactoring (def67890)
+      Current session: Fix the broken tests
+      Tap a session to switch or delete.
 
 You:  What were we working on?
 Bot:  [agent responds with context from the auth refactoring session]
 
-You:  /delete abc1
-Bot:  Deleted session: Fix the broken tests (abc12345)
+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` or `/switch` first.
+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.
 
 ## Session Persistence
 

package/dist/app.d.ts

@@ -36,6 +36,7 @@ interface TelegramBot {
     help: (fn: (ctx: any) => void | Promise<void>) => void;
     command: (command: string, fn: (ctx: any) => void | Promise<void>) => void;
     on: (event: string, fn: (ctx: any) => void | Promise<void>) => void;
+    action: (trigger: string | RegExp, fn: (ctx: any) => void | Promise<void>) => void;
     launch: () => Promise<void>;
     stop: (reason?: string) => void;
     telegram: {
@@ -48,6 +49,10 @@ interface TelegramBot {
         getFileLink: (fileId: string) => Promise<{
             toString(): string;
         }>;
+        setMyCommands: (commands: Array<{
+            command: string;
+            description: string;
+        }>) => Promise<unknown>;
     };
 }
 export declare function startTelegram(options: StartOptions): Promise<TelegramBot>;

package/dist/index.js

@@ -18589,6 +18589,9 @@ async function startTelegram(options) {
     const client = options.client || client_createOpencodeClient({ baseUrl: url });
     // Verify connection to the OpenCode server and fetch available commands
     const opencodeCommands = new Set();
+    const opencodeCommandMenu = [];
+    const hiddenOpenCodeCommands = new Set(["init", "review", "reviews"]);
+    const isHiddenOpenCodeCommand = (name) => hiddenOpenCodeCommands.has(name.toLowerCase());
     let projectDirectory = "";
     try {
         const sessions = await client.session.list();
@@ -18606,7 +18609,16 @@ async function startTelegram(options) {
         const cmds = await client.command.list();
         if (cmds.data) {
             for (const cmd of cmds.data) {
-                opencodeCommands.add(cmd.name);
+                const name = cmd.name;
+                if (!name)
+                    continue;
+                opencodeCommands.add(name);
+                if (!isHiddenOpenCodeCommand(name)) {
+                    opencodeCommandMenu.push({
+                        command: name,
+                        description: cmd.description || "OpenCode command",
+                    });
+                }
             }
             console.log(`[Telegram] Available OpenCode commands: ${[...opencodeCommands].join(", ")}`);
         }
@@ -18618,6 +18630,17 @@ async function startTelegram(options) {
     const telegramCommands = new Set([
         "start", "help", "new", "sessions", "switch", "title", "delete", "export", "verbose", "model", "usage",
     ]);
+    const telegramCommandMenu = [
+        { command: "new", description: "Start a new conversation" },
+        { command: "sessions", description: "List your sessions" },
+        { command: "title", description: "Rename a session (/title <text>)" },
+        { command: "export", description: "Export session (/export full for details)" },
+        { command: "verbose", description: "Toggle verbose mode" },
+        { command: "model", description: "Search models (/model <keyword>)" },
+        { command: "usage", description: "Show token and cost usage" },
+        { command: "help", description: "Show available commands" },
+    ];
+    const getVisibleOpenCodeCommands = () => [...opencodeCommands].filter((command) => !isHiddenOpenCodeCommand(command));
     // Map of chatId -> sessionId for the active session per chat
     const chatSessions = new Map();
     // Set of all session IDs ever created/used by this bot (for filtering)
@@ -18801,6 +18824,25 @@ async function startTelegram(options) {
         }
         return promptBody;
     }
+    function getChatIdFromContext(ctx) {
+        const direct = ctx.chat?.id;
+        if (direct)
+            return direct.toString();
+        const fromCallback = ctx.callbackQuery?.message?.chat?.id;
+        if (fromCallback)
+            return fromCallback.toString();
+        return null;
+    }
+    async function answerAndEdit(ctx, text) {
+        if (typeof ctx.answerCbQuery === "function") {
+            await ctx.answerCbQuery();
+        }
+        if (typeof ctx.editMessageText === "function") {
+            await ctx.editMessageText(text);
+            return;
+        }
+        await ctx.reply(text);
+    }
     async function getTelegramFileUrl(fileId) {
         const link = await bot.telegram.getFileLink(fileId);
         return link.toString();
@@ -19100,6 +19142,25 @@ async function startTelegram(options) {
     const bot = options.botFactory
         ? options.botFactory(token)
         : new lib.Telegraf(token);
+    async function registerCommandMenu() {
+        const combined = [...telegramCommandMenu, ...opencodeCommandMenu];
+        const seen = new Set();
+        const commands = [];
+        for (const entry of combined) {
+            if (!entry.command || seen.has(entry.command))
+                continue;
+            seen.add(entry.command);
+            commands.push(entry);
+        }
+        if (commands.length === 0)
+            return;
+        try {
+            await bot.telegram.setMyCommands(commands);
+        }
+        catch (err) {
+            console.warn("[Telegram] Failed to register command menu:", err);
+        }
+    }
     // Middleware to check if the user is authorized
     bot.use((ctx, next) => {
         if (!authorizedUserId) {
@@ -19115,26 +19176,26 @@ async function startTelegram(options) {
             return;
         }
     });
+    await registerCommandMenu();
     // Handle /start command
     bot.start((ctx) => {
         let msg = "Hello! I'm your OpenCode bot. Send me a message and I'll forward it to the OpenCode agent.\n\n" +
             "Bot commands:\n" +
             "/new - Start a new conversation\n" +
-            "/sessions - List your sessions\n" +
-            "/switch <number> - Switch to a different session\n" +
+            "/sessions - List your sessions (buttons)\n" +
             "/title <text> - Rename the current session\n" +
-            "/delete <number> - Delete a session\n" +
             "/export - Export the current session as a markdown file\n" +
             "/export full - Export with all details (thinking, costs, steps)\n" +
             "/verbose - Toggle verbose mode (show thinking and tool calls)\n" +
             "/verbose on|off - Set verbose mode explicitly\n" +
-            "/model - Show or search available models\n" +
+            "/model <keyword> - Search available models\n" +
             "/usage - Show token and cost usage for this session\n" +
             "/help - Show this help message\n";
-        if (opencodeCommands.size > 0) {
+        const visibleOpenCodeCommands = getVisibleOpenCodeCommands();
+        if (visibleOpenCodeCommands.length > 0) {
             msg +=
                 "\nOpenCode commands are also available:\n" +
-                    [...opencodeCommands].map((c) => `/${c}`).join(", ");
+                    visibleOpenCodeCommands.map((c) => `/${c}`).join(", ");
         }
         ctx.reply(msg);
     });
@@ -19143,21 +19204,20 @@ async function startTelegram(options) {
         let msg = "Send me any message and I'll process it using OpenCode.\n\n" +
             "Bot commands:\n" +
             "/new - Start a new conversation\n" +
-            "/sessions - List your sessions\n" +
-            "/switch <number> - Switch to a different session\n" +
+            "/sessions - List your sessions (buttons)\n" +
             "/title <text> - Rename the current session\n" +
-            "/delete <number> - Delete a session\n" +
             "/export - Export the current session as a markdown file\n" +
             "/export full - Export with all details (thinking, costs, steps)\n" +
             "/verbose - Toggle verbose mode (show thinking and tool calls)\n" +
             "/verbose on|off - Set verbose mode explicitly\n" +
-            "/model - Show or search available models\n" +
+            "/model <keyword> - Search available models\n" +
             "/usage - Show token and cost usage for this session\n" +
             "/help - Show this help message\n";
-        if (opencodeCommands.size > 0) {
+        const visibleOpenCodeCommands = getVisibleOpenCodeCommands();
+        if (visibleOpenCodeCommands.length > 0) {
             msg +=
                 "\nOpenCode commands:\n" +
-                    [...opencodeCommands].map((c) => `/${c}`).join(", ");
+                    visibleOpenCodeCommands.map((c) => `/${c}`).join(", ");
         }
         ctx.reply(msg);
     });
@@ -19182,16 +19242,9 @@ async function startTelegram(options) {
             .sort((a, b) => b.time.updated - a.time.updated);
     }
     /**
-     * Resolve a user argument to a session. Accepts either a numeric index
-     * (1-based, as shown by /sessions) or a session ID / prefix.
+     * Resolve a user argument to a session ID / prefix.
      */
     function resolveSession(sessions, arg) {
-        // Try numeric index first
-        const num = parseInt(arg, 10);
-        if (!isNaN(num) && String(num) === arg && num >= 1 && num <= sessions.length) {
-            return sessions[num - 1];
-        }
-        // Fall back to ID / prefix match
         return sessions.find((s) => s.id === arg || s.id.startsWith(arg));
     }
     // Handle /sessions command - list Telegram bot sessions only
@@ -19204,28 +19257,48 @@ async function startTelegram(options) {
                 await ctx.reply("No sessions found.");
                 return;
             }
-            let msg = "Your sessions:\n\n";
-            sessions.forEach((session, i) => {
-                const isActive = session.id === activeSessionId;
-                const age = formatAge(session.time.updated);
-                const marker = isActive ? " [active]" : "";
-                msg += `${i + 1}. ${session.title} - ${age}${marker}\n`;
+            const activeSession = sessions.find((session) => session.id === activeSessionId);
+            const msgLines = ["Your sessions:"];
+            if (activeSession) {
+                msgLines.push(`Current session: ${activeSession.title}`);
+            }
+            const otherSessions = sessions.filter((session) => session.id !== activeSessionId);
+            if (otherSessions.length === 0) {
+                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}`,
+                    },
+                ]);
+            });
+            await ctx.reply(msgLines.join("\n"), {
+                reply_markup: {
+                    inline_keyboard: keyboard,
+                },
             });
-            msg += `\nUse /switch <number> to switch sessions.`;
-            msg += `\nUse /delete <number> to delete a session.`;
-            await ctx.reply(msg);
         }
         catch (err) {
             console.error("[Telegram] Error listing sessions:", err);
             await ctx.reply("Failed to list sessions.");
         }
     });
-    // Handle /switch <number> command - switch to a different session
+    // Handle /switch <id> command - switch to a different session
     bot.command("switch", async (ctx) => {
         const chatId = ctx.chat.id.toString();
         const args = ctx.message.text.replace(/^\/switch\s*/, "").trim();
         if (!args) {
-            await ctx.reply("Usage: /switch <number>\n\nUse /sessions to see available sessions.");
+            await ctx.reply("Usage: /switch <session id>\n\nUse /sessions to see available sessions.");
             return;
         }
         try {
@@ -19274,12 +19347,12 @@ async function startTelegram(options) {
             await ctx.reply("Failed to rename session.");
         }
     });
-    // Handle /delete <number> command - delete a session
+    // Handle /delete <id> command - delete a session
     bot.command("delete", async (ctx) => {
         const chatId = ctx.chat.id.toString();
         const args = ctx.message.text.replace(/^\/delete\s*/, "").trim();
         if (!args) {
-            await ctx.reply("Usage: /delete <number>\n\nUse /sessions to see available sessions.");
+            await ctx.reply("Usage: /delete <session id>\n\nUse /sessions to see available sessions.");
             return;
         }
         try {
@@ -19313,6 +19386,61 @@ async function startTelegram(options) {
             await ctx.reply("Failed to delete session.");
         }
     });
+    bot.action(/^switch:(.+)$/, async (ctx) => {
+        const chatId = getChatIdFromContext(ctx);
+        const sessionId = ctx.match?.[1];
+        if (!chatId || !sessionId)
+            return;
+        try {
+            const sessions = await getKnownSessions();
+            const match = sessions.find((session) => session.id === sessionId);
+            if (!match) {
+                await answerAndEdit(ctx, "Session not found. Use /sessions to refresh.");
+                return;
+            }
+            chatSessions.set(chatId, match.id);
+            saveSessions();
+            console.log(`[Telegram] Switched chat ${chatId} to session ${match.id}`);
+            await answerAndEdit(ctx, `Switched to session: ${match.title}`);
+        }
+        catch (err) {
+            console.error("[Telegram] Error switching session:", err);
+            await answerAndEdit(ctx, "Failed to switch session.");
+        }
+    });
+    bot.action(/^delete:(.+)$/, async (ctx) => {
+        const chatId = getChatIdFromContext(ctx);
+        const sessionId = ctx.match?.[1];
+        if (!chatId || !sessionId)
+            return;
+        try {
+            const sessions = await getKnownSessions();
+            const match = sessions.find((session) => session.id === sessionId);
+            if (!match) {
+                await answerAndEdit(ctx, "Session not found. Use /sessions to refresh.");
+                return;
+            }
+            const activeSessionId = chatSessions.get(chatId);
+            if (match.id === activeSessionId) {
+                await answerAndEdit(ctx, "Cannot delete the active session. Use /new or /switch first, then delete it.");
+                return;
+            }
+            const result = await client.session.delete({
+                path: { id: match.id },
+            });
+            if (result.error) {
+                throw new Error(JSON.stringify(result.error));
+            }
+            knownSessionIds.delete(match.id);
+            saveSessions();
+            console.log(`[Telegram] Deleted session ${match.id}`);
+            await answerAndEdit(ctx, `Deleted session: ${match.title}`);
+        }
+        catch (err) {
+            console.error("[Telegram] Error deleting session:", err);
+            await answerAndEdit(ctx, "Failed to delete session.");
+        }
+    });
     // Handle /verbose command - toggle verbose mode for this chat
     // Usage: /verbose, /verbose on, /verbose off
     bot.command("verbose", (ctx) => {
@@ -19368,7 +19496,7 @@ async function startTelegram(options) {
         return results;
     }
     // Handle /model command
-    // Usage: /model, /model <keyword>, /model <number>, /model default
+    // Usage: /model, /model <keyword>, /model default
     bot.command("model", async (ctx) => {
         const chatId = ctx.chat.id.toString();
         const args = ctx.message.text.replace(/^\/model\s*/, "").trim();
@@ -19385,24 +19513,6 @@ async function startTelegram(options) {
             await ctx.reply("Model reset to the default model.");
             return;
         }
-        const asNumber = Number.parseInt(args, 10);
-        if (!Number.isNaN(asNumber) && String(asNumber) === args) {
-            const results = chatModelSearchResults.get(chatId) || [];
-            if (results.length === 0) {
-                await ctx.reply("No recent search results. Use /model <keyword> first.");
-                return;
-            }
-            if (asNumber < 1 || asNumber > results.length) {
-                await ctx.reply("Invalid selection. Use /model <number> from the latest search results.");
-                return;
-            }
-            const selection = results[asNumber - 1];
-            const value = `${selection.providerID}/${selection.modelID}`;
-            chatModelOverride.set(chatId, value);
-            saveSessions();
-            await ctx.reply(`Switched to ${selection.displayName}`);
-            return;
-        }
         try {
             const results = await searchModels(args);
             if (results.length === 0) {
@@ -19411,21 +19521,60 @@ async function startTelegram(options) {
             }
             const limited = results.slice(0, 10);
             chatModelSearchResults.set(chatId, limited);
-            let msg = `Models matching "${args}":\n\n`;
-            for (const [index, item] of limited.entries()) {
-                msg += `${index + 1}. ${item.displayName}\n`;
-            }
+            let msg = `Models matching "${args}":`;
             if (results.length > limited.length) {
                 msg += `\nFound ${results.length} models. Refine your search to narrow the list.`;
             }
-            msg += "\nUse /model <number> to select.";
-            await ctx.reply(msg);
+            msg += "\nTap a model to select.";
+            const keyboard = limited.map((item, index) => [
+                {
+                    text: item.displayName,
+                    callback_data: `model:${index + 1}`,
+                },
+            ]);
+            keyboard.push([
+                { text: "Reset to default", callback_data: "model_default" },
+            ]);
+            await ctx.reply(msg, {
+                reply_markup: {
+                    inline_keyboard: keyboard,
+                },
+            });
         }
         catch (err) {
             console.error("[Telegram] Error searching models:", err);
             await ctx.reply("Failed to list models. Try again later.");
         }
     });
+    bot.action(/^model:(\d+)$/, async (ctx) => {
+        const chatId = getChatIdFromContext(ctx);
+        const indexText = ctx.match?.[1];
+        if (!chatId || !indexText)
+            return;
+        const selectionIndex = Number.parseInt(indexText, 10);
+        const results = chatModelSearchResults.get(chatId) || [];
+        if (results.length === 0) {
+            await answerAndEdit(ctx, "No recent search results. Use /model <keyword> first.");
+            return;
+        }
+        if (selectionIndex < 1 || selectionIndex > results.length) {
+            await answerAndEdit(ctx, "Invalid selection. Use the latest model search results.");
+            return;
+        }
+        const selection = results[selectionIndex - 1];
+        const value = `${selection.providerID}/${selection.modelID}`;
+        chatModelOverride.set(chatId, value);
+        saveSessions();
+        await answerAndEdit(ctx, `Switched to ${selection.displayName}`);
+    });
+    bot.action("model_default", async (ctx) => {
+        const chatId = getChatIdFromContext(ctx);
+        if (!chatId)
+            return;
+        chatModelOverride.delete(chatId);
+        saveSessions();
+        await answerAndEdit(ctx, "Model reset to the default model.");
+    });
     // Handle /usage command - show token and cost usage for current session
     bot.command("usage", async (ctx) => {
         const chatId = ctx.chat.id.toString();
@@ -19738,7 +19887,9 @@ async function startTelegram(options) {
             }
             // Check if it's a known OpenCode command
             if (!opencodeCommands.has(commandName)) {
-                const available = [...opencodeCommands].map((c) => `/${c}`).join(", ");
+                const available = getVisibleOpenCodeCommands()
+                    .map((c) => `/${c}`)
+                    .join(", ");
                 await ctx.reply(`Unknown command: /${commandName}\n\n` +
                     `Available OpenCode commands: ${available || "none"}\n` +
                     `Bot commands: /new, /help`);
@@ -19804,22 +19955,6 @@ async function startTelegram(options) {
     }
     return bot;
 }
-/**
- * Format a Unix timestamp (seconds) into a human-readable relative time.
- */
-function formatAge(timestamp) {
-    const now = Date.now() / 1000;
-    const diff = now - timestamp;
-    if (diff < 60)
-        return "just now";
-    if (diff < 3600)
-        return `${Math.floor(diff / 60)} min ago`;
-    if (diff < 86400)
-        return `${Math.floor(diff / 3600)} hours ago`;
-    if (diff < 604800)
-        return `${Math.floor(diff / 86400)} days ago`;
-    return `${Math.floor(diff / 604800)} weeks ago`;
-}
 /**
  * Truncate text to a maximum length, appending "..." if truncated.
  */

package/package.json

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