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

aisubs 0.1.0 → 0.2.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 (18) hide show

package/README.md +381 -425
package/dist/auth.js +7 -2
package/dist/cli.js +10 -7
package/dist/dashboard/assets/index-DYe3pr2a.css +2 -0
package/dist/dashboard/assets/index-V-AoOW2F.js +83 -0
package/dist/dashboard/index.html +2 -2
package/dist/dashboard.d.ts +1 -0
package/dist/dashboard.js +86 -27
package/dist/http.js +140 -3
package/dist/index.d.ts +1 -1
package/dist/index.js +1 -1
package/dist/store.d.ts +6 -0
package/dist/store.js +51 -2
package/examples/server.mjs +6 -4
package/package.json +1 -1
package/public/aisubs-dashboard.png +0 -0
package/dist/dashboard/assets/index-BMoILzPw.js +0 -64
package/dist/dashboard/assets/index-DHqDdNVe.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-BMoILzPw.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DHqDdNVe.css">
+    <script type="module" crossorigin src="/assets/index-V-AoOW2F.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DYe3pr2a.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/dashboard.d.ts CHANGED Viewed

@@ -3,6 +3,7 @@ import type { SubscriptionAuth } from "./auth.js";
 export interface SubscriptionAuthDashboardOptions {
     auth: SubscriptionAuth;
     apiKey?: string;
+    regenerateApiKey?: () => Promise<string>;
     host?: string;
     port?: number;
     /** Maximum buffered proxy request body. Defaults to 10 MiB. */

package/dist/dashboard.js CHANGED Viewed

@@ -37,35 +37,62 @@ function secure(response) {
     response.setHeader("x-content-type-options", "nosniff");
     response.setHeader("x-frame-options", "DENY");
 }
+function hostname(value) {
+    if (!value)
+        return undefined;
+    try {
+        return new URL(`http://${value}`).hostname.replace(/^\[|\]$/g, "");
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function createSubscriptionAuthDashboardServer(options) {
     const host = options.host ?? "127.0.0.1";
     if (!["127.0.0.1", "::1", "localhost"].includes(host)) {
         throw new Error("The AI Subs dashboard may only bind to localhost");
     }
     const origin = `http://${urlHost(host)}`;
-    const apiKey = options.apiKey ?? randomBytes(32).toString("base64url");
-    const bootstrapToken = randomBytes(32).toString("base64url");
+    let apiKey = options.apiKey ?? `aisubs_${randomBytes(32).toString("base64url")}`;
+    let regeneratingApiKey;
     const sessionToken = randomBytes(32).toString("base64url");
-    let bootstrapAvailable = true;
+    const requestLogs = [];
+    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 === "/health")
-                return sendJson(response, 200, { ok: true });
-            if (request.method === "GET" && url.pathname === "/bootstrap") {
-                if (!bootstrapAvailable ||
-                    !sameSecret(url.searchParams.get("token") ?? undefined, bootstrapToken)) {
-                    return sendJson(response, 401, { error: "Bootstrap link is invalid or has expired" });
-                }
-                bootstrapAvailable = false;
-                response.writeHead(302, {
-                    location: "/",
-                    "cache-control": "no-store",
-                    "set-cookie": `aisubs_session=${encodeURIComponent(sessionToken)}; HttpOnly; SameSite=Strict; Path=/`,
+            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);
+                });
+            }
+            if (url.pathname === "/health") {
+                return sendJson(response, 200, { ok: true }, {
+                    "x-aisubs-service": "aisubs",
+                    "x-aisubs-pid": String(process.pid),
                 });
-                response.end();
-                return;
+            }
+            if (request.method === "GET" && url.pathname === "/") {
+                response.setHeader("set-cookie", `aisubs_session=${encodeURIComponent(sessionToken)}; HttpOnly; SameSite=Strict; Path=/`);
             }
             const bearer = request.headers.authorization?.startsWith("Bearer ")
                 ? request.headers.authorization.slice(7)
@@ -75,16 +102,42 @@ export async function createSubscriptionAuthDashboardServer(options) {
                 : request.headers["x-api-key"];
             const bearerAuthenticated = sameSecret(bearer, apiKey) || sameSecret(headerKey, apiKey);
             const cookieAuthenticated = sameSecret(cookie(request, "aisubs_session"), sessionToken);
-            if (!bearerAuthenticated && !cookieAuthenticated) {
+            const apiRoute = ["v1", "aisubs"].includes(routeSegments(url.pathname)[0] ?? "");
+            if (apiRoute && !bearerAuthenticated && !cookieAuthenticated) {
                 return sendJson(response, 401, { error: "Unauthorized" });
             }
-            if (cookieAuthenticated &&
-                !bearerAuthenticated &&
-                !["GET", "HEAD", "OPTIONS"].includes(request.method ?? "GET") &&
-                request.headers.origin !== `http://${request.headers.host}`) {
-                return sendJson(response, 403, { error: "Cross-origin mutation blocked" });
+            if (request.method === "GET" && url.pathname === "/v1/logs/stream") {
+                response.writeHead(200, {
+                    "content-type": "text/event-stream",
+                    "cache-control": "no-store",
+                    connection: "keep-alive",
+                });
+                response.flushHeaders();
+                for (const entry of requestLogs)
+                    response.write(`data: ${JSON.stringify(entry)}\n\n`);
+                logStreams.add(response);
+                request.once("close", () => logStreams.delete(response));
+                return;
+            }
+            if (apiRoute && cookieAuthenticated && !bearerAuthenticated) {
+                if (!["GET", "HEAD", "OPTIONS"].includes(request.method ?? "GET") &&
+                    request.headers.origin !== `http://${request.headers.host}`) {
+                    return sendJson(response, 403, { error: "Cross-origin mutation blocked" });
+                }
+                if (request.method === "GET" && url.pathname === "/v1/api-key") {
+                    return sendJson(response, 200, { apiKey });
+                }
+                if (request.method === "POST" && url.pathname === "/v1/api-key/regenerate") {
+                    regeneratingApiKey ??= (options.regenerateApiKey
+                        ? options.regenerateApiKey()
+                        : Promise.resolve(`aisubs_${randomBytes(32).toString("base64url")}`)).finally(() => {
+                        regeneratingApiKey = undefined;
+                    });
+                    apiKey = await regeneratingApiKey;
+                    return sendJson(response, 200, { apiKey });
+                }
             }
-            if (["v1", "aisubs"].includes(routeSegments(url.pathname)[0] ?? "")) {
+            if (apiRoute) {
                 if (!(await handleSubscriptionAuthApi(options.auth, request, response, url, options.maxProxyBodyBytes))) {
                     sendJson(response, 404, { error: "Not found" });
                 }
@@ -131,9 +184,15 @@ export async function createSubscriptionAuthDashboardServer(options) {
     const url = `${origin}:${address.port}`;
     return {
         server,
-        apiKey,
+        get apiKey() {
+            return apiKey;
+        },
         url,
-        bootstrapUrl: `${url}/bootstrap?token=${encodeURIComponent(bootstrapToken)}`,
-        close: () => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))),
+        bootstrapUrl: url,
+        close: () => {
+            for (const stream of logStreams)
+                stream.end();
+            return new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+        },
     };
 }

package/dist/http.js CHANGED Viewed

@@ -70,9 +70,133 @@ export function sendJson(response, status, body, headers = {}) {
 export function routeSegments(pathname) {
     return pathname.split("/").filter(Boolean).map(decodeURIComponent);
 }
+function chatCompletionRequest(body) {
+    const raw = JSON.parse(body.toString("utf8"));
+    if (!isRecord(raw) || !Array.isArray(raw.messages)) {
+        throw new Error("Chat Completions requires a messages array");
+    }
+    const model = stringValue(raw.model);
+    if (!model)
+        throw new Error("Chat Completions requires a model");
+    if (raw.stream === true) {
+        throw new Error("ChatGPT Chat Completions compatibility does not support streaming");
+    }
+    const instructions = [];
+    const input = [];
+    for (const message of raw.messages) {
+        if (!isRecord(message))
+            throw new Error("Chat Completions messages must be objects");
+        const role = stringValue(message.role);
+        const content = stringValue(message.content);
+        if (!role || content == null) {
+            throw new Error("ChatGPT compatibility supports text-only messages");
+        }
+        if (role === "system" || role === "developer")
+            instructions.push(content);
+        else if (role === "user" || role === "assistant") {
+            input.push({
+                role,
+                content: [{ type: role === "assistant" ? "output_text" : "input_text", text: content }],
+            });
+        }
+        else
+            throw new Error(`Unsupported Chat Completions role: ${role}`);
+    }
+    const translated = { model, store: false, stream: true, input };
+    if (instructions.length)
+        translated.instructions = instructions.join("\n\n");
+    const maxOutputTokens = raw.max_completion_tokens ?? raw.max_tokens;
+    if (typeof maxOutputTokens === "number")
+        translated.max_output_tokens = maxOutputTokens;
+    if (isRecord(raw.response_format) &&
+        raw.response_format.type === "json_schema" &&
+        isRecord(raw.response_format.json_schema)) {
+        translated.text = { format: { type: "json_schema", ...raw.response_format.json_schema } };
+    }
+    return { model, body: JSON.stringify(translated) };
+}
+function responseText(raw) {
+    if (!isRecord(raw))
+        return undefined;
+    const direct = stringValue(raw.output_text);
+    if (direct != null)
+        return direct;
+    if (!Array.isArray(raw.output))
+        return undefined;
+    const text = raw.output.flatMap((item) => {
+        if (!isRecord(item) || !Array.isArray(item.content))
+            return [];
+        return item.content.flatMap((part) => isRecord(part) && part.type === "output_text" && stringValue(part.text) != null
+            ? [stringValue(part.text)]
+            : []);
+    });
+    return text.length ? text.join("") : undefined;
+}
+async function chatCompletionResponse(upstream, model) {
+    if (!upstream.ok)
+        return upstream;
+    let completed;
+    let content = "";
+    const body = await upstream.text();
+    if (body.startsWith("event:") || body.startsWith("data:")) {
+        for (const line of body.split(/\r?\n/)) {
+            if (!line.startsWith("data:"))
+                continue;
+            const data = line.slice(5).trim();
+            if (!data || data === "[DONE]")
+                continue;
+            const event = JSON.parse(data);
+            if (!isRecord(event))
+                continue;
+            if (event.type === "response.output_text.delta")
+                content += stringValue(event.delta) ?? "";
+            if (event.type === "response.completed")
+                completed = event.response;
+        }
+    }
+    else
+        completed = JSON.parse(body);
+    content ||= responseText(completed) ?? "";
+    const raw = isRecord(completed) ? completed : {};
+    const usage = isRecord(raw.usage)
+        ? {
+            prompt_tokens: raw.usage.input_tokens,
+            completion_tokens: raw.usage.output_tokens,
+            total_tokens: raw.usage.total_tokens,
+        }
+        : undefined;
+    return Response.json({
+        id: stringValue(raw.id) ?? `chatcmpl_${crypto.randomUUID()}`,
+        object: "chat.completion",
+        created: typeof raw.created_at === "number" ? raw.created_at : Math.floor(Date.now() / 1000),
+        model: stringValue(raw.model) ?? model,
+        choices: [{ index: 0, message: { role: "assistant", content }, finish_reason: "stop" }],
+        ...(usage ? { usage } : {}),
+    });
+}
 export async function handleSubscriptionAuthApi(auth, request, response, url, maxProxyBodyBytes = MAX_PROXY_BODY_BYTES) {
     const parts = routeSegments(url.pathname);
     if (parts[0] === "aisubs" && parts[1] && parts[2] && request.method !== "OPTIONS") {
+        const upstreamParts = parts.slice(3);
+        const versioned = upstreamParts[0] === "v1";
+        if (versioned)
+            upstreamParts.shift();
+        if (versioned && upstreamParts[0] === "embeddings") {
+            sendJson(response, 404, { error: "AISubs does not expose an embeddings API" });
+            return true;
+        }
+        if (versioned && request.method === "GET" && upstreamParts.join("/") === "models") {
+            const catalog = await auth.getModels(parts[1], parts[2]);
+            sendJson(response, 200, {
+                object: "list",
+                data: (catalog?.models ?? []).map((model) => ({
+                    id: model.id,
+                    object: "model",
+                    owned_by: parts[1],
+                })),
+            });
+            return true;
+        }
         const headers = new Headers();
         const privateHeaders = new Set([
             "authorization",
@@ -95,13 +219,26 @@ export async function handleSubscriptionAuthApi(auth, request, response, url, ma
             }
         }
         const body = await readProxyBody(request, maxProxyBodyBytes);
-        const path = parts.slice(3).map(encodeURIComponent).join("/") + url.search;
+        let path = upstreamParts.map(encodeURIComponent).join("/") + url.search;
+        let proxyBody = body;
+        let chatCompletionModel;
+        if (parts[1] === "chatgpt" &&
+            versioned &&
+            request.method === "POST" &&
+            upstreamParts.join("/") === "chat/completions") {
+            const translated = chatCompletionRequest(body);
+            path = "responses";
+            proxyBody = Buffer.from(translated.body);
+            chatCompletionModel = translated.model;
+            headers.set("accept", "text/event-stream");
+            headers.set("content-type", "application/json");
+        }
         const upstream = await auth.proxy(parts[1], parts[2], path, {
             method: request.method,
             headers,
-            body: body.length ? body : undefined,
+            body: proxyBody.length ? proxyBody : undefined,
         });
-        await sendUpstream(response, upstream);
+        await sendUpstream(response, chatCompletionModel ? await chatCompletionResponse(upstream, chatCompletionModel) : upstream);
         return true;
     }
     if (request.method === "GET" && parts.join("/") === "v1/providers") {

package/dist/index.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 export { createSubscriptionAuth, DEFAULT_ACCOUNT, SubscriptionAuth, type SubscriptionAccount, type SubscriptionAuthOptions, } from "./auth.js";
-export { defaultAiSubsDataDir, FileCredentialStore, MemoryCredentialStore } from "./store.js";
+export { defaultAiSubsDataDir, FileApiKeyStore, FileCredentialStore, MemoryCredentialStore, } from "./store.js";
 export { chatGptProvider, type ChatGptProviderOptions } from "./providers/chatgpt.js";
 export { claudeProvider, type ClaudeProviderOptions } from "./providers/claude.js";
 export { copilotProvider, type CopilotProviderOptions } from "./providers/copilot.js";

package/dist/index.js CHANGED Viewed

@@ -1,5 +1,5 @@
 export { createSubscriptionAuth, DEFAULT_ACCOUNT, SubscriptionAuth, } from "./auth.js";
-export { defaultAiSubsDataDir, FileCredentialStore, MemoryCredentialStore } from "./store.js";
+export { defaultAiSubsDataDir, FileApiKeyStore, FileCredentialStore, MemoryCredentialStore, } from "./store.js";
 export { chatGptProvider } from "./providers/chatgpt.js";
 export { claudeProvider } from "./providers/claude.js";
 export { copilotProvider } from "./providers/copilot.js";

package/dist/store.d.ts CHANGED Viewed

@@ -1,5 +1,11 @@
 import type { CredentialStore, OAuthCredential, ProviderId } from "./types.js";
 export declare function defaultAiSubsDataDir(): string;
+export declare class FileApiKeyStore {
+    readonly file: string;
+    constructor(file: string);
+    readOrCreate(): Promise<string>;
+    regenerate(): Promise<string>;
+}
 export declare class FileCredentialStore implements CredentialStore {
     readonly file: string;
     constructor(file: string);

package/dist/store.js CHANGED Viewed

@@ -1,5 +1,5 @@
-import { createHash } from "node:crypto";
-import { chmod, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { createHash, randomBytes } from "node:crypto";
+import { chmod, link, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { abortableDelay, isRecord } from "./utils.js";
@@ -9,6 +9,55 @@ export function defaultAiSubsDataDir() {
     const override = process.env.AISUBS_DATA_DIR?.trim();
     return override ? resolve(override) : join(homedir(), ".aisubs");
 }
+export class FileApiKeyStore {
+    file;
+    constructor(file) {
+        this.file = file;
+    }
+    async readOrCreate() {
+        try {
+            const value = (await readFile(this.file, "utf8")).trim();
+            if (value)
+                return value;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        const value = `aisubs_${randomBytes(32).toString("base64url")}`;
+        const temp = `${this.file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+        await mkdir(dirname(this.file), { recursive: true, mode: 0o700 });
+        try {
+            await writeFile(temp, `${value}\n`, { mode: 0o600 });
+            try {
+                await link(temp, this.file);
+                return value;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const existing = (await readFile(this.file, "utf8")).trim();
+                return existing || this.regenerate();
+            }
+        }
+        finally {
+            await rm(temp, { force: true }).catch(() => { });
+        }
+    }
+    async regenerate() {
+        const value = `aisubs_${randomBytes(32).toString("base64url")}`;
+        const temp = `${this.file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+        await mkdir(dirname(this.file), { recursive: true, mode: 0o700 });
+        try {
+            await writeFile(temp, `${value}\n`, { mode: 0o600 });
+            await rename(temp, this.file);
+            return value;
+        }
+        finally {
+            await rm(temp, { force: true }).catch(() => { });
+        }
+    }
+}
 async function readEnvelope(file) {
     try {
         const parsed = JSON.parse(await readFile(file, "utf8"));

package/examples/server.mjs CHANGED Viewed

@@ -1,8 +1,8 @@
-import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
   FileCredentialStore,
+  FileApiKeyStore,
   chatGptProvider,
   copilotProvider,
   createSubscriptionAuth,
@@ -10,11 +10,13 @@ import {
 } from "aisubs";
 import { createSubscriptionAuthServer } from "aisubs/http";
-const apiKey = process.env.AISUBS_API_KEY ?? randomBytes(24).toString("hex");
+const directory = join(homedir(), ".aisubs-demo");
+const apiKey =
+  process.env.AISUBS_API_KEY ??
+  (await new FileApiKeyStore(join(directory, "api-key")).readOrCreate());
 const auth = createSubscriptionAuth({
-  store: new FileCredentialStore(join(homedir(), ".aisubs-demo", "credentials.json")),
+  store: new FileCredentialStore(join(directory, "credentials.json")),
   providers: [chatGptProvider(), copilotProvider(), grokProvider()],
 });
 const server = await createSubscriptionAuthServer({ auth, apiKey, port: 4319 });
 console.log(`AI Subs API: ${server.url}`);
-console.log(`API key: ${apiKey}`);

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "aisubs",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Connect AI provider accounts and use those subscriptions from any local tool or as api.",
   "keywords": [
     "ai",

package/public/aisubs-dashboard.png CHANGED Viewed

Binary file