swayrouter 1.0.0

package/src/lib/db/paths.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+import fs from "node:fs";
+import { DATA_DIR } from "@/lib/dataDir.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() {
+  for (const dir of [DATA_DIR, DB_DIR, BACKUPS_DIR]) {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32") {
+      try { fs.chmodSync(dir, 0o700); } catch (error) {
+        if (process.env.NODE_ENV === "production") throw error;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,74 @@
+import { getAdapter } from "../driver.js";
+
+export const LOCK_MODEL_ALL = "__all";
+
+export function lockModelId(model) {
+  return model ? String(model) : LOCK_MODEL_ALL;
+}
+
+export async function recordLock(connectionId, model, { tier, reason, expiresAt } = {}) {
+  if (!connectionId) return;
+  const db = await getAdapter();
+  const modelId = lockModelId(model);
+  const now = new Date().toISOString();
+  db.run(
+    `INSERT INTO account_model_locks(connectionId, modelId, tier, reason, expiresAt, createdAt, updatedAt)
+     VALUES(?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(connectionId, modelId) DO UPDATE SET
+       tier = excluded.tier, reason = excluded.reason,
+       expiresAt = excluded.expiresAt, updatedAt = excluded.updatedAt`,
+    [connectionId, modelId, tier || null, reason || null, expiresAt, now, now]
+  );
+}
+
+export async function clearLock(connectionId, model) {
+  if (!connectionId) return;
+  const db = await getAdapter();
+  db.run(`DELETE FROM account_model_locks WHERE connectionId = ? AND modelId = ?`,
+    [connectionId, lockModelId(model)]);
+}
+
+export async function clearAllLocksForConnection(connectionId) {
+  if (!connectionId) return;
+  const db = await getAdapter();
+  db.run(`DELETE FROM account_model_locks WHERE connectionId = ?`, [connectionId]);
+}
+
+export async function getActiveLocks(filter = {}) {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  const where = ["expiresAt > ?"];
+  const params = [now];
+  if (filter.connectionId) { where.push("connectionId = ?"); params.push(filter.connectionId); }
+  if (filter.model !== undefined) { where.push("modelId = ?"); params.push(lockModelId(filter.model)); }
+  const rows = db.all(
+    `SELECT connectionId, modelId, tier, reason, expiresAt FROM account_model_locks WHERE ${where.join(" AND ")} ORDER BY expiresAt ASC`,
+    params
+  );
+  return rows || [];
+}
+
+export async function isLocked(connectionId, model) {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+
+  const row = db.get(
+    `SELECT 1 FROM account_model_locks
+     WHERE connectionId = ? AND modelId IN (?, ?) AND expiresAt > ? LIMIT 1`,
+    [connectionId, lockModelId(model), LOCK_MODEL_ALL, now]
+  );
+  return !!row;
+}
+
+export async function countActiveLocks() {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  const row = db.get(`SELECT COUNT(*) AS c FROM account_model_locks WHERE expiresAt > ?`, [now]);
+  return row?.c || 0;
+}
+
+export async function reapExpired() {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  db.run(`DELETE FROM account_model_locks WHERE expiresAt <= ?`, [now]);
+}

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

@@ -0,0 +1,108 @@
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+import { makeKv } from "../helpers/kvStore.js";
+import { getConfigCache, bumpConfigCacheVersion } from "../../cache/ttlCache.js";
+
+const customKv = makeKv("customModels");
+
+const customCache = getConfigCache("customModels", { ttlMs: 5000 });
+
+function isClinePassProvider(providerAlias) {
+  const value = String(providerAlias || "").trim().toLowerCase();
+  return value === "clinepass" || value === "cline-pass";
+}
+
+function canonicalModelId(providerAlias, id) {
+  const value = String(id || "").trim();
+  if (!isClinePassProvider(providerAlias)) return value;
+  return value.replace(/^(?:clinepass|cline-pass)\//i, "");
+}
+
+function canonicalProviderAlias(providerAlias) {
+  return isClinePassProvider(providerAlias) ? "clinepass" : String(providerAlias || "").trim();
+}
+
+function customKey(providerAlias, id, type) {
+  return `${canonicalProviderAlias(providerAlias)}|${canonicalModelId(providerAlias, id)}|${type}`;
+}
+
+function legacyCustomKeys(providerAlias, id, type) {
+  const providerValue = String(providerAlias || "").trim();
+  const provider = canonicalProviderAlias(providerValue);
+  const value = String(id || "").trim();
+  const canonical = canonicalModelId(providerValue, value);
+  const keys = new Set([
+    customKey(provider, canonical, type),
+    `${provider}|${canonical}|${type}`,
+    `${providerValue}|${value}|${type}`,
+  ]);
+  if (isClinePassProvider(providerValue)) {
+    keys.add(`${provider}|cline-pass/${canonical}|${type}`);
+    keys.add(`${provider}|clinepass/${canonical}|${type}`);
+    keys.add(`cline-pass|${canonical}|${type}`);
+    keys.add(`cline-pass|cline-pass/${canonical}|${type}`);
+    keys.add(`cline-pass|clinepass/${canonical}|${type}`);
+  }
+  return [...keys];
+}
+
+export async function getCustomModels() {
+  const all = await customCache.get("all", () => customKv.getAll());
+  const deduped = new Map();
+  for (const raw of Object.values(all)) {
+    if (!raw?.id || !raw?.providerAlias) continue;
+    const providerAlias = canonicalProviderAlias(raw.providerAlias);
+    const id = canonicalModelId(providerAlias, raw.id);
+    const type = raw.type || "llm";
+    const key = `${providerAlias}|${id}|${type}`;
+    const existing = deduped.get(key);
+    if (!existing) {
+      deduped.set(key, { ...raw, providerAlias, id, type });
+    } else if (!existing.capabilities && raw.capabilities) {
+      deduped.set(key, { ...existing, capabilities: raw.capabilities });
+    }
+  }
+  return [...deduped.values()];
+}
+
+export async function addCustomModel({ providerAlias, id, type = "llm", name, capabilities }) {
+  const provider = canonicalProviderAlias(providerAlias);
+  const modelId = canonicalModelId(provider, id);
+  const key = customKey(provider, modelId, type);
+  const db = await getAdapter();
+  let changed = false;
+  db.transaction(() => {
+    const existing = legacyCustomKeys(provider, id, type)
+      .map((candidate) => db.get(`SELECT key, value FROM kv WHERE scope = 'customModels' AND key = ?`, [candidate]))
+      .find(Boolean);
+    const parsedExisting = existing ? parseJson(existing.value, {}) : {};
+    const value = stringifyJson({
+      ...parsedExisting,
+      providerAlias: provider,
+      id: modelId,
+      type,
+      name: name || parsedExisting.name || modelId,
+      ...(capabilities && typeof capabilities === "object" ? { capabilities } : {}),
+    });
+    if (existing) {
+      if (existing.key !== key) db.run(`DELETE FROM kv WHERE scope = 'customModels' AND key = ?`, [key]);
+      if (existing.key !== key || value !== existing.value) {
+        db.run(`UPDATE kv SET key = ?, value = ? WHERE scope = 'customModels' AND key = ?`, [key, value, existing.key]);
+        changed = true;
+      }
+      return;
+    }
+    db.run(`INSERT INTO kv(scope, key, value) VALUES('customModels', ?, ?)`, [key, value]);
+    changed = true;
+  });
+  if (changed) await bumpConfigCacheVersion().catch(() => {});
+  return changed;
+}
+
+export async function deleteCustomModel({ providerAlias, id, type = "llm" }) {
+  const db = await getAdapter();
+  for (const key of legacyCustomKeys(providerAlias, id, type)) {
+    db.run(`DELETE FROM kv WHERE scope = 'customModels' AND key = ?`, [key]);
+  }
+  await bumpConfigCacheVersion().catch(() => {});
+}

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

@@ -0,0 +1,204 @@
+import { v4 as uuidv4 } from "uuid";
+import { getAdapter } from "../driver.js";
+import { getConfigCache, bumpConfigCacheVersion } from "../../cache/ttlCache.js";
+
+const apiKeysCache = getConfigCache("apiKeys", { ttlMs: 5000 });
+let defaultApiKeyPromise = null;
+
+async function readAllKeys() {
+  const db = await getAdapter();
+  await ensureDefaultApiKey(db);
+  const rows = db.all(`SELECT * FROM apiKeys ORDER BY isDefault DESC, createdAt ASC`);
+  return rows.map(rowToKey);
+}
+
+async function ensureDefaultApiKey(db) {
+  const existing = db.get(`SELECT id FROM apiKeys WHERE isDefault = 1 ORDER BY createdAt ASC LIMIT 1`);
+  if (existing?.id) {
+    db.run(`UPDATE apiKeys SET isDefault = 0 WHERE id <> ? AND isDefault = 1`, [existing.id]);
+    return existing.id;
+  }
+  const first = db.get(`SELECT id FROM apiKeys ORDER BY createdAt ASC LIMIT 1`);
+  if (first?.id) {
+    db.run(`UPDATE apiKeys SET isDefault = 0`);
+    db.run(`UPDATE apiKeys SET isDefault = 1 WHERE id = ?`, [first.id]);
+    return first.id;
+  }
+
+  if (!defaultApiKeyPromise) {
+    defaultApiKeyPromise = (async () => {
+
+      const currentDefault = db.get(`SELECT id FROM apiKeys WHERE isDefault = 1 ORDER BY createdAt ASC LIMIT 1`);
+      if (currentDefault?.id) return currentDefault.id;
+      const currentFirst = db.get(`SELECT id FROM apiKeys ORDER BY createdAt ASC LIMIT 1`);
+      if (currentFirst?.id) {
+        db.run(`UPDATE apiKeys SET isDefault = 0`);
+        db.run(`UPDATE apiKeys SET isDefault = 1 WHERE id = ?`, [currentFirst.id]);
+        return currentFirst.id;
+      }
+
+      const [{ getConsistentMachineId }, { generateApiKeyWithMachine }] = await Promise.all([
+        import("@/shared/utils/machineId"),
+        import("@/shared/utils/apiKey"),
+      ]);
+      const machineId = await getConsistentMachineId();
+      const generated = generateApiKeyWithMachine(machineId);
+      const id = uuidv4();
+      const createdAt = new Date().toISOString();
+      db.run(
+        `INSERT INTO apiKeys(id, key, name, machineId, isActive, isDefault, createdAt) VALUES(?, ?, ?, ?, ?, ?, ?)`,
+        [id, generated.key, "Primary", machineId, 1, 1, createdAt]
+      );
+      return id;
+    })().finally(() => {
+      defaultApiKeyPromise = null;
+    });
+  }
+
+  return defaultApiKeyPromise;
+}
+
+async function readKeyMap() {
+
+  const db = await getAdapter();
+  const rows = db.all(`SELECT key, isActive FROM apiKeys`);
+  const map = {};
+  for (const r of rows) map[r.key] = r.isActive === 1 || r.isActive === true;
+  return map;
+}
+
+function rowToKey(row, includeSecret = false) {
+  if (!row) return null;
+  const result = {
+    id: row.id,
+    name: row.name,
+    machineId: row.machineId,
+    prefix: maskApiKeyPrefix(row.key),
+    isActive: row.isActive === 1 || row.isActive === true,
+    isDefault: row.isDefault === 1 || row.isDefault === true,
+    createdAt: row.createdAt,
+  };
+  if (includeSecret) result.key = row.key;
+  return result;
+}
+
+function maskApiKeyPrefix(key) {
+  const trimmed = typeof key === "string" ? key.trim() : "";
+  if (!trimmed) return undefined;
+  const match = trimmed.match(/^[^-]+-/);
+  return `${match?.[0] || trimmed.slice(0, 3)}••••`;
+}
+
+export function mergeApiKeyUpdate(row, data = {}) {
+  return {
+    key: row.key,
+    name: data.name !== undefined ? data.name : row.name,
+    machineId: data.machineId !== undefined ? data.machineId : row.machineId,
+    isActive: data.isActive !== undefined ? data.isActive : row.isActive === 1 || row.isActive === true,
+  };
+}
+
+async function readActiveKey() {
+  const db = await getAdapter();
+  await ensureDefaultApiKey(db);
+  const row = db.get(`SELECT key FROM apiKeys WHERE isActive = 1 ORDER BY isDefault DESC, createdAt ASC LIMIT 1`);
+  return row?.key || null;
+}
+
+export async function getActiveApiKey() {
+  return await apiKeysCache.get("active", readActiveKey);
+}
+
+export async function getApiKeySecretById(id) {
+  const db = await getAdapter();
+  const row = db.get(`SELECT key FROM apiKeys WHERE id = ?`, [id]);
+  return row?.key || null;
+}
+
+export async function getApiKeys() {
+  return await apiKeysCache.get("all", readAllKeys);
+}
+
+export async function getApiKeyById(id) {
+  const db = await getAdapter();
+  await ensureDefaultApiKey(db);
+  const row = db.get(`SELECT * FROM apiKeys WHERE id = ?`, [id]);
+  return rowToKey(row);
+}
+
+export async function createApiKey(name, machineId) {
+  if (!machineId) throw new Error("machineId is required");
+  const db = await getAdapter();
+  await ensureDefaultApiKey(db);
+  const { generateApiKeyWithMachine } = await import("@/shared/utils/apiKey");
+  const result = generateApiKeyWithMachine(machineId);
+  const isDefault = !db.get(`SELECT id FROM apiKeys WHERE isDefault = 1 LIMIT 1`);
+  const apiKey = {
+    id: uuidv4(),
+    name,
+    key: result.key,
+    machineId,
+    isActive: true,
+    isDefault,
+    createdAt: new Date().toISOString(),
+  };
+  db.run(
+    `INSERT INTO apiKeys(id, key, name, machineId, isActive, isDefault, createdAt) VALUES(?, ?, ?, ?, ?, ?, ?)`,
+    [apiKey.id, apiKey.key, apiKey.name, apiKey.machineId, 1, isDefault ? 1 : 0, apiKey.createdAt]
+  );
+  await bumpConfigCacheVersion().catch(() => {});
+  return apiKey;
+}
+
+export async function updateApiKey(id, data) {
+  const db = await getAdapter();
+  await ensureDefaultApiKey(db);
+  let result = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM apiKeys WHERE id = ?`, [id]);
+    if (!row) return;
+
+    const merged = mergeApiKeyUpdate(row, data);
+    db.run(
+      `UPDATE apiKeys SET key = ?, name = ?, machineId = ?, isActive = ? WHERE id = ?`,
+      [merged.key, merged.name, merged.machineId, merged.isActive ? 1 : 0, id]
+    );
+    result = rowToKey({ ...row, ...merged });
+  });
+  if (result) await bumpConfigCacheVersion().catch(() => {});
+  return result;
+}
+
+export async function deleteApiKey(id) {
+  const db = await getAdapter();
+  await ensureDefaultApiKey(db);
+  const row = db.get(`SELECT isDefault FROM apiKeys WHERE id = ?`, [id]);
+  if (!row) return false;
+  if (row.isDefault === 1 || row.isDefault === true) {
+    const error = new Error("The default API key cannot be deleted. Revoke or rotate it instead.");
+    error.code = "DEFAULT_API_KEY";
+    throw error;
+  }
+  const res = db.run(`DELETE FROM apiKeys WHERE id = ?`, [id]);
+  const deleted = (res?.changes ?? 0) > 0;
+  if (deleted) await bumpConfigCacheVersion().catch(() => {});
+  return deleted;
+}
+
+export async function rotateApiKey(id) {
+  const db = await getAdapter();
+  const row = db.get(`SELECT * FROM apiKeys WHERE id = ?`, [id]);
+  if (!row) return null;
+  if (!row.machineId) throw new Error("This API key has no machine id and cannot be rotated.");
+  const { generateApiKeyWithMachine } = await import("@/shared/utils/apiKey");
+  const generated = generateApiKeyWithMachine(row.machineId);
+  db.run(`UPDATE apiKeys SET key = ? WHERE id = ?`, [generated.key, id]);
+  await bumpConfigCacheVersion().catch(() => {});
+  return rowToKey({ ...row, key: generated.key }, true);
+}
+
+export async function validateApiKey(key) {
+  if (!key) return false;
+  const map = await apiKeysCache.get("map", readKeyMap);
+  return !!map[key];
+}

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

@@ -0,0 +1,85 @@
+import { v4 as uuidv4 } from "uuid";
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+import { getConfigCache, bumpConfigCacheVersion } from "../../cache/ttlCache.js";
+
+const combosCache = getConfigCache("combos", { ttlMs: 5000 });
+
+async function readAllCombos() {
+  const db = await getAdapter();
+  const rows = db.all(`SELECT * FROM combos ORDER BY createdAt ASC`);
+  return rows.map(rowToCombo);
+}
+
+function rowToCombo(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    name: row.name,
+    kind: row.kind,
+    models: parseJson(row.models, []),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}
+
+export async function getCombos() {
+  return await combosCache.get("all", readAllCombos);
+}
+
+export async function getComboById(id) {
+  const db = await getAdapter();
+  const row = db.get(`SELECT * FROM combos WHERE id = ?`, [id]);
+  return rowToCombo(row);
+}
+
+export async function getComboByName(name) {
+  if (!name) return null;
+
+  const all = await getCombos();
+  return all.find((c) => c.name === name) ?? null;
+}
+
+export async function createCombo(data) {
+  const db = await getAdapter();
+  const now = new Date().toISOString();
+  const combo = {
+    id: uuidv4(),
+    name: data.name,
+    kind: data.kind || null,
+    models: data.models || [],
+    createdAt: now,
+    updatedAt: now,
+  };
+  db.run(
+    `INSERT INTO combos(id, name, kind, models, createdAt, updatedAt) VALUES(?, ?, ?, ?, ?, ?)`,
+    [combo.id, combo.name, combo.kind, stringifyJson(combo.models), combo.createdAt, combo.updatedAt]
+  );
+  await bumpConfigCacheVersion().catch(() => {});
+  return combo;
+}
+
+export async function updateCombo(id, data) {
+  const db = await getAdapter();
+  let result = null;
+  db.transaction(() => {
+    const row = db.get(`SELECT * FROM combos WHERE id = ?`, [id]);
+    if (!row) return;
+    const merged = { ...rowToCombo(row), ...data, updatedAt: new Date().toISOString() };
+    db.run(
+      `UPDATE combos SET name = ?, kind = ?, models = ?, updatedAt = ? WHERE id = ?`,
+      [merged.name, merged.kind, stringifyJson(merged.models || []), merged.updatedAt, id]
+    );
+    result = merged;
+  });
+  if (result) await bumpConfigCacheVersion().catch(() => {});
+  return result;
+}
+
+export async function deleteCombo(id) {
+  const db = await getAdapter();
+  const res = db.run(`DELETE FROM combos WHERE id = ?`, [id]);
+  const deleted = (res?.changes ?? 0) > 0;
+  if (deleted) await bumpConfigCacheVersion().catch(() => {});
+  return deleted;
+}