ccm-account-manager 1.13.0

package/src/memory.js

@@ -0,0 +1,111 @@
+// Shared auto-memory: Claude Code keeps learned facts per project inside each
+// config dir (projects/<slug>/memory). ccm pools them in ~/.ccm/shared/memory
+// and junction-links each profile's project memory to the pool, so what
+// Claude learns about a repo on one account is known on every account.
+// The memory follows the repo, not the account.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { SHARED_DIR, DEFAULT_CLAUDE_DIR } from './paths.js';
+
+export const SHARED_MEMORY_DIR = path.join(SHARED_DIR, 'memory');
+
+// Copy files from src that are missing in dst or newer than dst's copy.
+function mergeInto(srcDir, dstDir) {
+  fs.mkdirSync(dstDir, { recursive: true });
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const s = path.join(srcDir, entry.name);
+    const d = path.join(dstDir, entry.name);
+    if (entry.isDirectory()) { mergeInto(s, d); continue; }
+    if (!entry.isFile()) continue;
+    let dst;
+    try { dst = fs.statSync(d); } catch {}
+    if (!dst || fs.statSync(s).mtimeMs > dst.mtimeMs) fs.copyFileSync(s, d);
+  }
+}
+
+// One-time-per-project seeding from the untouched default ~/.claude, so the
+// pool starts with what the default install already learned. ~/.claude itself
+// is never linked or modified.
+export function seedFromDefault() {
+  let slugs = [];
+  try { slugs = fs.readdirSync(path.join(DEFAULT_CLAUDE_DIR, 'projects')); } catch { return; }
+  for (const slug of slugs) {
+    const src = path.join(DEFAULT_CLAUDE_DIR, 'projects', slug, 'memory');
+    const target = path.join(SHARED_MEMORY_DIR, slug);
+    if (fs.existsSync(src) && !fs.existsSync(target)) mergeInto(src, target);
+  }
+}
+
+// Sweep a profile's project folders at launch. mode 'shared': local memory is
+// merged into the pool (original kept as memory.bak) and replaced with a
+// junction; projects with pooled memory get linked as soon as the profile has
+// visited them. mode 'private': junctions are replaced with a real copy of
+// the pool — the profile's memory forks from there.
+export function syncMemory(dir, mode = 'shared') {
+  const warnings = [];
+  const projects = path.join(dir, 'projects');
+  let slugs = [];
+  try { slugs = fs.readdirSync(projects); } catch { return warnings; }
+  for (const slug of slugs) {
+    const slugDir = path.join(projects, slug);
+    try { if (!fs.lstatSync(slugDir).isDirectory()) continue; } catch { continue; }
+    const local = path.join(slugDir, 'memory');
+    const target = path.join(SHARED_MEMORY_DIR, slug);
+    let st = null;
+    try { st = fs.lstatSync(local); } catch {}
+
+    if (mode === 'private') {
+      if (st?.isSymbolicLink()) {
+        try {
+          fs.unlinkSync(local);
+          if (fs.existsSync(target)) fs.cpSync(target, local, { recursive: true });
+        } catch (e) { warnings.push(`memory: could not detach ${slug} (${e.code ?? e.message})`); }
+      }
+      continue;
+    }
+
+    if (st?.isSymbolicLink()) continue; // already pooled
+    if (st) {
+      // real local memory → merge into the pool, keep the original as a backup
+      try {
+        mergeInto(local, target);
+        const bak = path.join(slugDir, 'memory.bak');
+        fs.rmSync(bak, { recursive: true, force: true });
+        fs.renameSync(local, bak);
+      } catch (e) {
+        warnings.push(`memory: could not pool ${slug} (${e.code ?? e.message})`);
+        continue;
+      }
+    } else if (!fs.existsSync(target)) {
+      continue; // no memory anywhere for this project yet
+    }
+    try {
+      fs.symlinkSync(target, local, 'junction');
+    } catch (e) {
+      warnings.push(`memory: could not junction ${slug} (${e.code ?? e.message})`);
+      const bak = path.join(slugDir, 'memory.bak');
+      if (!fs.existsSync(local) && fs.existsSync(bak)) {
+        try { fs.renameSync(bak, local); } catch {}
+      }
+    }
+  }
+  return warnings;
+}
+
+// Doctor/status helper: how many of this profile's projects are pooled.
+export function memoryStatus(dir) {
+  const projects = path.join(dir, 'projects');
+  let linked = 0;
+  let local = 0;
+  let slugs = [];
+  try { slugs = fs.readdirSync(projects); } catch {}
+  for (const slug of slugs) {
+    try {
+      const st = fs.lstatSync(path.join(projects, slug, 'memory'));
+      if (st.isSymbolicLink()) linked++;
+      else if (st.isDirectory()) local++;
+    } catch {}
+  }
+  return { linked, local };
+}

