aisubs 0.1.0

package/dist/providers/opencode.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderAdapter, ProviderUsageData } from "../types.js";
+export declare function parseOpenCodeGoUsage(raw: unknown): ProviderUsageData | null;
+export declare function openCodeGoProvider(): ProviderAdapter;
+export declare function openCodeZenProvider(): ProviderAdapter;

package/dist/providers/opencode.js

@@ -0,0 +1,147 @@
+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;
+function openCodeUsageMeter(id, label, raw) {
+    if (!isRecord(raw))
+        return null;
+    const percentUsed = numberValue(raw.percent);
+    const resetsAt = stringValue(raw.resetsAt);
+    if (percentUsed == null)
+        return null;
+    const resetAt = resetsAt ? Date.parse(resetsAt) : Number.NaN;
+    return {
+        id,
+        label,
+        unit: "percent",
+        percentUsed: Math.min(100, Math.max(0, percentUsed)),
+        resetAt: Number.isNaN(resetAt) ? undefined : resetAt,
+    };
+}
+export function parseOpenCodeGoUsage(raw) {
+    if (!isRecord(raw) || !isRecord(raw.usage))
+        return null;
+    const meters = [
+        openCodeUsageMeter("rolling", "5-hour limit", raw.usage.rolling),
+        openCodeUsageMeter("weekly", "Weekly limit", raw.usage.weekly),
+        openCodeUsageMeter("monthly", "Monthly limit", raw.usage.monthly),
+    ].filter((meter) => meter !== null);
+    if (!meters.length)
+        return null;
+    return {
+        plan: "OpenCode Go",
+        meters,
+        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) {
+    const credential = (apiKey) => ({
+        accessToken: apiKey,
+        expiresAt: Date.now() + API_KEY_LIFETIME_MS,
+        account: { label: config.name },
+    });
+    return {
+        id: config.id,
+        name: config.name,
+        description: config.description,
+        homepage: "https://opencode.ai/auth",
+        allowedHosts: [API_HOST],
+        proxyBaseUrl: config.baseUrl,
+        loginModes: ["api-key"],
+        loginFields: [
+            {
+                name: "apiKey",
+                label: "API key",
+                description: "Create an API key at opencode.ai/auth.",
+                type: "password",
+                required: true,
+            },
+        ],
+        async startLogin(_signal, options) {
+            const apiKey = stringValue(options?.apiKey);
+            if (!apiKey)
+                throw new Error(`${config.name} API key is required`);
+            return {
+                prompt: { mode: "api-key", expiresAt: Date.now() + 60_000 },
+                complete: Promise.resolve(credential(apiKey)),
+            };
+        },
+        async refresh(current) {
+            return { ...current, expiresAt: Date.now() + API_KEY_LIFETIME_MS };
+        },
+        authorize(request, current) {
+            requireAllowedHost(request, [API_HOST]);
+            return bearerRequest(request, current);
+        },
+        async getModels({ fetch, signal }) {
+            const raw = await responseJson(await fetch(`${config.baseUrl}/models`, {
+                headers: { accept: "application/json" },
+                signal,
+            }), `${config.name} models`);
+            const values = Array.isArray(raw.data)
+                ? raw.data
+                : Array.isArray(raw.models)
+                    ? raw.models
+                    : [];
+            return values.flatMap((value) => {
+                if (!isRecord(value))
+                    return [];
+                const id = stringValue(value.id);
+                return id
+                    ? [
+                        {
+                            id,
+                            name: stringValue(value.name),
+                            description: stringValue(value.description),
+                            endpoints: stringArray(value.supported_endpoints) ??
+                                stringArray(value.endpoints) ??
+                                documentedEndpoints(config.id, id),
+                            available: true,
+                            selectable: true,
+                        },
+                    ]
+                    : [];
+            });
+        },
+        async getUsage({ fetch, signal }) {
+            if (config.id === "opencode-zen") {
+                return {
+                    plan: "Pay as you go",
+                    facts: [{ label: "Billing", value: "Metered balance" }],
+                    note: "OpenCode does not expose Zen balance or spend through its API. Check the OpenCode console for the charged amount; chat costs are calculated from public Zen rates.",
+                };
+            }
+            const raw = await responseJson(await fetch(`${config.baseUrl}/usage`, {
+                headers: { accept: "application/json" },
+                signal,
+            }), "OpenCode Go usage");
+            return parseOpenCodeGoUsage(raw);
+        },
+    };
+}
+export function openCodeGoProvider() {
+    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",
+    });
+}
+export function openCodeZenProvider() {
+    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",
+    });
+}

