@grinev/opencode-telegram-bot 0.1.0-rc.1

package/.env.example

@@ -0,0 +1,34 @@
+# Telegram Bot Token (from @BotFather)
+TELEGRAM_BOT_TOKEN=
+
+# Allowed Telegram User ID (fron @userinfobot)
+TELEGRAM_ALLOWED_USER_ID=
+
+# OpenCode API URL (optional, default: http://localhost:4096)
+# OPENCODE_API_URL=http://localhost:4096
+
+# OpenCode Server Authentication (optional)
+# OPENCODE_SERVER_USERNAME=opencode
+# OPENCODE_SERVER_PASSWORD=
+
+# OpenCode Model Configuration (REQUIRED)
+# You must specify a default model provider and model ID
+# Examples:
+#   Anthropic Claude 3.5 Sonnet: OPENCODE_MODEL_PROVIDER=anthropic, OPENCODE_MODEL_ID=claude-3-5-sonnet-20241022
+#   OpenAI GPT-4 Turbo: OPENCODE_MODEL_PROVIDER=openai, OPENCODE_MODEL_ID=gpt-4-turbo
+#   Groq Mixtral: OPENCODE_MODEL_PROVIDER=groq, OPENCODE_MODEL_ID=mixtral-8x7b-32768
+OPENCODE_MODEL_PROVIDER=opencode
+OPENCODE_MODEL_ID=big-pickle
+
+# Server Configuration (optional)
+# Logging level: debug, info, warn, error (default: info)
+# Use "debug" to see detailed diagnostic logs including all bot events
+# LOG_LEVEL=info
+
+# Bot Configuration (optional)
+# Maximum number of sessions shown in /sessions (default: 10)
+# SESSIONS_LIST_LIMIT=10
+
+# Code File Settings (optional)
+# Maximum file size in KB to send as document (default: 100)
+# CODE_FILE_MAX_SIZE_KB=100

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ruslan Grinev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# OpenCode Telegram Client
+
+Мобильный клиент для OpenCode в Telegram, позволяющий управлять задачами разработки на локальном компьютере.
+
+## Требования
+
+- Node.js 20+
+- Установленный OpenCode CLI (`opencode`)
+
+## Установка
+
+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`
+
+## Переменные окружения
+
+Основные переменные в `.env`:
+
+- `TELEGRAM_BOT_TOKEN` — токен бота (обязательно).
+- `TELEGRAM_ALLOWED_USER_ID` — ваш Telegram user ID (обязательно).
+- `OPENCODE_MODEL_PROVIDER` — провайдер модели по умолчанию (обязательно).
+- `OPENCODE_MODEL_ID` — ID модели по умолчанию (обязательно).
+- `SESSIONS_LIST_LIMIT` — сколько последних сессий показывать в `/sessions` (опционально, по умолчанию `10`).
+
+## Сборка и запуск
+
+### Режим разработки
+
+Запуск без автоматической перезагрузки процесса:
+
+> В этом проекте auto-restart (watch/restart) намеренно не используется для runtime-бота,
+> чтобы не ломать активные SSE/polling соединения.
+
+```bash
+npm run dev
+```
+
+### Продакшн
+
+1. Соберите проект:
+   ```bash
+   npm run build
+   ```
+2. Запустите собранный код:
+   ```bash
+   npm start
+   ```
+
+## Команды
+
+- `npm run lint` — проверка кода линтером.
+- `npm run format` — форматирование кода через Prettier.
+- `npm run test` — запуск тестов через Vitest.
+- `npm run test:coverage` — запуск тестов с coverage-отчётом.
+
+## Функционал
+
+Подробное описание функционала и плана разработки находится в [PRODUCT.md](./PRODUCT.md).
+План технических улучшений (архитектура + тесты) — в [TECHNICAL_IMPROVEMENTS.md](./TECHNICAL_IMPROVEMENTS.md).
+Инструкции для разработчиков и описание архитектуры — в [AGENTS.md](./AGENTS.md).

package/dist/agent/manager.js

@@ -0,0 +1,92 @@
+import { opencodeClient } from "../opencode/client.js";
+import { getCurrentProject } from "../settings/manager.js";
+import { getCurrentSession } from "../session/manager.js";
+import { getCurrentAgent, setCurrentAgent } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Get list of available agents from OpenCode API
+ * @returns Array of available agents (filtered by mode and hidden flag)
+ */
+export async function getAvailableAgents() {
+    const project = getCurrentProject();
+    if (!project) {
+        logger.warn("[AgentManager] Cannot get agents: no project selected");
+        return [];
+    }
+    try {
+        const { data: agents, error } = await opencodeClient.app.agents({
+            directory: project.worktree,
+        });
+        if (error) {
+            logger.error("[AgentManager] Failed to fetch agents:", error);
+            return [];
+        }
+        if (!agents) {
+            return [];
+        }
+        // Filter out hidden agents and subagents (only show primary and all)
+        const filtered = agents.filter((agent) => !agent.hidden && (agent.mode === "primary" || agent.mode === "all"));
+        logger.debug(`[AgentManager] Fetched ${filtered.length} available agents`);
+        return filtered;
+    }
+    catch (err) {
+        logger.error("[AgentManager] Error fetching agents:", err);
+        return [];
+    }
+}
+/**
+ * Get current agent from last session message or settings
+ * @returns Current agent name or undefined
+ */
+export async function fetchCurrentAgent() {
+    const storedAgent = getCurrentAgent();
+    const session = getCurrentSession();
+    const project = getCurrentProject();
+    if (!session || !project) {
+        // No active session, return stored agent from settings
+        return storedAgent;
+    }
+    try {
+        const { data: messages, error } = await opencodeClient.session.messages({
+            sessionID: session.id,
+            directory: project.worktree,
+            limit: 1,
+        });
+        if (error || !messages || messages.length === 0) {
+            logger.debug("[AgentManager] No messages found, using stored agent");
+            return storedAgent;
+        }
+        const lastAgent = messages[0].info.agent;
+        logger.debug(`[AgentManager] Current agent from session: ${lastAgent}`);
+        // If user explicitly selected an agent in bot settings, prefer it.
+        // Session messages may contain stale agent until next prompt is sent.
+        if (storedAgent && lastAgent !== storedAgent) {
+            logger.debug(`[AgentManager] Using stored agent "${storedAgent}" instead of session agent "${lastAgent}"`);
+            return storedAgent;
+        }
+        // No stored agent yet: sync from session history
+        if (lastAgent && lastAgent !== storedAgent) {
+            setCurrentAgent(lastAgent);
+        }
+        return lastAgent || storedAgent;
+    }
+    catch (err) {
+        logger.error("[AgentManager] Error fetching current agent:", err);
+        return storedAgent;
+    }
+}
+/**
+ * Select agent and persist to settings
+ * @param agentName Name of the agent to select
+ */
+export function selectAgent(agentName) {
+    logger.info(`[AgentManager] Selected agent: ${agentName}`);
+    setCurrentAgent(agentName);
+}
+/**
+ * Get stored agent from settings (synchronous)
+ * @returns Current agent name or default "build"
+ */
+export function getStoredAgent() {
+    return getCurrentAgent() ?? "build";
+}

package/dist/agent/types.js

@@ -0,0 +1,26 @@
+/**
+ * Agent emoji mapping for visual distinction
+ */
+export const AGENT_EMOJI = {
+    plan: "📋",
+    build: "🛠️",
+    general: "💬",
+    explore: "🔍",
+    title: "📝",
+    summary: "📄",
+    compaction: "📦",
+};
+/**
+ * Get emoji for agent (fallback to 🤖 if not found)
+ */
+export function getAgentEmoji(agentName) {
+    return AGENT_EMOJI[agentName] ?? "🤖";
+}
+/**
+ * Get display name for agent (with emoji)
+ */
+export function getAgentDisplayName(agentName) {
+    const emoji = getAgentEmoji(agentName);
+    const capitalizedName = agentName.charAt(0).toUpperCase() + agentName.slice(1);
+    return `${emoji} ${capitalizedName} Mode`;
+}

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

@@ -0,0 +1,26 @@
+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";
+export async function startBotApp() {
+    const mode = getRuntimeMode();
+    logger.info("Starting OpenCode Telegram Client...");
+    logger.info(`Allowed User ID: ${config.telegram.allowedUserId}`);
+    logger.debug(`[Runtime] Application start mode: ${mode}`);
+    await loadSettings();
+    await processManager.initialize();
+    const bot = createBot();
+    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!`);
+        },
+    });
+}