package/src/notify.js

@@ -0,0 +1,62 @@
+import { spawn } from 'node:child_process';
+import { loadConfig, saveConfig } from './registry.js';
+
+// Usage buckets: 0 = fine (<80), 1 = warning (80-94), 2 = critical (>=95).
+// A toast fires only when a window crosses UP into a bucket, or drops back to
+// 0 from >=1 (quota reset → "fresh again"). No repeats while a bucket holds.
+export function bucketFor(percent) {
+  if (percent >= 95) return 2;
+  if (percent >= 80) return 1;
+  return 0;
+}
+
+// Compare two usage caches → notification events per profile.
+export function diffNotifications(prev, next) {
+  const events = [];
+  for (const [name, entry] of Object.entries(next ?? {})) {
+    if (!entry?.windows?.length) continue;
+    const prevWindows = new Map((prev?.[name]?.windows ?? []).map((w) => [w.label, w]));
+    const warns = [];
+    let fresh = false;
+    for (const w of entry.windows) {
+      const pb = bucketFor(prevWindows.get(w.label)?.percent ?? 0);
+      const nb = bucketFor(w.percent);
+      if (nb > pb) warns.push({ label: w.label, percent: Math.round(w.percent), resetsAt: w.resetsAt, bucket: nb });
+      else if (pb >= 1 && nb === 0) fresh = true;
+    }
+    if (warns.length) events.push({ profile: name, kind: 'warn', windows: warns });
+    else if (fresh) events.push({ profile: name, kind: 'fresh', windows: [] });
+  }
+  return events;
+}
+
+export function notificationsEnabled() {
+  return loadConfig().notifications?.enabled !== false;
+}
+
+export function setNotificationsEnabled(enabled) {
+  const cfg = loadConfig();
+  cfg.notifications = { ...(cfg.notifications ?? {}), enabled };
+  saveConfig(cfg);
+}
+
+// Windows toast via the WinRT API from PowerShell. Uses PowerShell's own
+// AppUserModelID so no app registration is needed. Fire-and-forget.
+export function sendToast(title, body) {
+  if (process.platform !== 'win32') {
+    console.error(`[notify] ${title}: ${body}`);
+    return;
+  }
+  const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  const xml = `<toast><visual><binding template="ToastGeneric"><text>${esc(title)}</text><text>${esc(body)}</text></binding></visual></toast>`;
+  const script = [
+    '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null',
+    '[Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom, ContentType = WindowsRuntime] | Out-Null',
+    '$xml = New-Object Windows.Data.Xml.Dom.XmlDocument',
+    `$xml.LoadXml('${xml.replace(/'/g, "''")}')`,
+    "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe').Show([Windows.UI.Notifications.ToastNotification]::new($xml))",
+  ].join('; ');
+  spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', script], {
+    detached: true, stdio: 'ignore', windowsHide: true,
+  }).unref();
+}

package/src/oauth.js

