Refactor unit test DB infrastructure to use real migrations and getDb()

- Replaced manual database mocks and sql.js wrappers with a global better-sqlite3 mock (backed by sql.js to avoid ABI issues).
- Created tests/unit/setup.ts for centralized test environment and DB initialization.
- Updated all unit tests to use the actual getDb() singleton and standard SQLite API.
- Fixed a greedy regex bug in gemini-session-store.ts that failed on titles with parentheses.
- Expanded test coverage for token cost estimation and session list parsing.
- Removed redundant tests/unit/main/test-db.ts.

Author: waterdrop86

src/main/db.ts

@@ -60,8 +60,12 @@ function applyMigrations(database: Database.Database): void {
 export function getDb(): Database.Database {
   if (db) return db;
 
-  const dbPath = join(app.getPath('userData'), 'mcode.db');
-  logger.info('db', 'Opening database', { path: dbPath });
+  const isTest = process.env.NODE_ENV === 'test';
+  const dbPath = isTest ? ':memory:' : join(app.getPath('userData'), 'mcode.db');
+
+  if (!isTest) {
+    logger.info('db', 'Opening database', { path: dbPath });
+  }
 
   db = new Database(dbPath);
   db.pragma('journal_mode = WAL');
@@ -78,3 +82,14 @@ export function closeDb(): void {
     db = null;
   }
 }
+
+/**
+ * ONLY FOR TESTING: Force closes the database and clears the singleton.
+ * Next call to getDb() will return a fresh instance.
+ */
+export function resetDbForTest(): void {
+  if (process.env.NODE_ENV !== 'test') {
+    throw new Error('resetDbForTest can only be called in test environment');
+  }
+  closeDb();
+}

src/main/session/gemini-session-store.ts

@@ -26,7 +26,7 @@ export function parseGeminiSessionList(output: string): GeminiListedSession[] {
     if (!trimmed) continue;
     nonEmptyLines++;
 
-    const match = line.match(/^\s*(\d+)\.\s+(.*?)\s+\((.*?)\)\s+\[([^\]]+)\]\s*$/);
+    const match = line.match(/^\s*(\d+)\.\s+(.*)\s+\(([^)]+)\)\s+\[([^\]]+)\]\s*$/);
     if (!match) continue;
 
     const [, indexText, title, relativeAgeText, geminiSessionId] = match;

tests/unit/main/copilot-session-store.test.ts

@@ -66,6 +66,19 @@ describe('parseEventsJsonlFirstLine', () => {
     expect(parseEventsJsonlFirstLine(path)).toBeNull();
   });
 
