@grinev/opencode-telegram-bot 0.15.0 → 0.16.0

package/dist/bot/utils/assistant-rendering.js

@@ -0,0 +1,117 @@
+import { config } from "../../config.js";
+import { logger } from "../../utils/logger.js";
+import { chunkTelegramRenderedBlocks } from "../../telegram/render/chunker.js";
+import { renderTelegramBlocks, renderTelegramParts } from "../../telegram/render/pipeline.js";
+export function createPlainRenderedBlock(text) {
+    return {
+        blockType: "plain",
+        mode: "plain",
+        text,
+        fallbackText: text,
+        source: "plain",
+    };
+}
+export function createPlainRenderedParts(text, maxPartLength) {
+    return chunkTelegramRenderedBlocks([createPlainRenderedBlock(text)], { maxPartLength });
+}
+function useAssistantEntitiesFormat() {
+    return config.bot.messageFormatMode === "markdown";
+}
+function renderAssistantBlocksSafe(text) {
+    if (!text) {
+        return [];
+    }
+    try {
+        return renderTelegramBlocks(text);
+    }
+    catch (error) {
+        logger.warn("[AssistantRender] Block rendering failed, falling back to plain streaming block", error);
+        return [createPlainRenderedBlock(text)];
+    }
+}
+export function renderAssistantFinalPartsSafe(text, maxPartLength = 4096) {
+    if (!text) {
+        return [];
+    }
+    const formatMode = useAssistantEntitiesFormat() ? "entities" : "raw";
+    if (!useAssistantEntitiesFormat()) {
+        const parts = createPlainRenderedParts(text, maxPartLength);
+        logger.debug("[AssistantRender] Built final assistant parts in raw mode", {
+            formatMode,
+            textLength: text.length,
+            partCount: parts.length,
+        });
+        return parts;
+    }
+    try {
+        const parts = renderTelegramParts(text, { maxPartLength });
+        logger.debug("[AssistantRender] Built final assistant parts in entities mode", {
+            formatMode,
+            textLength: text.length,
+            partCount: parts.length,
+            richParts: parts.filter((part) => part.source === "entities").length,
+            plainParts: parts.filter((part) => part.source === "plain").length,
+        });
+        return parts;
+    }
+    catch (error) {
+        logger.warn("[AssistantRender] Part rendering failed, falling back to plain text parts", error);
+        const parts = createPlainRenderedParts(text, maxPartLength);
+        logger.debug("[AssistantRender] Built final assistant parts in raw fallback mode", {
+            formatMode,
+            textLength: text.length,
+            partCount: parts.length,
+        });
+        return parts;
+    }
+}
+function getStableStreamingBoundary(messageText) {
+    if (!messageText) {
+        return 0;
+    }
+    if (messageText.endsWith("\n\n")) {
+        return messageText.length;
+    }
+    const lastBlockSeparatorIndex = messageText.lastIndexOf("\n\n");
+    return lastBlockSeparatorIndex >= 0 ? lastBlockSeparatorIndex + 2 : 0;
+}
+export function prepareAssistantStreamingPayload(messageText, maxPartLength) {
+    if (!messageText) {
+        return null;
+    }
+    const formatMode = useAssistantEntitiesFormat() ? "entities" : "raw";
+    if (!useAssistantEntitiesFormat()) {
+        const parts = createPlainRenderedParts(messageText, maxPartLength);
+        logger.debug("[AssistantRender] Built streaming assistant payload in raw mode", {
+            formatMode,
+            textLength: messageText.length,
+            partCount: parts.length,
+        });
+        return parts.length > 0 ? { parts } : null;
+    }
+    const stableBoundary = getStableStreamingBoundary(messageText);
+    const blocks = [];
+    if (stableBoundary > 0) {
+        blocks.push(...renderAssistantBlocksSafe(messageText.slice(0, stableBoundary)));
+    }
+    const unstableTail = stableBoundary > 0 ? messageText.slice(stableBoundary) : messageText;
+    if (unstableTail) {
+        blocks.push(createPlainRenderedBlock(unstableTail));
+    }
+    const parts = chunkTelegramRenderedBlocks(blocks, { maxPartLength });
+    logger.debug("[AssistantRender] Built streaming assistant payload in entities mode", {
+        formatMode,
+        textLength: messageText.length,
+        stableBoundary,
+        tailLength: unstableTail.length,
+        blockCount: blocks.length,
+        partCount: parts.length,
+        richParts: parts.filter((part) => part.source === "entities").length,
+        plainParts: parts.filter((part) => part.source === "plain").length,
+    });
+    return parts.length > 0 ? { parts } : null;
+}
+export function prepareAssistantFinalStreamingPayload(messageText, maxPartLength) {
+    const parts = renderAssistantFinalPartsSafe(messageText, maxPartLength);
+    return parts.length > 0 ? { parts } : null;
+}

