@grinev/opencode-telegram-bot 0.1.0-rc.7 → 0.1.0

package/.env.example

@@ -1,7 +1,7 @@
 # Telegram Bot Token (from @BotFather)
 TELEGRAM_BOT_TOKEN=
 
-# Allowed Telegram User ID (fron @userinfobot)
+# Allowed Telegram User ID (from @userinfobot)
 TELEGRAM_ALLOWED_USER_ID=
 
 # OpenCode API URL (optional, default: http://localhost:4096)
@@ -28,6 +28,8 @@ OPENCODE_MODEL_ID=big-pickle
 # Bot Configuration (optional)
 # Maximum number of sessions shown in /sessions (default: 10)
 # SESSIONS_LIST_LIMIT=10
+# Bot locale: en or ru (default: en)
+# BOT_LOCALE=en
 
 # Code File Settings (optional)
 # Maximum file size in KB to send as document (default: 100)

package/README.md

@@ -1,72 +1,205 @@
-# OpenCode Telegram Client
+# OpenCode Telegram Bot
 
-Мобильный клиент для OpenCode в Telegram, позволяющий управлять задачами разработки на локальном компьютере.
+[![npm version](https://img.shields.io/npm/v/@grinev/opencode-telegram-bot)](https://www.npmjs.com/package/@grinev/opencode-telegram-bot)
+[![CI](https://github.com/grinev/opencode-telegram-bot/actions/workflows/ci.yml/badge.svg)](https://github.com/grinev/opencode-telegram-bot/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
 
-## Требования
+Control your [OpenCode](https://opencode.ai) coding agent from your phone. Send tasks, switch models, monitor progress — all through Telegram.
 
-- Node.js 20+
-- Установленный OpenCode CLI (`opencode`)
+No open ports, no exposed APIs. The bot runs on your machine alongside OpenCode and communicates exclusively through the Telegram Bot API.
 
-## Установка
+<p align="center">
+  <img src="assets/Screenshot-1.png" width="32%" alt="Sending a coding task and receiving file edit results" />
+  <img src="assets/Screenshot-2.png" width="32%" alt="Live session status with context usage and changed files" />
+  <img src="assets/Screenshot-3.png" width="32%" alt="Switching between AI models from favorites" />
+</p>
 
-1. Клонируйте репозиторий.
-2. Установите зависимости:
-   ```bash
-   npm install
-   ```
-3. Скопируйте файл с переменными окружения:
-   ```bash
-   cp .env.example .env
-   ```
-4. Заполните `.env` файл (токен бота, ваш ID и путь к проекту).
-5. Настройте избранные модели в OpenCode (Desktop/TUI). Бот автоматически читает их из локального state файла OpenCode (`model.json`).
-6. Если избранные модели недоступны или файл не читается, бот использует fallback из `.env`:
-   - `OPENCODE_MODEL_PROVIDER`
-   - `OPENCODE_MODEL_ID`
+## Features
 
-## Переменные окружения
+- **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
+- **Model switching** — pick any model from your OpenCode favorites directly in the chat
+- **Agent modes** — switch between Plan and Build modes on the fly
+- **Interactive Q&A** — answer agent questions and approve permissions via inline buttons
+- **Context control** — compact context when it gets too large, right from the chat
+- **Security** — strict user ID whitelist; no one else can access your bot, even if they find it
+- **Localization** — English and Russian UI (`BOT_LOCALE=en|ru`)
 
-Основные переменные в `.env`:
+## Prerequisites
 
-- `TELEGRAM_BOT_TOKEN` — токен бота (обязательно).
-- `TELEGRAM_ALLOWED_USER_ID` — ваш Telegram user ID (обязательно).
-- `OPENCODE_MODEL_PROVIDER` — провайдер модели по умолчанию (обязательно).
-- `OPENCODE_MODEL_ID` — ID модели по умолчанию (обязательно).
-- `SESSIONS_LIST_LIMIT` — сколько последних сессий показывать в `/sessions` (опционально, по умолчанию `10`).
+- **Node.js 20+** — [download](https://nodejs.org)
+- **OpenCode** — install from [opencode.ai](https://opencode.ai) or [GitHub](https://github.com/sst/opencode)
+- **Telegram Bot** — you'll create one during setup (takes 1 minute)
 
-## Сборка и запуск
+## Quick Start
 
-### Режим разработки
+### 1. Create a Telegram Bot
 
-Запуск без автоматической перезагрузки процесса:
+1. Open [@BotFather](https://t.me/BotFather) in Telegram and send `/newbot`
+2. Follow the prompts to choose a name and username
+3. Copy the **bot token** you receive (e.g. `123456:ABC-DEF1234...`)
 
-> В этом проекте auto-restart (watch/restart) намеренно не используется для runtime-бота,
-> чтобы не ломать активные SSE/polling соединения.
+You'll also need your **Telegram User ID** — send any message to [@userinfobot](https://t.me/userinfobot) and it will reply with your numeric ID.
+
+### 2. Start OpenCode Server
+
+In your project directory, start the OpenCode server:
+
+```bash
+opencode serve
+```
+
+> The bot connects to the OpenCode API at `http://localhost:4096` by default.
+
+### 3. Install & Run
+
+The fastest way — run directly with `npx`:
+
+```bash
+npx @grinev/opencode-telegram-bot
+```
+
+On first launch, an interactive wizard will guide you through the configuration — it will ask for your bot token, user ID, and OpenCode API URL. After that, you're ready to go. Open your bot in Telegram and start sending tasks.
+
+#### Alternative: Global Install
+
+```bash
+npm install -g @grinev/opencode-telegram-bot
+opencode-telegram start
+```
+
+To reconfigure at any time:
+
+```bash
+opencode-telegram config
+```
+
+## Supported Platforms
+
+| Platform | Status                                                                                                                               |
+| -------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| macOS    | Fully supported                                                                                                                      |
+| Windows  | Fully supported                                                                                                                      |
+| Linux    | Experimental — should work, but has not been extensively tested. You may need additional steps such as granting execute permissions. |
+
+## Bot Commands
+
+| Command           | Description                                             |
+| ----------------- | ------------------------------------------------------- |
+| `/status`         | Server health, current project, session, and model info |
+| `/new`            | Create a new session                                    |
+| `/stop`           | Abort the current task                                  |
+| `/sessions`       | Browse and switch between recent sessions               |
+| `/projects`       | Switch between OpenCode projects                        |
+| `/model`          | Choose a model from your favorites                      |
+| `/agent`          | Switch agent mode (Plan / Build)                        |
+| `/opencode_start` | Start the OpenCode server remotely                      |
+| `/opencode_stop`  | Stop the OpenCode server remotely                       |
+| `/help`           | Show available commands                                 |
+
+Any regular text message is sent as a prompt to the coding agent.
+
+> `/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.
+
+## Configuration
+
+### Environment Variables
+
+When installed via npm, the configuration wizard handles the initial setup. The `.env` file is stored in your platform's app data directory:
+
+- **macOS:** `~/Library/Application Support/opencode-telegram-bot/.env`
+- **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    | —                       |
+| `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 (`en` or `ru`)               |    No    | `en`                    |
+| `SESSIONS_LIST_LIMIT`      | Max sessions shown in `/sessions`            |    No    | `10`                    |
+| `CODE_FILE_MAX_SIZE_KB`    | Max file size (KB) to send as document       |    No    | `100`                   |
+| `LOG_LEVEL`                | Log level (`debug`, `info`, `warn`, `error`) |    No    | `info`                  |
+
+> **Keep your `.env` file private.** It contains your bot token. Never commit it to version control.
+
+### Model Configuration
+
+The bot picks up your **favorite models** from OpenCode. To add a model to favorites:
+
+1. Open OpenCode TUI (`opencode`)
+2. Go to model selection
+3. Hover over the model you want and press **Ctrl+F** to add it to favorites
+
+These favorites will appear in the `/model` command menu in Telegram.
+
+A free model (`opencode/big-pickle`) is configured as the default fallback — if you haven't set up any favorites yet, the bot will use it automatically.
+
+## Security
+
+The bot enforces a strict **user ID whitelist**. Only the Telegram user whose numeric ID matches `TELEGRAM_ALLOWED_USER_ID` can interact with the bot. Messages from any other user are silently ignored and logged as unauthorized access attempts.
+
+Since the bot runs locally on your machine and connects to your local OpenCode server, there is no external attack surface beyond the Telegram Bot API itself.
+
+## Development
+
+### Running from Source
+
+```bash
+git clone https://github.com/grinev/opencode-telegram-bot.git
+cd opencode-telegram-bot
+npm install
+cp .env.example .env
+# Edit .env with your bot token, user ID, and model settings
+```
+
+Build and run:
 
 ```bash
 npm run dev
 ```
 
-### Продакшн
+### Available Scripts
+
+| Script                  | Description                         |
+| ----------------------- | ----------------------------------- |
+| `npm run dev`           | Build and start (development)       |
+| `npm run build`         | Compile TypeScript                  |
+| `npm start`             | Run compiled code                   |
+| `npm run lint`          | ESLint check (zero warnings policy) |
+| `npm run format`        | Format code with Prettier           |
+| `npm test`              | Run tests (Vitest)                  |
+| `npm run test:coverage` | Tests with coverage report          |
+
+> **Note:** No file watcher or auto-restart is used. The bot maintains persistent SSE and long-polling connections — automatic restarts would break them mid-task. After making changes, restart manually with `npm run dev`.
+
+## Troubleshooting
+
+**Bot doesn't respond to messages**
+
+- Make sure `TELEGRAM_ALLOWED_USER_ID` matches your actual Telegram user ID (check with [@userinfobot](https://t.me/userinfobot))
+- Verify the bot token is correct
+
+**"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`)
+
+**No models in `/model` menu**
 
-1. Соберите проект:
-   ```bash
-   npm run build
-   ```
-2. Запустите собранный код:
-   ```bash
-   npm start
-   ```
+- Add models to your OpenCode favorites: open OpenCode TUI, go to model selection, press **Ctrl+F** on desired models
 
-## Команды
+**Linux: permission denied errors**
 
-- `npm run lint` — проверка кода линтером.
-- `npm run format` — форматирование кода через Prettier.
-- `npm run test` — запуск тестов через Vitest.
-- `npm run test:coverage` — запуск тестов с coverage-отчётом.
+- Make sure the CLI binary has execute permission: `chmod +x $(which opencode-telegram)`
+- Check that the config directory is writable: `~/.config/opencode-telegram-bot/`
 
-## Функционал
+## License
 
-Подробное описание функционала и плана разработки находится в [PRODUCT.md](./PRODUCT.md).
-План технических улучшений (архитектура + тесты) — в [TECHNICAL_IMPROVEMENTS.md](./TECHNICAL_IMPROVEMENTS.md).
-Инструкции для разработчиков и описание архитектуры — в [AGENTS.md](./AGENTS.md).
+[MIT](LICENSE) © Ruslan Grinev

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

@@ -1,12 +1,26 @@
+import { readFile } from "node:fs/promises";
 import { createBot } from "../bot/index.js";
 import { config } from "../config.js";
 import { loadSettings } from "../settings/manager.js";
 import { processManager } from "../process/manager.js";
 import { getRuntimeMode } from "../runtime/mode.js";
 import { logger } from "../utils/logger.js";
+async function getBotVersion() {
+    try {
+        const packageJsonPath = new URL("../../package.json", import.meta.url);
+        const packageJsonContent = await readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(packageJsonContent);
+        return packageJson.version ?? "unknown";
+    }
+    catch (error) {
+        logger.warn("[App] Failed to read bot version", error);
+        return "unknown";
+    }
+}
 export async function startBotApp() {
     const mode = getRuntimeMode();
-    logger.info("Starting OpenCode Telegram Client...");
+    const version = await getBotVersion();
+    logger.info(`Starting OpenCode Telegram Bot v${version}...`);
     logger.info(`Allowed User ID: ${config.telegram.allowedUserId}`);
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();

package/dist/bot/commands/agent.js

@@ -1,5 +1,6 @@
 import { showAgentSelectionMenu } from "../handlers/agent.js";
 import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 /**
  * Handler for /agent command
  * Shows inline menu to select agent mode
@@ -11,6 +12,6 @@ export async function handleAgentCommand(ctx) {
     }
     catch (err) {
         logger.error("[AgentCommand] Error showing agent menu:", err);
-        await ctx.reply("❌ Ошибка при загрузке списка агентов");
+        await ctx.reply(t("error.load_agents"));
     }
 }

package/dist/bot/commands/definitions.js

@@ -1,20 +1,21 @@
-/**
- * Centralized bot commands definitions
- * Used for both Telegram API setMyCommands and command handler registration
- */
+import { t } from "../../i18n/index.js";
 /**
  * List of all bot commands
  * Update this array when adding new commands
  */
-export const BOT_COMMANDS = [
-    { command: "status", description: "Статус сервера и сессии" },
-    { command: "new", description: "Создать новую сессию" },
-    { command: "stop", description: "Прервать текущее действие" },
-    { command: "sessions", description: "Список сессий" },
-    { command: "projects", description: "Список проектов" },
-    { command: "model", description: "Выбрать модель" },
-    { command: "agent", description: "Выбрать режим работы" },
-    { command: "opencode_start", description: "Запустить OpenCode сервер" },
-    { command: "opencode_stop", description: "Остановить OpenCode сервер" },
-    { command: "help", description: "Справка" },
+const COMMAND_DEFINITIONS = [
+    { command: "status", descriptionKey: "cmd.description.status" },
+    { command: "new", descriptionKey: "cmd.description.new" },
+    { command: "stop", descriptionKey: "cmd.description.stop" },
+    { command: "sessions", descriptionKey: "cmd.description.sessions" },
+    { command: "projects", descriptionKey: "cmd.description.projects" },
+    { command: "model", descriptionKey: "cmd.description.model" },
+    { command: "agent", descriptionKey: "cmd.description.agent" },
+    { command: "opencode_start", descriptionKey: "cmd.description.opencode_start" },
+    { command: "opencode_stop", descriptionKey: "cmd.description.opencode_stop" },
+    { command: "help", descriptionKey: "cmd.description.help" },
 ];
+export const BOT_COMMANDS = COMMAND_DEFINITIONS.map(({ command, descriptionKey }) => ({
+    command,
+    description: t(descriptionKey),
+}));

package/dist/bot/commands/help.js

@@ -1,7 +1,4 @@
+import { t } from "../../i18n/index.js";
 export async function helpCommand(ctx) {
-    await ctx.reply("📖 **Справка**\n\n" +
-        "/status - Проверить статус сервера\n" +
-        "/sessions - Список сессий\n" +
-        "/new - Создать новую сессию\n" +
-        "/help - Справка", { parse_mode: "Markdown" });
+    await ctx.reply(t("help.text"), { parse_mode: "Markdown" });
 }

package/dist/bot/commands/model.js

@@ -1,5 +1,6 @@
 import { showModelSelectionMenu } from "../handlers/model.js";
 import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 /**
  * Handler for /model command
  * Shows inline menu to select model from favorites
@@ -11,6 +12,6 @@ export async function handleModelCommand(ctx) {
     }
     catch (err) {
         logger.error("[ModelCommand] Error showing model menu:", err);
-        await ctx.reply("❌ Ошибка при загрузке списка моделей");
+        await ctx.reply(t("error.load_models"));
     }
 }

package/dist/bot/commands/models.js

@@ -1,23 +1,24 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 export async function modelsCommand(ctx) {
     try {
         const { data: providersData, error } = await opencodeClient.config.providers();
         if (error || !providersData) {
-            await ctx.reply("🔴 Не удалось получить список моделей. Проверьте статус сервера /status.");
+            await ctx.reply(t("legacy.models.fetch_error"));
             return;
         }
         const providers = providersData.providers;
         if (!providers || providers.length === 0) {
-            await ctx.reply("📋 Нет доступных моделей. Настройте провайдеры через OpenCode.");
+            await ctx.reply(t("legacy.models.empty"));
             return;
         }
-        let message = "📋 **Доступные модели:**\n\n";
+        let message = t("legacy.models.header");
         for (const provider of providers) {
             message += `🔹 **\`${provider.id}\`**\n`;
             const models = Object.values(provider.models);
             if (models.length === 0) {
-                message += "  ⚠️ Нет доступных моделей\n";
+                message += t("legacy.models.no_provider_models");
             }
             else {
                 for (const model of models) {
@@ -26,12 +27,12 @@ export async function modelsCommand(ctx) {
             }
             message += "\n";
         }
-        message += "💡 Для использования модели в .env:\n";
+        message += t("legacy.models.env_hint");
         message += "```\nOPENCODE_MODEL_PROVIDER=<provider.id>\nOPENCODE_MODEL_ID=<model.id>\n```";
         await ctx.reply(message, { parse_mode: "Markdown" });
     }
     catch (error) {
         logger.error("[ModelsCommand] Error listing models:", error);
-        await ctx.reply("🔴 Произошла ошибка при получении списка моделей.");
+        await ctx.reply(t("legacy.models.error"));
     }
 }

package/dist/bot/commands/new.js

@@ -8,11 +8,12 @@ import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { createMainKeyboard } from "../utils/keyboard.js";
 import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 export async function newCommand(ctx) {
     try {
         const currentProject = getCurrentProject();
         if (!currentProject) {
-            await ctx.reply("🏗 Проект не выбран.\n\nСначала выберите проект командой /projects.");
+            await ctx.reply(t("new.project_not_selected"));
             return;
         }
         logger.debug("[Bot] Creating new session for directory:", currentProject.worktree);
@@ -47,12 +48,12 @@ export async function newCommand(ctx) {
         const contextInfo = pinnedMessageManager.getContextInfo();
         const variantName = formatVariantForButton(currentModel.variant || "default");
         const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
-        await ctx.reply(`✅ Создана новая сессия: ${session.title}`, {
+        await ctx.reply(t("new.created", { title: session.title }), {
             reply_markup: keyboard,
         });
     }
     catch (error) {
         logger.error("[Bot] Error creating session:", error);
-        await ctx.reply("🔴 OpenCode Server недоступен или произошла ошибка при создании сессии.");
+        await ctx.reply(t("new.create_error"));
     }
 }

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

@@ -1,6 +1,7 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { processManager } from "../../process/manager.js";
 import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 /**
  * Wait for OpenCode server to become ready by polling health endpoint
  * @param maxWaitMs Maximum time to wait in milliseconds
@@ -33,18 +34,19 @@ export async function opencodeStartCommand(ctx) {
         if (processManager.isRunning()) {
             const uptime = processManager.getUptime();
             const uptimeStr = uptime ? Math.floor(uptime / 1000) : 0;
-            await ctx.reply(`⚠️ OpenCode Server уже запущен\n\n` +
-                `PID: ${processManager.getPID()}\n` +
-                `Uptime: ${uptimeStr} секунд`);
+            await ctx.reply(t("opencode_start.already_running_managed", {
+                pid: processManager.getPID() ?? "-",
+                seconds: uptimeStr,
+            }));
             return;
         }
         // 2. Check if server is accessible (external process)
         try {
             const { data, error } = await opencodeClient.global.health();
             if (!error && data?.healthy) {
-                await ctx.reply(`✅ OpenCode Server уже запущен внешним процессом\n\n` +
-                    `Версия: ${data.version || "неизвестна"}\n\n` +
-                    `Этот сервер не был запущен через бота, поэтому команда /opencode-stop не сможет его остановить.`);
+                await ctx.reply(t("opencode_start.already_running_external", {
+                    version: data.version || t("common.unknown"),
+                }));
                 return;
             }
         }
@@ -52,36 +54,32 @@ export async function opencodeStartCommand(ctx) {
             // Server not accessible, continue with start
         }
         // 3. Notify user that we're starting the server
-        const statusMessage = await ctx.reply("🔄 Запускаю OpenCode Server...");
+        const statusMessage = await ctx.reply(t("opencode_start.starting"));
         // 4. Start the process
         const { success, error } = await processManager.start();
         if (!success) {
-            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, `🔴 Не удалось запустить OpenCode Server\n\n` +
-                `Ошибка: ${error || "неизвестная ошибка"}\n\n` +
-                `Проверьте, что OpenCode CLI установлен и доступен в PATH:\n` +
-                `\`opencode --version\`\n` +
-                `\`npm install -g @opencode-ai/cli\``, { parse_mode: "Markdown" });
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_start.start_error", { error: error || t("common.unknown_error") }), { parse_mode: "Markdown" });
             return;
         }
         // 5. Wait for server to become ready
         logger.info("[Bot] Waiting for OpenCode server to become ready...");
         const ready = await waitForServerReady(10000);
         if (!ready) {
-            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, `⚠️ OpenCode Server запущен, но не отвечает\n\n` +
-                `PID: ${processManager.getPID()}\n\n` +
-                `Сервер может запускаться. Попробуйте /status через несколько секунд.`);
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_start.started_not_ready", {
+                pid: processManager.getPID() ?? "-",
+            }));
             return;
         }
         // 6. Get server version and send success message
         const { data: health } = await opencodeClient.global.health();
-        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, `✅ OpenCode Server успешно запущен\n\n` +
-            `PID: ${processManager.getPID()}\n` +
-            `Версия: ${health?.version || "неизвестна"}`);
+        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_start.success", {
+            pid: processManager.getPID() ?? "-",
+            version: health?.version || t("common.unknown"),
+        }));
         logger.info(`[Bot] OpenCode server started successfully, PID=${processManager.getPID()}`);
     }
     catch (err) {
         logger.error("[Bot] Error in /opencode-start command:", err);
-        await ctx.reply("🔴 Произошла ошибка при запуске сервера.\n\n" +
-            "Проверьте логи приложения для подробностей.");
+        await ctx.reply(t("opencode_start.error"));
     }
 }

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

@@ -1,6 +1,7 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { processManager } from "../../process/manager.js";
 import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 /**
  * Command handler for /opencode-stop
  * Stops the OpenCode server process
@@ -13,34 +14,31 @@ export async function opencodeStopCommand(ctx) {
             try {
                 const { data, error } = await opencodeClient.global.health();
                 if (!error && data?.healthy) {
-                    await ctx.reply(`⚠️ OpenCode Server запущен внешним процессом\n\n` +
-                        `Этот сервер не был запущен через /opencode-start.\n` +
-                        `Остановите его вручную или используйте /status для проверки состояния.`);
+                    await ctx.reply(t("opencode_stop.external_running"));
                     return;
                 }
             }
             catch {
                 // Server not accessible
             }
-            await ctx.reply("⚠️ OpenCode Server не запущен");
+            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(`🛑 Останавливаю OpenCode Server...\n\nPID: ${pid}`);
+        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, `🔴 Не удалось остановить OpenCode Server\n\n` + `Ошибка: ${error || "неизвестная ошибка"}`);
+            await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_stop.stop_error", { error: error || t("common.unknown_error") }));
             return;
         }
         // 4. Success - process has been stopped
-        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, `✅ OpenCode Server успешно остановлен`);
+        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, t("opencode_stop.success"));
         logger.info("[Bot] OpenCode server stopped successfully");
     }
     catch (err) {
         logger.error("[Bot] Error in /opencode-stop command:", err);
-        await ctx.reply("🔴 Произошла ошибка при остановке сервера.\n\n" +
-            "Проверьте логи приложения для подробностей.");
+        await ctx.reply(t("opencode_stop.error"));
     }
 }

package/dist/bot/commands/projects.js

@@ -10,6 +10,7 @@ import { getStoredModel } from "../../model/manager.js";
 import { formatVariantForButton } from "../../variant/manager.js";
 import { createMainKeyboard } from "../utils/keyboard.js";
 import { logger } from "../../utils/logger.js";
+import { t } from "../../i18n/index.js";
 const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
 function formatProjectButtonLabel(label, isActive) {
     const prefix = isActive ? "✅ " : "";
@@ -23,7 +24,7 @@ export async function projectsCommand(ctx) {
     try {
         const projects = await getProjects();
         if (projects.length === 0) {
-            await ctx.reply("📭 Проектов нет.");
+            await ctx.reply(t("projects.empty"));
             return;
         }
         const keyboard = new InlineKeyboard();
@@ -39,15 +40,17 @@ export async function projectsCommand(ctx) {
         });
         if (currentProject) {
             const projectName = currentProject.name || currentProject.worktree;
-            await ctx.reply(`Выберите проект:\n\nТекущий: 🏗 ${projectName}`, { reply_markup: keyboard });
+            await ctx.reply(t("projects.select_with_current", { project: projectName }), {
+                reply_markup: keyboard,
+            });
         }
         else {
-            await ctx.reply("Выберите проект:", { reply_markup: keyboard });
+            await ctx.reply(t("projects.select"), { reply_markup: keyboard });
         }
     }
     catch (error) {
         logger.error("[Bot] Error fetching projects:", error);
-        await ctx.reply("🔴 OpenCode Server недоступен или произошла ошибка при получении списка проектов.");
+        await ctx.reply(t("projects.fetch_error"));
     }
 }
 export async function handleProjectSelect(ctx) {
@@ -90,7 +93,7 @@ export async function handleProjectSelect(ctx) {
         const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo, variantName);
         const projectName = selectedProject.name || selectedProject.worktree;
         await ctx.answerCallbackQuery();
-        await ctx.reply(`✅ Проект выбран: ${projectName}\n\n📋 Сессия сброшена. Используйте /sessions или /new для работы с этим проектом.`, {
+        await ctx.reply(t("projects.selected", { project: projectName }), {
             reply_markup: keyboard,
         });
         await ctx.deleteMessage();
@@ -98,7 +101,7 @@ export async function handleProjectSelect(ctx) {
     catch (error) {
         logger.error("[Bot] Error selecting project:", error);
         await ctx.answerCallbackQuery();
-        await ctx.reply("🔴 Ошибка при выборе проекта.");
+        await ctx.reply(t("projects.select_error"));
     }
     return true;
 }