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

package/dist/runtime/bootstrap.js

@@ -0,0 +1,278 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+import { getRuntimePaths } from "./paths.js";
+const DEFAULT_API_URL = "http://localhost:4096";
+const FALLBACK_MODEL_PROVIDER = "opencode";
+const FALLBACK_MODEL_ID = "big-pickle";
+function isPositiveInteger(value) {
+    return /^[1-9]\d*$/.test(value);
+}
+function isValidHttpUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+export function validateRuntimeEnvValues(values) {
+    if (!values.TELEGRAM_BOT_TOKEN || values.TELEGRAM_BOT_TOKEN.trim().length === 0) {
+        return { isValid: false, reason: "Missing TELEGRAM_BOT_TOKEN" };
+    }
+    if (!isPositiveInteger(values.TELEGRAM_ALLOWED_USER_ID || "")) {
+        return { isValid: false, reason: "Invalid TELEGRAM_ALLOWED_USER_ID" };
+    }
+    if (!values.OPENCODE_MODEL_PROVIDER || values.OPENCODE_MODEL_PROVIDER.trim().length === 0) {
+        return { isValid: false, reason: "Missing OPENCODE_MODEL_PROVIDER" };
+    }
+    if (!values.OPENCODE_MODEL_ID || values.OPENCODE_MODEL_ID.trim().length === 0) {
+        return { isValid: false, reason: "Missing OPENCODE_MODEL_ID" };
+    }
+    const apiUrl = values.OPENCODE_API_URL?.trim();
+    if (apiUrl && !isValidHttpUrl(apiUrl)) {
+        return { isValid: false, reason: "Invalid OPENCODE_API_URL" };
+    }
+    return { isValid: true };
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeEnvLineEndings(content) {
+    const lines = content.split(/\r?\n/).map((line) => line.replace(/\r$/, ""));
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines;
+}
+function removeEnvKey(lines, key) {
+    const regex = new RegExp(`^\\s*(?:export\\s+)?${escapeRegex(key)}\\s*=`);
+    return lines.filter((line) => !regex.test(line));
+}
+function finalizeEnvContent(lines) {
+    return `${lines.join("\n")}\n`;
+}
+export function buildEnvFileContent(existingContent, values) {
+    let lines = normalizeEnvLineEndings(existingContent);
+    const orderedUpdates = [
+        ["TELEGRAM_BOT_TOKEN", values.TELEGRAM_BOT_TOKEN],
+        ["TELEGRAM_ALLOWED_USER_ID", values.TELEGRAM_ALLOWED_USER_ID],
+        ["OPENCODE_API_URL", values.OPENCODE_API_URL],
+        ["OPENCODE_MODEL_PROVIDER", values.OPENCODE_MODEL_PROVIDER],
+        ["OPENCODE_MODEL_ID", values.OPENCODE_MODEL_ID],
+    ];
+    for (const [key, value] of orderedUpdates) {
+        lines = removeEnvKey(lines, key);
+        if (value && value.trim().length > 0) {
+            lines.push(`${key}=${value}`);
+        }
+    }
+    return finalizeEnvContent(lines);
+}
+async function readEnvFileIfExists(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf-8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeFileAtomically(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempFilePath = `${filePath}.${process.pid}.tmp`;
+    await fs.writeFile(tempFilePath, content, "utf-8");
+    await fs.rename(tempFilePath, filePath);
+}
+async function ensureSettingsFile(settingsFilePath) {
+    try {
+        await fs.access(settingsFilePath);
+        return;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    await fs.mkdir(path.dirname(settingsFilePath), { recursive: true });
+    await fs.writeFile(settingsFilePath, "{}\n", "utf-8");
+}
+function getEnvExamplePath() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    return path.resolve(path.dirname(currentFilePath), "..", "..", ".env.example");
+}
+async function loadModelDefaultsFromEnvExample() {
+    const fallbackDefaults = {
+        provider: FALLBACK_MODEL_PROVIDER,
+        modelId: FALLBACK_MODEL_ID,
+    };
+    try {
+        const content = await fs.readFile(getEnvExamplePath(), "utf-8");
+        const parsed = dotenv.parse(content);
+        const provider = parsed.OPENCODE_MODEL_PROVIDER?.trim();
+        const modelId = parsed.OPENCODE_MODEL_ID?.trim();
+        if (!provider || !modelId) {
+            return fallbackDefaults;
+        }
+        return {
+            provider,
+            modelId,
+        };
+    }
+    catch {
+        return fallbackDefaults;
+    }
+}
+async function askVisible(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await rl.question(question);
+        return answer.trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askHidden(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+        const maskedRl = rl;
+        maskedRl._writeToOutput = (value) => {
+            if (maskedRl.stdoutMuted) {
+                if (value.includes("\n") || value.includes("\r")) {
+                    process.stdout.write(value);
+                    return;
+                }
+                if (value.length > 0) {
+                    process.stdout.write("*");
+                }
+                return;
+            }
+            process.stdout.write(value);
+        };
+        maskedRl.stdoutMuted = false;
+        rl.question(question, (answer) => {
+            maskedRl.stdoutMuted = false;
+            process.stdout.write("\n");
+            rl.close();
+            resolve(answer.trim());
+        });
+        maskedRl.stdoutMuted = true;
+    });
+}
+async function askToken() {
+    for (;;) {
+        const token = await askHidden("Введите токен Telegram-бота (получить у @BotFather).\n> ");
+        if (!token) {
+            process.stdout.write("Токен обязателен. Попробуйте еще раз.\n");
+            continue;
+        }
+        if (!token.includes(":")) {
+            process.stdout.write("Похоже на невалидный токен (ожидается формат <id>:<secret>). Попробуйте еще раз.\n");
+            continue;
+        }
+        return token;
+    }
+}
+async function askAllowedUserId() {
+    for (;;) {
+        const allowedUserId = await askVisible("Введите ваш Telegram User ID (можно узнать у @userinfobot).\n> ");
+        if (!isPositiveInteger(allowedUserId)) {
+            process.stdout.write("Введите положительное целое число (> 0).\n");
+            continue;
+        }
+        return allowedUserId;
+    }
+}
+async function askApiUrl() {
+    const prompt = `Введите URL OpenCode API (опционально).\nНажмите Enter для значения по умолчанию: ${DEFAULT_API_URL}\n> `;
+    for (;;) {
+        const apiUrl = await askVisible(prompt);
+        if (!apiUrl) {
+            return undefined;
+        }
+        if (!isValidHttpUrl(apiUrl)) {
+            process.stdout.write("Введите корректный URL (http/https) или нажмите Enter для значения по умолчанию.\n");
+            continue;
+        }
+        return apiUrl;
+    }
+}
+async function collectWizardValues() {
+    process.stdout.write("Запуск first-run wizard для настройки OpenCode Telegram Bot.\n");
+    process.stdout.write("\n");
+    const token = await askToken();
+    const allowedUserId = await askAllowedUserId();
+    const apiUrl = await askApiUrl();
+    process.stdout.write("\n");
+    return {
+        token,
+        allowedUserId,
+        apiUrl,
+    };
+}
+function ensureInteractiveTty() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("Interactive wizard requires a TTY terminal. Run `opencode-telegram config` in an interactive shell.");
+    }
+}
+async function validateExistingEnv(envFilePath) {
+    const content = await readEnvFileIfExists(envFilePath);
+    if (content === null) {
+        return { isValid: false, reason: "Missing .env" };
+    }
+    const parsed = dotenv.parse(content);
+    return validateRuntimeEnvValues(parsed);
+}
+async function runWizardAndPersist(runtimePaths) {
+    ensureInteractiveTty();
+    const [existingContent, modelDefaults, wizardValues] = await Promise.all([
+        readEnvFileIfExists(runtimePaths.envFilePath),
+        loadModelDefaultsFromEnvExample(),
+        collectWizardValues(),
+    ]);
+    const existingParsed = existingContent ? dotenv.parse(existingContent) : {};
+    const provider = existingParsed.OPENCODE_MODEL_PROVIDER || modelDefaults.provider;
+    const modelId = existingParsed.OPENCODE_MODEL_ID || modelDefaults.modelId;
+    const envValues = {
+        TELEGRAM_BOT_TOKEN: wizardValues.token,
+        TELEGRAM_ALLOWED_USER_ID: wizardValues.allowedUserId,
+        OPENCODE_API_URL: wizardValues.apiUrl,
+        OPENCODE_MODEL_PROVIDER: provider,
+        OPENCODE_MODEL_ID: modelId,
+    };
+    const envContent = buildEnvFileContent(existingContent ?? "", envValues);
+    await writeFileAtomically(runtimePaths.envFilePath, envContent);
+    await ensureSettingsFile(runtimePaths.settingsFilePath);
+    process.stdout.write(`Конфигурация сохранена:\n- ${runtimePaths.envFilePath}\n- ${runtimePaths.settingsFilePath}\n`);
+}
+export async function ensureRuntimeConfigForStart() {
+    const runtimePaths = getRuntimePaths();
+    if (runtimePaths.mode !== "installed") {
+        return;
+    }
+    const validationResult = await validateExistingEnv(runtimePaths.envFilePath);
+    if (validationResult.isValid) {
+        await ensureSettingsFile(runtimePaths.settingsFilePath);
+        return;
+    }
+    process.stdout.write("Приложение еще не сконфигурировано. Запускаю wizard...\n");
+    await runWizardAndPersist(runtimePaths);
+}
+export async function runConfigWizardCommand() {
+    const runtimePaths = getRuntimePaths();
+    await runWizardAndPersist(runtimePaths);
+}

