waypoi 0.0.0

package/dist/src/routes/admin.js

@@ -0,0 +1,531 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAdminRoutes = registerAdminRoutes;
+const registry_1 = require("../protocols/registry");
+const repository_1 = require("../providers/repository");
+const repository_2 = require("../pools/repository");
+const builder_1 = require("../pools/builder");
+const runner_1 = require("../benchmark/runner");
+const jobs_1 = require("../benchmark/jobs");
+const capabilityStore_1 = require("../benchmark/capabilityStore");
+const modelDiscovery_1 = require("../utils/modelDiscovery");
+const captureRepository_1 = require("../storage/captureRepository");
+const fs_1 = require("fs");
+async function registerAdminRoutes(app, paths, env) {
+    app.addHook("onRequest", async (req, reply) => {
+        if (!req.url.startsWith("/admin")) {
+            return;
+        }
+        if (!isAuthorized(req, env.adminToken)) {
+            reply.code(401).send({ error: { message: "Unauthorized" } });
+            return reply;
+        }
+    });
+    app.get("/admin/meta", async (_req, reply) => {
+        reply.send({
+            name: "waypoi",
+            version: env.version ?? "0.0.0",
+            now: new Date().toISOString(),
+        });
+    });
+    app.get("/admin/protocols", async (_req, reply) => {
+        reply.send({ data: (0, registry_1.listAllProtocolAdapters)() });
+    });
+    app.get("/admin/providers", async (_req, reply) => {
+        const providers = await (0, repository_1.listProviders)(paths);
+        reply.send(providers);
+    });
+    app.get("/admin/providers/:id", async (req, reply) => {
+        const { id } = req.params;
+        const provider = await (0, repository_1.getProviderById)(paths, id);
+        if (!provider) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        reply.send(provider);
+    });
+    app.post("/admin/providers", async (req, reply) => {
+        const body = req.body;
+        if (!body?.id || !body?.baseUrl || !body?.protocol) {
+            reply.code(400).send({ error: { message: "id, baseUrl, and protocol are required" } });
+            return;
+        }
+        const provider = {
+            id: body.id,
+            name: body.name ?? body.id,
+            description: body.description,
+            docs: body.docs,
+            protocol: body.protocol,
+            protocolRaw: body.protocolRaw,
+            protocolConfig: body.protocolConfig,
+            baseUrl: body.baseUrl,
+            insecureTls: body.insecureTls,
+            autoInsecureTlsDomains: body.autoInsecureTlsDomains ?? [],
+            enabled: body.enabled ?? true,
+            supportsRouting: body.supportsRouting ?? true,
+            auth: body.auth,
+            envVar: body.envVar,
+            apiKey: body.apiKey,
+            limits: body.limits,
+            models: [],
+            importedAt: new Date().toISOString(),
+        };
+        const saved = await (0, repository_1.upsertProvider)(paths, provider);
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.code(201).send(saved);
+    });
+    app.patch("/admin/providers/:id", async (req, reply) => {
+        const { id } = req.params;
+        const body = req.body;
+        if (!body) {
+            reply.code(400).send({ error: { message: "payload required" } });
+            return;
+        }
+        const updated = await (0, repository_1.updateProvider)(paths, id, body);
+        if (!updated) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send(updated);
+    });
+    app.delete("/admin/providers/:id", async (req, reply) => {
+        const { id } = req.params;
+        const removed = await (0, repository_1.deleteProvider)(paths, id);
+        if (!removed) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send({ deleted: removed.id });
+    });
+    app.post("/admin/providers/:id/enable", async (req, reply) => {
+        const { id } = req.params;
+        const provider = await (0, repository_1.setProviderEnabled)(paths, id, true);
+        if (!provider) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send(provider);
+    });
+    app.post("/admin/providers/:id/disable", async (req, reply) => {
+        const { id } = req.params;
+        const provider = await (0, repository_1.setProviderEnabled)(paths, id, false);
+        if (!provider) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send(provider);
+    });
+    app.get("/admin/providers/:id/models", async (req, reply) => {
+        const { id } = req.params;
+        const models = await (0, repository_1.listProviderModels)(paths, id);
+        if (!models) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        reply.send(models);
+    });
+    app.post("/admin/providers/:id/models/discover", async (req, reply) => {
+        const { id } = req.params;
+        const body = req.body;
+        const provider = await (0, repository_1.getProviderById)(paths, id);
+        if (!provider) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        const baseUrl = body?.baseUrl?.trim() || provider.baseUrl;
+        if (!baseUrl) {
+            reply.code(400).send({ error: { message: "baseUrl is required" } });
+            return;
+        }
+        try {
+            const models = await (0, modelDiscovery_1.discoverUpstreamModels)({
+                baseUrl,
+                apiKey: body?.apiKey?.trim() || provider.apiKey,
+                insecureTls: body?.insecureTls === true
+                    ? true
+                    : (0, repository_1.getEffectiveModelInsecureTls)(provider, { insecureTls: undefined }),
+                auth: provider.auth,
+            });
+            reply.send({ baseUrl, models });
+        }
+        catch (error) {
+            const message = error instanceof Error && error.message ? error.message : "model discovery failed";
+            reply.code(502).send({ error: { message } });
+        }
+    });
+    app.post("/admin/providers/:id/models", async (req, reply) => {
+        const { id } = req.params;
+        const body = req.body;
+        if (!body?.modelId || !body?.upstreamModel || !body?.endpointType || !body?.capabilities) {
+            reply.code(400).send({
+                error: {
+                    message: "modelId, upstreamModel, endpointType, and capabilities are required",
+                },
+            });
+            return;
+        }
+        const provider = await (0, repository_1.getProviderById)(paths, id);
+        if (!provider) {
+            reply.code(404).send({ error: { message: "provider not found" } });
+            return;
+        }
+        const record = {
+            providerModelId: body.providerModelId ?? `${id}/${body.modelId}`,
+            providerId: id,
+            modelId: body.modelId,
+            upstreamModel: body.upstreamModel,
+            baseUrl: body.baseUrl || provider.baseUrl,
+            apiKey: body.apiKey,
+            insecureTls: body.insecureTls,
+            enabled: body.enabled ?? true,
+            aliases: body.aliases ?? [],
+            free: body.free ?? true,
+            modalities: body.modalities ?? [],
+            capabilities: body.capabilities,
+            endpointType: body.endpointType,
+            limits: body.limits,
+        };
+        const result = await (0, repository_1.upsertProviderModel)(paths, id, record);
+        if (!result) {
+            reply.code(500).send({ error: { message: "failed to add model" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.code(result.created ? 201 : 200).send(record);
+    });
+    app.patch("/admin/providers/:id/models/:modelRef", async (req, reply) => {
+        const { id, modelRef } = req.params;
+        const body = req.body;
+        if (!body) {
+            reply.code(400).send({ error: { message: "payload required" } });
+            return;
+        }
+        const updated = await (0, repository_1.updateProviderModel)(paths, id, modelRef, body);
+        if (!updated) {
+            reply.code(404).send({ error: { message: "model not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send(updated);
+    });
+    app.delete("/admin/providers/:id/models/:modelRef", async (req, reply) => {
+        const { id, modelRef } = req.params;
+        const removed = await (0, repository_1.deleteProviderModel)(paths, id, modelRef);
+        if (!removed) {
+            reply.code(404).send({ error: { message: "model not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send({ deleted: removed.providerModelId });
+    });
+    app.post("/admin/providers/:id/models/:modelRef/enable", async (req, reply) => {
+        const { id, modelRef } = req.params;
+        const model = await (0, repository_1.setProviderModelEnabled)(paths, id, modelRef, true);
+        if (!model) {
+            reply.code(404).send({ error: { message: "model not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send(model);
+    });
+    app.post("/admin/providers/:id/models/:modelRef/disable", async (req, reply) => {
+        const { id, modelRef } = req.params;
+        const model = await (0, repository_1.setProviderModelEnabled)(paths, id, modelRef, false);
+        if (!model) {
+            reply.code(404).send({ error: { message: "model not found" } });
+            return;
+        }
+        await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send(model);
+    });
+    app.get("/admin/pools", async (_req, reply) => {
+        const pools = await (0, repository_2.listPools)(paths);
+        reply.send(pools);
+    });
+    app.post("/admin/pools", async (req, reply) => {
+        const body = req.body ?? {};
+        if (!body.id?.trim()) {
+            reply.code(400).send({ error: { message: "Pool ID is required" } });
+            return;
+        }
+        const existing = await (0, repository_2.listPools)(paths);
+        if (existing.some((p) => p.id === body.id)) {
+            reply.code(409).send({ error: { message: "A pool with this ID already exists" } });
+            return;
+        }
+        const pool = {
+            id: body.id.trim(),
+            name: body.name?.trim() || body.id.trim(),
+            aliases: body.aliases ?? [body.id.trim()],
+            enabled: body.enabled !== false,
+            strategy: body.strategy ?? "highest_rank_available",
+            requiredInput: body.requiredInput ?? [],
+            requiredOutput: body.requiredOutput ?? [],
+            scoreFallback: typeof body.scoreFallback === "number" ? body.scoreFallback : 20,
+            candidates: [],
+            candidateSelection: body.candidateSelection ?? [],
+            userDefined: true,
+            updatedAt: new Date().toISOString(),
+        };
+        existing.push(pool);
+        await (0, repository_2.savePools)(paths, existing);
+        reply.code(201).send(pool);
+    });
+    app.put("/admin/pools/:id", async (req, reply) => {
+        const { id } = req.params;
+        const body = req.body ?? {};
+        const pools = await (0, repository_2.listPools)(paths);
+        const idx = pools.findIndex((p) => p.id === id);
+        if (idx === -1) {
+            reply.code(404).send({ error: { message: "Pool not found" } });
+            return;
+        }
+        const existing = pools[idx];
+        if (!existing.userDefined) {
+            reply.code(403).send({ error: { message: "Cannot modify auto-generated pools" } });
+            return;
+        }
+        pools[idx] = {
+            ...existing,
+            name: body.name !== undefined ? body.name.trim() : existing.name,
+            aliases: body.aliases ?? existing.aliases,
+            enabled: body.enabled !== undefined ? body.enabled : existing.enabled,
+            strategy: body.strategy ?? existing.strategy,
+            requiredInput: body.requiredInput ?? existing.requiredInput,
+            requiredOutput: body.requiredOutput ?? existing.requiredOutput,
+            scoreFallback: typeof body.scoreFallback === "number" ? body.scoreFallback : existing.scoreFallback,
+            candidateSelection: body.candidateSelection ?? existing.candidateSelection,
+            updatedAt: new Date().toISOString(),
+        };
+        await (0, repository_2.savePools)(paths, pools);
+        reply.send(pools[idx]);
+    });
+    app.delete("/admin/pools/:id", async (req, reply) => {
+        const { id } = req.params;
+        const pools = await (0, repository_2.listPools)(paths);
+        const idx = pools.findIndex((p) => p.id === id);
+        if (idx === -1) {
+            reply.code(404).send({ error: { message: "Pool not found" } });
+            return;
+        }
+        if (!pools[idx].userDefined) {
+            reply.code(403).send({ error: { message: "Cannot delete auto-generated pools" } });
+            return;
+        }
+        pools.splice(idx, 1);
+        await (0, repository_2.savePools)(paths, pools);
+        reply.send({ deleted: id });
+    });
+    app.post("/admin/pools/:id/toggle", async (req, reply) => {
+        const { id } = req.params;
+        const pools = await (0, repository_2.listPools)(paths);
+        const pool = pools.find((p) => p.id === id);
+        if (!pool) {
+            reply.code(404).send({ error: { message: "Pool not found" } });
+            return;
+        }
+        pool.enabled = !pool.enabled;
+        pool.updatedAt = new Date().toISOString();
+        await (0, repository_2.savePools)(paths, pools);
+        reply.send(pool);
+    });
+    app.post("/admin/pools/rebuild", async (_req, reply) => {
+        const pools = await (0, builder_1.rebuildDefaultPools)(paths);
+        reply.send({ rebuilt: pools.length, pools });
+    });
+    app.post("/admin/benchmarks/runs", async (req, reply) => {
+        if ((0, jobs_1.hasRunningBenchmarkRun)()) {
+            reply.code(409).send({
+                error: { message: "A benchmark run is already in progress" },
+            });
+            return;
+        }
+        const body = req.body ?? {};
+        const run = await (0, jobs_1.startBenchmarkRun)(paths, {
+            suite: body.suite,
+            exampleId: body.exampleId,
+            scenarioPath: body.scenarioPath,
+            modelOverride: body.modelOverride,
+            outPath: body.outPath,
+            configPath: body.configPath,
+            profile: body.profile,
+            baselinePath: body.baselinePath,
+            executionMode: body.executionMode,
+            updateCapCache: body.updateCapCache,
+            capTtlDays: body.capTtlDays,
+            temperature: body.temperature,
+            top_p: body.top_p,
+            max_tokens: body.max_tokens,
+            presence_penalty: body.presence_penalty,
+            frequency_penalty: body.frequency_penalty,
+            seed: body.seed,
+            stop: body.stop,
+        });
+        reply.code(202).send(run);
+    });
+    app.get("/admin/benchmarks/runs", async (_req, reply) => {
+        const items = await (0, jobs_1.listBenchmarkRuns)(paths);
+        reply.send({
+            object: "list",
+            data: items,
+        });
+    });
+    app.get("/admin/benchmarks/examples", async (req, reply) => {
+        const suite = (req.query?.suite ?? "showcase").trim() || "showcase";
+        reply.send({
+            object: "list",
+            suite,
+            data: (0, runner_1.listBenchmarkExamples)(suite),
+        });
+    });
+    app.get("/admin/benchmarks/runs/:id", async (req, reply) => {
+        const { id } = req.params;
+        const run = (0, jobs_1.getBenchmarkRun)(id);
+        if (run) {
+            reply.send(run);
+            return;
+        }
+        const historical = await (0, jobs_1.getArtifactBenchmarkRun)(paths, id);
+        if (!historical) {
+            reply.code(404).send({ error: { message: "benchmark run not found" } });
+            return;
+        }
+        reply.send(historical);
+    });
+    app.get("/admin/benchmarks/runs/:id/events", async (req, reply) => {
+        const { id } = req.params;
+        const run = (0, jobs_1.getBenchmarkRun)(id);
+        if (!run) {
+            reply.code(404).send({ error: { message: "benchmark run not found" } });
+            return;
+        }
+        reply.raw.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache, no-transform",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no",
+        });
+        const sendEvent = (event) => {
+            reply.raw.write(`data: ${JSON.stringify(event)}\n\n`);
+        };
+        for (const event of (0, jobs_1.listBenchmarkRunEvents)(id)) {
+            sendEvent(event);
+        }
+        const unsubscribe = (0, jobs_1.subscribeBenchmarkRunEvents)(id, (event) => {
+            sendEvent(event);
+        });
+        const heartbeat = setInterval(() => {
+            reply.raw.write(": ping\n\n");
+        }, 15_000);
+        req.raw.on("close", () => {
+            clearInterval(heartbeat);
+            unsubscribe();
+            reply.raw.end();
+        });
+    });
+    app.get("/admin/benchmarks/capabilities", async (req, reply) => {
+        const ttlParam = Number(req.query?.ttlDays);
+        const ttlDays = Number.isFinite(ttlParam) && ttlParam > 0 ? Math.floor(ttlParam) : 7;
+        const data = await (0, capabilityStore_1.listCapabilitySnapshots)(paths, ttlDays);
+        reply.send((0, capabilityStore_1.toCapabilityMatrix)(data));
+    });
+    app.get("/admin/benchmarks/capabilities/:modelId", async (req, reply) => {
+        const { modelId } = req.params;
+        const ttlParam = Number(req.query?.ttlDays);
+        const ttlDays = Number.isFinite(ttlParam) && ttlParam > 0 ? Math.floor(ttlParam) : 7;
+        const model = await (0, capabilityStore_1.getCapabilitySnapshotByModel)(paths, modelId, ttlDays);
+        if (!model) {
+            reply.code(404).send({ error: { message: "capability snapshot not found" } });
+            return;
+        }
+        reply.send(model);
+    });
+    app.get("/admin/capture/config", async (_req, reply) => {
+        const config = await (0, captureRepository_1.getCaptureConfig)(paths);
+        reply.send(config);
+    });
+    app.put("/admin/capture/config", async (req, reply) => {
+        const next = await (0, captureRepository_1.updateCaptureConfig)(paths, req.body ?? {});
+        reply.send(next);
+    });
+    app.get("/admin/capture/records", async (req, reply) => {
+        const query = req.query;
+        const parsed = Number(query?.limit);
+        const limit = Number.isFinite(parsed) ? Math.max(1, Math.min(50, Math.floor(parsed))) : 5;
+        const offsetParsed = Number(query?.offset);
+        const offset = Number.isFinite(offsetParsed) ? Math.max(0, Math.floor(offsetParsed)) : 0;
+        const timeZone = normalizeTimeZone(query?.timeZone);
+        const result = await (0, captureRepository_1.listCaptureRecords)(paths, {
+            limit,
+            offset,
+            date: typeof query?.date === "string" && /^\d{4}-\d{2}-\d{2}$/.test(query.date) ? query.date : undefined,
+            timeZone,
+        });
+        reply.send({ object: "list", data: result.data, total: result.total });
+    });
+    app.get("/admin/capture/calendar", async (req, reply) => {
+        const query = req.query;
+        const timeZone = normalizeTimeZone(query?.timeZone);
+        const month = typeof query?.month === "string" && /^\d{4}-\d{2}$/.test(query.month)
+            ? query.month
+            : formatDateForTimeZone(new Date(), timeZone).slice(0, 7);
+        const days = await (0, captureRepository_1.getCaptureCalendarMonth)(paths, month, timeZone);
+        reply.send({ month, days });
+    });
+    app.get("/admin/capture/records/:id", async (req, reply) => {
+        const { id } = req.params;
+        const record = await (0, captureRepository_1.getCaptureRecordById)(paths, id);
+        if (!record) {
+            reply.code(404).send({ error: { message: "capture record not found" } });
+            return;
+        }
+        reply.send(record);
+    });
+    app.get("/admin/capture/blobs/:hash", async (req, reply) => {
+        const { hash } = req.params;
+        const located = await (0, captureRepository_1.findCaptureBlobPath)(paths, hash);
+        if (!located) {
+            reply.code(404).send({ error: { message: "capture blob not found" } });
+            return;
+        }
+        const buffer = await fs_1.promises.readFile(located.path);
+        reply.header("content-type", located.mime);
+        reply.send(buffer);
+    });
+}
+function isAuthorized(req, token) {
+    if (token) {
+        const header = req.headers.authorization ?? "";
+        return header === `Bearer ${token}`;
+    }
+    const remote = req.socket.remoteAddress ?? "";
+    return remote === "127.0.0.1" || remote === "::1";
+}
+function formatDateForTimeZone(value, timeZone) {
+    const formatter = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    });
+    const parts = formatter.formatToParts(value);
+    const year = parts.find((part) => part.type === "year")?.value ?? "0000";
+    const month = parts.find((part) => part.type === "month")?.value ?? "00";
+    const day = parts.find((part) => part.type === "day")?.value ?? "00";
+    return `${year}-${month}-${day}`;
+}
+function normalizeTimeZone(input) {
+    if (!input)
+        return "UTC";
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: input });
+        return input;
+    }
+    catch {
+        return "UTC";
+    }
+}