opencode-copilot-account-switcher 0.1.0

package/dist/store.d.ts

@@ -0,0 +1,62 @@
+export type AccountEntry = {
+    name: string;
+    refresh: string;
+    access: string;
+    expires: number;
+    enterpriseUrl?: string;
+    user?: string;
+    email?: string;
+    orgs?: string[];
+    addedAt?: number;
+    lastUsed?: number;
+    source?: "auth" | "manual";
+    providerId?: string;
+    quota?: {
+        plan?: string;
+        sku?: string;
+        reset?: string;
+        updatedAt?: number;
+        error?: string;
+        snapshots?: {
+            premium?: {
+                entitlement?: number;
+                remaining?: number;
+                used?: number;
+                unlimited?: boolean;
+                percentRemaining?: number;
+            };
+            chat?: {
+                entitlement?: number;
+                remaining?: number;
+                used?: number;
+                unlimited?: boolean;
+                percentRemaining?: number;
+            };
+            completions?: {
+                entitlement?: number;
+                remaining?: number;
+                used?: number;
+                unlimited?: boolean;
+                percentRemaining?: number;
+            };
+        };
+    };
+    models?: {
+        available: string[];
+        disabled: string[];
+        updatedAt?: number;
+        error?: string;
+    };
+};
+export type StoreFile = {
+    active?: string;
+    accounts: Record<string, AccountEntry>;
+    autoRefresh?: boolean;
+    refreshMinutes?: number;
+    lastQuotaRefresh?: number;
+};
+export declare function storePath(): string;
+export declare function authPath(): string;
+export declare function readStore(): Promise<StoreFile>;
+export declare function readAuth(filePath?: string): Promise<Record<string, AccountEntry>>;
+export declare function writeStore(store: StoreFile): Promise<void>;

package/dist/store.js

@@ -0,0 +1,63 @@
+import path from "node:path";
+import os from "node:os";
+import { promises as fs } from "node:fs";
+import { xdgConfig, xdgData } from "xdg-basedir";
+const filename = "copilot-accounts.json";
+const authFile = "auth.json";
+export function storePath() {
+    const base = xdgConfig ?? path.join(os.homedir(), ".config");
+    return path.join(base, "opencode", filename);
+}
+export function authPath() {
+    const dataDir = xdgData ?? path.join(os.homedir(), ".local", "share");
+    return path.join(dataDir, "opencode", authFile);
+}
+export async function readStore() {
+    const file = storePath();
+    const raw = await fs.readFile(file, "utf-8").catch(() => "");
+    const data = raw ? JSON.parse(raw) : { accounts: {} };
+    if (!data.accounts)
+        data.accounts = {};
+    for (const [name, entry] of Object.entries(data.accounts)) {
+        const info = entry;
+        if (!info.name)
+            info.name = name;
+    }
+    return data;
+}
+export async function readAuth(filePath) {
+    const dataFile = path.join(xdgData ?? path.join(os.homedir(), ".local", "share"), "opencode", authFile);
+    const configFile = path.join(xdgConfig ?? path.join(os.homedir(), ".config"), "opencode", authFile);
+    const files = filePath ? [filePath] : [dataFile, configFile];
+    let raw = "";
+    for (const file of files) {
+        raw = await fs.readFile(file, "utf-8").catch(() => "");
+        if (raw)
+            break;
+    }
+    if (!raw)
+        return {};
+    const parsed = JSON.parse(raw);
+    return Object.entries(parsed).reduce((acc, [key, value]) => {
+        if (!value || typeof value !== "object")
+            return acc;
+        const info = value;
+        if (info.type !== "oauth" || !(info.refresh || info.access))
+            return acc;
+        acc[key] = {
+            name: `auth:${key}`,
+            refresh: info.refresh ?? info.access,
+            access: info.access ?? info.refresh,
+            expires: info.expires ?? 0,
+            enterpriseUrl: info.enterpriseUrl,
+            source: "auth",
+            providerId: key,
+        };
+        return acc;
+    }, {});
+}
+export async function writeStore(store) {
+    const file = storePath();
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify(store, null, 2), { mode: 0o600 });
+}