package/dist/runtime/mode.js

@@ -0,0 +1,74 @@
+const RUNTIME_MODE_ENV_KEY = "OPENCODE_TELEGRAM_RUNTIME_MODE";
+function normalizeMode(value) {
+    if (value === "installed") {
+        return "installed";
+    }
+    if (value === "sources") {
+        return "sources";
+    }
+    return null;
+}
+function parseModeFromArgv(argv) {
+    let mode = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--mode") {
+            const modeValue = argv[index + 1];
+            if (!modeValue || modeValue.startsWith("-")) {
+                return null;
+            }
+            mode = normalizeMode(modeValue);
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--mode=")) {
+            mode = normalizeMode(token.slice("--mode=".length));
+        }
+    }
+    return mode;
+}
+function hasInvalidModeSyntax(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--mode") {
+            const modeValue = argv[index + 1];
+            if (!modeValue || modeValue.startsWith("-")) {
+                return true;
+            }
+            if (!normalizeMode(modeValue)) {
+                return true;
+            }
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--mode=")) {
+            const modeValue = token.slice("--mode=".length);
+            if (!normalizeMode(modeValue)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function resolveRuntimeMode(options) {
+    if (options.explicitMode) {
+        return { mode: options.explicitMode };
+    }
+    const argv = options.argv ?? [];
+    if (hasInvalidModeSyntax(argv)) {
+        return {
+            mode: options.defaultMode,
+            error: "Invalid value for --mode. Expected sources|installed",
+        };
+    }
+    const modeFromArgv = parseModeFromArgv(argv);
+    return { mode: modeFromArgv ?? options.defaultMode };
+}
+export function setRuntimeMode(mode) {
+    process.env[RUNTIME_MODE_ENV_KEY] = mode;
+}
+export function getRuntimeMode() {
+    const rawMode = process.env[RUNTIME_MODE_ENV_KEY];
+    const normalized = rawMode ? normalizeMode(rawMode) : null;
+    return normalized ?? "sources";
+}

package/dist/runtime/paths.js

@@ -0,0 +1,37 @@
+import os from "node:os";
+import path from "node:path";
+import { getRuntimeMode } from "./mode.js";
+const APP_DIR_NAME = "opencode-telegram-bot";
+function getInstalledAppHome() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, APP_DIR_NAME);
+    }
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", APP_DIR_NAME);
+    }
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    return path.join(xdgConfigHome, APP_DIR_NAME);
+}
+function resolveAppHome(mode) {
+    const homeOverride = process.env.OPENCODE_TELEGRAM_HOME;
+    if (homeOverride && homeOverride.trim().length > 0) {
+        return path.resolve(homeOverride);
+    }
+    if (mode === "sources") {
+        return process.cwd();
+    }
+    return getInstalledAppHome();
+}
+export function getRuntimePaths() {
+    const mode = getRuntimeMode();
+    const appHome = resolveAppHome(mode);
+    return {
+        mode,
+        appHome,
+        envFilePath: path.join(appHome, ".env"),
+        settingsFilePath: path.join(appHome, "settings.json"),
+        logsDirPath: path.join(appHome, "logs"),
+        runDirPath: path.join(appHome, "run"),
+    };
+}

