llm-simple-router 0.1.1 → 0.3.5

package/README.md

@@ -59,7 +59,7 @@ Router 根据模型映射找到后端供应商 -> 转发请求 -> 自动重试
 **方式一：shell alias（推荐）**
 
 ```bash
-alias clodedev='ANTHROPIC_AUTH_TOKEN="<your-router-key>" ANTHROPIC_BASE_URL="http://127.0.0.1:3000" claude'
+alias clodedev='ANTHROPIC_AUTH_TOKEN="<your-router-key>" ANTHROPIC_BASE_URL="http://127.0.0.1:9981" claude'
 ```
 
 **方式二：~/.claude/settings.json**
@@ -68,7 +68,7 @@ alias clodedev='ANTHROPIC_AUTH_TOKEN="<your-router-key>" ANTHROPIC_BASE_URL="htt
 {
   "env": {
     "ANTHROPIC_AUTH_TOKEN": "sk-router-change-me",
-    "ANTHROPIC_BASE_URL": "http://127.0.0.1:3000",
+    "ANTHROPIC_BASE_URL": "http://127.0.0.1:9981",
     "ANTHROPIC_MODEL": "some-model"
   }
 }
@@ -90,14 +90,13 @@ alias clodedev='ANTHROPIC_AUTH_TOKEN="<your-router-key>" ANTHROPIC_BASE_URL="htt
 ## 快速开始
 
 ```bash
-npm install
-cp .env.example .env
-# 编辑 .env，设置 ADMIN_PASSWORD、ENCRYPTION_KEY、JWT_SECRET
-npm run dev
-# 访问 http://localhost:3000/admin
+# 一行命令启动
+npx llm-simple-router
+# 访问 http://localhost:9981/admin
+# 首次访问会进入 Setup 页面设置管理员密码
 ```
 
-生成随机密钥：`openssl rand -hex 32`
+无需任何环境变量。数据默认存储在 `~/.llm-simple-router/`。
 
 ## Docker 部署
 
@@ -107,15 +106,14 @@ docker compose up -d
 
 ## 环境变量
 
+所有密钥（管理员密码、加密密钥、JWT 密钥）通过首次启动的 Setup 页面设置，无需环境变量。
+
 | 变量 | 必需 | 默认值 | 说明 |
 |------|------|--------|------|
-| `ADMIN_PASSWORD` | Yes | -- | 管理后台密码 |
-| `ENCRYPTION_KEY` | Yes | -- | AES-256-GCM 密钥（64字符 hex） |
-| `JWT_SECRET` | Yes | -- | JWT 签名密钥（64字符 hex） |
-| `PORT` | No | `3000` | 服务端口 |
-| `DB_PATH` | No | `./data/router.db` | SQLite 数据库路径 |
+| `PORT` | No | `9981` | 服务端口 |
+| `DB_PATH` | No | `~/.llm-simple-router/router.db` | SQLite 数据库路径 |
 | `LOG_LEVEL` | No | `info` | 日志级别 |
-| `TZ` | No | -- | 时区设置 |
+| `TZ` | No | `Asia/Shanghai` | 时区设置 |
 | `STREAM_TIMEOUT_MS` | No | `3000000` | 流式代理空闲超时（ms） |
 | `RETRY_MAX_ATTEMPTS` | No | `3` | 最大重试次数 |
 | `RETRY_BASE_DELAY_MS` | No | `1000` | 重试基础延迟（ms） |

package/dist/admin/groups.js

@@ -2,6 +2,7 @@ import { Type } from "@sinclair/typebox";
 import { getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, getProviderById, getMappingGroupById, } from "../db/index.js";
 import { STRATEGY_NAMES } from "../proxy/strategy/types.js";
 import { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_CONFLICT } from "./constants.js";