package/dist/ui/ansi.d.ts

@@ -0,0 +1,18 @@
+export declare const ANSI: {
+    readonly hide: "\u001B[?25l";
+    readonly show: "\u001B[?25h";
+    readonly up: (n?: number) => string;
+    readonly clearLine: "\u001B[2K";
+    readonly clearScreen: "\u001B[2J";
+    readonly moveTo: (row: number, col: number) => string;
+    readonly cyan: "\u001B[36m";
+    readonly green: "\u001B[32m";
+    readonly red: "\u001B[31m";
+    readonly yellow: "\u001B[33m";
+    readonly dim: "\u001B[2m";
+    readonly bold: "\u001B[1m";
+    readonly reset: "\u001B[0m";
+};
+export type KeyAction = "up" | "down" | "enter" | "escape" | "escape-start" | null;
+export declare function parseKey(data: Buffer): KeyAction;
+export declare function isTTY(): boolean;

package/dist/ui/ansi.js

@@ -0,0 +1,32 @@
+export const ANSI = {
+    hide: "\x1b[?25l",
+    show: "\x1b[?25h",
+    up: (n = 1) => `\x1b[${n}A`,
+    clearLine: "\x1b[2K",
+    clearScreen: "\x1b[2J",
+    moveTo: (row, col) => `\x1b[${row};${col}H`,
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    reset: "\x1b[0m",
+};
+export function parseKey(data) {
+    const s = data.toString();
+    if (s === "\x1b[A" || s === "\x1bOA")
+        return "up";
+    if (s === "\x1b[B" || s === "\x1bOB")
+        return "down";
+    if (s === "\r" || s === "\n")
+        return "enter";
+    if (s === "\x03")
+        return "escape";
+    if (s === "\x1b")
+        return "escape-start";
+    return null;
+}
+export function isTTY() {
+    return Boolean(process.stdin.isTTY);
+}

package/dist/ui/confirm.d.ts

@@ -0,0 +1 @@
+export declare function confirm(message: string, defaultYes?: boolean): Promise<boolean>;

package/dist/ui/confirm.js

@@ -0,0 +1,14 @@
+import { select } from "./select";
+export async function confirm(message, defaultYes = false) {
+    const items = defaultYes
+        ? [
+            { label: "Yes", value: true },
+            { label: "No", value: false },
+        ]
+        : [
+            { label: "No", value: false },
+            { label: "Yes", value: true },
+        ];
+    const result = await select(items, { message });
+    return result ?? false;
+}

package/dist/ui/menu.d.ts

@@ -0,0 +1,70 @@
+export type AccountStatus = "active" | "expired" | "unknown";
+export interface AccountInfo {
+    name: string;
+    index: number;
+    addedAt?: number;
+    lastUsed?: number;
+    status?: AccountStatus;
+    isCurrent?: boolean;
+    source?: "auth" | "manual";
+    orgs?: string[];
+    plan?: string;
+    sku?: string;
+    reset?: string;
+    models?: {
+        enabled: number;
+        disabled: number;
+    };
+    modelsError?: string;
+    modelList?: {
+        available: string[];
+        disabled: string[];
+    };
+    quota?: {
+        premium?: {
+            remaining?: number;
+            entitlement?: number;
+            unlimited?: boolean;
+        };
+        chat?: {
+            remaining?: number;
+            entitlement?: number;
+            unlimited?: boolean;
+        };
+        completions?: {
+            remaining?: number;
+            entitlement?: number;
+            unlimited?: boolean;
+        };
+    };
+}
+export type MenuAction = {
+    type: "add";
+} | {
+    type: "import";
+} | {
+    type: "quota";
+} | {
+    type: "refresh-identity";
+} | {
+    type: "check-models";
+} | {
+    type: "toggle-refresh";
+} | {
+    type: "set-interval";
+} | {
+    type: "switch";
+    account: AccountInfo;
+} | {
+    type: "remove";
+    account: AccountInfo;
+} | {
+    type: "remove-all";
+} | {
+    type: "cancel";
+};
+export declare function showMenu(accounts: AccountInfo[], refresh?: {
+    enabled: boolean;
+    minutes: number;
+}, lastQuotaRefresh?: number): Promise<MenuAction>;
+export declare function showAccountActions(account: AccountInfo): Promise<"switch" | "remove" | "back">;

