parallel-codex-tui 0.1.3 → 0.1.5

package/dist/core/session-index.js

@@ -1,82 +1,90 @@
-import { readdir } from "node:fs/promises";
+import { copyFile, readdir, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { NativeSessionSchema, TaskMetaSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
-import { ensureDir, pathExists, readJson } from "./file-store.js";
+import { NativeSessionSchema, RetiredNativeSessionSchema, RouteDecisionSchema, TaskIdSchema, TaskMetaSchema, TurnMetaSchema, WorkerStatusSchema } from "../domain/schemas.js";
+import { ensureDir, pathExists, readJson, readTextIfExists } from "./file-store.js";
+const SESSION_INDEX_SCHEMA_VERSION = 2;
+const SESSION_INDEX_FILENAME = "session-index.sqlite";
 export class SessionIndex {
     db;
     projectRoot;
     dataDir;
-    constructor(db, projectRoot, dataDir) {
+    databasePath;
+    recovery;
+    constructor(db, projectRoot, dataDir, databasePath, recovery) {
         this.db = db;
         this.projectRoot = projectRoot;
         this.dataDir = dataDir;
+        this.databasePath = databasePath;
+        this.recovery = recovery;
     }
     static async open(projectRoot, dataDir) {
-        await ensureDir(join(projectRoot, dataDir));
-        const index = new SessionIndex(new DatabaseSync(join(projectRoot, dataDir, "session-index.sqlite")), projectRoot, dataDir);
-        index.initialize();
-        return index;
+        const runtimeDir = join(projectRoot, dataDir);
+        const databasePath = join(runtimeDir, SESSION_INDEX_FILENAME);
+        const recoveryBackupPath = `${databasePath}.backup`;
+        await ensureDir(runtimeDir);
+        const databaseExisted = await pathExists(databasePath);
+        const opened = await openSessionDatabase(databasePath, recoveryBackupPath);
+        const index = new SessionIndex(opened.db, projectRoot, dataDir, databasePath, opened.recovery);
+        try {
+            const previousVersion = index.schemaVersion();
+            if (databaseExisted && previousVersion < SESSION_INDEX_SCHEMA_VERSION) {
+                await index.writeBackup(`${databasePath}.pre-migration-v${previousVersion}.backup`);
+            }
+            index.initialize();
+            await index.writeBackup(recoveryBackupPath);
+            return index;
+        }
+        catch (error) {
+            try {
+                index.close();
+            }
+            catch {
+                // Preserve the migration or backup failure that prevented startup.
+            }
+            throw error;
+        }
     }
     initialize() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS tasks (
-        id TEXT PRIMARY KEY,
-        title TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        cwd TEXT NOT NULL,
-        mode TEXT NOT NULL,
-        status TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS turns (
-        task_id TEXT NOT NULL,
-        turn_id TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        request_path TEXT NOT NULL,
-        PRIMARY KEY (task_id, turn_id)
-      );
-
-      CREATE TABLE IF NOT EXISTS workers (
-        task_id TEXT NOT NULL,
-        worker_id TEXT NOT NULL,
-        role TEXT NOT NULL,
-        engine TEXT NOT NULL,
-        state TEXT NOT NULL,
-        phase TEXT NOT NULL,
-        summary TEXT NOT NULL,
-        status_path TEXT NOT NULL,
-        output_log_path TEXT NOT NULL,
-        dir TEXT NOT NULL,
-        native_session_id TEXT,
-        PRIMARY KEY (task_id, worker_id)
-      );
-
-      CREATE TABLE IF NOT EXISTS native_sessions (
-        task_id TEXT NOT NULL,
-        worker_id TEXT NOT NULL,
-        engine TEXT NOT NULL,
-        role TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        cwd TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        last_used_at TEXT NOT NULL,
-        source TEXT NOT NULL,
-        PRIMARY KEY (task_id, worker_id)
-      );
-    `);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const currentVersion = this.schemaVersion();
+            if (currentVersion > SESSION_INDEX_SCHEMA_VERSION) {
+                throw new Error(`Session index schema v${currentVersion} is newer than supported v${SESSION_INDEX_SCHEMA_VERSION}`);
+            }
+            for (let targetVersion = currentVersion + 1; targetVersion <= SESSION_INDEX_SCHEMA_VERSION; targetVersion += 1) {
+                this.applyMigration(targetVersion);
+                this.db.exec(`PRAGMA user_version = ${targetVersion}`);
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            try {
+                this.db.exec("ROLLBACK");
+            }
+            catch {
+                // Preserve the migration failure if SQLite already rolled the transaction back.
+            }
+            throw error;
+        }
+        assertHealthyDatabase(this.db);
+    }
+    schemaVersion() {
+        const row = this.db.prepare("PRAGMA user_version").get();
+        return Number(row?.user_version) || 0;
     }
     async upsertTask(task) {
         this.db
-            .prepare(`INSERT INTO tasks (id, title, created_at, cwd, mode, status)
-         VALUES (?, ?, ?, ?, ?, ?)
+            .prepare(`INSERT INTO tasks (id, title, created_at, cwd, mode, status, archived_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(id) DO UPDATE SET
            title=excluded.title,
            created_at=excluded.created_at,
            cwd=excluded.cwd,
            mode=excluded.mode,
-           status=excluded.status`)
-            .run(task.id, task.title, task.created_at, task.cwd, task.mode, task.status);
+           status=excluded.status,
+           archived_at=excluded.archived_at`)
+            .run(task.id, task.title, task.created_at, task.cwd, task.mode, task.status, task.archived_at ?? null);
     }
     async upsertTurn(taskId, turn) {
         this.db
@@ -124,10 +132,94 @@ export class SessionIndex {
     async deleteNativeSession(taskId, workerId) {
         this.db.prepare("DELETE FROM native_sessions WHERE task_id = ? AND worker_id = ?").run(taskId, workerId);
     }
+    async deleteTask(taskId) {
+        const id = TaskIdSchema.parse(taskId);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db.prepare("DELETE FROM native_sessions WHERE task_id = ?").run(id);
+            this.db.prepare("DELETE FROM workers WHERE task_id = ?").run(id);
+            this.db.prepare("DELETE FROM turns WHERE task_id = ?").run(id);
+            this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+            this.db.prepare("UPDATE workspace_state SET value = '' WHERE key = 'active_task_id' AND value = ?").run(id);
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
     async countRows(table) {
         const row = this.db.prepare(`SELECT COUNT(*) AS count FROM ${table}`).get();
         return row.count;
     }
+    async listTasks(limit = 50, options = {}) {
+        const boundedLimit = Number.isFinite(limit)
+            ? Math.min(500, Math.max(0, Math.trunc(limit)))
+            : 50;
+        if (boundedLimit === 0) {
+            return [];
+        }
+        const archivedFilter = options.includeArchived ? "" : "WHERE tasks.archived_at IS NULL";
+        const rows = this.db.prepare(`SELECT
+         tasks.id,
+         tasks.title,
+         tasks.created_at,
+         tasks.cwd,
+         tasks.mode,
+         tasks.status,
+         tasks.archived_at,
+         (SELECT COUNT(*) FROM turns WHERE turns.task_id = tasks.id) AS turn_count,
+         (SELECT COUNT(*) FROM workers WHERE workers.task_id = tasks.id) AS worker_count,
+         (SELECT COUNT(DISTINCT engine || char(31) || session_id)
+           FROM native_sessions
+           WHERE native_sessions.task_id = tasks.id) AS native_session_count
+       FROM tasks
+       ${archivedFilter}
+       ORDER BY tasks.created_at DESC, tasks.id DESC
+       LIMIT ?`).all(boundedLimit);
+        return rows.flatMap((row) => {
+            const task = TaskMetaSchema.safeParse({
+                id: row.id,
+                title: row.title,
+                created_at: row.created_at,
+                cwd: row.cwd,
+                mode: row.mode,
+                status: row.status,
+                archived_at: row.archived_at ?? undefined
+            });
+            if (!task.success) {
+                return [];
+            }
+            return [{
+                    ...task.data,
+                    turnCount: Number(row.turn_count) || 0,
+                    workerCount: Number(row.worker_count) || 0,
+                    nativeSessionCount: Number(row.native_session_count) || 0
+                }];
+        });
+    }
+    async activeTaskId() {
+        const row = this.db
+            .prepare("SELECT value FROM workspace_state WHERE key = 'active_task_id'")
+            .get();
+        if (!row) {
+            return undefined;
+        }
+        const value = row.value.trim();
+        if (!value) {
+            return null;
+        }
+        return TaskIdSchema.safeParse(value).success ? value : undefined;
+    }
+    async setActiveTaskId(taskId) {
+        const value = taskId?.trim() ?? "";
+        if (value && !TaskIdSchema.safeParse(value).success) {
+            throw new Error(`Invalid active task id: ${JSON.stringify(taskId)}`);
+        }
+        this.db.prepare(`INSERT INTO workspace_state (key, value)
+       VALUES ('active_task_id', ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(value);
+    }
     async workerNativeSessionId(taskId, workerId) {
         const row = this.db
             .prepare("SELECT native_session_id FROM workers WHERE task_id = ? AND worker_id = ?")
@@ -135,81 +227,313 @@ export class SessionIndex {
         return row?.native_session_id ?? null;
     }
     async rebuildFromFiles() {
-        this.db.exec("DELETE FROM native_sessions; DELETE FROM workers; DELETE FROM turns; DELETE FROM tasks;");
-        const sessions = join(this.projectRoot, this.dataDir, "sessions");
-        if (!(await pathExists(sessions))) {
-            return;
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db.exec("DELETE FROM native_sessions; DELETE FROM workers; DELETE FROM turns; DELETE FROM tasks;");
+            const sessions = join(this.projectRoot, this.dataDir, "sessions");
+            if (await pathExists(sessions)) {
+                const taskEntries = await readdir(sessions, { withFileTypes: true });
+                for (const taskEntry of taskEntries) {
+                    if (!taskEntry.isDirectory()) {
+                        continue;
+                    }
+                    if (taskEntry.name === "main") {
+                        await this.rebuildWorkers(join(sessions, taskEntry.name), "main");
+                        continue;
+                    }
+                    if (!TaskIdSchema.safeParse(taskEntry.name).success) {
+                        continue;
+                    }
+                    await this.rebuildTask(join(sessions, taskEntry.name), taskEntry.name);
+                }
+            }
+            this.db.exec("COMMIT");
         }
-        const taskEntries = await readdir(sessions, { withFileTypes: true });
-        for (const taskEntry of taskEntries) {
-            if (!taskEntry.isDirectory() || !taskEntry.name.startsWith("task-")) {
-                continue;
+        catch (error) {
+            try {
+                this.db.exec("ROLLBACK");
             }
-            await this.rebuildTask(join(sessions, taskEntry.name), taskEntry.name);
+            catch {
+                // Preserve the filesystem or SQLite failure that interrupted rebuilding.
+            }
+            throw error;
         }
+        await this.writeBackup(`${this.databasePath}.backup`);
     }
     close() {
         this.db.close();
     }
+    ensureColumn(table, column, declaration) {
+        if (this.tableHasColumn(table, column)) {
+            return;
+        }
+        try {
+            this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${declaration}`);
+        }
+        catch (error) {
+            if (!this.tableHasColumn(table, column)) {
+                throw error;
+            }
+        }
+    }
+    applyMigration(targetVersion) {
+        if (targetVersion === 1) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS tasks (
+          id TEXT PRIMARY KEY,
+          title TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          cwd TEXT NOT NULL,
+          mode TEXT NOT NULL,
+          status TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS turns (
+          task_id TEXT NOT NULL,
+          turn_id TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          request_path TEXT NOT NULL,
+          PRIMARY KEY (task_id, turn_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS workers (
+          task_id TEXT NOT NULL,
+          worker_id TEXT NOT NULL,
+          role TEXT NOT NULL,
+          engine TEXT NOT NULL,
+          state TEXT NOT NULL,
+          phase TEXT NOT NULL,
+          summary TEXT NOT NULL,
+          status_path TEXT NOT NULL,
+          output_log_path TEXT NOT NULL,
+          dir TEXT NOT NULL,
+          native_session_id TEXT,
+          PRIMARY KEY (task_id, worker_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS native_sessions (
+          task_id TEXT NOT NULL,
+          worker_id TEXT NOT NULL,
+          engine TEXT NOT NULL,
+          role TEXT NOT NULL,
+          session_id TEXT NOT NULL,
+          cwd TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          last_used_at TEXT NOT NULL,
+          source TEXT NOT NULL,
+          PRIMARY KEY (task_id, worker_id)
+        );
+
+        CREATE TABLE IF NOT EXISTS workspace_state (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
+      `);
+            return;
+        }
+        if (targetVersion === 2) {
+            this.ensureColumn("tasks", "archived_at", "TEXT");
+            return;
+        }
+        throw new Error(`Missing session index migration for schema v${targetVersion}`);
+    }
+    async writeBackup(targetPath) {
+        const tempPath = `${targetPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+        try {
+            this.db.prepare("VACUUM INTO ?").run(tempPath);
+            await replaceFile(tempPath, targetPath);
+        }
+        catch (error) {
+            await rm(tempPath, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    tableHasColumn(table, column) {
+        const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
+        return columns.some((entry) => entry.name === column);
+    }
     async rebuildTask(taskDir, taskId) {
         const metaPath = join(taskDir, "meta.json");
-        if (await pathExists(metaPath)) {
-            const meta = await readJsonIfValid(metaPath, TaskMetaSchema);
-            if (meta) {
-                await this.upsertTask(meta);
-            }
+        const meta = await pathExists(metaPath)
+            ? await readJsonIfValid(metaPath, TaskMetaSchema)
+            : null;
+        if (!meta || meta.id !== taskId) {
+            return;
         }
+        await this.upsertTask(meta);
         const turnsDir = join(taskDir, "turns");
         if (await pathExists(turnsDir)) {
             const turnEntries = await readdir(turnsDir, { withFileTypes: true });
             for (const turnEntry of turnEntries) {
+                if (!turnEntry.isDirectory() || !/^\d{4}$/.test(turnEntry.name)) {
+                    continue;
+                }
                 const turnPath = join(turnsDir, turnEntry.name, "turn.json");
-                if (turnEntry.isDirectory() && (await pathExists(turnPath))) {
-                    const turn = await readJsonIfValid(turnPath, TurnMetaSchema);
-                    if (turn) {
-                        await this.upsertTurn(taskId, turn);
-                    }
+                const [turn, route, request] = await Promise.all([
+                    readJsonIfValid(turnPath, TurnMetaSchema),
+                    readJsonIfValid(join(turnsDir, turnEntry.name, "route.json"), RouteDecisionSchema),
+                    readTextIfExists(join(turnsDir, turnEntry.name, "user.md"))
+                ]);
+                if (turn
+                    && route
+                    && request.trim()
+                    && turn.task_id === taskId
+                    && turn.turn_id === turnEntry.name
+                    && turn.request_path === `turns/${turnEntry.name}/user.md`) {
+                    await this.upsertTurn(taskId, turn);
                 }
             }
         }
-        const entries = await readdir(taskDir, { withFileTypes: true });
+        await this.rebuildWorkers(taskDir, taskId);
+    }
+    async rebuildWorkers(sessionDir, sessionId) {
+        const entries = await readdir(sessionDir, { withFileTypes: true });
         for (const entry of entries) {
             if (!entry.isDirectory() || entry.name === "turns") {
                 continue;
             }
-            const workerDir = join(taskDir, entry.name);
+            const workerDir = join(sessionDir, entry.name);
             const statusPath = join(workerDir, "status.json");
             const nativePath = join(workerDir, "native-session.json");
+            const retiredNativePath = join(workerDir, "native-session.retired.json");
+            const nativeSession = await this.readRebuildNativeSession(nativePath, retiredNativePath);
             if (await pathExists(statusPath)) {
-                const status = await this.readRebuildWorkerStatus(statusPath, nativePath);
+                const status = await this.readRebuildWorkerStatus(statusPath, nativeSession);
                 if (status) {
-                    await this.upsertWorker(taskId, status, {
+                    await this.upsertWorker(sessionId, status, {
                         dir: workerDir,
                         statusPath,
                         outputLogPath: join(workerDir, "output.log")
                     });
                 }
             }
-            if (await pathExists(nativePath)) {
-                const nativeSession = await readJsonIfValid(nativePath, NativeSessionSchema);
-                if (nativeSession) {
-                    await this.upsertNativeSession(taskId, nativeSession);
-                }
+            if (nativeSession) {
+                await this.upsertNativeSession(sessionId, nativeSession);
             }
         }
     }
-    async readRebuildWorkerStatus(statusPath, nativePath) {
+    async readRebuildWorkerStatus(statusPath, nativeSession) {
         const status = await readJsonIfValid(statusPath, WorkerStatusSchema);
         if (!status) {
             return null;
         }
-        if (status.native_session_id && !(await readJsonIfValid(nativePath, NativeSessionSchema))) {
+        if (status.native_session_id && status.native_session_id !== nativeSession?.session_id) {
             const nextStatus = { ...status };
             delete nextStatus.native_session_id;
             return WorkerStatusSchema.parse(nextStatus);
         }
         return status;
     }
+    async readRebuildNativeSession(nativePath, retiredNativePath) {
+        const active = await readJsonIfValid(nativePath, NativeSessionSchema);
+        if (!active) {
+            return null;
+        }
+        const retired = await readJsonIfValid(retiredNativePath, RetiredNativeSessionSchema);
+        return retired?.session_id === active.session_id ? null : active;
+    }
+}
+async function openSessionDatabase(databasePath, backupPath) {
+    let db = null;
+    try {
+        db = openCheckedDatabase(databasePath);
+        return { db, recovery: null };
+    }
+    catch (primaryError) {
+        try {
+            db?.close();
+        }
+        catch {
+            // Continue into file-backed recovery.
+        }
+        const backupIsHealthy = await isHealthyDatabaseFile(backupPath);
+        const quarantinedPath = await quarantineDatabase(databasePath);
+        await Promise.all([
+            rm(`${databasePath}-wal`, { force: true }),
+            rm(`${databasePath}-shm`, { force: true })
+        ]);
+        if (backupIsHealthy) {
+            await copyFile(backupPath, databasePath);
+        }
+        try {
+            return {
+                db: openCheckedDatabase(databasePath),
+                recovery: {
+                    source: backupIsHealthy ? "backup" : "empty",
+                    quarantinedPath
+                }
+            };
+        }
+        catch (recoveryError) {
+            throw new AggregateError([primaryError, recoveryError], `Unable to open or recover session index: ${databasePath}`);
+        }
+    }
+}
+function openCheckedDatabase(path) {
+    const db = new DatabaseSync(path);
+    try {
+        db.exec("PRAGMA busy_timeout = 5000");
+        assertHealthyDatabase(db);
+        return db;
+    }
+    catch (error) {
+        try {
+            db.close();
+        }
+        catch {
+            // Preserve the database validation failure.
+        }
+        throw error;
+    }
+}
+function assertHealthyDatabase(db) {
+    const rows = db.prepare("PRAGMA quick_check").all();
+    if (rows.length !== 1
+        || Object.values(rows[0] ?? {}).length !== 1
+        || Object.values(rows[0] ?? {})[0] !== "ok") {
+        throw new Error(`Session index integrity check failed: ${JSON.stringify(rows)}`);
+    }
+}
+async function isHealthyDatabaseFile(path) {
+    if (!(await pathExists(path))) {
+        return false;
+    }
+    let db = null;
+    try {
+        db = new DatabaseSync(path);
+        assertHealthyDatabase(db);
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+            // A failed validation can leave no open handle to close.
+        }
+    }
+}
+async function quarantineDatabase(path) {
+    const quarantinedPath = `${path}.corrupt-${Date.now()}-${process.pid}`;
+    if (await pathExists(path)) {
+        await rename(path, quarantinedPath);
+    }
+    return quarantinedPath;
+}
+async function replaceFile(source, target) {
+    try {
+        await rename(source, target);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST" && error.code !== "EPERM") {
+            throw error;
+        }
+        await rm(target, { force: true });
+        await rename(source, target);
+    }
 }
 async function readJsonIfValid(path, schema) {
     if (!(await pathExists(path))) {