swayrouter 1.0.0

package/src/lib/db/migrate.js

@@ -0,0 +1,267 @@
+import fs from "node:fs";
+import path from "node:path";
+import { LEGACY_FILES, DB_DIR } from "./paths.js";
+import { TABLES, buildCreateTableSql, SCHEMA_VERSION } from "./schema.js";
+import { MIGRATIONS, latestVersion } from "./migrations/index.js";
+import { getMetaSync, setMetaSync } from "./helpers/metaStore.js";
+import { makeBackupDir, backupFile, backupDbLite, pruneOldBackups } from "./backup.js";
+import { getAppVersion } from "./version.js";
+import { stringifyJson } from "./helpers/jsonCol.js";
+
+const MIGRATED_MARKER = path.join(DB_DIR, ".migrated-from-json");
+
+const _migratedAdapters = new WeakSet();
+
+export class MigrationAborted extends Error {
+  constructor(message, droppedRows) {
+    super(message);
+    this.name = "MigrationAborted";
+    this.droppedRows = droppedRows;
+  }
+}
+
+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) {
+
+  try {
+    const row = adapter.get(`SELECT COUNT(*) as c FROM _meta`);
+    return !row || row.c === 0;
+  } catch {
+    return true;
+  }
+}
+
+function runVersionedMigrations(adapter) {
+
+  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 };
+}
+
+function syncSchemaFromTables(adapter) {
+  for (const [tableName, def] of Object.entries(TABLES)) {
+
+    adapter.exec(buildCreateTableSql(tableName, def));
+
+    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)) {
+
+        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}`);
+        }
+      }
+    }
+
+    for (const idx of def.indexes || []) {
+      try { adapter.exec(idx); } catch {}
+    }
+  }
+}
+
+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 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 [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)]
+    );
+  }
+}
+
+export async function runMigrationOnce(adapter) {
+  if (_migratedAdapters.has(adapter)) return;
+  _migratedAdapters.add(adapter);
+
+  const fresh = isFreshDb(adapter);
+
+  pruneOldBackups();
+
+  adapter.exec(buildCreateTableSql("_meta", TABLES._meta));
+
+  const storedSchemaVer = parseInt(getMetaSync(adapter, "backupSchemaVersion", "0"), 10) || 0;
+  const schemaChanging = !fresh && storedSchemaVer < SCHEMA_VERSION;
+  if (schemaChanging) {
+    try {
+      const backupDir = makeBackupDir(`schema-${storedSchemaVer}-to-${SCHEMA_VERSION}`);
+      backupDbLite(adapter, backupDir);
+      pruneOldBackups();
+      console.log(`[DB][migrate] pre-schema backup ${storedSchemaVer} → ${SCHEMA_VERSION}: ${backupDir}`);
+    } catch (e) {
+      console.warn(`[DB][migrate] pre-schema backup failed (continuing): ${e.message}`);
+    }
+  }
+
+  const migInfo = runVersionedMigrations(adapter);
+
+  syncSchemaFromTables(adapter);
+
+  setMetaSync(adapter, "backupSchemaVersion", SCHEMA_VERSION);
+
+  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, "backupSchemaVersion", SCHEMA_VERSION);
+        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}`);
+    return;
+  }
+
+  const newVer = getAppVersion();
+  const oldVer = getMetaSync(adapter, "appVersion", null);
+  if (oldVer !== newVer) setMetaSync(adapter, "appVersion", newVer);
+}

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

@@ -0,0 +1,12 @@
+import { TABLES, buildCreateTableSql } from "../schema.js";
+
+export default {
+  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);
+    }
+  },
+};

package/src/lib/db/migrations/002-prune-headroom-pxpipe-settings.js

@@ -0,0 +1,32 @@
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+const STALE_KEYS = [
+  "headroomEnabled",
+  "headroomUrl",
+  "headroomCompressUserMessages",
+  "pxpipeEnabled",
+  "pxpipeAutoInstall",
+  "pxpipeMinChars",
+  "pxpipeTimeoutMs",
+];
+
+export default {
+  version: 2,
+  name: "prune-headroom-pxpipe-settings",
+  up(db) {
+    const row = db.get(`SELECT data FROM settings WHERE id = 1`);
+    if (!row) return;
+    const settings = parseJson(row.data, {});
+    if (!settings || typeof settings !== "object") return;
+    let changed = false;
+    for (const k of STALE_KEYS) {
+      if (Object.prototype.hasOwnProperty.call(settings, k)) {
+        delete settings[k];
+        changed = true;
+      }
+    }
+    if (changed) {
+      db.run(`INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`, [stringifyJson(settings)]);
+    }
+  },
+};

package/src/lib/db/migrations/004-request-details-trace-id.js

