swayrouter 1.0.0

package/src/lib/db/repos/pricingRepo.js

@@ -0,0 +1,108 @@
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+import { makeKv } from "../helpers/kvStore.js";
+
+const pricingKv = makeKv("pricing");
+const CACHE_TTL_MS = 5000;
+
+let cache = { value: null, expiresAt: 0 };
+
+function invalidate() {
+  cache = { value: null, expiresAt: 0 };
+}
+
+async function getUserPricing() {
+  return await pricingKv.getAll();
+}
+
+export async function getPricing() {
+  const now = Date.now();
+  if (cache.value && cache.expiresAt > now) return cache.value;
+
+  const userPricing = await getUserPricing();
+  const { PROVIDER_PRICING } = await import("../../../providers/pricing.js");
+  const merged = {};
+
+  for (const [provider, models] of Object.entries(PROVIDER_PRICING)) {
+    merged[provider] = { ...models };
+    if (userPricing[provider]) {
+      for (const [model, pricing] of Object.entries(userPricing[provider])) {
+        merged[provider][model] = merged[provider][model]
+          ? { ...merged[provider][model], ...pricing }
+          : pricing;
+      }
+    }
+  }
+
+  for (const [provider, models] of Object.entries(userPricing)) {
+    if (!merged[provider]) {
+      merged[provider] = { ...models };
+    } else {
+      for (const [model, pricing] of Object.entries(models)) {
+        if (!merged[provider][model]) merged[provider][model] = pricing;
+      }
+    }
+  }
+
+  cache = { value: merged, expiresAt: now + CACHE_TTL_MS };
+  return merged;
+}
+
+export async function getPricingForModel(provider, model) {
+  if (!model) return null;
+
+  const all = await getPricing();
+  if (provider && all[provider]?.[model]) return all[provider][model];
+  const { getPricingForModel: resolveConst } = await import("../../../providers/pricing.js");
+  return resolveConst(provider, model);
+}
+
+export async function updatePricing(pricingData) {
+  const db = await getAdapter();
+  db.transaction(() => {
+    for (const [provider, models] of Object.entries(pricingData)) {
+      const row = db.get(`SELECT value FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+      const current = row ? (parseJson(row.value, {}) || {}) : {};
+      const merged = { ...current };
+      for (const [model, pricing] of Object.entries(models)) {
+        merged[model] = pricing;
+      }
+      db.run(
+        `INSERT INTO kv(scope, key, value) VALUES('pricing', ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`,
+        [provider, stringifyJson(merged)]
+      );
+    }
+  });
+  invalidate();
+  return await getUserPricing();
+}
+
+export async function resetPricing(provider, model) {
+  if (!provider) return await getUserPricing();
+  const db = await getAdapter();
+  db.transaction(() => {
+    if (!model) {
+      db.run(`DELETE FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+      return;
+    }
+    const row = db.get(`SELECT value FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+    const current = row ? (parseJson(row.value, {}) || {}) : {};
+    delete current[model];
+    if (Object.keys(current).length === 0) {
+      db.run(`DELETE FROM kv WHERE scope = 'pricing' AND key = ?`, [provider]);
+    } else {
+      db.run(
+        `INSERT INTO kv(scope, key, value) VALUES('pricing', ?, ?) ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`,
+        [provider, stringifyJson(current)]
+      );
+    }
+  });
+  invalidate();
+  return await getUserPricing();
+}
+
+export async function resetAllPricing() {
+  await pricingKv.clear();
+  invalidate();
+  return {};
+}

package/src/lib/db/repos/proxyPoolsRepo.js

@@ -0,0 +1,104 @@
+import { v4 as uuidv4 } from "uuid";
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+function rowToPool(row) {
+  if (!row) return null;
+  const extra = parseJson(row.data, {});
+  return {
+    ...extra,
+    id: row.id,
+    isActive: row.isActive === 1 || row.isActive === true,
+    testStatus: row.testStatus,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+function poolToRow(p) {
+  const { id, isActive, testStatus, createdAt, updatedAt, ...rest } = p;
+  return {
+    id,
+    isActive: isActive === false ? 0 : 1,
+    testStatus: testStatus ?? null,
+    data: stringifyJson(rest),
+    createdAt,
+    updatedAt,
+  };
+}
+
+function upsert(db, p) {
+  const r = poolToRow(p);
+  db.run(
+    `INSERT INTO proxyPools(id, isActive, testStatus, data, createdAt, updatedAt)
+     VALUES(?, ?, ?, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       isActive=excluded.isActive, testStatus=excluded.testStatus,
+       data=excluded.data, updatedAt=excluded.updatedAt`,
+    [r.id, r.isActive, r.testStatus, r.data, r.createdAt, r.updatedAt]
+  );
+}
+
+export async function getProxyPools(filter = {}) {
+  const db = await getAdapter();
+  const where = [];
+  const params = [];
+  if (filter.isActive !== undefined) { where.push("isActive = ?"); params.push(filter.isActive ? 1 : 0); }
+  if (filter.testStatus) { where.push("testStatus = ?"); params.push(filter.testStatus); }
+  const sql = `SELECT * FROM proxyPools${where.length ? ` WHERE ${where.join(" AND ")}` : ""}`;
+  const list = db.all(sql, params).map(rowToPool);
+  list.sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0));
+  return list;
+}
+
+export async function getProxyPoolById(id) {
+  const db = await getAdapter();
+  return rowToPool(db.get(`SELECT * FROM proxyPools WHERE id = ?`, [id]));
+}
+
+export async function createProxyPool(data) {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  const pool = {
+    id: data.id || uuidv4(),
+    name: data.name,
+    proxyUrl: data.proxyUrl,
+    noProxy: data.noProxy || "",
+    type: data.type || "http",
+    isActive: data.isActive !== undefined ? data.isActive : true,
+    strictProxy: data.strictProxy === true,
+    testStatus: data.testStatus || "unknown",
+    lastTestedAt: data.lastTestedAt || null,
+    lastError: data.lastError || null,
+    relayToken: data.relayToken || null,
+    createdAt: now,
+    updatedAt: now,
+  };
+  upsert(db, pool);
+  return pool;
+}
+
+export async function updateProxyPool(id, data) {
+  const db = await getAdapter();
+  let result = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM proxyPools WHERE id = ?`, [id]);
+    if (!row) return;
+    const merged = { ...rowToPool(row), ...data, updatedAt: new Date().toISOString() };
+    upsert(db, merged);
+    result = merged;
+  });
+  return result;
+}
+
+export async function deleteProxyPool(id) {
+  const db = await getAdapter();
+  let removed = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM proxyPools WHERE id = ?`, [id]);
+    if (!row) return;
+    removed = rowToPool(row);
+    db.run(`DELETE FROM proxyPools WHERE id = ?`, [id]);
+  });
+  return removed;
+}

package/src/lib/db/repos/requestDetailsRepo.js

@@ -0,0 +1,345 @@
+import crypto from "node:crypto";
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+import { getCurrentTraceId } from "@/observability/tracing.js";
+
+import { getCapturePolicy, decideWithPolicy, applyCaptureDecision } from "@/lib/security/payloadCapture.js";
+import { getEnvConfig } from "@/lib/env.ts";
+
+const DEFAULT_MAX_RECORDS = 200;
+const DEFAULT_BATCH_SIZE = 20;
+const DEFAULT_FLUSH_INTERVAL_MS = 5000;
+const DEFAULT_MAX_JSON_SIZE = 5 * 1024;
+const CONFIG_CACHE_TTL_MS = 5000;
+
+let cachedConfig = null;
+let cachedConfigTs = 0;
+
+async function getObservabilityConfig() {
+  if (cachedConfig && (Date.now() - cachedConfigTs) < CONFIG_CACHE_TTL_MS) return cachedConfig;
+  try {
+    const { getSettings } = await import("./settingsRepo.js");
+    const settings = await getSettings();
+    const runtimeEnv = getEnvConfig({ refresh: true });
+    const envRequestLogs = runtimeEnv.requestLogsConfigured
+      ? runtimeEnv.requestLogsEnabled
+      : undefined;
+    if (envRequestLogs !== undefined) {
+      const enabled = envRequestLogs;
+      cachedConfig = {
+        enabled,
+        maxRecords: settings.observabilityMaxRecords || parseInt(process.env.OBSERVABILITY_MAX_RECORDS || String(DEFAULT_MAX_RECORDS), 10),
+        batchSize: settings.observabilityBatchSize || parseInt(process.env.OBSERVABILITY_BATCH_SIZE || String(DEFAULT_BATCH_SIZE), 10),
+        flushIntervalMs: settings.observabilityFlushIntervalMs || parseInt(process.env.OBSERVABILITY_FLUSH_INTERVAL_MS || String(DEFAULT_FLUSH_INTERVAL_MS), 10),
+        maxJsonSize: (settings.observabilityMaxJsonSize || parseInt(process.env.OBSERVABILITY_MAX_JSON_SIZE || "5", 10)) * 1024,
+      };
+      cachedConfigTs = Date.now();
+      return cachedConfig;
+    }
+    const envFallback = process.env.OBSERVABILITY_ENABLED !== "false";
+    const uiFlag = typeof settings.enableObservability === "boolean";
+    const payloadCaptureEnabled = settings.payloadCaptureEnabled === true;
+
+    const enabled = uiFlag
+      ? settings.enableObservability || payloadCaptureEnabled
+      : envFallback || payloadCaptureEnabled;
+
+    cachedConfig = {
+      enabled,
+      maxRecords: settings.observabilityMaxRecords || parseInt(process.env.OBSERVABILITY_MAX_RECORDS || String(DEFAULT_MAX_RECORDS), 10),
+      batchSize: settings.observabilityBatchSize || parseInt(process.env.OBSERVABILITY_BATCH_SIZE || String(DEFAULT_BATCH_SIZE), 10),
+      flushIntervalMs: settings.observabilityFlushIntervalMs || parseInt(process.env.OBSERVABILITY_FLUSH_INTERVAL_MS || String(DEFAULT_FLUSH_INTERVAL_MS), 10),
+      maxJsonSize: (settings.observabilityMaxJsonSize || parseInt(process.env.OBSERVABILITY_MAX_JSON_SIZE || "5", 10)) * 1024,
+    };
+  } catch {
+    cachedConfig = {
+      enabled: false,
+      maxRecords: DEFAULT_MAX_RECORDS,
+      batchSize: DEFAULT_BATCH_SIZE,
+      flushIntervalMs: DEFAULT_FLUSH_INTERVAL_MS,
+      maxJsonSize: DEFAULT_MAX_JSON_SIZE,
+    };
+  }
+  cachedConfigTs = Date.now();
+  return cachedConfig;
+}
+
+let writeBuffer = [];
+let flushTimer = null;
+let isFlushing = false;
+let flushPromise = null;
+
+const SENSITIVE_KEY_PATTERN = /(authorization|proxy-authorization|api[-_]?key|cookie|set-cookie|token|secret|password|credential|private[-_]?key|signature)/i;
+
+function redactSensitive(value, key = "", seen = new WeakSet()) {
+  if (SENSITIVE_KEY_PATTERN.test(key)) return "[REDACTED]";
+  if (typeof value === "string") return value;
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return "[REDACTED:circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((item) => redactSensitive(item, key, seen));
+  const sanitized = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    sanitized[childKey] = redactSensitive(childValue, childKey, seen);
+  }
+  return sanitized;
+}
+
+function sanitizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return {};
+  const plain = typeof headers.entries === "function" ? Object.fromEntries(headers.entries()) : headers;
+  return redactSensitive(plain);
+}
+
+function generateDetailId(model) {
+  const timestamp = new Date().toISOString();
+  const random = crypto.randomUUID();
+  const modelPart = model ? model.replace(/[^a-zA-Z0-9-]/g, "-") : "unknown";
+  return `${timestamp}-${random}-${modelPart}`;
+}
+
+function truncateField(obj, maxSize) {
+  const sanitized = redactSensitive(obj || {});
+  const str = JSON.stringify(sanitized);
+  if (str.length > maxSize) {
+    return { _truncated: true, _originalSize: str.length, _preview: str.substring(0, 200) };
+  }
+  return sanitized;
+}
+
+function rawField(obj) {
+  if (obj == null) return obj;
+  try {
+    JSON.stringify(obj);
+    return obj;
+  } catch {
+    return { _captureError: "payload_not_json_serializable" };
+  }
+}
+
+function persistBody(obj, maxSize, decision) {
+  return decision === "raw" ? rawField(obj) : truncateField(obj, maxSize);
+}
+
+async function flushToDatabase() {
+  if (isFlushing) {
+    await flushPromise;
+    return;
+  }
+  if (writeBuffer.length === 0) return;
+  isFlushing = true;
+  flushPromise = (async () => {
+    try {
+
+      while (writeBuffer.length > 0) {
+        const items = writeBuffer.splice(0, writeBuffer.length);
+        const db = await getAdapter();
+        const config = await getObservabilityConfig();
+
+        const policy = await getCapturePolicy().catch(() => ({ mode: "none", sampleRate: 0.01 }));
+
+        db.transaction(() => {
+          for (const item of items) {
+            if (!item.id) item.id = generateDetailId(item.model);
+            if (!item.timestamp) item.timestamp = new Date().toISOString();
+            if (item.request?.headers) item.request.headers = sanitizeHeaders(item.request.headers);
+
+            const trace_id = item.traceId || item.trace_id || null;
+            const decision = decideWithPolicy(policy, item.status, trace_id);
+            applyCaptureDecision(item, decision);
+
+            const record = {
+              id: item.id,
+              provider: item.provider || null,
+              model: item.model || null,
+              connectionId: item.connectionId || null,
+              timestamp: item.timestamp,
+              status: item.status || null,
+              latency: item.latency || {},
+              tokens: item.tokens || {},
+              request: persistBody(item.request, config.maxJsonSize, decision),
+              providerRequest: persistBody(item.providerRequest, config.maxJsonSize, decision),
+              providerResponse: persistBody(item.providerResponse, config.maxJsonSize, decision),
+              response: persistBody(item.response, config.maxJsonSize, decision),
+            };
+            record.trace_id = trace_id;
+
+            record.payload_capture = `${policy.mode}:${decision}`;
+
+            db.run(
+              `INSERT INTO requestDetails(id, timestamp, provider, model, connectionId, status, data, trace_id, payload_capture) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET timestamp = excluded.timestamp, provider = excluded.provider, model = excluded.model, connectionId = excluded.connectionId, status = excluded.status, data = excluded.data, trace_id = excluded.trace_id, payload_capture = excluded.payload_capture`,
+              [record.id, record.timestamp, record.provider, record.model, record.connectionId, record.status, stringifyJson(record), trace_id, record.payload_capture]
+            );
+          }
+
+          const cnt = db.get(`SELECT COUNT(*) as c FROM requestDetails`);
+          if (cnt && cnt.c > config.maxRecords) {
+            db.run(
+              `DELETE FROM requestDetails WHERE id IN (SELECT id FROM requestDetails ORDER BY timestamp ASC LIMIT ?)`,
+              [cnt.c - config.maxRecords]
+            );
+          }
+        });
+      }
+    } catch (e) {
+      console.error("[requestDetailsRepo] Batch write failed:", e);
+    } finally {
+      isFlushing = false;
+      flushPromise = null;
+    }
+  })();
+  await flushPromise;
+}
+
+export async function clearRequestDetails({ startDate, endDate } = {}) {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+
+  await flushToDatabase();
+  const db = await getAdapter();
+  const conds = [];
+  const params = [];
+  if (startDate) {
+    conds.push("timestamp >= ?");
+    params.push(new Date(startDate).toISOString());
+  }
+  if (endDate) {
+    conds.push("timestamp <= ?");
+    params.push(new Date(endDate).toISOString());
+  }
+  const where = conds.length ? `WHERE ${conds.join(" AND ")}` : "";
+  const row = db.get(`SELECT COUNT(*) AS count FROM requestDetails ${where}`, params);
+  db.run(`DELETE FROM requestDetails ${where}`, params);
+  return Number(row?.count || 0);
+}
+
+export async function saveRequestDetail(detail) {
+  const config = await getObservabilityConfig();
+  if (!config.enabled) {return;}
+
+  if (detail && !detail.traceId && !detail.trace_id) {
+    const tid = getCurrentTraceId();
+    if (tid) {
+      detail.traceId = tid;
+      detail.trace_id = tid;
+    }
+  }
+
+  writeBuffer.push(detail);
+
+  if (writeBuffer.length >= config.batchSize) {
+    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    flushToDatabase().catch((e) => console.error("[requestDetailsRepo] flush err:", e));
+  } else if (!flushTimer) {
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      flushToDatabase().catch(() => {});
+    }, config.flushIntervalMs);
+  }
+}
+
+async function enrichDetailsWithUsage(db, details) {
+  if (!details.length) return details;
+
+  const usageRows = db.all(`
+    SELECT timestamp, provider, model, connectionId, promptTokens,
+           completionTokens, tokens
+    FROM usageHistory
+    ORDER BY id DESC
+    LIMIT 500
+  `);
+  const candidates = usageRows.map((row) => ({
+    ...row,
+    time: Date.parse(row.timestamp),
+    tokens: parseJson(row.tokens, {}) || {},
+  })).filter((row) => Number.isFinite(row.time));
+  const used = new Set();
+
+  return details.map((detail) => {
+    const detailTokens = detail?.tokens || {};
+    const hasTokens = Number(detailTokens.prompt_tokens ?? detailTokens.input_tokens ?? 0) > 0
+      || Number(detailTokens.completion_tokens ?? detailTokens.output_tokens ?? 0) > 0;
+    if (hasTokens || !detail?.timestamp) return detail;
+
+    const detailTime = Date.parse(detail.timestamp);
+    if (!Number.isFinite(detailTime)) return detail;
+    let best = null;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < candidates.length; i++) {
+      if (used.has(i)) continue;
+      const row = candidates[i];
+      if (row.provider !== detail.provider || row.model !== detail.model) continue;
+      if ((row.connectionId || null) !== (detail.connectionId || null)) continue;
+      const distance = Math.abs(row.time - detailTime);
+      if (distance <= 10_000 && distance < bestDistance) {
+        best = { row, index: i };
+        bestDistance = distance;
+      }
+    }
+    if (!best) return detail;
+    used.add(best.index);
+    return { ...detail, tokens: best.row.tokens };
+  });
+}
+
+export async function getRequestDetails(filter = {}) {
+  await flushToDatabase();
+  const db = await getAdapter();
+  const conds = [];
+  const params = [];
+
+  if (filter.provider) { conds.push("provider = ?"); params.push(filter.provider); }
+  if (filter.model) { conds.push("model = ?"); params.push(filter.model); }
+  if (filter.connectionId) { conds.push("connectionId = ?"); params.push(filter.connectionId); }
+  if (filter.status) { conds.push("status = ?"); params.push(filter.status); }
+  if (filter.query) {
+    const like = `%${String(filter.query).replace(/[\\%_]/g, "\\$&").slice(0, 200)}%`;
+    conds.push("(provider LIKE ? ESCAPE '\\' OR model LIKE ? ESCAPE '\\' OR status LIKE ? ESCAPE '\\' OR connectionId LIKE ? ESCAPE '\\')");
+    params.push(like, like, like, like);
+  }
+  if (filter.startDate) { conds.push("timestamp >= ?"); params.push(new Date(filter.startDate).toISOString()); }
+  if (filter.endDate) { conds.push("timestamp <= ?"); params.push(new Date(filter.endDate).toISOString()); }
+
+  const where = conds.length ? `WHERE ${conds.join(" AND ")}` : "";
+  const cntRow = db.get(`SELECT COUNT(*) as c FROM requestDetails ${where}`, params);
+  const totalItems = cntRow ? cntRow.c : 0;
+
+  const page = filter.page || 1;
+  const pageSize = filter.pageSize || 50;
+  const totalPages = Math.ceil(totalItems / pageSize);
+  const offset = (page - 1) * pageSize;
+
+  const order = filter.sortDir === "asc" ? "ASC" : "DESC";
+  const rows = db.all(
+    `SELECT data FROM requestDetails ${where} ORDER BY timestamp ${order}, id ${order} LIMIT ? OFFSET ?`,
+    [...params, pageSize, offset]
+  );
+  const details = await enrichDetailsWithUsage(db, rows.map((r) => parseJson(r.data, {})));
+
+  return {
+    details,
+    pagination: { page, pageSize, totalItems, totalPages, hasNext: page < totalPages, hasPrev: page > 1 },
+  };
+}
+
+export async function getDistinctProviders() {
+  await flushToDatabase();
+  const db = await getAdapter();
+  const rows = db.all(`SELECT DISTINCT provider FROM requestDetails WHERE provider IS NOT NULL ORDER BY provider ASC`);
+  return rows.map((r) => r.provider);
+}
+
+export async function getRequestDetailById(id) {
+  await flushToDatabase();
+  const db = await getAdapter();
+  const row = db.get(`SELECT data FROM requestDetails WHERE id = ?`, [id]);
+  return row ? parseJson(row.data, null) : null;
+}
+
+export async function flushRequestDetails() {
+  if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+  if (writeBuffer.length > 0) await flushToDatabase();
+}

package/src/lib/db/repos/settingsRepo.js

@@ -0,0 +1,135 @@
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+import { getConfigCache, bumpConfigCacheVersion } from "../../cache/ttlCache.js";
+
+const DEFAULT_SETTINGS = {
+
+  profileName: "",
+  profileAvatar: "",
+  currency: "USD",
+  cloudEnabled: false,
+  tunnelEnabled: false,
+  tunnelUrl: "",
+  tunnelProvider: "cloudflare",
+  stickyRoundRobinLimit: 1,
+  fallbackStrategy: "fill-first",
+  providerStrategies: {},
+
+  accountPool: {
+    enabled: true,
+    maxConcurrentPerAccount: 30,
+    maxQueuePerProvider: 1024,
+    queueWaitTimeoutMs: 30000,
+    cacheTtlMs: 5000,
+  },
+  quotaVisibility: {},
+  comboStrategy: "fallback",
+  comboStickyRoundRobinLimit: 1,
+  comboStrategies: {},
+  capacityAdapter: {
+    vision: { enabled: true, roundRobin: false, models: [] },
+    pdf: { enabled: false, roundRobin: false, models: [] },
+    audioInput: { enabled: true, roundRobin: false, models: [] },
+    videoInput: { enabled: false, roundRobin: false, models: [] },
+  },
+  requireLogin: true,
+  requireApiKey: true,
+  tunnelDashboardAccess: true,
+  enableObservability: false,
+
+  payloadCaptureEnabled: false,
+  observabilityMaxRecords: 500,
+  observabilityBatchSize: 20,
+  observabilityFlushIntervalMs: 5000,
+  observabilityMaxJsonSize: 5,
+  rtkEnabled: true,
+  cavemanEnabled: false,
+  cavemanLevel: "full",
+  ponytailEnabled: false,
+  ponytailLevel: "full",
+
+  mediaProviders: [],
+
+  cliModelMappings: {},
+};
+
+const REMOVED_SETTING_KEYS = [
+  "outboundProxyEnabled",
+  "outboundProxyUrl",
+  "outboundNoProxy",
+  "accentColor",
+  "authMode",
+  "oidcIssuerUrl",
+  "oidcClientId",
+  "oidcClientSecret",
+  "oidcScopes",
+  "oidcLoginLabel",
+];
+
+export function stripRemovedSettings(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const clean = { ...raw };
+  for (const key of REMOVED_SETTING_KEYS) delete clean[key];
+  return clean;
+}
+
+async function readRaw() {
+  const db = await getAdapter();
+  const row = db.get(`SELECT data FROM settings WHERE id = 1`);
+  return stripRemovedSettings(row ? parseJson(row.data, {}) : {});
+}
+
+function mergeWithDefaults(raw) {
+  const merged = { ...DEFAULT_SETTINGS, ...stripRemovedSettings(raw) };
+  for (const [key, defVal] of Object.entries(DEFAULT_SETTINGS)) {
+    if (merged[key] === undefined) {
+      merged[key] = defVal;
+    }
+  }
+  return merged;
+}
+
+const settingsCache = getConfigCache("settings", { ttlMs: 5000 });
+
+export async function getSettings() {
+  return await settingsCache.get("merged", async () => {
+    const raw = await readRaw();
+    return mergeWithDefaults(raw);
+  });
+}
+
+export async function updateSettings(updates) {
+  const db = await getAdapter();
+  let next;
+  db.transaction(function () {
+    const row = db.get(`SELECT data FROM settings WHERE id = 1`);
+    const current = stripRemovedSettings(row ? parseJson(row.data, {}) : {});
+    next = stripRemovedSettings({ ...current, ...updates });
+    db.run(
+      `INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`,
+      [stringifyJson(next)],
+    );
+  });
+
+  await bumpConfigCacheVersion().catch(() => {});
+  return mergeWithDefaults(next);
+}
+
+export async function isCloudEnabled() {
+  const settings = await getSettings();
+  return settings.cloudEnabled === true;
+}
+
+export async function getCloudUrl() {
+  const settings = await getSettings();
+  return (
+    settings.cloudUrl ||
+    process.env.CLOUD_URL ||
+    process.env.NEXT_PUBLIC_CLOUD_URL ||
+    ""
+  );
+}
+
+export async function exportSettings() {
+  return await readRaw();
+}