wyxrouter 0.4.71

package/src/lib/db/adapters/betterSqliteAdapter.js

@@ -0,0 +1,55 @@
+import Database from "better-sqlite3";
+import { PRAGMA_SQL } from "../schema.js";
+
+// Periodic checkpoint to keep WAL file small (avoid huge -wal/-shm growth)
+const CHECKPOINT_INTERVAL_MS = 60 * 1000;
+
+export function createBetterSqliteAdapter(filePath) {
+  const db = new Database(filePath);
+  db.exec(PRAGMA_SQL);
+  // Schema is created/synced by migrate.js after adapter init
+
+  const stmtCache = new Map();
+
+  function prepare(sql) {
+    let stmt = stmtCache.get(sql);
+    if (!stmt) {
+      stmt = db.prepare(sql);
+      stmtCache.set(sql, stmt);
+    }
+    return stmt;
+  }
+
+  // Truncate WAL periodically so file stays small for backup/copy
+  const checkpointTimer = setInterval(() => {
+    try { db.pragma("wal_checkpoint(TRUNCATE)"); } catch {}
+  }, CHECKPOINT_INTERVAL_MS);
+  if (typeof checkpointTimer.unref === "function") checkpointTimer.unref();
+
+  function gracefulClose() {
+    try { db.pragma("wal_checkpoint(TRUNCATE)"); } catch {}
+    try { stmtCache.clear(); } catch {}
+    try { db.close(); } catch {}
+  }
+
+  // Ensure WAL is flushed and -wal/-shm files removed on shutdown
+  const onShutdown = () => gracefulClose();
+  process.once("beforeExit", onShutdown);
+  process.once("SIGINT", () => { onShutdown(); process.exit(0); });
+  process.once("SIGTERM", () => { onShutdown(); process.exit(0); });
+
+  return {
+    driver: "better-sqlite3",
+    run(sql, params = []) { return prepare(sql).run(params); },
+    get(sql, params = []) { return prepare(sql).get(params); },
+    all(sql, params = []) { return prepare(sql).all(params); },
+    exec(sql) { return db.exec(sql); },
+    transaction(fn) { return db.transaction(fn)(); },
+    checkpoint() { try { db.pragma("wal_checkpoint(TRUNCATE)"); } catch {} },
+    close() {
+      clearInterval(checkpointTimer);
+      gracefulClose();
+    },
+    raw: db,
+  };
+}

package/src/lib/db/adapters/bunSqliteAdapter.js

@@ -0,0 +1,63 @@
+// Bun runtime adapter — uses built-in bun:sqlite (native, fastest under Bun).
+// Loaded only when process.versions.bun is present.
+import { PRAGMA_SQL } from "../schema.js";
+
+const CHECKPOINT_INTERVAL_MS = 60 * 1000;
+
+export async function createBunSqliteAdapter(filePath) {
+  // Dynamic import — only resolves under Bun runtime
+  const { Database } = await import("bun:sqlite");
+  const db = new Database(filePath, { create: true });
+  db.exec(PRAGMA_SQL);
+
+  const stmtCache = new Map();
+  function prepare(sql) {
+    let stmt = stmtCache.get(sql);
+    if (!stmt) {
+      stmt = db.prepare(sql);
+      stmtCache.set(sql, stmt);
+    }
+    return stmt;
+  }
+
+  const checkpointTimer = setInterval(() => {
+    try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {}
+  }, CHECKPOINT_INTERVAL_MS);
+  if (typeof checkpointTimer.unref === "function") checkpointTimer.unref();
+
+  function gracefulClose() {
+    try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {}
+    try { stmtCache.clear(); } catch {}
+    try { db.close(); } catch {}
+  }
+  const onShutdown = () => gracefulClose();
+  process.once("beforeExit", onShutdown);
+  process.once("SIGINT", () => { onShutdown(); process.exit(0); });
+  process.once("SIGTERM", () => { onShutdown(); process.exit(0); });
+
+  return {
+    driver: "bun:sqlite",
+    run(sql, params = []) {
+      const r = prepare(sql).run(...params);
+      return { changes: Number(r.changes ?? 0), lastInsertRowid: Number(r.lastInsertRowid ?? 0) };
+    },
+    get(sql, params = []) {
+      return prepare(sql).get(...params);
+    },
+    all(sql, params = []) {
+      return prepare(sql).all(...params);
+    },
+    exec(sql) { return db.exec(sql); },
+    transaction(fn) {
+      // bun:sqlite has db.transaction() API (similar to better-sqlite3)
+      const tx = db.transaction(fn);
+      return tx();
+    },
+    checkpoint() { try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {} },
+    close() {
+      clearInterval(checkpointTimer);
+      gracefulClose();
+    },
+    raw: db,
+  };
+}