@@ -0,0 +1,150 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { profileDir, DEFAULT_CLAUDE_DIR, HOME_CLAUDE_JSON } from './paths.js';
+import { readJson } from './util.js';
+import { listProfiles } from './registry.js';
+
+// Claude Code's OAuth client — CLIENT_ID confirmed from the CLI binary
+// (CLIENT_ID:"9d1c250a…"). The token endpoint is api.anthropic.com, verified
+// by probing: it returns invalid_grant for a bad token (right endpoint) where
+// claude.com/v1/oauth/token is a plain 405. ccm refreshes a profile's access
+// token the same way Claude Code does, so the dashboard is accurate even for
+// accounts that aren't currently running.
+const TOKEN_URL = 'https://api.anthropic.com/v1/oauth/token';
+const CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+const REFRESH_SKEW_MS = 60_000; // refresh a token about to expire, not just an expired one
+
+function credsPath(name) {
+  return path.join(profileDir(name), '.credentials.json');
+}
+
+export function readOauth(name) {
+  return readJson(credsPath(name), null)?.claudeAiOauth ?? null;
+}
+
+export function isExpired(oauth, now = Date.now()) {
+  return !oauth?.expiresAt || oauth.expiresAt <= now + REFRESH_SKEW_MS;
+}
+
+// Whether a profile can start a session without dead-ending at Claude's login
+// screen. 'logged-out' means the stored token is empty or unusable — the classic
+// symptom being that the same account was live elsewhere, the (single-use)
+// refresh token rotated, and Claude Code cleared these credentials on its next
+// failed refresh. A present-but-expired token with a refresh token is still 'ok':
+// Claude Code refreshes it on launch (and if THAT fails, the next check catches it).
+export function authState(name) {
+  const oauth = readOauth(name);
+  const hasAccess = !!oauth?.accessToken;
+  const hasRefresh = !!oauth?.refreshToken;
+  if (!hasAccess) return 'logged-out';
+  if (isExpired(oauth) && !hasRefresh) return 'logged-out';
+  return 'ok';
+}
+
+// Persist rotated credentials without disturbing the rest of the file
+// (mcpOAuth etc.). Write-then-rename so a crash can't leave a half-written
+// credentials file that would log the account out.
+function persist(name, oauth) {
+  const file = credsPath(name);
+  const full = readJson(file, {}) ?? {};
+  full.claudeAiOauth = oauth;
+  const tmp = file + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(full, null, 2));
+  fs.renameSync(tmp, file);
+}
+
+// Exchange the refresh token for a fresh access token. Anthropic rotates
+// refresh tokens, so the new one is persisted immediately. Returns the new
+// oauth object, or { error } on failure (caller falls back gracefully).
+export async function refreshToken(name) {
+  const oauth = readOauth(name);
+  if (!oauth?.refreshToken) return { error: 'no-refresh-token' };
+  try {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), 10_000);
+    const res = await fetch(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: ctrl.signal,
+    });
+    clearTimeout(timer);
+    if (!res.ok) return { error: res.status === 400 || res.status === 401 ? 'refresh-rejected' : `refresh-http-${res.status}` };
+    const data = await res.json();
+    if (!data.access_token) return { error: 'refresh-malformed' };
+    const next = {
+      ...oauth,
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token ?? oauth.refreshToken,
+      expiresAt: Date.now() + (data.expires_in ?? 3600) * 1000,
+      scopes: data.scope ? data.scope.split(' ') : oauth.scopes,
+    };
+    persist(name, next);
+    return next;
+  } catch (e) {
+    return { error: e.name === 'AbortError' ? 'refresh-timeout' : 'refresh-network' };
+  }
+}
+
+// A non-expired oauth for the profile, refreshing if needed.
+// Returns { oauth } or { error }.
+export async function validOauth(name) {
+  const oauth = readOauth(name);
+  if (!oauth?.accessToken) return { error: 'no-credentials' };
+  if (!isExpired(oauth)) return { oauth };
+  if (!oauth.refreshToken) return { error: 'token-expired' };
+  const refreshed = await refreshToken(name);
+  return refreshed.error ? { error: refreshed.error } : { oauth: refreshed };
+}
+
+// Which Anthropic account a credential source belongs to (uuid preferred).
+// The default ~/.claude keeps oauthAccount in ~/.claude.json (home level);
+// profiles keep it inside their own config dir.
+function accountIdOf(dir) {
+  const jsonPath = dir === DEFAULT_CLAUDE_DIR ? HOME_CLAUDE_JSON : path.join(dir, '.claude.json');
+  const a = readJson(jsonPath, null)?.oauthAccount;
+  return a?.accountUuid ?? a?.emailAddress ?? null;
+}
+
+function credentialSources() {
+  return [
+    ...listProfiles().map((p) => ({ label: p.name, dir: profileDir(p.name) })),
+    { label: '~/.claude', dir: DEFAULT_CLAUDE_DIR },
+  ];
+}
+
+// When a profile is logged out, report the SAME Anthropic account still valid in
+// another source on this machine (another profile, or the ~/.claude default).
+// That other login is usually what rotated the shared refresh token out from
+// under this profile — surfacing it turns a mystery ("why is my logged-in
+// account asking me to log in?") into an explanation. Returns its label or null.
+export function sameAccountValidSource(name) {
+  const wantId = accountIdOf(profileDir(name));
+  if (!wantId) return null;
+  for (const src of credentialSources()) {
+    if (src.dir === profileDir(name) || accountIdOf(src.dir) !== wantId) continue;
+    const o = readJson(path.join(src.dir, '.credentials.json'), null)?.claudeAiOauth;
+    if (o?.accessToken && !isExpired(o)) return src.label;
+  }
+  return null;
+}
+
+// An access token that can query this profile's usage. Prefers the profile's
+// own token (refreshing if needed). If that can't be revived, borrows a
+// currently-valid token from any other source logged into the SAME account
+// (another profile, or the ~/.claude default) — usage is per-account, so the
+// number is identical. Borrowed tokens are used read-only: never refreshed or
+// rotated, so a running ~/.claude session isn't disturbed.
+export async function resolveToken(name) {
+  const own = await validOauth(name);
+  if (own.oauth) return { accessToken: own.oauth.accessToken };
+  const wantId = accountIdOf(profileDir(name));
+  if (wantId) {
+    for (const src of credentialSources()) {
+      if (src.dir === profileDir(name) || accountIdOf(src.dir) !== wantId) continue;
+      const o = readJson(path.join(src.dir, '.credentials.json'), null)?.claudeAiOauth;
+      if (o?.accessToken && !isExpired(o)) return { accessToken: o.accessToken, borrowedFrom: src.label };
+    }
+  }
+  return { error: own.error };
+}

