claude-switcher-account 2.2.1 → 2.4.0

package/README.md

@@ -86,6 +86,20 @@ or `NO_COLOR` is set.
 
 Global flags: `--json` (on `list`), `--version`, `--help`.
 
+`claudep list` shows each account's plan usage, the same numbers as Claude Code's
+`/usage` (the interactive menu stays compact and skips it):
+
+```
+   5h: 40.0%  Reset: 55m
+   Weekly: 12.0%  Weekly Reset: 5d 9hr 45m
+```
+
+They are fetched live from Anthropic with each account's token. When a saved
+(inactive) account's access token has expired, claudep refreshes it the way
+Claude Code does and saves the new credential in place of the old one; the active
+login is left to Claude Code. An account that was logged out (no refresh token
+left), or any fetch that fails, shows `--`.
+
 ### Interactive menu
 
 Running `claudep` with no arguments (in a terminal) opens a menu of your saved
@@ -137,6 +151,8 @@ Configured in `~/.claude-profiles/config.json`:
 - **Linux/Windows**: canonical login file `~/.claude/.credentials.json`; saved
   accounts in `~/.claude-profiles/creds.json` (mode `0600`).
 - Account metadata: `~/.claude-profiles/accounts.json`.
+- `CLAUDE_CONFIG_DIR` is not supported: only the default `~/.claude` login is
+  managed, and `claudep doctor` flags the variable when it is set.
 
 On macOS the first read of Claude's Keychain item may raise an "allow access"
 dialog — click Allow. Run `claudep doctor` if anything looks off.

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command } from "commander";
+import { Command, CommanderError } from "commander";
 import { createInterface as createInterface2 } from "readline/promises";
 import { homedir as homedir5 } from "os";
 import { join as join6 } from "path";
@@ -19,10 +19,14 @@ import { promisify } from "util";
 var execFileP = promisify(execFile);
 var CLAUDE_SERVICE = "Claude Code-credentials";
 var STORE_SERVICE = "claude-profiles-accounts";
