@hasna/economy 0.2.26 → 0.2.28

package/dist/index.js

@@ -565,6 +565,26 @@ function openDatabase(dbPath, skipSeed = false) {
   }
   return db;
 }
+function quoteSqlIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function hasColumn(db, table, column) {
+  const columns = db.prepare(`PRAGMA table_info(${quoteSqlIdent(table)})`).all();
+  return columns.some((c) => c.name === column);
+}
+function addColumnIfMissing(db, table, column, definition) {
+  if (hasColumn(db, table, column))
+    return false;
+  try {
+    db.exec(`ALTER TABLE ${quoteSqlIdent(table)} ADD COLUMN ${quoteSqlIdent(column)} ${definition}`);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/duplicate column name/i.test(message))
+      return true;
+    throw error;
+  }
+}
 function initSchema(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS requests (
@@ -735,59 +755,31 @@ function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_usage_agent_date ON usage_snapshots(agent, date);
     CREATE INDEX IF NOT EXISTS idx_savings_date ON savings_daily(date);
   `);
-  const cols = db.prepare(`PRAGMA table_info(requests)`).all();
-  if (!cols.some((c) => c.name === "machine_id")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN machine_id TEXT DEFAULT ''`);
-    db.exec(`ALTER TABLE sessions ADD COLUMN machine_id TEXT DEFAULT ''`);
-  }
-  if (!cols.some((c) => c.name === "cache_create_5m_tokens")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN cache_create_5m_tokens INTEGER DEFAULT 0`);
+  addColumnIfMissing(db, "requests", "machine_id", `TEXT DEFAULT ''`);
+  addColumnIfMissing(db, "sessions", "machine_id", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "requests", "cache_create_5m_tokens", "INTEGER DEFAULT 0")) {
     db.exec(`UPDATE requests SET cache_create_5m_tokens = cache_create_tokens WHERE cache_create_5m_tokens = 0`);
   }
-  if (!cols.some((c) => c.name === "cache_create_1h_tokens")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN cache_create_1h_tokens INTEGER DEFAULT 0`);
-  }
-  if (!cols.some((c) => c.name === "cost_basis")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN cost_basis TEXT DEFAULT 'estimated'`);
-  }
-  if (!cols.some((c) => c.name === "attribution_tag")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN attribution_tag TEXT DEFAULT ''`);
-  }
-  if (!cols.some((c) => c.name === "updated_at")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN updated_at TEXT DEFAULT ''`);
+  addColumnIfMissing(db, "requests", "cache_create_1h_tokens", "INTEGER DEFAULT 0");
+  addColumnIfMissing(db, "requests", "cost_basis", `TEXT DEFAULT 'estimated'`);
+  addColumnIfMissing(db, "requests", "attribution_tag", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "requests", "updated_at", `TEXT DEFAULT ''`)) {
     db.exec(`UPDATE requests SET updated_at = timestamp WHERE updated_at = '' OR updated_at IS NULL`);
   }
-  if (!cols.some((c) => c.name === "synced_at")) {
-    db.exec(`ALTER TABLE requests ADD COLUMN synced_at TEXT DEFAULT ''`);
-  }
+  addColumnIfMissing(db, "requests", "synced_at", `TEXT DEFAULT ''`);
   for (const column of ["account_key", "account_tool", "account_name", "account_email", "account_source"]) {
-    if (!cols.some((c) => c.name === column)) {
-      db.exec(`ALTER TABLE requests ADD COLUMN ${column} TEXT DEFAULT ''`);
-    }
-  }
-  const sessionCols = db.prepare(`PRAGMA table_info(sessions)`).all();
-  if (!sessionCols.some((c) => c.name === "attribution_tag")) {
-    db.exec(`ALTER TABLE sessions ADD COLUMN attribution_tag TEXT DEFAULT ''`);
+    addColumnIfMissing(db, "requests", column, `TEXT DEFAULT ''`);
   }
-  if (!sessionCols.some((c) => c.name === "updated_at")) {
-    db.exec(`ALTER TABLE sessions ADD COLUMN updated_at TEXT DEFAULT ''`);
+  addColumnIfMissing(db, "sessions", "attribution_tag", `TEXT DEFAULT ''`);
+  if (addColumnIfMissing(db, "sessions", "updated_at", `TEXT DEFAULT ''`)) {
     db.exec(`UPDATE sessions SET updated_at = started_at WHERE updated_at = '' OR updated_at IS NULL`);
   }
-  if (!sessionCols.some((c) => c.name === "synced_at")) {
-    db.exec(`ALTER TABLE sessions ADD COLUMN synced_at TEXT DEFAULT ''`);
-  }
+  addColumnIfMissing(db, "sessions", "synced_at", `TEXT DEFAULT ''`);
   for (const column of ["account_key", "account_tool", "account_name", "account_email", "account_source"]) {
-    if (!sessionCols.some((c) => c.name === column)) {
-      db.exec(`ALTER TABLE sessions ADD COLUMN ${column} TEXT DEFAULT ''`);
-    }
-  }
-  const pricingCols = db.prepare(`PRAGMA table_info(model_pricing)`).all();
-  if (!pricingCols.some((c) => c.name === "cache_write_1h_per_1m")) {
-    db.exec(`ALTER TABLE model_pricing ADD COLUMN cache_write_1h_per_1m REAL NOT NULL DEFAULT 0`);
-  }
-  if (!pricingCols.some((c) => c.name === "cache_storage_per_1m_hour")) {
-    db.exec(`ALTER TABLE model_pricing ADD COLUMN cache_storage_per_1m_hour REAL NOT NULL DEFAULT 0`);
+    addColumnIfMissing(db, "sessions", column, `TEXT DEFAULT ''`);
   }
+  addColumnIfMissing(db, "model_pricing", "cache_write_1h_per_1m", "REAL NOT NULL DEFAULT 0");
+  addColumnIfMissing(db, "model_pricing", "cache_storage_per_1m_hour", "REAL NOT NULL DEFAULT 0");
   db.exec(`
     CREATE INDEX IF NOT EXISTS idx_requests_machine ON requests(machine_id);
     CREATE INDEX IF NOT EXISTS idx_sessions_machine ON sessions(machine_id);
@@ -948,17 +940,22 @@ function querySummary(db, period, machine, allMachines = false) {
   const codexTotals = db.prepare(`
     SELECT COALESCE(SUM(total_cost_usd), 0) as cost_usd,
            COALESCE(SUM(total_tokens), 0) as tokens,
+           COALESCE(SUM(request_count), 0) as requests,
            COUNT(*) as sessions
     FROM sessions
     WHERE ${sWhere}${machineClause}
     AND id NOT IN (SELECT DISTINCT session_id FROM requests)
   `).get();
-  const sessionCount = db.prepare(`SELECT COUNT(*) as sessions FROM sessions WHERE ${sWhere}${machineClause}`).get();
+  const requestSessionCount = db.prepare(`
+    SELECT COUNT(DISTINCT session_id) as sessions
+    FROM requests
+    WHERE ${rWhere}${machineClause}
+  `).get();
   return {
     total_usd: r.total_usd + codexTotals.cost_usd,
-    requests: r.requests,
+    requests: r.requests + codexTotals.requests,
     tokens: r.tokens + codexTotals.tokens,
-    sessions: sessionCount.sessions,
+    sessions: requestSessionCount.sessions + codexTotals.sessions,
     period
   };
 }
@@ -1037,9 +1034,7 @@ function queryAgentBreakdown(db, period = "all") {
   }
   return [...groups.values()].sort((a, b) => b.api_equivalent_usd - a.api_equivalent_usd);
 }
