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

package/dist/cli/args.js

@@ -0,0 +1,97 @@
+const SUPPORTED_COMMANDS = ["start", "status", "stop", "config"];
+function isCliCommand(value) {
+    return SUPPORTED_COMMANDS.includes(value);
+}
+function normalizeMode(value) {
+    if (value === "installed") {
+        return "installed";
+    }
+    if (value === "sources") {
+        return "sources";
+    }
+    return null;
+}
+export function parseCliArgs(argv) {
+    const args = [...argv];
+    let command = "start";
+    let mode;
+    let showHelp = false;
+    let currentIndex = 0;
+    const firstArg = args[0];
+    if (firstArg && !firstArg.startsWith("-")) {
+        if (!isCliCommand(firstArg)) {
+            return {
+                command,
+                showHelp: true,
+                error: `Unknown command: ${firstArg}`,
+            };
+        }
+        command = firstArg;
+        currentIndex = 1;
+    }
+    while (currentIndex < args.length) {
+        const token = args[currentIndex];
+        if (token === "--help" || token === "-h") {
+            showHelp = true;
+            currentIndex += 1;
+            continue;
+        }
+        if (token === "--mode") {
+            const modeValue = args[currentIndex + 1];
+            if (!modeValue || modeValue.startsWith("-")) {
+                return {
+                    command,
+                    mode,
+                    showHelp: true,
+                    error: "Option --mode requires a value: sources|installed",
+                };
+            }
+            const parsedMode = normalizeMode(modeValue);
+            if (!parsedMode) {
+                return {
+                    command,
+                    mode,
+                    showHelp: true,
+                    error: `Invalid mode value: ${modeValue}. Expected sources|installed`,
+                };
+            }
+            mode = parsedMode;
+            currentIndex += 2;
+            continue;
+        }
+        if (token.startsWith("--mode=")) {
+            const modeValue = token.slice("--mode=".length);
+            const parsedMode = normalizeMode(modeValue);
+            if (!parsedMode) {
+                return {
+                    command,
+                    mode,
+                    showHelp: true,
+                    error: `Invalid mode value: ${modeValue}. Expected sources|installed`,
+                };
+            }
+            mode = parsedMode;
+            currentIndex += 1;
+            continue;
+        }
+        return {
+            command,
+            mode,
+            showHelp: true,
+            error: `Unknown option: ${token}`,
+        };
+    }
+    if (command !== "start" && mode) {
+        return {
+            command,
+            mode,
+            showHelp: true,
+            error: "Option --mode is supported only for the start command",
+        };
+    }
+    return {
+        command,
+        mode,
+        showHelp,
+    };
+}

package/dist/cli.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { parseCliArgs } from "./cli/args.js";
+import { resolveRuntimeMode, setRuntimeMode } from "./runtime/mode.js";
+const EXIT_SUCCESS = 0;
+const EXIT_RUNTIME_ERROR = 1;
+const EXIT_INVALID_ARGS = 2;
+const USAGE_TEXT = [
+    "Usage:",
+    "  opencode-telegram [start] [--mode sources|installed]",
+    "  opencode-telegram status",
+    "  opencode-telegram stop",
+    "  opencode-telegram config",
+    "",
+    "Notes:",
+    "  - No command defaults to `start`",
+    "  - `--mode` is currently supported for `start` only",
+].join("\n");
+function writeStdout(message) {
+    process.stdout.write(`${message}\n`);
+}
+function writeStderr(message) {
+    process.stderr.write(`${message}\n`);
+}
+function printUsage() {
+    writeStdout(USAGE_TEXT);
+}
+function getPlaceholderMessage(command) {
+    if (command === "status") {
+        return "Команда `status` пока работает как заглушка. Реальная проверка статуса появится на этапе service-слоя (Этап 5).";
+    }
+    if (command === "stop") {
+        return "Команда `stop` пока работает как заглушка. Реальная остановка фонового процесса появится на этапе service-слоя (Этап 5).";
+    }
+    return "Команда недоступна.";
+}
+async function runStartCommand(mode) {
+    const modeResult = resolveRuntimeMode({
+        defaultMode: "installed",
+        explicitMode: mode,
+    });
+    if (modeResult.error) {
+        throw new Error(modeResult.error);
+    }
+    setRuntimeMode(modeResult.mode);
+    const { ensureRuntimeConfigForStart } = await import("./runtime/bootstrap.js");
+    await ensureRuntimeConfigForStart();
+    const { startBotApp } = await import("./app/start-bot-app.js");
+    await startBotApp();
+    return EXIT_SUCCESS;
+}
+async function runConfigCommand() {
+    setRuntimeMode("installed");
+    const { runConfigWizardCommand } = await import("./runtime/bootstrap.js");
+    await runConfigWizardCommand();
+    return EXIT_SUCCESS;
+}
+async function runPlaceholderCommand(command) {
+    writeStdout(getPlaceholderMessage(command));
+    return EXIT_SUCCESS;
+}
+async function runCli(argv) {
+    const parsedArgs = parseCliArgs(argv);
+    if (parsedArgs.error) {
+        writeStderr(parsedArgs.error);
+    }
+    if (parsedArgs.showHelp) {
+        printUsage();
+        return parsedArgs.error ? EXIT_INVALID_ARGS : EXIT_SUCCESS;
+    }
+    if (parsedArgs.command === "start") {
+        return runStartCommand(parsedArgs.mode);
+    }
+    if (parsedArgs.command === "config") {
+        return runConfigCommand();
+    }
+    return runPlaceholderCommand(parsedArgs.command);
+}
+void runCli(process.argv.slice(2))
+    .then((exitCode) => {
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
+    if (error instanceof Error) {
+        writeStderr(`CLI error: ${error.message}`);
+    }
+    else {
+        writeStderr(`CLI error: ${String(error)}`);
+    }
+    process.exitCode = EXIT_RUNTIME_ERROR;
+});