package/dist/session/manager.js

@@ -0,0 +1,10 @@
+import { getCurrentSession as getSettingsSession, setCurrentSession as setSettingsSession, clearSession as clearSettingsSession, } from "../settings/manager.js";
+export function setCurrentSession(sessionInfo) {
+    setSettingsSession(sessionInfo);
+}
+export function getCurrentSession() {
+    return getSettingsSession() ?? null;
+}
+export function clearSession() {
+    clearSettingsSession();
+}

package/dist/session/state.js

@@ -0,0 +1,24 @@
+const state = new Map();
+export function getSessionState(sessionId) {
+    if (!state.has(sessionId)) {
+        state.set(sessionId, {
+            todos: [],
+        });
+    }
+    return state.get(sessionId);
+}
+export function updateLastUserMessage(sessionId, message) {
+    const sessionState = getSessionState(sessionId);
+    sessionState.lastUserMessage = message;
+}
+export function updateTodos(sessionId, todos) {
+    const sessionState = getSessionState(sessionId);
+    sessionState.todos = todos;
+}
+export function updateTokens(sessionId, input, limit) {
+    const sessionState = getSessionState(sessionId);
+    sessionState.lastTokens = { input, limit };
+}
+export function clearSessionState(sessionId) {
+    state.delete(sessionId);
+}

