@grinev/opencode-telegram-bot 0.15.0 → 0.16.1

package/dist/bot/utils/telegram-text.js

@@ -1,10 +1,25 @@
-import { editMessageWithMarkdownFallback, sendMessageWithMarkdownFallback, } from "./send-with-markdown-fallback.js";
+import { logger } from "../../utils/logger.js";
+import { editMessageWithMarkdownFallback, isTelegramMarkdownParseError, sendMessageWithMarkdownFallback, } from "./send-with-markdown-fallback.js";
 function resolveParseMode(format) {
     if (format === "markdown_v2") {
         return "MarkdownV2";
     }
     return undefined;
 }
+function stripRichFormattingOptions(options) {
+    if (!options) {
+        return options;
+    }
+    const rawOptions = {
+        ...options,
+    };
+    delete rawOptions.parse_mode;
+    delete rawOptions.entities;
+    return rawOptions;
+}
+export function getTelegramRenderedPartSignature(part) {
+    return `${part.text}\n${JSON.stringify(part.entities ?? null)}`;
+}
 export async function sendBotText({ api, chatId, text, rawFallbackText, options, format = "raw", }) {
     await sendMessageWithMarkdownFallback({
         api,
@@ -15,6 +30,85 @@ export async function sendBotText({ api, chatId, text, rawFallbackText, options,
         parseMode: resolveParseMode(format),
     });
 }
+export async function sendRenderedBotPart({ api, chatId, part, options, }) {
+    const rawOptions = stripRichFormattingOptions(options);
+    logger.debug("[Bot] Sending rendered Telegram part", {
+        source: part.source,
+        textLength: part.text.length,
+        fallbackTextLength: part.fallbackText.length,
+        entityCount: part.entities?.length ?? 0,
+    });
+    if (!part.entities?.length) {
+        const sentMessage = await api.sendMessage(chatId, part.text, rawOptions);
+        return {
+            messageId: sentMessage.message_id,
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.text }),
+        };
+    }
+    try {
+        const sentMessage = await api.sendMessage(chatId, part.text, {
+            ...(rawOptions || {}),
+            entities: part.entities,
+        });
+        return {
+            messageId: sentMessage.message_id,
+            deliveredSignature: getTelegramRenderedPartSignature(part),
+        };
+    }
+    catch (error) {
+        if (!isTelegramMarkdownParseError(error)) {
+            throw error;
+        }
+        logger.warn("[Bot] Entity payload rejected, retrying assistant message part in raw mode", error);
+        const sentMessage = await api.sendMessage(chatId, part.fallbackText, rawOptions);
+        logger.debug("[Bot] Assistant message part sent in raw fallback mode", {
+            fallbackTextLength: part.fallbackText.length,
+        });
+        return {
+            messageId: sentMessage.message_id,
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.fallbackText }),
+        };
+    }
+}
+export async function editRenderedBotPart({ api, chatId, messageId, part, options, }) {
+    const rawOptions = stripRichFormattingOptions(options);
+    logger.debug("[Bot] Editing rendered Telegram part", {
+        messageId,
+        source: part.source,
+        textLength: part.text.length,
+        fallbackTextLength: part.fallbackText.length,
+        entityCount: part.entities?.length ?? 0,
+    });
+    if (!part.entities?.length) {
+        await api.editMessageText(chatId, messageId, part.text, rawOptions);
+        return {
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.text }),
+        };
+    }
+    try {
+        await api.editMessageText(chatId, messageId, part.text, {
+            ...(rawOptions || {}),
+            entities: part.entities,
+        });
+        return {
+            deliveredSignature: getTelegramRenderedPartSignature(part),
+        };
+    }
+    catch (error) {
+        if (!isTelegramMarkdownParseError(error)) {
+            throw error;
+        }
+        logger.warn("[Bot] Entity payload rejected, retrying assistant edit part in raw mode", error);
+        await api.editMessageText(chatId, messageId, part.fallbackText, rawOptions);
+        logger.debug("[Bot] Assistant edit part applied in raw fallback mode", {
+            messageId,
+            fallbackTextLength: part.fallbackText.length,
+        });
+        return {
+            deliveredSignature: getTelegramRenderedPartSignature({ text: part.fallbackText }),
+        };
+    }
+}
 export async function editBotText({ api, chatId, messageId, text, rawFallbackText, options, format = "raw", }) {
     await editMessageWithMarkdownFallback({
         api,

package/dist/cli/args.js

@@ -1,4 +1,11 @@
-import { t } from "../i18n/index.js";
+const CLI_MESSAGES = {
+    unknownCommand: (value) => `Unknown command: ${value}`,
+    modeRequiresValue: "Option --mode requires a value: sources|installed",
+    invalidMode: (value) => `Invalid mode value: ${value}. Expected sources|installed`,
+    unknownOption: (value) => `Unknown option: ${value}`,
+    modeOnlyStart: "Option --mode is supported only for the start command",
+    daemonOnlyStart: "Option --daemon is supported only for the start command",
+};
 const SUPPORTED_COMMANDS = ["start", "status", "stop", "config"];
 function isCliCommand(value) {
     return SUPPORTED_COMMANDS.includes(value);
@@ -16,6 +23,7 @@ export function parseCliArgs(argv) {
     const args = [...argv];
     let command = "start";
     let mode;
+    let daemon = false;
     let showHelp = false;
     let currentIndex = 0;
     const firstArg = args[0];
@@ -23,8 +31,9 @@ export function parseCliArgs(argv) {
         if (!isCliCommand(firstArg)) {
             return {
                 command,
+                daemon,
                 showHelp: true,
-                error: t("cli.args.unknown_command", { value: firstArg }),
+                error: CLI_MESSAGES.unknownCommand(firstArg),
             };
         }
         command = firstArg;
@@ -37,23 +46,30 @@ export function parseCliArgs(argv) {
             currentIndex += 1;
             continue;
         }
+        if (token === "--daemon") {
+            daemon = true;
+            currentIndex += 1;
+            continue;
+        }
         if (token === "--mode") {
             const modeValue = args[currentIndex + 1];
             if (!modeValue || modeValue.startsWith("-")) {
                 return {
                     command,
+                    daemon,
                     mode,
                     showHelp: true,
-                    error: t("cli.args.mode_requires_value"),
+                    error: CLI_MESSAGES.modeRequiresValue,
                 };
             }
             const parsedMode = normalizeMode(modeValue);
             if (!parsedMode) {
                 return {
                     command,
+                    daemon,
                     mode,
                     showHelp: true,
-                    error: t("cli.args.invalid_mode", { value: modeValue }),
+                    error: CLI_MESSAGES.invalidMode(modeValue),
                 };
             }
             mode = parsedMode;
@@ -66,9 +82,10 @@ export function parseCliArgs(argv) {
             if (!parsedMode) {
                 return {
                     command,
+                    daemon,
                     mode,
                     showHelp: true,
-                    error: t("cli.args.invalid_mode", { value: modeValue }),
+                    error: CLI_MESSAGES.invalidMode(modeValue),
                 };
             }
             mode = parsedMode;
@@ -77,21 +94,33 @@ export function parseCliArgs(argv) {
         }
         return {
             command,
+            daemon,
             mode,
             showHelp: true,
-            error: t("cli.args.unknown_option", { value: token }),
+            error: CLI_MESSAGES.unknownOption(token),
         };
     }
     if (command !== "start" && mode) {
         return {
             command,
+            daemon,
+            mode,
+            showHelp: true,
+            error: CLI_MESSAGES.modeOnlyStart,
+        };
+    }
+    if (command !== "start" && daemon) {
+        return {
+            command,
+            daemon,
             mode,
             showHelp: true,
-            error: t("cli.args.mode_only_start"),
+            error: CLI_MESSAGES.daemonOnlyStart,
         };
     }
     return {
         command,
+        daemon,
         mode,
         showHelp,
     };

package/dist/cli.js

@@ -1,10 +1,38 @@
 #!/usr/bin/env node
 import { parseCliArgs } from "./cli/args.js";
 import { resolveRuntimeMode, setRuntimeMode } from "./runtime/mode.js";
-import { t } from "./i18n/index.js";
+import { getRuntimePaths } from "./runtime/paths.js";
 const EXIT_SUCCESS = 0;
 const EXIT_RUNTIME_ERROR = 1;
 const EXIT_INVALID_ARGS = 2;
+const CLI_USAGE = `Usage:
+  opencode-telegram [start] [--daemon] [--mode installed]
+  opencode-telegram status
+  opencode-telegram stop
+  opencode-telegram config
+
+Notes:
+  - No command defaults to start
+  - start runs in foreground by default
+  - --daemon is supported for the installed runtime only`;
+const CLI_MESSAGES = {
+    daemonRequiresInstalled: "Daemon mode is supported only for the installed runtime. Use `opencode-telegram start` for foreground source runs.",
+    unknownServiceError: "Unknown service error.",
+    cleanupStale: "Removed stale daemon state file.",
+    cleanupInvalid: "Removed invalid daemon state file.",
+    startSuccess: "OpenCode Telegram Bot daemon started.",
+    startAlreadyRunning: "OpenCode Telegram Bot daemon is already running.",
+    statusRunning: "Service status: running",
+    statusStopped: "Service status: stopped",
+    stopSuccess: "OpenCode Telegram Bot daemon stopped.",
+    stopAlreadyStopped: "OpenCode Telegram Bot daemon is not running.",
+    linePid: (pid) => `PID: ${pid}`,
+    lineStartedAt: (startedAt) => `Started at: ${startedAt}`,
+    lineUptimeSec: (seconds) => `Uptime: ${seconds} sec`,
+    lineLogFile: (filePath) => `Log file: ${filePath}`,
+    lineAppHome: (appHome) => `App home: ${appHome}`,
+    errorPrefix: (message) => `CLI error: ${message}`,
+};
 function writeStdout(message) {
     process.stdout.write(`${message}\n`);
 }
@@ -12,18 +40,33 @@ function writeStderr(message) {
     process.stderr.write(`${message}\n`);
 }
 function printUsage() {
-    writeStdout(t("cli.usage"));
+    writeStdout(CLI_USAGE);
 }
-function getPlaceholderMessage(command) {
-    if (command === "status") {
-        return t("cli.placeholder.status");
+function formatServiceCleanupMessage(cleanupReason) {
+    if (cleanupReason === "stale") {
+        return CLI_MESSAGES.cleanupStale;
     }
-    if (command === "stop") {
-        return t("cli.placeholder.stop");
+    if (cleanupReason === "invalid") {
+        return CLI_MESSAGES.cleanupInvalid;
     }
-    return t("cli.placeholder.unavailable");
+    return null;
 }
-async function runStartCommand(mode) {
+function formatServiceDetails(details) {
+    const uptimeSec = Math.max(0, Math.floor((Date.now() - Date.parse(details.startedAt)) / 1000));
+    return [
+        CLI_MESSAGES.linePid(details.pid),
+        CLI_MESSAGES.lineStartedAt(details.startedAt),
+        CLI_MESSAGES.lineUptimeSec(uptimeSec),
+        CLI_MESSAGES.lineLogFile(details.logFilePath),
+        CLI_MESSAGES.lineAppHome(details.appHome),
+    ].join("\n");
+}
+function writeOptionalLine(message) {
+    if (message) {
+        writeStdout(message);
+    }
+}
+async function runStartCommand(mode, daemon) {
     const modeResult = resolveRuntimeMode({
         defaultMode: "installed",
         explicitMode: mode,
@@ -32,20 +75,92 @@ async function runStartCommand(mode) {
         throw new Error(modeResult.error);
     }
     setRuntimeMode(modeResult.mode);
+    if (daemon && modeResult.mode !== "installed") {
+        throw new Error(CLI_MESSAGES.daemonRequiresInstalled);
+    }
     const { ensureRuntimeConfigForStart } = await import("./runtime/bootstrap.js");
     await ensureRuntimeConfigForStart();
+    if (daemon) {
+        const { startBotDaemon } = await import("./service/manager.js");
+        const result = await startBotDaemon(modeResult.mode);
+        const cleanupMessage = formatServiceCleanupMessage(result.cleanupReason);
+        const runtimePaths = getRuntimePaths();
+        writeOptionalLine(cleanupMessage);
+        if (!result.success) {
+            if (result.alreadyRunning && result.service) {
+                writeStdout(CLI_MESSAGES.startAlreadyRunning);
+                writeStdout("");
+                writeStdout(formatServiceDetails({
+                    pid: result.service.pid,
+                    startedAt: result.service.startedAt,
+                    logFilePath: result.service.logFilePath,
+                    appHome: runtimePaths.appHome,
+                }));
+                return EXIT_SUCCESS;
+            }
+            throw new Error(result.error || CLI_MESSAGES.unknownServiceError);
+        }
+        if (!result.service) {
+            throw new Error(CLI_MESSAGES.unknownServiceError);
+        }
+        writeStdout(CLI_MESSAGES.startSuccess);
+        writeStdout("");
+        writeStdout(formatServiceDetails({
+            pid: result.service.pid,
+            startedAt: result.service.startedAt,
+            logFilePath: result.service.logFilePath,
+            appHome: runtimePaths.appHome,
+        }));
+        return EXIT_SUCCESS;
+    }
+    const { initializeLogger } = await import("./utils/logger.js");
+    await initializeLogger();
     const { startBotApp } = await import("./app/start-bot-app.js");
     await startBotApp();
     return EXIT_SUCCESS;
 }
 async function runConfigCommand() {
     setRuntimeMode("installed");
+    const { initializeLogger } = await import("./utils/logger.js");
+    await initializeLogger();
     const { runConfigWizardCommand } = await import("./runtime/bootstrap.js");
     await runConfigWizardCommand();
     return EXIT_SUCCESS;
 }
-async function runPlaceholderCommand(command) {
-    writeStdout(getPlaceholderMessage(command));
+async function runStatusCommand() {
+    setRuntimeMode("installed");
+    const { getBotServiceStatus } = await import("./service/manager.js");
+    const runtimePaths = getRuntimePaths();
+    const status = await getBotServiceStatus();
+    writeOptionalLine(formatServiceCleanupMessage(status.cleanupReason));
+    if (status.status !== "running" || !status.service) {
+        writeStdout(CLI_MESSAGES.statusStopped);
+        writeStdout(CLI_MESSAGES.lineAppHome(runtimePaths.appHome));
+        return EXIT_SUCCESS;
+    }
+    writeStdout(CLI_MESSAGES.statusRunning);
+    writeStdout("");
+    writeStdout(formatServiceDetails({
+        pid: status.service.pid,
+        startedAt: status.service.startedAt,
+        logFilePath: status.service.logFilePath,
+        appHome: runtimePaths.appHome,
+    }));
+    return EXIT_SUCCESS;
+}
+async function runStopCommand() {
+    setRuntimeMode("installed");
+    const { stopBotDaemon } = await import("./service/manager.js");
+    const result = await stopBotDaemon();
+    writeOptionalLine(formatServiceCleanupMessage(result.cleanupReason));
+    if (!result.success) {
+        throw new Error(result.error || CLI_MESSAGES.unknownServiceError);
+    }
+    if (result.alreadyStopped) {
+        writeStdout(CLI_MESSAGES.stopAlreadyStopped);
+        return EXIT_SUCCESS;
+    }
+    writeStdout(CLI_MESSAGES.stopSuccess);
     return EXIT_SUCCESS;
 }
 async function runCli(argv) {
@@ -58,12 +173,15 @@ async function runCli(argv) {
         return parsedArgs.error ? EXIT_INVALID_ARGS : EXIT_SUCCESS;
     }
     if (parsedArgs.command === "start") {
-        return runStartCommand(parsedArgs.mode);
+        return runStartCommand(parsedArgs.mode, parsedArgs.daemon);
     }
     if (parsedArgs.command === "config") {
         return runConfigCommand();
     }
-    return runPlaceholderCommand(parsedArgs.command);
+    if (parsedArgs.command === "status") {
+        return runStatusCommand();
+    }
+    return runStopCommand();
 }
 void runCli(process.argv.slice(2))
     .then((exitCode) => {
@@ -71,10 +189,10 @@ void runCli(process.argv.slice(2))
 })
     .catch((error) => {
     if (error instanceof Error) {
-        writeStderr(t("cli.error.prefix", { message: error.message }));
+        writeStderr(CLI_MESSAGES.errorPrefix(error.message));
     }
     else {
-        writeStderr(t("cli.error.prefix", { message: String(error) }));
+        writeStderr(CLI_MESSAGES.errorPrefix(String(error)));
     }
     process.exitCode = EXIT_RUNTIME_ERROR;
 });

package/dist/config.js

@@ -78,11 +78,15 @@ export const config = {
         locale: getOptionalLocaleEnvVar("BOT_LOCALE", "en"),
         hideThinkingMessages: getOptionalBooleanEnvVar("HIDE_THINKING_MESSAGES", false),
         hideToolCallMessages: getOptionalBooleanEnvVar("HIDE_TOOL_CALL_MESSAGES", false),
+        hideToolFileMessages: getOptionalBooleanEnvVar("HIDE_TOOL_FILE_MESSAGES", false),
         messageFormatMode: getOptionalMessageFormatModeEnvVar("MESSAGE_FORMAT_MODE", "markdown"),
     },
     files: {
         maxFileSizeKb: parseInt(getEnvVar("CODE_FILE_MAX_SIZE_KB", false) || "100", 10),
     },
+    open: {
+        browserRoots: getEnvVar("OPEN_BROWSER_ROOTS", false),
+    },
     stt: {
         apiUrl: getEnvVar("STT_API_URL", false),
         apiKey: getEnvVar("STT_API_KEY", false),

package/dist/i18n/de.js

@@ -324,16 +324,6 @@ export const de = {
     "commands.page_empty_callback": "Keine Befehle auf dieser Seite",
     "commands.page_load_error_callback": "Diese Seite konnte nicht geladen werden. Bitte versuche es erneut.",
     "cmd.description.rename": "Aktuelle Sitzung umbenennen",
-    "cli.usage": "Verwendung:\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\nHinweise:\n  - Ohne Befehl wird standardmäßig `start` verwendet\n  - `--mode` wird derzeit nur für `start` unterstützt",
-    "cli.placeholder.status": "Befehl `status` ist derzeit ein Platzhalter. Echte Statusprüfungen werden in der Service-Schicht hinzugefügt (Phase 5).",
-    "cli.placeholder.stop": "Befehl `stop` ist derzeit ein Platzhalter. Ein echter Stop des Hintergrundprozesses wird in der Service-Schicht hinzugefügt (Phase 5).",
-    "cli.placeholder.unavailable": "Befehl ist nicht verfügbar.",
-    "cli.error.prefix": "CLI-Fehler: {message}",
-    "cli.args.unknown_command": "Unbekannter Befehl: {value}",
-    "cli.args.mode_requires_value": "Option --mode erfordert einen Wert: sources|installed",
-    "cli.args.invalid_mode": "Ungültiger Wert für --mode: {value}. Erwartet sources|installed",
-    "cli.args.unknown_option": "Unbekannte Option: {value}",
-    "cli.args.mode_only_start": "Option --mode wird nur für den start-Befehl unterstützt",
     "legacy.models.fetch_error": "🔴 Modellliste konnte nicht geladen werden. Prüfe den Serverstatus mit /status.",
     "legacy.models.empty": "📋 Keine verfügbaren Modelle. Konfiguriere Provider in OpenCode.",
     "legacy.models.header": "📋 Verfügbare Modelle:\n\n",
@@ -345,4 +335,19 @@ export const de = {
     "stt.not_configured": "🎤 Spracherkennung ist nicht konfiguriert.\n\nSetze STT_API_URL und STT_API_KEY in .env, um sie zu aktivieren.",
     "stt.error": "🔴 Audio konnte nicht erkannt werden: {error}",
     "stt.empty_result": "🎤 Keine Sprache in der Audionachricht erkannt.",
+    "cmd.description.open": "Projekt durch Ordner-Auswahl hinzufügen",
+    "open.back": "⬆️ Hoch",
+    "open.roots": "📋 Zurück zur Auswahl",
+    "open.prev_page": "⬅️ Zurück",
+    "open.next_page": "Weiter ➡️",
+    "open.select_current": "✅ Diesen Ordner wählen",
+    "open.select_root": "📂 Stammverzeichnis zum Durchsuchen wählen:",
+    "open.access_denied": "⛔ Zugriff verweigert: Pfad liegt außerhalb erlaubter Verzeichnisse",
+    "open.scan_error": "🔴 Verzeichnis kann nicht durchsucht werden: {error}",
+    "open.open_error": "🔴 Verzeichnisbrowser konnte nicht geöffnet werden.",
+    "open.selected": "✅ Projekt hinzugefügt: {project}\n\n📋 Verwende /sessions oder /new zum Arbeiten.",
+    "open.select_error": "🔴 Projekt konnte nicht hinzugefügt werden.",
+    "open.no_subfolders": "📭 Keine Unterordner",
+    "open.subfolder_count": "{count} Unterordner",
+    "open.subfolders_count": "{count} Unterordner",
 };

package/dist/i18n/en.js

@@ -324,16 +324,6 @@ export const en = {
     "commands.page_empty_callback": "No commands on this page",
     "commands.page_load_error_callback": "Cannot load this page. Please try again.",
     "cmd.description.rename": "Rename current session",
-    "cli.usage": "Usage:\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\nNotes:\n  - No command defaults to `start`\n  - `--mode` is currently supported for `start` only",
-    "cli.placeholder.status": "Command `status` is currently a placeholder. Real status checks will be added in service layer (Phase 5).",
-    "cli.placeholder.stop": "Command `stop` is currently a placeholder. Real background process stop will be added in service layer (Phase 5).",
-    "cli.placeholder.unavailable": "Command is unavailable.",
-    "cli.error.prefix": "CLI error: {message}",
-    "cli.args.unknown_command": "Unknown command: {value}",
-    "cli.args.mode_requires_value": "Option --mode requires a value: sources|installed",
-    "cli.args.invalid_mode": "Invalid mode value: {value}. Expected sources|installed",
-    "cli.args.unknown_option": "Unknown option: {value}",
-    "cli.args.mode_only_start": "Option --mode is supported only for the start command",
     "legacy.models.fetch_error": "🔴 Failed to get models list. Check server status with /status.",
     "legacy.models.empty": "📋 No available models. Configure providers in OpenCode.",
     "legacy.models.header": "📋 Available models:\n\n",
@@ -345,4 +335,19 @@ export const en = {
     "stt.not_configured": "🎤 Voice recognition is not configured.\n\nSet STT_API_URL and STT_API_KEY in .env to enable it.",
     "stt.error": "🔴 Failed to recognize audio: {error}",
     "stt.empty_result": "🎤 No speech detected in the audio message.",
+    "cmd.description.open": "Add a project by browsing directories",
+    "open.back": "⬆️ Up",
+    "open.roots": "📋 Back to roots",
+    "open.prev_page": "⬅️ Previous",
+    "open.next_page": "Next ➡️",
+    "open.select_current": "✅ Select this folder",
+    "open.select_root": "📂 Select a root directory to browse:",
+    "open.access_denied": "⛔ Access denied: path is outside allowed roots",
+    "open.scan_error": "🔴 Cannot browse directory: {error}",
+    "open.open_error": "🔴 Failed to open directory browser.",
+    "open.selected": "✅ Project added: {project}\n\n📋 Use /sessions or /new to start working.",
+    "open.select_error": "🔴 Failed to add project.",
+    "open.no_subfolders": "📭 No subfolders",
+    "open.subfolder_count": "{count} subfolder",
+    "open.subfolders_count": "{count} subfolders",
 };

package/dist/i18n/es.js

@@ -324,16 +324,6 @@ export const es = {
     "commands.page_empty_callback": "No hay comandos en esta página",
     "commands.page_load_error_callback": "No se pudo cargar esta página. Por favor, inténtalo de nuevo.",
     "cmd.description.rename": "Renombrar la sesión actual",
-    "cli.usage": "Uso:\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\nNotas:\n  - Sin comando, el valor por defecto es `start`\n  - `--mode` actualmente solo se admite para `start`",
-    "cli.placeholder.status": "El comando `status` es actualmente un marcador de posición. Las comprobaciones reales de estado se agregarán en la capa de servicio (Fase 5).",
-    "cli.placeholder.stop": "El comando `stop` es actualmente un marcador de posición. La detención real del proceso en segundo plano se agregará en la capa de servicio (Fase 5).",
-    "cli.placeholder.unavailable": "El comando no esta disponible.",
-    "cli.error.prefix": "Error de CLI: {message}",
-    "cli.args.unknown_command": "Comando desconocido: {value}",
-    "cli.args.mode_requires_value": "La opción --mode requiere un valor: sources|installed",
-    "cli.args.invalid_mode": "Valor de --mode inválido: {value}. Se espera sources|installed",
-    "cli.args.unknown_option": "Opción desconocida: {value}",
-    "cli.args.mode_only_start": "La opción --mode solo se admite para el comando start",
     "legacy.models.fetch_error": "🔴 No se pudo obtener la lista de modelos. Revisa el estado del servidor con /status.",
     "legacy.models.empty": "📋 No hay modelos disponibles. Configura los proveedores en OpenCode.",
     "legacy.models.header": "📋 Modelos disponibles:\n\n",
@@ -345,4 +335,19 @@ export const es = {
     "stt.not_configured": "🎤 El reconocimiento de voz no está configurado.\n\nConfigura STT_API_URL y STT_API_KEY en .env para habilitarlo.",
     "stt.error": "🔴 No se pudo reconocer el audio: {error}",
     "stt.empty_result": "🎤 No se detectó voz en el mensaje de audio.",
+    "cmd.description.open": "Añadir proyecto navegando directorios",
+    "open.back": "⬆️ Subir",
+    "open.roots": "📋 Volver a raíces",
+    "open.prev_page": "⬅️ Anterior",
+    "open.next_page": "Siguiente ➡️",
+    "open.select_current": "✅ Seleccionar esta carpeta",
+    "open.select_root": "📂 Selecciona un directorio raíz para explorar:",
+    "open.access_denied": "⛔ Acceso denegado: la ruta está fuera de los directorios permitidos",
+    "open.scan_error": "🔴 No se puede explorar el directorio: {error}",
+    "open.open_error": "🔴 No se pudo abrir el explorador de directorios.",
+    "open.selected": "✅ Proyecto añadido: {project}\n\n📋 Usa /sessions o /new para empezar a trabajar.",
+    "open.select_error": "🔴 No se pudo añadir el proyecto.",
+    "open.no_subfolders": "📭 Sin subcarpetas",
+    "open.subfolder_count": "{count} subcarpeta",
+    "open.subfolders_count": "{count} subcarpetas",
 };

package/dist/i18n/fr.js

@@ -324,16 +324,6 @@ export const fr = {
     "commands.page_empty_callback": "Aucune commande sur cette page",
     "commands.page_load_error_callback": "Impossible de charger cette page. Veuillez réessayer.",
     "cmd.description.rename": "Renommer la session actuelle",
-    "cli.usage": "Utilisation :\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\nNotes :\n  - Sans commande, `start` est utilisé par défaut\n  - `--mode` n'est actuellement pris en charge que pour `start`",
-    "cli.placeholder.status": "La commande `status` est actuellement un placeholder. Les vraies vérifications d'état seront ajoutées dans la couche service (Phase 5).",
-    "cli.placeholder.stop": "La commande `stop` est actuellement un placeholder. Le véritable arrêt du processus en arrière-plan sera ajouté dans la couche service (Phase 5).",
-    "cli.placeholder.unavailable": "Commande indisponible.",
-    "cli.error.prefix": "Erreur CLI : {message}",
-    "cli.args.unknown_command": "Commande inconnue : {value}",
-    "cli.args.mode_requires_value": "L'option --mode nécessite une valeur : sources|installed",
-    "cli.args.invalid_mode": "Valeur de mode invalide : {value}. Attendu : sources|installed",
-    "cli.args.unknown_option": "Option inconnue : {value}",
-    "cli.args.mode_only_start": "L'option --mode est prise en charge uniquement pour la commande start",
     "legacy.models.fetch_error": "🔴 Impossible de récupérer la liste des modèles. Vérifiez l'état du serveur avec /status.",
     "legacy.models.empty": "📋 Aucun modèle disponible. Configurez les fournisseurs dans OpenCode.",
     "legacy.models.header": "📋 Modèles disponibles :\n\n",
@@ -345,4 +335,19 @@ export const fr = {
     "stt.not_configured": "🎤 La reconnaissance vocale n'est pas configurée.\n\nDéfinissez STT_API_URL et STT_API_KEY dans .env pour l'activer.",
     "stt.error": "🔴 Impossible de reconnaître l'audio : {error}",
     "stt.empty_result": "🎤 Aucune parole détectée dans le message audio.",
+    "cmd.description.open": "Ajouter un projet en parcourant les dossiers",
+    "open.back": "⬆️ Remonter",
+    "open.roots": "📋 Retour aux racines",
+    "open.prev_page": "⬅️ Précédent",
+    "open.next_page": "Suivant ➡️",
+    "open.select_current": "✅ Sélectionner ce dossier",
+    "open.select_root": "📂 Sélectionnez un répertoire racine à parcourir :",
+    "open.access_denied": "⛔ Accès refusé : le chemin est en dehors des répertoires autorisés",
+    "open.scan_error": "🔴 Impossible de parcourir le répertoire : {error}",
+    "open.open_error": "🔴 Impossible d'ouvrir l'explorateur de répertoires.",
+    "open.selected": "✅ Projet ajouté : {project}\n\n📋 Utilisez /sessions ou /new pour commencer.",
+    "open.select_error": "🔴 Impossible d'ajouter le projet.",
+    "open.no_subfolders": "📭 Aucun sous-dossier",
+    "open.subfolder_count": "{count} sous-dossier",
+    "open.subfolders_count": "{count} sous-dossiers",
 };

package/dist/i18n/ru.js

@@ -324,16 +324,6 @@ export const ru = {
     "commands.page_empty_callback": "На этой странице нет команд",
     "commands.page_load_error_callback": "Не удалось загрузить эту страницу. Пожалуйста, попробуйте снова.",
     "cmd.description.rename": "Переименовать текущую сессию",
-    "cli.usage": "Использование:\n  opencode-telegram [start] [--mode sources|installed]\n  opencode-telegram status\n  opencode-telegram stop\n  opencode-telegram config\n\nЗаметки:\n  - Без команды по умолчанию используется `start`\n  - `--mode` сейчас поддерживается только для `start`",
-    "cli.placeholder.status": "Команда `status` пока работает как заглушка. Реальная проверка статуса появится на этапе service-слоя (Этап 5).",
-    "cli.placeholder.stop": "Команда `stop` пока работает как заглушка. Реальная остановка фонового процесса появится на этапе service-слоя (Этап 5).",
-    "cli.placeholder.unavailable": "Команда недоступна.",
-    "cli.error.prefix": "CLI error: {message}",
-    "cli.args.unknown_command": "Неизвестная команда: {value}",
-    "cli.args.mode_requires_value": "Опция --mode требует значение: sources|installed",
-    "cli.args.invalid_mode": "Некорректное значение --mode: {value}. Ожидается sources|installed",
-    "cli.args.unknown_option": "Неизвестная опция: {value}",
-    "cli.args.mode_only_start": "Опция --mode поддерживается только для команды start",
     "legacy.models.fetch_error": "🔴 Не удалось получить список моделей. Проверьте статус сервера /status.",
     "legacy.models.empty": "📋 Нет доступных моделей. Настройте провайдеры через OpenCode.",
     "legacy.models.header": "📋 Доступные модели:\n\n",
@@ -345,4 +335,19 @@ export const ru = {
     "stt.not_configured": "🎤 Распознавание голоса не настроено.\n\nУстановите STT_API_URL и STT_API_KEY в .env для включения.",
     "stt.error": "🔴 Не удалось распознать аудио: {error}",
     "stt.empty_result": "🎤 В аудиосообщении не обнаружена речь.",
+    "cmd.description.open": "Добавить проект через обзор папок",
+    "open.back": "⬆️ Наверх",
+    "open.roots": "📋 К списку корней",
+    "open.prev_page": "⬅️ Назад",
+    "open.next_page": "Далее ➡️",
+    "open.select_current": "✅ Выбрать эту папку",
+    "open.select_root": "📂 Выберите корневой каталог для просмотра:",
+    "open.access_denied": "⛔ Доступ запрещён: путь за пределами разрешённых каталогов",
+    "open.scan_error": "🔴 Не удалось открыть каталог: {error}",
+    "open.open_error": "🔴 Не удалось открыть обозреватель каталогов.",
+    "open.selected": "✅ Проект добавлен: {project}\n\n📋 Используйте /sessions или /new для начала работы.",
+    "open.select_error": "🔴 Не удалось добавить проект.",
+    "open.no_subfolders": "📭 Нет подпапок",
+    "open.subfolder_count": "{count} подпапка",
+    "open.subfolders_count": "{count} подпапок",
 };