aisubs 0.3.7 → 0.3.8

package/dist/providers/opencode.js

@@ -1,6 +1,11 @@
+import { randomBytes } from "node:crypto";
 import { bearerRequest, isRecord, numberValue, requireAllowedHost, responseJson, stringArray, stringValue, } from "../utils.js";
 const API_HOST = "opencode.ai";
 const API_KEY_LIFETIME_MS = 365 * 24 * 60 * 60_000;
+const DEFAULT_COMPATIBILITY_VERSION = "1.18.31";
+const COMPATIBILITY_VERSION_TTL_MS = 60 * 60_000;
+const ID_PATTERN = /^(ses|msg)_[0-9a-f]{12}[0-9A-Za-z]{14}$/;
+const ID_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function openCodeUsageMeter(id, label, raw) {
     if (!isRecord(raw))
         return null;
@@ -33,18 +38,53 @@ export function parseOpenCodeGoUsage(raw) {
         note: "Provider-reported quota usage. API-equivalent costs shown in chats are estimates, not charges.",
     };
 }
-function documentedEndpoints(provider, model) {
-    if (/^(gpt-|grok-)/.test(model))
-        return ["responses"];
-    if (provider === "opencode-go" && /^(minimax-|qwen)/.test(model))
-        return ["messages"];
-    if (provider === "opencode-zen" && /^(claude-|qwen)/.test(model))
-        return ["messages"];
-    if (provider === "opencode-zen" && model.startsWith("gemini-"))
-        return [`models/${model}`];
-    return ["chat/completions"];
-}
-function openCodeProvider(config) {
+function openCodeProvider(config, options = {}) {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    let versionRequest;
+    let versionExpiresAt = 0;
+    const compatibilityVersion = () => {
+        if (options.compatibilityVersion)
+            return Promise.resolve(options.compatibilityVersion);
+        if (!versionRequest || Date.now() >= versionExpiresAt) {
+            versionExpiresAt = Date.now() + COMPATIBILITY_VERSION_TTL_MS;
+            versionRequest = fetcher("https://api.github.com/repos/anomalyco/opencode/releases/latest", {
+                headers: { accept: "application/vnd.github+json", "user-agent": "aisubs" },
+            })
+                .then(async (response) => {
+                if (!response.ok)
+                    throw new Error(`OpenCode version lookup failed: ${response.status}`);
+                const raw = await response.json();
+                return isRecord(raw) ? stringValue(raw.tag_name)?.replace(/^v/, "") : undefined;
+            })
+                .then((version) => version || DEFAULT_COMPATIBILITY_VERSION)
+                .catch(() => DEFAULT_COMPATIBILITY_VERSION);
+        }
+        return versionRequest;
+    };
+    const routingIds = new Map();
+    let lastTimestamp = 0;
+    let counter = 0;
+    const identifier = (prefix, source) => {
+        if (source && ID_PATTERN.test(source) && source.startsWith(`${prefix}_`))
+            return source;
+        const key = source ? `${prefix}:${source}` : undefined;
+        const cached = key ? routingIds.get(key) : undefined;
+        if (cached)
+            return cached;
+        const timestamp = Date.now();
+        counter = timestamp === lastTimestamp ? counter + 1 : 1;
+        lastTimestamp = timestamp;
+        const encoded = BigInt(timestamp) * 0x1000n + BigInt(counter);
+        const time = Buffer.alloc(6);
+        for (let index = 0; index < time.length; index += 1) {
+            time[index] = Number((encoded >> BigInt(40 - 8 * index)) & 0xffn);
+        }
+        const random = [...randomBytes(14)].map((byte) => ID_CHARS[byte % ID_CHARS.length]).join("");
+        const value = `${prefix}_${time.toString("hex")}${random}`;
+        if (key)
+            routingIds.set(key, value);
+        return value;
+    };
     const credential = (apiKey) => ({
         accessToken: apiKey,
         expiresAt: Date.now() + API_KEY_LIFETIME_MS,
@@ -79,9 +119,15 @@ function openCodeProvider(config) {
         async refresh(current) {
             return { ...current, expiresAt: Date.now() + API_KEY_LIFETIME_MS };
         },
-        authorize(request, current) {
+        async authorize(request, current) {
             requireAllowedHost(request, [API_HOST]);
-            return bearerRequest(request, current);
+            const client = request.headers.get("x-opencode-client")?.trim() || "aisubs";
+            return bearerRequest(request, current, {
+                "user-agent": `opencode/latest/${await compatibilityVersion()}/${client}`,
+                "x-opencode-client": client,
+                "x-opencode-session": identifier("ses", request.headers.get("x-opencode-session")),
+                "x-opencode-request": identifier("msg", request.headers.get("x-opencode-request")),
+            });
         },
         async getModels({ fetch, signal }) {
             const raw = await responseJson(await fetch(`${config.baseUrl}/models`, {
@@ -103,9 +149,7 @@ function openCodeProvider(config) {
                             id,
                             name: stringValue(value.name),
                             description: stringValue(value.description),
-                            endpoints: stringArray(value.supported_endpoints) ??
-                                stringArray(value.endpoints) ??
-                                documentedEndpoints(config.id, id),
+                            endpoints: stringArray(value.supported_endpoints) ?? stringArray(value.endpoints),
                             available: true,
                             selectable: true,
                         },
@@ -129,19 +173,19 @@ function openCodeProvider(config) {
         },
     };
 }
-export function openCodeGoProvider() {
+export function openCodeGoProvider(options = {}) {
     return openCodeProvider({
         id: "opencode-go",
         name: "OpenCode Go",
         description: "OpenCode Go subscription access with an OpenCode API key.",
         baseUrl: "https://opencode.ai/zen/go/v1",
-    });
+    }, options);
 }
-export function openCodeZenProvider() {
+export function openCodeZenProvider(options = {}) {
     return openCodeProvider({
         id: "opencode-zen",
         name: "OpenCode Zen",
         description: "OpenCode Zen pay-as-you-go access with an OpenCode API key.",
         baseUrl: "https://opencode.ai/zen/v1",
-    });
+    }, options);
 }

package/dist/sqlite-store.d.ts

@@ -0,0 +1,61 @@
+import { DatabaseSync } from "node:sqlite";
+import type { CoordinatedCredentialStore, OAuthCredential, ProviderId, VersionedCredential } from "./types.js";
+/** Node SQLite persistence. Pass a DatabaseSync to share a host-owned connection. */
+export declare class SqliteCredentialStore implements CoordinatedCredentialStore {
+    private readonly database;
+    private readonly ownsConnection;
+    private readonly queues;
+    constructor(database: string | DatabaseSync);
+    read(provider: ProviderId): Promise<OAuthCredential | null>;
+    listKeys(): Promise<string[]>;
+    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;
+    }>;
+    modify(provider: ProviderId, update: (current: OAuthCredential | null) => OAuthCredential | null | Promise<OAuthCredential | null>): Promise<OAuthCredential | null>;
+    delete(provider: ProviderId): Promise<void>;
+    close(): void;
+    private row;
+    private generation;
+    private setGeneration;
+    private writeCredential;
+    private versioned;
+    private operation;
+    private rememberOperation;
+}
+export declare class SqliteApiKeyStore {
+    private readonly database;
+    private readonly ownsConnection;
+    constructor(database: string | DatabaseSync);
+    readOrCreate(): Promise<string>;
+    regenerate(): Promise<string>;
+    close(): void;
+    private read;
+}

package/dist/sqlite-store.js

@@ -0,0 +1,323 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { dirname } from "node:path";
+import { mkdirSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+/** Node SQLite persistence. Pass a DatabaseSync to share a host-owned connection. */
+export class SqliteCredentialStore {
+    database;
+    ownsConnection;
+    queues = new Map();
+    constructor(database) {
+        if (typeof database === "string") {
+            mkdirSync(dirname(database), { recursive: true, mode: 0o700 });
+            this.database = new DatabaseSync(database, { timeout: 5_000 });
+            this.ownsConnection = true;
+        }
+        else {
+            this.database = database;
+            this.ownsConnection = false;
+        }
+        this.database.exec(`
+      PRAGMA foreign_keys = ON;
+      CREATE TABLE IF NOT EXISTS aisubs_credentials (
+        account_key TEXT PRIMARY KEY,
+        credential_json TEXT NOT NULL,
+        version INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS aisubs_refresh_claims (
+        account_key TEXT PRIMARY KEY,
+        claim_id TEXT NOT NULL UNIQUE,
+        credential_version INTEGER NOT NULL,
+        account_generation INTEGER NOT NULL,
+        created_at INTEGER NOT NULL
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS aisubs_account_generations (
+        account_key TEXT PRIMARY KEY,
+        generation INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS aisubs_operations (
+        operation_id TEXT PRIMARY KEY,
+        result_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS aisubs_api_keys (
+        name TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      ) STRICT;
+    `);
+    }
+    async read(provider) {
+        const row = this.row(provider);
+        return row ? JSON.parse(row.credential_json) : null;
+    }
+    async listKeys() {
+        return this.database.prepare("SELECT account_key FROM aisubs_credentials ORDER BY rowid").all().map(({ account_key }) => account_key);
+    }
+    async readVersioned(provider) {
+        const row = this.row(provider);
+        return {
+            credential: row ? JSON.parse(row.credential_json) : null,
+            version: row?.version ?? 0,
+            generation: this.generation(provider),
+        };
+    }
+    async replaceCredential(input) {
+        const replay = this.operation(input.operationId);
+        if (replay)
+            return replay;
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const generation = this.generation(input.provider);
+            if (generation !== input.expectedGeneration) {
+                const result = { applied: false, record: this.versioned(input.provider) };
+                this.rememberOperation(input.operationId, result);
+                this.database.exec("COMMIT");
+                return result;
+            }
+            this.writeCredential(input.provider, input.credential);
+            this.setGeneration(input.provider, generation + 1);
+            this.database
+                .prepare("DELETE FROM aisubs_refresh_claims WHERE account_key = ?")
+                .run(input.provider);
+            const result = { applied: true, record: this.versioned(input.provider) };
+            this.rememberOperation(input.operationId, result);
+            this.database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    async deleteCredential(input) {
+        if (this.operation(input.operationId))
+            return;
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            this.database
+                .prepare("DELETE FROM aisubs_credentials WHERE account_key = ?")
+                .run(input.provider);
+            this.database
+                .prepare("DELETE FROM aisubs_refresh_claims WHERE account_key = ?")
+                .run(input.provider);
+            this.setGeneration(input.provider, this.generation(input.provider) + 1);
+            this.rememberOperation(input.operationId, { applied: true });
+            this.database.exec("COMMIT");
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    async claimRefresh(input) {
+        const replay = this.operation(input.operationId);
+        if (replay?.value)
+            return replay.value;
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const row = this.row(input.provider);
+            const generation = this.generation(input.provider);
+            const value = !row
+                ? "missing"
+                : row.version !== input.expectedVersion || generation !== input.expectedGeneration
+                    ? "changed"
+                    : this.database
+                        .prepare("SELECT 1 FROM aisubs_refresh_claims WHERE account_key = ?")
+                        .get(input.provider)
+                        ? "busy"
+                        : "claimed";
+            if (value === "claimed") {
+                this.database
+                    .prepare(`INSERT INTO aisubs_refresh_claims(account_key, claim_id, credential_version, account_generation, created_at)
+            VALUES(?, ?, ?, ?, ?)`)
+                    .run(input.provider, input.claimId, input.expectedVersion, input.expectedGeneration, Date.now());
+            }
+            this.rememberOperation(input.operationId, { value });
+            this.database.exec("COMMIT");
+            return value;
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    async commitRefresh(input) {
+        const replay = this.operation(input.operationId);
+        if (replay)
+            return replay;
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const claim = this.database
+                .prepare(`SELECT account_generation FROM aisubs_refresh_claims
+          WHERE account_key = ? AND claim_id = ?`)
+                .get(input.provider, input.claimId);
+            const applied = Boolean(claim &&
+                claim.account_generation === input.expectedGeneration &&
+                this.generation(input.provider) === input.expectedGeneration);
+            if (applied) {
+                this.writeCredential(input.provider, input.credential);
+                this.database
+                    .prepare("DELETE FROM aisubs_refresh_claims WHERE account_key = ? AND claim_id = ?")
+                    .run(input.provider, input.claimId);
+            }
+            const result = { applied, record: this.versioned(input.provider) };
+            this.rememberOperation(input.operationId, result);
+            this.database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    async modify(provider, update) {
+        const previous = this.queues.get(provider) ?? Promise.resolve();
+        let result = null;
+        const current = previous.then(async () => {
+            for (;;) {
+                const observed = this.row(provider);
+                result = await update(observed ? JSON.parse(observed.credential_json) : null);
+                this.database.exec("BEGIN IMMEDIATE");
+                try {
+                    const latest = this.row(provider);
+                    if ((latest?.version ?? 0) !== (observed?.version ?? 0)) {
+                        this.database.exec("ROLLBACK");
+                        continue;
+                    }
+                    if (result) {
+                        this.database
+                            .prepare(`INSERT INTO aisubs_credentials(account_key, credential_json, version, updated_at)
+                VALUES(?, ?, 1, ?)
+                ON CONFLICT(account_key) DO UPDATE SET credential_json = excluded.credential_json,
+                  version = aisubs_credentials.version + 1, updated_at = excluded.updated_at`)
+                            .run(provider, JSON.stringify(result), Date.now());
+                    }
+                    else {
+                        this.database
+                            .prepare("DELETE FROM aisubs_credentials WHERE account_key = ?")
+                            .run(provider);
+                    }
+                    this.database.exec("COMMIT");
+                    return;
+                }
+                catch (error) {
+                    this.database.exec("ROLLBACK");
+                    throw error;
+                }
+            }
+        });
+        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);
+    }
+    close() {
+        if (this.ownsConnection)
+            this.database.close();
+    }
+    row(provider) {
+        return this.database
+            .prepare("SELECT credential_json, version FROM aisubs_credentials WHERE account_key = ?")
+            .get(provider);
+    }
+    generation(provider) {
+        const row = this.database
+            .prepare("SELECT generation FROM aisubs_account_generations WHERE account_key = ?")
+            .get(provider);
+        return row?.generation ?? 0;
+    }
+    setGeneration(provider, generation) {
+        this.database
+            .prepare(`INSERT INTO aisubs_account_generations(account_key, generation, updated_at) VALUES(?, ?, ?)
+        ON CONFLICT(account_key) DO UPDATE SET generation = excluded.generation, updated_at = excluded.updated_at`)
+            .run(provider, generation, Date.now());
+    }
+    writeCredential(provider, credential) {
+        this.database
+            .prepare(`INSERT INTO aisubs_credentials(account_key, credential_json, version, updated_at)
+        VALUES(?, ?, 1, ?)
+        ON CONFLICT(account_key) DO UPDATE SET credential_json = excluded.credential_json,
+          version = aisubs_credentials.version + 1, updated_at = excluded.updated_at`)
+            .run(provider, JSON.stringify(credential), Date.now());
+    }
+    versioned(provider) {
+        const row = this.row(provider);
+        return {
+            credential: row ? JSON.parse(row.credential_json) : null,
+            version: row?.version ?? 0,
+            generation: this.generation(provider),
+        };
+    }
+    operation(operationId) {
+        const row = this.database
+            .prepare("SELECT result_json FROM aisubs_operations WHERE operation_id = ?")
+            .get(operationId);
+        return row ? JSON.parse(row.result_json) : undefined;
+    }
+    rememberOperation(operationId, result) {
+        this.database
+            .prepare("INSERT OR IGNORE INTO aisubs_operations(operation_id, result_json, created_at) VALUES(?, ?, ?)")
+            .run(operationId, JSON.stringify(result), Date.now());
+    }
+}
+export class SqliteApiKeyStore {
+    database;
+    ownsConnection;
+    constructor(database) {
+        if (typeof database === "string") {
+            mkdirSync(dirname(database), { recursive: true, mode: 0o700 });
+            this.database = new DatabaseSync(database, { timeout: 5_000 });
+            this.ownsConnection = true;
+        }
+        else {
+            this.database = database;
+            this.ownsConnection = false;
+        }
+        this.database.exec(`CREATE TABLE IF NOT EXISTS aisubs_api_keys (
+      name TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at INTEGER NOT NULL
+    ) STRICT;`);
+    }
+    async readOrCreate() {
+        const existing = this.read();
+        if (existing)
+            return existing;
+        const value = apiKey();
+        this.database
+            .prepare("INSERT OR IGNORE INTO aisubs_api_keys(name, value, updated_at) VALUES('default', ?, ?)")
+            .run(value, Date.now());
+        return this.read() ?? value;
+    }
+    async regenerate() {
+        const value = apiKey();
+        this.database
+            .prepare(`INSERT INTO aisubs_api_keys(name, value, updated_at) VALUES('default', ?, ?)
+        ON CONFLICT(name) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
+            .run(value, Date.now());
+        return value;
+    }
+    close() {
+        if (this.ownsConnection)
+            this.database.close();
+    }
+    read() {
+        const row = this.database
+            .prepare("SELECT value FROM aisubs_api_keys WHERE name = 'default'")
+            .get();
+        return row?.value ?? null;
+    }
+}
+function apiKey() {
+    return `aisubs_${randomBytes(32).toString("base64url")}_${randomUUID().slice(0, 8)}`;
+}

package/dist/store.d.ts

@@ -1,24 +1 @@
-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);
-    read(provider: ProviderId): Promise<OAuthCredential | null>;
-    listKeys(): Promise<string[]>;
-    modify(provider: ProviderId, update: (current: OAuthCredential | null) => OAuthCredential | null | Promise<OAuthCredential | null>): Promise<OAuthCredential | null>;
-    delete(provider: ProviderId): Promise<void>;
-}
-export declare class MemoryCredentialStore implements CredentialStore {
-    private readonly values;
-    private readonly queues;
-    read(provider: ProviderId): Promise<OAuthCredential | null>;
-    listKeys(): Promise<string[]>;
-    modify(provider: ProviderId, update: (current: OAuthCredential | null) => OAuthCredential | null | Promise<OAuthCredential | null>): Promise<OAuthCredential | null>;
-    delete(provider: ProviderId): Promise<void>;
-}