package/dist/settings/manager.js

@@ -0,0 +1,99 @@
+import path from "node:path";
+import { getRuntimePaths } from "../runtime/paths.js";
+import { logger } from "../utils/logger.js";
+function getSettingsFilePath() {
+    return getRuntimePaths().settingsFilePath;
+}
+async function readSettingsFile() {
+    try {
+        const fs = await import("fs/promises");
+        const content = await fs.readFile(getSettingsFilePath(), "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            logger.error("[SettingsManager] Error reading settings file:", error);
+        }
+        return {};
+    }
+}
+function writeSettingsFile(settings) {
+    import("fs/promises").then((fs) => {
+        const settingsFilePath = getSettingsFilePath();
+        fs.mkdir(path.dirname(settingsFilePath), { recursive: true })
+            .then(() => fs.writeFile(settingsFilePath, JSON.stringify(settings, null, 2)))
+            .catch((err) => {
+            logger.error("[SettingsManager] Error writing settings file:", err);
+        });
+    });
+}
+let currentSettings = {};
+export function getCurrentProject() {
+    return currentSettings.currentProject;
+}
+export function setCurrentProject(projectInfo) {
+    currentSettings.currentProject = projectInfo;
+    writeSettingsFile(currentSettings);
+}
+export function clearProject() {
+    currentSettings.currentProject = undefined;
+    writeSettingsFile(currentSettings);
+}
+export function getCurrentSession() {
+    return currentSettings.currentSession;
+}
+export function setCurrentSession(sessionInfo) {
+    currentSettings.currentSession = sessionInfo;
+    writeSettingsFile(currentSettings);
+}
+export function clearSession() {
+    currentSettings.currentSession = undefined;
+    writeSettingsFile(currentSettings);
+}
+export function getCurrentAgent() {
+    return currentSettings.currentAgent;
+}
+export function setCurrentAgent(agentName) {
+    currentSettings.currentAgent = agentName;
+    writeSettingsFile(currentSettings);
+}
+export function clearCurrentAgent() {
+    currentSettings.currentAgent = undefined;
+    writeSettingsFile(currentSettings);
+}
+export function getCurrentModel() {
+    return currentSettings.currentModel;
+}
+export function setCurrentModel(modelInfo) {
+    currentSettings.currentModel = modelInfo;
+    writeSettingsFile(currentSettings);
+}
+export function clearCurrentModel() {
+    currentSettings.currentModel = undefined;
+    writeSettingsFile(currentSettings);
+}
+export function getPinnedMessageId() {
+    return currentSettings.pinnedMessageId;
+}
+export function setPinnedMessageId(messageId) {
+    currentSettings.pinnedMessageId = messageId;
+    writeSettingsFile(currentSettings);
+}
+export function clearPinnedMessageId() {
+    currentSettings.pinnedMessageId = undefined;
+    writeSettingsFile(currentSettings);
+}
+export function getServerProcess() {
+    return currentSettings.serverProcess;
+}
+export function setServerProcess(processInfo) {
+    currentSettings.serverProcess = processInfo;
+    writeSettingsFile(currentSettings);
+}
+export function clearServerProcess() {
+    currentSettings.serverProcess = undefined;
+    writeSettingsFile(currentSettings);
+}
+export async function loadSettings() {
+    currentSettings = await readSettingsFile();
+}

