@timo972/cc-router 0.12.4 → 0.13.0-rc.0

package/dist/cli/cmd-accounts.js

@@ -1,16 +1,14 @@
 import chalk from "chalk";
-import { loadAccounts, loadOpenAIAccounts, loadXaiAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById, renameAccountRecordById, readConfig, serialize } from "../config/manager.js";
+import { loadAccounts, loadOpenAIAccounts, loadXaiAccounts, accountsFileExists, upsertAccountRecord, removeAccountRecordById, renameAccountRecordById, readConfig } from "../config/manager.js";
 import { saveAccounts } from "../proxy/token-refresher.js";
 import { formatExpiry, redactToken } from "../utils/token-extractor.js";
 import { PROXY_PORT } from "../config/paths.js";
-import { createOpenAIAccountRecord } from "../providers/openai/account-record.js";
-import { loginOpenAIWithDeviceCode } from "../providers/openai/device-oauth.js";
-import { importGrokCliAuth } from "../providers/xai/import-auth.js";
-import { loginXaiWithDeviceCode } from "../providers/xai/device-oauth.js";
 import { isValidAccountId } from "../proxy/account-rename.js";
-import { createSetupAttempt, failAttemptFromError, withSetupTelemetryFlush, } from "../telemetry/setup-diagnostics.js";
+import { failAttemptFromError, withSetupTelemetryFlush, } from "../telemetry/setup-diagnostics.js";
+import { isTokenOnly } from "../proxy/types.js";
 import { sanitizeAccountInfo, formatAccountInfo } from "../providers/account-info.js";
 import { needsReauthentication } from "../providers/auth-state.js";