package/src/paths.js

@@ -0,0 +1,33 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export const CCM_HOME = process.env.CCM_HOME || path.join(os.homedir(), '.ccm');
+export const PROFILES_DIR = path.join(CCM_HOME, 'profiles');
+export const SHARED_DIR = path.join(CCM_HOME, 'shared');
+export const CONFIG_PATH = path.join(CCM_HOME, 'config.json');
+export const CACHE_DIR = path.join(CCM_HOME, 'cache');
+export const USAGE_CACHE = path.join(CACHE_DIR, 'usage.json');
+
+export const DEFAULT_CLAUDE_DIR = process.env.CCM_CLAUDE_DIR || path.join(os.homedir(), '.claude');
+export const HOME_CLAUDE_JSON = path.join(os.homedir(), '.claude.json');
+
+export const OVERRIDES_DIR = path.join(CCM_HOME, 'overrides');
+export const SHARED_MCP = path.join(SHARED_DIR, 'mcp.json');
+export const NOTIFY_STATE = path.join(CACHE_DIR, 'notify-state.json');
+export const MCP_RECORD_DIR = path.join(CACHE_DIR, 'mcp-injected');
+
+const LOCALAPPDATA = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+export const WT_FRAGMENT_DIR = path.join(LOCALAPPDATA, 'Microsoft', 'Windows Terminal', 'Fragments', 'ccm');
+export const WT_FRAGMENT = path.join(WT_FRAGMENT_DIR, 'ccm.json');
+
+export function profileDir(name) {
+  return path.join(PROFILES_DIR, name);
+}
+
+export function overrideSettingsPath(name) {
+  return path.join(OVERRIDES_DIR, `${name}.json`);
+}
+
+export function overrideClaudeMdPath(name) {
+  return path.join(OVERRIDES_DIR, `${name}.CLAUDE.md`);
+}

