swayrouter 1.0.0

package/src/lib/db/schema.js

@@ -0,0 +1,179 @@
+export const SCHEMA_VERSION = 16;
+
+export const PRAGMA_SQL = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+PRAGMA temp_store = MEMORY;
+PRAGMA mmap_size = 30000000;
+PRAGMA cache_size = -64000;
+PRAGMA foreign_keys = ON;
+PRAGMA busy_timeout = 5000;
+`;
+
+export const TABLES = {
+  _meta: {
+    columns: {
+      key: "TEXT PRIMARY KEY",
+      value: "TEXT NOT NULL",
+    },
+  },
+  settings: {
+    columns: {
+      id: "INTEGER PRIMARY KEY CHECK (id = 1)",
+      data: "TEXT NOT NULL",
+    },
+  },
+  providerConnections: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      provider: "TEXT NOT NULL",
+      authType: "TEXT NOT NULL",
+      name: "TEXT",
+      email: "TEXT",
+      priority: "INTEGER",
+      isActive: "INTEGER DEFAULT 1",
+      data: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_pc_provider ON providerConnections(provider)",
+      "CREATE INDEX IF NOT EXISTS idx_pc_provider_active ON providerConnections(provider, isActive)",
+      "CREATE INDEX IF NOT EXISTS idx_pc_priority ON providerConnections(provider, priority)",
+      "CREATE INDEX IF NOT EXISTS idx_pc_provider_order ON providerConnections(provider, COALESCE(priority, 999), id)",
+      "CREATE INDEX IF NOT EXISTS idx_pc_provider_active_order ON providerConnections(provider, isActive, COALESCE(priority, 999), id)",
+      "CREATE INDEX IF NOT EXISTS idx_pc_auth_active_order ON providerConnections(authType, isActive, COALESCE(priority, 999), id)",
+    ],
+  },
+  providerNodes: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      type: "TEXT",
+      name: "TEXT",
+      data: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_pn_type ON providerNodes(type)"],
+  },
+  proxyPools: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      isActive: "INTEGER DEFAULT 1",
+      testStatus: "TEXT",
+      data: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_pp_active ON proxyPools(isActive)",
+      "CREATE INDEX IF NOT EXISTS idx_pp_status ON proxyPools(testStatus)",
+    ],
+  },
+  apiKeys: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      key: "TEXT UNIQUE NOT NULL",
+      name: "TEXT",
+      machineId: "TEXT",
+      isActive: "INTEGER DEFAULT 1",
+      isDefault: "INTEGER DEFAULT 0",
+      createdAt: "TEXT NOT NULL",
+    },
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_ak_key ON apiKeys(key)"],
+  },
+  combos: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      name: "TEXT UNIQUE NOT NULL",
+      kind: "TEXT",
+      models: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_combo_name ON combos(name)"],
+  },
+  kv: {
+    columns: {
+      scope: "TEXT NOT NULL",
+      key: "TEXT NOT NULL",
+      value: "TEXT NOT NULL",
+    },
+    primaryKey: "PRIMARY KEY (scope, key)",
+    indexes: ["CREATE INDEX IF NOT EXISTS idx_kv_scope ON kv(scope)"],
+  },
+  usageHistory: {
+    columns: {
+      id: "INTEGER PRIMARY KEY AUTOINCREMENT",
+      timestamp: "TEXT NOT NULL",
+      provider: "TEXT",
+      model: "TEXT",
+      connectionId: "TEXT",
+      apiKey: "TEXT",
+      endpoint: "TEXT",
+      promptTokens: "INTEGER DEFAULT 0",
+      completionTokens: "INTEGER DEFAULT 0",
+      cost: "REAL DEFAULT 0",
+      status: "TEXT",
+      tokens: "TEXT",
+      meta: "TEXT",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_uh_ts ON usageHistory(timestamp DESC)",
+      "CREATE INDEX IF NOT EXISTS idx_uh_provider ON usageHistory(provider)",
+      "CREATE INDEX IF NOT EXISTS idx_uh_model ON usageHistory(model)",
+      "CREATE INDEX IF NOT EXISTS idx_uh_conn ON usageHistory(connectionId)",
+    ],
+  },
+  usageDaily: {
+    columns: {
+      dateKey: "TEXT PRIMARY KEY",
+      data: "TEXT NOT NULL",
+    },
+  },
+  requestDetails: {
+    columns: {
+      id: "TEXT PRIMARY KEY",
+      timestamp: "TEXT NOT NULL",
+      provider: "TEXT",
+      model: "TEXT",
+      connectionId: "TEXT",
+      status: "TEXT",
+      data: "TEXT NOT NULL",
+
+      trace_id: "TEXT",
+
+      payload_capture: "TEXT",
+    },
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_rd_ts ON requestDetails(timestamp DESC)",
+      "CREATE INDEX IF NOT EXISTS idx_rd_provider ON requestDetails(provider)",
+      "CREATE INDEX IF NOT EXISTS idx_rd_model ON requestDetails(model)",
+      "CREATE INDEX IF NOT EXISTS idx_rd_conn ON requestDetails(connectionId)",
+      "CREATE INDEX IF NOT EXISTS idx_rd_trace ON requestDetails(trace_id)",
+    ],
+  },
+
+  account_model_locks: {
+    columns: {
+      connectionId: "TEXT NOT NULL",
+      modelId: "TEXT NOT NULL",
+      tier: "TEXT",
+      reason: "TEXT",
+      expiresAt: "TEXT NOT NULL",
+      createdAt: "TEXT NOT NULL",
+      updatedAt: "TEXT NOT NULL",
+    },
+    primaryKey: "PRIMARY KEY (connectionId, modelId)",
+    indexes: [
+      "CREATE INDEX IF NOT EXISTS idx_aml_model_expires ON account_model_locks(modelId, expiresAt)",
+      "CREATE INDEX IF NOT EXISTS idx_aml_conn ON account_model_locks(connectionId)",
+    ],
+  },
+};
+
+export function buildCreateTableSql(name, def) {
+  const cols = Object.entries(def.columns).map(([k, v]) => `${k} ${v}`);
+  if (def.primaryKey) cols.push(def.primaryKey);
+  return `CREATE TABLE IF NOT EXISTS ${name} (${cols.join(", ")})`;
+}

package/src/lib/db/version.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+let cachedVersion = null;
+
+export function getAppVersion() {
+  if (cachedVersion) return cachedVersion;
+  const candidates = [
+    path.join(process.cwd(), "package.json"),
+    path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "package.json"),
+    path.join(process.execPath, "..", "package.json"),
+  ];
+  for (const pkgPath of candidates) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.version) {
+        cachedVersion = pkg.version;
+        return cachedVersion;
+      }
+    } catch {
+
+    }
+  }
+  cachedVersion = "0.0.0";
+  return cachedVersion;
+}
+
+export function timestampSlug(date = new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+}

package/src/lib/db/writeBehind.js

@@ -0,0 +1,174 @@
+import { histogram, counter, writeBehindBufferRows } from "@/observability/metrics.js";
+
+const FLUSH_LATENCY = histogram({
+  name: "sway_write_behind_flush_ms",
+  help: "Write-behind buffer flush latency in milliseconds",
+  labels: ["buffer"],
+});
+
+const COALESCED_TOTAL = counter({
+  name: "sway_write_behind_writes_total",
+  help: "Rows coalesced and flushed by the write-behind buffer",
+  labels: ["buffer"],
+});
+
+const DEFAULT_FLUSH_MS = 20;
+const DEFAULT_BATCH_SIZE = 200;
+const BACKPRESSURE_ROWS = 1000;
+
+const buffers = new Map();
+
+export function getWriteBehindBuffer(opts) {
+  const name = opts.name;
+  const existing = buffers.get(name);
+  if (existing) return existing;
+
+  const state = {
+    pending: [],
+    lastFlush: Date.now(),
+    flushing: false,
+    timer: null,
+    flushFn: opts.flushFn,
+    flushMs: opts.flushMs ?? DEFAULT_FLUSH_MS,
+    batchSize: opts.batchSize ?? DEFAULT_BATCH_SIZE,
+    closed: false,
+    closing: false,
+    flushPromise: null,
+    closePromise: null,
+  };
+  buffers.set(name, state);
+
+  let api;
+
+  function armTimer() {
+    if (state.timer || state.closed || state.closing) return;
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      flush().catch(() => {});
+    }, state.flushMs);
+    state.timer?.unref?.();
+  }
+
+  async function flush() {
+    if (state.closed || state.pending.length === 0) return;
+    if (state.flushing) {
+      await state.flushPromise;
+      return;
+    }
+    state.flushing = true;
+
+    const rows = state.pending;
+    state.pending = [];
+    const t0 = Date.now();
+    state.flushPromise = (async () => {
+      try {
+        await state.flushFn(rows);
+        FLUSH_LATENCY.observe({ buffer: name }, Date.now() - t0);
+        COALESCED_TOTAL.inc({ buffer: name }, rows.length);
+      } catch (e) {
+
+        state.pending.unshift(...rows);
+        console.error(`[writeBehind:${name}] flush failed (${e?.message ?? e}); ${rows.length} rows re-queued`);
+      } finally {
+        state.flushing = false;
+        state.flushPromise = null;
+        state.lastFlush = Date.now();
+        updateGauge();
+
+        if (state.pending.length > 0) armTimer();
+      }
+    })();
+    await state.flushPromise;
+  }
+
+  function updateGauge() {
+    try {
+      writeBehindBufferRows.set({ buffer: name }, state.pending.length);
+    } catch {
+
+    }
+  }
+
+  function push(row) {
+    if (state.closed || state.closing) return;
+    state.pending.push(row);
+
+    if (state.pending.length >= BACKPRESSURE_ROWS) {
+      flush().catch(() => {});
+      return;
+    }
+    if (state.pending.length >= state.batchSize) {
+
+      if (!state.flushing) {
+        if (state.timer) {
+          clearTimeout(state.timer);
+          state.timer = null;
+        }
+        flush().catch(() => {});
+      }
+      return;
+    }
+    armTimer();
+  }
+
+  async function flushImmediate() {
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    await flush();
+  }
+
+  function pendingSize() {
+    return state.pending.length;
+  }
+
+  async function close() {
+    if (state.closed) return;
+    if (state.closePromise) return state.closePromise;
+    state.closing = true;
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    state.closePromise = (async () => {
+
+      await flush();
+      if (state.pending.length > 0) await flush();
+      state.closed = true;
+      state.closing = false;
+      liveBuffers.delete(name);
+    })();
+    return state.closePromise;
+  }
+
+  api = {
+    push,
+    flush,
+    flushImmediate,
+    pendingSize,
+    close,
+    get name() {
+      return name;
+    },
+  };
+  liveBuffers.set(name, api);
+  return api;
+}
+
+export async function flushAllWriteBehindBuffers() {
+
+  const closers = [];
+  for (const buf of liveBuffers.values()) closers.push(buf.flushImmediate().catch(() => {}));
+  await Promise.all(closers);
+}
+
+const liveBuffers = new Map();
+
+export function __resetWriteBehindForTests() {
+  for (const b of buffers.values()) {
+    if (b.timer) clearTimeout(b.timer);
+  }
+  buffers.clear();
+  liveBuffers.clear();
+}

package/src/lib/disabledModelsDb.js

@@ -0,0 +1,3 @@
+export {
+  getDisabledModels, getDisabledByProvider, disableModels, enableModels,
+} from "@/lib/db/index.js";

package/src/lib/env.ts

@@ -0,0 +1,175 @@
+import { deriveResourceProfile } from "./resourceProfile";
+import { installRuntimeSecrets } from "./runtimeSecrets";
+
+export type NodeEnv = "development" | "production" | "test";
+
+export interface EnvConfig {
+  port: number;
+  hostname: string;
+  dataDir: string;
+  baseUrl: string;
+  jwtSecret: string;
+  jwtExpiresIn: string;
+  apiKeySecret: string;
+
+  initialPassword: string;
+  nodeEnv: NodeEnv;
+  trustProxy: boolean;
+  requestLogsEnabled: boolean;
+  requestLogsConfigured: boolean;
+  translatorEnabled: boolean;
+  authCookieSecure: boolean;
+  metricsToken: string;
+  metricsLocal: boolean;
+  resourceProfile: "low-memory" | "balanced" | "throughput";
+  resourceMemoryBytes: number;
+  resourceCpuCount: number;
+
+  routerMaxConcurrent: number;
+  routerInitialConcurrent: number;
+  routerMinConcurrent: number;
+  routerMaxQueue: number;
+  routerQueueWaitMs: number;
+  routerBodyBudgetBytes: number;
+  routerBodyReadTimeoutMs: number;
+  routerMemoryHighWaterBytes: number;
+  routerMemoryCriticalWaterBytes: number;
+
+  usageHistoryRetentionDays: number;
+  usageHistoryMaxRows: number;
+
+  upstreamMaxAttempts: number;
+}
+
+const DEFAULT_PASSWORD = "123456";
+const INSECURE_JWT_SECRETS = new Set(["", "change-me", "secret", "development-secret"]);
+const INSECURE_API_KEY_SECRETS = new Set(["", "endpoint-proxy-api-key-secret", "change-me"]);
+
+function parsePort(value: string): number {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("PORT must be an integer between 1 and 65535");
+  }
+  return port;
+}
+
+function parseHostname(value: string | undefined): string {
+  const hostname = String(value ?? "").trim() || "127.0.0.1";
+  if (/\s/.test(hostname) || hostname.length > 255) {
+    throw new Error("HOSTNAME must be a valid listen host");
+  }
+  return hostname;
+}
+
+function parseBoolean(value: string): boolean {
+  return value === "true" || value === "1";
+}
+
+function parsePositiveInt(value: string | undefined, fallback: number, max: number): number {
+  const parsed = Number.parseInt(value ?? "", 10);
+  if (!Number.isFinite(parsed) || parsed < 1) return fallback;
+  return Math.min(parsed, max);
+}
+
+function parseNodeEnv(value: string): NodeEnv {
+  if (value === "development" || value === "production" || value === "test") return value;
+  throw new Error("NODE_ENV must be development, test, or production");
+}
+
+export function loadEnv(source: Record<string, string | undefined> = process.env): EnvConfig {
+  const nodeEnv = parseNodeEnv(source.NODE_ENV ?? "development");
+  const jwtSecret = source.JWT_SECRET ?? (nodeEnv === "production" ? "" : "change-me");
+  const apiKeySecret = source.API_KEY_SECRET ?? (nodeEnv === "production" ? "" : "endpoint-proxy-api-key-secret");
+
+  const initialPassword = DEFAULT_PASSWORD;
+
+  if (nodeEnv === "production") {
+    if (INSECURE_JWT_SECRETS.has(jwtSecret) || jwtSecret.length < 32) {
+      throw new Error("JWT_SECRET must be explicitly configured with at least 32 characters in production");
+    }
+    if (INSECURE_API_KEY_SECRETS.has(apiKeySecret) || apiKeySecret.length < 32) {
+      throw new Error("API_KEY_SECRET must be explicitly configured with at least 32 characters in production");
+    }
+  }
+
+  const dataDir = source.DATA_DIR?.trim() || "";
+  const baseUrl = source.BASE_URL?.trim() || source.NEXT_PUBLIC_BASE_URL?.trim() || "";
+  const metricsToken = source.SWAY_METRICS_TOKEN?.trim() || "";
+  const resource = deriveResourceProfile(undefined, source.SWAY_PERFORMANCE_PROFILE);
+  const routerMaxConcurrent = parsePositiveInt(source.SWAY_ROUTER_MAX_CONCURRENT, resource.maxConcurrent, 100_000);
+  const routerInitialConcurrent = Math.min(
+    routerMaxConcurrent,
+    parsePositiveInt(source.SWAY_ROUTER_INITIAL_CONCURRENT, resource.initialConcurrent, 100_000),
+  );
+  const routerMinConcurrent = Math.min(
+    routerInitialConcurrent,
+    parsePositiveInt(source.SWAY_ROUTER_MIN_CONCURRENT, resource.minConcurrent, 100_000),
+  );
+  const routerBodyBudgetBytes = parsePositiveInt(
+    source.SWAY_ROUTER_BODY_BUDGET_MB,
+    resource.bodyBudgetMb,
+    16 * 1024,
+  ) * 1024 * 1024;
+  const routerMemoryHighWaterBytes = parsePositiveInt(
+    source.SWAY_ROUTER_MEMORY_HIGH_WATER_MB,
+    0,
+    1024 * 1024,
+  ) * 1024 * 1024;
+  const routerMemoryCriticalWaterBytes = parsePositiveInt(
+    source.SWAY_ROUTER_MEMORY_CRITICAL_MB,
+    0,
+    1024 * 1024,
+  ) * 1024 * 1024;
+
+  return Object.freeze({
+    port: parsePort(source.PORT ?? "14045"),
+    hostname: parseHostname(source.HOSTNAME),
+    dataDir,
+    baseUrl,
+    jwtSecret,
+    jwtExpiresIn: source.JWT_EXPIRES_IN ?? "7d",
+    apiKeySecret,
+    initialPassword,
+    nodeEnv,
+    trustProxy: parseBoolean(source.TRUST_PROXY ?? "false"),
+    requestLogsEnabled: parseBoolean(source.ENABLE_REQUEST_LOGS ?? "false"),
+    requestLogsConfigured: source.ENABLE_REQUEST_LOGS !== undefined,
+    translatorEnabled: parseBoolean(source.ENABLE_TRANSLATOR ?? "false"),
+    authCookieSecure: parseBoolean(source.AUTH_COOKIE_SECURE ?? "false"),
+    metricsToken,
+    metricsLocal: source.SWAY_METRICS_LOCAL !== "0",
+    resourceProfile: resource.name,
+    resourceMemoryBytes: resource.memoryBytes,
+    resourceCpuCount: resource.cpuCount,
+    routerMaxConcurrent,
+    routerInitialConcurrent,
+    routerMinConcurrent,
+    routerMaxQueue: parsePositiveInt(source.SWAY_ROUTER_MAX_QUEUE, resource.maxQueue, 1_000_000),
+    routerQueueWaitMs: parsePositiveInt(
+      source.SWAY_ROUTER_QUEUE_WAIT_MS,
+      resource.queueWaitMs,
+      10 * 60 * 1000,
+    ),
+    routerBodyBudgetBytes,
+    routerBodyReadTimeoutMs: parsePositiveInt(source.SWAY_ROUTER_BODY_TIMEOUT_MS, 30_000, 10 * 60 * 1000),
+    routerMemoryHighWaterBytes,
+    routerMemoryCriticalWaterBytes,
+    usageHistoryRetentionDays: parsePositiveInt(source.SWAY_USAGE_RETENTION_DAYS, 7, 3650),
+    usageHistoryMaxRows: parsePositiveInt(source.SWAY_USAGE_HISTORY_MAX_ROWS, 500_000, 100_000_000),
+    upstreamMaxAttempts: parsePositiveInt(
+      source.SWAY_UPSTREAM_MAX_ATTEMPTS,
+      nodeEnv === "production" ? resource.upstreamMaxAttempts : 8,
+      100,
+    ),
+  });
+}
+
+if (process.env.NODE_ENV !== "test") installRuntimeSecrets(process.env);
+
+export const env = loadEnv();
+
+export function getEnvConfig(options: { refresh?: boolean } = {}): EnvConfig {
+  if (!options.refresh) return env;
+  if (process.env.NODE_ENV !== "test") installRuntimeSecrets(process.env);
+  return loadEnv(process.env);
+}

package/src/lib/errors/publicError.js

@@ -0,0 +1,18 @@
+const SAFE_MESSAGES = new Map([
+  ["auth", "Authentication failed"],
+  ["login", "Login failed"],
+  ["database_import", "Failed to import database"],
+  ["database_export", "Failed to export database"],
+  ["provider", "Provider request failed"],
+  ["oauth", "OAuth request failed"],
+  ["tunnel", "Tunnel operation failed"],
+  ["deployment", "Deployment failed"],
+]);
+
+export function publicError(kind, fallback = "Request failed") {
+  return SAFE_MESSAGES.get(kind) || fallback;
+}
+
+export function logRouteError(scope, error) {
+  console.error(`[${scope}]`, error);
+}