llm-simple-router 0.3.7 → 0.4.1

package/dist/proxy/stream-proxy.js

@@ -0,0 +1,263 @@
+import { PassThrough } from "stream";
+import { UPSTREAM_SUCCESS, filterHeaders } from "./types.js";
+import { _transportInternals, buildRequestOptions, } from "./transport.js";
+const UPSTREAM_BAD_GATEWAY = 502;
+const BUFFER_SIZE_LIMIT = 4096;
+class StreamProxy {
+    statusCode;
+    sentUpstreamHeaders;
+    reply;
+    metricsTransform;
+    checkEarlyError;
+    timeoutMs;
+    state = "BUFFERING";
+    resolved = false;
+    resolveFn = null;
+    pendingResult = null;
+    bufferChunks = [];
+    captureChunks = [];
+    idleTimer = null;
+    headersSent = false;
+    closeHandlerRegistered = false;
+    sseHeaders;
+    passThrough = new PassThrough();
+    pipeEntry;
+    constructor(statusCode, rawUpstreamHeaders, sentUpstreamHeaders, reply, metricsTransform, checkEarlyError, timeoutMs) {
+        this.statusCode = statusCode;
+        this.sentUpstreamHeaders = sentUpstreamHeaders;
+        this.reply = reply;
+        this.metricsTransform = metricsTransform;
+        this.checkEarlyError = checkEarlyError;
+        this.timeoutMs = timeoutMs;
+        this.sseHeaders = filterHeaders(rawUpstreamHeaders);
+        this.sseHeaders["Content-Type"] = "text/event-stream";
+        this.sseHeaders["Cache-Control"] = "no-cache";
+        this.sseHeaders["Connection"] = "keep-alive";
+        this.pipeEntry = metricsTransform ?? this.passThrough;
+    }
+    bindResolve(resolve) {
+        this.resolveFn = resolve;
+        if (this.pendingResult)
+            resolve(this.pendingResult);
+    }
+    transition(newState) {
+        const VALID = {
+            BUFFERING: ["STREAMING", "EARLY_ERROR"],
+            STREAMING: ["COMPLETED", "ABORTED"],
+            COMPLETED: [],
+            EARLY_ERROR: [],
+            ABORTED: [],
+        };
+        if (!VALID[this.state].includes(newState)) {
+            throw new Error(`Invalid state transition: ${this.state} → ${newState}`);
+        }
+        this.state = newState;
+    }
+    terminal(kind, extra = {}, deferred = false) {
+        if (this.resolved)
+            return;
+        this.resolved = true;
+        const base = {
+            statusCode: this.statusCode,
+            upstreamResponseHeaders: this.sseHeaders,
+            sentHeaders: this.sentUpstreamHeaders,
+        };
+        let result;
+        switch (kind) {
+            case "stream_success":
+                result = { kind: "stream_success", ...base, metrics: extra.metrics };
+                break;
+            case "stream_error":
+                result = { kind: "stream_error", ...base, body: extra.body, headers: this.sseHeaders };
+                break;
+            case "stream_abort":
+                result = { kind: "stream_abort", ...base, metrics: extra.metrics };
+                break;
+        }
+        // deferred 模式：先 resolve 让 handler 链路（日志写入等）在 microtask 中执行，
+        // cleanup 由调用方在 setImmediate（macrotask）中处理。
+        if (deferred) {
+            if (this.resolveFn) {
+                this.resolveFn(result);
+            }
+            else {
+                this.pendingResult = result;
+            }
+        }
+        else {
+            this.cleanup();
+            if (this.resolveFn) {
+                this.resolveFn(result);
+            }
+            else {
+                this.pendingResult = result;
+            }
+        }
+    }
+    cleanup() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+        if (!this.passThrough.destroyed)
+            this.passThrough.destroy();
+        if (this.metricsTransform && !this.metricsTransform.destroyed)
+            this.metricsTransform.destroy();
+    }
+    collectMetrics(isComplete) {
+        if (!this.metricsTransform)
+            return undefined;
+        const result = this.metricsTransform.getExtractor().getMetrics();
+        return isComplete ? result : { ...result, is_complete: 0 };
+    }
+    resetIdleTimer() {
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => {
+            if (this.resolved)
+                return;
+            this.terminal("stream_abort", { metrics: this.collectMetrics(false) });
+        }, this.timeoutMs);
+    }
+    startStreaming() {
+        if (this.headersSent)
+            return;
+        this.transition("STREAMING");
+        this.headersSent = true;
+        this.reply.raw.writeHead(this.statusCode, this.sseHeaders);
+        if (this.metricsTransform) {
+            this.metricsTransform.pipe(this.passThrough, { end: true });
+        }
+        // 手动转发而非 pipe，避免 Node.js 在 dest 上自动注册 close/finish handler
+        this.passThrough.on("data", (chunk) => {
+            this.reply.raw.write(chunk);
+        });
+        // 不在 passThrough end 事件中调用 reply.raw.end()，
+        // 因为 onEnd() 统一管理响应结束时机，确保日志在 reply end 之前写入
+        for (const c of this.bufferChunks)
+            this.pipeEntry.write(c);
+        this.bufferChunks.length = 0;
+    }
+    registerCloseHandler() {
+        if (this.closeHandlerRegistered)
+            return;
+        this.closeHandlerRegistered = true;
+        this.reply.raw.on("close", () => {
+            if (this.resolved)
+                return;
+            if (this.state === "BUFFERING" || this.state === "STREAMING") {
+                this.transition("ABORTED");
+            }
+            this.terminal("stream_abort", { metrics: this.collectMetrics(false) });
+        });
+    }
+    onData(chunk) {
+        if (this.resolved)
+            return;
+        this.resetIdleTimer();
+        this.captureChunks.push(chunk);
+        if (this.state === "BUFFERING") {
+            this.bufferChunks.push(chunk);
+            const buf = Buffer.concat(this.bufferChunks);
+            const text = buf.toString("utf-8");
+            if (text.includes("\n\n")) {
+                if (this.checkEarlyError?.(text)) {
+                    this.transition("EARLY_ERROR");
+                    this.terminal("stream_error", { body: text });
+                    return;
+                }
+                this.startStreaming();
+            }
+            else if (buf.length >= BUFFER_SIZE_LIMIT) {
+                this.startStreaming();
+            }
+            return;
+        }
+        this.pipeEntry.write(chunk);
+    }
+    onEnd() {
+        if (this.resolved)
+            return;
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        if (this.state === "BUFFERING" && this.checkEarlyError) {
+            const text = Buffer.concat(this.captureChunks).toString("utf-8");
+            if (this.checkEarlyError(text)) {
+                this.transition("EARLY_ERROR");
+                this.terminal("stream_error", { body: text });
+                return;
+            }
+            this.startStreaming();
+        }
+        if (this.state === "STREAMING") {
+            this.transition("COMPLETED");
+        }
+        // 通过 terminal 的 deferred 模式统一 resolve：
+        // 先 resolve Promise，让 handler 链路（日志写入等）在 microtask 中执行。
+        // reply.raw.end() 延迟到 setImmediate（macrotask），确保 microtask 先完成。
+        // light-my-request 监听 reply.raw 的 end 事件判定响应完成，
+        // 这保证了 inject() 返回时日志已经写入 DB。
+        const metrics = this.collectMetrics(true);
+        this.terminal("stream_success", { metrics }, true);
+        // 延迟结束管道和响应，属于 reply 层面操作，不属于 StreamProxy 状态管理
+        setImmediate(() => {
+            this.pipeEntry.end();
+            if (this.headersSent)
+                this.reply.raw.end();
+            this.cleanup();
+        });
+    }
+    onUpstreamError(err) {
+        if (this.resolved)
+            return;
+        this.resolved = true;
+        this.cleanup();
+        const result = { kind: "throw", error: err };
+        if (this.resolveFn) {
+            this.resolveFn(result);
+        }
+        else {
+            this.pendingResult = result;
+        }
+    }
+}
+// ---------- callStream ----------
+export function callStream(backend, apiKey, body, clientHeaders, reply, timeoutMs, upstreamPath, buildHeaders, metricsTransform, checkEarlyError, compatResolve) {
+    return new Promise((resolve) => {
+        const effectiveResolve = compatResolve ?? resolve;
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const payload = JSON.stringify(body);
+        const upstreamHeaders = buildHeaders(clientHeaders, apiKey, Buffer.byteLength(payload));
+        const options = buildRequestOptions(url, upstreamHeaders);
+        const upstreamReq = _transportInternals.createUpstreamRequest(url, options);
+        upstreamReq.on("response", (upstreamRes) => {
+            const statusCode = upstreamRes.statusCode || UPSTREAM_BAD_GATEWAY;
+            if (statusCode !== UPSTREAM_SUCCESS) {
+                const chunks = [];
+                upstreamRes.on("data", (chunk) => chunks.push(chunk));
+                upstreamRes.on("end", () => {
+                    effectiveResolve({
+                        kind: "stream_error",
+                        statusCode,
+                        body: Buffer.concat(chunks).toString("utf-8"),
+                        headers: filterHeaders(upstreamRes.headers),
+                        sentHeaders: upstreamHeaders,
+                    });
+                });
+                return;
+            }
+            const proxy = new StreamProxy(statusCode, upstreamRes.headers, upstreamHeaders, reply, metricsTransform, checkEarlyError, timeoutMs);
+            proxy.bindResolve(effectiveResolve);
+            proxy.registerCloseHandler();
+            // 无 early error checker 时直接开始流式传输
+            if (!checkEarlyError)
+                proxy.startStreaming();
+            proxy.resetIdleTimer();
+            upstreamRes.on("data", (chunk) => proxy.onData(chunk));
+            upstreamRes.on("end", () => proxy.onEnd());
+            upstreamRes.on("error", (err) => proxy.onUpstreamError(err));
+        });
+        upstreamReq.on("error", (error) => effectiveResolve({ kind: "throw", error }));
+        upstreamReq.write(payload);
+        upstreamReq.end();
+    });
+}

