aisubs 0.1.0 → 0.3.0

package/dist/realtime.js

@@ -0,0 +1,163 @@
+import WebSocket from "ws";
+import { errorMessage } from "./utils.js";
+function rawDataBytes(data) {
+    if (Array.isArray(data))
+        return data.reduce((total, item) => total + item.byteLength, 0);
+    return data.byteLength;
+}
+function closeSocket(socket, code, reason) {
+    if (code >= 1000 && code <= 4999 && ![1004, 1005, 1006, 1015].includes(code)) {
+        socket.close(code, reason);
+    }
+    else
+        socket.close();
+}
+function upstreamHeaders(request) {
+    const headers = {};
+    request.headers.forEach((value, name) => {
+        if (![
+            "connection",
+            "content-length",
+            "host",
+            "sec-websocket-extensions",
+            "sec-websocket-key",
+            "sec-websocket-protocol",
+            "sec-websocket-version",
+            "upgrade",
+        ].includes(name)) {
+            headers[name] = value;
+        }
+    });
+    return headers;
+}
+function clientHeaders(request) {
+    const local = new Set([
+        "authorization",
+        "connection",
+        "cookie",
+        "host",
+        "origin",
+        "proxy-authorization",
+        "sec-websocket-extensions",
+        "sec-websocket-key",
+        "sec-websocket-protocol",
+        "sec-websocket-version",
+        "upgrade",
+        "x-api-key",
+        "x-goog-api-key",
+    ]);
+    return Object.fromEntries(Object.entries(request.headers).flatMap(([name, value]) => value == null || local.has(name)
+        ? []
+        : [[name, Array.isArray(value) ? value.join(", ") : String(value)]]));
+}
+/** Register a native Realtime WebSocket tunnel for providers that expose one. */
+export function registerRealtimeProxy(app, auth, authenticate) {
+    app.route({
+        method: "GET",
+        url: "/aisubs/:provider/:account/v1/realtime",
+        async preValidation(request, reply) {
+            if (!(await authenticate(request))) {
+                await reply.code(401).send({
+                    error: {
+                        message: "Unauthorized",
+                        type: "authentication_error",
+                        code: "invalid_api_key",
+                    },
+                });
+            }
+        },
+        async handler(_request, reply) {
+            await reply.code(426).send({
+                error: {
+                    message: "Use a WebSocket connection for the Realtime endpoint",
+                    type: "invalid_request_error",
+                    code: "websocket_required",
+                },
+            });
+        },
+        wsHandler(socket, request) {
+            const params = request.params;
+            const url = new URL(request.url, "http://aisubs.local");
+            url.searchParams.delete("key");
+            const search = url.search;
+            const pending = [];
+            let pendingBytes = 0;
+            let upstream;
+            socket.on("message", (data, binary) => {
+                if (upstream?.readyState === WebSocket.OPEN) {
+                    upstream.send(data, { binary });
+                    return;
+                }
+                const bytes = rawDataBytes(data);
+                pendingBytes += bytes;
+                if (pending.length >= 100 || pendingBytes > 1024 * 1024) {
+                    socket.close(1009, "Realtime startup queue exceeded");
+                    return;
+                }
+                pending.push({ data, binary });
+            });
+            socket.once("close", (code, reason) => {
+                if (upstream?.readyState === WebSocket.OPEN)
+                    closeSocket(upstream, code, reason);
+                else
+                    upstream?.terminate();
+            });
+            void auth
+                .authorizeProxyRequest(params.provider, params.account, `realtime${search}`, {
+                method: "GET",
+                headers: clientHeaders(request),
+            })
+                .then((authorized) => {
+                const target = new URL(authorized.url);
+                target.protocol = target.protocol === "https:" ? "wss:" : "ws:";
+                const protocols = request.headers["sec-websocket-protocol"]
+                    ?.split(",")
+                    .map((value) => value.trim())
+                    .filter(Boolean);
+                upstream = protocols?.length
+                    ? new WebSocket(target, protocols, { headers: upstreamHeaders(authorized) })
+                    : new WebSocket(target, { headers: upstreamHeaders(authorized) });
+                upstream.on("open", () => {
+                    for (const item of pending)
+                        upstream.send(item.data, { binary: item.binary });
+                    pending.length = 0;
+                    pendingBytes = 0;
+                });
+                upstream.on("message", (data, binary) => {
+                    if (socket.readyState === WebSocket.OPEN)
+                        socket.send(data, { binary });
+                });
+                upstream.on("close", (code, reason) => {
+                    if (socket.readyState === WebSocket.OPEN)
+                        closeSocket(socket, code, reason);
+                });
+                upstream.on("error", (error) => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send(JSON.stringify({
+                            type: "error",
+                            error: {
+                                type: "provider_error",
+                                code: "realtime_connection_failed",
+                                message: errorMessage(error),
+                            },
+                        }));
+                        socket.close(1011, "Provider Realtime connection failed");
+                    }
+                });
+            })
+                .catch((error) => {
+                if (socket.readyState === WebSocket.OPEN) {
+                    socket.send(JSON.stringify({
+                        type: "error",
+                        error: {
+                            type: "provider_error",
+                            code: "realtime_connection_failed",
+                            message: errorMessage(error),
+                        },
+                    }));
+                    socket.close(1011, "Provider Realtime connection failed");
+                }
+            });
+        },
+    });
+}