-var defaultExec = async (args) => {
-  const { stdout } = await execFileP("security", args);
+var defaultExec = async (args, input) => {
+  const p = execFileP("security", args);
+  p.child.stdin?.end(input ?? "");
+  const { stdout } = await p;
   return stdout;
 };
+var INTERACTIVE_MAX_LINE = 4e3;
+var quote = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 var MacKeychainStore = class {
   exec;
   osUsername;
@@ -43,8 +47,18 @@ var MacKeychainStore = class {
       return "";
     }
   }
+  /** Upsert a secret, keeping it off the argv (visible to `ps`) whenever it fits on one `security -i` line. */
+  async addPassword(service, account, blob) {
+    const line = `add-generic-password -U -s ${quote(service)} -a ${quote(account)} -w ${quote(blob)}
+`;
+    if (!/[\r\n]/.test(blob) && Buffer.byteLength(line) <= INTERACTIVE_MAX_LINE) {
+      await this.exec(["-i"], line);
+      return;
+    }
+    await this.exec(["add-generic-password", "-U", "-s", service, "-a", account, "-w", blob]);
+  }
   async writeCanonical(blob) {
-    await this.exec(["add-generic-password", "-U", "-s", CLAUDE_SERVICE, "-a", this.osUsername, "-w", blob]);
+    await this.addPassword(CLAUDE_SERVICE, this.osUsername, blob);
   }
   async readSaved(name) {
     try {
@@ -55,7 +69,7 @@ var MacKeychainStore = class {
     }
   }
   async writeSaved(name, blob) {
-    await this.exec(["add-generic-password", "-U", "-s", STORE_SERVICE, "-a", name, "-w", blob]);
+    await this.addPassword(STORE_SERVICE, name, blob);
   }
   async deleteSaved(name) {
     try {
@@ -66,8 +80,46 @@ var MacKeychainStore = class {
 };
 
 // src/stores/fileStore.ts
-import { mkdirSync, readFileSync, writeFileSync, renameSync, existsSync } from "fs";
+import { mkdirSync as mkdirSync2, readFileSync, writeFileSync, renameSync, existsSync } from "fs";
+import { dirname as dirname2 } from "path";
+
+// src/lock.ts
+import { mkdirSync, statSync, rmSync } from "fs";
 import { dirname } from "path";
+var LOCK_STALE_MS = 1e4;
+var LOCK_RETRY_MS = 25;
+var LOCK_TIMEOUT_MS = 5e3;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function acquireLock(lockPath) {
+  mkdirSync(dirname(lockPath), { recursive: true });
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  for (; ; ) {
+    try {
+      mkdirSync(lockPath);
+      return;
+    } catch {
+      try {
+        if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+          rmSync(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() > deadline) throw new Error(`Timed out acquiring lock ${lockPath}`);
+      await sleep(LOCK_RETRY_MS);
+    }
+  }
+}
+async function withLock(lockPath, fn) {
+  await acquireLock(lockPath);
+  try {
+    return await fn();
+  } finally {
+    rmSync(lockPath, { recursive: true, force: true });
+  }
+}
+
+// src/stores/fileStore.ts
 var FileStore = class {
   canonicalPath;
   credsPath;
@@ -81,19 +133,28 @@ var FileStore = class {
     return this.platform === "linux" || this.platform === "win32";
   }
   atomicWrite(path, data, mode) {
-    mkdirSync(dirname(path), { recursive: true });
+    mkdirSync2(dirname2(path), { recursive: true });
     const tmp = `${path}.tmp-${process.pid}`;
     writeFileSync(tmp, data, mode !== void 0 ? { mode } : void 0);
     renameSync(tmp, path);
   }
+  /** Throws if the file exists but can't be parsed, so a write never replaces it with an empty map. */
   readMap() {
     if (!existsSync(this.credsPath)) return {};
+    let parsed;
     try {
-      const parsed = JSON.parse(readFileSync(this.credsPath, "utf8"));
-      return parsed && typeof parsed === "object" ? parsed : {};
+      parsed = JSON.parse(readFileSync(this.credsPath, "utf8"));
     } catch {
-      return {};
+      parsed = null;
     }
+    if (!parsed || typeof parsed !== "object") throw new Error(`Saved creds file ${this.credsPath} is unreadable.`);
+    return parsed;
+  }
+  updateMap(mutate) {
+    return withLock(`${this.credsPath}.lock`, () => {
+      const map = this.readMap();
+      if (mutate(map)) this.atomicWrite(this.credsPath, JSON.stringify(map, null, 2), 384);
+    });
   }
   async readCanonical() {
     try {
@@ -106,18 +167,24 @@ var FileStore = class {
     this.atomicWrite(this.canonicalPath, blob, 384);
   }
   async readSaved(name) {
-    return this.readMap()[name] ?? "";
+    try {
+      return this.readMap()[name] ?? "";
+    } catch {
+      return "";
+    }
   }
   async writeSaved(name, blob) {
-    const map = this.readMap();
-    map[name] = blob;
-    this.atomicWrite(this.credsPath, JSON.stringify(map, null, 2), 384);
+    await this.updateMap((map) => {
+      map[name] = blob;
+      return true;
+    });
   }
   async deleteSaved(name) {
-    const map = this.readMap();
-    if (!(name in map)) return;
-    delete map[name];
-    this.atomicWrite(this.credsPath, JSON.stringify(map, null, 2), 384);
+    await this.updateMap((map) => {
+      if (!(name in map)) return false;
+      delete map[name];
+      return true;
+    });
   }
 };
 
@@ -134,12 +201,8 @@ function createCredentialStore(opts) {
 }
 
 // src/metadataStore.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync2, existsSync as existsSync2, statSync, rmSync } from "fs";
-import { dirname as dirname2 } from "path";
-var LOCK_STALE_MS = 1e4;
-var LOCK_RETRY_MS = 25;
-var LOCK_TIMEOUT_MS = 5e3;
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync2, existsSync as existsSync2 } from "fs";
+import { dirname as dirname3 } from "path";
 var MetadataStore = class {
   path;
   lockPath;
@@ -151,53 +214,34 @@ var MetadataStore = class {
     if (!existsSync2(this.path)) return { accounts: [] };
     try {
       const parsed = JSON.parse(readFileSync2(this.path, "utf8"));
-      return { lastActive: parsed?.lastActive, accounts: Array.isArray(parsed?.accounts) ? parsed.accounts : [] };
+      return {
+        lastActive: parsed?.lastActive,
+        pendingRefresh: parsed?.pendingRefresh,
+        accounts: Array.isArray(parsed?.accounts) ? parsed.accounts : []
+      };
     } catch {
       return { accounts: [] };
     }
   }
-  async acquireLock() {
-    mkdirSync2(dirname2(this.lockPath), { recursive: true });
-    const deadline = Date.now() + LOCK_TIMEOUT_MS;
-    for (; ; ) {
-      try {
-        mkdirSync2(this.lockPath);
-        return;
-      } catch {
-        try {
-          if (Date.now() - statSync(this.lockPath).mtimeMs > LOCK_STALE_MS) {
-            rmSync(this.lockPath, { recursive: true, force: true });
-            continue;
-          }
-        } catch {
-        }
-        if (Date.now() > deadline) throw new Error(`Timed out acquiring lock ${this.lockPath}`);
-        await sleep(LOCK_RETRY_MS);
-      }
-    }
-  }
-  releaseLock() {
-    rmSync(this.lockPath, { recursive: true, force: true });
-  }
   async update(mutator) {
-    await this.acquireLock();
-    try {
+    return withLock(this.lockPath, () => {
       const data = this.read();
       mutator(data);
-      mkdirSync2(dirname2(this.path), { recursive: true });
+      mkdirSync3(dirname3(this.path), { recursive: true });
       const tmp = `${this.path}.tmp-${process.pid}`;
-      writeFileSync2(tmp, JSON.stringify({ lastActive: data.lastActive, accounts: data.accounts }, null, 2));
+      writeFileSync2(
+        tmp,
+        JSON.stringify({ lastActive: data.lastActive, pendingRefresh: data.pendingRefresh, accounts: data.accounts }, null, 2)
+      );
       renameSync2(tmp, this.path);
       return data;
-    } finally {
-      this.releaseLock();
-    }
+    });
   }
 };
 
 // src/profileFile.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, renameSync as renameSync3 } from "fs";
-import { dirname as dirname3 } from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, renameSync as renameSync3 } from "fs";
+import { dirname as dirname4 } from "path";
 var ProfileFile = class {
   path;
   constructor(opts) {
@@ -241,7 +285,7 @@ var ProfileFile = class {
     if (snapshot) d.oauthAccount = snapshot;
     else delete d.oauthAccount;
     try {
-      mkdirSync3(dirname3(this.path), { recursive: true });
+      mkdirSync4(dirname4(this.path), { recursive: true });
       const tmp = `${this.path}.tmp-${process.pid}`;
       writeFileSync3(tmp, JSON.stringify(d, null, 2));
       renameSync3(tmp, this.path);
@@ -285,6 +329,7 @@ function orderAccounts(views) {
 }
 
 // src/accountManager.ts
+var REFRESH_CONFIRM_MS = 1e4;
 function toView(a, active) {
   return {
     name: a.name,
@@ -301,12 +346,14 @@ var AccountManager = class {
   profile;
   config;
   now;
+  clock;
   constructor(deps) {
     this.store = deps.store;
     this.meta = deps.meta;
     this.profile = deps.profile;
     this.config = deps.config;
     this.now = deps.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.clock = deps.clock ?? Date.now;
   }
   matchByIdentity(accounts, id) {
     if (id.uuid) {
@@ -365,7 +412,25 @@ var AccountManager = class {
     const ordered = orderAccounts(await this.listAccounts());
     return ordered[n - 1]?.name ?? null;
   }
+  /** Before the login is replaced, copy a token the active account rotated since its last save — reconcile
+   *  may still be waiting out REFRESH_CONFIRM_MS on it. Skipped when the credential is another saved
+   *  account's, i.e. a login-over whose ~/.claude.json write hasn't landed. */
+  async keepActiveCredential() {
+    let blob = "";
+    try {
+      blob = await this.store.readCanonical();
+    } catch {
+      return;
+    }
+    if (!blob) return;
+    const fp = fingerprint(blob);
+    const accounts = this.meta.read().accounts;
+    if (accounts.some((a) => a.fingerprint === fp)) return;
+    const active = this.matchByIdentity(accounts, this.profile.currentIdentity());
+    if (active) await this.refreshStoredCredential(active.name, blob, fp);
+  }
   async switchTo(name) {
+    await this.keepActiveCredential();
     const blob = (await this.store.readSaved(name)).trim();
     if (!blob) throw new Error(`Saved account '${name}' not found.`);
     await this.store.writeCanonical(blob);
@@ -385,7 +450,8 @@ var AccountManager = class {
     if (!entry) throw new Error(`Saved account '${oldName}' not found.`);
     if (data.accounts.some((a) => a.name === newName)) throw new Error(`Account '${newName}' already exists.`);
     const blob = await this.store.readSaved(oldName);
-    if (blob) await this.store.writeSaved(newName, blob);
+    if (!blob) throw new Error(`Saved account '${oldName}' has no stored credential.`);
+    await this.store.writeSaved(newName, blob);
     await this.store.deleteSaved(oldName);
     await this.meta.update((d) => {
       d.accounts = d.accounts.map((a) => a.name === oldName ? { ...a, name: newName } : a);
@@ -403,6 +469,23 @@ var AccountManager = class {
     }
     return accounts.map((a) => toView(a, byId ? a.name === byId.name : activeFp !== null && a.fingerprint === activeFp));
   }
+  /** The account's credential: the live login for the active one (its saved copy may be older), else the saved one. */
+  async credentialOf(view) {
+    try {
+      return view.active ? await this.store.readCanonical() : await this.store.readSaved(view.name);
+    } catch {
+      return "";
+    }
+  }
+  /** Replace an idle account's saved credential with a refreshed one. Unlike refreshStoredCredential it
+   *  leaves savedAt and the profile alone: only the tokens changed. */
+  async saveRefreshedCredential(name, blob) {
+    await this.store.writeSaved(name, blob);
+    await this.meta.update((d) => {
+      const a = d.accounts.find((x) => x.name === name);
+      if (a) a.fingerprint = fingerprint(blob);
+    });
+  }
   current() {
     const label = this.profile.peekLabel();
     const accounts = this.meta.read().accounts;
@@ -492,16 +575,30 @@ var AccountManager = class {
       const accounts = this.meta.read().accounts;
       const known = this.matchByIdentity(accounts, this.profile.currentIdentity()) ?? accounts.find((a) => a.fingerprint === fpNow);
       if (known) {
+        const nowMs = this.clock();
+        let confirmed = false;
         await this.meta.update((d) => {
           d.lastActive = known.name;
+          if (known.fingerprint === fpNow) {
+            d.pendingRefresh = void 0;
+            return;
+          }
+          const p = d.pendingRefresh;
+          if (p?.name !== known.name || p.fingerprint !== fpNow) {
+            d.pendingRefresh = { name: known.name, fingerprint: fpNow, since: nowMs };
+          } else if (nowMs - p.since >= REFRESH_CONFIRM_MS) {
+            d.pendingRefresh = void 0;
+            confirmed = true;
+          }
         });
-        if (known.fingerprint !== fpNow) await this.refreshStoredCredential(known.name, blob, fpNow);
+        if (confirmed) await this.refreshStoredCredential(known.name, blob, fpNow);
         return nothing;
       }
       const saved = await this.autoSaveIfNewLogin();
       if (saved) {
         await this.meta.update((d) => {
           d.lastActive = saved.name;
+          d.pendingRefresh = void 0;
         });
       }
       return { autoSaved: saved, removed: null, switchedTo: null };
@@ -522,6 +619,119 @@ function createManager(env) {
   return new AccountManager({ store, meta, profile, config });
 }
 
+// src/oauth.ts
+var TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var TIMEOUT_MS = 5e3;
+async function refreshCredential(blob, nowMs, fetchFn = fetch) {
+  try {
+    const parsed = JSON.parse(blob);
+    const oauth = parsed?.claudeAiOauth;
+    if (typeof oauth?.refreshToken !== "string" || !oauth.refreshToken) return null;
+    const res = await fetchFn(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ grant_type: "refresh_token", refresh_token: oauth.refreshToken, client_id: CLIENT_ID }),
+      signal: AbortSignal.timeout(TIMEOUT_MS)
+    });
+    if (!res.ok) return null;
+    const t = await res.json();
+    if (typeof t?.access_token !== "string") return null;
+    const next = {
+      ...parsed,
+      claudeAiOauth: {
+        ...oauth,
+        accessToken: t.access_token,
+        refreshToken: typeof t.refresh_token === "string" ? t.refresh_token : oauth.refreshToken,
+        expiresAt: typeof t.expires_in === "number" ? nowMs + t.expires_in * 1e3 : oauth.expiresAt,
+        ...typeof t.refresh_token_expires_in === "number" && {
+          refreshTokenExpiresAt: nowMs + t.refresh_token_expires_in * 1e3
+        }
+      }
+    };
+    return { blob: JSON.stringify(next), accessToken: t.access_token };
+  } catch {
+    return null;
+  }
+}
+
+// src/usage.ts
+var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var TIMEOUT_MS2 = 3e3;
+function accessTokenOf(blob, nowMs) {
+  try {
+    const o = JSON.parse(blob)?.claudeAiOauth;
+    if (typeof o?.accessToken !== "string") return null;
+    if (typeof o.expiresAt === "number" && o.expiresAt <= nowMs) return null;
+    return o.accessToken;
+  } catch {
+    return null;
+  }
+}
+function parseWindow(w) {
+  const o = w;
+  if (typeof o?.utilization !== "number") return null;
+  const t = typeof o.resets_at === "string" ? Date.parse(o.resets_at) : NaN;
+  return { pct: o.utilization, resetsAt: Number.isNaN(t) ? null : t };
+}
+function parseUsage(json) {
+  if (!json || typeof json !== "object") return null;
+  const o = json;
+  return { fiveHour: parseWindow(o.five_hour), weekly: parseWindow(o.seven_day) };
+}
+async function fetchUsage(token, fetchFn = fetch) {
+  try {
+    const res = await fetchFn(USAGE_URL, {
+      headers: { Authorization: `Bearer ${token}`, "anthropic-beta": "oauth-2025-04-20" },
+      signal: AbortSignal.timeout(TIMEOUT_MS2)
+    });
+    if (!res.ok) return null;
+    return parseUsage(await res.json());
+  } catch {
+    return null;
+  }
+}
+async function liveToken(mgr, v, nowMs, refresh) {
+  const blob = await mgr.credentialOf(v);
+  const token = accessTokenOf(blob, nowMs);
+  if (token || v.active || !blob) return token;
+  const r = await refresh(blob, nowMs);
+  if (!r) return null;
+  try {
+    await mgr.saveRefreshedCredential(v.name, r.blob);
+  } catch {
+    return null;
+  }
+  return r.accessToken;
+}
+async function loadUsage(mgr, views, nowMs, deps = {}) {
+  const fetchFn = deps.fetchUsage ?? fetchUsage;
+  const refresh = deps.refresh ?? refreshCredential;
+  const entries = await Promise.all(
+    views.map(async (v) => {
+      const token = await liveToken(mgr, v, nowMs, refresh);
+      return [v.name, token ? await fetchFn(token) : null];
+    })
+  );
+  return Object.fromEntries(entries);
+}
+function formatDuration(ms) {
+  const totalMin = Math.floor(Math.max(0, ms) / 6e4);
+  const d = Math.floor(totalMin / 1440);
+  const h = Math.floor(totalMin % 1440 / 60);
+  const m = totalMin % 60;
+  const parts = [d && `${d}d`, h && `${h}hr`, m && `${m}m`].filter(Boolean);
+  return parts.length ? parts.join(" ") : "<1m";
+}
+function formatUsageLines(u, nowMs) {
+  const pct = (w) => w ? `${w.pct.toFixed(1)}%` : "--";
+  const reset = (w) => w?.resetsAt != null ? formatDuration(w.resetsAt - nowMs) : "--";
+  return [
+    `5h: ${pct(u?.fiveHour)}  Reset: ${reset(u?.fiveHour)}`,
+    `Weekly: ${pct(u?.weekly)}  Weekly Reset: ${reset(u?.weekly)}`
+  ];
+}
+
 // src/format.ts
 var SYMBOLS = { active: "\u25CF", ok: "\u2713", err: "\u2717", warn: "!", off: "\u25CB" };
 function formatRelative(iso, nowMs) {
@@ -562,13 +772,16 @@ function formatList(views, nowMs, colors, opts = {}) {
   const idxW = String(ordered.length).length;
   const emailW = Math.max(...ordered.map((v) => v.email.length));
   const orgW = Math.min(ORG_MAX, Math.max(...ordered.map((v) => (v.organizationName ?? "\u2014").length)));
-  const rows = ordered.map((v, i) => {
+  const usageIndent = " ".repeat(2 + idxW + 4);
+  const rows = ordered.flatMap((v, i) => {
     const idx = colors.dim(pad(String(i + 1), idxW));
     const mark = v.active ? colors.green(SYMBOLS.active) : " ";
     const email = v.active ? colors.green(pad(v.email, emailW)) : pad(v.email, emailW);
     const org = colors.dim(pad(truncate(v.organizationName ?? "\u2014", ORG_MAX), orgW));
     const when = v.active ? colors.green("active") : colors.dim(formatRelative(v.savedAt, nowMs));
-    return `  ${idx}  ${mark} ${email}  ${org}  ${when}`;
+    const row = `  ${idx}  ${mark} ${email}  ${org}  ${when}`;
+    if (!opts.usage) return [row];
+    return [row, ...formatUsageLines(opts.usage[v.name] ?? null, nowMs).map((l) => colors.dim(usageIndent + l))];
   });
   const lines = [header, colors.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"), ...rows, ""];
   if (opts.external) {
@@ -608,7 +821,15 @@ async function runDoctor(deps, colors = makeColors(false)) {
         label: "credential backend",
         detail: deps.store.isAvailable() ? "available" : "unavailable",
         hint: "This OS/backend is not supported yet."
-      }
+      },
+      ...deps.claudeConfigDir ? [
+        {
+          ok: false,
+          label: "CLAUDE_CONFIG_DIR",
+          detail: `${deps.claudeConfigDir} (not supported)`,
+          hint: "claudep only manages the default ~/.claude login; unset CLAUDE_CONFIG_DIR to use it."
+        }
+      ] : []
     ]
   });
   const blob = await deps.store.readCanonical().catch(() => "");
@@ -671,14 +892,15 @@ function buildDoctorDeps(env) {
     profile: new ProfileFile({ path: join3(home, ".claude.json") }),
     meta: new MetadataStore({ path: join3(home, ".claude-profiles", "accounts.json") }),
     config: new ConfigStore({ path: join3(home, ".claude-profiles", "config.json") }).load(),
-    platform
+    platform,
+    claudeConfigDir: process.env.CLAUDE_CONFIG_DIR || void 0
   };
 }
 
 // package.json
 var package_default = {
   name: "claude-switcher-account",
-  version: "2.2.1",
+  version: "2.4.0",
   description: "Switch between multiple Claude Code accounts from your terminal.",
   keywords: [
     "claude",
@@ -794,7 +1016,8 @@ async function dispatchMenu(manager, action, io) {
     case "switch":
       try {
         await manager.switchTo(action.name);
-        io.out(`${SYMBOLS.ok} Now using ${action.name}`);
+        io.out(`${SYMBOLS.ok} Now using ${action.name}
+  restart running claude sessions to apply`);
       } catch (e) {
         io.out(`${SYMBOLS.err} ${e.message}`);
       }
@@ -922,12 +1145,6 @@ async function runInteractiveMenu(manager, out) {
       rl.close();
       return a;
     },
-    confirm: async (q) => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      const a = (await rl.question(`${q} [y/N] `)).trim().toLowerCase();
-      rl.close();
-      return a === "y" || a === "yes";
-    },
     doctor: async () => (await runDoctor(buildDoctorDeps())).report,
     out
   };
@@ -958,9 +1175,23 @@ function startDaemon(manager, opts = {}) {
   const interval = opts.intervalMs ?? 1e3;
   const log = opts.log ?? ((s) => console.log(s));
   const subscribe = opts.watch ?? defaultWatch;
+  let running = false;
+  let again = false;
+  const run = async () => {
+    if (running) {
+      again = true;
+      return;
+    }
+    running = true;
+    do {
+      again = false;
+      await reconcileAndLog(manager, log);
+    } while (again);
+    running = false;
+  };
   log(`[claudep] watching ${path} every ${interval}ms \u2014 instant capture on login/switch/logout`);
-  void reconcileAndLog(manager, log);
-  return subscribe(path, interval, () => void reconcileAndLog(manager, log));
+  void run();
+  return subscribe(path, interval, () => void run());
 }
 function defaultWatch(path, intervalMs, onChange) {
   const listener = () => onChange();
@@ -971,9 +1202,9 @@ function defaultWatch(path, intervalMs, onChange) {
 // src/autostart.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, rmSync as rmSync2, existsSync as existsSync3 } from "fs";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, rmSync as rmSync2, existsSync as existsSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname as dirname4, join as join5 } from "path";
+import { dirname as dirname5, join as join5 } from "path";
 var execFileP2 = promisify2(execFile2);
 var LABEL = "com.claude-switcher-account.daemon";
 var WIN_TASK = "claude-switcher-account";
@@ -984,6 +1215,8 @@ var LEGACY_UNIT = "claude-login-switcher.service";
 var defaultExec2 = async (file, args) => {
   await execFileP2(file, args);
 };
+var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var systemdArg = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%").replace(/\$/g, "$$$$")}"`;
 function launchdPlist(p) {
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -992,15 +1225,15 @@ function launchdPlist(p) {
   <key>Label</key><string>${LABEL}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${p.nodePath}</string>
-    <string>${p.binPath}</string>
+    <string>${xml(p.nodePath)}</string>
+    <string>${xml(p.binPath)}</string>
     <string>daemon</string>
     <string>run</string>
   </array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
-  <key>StandardOutPath</key><string>${p.logPath}</string>
-  <key>StandardErrorPath</key><string>${p.logPath}</string>
+  <key>StandardOutPath</key><string>${xml(p.logPath)}</string>
+  <key>StandardErrorPath</key><string>${xml(p.logPath)}</string>
 </dict>
 </plist>
 `;
@@ -1010,7 +1243,7 @@ function systemdUnit(p) {
 Description=claude-switcher-account instant login watcher
 
 [Service]
-ExecStart=${p.nodePath} ${p.binPath} daemon run
+ExecStart=${systemdArg(p.nodePath)} ${systemdArg(p.binPath)} daemon run
 Restart=always
 StandardOutput=append:${p.logPath}
 StandardError=append:${p.logPath}
@@ -1040,7 +1273,7 @@ function autostartInstalled(platform, home = homedir4()) {
   return false;
 }
 function writeFile(path, contents) {
-  mkdirSync4(dirname4(path), { recursive: true });
+  mkdirSync5(dirname5(path), { recursive: true });
   writeFileSync4(path, contents);
 }
 async function removeLegacyAutostart(platform, home = homedir4(), exec = defaultExec2) {
@@ -1077,7 +1310,14 @@ async function installAutostart(platform, paths, home = homedir4(), exec = defau
     return `systemd user service installed at ${unit}`;
   }
   if (platform === "win32") {
-    await exec("schtasks", windowsCreateArgs(paths));
+    try {
+      await exec("schtasks", windowsCreateArgs(paths));
+    } catch (e) {
+      throw new Error(
+        `${e.message.trim()}
+Creating a logon task can require an Administrator terminal \u2014 rerun \`claudep daemon install\` from one.`
+      );
+    }
     return `Task Scheduler task '${WIN_TASK}' created (runs at logon)`;
   }
   throw new Error(`Autostart not supported on ${platform}.`);
@@ -1110,6 +1350,11 @@ async function defaultConfirm(question) {
   rl.close();
   return answer === "y" || answer === "yes";
 }
+function handleFatal(err, errOut) {
+  if (err instanceof CommanderError) return err.exitCode;
+  errOut(`  ${SYMBOLS.err} ${err instanceof Error ? err.message : String(err)}`);
+  return 1;
+}
 function buildProgram(deps = {}) {
   const out = deps.out ?? ((s) => console.log(s));
   const now = deps.now ?? (() => Date.now());
@@ -1178,7 +1423,8 @@ function buildProgram(deps = {}) {
     }
     const cur = mgr.current();
     const external = !cur.saved && cur.label ? cur.label.email : void 0;
-    out(formatList(views, now(), colors, { external }));
+    const usage = await loadUsage(mgr, views, now(), { fetchUsage: deps.fetchUsage, refresh: deps.refreshCredential });
+    out(formatList(views, now(), colors, { external, usage }));
   });
   program2.command("switch <target>").alias("use").description("Make an account the active login (by name or number)").action(async (target) => {
     const mgr = manager();
@@ -1194,6 +1440,11 @@ function buildProgram(deps = {}) {
       process.exitCode = 1;
       return;
     }
+    if (!(await mgr.listAccounts()).some((a) => a.name === name)) {
+      out(err(`Saved account '${name}' not found.`) + "\n" + note(listHint));
+      process.exitCode = 1;
+      return;
+    }
     if (!opts.yes) {
       const yes = await confirm(`Remove ${name}? This deletes its stored credential.`);
       if (!yes) {
@@ -1264,6 +1515,5 @@ var program = buildProgram();
 try {
   await program.parseAsync(process.argv);
 } catch (err) {
-  const code = err.exitCode ?? 1;
-  process.exit(code);
+  process.exit(handleFatal(err, (s) => console.error(s)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-switcher-account",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "Switch between multiple Claude Code accounts from your terminal.",
   "keywords": [
     "claude",