zevairouter 1.0.0

package/src/lib/db/dataDirMigration.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// Legacy data dir from the upstream 9router fork. We auto-migrate its contents
+// into the new ~/.zevai data dir on first run so existing accounts/connections
+// are preserved. This module is intentionally self-contained (no imports from
+// dataDir.js) because cli/ (CommonJS) and src/ (ESM) both need the same logic.
+const LEGACY_APP_NAME = "9router";
+const MIGRATED_MARKER = ".migrated-from-9router";
+
+function legacyDefaultDir() {
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), LEGACY_APP_NAME);
+  }
+  return path.join(os.homedir(), `.${LEGACY_APP_NAME}`);
+}
+
+/**
+ * One-time migration of the legacy ~/.9router data dir into the new data dir
+ * (~/.zevai on macOS/Linux, %APPDATA%/zevai on Windows). Copies recursively
+ * and leaves the legacy dir intact as a backup. Idempotent via a marker file.
+ * Safe to call on every boot — no-ops once migrated or on fresh installs.
+ *
+ * @param {string} newDataDir - resolved new data dir (from dataDir.js getDataDir)
+ */
+export function migrateLegacyDataDir(newDataDir) {
+  if (!newDataDir) return;
+
+  // Already migrated, or user is explicitly using DATA_DIR env override that
+  // points elsewhere — don't touch.
+  const marker = path.join(newDataDir, MIGRATED_MARKER);
+  if (fs.existsSync(marker)) return;
+  if (process.env.DATA_DIR && process.env.DATA_DIR !== newDataDir) return;
+
+  const legacyDir = legacyDefaultDir();
+  if (!fs.existsSync(legacyDir)) return;
+
+  // If new dir already has real content (e.g. user started fresh before
+  // migration ran), don't clobber — just stamp the marker and move on.
+  const newExists = fs.existsSync(newDataDir);
+  if (newExists) {
+    try {
+      // Stamp marker so we don't keep checking; legacy dir left as backup.
+      fs.mkdirSync(newDataDir, { recursive: true });
+      fs.writeFileSync(marker, new Date().toISOString());
+    } catch {}
+    return;
+  }
+
+  try {
+    console.log(`[migrate] Copying legacy data ${legacyDir} → ${newDataDir}`);
+    fs.mkdirSync(path.dirname(newDataDir), { recursive: true });
+    fs.cpSync(legacyDir, newDataDir, { recursive: true });
+    fs.writeFileSync(marker, new Date().toISOString());
+    console.log(`[migrate] Done. Legacy data kept at ${legacyDir} as backup.`);
+  } catch (err) {
+    // Never crash the app over migration — fall back to a fresh data dir.
+    console.warn(`[migrate] Failed to migrate ${legacyDir} → ${newDataDir}: ${err.message}. Starting fresh.`);
+  }
+}

package/src/lib/db/driver.js

