zevairouter 1.0.154 → 1.0.155

package/src/lib/db/index.js

@@ -1,218 +0,0 @@
-// Public API barrel — all DB functions
-import { getAdapter } from "./driver.js";
-import { TABLES } from "./schema.js";
-import { stringifyJson, parseJson } from "./helpers/jsonCol.js";
-
-// Settings
-export {
-  getSettings, updateSettings, isCloudEnabled, getCloudUrl, exportSettings,
-} from "./repos/settingsRepo.js";
-
-// Provider connections
-export {
-  getProviderConnections, getProviderConnectionById,
-  createProviderConnection, updateProviderConnection,
-  deleteProviderConnection, deleteProviderConnectionsByProvider,
-  reorderProviderConnections, cleanupProviderConnections,
-} from "./repos/connectionsRepo.js";
-
-// Provider nodes
-export {
-  getProviderNodes, getProviderNodeById,
-  createProviderNode, updateProviderNode, deleteProviderNode,
-} from "./repos/nodesRepo.js";
-
-// Proxy pools
-export {
-  getProxyPools, getProxyPoolById,
-  createProxyPool, updateProxyPool, deleteProxyPool,
-} from "./repos/proxyPoolsRepo.js";
-
-// Quota cache (server-side per-account quota snapshots for routing)
-export {
-  saveQuotaSnapshot, getQuotaSnapshot, getAllQuotaSnapshots,
-  deleteQuotaSnapshot, getCachedRemainingPercent,
-} from "./repos/quotaCacheRepo.js";
-
-// Context files (user-authored system-prompt injection)
-export {
-  listContextFiles, getEnabledContextFiles, getContextFile,
-  createContextFile, createContextFilesBulk, updateContextFile, deleteContextFile,
-} from "./repos/contextFilesRepo.js";
-
-// API keys
-export {
-  getApiKeys, getApiKeyById, createApiKey, updateApiKey, deleteApiKey, validateApiKey,
-  checkApiKeyBudget, admitApiKeyRequest, rotateApiKey, maskApiKey,
-} from "./repos/apiKeysRepo.js";
-
-// Combos
-export {
-  getCombos, getComboById, getComboByName,
-  createCombo, updateCombo, deleteCombo,
-} from "./repos/combosRepo.js";
-
-// Aliases (model + custom + mitm)
-export {
-  getModelAliases, setModelAlias, deleteModelAlias,
-  getCustomModels, addCustomModel, deleteCustomModel,
-  getMitmAlias, setMitmAliasAll,
-} from "./repos/aliasRepo.js";
-
-// Pricing
-export {
-  getPricing, getPricingForModel, updatePricing, resetPricing, resetAllPricing,
-} from "./repos/pricingRepo.js";
-
-// Disabled models
-export {
-  getDisabledModels, getDisabledByProvider, disableModels, enableModels,
-} from "./repos/disabledModelsRepo.js";
-
-// Usage
-export {
-  statsEmitter, trackPendingRequest, getActiveRequests,
-  saveRequestUsage, getUsageHistory, getUsageStats, getChartData,
-  getLatencyStats,
-  appendRequestLog, getRecentLogs,
-} from "./repos/usageRepo.js";
-
-// Request details
-export {
-  saveRequestDetail, getRequestDetails, getRequestDetailById,
-} from "./repos/requestDetailsRepo.js";
-
-// Telemetry/history tables — huge and not needed for config restore (settings,
-// connections, API keys, proxies, combos). Including them made "Download backup"
-// multi‑MB JSON after long usage (usageHistory alone often 20MB+).
-const BACKUP_EXCLUDE_TABLES = new Set([
-  "usageHistory",
-  "requestDetails",
-  "quotaCache",
-]);
-
-// Export/import full DB
-export async function exportDb() {
-  const db = await getAdapter();
-  const { exportSettings } = await import("./repos/settingsRepo.js");
-
-  const tableNames = Object.keys(TABLES).filter((table) => !BACKUP_EXCLUDE_TABLES.has(table));
-
-  const out = {
-    // Config-oriented export (legacy top-level fields for older importers)
-    settings: await exportSettings(),
-    providerConnections: db.all(`SELECT * FROM providerConnections`).map((r) => ({ ...parseJson(r.data, {}), id: r.id, provider: r.provider, authType: r.authType, name: r.name, email: r.email, priority: r.priority, isActive: r.isActive === 1, createdAt: r.createdAt, updatedAt: r.updatedAt })),
-    providerNodes: db.all(`SELECT * FROM providerNodes`).map((r) => ({ ...parseJson(r.data, {}), id: r.id, type: r.type, name: r.name, createdAt: r.createdAt, updatedAt: r.updatedAt })),
-    proxyPools: db.all(`SELECT * FROM proxyPools`).map((r) => ({ ...parseJson(r.data, {}), id: r.id, isActive: r.isActive === 1, testStatus: r.testStatus, createdAt: r.createdAt, updatedAt: r.updatedAt })),
-    apiKeys: db.all(`SELECT * FROM apiKeys`).map((r) => ({ id: r.id, key: r.key, name: r.name, machineId: r.machineId, isActive: r.isActive === 1, createdAt: r.createdAt })),
-    combos: db.all(`SELECT * FROM combos`).map((r) => ({ id: r.id, name: r.name, kind: r.kind, models: parseJson(r.models, []), createdAt: r.createdAt, updatedAt: r.updatedAt })),
-    modelAliases: {},
-    customModels: [],
-    mitmAlias: {},
-    pricing: {},
-    // Modern path: only config tables (no usage/request dump)
-    tables: Object.fromEntries(tableNames.map((table) => [table, db.all(`SELECT * FROM "${table}"`)])),
-    // Hint for UI / future full-export option
-    excludedTables: [...BACKUP_EXCLUDE_TABLES],
-  };
-
-  for (const r of db.all(`SELECT key, value FROM kv WHERE scope = 'modelAliases'`)) out.modelAliases[r.key] = parseJson(r.value);
-  for (const r of db.all(`SELECT key, value FROM kv WHERE scope = 'customModels'`)) out.customModels.push(parseJson(r.value));
-  for (const r of db.all(`SELECT key, value FROM kv WHERE scope = 'mitmAlias'`)) out.mitmAlias[r.key] = parseJson(r.value);
-  for (const r of db.all(`SELECT key, value FROM kv WHERE scope = 'pricing'`)) out.pricing[r.key] = parseJson(r.value);
-
-  return out;
-}
-
-export async function importDb(payload) {
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    throw new Error("Invalid database payload");
-  }
-  const db = await getAdapter();
-
-  db.transaction(() => {
-    if (payload.tables && typeof payload.tables === "object" && !Array.isArray(payload.tables)) {
-      for (const table of Object.keys(TABLES).reverse()) db.run(`DELETE FROM "${table}"`);
-      for (const [table, rows] of Object.entries(payload.tables)) {
-        if (!TABLES[table] || !Array.isArray(rows)) continue;
-        for (const row of rows) {
-          const columns = Object.keys(row).filter((column) => TABLES[table].columns[column]);
-          if (columns.length === 0) continue;
-          db.run(
-            `INSERT INTO "${table}" (${columns.map((column) => `"${column}"`).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`,
-            columns.map((column) => row[column])
-          );
-        }
-      }
-      return;
-    }
-
-    // Legacy exports replace only the datasets they historically contained.
-    db.run(`DELETE FROM settings`);
-    db.run(`DELETE FROM providerConnections`);
-    db.run(`DELETE FROM providerNodes`);
-    db.run(`DELETE FROM proxyPools`);
-    db.run(`DELETE FROM apiKeys`);
-    db.run(`DELETE FROM combos`);
-    db.run(`DELETE FROM kv WHERE scope IN ('modelAliases', 'customModels', 'mitmAlias', 'pricing')`);
-
-    // Settings
-    if (payload.settings) {
-      db.run(`INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`, [stringifyJson(payload.settings)]);
-    }
-
-    for (const c of payload.providerConnections || []) {
-      const { id, provider, authType, name, email, priority, isActive, createdAt, updatedAt, ...rest } = c;
-      db.run(
-        `INSERT OR REPLACE INTO providerConnections(id, provider, authType, name, email, priority, isActive, data, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [id, provider, authType || "oauth", name || null, email || null, priority || null, isActive === false ? 0 : 1, stringifyJson(rest), createdAt || new Date().toISOString(), updatedAt || new Date().toISOString()]
-      );
-    }
-    for (const n of payload.providerNodes || []) {
-      const { id, type, name, createdAt, updatedAt, ...rest } = n;
-      db.run(
-        `INSERT OR REPLACE INTO providerNodes(id, type, name, data, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?)`,
-        [id, type || null, name || null, stringifyJson(rest), createdAt || new Date().toISOString(), updatedAt || new Date().toISOString()]
-      );
-    }
-    for (const p of payload.proxyPools || []) {
-      const { id, isActive, testStatus, createdAt, updatedAt, ...rest } = p;
-      db.run(
-        `INSERT OR REPLACE INTO proxyPools(id, isActive, testStatus, data, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?)`,
-        [id, isActive === false ? 0 : 1, testStatus || "unknown", stringifyJson(rest), createdAt || new Date().toISOString(), updatedAt || new Date().toISOString()]
-      );
-    }
-    for (const k of payload.apiKeys || []) {
-      db.run(
-        `INSERT OR REPLACE INTO apiKeys(id, key, name, machineId, isActive, createdAt) VALUES(?, ?, ?, ?, ?, ?)`,
-        [k.id, k.key, k.name || null, k.machineId || null, k.isActive === false ? 0 : 1, k.createdAt || new Date().toISOString()]
-      );
-    }
-    for (const c of payload.combos || []) {
-      db.run(
-        `INSERT OR REPLACE INTO combos(id, name, kind, models, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?)`,
-        [c.id, c.name, c.kind || null, stringifyJson(c.models || []), c.createdAt || new Date().toISOString(), c.updatedAt || new Date().toISOString()]
-      );
-    }
-    for (const [a, m] of Object.entries(payload.modelAliases || {})) {
-      db.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('modelAliases', ?, ?)`, [a, stringifyJson(m)]);
-    }
-    for (const m of payload.customModels || []) {
-      const k = `${m.providerAlias}|${m.id}|${m.type || "llm"}`;
-      db.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('customModels', ?, ?)`, [k, stringifyJson(m)]);
-    }
-    for (const [tool, mappings] of Object.entries(payload.mitmAlias || {})) {
-      db.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('mitmAlias', ?, ?)`, [tool, stringifyJson(mappings || {})]);
-    }
-    for (const [provider, models] of Object.entries(payload.pricing || {})) {
-      db.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('pricing', ?, ?)`, [provider, stringifyJson(models || {})]);
-    }
-  });
-
-  return await exportDb();
-}
-
-// Eager init helper (optional)
-export async function initDb() {
-  await getAdapter();
-}

package/src/lib/db/maintenance.js

@@ -1,78 +0,0 @@
-import { getMetaSync, setMetaSync } from "./helpers/metaStore.js";
-
-// One-time VACUUM marker. Bump the suffix if we ever need to force a re-run.
-const VACUUM_DONE_KEY = "usageHistoryVacuum_v1";
-
-// How often the lightweight recurring prune runs.
-const PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6h
-
-function getRetentionDays() {
-  const d = parseInt(process.env.USAGE_HISTORY_RETENTION_DAYS || "60", 10);
-  return Number.isFinite(d) && d > 0 ? d : 60;
-}
-
-function cutoffIso(days) {
-  return new Date(Date.now() - days * 86400000).toISOString();
-}
-
-// Delete usageHistory rows older than `days`. Returns rows removed (best-effort).
-// NOTE: aggregate charts (7d/30d/60d) read from the usageDaily table, NOT from
-// usageHistory, so pruning raw history does not affect historical stats.
-export function pruneUsageHistory(adapter, days = getRetentionDays()) {
-  if (!adapter || !days || days <= 0) return 0;
-  try {
-    const before = adapter.get(`SELECT COUNT(*) as c FROM usageHistory`)?.c ?? 0;
-    adapter.run(`DELETE FROM usageHistory WHERE timestamp < ?`, [cutoffIso(days)]);
-    const after = adapter.get(`SELECT COUNT(*) as c FROM usageHistory`)?.c ?? 0;
-    return Math.max(0, before - after);
-  } catch (e) {
-    console.warn(`[DB][maintenance] prune failed: ${e.message}`);
-    return 0;
-  }
-}
-
-// Called once per adapter init (from driver.initAdapter, after migrations).
-// 1) One-time prune + VACUUM to reclaim pre-existing bloat (gated by _meta).
-// 2) Start a recurring prune so usageHistory stays bounded going forward.
-export function runStartupMaintenanceOnce(adapter) {
-  if (!adapter) return;
-
-  // --- One-time reclaim (prune + VACUUM) ---
-  try {
-    if (!getMetaSync(adapter, VACUUM_DONE_KEY, null)) {
-      const days = getRetentionDays();
-      const deleted = pruneUsageHistory(adapter, days);
-      try {
-        // VACUUM rebuilds the file and MUST run outside any transaction.
-        // On a large legacy DB this can take a while and briefly locks the DB.
-        adapter.exec(`VACUUM`);
-        setMetaSync(adapter, VACUUM_DONE_KEY, new Date().toISOString());
-        console.log(`[DB][maintenance] one-time prune (<${days}d, ${deleted} rows) + VACUUM done`);
-      } catch (e) {
-        // Leave the flag unset so VACUUM is retried on the next boot.
-        console.warn(`[DB][maintenance] VACUUM failed, will retry next boot: ${e.message}`);
-      }
-    }
-  } catch (e) {
-    console.warn(`[DB][maintenance] startup maintenance skipped: ${e.message}`);
-  }
-
-  // --- Recurring lightweight prune (DELETE only; free pages get reused) ---
-  if (!global._usageHistoryPruneTimer) {
-    try {
-      global._usageHistoryPruneTimer = setInterval(() => {
-        try { pruneUsageHistory(adapter); } catch {}
-      }, PRUNE_INTERVAL_MS);
-      // Don't keep the process alive just for this timer.
-      if (typeof global._usageHistoryPruneTimer.unref === "function") {
-        global._usageHistoryPruneTimer.unref();
-      }
-    } catch {}
-  }
-}
-
-export function stopStartupMaintenance() {
-  if (!global._usageHistoryPruneTimer) return;
-  clearInterval(global._usageHistoryPruneTimer);
-  global._usageHistoryPruneTimer = null;
-}

package/src/lib/db/migrate.js

@@ -1,295 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { LEGACY_FILES, DB_DIR, DATA_FILE } from "./paths.js";
-import { TABLES, buildCreateTableSql } from "./schema.js";
-import { MIGRATIONS, latestVersion } from "./migrations/index.js";
-import { getMetaSync, setMetaSync } from "./helpers/metaStore.js";
-import { makeBackupDir, backupFile, pruneOldBackups } from "./backup.js";
-import { getAppVersion } from "./version.js";
-import { stringifyJson } from "./helpers/jsonCol.js";
-
-// Marker file: prevents re-importing legacy JSON when user wipes data.sqlite.
-const MIGRATED_MARKER = path.join(DB_DIR, ".migrated-from-json");
-
-// Track per-adapter so reusing same adapter skips re-run, but new adapter (after reset) re-runs.
-const _migratedAdapters = new WeakSet();
-
-// Thrown when row-count assertion fails. Outer transaction rolls back,
-// legacy db.json kept intact, marker not written → next boot retries.
-export class MigrationAborted extends Error {
-  constructor(message, droppedRows) {
-    super(message);
-    this.name = "MigrationAborted";
-    this.droppedRows = droppedRows;
-  }
-}
-
-// Insert rows one-by-one, collect failures, then assert COUNT(*) matches input length.
-function importWithAssertion(adapter, tableName, rows, insertFn, rowMeta) {
-  const dropped = [];
-  for (const row of rows) {
-    try { insertFn(row); }
-    catch (err) { dropped.push({ ...rowMeta(row), reason: err.message }); }
-  }
-  const inserted = adapter.get(`SELECT COUNT(*) as c FROM ${tableName}`)?.c ?? 0;
-  if (inserted !== rows.length) {
-    console.warn(`[DB][migrate] ${tableName} row-count mismatch: expected ${rows.length}, got ${inserted}. Dropped:`, dropped);
-    throw new MigrationAborted(`${tableName} row-count mismatch: expected ${rows.length}, got ${inserted}`, dropped);
-  }
-}
-
-function readJsonSafe(file) {
-  if (!fs.existsSync(file)) return null;
-  try { return JSON.parse(fs.readFileSync(file, "utf-8")); } catch { return null; }
-}
-
-function isFreshDb(adapter) {
-  // Table _meta may not exist yet on truly fresh DB
-  try {
-    const row = adapter.get(`SELECT COUNT(*) as c FROM _meta`);
-    return !row || row.c === 0;
-  } catch {
-    return true;
-  }
-}
-
-// ─── Versioned migrations runner (skip-version safe) ─────────────────────
-function runVersionedMigrations(adapter) {
-  // Bootstrap _meta first so we can read schemaVersion
-  adapter.exec(buildCreateTableSql("_meta", TABLES._meta));
-
-  const current = parseInt(getMetaSync(adapter, "schemaVersion", "0"), 10) || 0;
-  const target = latestVersion();
-  if (current >= target) return { applied: 0, from: current, to: current };
-
-  const pending = MIGRATIONS.filter((m) => m.version > current);
-  let lastApplied = current;
-  for (const m of pending) {
-    adapter.transaction(() => {
-      m.up(adapter);
-      setMetaSync(adapter, "schemaVersion", m.version);
-    });
-    lastApplied = m.version;
-    console.log(`[DB][migrate] applied #${m.version} ${m.name}`);
-  }
-  return { applied: pending.length, from: current, to: lastApplied };
-}
-
-// ─── Auto-sync (additive only): add missing tables/columns/indexes ───────
-function syncSchemaFromTables(adapter) {
-  for (const [tableName, def] of Object.entries(TABLES)) {
-    // Create table if absent
-    adapter.exec(buildCreateTableSql(tableName, def));
-
-    // Diff columns
-    const existing = adapter.all(`PRAGMA table_info(${tableName})`);
-    const existingNames = new Set(existing.map((r) => r.name));
-    for (const [colName, colDef] of Object.entries(def.columns)) {
-      if (!existingNames.has(colName)) {
-        // SQLite ADD COLUMN restrictions: no PRIMARY KEY / UNIQUE w/o NULL ok.
-        // We strip PRIMARY KEY / UNIQUE since those are only valid at create time.
-        const safeDef = colDef
-          .replace(/PRIMARY KEY( AUTOINCREMENT)?/i, "")
-          .replace(/UNIQUE/i, "")
-          .trim();
-        try {
-          adapter.exec(`ALTER TABLE ${tableName} ADD COLUMN ${colName} ${safeDef}`);
-          console.log(`[DB][sync] +column ${tableName}.${colName}`);
-        } catch (e) {
-          console.warn(`[DB][sync] add column ${tableName}.${colName} failed: ${e.message}`);
-        }
-      }
-    }
-
-    // Indexes (idempotent)
-    for (const idx of def.indexes || []) {
-      try { adapter.exec(idx); } catch {}
-    }
-  }
-}
-
-// ─── Legacy JSON import (one-time) ───────────────────────────────────────
-function importLegacyMain(adapter, data) {
-  if (!data || typeof data !== "object") return;
-
-  if (data.settings) {
-    adapter.run(`INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`, [stringifyJson(data.settings)]);
-  }
-
-  importWithAssertion(adapter, "providerConnections", data.providerConnections || [], (c) => {
-    const { id, provider, authType, name, email, priority, isActive, createdAt, updatedAt, ...rest } = c;
-    adapter.run(
-      `INSERT OR REPLACE INTO providerConnections(id, provider, authType, name, email, priority, isActive, data, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [id, provider, authType || "oauth", name || null, email || null, priority || null, isActive === false ? 0 : 1, stringifyJson(rest), createdAt || new Date().toISOString(), updatedAt || new Date().toISOString()]
-    );
-  }, (c) => ({ id: c.id ?? null, provider: c.provider ?? null, name: c.name ?? null }));
-
-  importWithAssertion(adapter, "providerNodes", data.providerNodes || [], (n) => {
-    const { id, type, name, createdAt, updatedAt, ...rest } = n;
-    adapter.run(
-      `INSERT OR REPLACE INTO providerNodes(id, type, name, data, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?)`,
-      [id, type || null, name || null, stringifyJson(rest), createdAt || new Date().toISOString(), updatedAt || new Date().toISOString()]
-    );
-  }, (n) => ({ id: n.id ?? null, type: n.type ?? null, name: n.name ?? null }));
-
-  importWithAssertion(adapter, "proxyPools", data.proxyPools || [], (p) => {
-    const { id, isActive, testStatus, createdAt, updatedAt, ...rest } = p;
-    adapter.run(
-      `INSERT OR REPLACE INTO proxyPools(id, isActive, testStatus, data, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?)`,
-      [id, isActive === false ? 0 : 1, testStatus || "unknown", stringifyJson(rest), createdAt || new Date().toISOString(), updatedAt || new Date().toISOString()]
-    );
-  }, (p) => ({ id: p.id ?? null }));
-
-  importWithAssertion(adapter, "apiKeys", data.apiKeys || [], (k) => {
-    adapter.run(
-      `INSERT OR REPLACE INTO apiKeys(id, key, name, machineId, isActive, createdAt) VALUES(?, ?, ?, ?, ?, ?)`,
-      [k.id, k.key, k.name || null, k.machineId || null, k.isActive === false ? 0 : 1, k.createdAt || new Date().toISOString()]
-    );
-  }, (k) => ({ id: k.id ?? null, name: k.name ?? null }));
-
-  importWithAssertion(adapter, "combos", data.combos || [], (c) => {
-    adapter.run(
-      `INSERT OR REPLACE INTO combos(id, name, kind, models, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?)`,
-      [c.id, c.name, c.kind || null, stringifyJson(c.models || []), c.createdAt || new Date().toISOString(), c.updatedAt || new Date().toISOString()]
-    );
-  }, (c) => ({ id: c.id ?? null, name: c.name ?? null }));
-
-  for (const [alias, model] of Object.entries(data.modelAliases || {})) {
-    adapter.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('modelAliases', ?, ?)`, [alias, stringifyJson(model)]);
-  }
-  for (const m of data.customModels || []) {
-    const k = `${m.providerAlias}|${m.id}|${m.type || "llm"}`;
-    adapter.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('customModels', ?, ?)`, [k, stringifyJson(m)]);
-  }
-  for (const [tool, mappings] of Object.entries(data.mitmAlias || {})) {
-    adapter.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('mitmAlias', ?, ?)`, [tool, stringifyJson(mappings || {})]);
-  }
-  for (const [provider, models] of Object.entries(data.pricing || {})) {
-    adapter.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('pricing', ?, ?)`, [provider, stringifyJson(models || {})]);
-  }
-}
-
-function importLegacyUsage(adapter, data) {
-  if (!data || typeof data !== "object") return;
-  for (const e of data.history || []) {
-    const t = e.tokens || {};
-    adapter.run(
-      `INSERT INTO usageHistory(timestamp, provider, model, connectionId, apiKey, endpoint, promptTokens, completionTokens, cost, status, tokens, meta) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        e.timestamp || new Date().toISOString(),
-        e.provider || null, e.model || null, e.connectionId || null, e.apiKey || null, e.endpoint || null,
-        t.prompt_tokens || t.input_tokens || 0,
-        t.completion_tokens || t.output_tokens || 0,
-        e.cost || 0,
-        e.status || "ok",
-        stringifyJson(t),
-        stringifyJson({}),
-      ]
-    );
-  }
-  for (const [dateKey, day] of Object.entries(data.dailySummary || {})) {
-    adapter.run(`INSERT OR REPLACE INTO usageDaily(dateKey, data) VALUES(?, ?)`, [dateKey, stringifyJson(day)]);
-  }
-  if (typeof data.totalRequestsLifetime === "number") {
-    setMetaSync(adapter, "totalRequestsLifetime", data.totalRequestsLifetime);
-  }
-}
-
-function importLegacyDisabled(adapter, data) {
-  if (!data || typeof data.disabled !== "object") return;
-  for (const [provider, ids] of Object.entries(data.disabled)) {
-    adapter.run(`INSERT OR REPLACE INTO kv(scope, key, value) VALUES('disabledModels', ?, ?)`, [provider, stringifyJson(ids || [])]);
-  }
-}
-
-function importLegacyDetails(adapter, data) {
-  if (!data || !Array.isArray(data.records)) return;
-  for (const r of data.records) {
-    adapter.run(
-      `INSERT OR REPLACE INTO requestDetails(id, timestamp, provider, model, connectionId, status, data) VALUES(?, ?, ?, ?, ?, ?, ?)`,
-      [r.id, r.timestamp || new Date().toISOString(), r.provider || null, r.model || null, r.connectionId || null, r.status || null, stringifyJson(r)]
-    );
-  }
-}
-
-// ─── Main entry ──────────────────────────────────────────────────────────
-export async function runMigrationOnce(adapter) {
-  if (_migratedAdapters.has(adapter)) return;
-
-  // Capture freshness BEFORE migrations stamp _meta (otherwise we'd misclassify
-  // a brand-new DB as non-fresh once schemaVersion is written).
-  const fresh = isFreshDb(adapter);
-  // Bootstrap _meta before any meta reads — on a truly fresh DB the table does
-  // not exist yet and unguarded SELECTs below (and in runVersionedMigrations)
-  // would crash with "no such table: _meta".
-  adapter.exec(buildCreateTableSql("_meta", TABLES._meta));
-  const oldSchemaVersion = Number(getMetaSync(adapter, "schemaVersion", 0));
-  const oldAppVersion = getMetaSync(adapter, "appVersion", null);
-  const newAppVersion = getAppVersion();
-  let preMigrationBackup = null;
-  if (!fresh && (oldSchemaVersion < latestVersion() || (oldAppVersion && oldAppVersion !== newAppVersion))) {
-    preMigrationBackup = makeBackupDir(
-      oldSchemaVersion < latestVersion()
-        ? `schema-${oldSchemaVersion}-to-${latestVersion()}`
-        : `upgrade-${oldAppVersion}-to-${newAppVersion}`
-    );
-    backupFile(DATA_FILE, preMigrationBackup, null, adapter);
-  }
-
-  // 1. Always run versioned migrations chain (skip-version safe)
-  const migInfo = runVersionedMigrations(adapter);
-
-  // 2. Additive sync (auto add missing columns/indexes declared in TABLES)
-  syncSchemaFromTables(adapter);
-
-  // 3. One-time legacy JSON import (only if DB was fresh on entry)
-  const alreadyImported = fs.existsSync(MIGRATED_MARKER);
-  const legacyMain = readJsonSafe(LEGACY_FILES.main);
-  const legacyUsage = readJsonSafe(LEGACY_FILES.usage);
-  const legacyDisabled = readJsonSafe(LEGACY_FILES.disabled);
-  const legacyDetails = readJsonSafe(LEGACY_FILES.details);
-  const hasLegacy = !!(legacyMain || legacyUsage || legacyDisabled || legacyDetails);
-
-  if (fresh && hasLegacy && !alreadyImported) {
-    const t0 = Date.now();
-    const backupDir = makeBackupDir("migrate-from-json");
-    for (const f of Object.values(LEGACY_FILES)) backupFile(f, backupDir);
-
-    try {
-      adapter.transaction(() => {
-        importLegacyMain(adapter, legacyMain);
-        importLegacyUsage(adapter, legacyUsage);
-        importLegacyDisabled(adapter, legacyDisabled);
-        importLegacyDetails(adapter, legacyDetails);
-        setMetaSync(adapter, "appVersion", getAppVersion());
-        setMetaSync(adapter, "migratedAt", new Date().toISOString());
-      });
-    } catch (err) {
-      if (err instanceof MigrationAborted) {
-        console.error(`[DB][migrate] aborted: ${err.message} | legacy JSON kept | backup: ${backupDir}`);
-        return;
-      }
-      throw err;
-    }
-
-    try { fs.writeFileSync(MIGRATED_MARKER, new Date().toISOString()); } catch {}
-    pruneOldBackups();
-    console.log(`[DB][migrate] JSON → SQLite in ${Date.now() - t0}ms | legacy JSON kept at DATA_DIR | backup: ${backupDir}`);
-    _migratedAdapters.add(adapter);
-    return;
-  }
-
-  if (fresh) {
-    setMetaSync(adapter, "appVersion", getAppVersion());
-    _migratedAdapters.add(adapter);
-    return;
-  }
-
-  // 4. Record the app version after the pre-migration backup and successful migration.
-  if (oldAppVersion !== newAppVersion) setMetaSync(adapter, "appVersion", newAppVersion);
-  if (preMigrationBackup) {
-    pruneOldBackups();
-    console.log(`[DB][migrate] App ${oldAppVersion} → ${newAppVersion} | schema ${migInfo.from} → ${migInfo.to} | backup: ${preMigrationBackup}`);
-  }
-  _migratedAdapters.add(adapter);
-}