-function labelForPath(projectPath, projectName) {
-  if (projectName && projectName.trim() !== "")
-    return projectName;
+function pathProjectLabel(projectPath) {
   if (!projectPath)
     return "";
   const segments = projectPath.split("/").filter(Boolean);
@@ -1048,12 +1043,45 @@ function labelForPath(projectPath, projectName) {
     if (projectPrefix.test(seg))
       return seg;
   }
-  const generic = new Set(["web", "app", "apps", "packages", "src", "lib", "server", "client", "api", "frontend", "backend"]);
+  const generic = new Set([
+    "web",
+    "app",
+    "apps",
+    "packages",
+    "src",
+    "lib",
+    "server",
+    "client",
+    "api",
+    "frontend",
+    "backend",
+    "home",
+    "users",
+    "workspace",
+    "workspaces",
+    "hasna"
+  ]);
   for (let i = segments.length - 1;i >= 0; i--) {
     if (!generic.has(segments[i].toLowerCase()))
       return segments[i];
   }
-  return segments[segments.length - 1] ?? projectPath;
+  return null;
+}
+function isRepoLikeLabel(label) {
+  return /^(open|skill|hook|service|connect|platform|agent|tool|iapp|project|scaffold|capp)-/.test(label) || label.includes("-");
+}
+function labelForPath(projectPath, projectName) {
+  const pathLabel = pathProjectLabel(projectPath);
+  if (pathLabel && (!projectName || projectName.trim() === "" || isRepoLikeLabel(pathLabel)))
+    return pathLabel;
+  if (projectName && projectName.trim() !== "")
+    return projectName;
+  if (pathLabel)
+    return pathLabel;
+  return projectPath;
+}
+function groupKeyForPath(projectPath, projectName) {
+  return labelForPath(projectPath, projectName).trim().toLowerCase();
 }
 function queryProjectBreakdown(db, period = "all") {
   const requestWhere = requestPeriodWhere(period);
@@ -1068,14 +1096,15 @@ function queryProjectBreakdown(db, period = "all") {
     const label = labelForPath(s.project_path, s.project_name);
     if (!label)
       continue;
-    const g = groups.get(label) ?? { sessionIds: [], samplePath: s.project_path };
+    const key = groupKeyForPath(s.project_path, s.project_name);
+    const g = groups.get(key) ?? { label, sessionIds: [], samplePath: s.project_path };
     g.sessionIds.push(s.id);
     if (!g.samplePath)
       g.samplePath = s.project_path;
-    groups.set(label, g);
+    groups.set(key, g);
   }
   const result = [];
-  for (const [label, g] of groups.entries()) {
+  for (const g of groups.values()) {
     const placeholders = g.sessionIds.map(() => "?").join(",");
     const reqStats = placeholders.length ? db.prepare(`
           SELECT
@@ -1106,7 +1135,7 @@ function queryProjectBreakdown(db, period = "all") {
     const lastActive = [reqStats.last_active, sessionOnlyStats.last_active].filter(Boolean).sort().at(-1) ?? "";
     result.push({
       project_path: g.samplePath,
-      project_name: label,
+      project_name: g.label,
       sessions: totalSessions,
       requests: reqStats.requests + sessionOnlyStats.requests,
       total_tokens: reqStats.total_tokens + sessionOnlyStats.total_tokens,
@@ -1346,17 +1375,48 @@ function queryBillingSummary(db, period) {
   }
   return { total_usd: total, by_provider };
 }
-function listMachines(db) {
+function listMachines(db, period = "all") {
+  const rWhere = requestPeriodWhere(period);
+  const sWhere = sessionPeriodWhere(period);
   return db.prepare(`
+    WITH request_stats AS (
+      SELECT
+        machine_id,
+        COUNT(DISTINCT session_id) as sessions,
+        COUNT(*) as requests,
+        COALESCE(SUM(cost_usd), 0) as total_cost_usd,
+        MAX(timestamp) as last_active
+      FROM requests
+      WHERE machine_id != ''
+        AND ${rWhere}
+      GROUP BY machine_id
+    ),
+    session_only_stats AS (
+      SELECT
+        machine_id,
+        COUNT(*) as sessions,
+        COALESCE(SUM(request_count), 0) as requests,
+        COALESCE(SUM(total_cost_usd), 0) as total_cost_usd,
+        MAX(started_at) as last_active
+      FROM sessions
+      WHERE machine_id != ''
+        AND ${sWhere}
+        AND id NOT IN (SELECT DISTINCT session_id FROM requests)
+      GROUP BY machine_id
+    ),
+    combined AS (
+      SELECT * FROM request_stats
+      UNION ALL
+      SELECT * FROM session_only_stats
+    )
     SELECT
-      s.machine_id,
-      COUNT(DISTINCT s.id) as sessions,
-      COALESCE((SELECT COUNT(*) FROM requests r WHERE r.machine_id = s.machine_id), 0) as requests,
-      COALESCE(SUM(s.total_cost_usd), 0) as total_cost_usd,
-      MAX(s.started_at) as last_active
-    FROM sessions s
-    WHERE s.machine_id != ''
-    GROUP BY s.machine_id
+      machine_id,
+      COALESCE(SUM(sessions), 0) as sessions,
+      COALESCE(SUM(requests), 0) as requests,
+      COALESCE(SUM(total_cost_usd), 0) as total_cost_usd,
+      MAX(last_active) as last_active
+    FROM combined
+    GROUP BY machine_id
     ORDER BY total_cost_usd DESC
   `).all();
 }
@@ -1438,17 +1498,21 @@ function listMachineRegistry(db) {
 }
 function dedupeRequests(db) {
   const dupes = db.prepare(`
-    SELECT source_request_id, agent, MIN(id) as keep_id, COUNT(*) as cnt
+    SELECT source_request_id, agent, COALESCE(machine_id, '') as machine_id, MIN(id) as keep_id, COUNT(*) as cnt
     FROM requests
     WHERE source_request_id != '' AND source_request_id IS NOT NULL
-    GROUP BY source_request_id, agent
+    GROUP BY source_request_id, agent, COALESCE(machine_id, '')
     HAVING cnt > 1
   `).all();
   let removed = 0;
   for (const row of dupes) {
     const result = db.prepare(`
-      DELETE FROM requests WHERE source_request_id = ? AND agent = ? AND id != ?
-    `).run(row.source_request_id, row.agent, row.keep_id);
+      DELETE FROM requests
+      WHERE source_request_id = ?
+        AND agent = ?
+        AND COALESCE(machine_id, '') = ?
+        AND id != ?
+    `).run(row.source_request_id, row.agent, row.machine_id, row.keep_id);
     removed += result.changes;
   }
   return removed;
@@ -1731,10 +1795,303 @@ async function syncOpenProjectsRegistry(db, listActiveProjects) {
   }
   return { imported, skipped };
 }
+// src/lib/peer-sync.ts
+init_database();
+import { Database as BunDatabase } from "bun:sqlite";
+import { existsSync as existsSync3 } from "fs";
+
+// src/lib/package-metadata.ts
+import { readFileSync as readFileSync2 } from "fs";
+var cachedMetadata = null;
+function getPackageMetadata() {
+  if (cachedMetadata)
+    return cachedMetadata;
+  const raw = readFileSync2(new URL("../../package.json", import.meta.url), "utf8");
+  const parsed = JSON.parse(raw);
+  cachedMetadata = {
+    name: parsed.name ?? "@hasna/economy",
+    version: parsed.version ?? "0.0.0"
+  };
+  return cachedMetadata;
+}
+var packageMetadata = getPackageMetadata();
+
+// src/lib/peer-sync.ts
+var GENERIC_PEER_TABLES = [
+  "usage_snapshots",
+  "subscriptions",
+  "billing_daily",
+  "savings_daily",
+  "budgets",
+  "goals",
+  "model_pricing",
+  "machines"
+];
+function quoteIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function tableExists(db, table) {
+  const row = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(table);
+  return Boolean(row);
+}
+function tableColumns(db, table) {
+  if (!tableExists(db, table))
+    return [];
+  return db.prepare(`PRAGMA table_info(${quoteIdent(table)})`).all();
+}
+function commonColumns(source, target, table) {
+  const sourceCols = new Set(tableColumns(source, table).map((c) => c.name));
+  return tableColumns(target, table).map((c) => c.name).filter((c) => sourceCols.has(c));
+}
+function primaryKeyColumns(db, table) {
+  return tableColumns(db, table).filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk).map((c) => c.name);
+}
+function selectRows(source, table, columns) {
+  if (columns.length === 0)
+    return [];
+  const select = columns.map(quoteIdent).join(", ");
+  return source.prepare(`SELECT ${select} FROM ${quoteIdent(table)}`).all();
+}
+function rowByKey(target, table, keyColumns, row) {
+  if (keyColumns.length === 0)
+    return null;
+  if (keyColumns.some((c) => row[c] == null))
+    return null;
+  const where = keyColumns.map((c) => `${quoteIdent(c)} = ?`).join(" AND ");
+  return target.prepare(`SELECT * FROM ${quoteIdent(table)} WHERE ${where}`).get(...keyColumns.map((c) => row[c]));
+}
+function hasId(target, table, id) {
+  return target.prepare(`SELECT id, machine_id FROM ${quoteIdent(table)} WHERE id = ?`).get(id);
+}
+function shouldReplace(source, existing) {
+  if (!existing)
+    return true;
+  const sourceUpdated = source["updated_at"];
+  const existingUpdated = existing["updated_at"];
+  if (typeof sourceUpdated === "string" && typeof existingUpdated === "string" && existingUpdated !== "") {
+    return sourceUpdated >= existingUpdated;
+  }
+  return true;
+}
+function normalizeRow(row, columns, sourceMachine, now) {
+  const next = { ...row };
+  if (columns.includes("machine_id") && (!next["machine_id"] || next["machine_id"] === "")) {
+    next["machine_id"] = sourceMachine;
+  }
+  if (columns.includes("updated_at") && (!next["updated_at"] || next["updated_at"] === "")) {
+    next["updated_at"] = next["timestamp"] ?? next["started_at"] ?? next["created_at"] ?? now;
+  }
+  if (columns.includes("synced_at") && next["synced_at"] == null)
+    next["synced_at"] = "";
+  if (columns.includes("attribution_tag") && next["attribution_tag"] == null)
+    next["attribution_tag"] = "";
+  return next;
+}
+function insertOrReplace(target, table, columns, row) {
+  const colSql = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  target.prepare(`
+    INSERT OR REPLACE INTO ${quoteIdent(table)} (${colSql})
+    VALUES (${placeholders})
+  `).run(...columns.map((c) => row[c] ?? null));
+}
+function collisionId(target, table, machine, originalId) {
+  const base = `${machine || "peer"}:${originalId}`;
+  const baseRow = hasId(target, table, base);
+  if (!baseRow || String(baseRow["machine_id"] ?? "") === machine)
+    return base;
+  for (let i = 2;; i++) {
+    const candidate = `${base}:${i}`;
+    const row = hasId(target, table, candidate);
+    if (!row || String(row["machine_id"] ?? "") === machine)
+      return candidate;
+  }
+}
+function mergeIdentityTable(target, source, table, sourceMachine, now, sessionIdMap) {
+  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
+  const columns = commonColumns(source, target, table);
+  const rows = selectRows(source, table, columns);
+  const idMap = new Map;
+  for (const raw of rows) {
+    const row = normalizeRow(raw, columns, sourceMachine, now);
+    const originalId = String(row["id"] ?? "");
+    if (!originalId) {
+      stats.skipped++;
+      continue;
+    }
+    const machine = String(row["machine_id"] ?? "");
+    const directExisting = hasId(target, table, originalId);
+    if (directExisting && String(directExisting["machine_id"] ?? "") !== machine) {
+      row["id"] = collisionId(target, table, machine, originalId);
+      stats.collisions++;
+    }
+    if (table === "requests" && sessionIdMap) {
+      const originalSessionId = String(row["session_id"] ?? "");
+      row["session_id"] = sessionIdMap.get(originalSessionId) ?? originalSessionId;
+    }
+    const existing = hasId(target, table, String(row["id"]));
+    idMap.set(originalId, String(row["id"]));
+    if (existing && !shouldReplace(row, existing)) {
+      stats.skipped++;
+      continue;
+    }
+    insertOrReplace(target, table, columns, row);
+    if (existing)
+      stats.updated++;
+    else
+      stats.inserted++;
+  }
+  return { stats, idMap };
+}
+function mergeProjects(target, source) {
+  const table = "projects";
+  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
+  const columns = commonColumns(source, target, table);
+  const rows = selectRows(source, table, columns);
+  for (const raw of rows) {
+    const row = { ...raw };
+    const path = String(row["path"] ?? "");
+    const id = String(row["id"] ?? "");
+    if (!path || !id) {
+      stats.skipped++;
+      continue;
+    }
+    const existingByPath = target.prepare(`SELECT * FROM projects WHERE path = ?`).get(path);
+    if (existingByPath) {
+      row["id"] = existingByPath["id"] ?? id;
+      insertOrReplace(target, table, columns, row);
+      stats.updated++;
+      continue;
+    }
+    const existingById = target.prepare(`SELECT * FROM projects WHERE id = ?`).get(id);
+    if (existingById && String(existingById["path"] ?? "") !== path) {
+      row["id"] = `peer:${id}`;
+      stats.collisions++;
+      while (target.prepare(`SELECT id FROM projects WHERE id = ?`).get(row["id"])) {
+        row["id"] = `peer:${String(row["id"])}`;
+      }
+    }
+    insertOrReplace(target, table, columns, row);
+    stats.inserted++;
+  }
+  return stats;
+}
+function mergeGenericTable(target, source, table, sourceMachine, now) {
+  const stats = { table, inserted: 0, updated: 0, skipped: 0, collisions: 0 };
+  const columns = commonColumns(source, target, table);
+  const keyColumns = primaryKeyColumns(target, table).filter((c) => columns.includes(c));
+  const rows = selectRows(source, table, columns);
+  for (const raw of rows) {
+    const row = normalizeRow(raw, columns, sourceMachine, now);
+    const existing = rowByKey(target, table, keyColumns, row);
+    if (existing && !shouldReplace(row, existing)) {
+      stats.skipped++;
+      continue;
+    }
+    insertOrReplace(target, table, columns, row);
+    if (existing)
+      stats.updated++;
+    else
+      stats.inserted++;
+  }
+  return stats;
+}
+function detectSourceMachine(source, fallback) {
+  if (fallback && fallback.trim())
+    return fallback.trim();
+  const counts = new Map;
+  for (const table of ["sessions", "requests", "usage_snapshots"]) {
+    if (!tableExists(source, table))
+      continue;
+    const rows = source.prepare(`
+      SELECT machine_id, COUNT(*) as cnt
+      FROM ${quoteIdent(table)}
+      WHERE machine_id != '' AND machine_id IS NOT NULL
+      GROUP BY machine_id
+    `).all();
+    for (const row of rows) {
+      counts.set(row.machine_id, (counts.get(row.machine_id) ?? 0) + row.cnt);
+    }
+  }
+  let best = "";
+  let bestCount = -1;
+  for (const [machine, count] of counts.entries()) {
+    if (count > bestCount) {
+      best = machine;
+      bestCount = count;
+    }
+  }
+  return best || "peer";
+}
+function ensureMachineRegistry(target, machine, now) {
+  if (!machine)
+    return;
+  target.prepare(`
+    INSERT INTO machines (machine_id, hostname, last_seen_at, last_push_at, last_pull_at, economy_version, updated_at)
+    VALUES (?, ?, ?, NULL, ?, ?, ?)
+    ON CONFLICT(machine_id) DO UPDATE SET
+      hostname = COALESCE(NULLIF(machines.hostname, ''), excluded.hostname),
+      last_seen_at = CASE
+        WHEN machines.last_seen_at IS NULL OR machines.last_seen_at < excluded.last_seen_at THEN excluded.last_seen_at
+        ELSE machines.last_seen_at
+      END,
+      last_pull_at = excluded.last_pull_at,
+      economy_version = excluded.economy_version,
+      updated_at = excluded.updated_at
+  `).run(machine, machine, now, now, packageMetadata.version, now);
+}
+function openSourceDatabase(path) {
+  try {
+    return new BunDatabase(path, { readonly: true });
+  } catch {
+    return new BunDatabase(path);
+  }
+}
+function mergePeerDatabase(target, sourcePath, opts = {}) {
+  if (!existsSync3(sourcePath))
+    throw new Error(`source database does not exist: ${sourcePath}`);
+  const source = openSourceDatabase(sourcePath);
+  const now = opts.now ?? new Date().toISOString();
+  const sourceMachine = detectSourceMachine(source, opts.sourceMachine);
+  const tables = [];
+  try {
+    target.exec("PRAGMA foreign_keys = OFF");
+    target.exec("BEGIN IMMEDIATE");
+    try {
+      tables.push(mergeProjects(target, source));
+      const sessionMerge = mergeIdentityTable(target, source, "sessions", sourceMachine, now);
+      tables.push(sessionMerge.stats);
+      tables.push(mergeIdentityTable(target, source, "requests", sourceMachine, now, sessionMerge.idMap).stats);
+      for (const table of GENERIC_PEER_TABLES) {
+        tables.push(mergeGenericTable(target, source, table, sourceMachine, now));
+      }
+      ensureMachineRegistry(target, sourceMachine, now);
+      target.exec("COMMIT");
+    } catch (err) {
+      target.exec("ROLLBACK");
+      throw err;
+    } finally {
+      target.exec("PRAGMA foreign_keys = ON");
+    }
+  } finally {
+    source.close();
+  }
+  const deduped = dedupeRequests(target);
+  const rowsWritten = tables.reduce((sum, table) => sum + table.inserted + table.updated, 0);
+  const collisions = tables.reduce((sum, table) => sum + table.collisions, 0);
+  return {
+    source_path: sourcePath,
+    source_machine: sourceMachine,
+    rows_written: rowsWritten,
+    collisions,
+    deduped,
+    tables: tables.filter((t) => t.inserted || t.updated || t.skipped || t.collisions)
+  };
+}
 // src/ingest/claude.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join3, basename } from "path";
 
@@ -1903,7 +2260,7 @@ async function ingestTakumi(db, verbose = false, projectsDir = TAKUMI_PROJECTS_D
   return ingestJsonlProjects(db, projectsDir, "takumi", verbose);
 }
 async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false) {
-  if (!existsSync3(projectsDir)) {
+  if (!existsSync4(projectsDir)) {
     if (verbose)
       console.log(`${agentName} projects dir not found:`, projectsDir);
     return { files: 0, requests: 0, sessions: 0 };
@@ -1932,7 +2289,7 @@ async function ingestJsonlProjects(db, projectsDir, agentName, verbose = false)
         continue;
       let lines;
       try {
-        lines = readFileSync2(filePath, "utf-8").split(`
+        lines = readFileSync3(filePath, "utf-8").split(`
 `).filter((l) => l.trim());
       } catch {
         continue;
@@ -2051,10 +2408,10 @@ function supportsClaudeDataResidencyPricing(model) {
 // src/ingest/codex.ts
 init_database();
 init_pricing();
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4, basename as basename2 } from "path";
-import { Database as BunDatabase } from "bun:sqlite";
+import { Database as BunDatabase2 } from "bun:sqlite";
 var DEFAULT_CODEX_DB_PATH = join4(homedir3(), ".codex", "state_5.sqlite");
 var DEFAULT_CODEX_CONFIG_PATH = join4(homedir3(), ".codex", "config.toml");
 var CODEX_INGEST_VERSION = "rollout-aggregate-v3";
@@ -2066,10 +2423,10 @@ function codexConfigPath() {
 }
 function readCodexModel() {
   const configPath = codexConfigPath();
-  if (!existsSync4(configPath))
+  if (!existsSync5(configPath))
     return "gpt-5-codex";
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const match = content.match(/^model\s*=\s*"([^"]+)"/m);
     return match?.[1] ?? "gpt-5-codex";
   } catch {
@@ -2092,7 +2449,7 @@ function openCodexDb(dbPath, verbose) {
   for (const readonly of [true, false]) {
     let codexDb = null;
     try {
-      codexDb = readonly ? new BunDatabase(dbPath, { readonly: true }) : new BunDatabase(dbPath);
+      codexDb = readonly ? new BunDatabase2(dbPath, { readonly: true }) : new BunDatabase2(dbPath);
       codexDb.prepare("PRAGMA schema_version").get();
       return codexDb;
     } catch (error) {
@@ -2107,12 +2464,12 @@ function openCodexDb(dbPath, verbose) {
   return null;
 }
 function readTokenEvents(rolloutPath) {
-  if (!rolloutPath || !existsSync4(rolloutPath))
+  if (!rolloutPath || !existsSync5(rolloutPath))
     return [];
   const fallbackUsages = new Map;
   let fallbackTimestamp;
   let aggregate = null;
-  for (const line of readFileSync3(rolloutPath, "utf-8").split(`
+  for (const line of readFileSync4(rolloutPath, "utf-8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -2184,7 +2541,7 @@ function fallbackEvents(totalTokens) {
 }
 async function ingestCodex(db, verbose = false) {
   const dbPath = codexDbPath();
-  if (!existsSync4(dbPath)) {
+  if (!existsSync5(dbPath)) {
     if (verbose)
       console.log("Codex DB not found:", dbPath);
     return { sessions: 0, requests: 0 };
@@ -2267,7 +2624,7 @@ async function ingestCodex(db, verbose = false) {
 // src/ingest/gemini.ts
 init_database();
 init_pricing();
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync5, existsSync as existsSync6, statSync as statSync3 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join5, basename as basename3 } from "path";
 var DEFAULT_GEMINI_TMP_DIR = join5(homedir4(), ".gemini", "tmp");
@@ -2288,7 +2645,7 @@ function numberField(...values) {
 function listProjectDirs(...roots) {
   const dirs = new Set;
   for (const root of roots) {
-    if (!existsSync5(root))
+    if (!existsSync6(root))
       continue;
     try {
       for (const entry of readdirSync3(root, { withFileTypes: true })) {
@@ -2306,15 +2663,15 @@ function projectRoot(projectDir, chatData) {
     return chatData.project_path;
   const rootFile = join5(projectDir, ".project_root");
   try {
-    if (existsSync5(rootFile))
-      return readFileSync4(rootFile, "utf-8").trim();
+    if (existsSync6(rootFile))
+      return readFileSync5(rootFile, "utf-8").trim();
   } catch {}
   return "";
 }
 async function ingestGemini(db, verbose) {
   const tmpDir = geminiTmpDir();
   const historyDir = geminiHistoryDir();
-  if (!existsSync5(tmpDir) && !existsSync5(historyDir)) {
+  if (!existsSync6(tmpDir) && !existsSync6(historyDir)) {
     if (verbose)
       console.log("Gemini tmp/history dirs not found:", tmpDir, historyDir);
     return { sessions: 0, requests: 0 };
@@ -2327,7 +2684,7 @@ async function ingestGemini(db, verbose) {
   const projectDirs = listProjectDirs(tmpDir, historyDir);
   for (const projectDir of projectDirs) {
     const chatsDir = join5(projectDir, "chats");
-    if (!existsSync5(chatsDir))
+    if (!existsSync6(chatsDir))
       continue;
     let chatFiles = [];
     try {
@@ -2348,7 +2705,7 @@ async function ingestGemini(db, verbose) {
         continue;
       let chatData;
       try {
-        chatData = JSON.parse(readFileSync4(filePath, "utf-8"));
+        chatData = JSON.parse(readFileSync5(filePath, "utf-8"));
       } catch {
         continue;
       }
@@ -2451,6 +2808,7 @@ export {
   queryAccountBreakdown,
   openDatabase,
   normalizeModelName,
+  mergePeerDatabase,
   listSubscriptions,
   listProjects,
   listModelPricing,