+import { CliUsageError } from "./cli-errors.js";
 export function registerAccounts(program) {
     const accounts = program
         .command("accounts")
@@ -45,10 +43,10 @@ export function registerAccounts(program) {
             ? `\n  Accounts (${liveStats.length} in the running proxy)\n`
             : `\n  Accounts (${stored.length + openAIStored.length + xaiStored.length} configured)\n`));
         /**
-         * Accounts only re-authentication can restore, tagged with the provider
-         * whose sign-in command actually recovers them — `accounts add` runs the
-         * Claude Max flow, so pointing an OpenAI or Grok operator at it would
-         * re-add the id under the wrong provider.
+         * Accounts only re-authentication can restore. Just the ids: `accounts
+         * reauth <id>` resolves the provider itself, so the hint no longer has
+         * to pick a per-provider sign-in command — getting that wrong re-added
+         * the id under the wrong provider entirely.
          */
         const reauthNeeded = [];
         if (liveStats) {
@@ -63,19 +61,23 @@ export function registerAccounts(program) {
                 // permanently rejected refresh token. Only the latter needs the
                 // operator, so it gets its own label rather than hiding in the crowd.
                 if (needsReauthentication(s))
-                    reauthNeeded.push({ id: s.id, provider: s.provider });
+                    reauthNeeded.push(s.id);
                 const status = needsReauthentication(s)
                     ? chalk.red("✗ re-auth required")
                     : s.healthy
                         ? chalk.green("✓ healthy")
                         : chalk.red("✗ unhealthy");
                 const busy = s.busy ? chalk.yellow(" [busy]") : "";
+                // A `claude setup-token` account has no refresh token, so it never
+                // refreshes and carries the inference scope only. Saying so here is
+                // what stops "expires" reading as a bug rather than a deadline.
+                const tokenOnly = s.tokenOnly ? chalk.gray(" token-only") : "";
                 const exp = s.expiresInMs > 0
                     ? chalk.yellow(formatMs(s.expiresInMs))
                     : chalk.red("EXPIRED");
                 console.log(`  ${chalk.bold(s.id.padEnd(24))}` +
                     `  ${provider}` +
-                    `  ${status}${busy}` +
+                    `  ${status}${busy}${tokenOnly}` +
                     `  requests: ${chalk.cyan(String(s.requestCount).padStart(5))}` +
                     `  errors: ${chalk.red(String(s.errorCount).padStart(3))}` +
                     `  expires: ${exp}`);
@@ -110,11 +112,13 @@ export function registerAccounts(program) {
                 // `authExpired` is persisted, so the dead state is knowable without
                 // the proxy running — and this is exactly when an operator looks.
                 if (needsReauthentication(a))
-                    reauthNeeded.push({ id: a.id, provider: "anthropic_subscription" });
+                    reauthNeeded.push(a.id);
                 console.log(`  ${chalk.bold(a.id.padEnd(24))}` +
                     `  ${redactToken(a.tokens.accessToken).padEnd(26)}` +
                     `  expires: ${expColor}` +
-                    `  scopes: ${chalk.gray(a.tokens.scopes.join(" "))}` +
+                    (isTokenOnly(a.tokens)
+                        ? `  ${chalk.gray("token-only")}`
+                        : `  scopes: ${chalk.gray(a.tokens.scopes.join(" "))}`) +
                     (needsReauthentication(a) ? `  ${chalk.red("✗ re-auth required")}` : ""));
             }
             for (const a of openAIStored) {
@@ -122,7 +126,7 @@ export function registerAccounts(program) {
                     ? chalk.yellow(formatExpiry(a.expiresAt))
                     : chalk.red("EXPIRED");
                 if (needsReauthentication(a))
-                    reauthNeeded.push({ id: a.id, provider: "openai_subscription" });
+                    reauthNeeded.push(a.id);
                 console.log(`  ${chalk.bold(a.id.padEnd(24))}` +
                     `  ${chalk.magenta("openai".padEnd(10))}` +
                     `  ${redactToken(a.accessToken).padEnd(26)}` +
@@ -143,204 +147,118 @@ export function registerAccounts(program) {
         // out of: the refresh loop has deliberately stopped retrying, so nothing
         // changes until someone re-authenticates. Say so, and say how.
         if (reauthNeeded.length > 0) {
-            console.log(chalk.red(`\n  ⚠ Needs re-authentication: ${reauthNeeded.map(a => a.id).join(", ")}`));
+            console.log(chalk.red(`\n  ⚠ Needs re-authentication: ${reauthNeeded.join(", ")}`));
             console.log(chalk.gray("    The provider rejected these refresh tokens permanently; they cannot\n"
                 + "    be recovered and the refresh loop has stopped retrying them. Sign in\n"
                 + "    again under the same account id to resume routing — the existing\n"
                 + "    account is replaced, so there is nothing to remove first:"));
-            for (const { id, provider } of reauthNeeded) {
-                console.log(chalk.gray(`      ${reauthCommand(provider)}   (for ${id})`));
+            for (const id of reauthNeeded) {
+                console.log(chalk.gray(`      ${reauthCommand(id)}`));
             }
         }
         console.log();
     });
-    // ── accounts add ─────────────────────────────────────────────────────────
-    accounts
-        .command("add")
-        .description("Add a new Claude Max account interactively")
-        .action(async () => {
-        const { setupSingleAccountWithAttempt } = await import("./cmd-setup.js");
-        const existing = accountsFileExists() ? loadAccounts() : [];
-        const { account, attempt } = await setupSingleAccountWithAttempt(existing.length + 1);
-        if (!account) {
-            console.log(chalk.yellow("\nNo account added.\n"));
-            return;
-        }
-        // Merge: replace by ID if already exists, otherwise append
-        const merged = [
-            ...existing.filter(a => a.id !== account.id),
-            account,
-        ];
-        let mode;
-        try {
-            // Only `addStored` is overridden: this flow merges by id across the
-            // whole Claude pool. `tryAddLive` must stay the default so the live
-            // pool is asked to replace an existing id rather than reject it.
-            ({ mode } = await addAccountRuntimeAware(serialize([account])[0], {
-                addStored: () => saveAccounts(merged),
-            }));
-        }
-        catch (error) {
-            endFailedAttempt(attempt, error, "persistence");
-            throw error;
-        }
-        attempt.stageCompleted("persistence");
-        attempt.succeeded();
-        console.log(chalk.green(`\n✓ Account "${account.id}" added (${merged.length} total).\n`));
-        printAddOutcome(mode);
-    });
-    // ── accounts add-openai ──────────────────────────────────────────────────
+    // ── accounts login ───────────────────────────────────────────────────────
     accounts
-        .command("add-openai")
-        .description("Add an OpenAI ChatGPT/Codex subscription account manually")
-        .action(async () => withSetupTelemetryFlush(async () => {
-        const { input, password } = await import("@inquirer/prompts");
-        const attempt = createSetupAttempt({ provider: "openai", method: "manual_token" });
-        attempt.stageCompleted("credential_source_selection");
-        let reached = "credential_read";
-        try {
-            const id = await input({
-                message: "OpenAI account ID:",
-                default: `openai-account-${loadOpenAIAccounts().length + 1}`,
-                validate: (v) => /^[a-zA-Z0-9_-]+$/.test(v) || "Only letters, numbers, _ and - allowed",
+        .command("login [provider]")
+        .description("Sign in to a Claude, OpenAI or Grok account in the browser (provider: claude | openai | grok)")
+        .option("--id <id>", "Account id to store the credentials under")
+        .option("--email <email>", "Email to prefill on the sign-in page")
+        .option("--long-lived", "Claude only: create a long-lived token with claude setup-token instead of a full sign-in")
+        .action(async (providerArg, opts) => withSetupTelemetryFlush(async () => {
+        const provider = await chooseProvider(providerArg);
+        const flows = await import("./account-flows.js");
+        if (provider === "claude") {
+            const { account, attempt } = await flows.collectClaudeAccount({
+                index: (accountsFileExists() ? loadAccounts().length : 0) + 1,
+                fixedId: opts.id,
+                email: opts.email,
+                offer: "login",
+                ...(opts.longLived ? { method: "setup_token" } : {}),
             });
-            const accessToken = await password({
-                message: "OpenAI access token:",
-                mask: "*",
-                validate: (v) => v.trim().length > 0 || "Access token is required",
-            });
-            const refreshToken = await password({
-                message: "OpenAI refresh token:",
-                mask: "*",
-                validate: (v) => v.trim().length > 0 || "Refresh token is required",
-            });
-            const expiresAt = await input({
-                message: "Access token expiry (Unix ms):",
-                default: String(Date.now() + 60 * 60 * 1000),
-                validate: (v) => Number.isFinite(Number(v)) && Number(v) > 0 || "Enter a positive Unix timestamp in milliseconds",
-            });
-            const scopes = await input({
-                message: "Scopes:",
-                default: "openid profile email offline_access",
-            });
-            attempt.stageCompleted("credential_read");
-            reached = "credential_parse";
-            const record = createOpenAIAccountRecord({
-                id,
-                accessToken,
-                refreshToken,
-                expiresAt,
-                scopes,
-            });
-            attempt.stageCompleted("credential_parse");
-            reached = "persistence";
-            const { mode } = await addAccountRuntimeAware(record);
-            attempt.stageCompleted("persistence");
-            attempt.succeeded();
-            console.log(chalk.green(`\n✓ OpenAI account "${record.id}" saved.\n`));
-            printAddOutcome(mode);
-            console.log(chalk.yellow("  Treat this as experimental until the OAuth login wizard lands.\n"));
+            if (!account) {
+                console.log(chalk.yellow("\nNo account added.\n"));
+                return;
+            }
+            await persistClaude(account, attempt);
+            return;
         }
-        catch (error) {
-            endFailedAttempt(attempt, error, reached);
-            throw error;
+        if (provider === "openai") {
+            // The id prompt (with its `openai-account-N` default) lives in the
+            // flow, so an absent --id is a prompt rather than a guessed name.
+            const { record, attempt } = await flows.loginOpenAIAccount({ accountId: opts.id, email: opts.email });
+            await persistRecord(record, attempt, "OpenAI account");
+            return;
         }
+        const record = await flows.loginGrokAccount({ accountId: opts.id });
+        upsertAccountRecord(record);
+        console.log(chalk.green(`\n✓ Grok account "${record.id}" saved via device login.\n`));
+        printAddOutcome("stored");
     }));
-    // ── accounts login-openai ────────────────────────────────────────────────
+    // ── accounts add ─────────────────────────────────────────────────────────
     accounts
-        .command("login-openai")
-        .description("Sign in to an OpenAI ChatGPT/Codex subscription account with device code")
-        .action(async () => withSetupTelemetryFlush(async () => {
-        const { input } = await import("@inquirer/prompts");
-        const attempt = createSetupAttempt({ provider: "openai", method: "device_oauth" });
-        let reached = "device_code_request";
-        try {
-            const accountId = await input({
-                message: "OpenAI account ID:",
-                default: `openai-account-${loadOpenAIAccounts().length + 1}`,
-                validate: (v) => /^[a-zA-Z0-9_-]+$/.test(v) || "Only letters, numbers, _ and - allowed",
-            });
-            console.log(chalk.cyan("\nOpenAI Codex device login"));
-            console.log(chalk.gray("This will open no local callback server. You will approve the login in your browser.\n"));
-            const record = await loginOpenAIWithDeviceCode({
-                accountId,
-                onDeviceCode: (code) => {
-                    console.log(chalk.bold("1. Open this URL:"));
-                    console.log(`   ${chalk.cyan(code.verificationUrl)}`);
-                    console.log(chalk.bold("2. Enter this code:"));
-                    console.log(`   ${chalk.cyan(code.userCode)}\n`);
-                    console.log(chalk.gray("Waiting for authorization..."));
-                },
-                onStageCompleted: (stage) => {
-                    attempt.stageCompleted(stage);
-                    reached = stage;
-                },
+        .command("add [provider]")
+        .description("Import credentials that already exist: Claude Keychain / credentials file / pasted tokens, OpenAI tokens, or ~/.grok")
+        .option("--id <id>", "Account id to store the credentials under")
+        .action(async (providerArg, opts) => withSetupTelemetryFlush(async () => {
+        const provider = await chooseProvider(providerArg);
+        const flows = await import("./account-flows.js");
+        if (provider === "claude") {
+            const { account, attempt } = await flows.collectClaudeAccount({
+                index: (accountsFileExists() ? loadAccounts().length : 0) + 1,
+                fixedId: opts.id,
+                offer: "import",
             });
-            reached = "persistence";
-            const { mode } = await addAccountRuntimeAware(record);
-            attempt.stageCompleted("persistence");
-            attempt.succeeded();
-            console.log(chalk.green(`\n✓ OpenAI account "${record.id}" saved via device login.\n`));
-            printAddOutcome(mode);
-        }
-        catch (error) {
-            endFailedAttempt(attempt, error, reached);
-            throw error;
-        }
-    }));
-    // ── accounts add-grok ────────────────────────────────────────────────────
-    accounts
-        .command("add-grok")
-        .description("Import the Grok CLI login from ~/.grok/auth.json")
-        .action(async () => {
-        const { input } = await import("@inquirer/prompts");
-        let imported;
-        try {
-            imported = importGrokCliAuth();
+            if (!account) {
+                console.log(chalk.yellow("\nNo account added.\n"));
+                return;
+            }
+            await persistClaude(account, attempt);
+            return;
         }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.log(chalk.red(`\n✗ ${message}\n`));
-            console.log(chalk.gray("  Or sign in here: cc-router accounts login-grok\n"));
-            process.exit(1);
+        if (provider === "openai") {
+            const { record, attempt } = await flows.importOpenAIAccount({ accountId: opts.id });
+            await persistRecord(record, attempt, "OpenAI account");
+            return;
         }
-        const id = await input({
-            message: "Grok account ID:",
-            default: imported.id,
-            validate: (v) => /^[a-zA-Z0-9_-]+$/.test(v) || "Only letters, numbers, _ and - allowed",
-        });
-        const record = { ...imported, id };
+        const record = await flows.importGrokAccount({ accountId: opts.id });
         upsertAccountRecord(record);
         console.log(chalk.green(`\n✓ Grok account "${record.id}" imported from ~/.grok.\n`));
         printAddOutcome("stored");
-    });
-    // ── accounts login-grok ──────────────────────────────────────────────────
+    }));
+    // ── accounts reauth ──────────────────────────────────────────────────────
     accounts
-        .command("login-grok")
-        .description("Sign in to a Grok / xAI account with device code")
-        .action(async () => {
-        const { input } = await import("@inquirer/prompts");
-        const accountId = await input({
-            message: "Grok account ID:",
-            default: loadXaiAccounts().length === 0 ? "grok" : `grok-${loadXaiAccounts().length + 1}`,
-            validate: (v) => /^[a-zA-Z0-9_-]+$/.test(v) || "Only letters, numbers, _ and - allowed",
+        .command("reauth <id>")
+        .description("Sign an existing account in again under the same id (its provider and email are looked up for you)")
+        .option("--email <email>", "Override the email to prefill on the sign-in page")
+        .option("--long-lived", "Claude only: use claude setup-token")
+        .action(async (id, opts) => withSetupTelemetryFlush(async () => {
+        const live = await fetchLiveStats();
+        const target = resolveReauthTarget(id, live, {
+            anthropic: accountsFileExists() ? loadAccounts() : [],
+            openai: loadOpenAIAccounts(),
+            xai: loadXaiAccounts(),
         });
-        console.log(chalk.cyan("\nGrok device login"));
-        console.log(chalk.gray("Approve the login in your browser. No local callback server is used.\n"));
-        const record = await loginXaiWithDeviceCode({
-            accountId,
-            onDeviceCode: (code) => {
-                console.log(chalk.bold("1. Open this URL:"));
-                console.log(`   ${chalk.cyan(code.verificationUrl)}`);
-                console.log(chalk.bold("2. Enter this code if the page does not fill it in:"));
-                console.log(`   ${chalk.cyan(code.userCode)}\n`);
-                console.log(chalk.gray("Waiting for authorization..."));
-            },
-        });
-        upsertAccountRecord(record);
-        console.log(chalk.green(`\n✓ Grok account "${record.id}" saved via device login.\n`));
-        printAddOutcome("stored");
-    });
+        if (!target) {
+            const { ids } = mergeAccountInventory(loadAccounts().map(a => a.id), loadOpenAIAccounts().map(a => a.id), live, loadXaiAccounts().map(a => a.id));
+            console.log(chalk.red(`✗ Account "${id}" not found.`));
+            console.log(chalk.gray(`  Available: ${ids.join(", ")}`));
+            process.exit(1);
+        }
+        // Grok credentials are minted by the Grok CLI and read back out of
+        // ~/.grok; there is no id-preserving sign-in to re-run here.
+        if ("grok" in target) {
+            console.log(chalk.yellow(`Grok credentials live in ~/.grok. Run ${chalk.white("grok login")}, then ${chalk.white("cc-router accounts add grok")}.`));
+            process.exit(1);
+        }
+        const flows = await import("./account-flows.js");
+        const result = await flows.collectReauthRecord({ ...target, ...(opts.email ? { email: opts.email } : {}) }, { longLived: opts.longLived });
+        if (!result) {
+            console.log(chalk.yellow("\nNo account re-authenticated.\n"));
+            return;
+        }
+        await persistRecord(result.record, result.attempt, target.provider === "openai_subscription" ? "OpenAI account" : "Account");
+    }));
     // ── accounts remove ───────────────────────────────────────────────────────
     accounts
         .command("remove <id>")
@@ -426,7 +344,102 @@ export function registerAccounts(program) {
             : chalk.gray("  Saved to accounts.json — loads on next start: cc-router start"));
     });
 }
-// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * The provider named on the command line, if one was.
+ *
+ * Unknown values throw rather than falling back to a picker: silently asking
+ * again would let `accounts login clade` sign the operator into whatever they
+ * then clicked, under a command they did not mean to run.
+ */
+export function parseProviderArg(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === "claude" || value === "openai" || value === "grok")
+        return value;
+    throw new CliUsageError(`Unknown provider "${value}" — use claude, openai or grok`);
+}
+async function chooseProvider(given) {
+    const parsed = parseProviderArg(given);
+    if (parsed)
+        return parsed;
+    const { select } = await import("@inquirer/prompts");
+    return select({
+        message: "Which provider?",
+        choices: [
+            { name: "Claude (Claude Max / Pro subscription)", value: "claude" },
+            { name: "OpenAI (ChatGPT / Codex subscription)", value: "openai" },
+            { name: "Grok (xAI)", value: "grok" },
+        ],
+    });
+}
+/**
+ * Persist a collected Claude account, replacing any account already holding
+ * its id. The merge is by id across the whole Claude pool, so only `addStored`
+ * is overridden — `tryAddLive` must stay the default, which asks the running
+ * proxy to replace rather than reject the id.
+ */
+async function persistClaude(account, attempt) {
+    const { accountToRecord } = await import("./account-flows.js");
+    const existing = accountsFileExists() ? loadAccounts() : [];
+    const merged = [...existing.filter(a => a.id !== account.id), account];
+    let mode;
+    try {
+        ({ mode } = await addAccountRuntimeAware(accountToRecord(account), {
+            addStored: () => saveAccounts(merged),
+        }));
+    }
+    catch (error) {
+        endFailedAttempt(attempt, error, "persistence");
+        throw error;
+    }
+    attempt.stageCompleted("persistence");
+    attempt.succeeded();
+    console.log(chalk.green(`\n✓ Account "${account.id}" saved (${merged.length} Claude accounts).\n`));
+    printAddOutcome(mode);
+}
+/** Persist any already-serialized record (OpenAI, or a re-authenticated account). */
+async function persistRecord(record, attempt, label) {
+    let mode;
+    try {
+        ({ mode } = await addAccountRuntimeAware(record));
+    }
+    catch (error) {
+        if (attempt)
+            endFailedAttempt(attempt, error, "persistence");
+        throw error;
+    }
+    attempt?.stageCompleted("persistence");
+    attempt?.succeeded();
+    console.log(chalk.green(`\n✓ ${label} "${record.id}" saved.\n`));
+    printAddOutcome(mode);
+}
+/**
+ * Which account `accounts reauth <id>` should sign in again, and as whom.
+ *
+ * The live pool wins: it is the only source that carries the fetched account
+ * metadata, and its email is what makes the sign-in page land on the right
+ * account instead of whichever one the browser is already holding. Disk is the
+ * fallback for a proxy that is not running, and knows no email.
+ */
+export function resolveReauthTarget(id, live, stored) {
+    const liveMatch = live?.find(a => a.id === id);
+    if (liveMatch) {
+        if (liveMatch.provider === "xai_subscription")
+            return { grok: true };
+        return {
+            id,
+            provider: liveMatch.provider === "openai_subscription" ? "openai_subscription" : "anthropic_subscription",
+            ...(liveMatch.accountInfo?.email ? { email: liveMatch.accountInfo.email } : {}),
+        };
+    }
+    if (stored.xai.some(a => a.id === id))
+        return { grok: true };
+    if (stored.openai.some(a => a.id === id))
+        return { id, provider: "openai_subscription" };
+    if (stored.anthropic.some(a => a.id === id))
+        return { id, provider: "anthropic_subscription" };
+    return null;
+}
 /**
  * Close a setup attempt that ended in a thrown error. A cancelled prompt is a
  * user decision, not a failure, and only an unexpected failure gets a
@@ -494,6 +507,7 @@ export function buildStoredAccountsJson(anthropicAccounts, openAIAccounts, xaiAc
             expiresAt: a.tokens.expiresAt,
             scopes: a.tokens.scopes,
             ...(needsReauthentication(a) ? { authExpired: true } : {}),
+            ...(isTokenOnly(a.tokens) ? { tokenOnly: true } : {}),
         })),
         ...openAIAccounts.map(a => ({
             id: a.id,
@@ -669,19 +683,17 @@ export async function addAccountRuntimeAware(record, dependencies = {}) {
     return { mode: "stored" };
 }
 /**
- * The sign-in command that recovers an account of this provider.
+ * The command that recovers this account, whatever its provider.
  *
- * `accounts add` is the Claude Max flow specifically; the other providers have
- * their own. Each re-registers under the id the operator types, and the live
- * pool now replaces rather than rejects it, so no deletion step is needed —
- * which also avoids the running proxy refusing to delete a lone Claude account.
+ * One command for every provider, because it resolves the provider from the id
+ * itself — the previous per-provider hints had to guess, and guessing wrong
+ * re-added the id under the wrong provider. It re-registers under the id the
+ * operator already has, and the live pool replaces rather than rejects it, so
+ * no deletion step is needed — which also avoids the running proxy refusing to
+ * delete a lone Claude account.
  */
-function reauthCommand(provider) {
-    if (provider === "openai_subscription")
-        return "cc-router accounts login-openai";
-    if (provider === "xai_subscription")
-        return "cc-router accounts login-grok";
-    return "cc-router accounts add";
+function reauthCommand(id) {
+    return `cc-router accounts reauth ${id}`;
 }
 async function fetchLiveStats() {
     try {