package/dist/bot/utils/assistant-run-footer.js

@@ -0,0 +1,9 @@
+import { getAgentDisplayName } from "../../agent/types.js";
+function formatElapsedSeconds(elapsedMs) {
+    const safeElapsedMs = Math.max(0, elapsedMs);
+    return `${(safeElapsedMs / 1000).toFixed(1)}s`;
+}
+export function formatAssistantRunFooter({ agent, providerID, modelID, elapsedMs, }) {
+    const agentDisplay = getAgentDisplayName(agent);
+    return `${agentDisplay} · 🤖 ${providerID}/${modelID} · 🕒 ${formatElapsedSeconds(elapsedMs)}`;
+}

package/dist/bot/utils/browser-roots.js

@@ -0,0 +1,140 @@
+import path from "node:path";
+import { realpath } from "node:fs/promises";
+import os from "node:os";
+import { logger } from "../../utils/logger.js";
+/**
+ * Allowed root directories for the `/open` command.
+ *
+ * Configured via `OPEN_BROWSER_ROOTS` env var (comma-separated absolute paths).
+ * Defaults to `[os.homedir()]` when the variable is not set.
+ *
+ * All navigation in the directory browser is restricted to stay within one
+ * of the configured roots. This prevents the bot from browsing arbitrary
+ * locations on the filesystem.
+ */
+let resolvedRoots = null;
+function isWindows() {
+    return process.platform === "win32";
+}
+function resolveConfiguredPath(p) {
+    return path.resolve(expandTilde(p));
+}
+/**
+ * Expand a leading `~` or `~/` to the user's home directory.
+ * Does not handle `~user/` syntax — only the current user's home.
+ */
+function expandTilde(p) {
+    if (p === "~") {
+        return os.homedir();
+    }
+    if (p.startsWith("~/") || p.startsWith("~\\")) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    return p;
+}
+/**
+ * Normalize a path for comparison: expand tilde, resolve, then lowercase on Windows.
+ */
+function normalizePath(p) {
+    const resolved = resolveConfiguredPath(p);
+    return isWindows() ? resolved.toLowerCase() : resolved;
+}
+/**
+ * Initialize (or re-initialize) the allowed browser roots from the raw
+ * env string. Each entry is resolved to an absolute path via `path.resolve`.
+ *
+ * Entries that cannot be resolved are logged and skipped.
+ */
+export function initBrowserRoots(raw) {
+    if (!raw || raw.trim() === "") {
+        resolvedRoots = [resolveConfiguredPath(os.homedir())];
+        logger.debug(`[BrowserRoots] No OPEN_BROWSER_ROOTS configured, defaulting to home: ${resolvedRoots[0]}`);
+        return;
+    }
+    const entries = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    const roots = [];
+    for (const entry of entries) {
+        roots.push(resolveConfiguredPath(entry));
+    }
+    if (roots.length === 0) {
+        resolvedRoots = [resolveConfiguredPath(os.homedir())];
+        logger.warn("[BrowserRoots] All configured roots were invalid, falling back to home directory");
+    }
+    else {
+        resolvedRoots = roots;
+        logger.info(`[BrowserRoots] Configured roots: ${roots.join(", ")}`);
+    }
+}
+/**
+ * Return the configured browser roots. Lazily initializes from env if
+ * `initBrowserRoots` was never called.
+ */
+export function getBrowserRoots() {
+    if (resolvedRoots === null) {
+        initBrowserRoots(process.env.OPEN_BROWSER_ROOTS);
+    }
+    return resolvedRoots;
+}
+/**
+ * Return the original (non-normalized) root paths for display/navigation.
+ * On Windows the display roots are lowercased because `normalizePath` is
+ * used during init — this is acceptable for button labels.
+ */
+export function getBrowserRootPaths() {
+    return getBrowserRoots();
+}
+/**
+ * Check whether a target path is inside one of the allowed roots.
+ *
+ * Uses `path.resolve` on the target for consistent comparison, then
+ * checks that the target equals a root or is a descendant (starts with
+ * root + separator).
+ *
+ * For full symlink-proof validation, callers can optionally resolve the
+ * target with `fs.realpath` before calling this function.
+ */
+export function isWithinAllowedRoot(targetPath) {
+    const normalizedTarget = normalizePath(targetPath);
+    const roots = getBrowserRoots();
+    for (const root of roots) {
+        const normalizedRoot = normalizePath(root);
+        if (normalizedTarget === normalizedRoot) {
+            return true;
+        }
+        // Check both separators — `path.sep` is always `/` on Unix but a
+        // lowercased Windows path may contain either `\` or `/`.
+        if (normalizedTarget.startsWith(normalizedRoot + "/") ||
+            normalizedTarget.startsWith(normalizedRoot + "\\")) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Like `isWithinAllowedRoot` but resolves symlinks first using `realpath`.
+ * Falls back to the plain path if `realpath` fails (e.g. ENOENT).
+ */
+export async function isWithinAllowedRootSafe(targetPath) {
+    let resolved = targetPath;
+    try {
+        resolved = await realpath(targetPath);
+    }
+    catch {
+        // Path doesn't exist yet or can't be resolved — use as-is
+    }
+    return isWithinAllowedRoot(resolved);
+}
+/**
+ * Check whether a path is exactly one of the allowed roots (not a descendant).
+ */
+export function isAllowedRoot(targetPath) {
+    const normalizedTarget = normalizePath(targetPath);
+    return getBrowserRoots().some((root) => normalizePath(root) === normalizedTarget);
+}
+/** Reset state — for testing only. */
+export function __resetBrowserRootsForTests() {
+    resolvedRoots = null;
+}

package/dist/bot/utils/file-tree.js

@@ -0,0 +1,92 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { t } from "../../i18n/index.js";
+export const MAX_ENTRIES_PER_PAGE = 8;
+export function getHomeDirectory() {
+    return os.homedir();
+}
+export function pathToDisplayPath(absolutePath) {
+    const home = getHomeDirectory();
+    if (absolutePath === home) {
+        return "~";
+    }
+    if (absolutePath.startsWith(home + path.sep)) {
+        return "~" + absolutePath.slice(home.length);
+    }
+    return absolutePath;
+}
+export async function scanDirectory(dirPath, page = 0) {
+    try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const subdirs = [];
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                subdirs.push({
+                    name: entry.name,
+                    fullPath: path.join(dirPath, entry.name),
+                });
+            }
+        }
+        subdirs.sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }));
+        const parentPath = path.dirname(dirPath);
+        const hasParent = dirPath !== path.parse(dirPath).root;
+        // Clamp page to valid range so stale or crafted callbacks never produce
+        // an out-of-bounds page indicator like "(4/2)".
+        const totalPages = Math.max(1, Math.ceil(subdirs.length / MAX_ENTRIES_PER_PAGE));
+        const safePage = Math.max(0, Math.min(page, totalPages - 1));
+        const start = safePage * MAX_ENTRIES_PER_PAGE;
+        const pageEntries = subdirs.slice(start, start + MAX_ENTRIES_PER_PAGE);
+        return {
+            entries: pageEntries,
+            totalCount: subdirs.length,
+            page: safePage,
+            currentPath: dirPath,
+            displayPath: pathToDisplayPath(dirPath),
+            hasParent,
+            parentPath: hasParent ? parentPath : null,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if ("code" in error) {
+                const code = error.code;
+                if (code === "ENOENT" || code === "ELOOP") {
+                    return { error: `Directory not found: ${dirPath}`, code: "ENOENT" };
+                }
+                if (code === "EACCES" || code === "EPERM") {
+                    return { error: `Permission denied: ${dirPath}`, code: "EACCES" };
+                }
+                if (code === "ENOTDIR") {
+                    return { error: `Not a directory: ${dirPath}`, code: "ENOTDIR" };
+                }
+            }
+        }
+        return {
+            error: error instanceof Error ? error.message : "Unknown error",
+            code: "UNKNOWN",
+        };
+    }
+}
+export function buildEntryLabel(entry) {
+    return `📁 ${entry.name}`;
+}
+export function buildTreeHeader(displayPath, totalCount, page, totalPages) {
+    let header = `📂 ${displayPath}`;
+    if (totalPages > 1) {
+        header += `  (${page + 1}/${totalPages})`;
+    }
+    if (totalCount === 0) {
+        header += `\n${t("open.no_subfolders")}`;
+    }
+    else if (totalCount === 1) {
+        header += `\n${t("open.subfolder_count", { count: String(totalCount) })}`;
+    }
+    else {
+        header += `\n${t("open.subfolders_count", { count: String(totalCount) })}`;
+    }
+    return header;
+}
+export function isScanError(result) {
+    return "error" in result;
+}

