@grinev/opencode-telegram-bot 0.17.0 → 0.19.0

package/dist/bot/commands/mcps.js

@@ -0,0 +1,394 @@
+import { InlineKeyboard } from "grammy";
+import { opencodeClient } from "../../opencode/client.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { interactionManager } from "../../interaction/manager.js";
+import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
+const MCPS_CALLBACK_PREFIX = "mcps:";
+const MCPS_CALLBACK_SELECT_PREFIX = `${MCPS_CALLBACK_PREFIX}select:`;
+const MCPS_CALLBACK_TOGGLE = `${MCPS_CALLBACK_PREFIX}toggle`;
+const MCPS_CALLBACK_BACK = `${MCPS_CALLBACK_PREFIX}back`;
+const MCPS_CALLBACK_CANCEL = `${MCPS_CALLBACK_PREFIX}cancel`;
+const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+function normalizeDirectoryForApi(directory) {
+    return directory.replace(/\\/g, "/");
+}
+function getCallbackMessageId(ctx) {
+    const message = ctx.callbackQuery?.message;
+    if (!message || !("message_id" in message)) {
+        return null;
+    }
+    const messageId = message.message_id;
+    return typeof messageId === "number" ? messageId : null;
+}
+function getStatusLabel(status) {
+    switch (status.status) {
+        case "connected":
+            return t("mcps.status.connected");
+        case "disabled":
+            return t("mcps.status.disabled");
+        case "failed":
+            return t("mcps.status.failed");
+        case "needs_auth":
+            return t("mcps.status.needs_auth");
+        case "needs_client_registration":
+            return t("mcps.status.needs_client_registration");
+        default:
+            return t("common.unknown");
+    }
+}
+function getStatusEmoji(status) {
+    switch (status.status) {
+        case "connected":
+            return "🟢";
+        case "disabled":
+            return "🔴";
+        case "failed":
+            return "⚠️";
+        case "needs_auth":
+            return "🔒";
+        case "needs_client_registration":
+            return "🔒";
+        default:
+            return "❓";
+    }
+}
+function formatMcpButtonLabel(server) {
+    const rawLabel = `${getStatusEmoji(server.status)} ${server.name}`;
+    if (rawLabel.length <= MAX_INLINE_BUTTON_LABEL_LENGTH) {
+        return rawLabel;
+    }
+    return `${rawLabel.slice(0, MAX_INLINE_BUTTON_LABEL_LENGTH - 3)}...`;
+}
+function buildMcpsListKeyboard(servers) {
+    const keyboard = new InlineKeyboard();
+    servers.forEach((server, index) => {
+        keyboard
+            .text(formatMcpButtonLabel(server), `${MCPS_CALLBACK_SELECT_PREFIX}${index}`)
+            .row();
+    });
+    keyboard.text(t("inline.button.cancel"), MCPS_CALLBACK_CANCEL);
+    return keyboard;
+}
+function buildMcpsDetailKeyboard(server) {
+    const keyboard = new InlineKeyboard();
+    let hasToggleButton = false;
+    if (server.status.status === "connected") {
+        keyboard.text(t("mcps.button.disable"), MCPS_CALLBACK_TOGGLE);
+        hasToggleButton = true;
+    }
+    else if (server.status.status === "disabled" || server.status.status === "failed") {
+        keyboard.text(t("mcps.button.enable"), MCPS_CALLBACK_TOGGLE);
+        hasToggleButton = true;
+    }
+    if (hasToggleButton) {
+        keyboard.row();
+    }
+    keyboard.text(t("mcps.button.back"), MCPS_CALLBACK_BACK);
+    keyboard.text(t("inline.button.cancel"), MCPS_CALLBACK_CANCEL);
+    return keyboard;
+}
+function buildMcpsDetailText(server) {
+    const lines = [];
+    lines.push(t("mcps.detail.title", { name: server.name }));
+    lines.push("");
+    lines.push(t("mcps.detail.status", { status: getStatusLabel(server.status) }));
+    if (server.status.status === "failed" || server.status.status === "needs_client_registration") {
+        lines.push(t("mcps.detail.error", { error: server.status.error }));
+    }
+    if (server.status.status === "needs_auth" || server.status.status === "needs_client_registration") {
+        lines.push("");
+        lines.push(t("mcps.auth_required"));
+    }
+    return lines.join("\n");
+}
+function parseMcpsServers(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        const servers = [];
+        for (const item of value) {
+            if (!item || typeof item !== "object") {
+                return null;
+            }
+            const name = item.name;
+            const status = item.status;
+            if (typeof name !== "string" || !status || typeof status !== "object") {
+                return null;
+            }
+            const s = status;
+            if (typeof s.status !== "string") {
+                return null;
+            }
+            const mcpStatus = { status: s.status };
+            if ("error" in s && typeof s.error === "string") {
+                mcpStatus.error = s.error;
+            }
+            servers.push({ name, status: mcpStatus });
+        }
+        return servers;
+    }
+    const entries = Object.entries(value);
+    const servers = [];
+    for (const [name, status] of entries) {
+        if (!status || typeof status !== "object") {
+            return null;
+        }
+        const s = status;
+        if (typeof s.status !== "string") {
+            return null;
+        }
+        const mcpStatus = { status: s.status };
+        if ("error" in s && typeof s.error === "string") {
+            mcpStatus.error = s.error;
+        }
+        servers.push({ name, status: mcpStatus });
+    }
+    return servers;
+}
+function parseMcpsMetadata(state) {
+    if (!state || state.kind !== "custom") {
+        return null;
+    }
+    const flow = state.metadata.flow;
+    const stage = state.metadata.stage;
+    const messageId = state.metadata.messageId;
+    const projectDirectory = state.metadata.projectDirectory;
+    if (flow !== "mcps" || typeof messageId !== "number" || typeof projectDirectory !== "string") {
+        return null;
+    }
+    const servers = parseMcpsServers(state.metadata.servers);
+    if (!servers) {
+        return null;
+    }
+    if (stage === "list") {
+        return {
+            flow,
+            stage,
+            messageId,
+            projectDirectory,
+            servers,
+        };
+    }
+    if (stage === "detail") {
+        const serverName = state.metadata.serverName;
+        if (typeof serverName !== "string" || !serverName.trim()) {
+            return null;
+        }
+        return {
+            flow,
+            stage,
+            messageId,
+            projectDirectory,
+            serverName,
+            servers,
+        };
+    }
+    return null;
+}
+function clearMcpsInteraction(reason) {
+    const metadata = parseMcpsMetadata(interactionManager.getSnapshot());
+    if (metadata) {
+        interactionManager.clear(reason);
+    }
+}
+function parseSelectIndex(data) {
+    if (!data.startsWith(MCPS_CALLBACK_SELECT_PREFIX)) {
+        return null;
+    }
+    const index = Number(data.slice(MCPS_CALLBACK_SELECT_PREFIX.length));
+    if (!Number.isInteger(index) || index < 0) {
+        return null;
+    }
+    return index;
+}
+async function getMcpServerList(projectDirectory) {
+    const { data, error } = await opencodeClient.mcp.status({
+        directory: normalizeDirectoryForApi(projectDirectory),
+    });
+    if (error || !data) {
+        throw error || new Error("No MCP status data received");
+    }
+    const servers = parseMcpsServers(data);
+    if (!servers) {
+        throw new Error("Invalid MCP status data format");
+    }
+    return servers;
+}
+async function toggleMcpServer(projectDirectory, serverName, enable) {
+    const params = {
+        name: serverName,
+        directory: normalizeDirectoryForApi(projectDirectory),
+    };
+    if (enable) {
+        const { error } = await opencodeClient.mcp.connect(params);
+        if (error) {
+            throw error;
+        }
+    }
+    else {
+        const { error } = await opencodeClient.mcp.disconnect(params);
+        if (error) {
+            throw error;
+        }
+    }
+}
+export async function mcpsCommand(ctx) {
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply(t("bot.project_not_selected"));
+            return;
+        }
+        const servers = await getMcpServerList(currentProject.worktree);
+        if (servers.length === 0) {
+            await ctx.reply(t("mcps.empty"));
+            return;
+        }
+        const keyboard = buildMcpsListKeyboard(servers);
+        const message = await ctx.reply(t("mcps.select"), {
+            reply_markup: keyboard,
+        });
+        interactionManager.start({
+            kind: "custom",
+            expectedInput: "callback",
+            metadata: {
+                flow: "mcps",
+                stage: "list",
+                messageId: message.message_id,
+                projectDirectory: currentProject.worktree,
+                servers,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[Mcps] Error fetching MCP servers list:", error);
+        await ctx.reply(t("mcps.fetch_error"));
+    }
+}
+export async function handleMcpsCallback(ctx) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(MCPS_CALLBACK_PREFIX)) {
+        return false;
+    }
+    const metadata = parseMcpsMetadata(interactionManager.getSnapshot());
+    const callbackMessageId = getCallbackMessageId(ctx);
+    if (!metadata || callbackMessageId === null || metadata.messageId !== callbackMessageId) {
+        await ctx.answerCallbackQuery({ text: t("inline.inactive_callback"), show_alert: true });
+        return true;
+    }
+    try {
+        if (data === MCPS_CALLBACK_CANCEL) {
+            clearMcpsInteraction("mcps_cancelled");
+            await ctx.answerCallbackQuery({ text: t("inline.cancelled_callback") });
+            await ctx.deleteMessage().catch(() => { });
+            return true;
+        }
+        if (data === MCPS_CALLBACK_BACK) {
+            if (metadata.stage !== "detail") {
+                await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+                return true;
+            }
+            const servers = await getMcpServerList(metadata.projectDirectory);
+            const keyboard = buildMcpsListKeyboard(servers);
+            await ctx.editMessageText(t("mcps.select"), { reply_markup: keyboard });
+            await ctx.answerCallbackQuery();
+            interactionManager.transition({
+                expectedInput: "callback",
+                metadata: {
+                    flow: "mcps",
+                    stage: "list",
+                    messageId: metadata.messageId,
+                    projectDirectory: metadata.projectDirectory,
+                    servers,
+                },
+            });
+            return true;
+        }
+        if (data === MCPS_CALLBACK_TOGGLE) {
+            if (metadata.stage !== "detail") {
+                await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+                return true;
+            }
+            const serverName = metadata.serverName;
+            const server = metadata.servers.find((s) => s.name === serverName);
+            if (!server) {
+                await ctx.answerCallbackQuery({ text: t("inline.inactive_callback"), show_alert: true });
+                return true;
+            }
+            const enable = server.status.status !== "connected";
+            await ctx.answerCallbackQuery({ text: enable ? t("mcps.enabling") : t("mcps.disabling") });
+            await toggleMcpServer(metadata.projectDirectory, serverName, enable);
+            const updatedServers = await getMcpServerList(metadata.projectDirectory);
+            const updatedServer = updatedServers.find((s) => s.name === serverName);
+            if (!updatedServer) {
+                await ctx.editMessageText(t("mcps.select"), {
+                    reply_markup: buildMcpsListKeyboard(updatedServers),
+                });
+                interactionManager.transition({
+                    expectedInput: "callback",
+                    metadata: {
+                        flow: "mcps",
+                        stage: "list",
+                        messageId: metadata.messageId,
+                        projectDirectory: metadata.projectDirectory,
+                        servers: updatedServers,
+                    },
+                });
+                return true;
+            }
+            await ctx.editMessageText(buildMcpsDetailText(updatedServer), {
+                reply_markup: buildMcpsDetailKeyboard(updatedServer),
+            });
+            interactionManager.transition({
+                expectedInput: "callback",
+                metadata: {
+                    flow: "mcps",
+                    stage: "detail",
+                    messageId: metadata.messageId,
+                    projectDirectory: metadata.projectDirectory,
+                    serverName: updatedServer.name,
+                    servers: updatedServers,
+                },
+            });
+            return true;
+        }
+        if (data.startsWith(MCPS_CALLBACK_SELECT_PREFIX)) {
+            if (metadata.stage !== "list") {
+                await ctx.answerCallbackQuery({ text: t("callback.processing_error"), show_alert: true });
+                return true;
+            }
+            const serverIndex = parseSelectIndex(data);
+            const server = serverIndex === null ? undefined : metadata.servers[serverIndex];
+            if (!server) {
+                await ctx.answerCallbackQuery({ text: t("inline.inactive_callback"), show_alert: true });
+                return true;
+            }
+            await ctx.answerCallbackQuery();
+            await ctx.editMessageText(buildMcpsDetailText(server), {
+                reply_markup: buildMcpsDetailKeyboard(server),
+            });
+            interactionManager.transition({
+                expectedInput: "callback",
+                metadata: {
+                    flow: "mcps",
+                    stage: "detail",
+                    messageId: metadata.messageId,
+                    projectDirectory: metadata.projectDirectory,
+                    serverName: server.name,
+                    servers: metadata.servers,
+                },
+            });
+            return true;
+        }
+        await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
+        return true;
+    }
+    catch (error) {
+        logger.error("[Mcps] Error handling MCP callback:", error);
+        clearMcpsInteraction("mcps_callback_error");
+        await ctx.answerCallbackQuery({ text: t("mcps.toggle_error") }).catch(() => { });
+        return true;
+    }
+}

