@efoo/ccprofile 0.1.3 → 0.3.0

package/README.md

@@ -73,7 +73,7 @@ Repeat with `ccprofile add personal` etc. Different terminals in different direc
 | `ccprofile unlink [dir]` | Remove the managed block (deletes `.envrc` if nothing else remains) |
 | `ccprofile token <name>` | Print the stored token to stdout (for scripting — handle with care) |
 | `ccprofile remove <name>` | Delete the profile and its Keychain entry |
-| `ccprofile doctor [dir]` | Diagnose provider overrides, stale/missing active token env, expiry, token liveness, broken links. `--offline` skips the server probe |
+| `ccprofile doctor [dir]` | Diagnose provider overrides, stale/missing active token env, expiry, token liveness, usage limits (a minimal real inference per profile — fable first, haiku fallback), broken links. `--model <alias>` pins the probe model; `--offline` skips all server probes |
 | `ccprofile completion <shell>` | Print a completion script for fish, zsh, or bash |
 
 ## Shell completion
@@ -120,7 +120,7 @@ ccprofile is built on `claude setup-token`, whose long-lived tokens are **delibe
 
 - **No account identity introspection.** The token cannot answer "whose token is this?" — the OAuth profile endpoint rejects it (`user:profile` scope missing, see [#11985](https://github.com/anthropics/claude-code/issues/11985)). The `--email` you record is a self-declared label, not verified.
   *Verify identity once, at registration time:* make sure the browser is logged into the intended claude.ai account before `claude setup-token`, then send a couple of prompts from a linked directory and confirm on claude.ai (web) that the intended account's usage moved.
-- **`/status` → Usage tab shows no plan utilization** in token-authenticated sessions (same scope restriction). Check usage on claude.ai instead.
+- **`/status` → Usage tab shows no plan utilization** in token-authenticated sessions (same scope restriction — the usage endpoint also requires `user:profile`). Check usage on claude.ai, or run `ccprofile doctor`: it detects exhausted usage limits the only way these tokens allow, by sending one minimal real inference per profile (fable first; on a fable limit it retries with haiku to tell "fable's separate budget exhausted" from "subscription window exhausted"). The probe consumes a negligible amount of quota and starts the 5-hour window of an idle profile; use `--offline` if you don't want that.
 - **Remote Control is unavailable** in linked directories. Claude Code treats `ANTHROPIC_AUTH_TOKEN` sessions as API-key authentication, while Remote Control requires claude.ai subscription authentication.
 - **Tokens last up to 1 year but can die earlier** (password change, logout-all). The recorded expiry is a hint, not a guarantee — `ccprofile doctor` probes the server and tells live tokens apart from revoked ones.
 - **Routing only applies to shell-launched processes.** direnv activates the token when a hooked shell enters the directory; apps launched outside a hooked shell (GUI launchers) bypass it.

package/dist/commands/completion.js

@@ -7,6 +7,7 @@ export const SUBCOMMANDS = [
     { name: "token", description: "Print the stored token" },
     { name: "remove", description: "Delete a profile and its Keychain entry" },
     { name: "doctor", description: "Diagnose configuration problems" },
+    { name: "usage", description: "Show claude.ai usage per account" },
     { name: "completion", description: "Print a shell completion script" },
     { name: "help", description: "Show help" },
 ];
@@ -41,7 +42,7 @@ complete -c ccprofile -n "__fish_seen_subcommand_from add" -l expires-at -r -d "
 complete -c ccprofile -n "__fish_seen_subcommand_from add" -l token -r -d "Provide the token directly"
 complete -c ccprofile -n "__fish_seen_subcommand_from add" -l force -d "Overwrite an existing profile"
 complete -c ccprofile -n "__fish_seen_subcommand_from add" -l no-setup -d "Skip launching claude setup-token"
-complete -c ccprofile -n "__fish_seen_subcommand_from list" -l json -d "JSON output"
+complete -c ccprofile -n "__fish_seen_subcommand_from list usage" -l json -d "JSON output"
 complete -c ccprofile -n "__fish_seen_subcommand_from remove" -l force -d "Skip confirmation"
 complete -c ccprofile -n __fish_use_subcommand -l help -d "Show help"
 complete -c ccprofile -n __fish_use_subcommand -l version -d "Show version"
@@ -82,7 +83,7 @@ ${describeLines}
     add)
       compadd -- --email --expires-at --token --force --no-setup
       ;;
-    list)
+    list|usage)
       compadd -- --json
       ;;
   esac
@@ -119,7 +120,7 @@ _ccprofile() {
       COMPREPLY=( \$(compgen -W "fish zsh bash" -- "\$cur") ) ;;
     add)
       COMPREPLY=( \$(compgen -W "--email --expires-at --token --force --no-setup" -- "\$cur") ) ;;
-    list)
+    list|usage)
       COMPREPLY=( \$(compgen -W "--json" -- "\$cur") ) ;;
   esac
 }

package/dist/commands/doctor.js

@@ -7,22 +7,16 @@ import { daysRemaining, loadConfig } from "../lib/config.js";
 import { parseLinkedProfile } from "../lib/envrc.js";
 import { Keychain } from "../lib/keychain.js";
 import { probeToken } from "../lib/probe.js";
