claude-switcher-account 2.1.0

package/dist/bin.js

@@ -0,0 +1,1277 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { createInterface as createInterface2 } from "readline/promises";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+
+// src/app.ts
+import { homedir, userInfo } from "os";
+import { join as join2 } from "path";
+
+// src/credentialStore.ts
+import { join } from "path";
+
+// src/stores/macKeychainStore.ts
+import { execFile } from "child_process";
+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);
+  return stdout;
+};
+var MacKeychainStore = class {
+  exec;
+  osUsername;
+  platform;
+  constructor(opts) {
+    this.exec = opts.exec ?? defaultExec;
+    this.osUsername = opts.osUsername;
+    this.platform = opts.platform ?? process.platform;
+  }
+  isAvailable() {
+    return this.platform === "darwin";
+  }
+  async readCanonical() {
+    try {
+      const out = await this.exec(["find-generic-password", "-w", "-s", CLAUDE_SERVICE, "-a", this.osUsername]);
+      return out.trim();
+    } catch {
+      return "";
+    }
+  }
+  async writeCanonical(blob) {
+    await this.exec(["add-generic-password", "-U", "-s", CLAUDE_SERVICE, "-a", this.osUsername, "-w", blob]);
+  }
+  async readSaved(name) {
+    try {
+      const out = await this.exec(["find-generic-password", "-w", "-s", STORE_SERVICE, "-a", name]);
+      return out.trim();
+    } catch {
+      return "";
+    }
+  }
+  async writeSaved(name, blob) {
+    await this.exec(["add-generic-password", "-U", "-s", STORE_SERVICE, "-a", name, "-w", blob]);
+  }
+  async deleteSaved(name) {
+    try {
+      await this.exec(["delete-generic-password", "-s", STORE_SERVICE, "-a", name]);
+    } catch {
+    }
+  }
+};
+
+// src/stores/fileStore.ts
+import { mkdirSync, readFileSync, writeFileSync, renameSync, existsSync } from "fs";
+import { dirname } from "path";
+var FileStore = class {
+  canonicalPath;
+  credsPath;
+  platform;
+  constructor(opts) {
+    this.canonicalPath = opts.canonicalPath;
+    this.credsPath = opts.credsPath;
+    this.platform = opts.platform ?? process.platform;
+  }
+  isAvailable() {
+    return this.platform === "linux" || this.platform === "win32";
+  }
+  atomicWrite(path, data, mode) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, data, mode !== void 0 ? { mode } : void 0);
+    renameSync(tmp, path);
+  }
+  readMap() {
+    if (!existsSync(this.credsPath)) return {};
+    try {
+      const parsed = JSON.parse(readFileSync(this.credsPath, "utf8"));
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  async readCanonical() {
+    try {
+      return readFileSync(this.canonicalPath, "utf8").trim();
+    } catch {
+      return "";
+    }
+  }
+  async writeCanonical(blob) {
+    this.atomicWrite(this.canonicalPath, blob, 384);
+  }
+  async readSaved(name) {
+    return this.readMap()[name] ?? "";
+  }
+  async writeSaved(name, blob) {
+    const map = this.readMap();
+    map[name] = blob;
+    this.atomicWrite(this.credsPath, JSON.stringify(map, null, 2), 384);
+  }
+  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);
+  }
+};
+
+// src/credentialStore.ts
+function createCredentialStore(opts) {
+  if (opts.platform === "darwin") {
+    return new MacKeychainStore({ osUsername: opts.osUsername, platform: opts.platform });
+  }
+  return new FileStore({
+    canonicalPath: join(opts.home, ".claude", ".credentials.json"),
+    credsPath: join(opts.home, ".claude-profiles", "creds.json"),
+    platform: opts.platform
+  });
+}
+
+// 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));
+var MetadataStore = class {
+  path;
+  lockPath;
+  constructor(opts) {
+    this.path = opts.path;
+    this.lockPath = `${opts.path}.lock`;
+  }
+  read() {
+    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 : [] };
+    } 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 {
+      const data = this.read();
+      mutator(data);
+      mkdirSync2(dirname2(this.path), { recursive: true });
+      const tmp = `${this.path}.tmp-${process.pid}`;
+      writeFileSync2(tmp, JSON.stringify({ lastActive: data.lastActive, 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";
+var ProfileFile = class {
+  path;
+  constructor(opts) {
+    this.path = opts.path;
+  }
+  read() {
+    try {
+      const d = JSON.parse(readFileSync3(this.path, "utf8"));
+      return d && typeof d === "object" ? d : null;
+    } catch {
+      return null;
+    }
+  }
+  peekOauthAccount() {
+    const oa = this.read()?.oauthAccount;
+    return oa && typeof oa === "object" ? oa : void 0;
+  }
+  peekLabel() {
+    const oa = this.peekOauthAccount();
+    const email = typeof oa?.emailAddress === "string" ? oa.emailAddress : void 0;
+    if (!email) return null;
+    return {
+      email,
+      displayName: typeof oa?.displayName === "string" ? oa.displayName : void 0,
+      organizationName: typeof oa?.organizationName === "string" ? oa.organizationName : void 0
+    };
+  }
+  currentIdentity() {
+    const oa = this.peekOauthAccount();
+    return {
+      uuid: typeof oa?.accountUuid === "string" ? oa.accountUuid : void 0,
+      email: typeof oa?.emailAddress === "string" ? oa.emailAddress : void 0
+    };
+  }
+  applyOauthAccount(snapshot) {
+    let d = this.read();
+    if (!d) {
+      if (!snapshot) return;
+      d = {};
+    }
+    if (snapshot) d.oauthAccount = snapshot;
+    else delete d.oauthAccount;
+    try {
+      mkdirSync3(dirname3(this.path), { recursive: true });
+      const tmp = `${this.path}.tmp-${process.pid}`;
+      writeFileSync3(tmp, JSON.stringify(d, null, 2));
+      renameSync3(tmp, this.path);
+    } catch {
+    }
+  }
+};
+
+// src/config.ts
+import { readFileSync as readFileSync4 } from "fs";
+var VALID = ["delete-switch", "keep-switch", "keep", "none"];
+var DEFAULT = { logoutBehavior: "keep" };
+var ConfigStore = class {
+  path;
+  constructor(opts) {
+    this.path = opts.path;
+  }
+  load() {
+    try {
+      const d = JSON.parse(readFileSync4(this.path, "utf8"));
+      const b = d?.logoutBehavior;
+      return VALID.includes(b) ? { logoutBehavior: b } : DEFAULT;
+    } catch {
+      return DEFAULT;
+    }
+  }
+};
+
+// src/fingerprint.ts
+import { createHash } from "crypto";
+function fingerprint(blob) {
+  return createHash("sha256").update(blob).digest("hex");
+}
+
+// src/order.ts
+function compareByEmail(a, b) {
+  return a.email.toLowerCase().localeCompare(b.email.toLowerCase());
+}
+function orderAccounts(views) {
+  return [...views].sort(compareByEmail);
+}
+
+// src/accountManager.ts
+function toView(a, active) {
+  return {
+    name: a.name,
+    email: a.email,
+    displayName: a.displayName,
+    organizationName: a.organizationName,
+    savedAt: a.savedAt,
+    active
+  };
+}
+var AccountManager = class {
+  store;
+  meta;
+  profile;
+  config;
+  now;
+  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());
+  }
+  matchByIdentity(accounts, id) {
+    if (id.uuid) {
+      const m = accounts.find((a) => a.oauthAccount?.accountUuid === id.uuid);
+      if (m) return m;
+    }
+    if (id.email) return accounts.find((a) => a.email === id.email);
+    return void 0;
+  }
+  async saveCurrent(name) {
+    const blob = await this.store.readCanonical();
+    if (!blob) throw new Error("No current Claude login found.");
+    const fp = fingerprint(blob);
+    const data = this.meta.read();
+    const label = this.profile.peekLabel();
+    let finalName = name;
+    let matched;
+    if (!finalName) {
+      matched = data.accounts.find((a) => a.fingerprint === fp);
+      finalName = matched?.name;
+    }
+    if (!finalName) {
+      const email2 = label?.email;
+      const collision = email2 ? data.accounts.find((a) => a.name === email2 && a.fingerprint !== fp) : void 0;
+      if (collision) {
+        throw new Error(
+          `Current login does not match saved account '${email2}'. Its profile may be stale \u2014 retry after the session initializes.`
+        );
+      }
+      finalName = email2;
+    }
+    if (!finalName) throw new Error("Could not determine an account name.");
+    await this.store.writeSaved(finalName, blob);
+    const email = matched ? matched.email : label?.email ?? finalName;
+    const current = this.profile.peekOauthAccount();
+    const currentEmail = typeof current?.emailAddress === "string" ? current.emailAddress : void 0;
+    const oauthAccount = current && (currentEmail === email || currentEmail === finalName) ? current : matched?.oauthAccount;
+    const entry = {
+      name: finalName,
+      email: matched ? matched.email : label?.email ?? finalName,
+      displayName: matched ? matched.displayName : label?.displayName,
+      organizationName: matched ? matched.organizationName : label?.organizationName,
+      fingerprint: fp,
+      savedAt: this.now(),
+      oauthAccount
+    };
+    const nameToWrite = finalName;
+    await this.meta.update((d) => {
+      d.accounts = [...d.accounts.filter((a) => a.name !== nameToWrite), entry];
+    });
+    return toView(entry, true);
+  }
+  /** Map a 1-based index (as printed by `list`) to an account name, or null if out of range. */
+  async resolveByIndex(n) {
+    if (!Number.isInteger(n) || n < 1) return null;
+    const ordered = orderAccounts(await this.listAccounts());
+    return ordered[n - 1]?.name ?? null;
+  }
+  async switchTo(name) {
+    const blob = (await this.store.readSaved(name)).trim();
+    if (!blob) throw new Error(`Saved account '${name}' not found.`);
+    await this.store.writeCanonical(blob);
+    const saved = this.meta.read().accounts.find((a) => a.name === name);
+    this.profile.applyOauthAccount(saved?.oauthAccount);
+  }
+  async removeAccount(name) {
+    await this.store.deleteSaved(name);
+    await this.meta.update((d) => {
+      d.accounts = d.accounts.filter((a) => a.name !== name);
+      if (d.lastActive === name) d.lastActive = void 0;
+    });
+  }
+  async renameAccount(oldName, newName) {
+    const data = this.meta.read();
+    const entry = data.accounts.find((a) => a.name === oldName);
+    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);
+    await this.store.deleteSaved(oldName);
+    await this.meta.update((d) => {
+      d.accounts = d.accounts.map((a) => a.name === oldName ? { ...a, name: newName } : a);
+      if (d.lastActive === oldName) d.lastActive = newName;
+    });
+  }
+  async listAccounts() {
+    const accounts = this.meta.read().accounts;
+    const id = this.profile.currentIdentity();
+    const byId = id.uuid || id.email ? this.matchByIdentity(accounts, id) : void 0;
+    let activeFp = null;
+    if (!byId) {
+      const blob = await this.store.readCanonical();
+      activeFp = blob ? fingerprint(blob) : null;
+    }
+    return accounts.map((a) => toView(a, byId ? a.name === byId.name : activeFp !== null && a.fingerprint === activeFp));
+  }
+  current() {
+    const label = this.profile.peekLabel();
+    const accounts = this.meta.read().accounts;
+    const byId = this.matchByIdentity(accounts, this.profile.currentIdentity());
+    return { saved: byId ? toView(byId, true) : null, label };
+  }
+  async refreshStoredCredential(name, blob, fp) {
+    try {
+      await this.store.writeSaved(name, blob);
+    } catch {
+      return;
+    }
+    await this.meta.update((d) => {
+      const idx = d.accounts.findIndex((a) => a.name === name);
+      if (idx < 0) return;
+      const cur = d.accounts[idx];
+      d.accounts[idx] = {
+        ...cur,
+        fingerprint: fp,
+        oauthAccount: this.profile.peekOauthAccount() ?? cur.oauthAccount,
+        savedAt: this.now()
+      };
+    });
+  }
+  async autoSaveIfNewLogin() {
+    if (!this.store.isAvailable()) return null;
+    let blob = "";
+    try {
+      blob = await this.store.readCanonical();
+    } catch {
+      return null;
+    }
+    if (!blob) return null;
+    const fp = fingerprint(blob);
+    if (this.meta.read().accounts.some((a) => a.fingerprint === fp)) return null;
+    if (!this.profile.peekLabel()?.email) return null;
+    try {
+      return await this.saveCurrent();
+    } catch {
+      return null;
+    }
+  }
+  pickNext(exclude) {
+    return [...this.meta.read().accounts].filter((a) => a.name !== exclude).sort((a, b) => (b.savedAt || "").localeCompare(a.savedAt || "") || a.name.localeCompare(b.name))[0];
+  }
+  async reconcileOnChange() {
+    const nothing = { autoSaved: null, removed: null, switchedTo: null };
+    if (!this.store.isAvailable()) return nothing;
+    let blob = "";
+    try {
+      blob = await this.store.readCanonical();
+    } catch {
+      blob = "";
+    }
+    const loggedIn = !!this.profile.peekLabel();
+    if (!blob && !loggedIn) {
+      const behavior = this.config.logoutBehavior;
+      if (behavior === "none") return nothing;
+      const wasActive = this.meta.read().lastActive;
+      let removed = null;
+      if (behavior === "delete-switch" && wasActive && this.meta.read().accounts.some((a) => a.name === wasActive)) {
+        try {
+          await this.removeAccount(wasActive);
+          removed = wasActive;
+        } catch {
+          return nothing;
+        }
+      }
+      let switchedTo = null;
+      if (behavior === "delete-switch" || behavior === "keep-switch") {
+        const next = this.pickNext(wasActive);
+        if (next) {
+          try {
+            await this.switchTo(next.name);
+            switchedTo = next.name;
+          } catch {
+          }
+        }
+      }
+      await this.meta.update((d) => {
+        d.lastActive = switchedTo ?? void 0;
+      });
+      return { autoSaved: null, removed, switchedTo };
+    }
+    if (blob) {
+      const fpNow = fingerprint(blob);
+      const accounts = this.meta.read().accounts;
+      const known = this.matchByIdentity(accounts, this.profile.currentIdentity()) ?? accounts.find((a) => a.fingerprint === fpNow);
+      if (known) {
+        await this.meta.update((d) => {
+          d.lastActive = known.name;
+        });
+        if (known.fingerprint !== fpNow) 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;
+        });
+      }
+      return { autoSaved: saved, removed: null, switchedTo: null };
+    }
+    return nothing;
+  }
+};
+
+// src/app.ts
+function createManager(env) {
+  const platform = env?.platform ?? process.platform;
+  const home = env?.home ?? homedir();
+  const osUsername = env?.osUsername ?? userInfo().username;
+  const store = createCredentialStore({ platform, home, osUsername });
+  const meta = new MetadataStore({ path: join2(home, ".claude-profiles", "accounts.json") });
+  const profile = new ProfileFile({ path: join2(home, ".claude.json") });
+  const config = new ConfigStore({ path: join2(home, ".claude-profiles", "config.json") }).load();
+  return new AccountManager({ store, meta, profile, config });
+}
+
+// src/format.ts
+var SYMBOLS = { active: "\u25CF", ok: "\u2713", err: "\u2717", warn: "!", off: "\u25CB" };
+function formatRelative(iso, nowMs) {
+  const then = Date.parse(iso);
+  if (Number.isNaN(then)) return "\u2014";
+  const s = Math.max(0, Math.floor((nowMs - then) / 1e3));
+  if (s < 60) return "just now";
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  const d = Math.floor(h / 24);
+  if (d < 7) return `${d}d ago`;
+  const w = Math.floor(d / 7);
+  if (w < 5) return `${w}w ago`;
+  const mo = Math.floor(d / 30);
+  if (mo < 12) return `${mo}mo ago`;
+  return `${Math.floor(d / 365)}y ago`;
+}
+function pad(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+var ORG_MAX = 20;
+function formatList(views, nowMs, colors, opts = {}) {
+  const header = `  ${colors.bold("claudep")} ${colors.dim(`\xB7 ${views.length} account${views.length === 1 ? "" : "s"}`)}`;
+  if (views.length === 0) {
+    return [
+      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"),
+      colors.dim("  No saved accounts yet."),
+      colors.dim(`  \u2192 log in with ${colors.cyan("claude")}, then run ${colors.cyan("claudep list")}`)
+    ].join("\n");
+  }
+  const ordered = orderAccounts(views);
+  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 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 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) {
+    lines.push(
+      `  ${colors.yellow(SYMBOLS.warn)} ${colors.dim(`${opts.external} is active but not saved yet`)}`,
+      colors.dim("    run any command again to capture it")
+    );
+  }
+  if (ordered.length > 1) lines.push(colors.dim("  \u2192 claudep <n> to switch"));
+  return lines.join("\n").replace(/\n+$/, "");
+}
+
+// src/color.ts
+function makeColors(enabled) {
+  const wrap = (code) => (s) => enabled ? `\x1B[${code}m${s}\x1B[0m` : s;
+  return {
+    green: wrap("32"),
+    dim: wrap("2"),
+    bold: wrap("1"),
+    cyan: wrap("36"),
+    red: wrap("31"),
+    yellow: wrap("33")
+  };
+}
+
+// src/doctor.ts
+import { homedir as homedir2, userInfo as userInfo2, platform as osPlatform } from "os";
+import { join as join3 } from "path";
+async function runDoctor(deps, colors = makeColors(false)) {
+  const checks = [];
+  checks.push({
+    section: "System",
+    items: [
+      { ok: true, label: "platform", detail: `${deps.platform} (node ${process.version})` },
+      {
+        ok: deps.store.isAvailable(),
+        label: "credential backend",
+        detail: deps.store.isAvailable() ? "available" : "unavailable",
+        hint: "This OS/backend is not supported yet."
+      }
+    ]
+  });
+  const blob = await deps.store.readCanonical().catch(() => "");
+  const label = deps.profile.peekLabel();
+  checks.push({
+    section: "Claude login",
+    items: [
+      {
+        ok: !!blob,
+        label: "canonical slot",
+        detail: blob ? "present" : "missing",
+        hint: "run `claude` and log in once, then `claudep doctor`"
+      },
+      {
+        ok: !!label,
+        label: "active identity",
+        detail: label ? `${label.email}${label.organizationName ? ` \xB7 ${label.organizationName}` : ""}` : "unknown",
+        hint: "wait for the session to initialize"
+      }
+    ]
+  });
+  const accounts = deps.meta.read().accounts;
+  checks.push({
+    section: "Store",
+    items: [
+      { ok: true, label: "config", detail: `logout=${deps.config.logoutBehavior}` },
+      { ok: true, label: "accounts", detail: `${accounts.length} saved` }
+    ]
+  });
+  const lines = [
+    `  ${colors.bold("claudep")} ${colors.dim("\xB7 doctor")}`,
+    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")
+  ];
+  let ok = true;
+  let issues = 0;
+  for (const group of checks) {
+    lines.push(`  ${colors.bold(group.section)}`);
+    for (const c of group.items) {
+      const sym = c.ok ? colors.green(SYMBOLS.ok) : colors.red(SYMBOLS.err);
+      if (!c.ok) {
+        ok = false;
+        issues++;
+      }
+      lines.push(`    ${sym} ${c.label.padEnd(18)} ${colors.dim(c.detail)}`);
+      if (!c.ok && c.hint) lines.push(colors.dim(`      \u2192 ${c.hint}`));
+    }
+  }
+  lines.push("");
+  lines.push(
+    ok ? `  ${colors.green(SYMBOLS.ok)} All checks passed` : `  ${colors.red(SYMBOLS.err)} ${issues} issue${issues === 1 ? "" : "s"} found`
+  );
+  return { ok, report: lines.join("\n") };
+}
+function buildDoctorDeps(env) {
+  const platform = env?.platform ?? osPlatform();
+  const home = env?.home ?? homedir2();
+  const osUsername = env?.osUsername ?? userInfo2().username;
+  return {
+    store: createCredentialStore({ platform, home, osUsername }),
+    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
+  };
+}
+
+// package.json
+var package_default = {
+  name: "claude-switcher-account",
+  version: "2.1.0",
+  description: "Switch between multiple Claude Code accounts from the terminal \u2014 save every login, swap in one command, no re-authenticating. macOS, Linux, Windows.",
+  keywords: [
+    "claude",
+    "claude-code",
+    "claude-code-cli",
+    "anthropic",
+    "account-switcher",
+    "switch-account",
+    "multiple-accounts",
+    "multi-account",
+    "login-switcher",
+    "profile-manager",
+    "credentials",
+    "keychain",
+    "cli",
+    "developer-tools"
+  ],
+  homepage: "https://github.com/khainguyenhm-itr/claude-switcher-account#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/khainguyenhm-itr/claude-switcher-account.git"
+  },
+  bugs: {
+    url: "https://github.com/khainguyenhm-itr/claude-switcher-account/issues"
+  },
+  license: "MIT",
+  author: "khainguyenhm-itr",
+  type: "module",
+  bin: {
+    claudep: "dist/bin.js"
+  },
+  files: [
+    "dist",
+    "scripts/postinstall.mjs"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  scripts: {
+    build: "tsup src/bin.ts --format esm --target node18 --clean",
+    prepare: "npm run build",
+    postinstall: "node scripts/postinstall.mjs",
+    prepublishOnly: "npm run typecheck && npm test",
+    test: "vitest run --coverage",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit"
+  },
+  dependencies: {
+    commander: "^15.0.0"
+  },
+  devDependencies: {
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.1.10",
+    tsup: "^8.5.1",
+    typescript: "^5.6.0",
+    vitest: "^4.1.10"
+  }
+};
+
+// src/version.ts
+var PKG_NAME = package_default.name;
+var VERSION = package_default.version;
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => Number(n) || 0);
+  const pb = b.split(".").map((n) => Number(n) || 0);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+async function checkForUpdate(current, pkg = PKG_NAME, fetchFn = fetch) {
+  try {
+    const res = await fetchFn(`https://registry.npmjs.org/${pkg}/latest`, { headers: { accept: "application/json" } });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data.version) return null;
+    return { current, latest: data.version, isNewer: compareVersions(data.version, current) > 0 };
+  } catch {
+    return null;
+  }
+}
+function formatVersion(info, colors = makeColors(false)) {
+  const head = `  ${colors.bold(`claudep ${VERSION}`)}  ${colors.dim(`\xB7 npm: ${PKG_NAME}`)}`;
+  const rule = 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");
+  let result;
+  if (!info) result = colors.dim("  \xB7 could not check for updates");
+  else if (info.isNewer)
+    result = `  ${colors.yellow("\u25B2")} v${info.latest} available
+${colors.dim(`    update: ${colors.cyan(`npm i -g ${PKG_NAME}`)}`)}`;
+  else result = `  ${colors.green("\u2713")} up to date`;
+  return [head, rule, result].join("\n");
+}
+
+// src/menu.ts
+import { createInterface } from "readline/promises";
+function pad2(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function buildMenuChoices(accounts) {
+  const ordered = orderAccounts(accounts);
+  if (!ordered.length) return [];
+  const emailW = Math.max(...ordered.map((a) => a.email.length));
+  return ordered.map((a, i) => {
+    const mark = a.active ? SYMBOLS.active : " ";
+    const when = a.active ? "active" : formatRelative(a.savedAt, Date.now());
+    const org = a.organizationName ? `  ${a.organizationName}` : "";
+    return {
+      label: `${i + 1}  ${mark} ${pad2(a.email, emailW)}${org}  ${when}`,
+      action: { type: "switch", name: a.name }
+    };
+  });
+}
+function accountChoices(views) {
+  return orderAccounts(views).map((v) => ({ label: v.email, action: { type: "switch", name: v.name } }));
+}
+async function dispatchMenu(manager, action, io) {
+  switch (action.type) {
+    case "quit":
+      return;
+    case "switch":
+      try {
+        await manager.switchTo(action.name);
+        io.out(`${SYMBOLS.ok} Now using ${action.name}`);
+      } catch (e) {
+        io.out(`${SYMBOLS.err} ${e.message}`);
+      }
+      return;
+    case "doctor":
+      io.out(await io.doctor());
+      return;
+    case "rename": {
+      const views = await manager.listAccounts();
+      if (!views.length) {
+        io.out("No saved accounts.");
+        return;
+      }
+      const choice = await io.pick("Rename which account?", accountChoices(views));
+      if (!choice || choice.action.type !== "switch") return;
+      const oldName = choice.action.name;
+      const newName = (await io.ask(`New name for ${oldName}: `)).trim();
+      if (!newName) {
+        io.out("Cancelled.");
+        return;
+      }
+      try {
+        await manager.renameAccount(oldName, newName);
+        io.out(`${SYMBOLS.ok} Renamed ${oldName} \u2192 ${newName}`);
+      } catch (e) {
+        io.out(`${SYMBOLS.err} ${e.message}`);
+      }
+      return;
+    }
+  }
+}
+async function runMenu(manager, io) {
+  try {
+    await manager.reconcileOnChange();
+  } catch {
+  }
+  const accounts = await manager.listAccounts();
+  const choice = await io.pick(`claudep \xB7 ${accounts.length} account${accounts.length === 1 ? "" : "s"}`, buildMenuChoices(accounts));
+  if (!choice) return;
+  await dispatchMenu(manager, choice.action, io);
+}
+var DIVIDER = "\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";
+function interactiveSelect(title, choices) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const colors = makeColors(stdout.isTTY === true && !process.env.NO_COLOR);
+  const rename = { label: "rename", action: { type: "rename" } };
+  const doctor = { label: "doctor", action: { type: "doctor" } };
+  return new Promise((resolve) => {
+    if (!stdin.isTTY) {
+      resolve(null);
+      return;
+    }
+    let selected = Math.max(0, choices.findIndex((c) => c.label.includes(SYMBOLS.active)));
+    const header = `  ${colors.bold("claudep")} ${colors.dim(title.replace(/^claudep\s*/, ""))}`;
+    const footer = `  ${colors.cyan("r")} ${colors.dim("rename")}   ${colors.cyan("d")} ${colors.dim("doctor")}   ${colors.cyan("q")} ${colors.dim("quit")}`;
+    const hint = colors.dim("  \u2191/\u2193 move \xB7 \u21B5 switch \xB7 1-9 pick \xB7 q quit");
+    const chrome = 4;
+    stdout.write(`${header}
+${colors.dim(`  ${DIVIDER}`)}
+`);
+    if (!choices.length) stdout.write(colors.dim("  (no saved accounts yet)\n"));
+    const render = (first) => {
+      if (!first) stdout.write(`\x1B[${choices.length + chrome}A`);
+      for (let i = 0; i < choices.length; i++) {
+        const active = i === selected;
+        const line = active ? `${colors.cyan("\u276F")} ${choices[i].label}` : `  ${choices[i].label}`;
+        stdout.write(`\x1B[2K\r${line}
+`);
+      }
+      stdout.write(`\x1B[2K\r${colors.dim(`  ${DIVIDER}`)}
+`);
+      stdout.write(`\x1B[2K\r${footer}
+`);
+      stdout.write(`\x1B[2K\r
+`);
+      stdout.write(`\x1B[2K\r${hint}
+`);
+    };
+    render(true);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    const move = (delta) => {
+      if (!choices.length) return;
+      selected = (selected + delta + choices.length) % choices.length;
+      render(false);
+    };
+    const finish = (result) => {
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      resolve(result);
+    };
+    const onData = (data) => {
+      const mouse = /\x1b\[<(\d+);\d+;\d+[Mm]/.exec(data);
+      if (mouse) {
+        const btn = Number(mouse[1]);
+        if (btn === 64) move(-1);
+        else if (btn === 65) move(1);
+        return;
+      }
+      if (data === "\x1B[A" || data === "\x1BOA" || data === "k") return move(-1);
+      if (data === "\x1B[B" || data === "\x1BOB" || data === "j") return move(1);
+      if (data === "r") return finish(rename);
+      if (data === "d") return finish(doctor);
+      if (data === "\r" || data === "\n") return finish(choices[selected] ?? null);
+      if (data === "" || data === "q" || data === "\x1B") return finish(null);
+      if (data.length === 1 && data >= "1" && data <= "9") {
+        const i = Number(data) - 1;
+        if (i < choices.length) finish(choices[i]);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function runInteractiveMenu(manager, out) {
+  const io = {
+    pick: (title, choices) => interactiveSelect(title, choices),
+    ask: async (q) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const a = await rl.question(q);
+      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
+  };
+  await runMenu(manager, io);
+}
+
+// src/daemon.ts
+import { watchFile, unwatchFile } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+function formatReconcileLog(r) {
+  if (r.autoSaved) return `captured new login ${r.autoSaved.email}`;
+  if (r.removed && r.switchedTo) return `logged out of ${r.removed} \u2014 switched to ${r.switchedTo}`;
+  if (r.switchedTo) return `logged out \u2014 switched to ${r.switchedTo}`;
+  if (r.removed) return `logged out \u2014 removed ${r.removed}`;
+  return null;
+}
+async function reconcileAndLog(manager, log) {
+  try {
+    const r = await manager.reconcileOnChange();
+    const msg = formatReconcileLog(r);
+    if (msg) log(`[claudep] ${msg}`);
+  } catch {
+  }
+}
+function startDaemon(manager, opts = {}) {
+  const path = opts.watchPath ?? join4(homedir3(), ".claude.json");
+  const interval = opts.intervalMs ?? 1e3;
+  const log = opts.log ?? ((s) => console.log(s));
+  const subscribe = opts.watch ?? defaultWatch;
+  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));
+}
+function defaultWatch(path, intervalMs, onChange) {
+  const listener = () => onChange();
+  watchFile(path, { interval: intervalMs }, listener);
+  return () => unwatchFile(path, listener);
+}
+
+// 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 { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join5 } from "path";
+var execFileP2 = promisify2(execFile2);
+var LABEL = "com.claude-switcher-account.daemon";
+var WIN_TASK = "claude-switcher-account";
+var UNIT = "claude-switcher-account.service";
+var LEGACY_LABEL = "com.claude-login-switcher.daemon";
+var LEGACY_WIN_TASK = "claude-login-switcher";
+var LEGACY_UNIT = "claude-login-switcher.service";
+var defaultExec2 = async (file, args) => {
+  await execFileP2(file, args);
+};
+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">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${p.nodePath}</string>
+    <string>${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>
+</dict>
+</plist>
+`;
+}
+function systemdUnit(p) {
+  return `[Unit]
+Description=claude-switcher-account instant login watcher
+
+[Service]
+ExecStart=${p.nodePath} ${p.binPath} daemon run
+Restart=always
+StandardOutput=append:${p.logPath}
+StandardError=append:${p.logPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function windowsCreateArgs(p) {
+  return ["/Create", "/F", "/SC", "ONLOGON", "/TN", WIN_TASK, "/TR", `"${p.nodePath}" "${p.binPath}" daemon run`];
+}
+function plistPath(home = homedir4()) {
+  return join5(home, "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function systemdPath(home = homedir4()) {
+  return join5(home, ".config", "systemd", "user", UNIT);
+}
+function legacyPlistPath(home = homedir4()) {
+  return join5(home, "Library", "LaunchAgents", `${LEGACY_LABEL}.plist`);
+}
+function legacySystemdPath(home = homedir4()) {
+  return join5(home, ".config", "systemd", "user", LEGACY_UNIT);
+}
+function autostartInstalled(platform, home = homedir4()) {
+  if (platform === "darwin") return existsSync3(plistPath(home)) || existsSync3(legacyPlistPath(home));
+  if (platform === "linux") return existsSync3(systemdPath(home)) || existsSync3(legacySystemdPath(home));
+  return false;
+}
+function writeFile(path, contents) {
+  mkdirSync4(dirname4(path), { recursive: true });
+  writeFileSync4(path, contents);
+}
+async function removeLegacyAutostart(platform, home = homedir4(), exec = defaultExec2) {
+  if (platform === "darwin") {
+    const plist = legacyPlistPath(home);
+    await exec("launchctl", ["unload", plist]).catch(() => void 0);
+    if (existsSync3(plist)) rmSync2(plist, { force: true });
+    return;
+  }
+  if (platform === "linux") {
+    await exec("systemctl", ["--user", "disable", "--now", LEGACY_UNIT]).catch(() => void 0);
+    const unit = legacySystemdPath(home);
+    if (existsSync3(unit)) rmSync2(unit, { force: true });
+    return;
+  }
+  if (platform === "win32") {
+    await exec("schtasks", ["/Delete", "/F", "/TN", LEGACY_WIN_TASK]).catch(() => void 0);
+  }
+}
+async function installAutostart(platform, paths, home = homedir4(), exec = defaultExec2) {
+  await removeLegacyAutostart(platform, home, exec);
+  if (platform === "darwin") {
+    const plist = plistPath(home);
+    writeFile(plist, launchdPlist(paths));
+    await exec("launchctl", ["unload", plist]).catch(() => void 0);
+    await exec("launchctl", ["load", "-w", plist]);
+    return `launchd agent installed at ${plist}`;
+  }
+  if (platform === "linux") {
+    const unit = systemdPath(home);
+    writeFile(unit, systemdUnit(paths));
+    await exec("systemctl", ["--user", "daemon-reload"]);
+    await exec("systemctl", ["--user", "enable", "--now", UNIT]);
+    return `systemd user service installed at ${unit}`;
+  }
+  if (platform === "win32") {
+    await exec("schtasks", windowsCreateArgs(paths));
+    return `Task Scheduler task '${WIN_TASK}' created (runs at logon)`;
+  }
+  throw new Error(`Autostart not supported on ${platform}.`);
+}
+async function uninstallAutostart(platform, home = homedir4(), exec = defaultExec2) {
+  await removeLegacyAutostart(platform, home, exec);
+  if (platform === "darwin") {
+    const plist = plistPath(home);
+    await exec("launchctl", ["unload", plist]).catch(() => void 0);
+    if (existsSync3(plist)) rmSync2(plist, { force: true });
+    return "launchd agent removed";
+  }
+  if (platform === "linux") {
+    await exec("systemctl", ["--user", "disable", "--now", UNIT]).catch(() => void 0);
+    const unit = systemdPath(home);
+    if (existsSync3(unit)) rmSync2(unit, { force: true });
+    return "systemd user service removed";
+  }
+  if (platform === "win32") {
+    await exec("schtasks", ["/Delete", "/F", "/TN", WIN_TASK]);
+    return `Task Scheduler task '${WIN_TASK}' removed`;
+  }
+  throw new Error(`Autostart not supported on ${platform}.`);
+}
+
+// src/cli.ts
+async function defaultConfirm(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+  rl.close();
+  return answer === "y" || answer === "yes";
+}
+function buildProgram(deps = {}) {
+  const out = deps.out ?? ((s) => console.log(s));
+  const now = deps.now ?? (() => Date.now());
+  const confirm = deps.confirm ?? defaultConfirm;
+  const manager = () => deps.manager ?? createManager();
+  const checkUpdate = deps.checkUpdate ?? ((current) => checkForUpdate(current));
+  const runMenu2 = deps.menu ?? runInteractiveMenu;
+  const useColor = process.stdout.isTTY === true && !process.env.NO_COLOR;
+  const colors = makeColors(useColor);
+  const ok = (s) => `  ${colors.green(SYMBOLS.ok)} ${s}`;
+  const err = (s) => `  ${colors.red(SYMBOLS.err)} ${s}`;
+  const note = (s) => colors.dim(`    ${s}`);
+  const listHint = `run ${colors.cyan("claudep list")} to see saved accounts`;
+  const program2 = new Command();
+  program2.name("claudep").description("Switch between Claude Code logins").version(VERSION).exitOverride();
+  async function reconcileFirst(mgr) {
+    try {
+      await mgr.reconcileOnChange();
+    } catch {
+    }
+  }
+  async function switchByArg(mgr, arg, bareNumeric) {
+    const isNum = /^\d+$/.test(arg);
+    if (bareNumeric && !isNum) {
+      out(err(`Unknown account '${arg}'`) + "\n" + note(listHint));
+      process.exitCode = 1;
+      return;
+    }
+    const name = isNum ? await mgr.resolveByIndex(Number(arg)) : arg;
+    if (!name) {
+      out(err(`No account #${arg}`) + "\n" + note(listHint));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      await mgr.switchTo(name);
+      out(ok(`Now using ${name}`) + "\n" + note("restart running claude sessions to apply"));
+    } catch (e) {
+      out(err(e.message) + "\n" + note(listHint));
+      process.exitCode = 1;
+    }
+  }
+  program2.argument("[target]", "account number to switch to").action(async (target) => {
+    if (target !== void 0) {
+      const mgr = manager();
+      await reconcileFirst(mgr);
+      await switchByArg(mgr, target, true);
+      return;
+    }
+    if (!deps.menu && (!process.stdin.isTTY || !process.stdout.isTTY)) {
+      out(program2.helpInformation());
+      return;
+    }
+    await runMenu2(manager(), out);
+  });
+  program2.command("version").description("Show the version and check npm for a newer one").action(async () => {
+    out(formatVersion(await checkUpdate(VERSION), colors));
+  });
+  program2.command("list").aliases(["ls", "status", "current"]).description("List saved accounts").option("--json", "machine-readable output").action(async (opts) => {
+    const mgr = manager();
+    await reconcileFirst(mgr);
+    const views = await mgr.listAccounts();
+    if (opts.json) {
+      out(JSON.stringify(views, null, 2));
+      return;
+    }
+    const cur = mgr.current();
+    const external = !cur.saved && cur.label ? cur.label.email : void 0;
+    out(formatList(views, now(), colors, { external }));
+  });
+  program2.command("switch <target>").alias("use").description("Make an account the active login (by name or number)").action(async (target) => {
+    const mgr = manager();
+    await reconcileFirst(mgr);
+    await switchByArg(mgr, target, false);
+  });
+  program2.command("remove <target>").alias("rm").description("Forget a saved account (by name or number)").option("-y, --yes", "skip confirmation").action(async (target, opts) => {
+    const mgr = manager();
+    await reconcileFirst(mgr);
+    const name = /^\d+$/.test(target) ? await mgr.resolveByIndex(Number(target)) : target;
+    if (!name) {
+      out(err(`No account #${target}`) + "\n" + note(listHint));
+      process.exitCode = 1;
+      return;
+    }
+    if (!opts.yes) {
+      const yes = await confirm(`Remove ${name}? This deletes its stored credential.`);
+      if (!yes) {
+        out("  Cancelled.");
+        return;
+      }
+    }
+    await mgr.removeAccount(name);
+    out(ok(`Removed ${name}`));
+  });
+  program2.command("rename <old> <new>").description("Relabel a saved account").action(async (oldName, newName) => {
+    const mgr = manager();
+    await reconcileFirst(mgr);
+    try {
+      await mgr.renameAccount(oldName, newName);
+      out(ok(`Renamed ${oldName} ${colors.dim("\u2192")} ${newName}`));
+    } catch (e) {
+      out(err(e.message));
+      process.exitCode = 1;
+    }
+  });
+  program2.command("doctor").description("Diagnose credential path, config, and store").action(async () => {
+    const { ok: healthy, report } = await runDoctor(buildDoctorDeps(), colors);
+    out(report);
+    if (!healthy) process.exitCode = 1;
+  });
+  const daemonPaths = () => ({
+    nodePath: process.execPath,
+    binPath: process.argv[1] ?? "",
+    logPath: join6(homedir5(), ".claude-profiles", "daemon.log")
+  });
+  const daemon = program2.command("daemon").description("Background watcher for instant capture/switch");
+  daemon.command("run").description("Run the watcher in the foreground (used by the OS autostart service)").action(async () => {
+    startDaemon(manager(), { log: out });
+    await new Promise(() => {
+    });
+  });
+  daemon.command("install").description("Install autostart so the watcher runs on login, and capture the current login now").action(async () => {
+    try {
+      const msg = await installAutostart(process.platform, daemonPaths());
+      await manager().reconcileOnChange().catch(() => void 0);
+      out(ok(msg) + "\n" + note("instant capture is on \u2014 new logins are saved automatically"));
+    } catch (e) {
+      out(err(e.message));
+      process.exitCode = 1;
+    }
+  });
+  daemon.command("uninstall").description("Remove the autostart watcher").action(async () => {
+    try {
+      out(ok(await uninstallAutostart(process.platform)));
+    } catch (e) {
+      out(err(e.message));
+      process.exitCode = 1;
+    }
+  });
+  daemon.command("status").description("Show whether the autostart watcher is installed").action(() => {
+    const on = autostartInstalled(process.platform);
+    out(
+      on ? `  ${colors.green(SYMBOLS.active)} daemon autostart installed` : `  ${colors.dim(`${SYMBOLS.off} daemon not installed`)}
+` + note(`run: ${colors.cyan("claudep daemon install")}`)
+    );
+  });
+  return program2;
+}
+
+// src/bin.ts
+var program = buildProgram();
+try {
+  await program.parseAsync(process.argv);
+} catch (err) {
+  const code = err.exitCode ?? 1;
+  process.exit(code);
+}