waypoi 0.0.0

package/dist/src/routes/stats.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStatsRoutes = registerStatsRoutes;
+const statsRepository_1 = require("../storage/statsRepository");
+async function registerStatsRoutes(app, paths) {
+    // GET /admin/stats - aggregated statistics
+    app.get("/admin/stats", async (req, reply) => {
+        const windowMs = parseWindow(req.query.window ?? "24h");
+        const timeZone = normalizeTimeZone(req.query.timeZone);
+        if (windowMs === null) {
+            reply.code(400).send({
+                error: {
+                    message: "Invalid window format. Use format like '1h', '24h', '7d'"
+                }
+            });
+            return;
+        }
+        try {
+            const stats = await (0, statsRepository_1.aggregateStats)(paths, windowMs);
+            reply.send({
+                ...stats,
+                timeZone,
+            });
+        }
+        catch (error) {
+            app.log.error({ error }, "Failed to aggregate stats");
+            reply.code(500).send({ error: { message: "Failed to retrieve statistics" } });
+        }
+    });
+    // GET /admin/stats/raw - raw stats entries
+    app.get("/admin/stats/raw", async (req, reply) => {
+        const windowDays = parseWindowDays(req.query.window ?? "1d");
+        const limit = Math.min(parseInt(req.query.limit ?? "1000", 10), 10000);
+        if (windowDays === null) {
+            reply.code(400).send({
+                error: { message: "Invalid window format" }
+            });
+            return;
+        }
+        try {
+            const stats = await (0, statsRepository_1.readStatsForWindow)(paths, windowDays);
+            // Return most recent entries up to limit
+            const entries = stats.slice(-limit);
+            reply.send({
+                window: `${windowDays}d`,
+                count: entries.length,
+                totalInWindow: stats.length,
+                entries
+            });
+        }
+        catch (error) {
+            app.log.error({ error }, "Failed to read raw stats");
+            reply.code(500).send({ error: { message: "Failed to retrieve statistics" } });
+        }
+    });
+    // GET /admin/stats/latency - latency distribution
+    app.get("/admin/stats/latency", async (req, reply) => {
+        const windowMs = parseWindow(req.query.window ?? "7d");
+        const timeZone = normalizeTimeZone(req.query.timeZone);
+        if (windowMs === null) {
+            reply.code(400).send({ error: { message: "Invalid window format" } });
+            return;
+        }
+        try {
+            const stats = await selectStatsForWindow(paths, windowMs);
+            const latencies = stats.map((s) => s.latencyMs).sort((a, b) => a - b);
+            const window = formatWindowString(windowMs);
+            if (latencies.length === 0) {
+                reply.send({
+                    window,
+                    timeZone,
+                    count: 0,
+                    min: null,
+                    max: null,
+                    avg: null,
+                    p50: null,
+                    p95: null,
+                    p99: null,
+                    histogram: {}
+                });
+                return;
+            }
+            // Create histogram buckets
+            const buckets = [50, 100, 200, 500, 1000, 2000, 5000, 10000];
+            const histogram = {};
+            for (const bucket of buckets) {
+                histogram[`<${bucket}ms`] = 0;
+            }
+            histogram[">10000ms"] = 0;
+            for (const latency of latencies) {
+                let assigned = false;
+                for (const bucket of buckets) {
+                    if (latency < bucket) {
+                        histogram[`<${bucket}ms`]++;
+                        assigned = true;
+                        break;
+                    }
+                }
+                if (!assigned) {
+                    histogram[">10000ms"]++;
+                }
+            }
+            reply.send({
+                window,
+                timeZone,
+                count: latencies.length,
+                min: latencies[0],
+                max: latencies[latencies.length - 1],
+                avg: Math.round(latencies.reduce((a, b) => a + b, 0) / latencies.length),
+                p50: percentile(latencies, 50),
+                p95: percentile(latencies, 95),
+                p99: percentile(latencies, 99),
+                histogram
+            });
+        }
+        catch (error) {
+            app.log.error({ error }, "Failed to compute latency distribution");
+            reply.code(500).send({ error: { message: "Failed to retrieve statistics" } });
+        }
+    });
+    // GET /admin/stats/tokens - token usage over time
+    app.get("/admin/stats/tokens", async (req, reply) => {
+        const windowMs = parseWindow(req.query.window ?? "7d");
+        const timeZone = normalizeTimeZone(req.query.timeZone);
+        if (windowMs === null) {
+            reply.code(400).send({ error: { message: "Invalid window format" } });
+            return;
+        }
+        try {
+            const stats = await selectStatsForWindow(paths, windowMs);
+            const bucketGranularity = windowMs <= 24 * 60 * 60 * 1000 ? "hour" : "day";
+            const byDay = {};
+            let tokenEstimatedCount = 0;
+            let splitUnknownCount = 0;
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            for (const stat of stats) {
+                const bucket = formatTokenBucket(stat.timestamp, bucketGranularity, timeZone);
+                if (!byDay[bucket]) {
+                    byDay[bucket] = {
+                        count: 0,
+                        tokens: 0,
+                        estimated: 0,
+                        inputTokens: 0,
+                        outputTokens: 0,
+                        splitUnknown: 0,
+                    };
+                }
+                byDay[bucket].count++;
+                if (stat.totalTokens !== null && stat.totalTokens !== undefined) {
+                    byDay[bucket].tokens += stat.totalTokens;
+                }
+                else {
+                    byDay[bucket].estimated++;
+                    tokenEstimatedCount += 1;
+                }
+                const promptTokens = stat.promptTokens;
+                const completionTokens = stat.completionTokens;
+                const hasSplit = promptTokens !== null &&
+                    promptTokens !== undefined &&
+                    completionTokens !== null &&
+                    completionTokens !== undefined;
+                if (hasSplit) {
+                    byDay[bucket].inputTokens += promptTokens;
+                    byDay[bucket].outputTokens += completionTokens;
+                    totalInputTokens += promptTokens;
+                    totalOutputTokens += completionTokens;
+                }
+                else {
+                    byDay[bucket].splitUnknown++;
+                    splitUnknownCount += 1;
+                }
+            }
+            const days = Object.entries(byDay)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([date, data]) => ({ date, ...data }));
+            const totalTokens = stats.reduce((sum, s) => sum + (s.totalTokens ?? 0), 0);
+            reply.send({
+                window: formatWindowString(windowMs),
+                totalTokens,
+                totalInputTokens,
+                totalOutputTokens,
+                totalRequests: stats.length,
+                avgTokensPerRequest: stats.length > 0 ? Math.round(totalTokens / stats.length) : 0,
+                byDay: days,
+                tokenEstimatedCount,
+                tokenEstimatedRate: stats.length > 0 ? tokenEstimatedCount / stats.length : 0,
+                splitUnknownCount,
+                splitUnknownRate: stats.length > 0 ? splitUnknownCount / stats.length : 0,
+                bucketGranularity,
+                bucketTimeZone: timeZone,
+            });
+        }
+        catch (error) {
+            app.log.error({ error }, "Failed to compute token usage");
+            reply.code(500).send({ error: { message: "Failed to retrieve statistics" } });
+        }
+    });
+}
+function parseWindow(window) {
+    const match = window.match(/^(\d+)(h|d|m)$/);
+    if (!match)
+        return null;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case "m": return value * 60 * 1000;
+        case "h": return value * 60 * 60 * 1000;
+        case "d": return value * 24 * 60 * 60 * 1000;
+        default: return null;
+    }
+}
+function parseWindowDays(window) {
+    const ms = parseWindow(window);
+    if (ms === null)
+        return null;
+    return Math.ceil(ms / (24 * 60 * 60 * 1000));
+}
+function percentile(sortedArr, p) {
+    if (sortedArr.length === 0)
+        return 0;
+    const index = Math.ceil((p / 100) * sortedArr.length) - 1;
+    return sortedArr[Math.max(0, index)];
+}
+async function selectStatsForWindow(paths, windowMs) {
+    const windowDays = Math.ceil(windowMs / (24 * 60 * 60 * 1000));
+    const stats = await (0, statsRepository_1.readStatsForWindow)(paths, windowDays);
+    const cutoff = Date.now() - windowMs;
+    return stats.filter((s) => s.timestamp.getTime() >= cutoff);
+}
+function formatWindowString(ms) {
+    const hours = ms / (60 * 60 * 1000);
+    if (hours < 24)
+        return `${Math.round(hours)}h`;
+    return `${Math.round(hours / 24)}d`;
+}
+function formatTokenBucket(timestamp, granularity, timeZone) {
+    const formatter = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        ...(granularity === "hour"
+            ? {
+                hour: "2-digit",
+                hourCycle: "h23",
+            }
+            : {}),
+    });
+    const parts = formatter.formatToParts(timestamp);
+    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";
+    if (granularity === "day") {
+        return `${year}-${month}-${day}`;
+    }
+    const hour = parts.find((part) => part.type === "hour")?.value ?? "00";
+    return `${year}-${month}-${day}T${hour}:00`;
+}
+function normalizeTimeZone(input) {
+    if (!input)
+        return "UTC";
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: input });
+        return input;
+    }
+    catch {
+        return "UTC";
+    }
+}

