@timo972/cc-router 0.13.0-rc.1 → 0.13.0-rc.2

package/CHANGELOG.md

@@ -38,6 +38,8 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- Escape or Ctrl-C at any prompt of the dashboard's `n` / `l` flows returns
+  to the dashboard with a quiet "Cancelled." instead of a red failure line.
 - Pressing `n` (and now `l`) in the dashboard no longer kills the process
   before the sign-in prompt can take input. Ink unrefs stdin when it
   unmounts and nothing ref'd it again, so with no other work pending the

package/dist/cli/account-flows.js

@@ -59,7 +59,7 @@ export async function collectClaudeAccount(options) {
     const method = options.method ?? await select({
         message: "How do you want to add the account?",
         choices: claudeMethodChoices(options.offer ?? "all"),
-    });
+    }, { signal: options.signal });
     const attempt = createSetupAttempt({ provider: "anthropic", method: CLAUDE_METHOD_TELEMETRY[method] });
     attempt.stageCompleted("credential_source_selection");
     // Shared by reference: the file-extraction fallback swaps in a manual-token attempt.
@@ -106,12 +106,12 @@ async function collectAnthropicAccount(options, method, current, reached) {
                 message: "Paste the token (sk-ant-oat01-...):",
                 mask: "•",
                 validate: v => v.startsWith("sk-ant-oat01-") || "Must start with sk-ant-oat01-",
-            });
+            }, { signal: options.signal });
         }
-        const useDefaultExpiry = await confirm({ message: "Token valid for 1 year (default)?", default: true });
+        const useDefaultExpiry = await confirm({ message: "Token valid for 1 year (default)?", default: true }, { signal: options.signal });
         const expiresAt = useDefaultExpiry
             ? Date.now() + LONG_LIVED_TOKEN_TTL_MS
-            : await promptExpiry();
+            : await promptExpiry(options.signal);
         tokens = { accessToken, refreshToken: undefined, expiresAt, scopes: ["user:inference"] };
         console.log(chalk.gray("  This token has no refresh token and the inference scope only: usage and identity metadata are unavailable for it."));
     }