package/dist/proxy/{upstream-call.d.ts → transport.d.ts}

@@ -1,7 +1,8 @@
 import type { FastifyReply } from "fastify";
-import type { RawHeaders } from "./proxy-core.js";
+import type { RawHeaders, TransportResult } from "./types.js";
 import type { MetricsResult } from "../metrics/metrics-extractor.js";
-import { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
+import type { SSEMetricsTransform } from "../metrics/sse-metrics-transform.js";
+export { callStream } from "./stream-proxy.js";
 export interface UpstreamRequestOptions {
     hostname: string;
     port: number;
@@ -9,6 +10,23 @@ export interface UpstreamRequestOptions {
     method: string;
     headers: Record<string, string>;
 }
+export declare const _transportInternals: {
+    createUpstreamRequest(url: URL, options: UpstreamRequestOptions): import("http").ClientRequest;
+};
+export declare function createUpstreamRequest(url: URL, options: UpstreamRequestOptions): import("http").ClientRequest;
+export declare function buildRequestOptions(url: URL, headers: Record<string, string>, method?: string): UpstreamRequestOptions;
+export type BuildHeadersFn = (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>;
+export declare function callNonStream(backend: {
+    base_url: string;
+}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: BuildHeadersFn): Promise<TransportResult>;
+export interface GetTransportResult {
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+}
+export declare function callGet(backend: {
+    base_url: string;
+}, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string) => Record<string, string>): Promise<GetTransportResult>;
 export interface ProxyResult {
     statusCode: number;
     body: string;
@@ -22,22 +40,11 @@ export interface StreamProxyResult {
     upstreamResponseHeaders?: Record<string, string>;
     sentHeaders?: Record<string, string>;
     metricsResult?: MetricsResult;
+    abnormalClose?: boolean;
 }
-export interface GetProxyResult {
-    statusCode: number;
-    body: string;
-    headers: Record<string, string>;
-}
-/** 根据 URL scheme 选择 http 或 https 模块 */
-export declare function createUpstreamRequest(url: URL, options: UpstreamRequestOptions): import("http").ClientRequest;
-/** 从 URL + headers 构造 Node.js http.request 所需的 options */
-export declare function buildRequestOptions(url: URL, headers: Record<string, string>, method?: string): UpstreamRequestOptions;
-export declare function proxyNonStream(backend: {
-    base_url: string;
-}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>): Promise<ProxyResult>;
-export declare function proxyStream(backend: {
+export declare function proxyNonStreamCompat(backend: {
     base_url: string;
-}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, reply: FastifyReply, timeoutMs: number, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string, bytes?: number) => Record<string, string>, metricsTransform?: SSEMetricsTransform): Promise<StreamProxyResult>;
-export declare function proxyGetRequest(backend: {
+}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: BuildHeadersFn): Promise<ProxyResult>;
+export declare function proxyStreamCompat(backend: {
     base_url: string;
-}, apiKey: string, clientHeaders: RawHeaders, upstreamPath: string, buildHeaders: (cliHdrs: RawHeaders, key: string) => Record<string, string>): Promise<GetProxyResult>;
+}, apiKey: string, body: Record<string, unknown>, clientHeaders: RawHeaders, reply: FastifyReply, timeoutMs: number, upstreamPath: string, buildHeaders: BuildHeadersFn, metricsTransform?: SSEMetricsTransform, checkEarlyError?: (bufferedData: string) => boolean): Promise<StreamProxyResult>;

package/dist/proxy/transport.js

@@ -0,0 +1,128 @@
+import { request as httpRequestFn } from "http";
+import { request as httpsRequestFn } from "https";
+import { UPSTREAM_SUCCESS, filterHeaders } from "./types.js";
+import { callStream } from "./stream-proxy.js";
+// Re-export callStream from stream-proxy.ts for external consumers
+export { callStream } from "./stream-proxy.js";
+// ---------- Constants ----------
+const UPSTREAM_BAD_GATEWAY = 502;
+const UPSTREAM_SUCCESS_RANGE = 100;
+const HTTPS_DEFAULT_PORT = 443;
+const HTTP_DEFAULT_PORT = 80;
+export const _transportInternals = {
+    createUpstreamRequest(url, options) {
+        return url.protocol === "https:"
+            ? httpsRequestFn(options)
+            : httpRequestFn(options);
+    },
+};
+export function createUpstreamRequest(url, options) {
+    return _transportInternals.createUpstreamRequest(url, options);
+}
+export function buildRequestOptions(url, headers, method = "POST") {
+    return {
+        hostname: url.hostname,
+        port: Number(url.port) ||
+            (url.protocol === "https:" ? HTTPS_DEFAULT_PORT : HTTP_DEFAULT_PORT),
+        path: url.pathname,
+        method,
+        headers,
+    };
+}
+// ---------- callNonStream ----------
+export function callNonStream(backend, apiKey, body, clientHeaders, upstreamPath, buildHeaders) {
+    return new Promise((resolve) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const payload = JSON.stringify(body);
+        const upstreamHeaders = buildHeaders(clientHeaders, apiKey, Buffer.byteLength(payload));
+        const options = buildRequestOptions(url, upstreamHeaders);
+        const req = _transportInternals.createUpstreamRequest(url, options);
+        req.on("response", (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const statusCode = res.statusCode || UPSTREAM_BAD_GATEWAY;
+                const responseBody = Buffer.concat(chunks).toString("utf-8");
+                const headers = filterHeaders(res.headers);
+                if (statusCode >= UPSTREAM_SUCCESS && statusCode < UPSTREAM_SUCCESS + UPSTREAM_SUCCESS_RANGE) {
+                    resolve({
+                        kind: "success",
+                        statusCode,
+                        body: responseBody,
+                        headers,
+                        sentHeaders: upstreamHeaders,
+                        sentBody: payload,
+                    });
+                }
+                else {
+                    resolve({
+                        kind: "error",
+                        statusCode,
+                        body: responseBody,
+                        headers,
+                        sentHeaders: upstreamHeaders,
+                        sentBody: payload,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => resolve({ kind: "throw", error }));
+        req.write(payload);
+        req.end();
+    });
+}
+export function callGet(backend, apiKey, clientHeaders, upstreamPath, buildHeaders) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(`${backend.base_url}${upstreamPath}`);
+        const headers = buildHeaders(clientHeaders, apiKey);
+        const options = buildRequestOptions(url, headers, "GET");
+        const req = _transportInternals.createUpstreamRequest(url, options);
+        req.on("response", (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                resolve({
+                    statusCode: res.statusCode || UPSTREAM_BAD_GATEWAY,
+                    body: Buffer.concat(chunks).toString("utf-8"),
+                    headers: filterHeaders(res.headers),
+                });
+            });
+        });
+        req.on("error", (err) => reject(err));
+        req.end();
+    });
+}
+export function proxyNonStreamCompat(backend, apiKey, body, clientHeaders, upstreamPath, buildHeaders) {
+    return callNonStream(backend, apiKey, body, clientHeaders, upstreamPath, buildHeaders)
+        .then((r) => {
+        if (r.kind === "throw")
+            throw r.error;
+        return {
+            statusCode: r.statusCode,
+            body: "body" in r ? r.body : "",
+            headers: "headers" in r ? r.headers : {},
+            sentHeaders: r.sentHeaders,
+            sentBody: "sentBody" in r ? r.sentBody : "",
+        };
+    });
+}
+export function proxyStreamCompat(backend, apiKey, body, clientHeaders, reply, timeoutMs, upstreamPath, buildHeaders, metricsTransform, checkEarlyError) {
+    return new Promise((resolve, reject) => {
+        function onResult(r) {
+            if (r.kind === "throw") {
+                reject(r.error);
+                return;
+            }
+            const metrics = (r.kind === "stream_success" || r.kind === "stream_abort") ? r.metrics : undefined;
+            resolve({
+                statusCode: r.statusCode,
+                responseBody: r.kind === "stream_success" ? undefined : ("body" in r ? r.body : undefined),
+                upstreamResponseHeaders: ("upstreamResponseHeaders" in r ? r.upstreamResponseHeaders : undefined) ?? ("headers" in r ? r.headers : {}) ?? {},
+                sentHeaders: r.sentHeaders,
+                metricsResult: metrics ?? undefined,
+                abnormalClose: r.kind === "stream_abort",
+            });
+        }
+        callStream(backend, apiKey, body, clientHeaders, reply, timeoutMs, upstreamPath, buildHeaders, metricsTransform, checkEarlyError, onResult);
+    });
+}