package/src/picker.js

@@ -0,0 +1,10 @@
+import { headroom } from './usage.js';
+
+// Most available quota first; profiles with no data go last, original order
+// kept. The split-flap board (src/tui) is the interactive picker now — this
+// ordering is the shared "which account has room" logic.
+export function sortByHeadroom(profiles, cache) {
+  return profiles.map((p, i) => ({ p, i, h: headroom(cache[p.name]) }))
+    .sort((a, b) => (b.h ?? -1) - (a.h ?? -1) || a.i - b.i)
+    .map((x) => x.p);
+}

package/src/pin.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const PIN_FILE = '.ccmrc';
+
+// Walk up from `from` looking for a .ccmrc; first line is the profile name.
+export function findPin(from = process.cwd()) {
+  let dir = path.resolve(from);
+  for (;;) {
+    const file = path.join(dir, PIN_FILE);
+    try {
+      const name = fs.readFileSync(file, 'utf8').split(/\r?\n/)[0].trim();
+      if (name) return { name, file };
+    } catch {}
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export function writePin(name, dir = process.cwd()) {
+  const file = path.join(dir, PIN_FILE);
+  fs.writeFileSync(file, name + '\n');
+  return file;
+}
+
+export function removePin(dir = process.cwd()) {
+  const file = path.join(dir, PIN_FILE);
+  if (!fs.existsSync(file)) return null;
+  fs.rmSync(file);
+  return file;
+}

package/src/profiles.js

@@ -0,0 +1,50 @@
+// Profile directory setup shared by the CLI commands and the TUI.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { profileDir, DEFAULT_CLAUDE_DIR, HOME_CLAUDE_JSON } from './paths.js';
+import { ensureShared, linkIntoProfile, unlinkShared } from './shared.js';
+import { composeProfile } from './compose.js';
+import { unregisterProfile } from './registry.js';
+import { isRunning } from './launch.js';
+
+// Session state that must travel with an import for --resume/--continue to
+// see past conversations: transcripts, prompt history, checkpoints, tasks.
+export const HISTORY_ITEMS = ['projects', 'sessions', 'session-data', 'tasks', 'file-history', 'history.jsonl'];
+
+// Create the profile's CLAUDE_CONFIG_DIR and compose the shared layer into it.
+// Returns warnings (junction fallbacks etc.) for the caller to surface.
+export function prepareProfileDir(name) {
+  const dir = profileDir(name);
+  fs.mkdirSync(dir, { recursive: true });
+  ensureShared();
+  return [...linkIntoProfile(dir), ...composeProfile(name, dir)];
+}
+
+export function hasDefaultLogin() {
+  return fs.existsSync(path.join(DEFAULT_CLAUDE_DIR, '.credentials.json'));
+}
+
+// Delete a profile: unlink its shared junctions first (so the recursive delete
+// can't follow them into ~/.ccm/shared), remove its CLAUDE_CONFIG_DIR, then drop
+// it from the registry. Refuses while a session is live — its files are in use.
+export function removeProfile(name) {
+  if (isRunning(name)) throw new Error(`profile "${name}" has a running session — close it first`);
+  const dir = profileDir(name);
+  unlinkShared(dir);
+  fs.rmSync(dir, { recursive: true, force: true });
+  unregisterProfile(name);
+}
+
+// Copy the default ~/.claude login (and optionally its session history)
+// into an already-prepared profile.
+export function importDefaultInto(name, { withHistory = true } = {}) {
+  const dir = profileDir(name);
+  fs.copyFileSync(path.join(DEFAULT_CLAUDE_DIR, '.credentials.json'), path.join(dir, '.credentials.json'));
+  if (fs.existsSync(HOME_CLAUDE_JSON)) fs.copyFileSync(HOME_CLAUDE_JSON, path.join(dir, '.claude.json'));
+  if (!withHistory) return;
+  for (const item of HISTORY_ITEMS) {
+    const src = path.join(DEFAULT_CLAUDE_DIR, item);
+    if (fs.existsSync(src)) fs.cpSync(src, path.join(dir, item), { recursive: true, force: true });
+  }
+}

package/src/registry.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { CONFIG_PATH, PROFILES_DIR, profileDir } from './paths.js';
+import { readJson, writeJson } from './util.js';
+
+const PALETTE = ['cyan', 'magenta', 'yellow', 'green', 'blue', 'red'];
+
+export function loadConfig() {
+  const cfg = readJson(CONFIG_PATH, null);
+  if (cfg?.profiles) return cfg;
+  // Rebuild from profile directories if the registry is missing or corrupt.
+  const rebuilt = { profiles: {} };
+  let names = [];
+  try {
+    names = fs.readdirSync(PROFILES_DIR).filter((n) =>
+      fs.existsSync(path.join(PROFILES_DIR, n, '.credentials.json')) ||
+      fs.existsSync(path.join(PROFILES_DIR, n, '.claude.json')));
+  } catch {}
+  for (const [i, name] of names.entries()) {
+    rebuilt.profiles[name] = {
+      email: null, displayName: null, organization: null, plan: null,
+      color: PALETTE[i % PALETTE.length], createdAt: null, lastUsed: null,
+    };
+  }
+  return rebuilt;
+}
+
+export function saveConfig(cfg) {
+  writeJson(CONFIG_PATH, cfg);
+}
+
+export function validName(name) {
+  return typeof name === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/.test(name);
+}
+
+export function listProfiles() {
+  const cfg = loadConfig();
+  return Object.entries(cfg.profiles).map(([name, p]) => ({ name, ...p }));
+}
+
+export function getProfile(name) {
+  return loadConfig().profiles[name] ?? null;
+}
+
+// Command words can never be profile names — the CLI dispatches commands first.
+const RESERVED = new Set([
+  'add', 'import', 'list', 'ls', 'remove', 'rm', 'status', 'st', 'pick',
+  'pin', 'unpin', 'statusline', 'refresh', 'help', 'version', 'doctor',
+  'mcp', 'wt', 'notify', 'override', 'move-session', 'sessions', 'ui', 'board',
+]);
+
+export function registerProfile(name) {
+  if (!validName(name)) throw new Error(`invalid profile name "${name}" (use letters, digits, - or _)`);
+  if (RESERVED.has(name)) throw new Error(`"${name}" is a ccm command — pick another profile name`);
+  const cfg = loadConfig();
+  if (cfg.profiles[name]) throw new Error(`profile "${name}" already exists`);
+  const used = new Set(Object.values(cfg.profiles).map((p) => p.color));
+  const color = PALETTE.find((c) => !used.has(c)) ?? PALETTE[Object.keys(cfg.profiles).length % PALETTE.length];
+  cfg.profiles[name] = {
+    email: null, displayName: null, organization: null, plan: null,
+    color, createdAt: new Date().toISOString(), lastUsed: null,
+  };
+  saveConfig(cfg);
+  return cfg.profiles[name];
+}
+
+export function updateProfile(name, patch) {
+  const cfg = loadConfig();
+  if (!cfg.profiles[name]) return null;
+  Object.assign(cfg.profiles[name], patch);
+  saveConfig(cfg);
+  return cfg.profiles[name];
+}
+
+export function unregisterProfile(name) {
+  const cfg = loadConfig();
+  delete cfg.profiles[name];
+  saveConfig(cfg);
+}
+
+// Pull identity (email, org, plan) out of the profile's own files after a login.
+export function refreshIdentity(name) {
+  const dir = profileDir(name);
+  const acct = readJson(path.join(dir, '.claude.json'), null)?.oauthAccount;
+  const oauth = readJson(path.join(dir, '.credentials.json'), null)?.claudeAiOauth;
+  const patch = {};
+  if (acct) {
+    patch.email = acct.emailAddress ?? null;
+    patch.displayName = acct.displayName ?? null;
+    patch.organization = acct.organizationName ?? null;
+  }
+  if (oauth?.subscriptionType) patch.plan = oauth.subscriptionType;
+  return Object.keys(patch).length ? updateProfile(name, patch) : getProfile(name);
+}