opencode-telegram-group-topics-bot 0.11.2

package/dist/session/cache-manager.js

@@ -0,0 +1,455 @@
+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 SERVER_UNAVAILABLE_ERROR_MARKERS = [
+    "fetch failed",
+    "econnrefused",
+    "connection refused",
+    "connect refused",
+];
+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}`;
+}
+function hasServerUnavailableMarker(value) {
+    const lower = value.toLowerCase();
+    return SERVER_UNAVAILABLE_ERROR_MARKERS.some((marker) => lower.includes(marker));
+}
+function isServerUnavailableError(error) {
+    const queue = [error];
+    const seen = new Set();
+    while (queue.length > 0) {
+        const current = queue.pop();
+        if (!current || seen.has(current)) {
+            continue;
+        }
+        seen.add(current);
+        if (typeof current === "string") {
+            if (hasServerUnavailableMarker(current)) {
+                return true;
+            }
+            continue;
+        }
+        if (current instanceof Error) {
+            if (hasServerUnavailableMarker(`${current.name}: ${current.message}`)) {
+                return true;
+            }
+            const errorWithCause = current;
+            if (errorWithCause.cause) {
+                queue.push(errorWithCause.cause);
+            }
+            continue;
+        }
+        if (typeof current === "object") {
+            const value = current;
+            if (typeof value.code === "string" && hasServerUnavailableMarker(value.code)) {
+                return true;
+            }
+            if (typeof value.message === "string" && hasServerUnavailableMarker(value.message)) {
+                return true;
+            }
+            if (value.cause) {
+                queue.push(value.cause);
+            }
+        }
+    }
+    return false;
+}
+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) => {
+        if (isServerUnavailableError(error)) {
+            logger.warn("[SessionCache] OpenCode server is not running. Start it with: opencode serve");
+        }
+        else {
+            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/session/manager.js

@@ -0,0 +1,87 @@
+import { getCurrentSession as getSettingsSession, getScopedSessions, setCurrentSession as setSettingsSession, clearSession as clearSettingsSession, } from "../settings/manager.js";
+import { parseScopeKey, SCOPE_CONTEXT } from "../bot/scope.js";
+import { logger } from "../utils/logger.js";
+const GLOBAL_SCOPE_KEY = "global";
+const sessionsByScope = new Map();
+const scopeBySessionId = new Map();
+let hydrated = false;
+function isTopicScopeKey(scopeKey) {
+    return parseScopeKey(scopeKey)?.context === SCOPE_CONTEXT.GROUP_TOPIC;
+}
+function ensureSessionsLoaded() {
+    if (hydrated) {
+        return;
+    }
+    hydrated = true;
+    const scopedSessions = getScopedSessions();
+    for (const [scopeKey, sessionInfo] of Object.entries(scopedSessions)) {
+        sessionsByScope.set(scopeKey, sessionInfo);
+        scopeBySessionId.set(sessionInfo.id, scopeKey);
+    }
+    const settingsSession = getSettingsSession();
+    if (!settingsSession) {
+        return;
+    }
+    sessionsByScope.set(GLOBAL_SCOPE_KEY, settingsSession);
+    scopeBySessionId.set(settingsSession.id, GLOBAL_SCOPE_KEY);
+}
+export function setCurrentSession(sessionInfo, scopeKey = GLOBAL_SCOPE_KEY) {
+    ensureSessionsLoaded();
+    const previous = sessionsByScope.get(scopeKey);
+    if (isTopicScopeKey(scopeKey) && previous && previous.id !== sessionInfo.id) {
+        logger.warn(`[SessionManager] Rejecting session switch in immutable topic scope: scope=${scopeKey}, existing=${previous.id}, requested=${sessionInfo.id}`);
+        return;
+    }
+    if (previous && previous.id !== sessionInfo.id) {
+        scopeBySessionId.delete(previous.id);
+    }
+    const previousScopeForSession = scopeBySessionId.get(sessionInfo.id);
+    if (previousScopeForSession && previousScopeForSession !== scopeKey) {
+        sessionsByScope.delete(previousScopeForSession);
+    }
+    sessionsByScope.set(scopeKey, sessionInfo);
+    scopeBySessionId.set(sessionInfo.id, scopeKey);
+    if (scopeKey === GLOBAL_SCOPE_KEY) {
+        setSettingsSession(sessionInfo, scopeKey);
+        return;
+    }
+    setSettingsSession(sessionInfo, scopeKey);
+}
+export function getCurrentSession(scopeKey = GLOBAL_SCOPE_KEY) {
+    ensureSessionsLoaded();
+    return sessionsByScope.get(scopeKey) ?? null;
+}
+export function clearSession(scopeKey = GLOBAL_SCOPE_KEY) {
+    ensureSessionsLoaded();
+    const session = sessionsByScope.get(scopeKey);
+    if (session) {
+        scopeBySessionId.delete(session.id);
+    }
+    sessionsByScope.delete(scopeKey);
+    if (scopeKey === GLOBAL_SCOPE_KEY) {
+        clearSettingsSession(scopeKey);
+        return;
+    }
+    clearSettingsSession(scopeKey);
+}
+export function getScopeForSession(sessionId) {
+    ensureSessionsLoaded();
+    return scopeBySessionId.get(sessionId) ?? null;
+}
+export function registerSessionScope(sessionId, scopeKey) {
+    ensureSessionsLoaded();
+    scopeBySessionId.set(sessionId, scopeKey);
+    const sessionInfo = sessionsByScope.get(scopeKey);
+    if (!sessionInfo || sessionInfo.id !== sessionId) {
+        return;
+    }
+    setSettingsSession(sessionInfo, scopeKey);
+}
+export function getSessionById(sessionId) {
+    ensureSessionsLoaded();
+    const scopeKey = scopeBySessionId.get(sessionId);
+    if (!scopeKey) {
+        return null;
+    }
+    return sessionsByScope.get(scopeKey) ?? null;
+}