@nvae/llmswitch 0.6.0 → 0.8.0

package/dist/gateway/state.js

@@ -0,0 +1,135 @@
+/**
+ * Gateway runtime state: listener address and the live daemon instance.
+ * Kept in its own file/port namespace so the outward-facing gateway never
+ * interferes with the local bridge.
+ */
+import { chmodSync, existsSync, readFileSync } from "node:fs";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { atomicWriteFile, ensureDir } from "../utils/fs.js";
+import { getGatewayDir, getGatewayStatePath } from "../utils/paths.js";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, } from "./types.js";
+const STATE_VERSION = 1;
+const MAX_PID = 2_147_483_647;
+export function generateGatewayControlToken() {
+    return randomBytes(32).toString("base64url");
+}
+export function constantTimeTokenEqual(a, b) {
+    if (typeof a !== "string" || typeof b !== "string")
+        return false;
+    const bufA = Buffer.from(a, "utf8");
+    const bufB = Buffer.from(b, "utf8");
+    if (bufA.length !== bufB.length)
+        return false;
+    return timingSafeEqual(bufA, bufB);
+}
+function isValidPid(pid) {
+    return (typeof pid === "number" &&
+        Number.isInteger(pid) &&
+        pid >= 1 &&
+        pid <= MAX_PID);
+}
+function defaultListener() {
+    return {
+        bindHost: process.env.LLM_SWITCH_GATEWAY_HOST || DEFAULT_GATEWAY_HOST,
+        advertiseHost: process.env.LLM_SWITCH_GATEWAY_HOST || DEFAULT_GATEWAY_HOST,
+        port: Number(process.env.LLM_SWITCH_GATEWAY_PORT) || DEFAULT_GATEWAY_PORT,
+        allowRemote: false,
+    };
+}
+function parseListener(raw) {
+    const fallback = defaultListener();
+    if (!raw || typeof raw !== "object")
+        return fallback;
+    const row = raw;
+    return {
+        bindHost: typeof row.bindHost === "string" ? row.bindHost : fallback.bindHost,
+        advertiseHost: typeof row.advertiseHost === "string"
+            ? row.advertiseHost
+            : fallback.advertiseHost,
+        port: typeof row.port === "number" ? row.port : fallback.port,
+        allowRemote: row.allowRemote === true,
+    };
+}
+function parseInstance(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const row = raw;
+    if (typeof row.id !== "string" ||
+        typeof row.controlToken !== "string" ||
+        !isValidPid(row.pid)) {
+        return null;
+    }
+    return {
+        id: row.id,
+        controlToken: row.controlToken,
+        pid: row.pid,
+        startedAt: typeof row.startedAt === "string" ? row.startedAt : "",
+    };
+}
+export function readGatewayState() {
+    const path = getGatewayStatePath();
+    if (!existsSync(path)) {
+        return {
+            version: STATE_VERSION,
+            revision: 0,
+            listener: defaultListener(),
+            instance: null,
+        };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        return {
+            version: STATE_VERSION,
+            revision: typeof raw.revision === "number" ? raw.revision : 0,
+            listener: parseListener(raw.listener),
+            instance: parseInstance(raw.instance),
+        };
+    }
+    catch {
+        return {
+            version: STATE_VERSION,
+            revision: 0,
+            listener: defaultListener(),
+            instance: null,
+        };
+    }
+}
+function persist(state) {
+    ensureDir(getGatewayDir());
+    try {
+        chmodSync(getGatewayDir(), 0o700);
+    }
+    catch {
+        // Windows relies on user-directory ACLs.
+    }
+    atomicWriteFile(getGatewayStatePath(), JSON.stringify({
+        version: STATE_VERSION,
+        revision: state.revision,
+        listener: state.listener,
+        instance: state.instance,
+    }, null, 2) + "\n");
+}
+export function updateGatewayState(mutate) {
+    const current = readGatewayState();
+    const mutated = mutate(current);
+    const next = {
+        version: STATE_VERSION,
+        revision: current.revision + 1,
+        listener: mutated.listener,
+        instance: mutated.instance,
+    };
+    persist(next);
+    return next;
+}
+function hostForUrl(host) {
+    return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+/** Root URL third parties connect to (clients append /v1/...). */
+export function gatewayRootUrl(state) {
+    const current = state || readGatewayState();
+    return `http://${hostForUrl(current.listener.advertiseHost)}:${current.listener.port}`;
+}
+/** OpenAI-style base URL (includes /v1). */
+export function gatewayBaseUrl(state) {
+    return `${gatewayRootUrl(state)}/v1`;
+}

package/dist/gateway/store.js

@@ -0,0 +1,392 @@
+/**
+ * Gateway provider / route / config persistence.
+ *
+ * Deliberately separate from `store/profiles.ts`: tool profiles are stored per
+ * tool (claude/codex/opencode), so the same upstream can exist three times with
+ * different names. The gateway needs one tool-independent provider list.
+ */
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { chmodSync } from "node:fs";
+import { TOOLS, isApiFormat, normalizeProxyValue } from "../types.js";
+import { ensureOpenAiV1BaseUrl, isOpenAiApiFormat } from "../utils/base-url.js";
+import { atomicWriteFile, ensureDir, maskSecret } from "../utils/fs.js";
+import { getGatewayConfigPath, getGatewayDir, getGatewayProviderPath, getGatewayProvidersDir, getGatewayRoutesPath, } from "../utils/paths.js";
+import { listProfiles } from "../store/profiles.js";
+import { defaultGatewayConfig, DEFAULT_GATEWAY_FALLBACK, } from "./types.js";
+const NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+/** Sanitized shape for `pathPrefix`: no slashes at the edges, bounded length. */
+const PATH_PREFIX_MAX = 64;
+export function normalizePathPrefix(value) {
+    const raw = typeof value === "string" ? value.trim() : "";
+    const trimmed = raw.replace(/^\/+|\/+$/g, "");
+    if (!trimmed)
+        return "";
+    if (trimmed.length > PATH_PREFIX_MAX || /[?#]/.test(trimmed))
+        return "v1";
+    return trimmed;
+}
+export function assertValidProviderName(name) {
+    if (!NAME_RE.test(name)) {
+        throw new Error(`无效的 provider 名称「${name}」。仅允许字母、数字、下划线、连字符，且以字母或数字开头。`);
+    }
+}
+function ensureGatewayDir() {
+    ensureDir(getGatewayDir());
+    try {
+        chmodSync(getGatewayDir(), 0o700);
+    }
+    catch {
+        // Windows relies on user-directory ACLs.
+    }
+}
+/**
+ * Gateway-specific base URL normalization.
+ *
+ * With the default prefix (`v1`, undefined field) OpenAI-format bases keep the
+ * historical "exactly one /v1" shape. Once a provider pins an explicit
+ * `pathPrefix` (including `""`), the base URL is the operator's business: only
+ * trailing slashes are trimmed, and `upstreamUrl` joins the prefix.
+ */
+function normalizeProviderBaseUrl(apiFormat, baseUrl, hasExplicitPrefix) {
+    const trimmed = baseUrl.trim();
+    if (!hasExplicitPrefix && isOpenAiApiFormat(apiFormat)) {
+        return ensureOpenAiV1BaseUrl(trimmed);
+    }
+    return trimmed.replace(/\/+$/, "");
+}
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function stringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return Array.from(new Set(value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean)));
+}
+// --- providers --------------------------------------------------------------
+function normalizeProvider(raw, fallbackName) {
+    const name = typeof raw.name === "string" && raw.name ? raw.name : fallbackName;
+    const apiFormat = String(raw.apiFormat || "");
+    if (!isApiFormat(apiFormat))
+        return null;
+    const baseUrl = String(raw.baseUrl || "");
+    if (!baseUrl)
+        return null;
+    const source = asRecord(raw.sourceProfile);
+    const pathPrefix = raw.pathPrefix === undefined ? undefined : normalizePathPrefix(raw.pathPrefix);
+    return {
+        name,
+        displayName: typeof raw.displayName === "string" && raw.displayName
+            ? raw.displayName
+            : name,
+        apiFormat,
+        baseUrl: normalizeProviderBaseUrl(apiFormat, baseUrl, pathPrefix !== undefined),
+        apiKey: typeof raw.apiKey === "string" ? raw.apiKey : "",
+        models: stringList(raw.models),
+        headers: asRecord(raw.headers) ?? {},
+        proxy: normalizeProxyValue(raw.proxy),
+        pathPrefix: raw.pathPrefix === undefined ? undefined : normalizePathPrefix(raw.pathPrefix),
+        priority: typeof raw.priority === "number" ? raw.priority : 100,
+        enabled: raw.enabled !== false,
+        sourceProfile: source && typeof source.tool === "string" && typeof source.name === "string"
+            ? { tool: source.tool, name: source.name }
+            : null,
+        updatedAt: typeof raw.updatedAt === "string"
+            ? raw.updatedAt
+            : new Date(0).toISOString(),
+    };
+}
+export function listGatewayProviders() {
+    const dir = getGatewayProvidersDir();
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const file of readdirSync(dir)) {
+        if (!file.endsWith(".json"))
+            continue;
+        const name = file.replace(/\.json$/, "");
+        const provider = readGatewayProvider(name);
+        if (provider)
+            out.push(provider);
+    }
+    return out.sort((a, b) => a.priority - b.priority || a.name.localeCompare(b.name));
+}
+export function readGatewayProvider(name) {
+    const path = getGatewayProviderPath(name);
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = asRecord(JSON.parse(readFileSync(path, "utf8")));
+        return raw ? normalizeProvider(raw, name) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function requireGatewayProvider(name) {
+    const provider = readGatewayProvider(name);
+    if (provider)
+        return provider;
+    const available = listGatewayProviders().map((p) => p.name);
+    throw new Error(available.length
+        ? `未找到 gateway provider「${name}」。现有：${available.join(", ")}`
+        : `未找到 gateway provider「${name}」。请先执行 llms gateway provider add`);
+}
+export function saveGatewayProvider(provider) {
+    assertValidProviderName(provider.name);
+    if (!isApiFormat(provider.apiFormat)) {
+        throw new Error(`无效的 apiFormat: ${provider.apiFormat}`);
+    }
+    if (!provider.baseUrl?.trim()) {
+        throw new Error("baseUrl 不能为空");
+    }
+    const nextPathPrefix = provider.pathPrefix === undefined
+        ? undefined
+        : normalizePathPrefix(provider.pathPrefix);
+    const next = {
+        ...provider,
+        displayName: provider.displayName || provider.name,
+        baseUrl: normalizeProviderBaseUrl(provider.apiFormat, provider.baseUrl, nextPathPrefix !== undefined),
+        apiKey: provider.apiKey ?? "",
+        models: stringList(provider.models),
+        headers: provider.headers || {},
+        pathPrefix: nextPathPrefix,
+        priority: typeof provider.priority === "number" ? provider.priority : 100,
+        enabled: provider.enabled !== false,
+        sourceProfile: provider.sourceProfile ?? null,
+        updatedAt: new Date().toISOString(),
+    };
+    ensureGatewayDir();
+    ensureDir(getGatewayProvidersDir());
+    atomicWriteFile(getGatewayProviderPath(next.name), JSON.stringify(next, null, 2) + "\n");
+    return next;
+}
+export function deleteGatewayProvider(name) {
+    const path = getGatewayProviderPath(name);
+    if (!existsSync(path)) {
+        throw new Error(`未找到 gateway provider「${name}」`);
+    }
+    unlinkSync(path);
+    // Drop routes that pointed at the removed provider.
+    const routes = listGatewayRoutes().filter((route) => {
+        if (route.provider === name)
+            return false;
+        route.fallbacks = (route.fallbacks || []).filter((item) => item.provider !== name);
+        return true;
+    });
+    writeGatewayRoutes(routes);
+    const config = readGatewayConfig();
+    if (config.defaultProvider === name) {
+        writeGatewayConfig({ ...config, defaultProvider: null });
+    }
+}
+export function publicProviderView(provider) {
+    return {
+        name: provider.name,
+        displayName: provider.displayName,
+        apiFormat: provider.apiFormat,
+        baseUrl: provider.baseUrl,
+        apiKey: maskSecret(provider.apiKey),
+        models: provider.models,
+        pathPrefix: provider.pathPrefix ?? "v1",
+        /** Header names only; values may carry secrets. */
+        headerNames: Object.keys(provider.headers || {}),
+        priority: provider.priority,
+        enabled: provider.enabled,
+        proxy: provider.proxy || null,
+        sourceProfile: provider.sourceProfile || null,
+        updatedAt: provider.updatedAt,
+    };
+}
+/**
+ * Import tool profiles as gateway providers, de-duplicated by
+ * (apiFormat, baseUrl, apiKey). Existing providers are never overwritten.
+ */
+export function importProvidersFromProfiles(tools = TOOLS) {
+    const existing = listGatewayProviders();
+    const fingerprint = (apiFormat, baseUrl, apiKey) => `${apiFormat}|${baseUrl.replace(/\/+$/, "")}|${apiKey}`;
+    const seen = new Set(existing.map((p) => fingerprint(p.apiFormat, p.baseUrl, p.apiKey)));
+    const usedNames = new Set(existing.map((p) => p.name));
+    const imported = [];
+    const skipped = [];
+    for (const tool of tools) {
+        for (const profile of listProfiles(tool)) {
+            const key = fingerprint(profile.apiFormat, profile.baseUrl, profile.apiKey);
+            if (seen.has(key)) {
+                skipped.push({ tool, name: profile.name, reason: "重复上游" });
+                continue;
+            }
+            let name = profile.name;
+            let suffix = 2;
+            while (usedNames.has(name)) {
+                name = `${profile.name}-${suffix++}`;
+            }
+            const models = Array.from(new Set([
+                profile.models.default,
+                profile.models.fast,
+                ...(profile.models.list || []),
+            ].filter((m) => Boolean(m && m.trim()))));
+            const provider = saveGatewayProvider({
+                name,
+                displayName: profile.displayName || name,
+                apiFormat: profile.apiFormat,
+                baseUrl: profile.baseUrl,
+                apiKey: profile.apiKey,
+                models,
+                headers: profile.headers || {},
+                proxy: profile.proxy,
+                priority: 100,
+                enabled: true,
+                sourceProfile: { tool, name: profile.name },
+                updatedAt: new Date().toISOString(),
+            });
+            seen.add(key);
+            usedNames.add(name);
+            imported.push(provider);
+        }
+    }
+    return { imported, skipped };
+}
+// --- routes -----------------------------------------------------------------
+function normalizeRoute(raw) {
+    const row = asRecord(raw);
+    if (!row)
+        return null;
+    const alias = String(row.alias || "").trim();
+    const provider = String(row.provider || "").trim();
+    if (!alias || !provider)
+        return null;
+    const fallbacks = [];
+    if (Array.isArray(row.fallbacks)) {
+        for (const item of row.fallbacks) {
+            const entry = asRecord(item);
+            const name = String(entry?.provider || "").trim();
+            if (!name)
+                continue;
+            const model = typeof entry?.model === "string" && entry.model.trim()
+                ? entry.model.trim()
+                : undefined;
+            fallbacks.push(model ? { provider: name, model } : { provider: name });
+        }
+    }
+    const model = typeof row.model === "string" && row.model.trim()
+        ? row.model.trim()
+        : undefined;
+    return {
+        alias,
+        provider,
+        ...(model ? { model } : {}),
+        ...(fallbacks.length ? { fallbacks } : {}),
+        updatedAt: typeof row.updatedAt === "string"
+            ? row.updatedAt
+            : new Date(0).toISOString(),
+    };
+}
+export function listGatewayRoutes() {
+    const path = getGatewayRoutesPath();
+    if (!existsSync(path))
+        return [];
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        const rows = Array.isArray(raw)
+            ? raw
+            : Array.isArray(asRecord(raw)?.routes)
+                ? asRecord(raw).routes
+                : [];
+        return rows
+            .map(normalizeRoute)
+            .filter((route) => route !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export function writeGatewayRoutes(routes) {
+    ensureGatewayDir();
+    atomicWriteFile(getGatewayRoutesPath(), JSON.stringify({ version: 1, routes }, null, 2) + "\n");
+}
+export function saveGatewayRoute(route) {
+    const alias = route.alias.trim();
+    if (!alias)
+        throw new Error("模型别名不能为空");
+    requireGatewayProvider(route.provider);
+    for (const fallback of route.fallbacks || []) {
+        requireGatewayProvider(fallback.provider);
+    }
+    const next = {
+        ...route,
+        alias,
+        updatedAt: new Date().toISOString(),
+    };
+    const routes = listGatewayRoutes().filter((item) => item.alias.toLowerCase() !== alias.toLowerCase());
+    routes.push(next);
+    routes.sort((a, b) => a.alias.localeCompare(b.alias));
+    writeGatewayRoutes(routes);
+    return next;
+}
+export function deleteGatewayRoute(alias) {
+    const routes = listGatewayRoutes();
+    const next = routes.filter((item) => item.alias.toLowerCase() !== alias.trim().toLowerCase());
+    if (next.length === routes.length) {
+        throw new Error(`未找到模型路由「${alias}」`);
+    }
+    writeGatewayRoutes(next);
+}
+// --- config -----------------------------------------------------------------
+export function readGatewayConfig() {
+    const path = getGatewayConfigPath();
+    const fallback = defaultGatewayConfig();
+    if (!existsSync(path))
+        return fallback;
+    try {
+        const raw = asRecord(JSON.parse(readFileSync(path, "utf8")));
+        if (!raw)
+            return fallback;
+        const fallbackRaw = asRecord(raw.fallback);
+        const retryStatuses = Array.isArray(fallbackRaw?.retryStatuses)
+            ? fallbackRaw.retryStatuses.filter((item) => typeof item === "number" && item >= 100 && item <= 599)
+            : [...DEFAULT_GATEWAY_FALLBACK.retryStatuses];
+        return {
+            version: 1,
+            defaultProvider: typeof raw.defaultProvider === "string" && raw.defaultProvider
+                ? raw.defaultProvider
+                : null,
+            fallback: {
+                enabled: fallbackRaw?.enabled !== false,
+                maxAttempts: typeof fallbackRaw?.maxAttempts === "number" &&
+                    fallbackRaw.maxAttempts >= 1
+                    ? Math.min(fallbackRaw.maxAttempts, 10)
+                    : DEFAULT_GATEWAY_FALLBACK.maxAttempts,
+                retryStatuses: retryStatuses.length
+                    ? retryStatuses
+                    : [...DEFAULT_GATEWAY_FALLBACK.retryStatuses],
+            },
+            corsOrigins: stringList(raw.corsOrigins),
+            rateLimitPerMinute: typeof raw.rateLimitPerMinute === "number" &&
+                raw.rateLimitPerMinute >= 0
+                ? raw.rateLimitPerMinute
+                : 0,
+            updatedAt: typeof raw.updatedAt === "string"
+                ? raw.updatedAt
+                : fallback.updatedAt,
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+export function writeGatewayConfig(config) {
+    const next = {
+        ...config,
+        version: 1,
+        updatedAt: new Date().toISOString(),
+    };
+    ensureGatewayDir();
+    atomicWriteFile(getGatewayConfigPath(), JSON.stringify(next, null, 2) + "\n");
+    return next;
+}