package/src/lib/db/adapters/nodeSqliteAdapter.js

@@ -0,0 +1,84 @@
+// Built-in node:sqlite adapter — available in Node >= 22.5.0.
+// No native build, no npm install. API mirrors betterSqliteAdapter.
+import { PRAGMA_SQL } from "../schema.js";
+
+const CHECKPOINT_INTERVAL_MS = 60 * 1000;
+
+export async function createNodeSqliteAdapter(filePath) {
+  // Suppress "ExperimentalWarning: SQLite is an experimental feature" from node:sqlite.
+  // Stable enough for production use as of Node 22.x (RC quality).
+  const origEmit = process.emit;
+  process.emit = function (name, data, ...rest) {
+    if (name === "warning" && data?.name === "ExperimentalWarning" && /SQLite/i.test(data.message || "")) {
+      return false;
+    }
+    return origEmit.call(process, name, data, ...rest);
+  };
+
+  // Dynamic import — fails on Node < 22.5 → driver.js falls back to sql.js
+  const sqlite = await import("node:sqlite");
+  const Database = sqlite.DatabaseSync;
+  const db = new Database(filePath);
+
+  db.exec(PRAGMA_SQL);
+
+  const stmtCache = new Map();
+  function prepare(sql) {
+    let stmt = stmtCache.get(sql);
+    if (!stmt) {
+      stmt = db.prepare(sql);
+      stmtCache.set(sql, stmt);
+    }
+    return stmt;
+  }
+
+  // Periodic WAL checkpoint to keep -wal/-shm small
+  const checkpointTimer = setInterval(() => {
+    try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {}
+  }, CHECKPOINT_INTERVAL_MS);
+  if (typeof checkpointTimer.unref === "function") checkpointTimer.unref();
+
+  function gracefulClose() {
+    try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {}
+    try { stmtCache.clear(); } catch {}
+    try { db.close(); } catch {}
+  }
+  const onShutdown = () => gracefulClose();
+  process.once("beforeExit", onShutdown);
+  process.once("SIGINT", () => { onShutdown(); process.exit(0); });
+  process.once("SIGTERM", () => { onShutdown(); process.exit(0); });
+
+  return {
+    driver: "node:sqlite",
+    run(sql, params = []) {
+      const r = prepare(sql).run(...params);
+      return { changes: Number(r.changes ?? 0), lastInsertRowid: Number(r.lastInsertRowid ?? 0) };
+    },
+    get(sql, params = []) {
+      return prepare(sql).get(...params);
+    },
+    all(sql, params = []) {
+      return prepare(sql).all(...params);
+    },
+    exec(sql) { return db.exec(sql); },
+    transaction(fn) {
+      // node:sqlite has no transaction wrapper. Use SAVEPOINT for nested support.
+      const sp = `sp_${Math.random().toString(36).slice(2)}`;
+      db.exec(`SAVEPOINT ${sp}`);
+      try {
+        const r = fn();
+        db.exec(`RELEASE ${sp}`);
+        return r;
+      } catch (e) {
+        try { db.exec(`ROLLBACK TO ${sp}`); db.exec(`RELEASE ${sp}`); } catch {}
+        throw e;
+      }
+    },
+    checkpoint() { try { db.exec("PRAGMA wal_checkpoint(TRUNCATE)"); } catch {} },
+    close() {
+      clearInterval(checkpointTimer);
+      gracefulClose();
+    },
+    raw: db,
+  };
+}