package/dist/bot/commands/new.js

@@ -3,8 +3,6 @@ import { setCurrentSession } from "../../session/manager.js";
 import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
 import { getStoredModel } from "../../model/manager.js";
@@ -13,7 +11,8 @@ import { createMainKeyboard } from "../utils/keyboard.js";
 import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
-export async function newCommand(ctx) {
+import { attachToSession } from "../../attach/service.js";
+export async function newCommand(ctx, deps) {
     try {
         if (isForegroundBusy()) {
             await replyBusyBlocked(ctx);
@@ -38,27 +37,20 @@ export async function newCommand(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
-        summaryAggregator.clear();
         clearAllInteractionState("session_created");
         await ingestSessionInfoForCache(session);
-        // Initialize pinned message manager and create pinned message
-        if (!pinnedMessageManager.isInitialized()) {
-            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
-        }
-        // Initialize keyboard manager if not already
-        keyboardManager.initialize(ctx.api, ctx.chat.id);
-        try {
-            await pinnedMessageManager.onSessionChange(session.id, session.title);
-        }
-        catch (err) {
-            logger.error("[Bot] Error creating pinned message:", err);
-        }
+        await attachToSession({
+            bot: deps.bot,
+            chatId: ctx.chat.id,
+            session: sessionInfo,
+            ensureEventSubscription: deps.ensureEventSubscription,
+        });
         // Get current state for keyboard
         const currentAgent = await resolveProjectAgent(getStoredAgent());
         const currentModel = getStoredModel();
-        const contextInfo = pinnedMessageManager.getContextInfo();
-        const variantName = formatVariantForButton(currentModel.variant || "default");
         keyboardManager.updateAgent(currentAgent);
+        const contextInfo = keyboardManager.getContextInfo();
+        const variantName = formatVariantForButton(currentModel.variant || "default");
         const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
         await ctx.reply(t("new.created", { title: session.title }), {
             reply_markup: keyboard,

package/dist/bot/commands/opencode-start.js

@@ -1,7 +1,6 @@
-import { spawn } from "node:child_process";
 import { config } from "../../config.js";
 import { opencodeClient } from "../../opencode/client.js";
-import { resolveLocalOpencodeTarget } from "../../opencode/process.js";
+import { resolveLocalOpencodeTarget, startLocalOpencodeServer } from "../../opencode/process.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { editBotText } from "../utils/telegram-text.js";
@@ -50,14 +49,7 @@ export async function opencodeStartCommand(ctx) {
             // Server not accessible, continue with start.
         }
         const statusMessage = await ctx.reply(t("opencode_start.starting"));
-        const isWindows = process.platform === "win32";
-        const command = isWindows ? "cmd.exe" : "opencode";
-        const args = isWindows ? ["/c", "opencode", "serve"] : ["serve"];
-        const childProcess = spawn(command, args, {
-            detached: true,
-            stdio: "ignore",
-            windowsHide: isWindows,
-        });
+        const childProcess = startLocalOpencodeServer(localTarget);
         childProcess.once("error", (error) => {
             logger.error("[Bot] OpenCode server process failed to start", error);
         });

package/dist/bot/commands/sessions.js

@@ -4,8 +4,6 @@ import { resolveProjectAgent } from "../../agent/manager.js";
 import { setCurrentSession } from "../../session/manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { clearAllInteractionState } from "../../interaction/cleanup.js";
-import { summaryAggregator } from "../../summary/aggregator.js";
-import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
 import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
 import { isForegroundBusy, replyBusyBlocked } from "../utils/busy-guard.js";
@@ -13,6 +11,7 @@ import { logger } from "../../utils/logger.js";
 import { safeBackgroundTask } from "../../utils/safe-background-task.js";
 import { config } from "../../config.js";
 import { getDateLocale, t } from "../../i18n/index.js";
+import { attachToSession } from "../../attach/service.js";
 const SESSION_CALLBACK_PREFIX = "session:";
 const SESSION_PAGE_CALLBACK_PREFIX = "session:page:";
 const SESSION_FETCH_EXTRA_COUNT = 1;
@@ -120,7 +119,7 @@ export async function sessionsCommand(ctx) {
         await ctx.reply(t("sessions.fetch_error"));
     }
 }
-export async function handleSessionSelect(ctx) {
+export async function handleSessionSelect(ctx, deps) {
     const callbackQuery = ctx.callbackQuery;
     if (!callbackQuery?.data || !callbackQuery.data.startsWith(SESSION_CALLBACK_PREFIX)) {
         return false;
@@ -182,7 +181,6 @@ export async function handleSessionSelect(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
-        summaryAggregator.clear();
         clearAllInteractionState("session_switched");
         await ctx.answerCallbackQuery();
         let loadingMessageId = null;
@@ -195,30 +193,31 @@ export async function handleSessionSelect(ctx) {
                 logger.error("[Sessions] Failed to send loading message:", err);
             }
         }
-        // Initialize pinned message manager if not already
-        if (!pinnedMessageManager.isInitialized() && ctx.chat) {
-            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
-        }
-        // Initialize keyboard manager if not already
-        if (ctx.chat) {
-            keyboardManager.initialize(ctx.api, ctx.chat.id);
-        }
         try {
-            // Create new pinned message for this session
-            await pinnedMessageManager.onSessionChange(session.id, session.title);
-            // Load context from session history (for existing sessions)
-            // Wait for it to complete so keyboard has correct context
-            await pinnedMessageManager.loadContextFromHistory(session.id, currentProject.worktree);
+            await attachToSession({
+                bot: deps.bot,
+                chatId: ctx.chat.id,
+                session: sessionInfo,
+                ensureEventSubscription: deps.ensureEventSubscription,
+            });
         }
         catch (err) {
-            logger.error("[Bot] Error initializing pinned message:", err);
+            if (loadingMessageId) {
+                try {
+                    await ctx.api.deleteMessage(ctx.chat.id, loadingMessageId);
+                }
+                catch (deleteError) {
+                    logger.debug("[Sessions] Failed to delete loading message after follow error:", deleteError);
+                }
+            }
+            logger.error("[Sessions] Error following selected session:", err);
+            throw err;
         }
         if (ctx.chat) {
             const chatId = ctx.chat.id;
             const currentAgent = await resolveProjectAgent();
             keyboardManager.updateAgent(currentAgent);
-            // Update keyboard with loaded context (callback executes async via setImmediate, so update manually)
-            const contextInfo = pinnedMessageManager.getContextInfo();
+            const contextInfo = keyboardManager.getContextInfo();
             if (contextInfo) {
                 keyboardManager.updateContext(contextInfo.tokensUsed, contextInfo.tokensLimit);
             }

package/dist/bot/commands/start.js

@@ -10,6 +10,7 @@ import { foregroundSessionState } from "../../scheduled-task/foreground-state.js
 import { abortCurrentOperation } from "./abort.js";
 import { t } from "../../i18n/index.js";
 import { assistantRunState } from "../assistant-run-state.js";
+import { detachAttachedSession } from "../../attach/service.js";
 export async function startCommand(ctx) {
     if (ctx.chat) {
         if (!pinnedMessageManager.isInitialized()) {
@@ -18,6 +19,7 @@ export async function startCommand(ctx) {
         keyboardManager.initialize(ctx.api, ctx.chat.id);
     }
     await abortCurrentOperation(ctx, { notifyUser: false });
+    detachAttachedSession("start_command_reset");
     foregroundSessionState.clearAll("start_command_reset");
     assistantRunState.clearAll("start_command_reset");
     clearSession();