@@ -129,7 +129,7 @@ async function collectAnthropicAccount(options, method, current, reached) {
             console.log(chalk.yellow("  Could not find credentials in Keychain."));
             console.log(chalk.gray("  Make sure Claude Code is logged in: run `claude login` first."));
             printDiagnosticId(attempt.stageFailed(extraction.error, "credential_read"));
-            const retry = await confirm({ message: "Try another extraction method?", default: true });
+            const retry = await confirm({ message: "Try another extraction method?", default: true }, { signal: options.signal });
             attempt.cancelled();
             if (!retry)
                 return { account: null, attempt };
@@ -147,7 +147,7 @@ async function collectAnthropicAccount(options, method, current, reached) {
         else {
             console.log(chalk.red("  ✗ ~/.claude/.credentials.json not found or unreadable."));
             console.log(chalk.gray("  Make sure Claude Code is installed and you've run `claude login`."));
-            const retry = await confirm({ message: "Paste tokens manually instead?", default: true });
+            const retry = await confirm({ message: "Paste tokens manually instead?", default: true }, { signal: options.signal });
             if (!retry) {
                 printDiagnosticId(attempt.stageFailed(extraction.error, "credential_read"));
                 attempt.cancelled();
@@ -158,11 +158,11 @@ async function collectAnthropicAccount(options, method, current, reached) {
             attempt = createSetupAttempt({ provider: "anthropic", method: "manual_token" });
             current.attempt = attempt;
             attempt.stageCompleted("credential_source_selection");
-            tokens = await promptManualTokens();
+            tokens = await promptManualTokens(options.signal);
         }
     }
     if (method === "manual") {
-        tokens = await promptManualTokens();
+        tokens = await promptManualTokens(options.signal);
     }
     if (!tokens) {
         attempt.cancelled();
@@ -175,7 +175,7 @@ async function collectAnthropicAccount(options, method, current, reached) {
         message: "Account ID (press Enter to accept default):",
         default: `max-account-${options.index}`,
         validate: v => /^[a-zA-Z0-9_-]+$/.test(v) || "Only letters, numbers, _ and - allowed",
-    });
+    }, { signal: options.signal });
     process.stdout.write(chalk.gray("  Validating tokens against Anthropic... "));
     const validation = await validateToken(tokens.accessToken);
     if (validation.valid) {
@@ -187,7 +187,7 @@ async function collectAnthropicAccount(options, method, current, reached) {
         console.log(chalk.yellow(`  Reason: ${validation.reason}`));
         printDiagnosticId(attempt.stageFailed(validation.diagnostic, "token_validation"));
         console.log(chalk.gray("  The token will be saved but may not work until refreshed."));
-        const keepAnyway = await confirm({ message: "Save this account anyway?", default: false });
+        const keepAnyway = await confirm({ message: "Save this account anyway?", default: false }, { signal: options.signal });
         if (!keepAnyway) {
             attempt.cancelled();
             return { account: null, attempt };
@@ -215,7 +215,7 @@ async function collectAnthropicAccount(options, method, current, reached) {
  * The refresh token stays required here: a pasted long-lived `setup-token`
  * credential has none, and it has its own method rather than this one.
  */
-async function promptManualTokens() {
+async function promptManualTokens(signal) {
     console.log(chalk.gray("\n  You can find your tokens by running:\n" +
         "    macOS:         security find-generic-password -s 'Claude Code-credentials' -w\n" +
         "    Linux/Windows: cat ~/.claude/.credentials.json\n"));
@@ -225,21 +225,21 @@ async function promptManualTokens() {
         validate: (v) => v.startsWith("sk-ant-oat01-") || v.startsWith("sk-ant-")
             ? true
             : "Must start with sk-ant-oat01-",
-    });
+    }, { signal });
     const refreshToken = await password({
         message: "Paste refreshToken (sk-ant-ort01-...):",
         mask: "•",
         validate: (v) => v.startsWith("sk-ant-ort01-") || v.startsWith("sk-ant-")
             ? true
             : "Must start with sk-ant-ort01-",
-    });
+    }, { signal });
     const useDefaultExpiry = await confirm({
         message: "Use default expiry (8 hours from now)?",
         default: true,
-    });
+    }, { signal });
     const expiresAt = useDefaultExpiry
         ? Date.now() + 8 * 60 * 60 * 1000
-        : await promptExpiry();
+        : await promptExpiry(signal);
     return {
         accessToken,
         refreshToken,
@@ -383,15 +383,16 @@ export async function collectReauthRecord(target, options = {}) {
         ...(target.email ? { email: target.email } : {}),
         offer: "login",
         ...(options.longLived ? { method: "setup_token" } : {}),
+        ...(options.signal ? { signal: options.signal } : {}),
     });
     return account ? { record: credentialsOnly(accountToRecord(account)), attempt } : null;
 }
 /** An explicit expiry: ISO date or Unix milliseconds, validated as typed. */