package/src/lib/db/migrations/001-initial.js

@@ -1,17 +0,0 @@
-// Initial schema bootstrap. For fresh DB this creates all tables/indexes.
-// For existing DB at version 0 (legacy unstamped), it's idempotent (IF NOT EXISTS).
-import { TABLES, buildCreateTableSql } from "../schema.js";
-
-const M001Initial = {
-  version: 1,
-  name: "initial",
-  up(db) {
-    for (const [name, def] of Object.entries(TABLES)) {
-      db.exec(buildCreateTableSql(name, def));
-      for (const idx of def.indexes || []) db.exec(idx);
-    }
-  },
-};
-
-
-export default M001Initial;

package/src/lib/db/migrations/index.js

@@ -1,10 +0,0 @@
-// Migration registry — append new entries when schema changes.
-// Each migration: { version: number, name: string, up(db): void }
-// Versions MUST be unique and monotonically increasing.
-import m001 from "./001-initial.js";
-
-export const MIGRATIONS = [m001].sort((a, b) => a.version - b.version);
-
-export function latestVersion() {
-  return MIGRATIONS.length ? MIGRATIONS[MIGRATIONS.length - 1].version : 0;
-}

package/src/lib/db/paths.js

@@ -1,21 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import { DATA_DIR } from "../dataDir.js";
-import { migrateLegacyDataDir } from "./dataDirMigration.js";
-
-export const DB_DIR = path.join(DATA_DIR, "db");
-export const DATA_FILE = path.join(DB_DIR, "data.sqlite");
-export const BACKUPS_DIR = path.join(DB_DIR, "backups");
-export const LEGACY_FILES = {
-  main: path.join(DATA_DIR, "db.json"),
-  usage: path.join(DATA_DIR, "usage.json"),
-  disabled: path.join(DATA_DIR, "disabledModels.json"),
-  details: path.join(DATA_DIR, "request-details.json"),
-};
-export function ensureDirs() {
-  // First-touch: migrate legacy ~/.zevai → ~/.zevai before creating dirs.
-  migrateLegacyDataDir(DATA_DIR);
-  for (const dir of [DATA_DIR, DB_DIR, BACKUPS_DIR]) {
-    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  }
-}