package/dist/store.d.ts

@@ -0,0 +1,18 @@
+import type { CredentialStore, OAuthCredential, ProviderId } from "./types.js";
+export declare function defaultAiSubsDataDir(): 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>;
+}

package/dist/store.js

@@ -0,0 +1,121 @@
+import { createHash } from "node:crypto";
+import { chmod, 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;
+export function defaultAiSubsDataDir() {
+    const override = process.env.AISUBS_DATA_DIR?.trim();
+    return override ? resolve(override) : join(homedir(), ".aisubs");
+}
+async function readEnvelope(file) {
+    try {
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        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);
+        });
+        this.queues.set(provider, current.catch(() => { }));
+        await current;
+        return result;
+    }
+    async delete(provider) {
+        await this.modify(provider, () => null);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,186 @@
+export type ProviderId = "chatgpt" | "claude" | "copilot" | "grok" | (string & {});
+export type LoginMode = "browser" | "device" | "external-token" | "external-cli" | "api-key";
+export interface OAuthCredential {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt: number;
+    account?: {
+        id?: string;
+        label?: string;
+        email?: string;
+        plan?: string;
+    };
+    metadata?: Record<string, string | number | boolean | null>;
+}
+export interface CredentialStore {
+    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 interface UsageMeter {
+    id: string;
+    label: string;
+    unit: "requests" | "tokens" | "credits" | "currency" | "percent" | (string & {});
+    used?: number;
+    limit?: number;
+    remaining?: number;
+    percentUsed?: number;
+    included?: boolean;
+    unlimited?: boolean;
+    resetAt?: number;
+    window?: string;
+}
+export interface UsageFact {
+    label: string;
+    value: string;
+}
+export interface UsageResetCredit {
+    id?: string;
+    status?: string;
+    grantedAt?: number;
+    expiresAt?: number;
+}
+export interface UsageResetCredits {
+    availableCount: number;
+    credits?: UsageResetCredit[];
+}
+export interface ProviderUsageData {
+    plan?: string;
+    account?: OAuthCredential["account"];
+    meters?: UsageMeter[];
+    facts?: UsageFact[];
+    resetCredits?: UsageResetCredits;
+    note?: string;
+    extensions?: Record<string, unknown>;
+}
+export interface ProviderUsage extends ProviderUsageData {
+    provider: ProviderId;
+    accountKey: string;
+    asOf: number;
+}
+export interface ProviderUsageContext {
+    credential: OAuthCredential;
+    signal: AbortSignal;
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+}
+export interface ProviderModel {
+    id: string;
+    name?: string;
+    description?: string;
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    reasoningEfforts?: string[];
+    inputModalities?: string[];
+    endpoints?: string[];
+    supportsToolCall?: boolean;
+    available?: boolean;
+    selectable?: boolean;
+}
+export interface ProviderModels {
+    provider: ProviderId;
+    accountKey: string;
+    asOf: number;
+    models: ProviderModel[];
+}
+export interface CredentialSummary {
+    provider: ProviderId;
+    accountKey: string;
+    accessCredentialStored: boolean;
+    refreshCredentialStored: boolean;
+    automaticRefresh: boolean;
+    expiresAt: number;
+    needsRefresh: boolean;
+    externallyManaged: boolean;
+    reauthRequired?: boolean;
+    endpoint?: string;
+    account?: OAuthCredential["account"];
+}
+/** Safe, account-scoped data for product settings and account views. */
+export interface SubscriptionAccountDetails {
+    session: Session;
+    credential: CredentialSummary;
+    usage: ProviderUsage | null;
+    models: ProviderModels | null;
+}
+export interface DeviceLoginPrompt {
+    mode: "device";
+    verificationUri: string;
+    userCode: string;
+    expiresAt: number;
+}
+export interface BrowserLoginPrompt {
+    mode: "browser";
+    authorizationUri: string;
+    expiresAt: number;
+}
+export interface ImmediateLoginPrompt {
+    mode: "external-token" | "external-cli" | "api-key";
+    expiresAt: number;
+}
+export type LoginPrompt = DeviceLoginPrompt | BrowserLoginPrompt | ImmediateLoginPrompt;
+export interface ProviderLogin {
+    prompt: LoginPrompt;
+    complete: Promise<OAuthCredential>;
+}
+export interface ProviderLoginField {
+    name: string;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    type?: "text" | "url" | "password";
+    required?: boolean;
+}
+export interface ProviderAdapter {
+    readonly id: ProviderId;
+    readonly name: string;
+    readonly loginModes: readonly LoginMode[];
+    readonly description?: string;
+    readonly homepage?: string;
+    readonly allowedHosts?: readonly string[];
+    readonly loginFields?: readonly ProviderLoginField[];
+    readonly supportsFetch?: boolean;
+    readonly proxyBaseUrl?: string | ((credential: OAuthCredential) => string | undefined);
+    /** Optional local OpenAI-compatible bridge for providers without a pass-through API. */
+    proxy?(request: Request, credential: OAuthCredential): Promise<Response>;
+    normalizeResponse?(request: Request, response: Response): Response | Promise<Response>;
+    startLogin(signal: AbortSignal, options?: Record<string, unknown>): Promise<ProviderLogin>;
+    refresh(credential: OAuthCredential, signal: AbortSignal): Promise<OAuthCredential>;
+    authorize(request: Request, credential: OAuthCredential): Request | Promise<Request>;
+    getUsage?(context: ProviderUsageContext): Promise<ProviderUsageData | null>;
+    getModels?(context: ProviderUsageContext): Promise<ProviderModel[]>;
+    isPermanentRefreshError?(error: unknown): boolean;
+}
+export interface ProviderSummary {
+    id: ProviderId;
+    name: string;
+    loginModes: readonly LoginMode[];
+    description?: string;
+    homepage?: string;
+    allowedHosts?: readonly string[];
+    loginFields?: readonly ProviderLoginField[];
+    supportsFetch: boolean;
+    supportsProxy: boolean;
+    supportsUsage: boolean;
+    supportsModels: boolean;
+}
+export interface Session {
+    provider: ProviderId;
+    accountKey: string;
+    authenticated: boolean;
+    expiresAt?: number;
+    needsRefresh?: boolean;
+    reauthRequired?: boolean;
+    account?: OAuthCredential["account"];
+}
+export type LoginState = "pending" | "complete" | "failed" | "cancelled";
+export interface LoginAttempt {
+    id: string;
+    provider: ProviderId;
+    accountKey: string;
+    prompt: LoginPrompt;
+    get state(): LoginState;
+    get error(): string | null;
+    wait(): Promise<Session>;
+    cancel(): void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/usage.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderUsageData } from "./types.js";
+export declare function parseChatGptUsage(raw: unknown, detailedResetCredits?: unknown): ProviderUsageData | null;
+export declare function copilotPlanName(raw: unknown): string | undefined;
+export declare function parseCopilotUsage(raw: unknown): ProviderUsageData | null;
+export declare function parseGrokUsage(raw: unknown, userRaw?: unknown, settingsRaw?: unknown): ProviderUsageData | null;