-import { bold, fail, ok, warn } from "../lib/format.js";
-/**
- * Env vars that outrank ccprofile's managed ANTHROPIC_AUTH_TOKEN in Claude
- * Code's documented authentication precedence. If any is set, ccprofile
- * routing is bypassed before the token is considered.
- */
-const OVERRIDING_ENV_VARS = [
-    "CLAUDE_CODE_USE_BEDROCK",
-    "CLAUDE_CODE_USE_VERTEX",
-    "CLAUDE_CODE_USE_FOUNDRY",
-];
+import { DEFAULT_PROBE_MODEL, FALLBACK_PROBE_MODEL, OVERRIDING_ENV_VARS, probeUsage, } from "../lib/usage.js";
+import { bold, dim, fail, green, ok, red, stripAnsi, warn, yellow } from "../lib/format.js";
 export async function doctorCommand(argv) {
     const { values, positionals } = parseArgs({
         args: argv,
         allowPositionals: true,
-        options: { offline: { type: "boolean", default: false } },
+        options: {
+            offline: { type: "boolean", default: false },
+            model: { type: "string" },
+        },
     });
     const dir = resolve(positionals[0] ?? process.cwd());
     let problems = 0;
@@ -31,23 +25,31 @@ export async function doctorCommand(argv) {
         console.log(fail("Not macOS: ccprofile's Keychain backend is unavailable on this platform."));
         return 1;
     }
-    console.log(ok("Platform: macOS (Keychain backend available)"));
     const claude = spawnSync("claude", ["--version"], { stdio: "pipe" });
-    if (claude.error || claude.status !== 0) {
-        console.log(warn("`claude` CLI not found. `ccprofile add` cannot launch setup-token for you."));
-        warnings += 1;
-    }
-    else {
-        console.log(ok(`Claude Code: ${claude.stdout.toString().trim()}`));
-    }
+    const claudeAvailable = !claude.error && claude.status === 0;
     const direnv = spawnSync("direnv", ["version"], { stdio: "pipe" });
-    if (direnv.error || direnv.status !== 0) {
-        console.log(fail("direnv not found. Linked directories will not activate tokens automatically."));
-        console.log("  Install: brew install direnv  /  fish hook: direnv hook fish | source");
-        problems += 1;
+    const direnvAvailable = !direnv.error && direnv.status === 0;
+    if (claudeAvailable && direnvAvailable) {
+        const claudeVersion = claude.stdout.toString().trim().split(" ")[0] ?? "";
+        console.log(ok(`macOS Keychain · Claude Code ${claudeVersion} · direnv ${direnv.stdout.toString().trim()}`));
     }
     else {
-        console.log(ok(`direnv: ${direnv.stdout.toString().trim()}`));
+        console.log(ok("Platform: macOS (Keychain backend available)"));
+        if (claudeAvailable) {
+            console.log(ok(`Claude Code: ${claude.stdout.toString().trim()}`));
+        }
+        else {
+            console.log(warn("`claude` CLI not found. `ccprofile add` cannot launch setup-token for you."));
+            warnings += 1;
+        }
+        if (direnvAvailable) {
+            console.log(ok(`direnv: ${direnv.stdout.toString().trim()}`));
+        }
+        else {
+            console.log(fail("direnv not found. Linked directories will not activate tokens automatically."));
+            console.log("  Install: brew install direnv  /  fish hook: direnv hook fish | source");
+            problems += 1;
+        }
     }
     for (const envVar of OVERRIDING_ENV_VARS) {
         if (process.env[envVar] !== undefined) {
@@ -72,72 +74,66 @@ export async function doctorCommand(argv) {
     }
     const config = loadConfig();
     const keychain = new Keychain();
-    for (const [name, profile] of Object.entries(config.profiles)) {
-        const present = await keychain.hasEntry(profile.keychain.service, profile.keychain.account);
-        if (!present) {
-            console.log(fail(`Profile "${name}": Keychain entry missing. Re-run: ccprofile add ${name} --force`));
-            problems += 1;
-            continue;
-        }
-        const days = daysRemaining(profile.expiresAt);
-        if (days < 0) {
-            console.log(fail(`Profile "${name}": token recorded as expired ${-days}d ago. Re-issue with claude setup-token.`));
-            problems += 1;
-        }
-        else if (days <= config.settings.expiryWarningDays) {
-            console.log(warn(`Profile "${name}": token expires in ${days}d.`));
-            warnings += 1;
-        }
-        else {
-            console.log(ok(`Profile "${name}": token stored, expires in ${days}d.`));
-        }
-        if (values.offline)
-            continue;
-        const token = await keychain.getToken(profile.keychain.service, profile.keychain.account);
-        if (token === null)
-            continue;
-        const live = await probeToken(token);
-        if (live.status === "alive") {
-            if (live.email !== undefined && profile.email !== undefined && live.email !== profile.email) {
-                console.log(fail(`Profile "${name}": server says the token belongs to ${live.email}, but config records ${profile.email}.`));
-                problems += 1;
-            }
-            else {
-                console.log(ok(`Profile "${name}": token is live on the server${live.email ? ` (account: ${live.email})` : ""}.`));
+    const profiles = Object.entries(config.profiles);
+    if (profiles.length > 0) {
+        const ctx = {
+            keychain,
+            expiryWarningDays: config.settings.expiryWarningDays,
+            offline: values.offline,
+            claudeAvailable,
+            probeModel: values.model ?? DEFAULT_PROBE_MODEL,
+        };
+        // All profiles are checked concurrently (each profile's own steps stay
+        // sequential so the fable→haiku cascade works); rows print in config
+        // order as they resolve, making wall time the slowest profile, not the sum.
+        const running = profiles.map(([name, profile]) => checkProfile(name, profile, ctx));
+        const widths = columnWidths(profiles.map(([name]) => name));
+        console.log();
+        console.log(dim(renderCells(HEADER, widths)));
+        const spinner = startSpinner(values.offline || !claudeAvailable
+            ? "checking profiles…"
+            : `probing ${profiles.length} profile(s) — one tiny real request each…`);
+        for (const pending of running) {
+            const row = await pending;
+            spinner.clear();
+            console.log(renderCells([bold(row.name), row.token, row.expires, row.fable, row.others, row.note], widths));
+            for (const detail of row.details) {
+                console.log(`  ${dim("↳")} ${detail}`);
             }
+            problems += row.problems;
+            warnings += row.warnings;
         }
-        else if (live.status === "invalid") {
-            console.log(fail(`Profile "${name}": token rejected by the server (revoked or expired early). Re-issue with: ccprofile add ${name} --force`));
-            problems += 1;
-        }
-        else {
-            console.log(warn(`Profile "${name}": liveness check inconclusive (${live.detail}). Use --offline to skip.`));
-            warnings += 1;
-        }
+        spinner.stop();
     }
     const envrcPath = join(dir, ".envrc");
     if (existsSync(envrcPath)) {
+        console.log();
         const linked = parseLinkedProfile(readFileSync(envrcPath, "utf8"));
         if (linked === null) {
             console.log(ok(`${envrcPath} exists but has no ccprofile block (not managed here).`));
         }
         else if (config.profiles[linked]) {
-            console.log(ok(`${bold(dir)} is linked to profile "${linked}".`));
-            if (dir === resolve(process.cwd())) {
+            if (dir !== resolve(process.cwd())) {
+                console.log(ok(`${bold(dir)} → profile "${linked}"`));
+            }
+            else {
                 const linkedProfile = config.profiles[linked];
                 const exportedToken = process.env.ANTHROPIC_AUTH_TOKEN;
                 if (exportedToken === undefined) {
-                    console.log(fail("Current shell does not export ANTHROPIC_AUTH_TOKEN. Run: direnv reload"));
+                    console.log(fail(`This directory → profile "${linked}", but ANTHROPIC_AUTH_TOKEN is not exported in this shell. Run: direnv reload`));
                     problems += 1;
                 }
                 else {
                     const linkedToken = await keychain.getToken(linkedProfile.keychain.service, linkedProfile.keychain.account);
                     if (linkedToken !== null && exportedToken !== linkedToken) {
-                        console.log(fail(`Current shell exports a different ANTHROPIC_AUTH_TOKEN than profile "${linked}". Run: direnv reload, then restart Claude Code.`));
+                        console.log(fail(`This directory → profile "${linked}", but this shell exports a different ANTHROPIC_AUTH_TOKEN. Run: direnv reload, then restart Claude Code.`));
                         problems += 1;
                     }
                     else if (linkedToken !== null) {
-                        console.log(ok(`Current shell exports profile "${linked}" token via ANTHROPIC_AUTH_TOKEN.`));
+                        console.log(ok(`This directory → profile "${linked}" (ANTHROPIC_AUTH_TOKEN exported)`));
+                    }
+                    else {
+                        console.log(ok(`This directory → profile "${linked}"`));
                     }
                 }
             }
@@ -155,3 +151,220 @@ export async function doctorCommand(argv) {
     console.log(ok(`No problems found (${warnings} warning(s)).`));
     return 0;
 }
+const HEADER = ["PROFILE", "TOKEN", "EXPIRES", "FABLE", "OTHERS", "NOTE"];
+// The cell vocabulary is fixed, so column widths are known before any check
+// resolves — rows can stream in as profiles finish, without a barrier.
+const TOKEN_CELLS = {
+    stored: green("✓ stored"),
+    live: green("✓ live"),
+    missing: red("✗ missing"),
+    revoked: red("✗ revoked"),
+    mismatch: red("✗ mismatch"),
+    unknown: yellow("? unknown"),
+};
+const PROBE_CELLS = {
+    ok: green("✓ ok"),
+    limit: yellow("⚠ limit"),
+    rejected: red("✗"),
+    unknown: yellow("?"),
+    none: dim("-"),
+};
+function columnWidths(names) {
+    const vocab = (cells) => Object.values(cells).map((c) => stripAnsi(c).length);
+    return [
+        Math.max("PROFILE".length, ...names.map((n) => n.length)),
+        Math.max("TOKEN".length, ...vocab(TOKEN_CELLS)),
+        "EXPIRES".length,
+        Math.max("FABLE".length, ...vocab(PROBE_CELLS)),
+        Math.max("OTHERS".length, ...vocab(PROBE_CELLS)),
+        0, // NOTE is last and stays unpadded
+    ];
+}
+function renderCells(cells, widths) {
+    return cells
+        .map((cell, i) => {
+        const width = widths[i] ?? 0;
+        return cell + " ".repeat(Math.max(0, width - stripAnsi(cell).length));
+    })
+        .join("  ")
+        .trimEnd();
+}
+function expiresCell(days, warningDays) {
+    const text = `${days}d`;
+    if (days < 0)
+        return red(text);
+    if (days <= warningDays)
+        return yellow(text);
+    return text;
+}
+/**
+ * Minimal dependency-free progress indicator for the parallel probe wait.
+ * Renders only on a TTY (piped/CI output stays clean). clear() erases the
+ * spinner line so a result row can print; the interval repaints it below.
+ */
+function startSpinner(text) {
+    if (!process.stdout.isTTY) {
+        return { clear: () => { }, stop: () => { } };
+    }
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const paint = () => {
+        process.stdout.write(`\r\u001B[2K${dim(`${frames[i % frames.length] ?? ""} ${text}`)}`);
+        i += 1;
+    };
+    paint();
+    const timer = setInterval(paint, 100);
+    const clear = () => {
+        process.stdout.write("\r\u001B[2K");
+    };
+    return {
+        clear,
+        stop: () => {
+            clearInterval(timer);
+            clear();
+        },
+    };
+}
+/**
+ * Runs every check for one profile and returns a table row instead of
+ * printing, so all profiles can run concurrently without interleaving
+ * output. Detail lines carry remediation/diagnostic text that does not fit
+ * a cell. Must never reject: doctor prints rows in config order while later
+ * profiles are still running, so a rejection before its turn would be an
+ * unhandled promise rejection.
+ */
+async function checkProfile(name, profile, ctx) {
+    const row = {
+        name,
+        token: PROBE_CELLS.none,
+        expires: PROBE_CELLS.none,
+        fable: PROBE_CELLS.none,
+        others: PROBE_CELLS.none,
+        note: "",
+        details: [],
+        problems: 0,
+        warnings: 0,
+    };
+    try {
+        const present = await ctx.keychain.hasEntry(profile.keychain.service, profile.keychain.account);
+        if (!present) {
+            row.token = TOKEN_CELLS.missing;
+            row.problems += 1;
+            row.details.push(`Keychain entry missing. Re-run: ccprofile add ${name} --force`);
+            return row;
+        }
+        row.token = TOKEN_CELLS.stored;
+        const days = daysRemaining(profile.expiresAt);
+        row.expires = expiresCell(days, ctx.expiryWarningDays);
+        if (days < 0) {
+            row.problems += 1;
+            row.details.push(`Token recorded as expired ${-days}d ago. Re-issue with claude setup-token.`);
+        }
+        else if (days <= ctx.expiryWarningDays) {
+            row.warnings += 1;
+        }
+        if (ctx.offline)
+            return row;
+        const token = await ctx.keychain.getToken(profile.keychain.service, profile.keychain.account);
+        if (token === null)
+            return row;
+        const live = await probeToken(token);
+        if (live.status === "alive") {
+            if (live.email !== undefined && profile.email !== undefined && live.email !== profile.email) {
+                row.token = TOKEN_CELLS.mismatch;
+                row.problems += 1;
+                row.details.push(`Server says the token belongs to ${live.email}, but config records ${profile.email}.`);
+            }
+            else {
+                row.token = TOKEN_CELLS.live;
+            }
+            if (ctx.claudeAvailable) {
+                await appendUsageProbe(row, token, ctx.probeModel);
+            }
+        }
+        else if (live.status === "invalid") {
+            row.token = TOKEN_CELLS.revoked;
+            row.problems += 1;
+            row.details.push(`Token rejected by the server (revoked or expired early). Re-issue with: ccprofile add ${name} --force`);
+        }
+        else {
+            row.token = TOKEN_CELLS.unknown;
+            row.warnings += 1;
+            row.details.push(`Liveness check inconclusive (${live.detail}). Use --offline to skip.`);
+        }
+    }
+    catch (error) {
+        row.problems += 1;
+        row.details.push(`Check failed (${error instanceof Error ? error.message : String(error)}).`);
+    }
+    return row;
+}
+/**
+ * Fills the FABLE/OTHERS cells via real inference. fable is probed first by
+ * default; on a fable limit, a haiku probe distinguishes "fable's separate
+ * budget is exhausted" from "the whole subscription window is exhausted".
+ * The two probes stay sequential within a profile (the cascade depends on
+ * the first result); concurrency happens across profiles. Limits count as
+ * warnings, not problems: doctor's exit code reflects configuration health,
+ * and a rate-limited profile is configured correctly.
+ */
+async function appendUsageProbe(row, token, model) {
+    const pinnedIsFable = /fable/i.test(model);
+    const setProbedCell = (cell) => {
+        if (pinnedIsFable)
+            row.fable = cell;
+        else
+            row.others = cell;
+    };
+    const usage = await probeUsage(token, model);
+    if (usage.status === "usable") {
+        if (pinnedIsFable) {
+            row.fable = PROBE_CELLS.ok;
+            // fable draws from the shared pool too, so fable OK implies the rest.
+            row.others = PROBE_CELLS.ok;
+        }
+        else {
+            row.others = PROBE_CELLS.ok;
+            row.note = `probed ${model}`;
+        }
+        return;
+    }
+    if (usage.status === "limited") {
+        row.warnings += 1;
+        const resets = usage.resetsAt === undefined ? "" : ` (resets ${usage.resetsAt.toLocaleString()})`;
+        if (!pinnedIsFable) {
+            row.others = PROBE_CELLS.limit;
+            row.note = `${model} usage limit reached${resets}`;
+            return;
+        }
+        row.fable = PROBE_CELLS.limit;
+        const fallback = await probeUsage(token, FALLBACK_PROBE_MODEL);
+        if (fallback.status === "usable") {
+            row.others = PROBE_CELLS.ok;
+            row.note = `${FALLBACK_PROBE_MODEL}/sonnet/opus available${resets}`;
+        }
+        else if (fallback.status === "limited") {
+            row.others = PROBE_CELLS.limit;
+            row.note =
+                fallback.resetsAt === undefined
+                    ? `subscription window exhausted${resets}`
+                    : `subscription window exhausted (resets ${fallback.resetsAt.toLocaleString()})`;
+        }
+        else {
+            row.others = PROBE_CELLS.unknown;
+            row.note = `${FALLBACK_PROBE_MODEL} probe inconclusive`;
+            row.details.push(`${FALLBACK_PROBE_MODEL} probe: ${fallback.detail}`);
+        }
+        return;
+    }
+    if (usage.status === "invalid") {
+        setProbedCell(PROBE_CELLS.rejected);
+        row.problems += 1;
+        row.details.push(`Inference probe rejected the token (${usage.detail}). Re-issue with: ccprofile add ${row.name} --force`);
+        return;
+    }
+    setProbedCell(PROBE_CELLS.unknown);
+    row.warnings += 1;
+    row.note = "usage probe inconclusive";
+    row.details.push(`Usage probe (${model}): ${usage.detail}`);
+}

package/dist/commands/usage.js

@@ -0,0 +1,155 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { assertDarwin } from "../lib/keychain.js";
+import { chromeUserAgent, chromeUserDataDir, parseProfiles, readSessionCookies, safeStorageKey, } from "../lib/chrome.js";
+import { fetchAccountUsage, NOT_SIGNED_IN, } from "../lib/claudeai.js";
+import { bold, dim, fail, red, table, warn, yellow } from "../lib/format.js";
+export async function usageCommand(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { json: { type: "boolean", default: false } },
+    });
+    assertDarwin();
+    const userDataDir = chromeUserDataDir();
+    const localStatePath = join(userDataDir, "Local State");
+    if (!existsSync(localStatePath)) {
+        console.error(fail("Google Chrome data not found. `ccprofile usage` reads claude.ai session cookies from Chrome."));
+        return 1;
+    }
+    let key;
+    try {
+        key = await safeStorageKey();
+    }
+    catch (error) {
+        console.error(fail(error instanceof Error ? error.message : String(error)));
+        return 1;
+    }
+    const userAgent = chromeUserAgent(userDataDir);
+    const profiles = parseProfiles(readFileSync(localStatePath, "utf8")).filter((p) => existsSync(join(userDataDir, p.dir, "Cookies")));
+    const spinner = values.json
+        ? { stop: () => { } }
+        : startSpinner(`querying claude.ai for ${profiles.length} Chrome profile(s)…`);
+    const results = await Promise.all(profiles.map((profile) => loadUsage(profile, userDataDir, key, userAgent)));
+    spinner.stop();
+    if (values.json) {
+        console.log(JSON.stringify(results.map(toJson), null, 2));
+        return hasRealFailure(results) ? 1 : 0;
+    }
+    return render(results);
+}
+/**
+ * A profile that was never signed in is expected and not a failure; anything
+ * else (expired session, Cloudflare block, decrypt/read error) is, so the
+ * command exits non-zero for scripts even though the table still prints.
+ */
+function hasRealFailure(results) {
+    return results.some((r) => !r.usage.ok && r.usage.detail !== NOT_SIGNED_IN);
+}
+/** Decrypts one profile's cookies and fetches its usage; never throws. */
+async function loadUsage(profile, userDataDir, key, userAgent) {
+    try {
+        const cookies = await readSessionCookies(join(userDataDir, profile.dir, "Cookies"), key);
+        return { profile, usage: await fetchAccountUsage(cookies, userAgent) };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return { profile, usage: { ok: false, status: 0, detail } };
+    }
+}
+function render(results) {
+    const header = ["ACCOUNT", "CHROME", "5-HOUR", "WEEK · ALL", "FABLE · WEEK"].map(bold);
+    const rows = [header];
+    const problems = [];
+    for (const { profile, usage } of results) {
+        if (usage.ok) {
+            rows.push([
+                usage.email ?? dim("(unknown)"),
+                dim(profile.name),
+                windowCell(usage.report.session),
+                windowCell(usage.report.weeklyAll),
+                windowCell(usage.report.fable),
+            ]);
+        }
+        else if (usage.detail !== NOT_SIGNED_IN) {
+            // A missing session is expected for stray Chrome profiles; only real
+            // failures (expired session, Cloudflare block) are worth surfacing.
+            problems.push(warn(`${profile.name}: ${usage.detail}`));
+        }
+    }
+    if (rows.length === 1 && problems.length === 0) {
+        console.log(dim("No claude.ai sessions found in Chrome. Sign in at https://claude.ai and retry."));
+        return 0;
+    }
+    if (rows.length > 1)
+        console.log(table(rows));
+    for (const problem of problems)
+        console.log(problem);
+    return problems.length > 0 ? 1 : 0;
+}
+function windowCell(window) {
+    if (window === null)
+        return dim("-");
+    const reset = window.resetsAt === null ? "" : `  ${dim(formatReset(window.resetsAt))}`;
+    return `${percent(window)}${reset}`;
+}
+function percent(window) {
+    // Right-align to 3 digits so the reset time lines up down the column.
+    const text = `${String(window.percent).padStart(3, " ")}%`;
+    if (window.severity === "critical" || window.percent >= 90)
+        return red(text);
+    if (window.severity === "warning" || window.percent >= 80)
+        return yellow(text);
+    return text;
+}
+/**
+ * Local-time reset as `M/D HH:mm` (respects the machine's timezone). The date
+ * is right-padded to a fixed width so the clock times align down the column.
+ */
+function formatReset(date) {
+    const pad = (n) => String(n).padStart(2, "0");
+    const md = `${date.getMonth() + 1}/${date.getDate()}`.padStart(5, " ");
+    return `${md} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+function toJson(result) {
+    const { profile, usage } = result;
+    return {
+        chromeProfile: profile.name,
+        chromeDir: profile.dir,
+        email: usage.ok ? usage.email : null,
+        error: usage.ok ? null : usage.detail,
+        usage: usage.ok ? serializeReport(usage.report) : null,
+    };
+}
+function serializeReport(report) {
+    const win = (w) => w === null
+        ? null
+        : { percent: w.percent, resetsAt: w.resetsAt?.toISOString() ?? null, severity: w.severity };
+    return {
+        session: win(report.session),
+        weeklyAll: win(report.weeklyAll),
+        fable: win(report.fable),
+    };
+}
+/**
+ * Minimal TTY-only spinner for the network wait; stays silent when output is
+ * piped so scripted/`--json` runs keep clean output.
+ */
+function startSpinner(text) {
+    if (!process.stdout.isTTY)
+        return { stop: () => { } };
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const paint = () => {
+        process.stdout.write(`\r\u001B[2K${dim(`${frames[i % frames.length] ?? ""} ${text}`)}`);
+        i += 1;
+    };
+    paint();
+    const timer = setInterval(paint, 100);
+    return {
+        stop: () => {
+            clearInterval(timer);
+            process.stdout.write("\r\u001B[2K");
+        },
+    };
+}

package/dist/index.js

@@ -23,7 +23,12 @@ ${bold("Commands")}
   token <name>            Print the stored token (for scripting; handle with care)
   remove <name> [--force] Delete a profile and its Keychain entry
   doctor [dir]            Diagnose overriding env vars, expiry, token liveness,
-      --offline           and broken links; --offline skips the server probe
+      --offline           usage limits (real inference probe), and broken links
+      --model <alias>     --offline skips probes; --model pins the probe model
+                          (default: fable, then haiku to isolate fable limits)
+  usage [--json]          Show claude.ai usage per account: 5-hour, weekly, and
+                          Fable-weekly percent + reset. Reads Chrome session
+                          cookies — no browser open or switch required
   completion <shell>      Print a completion script (fish, zsh, bash)
 
 ${bold("Typical flow")}
@@ -50,6 +55,8 @@ async function main() {
             return (await import("./commands/token.js")).tokenCommand(rest);
         case "doctor":
             return (await import("./commands/doctor.js")).doctorCommand(rest);
+        case "usage":
+            return (await import("./commands/usage.js")).usageCommand(rest);
         case "completion":
             return (await import("./commands/completion.js")).completionCommand(rest);
         // Hidden helper for shell completions: prints profile names, one per line.

package/dist/lib/chrome.js

@@ -0,0 +1,162 @@
+import { createDecipheriv, pbkdf2Sync } from "node:crypto";
+import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { defaultRunner } from "./keychain.js";
+/** claude.ai cookies needed to authenticate and clear the Cloudflare bot check. */
+export const SESSION_COOKIE_NAMES = [
+    "sessionKey",
+    "lastActiveOrg",
+    "cf_clearance",
+    "__cf_bm",
+];
+const SAFE_STORAGE_SERVICE = "Chrome Safe Storage";
+// Chrome's fixed KDF parameters for the "v10" Keychain-wrapped cookie scheme.
+const KDF_SALT = "saltysalt";
+const KDF_ITERATIONS = 1003;
+const KEY_LENGTH = 16;
+// AES-128-CBC with an all-spaces IV; the encrypted blob is prefixed with "v10".
+const COOKIE_IV = Buffer.alloc(16, 0x20);
+const COOKIE_PREFIX = "v10";
+// Chrome 130+ prepends a 32-byte SHA-256 of the cookie's host to the plaintext.
+const DOMAIN_HASH_LENGTH = 32;
+export function chromeUserDataDir() {
+    return join(homedir(), "Library", "Application Support", "Google", "Chrome");
+}
+export function parseProfiles(localStateJson) {
+    const data = JSON.parse(localStateJson);
+    const cache = data.profile?.info_cache ?? {};
+    return Object.entries(cache)
+        .map(([dir, info]) => ({ dir, name: info.name?.trim() || dir }))
+        .sort((a, b) => a.dir.localeCompare(b.dir, undefined, { numeric: true }));
+}
+/**
+ * Builds a Chrome-matching User-Agent from the installed version. Cloudflare
+ * ties cf_clearance to the exact UA, so the string must track the same Chrome
+ * that solved the challenge — hence reading the local "Last Version" file
+ * rather than hard-coding a version.
+ */
+export function buildUserAgent(version) {
+    const major = version?.split(".")[0]?.trim();
+    const m = major !== undefined && /^\d+$/.test(major) ? major : "140";
+    return `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${m}.0.0.0 Safari/537.36`;
+}
+export function chromeUserAgent(userDataDir) {
+    let version = null;
+    try {
+        version = readFileSync(join(userDataDir, "Last Version"), "utf8");
+    }
+    catch {
+        version = null;
+    }
+    return buildUserAgent(version);
+}
+export function deriveKey(password) {
+    return pbkdf2Sync(password, KDF_SALT, KDF_ITERATIONS, KEY_LENGTH, "sha1");
+}
+/**
+ * Fetches the Chrome cookie-encryption key from the login Keychain. The
+ * service name contains a space, so this cannot reuse the Keychain class
+ * (its assertSafe rejects spaces); a direct spawn with an argv array is safe.
+ */
+export async function safeStorageKey(run = defaultRunner) {
+    const result = await run("security", [
+        "find-generic-password",
+        "-w",
+        "-s",
+        SAFE_STORAGE_SERVICE,
+    ]);
+    if (result.code !== 0) {
+        throw new Error('Could not read the "Chrome Safe Storage" key from the Keychain. Is Google Chrome installed and set up?');
+    }
+    return deriveKey(result.stdout.trim());
+}
+export function decryptCookieValue(encHex, key) {
+    if (encHex.length === 0)
+        return null;
+    const buf = Buffer.from(encHex, "hex");
+    if (buf.subarray(0, 3).toString("latin1") !== COOKIE_PREFIX) {
+        // v20 (app-bound) cookies use a different key path we do not support.
+        return null;
+    }
+    try {
+        const decipher = createDecipheriv("aes-128-cbc", key, COOKIE_IV);
+        const plain = Buffer.concat([decipher.update(buf.subarray(3)), decipher.final()]);
+        return decodePlaintext(plain);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Newer Chrome builds prefix the value with a 32-byte host hash; older ones
+ * store the bare value. The hash is binary, so a plaintext that is not clean
+ * printable text is treated as prefixed and the leading 32 bytes are dropped.
+ */
+function decodePlaintext(plain) {
+    if (isPrintable(plain))
+        return plain.toString("utf8");
+    return plain.subarray(DOMAIN_HASH_LENGTH).toString("utf8");
+}
+function isPrintable(buf) {
+    for (const b of buf) {
+        if (b < 0x20 || b > 0x7e)
+            return false;
+    }
+    return true;
+}
+/**
+ * Copies the (Chrome-locked) cookie DB to a temp file and reads the claude.ai
+ * rows as hex via the macOS-bundled sqlite3, avoiding a native SQLite binding.
+ */
+export async function readRawClaudeCookies(cookiesDbPath, run = defaultRunner) {
+    const dir = mkdtempSync(join(tmpdir(), "ccprofile-cookies-"));
+    const copy = join(dir, "Cookies");
+    try {
+        copyFileSync(cookiesDbPath, copy);
+        // Chrome keeps the store in WAL mode; without the sidecars, recently
+        // refreshed cookies (notably the short-lived Cloudflare ones) stay
+        // invisible until Chrome checkpoints.
+        for (const suffix of ["-wal", "-shm"]) {
+            const sidecar = `${cookiesDbPath}${suffix}`;
+            if (existsSync(sidecar))
+                copyFileSync(sidecar, `${copy}${suffix}`);
+        }
+        // Only cookies a browser would send to https://claude.ai/: the apex
+        // host-only cookie and `.claude.ai` domain cookies. A subdomain host-only
+        // cookie (e.g. foo.claude.ai) is not sent there and could otherwise shadow
+        // the real sessionKey/cf_clearance.
+        const result = await run("/usr/bin/sqlite3", [
+            "-json",
+            copy,
+            "SELECT name, hex(encrypted_value) AS enc FROM cookies " +
+                "WHERE host_key = 'claude.ai' OR host_key = '.claude.ai'",
+        ]);
+        // A non-zero exit means sqlite3 itself failed (locked DB, unsupported
+        // option). Surface it so loadUsage reports a per-profile error instead of
+        // silently rendering the profile as "not signed in".
+        if (result.code !== 0) {
+            throw new Error(`sqlite3 failed to read Chrome cookies (exit ${result.code})${result.stderr.trim() ? `: ${result.stderr.trim()}` : ""}`);
+        }
+        const out = result.stdout.trim();
+        if (out === "")
+            return [];
+        return JSON.parse(out);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+export async function readSessionCookies(cookiesDbPath, key, run = defaultRunner) {
+    const raw = await readRawClaudeCookies(cookiesDbPath, run);
+    const wanted = new Set(SESSION_COOKIE_NAMES);
+    const cookies = {};
+    for (const { name, enc } of raw) {
+        if (!wanted.has(name))
+            continue;
+        const value = decryptCookieValue(enc, key);
+        if (value !== null)
+            cookies[name] = value;
+    }
+    return cookies;
+}

package/dist/lib/claudeai.js

@@ -0,0 +1,148 @@
+/**
+ * Minimal client for the claude.ai web API. ccprofile's own setup-token
+ * cannot read usage (the api.anthropic.com/api/oauth/usage endpoint requires a
+ * scope setup-tokens lack — see src/lib/usage.ts), so `ccprofile usage` speaks
+ * to the same endpoints the web app uses, authenticated with the browser's
+ * session cookies.
+ */
+/** Per-request ceiling so one stalled account cannot hang the whole command. */
+const REQUEST_TIMEOUT_MS = 15_000;
+export const defaultJsonFetcher = async (url, headers) => {
+    const res = await fetch(url, { headers, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+    const text = await res.text();
+    let body = null;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        body = null;
+    }
+    return { status: res.status, body };
+};
+export function buildHeaders(cookieHeader, userAgent) {
+    return {
+        Cookie: cookieHeader,
+        "User-Agent": userAgent,
+        "anthropic-client-platform": "web_claude_ai",
+        Referer: "https://claude.ai/",
+        Accept: "*/*",
+    };
+}
+function isRecord(v) {
+    return typeof v === "object" && v !== null;
+}
+function toDate(v) {
+    if (typeof v !== "string")
+        return null;
+    const d = new Date(v);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+function toSeverity(v) {
+    return v === "normal" || v === "warning" || v === "critical" ? v : "unknown";
+}
+function toPercent(v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+/** A `limits[]` entry carries percent/severity/resets_at directly. */
+function windowFromLimit(limit) {
+    return {
+        percent: toPercent(limit.percent),
+        resetsAt: toDate(limit.resets_at),
+        severity: toSeverity(limit.severity),
+    };
+}
+/** The top-level five_hour/seven_day objects use `utilization` and lack severity. */
+function windowFromTopLevel(obj) {
+    if (!isRecord(obj))
+        return null;
+    return {
+        percent: toPercent(obj.utilization),
+        resetsAt: toDate(obj.resets_at),
+        severity: "unknown",
+    };
+}
+function isFableScoped(limit) {
+    if (limit.kind !== "weekly_scoped")
+        return false;
+    const scope = limit.scope;
+    if (!isRecord(scope))
+        return false;
+    const model = scope.model;
+    return isRecord(model) && model.display_name === "Fable";
+}
+/**
+ * Normalizes an /organizations/{id}/usage response. The Fable window only ever
+ * appears inside `limits[]` (the top-level seven_day_* fields are null), so
+ * limits[] is the primary source; five_hour/seven_day are fallbacks for the
+ * session and weekly-all windows when limits[] is absent.
+ */
+export function parseUsage(json) {
+    const root = isRecord(json) ? json : {};
+    const limits = Array.isArray(root.limits) ? root.limits.filter(isRecord) : [];
+    const byKind = (kind) => limits.find((l) => l.kind === kind);
+    const session = byKind("session");
+    const weeklyAll = byKind("weekly_all");
+    const fable = limits.find(isFableScoped);
+    return {
+        session: session ? windowFromLimit(session) : windowFromTopLevel(root.five_hour),
+        weeklyAll: weeklyAll ? windowFromLimit(weeklyAll) : windowFromTopLevel(root.seven_day),
+        fable: fable ? windowFromLimit(fable) : null,
+    };
+}
+function extractEmail(body) {
+    if (!isRecord(body))
+        return null;
+    const account = body.account;
+    if (!isRecord(account))
+        return null;
+    return typeof account.email_address === "string" ? account.email_address : null;
+}
+/** Detail set when a profile simply has no claude.ai session (not an error). */
+export const NOT_SIGNED_IN = "not signed in to claude.ai";
+function describeStatus(status) {
+    if (status === 401)
+        return "session expired — sign in again in Chrome";
+    if (status === 403)
+        return "blocked (session expired or Cloudflare challenge)";
+    if (status === 429)
+        return "rate limited by claude.ai";
+    return `claude.ai returned HTTP ${status}`;
+}
+/**
+ * Resolves one account's email and usage from its cookies. Uses lastActiveOrg
+ * (the org the browser last viewed) for the usage URL so the numbers match
+ * what the web UI shows. Never throws — network/HTTP failures come back as
+ * `{ ok: false }` so callers can render one bad profile without aborting.
+ */
+export async function fetchAccountUsage(cookies, userAgent, fetcher = defaultJsonFetcher) {
+    if (cookies.sessionKey === undefined) {
+        return { ok: false, status: 0, detail: NOT_SIGNED_IN };
+    }
+    const org = cookies.lastActiveOrg;
+    if (org === undefined) {
+        return { ok: false, status: 0, detail: "no active organization cookie" };
+    }
+    const cookieHeader = Object.entries(cookies)
+        .map(([name, value]) => `${name}=${value}`)
+        .join("; ");
+    const headers = buildHeaders(cookieHeader, userAgent);
+    try {
+        const boot = await fetcher("https://claude.ai/api/bootstrap", headers);
+        if (boot.status !== 200) {
+            return { ok: false, status: boot.status, detail: describeStatus(boot.status) };
+        }
+        const email = extractEmail(boot.body);
+        const usage = await fetcher(`https://claude.ai/api/organizations/${encodeURIComponent(org)}/usage`, headers);
+        if (usage.status !== 200) {
+            return { ok: false, status: usage.status, detail: describeStatus(usage.status) };
+        }
+        return { ok: true, email, report: parseUsage(usage.body) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            status: 0,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/lib/format.js

@@ -12,21 +12,45 @@ export const cyan = (s) => paint("36", s);
 export const ok = (s) => `${green("✓")} ${s}`;
 export const warn = (s) => `${yellow("⚠")} ${s}`;
 export const fail = (s) => `${red("✗")} ${s}`;
-function stripAnsi(s) {
+export function stripAnsi(s) {
     return s.replaceAll(new RegExp(`${ESC}\\[[0-9;]*m`, "g"), "");
 }
+/** East Asian Wide/Fullwidth code points that occupy two terminal columns. */
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0x303e) ||
+        (cp >= 0x3041 && cp <= 0x33ff) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x4e00 && cp <= 0x9fff) ||
+        (cp >= 0xa000 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe4f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd));
+}
+/** Rendered column count of a string, ANSI-stripped and wide-char aware. */
+export function displayWidth(s) {
+    let width = 0;
+    for (const ch of stripAnsi(s)) {
+        width += isWide(ch.codePointAt(0) ?? 0) ? 2 : 1;
+    }
+    return width;
+}
 export function table(rows) {
     if (rows.length === 0)
         return "";
     const widths = [];
     for (const row of rows) {
         row.forEach((cell, i) => {
-            widths[i] = Math.max(widths[i] ?? 0, stripAnsi(cell).length);
+            widths[i] = Math.max(widths[i] ?? 0, displayWidth(cell));
         });
     }
     return rows
         .map((row) => row
-        .map((cell, i) => cell + " ".repeat((widths[i] ?? 0) - stripAnsi(cell).length))
+        .map((cell, i) => cell + " ".repeat((widths[i] ?? 0) - displayWidth(cell)))
         .join("  ")
         .trimEnd())
         .join("\n");

package/dist/lib/usage.js

@@ -0,0 +1,156 @@
+import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
+/**
+ * fable has its own budget (~50% of the plan, 5h/1-week windows) separate
+ * from the pool shared by haiku/sonnet/opus, and fable usage also counts
+ * against the shared pool. Probing fable first therefore answers for
+ * everything: fable OK ⇒ all models OK; fable limited ⇒ probe the cheapest
+ * shared-pool model to tell "fable-only exhausted" from "window exhausted".
+ */
+export const DEFAULT_PROBE_MODEL = "fable";
+export const FALLBACK_PROBE_MODEL = "haiku";
+const PROBE_TIMEOUT_MS = 120_000;
+/**
+ * Env vars that outrank ANTHROPIC_AUTH_TOKEN in Claude Code's documented
+ * authentication precedence. doctor flags them; the probe strips them so the
+ * spawned `claude -p` authenticates as the profile under test.
+ */
+export const OVERRIDING_ENV_VARS = [
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+];
+export const defaultProbeRunner = (cmd, args, opts) => new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+        env: opts.env,
+        cwd: opts.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+    }, opts.timeoutMs);
+    child.stdout.on("data", (d) => (stdout += d.toString()));
+    child.stderr.on("data", (d) => (stderr += d.toString()));
+    child.on("error", (error) => {
+        clearTimeout(timer);
+        resolve({ code: null, stdout, stderr, timedOut, spawnError: error.message });
+    });
+    child.on("close", (code) => {
+        clearTimeout(timer);
+        resolve({ code, stdout, stderr, timedOut });
+    });
+});
+/**
+ * Everything here trims the request to near-zero cost and isolates it from
+ * the invoking user's Claude Code customizations: a one-word turn with a
+ * replacement system prompt, no tools, no MCP servers, no settings (hooks,
+ * plugins, apiKeyHelper), no session file, run from tmpdir so no project
+ * CLAUDE.md is discovered. --fallback-model must never be added: it would
+ * silently succeed on another model and mask the limit being probed for.
+ */
+function probeArgs(model) {
+    return [
+        "--print", "ping",
+        "--model", model,
+        "--effort", "low",
+        "--system-prompt", 'Reply with exactly "ok".',
+        "--tools", "",
+        "--setting-sources", "",
+        "--strict-mcp-config",
+        "--no-session-persistence",
+        "--output-format", "json",
+    ];
+}
+function probeEnv(token) {
+    const env = { ...process.env, ANTHROPIC_AUTH_TOKEN: token };
+    delete env.ANTHROPIC_API_KEY;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+    delete env.ANTHROPIC_MODEL;
+    for (const name of OVERRIDING_ENV_VARS)
+        delete env[name];
+    return env;
+}
+// Claude Code's error strings are not a stable API; match loosely and fall
+// back to "unknown" rather than misclassifying. Checked against the legacy
+// print-mode message ("Claude AI usage limit reached|<epoch>"), the current
+// prose ("You've reached your usage limit..."), and API rate_limit_error.
+const LIMIT_RE = /usage limit|rate.?limit|limit (?:reached|exceeded|resets|will reset)|exceeded.*limit|out of (?:usage|credits)|hit your.*limit|\b429\b/i;
+const AUTH_RE = /authentication_error|invalid (?:bearer|oauth|api key)|oauth token|\b401\b|\/login\b/i;
+/** Legacy print-mode limit messages carry a reset time as "|<unix epoch>". */
+function parseResetEpoch(text) {
+    const digits = /\|(\d{10,13})\b/.exec(text)?.[1];
+    if (digits === undefined)
+        return undefined;
+    const n = Number(digits);
+    return new Date(digits.length >= 13 ? n : n * 1000);
+}
+function summarize(text) {
+    const line = text
+        .replaceAll(/\u001B\[[0-9;]*m/g, "")
+        .split("\n")
+        .map((l) => l.trim())
+        .find((l) => l.length > 0);
+    return (line ?? "").slice(0, 200);
+}
+function isRecord(v) {
+    return typeof v === "object" && v !== null;
+}
+/**
+ * `--output-format json` emits a single result object in some Claude Code
+ * versions and an array of messages (init/assistant/result) in others
+ * (observed with 2.1.201). The result message carries `is_error`, the final
+ * text, and — on API rejections — a structured `api_error_status` (e.g. 429),
+ * which beats string matching.
+ */
+function extractResultMessage(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        // Startup failures print plain text before any JSON is emitted.
+        return {};
+    }
+    const items = Array.isArray(parsed) ? parsed : [parsed];
+    const message = items.find((i) => isRecord(i) && i.type === "result") ??
+        items.find((i) => isRecord(i) && "is_error" in i);
+    if (message === undefined)
+        return {};
+    return {
+        isError: typeof message.is_error === "boolean" ? message.is_error : undefined,
+        resultText: typeof message.result === "string" ? message.result : undefined,
+        apiErrorStatus: typeof message.api_error_status === "number" ? message.api_error_status : undefined,
+    };
+}
+export function classifyProbeOutput(exec) {
+    if (exec.spawnError !== undefined) {
+        return { status: "unknown", detail: exec.spawnError };
+    }
+    if (exec.timedOut) {
+        return { status: "unknown", detail: `probe timed out after ${PROBE_TIMEOUT_MS / 1000}s` };
+    }
+    const { isError, resultText, apiErrorStatus } = extractResultMessage(exec.stdout);
+    if (exec.code === 0 && isError !== true)
+        return { status: "usable" };
+    const combined = [resultText ?? exec.stdout, exec.stderr].join("\n");
+    const detail = summarize(combined) || `claude exited with code ${exec.code}`;
+    if (apiErrorStatus === 429 || LIMIT_RE.test(combined)) {
+        return { status: "limited", detail, resetsAt: parseResetEpoch(combined) };
+    }
+    if (apiErrorStatus === 401 || AUTH_RE.test(combined)) {
+        return { status: "invalid", detail };
+    }
+    return { status: "unknown", detail };
+}
+export async function probeUsage(token, model, run = defaultProbeRunner) {
+    const exec = await run("claude", probeArgs(model), {
+        env: probeEnv(token),
+        cwd: tmpdir(),
+        timeoutMs: PROBE_TIMEOUT_MS,
+    });
+    return classifyProbeOutput(exec);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efoo/ccprofile",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Per-directory Claude Code account routing via ANTHROPIC_AUTH_TOKEN, direnv, and macOS Keychain",
   "type": "module",
   "packageManager": "pnpm@10.33.4",