parallel-codex-tui 0.1.0 → 0.1.4

package/dist/core/session-index.js

@@ -1,8 +1,8 @@
 import { readdir } 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";
 export class SessionIndex {
     db;
     projectRoot;
@@ -20,13 +20,16 @@ export class SessionIndex {
     }
     initialize() {
         this.db.exec(`
+      PRAGMA busy_timeout = 5000;
+
       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
+        status TEXT NOT NULL,
+        archived_at TEXT
       );
 
       CREATE TABLE IF NOT EXISTS turns (
@@ -64,19 +67,26 @@ export class SessionIndex {
         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
+      );
     `);
+        this.ensureColumn("tasks", "archived_at", "TEXT");
     }
     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
@@ -121,60 +131,245 @@ export class SessionIndex {
            source=excluded.source`)
             .run(taskId, record.worker_id, record.engine, record.role, record.session_id, record.cwd, record.created_at, record.last_used_at, record.source);
     }
+    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 = ?")
+            .get(taskId, workerId);
+        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;
         }
     }
     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;
+            }
+        }
+    }
+    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)) {
-            await this.upsertTask(await readJson(metaPath, TaskMetaSchema));
+        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))) {
-                    await this.upsertTurn(taskId, await readJson(turnPath, TurnMetaSchema));
+                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)) {
-                await this.upsertWorker(taskId, await readJson(statusPath, WorkerStatusSchema), {
-                    dir: workerDir,
-                    statusPath,
-                    outputLogPath: join(workerDir, "output.log")
-                });
+                const status = await this.readRebuildWorkerStatus(statusPath, nativeSession);
+                if (status) {
+                    await this.upsertWorker(sessionId, status, {
+                        dir: workerDir,
+                        statusPath,
+                        outputLogPath: join(workerDir, "output.log")
+                    });
+                }
             }
-            const nativePath = join(workerDir, "native-session.json");
-            if (await pathExists(nativePath)) {
-                await this.upsertNativeSession(taskId, await readJson(nativePath, NativeSessionSchema));
+            if (nativeSession) {
+                await this.upsertNativeSession(sessionId, nativeSession);
             }
         }
     }
+    async readRebuildWorkerStatus(statusPath, nativeSession) {
+        const status = await readJsonIfValid(statusPath, WorkerStatusSchema);
+        if (!status) {
+            return null;
+        }
+        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 readJsonIfValid(path, schema) {
+    if (!(await pathExists(path))) {
+        return null;
+    }
+    try {
+        return await readJson(path, schema);
+    }
+    catch {
+        return null;
+    }
 }