@@ -0,0 +1,90 @@
+import { ensureDirs, DATA_FILE } from "./paths.js";
+
+// Use global to survive Next.js dev hot-reload (module state resets on reload)
+if (!global._dbAdapter) global._dbAdapter = { instance: null, initPromise: null, logged: false };
+const state = global._dbAdapter;
+
+async function tryBunSqlite() {
+  // Bun runtime only — built-in, no install needed
+  if (!process.versions.bun) return null;
+  try {
+    const { createBunSqliteAdapter } = await import("./adapters/bunSqliteAdapter.js");
+    return await createBunSqliteAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] bun:sqlite unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function tryBetterSqlite() {
+  // Skip on Bun — better-sqlite3 native bindings unsupported
+  if (process.versions.bun) return null;
+  try {
+    const { createBetterSqliteAdapter } = await import("./adapters/betterSqliteAdapter.js");
+    return createBetterSqliteAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] better-sqlite3 unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function tryNodeSqlite() {
+  // Built-in since Node 22.5.0 — no install needed. Skip under Bun (no node:sqlite).
+  if (process.versions.bun) return null;
+  const [maj, min] = process.versions.node.split(".").map(Number);
+  if (maj < 22 || (maj === 22 && min < 5)) return null;
+  try {
+    const { createNodeSqliteAdapter } = await import("./adapters/nodeSqliteAdapter.js");
+    return await createNodeSqliteAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] node:sqlite unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function trySqlJs() {
+  try {
+    const { createSqlJsAdapter } = await import("./adapters/sqljsAdapter.js");
+    return await createSqlJsAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] sql.js unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function initAdapter() {
+  ensureDirs();
+  // Order per runtime:
+  //   Bun:  bun:sqlite → sql.js
+  //   Node: better-sqlite3 → node:sqlite (≥22.5) → sql.js
+  let adapter = await tryBunSqlite();
+  if (!adapter) adapter = await tryBetterSqlite();
+  if (!adapter) adapter = await tryNodeSqlite();
+  if (!adapter) adapter = await trySqlJs();
+  if (!adapter) throw new Error("[DB] No SQLite driver available (bun/better/node/sql.js all failed)");
+
+  if (!state.logged) {
+    console.log(`[DB] Driver: ${adapter.driver} | file: ${DATA_FILE}`);
+    state.logged = true;
+  }
+
+  const { runMigrationOnce } = await import("./migrate.js");
+  await runMigrationOnce(adapter);
+
+  // Reclaim legacy bloat once + keep usageHistory bounded going forward.
+  const { runStartupMaintenanceOnce } = await import("./maintenance.js");
+  runStartupMaintenanceOnce(adapter);
+
+  return adapter;
+}
+
+export async function getAdapter() {
+  if (state.instance) return state.instance;
+  if (!state.initPromise) state.initPromise = initAdapter().then((a) => { state.instance = a; return a; });
+  return state.initPromise;
+}
+
+export function getAdapterSync() {
+  if (!state.instance) throw new Error("[DB] adapter not initialized — await getAdapter() first");
+  return state.instance;
+}

package/src/lib/db/helpers/jsonCol.js

@@ -0,0 +1,9 @@
+export function parseJson(str, fallback = null) {
+  if (str == null) return fallback;
+  if (typeof str !== "string") return str;
+  try { return JSON.parse(str); } catch { return fallback; }
+}
+
+export function stringifyJson(value) {
+  return JSON.stringify(value ?? null);
+}

package/src/lib/db/helpers/kvStore.js

@@ -0,0 +1,39 @@
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "./jsonCol.js";
+
+export function makeKv(scope) {
+  return {
+    async get(key, fallback = null) {
+      const db = await getAdapter();
+      const row = db.get(`SELECT value FROM kv WHERE scope = ? AND key = ?`, [scope, key]);
+      return row ? parseJson(row.value, fallback) : fallback;
+    },
+    async getAll() {
+      const db = await getAdapter();
+      const rows = db.all(`SELECT key, value FROM kv WHERE scope = ?`, [scope]);
+      const out = {};
+      for (const r of rows) out[r.key] = parseJson(r.value);
+      return out;
+    },
+    async set(key, value) {
+      const db = await getAdapter();
+      db.run(`INSERT INTO kv(scope, key, value) VALUES(?, ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`, [scope, key, stringifyJson(value)]);
+    },
+    async setMany(obj) {
+      const db = await getAdapter();
+      db.transaction(() => {
+        for (const [k, v] of Object.entries(obj)) {
+          db.run(`INSERT INTO kv(scope, key, value) VALUES(?, ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`, [scope, k, stringifyJson(v)]);
+        }
+      });
+    },
+    async remove(key) {
+      const db = await getAdapter();
+      db.run(`DELETE FROM kv WHERE scope = ? AND key = ?`, [scope, key]);
+    },
+    async clear() {
+      const db = await getAdapter();
+      db.run(`DELETE FROM kv WHERE scope = ?`, [scope]);
+    },
+  };
+}

package/src/lib/db/helpers/metaStore.js

@@ -0,0 +1,22 @@
+import { getAdapter } from "../driver.js";
+
+export async function getMeta(key, fallback = null) {
+  const db = await getAdapter();
+  const row = db.get(`SELECT value FROM _meta WHERE key = ?`, [key]);
+  return row ? row.value : fallback;
+}
+
+export async function setMeta(key, value) {
+  const db = await getAdapter();
+  db.run(`INSERT INTO _meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`, [key, String(value)]);
+}
+
+// Sync versions for use during migration (adapter passed directly)
+export function getMetaSync(adapter, key, fallback = null) {
+  const row = adapter.get(`SELECT value FROM _meta WHERE key = ?`, [key]);
+  return row ? row.value : fallback;
+}
+
+export function setMetaSync(adapter, key, value) {
+  adapter.run(`INSERT INTO _meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`, [key, String(value)]);
+}

package/src/lib/db/index.js

@@ -0,0 +1,171 @@
+// Public API barrel — all DB functions
+import { getAdapter } from "./driver.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";
+
+// API keys
+export {
+  getApiKeys, getApiKeyById, createApiKey, updateApiKey, deleteApiKey, validateApiKey,
+} 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,
+  appendRequestLog, getRecentLogs,
+} from "./repos/usageRepo.js";
+
+// Request details
+export {
+  saveRequestDetail, getRequestDetails, getRequestDetailById,
+} from "./repos/requestDetailsRepo.js";
+
+// Export/import full DB
+export async function exportDb() {
+  const db = await getAdapter();
+  const { exportSettings } = await import("./repos/settingsRepo.js");
+
+  const out = {
+    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: {},
+  };
+
+  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(() => {
+    // Wipe all tables (keep _meta)
+    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

@@ -0,0 +1,72 @@
+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 {}
+  }
+}