Spaces:
Sleeping
Sleeping
| // Config export service. Snapshots the user's full configuration into a | |
| // versioned, importable envelope. All reads happen in a single read | |
| // transaction so the export is internally consistent: a model and its | |
| // fallback entry, an api_key and the row that decrypts it, etc., will not | |
| // race against a concurrent write. | |
| // | |
| // The optional `passphrase` encrypts the api_keys payload (only) into a | |
| // self-describing cipher blob. Without a passphrase the api_keys section | |
| // is included in plaintext — fine for offline backups, but the UI nudges | |
| // the user toward providing one. | |
| import type Database from 'better-sqlite3'; | |
| import { getDb } from '../../db/index.js'; | |
| import { decrypt } from '../crypto.js'; | |
| import { | |
| CONFIG_SCHEMA_VERSION, | |
| CONFIG_GENERATOR, | |
| type ConfigEnvelope, | |
| type ConfigSection, | |
| type ConfigModel, | |
| type ConfigFallbackEntry, | |
| type ConfigCustomProvider, | |
| type ConfigApiKey, | |
| type ConfigEmbeddingFamily, | |
| type ConfigSettings, | |
| type ConfigQuirk, | |
| type ConfigExportRequest, | |
| } from '@api-gateway/shared'; | |
| import { encryptKeysWithPassphrase } from './passphrase-crypto.js'; | |
| export interface BuildExportOptions { | |
| sections?: ConfigSection[]; | |
| passphrase?: string; | |
| label?: string; | |
| } | |
| const ALL_SECTIONS: ConfigSection[] = [ | |
| 'models', 'fallback_chain', 'custom_providers', 'api_keys', | |
| 'embeddings', 'settings', 'quirks', | |
| ]; | |
| function sectionSet(sections?: ConfigSection[]): Record<ConfigSection, true> { | |
| const keys = sections && sections.length > 0 ? sections : ALL_SECTIONS; | |
| const out = {} as Record<ConfigSection, true>; | |
| for (const k of keys) out[k] = true; | |
| return out; | |
| } | |
| export class ConfigExportError extends Error { | |
| status: number; | |
| constructor(message: string, status = 400) { | |
| super(message); | |
| this.status = status; | |
| this.name = 'ConfigExportError'; | |
| } | |
| } | |
| function readSection(db: Database.Database, sections: Record<ConfigSection, true>): ConfigEnvelope['sections'] { | |
| const out: ConfigEnvelope['sections'] = {}; | |
| const tx = db.transaction(() => { | |
| if (sections.models) { | |
| const rows = db.prepare(` | |
| SELECT platform, model_id, display_name, intelligence_rank, speed_rank, | |
| size_label, rpm_limit, rpd_limit, tpm_limit, tpd_limit, | |
| monthly_token_budget, context_window, enabled, supports_vision, | |
| supports_tools, max_output_tokens, paid_input_per_m, paid_output_per_m | |
| FROM models | |
| `).all() as Array<{ | |
| platform: string; model_id: string; display_name: string; | |
| intelligence_rank: number; speed_rank: number; size_label: string; | |
| rpm_limit: number | null; rpd_limit: number | null; | |
| tpm_limit: number | null; tpd_limit: number | null; | |
| monthly_token_budget: string; context_window: number | null; | |
| enabled: number; supports_vision: number; supports_tools: number; | |
| max_output_tokens: number | null; | |
| paid_input_per_m: number | null; paid_output_per_m: number | null; | |
| }>; | |
| out.models = rows.map<ConfigModel>((r) => ({ | |
| platform: r.platform, | |
| modelId: r.model_id, | |
| displayName: r.display_name, | |
| intelligenceRank: r.intelligence_rank, | |
| speedRank: r.speed_rank, | |
| sizeLabel: r.size_label, | |
| rpmLimit: r.rpm_limit, | |
| rpdLimit: r.rpd_limit, | |
| tpmLimit: r.tpm_limit, | |
| tpdLimit: r.tpd_limit, | |
| monthlyTokenBudget: r.monthly_token_budget, | |
| contextWindow: r.context_window, | |
| enabled: r.enabled === 1, | |
| supportsVision: r.supports_vision === 1, | |
| supportsTools: r.supports_tools === 1, | |
| maxOutputTokens: r.max_output_tokens, | |
| paidInputPerM: r.paid_input_per_m, | |
| paidOutputPerM: r.paid_output_per_m, | |
| })); | |
| } | |
| if (sections.fallback_chain) { | |
| // Tie-break by `model_db_id` so the export order is stable even | |
| // when two rows share a priority (which happens after manual | |
| // edits or when a model is re-inserted at the tail). The | |
| // stored `priority` is preserved verbatim in each entry so a | |
| // no-op round-trip can compare it directly without inferring | |
| // it from the list index. | |
| const rows = db.prepare(` | |
| SELECT m.platform, m.model_id, fc.id AS fallback_id, | |
| fc.priority, fc.enabled | |
| FROM fallback_config fc | |
| JOIN models m ON m.id = fc.model_db_id | |
| ORDER BY fc.priority ASC, fc.id ASC | |
| `).all() as Array<{ | |
| platform: string; model_id: string; fallback_id: number; | |
| priority: number; enabled: number; | |
| }>; | |
| out.fallbackChain = rows.map<ConfigFallbackEntry>((r) => ({ | |
| platform: r.platform, | |
| modelId: r.model_id, | |
| priority: r.priority, | |
| enabled: r.enabled === 1, | |
| })); | |
| } | |
| if (sections.custom_providers) { | |
| const rows = db.prepare(` | |
| SELECT slug, display_name, base_url, rpm_limit, rpd_limit, tpm_limit, | |
| tpd_limit, max_parallel_requests, archived, keyless, api_format | |
| FROM custom_providers | |
| `).all() as Array<{ | |
| slug: string; display_name: string; base_url: string; | |
| rpm_limit: number | null; rpd_limit: number | null; | |
| tpm_limit: number | null; tpd_limit: number | null; | |
| max_parallel_requests: number | null; | |
| archived: number | null; keyless: number | null; | |
| api_format: string | null; | |
| }>; | |
| out.customProviders = rows.map<ConfigCustomProvider>((r) => ({ | |
| slug: r.slug, | |
| displayName: r.display_name, | |
| baseUrl: r.base_url, | |
| rpmLimit: r.rpm_limit, | |
| rpdLimit: r.rpd_limit, | |
| tpmLimit: r.tpm_limit, | |
| tpdLimit: r.tpd_limit, | |
| maxParallelRequests: r.max_parallel_requests, | |
| archived: (r.archived ?? 0) === 1, | |
| keyless: (r.keyless ?? 0) === 1, | |
| apiFormat: (r.api_format === 'anthropic' ? 'anthropic' : 'openai'), | |
| })); | |
| } | |
| if (sections.api_keys) { | |
| const rows = db.prepare(` | |
| SELECT platform, label, encrypted_key, iv, auth_tag, enabled, base_url | |
| FROM api_keys | |
| `).all() as Array<{ | |
| platform: string; label: string; encrypted_key: string; iv: string; | |
| auth_tag: string; enabled: number; base_url: string | null; | |
| }>; | |
| // Always include both plaintext (key) and ciphertext shape. The | |
| // caller decides whether to wrap the plaintext in a passphrase | |
| // cipher. When a passphrase is requested, `key` is stripped below. | |
| out.apiKeys = rows.map<ConfigApiKey>((r) => { | |
| let plaintext: string | null = null; | |
| try { | |
| plaintext = decrypt(r.encrypted_key, r.iv, r.auth_tag); | |
| } catch { | |
| // Decryption failure shouldn't fail the whole export — the | |
| // user can still back up everything else. The row keeps its | |
| // ciphertext fields so an import on the same ENCRYPTION_KEY | |
| // can recover it; on a different host it will be skipped. | |
| plaintext = null; | |
| } | |
| return { | |
| platform: r.platform, | |
| label: r.label, | |
| enabled: r.enabled === 1, | |
| key: plaintext ?? undefined, | |
| encryptedKey: r.encrypted_key, | |
| iv: r.iv, | |
| authTag: r.auth_tag, | |
| baseUrl: r.base_url, | |
| }; | |
| }); | |
| } | |
| if (sections.embeddings) { | |
| const defaultFamily = db.prepare( | |
| "SELECT value FROM settings WHERE key = 'embeddings_default_family'", | |
| ).get() as { value: string } | undefined; | |
| const familyRows = db.prepare(` | |
| SELECT family, platform, model_id, display_name, dimensions, | |
| max_input_tokens, priority, enabled, quota_label | |
| FROM embedding_models | |
| ORDER BY family ASC, priority ASC | |
| `).all() as Array<{ | |
| family: string; platform: string; model_id: string; | |
| display_name: string; dimensions: number; | |
| max_input_tokens: number | null; priority: number; | |
| enabled: number; quota_label: string; | |
| }>; | |
| const byFamily = new Map<string, ConfigEmbeddingFamily>(); | |
| for (const r of familyRows) { | |
| let fam = byFamily.get(r.family); | |
| if (!fam) { | |
| fam = { | |
| family: r.family, | |
| providers: [], | |
| dimensions: r.dimensions, | |
| maxInputTokens: r.max_input_tokens, | |
| displayName: r.display_name, | |
| quotaLabel: r.quota_label, | |
| }; | |
| byFamily.set(r.family, fam); | |
| } | |
| fam.providers.push({ | |
| platform: r.platform, | |
| modelId: r.model_id, | |
| priority: r.priority, | |
| enabled: r.enabled === 1, | |
| }); | |
| } | |
| out.embeddings = { | |
| defaultFamily: defaultFamily?.value, | |
| families: Array.from(byFamily.values()), | |
| }; | |
| } | |
| if (sections.settings) { | |
| const s: ConfigSettings = {}; | |
| const strat = db.prepare( | |
| "SELECT value FROM settings WHERE key = 'routing_strategy'", | |
| ).get() as { value: string } | undefined; | |
| const retry = db.prepare( | |
| "SELECT value FROM settings WHERE key = 'global_retry_limit'", | |
| ).get() as { value: string } | undefined; | |
| const weights = db.prepare( | |
| "SELECT value FROM settings WHERE key = 'routing_custom_weights'", | |
| ).get() as { value: string } | undefined; | |
| if (strat) s.routingStrategy = strat.value as ConfigSettings['routingStrategy']; | |
| if (retry) s.globalRetryLimit = parseInt(retry.value, 10); | |
| if (weights) { | |
| try { | |
| s.customWeights = JSON.parse(weights.value); | |
| } catch { /* ignore — the importer falls back to defaults */ } | |
| } | |
| if (Object.keys(s).length > 0) { | |
| out.settings = s; | |
| } | |
| } | |
| if (sections.quirks) { | |
| const qRows = db.prepare(` | |
| SELECT id, slug, title, body, severity FROM quirks ORDER BY id ASC | |
| `).all() as Array<{ | |
| id: number; slug: string; title: string; body: string; severity: string; | |
| }>; | |
| const tRows = db.prepare(`SELECT quirk_id, platform, model_glob FROM quirk_targets`).all() as Array<{ | |
| quirk_id: number; platform: string | null; model_glob: string | null; | |
| }>; | |
| const targetsByQ = new Map<number, ConfigQuirk['targets']>(); | |
| for (const t of tRows) { | |
| let arr = targetsByQ.get(t.quirk_id); | |
| if (!arr) { arr = []; targetsByQ.set(t.quirk_id, arr); } | |
| arr.push({ platform: t.platform, modelGlob: t.model_glob }); | |
| } | |
| out.quirks = qRows.map<ConfigQuirk>((r) => ({ | |
| slug: r.slug, | |
| title: r.title, | |
| body: r.body, | |
| severity: (r.severity === 'critical' || r.severity === 'warning' | |
| ? r.severity : 'info') as ConfigQuirk['severity'], | |
| targets: targetsByQ.get(r.id) ?? [], | |
| })); | |
| } | |
| }); | |
| tx(); | |
| return out; | |
| } | |
| /** | |
| * Build a full export envelope. The optional `passphrase` causes the | |
| * api_keys section's plaintext to be encrypted into a self-describing | |
| * `keysCipher` blob and stripped from `sections.apiKeys` — so even a | |
| * malicious actor with the file but not the passphrase cannot recover the | |
| * keys. | |
| */ | |
| export function buildExport(opts: BuildExportOptions = {}): ConfigEnvelope { | |
| const requested = sectionSet(opts.sections); | |
| const db = getDb(); | |
| const sections = readSection(db, requested); | |
| let keysCipher: ConfigEnvelope['keysCipher']; | |
| if (opts.passphrase) { | |
| if (!sections.apiKeys) { | |
| throw new ConfigExportError( | |
| 'api_keys section not in export — nothing to encrypt', | |
| ); | |
| } | |
| const plaintext = sections.apiKeys | |
| .filter((k) => typeof k.key === 'string' && k.key.length > 0) | |
| .map((k) => ({ platform: k.platform, key: k.key as string })); | |
| if (plaintext.length === 0) { | |
| throw new ConfigExportError( | |
| 'no decryptable API keys to encrypt — every key failed to decrypt', | |
| ); | |
| } | |
| keysCipher = encryptKeysWithPassphrase(plaintext, opts.passphrase); | |
| sections.apiKeys = sections.apiKeys.map((k) => { | |
| const { key: _omit, ...rest } = k; | |
| return rest; | |
| }); | |
| } | |
| return { | |
| schemaVersion: CONFIG_SCHEMA_VERSION, | |
| generator: CONFIG_GENERATOR, | |
| exportedAt: new Date().toISOString(), | |
| label: opts.label, | |
| sections, | |
| keysCipher, | |
| }; | |
| } | |
| /** | |
| * Returns a brief inventory of what's exportable — used by the Settings UI | |
| * before the user clicks "Export" so they can see how big the file will be. | |
| */ | |
| export function getExportInventory(): Record<ConfigSection, number> { | |
| const db = getDb(); | |
| return { | |
| models: (db.prepare('SELECT COUNT(*) AS n FROM models').get() as { n: number }).n, | |
| fallback_chain: (db.prepare('SELECT COUNT(*) AS n FROM fallback_config').get() as { n: number }).n, | |
| custom_providers: (db.prepare('SELECT COUNT(*) AS n FROM custom_providers').get() as { n: number }).n, | |
| api_keys: (db.prepare('SELECT COUNT(*) AS n FROM api_keys').get() as { n: number }).n, | |
| embeddings: (db.prepare('SELECT COUNT(*) AS n FROM embedding_models').get() as { n: number }).n, | |
| settings: (db.prepare("SELECT COUNT(*) AS n FROM settings WHERE key IN ('routing_strategy','global_retry_limit','routing_custom_weights','embeddings_default_family')").get() as { n: number }).n, | |
| quirks: (db.prepare('SELECT COUNT(*) AS n FROM quirks').get() as { n: number }).n, | |
| }; | |
| } | |
| export type { ConfigExportRequest }; | |