@grinev/opencode-telegram-bot 0.16.1 → 0.18.0

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,5 +1,7 @@
+import { spawn } from "node:child_process";
+import { config } from "../../config.js";
 import { opencodeClient } from "../../opencode/client.js";
-import { processManager } from "../../process/manager.js";
+import { resolveLocalOpencodeTarget } from "../../opencode/process.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 import { editBotText } from "../utils/telegram-text.js";
@@ -31,43 +33,45 @@ async function waitForServerReady(maxWaitMs = 10000) {
  */
 export async function opencodeStartCommand(ctx) {
     try {
-        // 1. Check if process is already running under our management
-        if (processManager.isRunning()) {
-            const uptime = processManager.getUptime();
-            const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
-            await ctx.reply(t("opencode_start.already_running_managed", {
-                pid: processManager.getPID() ?? "-",
-                seconds: uptimeStr,
-            }));
+        const localTarget = resolveLocalOpencodeTarget(config.opencode.apiUrl);
+        if (!localTarget) {
+            await ctx.reply(t("opencode_start.remote_configured"));
             return;
         }
-        // 2. Check if server is accessible (external process)
+        // Check if server is already accessible.
         try {
             const { data, error } = await opencodeClient.global.health();
             if (!error && data?.healthy) {
-                await ctx.reply(t("opencode_start.already_running_external", {
-                    version: data.version || t("common.unknown"),
-                }));
+                await ctx.reply(t("opencode_start.already_running", { version: data.version || t("common.unknown") }));
                 return;
             }
         }
         catch {
-            // Server not accessible, continue with start
+            // Server not accessible, continue with start.
         }
-        // 3. Notify user that we're starting the server
         const statusMessage = await ctx.reply(t("opencode_start.starting"));
-        // 4. Start the process
-        const { success, error } = await processManager.start();
-        if (!success) {
+        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,
+        });
+        childProcess.once("error", (error) => {
+            logger.error("[Bot] OpenCode server process failed to start", error);
+        });
+        const pid = childProcess.pid;
+        if (!pid) {
             await editBotText({
                 api: ctx.api,
                 chatId: ctx.chat.id,
                 messageId: statusMessage.message_id,
-                text: t("opencode_start.start_error", { error: error || t("common.unknown_error") }),
+                text: t("opencode_start.start_error", { error: t("common.unknown_error") }),
             });
             return;
         }
-        // 5. Wait for server to become ready
+        childProcess.unref();
         logger.info("[Bot] Waiting for OpenCode server to become ready...");
         const ready = await waitForServerReady(10000);
         if (!ready) {
@@ -76,23 +80,22 @@ export async function opencodeStartCommand(ctx) {
                 chatId: ctx.chat.id,
                 messageId: statusMessage.message_id,
                 text: t("opencode_start.started_not_ready", {
-                    pid: processManager.getPID() ?? "-",
+                    pid,
                 }),
             });
             return;
         }
-        // 6. Get server version and send success message
         const { data: health } = await opencodeClient.global.health();
         await editBotText({
             api: ctx.api,
             chatId: ctx.chat.id,
             messageId: statusMessage.message_id,
             text: t("opencode_start.success", {
-                pid: processManager.getPID() ?? "-",
+                pid,
                 version: health?.version || t("common.unknown"),
             }),
         });
-        logger.info(`[Bot] OpenCode server started successfully, PID=${processManager.getPID()}`);
+        logger.info(`[Bot] OpenCode server started successfully, PID=${pid}, port=${localTarget.port}`);
     }
     catch (err) {
         logger.error("[Bot] Error in /opencode-start command:", err);

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

@@ -1,41 +1,69 @@
+import { config } from "../../config.js";
 import { opencodeClient } from "../../opencode/client.js";
-import { processManager } from "../../process/manager.js";
+import { findServerPid, killServerProcess, resolveLocalOpencodeTarget, } from "../../opencode/process.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
+import { editBotText } from "../utils/telegram-text.js";
 /**
  * Command handler for /opencode-stop
  * Stops the OpenCode server process
  */
 export async function opencodeStopCommand(ctx) {
     try {
-        // 1. Check if process is running under our management
-        if (!processManager.isRunning()) {
-            // Check if there's an external server running
-            try {
-                const { data, error } = await opencodeClient.global.health();
-                if (!error && data?.healthy) {
-                    await ctx.reply(t("opencode_stop.external_running"));
-                    return;
-                }
-            }
-            catch {
-                // Server not accessible
+        const localTarget = resolveLocalOpencodeTarget(config.opencode.apiUrl);
+        if (!localTarget) {
+            await ctx.reply(t("opencode_stop.remote_configured"));
+            return;
+        }
+        try {
+            const { data, error } = await opencodeClient.global.health();
+            if (error || !data?.healthy) {
+                await ctx.reply(t("opencode_stop.not_running"));
+                return;
             }
+        }
+        catch {
             await ctx.reply(t("opencode_stop.not_running"));
             return;
         }
-        // 2. Notify user that we're stopping the server
-        const pid = processManager.getPID();
-        const statusMessage = await ctx.reply(t("opencode_stop.stopping", { pid: pid ?? "-" }));
-        // 3. Stop the process
-        const { success, error } = await processManager.stop(5000);
-        if (!success) {
-            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_stop.stop_error", { error: error || t("common.unknown_error") }));
+        const pid = await findServerPid(localTarget.port);
+        if (!pid) {
+            await ctx.reply(t("opencode_stop.pid_not_found", { port: localTarget.port }));
             return;
         }
-        // 4. Success - process has been stopped
-        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_stop.success"));
-        logger.info("[Bot] OpenCode server stopped successfully");
+        const statusMessage = await ctx.reply(t("opencode_stop.stopping", { pid }));
+        const stopped = await killServerProcess(pid, 5000);
+        if (!stopped) {
+            await editBotText({
+                api: ctx.api,
+                chatId: ctx.chat.id,
+                messageId: statusMessage.message_id,
+                text: t("opencode_stop.stop_error", { error: t("common.unknown_error") }),
+            });
+            return;
+        }
+        try {
+            const { data, error } = await opencodeClient.global.health();
+            if (!error && data?.healthy) {
+                await editBotText({
+                    api: ctx.api,
+                    chatId: ctx.chat.id,
+                    messageId: statusMessage.message_id,
+                    text: t("opencode_stop.stop_error", { error: t("opencode_stop.still_running") }),
+                });
+                return;
+            }
+        }
+        catch {
+            // Health check failure after stop is expected.
+        }
+        await editBotText({
+            api: ctx.api,
+            chatId: ctx.chat.id,
+            messageId: statusMessage.message_id,
+            text: t("opencode_stop.success"),
+        });
+        logger.info(`[Bot] OpenCode server stopped successfully, PID=${pid}, port=${localTarget.port}`);
     }
     catch (err) {
         logger.error("[Bot] Error in /opencode-stop command:", err);

package/dist/bot/commands/projects.js

@@ -1,5 +1,6 @@
 import { InlineKeyboard } from "grammy";
 import { getCurrentProject } from "../../settings/manager.js";
+import { getGitWorktreeContext } from "../../git/worktree.js";
 import { getProjects } from "../../project/manager.js";
 import { syncSessionDirectoryCache } from "../../session/cache-manager.js";
 import { appendInlineMenuCancelButton, ensureActiveInlineMenu, replyWithInlineMenu, } from "../handlers/inline-menu.js";
@@ -68,14 +69,37 @@ function buildProjectsMenuText(currentProjectName, page, totalPages) {
         total: String(totalPages),
     })}`;
 }
-function buildProjectsKeyboard(projects, page) {
+function worktreeKey(worktree) {
+    return process.platform === "win32" ? worktree.toLowerCase() : worktree;
+}
+async function getActiveProjectWorktree() {
+    const currentProject = getCurrentProject();
+    if (!currentProject) {
+        return null;
+    }
+    try {
+        const worktreeContext = await getGitWorktreeContext(currentProject.worktree);
+        if (worktreeContext) {
+            return worktreeContext.mainProjectPath;
+        }
+    }
+    catch (error) {
+        logger.debug("[Projects] Could not resolve active git worktree metadata:", error);
+    }
+    return currentProject.worktree;
+}
+async function buildProjectsKeyboard(projects, page) {
     const keyboard = new InlineKeyboard();
     const currentProject = getCurrentProject();
+    const activeProjectWorktree = await getActiveProjectWorktree();
     const pageSize = config.bot.projectsListLimit;
     const { page: normalizedPage, totalPages, startIndex, endIndex, } = calculateProjectsPaginationRange(projects.length, page, pageSize);
     projects.slice(startIndex, endIndex).forEach((project, index) => {
         const isActive = currentProject &&
-            (project.id === currentProject.id || project.worktree === currentProject.worktree);
+            (project.id === currentProject.id ||
+                project.worktree === currentProject.worktree ||
+                (activeProjectWorktree !== null &&
+                    worktreeKey(project.worktree) === worktreeKey(activeProjectWorktree)));
         const label = buildProjectButtonLabel(startIndex + index, project.worktree);
         const labelWithCheck = formatProjectButtonLabel(label, Boolean(isActive));
         keyboard.text(labelWithCheck, `project:${project.id}`).row();
@@ -90,14 +114,14 @@ function buildProjectsKeyboard(projects, page) {
     }
     return keyboard;
 }
-function buildProjectsMenuView(projects, page) {
+async function buildProjectsMenuView(projects, page) {
     const currentProject = getCurrentProject();
     const pageSize = config.bot.projectsListLimit;
     const { page: normalizedPage, totalPages } = calculateProjectsPaginationRange(projects.length, page, pageSize);
     const currentProjectName = currentProject?.name || currentProject?.worktree || null;
     return {
         text: buildProjectsMenuText(currentProjectName, normalizedPage, totalPages),
-        keyboard: buildProjectsKeyboard(projects, normalizedPage),
+        keyboard: await buildProjectsKeyboard(projects, normalizedPage),
     };
 }
 export async function projectsCommand(ctx) {
@@ -112,7 +136,7 @@ export async function projectsCommand(ctx) {
             await ctx.reply(t("projects.empty"));
             return;
         }
-        const { text, keyboard } = buildProjectsMenuView(projects, 0);
+        const { text, keyboard } = await buildProjectsMenuView(projects, 0);
         await replyWithInlineMenu(ctx, {
             menuKind: "project",
             text,
@@ -146,7 +170,7 @@ export async function handleProjectSelect(ctx) {
                 await ctx.reply(t("projects.empty"));
                 return true;
             }
-            const { text, keyboard } = buildProjectsMenuView(projects, page);
+            const { text, keyboard } = await buildProjectsMenuView(projects, page);
             await ctx.answerCallbackQuery();
             await ctx.editMessageText(text, {
                 reply_markup: appendInlineMenuCancelButton(keyboard, "project"),

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);
             }