package/dist/proxy/types.d.ts

@@ -0,0 +1,58 @@
+import type { MetricsResult } from "../metrics/metrics-extractor.js";
+export declare const UPSTREAM_SUCCESS = 200;
+export type RawHeaders = Record<string, string | string[] | undefined>;
+export declare function filterHeaders(raw: RawHeaders): Record<string, string>;
+/**
+ * 上游调用的传输层结果。
+ * discriminated union，按 kind 区分 6 种情况：
+ * - success / stream_success：正常完成
+ * - stream_error / stream_abort：流式传输中途异常
+ * - error：非流式错误响应
+ * - throw：未捕获异常
+ */
+export type TransportResult = {
+    kind: "success";
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+    sentHeaders: Record<string, string>;
+    sentBody: string;
+} | {
+    kind: "stream_success";
+    statusCode: number;
+    metrics?: MetricsResult;
+    upstreamResponseHeaders?: Record<string, string>;
+    sentHeaders: Record<string, string>;
+} | {
+    kind: "stream_error";
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+    sentHeaders: Record<string, string>;
+} | {
+    kind: "stream_abort";
+    statusCode: number;
+    metrics?: MetricsResult;
+    upstreamResponseHeaders?: Record<string, string>;
+    sentHeaders: Record<string, string>;
+} | {
+    kind: "error";
+    statusCode: number;
+    body: string;
+    headers: Record<string, string>;
+    sentHeaders: Record<string, string>;
+    sentBody: string;
+} | {
+    kind: "throw";
+    error: Error;
+};
+/**
+ * 跨 provider failover 时由 ResilienceLayer 抛出，
+ * orchestrator 捕获后释放当前信号量并获取新 provider 的信号量。
+ */
+export declare class ProviderSwitchNeeded extends Error {
+    readonly targetProviderId: string;
+    constructor(targetProviderId: string);
+}
+/** 流式传输阶段状态 */
+export type StreamState = "BUFFERING" | "STREAMING" | "COMPLETED" | "EARLY_ERROR" | "ABORTED";