package/dist/ui/menu.js

@@ -0,0 +1,153 @@
+import { ANSI } from "./ansi";
+import { select } from "./select";
+import { confirm } from "./confirm";
+function formatRelativeTime(timestamp) {
+    if (!timestamp)
+        return "never";
+    const days = Math.floor((Date.now() - timestamp) / 86400000);
+    if (days === 0)
+        return "today";
+    if (days === 1)
+        return "yesterday";
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    return new Date(timestamp).toLocaleDateString();
+}
+function formatDate(timestamp) {
+    if (!timestamp)
+        return "unknown";
+    return new Date(timestamp).toLocaleDateString();
+}
+function getStatusBadge(status) {
+    if (status === "expired")
+        return `${ANSI.red}[expired]${ANSI.reset}`;
+    return "";
+}
+export async function showMenu(accounts, refresh, lastQuotaRefresh) {
+    const quotaHint = lastQuotaRefresh ? `last ${formatRelativeTime(lastQuotaRefresh)}` : undefined;
+    const items = [
+        { label: "Actions", value: { type: "cancel" }, kind: "heading" },
+        { label: "Add account", value: { type: "add" }, color: "cyan", hint: "device login or manual" },
+        { label: "Import from auth.json", value: { type: "import" }, color: "cyan" },
+        { label: "Check quotas", value: { type: "quota" }, color: "cyan", hint: quotaHint },
+        { label: "Refresh identity", value: { type: "refresh-identity" }, color: "cyan" },
+        { label: "Check models", value: { type: "check-models" }, color: "cyan" },
+        {
+            label: refresh?.enabled ? "Disable auto refresh" : "Enable auto refresh",
+            value: { type: "toggle-refresh" },
+            color: "cyan",
+            hint: refresh ? `${refresh.minutes}m` : undefined,
+        },
+        { label: "Set refresh interval", value: { type: "set-interval" }, color: "cyan" },
+        { label: "", value: { type: "cancel" }, separator: true },
+        { label: "Accounts", value: { type: "cancel" }, kind: "heading" },
+        ...accounts.map((account) => {
+            const statusBadge = getStatusBadge(account.status);
+            const currentBadge = account.isCurrent ? ` ${ANSI.cyan}*${ANSI.reset}` : "";
+            const format = (s) => s?.unlimited ? "∞" : s?.remaining !== undefined && s?.entitlement !== undefined ? `${s.remaining}/${s.entitlement}` : "?";
+            const quotaBadge = account.quota
+                ? ` ${ANSI.dim}[${format(account.quota.premium)}|${format(account.quota.chat)}|${format(account.quota.completions)}]${ANSI.reset}`
+                : "";
+            const numbered = `${account.index + 1}. ${account.name}`;
+            const label = `${numbered}${currentBadge}${statusBadge ? " " + statusBadge : ""}${quotaBadge}`;
+            const detail = [
+                account.lastUsed ? formatRelativeTime(account.lastUsed) : undefined,
+                account.plan,
+                account.models ? `${account.models.enabled}/${account.models.enabled + account.models.disabled} mods` : undefined,
+            ]
+                .filter(Boolean)
+                .join(" • ");
+            return {
+                label,
+                hint: detail || undefined,
+                value: { type: "switch", account },
+            };
+        }),
+        { label: "", value: { type: "cancel" }, separator: true },
+        { label: "Danger zone", value: { type: "cancel" }, kind: "heading" },
+        { label: "Remove all accounts", value: { type: "remove-all" }, color: "red" },
+    ];
+    while (true) {
+        const result = await select(items, {
+            message: "GitHub Copilot accounts",
+            subtitle: "Select an action or account",
+            clearScreen: true,
+        });
+        if (!result)
+            return { type: "cancel" };
+        if (result.type === "remove-all") {
+            const ok = await confirm("Remove ALL accounts? This cannot be undone.");
+            if (!ok)
+                continue;
+        }
+        return result;
+    }
+}
+export async function showAccountActions(account) {
+    const badge = getStatusBadge(account.status);
+    const header = `${account.name}${badge ? " " + badge : ""}`;
+    const info = [
+        `Added: ${formatDate(account.addedAt)} | Last used: ${formatRelativeTime(account.lastUsed)}`,
+        account.plan ? `Plan: ${account.plan}` : undefined,
+        account.sku ? `SKU: ${account.sku}` : undefined,
+        account.reset ? `Reset: ${account.reset}` : undefined,
+        account.models ? `Models: ${account.models.enabled}/${account.models.enabled + account.models.disabled}` : undefined,
+        account.orgs?.length ? `Orgs: ${account.orgs.slice(0, 2).join(",")}` : undefined,
+        account.modelsError ? `Models error: ${account.modelsError}` : undefined,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const subtitle = info;
+    while (true) {
+        const modelAction = account.modelList || account.modelsError
+            ? [{ label: "View models", value: "models", color: "cyan" }]
+            : [];
+        const result = await select([
+            { label: "Back", value: "back" },
+            ...modelAction,
+            { label: "Switch to this account", value: "switch", color: "cyan" },
+            { label: "Remove this account", value: "remove", color: "red" },
+        ], { message: header, subtitle, clearScreen: true, autoSelectSingle: false });
+        if (result === "models") {
+            await showModels(account);
+            continue;
+        }
+        if (result === "remove") {
+            const ok = await confirm(`Remove ${account.name}?`);
+            if (!ok)
+                continue;
+        }
+        return result ?? "back";
+    }
+}
+async function showModels(account) {
+    const available = account.modelList?.available ?? [];
+    const disabled = account.modelList?.disabled ?? [];
+    const items = [
+        { label: "Back", value: "back" },
+        { label: "", value: "", separator: true },
+    ];
+    if (account.modelsError) {
+        items.push({ label: `Error: ${account.modelsError}`, value: "err", disabled: true, color: "red" });
+        items.push({ label: "Run Check models from the main menu", value: "hint", disabled: true });
+    }
+    else if (!account.modelList) {
+        items.push({ label: "Models not checked", value: "hint", disabled: true });
+        items.push({ label: "Run Check models from the main menu", value: "hint2", disabled: true });
+    }
+    else {
+        items.push({ label: "Available", value: "", kind: "heading" });
+        items.push(...available.map((name) => ({ label: name, value: name, color: "green" })));
+        items.push({ label: "", value: "", separator: true });
+        items.push({ label: "Disabled", value: "", kind: "heading" });
+        items.push(...disabled.map((name) => ({ label: name, value: name, color: "red" })));
+    }
+    await select(items, {
+        message: "Copilot models",
+        subtitle: account.name,
+        clearScreen: true,
+        autoSelectSingle: false,
+    });
+}

package/dist/ui/select.d.ts

@@ -0,0 +1,17 @@
+export interface MenuItem<T = string> {
+    label: string;
+    value: T;
+    hint?: string;
+    disabled?: boolean;
+    separator?: boolean;
+    kind?: "heading";
+    color?: "red" | "green" | "yellow" | "cyan";
+}
+export interface SelectOptions {
+    message: string;
+    subtitle?: string;
+    help?: string;
+    clearScreen?: boolean;
+    autoSelectSingle?: boolean;
+}
+export declare function select<T>(items: MenuItem<T>[], options: SelectOptions): Promise<T | null>;

package/dist/ui/select.js

@@ -0,0 +1,237 @@
+import { ANSI, isTTY, parseKey } from "./ansi";
+const ESCAPE_TIMEOUT_MS = 50;
+const ANSI_REGEX = new RegExp("\\x1b\\[[0-9;]*m", "g");
+const ANSI_LEADING_REGEX = new RegExp("^\\x1b\\[[0-9;]*m");
+function stripAnsi(input) {
+    return input.replace(ANSI_REGEX, "");
+}
+function truncateAnsi(input, maxVisibleChars) {
+    if (maxVisibleChars <= 0)
+        return "";
+    const visible = stripAnsi(input);
+    if (visible.length <= maxVisibleChars)
+        return input;
+    const suffix = maxVisibleChars >= 3 ? "..." : ".".repeat(maxVisibleChars);
+    const keep = Math.max(0, maxVisibleChars - suffix.length);
+    let out = "";
+    let i = 0;
+    let kept = 0;
+    while (i < input.length && kept < keep) {
+        if (input[i] === "\x1b") {
+            const m = input.slice(i).match(ANSI_LEADING_REGEX);
+            if (m) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+        }
+        out += input[i];
+        i += 1;
+        kept += 1;
+    }
+    if (out.includes("\x1b["))
+        return `${out}${ANSI.reset}${suffix}`;
+    return out + suffix;
+}
+function getColorCode(color) {
+    if (color === "red")
+        return ANSI.red;
+    if (color === "green")
+        return ANSI.green;
+    if (color === "yellow")
+        return ANSI.yellow;
+    if (color === "cyan")
+        return ANSI.cyan;
+    return "";
+}
+export async function select(items, options) {
+    if (!isTTY())
+        throw new Error("Interactive select requires a TTY terminal");
+    if (items.length === 0)
+        throw new Error("No menu items provided");
+    const isSelectable = (i) => !i.disabled && !i.separator && i.kind !== "heading";
+    const enabled = items.filter(isSelectable);
+    if (enabled.length === 0)
+        throw new Error("All items disabled");
+    const autoSelectSingle = options.autoSelectSingle ?? true;
+    if (enabled.length === 1 && autoSelectSingle)
+        return enabled[0]?.value ?? null;
+    const { message, subtitle } = options;
+    const { stdin, stdout } = process;
+    let cursor = items.findIndex(isSelectable);
+    if (cursor === -1)
+        cursor = 0;
+    let escapeTimeout = null;
+    let done = false;
+    let rendered = 0;
+    const render = () => {
+        const columns = stdout.columns ?? 80;
+        const rows = stdout.rows ?? 24;
+        const clearScreen = options.clearScreen === true;
+        const prev = rendered;
+        if (clearScreen) {
+            stdout.write(ANSI.clearScreen + ANSI.moveTo(1, 1));
+        }
+        else if (prev > 0) {
+            stdout.write(ANSI.up(prev));
+        }
+        let lines = 0;
+        const write = (line) => {
+            stdout.write(`${ANSI.clearLine}${line}\n`);
+            lines += 1;
+        };
+        const subtitleLines = subtitle ? subtitle.split("\n").length + 2 : 0;
+        const fixed = 1 + subtitleLines + 2;
+        const maxVisible = Math.max(1, Math.min(items.length, rows - fixed - 1));
+        let windowStart = 0;
+        let windowEnd = items.length;
+        if (items.length > maxVisible) {
+            windowStart = cursor - Math.floor(maxVisible / 2);
+            windowStart = Math.max(0, Math.min(windowStart, items.length - maxVisible));
+            windowEnd = windowStart + maxVisible;
+        }
+        const visibleItems = items.slice(windowStart, windowEnd);
+        const header = truncateAnsi(message, Math.max(1, columns - 4));
+        write(`${ANSI.dim}┌  ${ANSI.reset}${header}`);
+        if (subtitle) {
+            write(`${ANSI.dim}│${ANSI.reset}`);
+            for (const line of subtitle.split("\n")) {
+                const sub = truncateAnsi(line, Math.max(1, columns - 4));
+                write(`${ANSI.cyan}◆${ANSI.reset}  ${sub}`);
+            }
+            write("");
+        }
+        for (let i = 0; i < visibleItems.length; i += 1) {
+            const index = windowStart + i;
+            const item = visibleItems[i];
+            if (!item)
+                continue;
+            if (item.separator) {
+                write(`${ANSI.dim}│${ANSI.reset}`);
+                continue;
+            }
+            if (item.kind === "heading") {
+                const heading = truncateAnsi(`${ANSI.dim}${ANSI.bold}${item.label}${ANSI.reset}`, Math.max(1, columns - 6));
+                write(`${ANSI.cyan}│${ANSI.reset}  ${heading}`);
+                continue;
+            }
+            const selected = index === cursor;
+            const color = getColorCode(item.color);
+            let label;
+            if (item.disabled) {
+                label = `${ANSI.dim}${item.label} (unavailable)${ANSI.reset}`;
+            }
+            else if (selected) {
+                label = color ? `${color}${item.label}${ANSI.reset}` : item.label;
+                if (item.hint)
+                    label += ` ${ANSI.dim}${item.hint}${ANSI.reset}`;
+            }
+            else {
+                label = color ? `${ANSI.dim}${color}${item.label}${ANSI.reset}` : `${ANSI.dim}${item.label}${ANSI.reset}`;
+                if (item.hint)
+                    label += ` ${ANSI.dim}${item.hint}${ANSI.reset}`;
+            }
+            label = truncateAnsi(label, Math.max(1, columns - 8));
+            if (selected) {
+                write(`${ANSI.cyan}│${ANSI.reset}  ${ANSI.green}●${ANSI.reset} ${label}`);
+            }
+            else {
+                write(`${ANSI.cyan}│${ANSI.reset}  ${ANSI.dim}○${ANSI.reset} ${label}`);
+            }
+        }
+        const windowHint = items.length > visibleItems.length ? ` (${windowStart + 1}-${windowEnd}/${items.length})` : "";
+        const helpText = options.help ?? `Up/Down to select | Enter: confirm | Esc: back${windowHint}`;
+        const help = truncateAnsi(helpText, Math.max(1, columns - 6));
+        write(`${ANSI.cyan}│${ANSI.reset}  ${ANSI.dim}${help}${ANSI.reset}`);
+        write(`${ANSI.cyan}└${ANSI.reset}`);
+        if (!clearScreen && prev > lines) {
+            const extra = prev - lines;
+            for (let i = 0; i < extra; i += 1)
+                write("");
+        }
+        rendered = lines;
+    };
+    return new Promise((resolve) => {
+        const wasRaw = stdin.isRaw ?? false;
+        const cleanup = () => {
+            if (done)
+                return;
+            done = true;
+            if (escapeTimeout) {
+                clearTimeout(escapeTimeout);
+                escapeTimeout = null;
+            }
+            try {
+                stdin.removeListener("data", onKey);
+                stdin.setRawMode(wasRaw);
+                stdin.pause();
+                stdout.write(ANSI.show);
+            }
+            catch { }
+            process.removeListener("SIGINT", onSignal);
+            process.removeListener("SIGTERM", onSignal);
+        };
+        const onSignal = () => {
+            cleanup();
+            resolve(null);
+        };
+        const finish = (value) => {
+            cleanup();
+            resolve(value);
+        };
+        const findNextSelectable = (from, direction) => {
+            if (items.length === 0)
+                return from;
+            let next = from;
+            do {
+                next = (next + direction + items.length) % items.length;
+            } while (items[next]?.disabled || items[next]?.separator || items[next]?.kind === "heading");
+            return next;
+        };
+        const onKey = (data) => {
+            if (escapeTimeout) {
+                clearTimeout(escapeTimeout);
+                escapeTimeout = null;
+            }
+            const action = parseKey(data);
+            if (action === "up") {
+                cursor = findNextSelectable(cursor, -1);
+                render();
+                return;
+            }
+            if (action === "down") {
+                cursor = findNextSelectable(cursor, 1);
+                render();
+                return;
+            }
+            if (action === "enter") {
+                finish(items[cursor]?.value ?? null);
+                return;
+            }
+            if (action === "escape") {
+                finish(null);
+                return;
+            }
+            if (action === "escape-start") {
+                escapeTimeout = setTimeout(() => {
+                    finish(null);
+                }, ESCAPE_TIMEOUT_MS);
+                return;
+            }
+        };
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            cleanup();
+            resolve(null);
+            return;
+        }
+        stdin.resume();
+        stdout.write(ANSI.hide);
+        render();
+        stdin.on("data", onKey);
+    });
+}