FEA-1550: Resolve PGlite migration review gaps

- Preserve live SQLite when prior backup and PGlite data already exist.

- Copy SQLite source rows in bounded batches instead of materializing entire tables.

- Sanitize the remaining SQLite path in migration failure logs.

- Add regression coverage for recreated SQLite, multi-batch event copy, and sanitized logs.

Testing: Focused SQLite-to-PGlite migration tests, desktop typecheck, desktop lint, desktop build, and full desktop test suite passed.

Risks: PGlite remains a prepared background copy while SQLite is the active runtime until async stores cut over.

Author: mikeangstadt

apps/desktop/src/main/database/sqlite-to-pglite-migration.ts

@@ -221,7 +221,6 @@ export async function migrateSqliteToPglite(
   }
 
   if (backupExists && pgdataExists) {
-    await rm(sqlitePath, { force: true });
     return {
       status: "skipped",
       reason: "already_migrated",
@@ -240,12 +239,14 @@ export async function migrateSqliteToPglite(
     );
     try {
       sqlite = new DatabaseSync(sqlitePath);
+      sqlite.exec("BEGIN");
       assertAllTablesManaged(sqlite);
       pglite = await PGlite.create(stagingDir);
 
       const sourceSchema = readSqliteSchema(sqlite);
       const sourceCounts = readSourceCounts(sqlite, sourceSchema);
       await initializeAndCopy(sqlite, pglite, sourceSchema, sourceCounts);
+      sqlite.exec("COMMIT");
 
       sqlite.close();
       sqlite = null;
@@ -285,8 +286,13 @@ export async function migrateSqliteToPglite(
       );
     }
   } catch (error) {
+    try {
+      sqlite?.exec("ROLLBACK");
+    } catch {
+      /* ignore rollback failure */
+    }
     log(
-      `SQLite to PGlite migration failed: sqlite=${sqlitePath}, pglite=${sanitizePath(pgliteDataDir)}, error=${sanitizeError(error)}`,
+      `SQLite to PGlite migration failed: sqlite=${sanitizePath(sqlitePath)}, pglite=${sanitizePath(pgliteDataDir)}, error=${sanitizeError(error)}`,
     );
     return {
       status: "failed",
@@ -344,19 +350,27 @@ async function initializeAndCopy(
       if (columns.length === 0) {
         continue;
       }
-      const rows = sqlite
-        .prepare(`SELECT ${columns.join(", ")} FROM ${table.name}`)
-        .all() as Record<string, unknown>[];
 
-      for (let i = 0; i < rows.length; i += BATCH_SIZE) {
-        const batch = rows.slice(i, i + BATCH_SIZE);
+      const selectBatchStmt = sqlite.prepare(
+        `SELECT ${columns.join(", ")} FROM ${table.name} ORDER BY rowid LIMIT ? OFFSET ?`,
+      );
+      let offset = 0;
+      while (true) {
+        const batch = selectBatchStmt.all(BATCH_SIZE, offset) as Record<
+          string,
+          unknown
+        >[];
+        if (batch.length === 0) {
+          break;
+        }
         await batchInsertRows(
           tx,
           table.name,
           table.conflictTarget,
           columns,
           batch,
         );
+        offset += batch.length;
       }
     }
 

apps/desktop/test/sqlite-to-pglite-migration.test.ts

@@ -175,6 +175,42 @@ function seedSqlite(dbPath: string): void {
   }
 }
 
+function insertAdditionalEvents(dbPath: string, count: number): void {
+  const db = new DatabaseSync(dbPath);
+  try {
+    const insert = db.prepare(`
+      INSERT INTO events (
+        id, session_id, agent_id, event_type, tool_name, summary, data,
+        created_at, user_id, organization_id
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    db.exec("BEGIN");
+    try {
+      for (let i = 0; i < count; i += 1) {
+        insert.run(
+          `event-extra-${i}`,
+          "session-1",
+          "session-1-main",
+          "PostToolUse",
+          "Read",
+          `Batch event ${i}`,
+          JSON.stringify({ index: i }),
+          `2026-06-01T00:${String(i % 60).padStart(2, "0")}:00.000Z`,
+          "user-1",
+          "org-1",
+        );
+      }
+      db.exec("COMMIT");
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  } finally {
+    db.close();
+  }
+}
+
 test("migrateSqliteToPglite copies rows, preserves attribution columns, and renames SQLite to .bak", async () => {
   const dir = makeTempDir();
   try {
@@ -216,17 +252,53 @@ test("migrateSqliteToPglite copies rows, preserves attribution columns, and rena
   }
 });
 
+test("migrateSqliteToPglite copies large tables in multiple bounded batches", async () => {
+  const dir = makeTempDir();
+  try {
+    const sqlitePath = path.join(dir, "agent-dashboard.sqlite");
+    seedSqlite(sqlitePath);
+    insertAdditionalEvents(sqlitePath, 1000);
+
+    const result = await migrateSqliteToPglite({ sqlitePath });
+
+    assert.equal(result.status, "migrated");
+    assert.equal(result.status === "migrated" ? result.rowCounts.events : 0, 1001);
+
+    const pg = await PGlite.create(resolvePgliteDataDir(sqlitePath));
+    try {
+      const eventCount = await pg.query<{ count: string }>(
+        "SELECT COUNT(*)::text AS count FROM events",
+      );
+      assert.equal(Number(eventCount.rows[0]?.count), 1001);
+    } finally {
+      await pg.close();
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("migrateSqliteToPglite returns failed and leaves SQLite intact with unmanaged source tables", async () => {
   const dir = makeTempDir();
   try {
     const sqlitePath = path.join(dir, "agent-dashboard.sqlite");
     const db = new DatabaseSync(sqlitePath);
     db.exec("CREATE TABLE compute_target (id TEXT PRIMARY KEY)");
     db.close();
+    const messages: string[] = [];
 
-    const result = await migrateSqliteToPglite({ sqlitePath });
+    const result = await migrateSqliteToPglite({
+      sqlitePath,
+      log: (message) => messages.push(message),
+    });
 
     assert.equal(result.status, "failed");
+    assert.ok(messages.length > 0);
+    assert.equal(
+      messages.some((message) => message.includes(sqlitePath)),
+      false,
+      "failure logs must not include absolute SQLite paths",
+    );
     assert.equal(
       existsSync(sqlitePath),
       true,
@@ -259,6 +331,34 @@ test("migrateSqliteToPglite skips when backup and pgdata exist", async () => {
   }
 });
 
+test("migrateSqliteToPglite does not delete live SQLite when backup and pgdata already exist", async () => {
+  const dir = makeTempDir();
+  try {
+    const sqlitePath = path.join(dir, "agent-dashboard.sqlite");
+    seedSqlite(sqlitePath);
+    writeFileSync(`${sqlitePath}.bak`, "backup");
+    mkdirSync(resolvePgliteDataDir(sqlitePath));
+
+    const result = await migrateSqliteToPglite({ sqlitePath });
+
+    assert.equal(result.status, "skipped");
+    assert.equal(result.status === "skipped" ? result.reason : "", "already_migrated");
+    assert.equal(existsSync(sqlitePath), true, "live SQLite must not be deleted");
+
+    const db = new DatabaseSync(sqlitePath);
+    try {
+      const row = db.prepare("SELECT id FROM sessions WHERE id = ?").get("session-1") as
+        | { id: string }
+        | undefined;
+      assert.equal(row?.id, "session-1");
+    } finally {
+      db.close();
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("migrateSqliteToPglite returns sqlite_missing when only .bak exists without .pgdata", async () => {
   const dir = makeTempDir();
   try {