aisubs 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,76 @@
+import type { CredentialStore, CredentialSummary, LoginAttempt, LoginState, ProviderAdapter, ProviderId, ProviderModels, ProviderSummary, ProviderUsage, Session, SubscriptionAccountDetails } from "./types.js";
+export interface SubscriptionAuthOptions {
+    refreshTimeoutMs?: number;
+    /** Successful usage snapshots stay in memory briefly; credentials never do. */
+    usageCacheTtlMs?: number;
+    /** Successful model catalogs stay in memory briefly; credentials never do. */
+    modelsCacheTtlMs?: number;
+}
+export declare const DEFAULT_ACCOUNT = "default";
+export interface SubscriptionAccount {
+    readonly provider: ProviderId;
+    readonly accountKey: string;
+    signIn(options?: Record<string, unknown>): Promise<LoginAttempt>;
+    status(options?: {
+        validate?: boolean;
+    }): Promise<Session>;
+    signOut(): Promise<void>;
+    getAccessToken(): Promise<string>;
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+    proxy(path: string, init?: RequestInit): Promise<Response>;
+    getUsage(signal?: AbortSignal): Promise<ProviderUsage | null>;
+    getModels(signal?: AbortSignal): Promise<ProviderModels | null>;
+    credentialSummary(): Promise<CredentialSummary>;
+    details(signal?: AbortSignal): Promise<SubscriptionAccountDetails>;
+}
+export declare class SubscriptionAuth {
+    readonly store: CredentialStore;
+    private readonly adapters;
+    private readonly attempts;
+    private readonly generations;
+    private readonly refreshes;
+    private readonly usageCache;
+    private readonly modelsCache;
+    private readonly usageInflight;
+    private readonly modelsInflight;
+    private readonly metadataGenerations;
+    private readonly refreshTimeoutMs;
+    private readonly usageCacheTtlMs;
+    private readonly modelsCacheTtlMs;
+    constructor(store: CredentialStore, providers: readonly ProviderAdapter[], options?: SubscriptionAuthOptions);
+    listProviders(): ProviderSummary[];
+    private adapter;
+    private generation;
+    private advance;
+    private clearMetadata;
+    private cachedMetadata;
+    signIn(provider: ProviderId, options?: Record<string, unknown>): Promise<LoginAttempt>;
+    private expireLoginAttempt;
+    getLoginAttempt(id: string): {
+        provider: ProviderId;
+        accountKey: string;
+        state: LoginState;
+        error: string | null;
+    } | null;
+    cancelLoginAttempt(id: string): boolean;
+    status(provider: ProviderId, options?: {
+        validate?: boolean;
+        account?: string;
+    }): Promise<Session>;
+    statuses(): Promise<Session[]>;
+    listAccounts(provider: ProviderId): Promise<Session[]>;
+    signOut(provider: ProviderId, account?: string): Promise<void>;
+    private credential;
+    getAccessToken(provider: ProviderId, account?: string): Promise<string>;
+    credentialSummary(provider: ProviderId, account?: string): Promise<CredentialSummary>;
+    details(provider: ProviderId, account?: string, signal?: AbortSignal): Promise<SubscriptionAccountDetails>;
+    fetch(provider: ProviderId, input: string | URL | Request, init?: RequestInit, account?: string): Promise<Response>;
+    proxy(provider: ProviderId, account: string, path: string, init?: RequestInit): Promise<Response>;
+    getUsage(provider: ProviderId, account?: string, callerSignal?: AbortSignal): Promise<ProviderUsage | null>;
+    getModels(provider: ProviderId, account?: string, callerSignal?: AbortSignal): Promise<ProviderModels | null>;
+    account(provider: ProviderId, account: string): SubscriptionAccount;
+}
+export declare function createSubscriptionAuth(options: {
+    store?: CredentialStore;
+    providers: readonly ProviderAdapter[];
+} & SubscriptionAuthOptions): SubscriptionAuth;