package/dist/proxy/types.js

@@ -0,0 +1,30 @@
+// ---------- Shared constants & types ----------
+export const UPSTREAM_SUCCESS = 200;
+/** 过滤掉不应转发给下游的 hop-by-hop headers */
+const SKIP_DOWNSTREAM = new Set([
+    "content-length",
+    "transfer-encoding",
+    "connection",
+    "keep-alive",
+]);
+export function filterHeaders(raw) {
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value == null || SKIP_DOWNSTREAM.has(key.toLowerCase()))
+            continue;
+        out[key] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    return out;
+}
+/**
+ * 跨 provider failover 时由 ResilienceLayer 抛出，
+ * orchestrator 捕获后释放当前信号量并获取新 provider 的信号量。
+ */
+export class ProviderSwitchNeeded extends Error {
+    targetProviderId;
+    constructor(targetProviderId) {
+        super(`Provider switch needed: ${targetProviderId}`);
+        this.targetProviderId = targetProviderId;
+        this.name = "ProviderSwitchNeeded";
+    }
+}

package/dist/proxy/usage-window-tracker.d.ts

@@ -0,0 +1,11 @@
+import Database from "better-sqlite3";
+export declare class UsageWindowTracker {
+    private db;
+    constructor(db: Database.Database);
+    /** 请求成功后调用，按需创建新窗口 */
+    recordRequest(routerKeyId?: string): void;
+    /** 启动时补齐因宕机/重启而缺失的窗口 */
+    reconcileOnStartup(): void;
+    /** 从 baseTime 开始，每 5h 一个窗口，直到覆盖 lastLogTime */
+    private backfillWindows;
+}

