@grinev/opencode-telegram-bot 0.18.0 → 0.19.0

package/.env.example

@@ -15,6 +15,13 @@ TELEGRAM_ALLOWED_USER_ID=
 # OpenCode API URL (optional, default: http://localhost:4096)
 # OPENCODE_API_URL=http://localhost:4096
 
+# Automatically restart a local OpenCode server when health-checks fail (default: false)
+# Only works when OPENCODE_API_URL points to localhost / 127.0.0.1 / ::1 / 0.0.0.0.
+# OPENCODE_AUTO_RESTART_ENABLED=false
+
+# OpenCode health monitor interval in seconds when auto-restart is enabled (default: 300)
+# OPENCODE_MONITOR_INTERVAL_SEC=300
+
 # OpenCode Server Authentication (optional)
 # OPENCODE_SERVER_USERNAME=opencode
 # OPENCODE_SERVER_PASSWORD=
@@ -105,8 +112,22 @@ OPENCODE_MODEL_ID=big-pickle
 
 # Text-to-Speech credentials (optional)
 # TTS reply behavior is controlled globally with /tts and persisted in settings.json.
-# Set both TTS_API_URL and TTS_API_KEY to enable audio replies.
+# Provider: "openai" (default) or "google".
+#
+# --- OpenAI-compatible (default) ---
+# Set TTS_API_URL and TTS_API_KEY to any OpenAI-compatible TTS endpoint.
 # TTS_API_URL=
 # TTS_API_KEY=
 # TTS_MODEL=gpt-4o-mini-tts
 # TTS_VOICE=alloy
+#
+# --- Google Cloud TTS ---
+# 1. Create a project at https://console.cloud.google.com
+# 2. Enable "Cloud Text-to-Speech API"
+# 3. Create a Service Account (IAM & Admin > Service Accounts)
+#    with role "Cloud Text-to-Speech API User"
+# 4. Download the JSON key file
+# Free tier: 1M characters/month (WaveNet/Neural2), 4M/month (Standard voices)
+# TTS_PROVIDER=google
+# TTS_VOICE=en-US-Studio-O
+# GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json

package/README.md

@@ -138,6 +138,7 @@ opencode-telegram config
 | `/rename`         | Rename the current session                              |
 | `/commands`       | Browse and run custom commands                          |
 | `/skills`         | Browse and run OpenCode skills                          |
+| `/mcps`           | Browse and toggle MCP servers                           |
 | `/task`           | Create a scheduled task                                 |
 | `/tasklist`       | Browse and delete scheduled tasks                       |
 | `/opencode_start` | Start the local OpenCode server on the bot machine      |
@@ -194,6 +195,8 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `TELEGRAM_ALLOWED_USER_ID`                 | Your numeric Telegram user ID                                                                                         |   Yes    | —                        |
 | `TELEGRAM_PROXY_URL`                       | Proxy URL for Telegram API (SOCKS5/HTTP)                                                                              |    No    | —                        |
 | `OPENCODE_API_URL`                         | OpenCode server URL                                                                                                   |    No    | `http://localhost:4096`  |
+| `OPENCODE_AUTO_RESTART_ENABLED`            | Automatically restart a local OpenCode server when health-checks fail                                                 |    No    | `false`                  |
+| `OPENCODE_MONITOR_INTERVAL_SEC`            | Health monitor interval in seconds when OpenCode auto-restart is enabled                                              |    No    | `300`                    |
 | `OPENCODE_SERVER_USERNAME`                 | Server auth username                                                                                                  |    No    | `opencode`               |
 | `OPENCODE_SERVER_PASSWORD`                 | Server auth password                                                                                                  |    No    | —                        |
 | `OPENCODE_MODEL_PROVIDER`                  | Default model provider                                                                                                |   Yes    | `opencode`               |
