aisubs 0.3.7 → 0.3.8

package/dist/store.js

@@ -1,203 +1,6 @@
-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";
-const LOCK_TIMEOUT_MS = 15_000;
-const LOCK_STALE_MS = 120_000;
-function isCredential(value) {
-    if (!isRecord(value) || typeof value.accessToken !== "string")
-        return false;
-    if (typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt))
-        return false;
-    if (value.refreshToken != null && typeof value.refreshToken !== "string")
-        return false;
-    if (value.account != null &&
-        (!isRecord(value.account) ||
-            ![value.account.id, value.account.label, value.account.email, value.account.plan].every((item) => item == null || typeof item === "string")))
-        return false;
-    return (value.metadata == null ||
-        (isRecord(value.metadata) &&
-            Object.values(value.metadata).every((item) => item == null ||
-                typeof item === "string" ||
-                typeof item === "number" ||
-                typeof item === "boolean")));
-}
+import { join, resolve } from "node:path";
 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"));
-        if (!isRecord(parsed))
-            throw new Error("Credential store must contain a JSON object");
-        const credentials = Object.create(null);
-        for (const [key, value] of Object.entries(parsed)) {
-            if (!isCredential(value))
-                throw new Error(`Credential store entry ${key} is invalid`);
-            credentials[key] = value;
-        }
-        return credentials;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return Object.create(null);
-        throw error;
-    }
-}
-async function withFileLock(path, task) {
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    const deadline = Date.now() + LOCK_TIMEOUT_MS;
-    let handle;
-    while (!handle) {
-        try {
-            handle = await open(path, "wx", 0o600);
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            try {
-                if (Date.now() - (await stat(path)).mtimeMs > LOCK_STALE_MS)
-                    await rm(path, { force: true });
-            }
-            catch { }
-            if (Date.now() >= deadline)
-                throw new Error("Timed out waiting for credential-store lock");
-            await abortableDelay(25);
-        }
-    }
-    try {
-        return await task();
-    }
-    finally {
-        await handle.close().catch(() => { });
-        await rm(path, { force: true }).catch(() => { });
-    }
-}
-async function writeEnvelope(file, value) {
-    const temp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
-    await mkdir(dirname(file), { recursive: true, mode: 0o700 });
-    try {
-        await writeFile(temp, JSON.stringify(value, null, 2), { mode: 0o600 });
-        await rename(temp, file);
-        if (process.platform !== "win32")
-            await chmod(file, 0o600);
-    }
-    finally {
-        await rm(temp, { force: true }).catch(() => { });
-    }
-}
-export class FileCredentialStore {
-    file;
-    constructor(file) {
-        this.file = file;
-    }
-    async read(provider) {
-        return (await readEnvelope(this.file))[provider] ?? null;
-    }
-    async listKeys() {
-        return Object.keys(await readEnvelope(this.file));
-    }
-    async modify(provider, update) {
-        const lockId = createHash("sha256").update(provider).digest("hex");
-        return withFileLock(join(dirname(this.file), `${lockId}.credential.lock`), async () => {
-            const next = await update(await this.read(provider));
-            await withFileLock(`${this.file}.lock`, async () => {
-                const all = await readEnvelope(this.file);
-                if (next)
-                    all[provider] = next;
-                else
-                    delete all[provider];
-                await writeEnvelope(this.file, all);
-            });
-            return next;
-        });
-    }
-    async delete(provider) {
-        await this.modify(provider, () => null);
-    }
-}
-export class MemoryCredentialStore {
-    values = new Map();
-    queues = new Map();
-    async read(provider) {
-        return this.values.get(provider) ?? null;
-    }
-    async listKeys() {
-        return [...this.values.keys()];
-    }
-    async modify(provider, update) {
-        const previous = this.queues.get(provider) ?? Promise.resolve();
-        let result = null;
-        const current = previous.then(async () => {
-            result = await update(this.values.get(provider) ?? null);
-            if (result)
-                this.values.set(provider, result);
-            else
-                this.values.delete(provider);
-        });
-        const settled = current.catch(() => { });
-        this.queues.set(provider, settled);
-        try {
-            await current;
-        }
-        finally {
-            if (this.queues.get(provider) === settled)
-                this.queues.delete(provider);
-        }
-        return result;
-    }
-    async delete(provider) {
-        await this.modify(provider, () => null);
-    }
-}

package/dist/types.d.ts

@@ -18,6 +18,45 @@ export interface CredentialStore {
     modify(provider: ProviderId, update: (current: OAuthCredential | null) => OAuthCredential | null | Promise<OAuthCredential | null>): Promise<OAuthCredential | null>;
     delete(provider: ProviderId): Promise<void>;
 }
