@archimonde12/llm-proxy 1.0.0

package/dist/admin/configStore.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPathWritableAsFile = isPathWritableAsFile;
+exports.resolveWriteTarget = resolveWriteTarget;
+exports.parseModelsFileJson = parseModelsFileJson;
+exports.writeModelsFileAtomic = writeModelsFileAtomic;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../config/paths");
+const schema_1 = require("../config/schema");
+async function isPathWritableAsFile(filePath) {
+    try {
+        await (0, promises_1.access)(filePath);
+        try {
+            await (0, promises_1.access)(filePath, node_fs_1.constants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    catch {
+        const parent = node_path_1.default.dirname(filePath);
+        try {
+            await (0, promises_1.access)(parent, node_fs_1.constants.W_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * If the loaded config file path is writable (or can be created), use it.
+ * Otherwise fall back to ~/.config/llm-proxy/models.json.
+ */
+async function resolveWriteTarget(loadedFrom) {
+    const abs = node_path_1.default.resolve(loadedFrom);
+    if (await isPathWritableAsFile(abs)) {
+        return { writeTarget: abs, usedAlternate: false };
+    }
+    return { writeTarget: (0, paths_1.defaultUserModelsPath)(), usedAlternate: true };
+}
+function parseModelsFileJson(raw) {
+    const res = schema_1.ModelsFileSchema.safeParse(raw);
+    if (!res.success) {
+        return {
+            ok: false,
+            issues: res.error.issues.map((i) => ({
+                path: pathToString(i.path),
+                message: i.message,
+            })),
+        };
+    }
+    return { ok: true, data: res.data };
+}
+function pathToString(p) {
+    if (!p.length)
+        return "<root>";
+    let out = "";
+    for (const seg of p) {
+        if (typeof seg === "number")
+            out += `[${seg}]`;
+        else
+            out += out ? `.${seg}` : String(seg);
+    }
+    return out;
+}
+async function writeModelsFileAtomic(filePath, data) {
+    const abs = node_path_1.default.resolve(filePath);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(abs), { recursive: true });
+    const tmp = `${abs}.${process.pid}.${Date.now()}.tmp`;
+    const json = `${JSON.stringify(data, null, 2)}\n`;
+    await (0, promises_1.writeFile)(tmp, json, "utf8");
+    await (0, promises_1.rename)(tmp, abs);
+}

package/dist/admin/envStore.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDotenvPath = resolveDotenvPath;
+exports.listEnvKeys = listEnvKeys;
+exports.listKeysInDotenvFile = listKeysInDotenvFile;
+exports.listEntriesInDotenvFile = listEntriesInDotenvFile;
+exports.applyEnvUpdates = applyEnvUpdates;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const ENV_KEY_RE = /^[A-Z0-9_]+$/;
+function resolveDotenvPath() {
+    const configured = (process.env.DOTENV_CONFIG_PATH ?? "").trim();
+    if (configured)
+        return { path: node_path_1.default.resolve(configured), source: "DOTENV_CONFIG_PATH" };
+    return { path: node_path_1.default.resolve(process.cwd(), ".env"), source: "cwd" };
+}
+function listEnvKeys() {
+    const keys = Object.keys(process.env ?? {}).filter((k) => ENV_KEY_RE.test(k));
+    keys.sort();
+    return keys;
+}
+/** Keys declared in the dotenv file (names only; no values). Missing file → []. */
+async function listKeysInDotenvFile(dotenvPath) {
+    const entries = await listEntriesInDotenvFile(dotenvPath);
+    const keys = entries.map((e) => e.key);
+    keys.sort();
+    return keys;
+}
+/** Key/value pairs from the dotenv file (localhost admin only). */
+async function listEntriesInDotenvFile(dotenvPath) {
+    let existing = "";
+    try {
+        existing = await promises_1.default.readFile(node_path_1.default.resolve(dotenvPath), "utf8");
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const parsed = parseEnvLines(existing);
+    const out = [];
+    for (const line of parsed) {
+        if (line.kind === "kv" && ENV_KEY_RE.test(line.key)) {
+            out.push({ key: line.key, value: line.value });
+        }
+    }
+    return out;
+}
+function parseEnvLines(raw) {
+    const lines = raw.split(/\r?\n/);
+    const out = [];
+    for (const line of lines) {
+        const m = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/.exec(line);
+        if (!m) {
+            out.push({ kind: "other", raw: line });
+            continue;
+        }
+        const rawKey = m[1] ?? "";
+        const key = rawKey.trim();
+        const value = m[2] ?? "";
+        out.push({ kind: "kv", key, rawKey, value, raw: line });
+    }
+    return out;
+}
+function normalizeEnvValue(v) {
+    // Keep as-is (no quoting rules). UI will paste raw tokens.
+    return String(v);
+}
+async function applyEnvUpdates(args) {
+    const abs = node_path_1.default.resolve(args.dotenvPath);
+    const updates = args.updates;
+    for (const u of updates) {
+        if (!ENV_KEY_RE.test(u.key)) {
+            throw Object.assign(new Error(`Invalid env key '${u.key}'. Use A-Z0-9_ only.`), { statusCode: 400 });
+        }
+    }
+    let existing = "";
+    try {
+        existing = await promises_1.default.readFile(abs, "utf8");
+    }
+    catch (err) {
+        if (err?.code !== "ENOENT")
+            throw err;
+        existing = "";
+    }
+    const parsed = parseEnvLines(existing);
+    const updateMap = new Map();
+    for (const u of updates)
+        updateMap.set(u.key, u.value == null ? null : normalizeEnvValue(u.value));
+    const seen = new Set();
+    const nextLines = [];
+    for (const line of parsed) {
+        if (line.kind !== "kv") {
+            nextLines.push(line.raw);
+            continue;
+        }
+        if (!ENV_KEY_RE.test(line.key)) {
+            // Preserve non-standard keys untouched.
+            nextLines.push(line.raw);
+            continue;
+        }
+        if (!updateMap.has(line.key)) {
+            nextLines.push(line.raw);
+            continue;
+        }
+        seen.add(line.key);
+        const nextVal = updateMap.get(line.key);
+        if (nextVal == null) {
+            // delete: skip line
+            continue;
+        }
+        nextLines.push(`${line.key}=${nextVal}`);
+    }
+    // Append new keys (not present in file)
+    const toAppend = [];
+    for (const [k, v] of updateMap) {
+        if (seen.has(k))
+            continue;
+        if (v == null)
+            continue;
+        toAppend.push(`${k}=${v}`);
+    }
+    if (toAppend.length) {
+        if (nextLines.length && nextLines[nextLines.length - 1] !== "")
+            nextLines.push("");
+        nextLines.push(...toAppend);
+    }
+    const finalText = `${nextLines.join("\n").replace(/\n+$/, "")}\n`;
+    await promises_1.default.mkdir(node_path_1.default.dirname(abs), { recursive: true });
+    await promises_1.default.writeFile(abs, finalText, "utf8");
+    // Apply to runtime env without restart
+    const changedKeys = [];
+    for (const [k, v] of updateMap) {
+        if (v == null) {
+            if (k in process.env)
+                changedKeys.push(k);
+            delete process.env[k];
+        }
+        else {
+            if (process.env[k] !== v)
+                changedKeys.push(k);
+            process.env[k] = v;
+        }
+    }
+    return { writtenTo: abs, changedKeys };
+}

package/dist/admin/routes.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAdminRoutes = registerAdminRoutes;
+const zod_1 = require("zod");
+const load_1 = require("../config/load");
+const configStore_1 = require("./configStore");
+const auth_1 = require("./auth");
+const summary_1 = require("../observability/summary");
+const config_1 = require("../config");
+const upstreamProbe_1 = require("../upstreamProbe");
+const envStore_1 = require("./envStore");
+function parseRange(raw) {
+    const v = String(raw ?? "").trim();
+    if (v === "15m")
+        return { ok: true, ms: 15 * 60_000, label: "15m" };
+    if (v === "1h")
+        return { ok: true, ms: 60 * 60_000, label: "1h" };
+    if (v === "24h")
+        return { ok: true, ms: 24 * 60 * 60_000, label: "24h" };
+    return { ok: false };
+}
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return null;
+    const idx = Math.max(0, Math.min(sorted.length - 1, Math.ceil(p * sorted.length) - 1));
+    return sorted[idx] ?? null;
+}
+const TestBodySchema = zod_1.z.union([
+    zod_1.z.object({ modelId: zod_1.z.string().min(1) }),
+    zod_1.z.object({
+        adapter: zod_1.z.enum(["ollama", "openai_compatible", "deepseek"]),
+        baseUrl: zod_1.z.string().min(1),
+        model: zod_1.z.string().min(1),
+        timeoutMs: zod_1.z.number().int().positive().max(60_000).optional(),
+        apiKey: zod_1.z.string().optional(),
+        apiKeyHeader: zod_1.z.string().optional(),
+        headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+    }),
+]);
+async function registerAdminRoutes(app, ctx) {
+    const guard = async (req, reply) => {
+        if (!ctx.enforceLocalhost)
+            return;
+        if (!(0, auth_1.isLocalhostRequest)(req))
+            return (0, auth_1.sendForbiddenNonLocal)(reply);
+    };
+    app.get("/admin/env", { preHandler: guard }, async () => {
+        const r = (0, envStore_1.resolveDotenvPath)();
+        const [keysInDotenvFile, dotenvEntries] = await Promise.all([
+            (0, envStore_1.listKeysInDotenvFile)(r.path),
+            (0, envStore_1.listEntriesInDotenvFile)(r.path),
+        ]);
+        return {
+            keys: (0, envStore_1.listEnvKeys)(),
+            keysInDotenvFile,
+            dotenvEntries,
+            dotenvPath: r.path,
+            dotenvSource: r.source,
+        };
+    });
+    app.put("/admin/env", { preHandler: guard }, async (req, reply) => {
+        const Body = zod_1.z.object({
+            updates: zod_1.z.array(zod_1.z.object({
+                key: zod_1.z.string().min(1),
+                value: zod_1.z.union([zod_1.z.string(), zod_1.z.null()]),
+            })),
+        });
+        const parsed = Body.safeParse(req.body);
+        if (!parsed.success) {
+            reply.code(400);
+            return {
+                error: {
+                    message: "Invalid body",
+                    issues: parsed.error.issues.map((i) => ({
+                        path: i.path.join("."),
+                        message: i.message,
+                    })),
+                },
+            };
+        }
+        const r = (0, envStore_1.resolveDotenvPath)();
+        try {
+            const result = await (0, envStore_1.applyEnvUpdates)({
+                dotenvPath: r.path,
+                updates: parsed.data.updates,
+            });
+            return {
+                ok: true,
+                writtenTo: result.writtenTo,
+                changedKeys: result.changedKeys,
+                note: "Runtime process.env was updated; if your config references ${ENV_VAR}, call /admin/reload to re-resolve.",
+            };
+        }
+        catch (err) {
+            const statusCode = typeof err?.statusCode === "number" ? err.statusCode : 500;
+            reply.code(statusCode);
+            return { error: { message: err?.message ?? String(err) } };
+        }
+    });
+    app.get("/admin/health", { preHandler: guard }, async () => ({
+        ok: true,
+        version: ctx.packageVersion,
+        ui: true,
+        activeConfigPath: ctx.state.activeConfigPath,
+    }));
+    app.get("/admin/config", { preHandler: guard }, async () => {
+        const wt = await (0, configStore_1.resolveWriteTarget)(ctx.state.activeConfigPath);
+        let config = ctx.state.modelsFile;
+        try {
+            config = await (0, load_1.loadModelsFileFromPathAsStored)(ctx.state.activeConfigPath);
+        }
+        catch {
+            // Fall back to in-memory config if the file is unreadable (should be rare).
+        }
+        return {
+            config,
+            loadedFromPath: ctx.state.activeConfigPath,
+            writeTarget: wt.writeTarget,
+            usedAlternateWritePath: wt.usedAlternate,
+            configSource: ctx.state.bootstrapSource.kind,
+            configGeneration: ctx.state.configGeneration,
+        };
+    });
+    app.put("/admin/config", { preHandler: guard }, async (req, reply) => {
+        const raw = req.body;
+        const parsed = (0, configStore_1.parseModelsFileJson)(raw);
+        if (!parsed.ok) {
+            reply.code(400);
+            return { error: { message: "Validation failed", issues: parsed.issues } };
+        }
+        const wt = await (0, configStore_1.resolveWriteTarget)(ctx.state.activeConfigPath);
+        try {
+            await (0, configStore_1.writeModelsFileAtomic)(wt.writeTarget, parsed.data);
+        }
+        catch (err) {
+            reply.code(500);
+            return {
+                error: {
+                    message: `Failed to write config: ${err?.message ?? String(err)}`,
+                },
+            };
+        }
+        ctx.state.activeConfigPath = wt.writeTarget;
+        ctx.state.configGeneration++;
+        try {
+            ctx.state.modelsFile = await (0, load_1.loadModelsFileFromPath)(wt.writeTarget);
+        }
+        catch {
+            ctx.state.modelsFile = parsed.data;
+        }
+        return {
+            ok: true,
+            writtenTo: wt.writeTarget,
+            usedAlternateWritePath: wt.usedAlternate,
+            configGeneration: ctx.state.configGeneration,
+            hint: wt.usedAlternate
+                ? "Config was written to the managed path because the previous location was not writable. Point MODELS_PATH or --models to this file if you want the CLI to use it."
+                : undefined,
+        };
+    });
+    app.post("/admin/reload", { preHandler: guard }, async (_req, reply) => {
+        let mf;
+        try {
+            mf = await (0, load_1.loadModelsFileFromPath)(ctx.state.activeConfigPath);
+        }
+        catch (err) {
+            reply.code(500);
+            return { error: { message: err?.message ?? String(err) } };
+        }
+        ctx.state.modelsFile = mf;
+        ctx.state.configGeneration++;
+        return {
+            ok: true,
+            activeConfigPath: ctx.state.activeConfigPath,
+            configGeneration: ctx.state.configGeneration,
+        };
+    });
+    app.post("/admin/test-connection", { preHandler: guard }, async (req, reply) => {
+        const parsed = TestBodySchema.safeParse(req.body);
+        if (!parsed.success) {
+            reply.code(400);
+            return {
+                error: {
+                    message: "Invalid body",
+                    issues: parsed.error.issues.map((i) => ({
+                        path: i.path.join("."),
+                        message: i.message,
+                    })),
+                },
+            };
+        }
+        const body = parsed.data;
+        if ("modelId" in body) {
+            try {
+                const mc = (0, config_1.resolveModelConfig)(ctx.state.modelsFile, body.modelId);
+                const result = await (0, upstreamProbe_1.probeModelUpstream)(mc);
+                return {
+                    ok: result.ok,
+                    status: result.status,
+                    message: result.message,
+                    baseUrl: mc.baseUrl.replace(/\/+$/, ""),
+                };
+            }
+            catch (err) {
+                reply.code(400);
+                return { error: { message: err?.message ?? String(err) } };
+            }
+        }
+        const mc = {
+            adapter: body.adapter,
+            baseUrl: body.baseUrl,
+            timeoutMs: body.timeoutMs,
+            apiKey: body.apiKey,
+            apiKeyHeader: body.apiKeyHeader,
+            headers: body.headers,
+        };
+        const result = await (0, upstreamProbe_1.probeModelUpstream)(mc);
+        return {
+            ok: result.ok,
+            status: result.status,
+            message: result.message,
+            baseUrl: body.baseUrl.replace(/\/+$/, ""),
+        };
+    });
+    app.get("/admin/metrics/summary", { preHandler: guard }, async () => {
+        return (0, summary_1.buildMetricsSummary)(ctx.metrics);
+    });
+    app.get("/admin/metrics/overview", { preHandler: guard }, async (req, reply) => {
+        const q = req.query;
+        const parsed = parseRange(q.range ?? "15m");
+        if (!parsed.ok) {
+            reply.code(400);
+            return { error: { message: "Invalid range. Use 15m|1h|24h" } };
+        }
+        const now = Date.now();
+        const since = now - parsed.ms;
+        const logs = ctx.modelRequests.getRecent(50_000);
+        const inRange = logs.filter((r) => r.ts >= since && r.ts <= now);
+        const reqCount = inRange.length;
+        const errCount = inRange.filter((r) => r.status >= 400).length;
+        const errorRate = reqCount > 0 ? errCount / reqCount : 0;
+        const lat = inRange.map((r) => r.latencyMs).filter((x) => Number.isFinite(x));
+        lat.sort((a, b) => a - b);
+        const latencyP50 = percentile(lat, 0.5);
+        const latencyP95 = percentile(lat, 0.95);
+        let tokensInTotal = 0;
+        let tokensOutTotal = 0;
+        for (const r of inRange) {
+            const u = r.usage;
+            if (u && typeof u.prompt_tokens === "number")
+                tokensInTotal += u.prompt_tokens;
+            if (u && typeof u.completion_tokens === "number")
+                tokensOutTotal += u.completion_tokens;
+        }
+        const bucketMs = parsed.label === "24h" ? 15 * 60_000 : 60_000;
+        const bucketCount = Math.ceil(parsed.ms / bucketMs);
+        const buckets = new Array(bucketCount).fill(0).map((_, i) => ({
+            ts: since + i * bucketMs,
+            tokens_in: 0,
+            tokens_out: 0,
+            req_count: 0,
+            error_count: 0,
+        }));
+        for (const r of inRange) {
+            const bi = Math.floor((r.ts - since) / bucketMs);
+            if (bi < 0 || bi >= buckets.length)
+                continue;
+            const b = buckets[bi];
+            b.req_count++;
+            if (r.status >= 400)
+                b.error_count++;
+            const u = r.usage;
+            if (u && typeof u.prompt_tokens === "number")
+                b.tokens_in += u.prompt_tokens;
+            if (u && typeof u.completion_tokens === "number")
+                b.tokens_out += u.completion_tokens;
+        }
+        return {
+            req_count: reqCount,
+            error_rate: errorRate,
+            latency_p50_ms: latencyP50,
+            latency_p95_ms: latencyP95,
+            tokens_in_total: tokensInTotal,
+            tokens_out_total: tokensOutTotal,
+            timeseries: buckets,
+        };
+    });
+    app.get("/admin/logs/models", { preHandler: guard }, async (req) => {
+        const q = req.query;
+        const parsed = parseRange(q.range ?? "15m");
+        const lim = Math.min(500, Math.max(1, Number(q.limit ?? 200) || 200));
+        const now = Date.now();
+        const since = parsed.ok ? now - parsed.ms : now - 15 * 60_000;
+        const wantModelId = (q.modelId ?? "").trim();
+        const wantStatus = (q.status ?? "").trim();
+        const rows = ctx.modelRequests
+            .getRecent(50_000)
+            .filter((r) => r.ts >= since && r.ts <= now)
+            .filter((r) => (wantModelId ? r.modelId === wantModelId : true))
+            .filter((r) => (wantStatus ? String(r.status) === wantStatus : true))
+            .slice(0, lim)
+            .map((r) => ({
+            ts: r.ts,
+            requestId: r.requestId,
+            modelId: r.modelId,
+            endpoint: r.endpoint,
+            status: r.status,
+            latencyMs: r.latencyMs,
+            usage: r.usage ?? null,
+        }));
+        return { logs: rows };
+    });
+    app.get("/admin/models/:modelId/debug/messages", { preHandler: guard }, async (req) => {
+        const params = req.params;
+        const q = req.query;
+        const lim = Math.min(50, Math.max(1, Number(q.limit ?? 10) || 10));
+        const rolesRaw = String(q.roles ?? "system,user")
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean);
+        const roles = rolesRaw.filter((r) => r === "system" || r === "user");
+        const items = ctx.modelMessages.getRecent(params.modelId, lim, roles);
+        return {
+            messages: items.map((m) => ({
+                id: m.id,
+                ts: m.ts,
+                modelId: m.modelId,
+                requestId: m.requestId,
+                endpoint: m.endpoint,
+                role: m.role,
+                rawMessageJson: m.rawMessageJson,
+            })),
+        };
+    });
+    app.get("/admin/requests/:requestId", { preHandler: guard }, async (req, reply) => {
+        const params = req.params;
+        const found = ctx.modelRequests.getById(params.requestId);
+        if (!found) {
+            reply.code(404);
+            return { error: { message: "Not found" } };
+        }
+        return {
+            request: {
+                ts: found.ts,
+                requestId: found.requestId,
+                modelId: found.modelId,
+                endpoint: found.endpoint,
+                status: found.status,
+                latencyMs: found.latencyMs,
+                usage: found.usage ?? null,
+                error: found.error ?? null,
+            },
+        };
+    });
+    app.get("/admin/requests", { preHandler: guard }, async (req) => {
+        const q = req.query;
+        const lim = Math.min(500, Math.max(1, Number(q.limit ?? 200) || 200));
+        return { requests: ctx.recorder.getRecent(lim) };
+    });
+}

package/dist/cli/bin.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const index_js_1 = require("./index.js");
+(0, index_js_1.runCli)().catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error(err);
+    process.exit(1);
+});

package/dist/cli/commands/config.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configCommand = configCommand;
+const commander_1 = require("commander");
+const node_path_1 = __importDefault(require("node:path"));
+const load_1 = require("../../config/load");
+function configCommand() {
+    const cmd = new commander_1.Command("config");
+    cmd.description("Configuration utilities.");
+    cmd
+        .command("validate")
+        .description("Validate models.json schema.")
+        .option("--file <path>", "Config file path (default: ./models.json)")
+        .action(async (opts) => {
+        const filePath = node_path_1.default.resolve(opts.file ?? node_path_1.default.resolve(process.cwd(), "models.json"));
+        try {
+            await (0, load_1.loadModelsFileFromPath)(filePath);
+            // eslint-disable-next-line no-console
+            console.log(`OK: ${filePath}`);
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.error((0, load_1.formatConfigError)(err));
+            process.exitCode = 1;
+        }
+    });
+    return cmd;
+}