@@ -0,0 +1,12 @@
+export default {
+  version: 4,
+  name: "request-details-trace-id",
+  up(db) {
+    const cols = db.all(`PRAGMA table_info(requestDetails)`).map((r) => r.name);
+    if (!cols.includes("trace_id")) {
+      db.run(`ALTER TABLE requestDetails ADD COLUMN trace_id TEXT`);
+      console.log(`[DB][migrate] +column requestDetails.trace_id`);
+    }
+    db.run(`CREATE INDEX IF NOT EXISTS idx_rd_trace ON requestDetails(trace_id)`);
+  },
+};

package/src/lib/db/migrations/005-request-details-payload-capture.js

@@ -0,0 +1,11 @@
+export default {
+  version: 5,
+  name: "request-details-payload-capture",
+  up(db) {
+    const cols = db.all(`PRAGMA table_info(requestDetails)`).map((r) => r.name);
+    if (!cols.includes("payload_capture")) {
+      db.run(`ALTER TABLE requestDetails ADD COLUMN payload_capture TEXT`);
+      console.log(`[DB][migrate] +column requestDetails.payload_capture`);
+    }
+  },
+};

package/src/lib/db/migrations/007-headroom-readd-settings.js

@@ -0,0 +1,35 @@
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+export default {
+  version: 7,
+  name: "headroom-readd-settings",
+  up(db) {
+
+    const row = db.get(`SELECT data FROM settings WHERE id = 1`);
+    if (!row) return;
+    const settings = parseJson(row.data, {});
+    if (!settings || typeof settings !== "object") return;
+
+    let changed = false;
+    if (
+      typeof settings.headroomUrl === "string" &&
+      settings.headroomUrl.trim() &&
+      !Array.isArray(settings.headroomProviders)
+    ) {
+      settings.headroomProviders = [settings.headroomUrl.trim()];
+      changed = true;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(settings, "headroomUrl")) {
+      delete settings.headroomUrl;
+      changed = true;
+    }
+
+    if (changed) {
+      db.run(
+        `INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`,
+        [stringifyJson(settings)],
+      );
+    }
+  },
+};

package/src/lib/db/migrations/008-account-model-locks.js

@@ -0,0 +1,22 @@
+export default {
+  version: 8,
+  name: "account-model-locks",
+  up(db) {
+    db.run(
+      `CREATE TABLE IF NOT EXISTS account_model_locks(
+        connectionId TEXT NOT NULL,
+        modelId TEXT NOT NULL,
+        tier TEXT,
+        reason TEXT,
+        expiresAt TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        PRIMARY KEY (connectionId, modelId)
+      )`
+    );
+
+    db.run(`CREATE INDEX IF NOT EXISTS idx_aml_model_expires ON account_model_locks(modelId, expiresAt)`);
+
+    db.run(`CREATE INDEX IF NOT EXISTS idx_aml_conn ON account_model_locks(connectionId)`);
+  },
+};

package/src/lib/db/migrations/009-warp-pool-lifecycle.js

@@ -0,0 +1,5 @@
+export default {
+  version: 9,
+  name: "proxy-pool-lifecycle-retired",
+  up() {},
+};

package/src/lib/db/migrations/010-api-key-file-permissions.js

@@ -0,0 +1,7 @@
+export default {
+  version: 10,
+  name: "api-key-file-permissions",
+  up() {
+
+  },
+};

package/src/lib/db/migrations/011-remove-upstream-user-agent-profile.js

@@ -0,0 +1,41 @@
+export default {
+  version: 11,
+  name: "remove-upstream-user-agent-profile",
+  up(db) {
+    const settingsRow = db.get(`SELECT data FROM settings WHERE id = 1`);
+    if (settingsRow?.data) {
+      try {
+        const settings = JSON.parse(settingsRow.data);
+        if (settings && typeof settings === "object" && !Array.isArray(settings)) {
+          delete settings.upstreamUserAgent;
+          db.run(`UPDATE settings SET data = ? WHERE id = 1`, [JSON.stringify(settings)]);
+        }
+      } catch {
+
+      }
+    }
+
+    for (const row of db.all(`SELECT id, data FROM providerConnections`)) {
+      if (!row?.data) continue;
+      try {
+        const connection = JSON.parse(row.data);
+        if (!connection || typeof connection !== "object" || Array.isArray(connection)) continue;
+        const providerSpecificData = connection.providerSpecificData;
+        if (
+          providerSpecificData &&
+          typeof providerSpecificData === "object" &&
+          !Array.isArray(providerSpecificData)
+        ) {
+          delete providerSpecificData.upstreamUserAgent;
+          delete providerSpecificData.userAgentProfile;
+          db.run(`UPDATE providerConnections SET data = ? WHERE id = ?`, [
+            JSON.stringify(connection),
+            row.id,
+          ]);
+        }
+      } catch {
+
+      }
+    }
+  },
+};

package/src/lib/db/migrations/012-remove-headroom-settings.js