package/dist/bot/commands/agent.js

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

package/dist/bot/commands/definitions.js

@@ -0,0 +1,20 @@
+/**
+ * Centralized bot commands definitions
+ * Used for both Telegram API setMyCommands and command handler registration
+ */
+/**
+ * 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: "Справка" },
+];

package/dist/bot/commands/help.js

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

package/dist/bot/commands/model.js

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

package/dist/bot/commands/models.js

@@ -0,0 +1,37 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { logger } from "../../utils/logger.js";
+export async function modelsCommand(ctx) {
+    try {
+        const { data: providersData, error } = await opencodeClient.config.providers();
+        if (error || !providersData) {
+            await ctx.reply("🔴 Не удалось получить список моделей. Проверьте статус сервера /status.");
+            return;
+        }
+        const providers = providersData.providers;
+        if (!providers || providers.length === 0) {
+            await ctx.reply("📋 Нет доступных моделей. Настройте провайдеры через OpenCode.");
+            return;
+        }
+        let message = "📋 **Доступные модели:**\n\n";
+        for (const provider of providers) {
+            message += `🔹 **\`${provider.id}\`**\n`;
+            const models = Object.values(provider.models);
+            if (models.length === 0) {
+                message += "  ⚠️ Нет доступных моделей\n";
+            }
+            else {
+                for (const model of models) {
+                    message += `  • \`${model.id}\`\n`;
+                }
+            }
+            message += "\n";
+        }
+        message += "💡 Для использования модели в .env:\n";
+        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("🔴 Произошла ошибка при получении списка моделей.");
+    }
+}

package/dist/bot/commands/new.js

@@ -0,0 +1,58 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { setCurrentSession } from "../../session/manager.js";
+import { getCurrentProject } from "../../settings/manager.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { getStoredAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { createMainKeyboard } from "../utils/keyboard.js";
+import { logger } from "../../utils/logger.js";
+export async function newCommand(ctx) {
+    try {
+        const currentProject = getCurrentProject();
+        if (!currentProject) {
+            await ctx.reply("🏗 Проект не выбран.\n\nСначала выберите проект командой /projects.");
+            return;
+        }
+        logger.debug("[Bot] Creating new session for directory:", currentProject.worktree);
+        const { data: session, error } = await opencodeClient.session.create({
+            directory: currentProject.worktree,
+        });
+        if (error || !session) {
+            throw error || new Error("No data received from server");
+        }
+        logger.info(`[Bot] Created new session via /new command: id=${session.id}, title="${session.title}", project=${currentProject.worktree}`);
+        const sessionInfo = {
+            id: session.id,
+            title: session.title,
+            directory: currentProject.worktree,
+        };
+        setCurrentSession(sessionInfo);
+        // Initialize pinned message manager and create pinned message
+        if (!pinnedMessageManager.isInitialized()) {
+            pinnedMessageManager.initialize(ctx.api, ctx.chat.id);
+        }
+        // Initialize keyboard manager if not already
+        keyboardManager.initialize(ctx.api, ctx.chat.id);
+        try {
+            await pinnedMessageManager.onSessionChange(session.id, session.title);
+        }
+        catch (err) {
+            logger.error("[Bot] Error creating pinned message:", err);
+        }
+        // Get current state for keyboard
+        const currentAgent = getStoredAgent();
+        const currentModel = getStoredModel();
+        const contextInfo = pinnedMessageManager.getContextInfo();
+        const variantName = formatVariantForButton(currentModel.variant || "default");
+        const keyboard = createMainKeyboard(currentAgent, currentModel, contextInfo ?? undefined, variantName);
+        await ctx.reply(`✅ Создана новая сессия: ${session.title}`, {
+            reply_markup: keyboard,
+        });
+    }
+    catch (error) {
+        logger.error("[Bot] Error creating session:", error);
+        await ctx.reply("🔴 OpenCode Server недоступен или произошла ошибка при создании сессии.");
+    }
+}

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

@@ -0,0 +1,87 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { processManager } from "../../process/manager.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Wait for OpenCode server to become ready by polling health endpoint
+ * @param maxWaitMs Maximum time to wait in milliseconds
+ * @returns true if server became ready, false if timeout
+ */
+async function waitForServerReady(maxWaitMs = 10000) {
+    const startTime = Date.now();
+    const pollInterval = 500;
+    while (Date.now() - startTime < maxWaitMs) {
+        try {
+            const { data, error } = await opencodeClient.global.health();
+            if (!error && data?.healthy) {
+                return true;
+            }
+        }
+        catch {
+            // Server not ready yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return false;
+}
+/**
+ * Command handler for /opencode-start
+ * Starts the OpenCode server process
+ */
+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(`⚠️ OpenCode Server уже запущен\n\n` +
+                `PID: ${processManager.getPID()}\n` +
+                `Uptime: ${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 не сможет его остановить.`);
+                return;
+            }
+        }
+        catch {
+            // Server not accessible, continue with start
+        }
+        // 3. Notify user that we're starting the server
+        const statusMessage = await ctx.reply("🔄 Запускаю OpenCode Server...");
+        // 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" });
+            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 через несколько секунд.`);
+            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 || "неизвестна"}`);
+        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" +
+            "Проверьте логи приложения для подробностей.");
+    }
+}

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

