@grinev/opencode-telegram-bot 0.16.0 → 0.17.0

package/.env.example

@@ -51,6 +51,10 @@ OPENCODE_MODEL_ID=big-pickle
 # Maximum number of scheduled tasks allowed at once (default: 10)
 # TASK_LIMIT=10
 
+# Maximum execution time for a scheduled task in minutes (default: 120)
+# If exceeded, the bot stops waiting for the result and marks the run as failed.
+# SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES=120
+
 # Stream update throttle in milliseconds for assistant/tool message edits (default: 500)
 # Higher value = fewer Telegram edit requests, lower value = more real-time updates
 # RESPONSE_STREAM_THROTTLE_MS=500
@@ -69,6 +73,9 @@ OPENCODE_MODEL_ID=big-pickle
 # Hide tool call service messages (default: false)
 # HIDE_TOOL_CALL_MESSAGES=false
 
+# Hide tool file edit documents sent as .txt attachments (default: false)
+# HIDE_TOOL_FILE_MESSAGES=false
+
 # Assistant message formatting mode (default: markdown)
 # markdown = convert assistant replies to Telegram MarkdownV2
 # raw = show assistant replies as plain text
@@ -94,6 +101,7 @@ OPENCODE_MODEL_ID=big-pickle
 # STT_API_KEY=
 # STT_MODEL=
 # STT_LANGUAGE=
+# STT_NOTE_PROMPT="The following text is transcribed from voice. It may contain homophone or phonetic errors. Infer the intended meaning from context."
 
 # Text-to-Speech credentials (optional)
 # TTS reply behavior is controlled globally with /tts and persisted in settings.json.

package/README.md

@@ -26,17 +26,19 @@ Languages: English (`en`), Deutsch (`de`), Español (`es`), Français (`fr`), Р
 
 - **Remote coding** — send prompts to OpenCode from anywhere, receive complete results with code sent as files
 - **Session management** — create new sessions or continue existing ones, just like in the TUI
-- **Live status** — pinned message with current project, model, context usage, and changed files list, updated in real time
+- **Live status** — pinned message with current project/worktree, model, context usage, and changed files list, updated in real time
 - **Model switching** — pick models from OpenCode favorites and recent history directly in the chat (favorites are shown first)
 - **Agent modes** — switch between Plan and Build modes on the fly
 - **Subagent activity** — watch live subagent progress in chat, including the current task, agent, model, and active tool step
 - **Custom Commands** — run OpenCode custom commands (and built-ins like `init`/`review`) from an inline menu with confirmation
