@grinev/opencode-telegram-bot 0.1.1 → 0.2.0

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

@@ -3,6 +3,7 @@ import { createBot } from "../bot/index.js";
 import { config } from "../config.js";
 import { loadSettings } from "../settings/manager.js";
 import { processManager } from "../process/manager.js";
+import { warmupSessionDirectoryCache } from "../session/cache-manager.js";
 import { getRuntimeMode } from "../runtime/mode.js";
 import { logger } from "../utils/logger.js";
 async function getBotVersion() {
@@ -25,6 +26,7 @@ export async function startBotApp() {
     logger.debug(`[Runtime] Application start mode: ${mode}`);
     await loadSettings();
     await processManager.initialize();
+    await warmupSessionDirectoryCache();
     const bot = createBot();
     const webhookInfo = await bot.api.getWebhookInfo();
     if (webhookInfo.url) {

package/dist/bot/commands/new.js

@@ -1,5 +1,6 @@
 import { opencodeClient } from "../../opencode/client.js";
 import { setCurrentSession } from "../../session/manager.js";
+import { ingestSessionInfoForCache } from "../../session/cache-manager.js";
 import { getCurrentProject } from "../../settings/manager.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
 import { keyboardManager } from "../../keyboard/manager.js";
@@ -30,6 +31,7 @@ export async function newCommand(ctx) {
             directory: currentProject.worktree,
         };
         setCurrentSession(sessionInfo);
+        await ingestSessionInfoForCache(session);
         // Initialize pinned message manager and create pinned message
         if (!pinnedMessageManager.isInitialized()) {
             pinnedMessageManager.initialize(ctx.api, ctx.chat.id);

package/dist/bot/commands/projects.js

@@ -1,6 +1,7 @@
 import { InlineKeyboard } from "grammy";
 import { setCurrentProject, getCurrentProject } from "../../settings/manager.js";
 import { getProjects } from "../../project/manager.js";
+import { syncSessionDirectoryCache } from "../../session/cache-manager.js";
 import { clearSession } from "../../session/manager.js";
 import { summaryAggregator } from "../../summary/aggregator.js";
 import { pinnedMessageManager } from "../../pinned/manager.js";
@@ -12,6 +13,7 @@ import { createMainKeyboard } from "../utils/keyboard.js";
 import { logger } from "../../utils/logger.js";
 import { t } from "../../i18n/index.js";
 const MAX_INLINE_BUTTON_LABEL_LENGTH = 64;
+const MAX_PROJECTS_TO_SHOW = 10;
 function formatProjectButtonLabel(label, isActive) {
     const prefix = isActive ? "✅ " : "";
     const availableLength = MAX_INLINE_BUTTON_LABEL_LENGTH - prefix.length;
@@ -22,14 +24,16 @@ function formatProjectButtonLabel(label, isActive) {
 }
 export async function projectsCommand(ctx) {
     try {
+        await syncSessionDirectoryCache();
         const projects = await getProjects();
-        if (projects.length === 0) {
+        const projectsToShow = projects.slice(0, MAX_PROJECTS_TO_SHOW);
+        if (projectsToShow.length === 0) {
             await ctx.reply(t("projects.empty"));
             return;
         }
         const keyboard = new InlineKeyboard();
         const currentProject = getCurrentProject();
-        projects.forEach((project, index) => {
+        projectsToShow.forEach((project, index) => {
             const isActive = currentProject &&
                 (project.id === currentProject.id || project.worktree === currentProject.worktree);
             const label = project.name

package/dist/bot/index.js

@@ -8,6 +8,7 @@ import { BOT_COMMANDS } from "./commands/definitions.js";
 import { startCommand } from "./commands/start.js";
 import { helpCommand } from "./commands/help.js";
 import { statusCommand } from "./commands/status.js";
+import { MODEL_BUTTON_TEXT_PATTERN, VARIANT_BUTTON_TEXT_PATTERN } from "./message-patterns.js";
 import { sessionsCommand, handleSessionSelect } from "./commands/sessions.js";
 import { newCommand } from "./commands/new.js";
 import { projectsCommand, handleProjectSelect } from "./commands/projects.js";
@@ -29,6 +30,7 @@ import { summaryAggregator } from "../summary/aggregator.js";
 import { formatSummary, formatToolInfo } from "../summary/formatter.js";
 import { opencodeClient } from "../opencode/client.js";
 import { getCurrentSession, setCurrentSession } from "../session/manager.js";
+import { ingestSessionInfoForCache } from "../session/cache-manager.js";
 import { getCurrentProject } from "../settings/manager.js";
 import { getStoredAgent } from "../agent/manager.js";
 import { getStoredModel } from "../model/manager.js";
@@ -256,6 +258,15 @@ async function ensureEventSubscription() {
     });
     logger.info(`[Bot] Subscribing to OpenCode events for project: ${currentProject.worktree}`);
     subscribeToEvents(currentProject.worktree, (event) => {
+        if (event.type === "session.created" || event.type === "session.updated") {
+            const info = event.properties.info;
+            if (info?.directory) {
+                safeBackgroundTask({
+                    taskName: `session.cache.${event.type}`,
+                    task: () => ingestSessionInfoForCache(info),
+                });
+            }
+        }
         summaryAggregator.processEvent(event);
     }).catch((err) => {
         logger.error("Failed to subscribe to events:", err);
@@ -369,8 +380,8 @@ export function createBot() {
         }
     });
     // Handle Reply Keyboard button press (model selector)
-    // Pattern: "ProviderName/ModelName" (may contain spaces, dots, parentheses, etc.)
-    bot.hears(/^[A-Za-z0-9\-\. ]+\/[A-Za-z0-9\-\. ()]+\.{0,3}$/, async (ctx) => {
+    // Model button text is produced by formatModelForButton() and always starts with "🤖 ".
+    bot.hears(MODEL_BUTTON_TEXT_PATTERN, async (ctx) => {
         logger.debug(`[Bot] Model button pressed: ${ctx.message?.text}`);
         try {
             await showModelSelectionMenu(ctx);
@@ -392,7 +403,8 @@ export function createBot() {
         }
     });
     // Handle Reply Keyboard button press (variant selector)
-    bot.hears(/^💭 \w+$/, async (ctx) => {
+    // Keep support for both legacy "💭" and current "💡" prefix.
+    bot.hears(VARIANT_BUTTON_TEXT_PATTERN, async (ctx) => {
         logger.debug(`[Bot] Variant button pressed: ${ctx.message?.text}`);
         try {
             await showVariantSelectionMenu(ctx);
@@ -476,6 +488,7 @@ export function createBot() {
                 directory: currentProject.worktree,
             };
             setCurrentSession(currentSession);
+            await ingestSessionInfoForCache(session);
             // Create pinned message for new session
             try {
                 await pinnedMessageManager.onSessionChange(session.id, session.title);

package/dist/bot/message-patterns.js

@@ -0,0 +1,3 @@
+export const MODEL_BUTTON_TEXT_PATTERN = /^🤖\s.+$/;
+// Keep support for both legacy "💭" and current "💡" prefix.
+export const VARIANT_BUTTON_TEXT_PATTERN = /^(💡|💭)\s.+$/;

package/dist/i18n/en.js

@@ -47,7 +47,7 @@ export const en = {
     "status.session_not_selected": "📋 Current session: not selected",
     "status.session_hint": "Use /sessions to select one or /new to create one",
     "status.server_unavailable": "🔴 OpenCode Server is unavailable\n\nUse /opencode_start to start the server.",
-    "projects.empty": "📭 No projects found.",
+    "projects.empty": "📭 No projects found.\n\nOpen a directory in OpenCode and create at least one session, then it will appear here.",
     "projects.select": "Select a project:",
     "projects.select_with_current": "Select a project:\n\nCurrent: 🏗 {project}",
     "projects.fetch_error": "🔴 OpenCode Server is unavailable or an error occurred while loading projects.",

package/dist/i18n/ru.js

@@ -47,7 +47,7 @@ export const ru = {
     "status.session_not_selected": "📋 Текущая сессия: не выбрана",
     "status.session_hint": "Используйте /sessions для выбора или /new для создания",
     "status.server_unavailable": "🔴 OpenCode Server недоступен\n\nИспользуйте /opencode_start для запуска сервера.",
-    "projects.empty": "📭 Проектов нет.",
+    "projects.empty": "📭 Проектов нет.\n\nОткройте директорию в OpenCode и создайте хотя бы одну сессию, после этого она появится здесь.",
     "projects.select": "Выберите проект:",
     "projects.select_with_current": "Выберите проект:\n\nТекущий: 🏗 {project}",
     "projects.fetch_error": "🔴 OpenCode Server недоступен или произошла ошибка при получении списка проектов.",

package/dist/project/manager.js

@@ -1,14 +1,74 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
 import { opencodeClient } from "../opencode/client.js";
+import { getCachedSessionProjects } from "../session/cache-manager.js";
+import { logger } from "../utils/logger.js";
+async function isLinkedGitWorktree(worktree) {
+    if (worktree === "/") {
+        return false;
+    }
+    const gitPath = path.join(worktree, ".git");
+    try {
+        const gitStat = await stat(gitPath);
+        if (!gitStat.isFile()) {
+            return false;
+        }
+        const gitPointer = (await readFile(gitPath, "utf-8")).trim();
+        const match = gitPointer.match(/^gitdir:\s*(.+)$/i);
+        if (!match) {
+            return false;
+        }
+        const gitDir = path.resolve(worktree, match[1].trim()).replace(/\\/g, "/").toLowerCase();
+        return gitDir.includes("/.git/worktrees/");
+    }
+    catch {
+        return false;
+    }
+}
+function worktreeKey(worktree) {
+    if (process.platform === "win32") {
+        return worktree.toLowerCase();
+    }
+    return worktree;
+}
 export async function getProjects() {
     const { data: projects, error } = await opencodeClient.project.list();
     if (error || !projects) {
         throw error || new Error("No data received from server");
     }
-    return projects.map((project) => ({
+    const apiProjects = projects.map((project) => ({
         id: project.id,
         worktree: project.worktree,
         name: project.name || project.worktree,
+        lastUpdated: project.time?.updated ?? 0,
     }));
+    const cachedProjects = await getCachedSessionProjects();
+    const mergedByWorktree = new Map();
+    for (const apiProject of apiProjects) {
+        mergedByWorktree.set(worktreeKey(apiProject.worktree), apiProject);
+    }
+    for (const cachedProject of cachedProjects) {
+        const key = worktreeKey(cachedProject.worktree);
+        const existing = mergedByWorktree.get(key);
+        if (existing) {
+            if ((cachedProject.lastUpdated ?? 0) > existing.lastUpdated) {
+                existing.lastUpdated = cachedProject.lastUpdated;
+            }
+            continue;
+        }
+        mergedByWorktree.set(key, {
+            id: cachedProject.id,
+            worktree: cachedProject.worktree,
+            name: cachedProject.name,
+            lastUpdated: cachedProject.lastUpdated ?? 0,
+        });
+    }
+    const projectList = Array.from(mergedByWorktree.values()).sort((left, right) => right.lastUpdated - left.lastUpdated);
+    const linkedWorktreeFlags = await Promise.all(projectList.map((project) => isLinkedGitWorktree(project.worktree)));
+    const visibleProjects = projectList.filter((_, index) => !linkedWorktreeFlags[index]);
+    const hiddenLinkedWorktrees = projectList.length - visibleProjects.length;
+    logger.debug(`[ProjectManager] Projects resolved: api=${projects.length}, cached=${cachedProjects.length}, hiddenLinkedWorktrees=${hiddenLinkedWorktrees}, total=${visibleProjects.length}`);
+    return visibleProjects.map(({ id, worktree, name }) => ({ id, worktree, name }));
 }
 export async function getProjectById(id) {
     const projects = await getProjects();

package/dist/session/cache-manager.js

@@ -0,0 +1,400 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { opencodeClient } from "../opencode/client.js";
+import { getSessionDirectoryCache, setSessionDirectoryCache } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+const CACHE_VERSION = 1;
+const INITIAL_WARMUP_LIMIT = 1000;
+const INCREMENTAL_SYNC_LIMIT = 1000;
+const MAX_CACHED_DIRECTORIES = 10;
+const SYNC_SAFETY_WINDOW_MS = 60_000;
+const SYNC_COOLDOWN_MS = 60_000;
+const STORAGE_FALLBACK_SCAN_LIMIT = 200;
+const SQLITE_FALLBACK_QUERY_LIMIT = 200;
+const EMPTY_CACHE = {
+    version: CACHE_VERSION,
+    lastSyncedUpdatedAt: 0,
+    directories: [],
+};
+function createEmptyCacheData() {
+    return {
+        version: EMPTY_CACHE.version,
+        lastSyncedUpdatedAt: EMPTY_CACHE.lastSyncedUpdatedAt,
+        directories: [],
+    };
+}
+let cacheData = createEmptyCacheData();
+let cacheLoaded = false;
+let syncInFlight = null;
+let lastSyncAttemptAt = 0;
+let persistQueue = Promise.resolve();
+function worktreeKey(worktree) {
+    if (process.platform === "win32") {
+        return worktree.toLowerCase();
+    }
+    return worktree;
+}
+function isValidWorktree(worktree) {
+    const trimmed = worktree.trim();
+    return trimmed.length > 0 && trimmed !== "/";
+}
+function normalizeCacheData(raw) {
+    if (!raw || typeof raw !== "object") {
+        return createEmptyCacheData();
+    }
+    const value = raw;
+    const lastSyncedUpdatedAt = typeof value.lastSyncedUpdatedAt === "number" && Number.isFinite(value.lastSyncedUpdatedAt)
+        ? value.lastSyncedUpdatedAt
+        : 0;
+    const directories = Array.isArray(value.directories)
+        ? value.directories
+            .filter((item) => Boolean(item) &&
+            typeof item === "object" &&
+            typeof item.worktree === "string" &&
+            typeof item.lastUpdated === "number")
+            .map((item) => ({
+            worktree: item.worktree.trim(),
+            lastUpdated: item.lastUpdated,
+        }))
+            .filter((item) => isValidWorktree(item.worktree))
+        : [];
+    const data = {
+        version: CACHE_VERSION,
+        lastSyncedUpdatedAt,
+        directories,
+    };
+    dedupeAndTrimDirectories(data);
+    return data;
+}
+function dedupeAndTrimDirectories(data) {
+    const unique = new Map();
+    for (const item of data.directories) {
+        const key = worktreeKey(item.worktree);
+        const existing = unique.get(key);
+        if (!existing || existing.lastUpdated < item.lastUpdated) {
+            unique.set(key, item);
+        }
+    }
+    data.directories = Array.from(unique.values())
+        .sort((a, b) => b.lastUpdated - a.lastUpdated)
+        .slice(0, MAX_CACHED_DIRECTORIES);
+}
+async function ensureCacheLoaded() {
+    if (cacheLoaded) {
+        return;
+    }
+    const storedCache = getSessionDirectoryCache();
+    cacheData = normalizeCacheData(storedCache);
+    cacheLoaded = true;
+    logger.debug(`[SessionCache] Loaded ${cacheData.directories.length} directories from settings.sessionDirectoryCache`);
+}
+function queuePersist() {
+    persistQueue = persistQueue
+        .catch(() => {
+        // Keep queue chain alive if previous write failed.
+    })
+        .then(async () => {
+        try {
+            await setSessionDirectoryCache(cacheData);
+        }
+        catch (error) {
+            logger.error("[SessionCache] Failed to persist sessions cache", error);
+        }
+    });
+    return persistQueue;
+}
+function upsertDirectory(worktree, lastUpdated) {
+    if (!isValidWorktree(worktree)) {
+        return false;
+    }
+    const normalizedWorktree = worktree.trim();
+    const key = worktreeKey(normalizedWorktree);
+    const existingIndex = cacheData.directories.findIndex((item) => worktreeKey(item.worktree) === key);
+    if (existingIndex >= 0) {
+        const existing = cacheData.directories[existingIndex];
+        if (existing.lastUpdated >= lastUpdated) {
+            return false;
+        }
+        cacheData.directories[existingIndex] = {
+            worktree: existing.worktree,
+            lastUpdated,
+        };
+    }
+    else {
+        cacheData.directories.push({
+            worktree: normalizedWorktree,
+            lastUpdated,
+        });
+    }
+    dedupeAndTrimDirectories(cacheData);
+    return true;
+}
+function buildListParams() {
+    const hasWatermark = cacheData.lastSyncedUpdatedAt > 0;
+    if (!hasWatermark) {
+        return { limit: INITIAL_WARMUP_LIMIT };
+    }
+    return {
+        limit: INCREMENTAL_SYNC_LIMIT,
+        start: Math.max(0, cacheData.lastSyncedUpdatedAt - SYNC_SAFETY_WINDOW_MS),
+    };
+}
+function createVirtualProjectId(worktree) {
+    const hash = createHash("sha1").update(worktree).digest("hex").slice(0, 16);
+    return `dir_${hash}`;
+}
+async function runSync() {
+    await ensureCacheLoaded();
+    const params = buildListParams();
+    const { data: sessions, error } = await opencodeClient.session.list(params);
+    if (error || !sessions) {
+        throw error || new Error("No session list received from server");
+    }
+    let changed = false;
+    let maxUpdated = cacheData.lastSyncedUpdatedAt;
+    for (const session of sessions) {
+        const updatedAt = session.time?.updated ?? Date.now();
+        if (upsertDirectory(session.directory, updatedAt)) {
+            changed = true;
+        }
+        if (updatedAt > maxUpdated) {
+            maxUpdated = updatedAt;
+        }
+    }
+    if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
+        cacheData.lastSyncedUpdatedAt = maxUpdated;
+        changed = true;
+    }
+    if (changed) {
+        await queuePersist();
+    }
+    logger.debug(`[SessionCache] Synced sessions: fetched=${sessions.length}, directories=${cacheData.directories.length}, lastSyncedUpdatedAt=${cacheData.lastSyncedUpdatedAt}`);
+}
+function getStorageRootCandidates(pathInfo) {
+    const candidates = new Set();
+    if (pathInfo.home) {
+        candidates.add(path.join(pathInfo.home, ".local", "share", "opencode"));
+    }
+    if (pathInfo.state) {
+        const normalizedState = pathInfo.state.replace(/[\\/]+$/, "");
+        const lowerState = normalizedState.toLowerCase();
+        const marker = `${path.sep}state${path.sep}opencode`;
+        const lowerMarker = marker.toLowerCase();
+        if (lowerState.endsWith(lowerMarker)) {
+            const prefix = normalizedState.slice(0, normalizedState.length - marker.length);
+            candidates.add(path.join(prefix, "share", "opencode"));
+        }
+    }
+    return Array.from(candidates);
+}
+function getPathApi() {
+    return opencodeClient.path;
+}
+async function getStorageRootsFromApi() {
+    const pathApi = getPathApi();
+    if (!pathApi?.get) {
+        return [];
+    }
+    const { data: pathInfo, error } = await pathApi.get();
+    if (error || !pathInfo) {
+        return [];
+    }
+    return getStorageRootCandidates(pathInfo);
+}
+async function querySessionDirectoriesFromSqlite(dbPath) {
+    try {
+        const db = new Database(dbPath, {
+            readonly: true,
+            fileMustExist: true,
+        });
+        try {
+            const rows = db
+                .prepare(`
+            SELECT directory, MAX(time_updated) AS updated
+            FROM session
+            GROUP BY directory
+            ORDER BY updated DESC
+            LIMIT ?
+          `)
+                .all(SQLITE_FALLBACK_QUERY_LIMIT);
+            return rows
+                .filter((item) => Boolean(item) && typeof item.directory === "string")
+                .map((item) => ({
+                worktree: item.directory,
+                lastUpdated: typeof item.updated === "number" && Number.isFinite(item.updated) ? item.updated : 0,
+            }));
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (error) {
+        logger.debug(`[SessionCache] Failed to read sqlite fallback at ${dbPath}`, error);
+    }
+    return null;
+}
+async function ingestFromSqliteSessionDatabase() {
+    await ensureCacheLoaded();
+    const fs = await import("node:fs/promises");
+    const roots = await getStorageRootsFromApi();
+    for (const root of roots) {
+        const dbPath = path.join(root, "opencode.db");
+        try {
+            await fs.access(dbPath);
+        }
+        catch {
+            continue;
+        }
+        const rows = await querySessionDirectoriesFromSqlite(dbPath);
+        if (!rows || rows.length === 0) {
+            continue;
+        }
+        let changed = false;
+        let maxUpdated = cacheData.lastSyncedUpdatedAt;
+        for (const row of rows) {
+            if (upsertDirectory(row.worktree, row.lastUpdated)) {
+                changed = true;
+            }
+            if (row.lastUpdated > maxUpdated) {
+                maxUpdated = row.lastUpdated;
+            }
+        }
+        if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
+            cacheData.lastSyncedUpdatedAt = maxUpdated;
+            changed = true;
+        }
+        if (changed) {
+            await queuePersist();
+        }
+        logger.debug(`[SessionCache] SQLite fallback loaded: db=${dbPath}, rows=${rows.length}, directories=${cacheData.directories.length}`);
+        return;
+    }
+}
+async function ingestFromGlobalSessionStorage() {
+    await ensureCacheLoaded();
+    const fs = await import("node:fs/promises");
+    const candidates = await getStorageRootsFromApi();
+    for (const storageRoot of candidates) {
+        const globalDir = path.join(storageRoot, "storage", "session", "global");
+        try {
+            const entries = await fs.readdir(globalDir, { withFileTypes: true });
+            const sessionFiles = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
+            const withMtime = await Promise.all(sessionFiles.map(async (entry) => {
+                const fullPath = path.join(globalDir, entry.name);
+                const stat = await fs.stat(fullPath);
+                return { fullPath, mtimeMs: stat.mtimeMs };
+            }));
+            const sorted = withMtime
+                .sort((a, b) => b.mtimeMs - a.mtimeMs)
+                .slice(0, STORAGE_FALLBACK_SCAN_LIMIT);
+            let changed = false;
+            let maxUpdated = cacheData.lastSyncedUpdatedAt;
+            for (const file of sorted) {
+                try {
+                    const raw = await fs.readFile(file.fullPath, "utf-8");
+                    const session = JSON.parse(raw);
+                    if (!session.directory) {
+                        continue;
+                    }
+                    const updated = session.time?.updated ?? Math.trunc(file.mtimeMs);
+                    if (upsertDirectory(session.directory, updated)) {
+                        changed = true;
+                    }
+                    if (updated > maxUpdated) {
+                        maxUpdated = updated;
+                    }
+                }
+                catch {
+                    // Ignore malformed session files.
+                }
+            }
+            if (maxUpdated !== cacheData.lastSyncedUpdatedAt) {
+                cacheData.lastSyncedUpdatedAt = maxUpdated;
+                changed = true;
+            }
+            if (changed) {
+                await queuePersist();
+            }
+            logger.debug(`[SessionCache] Storage fallback loaded: root=${storageRoot}, scanned=${sorted.length}, directories=${cacheData.directories.length}`);
+            return;
+        }
+        catch {
+            // Try next candidate path.
+        }
+    }
+}
+export async function warmupSessionDirectoryCache() {
+    await syncSessionDirectoryCache({ force: true });
+    try {
+        await ingestFromSqliteSessionDatabase();
+    }
+    catch (error) {
+        logger.warn("[SessionCache] Failed sqlite fallback warmup", error);
+    }
+    try {
+        await ingestFromGlobalSessionStorage();
+    }
+    catch (error) {
+        logger.warn("[SessionCache] Failed storage fallback warmup", error);
+    }
+}
+export async function syncSessionDirectoryCache(options) {
+    await ensureCacheLoaded();
+    if (!options?.force && Date.now() - lastSyncAttemptAt < SYNC_COOLDOWN_MS) {
+        return;
+    }
+    if (syncInFlight) {
+        return syncInFlight;
+    }
+    syncInFlight = runSync()
+        .then(() => {
+        lastSyncAttemptAt = Date.now();
+    })
+        .catch((error) => {
+        logger.warn("[SessionCache] Failed to sync sessions cache", error);
+        lastSyncAttemptAt = 0;
+    })
+        .finally(() => {
+        syncInFlight = null;
+    });
+    return syncInFlight;
+}
+export async function getCachedSessionDirectories() {
+    await ensureCacheLoaded();
+    return cacheData.directories.map((item) => ({ ...item }));
+}
+export async function getCachedSessionProjects() {
+    const directories = await getCachedSessionDirectories();
+    return directories.map((item) => ({
+        id: createVirtualProjectId(item.worktree),
+        worktree: item.worktree,
+        name: item.worktree,
+        lastUpdated: item.lastUpdated,
+    }));
+}
+export async function upsertSessionDirectory(worktree, lastUpdated = Date.now()) {
+    await ensureCacheLoaded();
+    if (!upsertDirectory(worktree, lastUpdated)) {
+        return;
+    }
+    if (lastUpdated > cacheData.lastSyncedUpdatedAt) {
+        cacheData.lastSyncedUpdatedAt = lastUpdated;
+    }
+    await queuePersist();
+}
+export async function ingestSessionInfoForCache(session) {
+    const directory = session.directory;
+    if (!directory) {
+        return;
+    }
+    const updated = session.time?.updated ?? Date.now();
+    await upsertSessionDirectory(directory, updated);
+}
+export function __resetSessionDirectoryCacheForTests() {
+    cacheData = createEmptyCacheData();
+    cacheLoaded = false;
+    syncInFlight = null;
+    lastSyncAttemptAt = 0;
+    persistQueue = Promise.resolve();
+}

package/dist/settings/manager.js

@@ -17,15 +17,24 @@ async function readSettingsFile() {
         return {};
     }
 }
+let settingsWriteQueue = Promise.resolve();
 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) => {
+    settingsWriteQueue = settingsWriteQueue
+        .catch(() => {
+        // Keep write queue alive after failed writes.
+    })
+        .then(async () => {
+        try {
+            const fs = await import("fs/promises");
+            const settingsFilePath = getSettingsFilePath();
+            await fs.mkdir(path.dirname(settingsFilePath), { recursive: true });
+            await fs.writeFile(settingsFilePath, JSON.stringify(settings, null, 2));
+        }
+        catch (err) {
             logger.error("[SettingsManager] Error writing settings file:", err);
-        });
+        }
     });
+    return settingsWriteQueue;
 }
 let currentSettings = {};
 export function getCurrentProject() {
@@ -33,66 +42,81 @@ export function getCurrentProject() {
 }
 export function setCurrentProject(projectInfo) {
     currentSettings.currentProject = projectInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearProject() {
     currentSettings.currentProject = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getCurrentSession() {
     return currentSettings.currentSession;
 }
 export function setCurrentSession(sessionInfo) {
     currentSettings.currentSession = sessionInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearSession() {
     currentSettings.currentSession = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getCurrentAgent() {
     return currentSettings.currentAgent;
 }
 export function setCurrentAgent(agentName) {
     currentSettings.currentAgent = agentName;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearCurrentAgent() {
     currentSettings.currentAgent = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getCurrentModel() {
     return currentSettings.currentModel;
 }
 export function setCurrentModel(modelInfo) {
     currentSettings.currentModel = modelInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearCurrentModel() {
     currentSettings.currentModel = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getPinnedMessageId() {
     return currentSettings.pinnedMessageId;
 }
 export function setPinnedMessageId(messageId) {
     currentSettings.pinnedMessageId = messageId;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearPinnedMessageId() {
     currentSettings.pinnedMessageId = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function getServerProcess() {
     return currentSettings.serverProcess;
 }
 export function setServerProcess(processInfo) {
     currentSettings.serverProcess = processInfo;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
 }
 export function clearServerProcess() {
     currentSettings.serverProcess = undefined;
-    writeSettingsFile(currentSettings);
+    void writeSettingsFile(currentSettings);
+}
+export function getSessionDirectoryCache() {
+    return currentSettings.sessionDirectoryCache;
+}
+export function setSessionDirectoryCache(cache) {
+    currentSettings.sessionDirectoryCache = cache;
+    return writeSettingsFile(currentSettings);
+}
+export function clearSessionDirectoryCache() {
+    currentSettings.sessionDirectoryCache = undefined;
+    void writeSettingsFile(currentSettings);
+}
+export function __resetSettingsForTests() {
+    currentSettings = {};
+    settingsWriteQueue = Promise.resolve();
 }
 export async function loadSettings() {
     currentSettings = await readSettingsFile();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grinev/opencode-telegram-bot",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Telegram bot client for OpenCode to run and monitor coding tasks from chat.",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,10 +53,12 @@
   "dependencies": {
     "@grammyjs/menu": "^1.3.1",
     "@opencode-ai/sdk": "^1.1.21",
+    "better-sqlite3": "^12.6.2",
     "dotenv": "^17.2.3",
     "grammy": "^1.39.2"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.0.8",
     "@typescript-eslint/eslint-plugin": "^8.53.0",
     "@typescript-eslint/parser": "^8.53.0",