package/dist/store.d.ts

@@ -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

@@ -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/direct.mjs

@@ -3,25 +3,49 @@ import { join } from "node:path";
 import {
   FileCredentialStore,
   chatGptProvider,
+  claudeProvider,
   copilotProvider,
   createSubscriptionAuth,
   grokProvider,
+  openCodeGoProvider,
+  openCodeZenProvider,
 } from "aisubs";
 
 const provider = process.argv[2] ?? "chatgpt";
 const accountKey = process.argv[3] ?? "default";
-if (!["chatgpt", "copilot", "grok"].includes(provider)) {
-  throw new Error("Use chatgpt, copilot, or grok");
+const providers = [
+  chatGptProvider(),
+  claudeProvider(),
+  copilotProvider(),
+  grokProvider(),
+  openCodeGoProvider(),
+  openCodeZenProvider(),
+];
+if (!providers.some((candidate) => candidate.id === provider)) {
+  throw new Error(`Use one of: ${providers.map((candidate) => candidate.id).join(", ")}`);
 }
 
 const auth = createSubscriptionAuth({
   store: new FileCredentialStore(join(homedir(), ".aisubs-demo", "credentials.json")),
-  providers: [chatGptProvider(), copilotProvider(), grokProvider()],
+  providers,
 });
 const account = auth.account(provider, accountKey);
 
 if (!(await account.status()).authenticated) {
-  const login = await account.signIn();
+  const apiKey =
+    provider === "opencode-go"
+      ? process.env.OPENCODE_GO_API_KEY
+      : provider === "opencode-zen"
+        ? process.env.OPENCODE_API_KEY
+        : undefined;
+  if (provider.startsWith("opencode-") && !apiKey) {
+    throw new Error(
+      provider === "opencode-go"
+        ? "Set OPENCODE_GO_API_KEY before signing in"
+        : "Set OPENCODE_API_KEY before signing in",
+    );
+  }
+  const login = await account.signIn(apiKey ? { apiKey } : undefined);
   if (login.prompt.mode === "browser") {
     console.log(`Open ${login.prompt.authorizationUri}`);
   } else if (login.prompt.mode === "device") {
@@ -32,7 +56,6 @@ if (!(await account.status()).authenticated) {
   console.log("Signed in; refresh credentials were saved securely.");
 }
 
-// In-process request: no localhost server, port, CORS, or control API key.
-const response = await account.proxy("models");
-console.log(`Provider response: ${response.status}`);
-console.log((await response.text()).slice(0, 1000));
+// In-process SDK request: no localhost server, port, CORS, or control API key.
+const catalog = await account.getModels();
+console.log(catalog?.models ?? []);

package/examples/server.mjs

@@ -1,20 +1,32 @@
-import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
   FileCredentialStore,
+  FileApiKeyStore,
   chatGptProvider,
+  claudeProvider,
   copilotProvider,
   createSubscriptionAuth,
   grokProvider,
+  openCodeGoProvider,
+  openCodeZenProvider,
 } 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")),
-  providers: [chatGptProvider(), copilotProvider(), grokProvider()],
+  store: new FileCredentialStore(join(directory, "credentials.json")),
+  providers: [
+    chatGptProvider(),
+    claudeProvider(),
+    copilotProvider(),
+    grokProvider(),
+    openCodeGoProvider(),
+    openCodeZenProvider(),
+  ],
 });
 const server = await createSubscriptionAuthServer({ auth, apiKey, port: 4319 });
 console.log(`AI Subs API: ${server.url}`);
-console.log(`API key: ${apiKey}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aisubs",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Connect AI provider accounts and use those subscriptions from any local tool or as api.",
   "keywords": [
     "ai",
@@ -38,6 +38,7 @@
     "dashboard/public/aisubs-mark.svg",
     "examples",
     "public",
+    "CHANGELOG.md",
     "README.md"
   ],
   "type": "module",
@@ -93,11 +94,18 @@
     "fmt:check": "oxfmt --check .",
     "check": "node --run typecheck && node --run lint && node --run fmt:check && node --run test && node --run build"
   },
+  "dependencies": {
+    "@fastify/cors": "^11.3.0",
+    "@fastify/websocket": "^11.3.0",
+    "fastify": "^5.12.0",
+    "ws": "^8.18.3"
+  },
   "devDependencies": {
     "@tailwindcss/vite": "^4.3.3",
     "@types/node": "^26.2.0",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",
+    "@types/ws": "^8.18.1",
     "@vitejs/plugin-react": "^6.0.5",
     "lucide-react": "^1.31.0",
     "oxfmt": "^0.63.0",