+- **Skills Catalog** — browse OpenCode skills from an inline menu and run them immediately or with arguments in the next message
 - **Interactive Q&A** — answer agent questions and approve permissions via inline buttons
 - **Voice prompts** — send voice/audio messages, transcribe them via a Whisper-compatible API, and optionally enable spoken replies with `/tts`
 - **File attachments** — send images, PDF documents, and any text-based files to OpenCode (code, logs, configs etc.)
 - **Scheduled tasks** — schedule prompts to run later or on a recurring interval; see [Scheduled Tasks](#scheduled-tasks)
 - **Context control** — compact context when it gets too large, right from the chat
 - **Input flow control** — when an interactive flow is active, the bot accepts only relevant input to keep context consistent and avoid accidental actions
+- **Git worktree switching** — browse and switch between existing git worktrees for the current repository with `/worktree`
 - **Security** — strict user ID whitelist; no one else can access your bot, even if they find it
 - **Localization** — UI localization is supported for multiple languages (`BOT_LOCALE`)
 
@@ -60,22 +62,26 @@ You'll also need your **Telegram User ID** — send any message to [@userinfobot
 
 ### 2. Start OpenCode Server
 
-Start the OpenCode server:
+Run the OpenCode server on the same machine where the bot runs:
 
 ```bash
 opencode serve
 ```
 
-> The bot connects to the OpenCode API at `http://localhost:4096` by default.
+> The bot connects to the local OpenCode API at `http://localhost:4096` by default.
+
+> After the bot is configured, you can also start and stop the local OpenCode server from Telegram with `/opencode_start` and `/opencode_stop`.
 
 ### 3. Install & Run
 
 The fastest way — run directly with `npx`:
 
 ```bash
-npx @grinev/opencode-telegram-bot
+npx @grinev/opencode-telegram-bot@latest
 ```
 
+> **Note:** This README tracks the `main` branch, which may include unreleased changes. The latest npm release may not include every feature described here yet. See [recent commits on `main`](https://github.com/grinev/opencode-telegram-bot/commits/main).
+
 > Quick start is for npm usage. You do not need to clone this repository. If you run this command from the source directory (repository root), it may fail with `opencode-telegram: not found`. To run from sources, use the [Development](#development) section.
 
 On first launch, an interactive wizard will guide you through the configuration — it asks for interface language first, then your bot token, user ID, OpenCode API URL, and optional OpenCode server credentials (username/password). After that, you're ready to go. Open your bot in Telegram and start sending tasks.
@@ -87,6 +93,20 @@ npm install -g @grinev/opencode-telegram-bot
 opencode-telegram start
 ```
 
+`start` runs in the foreground by default. This is the recommended mode for `systemd`, Docker, local debugging, and other external process managers.
+
+To run the bot in the built-in background mode instead:
+
+```bash
+opencode-telegram start --daemon
+opencode-telegram status
+opencode-telegram stop
+```
+
+> Built-in daemon mode is intended for standalone npm installs without an external supervisor. For `systemd`, `pm2`, or Docker, keep using `opencode-telegram start` without `--daemon`.
+
+For Linux `systemd` setup, see [`docs/LINUX_SYSTEMD_SETUP.md`](./docs/LINUX_SYSTEMD_SETUP.md).
+
 To reconfigure at any time:
 
 ```bash
@@ -110,19 +130,21 @@ opencode-telegram config
 | `/abort`          | Abort the current task                                  |
 | `/sessions`       | Browse and switch between recent sessions               |
 | `/projects`       | Switch between OpenCode projects                        |
+| `/worktree`       | Switch between existing git worktrees                   |
 | `/open`           | Add a project by browsing directories                   |
 | `/tts`            | Toggle audio replies                                    |
 | `/rename`         | Rename the current session                              |
 | `/commands`       | Browse and run custom commands                          |
+| `/skills`         | Browse and run OpenCode skills                          |
 | `/task`           | Create a scheduled task                                 |
 | `/tasklist`       | Browse and delete scheduled tasks                       |
-| `/opencode_start` | Start the OpenCode server remotely                      |
-| `/opencode_stop`  | Stop the OpenCode server remotely                       |
+| `/opencode_start` | Start the local OpenCode server on the bot machine      |
+| `/opencode_stop`  | Stop the local OpenCode server on the bot machine       |
 | `/help`           | Show available commands                                 |
 
 Any regular text message is sent as a prompt to the coding agent only when no blocking interaction is active. Voice/audio messages are transcribed and then sent as prompts when STT is configured.
 
-> `/opencode_start` and `/opencode_stop` are intended as emergency commands — for example, if you need to restart a stuck server while away from your computer. Under normal usage, start `opencode serve` yourself before launching the bot.
+When the current project is a git repository, `/worktree` shows the existing worktrees for that repository. Status and pinned updates display the main project path with the active branch, and show a separate `Worktree` line when a linked worktree is selected.
 
 ## Scheduled Tasks
 
@@ -132,6 +154,8 @@ Scheduled tasks let you prepare prompts in advance and run them automatically la
 - Scheduled executions currently always run with the `build` agent
 - Tasks run outside your active chat session, so they do not interrupt or affect the current session flow
 - The minimum recurring interval is 5 minutes
+- If a recurring task is still running when its next interval arrives, the bot does not start a parallel copy of the same task and does not replay missed intervals later
+- By default, the bot waits up to 120 minutes for one scheduled task run; change this with `SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES` if needed
 - Up to 10 scheduled tasks can exist at once by default; change this with `TASK_LIMIT` in your `.env`
 
 ## Configuration
@@ -150,39 +174,42 @@ When installed via npm, the configuration wizard handles the initial setup. The
 - **Windows:** `%APPDATA%\opencode-telegram-bot\.env`
 - **Linux:** `~/.config/opencode-telegram-bot/.env`
 
-| Variable                        | Description                                                                                                  | Required | Default                  |
-| ------------------------------- | ------------------------------------------------------------------------------------------------------------ | :------: | ------------------------ |
-| `TELEGRAM_BOT_TOKEN`            | Bot token from @BotFather                                                                                    |   Yes    | —                        |
-| `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_SERVER_USERNAME`      | Server auth username                                                                                         |    No    | `opencode`               |
-| `OPENCODE_SERVER_PASSWORD`      | Server auth password                                                                                         |    No    | —                        |
-| `OPENCODE_MODEL_PROVIDER`       | Default model provider                                                                                       |   Yes    | `opencode`               |
-| `OPENCODE_MODEL_ID`             | Default model ID                                                                                             |   Yes    | `big-pickle`             |
-| `BOT_LOCALE`                    | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`)                             |    No    | `en`                     |
-| `SESSIONS_LIST_LIMIT`           | Sessions per page in `/sessions`                                                                             |    No    | `10`                     |
-| `PROJECTS_LIST_LIMIT`           | Projects per page in `/projects`                                                                             |    No    | `10`                     |
-| `OPEN_BROWSER_ROOTS`            | Comma-separated paths `/open` is allowed to browse (supports `~`)                                            |    No    | `~` (home directory)     |
-| `COMMANDS_LIST_LIMIT`           | Commands per page in `/commands`                                                                             |    No    | `10`                     |
-| `TASK_LIMIT`                    | Maximum number of scheduled tasks that can exist at once                                                     |    No    | `10`                     |
-| `BASH_TOOL_DISPLAY_MAX_LENGTH`  | Maximum displayed length for `bash` tool commands in Telegram summaries; longer commands are truncated       |    No    | `128`                    |
-| `SERVICE_MESSAGES_INTERVAL_SEC` | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate |    No    | `5`                      |
-| `HIDE_THINKING_MESSAGES`        | Hide `💭 Thinking...` service messages                                                                       |    No    | `false`                  |
-| `HIDE_TOOL_CALL_MESSAGES`       | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                         |    No    | `false`                  |
-| `RESPONSE_STREAMING`            | Stream assistant replies while they are generated across one or more Telegram messages                       |    No    | `true`                   |
-| `MESSAGE_FORMAT_MODE`           | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`                                   |    No    | `markdown`               |
-| `CODE_FILE_MAX_SIZE_KB`         | Max file size (KB) to send as document                                                                       |    No    | `100`                    |
-| `STT_API_URL`                   | Whisper-compatible API base URL (enables voice/audio transcription)                                          |    No    | —                        |
-| `STT_API_KEY`                   | API key for your STT provider                                                                                |    No    | —                        |
-| `STT_MODEL`                     | STT model name passed to `/audio/transcriptions`                                                             |    No    | `whisper-large-v3-turbo` |
-| `STT_LANGUAGE`                  | Optional language hint (empty = provider auto-detect)                                                        |    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`                  |
-| `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`                     |
+| Variable                                   | Description                                                                                                           | Required | Default                  |
+| ------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- | :------: | ------------------------ |
+| `TELEGRAM_BOT_TOKEN`                       | Bot token from @BotFather                                                                                             |   Yes    | —                        |
+| `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_SERVER_USERNAME`                 | Server auth username                                                                                                  |    No    | `opencode`               |
+| `OPENCODE_SERVER_PASSWORD`                 | Server auth password                                                                                                  |    No    | —                        |
+| `OPENCODE_MODEL_PROVIDER`                  | Default model provider                                                                                                |   Yes    | `opencode`               |
+| `OPENCODE_MODEL_ID`                        | Default model ID                                                                                                      |   Yes    | `big-pickle`             |
+| `BOT_LOCALE`                               | Bot UI language (supported locale code, e.g. `en`, `de`, `es`, `fr`, `ru`, `zh`)                                      |    No    | `en`                     |
+| `SESSIONS_LIST_LIMIT`                      | Sessions per page in `/sessions`                                                                                      |    No    | `10`                     |
+| `PROJECTS_LIST_LIMIT`                      | Projects per page in `/projects`                                                                                      |    No    | `10`                     |
+| `OPEN_BROWSER_ROOTS`                       | Comma-separated paths `/open` is allowed to browse (supports `~`)                                                     |    No    | `~` (home directory)     |
+| `COMMANDS_LIST_LIMIT`                      | Items per page in `/commands` and `/skills`                                                                           |    No    | `10`                     |
+| `TASK_LIMIT`                               | Maximum number of scheduled tasks that can exist at once                                                              |    No    | `10`                     |
+| `SCHEDULED_TASK_EXECUTION_TIMEOUT_MINUTES` | Maximum time the bot waits for one scheduled task run before marking it failed                                        |    No    | `120`                    |
+| `BASH_TOOL_DISPLAY_MAX_LENGTH`             | Maximum displayed length for `bash` tool commands in Telegram summaries; longer commands are truncated                |    No    | `128`                    |
+| `SERVICE_MESSAGES_INTERVAL_SEC`            | Service messages interval (thinking + tool calls); keep `>=2` to avoid Telegram rate limits, `0` = immediate          |    No    | `5`                      |
+| `HIDE_THINKING_MESSAGES`                   | Hide `💭 Thinking...` service messages                                                                                |    No    | `false`                  |
+| `HIDE_TOOL_CALL_MESSAGES`                  | Hide tool-call service messages (`💻 bash ...`, `📖 read ...`, etc.)                                                  |    No    | `false`                  |
+| `HIDE_TOOL_FILE_MESSAGES`                  | Hide file edit documents sent as `.txt` attachments (`edit_*.txt`, `write_*.txt`)                                     |    No    | `false`                  |
+| `RESPONSE_STREAMING`                       | Stream assistant replies while they are generated across one or more Telegram messages                                |    No    | `true`                   |
+| `MESSAGE_FORMAT_MODE`                      | Assistant reply formatting mode: `markdown` (Telegram MarkdownV2) or `raw`                                            |    No    | `markdown`               |
+| `CODE_FILE_MAX_SIZE_KB`                    | Max file size (KB) to send as document                                                                                |    No    | `100`                    |
+| `STT_API_URL`                              | Whisper-compatible API base URL (enables voice/audio transcription)                                                   |    No    | —                        |
+| `STT_API_KEY`                              | API key for your STT provider                                                                                         |    No    | —                        |
+| `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`                  |
+| `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`                     |
 
 > **Keep your `.env` file private.** It contains your bot token. Never commit it to version control.
 
@@ -197,6 +224,8 @@ If `STT_API_URL` and `STT_API_KEY` are set, the bot will:
 3. Show recognized text in chat
 4. Send the recognized text to OpenCode as a normal prompt
 
+If `STT_NOTE_PROMPT` is set to a non-empty value other than `false` or `0`, the bot prepends `[Note: ...]` to the transcription before sending it to the LLM. The recognized text shown in Telegram stays unchanged.
+
 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:
@@ -281,8 +310,9 @@ npm run dev
 
 **"OpenCode server is not available"**
 
-- Ensure `opencode serve` is running in your project directory
-- Check that `OPENCODE_API_URL` points to the correct address (default: `http://localhost:4096`)
+- 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
+- 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

@@ -1,14 +1,17 @@
+import fs from "node:fs/promises";
 import { readFile } from "node:fs/promises";
-import { createBot } from "../bot/index.js";
+import { cleanupBotRuntime, createBot } from "../bot/index.js";
 import { config } from "../config.js";
 import { loadSettings } from "../settings/manager.js";
-import { processManager } from "../process/manager.js";
 import { scheduledTaskRuntime } from "../scheduled-task/runtime.js";
 import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
 import { reconcileStoredModelSelection } from "../model/manager.js";
 import { getRuntimeMode } from "../runtime/mode.js";
 import { getRuntimePaths } from "../runtime/paths.js";
+import { clearServiceStateFile } from "../service/manager.js";
+import { getServiceStateFilePathFromEnv, isServiceChildProcess } from "../service/runtime.js";
 import { getLogFilePath, initializeLogger, logger } from "../utils/logger.js";
+const SHUTDOWN_TIMEOUT_MS = 5000;
 async function getBotVersion() {
     try {
         const packageJsonPath = new URL("../../package.json", import.meta.url);
@@ -35,20 +38,85 @@ export async function startBotApp() {
     logger.info(`Allowed User ID: ${config.telegram.allowedUserId}`);
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
-    await processManager.initialize();
     await reconcileStoredModelSelection();
     await warmupSessionDirectoryCache();
     const bot = createBot();
     await scheduledTaskRuntime.initialize(bot);
+    let shutdownStarted = false;
+    let serviceStateCleared = false;
+    let shutdownTimeout = null;
+    const clearManagedServiceState = async () => {
+        if (!isServiceChildProcess() || serviceStateCleared) {
+            return;
+        }
+        const stateFilePath = getServiceStateFilePathFromEnv();
+        if (!stateFilePath) {
+            return;
+        }
+        try {
+            await fs.access(stateFilePath);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                serviceStateCleared = true;
+                return;
+            }
+            throw error;
+        }
+        await clearServiceStateFile(stateFilePath);
+        serviceStateCleared = true;
+    };
+    const shutdown = (signal) => {
+        if (shutdownStarted) {
+            return;
+        }
+        shutdownStarted = true;
+        logger.info(`[App] Received ${signal}, shutting down...`);
+        cleanupBotRuntime(`app_shutdown_${signal.toLowerCase()}`);
+        scheduledTaskRuntime.shutdown();
+        shutdownTimeout = setTimeout(() => {
+            logger.warn(`[App] Shutdown did not finish in ${SHUTDOWN_TIMEOUT_MS}ms, forcing exit.`);
+            process.exit(0);
+        }, SHUTDOWN_TIMEOUT_MS);
+        shutdownTimeout.unref?.();
+        try {
+            bot.stop();
+        }
+        catch (error) {
+            logger.warn("[App] Failed to stop Telegram bot cleanly", error);
+        }
+        void clearManagedServiceState().catch((error) => {
+            logger.warn("[App] Failed to clear managed service state", error);
+        });
+    };
+    const handleSigint = () => shutdown("SIGINT");
+    const handleSigterm = () => shutdown("SIGTERM");
+    process.on("SIGINT", handleSigint);
+    process.on("SIGTERM", handleSigterm);
     const webhookInfo = await bot.api.getWebhookInfo();
     if (webhookInfo.url) {
         logger.info(`[Bot] Webhook detected: ${webhookInfo.url}, removing...`);
         await bot.api.deleteWebhook();
         logger.info("[Bot] Webhook removed, switching to long polling");
     }
-    await bot.start({
-        onStart: (botInfo) => {
-            logger.info(`Bot @${botInfo.username} started!`);
-        },
-    });
+    try {
+        await bot.start({
+            onStart: (botInfo) => {
+                logger.info(`Bot @${botInfo.username} started!`);
+            },
+        });
+    }
+    finally {
+        process.off("SIGINT", handleSigint);
+        process.off("SIGTERM", handleSigterm);
+        if (shutdownTimeout) {
+            clearTimeout(shutdownTimeout);
+            shutdownTimeout = null;
+        }
+        cleanupBotRuntime("app_shutdown_complete");
+        scheduledTaskRuntime.shutdown();
+        await clearManagedServiceState().catch((error) => {
+            logger.warn("[App] Failed to clear managed service state", error);
+        });
+    }
 }

package/dist/bot/commands/definitions.js

@@ -10,10 +10,12 @@ const COMMAND_DEFINITIONS = [
     { command: "sessions", descriptionKey: "cmd.description.sessions" },
     { command: "tts", descriptionKey: "cmd.description.tts" },
     { command: "projects", descriptionKey: "cmd.description.projects" },
+    { command: "worktree", descriptionKey: "cmd.description.worktree" },
     { command: "task", descriptionKey: "cmd.description.task" },
     { command: "tasklist", descriptionKey: "cmd.description.tasklist" },
     { command: "rename", descriptionKey: "cmd.description.rename" },
     { command: "commands", descriptionKey: "cmd.description.commands" },
+    { command: "skills", descriptionKey: "cmd.description.skills" },
     { 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/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);