package/src/lib/db/adapters/sqljsAdapter.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import initSqlJs from "sql.js";
+import { PRAGMA_SQL } from "../schema.js";
+
+let SQL = null;
+
+async function loadSql() {
+  if (SQL) return SQL;
+  SQL = await initSqlJs();
+  return SQL;
+}
+
+export async function createSqlJsAdapter(filePath) {
+  const SQLLib = await loadSql();
+  const buf = fs.existsSync(filePath) ? fs.readFileSync(filePath) : null;
+  const db = new SQLLib.Database(buf);
+  db.exec(PRAGMA_SQL);
+  // Schema is created/synced by migrate.js after adapter init
+
+  let dirty = false;
+  let saveTimer = null;
+  const SAVE_DEBOUNCE_MS = 100;
+
+  function persist() {
+    const data = db.export();
+    fs.writeFileSync(filePath, Buffer.from(data));
+    dirty = false;
+  }
+
+  function scheduleSave() {
+    dirty = true;
+    if (saveTimer) clearTimeout(saveTimer);
+    saveTimer = setTimeout(() => {
+      saveTimer = null;
+      if (dirty) {
+        try { persist(); } catch (e) { console.error("[sqljs] save failed:", e); }
+      }
+    }, SAVE_DEBOUNCE_MS);
+  }
+
+  function paramsObj(params) {
+    if (!params || (Array.isArray(params) && params.length === 0)) return undefined;
+    return params;
+  }
+
+  function run(sql, params = []) {
+    const stmt = db.prepare(sql);
+    try {
+      stmt.bind(paramsObj(params));
+      stmt.step();
+      const changes = db.getRowsModified();
+      const lastInsertRowid = db.exec("SELECT last_insert_rowid() as id")[0]?.values?.[0]?.[0] ?? null;
+      scheduleSave();
+      return { changes, lastInsertRowid };
+    } finally {
+      stmt.free();
+    }
+  }
+
+  function get(sql, params = []) {
+    const stmt = db.prepare(sql);
+    try {
+      stmt.bind(paramsObj(params));
+      if (stmt.step()) return stmt.getAsObject();
+      return undefined;
+    } finally {
+      stmt.free();
+    }
+  }
+
+  function all(sql, params = []) {
+    const stmt = db.prepare(sql);
+    try {
+      stmt.bind(paramsObj(params));
+      const rows = [];
+      while (stmt.step()) rows.push(stmt.getAsObject());
+      return rows;
+    } finally {
+      stmt.free();
+    }
+  }
+
+  function exec(sql) {
+    db.exec(sql);
+    scheduleSave();
+  }
+
+  function transaction(fn) {
+    const sp = `sp_${Math.random().toString(36).slice(2)}`;
+    db.exec(`SAVEPOINT ${sp}`);
+    try {
+      const result = fn();
+      db.exec(`RELEASE ${sp}`);
+      scheduleSave();
+      return result;
+    } catch (e) {
+      try { db.exec(`ROLLBACK TO ${sp}`); db.exec(`RELEASE ${sp}`); } catch {}
+      throw e;
+    }
+  }
+
+  function close() {
+    if (saveTimer) clearTimeout(saveTimer);
+    if (dirty) persist();
+    db.close();
+  }
+
+  // Flush on shutdown
+  const flush = () => { if (dirty) try { persist(); } catch {} };
+  process.on("beforeExit", flush);
+  process.on("SIGINT", flush);
+  process.on("SIGTERM", flush);
+
+  return { driver: "sql.js", run, get, all, exec, transaction, close, raw: db };
+}

package/src/lib/db/backup.js

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import { BACKUPS_DIR, ensureDirs } from "./paths.js";
+import { timestampSlug, getAppVersion } from "./version.js";
+
+const KEEP_BACKUPS = 5;
+
+export function makeBackupDir(label) {
+  ensureDirs();
+  const ver = getAppVersion();
+  const slug = `${label}-${ver}-${timestampSlug()}`;
+  const dir = path.join(BACKUPS_DIR, slug);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function backupFile(srcPath, destDir, destName = null) {
+  if (!fs.existsSync(srcPath)) return null;
+  const name = destName || path.basename(srcPath);
+  const dest = path.join(destDir, name);
+  fs.copyFileSync(srcPath, dest);
+  return dest;
+}
+
+export function pruneOldBackups() {
+  if (!fs.existsSync(BACKUPS_DIR)) return;
+  const entries = fs.readdirSync(BACKUPS_DIR, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => ({ name: e.name, full: path.join(BACKUPS_DIR, e.name), mtime: fs.statSync(path.join(BACKUPS_DIR, e.name)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  for (const old of entries.slice(KEEP_BACKUPS)) {
+    try { fs.rmSync(old.full, { recursive: true, force: true }); } catch {}
+  }
+}

package/src/lib/db/driver.js

@@ -0,0 +1,85 @@
+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);
+  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();
+}