package/dist/auth.js

@@ -0,0 +1,477 @@
+import { defaultAiSubsDataDir, FileCredentialStore } from "./store.js";
+import { errorMessage } from "./utils.js";
+import { join } from "node:path";
+export const DEFAULT_ACCOUNT = "default";
+const ACCOUNT_STORAGE_PREFIX = "$subscription-account$";
+const LOGIN_ATTEMPT_RETENTION_MS = 5 * 60_000;
+function normalizeAccountKey(value) {
+    if (value == null)
+        return DEFAULT_ACCOUNT;
+    if (typeof value !== "string")
+        throw new Error("account must be a string");
+    const account = value.trim();
+    const hasControlCharacter = [...account].some((character) => {
+        const code = character.charCodeAt(0);
+        return code <= 31 || code === 127;
+    });
+    if (!account || account.length > 128 || hasControlCharacter) {
+        throw new Error("account must be 1-128 characters without control characters");
+    }
+    return account;
+}
+function credentialKey(provider, accountKey) {
+    if (accountKey === DEFAULT_ACCOUNT)
+        return provider;
+    return `${ACCOUNT_STORAGE_PREFIX}${Buffer.from(JSON.stringify([provider, accountKey])).toString("base64url")}`;
+}
+function accountFromCredentialKey(provider, key) {
+    if (key === provider)
+        return DEFAULT_ACCOUNT;
+    if (!key.startsWith(ACCOUNT_STORAGE_PREFIX))
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(key.slice(ACCOUNT_STORAGE_PREFIX.length), "base64url").toString("utf8"));
+        return Array.isArray(parsed) && parsed[0] === provider && typeof parsed[1] === "string"
+            ? parsed[1]
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function session(provider, accountKey, credential) {
+    return credential
+        ? {
+            provider,
+            accountKey,
+            authenticated: credential.metadata?.reauthRequired !== true,
+            reauthRequired: credential.metadata?.reauthRequired === true,
+            expiresAt: credential.expiresAt,
+            needsRefresh: credential.expiresAt <= Date.now(),
+            account: credential.account,
+        }
+        : { provider, accountKey, authenticated: false };
+}
+export class SubscriptionAuth {
+    store;
+    adapters = new Map();
+    attempts = new Map();
+    generations = new Map();
+    refreshes = new Map();
+    usageCache = new Map();
+    modelsCache = new Map();
+    usageInflight = new Map();
+    modelsInflight = new Map();
+    metadataGenerations = new Map();
+    refreshTimeoutMs;
+    usageCacheTtlMs;
+    modelsCacheTtlMs;
+    constructor(store, providers, options = {}) {
+        this.store = store;
+        this.refreshTimeoutMs = options.refreshTimeoutMs ?? 30_000;
+        this.usageCacheTtlMs = options.usageCacheTtlMs ?? 15_000;
+        this.modelsCacheTtlMs = options.modelsCacheTtlMs ?? 5 * 60_000;
+        for (const [name, value] of Object.entries({
+            refreshTimeoutMs: this.refreshTimeoutMs,
+            usageCacheTtlMs: this.usageCacheTtlMs,
+            modelsCacheTtlMs: this.modelsCacheTtlMs,
+        })) {
+            if (!Number.isFinite(value) || value <= 0)
+                throw new Error(`${name} must be greater than zero`);
+        }
+        for (const provider of providers) {
+            if (this.adapters.has(provider.id))
+                throw new Error(`Duplicate provider: ${provider.id}`);
+            this.adapters.set(provider.id, provider);
+        }
+    }
+    listProviders() {
+        return [...this.adapters.values()].map(({ id, name, loginModes, description, homepage, allowedHosts, loginFields, supportsFetch, proxyBaseUrl, proxy, getUsage, getModels, }) => ({
+            id,
+            name,
+            loginModes,
+            description,
+            homepage,
+            allowedHosts,
+            loginFields,
+            supportsFetch: supportsFetch !== false,
+            supportsProxy: Boolean(proxyBaseUrl || proxy),
+            supportsUsage: Boolean(getUsage),
+            supportsModels: Boolean(getModels),
+        }));
+    }
+    adapter(provider) {
+        const adapter = this.adapters.get(provider);
+        if (!adapter)
+            throw new Error(`Unknown subscription provider: ${provider}`);
+        return adapter;
+    }
+    generation(scope) {
+        return this.generations.get(scope) ?? 0;
+    }
+    advance(scope) {
+        const next = this.generation(scope) + 1;
+        this.generations.set(scope, next);
+        return next;
+    }
+    clearMetadata(scope) {
+        this.usageCache.delete(scope);
+        this.modelsCache.delete(scope);
+        this.usageInflight.delete(scope);
+        this.modelsInflight.delete(scope);
+        this.metadataGenerations.set(scope, (this.metadataGenerations.get(scope) ?? 0) + 1);
+    }
+    cachedMetadata(cache, inflight, scope, ttlMs, callerSignal, load) {
+        const cached = cache.get(scope);
+        if (cached && cached.expiresAt > Date.now())
+            return Promise.resolve(cached.value);
+        if (!callerSignal) {
+            const pending = inflight.get(scope);
+            if (pending)
+                return pending;
+        }
+        const generation = this.metadataGenerations.get(scope) ?? 0;
+        let request;
+        request = load()
+            .then((value) => {
+            if ((this.metadataGenerations.get(scope) ?? 0) === generation) {
+                cache.set(scope, { value, expiresAt: Date.now() + ttlMs });
+            }
+            return value;
+        })
+            .finally(() => {
+            if (inflight.get(scope) === request)
+                inflight.delete(scope);
+        });
+        if (!callerSignal)
+            inflight.set(scope, request);
+        return request;
+    }
+    async signIn(provider, options) {
+        const adapter = this.adapter(provider);
+        const accountKey = normalizeAccountKey(options?.account);
+        const scope = credentialKey(provider, accountKey);
+        const replace = options?.replace !== false;
+        if (!replace && (await this.store.read(scope))) {
+            throw new Error(`Account name ${accountKey} is already connected for ${provider}`);
+        }
+        const epoch = this.advance(scope);
+        for (const attempt of this.attempts.values()) {
+            if (attempt.scope === scope && attempt.state === "pending")
+                attempt.abort.abort();
+        }
+        const abort = new AbortController();
+        const providerOptions = { ...options };
+        delete providerOptions.account;
+        delete providerOptions.replace;
+        const login = await adapter.startLogin(abort.signal, providerOptions);
+        const id = crypto.randomUUID();
+        const record = {};
+        const promise = login.complete
+            .then(async (credential) => {
+            const saved = await this.store.modify(scope, (current) => {
+                if (this.generation(scope) !== epoch)
+                    return current;
+                if (current && !replace) {
+                    throw new Error(`Account name ${accountKey} is already connected for ${provider}`);
+                }
+                return credential;
+            });
+            if (this.generation(scope) !== epoch || !saved)
+                throw new Error("Login cancelled");
+            this.clearMetadata(scope);
+            record.state = "complete";
+            return session(provider, accountKey, saved);
+        })
+            .catch((error) => {
+            record.state = abort.signal.aborted ? "cancelled" : "failed";
+            record.error = errorMessage(error);
+            throw error;
+        });
+        void promise.catch(() => { });
+        Object.assign(record, {
+            id,
+            provider,
+            accountKey,
+            scope,
+            state: "pending",
+            error: null,
+            abort,
+            promise,
+        });
+        this.attempts.set(id, record);
+        void promise.then(() => this.expireLoginAttempt(id), () => this.expireLoginAttempt(id));
+        return {
+            id,
+            provider,
+            accountKey,
+            prompt: login.prompt,
+            get state() {
+                return record.state;
+            },
+            get error() {
+                return record.error;
+            },
+            wait: () => record.promise,
+            cancel: () => {
+                this.advance(scope);
+                abort.abort();
+            },
+        };
+    }
+    expireLoginAttempt(id) {
+        const timer = setTimeout(() => this.attempts.delete(id), LOGIN_ATTEMPT_RETENTION_MS);
+        timer.unref();
+    }
+    getLoginAttempt(id) {
+        const attempt = this.attempts.get(id);
+        return attempt
+            ? {
+                provider: attempt.provider,
+                accountKey: attempt.accountKey,
+                state: attempt.state,
+                error: attempt.error,
+            }
+            : null;
+    }
+    cancelLoginAttempt(id) {
+        const attempt = this.attempts.get(id);
+        if (!attempt || attempt.state !== "pending")
+            return false;
+        this.advance(attempt.scope);
+        attempt.abort.abort();
+        return true;
+    }
+    async status(provider, options = {}) {
+        const accountKey = normalizeAccountKey(options.account);
+        if (options.validate)
+            await this.getAccessToken(provider, accountKey).catch(() => null);
+        return session(provider, accountKey, await this.store.read(credentialKey(provider, accountKey)));
+    }
+    async statuses() {
+        const sessions = await Promise.all([...this.adapters.keys()].map(async (provider) => {
+            const accounts = await this.listAccounts(provider);
+            return accounts.length ? accounts : [await this.status(provider)];
+        }));
+        return sessions.flat();
+    }
+    async listAccounts(provider) {
+        this.adapter(provider);
+        const keys = this.store.listKeys ? await this.store.listKeys() : [provider];
+        const accounts = keys.flatMap((key) => {
+            const account = accountFromCredentialKey(provider, key);
+            return account == null ? [] : [account];
+        });
+        return Promise.all([...new Set(accounts)].map((account) => this.status(provider, { account })));
+    }
+    async signOut(provider, account = DEFAULT_ACCOUNT) {
+        const accountKey = normalizeAccountKey(account);
+        const scope = credentialKey(provider, accountKey);
+        this.advance(scope);
+        this.clearMetadata(scope);
+        for (const refresh of this.refreshes.get(scope) ?? [])
+            refresh.abort();
+        for (const attempt of this.attempts.values()) {
+            if (attempt.scope === scope && attempt.state === "pending")
+                attempt.abort.abort();
+        }
+        await this.store.delete(scope);
+    }
+    async credential(provider, account, forceRefresh = false) {
+        const adapter = this.adapter(provider);
+        const accountKey = normalizeAccountKey(account);
+        const scope = credentialKey(provider, accountKey);
+        const observed = await this.store.read(scope);
+        if (!observed)
+            throw new Error(`Not authenticated with ${provider} account ${accountKey}`);
+        if (observed.metadata?.reauthRequired === true) {
+            throw new Error(`Session expired for ${provider} account ${accountKey}; sign in again`);
+        }
+        if (!forceRefresh && observed.expiresAt > Date.now())
+            return observed;
+        const epoch = this.generation(scope);
+        const refreshed = await this.store.modify(scope, async (current) => {
+            if (!current)
+                throw new Error(`Not authenticated with ${provider} account ${accountKey}`);
+            if (this.generation(scope) !== epoch)
+                return current;
+            if (current.accessToken !== observed.accessToken && current.expiresAt > Date.now()) {
+                return current;
+            }
+            const abort = new AbortController();
+            const active = this.refreshes.get(scope) ?? new Set();
+            active.add(abort);
+            this.refreshes.set(scope, active);
+            try {
+                const signal = AbortSignal.any([abort.signal, AbortSignal.timeout(this.refreshTimeoutMs)]);
+                const next = await adapter.refresh(current, signal);
+                return this.generation(scope) === epoch ? next : current;
+            }
+            catch (error) {
+                if (adapter.isPermanentRefreshError?.(error)) {
+                    return {
+                        accessToken: "",
+                        expiresAt: 0,
+                        account: current.account,
+                        metadata: { ...current.metadata, reauthRequired: true },
+                    };
+                }
+                throw error;
+            }
+            finally {
+                active.delete(abort);
+                if (active.size === 0)
+                    this.refreshes.delete(scope);
+            }
+        });
+        if (this.generation(scope) !== epoch) {
+            throw new Error(`Session changed while refreshing ${provider} account ${accountKey}`);
+        }
+        if (!refreshed || refreshed.metadata?.reauthRequired === true) {
+            this.clearMetadata(scope);
+            throw new Error(`Session expired for ${provider} account ${accountKey}; sign in again`);
+        }
+        this.clearMetadata(scope);
+        return refreshed;
+    }
+    async getAccessToken(provider, account = DEFAULT_ACCOUNT) {
+        const credential = await this.credential(provider, account);
+        if (credential.metadata?.delegatedCli === true) {
+            throw new Error(`${provider} authentication is delegated to its official CLI`);
+        }
+        return credential.accessToken;
+    }
+    async credentialSummary(provider, account = DEFAULT_ACCOUNT) {
+        const adapter = this.adapter(provider);
+        const accountKey = normalizeAccountKey(account);
+        const credential = await this.store.read(credentialKey(provider, accountKey));
+        if (!credential)
+            throw new Error(`Not authenticated with ${provider} account ${accountKey}`);
+        return {
+            provider,
+            accountKey,
+            accessCredentialStored: Boolean(credential.accessToken) && credential.metadata?.delegatedCli !== true,
+            refreshCredentialStored: Boolean(credential.refreshToken),
+            automaticRefresh: Boolean(credential.refreshToken) || credential.metadata?.delegatedCli === true,
+            expiresAt: credential.expiresAt,
+            needsRefresh: credential.expiresAt <= Date.now(),
+            externallyManaged: credential.metadata?.delegatedCli === true,
+            reauthRequired: credential.metadata?.reauthRequired === true,
+            endpoint: typeof adapter.proxyBaseUrl === "function"
+                ? adapter.proxyBaseUrl(credential)
+                : adapter.proxyBaseUrl,
+            account: credential.account,
+        };
+    }
+    async details(provider, account = DEFAULT_ACCOUNT, signal) {
+        const accountKey = normalizeAccountKey(account);
+        const [session, credential, usage, models] = await Promise.all([
+            this.status(provider, { account: accountKey }),
+            this.credentialSummary(provider, accountKey),
+            this.getUsage(provider, accountKey, signal),
+            this.getModels(provider, accountKey, signal),
+        ]);
+        return { session, credential, usage, models };
+    }
+    async fetch(provider, input, init, account = DEFAULT_ACCOUNT) {
+        const adapter = this.adapter(provider);
+        const original = new Request(input, init);
+        const accountKey = normalizeAccountKey(account);
+        const send = async (credential) => {
+            const authorized = await adapter.authorize(original.clone(), credential);
+            const headers = new Headers(authorized.headers);
+            headers.set("cache-control", "no-store");
+            const request = new Request(authorized, { cache: "no-store", headers });
+            const response = await globalThis.fetch(request);
+            return adapter.normalizeResponse?.(request, response) ?? response;
+        };
+        if (adapter.supportsFetch === false) {
+            throw new Error(`${provider} does not expose credentials for direct provider requests`);
+        }
+        let response = await send(await this.credential(provider, accountKey));
+        if (response.status === 401) {
+            await response.body?.cancel();
+            response = await send(await this.credential(provider, accountKey, true));
+        }
+        return response;
+    }
+    async proxy(provider, account, path, init) {
+        const adapter = this.adapter(provider);
+        const accountKey = normalizeAccountKey(account);
+        const credential = await this.credential(provider, accountKey);
+        if (adapter.proxy) {
+            const local = new Request(`http://aisubs.local/${path.replace(/^\//, "")}`, init);
+            let response = await adapter.proxy(local.clone(), credential);
+            if (response.status === 401) {
+                await response.body?.cancel();
+                response = await adapter.proxy(local.clone(), await this.credential(provider, accountKey, true));
+            }
+            return response;
+        }
+        const baseUrl = typeof adapter.proxyBaseUrl === "function"
+            ? adapter.proxyBaseUrl(credential)
+            : adapter.proxyBaseUrl;
+        if (!baseUrl)
+            throw new Error(`${provider} does not expose a direct API endpoint`);
+        const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+        return this.fetch(provider, new URL(path, base), init, accountKey);
+    }
+    async getUsage(provider, account = DEFAULT_ACCOUNT, callerSignal) {
+        const adapter = this.adapter(provider);
+        if (!adapter.getUsage)
+            return null;
+        const accountKey = normalizeAccountKey(account);
+        const scope = credentialKey(provider, accountKey);
+        return this.cachedMetadata(this.usageCache, this.usageInflight, scope, this.usageCacheTtlMs, callerSignal, async () => {
+            const credential = await this.credential(provider, accountKey);
+            const timeout = AbortSignal.timeout(this.refreshTimeoutMs);
+            const signal = callerSignal ? AbortSignal.any([callerSignal, timeout]) : timeout;
+            const data = await adapter.getUsage({
+                credential,
+                signal,
+                fetch: (input, init) => this.fetch(provider, input, init, accountKey),
+            });
+            return data ? { provider, accountKey, asOf: Date.now(), ...data } : null;
+        });
+    }
+    async getModels(provider, account = DEFAULT_ACCOUNT, callerSignal) {
+        const adapter = this.adapter(provider);
+        if (!adapter.getModels)
+            return null;
+        const accountKey = normalizeAccountKey(account);
+        const scope = credentialKey(provider, accountKey);
+        return this.cachedMetadata(this.modelsCache, this.modelsInflight, scope, this.modelsCacheTtlMs, callerSignal, async () => {
+            const credential = await this.credential(provider, accountKey);
+            const timeout = AbortSignal.timeout(this.refreshTimeoutMs);
+            const signal = callerSignal ? AbortSignal.any([callerSignal, timeout]) : timeout;
+            const models = await adapter.getModels({
+                credential,
+                signal,
+                fetch: (input, init) => this.fetch(provider, input, init, accountKey),
+            });
+            return { provider, accountKey, asOf: Date.now(), models };
+        });
+    }
+    account(provider, account) {
+        const accountKey = normalizeAccountKey(account);
+        this.adapter(provider);
+        return {
+            provider,
+            accountKey,
+            signIn: (options) => this.signIn(provider, { ...options, account: accountKey }),
+            status: (options) => this.status(provider, { ...options, account: accountKey }),
+            signOut: () => this.signOut(provider, accountKey),
+            getAccessToken: () => this.getAccessToken(provider, accountKey),
+            fetch: (input, init) => this.fetch(provider, input, init, accountKey),
+            proxy: (path, init) => this.proxy(provider, accountKey, path, init),
+            getUsage: (signal) => this.getUsage(provider, accountKey, signal),
+            getModels: (signal) => this.getModels(provider, accountKey, signal),
+            credentialSummary: () => this.credentialSummary(provider, accountKey),
+            details: (signal) => this.details(provider, accountKey, signal),
+        };
+    }
+}
+export function createSubscriptionAuth(options) {
+    const store = options.store ?? new FileCredentialStore(join(defaultAiSubsDataDir(), "credentials.json"));
+    return new SubscriptionAuth(store, options.providers, options);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { join, resolve } from "node:path";
+import { createSubscriptionAuth } from "./auth.js";
+import { createSubscriptionAuthDashboardServer } from "./dashboard.js";
+import { chatGptProvider } from "./providers/chatgpt.js";
+import { claudeProvider } from "./providers/claude.js";
+import { copilotProvider } from "./providers/copilot.js";
+import { grokProvider } from "./providers/grok.js";
+import { openCodeGoProvider, openCodeZenProvider } from "./providers/opencode.js";
+import { defaultAiSubsDataDir, FileCredentialStore } from "./store.js";
+const DEFAULT_DASHBOARD_PORT = 4319;
+function usage() {
+    console.log(`AI Subs
+
+Usage:
+  aisubs dashboard [options]
+
+Options:
+  --data-dir <path>       State directory (default: ~/.aisubs)
+  --port <number>         Local port (default: 4319; use 0 for any available port)
+  --no-open               Print the secure link without opening a browser
+  --help                   Show this help
+`);
+}
+function value(args, index, flag) {
+    const next = args[index + 1];
+    if (!next || next.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+    return next;
+}
+function openBrowser(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => undefined);
+    child.unref();
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+        usage();
+        return;
+    }
+    const command = args[0];
+    if (command !== "dashboard")
+        throw new Error(`Unknown command: ${command}`);
+    let dataDirectory = defaultAiSubsDataDir();
+    let port = DEFAULT_DASHBOARD_PORT;
+    let shouldOpen = true;
+    for (let index = 1; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--no-open")
+            shouldOpen = false;
+        else if (argument === "--data-dir")
+            dataDirectory = resolve(value(args, index++, argument));
+        else if (argument === "--port")
+            port = Number(value(args, index++, argument));
+        else
+            throw new Error(`Unknown option: ${argument}`);
+    }
+    if (!Number.isInteger(port) || port < 0 || port > 65535)
+        throw new Error("Invalid port");
+    const store = new FileCredentialStore(join(dataDirectory, "credentials.json"));
+    const auth = createSubscriptionAuth({
+        store,
+        providers: [
+            chatGptProvider(),
+            claudeProvider(),
+            copilotProvider(),
+            grokProvider(),
+            openCodeGoProvider(),
+            openCodeZenProvider(),
+        ],
+    });
+    const dashboard = await createSubscriptionAuthDashboardServer({ auth, port });
+    console.log(`AI Subs is running at ${dashboard.url}`);
+    console.log(`Credentials: ${store.file}`);
+    console.log(`Control API key: ${dashboard.apiKey}`);
+    console.log(`Dashboard link: ${dashboard.bootstrapUrl}`);
+    console.log("Press Ctrl+C to stop.");
+    if (shouldOpen)
+        openBrowser(dashboard.bootstrapUrl);
+    let closing = false;
+    const close = async () => {
+        if (closing)
+            return;
+        closing = true;
+        await dashboard.close();
+    };
+    process.once("SIGINT", () => void close().then(() => process.exit(0)));
+    process.once("SIGTERM", () => void close().then(() => process.exit(0)));
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/dashboard/aisubs-mark.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 56 56">
+  <rect width="56" height="56" rx="14" fill="#e5e5e5"/>
+  <path
+    fill="#0f0f0f"
+    fill-rule="evenodd"
+    d="M11.25 25.12C11.34 24.55 11.74 22.98 12 22.38C12.26 21.77 12.21 21.23 13.38 20.12C14.54 19.02 20.49 14.16 21.75 13.12C23.01 12.09 23.27 11.86 23.88 11.5C24.48 11.14 26.18 10.34 26.75 10.12C27.32 9.91 28.1 9.79 28.62 9.75C29.15 9.71 30.61 9.71 31.12 9.75C31.64 9.79 32.41 9.96 32.88 10.12C33.34 10.29 34.45 10.72 35 11.12C35.55 11.53 37.01 12.81 37.5 13.5C37.99 14.19 38.9 16.16 39.12 16.88C39.35 17.59 39.08 19.04 39.38 19.5C39.67 19.96 41.15 20.38 41.62 20.75C42.1 21.12 43.05 22.19 43.38 22.62C43.7 23.06 44.16 23.8 44.38 24.38C44.59 24.95 45.03 26.77 45.12 27.38C45.22 27.98 45.2 28.84 45.12 29.38C45.05 29.91 44.78 31.23 44.5 31.88C44.22 32.52 44.1 33.46 42.75 34.75C41.4 36.04 34.78 41.47 33.25 42.62C31.72 43.78 30.59 44.12 30 44.38C29.41 44.63 28.93 44.7 28.38 44.75C27.82 44.8 26.18 44.91 25.38 44.75C24.57 44.59 22.41 43.83 21.62 43.38C20.84 42.92 19.4 41.65 18.88 41C18.35 40.35 17.5 38.77 17.25 38C17 37.23 17.04 35.15 16.75 34.62C16.46 34.1 15.29 33.94 14.88 33.62C14.46 33.31 13.6 32.44 13.25 32C12.9 31.57 12.24 30.59 12 30C11.76 29.41 11.34 27.71 11.25 27.12C11.16 26.54 11.16 25.7 11.25 25.12Z
+      M14.75 25.75C14.72 26.45 15.12 28.27 15.38 28.88C15.63 29.48 16.61 30.5 16.88 30.75C17.14 31 17.48 31.14 17.62 31C17.77 30.86 17.95 29.95 18.12 29.62C18.3 29.3 18.66 28.71 19.12 28.25C19.59 27.79 20.7 26.75 22 25.75C23.3 24.75 28.65 20.73 30 19.88C31.35 19.02 32.56 18.79 33.25 18.62C33.94 18.46 35.48 18.68 35.75 18.5C36.02 18.32 35.74 17.59 35.5 17.12C35.26 16.66 34.2 15.06 33.75 14.62C33.3 14.19 32.34 13.66 31.75 13.5C31.16 13.34 29.49 13.21 28.88 13.25C28.26 13.29 28.07 12.88 26.62 13.88C25.18 14.87 18.2 20.41 16.88 21.5C15.55 22.59 15.88 22.49 15.62 23C15.37 23.51 14.78 25.05 14.75 25.75Z
+      M20.75 32C20.68 32.16 20.5 32.23 20.75 32.25C21 32.27 22.38 32.24 22.88 32.12C23.37 32.01 23.63 32.13 24.88 31.25C26.12 30.36 32.06 25.73 33.25 24.75C34.44 23.77 34.51 23.45 34.75 23.12C34.99 22.8 35.35 22.14 35.25 22C35.15 21.86 34.31 21.89 33.88 22C33.44 22.11 32.98 21.96 31.62 22.88C30.27 23.79 23.86 28.66 22.62 29.62C21.39 30.59 21.6 30.59 21.38 30.88C21.15 31.16 20.82 31.84 20.75 32Z
+      M20.5 35.75C20.16 36.11 21.05 37.84 21.38 38.38C21.7 38.91 22.71 39.91 23.25 40.25C23.79 40.59 25.32 41.13 25.88 41.25C26.43 41.37 27.45 41.3 27.88 41.25C28.3 41.2 29.05 40.99 29.38 40.88C29.7 40.76 29.41 41.16 30.62 40.25C31.84 39.34 38.34 34.2 39.5 33.25C40.66 32.3 40.04 32.69 40.25 32.38C40.46 32.06 41.09 31.02 41.25 30.62C41.41 30.23 41.62 29.68 41.62 29.12C41.62 28.57 41.43 26.6 41.25 26C41.07 25.4 40.44 24.48 40.12 24.12C39.81 23.77 38.9 22.93 38.62 23C38.35 23.07 38.2 24.25 37.88 24.75C37.55 25.25 37.18 26.02 35.88 27.12C34.57 28.23 28.39 33.01 27 34C25.61 34.99 25.03 35.16 24.25 35.38C23.47 35.59 20.84 35.39 20.5 35.75Z"
+  />
+</svg>