package/dist/status/formatter.js

@@ -0,0 +1,44 @@
+export function formatStatus(data) {
+    const completedTasks = data.todos.filter((t) => t.status === "completed").length;
+    const totalTasks = data.todos.length;
+    const tasksStr = totalTasks > 0 ? `${completedTasks}/${totalTasks}` : "0/0";
+    const contextPercentage = data.contextMax > 0 ? (data.contextUsed / data.contextMax) * 100 : 0;
+    const contextBar = formatContextBar(contextPercentage);
+    const lastUpdated = data.lastUpdated
+        ? new Date(data.lastUpdated).toLocaleTimeString("ru-RU")
+        : new Date().toLocaleTimeString("ru-RU");
+    return `📊 Статус сессии
+
+🏗 Проект: ${formatProjectName(data.projectName)}
+🤖 Модель: ${formatModel(data.model)}
+📝 Сессия: ${data.sessionTitle}
+✅ Задачи: ${tasksStr}
+🔧 Режим: ${data.agent}
+📦 Контекст: ${contextPercentage.toFixed(0)}% ${contextBar}
+
+🕐 Обновлено: ${lastUpdated}`;
+}
+export function formatProjectName(name) {
+    if (name.length <= 30) {
+        return name;
+    }
+    const parts = name.split(/[\/\\]/);
+    const fileName = parts[parts.length - 1] || name;
+    if (fileName.length <= 30) {
+        return fileName;
+    }
+    return `${fileName.substring(0, 20)}...`;
+}
+export function formatModel(model) {
+    return model;
+}
+export function formatContextUsage(used, max) {
+    const percentage = max > 0 ? (used / max) * 100 : 0;
+    return `${percentage.toFixed(0)}% ${formatContextBar(percentage)}`;
+}
+function formatContextBar(percentage) {
+    const totalBars = 10;
+    const filledBars = Math.round((percentage / 100) * totalBars);
+    const emptyBars = totalBars - filledBars;
+    return `[${"█".repeat(filledBars)}${"░".repeat(emptyBars)}]`;
+}