@@ -0,0 +1,33 @@
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+const RETIRED_KEYS = [
+  "headroomEnabled",
+  "headroomUrl",
+  "headroomProviders",
+  "headroomCompressUserMessages",
+];
+
+export default {
+  version: 12,
+  name: "remove-headroom-settings",
+  up(db) {
+    const row = db.get(`SELECT data FROM settings WHERE id = 1`);
+    if (!row) return;
+    const settings = parseJson(row.data, {});
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) return;
+
+    let changed = false;
+    for (const key of RETIRED_KEYS) {
+      if (Object.prototype.hasOwnProperty.call(settings, key)) {
+        delete settings[key];
+        changed = true;
+      }
+    }
+    if (changed) {
+      db.run(
+        `INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`,
+        [stringifyJson(settings)],
+      );
+    }
+  },
+};

package/src/lib/db/migrations/013-default-fill-first-routing.js

@@ -0,0 +1,20 @@
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+export default {
+  version: 13,
+  name: "default-fill-first-routing",
+  up(db) {
+    const row = db.get(`SELECT data FROM settings WHERE id = 1`);
+    if (!row) return;
+
+    const settings = parseJson(row.data, {});
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) return;
+
+    if (settings.fallbackStrategy !== "least-inflight") return;
+    settings.fallbackStrategy = "fill-first";
+    db.run(
+      `INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`,
+      [stringifyJson(settings)],
+    );
+  },
+};

package/src/lib/db/migrations/014-normalize-fill-first-routing.js

@@ -0,0 +1,37 @@
+import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
+
+export default {
+  version: 14,
+  name: "normalize-fill-first-routing",
+  up(db) {
+    const row = db.get(`SELECT data FROM settings WHERE id = 1`);
+    if (!row) return;
+
+    const settings = parseJson(row.data, {});
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) return;
+
+    let changed = false;
+    if (settings.fallbackStrategy === "least-inflight") {
+      settings.fallbackStrategy = "fill-first";
+      changed = true;
+    }
+
+    if (settings.providerStrategies && typeof settings.providerStrategies === "object" && !Array.isArray(settings.providerStrategies)) {
+      for (const [provider, strategy] of Object.entries(settings.providerStrategies)) {
+        if (!strategy || typeof strategy !== "object" || Array.isArray(strategy)) continue;
+        if (strategy.fallbackStrategy !== "least-inflight") continue;
+        settings.providerStrategies[provider] = {
+          ...strategy,
+          fallbackStrategy: "fill-first",
+        };
+        changed = true;
+      }
+    }
+
+    if (!changed) return;
+    db.run(
+      `INSERT INTO settings(id, data) VALUES(1, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`,
+      [stringifyJson(settings)],
+    );
+  },
+};

package/src/lib/db/migrations/015-remove-ip-ban-tables.js

@@ -0,0 +1,8 @@
+export default {
+  version: 15,
+  name: "remove-ip-ban-tables",
+  up(db) {
+    db.run("DROP TABLE IF EXISTS security_offenses");
+    db.run("DROP TABLE IF EXISTS ip_bans");
+  },
+};

package/src/lib/db/migrations/016-prune-legacy-codebuddy-intl-models.js

@@ -0,0 +1,25 @@
+const LEGACY_MODELS = [
+  "default-model-lite",
+  "gpt-5.1-codex",
+  "gpt-5.1-codex-mini",
+  "gemini-3.0-flash",
+  "gemini-3.5-flash",
+  "gemini-2.5-flash",
+  "gemini-3.1-flash-lite",
+  "gemini-2.5-pro",
+  "deepseek-v3-2-volc",
+  "glm-5.0",
+];
+
+export default {
+  version: 16,
+  name: "prune-legacy-codebuddy-intl-models",
+  up(db) {
+    for (const modelId of LEGACY_MODELS) {
+      db.run(
+        "DELETE FROM kv WHERE scope = 'customModels' AND key = ?",
+        [`codebuddy-intl|${modelId}|llm`],
+      );
+    }
+  },
+};

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

@@ -0,0 +1,20 @@
+import m001 from "./001-initial.js";
+import m002 from "./002-prune-headroom-pxpipe-settings.js";
+import m004 from "./004-request-details-trace-id.js";
+import m005 from "./005-request-details-payload-capture.js";
+import m007 from "./007-headroom-readd-settings.js";
+import m008 from "./008-account-model-locks.js";
+import m009 from "./009-warp-pool-lifecycle.js";
+import m010 from "./010-api-key-file-permissions.js";
+import m011 from "./011-remove-upstream-user-agent-profile.js";
+import m012 from "./012-remove-headroom-settings.js";
+import m013 from "./013-default-fill-first-routing.js";
+import m014 from "./014-normalize-fill-first-routing.js";
+import m015 from "./015-remove-ip-ban-tables.js";
+import m016 from "./016-prune-legacy-codebuddy-intl-models.js";
+
+export const MIGRATIONS = [m001, m002, m004, m005, m007, m008, m009, m010, m011, m012, m013, m014, m015, m016].sort((a, b) => a.version - b.version);
+
+export function latestVersion() {
+  return MIGRATIONS.length ? MIGRATIONS[MIGRATIONS.length - 1].version : 0;
+}