+export interface VersionedCredential {
+    credential: OAuthCredential | null;
+    version: number;
+    generation: number;
+}
+/** Structured, remote-safe credential mutations used by hosted/shared stores. */
+export interface CoordinatedCredentialStore extends CredentialStore {
+    readVersioned(provider: ProviderId): Promise<VersionedCredential>;
+    replaceCredential(input: {
+        provider: ProviderId;
+        credential: OAuthCredential;
+        expectedGeneration: number;
+        operationId: string;
+    }): Promise<{
+        applied: boolean;
+        record: VersionedCredential;
+    }>;
+    deleteCredential(input: {
+        provider: ProviderId;
+        operationId: string;
+    }): Promise<void>;
+    claimRefresh(input: {
+        provider: ProviderId;
+        expectedVersion: number;
+        expectedGeneration: number;
+        claimId: string;
+        operationId: string;
+    }): Promise<"claimed" | "busy" | "changed" | "missing">;
+    commitRefresh(input: {
+        provider: ProviderId;
+        claimId: string;
+        expectedGeneration: number;
+        credential: OAuthCredential;
+        operationId: string;
+    }): Promise<{
+        applied: boolean;
+        record: VersionedCredential;
+    }>;
+}
 export interface UsageMeter {
     id: string;
     label: string;
@@ -72,6 +111,7 @@ export interface ProviderModel {
     maxOutputTokens?: number;
     reasoningEfforts?: string[];
     inputModalities?: string[];
+    outputModalities?: string[];
     endpoints?: string[];
     supportsToolCall?: boolean;
     available?: boolean;

package/dist/utils.js

@@ -1,4 +1,3 @@
-import { setTimeout as delay } from "node:timers/promises";
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -18,12 +17,21 @@ export function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 export async function abortableDelay(ms, signal) {
-    try {
-        await delay(ms, undefined, { signal });
-    }
-    catch {
+    if (signal?.aborted)
         throw new Error("Login cancelled");
-    }
+    await new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(timer);
+            reject(new Error("Login cancelled"));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", abort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
+    });
 }
 export async function responseJson(response, label) {
     const raw = await response.json().catch(() => null);

package/examples/direct.mjs

@@ -1,15 +1,12 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import {
-  FileCredentialStore,
-  chatGptProvider,
-  claudeProvider,
-  copilotProvider,
-  createSubscriptionAuth,
-  grokProvider,
-  openCodeGoProvider,
-  openCodeZenProvider,
-} from "aisubs";
+import { createSubscriptionAuth } from "aisubs";
+import { SqliteCredentialStore } from "aisubs/node";
+import { chatGptProvider } from "aisubs/providers/chatgpt";
+import { claudeProvider } from "aisubs/providers/claude";
+import { copilotProvider } from "aisubs/providers/copilot";
+import { grokProvider } from "aisubs/providers/grok";
+import { openCodeGoProvider, openCodeZenProvider } from "aisubs/providers/opencode";
 
 const provider = process.argv[2] ?? "chatgpt";
 const accountKey = process.argv[3] ?? "default";
@@ -26,7 +23,7 @@ if (!providers.some((candidate) => candidate.id === provider)) {
 }
 
 const auth = createSubscriptionAuth({
-  store: new FileCredentialStore(join(homedir(), ".aisubs-demo", "credentials.json")),
+  store: new SqliteCredentialStore(join(homedir(), ".aisubs-demo", "aisubs.db")),
   providers,
 });
 const account = auth.account(provider, accountKey);

package/examples/server.mjs

@@ -1,24 +1,19 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import {
-  FileCredentialStore,
-  FileApiKeyStore,
-  chatGptProvider,
-  claudeProvider,
-  copilotProvider,
-  createSubscriptionAuth,
-  grokProvider,
-  openCodeGoProvider,
-  openCodeZenProvider,
-} from "aisubs";
+import { createSubscriptionAuth } from "aisubs";
 import { createSubscriptionAuthServer } from "aisubs/http";
+import { SqliteApiKeyStore, SqliteCredentialStore } from "aisubs/node";
+import { chatGptProvider } from "aisubs/providers/chatgpt";
+import { claudeProvider } from "aisubs/providers/claude";
+import { copilotProvider } from "aisubs/providers/copilot";
+import { grokProvider } from "aisubs/providers/grok";
+import { openCodeGoProvider, openCodeZenProvider } from "aisubs/providers/opencode";
 
 const directory = join(homedir(), ".aisubs-demo");
-const apiKey =
-  process.env.AISUBS_API_KEY ??
-  (await new FileApiKeyStore(join(directory, "api-key")).readOrCreate());
+const database = join(directory, "aisubs.db");
+const apiKey = process.env.AISUBS_API_KEY ?? (await new SqliteApiKeyStore(database).readOrCreate());
 const auth = createSubscriptionAuth({
-  store: new FileCredentialStore(join(directory, "credentials.json")),
+  store: new SqliteCredentialStore(database),
   providers: [
     chatGptProvider(),
     claudeProvider(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aisubs",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "Connect AI provider accounts and use those subscriptions from any local tool or as api.",
   "keywords": [
     "ai",
@@ -59,6 +59,10 @@
       "types": "./dist/dashboard.d.ts",
       "import": "./dist/dashboard.js"
     },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
     "./providers/chatgpt": {
       "types": "./dist/providers/chatgpt.d.ts",
       "import": "./dist/providers/chatgpt.js"
@@ -126,11 +130,12 @@
   "devEngines": {
     "packageManager": {
       "name": "nub",
-      "version": "^0.6.0",
-      "onFail": "warn"
+      "version": "^0.9.2",
+      "onFail": "ignore"
     }
   },
   "engines": {
     "node": ">=24"
-  }
+  },
+  "packageManager": "nub@0.9.2"
 }