yepanywhere 0.5.2 → 0.6.0

package/dist/sessions/opencode-reader.js

@@ -1,14 +1,26 @@
-import { execFile } from "node:child_process";
-import { readFile, readdir, stat } from "node:fs/promises";
-import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import { open, readFile, readdir, stat, unlink, } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { getModelContextWindow, truncateSessionTitle, } from "../../bundled/@yep-anywhere/shared/dist/index.js";
+import { OpenCodeDbReader, } from "./opencode-db-reader.js";
 /** Default OpenCode storage directory */
 export const OPENCODE_STORAGE_DIR = join(homedir(), ".local", "share", "opencode", "storage");
 const OPENCODE_DATA_DIR = process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
 export const OPENCODE_DB_PATH = join(OPENCODE_DATA_DIR, "opencode", "opencode.db");
 const OPENCODE_CLI_TIMEOUT_MS = 10_000;
 const OPENCODE_CLI_MAX_SESSIONS = 200;
+// `opencode session list` output is global (not scoped to the spawn cwd), so
+// one spawn can serve every project's reader. Index validations for several
+// legacy (pre-1.16, no-DB) projects land in one burst; without sharing, each
+// scope paid its own 1-2s subprocess. TTL only bounds staleness between
+// bursts — the periodic index revalidation re-runs it anyway.
+const OPENCODE_CLI_LIST_CACHE_TTL_MS = 10_000;
+// Shared across reader instances (one per project): the CLI list output is
+// global, so any project's spawn serves them all. Keyed by the opencode
+// binary path; holds the in-flight promise so concurrent validations
+// coalesce onto one subprocess.
+const cliSessionListCache = new Map();
 // Use OpenCodeMessage and OpenCodeStoredPart types from shared
 /**
  * Find the OpenCode project ID for a given project path by scanning project files.
@@ -58,11 +70,13 @@ export class OpenCodeSessionReader {
     opencodePath;
     projectPath;
     openCodeProjectIdCache = undefined;
+    dbReader;
     constructor(options) {
         this.storageDir = options.storageDir ?? OPENCODE_STORAGE_DIR;
         this.databasePath = options.databasePath ?? OPENCODE_DB_PATH;
         this.opencodePath = options.opencodePath ?? "opencode";
         this.projectPath = options.projectPath;
+        this.dbReader = new OpenCodeDbReader(this.databasePath);
     }
     /**
      * Get the OpenCode project ID, looking it up lazily from storage.
@@ -78,25 +92,43 @@ export class OpenCodeSessionReader {
     async listSessions(projectId) {
         const summaries = [];
         const seen = new Set();
-        for (const summary of await this.listFileSessions(projectId)) {
-            summaries.push(summary);
-            seen.add(summary.id);
+        // OpenCode 1.16+: the DB is authoritative and the CLI `session list` reads
+        // the same store, so when the DB has this project we enumerate from it and
+        // skip the subprocess. The CLI stays a legacy fallback for pre-1.16 / no-DB.
+        const dbProjectId = await this.dbReader.getProjectId(this.projectPath);
+        if (dbProjectId) {
+            for (const summary of await this.listDbSessions(projectId)) {
+                summaries.push(summary);
+                seen.add(summary.id);
+            }
         }
-        for (const summary of await this.listCliSessions(projectId)) {
+        for (const summary of await this.listFileSessions(projectId)) {
             if (seen.has(summary.id))
                 continue;
             summaries.push(summary);
             seen.add(summary.id);
         }
+        if (!dbProjectId) {
+            for (const summary of await this.listCliSessions(projectId)) {
+                if (seen.has(summary.id))
+                    continue;
+                summaries.push(summary);
+                seen.add(summary.id);
+            }
+        }
         // Sort by updatedAt descending
         summaries.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
         return summaries;
     }
     async getSessionSummary(sessionId, projectId) {
-        return ((await this.getFileSessionSummary(sessionId, projectId)) ??
+        return ((await this.getDbSessionSummary(sessionId, projectId)) ??
+            (await this.getFileSessionSummary(sessionId, projectId)) ??
             (await this.getCliSessionSummary(sessionId, projectId)));
     }
     async getSession(sessionId, projectId, afterMessageId, _options) {
+        const fromDb = await this.loadDbSession(sessionId, projectId, afterMessageId);
+        if (fromDb)
+            return fromDb;
         const fileSummary = await this.getFileSessionSummary(sessionId, projectId);
         if (fileSummary) {
             const messages = await this.loadSessionMessages(sessionId, afterMessageId);
@@ -130,11 +162,31 @@ export class OpenCodeSessionReader {
         };
     }
     async getSessionSummaryIfChanged(sessionId, projectId, cachedMtime, cachedSize) {
+        const dbChanged = await this.getDbSessionSummaryIfChanged(sessionId, projectId, cachedMtime, cachedSize);
+        if (dbChanged === "unchanged") {
+            // The session exists in the DB and its row matches the cache. Without
+            // this terminal, an unchanged DB session fell through to the file-tree
+            // check (no json file for DB sessions) and then a per-session CLI
+            // spawn — on every index validation.
+            return null;
+        }
+        if (dbChanged) {
+            return dbChanged;
+        }
         const fileChanged = await this.getFileSessionSummaryIfChanged(sessionId, projectId, cachedMtime, cachedSize);
         if (fileChanged) {
             return fileChanged;
         }
-        const summary = await this.getCliSessionSummary(sessionId, projectId);
+        // Legacy CLI sessions: probe freshness from the (shared, cached) session
+        // list rather than a per-session `opencode export` spawn — the list row's
+        // updated-time is the same signal at 1/Nth the subprocesses. The stored
+        // summary matches what listCliSessions builds from the same row.
+        const cliSessions = await this.loadCliSessionList();
+        const cliRow = cliSessions.find((session) => this.stringField(session.id) === sessionId &&
+            this.cliListSessionBelongsToProject(session));
+        if (!cliRow)
+            return null;
+        const summary = this.summaryFromCliListSession(cliRow, projectId);
         if (!summary)
             return null;
         const mtime = Date.parse(summary.updatedAt);
@@ -148,20 +200,78 @@ export class OpenCodeSessionReader {
         return this.databasePath;
     }
     async listSessionFiles(_sessionDir, options) {
-        const sessions = await this.loadCliSessionList();
-        return sessions
-            .filter((session) => {
-            if (!this.cliListSessionBelongsToProject(session))
-                return false;
-            if (options?.activeAfterMs === undefined)
-                return true;
-            const updatedAt = this.numberField(session.updated);
-            return updatedAt === undefined || updatedAt >= options.activeAfterMs;
-        })
-            .map((session) => ({
-            sessionId: String(session.id),
-            filePath: this.databasePath,
-        }));
+        const out = [];
+        const seen = new Set();
+        // DB sessions (OpenCode 1.16+) are the primary durable source. Enumerate
+        // them straight from the `session` table rather than the CLI `session list`,
+        // using the db path as the index anchor (the index then stats nothing
+        // per-session; change detection runs through getSessionSummaryIfChanged,
+        // which compares the row's time_updated + message count).
+        const dbProjectId = await this.dbReader.getProjectId(this.projectPath);
+        if (dbProjectId) {
+            for (const { id, timeUpdated } of await this.dbReader.listSessionRows(dbProjectId)) {
+                if (seen.has(id))
+                    continue;
+                if (options?.activeAfterMs !== undefined &&
+                    timeUpdated < options.activeAfterMs) {
+                    continue;
+                }
+                out.push({
+                    sessionId: id,
+                    filePath: this.databasePath,
+                    sharedFilePath: true,
+                });
+                seen.add(id);
+            }
+        }
+        // File-storage sessions: storage/session/{openCodeProjectId}/*.json.
+        // These are the bulk of OpenCode sessions. The session index enumerates via
+        // this method (not listSessions), so omitting file sessions here meant they
+        // never appeared in project listings even though listSessions returns them.
+        // Use the session json path as filePath so the index gets per-session mtime.
+        const openCodeProjectId = await this.getOpenCodeProjectId();
+        if (openCodeProjectId) {
+            const sessionDir = join(this.storageDir, "session", openCodeProjectId);
+            try {
+                for (const file of await readdir(sessionDir)) {
+                    if (!file.endsWith(".json"))
+                        continue;
+                    const sessionId = file.replace(".json", "");
+                    out.push({ sessionId, filePath: join(sessionDir, file) });
+                    seen.add(sessionId);
+                }
+            }
+            catch {
+                // Session dir missing/unreadable — fall through to CLI sessions.
+            }
+        }
+        // CLI-listed sessions: legacy fallback only. With a 1.16+ DB present the
+        // CLI `session list` reads the same store, so enumerating it would just
+        // re-spawn the subprocess for rows the DB already returned. Run it only when
+        // the DB has no project for this worktree (pre-1.16 / no DB).
+        if (!dbProjectId) {
+            const cliSessions = await this.loadCliSessionList();
+            for (const session of cliSessions) {
+                if (!this.cliListSessionBelongsToProject(session))
+                    continue;
+                const sessionId = String(session.id);
+                if (seen.has(sessionId))
+                    continue;
+                if (options?.activeAfterMs !== undefined) {
+                    const updatedAt = this.numberField(session.updated);
+                    if (updatedAt !== undefined && updatedAt < options.activeAfterMs) {
+                        continue;
+                    }
+                }
+                out.push({
+                    sessionId,
+                    filePath: this.databasePath,
+                    sharedFilePath: true,
+                });
+                seen.add(sessionId);
+            }
+        }
+        return out;
     }
     getIndexScopeKey(_sessionDir) {
         return `opencode::${this.projectPath}`;
@@ -218,9 +328,12 @@ export class OpenCodeSessionReader {
                     try {
                         const msgContent = await readFile(msgPath, "utf-8");
                         const msg = JSON.parse(msgContent);
-                        // Get model from first assistant message
-                        if (!model && msg.role === "assistant" && msg.modelID) {
-                            model = msg.modelID;
+                        // Track the latest assistant model (a session's model can
+                        // change mid-transcript); files iterate in chronological order.
+                        if (msg.role === "assistant" && msg.modelID) {
+                            model =
+                                this.canonicalModelId(msg.providerID, msg.modelID) ??
+                                    msg.modelID;
                         }
                         // Get first user message text
                         if (!firstUserMessageText && msg.role === "user") {
@@ -295,6 +408,121 @@ export class OpenCodeSessionReader {
             return null;
         }
     }
+    /**
+     * Load a session straight from `opencode.db` — the authoritative durable
+     * source for OpenCode 1.16+ and the only one that does not spawn a subprocess
+     * or depend on the (frozen) JSON file tree. Returns null when the DB is
+     * absent, the session is not in this project, or sqlite is unavailable
+     * (Node < 22.5), so callers fall through to the file-tree and CLI-export
+     * readers. The summary always reflects the whole session even when
+     * `afterMessageId` pages the returned messages.
+     */
+    async loadDbSession(sessionId, projectId, afterMessageId) {
+        const projectIdHash = await this.dbReader.getProjectId(this.projectPath);
+        if (!projectIdHash)
+            return null;
+        const row = await this.dbReader.getSessionRow(sessionId, projectIdHash);
+        // Skip empty sessions (0 messages) so an unstarted session falls through to
+        // the same null the file path returns, rather than rendering blank.
+        if (!row || row.messageCount === 0)
+            return null;
+        const entries = await this.dbReader.loadEntries(sessionId, afterMessageId);
+        if (entries === null)
+            return null;
+        const summary = await this.buildDbSummary(row, projectId);
+        return {
+            summary,
+            data: {
+                provider: "opencode",
+                session: { messages: entries },
+            },
+        };
+    }
+    async getDbSessionSummary(sessionId, projectId) {
+        const projectIdHash = await this.dbReader.getProjectId(this.projectPath);
+        if (!projectIdHash)
+            return null;
+        const row = await this.dbReader.getSessionRow(sessionId, projectIdHash);
+        if (!row || row.messageCount === 0)
+            return null;
+        return this.buildDbSummary(row, projectId);
+    }
+    /**
+     * Change detection for DB sessions. Unlike the file path (which stats one
+     * per-session JSON file), every DB session shares a single `opencode.db`, so
+     * the db-file mtime over-triggers. Compare the session row's `time_updated`
+     * and message count instead — carried as the index's (mtime, size) pair, the
+     * same convention the CLI fallback uses.
+     */
+    /**
+     * DB-row change check. Returns "unchanged" as a terminal answer (the
+     * session is in the DB and needs no re-summarize), a changed summary, or
+     * null only when the DB cannot answer for this session at all — only then
+     * may callers fall through to the file-tree / CLI readers.
+     */
+    async getDbSessionSummaryIfChanged(sessionId, projectId, cachedMtime, cachedSize) {
+        const projectIdHash = await this.dbReader.getProjectId(this.projectPath);
+        if (!projectIdHash)
+            return null;
+        const meta = await this.dbReader.getSessionMeta(sessionId, projectIdHash);
+        if (!meta)
+            return null;
+        // An empty DB session summarizes to nothing; treat it as unchanged
+        // rather than "not in the DB" so it never triggers the CLI fallback.
+        if (meta.messageCount === 0)
+            return "unchanged";
+        if (meta.timeUpdated === cachedMtime && meta.messageCount === cachedSize) {
+            return "unchanged";
+        }
+        const summary = await this.getDbSessionSummary(sessionId, projectId);
+        // The row exists but yielded no summary (e.g. deleted mid-read): the DB
+        // is still authoritative for this session, so stay terminal.
+        if (!summary)
+            return "unchanged";
+        return { summary, mtime: meta.timeUpdated, size: meta.messageCount };
+    }
+    /**
+     * Build a SessionSummary from a DB session row plus cheap targeted lookups
+     * (first user text for the title fallback; last assistant tokens for context
+     * usage), so a summary never loads the full part list.
+     */
+    async buildDbSummary(row, projectId) {
+        const model = this.canonicalModelId(row.model?.providerID, row.model?.id ?? row.model?.modelID);
+        const dbTitle = row.title?.trim() || null;
+        const firstUserText = !dbTitle || dbTitle === "Yep Anywhere Session"
+            ? await this.dbReader.loadFirstUserText(row.id)
+            : null;
+        const fullTitle = dbTitle && dbTitle !== "Yep Anywhere Session"
+            ? dbTitle
+            : (firstUserText ?? dbTitle);
+        const tokens = await this.dbReader.loadLastAssistantTokens(row.id);
+        return {
+            id: row.id,
+            projectId,
+            title: this.truncateTitle(fullTitle),
+            fullTitle,
+            createdAt: this.dateFromMillis(row.timeCreated ?? undefined),
+            updatedAt: this.dateFromMillis(row.timeUpdated ?? undefined),
+            messageCount: row.messageCount,
+            ownership: { owner: "none" },
+            contextUsage: this.contextUsageFromTokens(tokens ?? undefined, model),
+            provider: "opencode",
+            model,
+        };
+    }
+    async listDbSessions(projectId) {
+        const projectIdHash = await this.dbReader.getProjectId(this.projectPath);
+        if (!projectIdHash)
+            return [];
+        const rows = await this.dbReader.listSessionRows(projectIdHash);
+        const summaries = [];
+        for (const { id } of rows) {
+            const summary = await this.getDbSessionSummary(id, projectId);
+            if (summary)
+                summaries.push(summary);
+        }
+        return summaries;
+    }
     async listCliSessions(projectId) {
         const sessions = await this.loadCliSessionList();
         const summaries = [];
@@ -317,6 +545,18 @@ export class OpenCodeSessionReader {
         return this.summaryFromExport(exported, entries, projectId);
     }
     async loadCliSessionList() {
+        const cached = cliSessionListCache.get(this.opencodePath);
+        if (cached && Date.now() - cached.atMs < OPENCODE_CLI_LIST_CACHE_TTL_MS) {
+            return cached.promise;
+        }
+        const promise = this.spawnCliSessionList();
+        cliSessionListCache.set(this.opencodePath, {
+            atMs: Date.now(),
+            promise,
+        });
+        return promise;
+    }
+    async spawnCliSessionList() {
         const output = await this.runOpenCodeCli([
             "session",
             "list",
@@ -347,21 +587,58 @@ export class OpenCodeSessionReader {
         return parsed;
     }
     async runOpenCodeCli(args) {
-        return new Promise((resolve) => {
-            execFile(this.opencodePath, args, {
-                cwd: this.projectPath,
-                encoding: "utf8",
-                maxBuffer: 16 * 1024 * 1024,
-                timeout: OPENCODE_CLI_TIMEOUT_MS,
-                windowsHide: true,
-            }, (error, stdout) => {
-                if (error) {
-                    resolve(null);
-                    return;
-                }
-                resolve(String(stdout));
+        // Capture stdout into a real file fd, not a pipe. `opencode` is a Bun
+        // binary that drops buffered piped stdout on process.exit() once it
+        // exceeds the kernel pipe buffer, so large `export` JSON was truncated
+        // mid-string (execFile) and failed to parse — blanking session reload.
+        // A regular file fd is lossless. See topics/opencode-backend.md
+        // "Durable Storage Format".
+        const tmpFile = join(tmpdir(), `ya-opencode-${process.pid}-${Date.now()}-${Math.random()
+            .toString(36)
+            .slice(2)}.json`);
+        let handle;
+        try {
+            handle = await open(tmpFile, "w");
+        }
+        catch {
+            return null;
+        }
+        try {
+            const fd = handle.fd;
+            const exitedOk = await new Promise((resolve) => {
+                const child = spawn(this.opencodePath, args, {
+                    cwd: this.projectPath,
+                    stdio: ["ignore", fd, "ignore"],
+                    windowsHide: true,
+                });
+                const timer = setTimeout(() => {
+                    child.kill("SIGKILL");
+                    resolve(false);
+                }, OPENCODE_CLI_TIMEOUT_MS);
+                child.on("error", () => {
+                    clearTimeout(timer);
+                    resolve(false);
+                });
+                child.on("close", (code) => {
+                    clearTimeout(timer);
+                    resolve(code === 0);
+                });
             });
-        }).catch(() => null);
+            await handle.close();
+            handle = undefined;
+            if (!exitedOk)
+                return null;
+            return await readFile(tmpFile, "utf8");
+        }
+        catch {
+            return null;
+        }
+        finally {
+            if (handle) {
+                await handle.close().catch(() => { });
+            }
+            await unlink(tmpFile).catch(() => { });
+        }
     }
     parseJsonOutput(output) {
         const trimmed = output.trim();
@@ -387,9 +664,7 @@ export class OpenCodeSessionReader {
         return !directory || directory === this.projectPath;
     }
     exportMessagesToEntries(exported, afterMessageId) {
-        const messages = Array.isArray(exported.messages)
-            ? exported.messages
-            : [];
+        const messages = Array.isArray(exported.messages) ? exported.messages : [];
         const entries = [];
         let foundAfterMessage = !afterMessageId;
         for (const exportedMessage of messages) {
@@ -511,48 +786,77 @@ export class OpenCodeSessionReader {
         }
         if (model && typeof model === "object" && !Array.isArray(model)) {
             const raw = model;
-            const id = this.stringField(raw.id) ?? this.stringField(raw.modelID);
-            if (id)
-                return id;
+            const canonical = this.canonicalModelId(raw.providerID, this.stringField(raw.id) ?? this.stringField(raw.modelID));
+            if (canonical)
+                return canonical;
         }
         for (const entry of entries) {
             if (entry.message.role !== "assistant")
                 continue;
-            const modelId = entry.message.modelID ??
-                (entry.message.model &&
-                    typeof entry.message.model === "object" &&
-                    !Array.isArray(entry.message.model)
-                    ? this.stringField(entry.message.model.modelID)
-                    : undefined);
-            if (modelId)
-                return modelId;
+            const nested = entry.message.model &&
+                typeof entry.message.model === "object" &&
+                !Array.isArray(entry.message.model)
+                ? entry.message.model
+                : undefined;
+            const canonical = this.canonicalModelId(entry.message.providerID ?? nested?.providerID, entry.message.modelID ?? this.stringField(nested?.modelID));
+            if (canonical)
+                return canonical;
         }
         return undefined;
     }
+    /**
+     * Canonical OpenCode model id as `providerID/modelID` — the form
+     * `opencode models` prints and `parseOpenCodeModelSelection` requires.
+     * A reload must not drop the provider prefix, or the next turn fails with
+     * `OpenCode model must use provider/model format`. modelID may itself
+     * contain slashes (e.g. `local-glm/Qwen/Qwen3.6-27B`); only the first
+     * slash separates provider from model, so a present prefix is preserved.
+     */
+    canonicalModelId(providerID, modelID) {
+        const mid = this.stringField(modelID);
+        if (!mid)
+            return undefined;
+        const pid = this.stringField(providerID);
+        if (!pid || mid.startsWith(`${pid}/`))
+            return mid;
+        return `${pid}/${mid}`;
+    }
     extractContextUsageFromEntries(entries, model) {
-        const contextWindowSize = getModelContextWindow(model);
         for (const entry of [...entries].reverse()) {
             const msg = entry.message;
-            if (msg.role !== "assistant" || !msg.tokens)
+            if (msg.role !== "assistant")
                 continue;
-            const inputTokens = (msg.tokens.input ?? 0) + (msg.tokens.cache?.read ?? 0);
-            if (inputTokens === 0)
-                continue;
-            const result = {
-                inputTokens,
-                percentage: Math.round((inputTokens / contextWindowSize) * 100),
-                contextWindow: contextWindowSize,
-            };
-            if (msg.tokens.output !== undefined && msg.tokens.output > 0) {
-                result.outputTokens = msg.tokens.output;
-            }
-            if (msg.tokens.cache?.read !== undefined && msg.tokens.cache.read > 0) {
-                result.cacheReadTokens = msg.tokens.cache.read;
-            }
-            return result;
+            const usage = this.contextUsageFromTokens(msg.tokens, model);
+            if (usage)
+                return usage;
         }
         return undefined;
     }
+    /**
+     * Context-window fill from an assistant message's token counts — input plus
+     * cache-read represents the prompt size carried into the next turn. Shared by
+     * the entries scan (file/export paths) and the DB path's last-assistant probe.
+     */
+    contextUsageFromTokens(tokens, model) {
+        if (!tokens)
+            return undefined;
+        const inputTokens = (tokens.input ?? 0) + (tokens.cache?.read ?? 0);
+        if (inputTokens === 0)
+            return undefined;
+        const contextWindowSize = getModelContextWindow(model);
+        const result = {
+            inputTokens,
+            percentage: Math.round((inputTokens / contextWindowSize) * 100),
+            contextWindow: contextWindowSize,
+        };
+        if (tokens.output !== undefined && tokens.output > 0) {
+            result.outputTokens = tokens.output;
+        }
+        if (tokens.cache?.read !== undefined && tokens.cache.read > 0) {
+            result.cacheReadTokens = tokens.cache.read;
+        }
+        return result;
+    }
     stringField(value) {
         return typeof value === "string" && value.trim() ? value : undefined;
     }