+  it('skips malformed first line and tries to find a valid session.start', () => {
+    // Note: current implementation only looks at the first line. 
+    // Let's verify this behavior or improve it if needed.
+    const path = join(tmpDir, 'events.jsonl');
+    writeFileSync(path, 'not json\n' + JSON.stringify({
+      type: 'session.start',
+      data: { sessionId: UUID_A, startTime: '2026-03-29T10:00:00Z', context: { cwd: '/tmp' } },
+    }) + '\n');
+    
+    // Current implementation:
+    expect(parseEventsJsonlFirstLine(path)).toBeNull();
+  });
+
   it('returns null for empty file', () => {
     const path = join(tmpDir, 'events.jsonl');
     writeFileSync(path, '');

tests/unit/main/gemini-session-store.test.ts

@@ -69,6 +69,8 @@ describe('gemini-session-store', () => {
       '  not a session line',
       '  0. bad index (just now) [invalid-zero]',
       '  3. Valid title (moments ago) [valid-id]',
+      '  4. Another title [no-age] [valid-id-2]',
+      '  5. Missing bracket age (just now valid-id-3',
       'Loaded cached credentials.',
     ].join('\n'))).toEqual([
       {
@@ -80,6 +82,30 @@ describe('gemini-session-store', () => {
     ]);
   });
 
+  it('handles titles with special characters', () => {
+    const output = `Available sessions for this project (1):
+  1. Title with (parens) and [brackets] (1 hour ago) [uuid-123]`;
+    expect(parseGeminiSessionList(output)).toEqual([
+      {
+        index: 1,
+        title: 'Title with (parens) and [brackets]',
+        relativeAgeText: '1 hour ago',
+        geminiSessionId: 'uuid-123',
+      },
+    ]);
+  });
+
+  it('handles very long session lists', () => {
+    const lines = ['Available sessions for this project (100):'];
+    for (let i = 1; i <= 100; i++) {
+      lines.push(`  ${i}. Session ${i} (day ago) [uuid-${i}]`);
+    }
+    const result = parseGeminiSessionList(lines.join('\n'));
+    expect(result).toHaveLength(100);
+    expect(result[99].index).toBe(100);
+    expect(result[99].geminiSessionId).toBe('uuid-100');
+  });
+
   it('returns null when every listed Gemini session is already claimed', () => {
     const entries = parseGeminiSessionList(sampleOutput);
     expect(selectGeminiSessionCandidate(entries, {

tests/unit/main/migrations.test.ts

@@ -1,37 +1,36 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { readdirSync } from 'node:fs';
 import { join } from 'node:path';
-import type { Database } from 'sql.js';
-import { createTestDb } from './test-db';
+import { getDb, resetDbForTest } from '../../../src/main/db';
 
 const migrationCount = readdirSync(join(__dirname, '../../../db/migrations'))
   .filter((f) => f.endsWith('.sql')).length;
 
 describe('database migrations', () => {
-  let db: Database;
-
-  beforeAll(async () => {
-    db = await createTestDb();
+  beforeAll(() => {
+    resetDbForTest();
   });
 
   afterAll(() => {
-    db.close();
+    resetDbForTest();
   });
 
   it(`applies all ${migrationCount} migrations without errors`, () => {
-    const results = db.exec('SELECT version FROM schema_version ORDER BY version');
-    const versions = results[0].values.map((row) => row[0] as number);
+    const db = getDb();
+    const rows = db.prepare('SELECT version FROM schema_version ORDER BY version').all() as { version: number }[];
+    const versions = rows.map((row) => row.version);
 
     expect(versions.length).toBe(migrationCount);
     expect(versions[0]).toBe(1);
     expect(versions[versions.length - 1]).toBe(migrationCount);
   });
 
   it('creates all expected tables', () => {
-    const results = db.exec(
+    const db = getDb();
+    const rows = db.prepare(
       `SELECT name FROM sqlite_master WHERE type = 'table' AND name != 'schema_version' ORDER BY name`,
-    );
-    const tableNames = results[0].values.map((row) => row[0] as string);
+    ).all() as { name: string }[];
+    const tableNames = rows.map((row) => row.name);
 
     const expected = [
       'account_profiles',
@@ -52,26 +51,28 @@ describe('database migrations', () => {
   });
 
   it('enforces foreign key constraints', () => {
+    const db = getDb();
     expect(() =>
-      db.run(
-        `INSERT INTO events (session_id, hook_event_name, payload) VALUES ('nonexistent', 'test', '{}')`,
-      ),
+      db.prepare(
+        `INSERT INTO events (session_id, hook_event_name, session_status, payload, created_at) VALUES ('nonexistent', 'test', 'active', '{}', datetime('now'))`,
+      ).run(),
     ).toThrow();
   });
 
   it('allows valid foreign key references', () => {
-    db.run(
-      `INSERT INTO sessions (session_id, label, cwd, status, started_at)
-       VALUES ('test-sess', 'test', '/tmp', 'active', datetime('now'))`,
-    );
+    const db = getDb();
+    db.prepare(
+      `INSERT INTO sessions (session_id, label, cwd, status, started_at, session_type, hook_mode)
+       VALUES ('test-sess', 'test', '/tmp', 'active', datetime('now'), 'claude', 'live')`,
+    ).run();
 
     expect(() =>
-      db.run(
-        `INSERT INTO events (session_id, hook_event_name, payload) VALUES ('test-sess', 'test', '{}')`,
-      ),
+      db.prepare(
+        `INSERT INTO events (session_id, hook_event_name, session_status, payload, created_at) VALUES ('test-sess', 'test', 'active', '{}', datetime('now'))`,
+      ).run(),
     ).not.toThrow();
 
-    db.run(`DELETE FROM events WHERE session_id = 'test-sess'`);
-    db.run(`DELETE FROM sessions WHERE session_id = 'test-sess'`);
+    db.prepare(`DELETE FROM events WHERE session_id = 'test-sess'`).run();
+    db.prepare(`DELETE FROM sessions WHERE session_id = 'test-sess'`).run();
   });
 });