package/dist/src/routes/ui.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUiRoutes = registerUiRoutes;
+const static_1 = __importDefault(require("@fastify/static"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+/**
+ * Register UI routes to serve the React frontend.
+ *
+ * - Serves static files from ui/dist at /ui/*
+ * - Provides SPA fallback for client-side routing
+ */
+async function registerUiRoutes(app) {
+    // When running from dist/src/routes/ui.js, we need to go up to project root
+    // __dirname = dist/src/routes -> go up 3 levels to project root, then into ui/dist
+    const uiDistPath = path_1.default.join(__dirname, "..", "..", "..", "ui", "dist");
+    // Check if UI is built
+    const uiExists = await checkUiExists(uiDistPath);
+    if (!uiExists) {
+        // UI not built - serve a placeholder
+        app.get("/ui", async (_req, reply) => {
+            reply.type("text/html").send(`
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>Waypoi UI</title>
+            <style>
+              body { 
+                font-family: monospace; 
+                background: #0a0a0c; 
+                color: #e5e2d9;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                height: 100vh;
+                margin: 0;
+              }
+              .container { text-align: center; }
+              h1 { color: #eab308; }
+              code { background: #1a1a1e; padding: 4px 8px; border-radius: 4px; }
+            </style>
+          </head>
+          <body>
+            <div class="container">
+              <h1>Waypoi UI</h1>
+              <p>UI not built. Run:</p>
+              <p><code>cd ui && npm install && npm run build</code></p>
+              <p>Then restart the server.</p>
+            </div>
+          </body>
+        </html>
+      `);
+        });
+        app.get("/ui/*", async (_req, reply) => {
+            reply.redirect("/ui");
+        });
+        return;
+    }
+    // Register static file serving
+    await app.register(static_1.default, {
+        root: uiDistPath,
+        prefix: "/ui/",
+        decorateReply: false,
+    });
+    // SPA fallback - serve index.html for all /ui/* routes that don't match a file
+    app.setNotFoundHandler(async (req, reply) => {
+        if (req.url.startsWith("/ui")) {
+            const indexPath = path_1.default.join(uiDistPath, "index.html");
+            try {
+                const html = await fs_1.promises.readFile(indexPath, "utf8");
+                reply.type("text/html").send(html);
+            }
+            catch {
+                reply.code(404).send({ error: { message: "UI not found" } });
+            }
+        }
+        else if (req.url === "/" && req.headers.accept?.includes("text/html")) {
+            reply.redirect("/ui");
+        }
+        else {
+            reply.code(404).send({ error: { message: "Not found" } });
+        }
+    });
+}
+async function checkUiExists(distPath) {
+    try {
+        const indexPath = path_1.default.join(distPath, "index.html");
+        await fs_1.promises.access(indexPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/routes/videos.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVideoRoutes = registerVideoRoutes;
+const crypto_1 = require("crypto");
+const repositories_1 = require("../storage/repositories");
+const videoGeneration_1 = require("../services/videoGeneration");
+const requestCapture_1 = require("../middleware/requestCapture");
+async function registerVideoRoutes(app, paths) {
+    app.post("/v1/videos/generations", async (req, reply) => {
+        const body = req.body;
+        if (!body?.prompt) {
+            reply.code(400).send({ error: { message: "prompt is required" } });
+            return;
+        }
+        const model = await (0, videoGeneration_1.resolveVideoGenerationModel)(paths, body.model);
+        if (!model) {
+            reply.code(400).send({ error: { message: "No video generation model available. Add or enable a provider model." } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const generated = await (0, videoGeneration_1.runVideoGeneration)(paths, { ...body, model }, req.headers, controller.signal);
+            setHeaders(reply, generated.headers);
+            reply.code(generated.statusCode).send(generated.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: model,
+                endpointId: generated.route.endpointId,
+                endpointName: generated.route.endpointName,
+                upstreamModel: generated.route.upstreamModel,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, model, {
+                attempt: {
+                    endpoint: {
+                        id: generated.route.endpointId,
+                        name: generated.route.endpointName,
+                    },
+                    upstreamModel: generated.route.upstreamModel,
+                    response: {
+                        statusCode: generated.statusCode,
+                    },
+                },
+            }, Date.now() - start, false));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: model },
+                request: { stream: false },
+                result: {
+                    errorType,
+                    errorMessage: error.message
+                }
+            });
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message, type: errorType } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Video generation unavailable", type: errorType } });
+        }
+    });
+}
+function setHeaders(reply, headers) {
+    for (const [key, value] of Object.entries(headers)) {
+        if (Array.isArray(value)) {
+            reply.header(key.toLowerCase(), value.join(", "));
+        }
+        else {
+            reply.header(key.toLowerCase(), value);
+        }
+    }
+}
+function buildLog(requestId, model, outcome, latencyMs, stream) {
+    return {
+        requestId,
+        ts: new Date(),
+        route: {
+            publicModel: model,
+            endpointId: outcome.attempt.endpoint.id,
+            endpointName: outcome.attempt.endpoint.name,
+            upstreamModel: outcome.attempt.upstreamModel
+        },
+        request: { stream },
+        result: {
+            statusCode: outcome.attempt.response.statusCode,
+            latencyMs,
+            totalTokens: null
+        }
+    };
+}