@@ -218,10 +221,12 @@ When installed via npm, the configuration wizard handles the initial setup. The
 | `STT_MODEL`                                | STT model name passed to `/audio/transcriptions`                                                                      |    No    | `whisper-large-v3-turbo` |
 | `STT_LANGUAGE`                             | Optional language hint (empty = provider auto-detect)                                                                 |    No    | —                        |
 | `STT_NOTE_PROMPT`                          | Optional note prepended to the LLM prompt as `[Note: ...]` for voice transcriptions; empty / `false` / `0` disable it |    No    | —                        |
-| `TTS_API_URL`                              | TTS API base URL                                                                                                      |    No    | —                        |
-| `TTS_API_KEY`                              | TTS API key                                                                                                           |    No    | —                        |
-| `TTS_MODEL`                                | TTS model name passed to `/audio/speech`                                                                              |    No    | `gpt-4o-mini-tts`        |
-| `TTS_VOICE`                                | OpenAI-compatible TTS voice name                                                                                      |    No    | `alloy`                  |
+| `TTS_PROVIDER`                             | TTS provider: `openai` for OpenAI-compatible APIs or `google` for Google Cloud TTS                                    |    No    | `openai`                 |
+| `TTS_API_URL`                              | OpenAI-compatible TTS API base URL                                                                                    |    No    | —                        |
+| `TTS_API_KEY`                              | OpenAI-compatible TTS API key                                                                                         |    No    | —                        |
+| `TTS_MODEL`                                | OpenAI-compatible TTS model name passed to `/audio/speech`                                                            |    No    | `gpt-4o-mini-tts`        |
+| `TTS_VOICE`                                | TTS voice name. Defaults to `alloy` for OpenAI-compatible APIs and `en-US-Studio-O` for Google Cloud TTS              |    No    | provider-specific        |
+| `GOOGLE_APPLICATION_CREDENTIALS`           | Path to a Google Cloud service account JSON key file for `TTS_PROVIDER=google`                                        |    No    | —                        |
 | `LOG_LEVEL`                                | Log level (`debug`, `info`, `warn`, `error`)                                                                          |    No    | `info`                   |
 | `LOG_RETENTION`                            | Number of log files to keep: launch files in `sources`, daily files in `installed`                                    |    No    | `10`                     |
 
@@ -242,15 +247,24 @@ If `STT_NOTE_PROMPT` is set to a non-empty value other than `false` or `0`, the
 
 If TTS credentials are configured, you can toggle spoken replies globally with `/tts`. The preference is stored in `settings.json` and persists across restarts.
 
-TTS configuration example:
+OpenAI-compatible TTS configuration example:
 
 ```env
+TTS_PROVIDER=openai
 TTS_API_URL=https://api.openai.com/v1
 TTS_API_KEY=your-tts-api-key
 TTS_MODEL=gpt-4o-mini-tts
 TTS_VOICE=alloy
 ```
 
+Google Cloud TTS configuration example:
+
+```env
+TTS_PROVIDER=google
+TTS_VOICE=en-US-Studio-O
+GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account-key.json
+```
+
 Supported provider examples (Whisper-compatible):
 
 - **OpenAI**
@@ -326,6 +340,7 @@ npm run dev
 
 - Ensure an OpenCode server is running at the configured `OPENCODE_API_URL` (default: `http://localhost:4096`)
 - For a local setup, you can start it with `opencode serve` or use `/opencode_start` in Telegram
+- For VPS/systemd setups with scheduled tasks, enable `OPENCODE_AUTO_RESTART_ENABLED=true` to let the bot restart a local OpenCode server when health-checks fail
 - If `OPENCODE_API_URL` points to a remote server, verify that the address is reachable from the bot machine and that the remote server is healthy
 
 **No models in model picker**

package/dist/app/start-bot-app.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import { readFile } from "node:fs/promises";
 import { cleanupBotRuntime, createBot } from "../bot/index.js";
 import { config } from "../config.js";
+import { opencodeAutoRestartService } from "../opencode/auto-restart.js";
 import { loadSettings } from "../settings/manager.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