@@ -0,0 +1,46 @@
+import { opencodeClient } from "../../opencode/client.js";
+import { processManager } from "../../process/manager.js";
+import { logger } from "../../utils/logger.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(`⚠️ OpenCode Server запущен внешним процессом\n\n` +
+                        `Этот сервер не был запущен через /opencode-start.\n` +
+                        `Остановите его вручную или используйте /status для проверки состояния.`);
+                    return;
+                }
+            }
+            catch {
+                // Server not accessible
+            }
+            await ctx.reply("⚠️ OpenCode Server не запущен");
+            return;
+        }
+        // 2. Notify user that we're stopping the server
+        const pid = processManager.getPID();
+        const statusMessage = await ctx.reply(`🛑 Останавливаю OpenCode Server...\n\nPID: ${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 || "неизвестная ошибка"}`);
+            return;
+        }
+        // 4. Success - process has been stopped
+        await ctx.api.editMessageText(ctx.chat.id, statusMessage.message_id, `✅ OpenCode Server успешно остановлен`);
+        logger.info("[Bot] OpenCode server stopped successfully");
+    }
+    catch (err) {
+        logger.error("[Bot] Error in /opencode-stop command:", err);
+        await ctx.reply("🔴 Произошла ошибка при остановке сервера.\n\n" +
+            "Проверьте логи приложения для подробностей.");
+    }
+}