feat(sessions): use npm SQLite reader for KiloCode

Author: awsl233777

cli.js

@@ -1875,15 +1875,20 @@ function getKiloCodeDataRoots() {
 function getKiloCodeDatabaseFiles() {
     const files = [];
     const seen = new Set();
+    const push = (value) => {
+        if (typeof value !== 'string' || !value.trim()) return;
+        const full = expandHomePath(value.trim());
+        if (!full || seen.has(full) || !fs.existsSync(full)) return;
+        seen.add(full);
+        files.push(full);
+    };
+    push(process.env.KILO_DB);
     for (const root of getKiloCodeDataRoots()) {
         let entries = [];
         try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch (_) { continue; }
         for (const entry of entries) {
-            if (!entry.isFile() || !/^kilo(?:-.+)?\.db$/i.test(entry.name)) continue;
-            const full = path.join(root, entry.name);
-            if (seen.has(full)) continue;
-            seen.add(full);
-            files.push(full);
+            if (!entry.isFile() || !/^(?:kilo|opencode)(?:-.+)?\.db$/i.test(entry.name)) continue;
+            push(path.join(root, entry.name));
         }
     }
     return files;
@@ -5724,68 +5729,68 @@ function normalizeKiloCodeStructuredMessage(row) {
     };
 }
 
-function runKiloCodeSqlitePython(dbPath, mode, options = {}) {
+let g_kiloCodeSqliteBinding = undefined;
+
+function loadKiloCodeSqliteBinding() {
+    if (g_kiloCodeSqliteBinding !== undefined) return g_kiloCodeSqliteBinding;
+    try {
+        g_kiloCodeSqliteBinding = require('better-sqlite3');
+    } catch (_) {
+        g_kiloCodeSqliteBinding = null;
+    }
+    return g_kiloCodeSqliteBinding;
+}
+
+function runKiloCodeSqlite(dbPath, mode, options = {}) {
     if (!dbPath || !fs.existsSync(dbPath)) return null;
-    const script = String.raw`
-import json, sqlite3, sys
-
-db_path, mode = sys.argv[1], sys.argv[2]
-session_id = sys.argv[3] if len(sys.argv) > 3 else ''
-limit = int(sys.argv[4]) if len(sys.argv) > 4 and sys.argv[4].isdigit() else 200
-conn = sqlite3.connect('file:' + db_path + '?mode=ro', uri=True)
-conn.row_factory = sqlite3.Row
-try:
-    tables = {r['name'] for r in conn.execute("select name from sqlite_master where type='table'")}
-    if 'session' not in tables or 'session_message' not in tables:
-        print('[]')
-    elif mode == 'list':
-        rows = conn.execute("""
-            select s.id, s.directory, s.path, s.title, s.model, s.cost,
-                   s.tokens_input, s.tokens_output, s.tokens_reasoning,
-                   s.tokens_cache_read, s.tokens_cache_write,
-                   s.time_created, s.time_updated,
-                   count(m.id) as message_count,
-                   max(coalesce(m.time_created, 0)) as last_message_time
-            from session s
-            left join session_message m on m.session_id = s.id
-            where s.time_archived is null
-            group by s.id
-            order by max(coalesce(m.time_created, s.time_updated, s.time_created, 0)) desc
-            limit ?
-        """, (limit,)).fetchall()
-        print(json.dumps([dict(r) for r in rows]))
-    elif mode == 'messages':
-        rows = conn.execute("""
-            select id, session_id, type, seq, time_created, time_updated, data
-            from session_message
-            where session_id = ?
-            order by coalesce(seq, time_created, 0), time_created, id
-        """, (session_id,)).fetchall()
-        print(json.dumps([dict(r) for r in rows]))
-    elif mode == 'session':
-        row = conn.execute("""
-            select id, directory, path, title, model, cost,
-                   tokens_input, tokens_output, tokens_reasoning,
-                   tokens_cache_read, tokens_cache_write,
-                   time_created, time_updated
-            from session
-            where id = ?
-        """, (session_id,)).fetchone()
-        print(json.dumps(dict(row) if row else None))
-    else:
-        print('[]')
-finally:
-    conn.close()
-`;
+    const Database = loadKiloCodeSqliteBinding();
+    if (!Database) return null;
+    let db;
     try {
-        const output = execFileSync('python3', ['-c', script, dbPath, mode, String(options.sessionId || ''), String(options.limit || 200)], {
-            encoding: 'utf8',
-            maxBuffer: 8 * 1024 * 1024,
-            timeout: 15000
-        });
-        return JSON.parse(output || 'null');
+        db = new Database(dbPath, { readonly: true, fileMustExist: true });
+        const tables = new Set(db.prepare("select name from sqlite_master where type='table'").all().map(row => row.name));
+        if (!tables.has('session') || !tables.has('session_message')) return [];
+        if (mode === 'list') {
+            return db.prepare(`
+                select s.id, s.directory, s.path, s.title, s.model, s.cost,
+                       s.tokens_input, s.tokens_output, s.tokens_reasoning,
+                       s.tokens_cache_read, s.tokens_cache_write,
+                       s.time_created, s.time_updated,
+                       count(m.id) as message_count,
+                       max(coalesce(m.time_created, 0)) as last_message_time
+                from session s
+                left join session_message m on m.session_id = s.id and m.seq is not null
+                where s.time_archived is null
+                group by s.id
+                order by max(coalesce(m.time_created, s.time_updated, s.time_created, 0)) desc
+                limit ?
+            `).all(Math.max(1, Math.floor(Number(options.limit) || 200)));
+        }
+        if (mode === 'messages') {
+            return db.prepare(`
+                select id, session_id, type, seq, time_created, time_updated, data
+                from session_message
+                where session_id = ? and seq is not null
+                order by seq, time_created, id
+            `).all(String(options.sessionId || ''));
+        }
+        if (mode === 'session') {
+            return db.prepare(`
+                select id, directory, path, title, model, cost,
+                       tokens_input, tokens_output, tokens_reasoning,
+                       tokens_cache_read, tokens_cache_write,
+                       time_created, time_updated
+                from session
+                where id = ?
+            `).get(String(options.sessionId || '')) || null;
+        }
+        return [];
     } catch (_) {
         return null;
+    } finally {
+        if (db) {
+            try { db.close(); } catch (_) { }
+        }
     }
 }
 
@@ -5833,7 +5838,7 @@ function listKiloCodeDatabaseSessions(limit) {
     const sessions = [];
     const lookupStore = g_sessionFileLookupCache.kilocode;
     for (const dbPath of getKiloCodeDatabaseFiles()) {
-        const rows = runKiloCodeSqlitePython(dbPath, 'list', { limit: Math.max(limit * 2, 200) });
+        const rows = runKiloCodeSqlite(dbPath, 'list', { limit: Math.max(limit * 2, 200) });
         if (!Array.isArray(rows)) continue;
         for (const row of rows) {
             const summary = toKiloCodeDbSessionSummary(row, dbPath);
@@ -5849,9 +5854,9 @@ function listKiloCodeDatabaseSessions(limit) {
 
 function readKiloCodeDatabaseSessionDetail(dbPath, sessionId, messageLimit = DEFAULT_SESSION_DETAIL_MESSAGES) {
     if (!dbPath || !sessionId || !fs.existsSync(dbPath)) return null;
-    const sessionRow = runKiloCodeSqlitePython(dbPath, 'session', { sessionId });
+    const sessionRow = runKiloCodeSqlite(dbPath, 'session', { sessionId });
     if (!sessionRow || typeof sessionRow !== 'object') return null;
-    const rows = runKiloCodeSqlitePython(dbPath, 'messages', { sessionId, limit: Math.max(messageLimit * 4, 200) });
+    const rows = runKiloCodeSqlite(dbPath, 'messages', { sessionId, limit: Math.max(messageLimit * 4, 200) });
     if (!Array.isArray(rows)) return null;
     const messages = rows.map(normalizeKiloCodeStructuredMessage).filter(Boolean);
     const filtered = removeLeadingSystemMessage(messages);