package/dist/config.js

@@ -0,0 +1,46 @@
+import dotenv from "dotenv";
+import { getRuntimePaths } from "./runtime/paths.js";
+const runtimePaths = getRuntimePaths();
+dotenv.config({ path: runtimePaths.envFilePath });
+function getEnvVar(key, required = true) {
+    const value = process.env[key];
+    if (required && !value) {
+        throw new Error(`Missing required environment variable: ${key} (expected in ${runtimePaths.envFilePath})`);
+    }
+    return value || "";
+}
+function getOptionalPositiveIntEnvVar(key, defaultValue) {
+    const value = getEnvVar(key, false);
+    if (!value) {
+        return defaultValue;
+    }
+    const parsedValue = Number.parseInt(value, 10);
+    if (Number.isNaN(parsedValue) || parsedValue <= 0) {
+        return defaultValue;
+    }
+    return parsedValue;
+}
+export const config = {
+    telegram: {
+        token: getEnvVar("TELEGRAM_BOT_TOKEN"),
+        allowedUserId: parseInt(getEnvVar("TELEGRAM_ALLOWED_USER_ID"), 10),
+    },
+    opencode: {
+        apiUrl: getEnvVar("OPENCODE_API_URL", false) || "http://localhost:4096",
+        username: getEnvVar("OPENCODE_SERVER_USERNAME", false) || "opencode",
+        password: getEnvVar("OPENCODE_SERVER_PASSWORD", false),
+        model: {
+            provider: getEnvVar("OPENCODE_MODEL_PROVIDER", true), // Required
+            modelId: getEnvVar("OPENCODE_MODEL_ID", true), // Required
+        },
+    },
+    server: {
+        logLevel: getEnvVar("LOG_LEVEL", false) || "info",
+    },
+    bot: {
+        sessionsListLimit: getOptionalPositiveIntEnvVar("SESSIONS_LIST_LIMIT", 10),
+    },
+    files: {
+        maxFileSizeKb: parseInt(getEnvVar("CODE_FILE_MAX_SIZE_KB", false) || "100", 10),
+    },
+};

package/dist/index.js

@@ -0,0 +1,26 @@
+import { resolveRuntimeMode, setRuntimeMode } from "./runtime/mode.js";
+const EXIT_RUNTIME_ERROR = 1;
+const EXIT_INVALID_ARGS = 2;
+async function main() {
+    const modeResult = resolveRuntimeMode({
+        defaultMode: "sources",
+        argv: process.argv.slice(2),
+    });
+    if (modeResult.error) {
+        process.stderr.write(`${modeResult.error}\n`);
+        process.exit(EXIT_INVALID_ARGS);
+        return;
+    }
+    setRuntimeMode(modeResult.mode);
+    const { startBotApp } = await import("./app/start-bot-app.js");
+    await startBotApp();
+}
+void main().catch((error) => {
+    if (error instanceof Error) {
+        process.stderr.write(`Failed to start bot: ${error.message}\n`);
+    }
+    else {
+        process.stderr.write(`Failed to start bot: ${String(error)}\n`);
+    }
+    process.exit(EXIT_RUNTIME_ERROR);
+});

package/dist/keyboard/manager.js