package/dist/proxy/usage-window-tracker.js

@@ -0,0 +1,75 @@
+import { randomUUID } from "crypto";
+import { getLatestWindow, insertWindow } from "../db/usage-windows.js";
+import { toSqliteDatetime, parseSqliteDatetime as parseDate } from "../utils/datetime.js";
+// eslint-disable-next-line no-magic-numbers
+const WINDOW_DURATION_MS = 5 * 3600_000;
+export class UsageWindowTracker {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** 请求成功后调用，按需创建新窗口 */
+    recordRequest(routerKeyId) {
+        const now = new Date();
+        const latest = getLatestWindow(this.db, routerKeyId);
+        if (!latest || now > parseDate(latest.end_time)) {
+            const startTime = truncateToMinute(now);
+            insertWindow(this.db, {
+                id: randomUUID(),
+                router_key_id: routerKeyId ?? null,
+                start_time: toSqliteDatetime(startTime),
+                end_time: toSqliteDatetime(new Date(startTime.getTime() + WINDOW_DURATION_MS)),
+            });
+        }
+    }
+    /** 启动时补齐因宕机/重启而缺失的窗口 */
+    reconcileOnStartup() {
+        const latest = getLatestWindow(this.db);
+        // 查找 request_logs 中最新一条请求的时间
+        const lastLog = this.db.prepare("SELECT created_at FROM request_logs ORDER BY created_at DESC LIMIT 1").get();
+        if (!lastLog)
+            return;
+        if (!latest) {
+            // 从未创建过窗口，但有请求记录，从最早请求创建初始窗口
+            const firstLog = this.db.prepare("SELECT created_at FROM request_logs ORDER BY created_at ASC LIMIT 1").get();
+            if (!firstLog)
+                return;
+            const start = parseDate(firstLog.created_at);
+            const truncated = truncateToMinute(start);
+            insertWindow(this.db, {
+                id: randomUUID(),
+                router_key_id: null,
+                start_time: toSqliteDatetime(truncated),
+                end_time: toSqliteDatetime(new Date(truncated.getTime() + WINDOW_DURATION_MS)),
+            });
+            // 继续补齐后续窗口
+            this.backfillWindows(truncated);
+            return;
+        }
+        // 有窗口，检查 end_time 之后是否有请求
+        this.backfillWindows(parseDate(latest.end_time));
+    }
+    /** 从 baseTime 开始，每 5h 一个窗口，直到覆盖 lastLogTime */
+    backfillWindows(baseTime) {
+        const lastLog = this.db.prepare("SELECT created_at FROM request_logs ORDER BY created_at DESC LIMIT 1").get();
+        if (!lastLog)
+            return;
+        const lastLogTime = parseDate(lastLog.created_at);
+        let windowStart = baseTime;
+        while (windowStart < lastLogTime) {
+            const windowEnd = new Date(windowStart.getTime() + WINDOW_DURATION_MS);
+            insertWindow(this.db, {
+                id: randomUUID(),
+                router_key_id: null,
+                start_time: toSqliteDatetime(windowStart),
+                end_time: toSqliteDatetime(windowEnd),
+            });
+            windowStart = windowEnd;
+        }
+    }
+}
+function truncateToMinute(date) {
+    const d = new Date(date);
+    d.setSeconds(0, 0);
+    return d;
+}