+const MIN_FAILOVER_TARGETS = 2;
 const CreateGroupSchema = Type.Object({
     client_model: Type.String({ minLength: 1 }),
     strategy: Type.String({ minLength: 1 }),
@@ -13,6 +14,10 @@ const UpdateGroupSchema = Type.Object({
     rule: Type.Optional(Type.String()),
 });
 async function validateRule(db, strategy, ruleJson) {
+    const VALID_STRATEGIES = new Set(Object.values(STRATEGY_NAMES));
+    if (!VALID_STRATEGIES.has(strategy)) {
+        return `Unknown strategy '${strategy}'. Valid: ${[...VALID_STRATEGIES].join(", ")}`;
+    }
     let rule;
     try {
         rule = JSON.parse(ruleJson);
@@ -45,6 +50,26 @@ async function validateRule(db, strategy, ruleJson) {
             }
         }
     }
+    if (strategy === STRATEGY_NAMES.ROUND_ROBIN || strategy === STRATEGY_NAMES.RANDOM || strategy === STRATEGY_NAMES.FAILOVER) {
+        const r = rule;
+        if (!Array.isArray(r.targets) || r.targets.length === 0) {
+            return "rule.targets must be a non-empty array";
+        }
+        const minTargets = strategy === STRATEGY_NAMES.FAILOVER ? MIN_FAILOVER_TARGETS : 1;
+        if (r.targets.length < minTargets) {
+            return `strategy '${strategy}' requires at least ${minTargets} target(s)`;
+        }
+        for (let i = 0; i < r.targets.length; i++) {
+            const t = r.targets[i];
+            if (!t.backend_model || !t.provider_id) {
+                return `targets[${i}] missing backend_model or provider_id`;
+            }
+            const p = getProviderById(db, t.provider_id);
+            if (!p) {
+                return `targets[${i}] provider_id '${t.provider_id}' not found`;
+            }
+        }
+    }
     return undefined;
 }
 export const adminGroupRoutes = (app, options, done) => {

package/dist/admin/monitor.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+import type { RequestTracker } from "../monitor/request-tracker.js";
+interface MonitorRoutesOptions {
+    tracker?: RequestTracker;
+}
+export declare const adminMonitorRoutes: FastifyPluginCallback<MonitorRoutesOptions>;
+export {};

package/dist/admin/monitor.js

@@ -0,0 +1,25 @@
+const HTTP_OK = 200;
+export const adminMonitorRoutes = (app, options, done) => {
+    const { tracker } = options;
+    if (!tracker) {
+        done();
+        return;
+    }
+    app.get("/admin/api/monitor/active", async () => tracker.getActive());
+    app.get("/admin/api/monitor/recent", async () => tracker.getRecent());
+    app.get("/admin/api/monitor/stats", async () => tracker.getStats());
+    app.get("/admin/api/monitor/concurrency", async () => tracker.getConcurrency());
+    app.get("/admin/api/monitor/runtime", async () => tracker.getRuntime());
+    app.get("/admin/api/monitor/stream", (request, reply) => {
+        reply.raw.writeHead(HTTP_OK, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        tracker.addClient(reply.raw);
+        request.raw.on("close", () => {
+            tracker.removeClient(reply.raw);
+        });
+    });
+    done();
+};

package/dist/admin/providers.d.ts

@@ -1,8 +1,11 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
+import { ProviderSemaphoreManager } from "../proxy/semaphore.js";
+import type { RequestTracker } from "../monitor/request-tracker.js";
 interface ProviderRoutesOptions {
     db: Database.Database;
-    encryptionKey: string;
+    semaphoreManager?: ProviderSemaphoreManager;
+    tracker?: RequestTracker;
 }
 export declare const adminProviderRoutes: FastifyPluginCallback<ProviderRoutesOptions>;
 export {};

package/dist/admin/providers.js

@@ -1,9 +1,11 @@
 import { Type } from "@sinclair/typebox";
-import { getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, getAllMappingGroups } from "../db/index.js";
-import { encrypt } from "../utils/crypto.js";
-import { HTTP_CREATED, HTTP_NOT_FOUND, HTTP_CONFLICT } from "./constants.js";
-const API_KEY_PREVIEW_MIN_LEN = 8;
+import { getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, getAllMappingGroups, PROVIDER_CONCURRENCY_DEFAULTS } from "../db/index.js";
+import { encrypt, decrypt } from "../utils/crypto.js";
+import { getSetting } from "../db/settings.js";
+import { HTTP_CREATED, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_BAD_REQUEST } from "./constants.js";
+const API_KEY_PREVIEW_MIN_LENGTH = 8;
 const API_KEY_PREVIEW_PREFIX_LEN = 4;
+const PROVIDER_NAME_RE = /^[a-zA-Z0-9_-]+$/;
 const CreateProviderSchema = Type.Object({
     name: Type.String({ minLength: 1 }),
     api_type: Type.Union([Type.Literal("openai"), Type.Literal("anthropic")]),
@@ -11,6 +13,9 @@ const CreateProviderSchema = Type.Object({
     api_key: Type.String({ minLength: 1 }),
     models: Type.Optional(Type.Array(Type.String())),
     is_active: Type.Optional(Type.Number()),
+    max_concurrency: Type.Optional(Type.Integer({ minimum: 0 })),
+    queue_timeout_ms: Type.Optional(Type.Integer({ minimum: 0 })),
+    max_queue_size: Type.Optional(Type.Integer({ minimum: 1 })),
 });
 const UpdateProviderSchema = Type.Object({
     name: Type.Optional(Type.String({ minLength: 1 })),
@@ -19,40 +24,59 @@ const UpdateProviderSchema = Type.Object({
     api_key: Type.Optional(Type.String({ minLength: 1 })),
     models: Type.Optional(Type.Array(Type.String())),
     is_active: Type.Optional(Type.Number()),
+    max_concurrency: Type.Optional(Type.Integer({ minimum: 0 })),
+    queue_timeout_ms: Type.Optional(Type.Integer({ minimum: 0 })),
+    max_queue_size: Type.Optional(Type.Integer({ minimum: 1 })),
 });
-function computeApiKeyPreview(apiKey) {
-    if (apiKey.length <= API_KEY_PREVIEW_MIN_LEN)
-        return "****";
-    return `${apiKey.slice(0, API_KEY_PREVIEW_PREFIX_LEN)}...${apiKey.slice(-API_KEY_PREVIEW_PREFIX_LEN)}`;
-}
 export const adminProviderRoutes = (app, options, done) => {
-    const { db, encryptionKey } = options;
+    const { db, semaphoreManager, tracker } = options;
     app.get("/admin/api/providers", async (_request, reply) => {
+        const encryptionKey = getSetting(db, "encryption_key");
         const providers = getAllProviders(db);
         return reply.send(providers.map((s) => ({
             id: s.id,
             name: s.name,
             api_type: s.api_type,
             base_url: s.base_url,
-            api_key_preview: s.api_key_preview || "****",
+            api_key: s.api_key ? decrypt(s.api_key, encryptionKey) : "",
             models: JSON.parse(s.models || "[]"),
             is_active: s.is_active,
+            max_concurrency: s.max_concurrency,
+            queue_timeout_ms: s.queue_timeout_ms,
+            max_queue_size: s.max_queue_size,
+            concurrency_status: semaphoreManager?.getStatus(s.id) ?? { active: 0, queued: 0 },
             created_at: s.created_at,
             updated_at: s.updated_at,
         })));
     });
     app.post("/admin/api/providers", { schema: { body: CreateProviderSchema } }, async (request, reply) => {
         const body = request.body;
-        const encryptedKey = encrypt(body.api_key, encryptionKey);
-        const apiKeyPreview = computeApiKeyPreview(body.api_key);
+        if (!PROVIDER_NAME_RE.test(body.name)) {
+            return reply.status(HTTP_BAD_REQUEST).send({ error: { message: "Provider 名称仅允许英文大小写字母、数字、横线和下划线" } });
+        }
+        const encryptedKey = encrypt(body.api_key, getSetting(db, "encryption_key"));
         const id = createProvider(db, {
             name: body.name,
             api_type: body.api_type,
             base_url: body.base_url,
             api_key: encryptedKey,
-            api_key_preview: apiKeyPreview,
+            api_key_preview: body.api_key.length > API_KEY_PREVIEW_MIN_LENGTH ? `${body.api_key.slice(0, API_KEY_PREVIEW_PREFIX_LEN)}...${body.api_key.slice(-API_KEY_PREVIEW_PREFIX_LEN)}` : "****",
             models: JSON.stringify(body.models ?? []),
             is_active: body.is_active ?? 1,
+            max_concurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
+            queue_timeout_ms: body.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
+            max_queue_size: body.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
+        });
+        semaphoreManager?.updateConfig(id, {
+            maxConcurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
+            queueTimeoutMs: body.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
+            maxQueueSize: body.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
+        });
+        tracker?.updateProviderConfig(id, {
+            name: body.name,
+            maxConcurrency: body.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency,
+            queueTimeoutMs: body.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms,
+            maxQueueSize: body.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size,
         });
         return reply.code(HTTP_CREATED).send({ id });
     });
@@ -63,6 +87,9 @@ export const adminProviderRoutes = (app, options, done) => {
             return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Provider not found" } });
         }
         const body = request.body;
+        if (body.name !== undefined && !PROVIDER_NAME_RE.test(body.name)) {
+            return reply.status(HTTP_BAD_REQUEST).send({ error: { message: "Provider 名称仅允许英文大小写字母、数字、横线和下划线" } });
+        }
         const fields = {};
         if (body.name !== undefined)
             fields.name = body.name;
@@ -74,11 +101,31 @@ export const adminProviderRoutes = (app, options, done) => {
             fields.is_active = body.is_active;
         if (body.models !== undefined)
             fields.models = JSON.stringify(body.models);
+        if (body.max_concurrency !== undefined)
+            fields.max_concurrency = body.max_concurrency;
+        if (body.queue_timeout_ms !== undefined)
+            fields.queue_timeout_ms = body.queue_timeout_ms;
+        if (body.max_queue_size !== undefined)
+            fields.max_queue_size = body.max_queue_size;
         if (body.api_key) {
-            fields.api_key = encrypt(body.api_key, encryptionKey);
-            fields.api_key_preview = computeApiKeyPreview(body.api_key);
+            fields.api_key = encrypt(body.api_key, getSetting(db, "encryption_key"));
+            fields.api_key_preview = body.api_key.length > API_KEY_PREVIEW_MIN_LENGTH ? `${body.api_key.slice(0, API_KEY_PREVIEW_PREFIX_LEN)}...${body.api_key.slice(-API_KEY_PREVIEW_PREFIX_LEN)}` : "****";
         }
         updateProvider(db, id, fields);
+        const updated = getProviderById(db, id);
+        if (body.max_concurrency !== undefined || body.queue_timeout_ms !== undefined || body.max_queue_size !== undefined) {
+            semaphoreManager?.updateConfig(id, {
+                maxConcurrency: updated.max_concurrency,
+                queueTimeoutMs: updated.queue_timeout_ms,
+                maxQueueSize: updated.max_queue_size,
+            });
+        }
+        tracker?.updateProviderConfig(id, {
+            name: body.name ?? existing.name,
+            maxConcurrency: updated.max_concurrency,
+            queueTimeoutMs: updated.queue_timeout_ms,
+            maxQueueSize: updated.max_queue_size,
+        });
         return reply.send({ success: true });
     });
     app.delete("/admin/api/providers/:id", async (request, reply) => {
@@ -92,9 +139,13 @@ export const adminProviderRoutes = (app, options, done) => {
                     return reply.code(HTTP_CONFLICT).send({ error: { message: `Provider is referenced by mapping group '${g.client_model}'` } });
                 }
             }
-            catch { /* rule format invalid, skip */ }
+            catch {
+                continue;
+            }
         }
         deleteProvider(db, id);
+        semaphoreManager?.remove(id);
+        tracker?.removeProviderConfig(id);
         return reply.send({ success: true });
     });
     done();

package/dist/admin/proxy-enhancement.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface ProxyEnhancementOptions {
+    db: Database.Database;
+}
+export declare const adminProxyEnhancementRoutes: FastifyPluginCallback<ProxyEnhancementOptions>;
+export {};

package/dist/admin/proxy-enhancement.js

@@ -0,0 +1,39 @@
+import { getSetting, setSetting } from "../db/settings.js";
+import { getSessionStates, getSessionHistory, } from "../db/session-states.js";
+import { modelState } from "../proxy/model-state.js";
+export const adminProxyEnhancementRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/proxy-enhancement", async (_req, reply) => {
+        const raw = getSetting(db, "proxy_enhancement");
+        const config = raw
+            ? JSON.parse(raw)
+            : { claude_code_enabled: false };
+        return reply.send(config);
+    });
+    app.put("/admin/api/proxy-enhancement", async (req, reply) => {
+        const body = req.body;
+        if (typeof body.claude_code_enabled !== "boolean") {
+            return reply.status(400).send({ error: "claude_code_enabled must be a boolean" }); // eslint-disable-line no-magic-numbers
+        }
+        const config = {
+            claude_code_enabled: body.claude_code_enabled,
+        };
+        setSetting(db, "proxy_enhancement", JSON.stringify(config));
+        return reply.send({ success: true });
+    });
+    app.get("/admin/api/session-states", async (_req, reply) => {
+        const states = getSessionStates(db);
+        return reply.send(states);
+    });
+    app.get("/admin/api/session-states/:keyId/:sessionId/history", async (req, reply) => {
+        const { keyId, sessionId } = req.params;
+        const history = getSessionHistory(db, keyId, sessionId);
+        return reply.send(history);
+    });
+    app.delete("/admin/api/session-states/:keyId/:sessionId", async (req, reply) => {
+        const { keyId, sessionId } = req.params;
+        modelState.delete(keyId, sessionId);
+        return reply.send({ success: true });
+    });
+    done();
+};

package/dist/admin/retry-rules.js

@@ -1,6 +1,9 @@
 import { Type } from "@sinclair/typebox";
 import { getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, } from "../db/index.js";
 import { HTTP_BAD_REQUEST, HTTP_CREATED } from "./constants.js";
+const DEFAULT_RETRY_DELAY_MS = 5000;
+const DEFAULT_MAX_RETRIES = 10;
+const DEFAULT_MAX_DELAY_MS = 60000;
 const CreateRetryRuleSchema = Type.Object({
     name: Type.String({ minLength: 1 }),
     status_code: Type.Number({ minimum: 100, maximum: 599 }),
@@ -52,9 +55,9 @@ export const adminRetryRuleRoutes = (app, options, done) => {
             body_pattern: body.body_pattern,
             is_active: body.is_active ?? 1,
             retry_strategy: body.retry_strategy ?? "exponential",
-            retry_delay_ms: body.retry_delay_ms ?? 5000,
-            max_retries: body.max_retries ?? 10,
-            max_delay_ms: body.max_delay_ms ?? 60000,
+            retry_delay_ms: body.retry_delay_ms ?? DEFAULT_RETRY_DELAY_MS,
+            max_retries: body.max_retries ?? DEFAULT_MAX_RETRIES,
+            max_delay_ms: body.max_delay_ms ?? DEFAULT_MAX_DELAY_MS,
         });
         refreshMatcher(matcher, db);
         return reply.code(HTTP_CREATED).send({ id });

package/dist/admin/router-keys.d.ts

@@ -2,7 +2,6 @@ import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 interface RouterKeyRoutesOptions {
     db: Database.Database;
-    encryptionKey: string;
 }
 export declare const adminRouterKeyRoutes: FastifyPluginCallback<RouterKeyRoutesOptions>;
 export {};

package/dist/admin/router-keys.js

@@ -2,10 +2,18 @@ import { randomBytes, createHash } from "crypto";
 import { Type } from "@sinclair/typebox";
 import { encrypt, decrypt } from "../utils/crypto.js";
 import { getAllRouterKeys, getRouterKeyById, createRouterKey, updateRouterKey, deleteRouterKey, getAvailableModels, } from "../db/index.js";
+import { getSetting } from "../db/settings.js";
 const HTTP_CREATED = 201;
 const HTTP_NOT_FOUND = 404;
 const KEY_RANDOM_BYTES = 32;
 const KEY_PREFIX_LENGTH = 8;
+/** 归一化 allowed_models：null/空数组/仅含空字符串 → null（允许所有模型） */
+function normalizeAllowedModels(val) {
+    if (!val)
+        return null;
+    const filtered = val.filter((m) => m.trim() !== "");
+    return filtered.length > 0 ? JSON.stringify(filtered) : null;
+}
 const CreateRouterKeySchema = Type.Object({
     name: Type.String({ minLength: 1 }),
     allowed_models: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Null()])),
@@ -15,14 +23,15 @@ const UpdateRouterKeySchema = Type.Object({
     allowed_models: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Null()])),
     is_active: Type.Optional(Type.Number()),
 });