@@ -39,6 +40,7 @@ export async function startBotApp() {
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
     await reconcileStoredModelSelection();
+    await opencodeAutoRestartService.start();
     await warmupSessionDirectoryCache();
     const bot = createBot();
     await scheduledTaskRuntime.initialize(bot);
@@ -73,6 +75,7 @@ export async function startBotApp() {
         shutdownStarted = true;
         logger.info(`[App] Received ${signal}, shutting down...`);
         cleanupBotRuntime(`app_shutdown_${signal.toLowerCase()}`);
+        opencodeAutoRestartService.stop();
         scheduledTaskRuntime.shutdown();
         shutdownTimeout = setTimeout(() => {
             logger.warn(`[App] Shutdown did not finish in ${SHUTDOWN_TIMEOUT_MS}ms, forcing exit.`);
@@ -114,6 +117,7 @@ export async function startBotApp() {
             shutdownTimeout = null;
         }
         cleanupBotRuntime("app_shutdown_complete");
+        opencodeAutoRestartService.stop();
         scheduledTaskRuntime.shutdown();
         await clearManagedServiceState().catch((error) => {
             logger.warn("[App] Failed to clear managed service state", error);

package/dist/attach/service.js

@@ -27,7 +27,12 @@ async function ensureAttachPinnedSession({ api, chatId, session, }) {
     if (pinnedState.sessionId === session.id && pinnedState.messageId) {
         return;
     }
-    await pinnedMessageManager.onSessionChange(session.id, session.title);
+    if (pinnedState.messageId && pinnedState.sessionId === null) {
+        await pinnedMessageManager.restoreExistingSession(session.id, session.title);
+    }
+    else {
+        await pinnedMessageManager.onSessionChange(session.id, session.title);
+    }
     await pinnedMessageManager.loadContextFromHistory(session.id, session.directory);
     const contextInfo = pinnedMessageManager.getContextInfo();
     if (contextInfo) {

package/dist/bot/commands/definitions.js

@@ -16,6 +16,7 @@ const COMMAND_DEFINITIONS = [
     { command: "rename", descriptionKey: "cmd.description.rename" },
     { command: "commands", descriptionKey: "cmd.description.commands" },
     { command: "skills", descriptionKey: "cmd.description.skills" },
+    { command: "mcps", descriptionKey: "cmd.description.mcps" },
     { command: "opencode_start", descriptionKey: "cmd.description.opencode_start" },
     { command: "opencode_stop", descriptionKey: "cmd.description.opencode_stop" },
     { command: "open", descriptionKey: "cmd.description.open" },

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/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/index.js

@@ -26,6 +26,7 @@ import { handleTaskCallback, handleTaskTextInput, taskCommand } from "./commands
 import { handleTaskListCallback, taskListCommand } from "./commands/tasklist.js";
 import { commandsCommand, handleCommandsCallback, handleCommandTextArguments, } from "./commands/commands.js";
 import { skillsCommand, handleSkillsCallback, handleSkillTextArguments, } from "./commands/skills.js";
+import { mcpsCommand, handleMcpsCallback } from "./commands/mcps.js";
 import { ttsCommand } from "./commands/tts.js";
 import { handleQuestionCallback, showCurrentQuestion, handleQuestionTextAnswer, } from "./handlers/question.js";
 import { handlePermissionCallback, showPermissionRequest } from "./handlers/permission.js";
@@ -873,6 +874,7 @@ export function createBot() {
     bot.command("rename", renameCommand);
     bot.command("commands", commandsCommand);
     bot.command("skills", skillsCommand);
+    bot.command("mcps", mcpsCommand);
     bot.on("message:text", unknownCommandMiddleware);
     bot.on("callback_query:data", async (ctx) => {
         logger.debug(`[Bot] Received callback_query:data: ${ctx.callbackQuery?.data}`);
@@ -902,7 +904,8 @@ export function createBot() {
             const handledRenameCancel = await handleRenameCancel(ctx);
             const handledCommands = await handleCommandsCallback(ctx, { bot, ensureEventSubscription });
             const handledSkills = await handleSkillsCallback(ctx, { bot, ensureEventSubscription });
-            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, skills=${handledSkills}`);
+            const handledMcps = await handleMcpsCallback(ctx);
+            logger.debug(`[Bot] Callback handled: inlineCancel=${handledInlineCancel}, session=${handledSession}, project=${handledProject}, worktree=${handledWorktree}, open=${handledOpen}, question=${handledQuestion}, permission=${handledPermission}, agent=${handledAgent}, model=${handledModel}, variant=${handledVariant}, compactConfirm=${handledCompactConfirm}, task=${handledTask}, taskList=${handledTaskList}, rename=${handledRenameCancel}, commands=${handledCommands}, skills=${handledSkills}, mcps=${handledMcps}`);
             if (!handledInlineCancel &&
                 !handledSession &&
                 !handledProject &&
@@ -918,7 +921,8 @@ export function createBot() {
                 !handledTaskList &&
                 !handledRenameCancel &&
                 !handledCommands &&
-                !handledSkills) {
+                !handledSkills &&
+                !handledMcps) {
                 logger.debug("Unknown callback query:", ctx.callbackQuery?.data);
                 await ctx.answerCallbackQuery({ text: t("callback.unknown_command") });
             }

package/dist/config.js

@@ -50,6 +50,18 @@ function getOptionalMessageFormatModeEnvVar(key, defaultValue) {
     }
     return defaultValue;
 }
+const VALID_TTS_PROVIDERS = ["openai", "google"];
+function getOptionalTtsProviderEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (VALID_TTS_PROVIDERS.includes(normalized)) {
+        return normalized;
+    }
+    return defaultValue;
+}
 export const config = {
     telegram: {
         token: getEnvVar("TELEGRAM_BOT_TOKEN"),
@@ -60,6 +72,8 @@ export const config = {
         apiUrl: getEnvVar("OPENCODE_API_URL", false) || "http://localhost:4096",
         username: getEnvVar("OPENCODE_SERVER_USERNAME", false) || "opencode",
         password: getEnvVar("OPENCODE_SERVER_PASSWORD", false),
+        autoRestartEnabled: getOptionalBooleanEnvVar("OPENCODE_AUTO_RESTART_ENABLED", false),
+        monitorIntervalSec: getOptionalPositiveIntEnvVar("OPENCODE_MONITOR_INTERVAL_SEC", 300),
         model: {
             provider: getEnvVar("OPENCODE_MODEL_PROVIDER", true), // Required
             modelId: getEnvVar("OPENCODE_MODEL_ID", true), // Required
@@ -95,10 +109,15 @@ export const config = {
         language: getEnvVar("STT_LANGUAGE", false),
         notePrompt: getEnvVar("STT_NOTE_PROMPT", false),
     },
-    tts: {
-        apiUrl: getEnvVar("TTS_API_URL", false),
-        apiKey: getEnvVar("TTS_API_KEY", false),
-        model: getEnvVar("TTS_MODEL", false) || "gpt-4o-mini-tts",
-        voice: getEnvVar("TTS_VOICE", false) || "alloy",
-    },
+    tts: (() => {
+        const provider = getOptionalTtsProviderEnvVar("TTS_PROVIDER", "openai");
+        const defaultVoice = provider === "google" ? "en-US-Studio-O" : "alloy";
+        return {
+            apiUrl: getEnvVar("TTS_API_URL", false),
+            apiKey: getEnvVar("TTS_API_KEY", false),
+            provider,
+            model: getEnvVar("TTS_MODEL", false) || "gpt-4o-mini-tts",
+            voice: getEnvVar("TTS_VOICE", false) || defaultVoice,
+        };
+    })(),
 };