package/dist/bot/utils/finalize-assistant-response.js

@@ -1,35 +1,29 @@
 import { logger } from "../../utils/logger.js";
-export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, formatSummary, formatRawSummary, resolveFormat, getReplyKeyboard, sendText, deleteMessages, }) {
-    let streamedMessageIds = [];
+export async function finalizeAssistantResponse({ sessionId, messageId, messageText, responseStreamer, flushPendingServiceMessages, prepareStreamingPayload, renderFinalParts, getReplyKeyboard, sendRenderedPart, }) {
+    logger.debug(`[FinalizeResponse] Final assistant raw text received: session=${sessionId}, message=${messageId}`, messageText);
+    const keyboard = getReplyKeyboard();
+    const replyOptions = keyboard ? { reply_markup: keyboard } : undefined;
+    const silentReplyOptions = {
+        disable_notification: true,
+        ...(replyOptions ?? {}),
+    };
+    const streamSendOptions = {
+        ...silentReplyOptions,
+    };
     const preparedStreamPayload = prepareStreamingPayload(messageText);
     if (preparedStreamPayload) {
-        preparedStreamPayload.sendOptions = { disable_notification: true };
+        preparedStreamPayload.sendOptions = streamSendOptions;
         preparedStreamPayload.editOptions = undefined;
     }
     const result = await responseStreamer.complete(sessionId, messageId, preparedStreamPayload ?? undefined);
-    if (result.streamed) {
-        streamedMessageIds = result.telegramMessageIds;
-    }
     await flushPendingServiceMessages();
-    // When the response was streamed, delete the streamed messages and re-send
-    // via the non-streamed path so the reply keyboard carries the latest context.
-    if (streamedMessageIds.length > 0) {
-        try {
-            await deleteMessages(streamedMessageIds);
-        }
-        catch (err) {
-            logger.warn("[FinalizeResponse] Failed to delete streamed messages, sending with keyboard anyway:", err);
-        }
+    if (result.streamed) {
+        logger.debug(`[FinalizeResponse] Finalized streamed assistant message in place: session=${sessionId}, message=${messageId}, telegramMessages=${result.telegramMessageIds.length}`);
+        return true;
     }
-    const parts = formatSummary(messageText);
-    const rawParts = formatRawSummary(messageText);
-    const format = resolveFormat();
-    for (let partIndex = 0; partIndex < parts.length; partIndex++) {
-        const part = parts[partIndex];
-        const rawFallbackText = rawParts[partIndex];
-        const keyboard = getReplyKeyboard();
-        const options = keyboard ? { reply_markup: keyboard } : undefined;
-        await sendText(part, rawFallbackText, options, format);
+    const parts = renderFinalParts(messageText);
+    for (const part of parts) {
+        await sendRenderedPart(part, silentReplyOptions);
     }
     return false;
 }

package/dist/bot/utils/send-with-markdown-fallback.js

@@ -110,7 +110,7 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, rawFa
         if (parseMode === "MarkdownV2") {
             const escapedText = escapeTelegramMarkdownV2(text);
             if (escapedText !== text) {
-                logger.warn("[Bot] Markdown parse failed, retrying assistant message with escaped MarkdownV2", error);
+                logger.warn("[Bot] Markdown parse failed, retrying message with escaped MarkdownV2", error);
                 try {
                     return await api.sendMessage(chatId, escapedText, markdownOptions);
                 }
@@ -118,12 +118,12 @@ export async function sendMessageWithMarkdownFallback({ api, chatId, text, rawFa
                     if (!isTelegramMarkdownParseError(escapedError)) {
                         throw escapedError;
                     }
-                    logger.warn("[Bot] Escaped Markdown parse failed, retrying assistant message in raw mode", escapedError);
+                    logger.warn("[Bot] Escaped Markdown parse failed, retrying message in raw mode", escapedError);
                     return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
                 }
             }
         }
-        logger.warn("[Bot] Markdown parse failed, retrying assistant message in raw mode", error);
+        logger.warn("[Bot] Markdown parse failed, retrying message in raw mode", error);
         return api.sendMessage(chatId, fallbackText, stripMarkdownFormattingOptions(options));
     }
 }

package/dist/bot/utils/switch-project.js

@@ -0,0 +1,48 @@
+import { setCurrentProject } from "../../settings/manager.js";
+import { clearSession } from "../../session/manager.js";
+import { summaryAggregator } from "../../summary/aggregator.js";
+import { pinnedMessageManager } from "../../pinned/manager.js";
+import { keyboardManager } from "../../keyboard/manager.js";
+import { getStoredAgent, resolveProjectAgent } from "../../agent/manager.js";
+import { getStoredModel } from "../../model/manager.js";
+import { formatVariantForButton } from "../../variant/manager.js";
+import { clearAllInteractionState } from "../../interaction/cleanup.js";
+import { createMainKeyboard } from "./keyboard.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Shared logic for switching the active project.
+ *
+ * Called by both `/projects` (selecting an existing project) and `/open`
+ * (browsing and adding a new directory). Performs the full state transition:
+ * persists the project, clears the session, resets the pinned message and
+ * keyboard, and returns a fresh reply keyboard for the caller to attach to
+ * its confirmation message.
+ *
+ * @param ctx       grammY callback context (used for `ctx.chat` / `ctx.api`)
+ * @param project   the project to switch to
+ * @param reason    short tag for `clearAllInteractionState` (e.g. "project_switched")
+ */
+export async function switchToProject(ctx, project, reason) {
+    setCurrentProject(project);
+    clearSession();
+    summaryAggregator.clear();
+    clearAllInteractionState(reason);
+    try {
+        await pinnedMessageManager.clear();
+    }
+    catch (err) {
+        logger.error("[Bot] Error clearing pinned message:", err);
+    }
+    if (ctx.chat) {
+        keyboardManager.initialize(ctx.api, ctx.chat.id);
+    }
+    await pinnedMessageManager.refreshContextLimit();
+    const contextLimit = pinnedMessageManager.getContextLimit();
+    keyboardManager.updateContext(0, contextLimit);
+    const currentAgent = await resolveProjectAgent(getStoredAgent());
+    const currentModel = getStoredModel();
+    const contextInfo = { tokensUsed: 0, tokensLimit: contextLimit };
+    const variantName = formatVariantForButton(currentModel.variant || "default");
+    keyboardManager.updateAgent(currentAgent);
+    return createMainKeyboard(currentAgent, currentModel, contextInfo, variantName);
+}

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.js

@@ -32,6 +32,8 @@ async function runStartCommand(mode) {
         throw new Error(modeResult.error);
     }
     setRuntimeMode(modeResult.mode);
+    const { initializeLogger } = await import("./utils/logger.js");
+    await initializeLogger();
     const { ensureRuntimeConfigForStart } = await import("./runtime/bootstrap.js");
     await ensureRuntimeConfigForStart();
     const { startBotApp } = await import("./app/start-bot-app.js");
@@ -40,6 +42,8 @@ async function runStartCommand(mode) {
 }
 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;

package/dist/config.js

@@ -83,6 +83,9 @@ export const config = {
     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

@@ -345,4 +345,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

@@ -345,4 +345,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",
 };