@@ -0,0 +1,171 @@
+import { createMainKeyboard } from "../bot/utils/keyboard.js";
+import { getStoredAgent } from "../agent/manager.js";
+import { getStoredModel } from "../model/manager.js";
+import { formatVariantForButton } from "../variant/manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Keyboard Manager - manages Reply Keyboard state and updates
+ * Singleton pattern
+ */
+class KeyboardManager {
+    state = null;
+    api = null;
+    chatId = null;
+    lastUpdateTime = 0;
+    UPDATE_DEBOUNCE_MS = 2000; // Don't update more than once per 2 seconds
+    /**
+     * Initialize the keyboard manager with Telegram API and chat ID
+     * Loads initial state from settings/config
+     */
+    initialize(api, chatId) {
+        this.api = api;
+        this.chatId = chatId;
+        // Initialize state from settings/config on first call
+        if (!this.state) {
+            const currentModel = getStoredModel();
+            this.state = {
+                currentAgent: getStoredAgent(),
+                currentModel: currentModel,
+                contextInfo: null,
+                variantName: formatVariantForButton(currentModel.variant || "default"),
+            };
+            logger.debug(`[KeyboardManager] Initialized with agent="${this.state.currentAgent}", model="${this.state.currentModel.providerID}/${this.state.currentModel.modelID}", variant="${currentModel.variant || "default"}", chatId=${chatId}`);
+        }
+        else {
+            logger.debug("[KeyboardManager] Already initialized, updating chatId:", chatId);
+        }
+    }
+    /**
+     * Update current agent
+     */
+    updateAgent(agent) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update agent: not initialized");
+            return;
+        }
+        this.state.currentAgent = agent;
+        logger.debug(`[KeyboardManager] Agent updated: ${agent}`);
+    }
+    /**
+     * Update current model
+     */
+    updateModel(model) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update model: not initialized");
+            return;
+        }
+        this.state.currentModel = model;
+        this.state.variantName = formatVariantForButton(model.variant || "default");
+        logger.debug(`[KeyboardManager] Model updated: ${model.providerID}/${model.modelID}, variant: ${model.variant || "default"}`);
+    }
+    /**
+     * Update current variant
+     */
+    updateVariant(variantId) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update variant: not initialized");
+            return;
+        }
+        this.state.variantName = formatVariantForButton(variantId);
+        logger.debug(`[KeyboardManager] Variant updated: ${variantId}`);
+    }
+    /**
+     * Update context information
+     */
+    updateContext(tokensUsed, tokensLimit) {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot update context: not initialized");
+            return;
+        }
+        this.state.contextInfo = { tokensUsed, tokensLimit };
+        logger.debug(`[KeyboardManager] Context updated: ${tokensUsed}/${tokensLimit}`);
+    }
+    /**
+     * Clear context information
+     */
+    clearContext() {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot clear context: not initialized");
+            return;
+        }
+        this.state.contextInfo = null;
+        logger.debug("[KeyboardManager] Context cleared");
+    }
+    /**
+     * Get current context info
+     */
+    getContextInfo() {
+        return this.state?.contextInfo ?? null;
+    }
+    /**
+     * Build keyboard with current state
+     */
+    buildKeyboard() {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot build keyboard: not initialized");
+            // Return a minimal keyboard as fallback
+            return createMainKeyboard("build", { providerID: "", modelID: "" }, undefined);
+        }
+        return createMainKeyboard(this.state.currentAgent, this.state.currentModel, this.state.contextInfo ?? undefined, this.state.variantName);
+    }
+    /**
+     * Send keyboard update to user
+     * Implements debouncing to avoid rate limits
+     */
+    async sendKeyboardUpdate(chatId) {
+        if (!this.api) {
+            logger.warn("[KeyboardManager] API not initialized");
+            return;
+        }
+        const targetChatId = chatId ?? this.chatId;
+        if (!targetChatId) {
+            logger.warn("[KeyboardManager] No chatId available");
+            return;
+        }
+        // Debounce: don't update more frequently than UPDATE_DEBOUNCE_MS
+        const now = Date.now();
+        if (now - this.lastUpdateTime < this.UPDATE_DEBOUNCE_MS) {
+            logger.debug("[KeyboardManager] Update debounced");
+            return;
+        }
+        this.lastUpdateTime = now;
+        try {
+            const keyboard = this.buildKeyboard();
+            // Send a dummy message with updated keyboard
+            // This is needed because Reply Keyboard updates require a message
+            await this.api.sendMessage(targetChatId, "⌨️ Клавиатура обновлена", {
+                reply_markup: keyboard,
+            });
+            logger.debug("[KeyboardManager] Keyboard update sent");
+        }
+        catch (err) {
+            logger.error("[KeyboardManager] Failed to send keyboard update:", err);
+        }
+    }
+    /**
+     * Update keyboard without sending a message (for use in existing messages)
+     * Returns undefined if not initialized (caller should handle this)
+     */
+    getKeyboard() {
+        if (!this.state) {
+            logger.warn("[KeyboardManager] Cannot get keyboard: not initialized");
+            return undefined;
+        }
+        return this.buildKeyboard();
+    }
+    /**
+     * Get current keyboard state
+     * Returns undefined if not initialized
+     */
+    getState() {
+        return this.state ?? undefined;
+    }
+    /**
+     * Check if keyboard manager is initialized
+     */
+    isInitialized() {
+        return this.state !== null;
+    }
+}
+// Export singleton instance
+export const keyboardManager = new KeyboardManager();