package/dist/utils/datetime.d.ts

@@ -0,0 +1,4 @@
+/** Date → SQLite datetime 文本 (YYYY-MM-DD HH:MM:SS)，UTC 时区，与 DEFAULT (datetime('now')) 对齐 */
+export declare function toSqliteDatetime(date: Date): string;
+/** 兼容 ISO 和 SQLite datetime 格式的日期解析，均视为 UTC */
+export declare function parseSqliteDatetime(s: string): Date;

package/dist/utils/datetime.js

@@ -0,0 +1,10 @@
+/** Date → SQLite datetime 文本 (YYYY-MM-DD HH:MM:SS)，UTC 时区，与 DEFAULT (datetime('now')) 对齐 */
+export function toSqliteDatetime(date) {
+    return date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
+}
+/** 兼容 ISO 和 SQLite datetime 格式的日期解析，均视为 UTC */
+export function parseSqliteDatetime(s) {
+    if (s.includes("T"))
+        return new Date(s);
+    return new Date(s + "Z");
+}

package/frontend-dist/assets/CardContent-fmM_iiuR.js

@@ -0,0 +1 @@
+import{Ft as e,K as t,Lt as n,U as r,at as i,ct as a,r as o}from"./button-qxGNBunr.js";var s=[`data-size`],c=t({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(t){let c=t;return(l,u)=>(i(),r(`div`,{"data-slot":`card`,"data-size":t.size,class:n(e(o)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-lg py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-lg *:[img:last-child]:rounded-b-lg group/card flex flex-col`,c.class))},[a(l.$slots,`default`)],10,s))}}),l=t({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(t){let s=t;return(t,c)=>(i(),r(`div`,{"data-slot":`card-content`,class:n(e(o)(`px-4 group-data-[size=sm]/card:px-3`,s.class))},[a(t.$slots,`default`)],2))}});export{c as n,l as t};

package/frontend-dist/assets/CardHeader-BzzFzZ1B.js

@@ -0,0 +1 @@
+import{Ft as e,K as t,Lt as n,U as r,at as i,ct as a,r as o}from"./button-qxGNBunr.js";var s=t({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(t){let s=t;return(t,c)=>(i(),r(`div`,{"data-slot":`card-header`,class:n(e(o)(`gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]`,s.class))},[a(t.$slots,`default`)],2))}});export{s as t};

package/frontend-dist/assets/CardTitle-09d7O-11.js

@@ -0,0 +1 @@
+import{Ft as e,K as t,Lt as n,U as r,at as i,ct as a,r as o}from"./button-qxGNBunr.js";var s=t({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(t){let s=t;return(t,c)=>(i(),r(`div`,{"data-slot":`card-title`,class:n(e(o)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm cn-font-heading`,s.class))},[a(t.$slots,`default`)],2))}});export{s as t};