opencode-telegram-bot 1.0.0 → 1.0.2

package/README.md

@@ -103,8 +103,21 @@ These are handled directly by the Telegram bot:
 | `/switch <id>` | Switch to a different session (prefix match supported) |
 | `/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) |
 | `/help` | Show available commands |
 
+### Session Export
+
+The `/export` command builds a markdown file from the current session and saves it to the directory where OpenCode is running. The file is also sent back to you as a Telegram document.
+
+Two modes are available:
+
+- **`/export`** -- Default. Includes user messages, assistant text, and tool calls (name, input, output).
+- **`/export full`** (also accepts `detailed` or `all`) -- Includes everything from the default mode plus reasoning/thinking blocks, step boundaries with token counts, costs, subtasks, retries, and compaction markers.
+
+The exported file is named `session-<id>.md` (or `session-<id>-detailed.md` for the full export).
+
 ### OpenCode Commands
 
 Any `/` command that isn't a bot command is automatically forwarded to the OpenCode server via its command system. The bot fetches the list of available commands on startup and validates them.

package/dist/index.js

@@ -18608,7 +18608,7 @@ async function startTelegram(options) {
     }
     // Telegram-only commands that should not be forwarded to OpenCode
     const telegramCommands = new Set([
-        "start", "help", "new", "sessions", "switch", "title", "delete",
+        "start", "help", "new", "sessions", "switch", "title", "delete", "export",
     ]);
     // Map of chatId -> sessionId for the active session per chat
     const chatSessions = new Map();
@@ -18842,9 +18842,11 @@ async function startTelegram(options) {
             "Bot commands:\n" +
             "/new - Start a new conversation\n" +
             "/sessions - List your sessions\n" +
-            "/switch <id> - Switch to a different session\n" +
+            "/switch <number> - Switch to a different session\n" +
             "/title <text> - Rename the current session\n" +
-            "/delete <id> - Delete a 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" +
             "/help - Show this help message\n";
         if (opencodeCommands.size > 0) {
             msg +=
@@ -18859,9 +18861,11 @@ async function startTelegram(options) {
             "Bot commands:\n" +
             "/new - Start a new conversation\n" +
             "/sessions - List your sessions\n" +
-            "/switch <id> - Switch to a different session\n" +
+            "/switch <number> - Switch to a different session\n" +
             "/title <text> - Rename the current session\n" +
-            "/delete <id> - Delete a 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" +
             "/help - Show this help message\n";
         if (opencodeCommands.size > 0) {
             msg +=
@@ -18878,34 +18882,49 @@ async function startTelegram(options) {
         console.log(`[Telegram] Session cleared for chat ${chatId}`);
         ctx.reply("Conversation reset. Your next message will start a new session.");
     });
+    /**
+     * Get the list of known sessions, sorted by most recently updated.
+     */
+    async function getKnownSessions() {
+        const list = await client.session.list();
+        if (!list.data || list.data.length === 0)
+            return [];
+        return list.data
+            .filter((s) => knownSessionIds.has(s.id))
+            .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.
+     */
+    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
     bot.command("sessions", async (ctx) => {
         const chatId = ctx.chat.id.toString();
         const activeSessionId = chatSessions.get(chatId);
         try {
-            const list = await client.session.list();
-            if (!list.data || list.data.length === 0) {
-                await ctx.reply("No sessions found.");
-                return;
-            }
-            // Filter to only sessions created by this bot
-            const sessions = list.data
-                .filter((s) => knownSessionIds.has(s.id))
-                .sort((a, b) => b.time.updated - a.time.updated);
+            const sessions = await getKnownSessions();
             if (sessions.length === 0) {
                 await ctx.reply("No sessions found.");
                 return;
             }
             let msg = "Your sessions:\n\n";
-            for (const session of sessions) {
+            sessions.forEach((session, i) => {
                 const isActive = session.id === activeSessionId;
                 const age = formatAge(session.time.updated);
-                const shortId = session.id.substring(0, 8);
-                const marker = isActive ? "[active] " : "";
-                msg += `${marker}${session.title} - ${age} (${shortId})\n`;
-            }
-            msg += `\nUse /switch <id> to switch sessions.`;
-            msg += `\nUse /delete <id> to delete a session.`;
+                const marker = isActive ? " [active]" : "";
+                msg += `${i + 1}. ${session.title} - ${age}${marker}\n`;
+            });
+            msg += `\nUse /switch <number> to switch sessions.`;
+            msg += `\nUse /delete <number> to delete a session.`;
             await ctx.reply(msg);
         }
         catch (err) {
@@ -18913,24 +18932,17 @@ async function startTelegram(options) {
             await ctx.reply("Failed to list sessions.");
         }
     });
-    // Handle /switch <id> command - switch to a different session
+    // Handle /switch <number> 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 <session-id>\n\nUse /sessions to see available sessions.");
+            await ctx.reply("Usage: /switch <number>\n\nUse /sessions to see available sessions.");
             return;
         }
         try {
-            // Fetch all sessions and find one matching the provided prefix
-            const list = await client.session.list();
-            if (!list.data) {
-                await ctx.reply("Failed to fetch sessions from the server.");
-                return;
-            }
-            const match = list.data
-                .filter((s) => knownSessionIds.has(s.id))
-                .find((s) => s.id === args || s.id.startsWith(args));
+            const sessions = await getKnownSessions();
+            const match = resolveSession(sessions, args);
             if (!match) {
                 await ctx.reply(`No session found matching "${args}".\n\nUse /sessions to see available sessions.`);
                 return;
@@ -18938,8 +18950,7 @@ async function startTelegram(options) {
             chatSessions.set(chatId, match.id);
             saveSessions();
             console.log(`[Telegram] Switched chat ${chatId} to session ${match.id}`);
-            const shortId = match.id.substring(0, 8);
-            await ctx.reply(`Switched to session: ${match.title} (${shortId})`);
+            await ctx.reply(`Switched to session: ${match.title}`);
         }
         catch (err) {
             console.error("[Telegram] Error switching session:", err);
@@ -18975,24 +18986,17 @@ async function startTelegram(options) {
             await ctx.reply("Failed to rename session.");
         }
     });
-    // Handle /delete <id> command - delete a session
+    // Handle /delete <number> 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 <session-id>\n\nUse /sessions to see available sessions.");
+            await ctx.reply("Usage: /delete <number>\n\nUse /sessions to see available sessions.");
             return;
         }
         try {
-            // Fetch all sessions and find one matching the provided prefix
-            const list = await client.session.list();
-            if (!list.data) {
-                await ctx.reply("Failed to fetch sessions from the server.");
-                return;
-            }
-            const match = list.data
-                .filter((s) => knownSessionIds.has(s.id))
-                .find((s) => s.id === args || s.id.startsWith(args));
+            const sessions = await getKnownSessions();
+            const match = resolveSession(sessions, args);
             if (!match) {
                 await ctx.reply(`No session found matching "${args}".\n\nUse /sessions to see available sessions.`);
                 return;
@@ -19013,15 +19017,242 @@ async function startTelegram(options) {
             // Remove from known sessions
             knownSessionIds.delete(match.id);
             saveSessions();
-            const shortId = match.id.substring(0, 8);
             console.log(`[Telegram] Deleted session ${match.id}`);
-            await ctx.reply(`Deleted session: ${match.title} (${shortId})`);
+            await ctx.reply(`Deleted session: ${match.title}`);
         }
         catch (err) {
             console.error("[Telegram] Error deleting session:", err);
             await ctx.reply("Failed to delete session.");
         }
     });
+    /**
+     * Render a message part to markdown.
+     * In default mode: only text and tool calls (name + input/output).
+     * In detailed mode: also includes reasoning, step info, subtasks, costs, etc.
+     */
+    function renderPart(part, detailed) {
+        let md = "";
+        switch (part.type) {
+            case "text": {
+                const text = part.text;
+                if (text) {
+                    md += `${text}\n\n`;
+                }
+                break;
+            }
+            case "tool": {
+                const tool = part.tool;
+                const state = part.state;
+                md += `**Tool: ${tool}**\n\n`;
+                if (state.input) {
+                    md += `**Input:**\n\`\`\`json\n${JSON.stringify(state.input, null, 2)}\n\`\`\`\n\n`;
+                }
+                if (state.output) {
+                    md += `**Output:**\n\`\`\`\n${state.output}\n\`\`\`\n\n`;
+                }
+                if (state.error) {
+                    md += `**Error:**\n\`\`\`\n${state.error}\n\`\`\`\n\n`;
+                }
+                if (detailed && state.time) {
+                    const duration = ((state.time.end - state.time.start) / 1000).toFixed(1);
+                    md += `*Status: ${state.status} (${duration}s)*\n\n`;
+                }
+                break;
+            }
+            case "reasoning": {
+                if (!detailed)
+                    break;
+                const text = part.text;
+                if (text) {
+                    md += `<details>\n<summary>Thinking</summary>\n\n${text}\n\n</details>\n\n`;
+                }
+                break;
+            }
+            case "step-start": {
+                if (!detailed)
+                    break;
+                md += `---\n*Step started*\n\n`;
+                break;
+            }
+            case "step-finish": {
+                if (!detailed)
+                    break;
+                const reason = part.reason;
+                const cost = part.cost;
+                const tokens = part.tokens;
+                let info = `*Step finished`;
+                if (reason)
+                    info += ` (${reason})`;
+                info += `*`;
+                if (tokens) {
+                    info += `\n*Tokens: ${tokens.input} in / ${tokens.output} out`;
+                    if (tokens.reasoning > 0)
+                        info += ` / ${tokens.reasoning} reasoning`;
+                    if (tokens.cache.read > 0 || tokens.cache.write > 0) {
+                        info += ` (cache: ${tokens.cache.read} read, ${tokens.cache.write} write)`;
+                    }
+                    info += `*`;
+                }
+                if (cost !== undefined && cost > 0) {
+                    info += `\n*Cost: $${cost.toFixed(4)}*`;
+                }
+                md += `${info}\n\n---\n\n`;
+                break;
+            }
+            case "subtask": {
+                if (!detailed)
+                    break;
+                const description = part.description;
+                const agent = part.agent;
+                const prompt = part.prompt;
+                md += `**Subtask${agent ? ` (${agent})` : ""}**`;
+                if (description)
+                    md += `: ${description}`;
+                md += `\n\n`;
+                if (prompt) {
+                    md += `> ${prompt.replace(/\n/g, "\n> ")}\n\n`;
+                }
+                break;
+            }
+            case "agent": {
+                if (!detailed)
+                    break;
+                const name = part.name;
+                if (name) {
+                    md += `*Agent: ${name}*\n\n`;
+                }
+                break;
+            }
+            case "retry": {
+                if (!detailed)
+                    break;
+                const attempt = part.attempt;
+                const error = part.error;
+                md += `**Retry (attempt ${attempt || "?"})**`;
+                if (error?.data?.message) {
+                    md += `\n\`\`\`\n${error.data.message}\n\`\`\``;
+                }
+                md += `\n\n`;
+                break;
+            }
+            case "compaction": {
+                if (!detailed)
+                    break;
+                const auto = part.auto;
+                md += `*Context compacted${auto ? " (auto)" : ""}*\n\n`;
+                break;
+            }
+            default:
+                // snapshot, patch, file, etc. - skip in both modes
+                break;
+        }
+        return md;
+    }
+    // Handle /export command - export the current session to the opencode project directory
+    // Usage: /export        - default (text + tool calls only)
+    //        /export full   - detailed (includes thinking, steps, costs, subtasks, etc.)
+    bot.command("export", async (ctx) => {
+        const chatId = ctx.chat.id.toString();
+        const sessionId = chatSessions.get(chatId);
+        if (!sessionId) {
+            await ctx.reply("No active session. Send a message first to create one.");
+            return;
+        }
+        const args = ctx.message.text.replace(/^\/export\s*/, "").trim().toLowerCase();
+        const detailed = args === "full" || args === "detailed" || args === "all";
+        try {
+            const modeLabel = detailed ? "detailed" : "summary";
+            const processingMsg = await ctx.reply(`Exporting session (${modeLabel})...`);
+            // Fetch session info and messages in parallel
+            const [sessionResult, messagesResult, pathResult] = await Promise.all([
+                client.session.get({ path: { id: sessionId } }),
+                client.session.messages({ path: { id: sessionId } }),
+                client.path.get(),
+            ]);
+            if (sessionResult.error || !sessionResult.data) {
+                throw new Error(`Failed to get session: ${JSON.stringify(sessionResult.error)}`);
+            }
+            if (messagesResult.error || !messagesResult.data) {
+                throw new Error(`Failed to get messages: ${JSON.stringify(messagesResult.error)}`);
+            }
+            const session = sessionResult.data;
+            const messages = messagesResult.data;
+            // Build the markdown export
+            let md = `# ${session.title}\n\n`;
+            md += `**Session ID:** ${session.id}\n`;
+            md += `**Created:** ${new Date(session.time.created * 1000).toLocaleString()}\n`;
+            md += `**Updated:** ${new Date(session.time.updated * 1000).toLocaleString()}\n`;
+            if (detailed) {
+                md += `**Export mode:** Detailed\n`;
+            }
+            md += `\n---\n\n`;
+            for (const msg of messages) {
+                const info = msg.info;
+                const parts = msg.parts || [];
+                if (info.role === "user") {
+                    md += `## User\n\n`;
+                    for (const part of parts) {
+                        md += renderPart(part, detailed);
+                    }
+                    md += `---\n\n`;
+                }
+                else if (info.role === "assistant") {
+                    const assistant = info;
+                    const duration = assistant.time.completed
+                        ? ((assistant.time.completed - assistant.time.created) / 1000).toFixed(1) + "s"
+                        : "";
+                    const modelLabel = assistant.modelID || "unknown";
+                    const modeLabel = assistant.mode || "";
+                    const header = [modeLabel, modelLabel, duration].filter(Boolean).join(" · ");
+                    md += `## Assistant (${header})\n\n`;
+                    if (detailed && assistant.tokens) {
+                        const t = assistant.tokens;
+                        md += `*Tokens: ${t.input} in / ${t.output} out`;
+                        if (t.reasoning > 0)
+                            md += ` / ${t.reasoning} reasoning`;
+                        if (t.cache.read > 0 || t.cache.write > 0) {
+                            md += ` (cache: ${t.cache.read} read, ${t.cache.write} write)`;
+                        }
+                        md += `*\n`;
+                        if (assistant.cost && assistant.cost > 0) {
+                            md += `*Cost: $${assistant.cost.toFixed(4)}*\n`;
+                        }
+                        md += `\n`;
+                    }
+                    for (const part of parts) {
+                        md += renderPart(part, detailed);
+                    }
+                    md += `---\n\n`;
+                }
+            }
+            // Write to the project directory
+            const projectDir = pathResult.data?.directory;
+            const idPrefix = sessionId.substring(0, 8);
+            const suffix = detailed ? "-detailed" : "";
+            const filename = `session-${idPrefix}${suffix}.md`;
+            const exportPath = (0,external_node_path_.resolve)(projectDir || ".", filename);
+            (0,external_node_fs_.writeFileSync)(exportPath, md, "utf-8");
+            console.log(`[Telegram] Exported session ${sessionId} to ${exportPath} (${detailed ? "detailed" : "summary"})`);
+            // Delete the processing message
+            try {
+                await bot.telegram.deleteMessage(ctx.chat.id, processingMsg.message_id);
+            }
+            catch {
+                // Ignore if we can't delete it
+            }
+            // Send the file to the user
+            await bot.telegram.sendDocument(ctx.chat.id, {
+                source: Buffer.from(md, "utf-8"),
+                filename,
+            });
+            await ctx.reply(`Session exported to: ${exportPath}`);
+        }
+        catch (err) {
+            console.error("[Telegram] Error exporting session:", err);
+            await handleSessionError(chatId);
+            await ctx.reply("Sorry, there was an error exporting the session. Try again or use /new to start a fresh session.");
+        }
+    });
     // Catch-all for unregistered / commands - forward to OpenCode
     bot.on("text", async (ctx) => {
         const userText = ctx.message.text;
@@ -19053,6 +19284,7 @@ async function startTelegram(options) {
                     body: {
                         command: commandName,
                         arguments: commandArgs,
+                        agent: "default",
                     },
                 });
                 if (result.error) {

package/package.json

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