package/dist/keyboard/types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/manager.js

@@ -0,0 +1,123 @@
+import { getCurrentModel, setCurrentModel } from "../settings/manager.js";
+import { config } from "../config.js";
+import { logger } from "../utils/logger.js";
+import path from "node:path";
+function getEnvDefaultModel() {
+    const providerID = config.opencode.model.provider;
+    const modelID = config.opencode.model.modelId;
+    if (!providerID || !modelID) {
+        return null;
+    }
+    return { providerID, modelID };
+}
+function dedupeModels(models) {
+    const unique = new Map();
+    for (const model of models) {
+        const key = `${model.providerID}/${model.modelID}`;
+        if (!unique.has(key)) {
+            unique.set(key, model);
+        }
+    }
+    return Array.from(unique.values());
+}
+function normalizeFavoriteModels(state) {
+    if (!Array.isArray(state.favorite)) {
+        return [];
+    }
+    return state.favorite
+        .filter((model) => typeof model?.providerID === "string" &&
+        model.providerID.length > 0 &&
+        typeof model.modelID === "string" &&
+        model.modelID.length > 0)
+        .map((model) => ({
+        providerID: model.providerID,
+        modelID: model.modelID,
+    }));
+}
+function getOpenCodeModelStatePath() {
+    const xdgStateHome = process.env.XDG_STATE_HOME;
+    if (xdgStateHome && xdgStateHome.trim().length > 0) {
+        return path.join(xdgStateHome, "opencode", "model.json");
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    return path.join(homeDir, ".local", "state", "opencode", "model.json");
+}
+/**
+ * Get list of favorite models from OpenCode local state file
+ * Falls back to env default model if file is unavailable or empty
+ */
+export async function getFavoriteModels() {
+    const envDefaultModel = getEnvDefaultModel();
+    try {
+        const fs = await import("fs/promises");
+        const stateFilePath = getOpenCodeModelStatePath();
+        const content = await fs.readFile(stateFilePath, "utf-8");
+        const state = JSON.parse(content);
+        const favorites = normalizeFavoriteModels(state);
+        if (favorites.length === 0) {
+            if (envDefaultModel) {
+                logger.info(`[ModelManager] No favorites in ${stateFilePath}, using env default model`);
+                return [envDefaultModel];
+            }
+            logger.warn(`[ModelManager] No favorites in ${stateFilePath}`);
+            return [];
+        }
+        const merged = envDefaultModel ? dedupeModels([...favorites, envDefaultModel]) : favorites;
+        logger.debug(`[ModelManager] Loaded ${merged.length} favorite models from ${stateFilePath}`);
+        return merged;
+    }
+    catch (err) {
+        if (envDefaultModel) {
+            logger.warn("[ModelManager] Failed to load OpenCode favorites, using env default model:", err);
+            return [envDefaultModel];
+        }
+        logger.error("[ModelManager] Failed to load OpenCode favorites:", err);
+        return [];
+    }
+}
+/**
+ * Get current model from settings or fallback to config
+ * @returns Current model info
+ */
+export function fetchCurrentModel() {
+    return getStoredModel();
+}
+/**
+ * Select model and persist to settings
+ * @param modelInfo Model to select
+ */
+export function selectModel(modelInfo) {
+    logger.info(`[ModelManager] Selected model: ${modelInfo.providerID}/${modelInfo.modelID}`);
+    setCurrentModel(modelInfo);
+}
+/**
+ * Get stored model from settings (synchronous)
+ * ALWAYS returns a model - fallback to config if not found
+ * @returns Current model info
+ */
+export function getStoredModel() {
+    const storedModel = getCurrentModel();
+    if (storedModel) {
+        // Ensure variant is set (default to "default")
+        if (!storedModel.variant) {
+            storedModel.variant = "default";
+        }
+        return storedModel;
+    }
+    // Fallback to model from config (environment variables)
+    if (config.opencode.model.provider && config.opencode.model.modelId) {
+        logger.debug("[ModelManager] Using model from config");
+        return {
+            providerID: config.opencode.model.provider,
+            modelID: config.opencode.model.modelId,
+            variant: "default",
+        };
+    }
+    // This should not happen if config is properly set
+    logger.warn("[ModelManager] No model found in settings or config, returning empty model");
+    return {
+        providerID: "",
+        modelID: "",
+        variant: "default",
+    };
+}

package/dist/model/types.js

@@ -0,0 +1,26 @@
+/**
+ * Model types and formatting utilities
+ */
+/**
+ * Format model for button display (compact format)
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Formatted string "providerID/modelID"
+ */
+export function formatModelForButton(providerID, modelID) {
+    const formatted = `${providerID}/${modelID}`;
+    // Limit to ~30 characters for button width
+    if (formatted.length > 30) {
+        return formatted.substring(0, 27) + "...";
+    }
+    return formatted;
+}
+/**
+ * Format model for display in messages (full format)
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Formatted string "providerID / modelID"
+ */
+export function formatModelForDisplay(providerID, modelID) {
+    return `${providerID} / ${modelID}`;
+}

package/dist/opencode/client.js

@@ -0,0 +1,13 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { config } from "../config.js";
+const getAuth = () => {
+    if (!config.opencode.password) {
+        return undefined;
+    }
+    const credentials = `${config.opencode.username}:${config.opencode.password}`;
+    return `Basic ${Buffer.from(credentials).toString("base64")}`;
+};
+export const opencodeClient = createOpencodeClient({
+    baseUrl: config.opencode.apiUrl,
+    headers: config.opencode.password ? { Authorization: getAuth() } : undefined,
+});

package/dist/opencode/events.js

@@ -0,0 +1,79 @@
+import { opencodeClient } from "./client.js";
+import { logger } from "../utils/logger.js";
+let eventStream = null;
+let eventCallback = null;
+let isListening = false;
+let activeDirectory = null;
+let streamAbortController = null;
+export async function subscribeToEvents(directory, callback) {
+    if (isListening && activeDirectory === directory) {
+        logger.debug(`Event listener already running for ${directory}`);
+        return;
+    }
+    if (isListening && activeDirectory !== directory) {
+        logger.info(`Stopping event listener for ${activeDirectory}, starting for ${directory}`);
+        streamAbortController?.abort();
+        streamAbortController = null;
+        isListening = false;
+        activeDirectory = null;
+    }
+    const controller = new AbortController();
+    activeDirectory = directory;
+    eventCallback = callback;
+    isListening = true;
+    streamAbortController = controller;
+    try {
+        const result = await opencodeClient.event.subscribe({ directory }, { signal: controller.signal });
+        if (!result.stream) {
+            throw new Error("No stream returned from event subscription");
+        }
+        eventStream = result.stream;
+        for await (const event of eventStream) {
+            if (!isListening || activeDirectory !== directory) {
+                logger.debug(`Event listener stopped or changed directory, breaking loop`);
+                break;
+            }
+            // КРИТИЧНО: Принудительно отдаем управление event loop ПЕРЕД обработкой события
+            // Это позволяет grammY обрабатывать getUpdates между SSE событиями
+            await new Promise((resolve) => setImmediate(resolve));
+            if (eventCallback) {
+                // Используем setImmediate чтобы не блокировать event loop
+                // и дать grammY возможность обрабатывать incoming Telegram updates
+                const callback = eventCallback;
+                setImmediate(() => callback(event));
+            }
+        }
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            logger.info("Event listener aborted");
+            return;
+        }
+        logger.error("Event stream error:", error);
+        isListening = false;
+        activeDirectory = null;
+        streamAbortController = null;
+        throw error;
+    }
+    finally {
+        if (streamAbortController === controller) {
+            if (isListening && activeDirectory === directory && !controller.signal.aborted) {
+                logger.warn(`Event stream ended for ${directory}, listener marked as disconnected`);
+            }
+            streamAbortController = null;
+            eventStream = null;
+            eventCallback = null;
+            isListening = false;
+            activeDirectory = null;
+        }
+    }
+}
+export function stopEventListening() {
+    streamAbortController?.abort();
+    streamAbortController = null;
+    isListening = false;
+    eventCallback = null;
+    eventStream = null;
+    activeDirectory = null;
+    logger.info("Event listener stopped");
+}