-function generateRouterKey(encryptionKey) {
+function generateRouterKey(db) {
     const key = `sk-router-${randomBytes(KEY_RANDOM_BYTES).toString("hex")}`;
     const hash = createHash("sha256").update(key).digest("hex");
     const prefix = key.slice(0, KEY_PREFIX_LENGTH);
-    const encrypted = encrypt(key, encryptionKey);
+    const encrypted = encrypt(key, getSetting(db, "encryption_key"));
     return { key, hash, prefix, encrypted };
 }
-function toPublicRouterKey(rk, encryptionKey) {
+function toPublicRouterKey(rk, db) {
+    const encryptionKey = getSetting(db, "encryption_key");
     return {
         id: rk.id,
         name: rk.name,
@@ -35,15 +44,15 @@ function toPublicRouterKey(rk, encryptionKey) {
     };
 }
 export const adminRouterKeyRoutes = (app, options, done) => {
-    const { db, encryptionKey } = options;
+    const { db } = options;
     app.get("/admin/api/router-keys", async (_request, reply) => {
         const keys = getAllRouterKeys(db);
-        return reply.send(keys.map((rk) => toPublicRouterKey(rk, encryptionKey)));
+        return reply.send(keys.map((rk) => toPublicRouterKey(rk, db)));
     });
     app.post("/admin/api/router-keys", { schema: { body: CreateRouterKeySchema } }, async (request, reply) => {
         const body = request.body;
-        const { key, hash, prefix, encrypted } = generateRouterKey(encryptionKey);
-        const allowedModels = body.allowed_models ? JSON.stringify(body.allowed_models) : null;
+        const { key, hash, prefix, encrypted } = generateRouterKey(db);
+        const allowedModels = normalizeAllowedModels(body.allowed_models);
         const id = createRouterKey(db, { name: body.name, key_hash: hash, key_prefix: prefix, key_encrypted: encrypted, allowed_models: allowedModels });
         return reply.code(HTTP_CREATED).send({
             id,
@@ -66,7 +75,7 @@ export const adminRouterKeyRoutes = (app, options, done) => {
         if (body.name !== undefined)
             fields.name = body.name;
         if (body.allowed_models !== undefined)
-            fields.allowed_models = JSON.stringify(body.allowed_models);
+            fields.allowed_models = normalizeAllowedModels(body.allowed_models);
         if (body.is_active !== undefined)
             fields.is_active = body.is_active;
         updateRouterKey(db, id, fields);

package/dist/admin/routes.d.ts

@@ -1,12 +1,13 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
 import { RetryRuleMatcher } from "../proxy/retry-rules.js";
+import type { RequestTracker } from "../monitor/request-tracker.js";
+import { ProviderSemaphoreManager } from "../proxy/semaphore.js";
 interface AdminRoutesOptions {
     db: Database.Database;
-    adminPassword: string;
-    jwtSecret: string;
-    encryptionKey: string;
     matcher: RetryRuleMatcher | null;
+    tracker?: RequestTracker;
+    semaphoreManager?: ProviderSemaphoreManager;
 }
 export declare const adminRoutes: FastifyPluginCallback<AdminRoutesOptions>;
 export {};

package/dist/admin/routes.js

@@ -6,17 +6,24 @@ import { adminRetryRuleRoutes } from "./retry-rules.js";
 import { adminLogRoutes } from "./logs.js";
 import { adminStatsRoutes } from "./stats.js";
 import { adminMetricsRoutes } from "./metrics.js";
+import { adminProxyEnhancementRoutes } from "./proxy-enhancement.js";
 import { adminRouterKeyRoutes } from "./router-keys.js";
+import { adminSetupRoutes } from "./setup.js";
+import { adminMonitorRoutes } from "./monitor.js";
 export const adminRoutes = (app, options, done) => {
-    app.register(adminAuthPlugin, { adminPassword: options.adminPassword, jwtSecret: options.jwtSecret });
-    app.register(adminLoginRoutes, { adminPassword: options.adminPassword, jwtSecret: options.jwtSecret });
-    app.register(adminProviderRoutes, { db: options.db, encryptionKey: options.encryptionKey });
+    // Setup 路由不需要 auth
+    app.register(adminSetupRoutes, { db: options.db });
+    app.register(adminAuthPlugin, { db: options.db });
+    app.register(adminLoginRoutes, { db: options.db });
+    app.register(adminProviderRoutes, { db: options.db, semaphoreManager: options.semaphoreManager, tracker: options.tracker });
     app.register(adminMappingRoutes, { db: options.db });
     app.register(adminGroupRoutes, { db: options.db });
     app.register(adminRetryRuleRoutes, { db: options.db, matcher: options.matcher });
     app.register(adminLogRoutes, { db: options.db });
-    app.register(adminRouterKeyRoutes, { db: options.db, encryptionKey: options.encryptionKey });
+    app.register(adminRouterKeyRoutes, { db: options.db });
     app.register(adminStatsRoutes, { db: options.db });
     app.register(adminMetricsRoutes, { db: options.db });
+    app.register(adminProxyEnhancementRoutes, { db: options.db });
+    app.register(adminMonitorRoutes, { tracker: options.tracker });
     done();
 };

package/dist/admin/setup.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface SetupOptions {
+    db: Database.Database;
+}
+export declare const adminSetupRoutes: FastifyPluginCallback<SetupOptions>;
+export {};

package/dist/admin/setup.js

@@ -0,0 +1,47 @@
+import { randomBytes } from "node:crypto";
+import jwt from "jsonwebtoken";
+import { getSetting, setSetting, isInitialized } from "../db/settings.js";
+import { hashPassword } from "../utils/password.js";
+import { HTTP_BAD_REQUEST, HTTP_CONFLICT } from "./constants.js";
+const CRYPTO_BYTES_LENGTH = 32;
+const MIN_PASSWORD_LENGTH = 6;
+export const adminSetupRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/setup/status", async () => {
+        return { initialized: isInitialized(db) };
+    });
+    app.post("/admin/api/setup/initialize", async (request, reply) => {
+        const { password } = request.body;
+        if (!password || password.length < MIN_PASSWORD_LENGTH) {
+            return reply.code(HTTP_BAD_REQUEST).send({ error: { message: `Password must be at least ${MIN_PASSWORD_LENGTH} characters` } });
+        }
+        // 事务中原子检查防竞态
+        const alreadyInitialized = db.transaction(() => {
+            if (isInitialized(db))
+                return true;
+            const encryptionKey = randomBytes(CRYPTO_BYTES_LENGTH).toString("hex");
+            const jwtSecret = randomBytes(CRYPTO_BYTES_LENGTH).toString("hex");
+            setSetting(db, "admin_password_hash", hashPassword(password));
+            setSetting(db, "encryption_key", encryptionKey);
+            setSetting(db, "jwt_secret", jwtSecret);
+            setSetting(db, "initialized", "true");
+            return false;
+        })();
+        if (alreadyInitialized) {
+            return reply.code(HTTP_CONFLICT).send({ error: { message: "Already initialized" } });
+        }
+        // 自动登录：签发 JWT
+        const TOKEN_EXPIRY_SECONDS = 172800; // 48 hours，与 admin-auth 保持一致
+        const secret = getSetting(db, "jwt_secret");
+        const token = jwt.sign({ role: "admin" }, secret, { expiresIn: TOKEN_EXPIRY_SECONDS });
+        reply.setCookie("admin_token", token, {
+            path: "/admin",
+            httpOnly: true,
+            secure: process.env.NODE_ENV === "production",
+            sameSite: "lax",
+            maxAge: TOKEN_EXPIRY_SECONDS,
+        });
+        return { success: true };
+    });
+    done();
+};

package/dist/config.d.ts

@@ -1,8 +1,4 @@
-import "dotenv/config";
 export interface Config {
-    ADMIN_PASSWORD: string;
-    ENCRYPTION_KEY: string;
-    JWT_SECRET: string;
     PORT: number;
     DB_PATH: string;
     LOG_LEVEL: string;
@@ -12,4 +8,5 @@ export interface Config {
     RETRY_BASE_DELAY_MS: number;
 }
 export declare function resetConfig(): void;
+export declare function getBaseConfig(): Config;
 export declare function getConfig(): Config;

package/dist/config.js

@@ -1,23 +1,20 @@
-import "dotenv/config";
+import { homedir } from "node:os";
+import { join } from "node:path";
 let cachedConfig = null;
+function getDefaultDbPath() {
+    if (process.env.DB_PATH)
+        return process.env.DB_PATH;
+    return join(homedir(), ".llm-simple-router", "router.db");
+}
 export function resetConfig() {
     cachedConfig = null;
 }
-export function getConfig() {
+export function getBaseConfig() {
     if (cachedConfig)
         return cachedConfig;
-    const requiredVars = ["ADMIN_PASSWORD", "ENCRYPTION_KEY", "JWT_SECRET"];
-    for (const name of requiredVars) {
-        if (!process.env[name]) {
-            throw new Error(`Missing required environment variable: ${name}`);
-        }
-    }
     cachedConfig = {
-        ADMIN_PASSWORD: process.env.ADMIN_PASSWORD,
-        ENCRYPTION_KEY: process.env.ENCRYPTION_KEY,
-        JWT_SECRET: process.env.JWT_SECRET,
-        PORT: parseInt(process.env.PORT || "3000", 10),
-        DB_PATH: process.env.DB_PATH || "./data/router.db",
+        PORT: parseInt(process.env.PORT || "9981", 10),
+        DB_PATH: getDefaultDbPath(),
         LOG_LEVEL: process.env.LOG_LEVEL || "info",
         TZ: process.env.TZ || "Asia/Shanghai",
         STREAM_TIMEOUT_MS: parseInt(process.env.STREAM_TIMEOUT_MS || "3000000", 10),
@@ -26,3 +23,6 @@ export function getConfig() {
     };
     return cachedConfig;
 }
+export function getConfig() {
+    return getBaseConfig();
+}

package/dist/db/index.d.ts

@@ -1,9 +1,9 @@
 import Database from "better-sqlite3";
 export declare function initDatabase(dbPath: string): Database.Database;
-export { getActiveProviders, getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, } from "./providers.js";
+export { getActiveProviders, getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, PROVIDER_CONCURRENCY_DEFAULTS, } from "./providers.js";
 export type { Provider } from "./providers.js";
-export { getModelMapping, getAllModelMappings, createModelMapping, updateModelMapping, deleteModelMapping, getMappingGroup, getMappingGroupById, getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, } from "./mappings.js";
-export type { ModelMapping, MappingGroup } from "./mappings.js";
+export { getModelMapping, getAllModelMappings, createModelMapping, updateModelMapping, deleteModelMapping, getMappingGroup, getMappingGroupById, getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, getActiveProviderModels, resolveByProviderModel, } from "./mappings.js";
+export type { ModelMapping, MappingGroup, ProviderModelEntry } from "./mappings.js";
 export { getActiveRetryRules, getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, seedDefaultRules, } from "./retry-rules.js";
 export type { RetryRule } from "./retry-rules.js";
 export { insertRequestLog, getRequestLogs, getRequestLogById, deleteLogsBefore, insertMetrics, } from "./logs.js";
@@ -14,3 +14,6 @@ export { getMetricsSummary, getMetricsTimeseries } from "./metrics.js";
 export type { MetricsSummaryRow, MetricsTimeseriesRow, MetricsPeriod, MetricsMetric } from "./metrics.js";
 export { getStats } from "./stats.js";
 export type { Stats, StatsPeriod } from "./stats.js";
+export { getSetting, setSetting, isInitialized } from "./settings.js";
+export { getSessionStates, getSessionState, getSessionHistory, upsertSessionState, insertSessionHistory, deleteSessionState, } from "./session-states.js";
+export type { SessionModelState, SessionModelHistory, UpsertSessionStateInput, InsertSessionHistoryInput } from "./session-states.js";