fix(upload): read the session store when no codev process has it open (#378)

opencode.db runs in WAL mode. The Bun session reader opened it read-only,
and a read-only connection cannot create the -wal/-shm side files a WAL
read needs. While a codev process holds the store they exist; after the
last one closes cleanly they are gone, and Bun's SQLite fails the first
query with SQLITE_CANTOPEN — so `codev upload`, `codev upload --logs`,
or a stats push with nothing else running found no sessions.

The Bun driver now probes the read-only connection and, only on
SQLITE_CANTOPEN, reopens read-write without create so SQLite recreates
the side files as any WAL reader does; the reader still only runs
SELECTs, and a missing store is never created. node:sqlite (the desktop
sidecar's driver) already handles this case; the parity test now covers
it for both drivers.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: quickbeard

packages/codev-upload/src/sqlite.bun.ts

@@ -3,7 +3,7 @@ import type { SessionDb, SessionStatement } from "./sqlite"
 
 // Bun driver for the session reader — see sqlite.ts for the split.
 export function openSessionDb(path: string): SessionDb {
-  const db = new Database(path, { readonly: true })
+  const db = openReadable(path)
   return {
     prepare<R>(sql: string): SessionStatement<R> {
       const stmt = db.prepare(sql)
@@ -13,4 +13,25 @@ export function openSessionDb(path: string): SessionDb {
   }
 }
 
+// The store runs in WAL mode, and a read-only connection cannot create the
+// -wal/-shm side files a WAL read needs. While a codev process has the store
+// open they exist; after the last one closes cleanly they are gone, and Bun's
+// SQLite then fails the first query with SQLITE_CANTOPEN — `codev upload`
+// with nothing else running would find no sessions. Only in that case, reopen
+// read-write (never creating the database) so SQLite can recreate the side
+// files the way any reader of a WAL database does; the reader itself still
+// only runs SELECTs. node:sqlite (the desktop sidecar's driver) handles this
+// case on its own.
+function openReadable(path: string): Database {
+  const readonly = new Database(path, { readonly: true })
+  try {
+    readonly.prepare("SELECT 1 FROM sqlite_master LIMIT 1").all()
+    return readonly
+  } catch (err) {
+    readonly.close()
+    if ((err as { code?: string }).code !== "SQLITE_CANTOPEN") throw err
+    return new Database(path, { readwrite: true, create: false })
+  }
+}
+
 export type { SessionDb, SessionStatement } from "./sqlite"

packages/codev-upload/test/sqlite-node.test.ts

@@ -1,6 +1,6 @@
 import { Database } from "bun:sqlite"
 import { describe, expect, test } from "bun:test"
-import { mkdtempSync, rmSync } from "node:fs"
+import { existsSync, mkdtempSync, rmSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { openSessionDb } from "../src/sqlite.bun"
@@ -22,6 +22,21 @@ function seedFixture(dir: string): string {
   return path
 }
 
+// The store as it looks once every codev process has closed it: WAL mode,
+// fully checkpointed, and no -wal/-shm side files left beside it.
+function seedClosedWalFixture(dir: string): string {
+  const path = join(dir, "wal.db")
+  const seed = new Database(path, { create: true })
+  seed.run("PRAGMA journal_mode=WAL")
+  seed.run("CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, time_created INTEGER)")
+  seed.run("INSERT INTO session VALUES ('s1', 'p1', 1), ('s2', 'p2', 2)")
+  seed.run("PRAGMA wal_checkpoint(TRUNCATE)")
+  seed.close()
+  rmSync(`${path}-wal`, { force: true })
+  rmSync(`${path}-shm`, { force: true })
+  return path
+}
+
 describe("sqlite driver parity", () => {
   test("bun driver answers the reader's query shapes", () => {
     const dir = mkdtempSync(join(tmpdir(), "codev-upload-sqlite-"))
@@ -39,11 +54,27 @@ describe("sqlite driver parity", () => {
     rmSync(dir, { recursive: true, force: true })
   })
 
+  test("bun driver reads a WAL store no codev process has open", () => {
+    const dir = mkdtempSync(join(tmpdir(), "codev-upload-sqlite-wal-"))
+    const db = openSessionDb(seedClosedWalFixture(dir))
+    expect(db.prepare<{ id: string }>("SELECT id FROM session WHERE project_id = ?").all("p1")).toEqual([{ id: "s1" }])
+    db.close()
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  test("bun driver never creates a missing store", () => {
+    const dir = mkdtempSync(join(tmpdir(), "codev-upload-sqlite-missing-"))
+    const path = join(dir, "missing.db")
+    expect(() => openSessionDb(path)).toThrow()
+    expect(existsSync(path)).toBe(false)
+    rmSync(dir, { recursive: true, force: true })
+  })
+
   test("node driver (the desktop sidecar's) returns the same rows under real node", async () => {
     const node = Bun.which("node")
     if (!node) return // no node on this machine — the bun half still ran
     const dir = mkdtempSync(join(tmpdir(), "codev-upload-sqlite-node-"))
-    const fixture = seedFixture(dir)
+    const fixtures = [seedFixture(dir), seedClosedWalFixture(dir)]
     const built = join(dir, "sqlite.node.mjs")
     const build = Bun.spawnSync([
       "bun",
@@ -55,18 +86,22 @@ describe("sqlite driver parity", () => {
     ])
     expect(build.exitCode).toBe(0)
 
+    // Both fixtures, including the WAL store with no side files left.
     const script = `
       import { openSessionDb } from ${JSON.stringify(built)}
-      const db = openSessionDb(${JSON.stringify(fixture)})
-      const rows = db.prepare("SELECT id FROM session WHERE project_id = ? ORDER BY time_created").all("p1")
-      db.close()
-      process.stdout.write(JSON.stringify(rows))
+      const results = ${JSON.stringify(fixtures)}.map((fixture) => {
+        const db = openSessionDb(fixture)
+        const rows = db.prepare("SELECT id FROM session WHERE project_id = ? ORDER BY time_created").all("p1")
+        db.close()
+        return rows
+      })
+      process.stdout.write(JSON.stringify(results))
     `
     const run = Bun.spawnSync([node, "--experimental-sqlite", "--no-warnings", "--input-type=module", "-e", script])
     const stderr = run.stderr.toString()
     if (run.exitCode !== 0 && stderr.includes("No such built-in module")) return // node too old — skip
     expect(stderr).toBe("")
-    expect(run.stdout.toString()).toBe(EXPECTED)
+    expect(run.stdout.toString()).toBe(`[${EXPECTED},${EXPECTED}]`)
     rmSync(dir, { recursive: true, force: true })
   })
 })