npm - aisubs - Versions diffs - 0.2.0 → 0.3.0 - Mend

aisubs 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/CHANGELOG.md +17 -0
package/README.md +141 -46
package/dist/auth.d.ts +2 -0
package/dist/auth.js +16 -0
package/dist/compatibility.d.ts +14 -0
package/dist/compatibility.js +1521 -0
package/dist/dashboard/assets/index-CEDww1hA.css +2 -0
package/dist/dashboard/assets/{index-V-AoOW2F.js → index-DrnM3oWy.js} +34 -33
package/dist/dashboard/index.html +2 -2
package/dist/dashboard.d.ts +4 -2
package/dist/dashboard.js +152 -86
package/dist/http.d.ts +9 -6
package/dist/http.js +254 -283
package/dist/providers/chatgpt.js +2 -0
package/dist/providers/claude.js +2 -0
package/dist/providers/copilot.js +0 -2
package/dist/realtime.d.ts +6 -0
package/dist/realtime.js +163 -0
package/examples/direct.mjs +31 -8
package/examples/server.mjs +11 -1
package/package.json +9 -1
package/public/aisubs-dashboard.png +0 -0
package/dist/dashboard/assets/index-DYe3pr2a.css +0 -2

package/dist/dashboard/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <meta name="color-scheme" content="light dark" />
     <meta name="theme-color" content="#181818" />
     <title>AI Subs</title>