-async function promptExpiry() {
+async function promptExpiry(signal) {
     const raw = await input({
         message: "Paste expiresAt (ISO date or ms timestamp):",
         validate: v => parseExpiryInput(v) !== null || "Enter an ISO date (2027-01-01) or a Unix timestamp in milliseconds",
-    });
+    }, { signal });
     return parseExpiryInput(raw);
 }
 /**

package/dist/cli/cmd-status.js

@@ -1,7 +1,8 @@
 import chalk from "chalk";
 import { PROXY_PORT } from "../config/paths.js";
 import { readConfig } from "../config/manager.js";
-import { classifyHttpSetupFailure, failAttemptFromError, } from "../telemetry/setup-diagnostics.js";
+import { classifyHttpSetupFailure, failAttemptFromError, isPromptCancellation, } from "../telemetry/setup-diagnostics.js";
+import { withEscapeCancel } from "./prompt-cancel.js";
 export function resolveStatusTarget(port) {
     const cfg = readConfig();
     if (cfg.client) {
@@ -169,11 +170,12 @@ async function runReauthFlow(target, intent) {
     let attempt;
     try {
         const { collectReauthRecord } = await import("./account-flows.js");
-        const result = await collectReauthRecord({
+        console.log(chalk.gray("  Esc or Ctrl-C returns to the dashboard.\n"));
+        const result = await withEscapeCancel(signal => collectReauthRecord({
             id: intent.id,
             provider: intent.provider,
             ...(intent.email ? { email: intent.email } : {}),
-        });
+        }, { signal }));
         if (!result)
             return null;
         attempt = result.attempt;
@@ -201,6 +203,10 @@ async function runReauthFlow(target, intent) {
         return result.record.id;
     }
     catch (err) {
+        if (isPromptCancellation(err)) {
+            console.log(chalk.gray("\n  Cancelled."));
+            return null;
+        }
         console.error(chalk.red(`\n✗ Re-authentication failed: ${err.message}`));
         if (attempt) {
             const outcome = failAttemptFromError(attempt, err, "persistence");
@@ -219,8 +225,9 @@ async function runAddAccountFlow(target) {
     let attempt;
     try {
         const { collectClaudeAccount, accountToRecord } = await import("./account-flows.js");
+        console.log(chalk.gray("  Esc or Ctrl-C returns to the dashboard.\n"));
         // The index shown in the flow is just for display, pick something neutral.
-        const setup = await collectClaudeAccount({ index: 1 });
+        const setup = await withEscapeCancel(signal => collectClaudeAccount({ index: 1, signal }));
         attempt = setup.attempt;
         const account = setup.account;
         if (!account)
@@ -250,6 +257,10 @@ async function runAddAccountFlow(target) {
         return account.id;
     }
     catch (err) {
+        if (isPromptCancellation(err)) {
+            console.log(chalk.gray("\n  Cancelled."));
+            return null;
+        }
         console.error(chalk.red(`\n✗ Failed to add account: ${err.message}`));
         if (attempt) {
             const outcome = failAttemptFromError(attempt, err, "persistence");

package/dist/cli/prompt-cancel.js

@@ -0,0 +1,21 @@
+import * as readline from "node:readline";
+/** The Escape key itself — not an escape sequence and not an Alt-chord. */
+export function isEscapeKey(key) {
+    return key?.name === "escape" && key.sequence === "\x1b";
+}
+export async function withEscapeCancel(flow, stdin = process.stdin) {
+    // Idempotent: the prompt's own readline interface installs the same decoder.
+    readline.emitKeypressEvents(stdin);
+    const controller = new AbortController();
+    const onKeypress = (_input, key) => {
+        if (isEscapeKey(key))
+            controller.abort();
+    };
+    stdin.on("keypress", onKeypress);
+    try {
+        return await flow(controller.signal);
+    }
+    finally {
+        stdin.off("keypress", onKeypress);
+    }
+}

package/dist/telemetry/setup-diagnostics.js

@@ -224,7 +224,10 @@ export async function withSetupTelemetryFlush(operation) {
     }
 }
 export function isPromptCancellation(error) {
-    return ownStringProperty(error, "name") === "ExitPromptError";
+    const name = ownStringProperty(error, "name");
+    // ExitPromptError: Ctrl-C or the process leaving. AbortPromptError: the
+    // prompt's AbortSignal fired — the dashboard's Escape key.
+    return name === "ExitPromptError" || name === "AbortPromptError";
 }
 /**
  * Close an attempt that ended in a thrown error: a cancelled prompt is a user

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timo972/cc-router",
-  "version": "0.13.0-rc.1",
+  "version": "0.13.0-rc.2",
   "description": "Cache-aware session router for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {