agentboss 0.1.0

package/server/etl/backfill-subagents.js

@@ -0,0 +1,178 @@
+/**
+ * One-shot backfill for the parent_session_id / agent_type columns on
+ * unified_session.
+ *
+ * Background
+ * ----------
+ * These columns were added after the ETL had already imported sessions
+ * from opencode.db.  Existing rows have NULL values, which means the
+ * "会话列表" filters (which hide subagents via `parent_session_id IS NULL`)
+ * would still leak old subagents until the user manually re-ran ETL.
+ *
+ * What this does
+ * --------------
+ * 1. Reads every unified_session row where source = 'opencode' AND
+ *    parent_session_id IS NULL.
+ * 2. Opens the user's opencode.db read-only and looks up the matching
+ *    rows in its `session` table.
+ * 3. For each row whose source has a non-null parent_id (or non-null
+ *    agent), updates unified_session.parent_session_id / agent_type
+ *    in place.
+ *
+ * Idempotent: once a row's parent_session_id is non-NULL it's excluded
+ * from the WHERE clause, so a second invocation is a no-op (modulo
+ * sessions whose source has parent_id but agent_type was NULL and
+ * stayed NULL — we still re-update, harmless).
+ *
+ * Safe failure: opencode.db missing / locked / table renamed → log and
+ * return 0; the migration is best-effort and absolutely must not break
+ * server boot.
+ *
+ * @author Felix
+ */
+
+'use strict';
+
+const fs = require('fs');
+const sqlite3 = require('sqlite3');
+
+const { queryAll, queryOne } = require('../db/queries');
+const { saveDb } = require('../db/connection');
+
+// ---------------------------------------------------------------------------
+//  sqlite3 promise wrappers (kept local to avoid a circular dep on opencode.js)
+// ---------------------------------------------------------------------------
+
+function openReadOnly(dbPath) {
+  return new Promise((resolve, reject) => {
+    const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
+      if (err) return reject(err);
+      resolve(db);
+    });
+  });
+}
+
+function closeNative(db) {
+  return new Promise((resolve, reject) => {
+    db.close((err) => (err ? reject(err) : resolve()));
+  });
+}
+
+function dbAll(db, sql, params = []) {
+  return new Promise((resolve, reject) => {
+    db.all(sql, params, (err, rows) => (err ? reject(err) : resolve(rows || [])));
+  });
+}
+
+// ---------------------------------------------------------------------------
+//  Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the path to the source opencode.db from the tool_config table,
+ * which is populated by detect.js on server boot.  Returns null if not
+ * configured / detected.
+ */
+function resolveOpenCodeDbPath(bossDb) {
+  const row = queryOne(
+    bossDb,
+    "SELECT data_path FROM tool_config WHERE tool = 'opencode'"
+  );
+  if (!row || !row.data_path) return null;
+  if (!fs.existsSync(row.data_path)) return null;
+  return row.data_path;
+}
+
+/**
+ * Chunk an array into N-element sub-arrays.  Used so the WHERE IN
+ * clause stays well under SQLite's 999-parameter limit.
+ */
+function chunk(arr, size) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) {
+    out.push(arr.slice(i, i + size));
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+//  Public
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the backfill.  Always resolves; logs failures.
+ *
+ * @param {object} bossDb  sql.js database (boss.db)
+ * @returns {Promise<{ scanned: number, updated: number, skipped: number, reason?: string }>}
+ */
+async function backfillSubagents(bossDb) {
+  // 1. Find candidates in boss.db.
+  const candidates = queryAll(
+    bossDb,
+    `SELECT id FROM unified_session
+      WHERE source = 'opencode'
+        AND parent_session_id IS NULL`
+  );
+  if (candidates.length === 0) {
+    return { scanned: 0, updated: 0, skipped: 0 };
+  }
+
+  // 2. Resolve source db path.
+  const ocPath = resolveOpenCodeDbPath(bossDb);
+  if (!ocPath) {
+    return { scanned: candidates.length, updated: 0, skipped: candidates.length, reason: 'opencode.db not configured' };
+  }
+
+  // 3. Open source db read-only.
+  let srcDb;
+  try {
+    srcDb = await openReadOnly(ocPath);
+  } catch (err) {
+    return { scanned: candidates.length, updated: 0, skipped: candidates.length, reason: `open failed: ${err.message}` };
+  }
+
+  let updated = 0;
+  try {
+    // 4. Look up parent_id / agent for each candidate, in chunks.
+    const idSet = candidates.map((r) => r.id);
+    const lookups = [];
+    for (const ids of chunk(idSet, 500)) {
+      const placeholders = ids.map(() => '?').join(',');
+      const rows = await dbAll(
+        srcDb,
+        `SELECT id, parent_id, agent FROM session WHERE id IN (${placeholders})`,
+        ids
+      );
+      lookups.push(...rows);
+    }
+
+    // 5. Build patch list (only rows that actually have parent or agent).
+    const patches = lookups.filter((r) => r.parent_id || r.agent);
+
+    // 6. Apply patches.  sql.js doesn't batch, so plain UPDATE-per-row
+    //    is fine — boss.db is in-memory.
+    for (const p of patches) {
+      bossDb.run(
+        `UPDATE unified_session
+            SET parent_session_id = ?, agent_type = ?
+          WHERE id = ?`,
+        [p.parent_id || null, p.agent || null, p.id]
+      );
+      updated++;
+    }
+
+    if (updated > 0) {
+      try { saveDb(); } catch { /* noop */ }
+    }
+  } finally {
+    try { await closeNative(srcDb); } catch { /* noop */ }
+  }
+
+  return {
+    scanned: candidates.length,
+    updated,
+    skipped: candidates.length - updated,
+  };
+}
+
+module.exports = { backfillSubagents };