-    <script type="module" crossorigin src="/assets/index-V-AoOW2F.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DYe3pr2a.css">
+    <script type="module" crossorigin src="/assets/index-DrnM3oWy.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CEDww1hA.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/dashboard.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
-import { type Server } from "node:http";
+import { type FastifyInstance } from "fastify";
+import type { Server } from "node:http";
 import type { SubscriptionAuth } from "./auth.js";
 export interface SubscriptionAuthDashboardOptions {
     auth: SubscriptionAuth;
@@ -6,11 +7,12 @@ export interface SubscriptionAuthDashboardOptions {
     regenerateApiKey?: () => Promise<string>;
     host?: string;
     port?: number;
-    /** Maximum buffered proxy request body. Defaults to 10 MiB. */
+    /** Maximum request body accepted by the compatibility proxy. Defaults to 10 MiB. */
     maxProxyBodyBytes?: number;
 }
 export interface SubscriptionAuthDashboardServer {
     server: Server;
+    app: FastifyInstance;
     apiKey: string;
     url: string;
     bootstrapUrl: string;

package/dist/dashboard.js CHANGED Viewed

@@ -1,10 +1,13 @@
+import cors from "@fastify/cors";
+import websocket from "@fastify/websocket";
+import Fastify from "fastify";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { createServer } from "node:http";
 import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { handleSubscriptionAuthApi, routeSegments, sendJson } from "./http.js";
-import { errorMessage, urlHost } from "./utils.js";
+import { clientAbortSignal, handleSubscriptionAuthApi, routeSegments, sendWebResponse, } from "./http.js";
+import { registerRealtimeProxy } from "./realtime.js";
+import { errorMessage, isRecord, stringValue, urlHost } from "./utils.js";
 const ASSET_DIRECTORY = join(dirname(fileURLToPath(import.meta.url)), "dashboard");
 const CONTENT_TYPES = {
     ".css": "text/css; charset=utf-8",
@@ -20,6 +23,16 @@ function sameSecret(actual, expected) {
     const right = Buffer.from(expected);
     return left.length === right.length && timingSafeEqual(left, right);
 }
+function requestApiKeys(request) {
+    const authorization = request.headers.authorization;
+    const bearer = authorization?.startsWith("Bearer ") ? authorization.slice(7) : undefined;
+    const header = (name) => {
+        const value = request.headers[name];
+        return Array.isArray(value) ? value[0] : value;
+    };
+    const queryKey = new URL(request.url, "http://aisubs.local").searchParams.get("key") ?? undefined;
+    return [bearer, header("x-api-key"), header("x-goog-api-key"), queryKey].filter((value) => value != null);
+}
 function cookie(request, name) {
     for (const part of request.headers.cookie?.split(";") ?? []) {
         const [key, ...value] = part.trim().split("=");
@@ -28,14 +41,14 @@ function cookie(request, name) {
     }
     return undefined;
 }
-function secure(response) {
-    response.setHeader("content-security-policy", "default-src 'self'; base-uri 'none'; connect-src 'self'; font-src 'self'; form-action 'self'; frame-ancestors 'none'; img-src 'self' data:; object-src 'none'; script-src 'self'; style-src 'self'");
-    response.setHeader("referrer-policy", "no-referrer");
-    response.setHeader("cross-origin-opener-policy", "same-origin");
-    response.setHeader("cross-origin-resource-policy", "same-origin");
-    response.setHeader("permissions-policy", "camera=(), geolocation=(), microphone=()");
-    response.setHeader("x-content-type-options", "nosniff");
-    response.setHeader("x-frame-options", "DENY");
+function secure(reply) {
+    reply.header("content-security-policy", "default-src 'self'; base-uri 'none'; connect-src 'self'; font-src 'self'; form-action 'self'; frame-ancestors 'none'; img-src 'self' data:; object-src 'none'; script-src 'self'; style-src 'self'");
+    reply.header("referrer-policy", "no-referrer");
+    reply.header("cross-origin-opener-policy", "same-origin");
+    reply.header("cross-origin-resource-policy", "same-origin");
+    reply.header("permissions-policy", "camera=(), geolocation=(), microphone=()");
+    reply.header("x-content-type-options", "nosniff");
+    reply.header("x-frame-options", "DENY");
 }
 function hostname(value) {
     if (!value)
@@ -47,6 +60,17 @@ function hostname(value) {
         return undefined;
     }
 }
+async function responseFailure(response) {
+    if (response.ok)
+        return undefined;
+    const body = await response
+        .clone()
+        .json()
+        .catch(() => null);
+    const failure = isRecord(body) ? body.error : undefined;
+    const message = isRecord(failure) ? stringValue(failure.message) : stringValue(failure);
+    return (message ?? `HTTP ${response.status}`).slice(0, 2_000);
+}
 export async function createSubscriptionAuthDashboardServer(options) {
     const host = options.host ?? "127.0.0.1";
     if (!["127.0.0.1", "::1", "localhost"].includes(host)) {
@@ -57,75 +81,116 @@ export async function createSubscriptionAuthDashboardServer(options) {
     let regeneratingApiKey;
     const sessionToken = randomBytes(32).toString("base64url");
     const requestLogs = [];
+    const requestErrors = new WeakMap();
     const logStreams = new Set();
     let requestId = 0;
-    const server = createServer(async (request, response) => {
-        secure(response);
-        try {
-            if (hostname(request.headers.host) !== host) {
-                return sendJson(response, 421, { error: "Invalid local host" });
-            }
-            const url = new URL(request.url ?? "/", origin);
-            if (url.pathname.startsWith("/aisubs/")) {
-                const startedAt = performance.now();
-                response.once("finish", () => {
-                    const entry = {
-                        id: ++requestId,
-                        timestamp: Date.now(),
-                        method: request.method ?? "GET",
-                        path: url.pathname,
-                        status: response.statusCode,
-                        durationMs: Math.round(performance.now() - startedAt),
-                    };
-                    requestLogs.push(entry);
-                    if (requestLogs.length > 200)
-                        requestLogs.shift();
-                    const event = `data: ${JSON.stringify(entry)}\n\n`;
-                    for (const stream of logStreams)
-                        stream.write(event);
-                });
-            }
+    const app = Fastify({
+        bodyLimit: options.maxProxyBodyBytes ?? 10 * 1024 * 1024,
+        forceCloseConnections: true,
+    });
+    app.removeAllContentTypeParsers();
+    app.addContentTypeParser("*", { parseAs: "buffer" }, (_request, body, done) => done(null, body));
+    await app.register(cors, {
+        origin: true,
+        credentials: false,
+        methods: ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+        allowedHeaders: [
+            "authorization",
+            "content-type",
+            "x-api-key",
+            "x-goog-api-key",
+            "anthropic-version",
+            "anthropic-beta",
+            "openai-beta",
+        ],
+        exposedHeaders: ["x-request-id", "retry-after"],
+    });
+    await app.register(websocket);
+    await app.register(async (scope) => {
+        registerRealtimeProxy(scope, options.auth, (request) => {
+            return (requestApiKeys(request).some((value) => sameSecret(value, apiKey)) ||
+                sameSecret(cookie(request, "aisubs_session"), sessionToken));
+        });
+    });
+    app.addHook("onRequest", async (request, reply) => {
+        secure(reply);
+        if (hostname(request.headers.host) !== host) {
+            await reply.code(421).send({ error: "Invalid local host" });
+            return;
+        }
+        if (request.url.startsWith("/aisubs/")) {
+            const startedAt = performance.now();
+            reply.raw.once("finish", () => {
+                const path = new URL(request.url, origin).pathname;
+                const entry = {
+                    id: ++requestId,
+                    timestamp: Date.now(),
+                    method: request.method,
+                    path,
+                    status: reply.statusCode,
+                    durationMs: Math.round(performance.now() - startedAt),
+                    error: requestErrors.get(request),
+                };
+                requestLogs.push(entry);
+                if (requestLogs.length > 200)
+                    requestLogs.shift();
+                const event = `data: ${JSON.stringify(entry)}\n\n`;
+                for (const stream of logStreams)
+                    stream.write(event);
+            });
+        }
+    });
+    app.route({
+        method: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+        url: "/*",
+        async handler(request, reply) {
+            const url = new URL(request.url, origin);
             if (url.pathname === "/health") {
-                return sendJson(response, 200, { ok: true }, {
-                    "x-aisubs-service": "aisubs",
-                    "x-aisubs-pid": String(process.pid),
-                });
+                await reply
+                    .header("x-aisubs-service", "aisubs")
+                    .header("x-aisubs-pid", String(process.pid))
+                    .send({ ok: true });
+                return;
             }
             if (request.method === "GET" && url.pathname === "/") {
-                response.setHeader("set-cookie", `aisubs_session=${encodeURIComponent(sessionToken)}; HttpOnly; SameSite=Strict; Path=/`);
+                reply.header("set-cookie", `aisubs_session=${encodeURIComponent(sessionToken)}; HttpOnly; SameSite=Strict; Path=/`);
             }
-            const bearer = request.headers.authorization?.startsWith("Bearer ")
-                ? request.headers.authorization.slice(7)
-                : undefined;
-            const headerKey = Array.isArray(request.headers["x-api-key"])
-                ? request.headers["x-api-key"][0]
-                : request.headers["x-api-key"];
-            const bearerAuthenticated = sameSecret(bearer, apiKey) || sameSecret(headerKey, apiKey);
+            const bearerAuthenticated = requestApiKeys(request).some((value) => sameSecret(value, apiKey));
             const cookieAuthenticated = sameSecret(cookie(request, "aisubs_session"), sessionToken);
             const apiRoute = ["v1", "aisubs"].includes(routeSegments(url.pathname)[0] ?? "");
             if (apiRoute && !bearerAuthenticated && !cookieAuthenticated) {
-                return sendJson(response, 401, { error: "Unauthorized" });
+                await reply.code(401).send({
+                    error: {
+                        message: "Unauthorized",
+                        type: "authentication_error",
+                        code: "invalid_api_key",
+                    },
+                });
+                return;
             }
             if (request.method === "GET" && url.pathname === "/v1/logs/stream") {
-                response.writeHead(200, {
+                reply.hijack();
+                reply.raw.writeHead(200, {
                     "content-type": "text/event-stream",
                     "cache-control": "no-store",
                     connection: "keep-alive",
                 });
-                response.flushHeaders();
+                reply.raw.flushHeaders();
                 for (const entry of requestLogs)
-                    response.write(`data: ${JSON.stringify(entry)}\n\n`);
-                logStreams.add(response);
-                request.once("close", () => logStreams.delete(response));
+                    reply.raw.write(`data: ${JSON.stringify(entry)}\n\n`);
+                logStreams.add(reply.raw);
+                request.raw.once("close", () => logStreams.delete(reply.raw));
                 return;
             }
             if (apiRoute && cookieAuthenticated && !bearerAuthenticated) {
-                if (!["GET", "HEAD", "OPTIONS"].includes(request.method ?? "GET") &&
+                if (!["GET", "HEAD", "OPTIONS"].includes(request.method) &&
                     request.headers.origin !== `http://${request.headers.host}`) {
-                    return sendJson(response, 403, { error: "Cross-origin mutation blocked" });
+                    await reply.code(403).send({ error: "Cross-origin mutation blocked" });
+                    return;
                 }
                 if (request.method === "GET" && url.pathname === "/v1/api-key") {
-                    return sendJson(response, 200, { apiKey });
+                    await reply.send({ apiKey });
+                    return;
                 }
                 if (request.method === "POST" && url.pathname === "/v1/api-key/regenerate") {
                     regeneratingApiKey ??= (options.regenerateApiKey
@@ -134,20 +199,28 @@ export async function createSubscriptionAuthDashboardServer(options) {
                         regeneratingApiKey = undefined;
                     });
                     apiKey = await regeneratingApiKey;
-                    return sendJson(response, 200, { apiKey });
+                    await reply.send({ apiKey });
+                    return;
                 }
             }
             if (apiRoute) {
-                if (!(await handleSubscriptionAuthApi(options.auth, request, response, url, options.maxProxyBodyBytes))) {
-                    sendJson(response, 404, { error: "Not found" });
+                const response = await handleSubscriptionAuthApi(options.auth, request, clientAbortSignal(request, reply));
+                if (response) {
+                    const failure = await responseFailure(response);
+                    if (failure)
+                        requestErrors.set(request, failure);
+                    await sendWebResponse(reply, response);
                 }
+                else
+                    await reply.code(404).send({ error: "Not found" });
                 return;
             }
             const requested = url.pathname === "/" ? "index.html" : url.pathname;
             const assetPath = resolve(ASSET_DIRECTORY, `.${requested}`);
             const assetRelative = relative(ASSET_DIRECTORY, assetPath);
             if (assetRelative.startsWith("..") || isAbsolute(assetRelative)) {
-                return sendJson(response, 404, { error: "Not found" });
+                await reply.code(404).send({ error: "Not found" });
+                return;
             }
             let file = assetPath;
             let body = await readFile(file).catch(() => null);
@@ -155,44 +228,37 @@ export async function createSubscriptionAuthDashboardServer(options) {
                 file = join(ASSET_DIRECTORY, "index.html");
                 body = await readFile(file);
             }
-            response.writeHead(200, {
-                "content-type": CONTENT_TYPES[extname(file)] ?? "application/octet-stream",
-                "cache-control": relative(ASSET_DIRECTORY, file).startsWith("assets/")
-                    ? "public, max-age=31536000, immutable"
-                    : "no-store",
-            });
-            response.end(body);
-        }
-        catch (error) {
-            if (response.headersSent)
-                response.destroy();
-            else
-                sendJson(response, 400, { error: errorMessage(error) });
-        }
+            await reply
+                .type(CONTENT_TYPES[extname(file)] ?? "application/octet-stream")
+                .header("cache-control", relative(ASSET_DIRECTORY, file).startsWith("assets/")
+                ? "public, max-age=31536000, immutable"
+                : "no-store")
+                .send(body);
+        },
     });
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(options.port ?? 0, host, () => {
-            server.off("error", reject);
-            resolve();
-        });
+    app.setErrorHandler(async (error, request, reply) => {
+        requestErrors.set(request, errorMessage(error));
+        await reply.code(400).send({ error: errorMessage(error) });
     });
-    const address = server.address();
+    await app.listen({ port: options.port ?? 0, host });
+    const address = app.server.address();
     if (!address || typeof address === "string") {
+        await app.close();
         throw new Error("Unable to determine AI Subs dashboard port");
     }
     const url = `${origin}:${address.port}`;
     return {
-        server,
+        server: app.server,
+        app,
         get apiKey() {
             return apiKey;
         },
         url,
         bootstrapUrl: url,
-        close: () => {
+        close: async () => {
             for (const stream of logStreams)
                 stream.end();
-            return new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+            await app.close();
         },
     };
 }

package/dist/http.d.ts CHANGED Viewed

@@ -1,22 +1,25 @@
-import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { type FastifyInstance, type FastifyReply, type FastifyRequest } from "fastify";
+import type { Server } from "node:http";
 import type { SubscriptionAuth } from "./auth.js";
-export declare function readJsonBody(request: IncomingMessage): Promise<unknown>;
-export declare function readProxyBody(request: IncomingMessage, maxBytes?: number): Promise<Buffer>;
-export declare function sendJson(response: ServerResponse, status: number, body: unknown, headers?: Record<string, string>): void;
 export declare function routeSegments(pathname: string): string[];
-export declare function handleSubscriptionAuthApi(auth: SubscriptionAuth, request: IncomingMessage, response: ServerResponse, url: URL, maxProxyBodyBytes?: number): Promise<boolean>;
+export declare function sendWebResponse(reply: FastifyReply, upstream: Response): Promise<void>;
+export declare function handleSubscriptionAuthApi(auth: SubscriptionAuth, request: FastifyRequest, signal?: AbortSignal): Promise<Response | null>;
+/** Abort upstream work only when the client disconnects before the response finishes. */
+export declare function clientAbortSignal(request: FastifyRequest, reply: FastifyReply): AbortSignal;
 export interface SubscriptionAuthServerOptions {
     auth: SubscriptionAuth;
     apiKey: string;
     host?: string;
     port?: number;
-    /** Maximum buffered proxy request body. Defaults to 10 MiB. */
+    /** Maximum request body accepted by the compatibility proxy. Defaults to 10 MiB. */
     maxProxyBodyBytes?: number;
 }
 export interface SubscriptionAuthServer {
     server: Server;
+    app: FastifyInstance;
     apiKey: string;
     url: string;
     close(): Promise<void>;
 }
+export declare function createApiApp(options: SubscriptionAuthServerOptions): FastifyInstance;
 export declare function createSubscriptionAuthServer(options: SubscriptionAuthServerOptions): Promise<SubscriptionAuthServer>;