@gnahz77/opencode-copilot-multi-auth 0.1.0 → 0.1.2

package/dist/pool.js

@@ -0,0 +1,157 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname } from "path";
+import { ACCOUNT_POOL_SCHEMA_VERSION } from "./constants.js";
+import { matchesAnyModelIdPattern, normalizeDomain, normalizeIdSource, normalizeList, normalizePriority, preserveStringOrDefault, } from "./utils.js";
+export function getPoolPath() {
+    return `${homedir()}/.local/share/opencode/copilot-auth.json`;
+}
+export function validatePoolSchema(pool, context) {
+    if (!pool
+        || typeof pool !== "object"
+        || pool.version !== ACCOUNT_POOL_SCHEMA_VERSION
+        || !Array.isArray(pool.accounts)) {
+        throw new Error(`[opencode-copilot-cli-auth] Invalid ${context}: expected { version: ${ACCOUNT_POOL_SCHEMA_VERSION}, accounts: [] } schema.`);
+    }
+    return pool;
+}
+export function readPool() {
+    const poolPath = getPoolPath();
+    if (!existsSync(poolPath)) {
+        const defaultPool = {
+            version: ACCOUNT_POOL_SCHEMA_VERSION,
+            accounts: [],
+        };
+        writePool(defaultPool);
+        return defaultPool;
+    }
+    const raw = readFileSync(poolPath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`[opencode-copilot-cli-auth] Malformed JSON in account pool file at ${poolPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return validatePoolSchema(parsed, `account pool file at ${poolPath}`);
+}
+export function writePool(pool) {
+    const validatedPool = validatePoolSchema(pool, "account pool payload");
+    const poolPath = getPoolPath();
+    const dirPath = dirname(poolPath);
+    const tmpPath = `${poolPath}.tmp`;
+    mkdirSync(dirPath, { recursive: true });
+    writeFileSync(tmpPath, `${JSON.stringify(validatedPool, null, 2)}\n`, "utf8");
+    renameSync(tmpPath, poolPath);
+    chmodSync(poolPath, 0o600);
+}
+function deriveDefaultAccountId(accounts, key, identity) {
+    const userIdText = String(identity.userId);
+    const baseId = normalizeIdSource(identity.login || userIdText) || userIdText;
+    const idTakenByDifferentKey = accounts.some((account) => account?.id === baseId && account?.key !== key);
+    if (!idTakenByDifferentKey) {
+        return baseId;
+    }
+    return `${baseId}-${userIdText.slice(-6)}`;
+}
+export function deriveAccountKey(deployment, userId) {
+    return `${deployment}:${userId}`;
+}
+export function upsertAccount(pool, accountData) {
+    const validatedPool = validatePoolSchema(pool, "account pool payload");
+    const now = new Date().toISOString();
+    const { key, deployment, domain, identity, enterpriseUrl, baseUrl, auth, authResult, } = accountData ?? {};
+    if (!key || typeof key !== "string") {
+        throw new Error("[opencode-copilot-cli-auth] Cannot upsert account: missing key.");
+    }
+    const userId = Number(identity?.userId);
+    if (!Number.isFinite(userId)) {
+        throw new Error("[opencode-copilot-cli-auth] Cannot upsert account: missing numeric identity.userId.");
+    }
+    const login = typeof identity?.login === "string" ? identity.login : "";
+    const normalizedDeployment = normalizeDomain(deployment || domain || enterpriseUrl || "github.com");
+    const normalizedDomain = normalizeDomain(domain || normalizedDeployment);
+    const normalizedEnterpriseUrl = normalizedDeployment === "github.com"
+        ? null
+        : normalizeDomain(enterpriseUrl || normalizedDeployment);
+    const normalizedIdentity = {
+        login,
+        userId,
+    };
+    const defaultId = deriveDefaultAccountId(validatedPool.accounts, key, normalizedIdentity);
+    const defaultName = login || String(userId);
+    const mergedAuth = (auth ?? authResult ?? {});
+    const nextBaseUrl = baseUrl ?? authResult?.baseUrl ?? null;
+    const existingIndex = validatedPool.accounts.findIndex((account) => account?.key === key);
+    if (existingIndex === -1) {
+        return {
+            ...validatedPool,
+            accounts: [
+                ...validatedPool.accounts,
+                {
+                    key,
+                    id: defaultId,
+                    name: defaultName,
+                    enabled: true,
+                    priority: 0,
+                    deployment: normalizedDeployment,
+                    domain: normalizedDomain,
+                    identity: normalizedIdentity,
+                    enterpriseUrl: normalizedEnterpriseUrl,
+                    baseUrl: nextBaseUrl,
+                    allowlist: [],
+                    blocklist: [],
+                    auth: mergedAuth,
+                    createdAt: now,
+                    updatedAt: now,
+                },
+            ],
+        };
+    }
+    const existing = validatedPool.accounts[existingIndex];
+    const updatedAccount = {
+        ...existing,
+        key,
+        deployment: normalizedDeployment,
+        domain: normalizedDomain,
+        identity: normalizedIdentity,
+        enterpriseUrl: normalizedEnterpriseUrl,
+        auth: mergedAuth,
+        baseUrl: nextBaseUrl ?? existing.baseUrl ?? null,
+        id: preserveStringOrDefault(existing.id, defaultId),
+        name: preserveStringOrDefault(existing.name, defaultName),
+        enabled: typeof existing.enabled === "boolean" ? existing.enabled : true,
+        priority: Number.isFinite(existing.priority) ? existing.priority : 0,
+        allowlist: Array.isArray(existing.allowlist) ? existing.allowlist : [],
+        blocklist: Array.isArray(existing.blocklist) ? existing.blocklist : [],
+        createdAt: existing.createdAt ?? now,
+        updatedAt: now,
+    };
+    const nextAccounts = [...validatedPool.accounts];
+    nextAccounts[existingIndex] = updatedAccount;
+    return {
+        ...validatedPool,
+        accounts: nextAccounts,
+    };
+}
+export function resolveWinnerAccount(rawModelId, pool) {
+    const canAccountServeModel = (account) => {
+        const allowlist = normalizeList(account?.allowlist);
+        if (allowlist.length > 0 && !matchesAnyModelIdPattern(allowlist, rawModelId)) {
+            return false;
+        }
+        const blocklist = normalizeList(account?.blocklist);
+        return !matchesAnyModelIdPattern(blocklist, rawModelId);
+    };
+    const candidates = (Array.isArray(pool?.accounts) ? pool.accounts : [])
+        .filter((account) => account?.enabled !== false)
+        .filter(canAccountServeModel)
+        .sort((left, right) => {
+        const priorityDelta = normalizePriority(left?.priority) - normalizePriority(right?.priority);
+        if (priorityDelta !== 0) {
+            return priorityDelta;
+        }
+        return String(left?.key ?? "").localeCompare(String(right?.key ?? ""));
+    });
+    return candidates[0] ?? null;
+}

package/dist/routing.d.ts

@@ -0,0 +1,8 @@
+import type { HeaderObject } from "./types.js";
+export declare function injectRoutingHeaders(headers: HeaderObject, accountKey: string): {
+    "x-opencode-copilot-account-key": string;
+    "x-opencode-copilot-route-source": string;
+};
+export declare function stripRoutingHeaders(headers: HeaderObject): {
+    [k: string]: string;
+};

package/dist/routing.js

@@ -0,0 +1,12 @@
+import { INTERNAL_ROUTING_HEADERS, ROUTING_ACCOUNT_KEY_HEADER, ROUTING_SOURCE_HEADER } from "./constants.js";
+import { normalizeHeaderObject } from "./utils.js";
+export function injectRoutingHeaders(headers, accountKey) {
+    return {
+        ...normalizeHeaderObject(headers),
+        [ROUTING_ACCOUNT_KEY_HEADER]: accountKey,
+        [ROUTING_SOURCE_HEADER]: "model-resolution",
+    };
+}
+export function stripRoutingHeaders(headers) {
+    return Object.fromEntries(Object.entries(normalizeHeaderObject(headers)).filter(([key]) => !INTERNAL_ROUTING_HEADERS.has(key.toLowerCase())));
+}

package/dist/tui.d.ts

@@ -0,0 +1,5 @@
+import type { TuiPluginModule } from "@opencode-ai/plugin/tui";
+declare const pluginModule: TuiPluginModule & {
+    id: string;
+};
+export default pluginModule;

package/dist/tui.js

@@ -0,0 +1,44 @@
+import { getCopilotUsageDialogMessage } from "./usage.js";
+const id = "@gnahz77/opencode-copilot-multi-auth";
+function showErrorToast(api, error) {
+    api.ui.toast({
+        title: "Copilot Usage",
+        message: error instanceof Error ? error.message : String(error),
+        variant: "error",
+        duration: 7000,
+    });
+}
+async function showCopilotUsageDialog(api) {
+    try {
+        const message = await getCopilotUsageDialogMessage();
+        api.ui.dialog.setSize("xlarge");
+        api.ui.dialog.replace(() => api.ui.DialogAlert({
+            title: "Copilot Usage",
+            message,
+        }));
+    }
+    catch (error) {
+        showErrorToast(api, error);
+    }
+}
+const tui = async (api) => {
+    api.command.register(() => [
+        {
+            title: "Copilot Usage",
+            value: "copilot-usage",
+            description: "Show Copilot usage for all accounts in the local account pool.",
+            category: "GitHub Copilot",
+            slash: {
+                name: "copilot-usage",
+            },
+            onSelect() {
+                void showCopilotUsageDialog(api);
+            },
+        },
+    ]);
+};
+const pluginModule = {
+    id,
+    tui,
+};
+export default pluginModule;

package/dist/types.d.ts

@@ -0,0 +1,133 @@
+export interface PoolIdentity {
+    login: string;
+    userId: number;
+}
+export interface OAuthAuth {
+    type: "oauth";
+    refresh: string;
+    access?: string;
+    expires?: number;
+    baseUrl?: string | null;
+    provider?: string;
+    enterpriseUrl?: string;
+}
+export interface PoolAccount {
+    key: string;
+    id: string;
+    name: string;
+    enabled: boolean;
+    priority: number;
+    deployment: string;
+    domain: string;
+    identity: PoolIdentity;
+    enterpriseUrl: string | null;
+    baseUrl: string | null;
+    allowlist: string[];
+    blocklist: string[];
+    auth: OAuthAuth;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface UpsertAccountData {
+    key: string;
+    deployment?: string;
+    domain?: string;
+    identity?: Partial<PoolIdentity>;
+    enterpriseUrl?: string | null;
+    baseUrl?: string | null;
+    auth?: OAuthAuth;
+    authResult?: OAuthAuth;
+}
+export interface AccountPool {
+    version: number;
+    accounts: PoolAccount[];
+}
+export interface LiveModel {
+    id: string;
+    name?: string;
+    version?: string;
+    model_picker_enabled?: boolean;
+    capabilities?: {
+        type?: string;
+        family?: string;
+        limits?: {
+            max_context_window_tokens?: number;
+            max_prompt_tokens?: number;
+            max_output_tokens?: number;
+            max_non_streaming_output_tokens?: number;
+            vision?: boolean;
+        };
+        supports?: {
+            vision?: boolean;
+            tool_calls?: boolean;
+            adaptive_thinking?: boolean;
+            max_thinking_budget?: number;
+            reasoning_effort?: string[];
+        };
+    };
+}
+export interface ProviderModel {
+    id: string;
+    api?: {
+        id?: string;
+        url?: string;
+        npm?: string;
+    };
+    name?: string;
+    family?: string;
+    cost?: unknown;
+    limit?: {
+        context?: number;
+        input?: number;
+        output?: number;
+    };
+    capabilities?: {
+        temperature?: boolean;
+        reasoning?: boolean;
+        attachment?: boolean;
+        toolcall?: boolean;
+        interleaved?: boolean;
+        input?: {
+            text?: boolean;
+            audio?: boolean;
+            image?: boolean;
+            video?: boolean;
+            pdf?: boolean;
+        };
+        output?: {
+            text?: boolean;
+            audio?: boolean;
+            image?: boolean;
+            video?: boolean;
+            pdf?: boolean;
+        };
+    };
+    options?: Record<string, unknown>;
+    headers?: Record<string, unknown>;
+    release_date?: string;
+    variants?: Record<string, unknown>;
+    status?: string;
+}
+export type HeaderObject = Headers | Array<[string, string]> | Record<string, string> | undefined;
+export interface AuthInput {
+    refresh: string;
+    enterpriseUrl?: string | null;
+    baseUrl?: string | null;
+    type?: string;
+}
+export interface DeviceFlowAuthorizeResult {
+    type: "success";
+    refresh: string;
+    access: string;
+    expires: number;
+    baseUrl?: string;
+    provider?: string;
+    enterpriseUrl?: string;
+}
+export interface ConversationMetadata {
+    isVision: boolean;
+    isAgent: boolean;
+}
+export interface ChatHeadersMessagePart {
+    type?: string;
+}

package/dist/types.js

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

package/dist/usage.d.ts

@@ -0,0 +1,11 @@
+export interface QuotaDetail {
+    entitlement: number;
+    overage_count: number;
+    overage_permitted: boolean;
+    percent_remaining: number;
+    quota_id: string;
+    quota_remaining: number;
+    remaining: number;
+    unlimited: boolean;
+}
+export declare function getCopilotUsageDialogMessage(): Promise<string>;

package/dist/usage.js

@@ -0,0 +1,113 @@
+import { fetchEntitlement } from "./auth.js";
+import { readPool } from "./pool.js";
+const USAGE_SNAPSHOT_PREFERENCE = ["premium_interactions", "chat", "completions"];
+function numberOrZero(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function roundToTwoDecimals(value) {
+    return Math.round(value * 100) / 100;
+}
+function buildProgressBar(percentUsed, width = 16) {
+    const normalizedWidth = Math.max(8, width);
+    const filled = Math.round((clamp(percentUsed, 0, 100) / 100) * normalizedWidth);
+    return `[${"#".repeat(filled)}${"-".repeat(normalizedWidth - filled)}]`;
+}
+function resolveUsageDetail(payload) {
+    const snapshots = payload?.quota_snapshots;
+    if (!snapshots || typeof snapshots !== "object")
+        return null;
+    for (const key of USAGE_SNAPSHOT_PREFERENCE) {
+        const candidate = snapshots[key];
+        if (!candidate || typeof candidate !== "object")
+            continue;
+        if (candidate.unlimited)
+            continue;
+        const total = numberOrZero(candidate.entitlement);
+        if (total > 0) {
+            return candidate;
+        }
+    }
+    for (const key of USAGE_SNAPSHOT_PREFERENCE) {
+        const candidate = snapshots[key];
+        if (!candidate || typeof candidate !== "object")
+            continue;
+        return candidate;
+    }
+    return null;
+}
+function formatUsageNumbers(detail) {
+    if (detail.unlimited) {
+        return {
+            used: 0,
+            total: 0,
+            percentUsed: 0,
+            unlimited: true,
+        };
+    }
+    const total = Math.max(0, numberOrZero(detail.entitlement));
+    const remaining = Math.max(0, numberOrZero(detail.remaining));
+    const used = clamp(total - remaining, 0, total);
+    const percentRemaining = clamp(numberOrZero(detail.percent_remaining), 0, 100);
+    const percentUsed = total > 0 ? roundToTwoDecimals(clamp(100 - percentRemaining, 0, 100)) : 0;
+    return {
+        used,
+        total,
+        percentUsed,
+        unlimited: false,
+    };
+}
+function getAccountLabel(account) {
+    const base = account.name || account.identity?.login || account.id || account.key;
+    const login = account.identity?.login?.trim();
+    if (login && login !== base) {
+        return `${base} (@${login})`;
+    }
+    return base;
+}
+async function getCopilotUsageSummary(account) {
+    const accountLabel = getAccountLabel(account);
+    const statusSuffix = account.enabled === false ? " [disabled]" : "";
+    if (account.auth?.type !== "oauth"
+        || typeof account.auth.refresh !== "string"
+        || !account.auth.refresh.trim()) {
+        return [`${accountLabel}${statusSuffix}`, "OAuth token missing"].join("\n");
+    }
+    try {
+        const payload = (await fetchEntitlement({
+            refresh: account.auth.refresh,
+            enterpriseUrl: account.enterpriseUrl,
+            baseUrl: account.baseUrl,
+        }));
+        const detail = resolveUsageDetail(payload);
+        if (!detail) {
+            return [`${accountLabel}${statusSuffix}`, "Usage unavailable"].join("\n");
+        }
+        const usage = formatUsageNumbers(detail);
+        if (usage.unlimited) {
+            return [`${accountLabel}${statusSuffix}`, "Usage: Unlimited", "Used: N/A"].join("\n");
+        }
+        return [
+            `${accountLabel}${statusSuffix}`,
+            `${buildProgressBar(usage.percentUsed)} ${usage.used}/${usage.total}`,
+            `Used: ${usage.percentUsed}%`,
+        ].join("\n");
+    }
+    catch (error) {
+        return [
+            `${accountLabel}${statusSuffix}`,
+            error instanceof Error ? error.message : String(error),
+        ].join("\n");
+    }
+}
+export async function getCopilotUsageDialogMessage() {
+    const pool = readPool();
+    const accounts = [...pool.accounts].sort((left, right) => left.key.localeCompare(right.key));
+    if (accounts.length === 0) {
+        throw new Error("No Copilot accounts found in the account pool. Log in again to populate ~/.local/share/opencode/copilot-auth.json.");
+    }
+    const sections = await Promise.all(accounts.map((account) => getCopilotUsageSummary(account)));
+    return sections.join("\n\n");
+}

package/dist/utils.d.ts

@@ -0,0 +1,28 @@
+import type { ConversationMetadata, HeaderObject } from "./types.js";
+export declare function normalizeHeaderObject(headers: HeaderObject): Record<string, string>;
+export declare function normalizeList(value: unknown): string[];
+export declare function matchesModelIdPattern(pattern: unknown, rawModelId: string): boolean;
+export declare function matchesAnyModelIdPattern(patterns: unknown, rawModelId: string): boolean;
+export declare function normalizePriority(value: unknown): number;
+export declare function normalizeDomain(urlOrDomain: unknown): string;
+export declare function normalizeIdSource(value: unknown): string;
+export declare function preserveStringOrDefault(value: unknown, fallback: string): string;
+export declare function zeroCost(): {
+    input: number;
+    output: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+};
+export declare function isLiveChatModel(model: unknown): boolean;
+export declare function isPickerModel(model: unknown): boolean;
+export declare function getReleaseDate(id: string, version: unknown, fallback?: string): string;
+export declare function getHeader(headers: HeaderObject, name: string): string | undefined;
+export declare function getConversationMetadata(init: RequestInit | undefined): ConversationMetadata;
+export declare function getRequestedRawModelId(init: RequestInit | undefined): string | undefined;
+export declare function applyBaseURLToRequestInput(input: RequestInfo | URL, baseURL?: string | null): URL | RequestInfo;
+export declare function isValidBaseURL(value: unknown): value is string;
+export declare function resolveClaudeThinkingBudget(model: {
+    id?: string;
+} | undefined, variant: unknown): number | undefined;