cchost 0.1.2 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # cchost
 
-Host multiple isolated Claude Code accounts on one machine via a single `cc` command. Works identically in PowerShell, cmd, bash, zsh, and fish on Windows, macOS, and Linux.
+Host multiple isolated Claude Code accounts on one machine via a single `cc` command. `cc` is a plain Node CLI on your PATH, so it runs the same from PowerShell, cmd, bash, zsh, or fish — there are no shell scripts or rc-file edits involved. Tested on Windows and Linux; macOS is expected to work but is not yet verified.
 
 Each profile is a complete, isolated `CLAUDE_CONFIG_DIR` — credentials, session history, project state, plugins, and settings. Create one with `cc add <name>`; launch under it with `cc use <name>`.
 
@@ -16,13 +16,14 @@ Requires Node.js 18+ and Claude Code 2.1.140+ already installed. Get Claude Code
 
 | Command | What it does |
 | --- | --- |
-| `cc add <profile> [--email=] [--org=] [--name=]` | Create a profile directory. Optional alias flags (EXPERIMENTAL, see below). |
+| `cc add <profile>` | Create a profile directory. |
 | `cc use <profile> [...args]` | Launch Claude under that profile. Profile must already exist. Args after the name are forwarded verbatim to `claude`. |
-| `cc list [--original] [--json]` | Show every profile: login state, account email, and storage mode (`shared` / `isolated`). |
+| `cc list [--json]` | Show every profile: login state, account email, and storage mode (`shared` / `isolated`). |
 | `cc migrate <src> <dest>` | Copy projects from `default`\|`shared` to `shared`\|`<profile>`. Skip-on-collision; credential files never copied. |
 | `cc link <profile> [<profile>...]` | Link a profile's `projects/` to `~/.claude-shared/projects`. Migrates existing content; renames on collision. |
 | `cc unlink <profile>` | Restore a profile to its own private `projects/` (copies shared content back). |
 | `cc remove <profile>` | Delete a profile. Requires typing the profile name to confirm. |
+| `cc doctor [--fix [--force]] [--json]` | Diagnose environment, storage, and platform issues. |
 | `cc help [command]` | Print usage (top-level, or for a single command). |
 
 ### Examples
@@ -76,21 +77,14 @@ If two profiles share history and you launch them against the same project at th
 
 `cc remove` is safe with shared profiles — it deletes only the link, never recursing into the shared target.
 
-### Aliases (`cc add` flags) — EXPERIMENTAL
-
-`cc add work --email=work@example.com --org=Acme --name="Work Account"` stores those values in `~/.claude-profiles/work/.cc-alias.json`. On every `cc use`, they're written into the profile's `.claude.json` `oauthAccount` so `cc list` and Claude's own UI display them instead of the real underlying account.
-
-**EXPERIMENTAL.** Claude Code may overwrite `oauthAccount` on server re-sync; we re-apply on the next `cc use`, but masking across all of Claude's UI surfaces has not been verified. Use `cc list --original` to see the real values from `.claude.json`.
-
 ## How it works
 
 `cc` is a Node CLI with **zero runtime dependencies**. For `cc use` it:
 
 1. Resolves the profile directory under `~/.claude-profiles/<name>/`
-2. Applies any stored alias to `.claude.json` `oauthAccount` (best-effort)
-3. Sets `CLAUDE_CONFIG_DIR` in its **own** spawn environment
-4. Spawns `claude` with `stdio: 'inherit'` so the TUI works correctly
-5. Forwards the child's exit code
+2. Sets `CLAUDE_CONFIG_DIR` in its **own** spawn environment
+3. Spawns `claude` with `stdio: 'inherit'` so the TUI works correctly
+4. Forwards the child's exit code
 
 The env var is set on the child process only — that's all `claude` needs.
 

package/lib/cli.js

@@ -14,32 +14,29 @@ const color = require('./color');
 const HELP = `cc - Multi-profile launcher for Claude Code
 
 Usage:
-  cc add <profile> [--email=] [--org=] [--name=]   Create a profile (EXPERIMENTAL aliases)
+  cc add <profile>                                 Create a profile directory
   cc use <profile> [...args]                       Launch Claude under a named profile
-  cc list [--original] [--json]                    Show all profiles: login state, email, storage (shared/isolated)
+  cc list [--json]                                 Show all profiles: login state, email, storage (shared/isolated)
   cc migrate <src> <dest>                          Copy projects from default|shared to shared|<profile>
   cc link <p>...                                   Replace each profile's projects/ with a link to shared
   cc unlink <profile>                              Restore a profile's private projects/
   cc remove <profile>                              Delete a profile and all its data (typed confirmation)
+  cc doctor [--fix [--force]] [--json]             Diagnose environment, storage, and platform issues
   cc help [command]                                Show usage (optionally for a single command)
+  cc --version                                     Print the installed cchost version
 
 Profiles live in ~/.claude-profiles/<profile>/ and become CLAUDE_CONFIG_DIR
 for that launch. Args after the profile name are forwarded verbatim to claude.
 `;
 
 const HELP_BY_CMD = {
-  add: `cc add <profile> [--email=...] [--org=...] [--name=...]
+  add: `cc add <profile>
 
-Create a new profile directory without launching Claude. Optional alias flags
-record account values shown in 'cc list' and written into the profile's
-.claude.json oauthAccount on subsequent 'cc use' launches.
-
-EXPERIMENTAL: Claude Code may overwrite these on server re-sync. Masking
-behavior across all UI surfaces has not been verified.
+Create a new profile directory without launching Claude.
 
 Examples:
   cc add work
-  cc add work --email=work@example.com --org=Acme --name="Work Account"
+  cc add personal
 `,
   use: `cc use <profile> [...args]
 
@@ -55,19 +52,16 @@ Examples:
   cc use work --resume
   cc use personal -p "summarize this codebase"
 `,
-  list: `cc list [--original] [--json]
+  list: `cc list [--json]
 
 Columns:
   Profile   - profile name
   LoggedIn  - true if .credentials.json exists
-  Email     - account email (alias-aware; - if not yet logged in)
+  Email     - account email from .claude.json; - if not yet logged in
   Storage   - 'shared' if projects/ is linked to ~/.claude-shared, 'isolated' otherwise
               (sessions/ is transient per-process state and is never shared)
 
-By default, the displayed email reflects any alias set via 'cc add'.
-With --original, shows the real value from .claude.json.
-
-With --json, emits an array of {name, dir, loggedIn, email, storage, alias}.
+With --json, emits an array of {name, dir, loggedIn, email, storage}.
 `,
   migrate: `cc migrate <src> <dest>
 
@@ -114,6 +108,21 @@ name — y/n is intentionally not accepted because credential loss is unrecovera
 
 If the profile's projects/ is a link to ~/.claude-shared/, only the link is
 removed — the shared target is preserved.
+`,
+  doctor: `cc doctor [--fix [--force]] [--json]
+
+Run diagnostic checks across four groups:
+
+  Environment  Node >=18, claude on PATH, claude >=2.1.140, no conflicting env vars, no cc shadow
+  Storage      ~/.claude-profiles/ writable, .claude.json parseable, junctions/symlinks valid
+  Platform     Windows: OneDrive home, WindowsApps stub, stale ~/bin/cc; Git Bash: cygpath
+  Sanity       Test-spawn claude --version through the same code path cc use uses
+
+Exit codes: 0 = all ok, 1 = warnings, 2 = errors.
+
+--fix           Auto-apply safe fixes: create missing dirs, recreate broken junctions
+--fix --force   Also apply confirmation-required fixes (e.g. reset a corrupt .claude.json)
+--json          Machine-readable output for CI / scripting
 `,
   help: `cc help [command]
 
@@ -205,41 +214,12 @@ function parseFlagsStrict(args, flagNames, { allowPositional = false } = {}) {
   return { flags, positional };
 }
 
-function parseAliasFlags(args) {
-  const out = {};
-  for (const a of args) {
-    if (!a.startsWith('--')) {
-      throw usageError(`Unexpected positional argument: ${a}`);
-    }
-    const eq = a.indexOf('=');
-    if (eq === -1) {
-      throw usageError(`Flag must be in --key=value form: ${a}`);
-    }
-    const key = a.slice(2, eq);
-    const value = a.slice(eq + 1);
-    if (!profiles.ALLOWED_ALIAS_KEYS.includes(key)) {
-      throw usageError(`Unknown flag: --${key}. Allowed: --email, --org, --name.`);
-    }
-    if (value.length === 0) {
-      throw usageError(`Flag --${key} requires a non-empty value.`);
-    }
-    out[key] = value;
-  }
-  return out;
-}
-
 async function cmdAdd(rest) {
-  const [name, ...flagArgs] = rest;
-  if (!name) throw usageError('Usage: cc add <profile> [--email=...] [--org=...] [--name=...]');
-  const aliasFlags = parseAliasFlags(flagArgs);
-  const { dir } = profiles.addProfile(name, aliasFlags);
+  const [name, ...extra] = rest;
+  if (!name) throw usageError('Usage: cc add <profile>');
+  if (extra.length > 0) throw usageError(`cc add takes no extra arguments: ${extra[0]}`);
+  const { dir } = profiles.addProfile(name);
   console.log(`Created profile "${name}" at ${dir}.`);
-  if (Object.keys(aliasFlags).length > 0) {
-    process.stderr.write(
-      color.stderr.yellow('Aliases are EXPERIMENTAL — Claude may overwrite them on server re-sync.') + '\n'
-    );
-    console.log(`  Stored aliases: ${JSON.stringify(aliasFlags)}`);
-  }
   console.log(`Next: cc use ${name}`);
   return 0;
 }
@@ -254,33 +234,21 @@ async function cmdUse(rest) {
     err.exitCode = 1;
     throw err;
   }
-  try {
-    profiles.applyAlias(dir);
-  } catch {
-    // best-effort; never block the launch
-  }
-  return spawnClaude({
-    args: passthrough,
-    profileDir: dir,
-  });
+  return spawnClaude({ args: passthrough, profileDir: dir });
 }
 
 function cmdList(rest) {
-  const { flags } = parseFlagsStrict(rest, ['--json', '--original']);
+  const { flags } = parseFlagsStrict(rest, ['--json']);
   const list = profiles.listProfiles();
-  const useOriginal = flags.has('--original');
 
   const enriched = list.map((p) => {
-    const alias = p.alias || {};
-    const displayEmail = useOriginal ? p.email : (alias.email || p.email);
     const storage = isLinkLike(path.join(p.dir, 'projects')) ? 'shared' : 'isolated';
     return {
       name: p.name,
       dir: p.dir,
       loggedIn: p.loggedIn,
-      email: displayEmail,
+      email: p.email,
       storage,
-      alias,
     };
   });
 
@@ -368,6 +336,16 @@ async function cmdUnlink(rest) {
   return 0;
 }
 
+async function cmdDoctor(rest) {
+  const { flags } = parseFlagsStrict(rest, ['--fix', '--force', '--json']);
+  const fix = flags.has('--fix');
+  const force = flags.has('--force');
+  if (force && !fix) throw usageError('--force requires --fix');
+  const json = flags.has('--json');
+  const doctor = require('./doctor');
+  return doctor.runDoctor({ fix, force, json, prompt });
+}
+
 async function cmdMigrate(rest) {
   const [src, dest, ...extra] = rest;
   if (!src || !dest) throw usageError('Usage: cc migrate <src> <dest>');
@@ -382,6 +360,11 @@ async function run(argv) {
     printHelp();
     return 0;
   }
+  if (action === '--version' || action === '-v') {
+    const { version } = require('../package.json');
+    process.stdout.write(version + '\n');
+    return 0;
+  }
   if (action === 'help') {
     printHelp(rest[0]);
     return 0;
@@ -401,6 +384,8 @@ async function run(argv) {
       return await cmdUnlink(rest);
     case 'remove':
       return await cmdRemove(rest);
+    case 'doctor':
+      return await cmdDoctor(rest);
     default: {
       process.stderr.write(color.stderr.red(`Unknown command: ${action}`) + '\n\n');
       printHelp();

package/lib/doctor.js

@@ -0,0 +1,375 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const profiles = require('./profiles');
+const { findClaude, getClaudeVersion, compareVersion, MIN_VERSION } = require('./spawn');
+const color = require('./color');
+
+const GROUP_ORDER = ['Environment', 'Storage', 'Platform', 'Sanity'];
+
+// fix: { safe, description, cmd, apply }
+//   safe=true  → auto-applied by --fix
+//   safe=false → needs --fix --force, prompted y/n
+//   cmd        → printed when fix cannot be auto-applied
+//   apply      → async fn to execute
+
+function mk(group, name, status, message, fix) {
+  return { group, name, status, message, fix: fix || null };
+}
+
+// --- Environment ---
+
+function checkNodeVersion() {
+  const v = `v${process.versions.node}`;
+  if (parseInt(process.versions.node.split('.')[0], 10) >= 18) {
+    return mk('Environment', 'Node.js version', 'ok', `${v} (>=18)`);
+  }
+  return mk('Environment', 'Node.js version', 'error', `${v} — requires >=18`, {
+    safe: false, description: 'Install Node.js 18+', cmd: 'https://nodejs.org', apply: null,
+  });
+}
+
+function checkClaudeOnPath() {
+  const bin = findClaude();
+  if (bin) return mk('Environment', 'claude on PATH', 'ok', bin);
+  return mk('Environment', 'claude on PATH', 'error', 'not found', {
+    safe: false,
+    description: 'Install Claude Code',
+    cmd: 'npm install -g @anthropic-ai/claude-code',
+    apply: null,
+  });
+}
+
+function checkClaudeVersion() {
+  const bin = findClaude();
+  if (!bin) return null;
+  const v = getClaudeVersion(bin);
+  const minStr = MIN_VERSION.join('.');
+  if (!v) {
+    return mk('Environment', 'claude version', 'warn', 'could not determine', {
+      safe: false, description: 'Update Claude Code', cmd: 'claude update', apply: null,
+    });
+  }
+  if (compareVersion(v, MIN_VERSION) >= 0) return mk('Environment', 'claude version', 'ok', `${v.raw} (>=${minStr})`);
+  return mk('Environment', 'claude version', 'warn', `${v.raw} < ${minStr} — CLAUDE_CONFIG_DIR isolation unreliable`, {
+    safe: false, description: 'Update Claude Code', cmd: 'claude update', apply: null,
+  });
+}
+
+const CONFLICT_VARS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN'];
+
+function checkConflictingEnv() {
+  const set = CONFLICT_VARS.filter(k => process.env[k]);
+  if (set.length === 0) return mk('Environment', 'conflicting env vars', 'ok', 'none set');
+  const cmd = process.platform === 'win32'
+    ? set.map(k => `Remove-Item Env:${k}`).join('; ')
+    : set.map(k => `unset ${k}`).join('; ');
+  return mk('Environment', 'conflicting env vars', 'warn', `set: ${set.join(', ')}`, {
+    safe: false, description: 'Unset to avoid auth interference with cc use', cmd, apply: null,
+  });
+}
+
+function findAllOnPath(name) {
+  const PATH = process.env.PATH || process.env.Path || '';
+  const sep = process.platform === 'win32' ? ';' : ':';
+  const exts = process.platform === 'win32'
+    ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').map(s => s.trim()).filter(Boolean)
+    : [''];
+  const found = [];
+  const seen = new Set();
+  for (const dir of PATH.split(sep).filter(Boolean)) {
+    for (const ext of exts) {
+      try {
+        const full = path.join(dir, name + ext);
+        if (fs.statSync(full).isFile()) {
+          const key = process.platform === 'win32' ? full.toLowerCase() : full;
+          if (!seen.has(key)) { seen.add(key); found.push(full); }
+          break;
+        }
+      } catch { /* skip */ }
+    }
+  }
+  return found;
+}
+
+function checkCcShadow() {
+  const all = findAllOnPath('cc');
+  if (all.length <= 1) {
+    return mk('Environment', 'cc on PATH', 'ok', all[0] || 'not found yet (expected after npm install -g)');
+  }
+  return mk('Environment', 'cc on PATH', 'warn', `multiple: ${all.join(', ')}`, {
+    safe: false, description: 'Remove duplicate cc entries to avoid version confusion', cmd: null, apply: null,
+  });
+}
+
+// --- Storage ---
+
+function checkProfilesDirWritable() {
+  const base = profiles.baseDir();
+  if (!fs.existsSync(base)) {
+    return mk('Storage', '~/.claude-profiles/', 'warn', 'does not exist', {
+      safe: true,
+      description: `Create ${base}`,
+      cmd: null,
+      apply: async () => {
+        fs.mkdirSync(base, { recursive: true });
+        process.stdout.write(`  Created ${base}\n`);
+      },
+    });
+  }
+  try {
+    fs.accessSync(base, fs.constants.W_OK);
+    return mk('Storage', '~/.claude-profiles/', 'ok', 'writable');
+  } catch {
+    const cmd = process.platform === 'win32'
+      ? `icacls "${base}" /grant "%USERNAME%:F"`
+      : `chmod u+w "${base}"`;
+    return mk('Storage', '~/.claude-profiles/', 'error', `not writable: ${base}`, {
+      safe: false, description: 'Fix directory permissions', cmd, apply: null,
+    });
+  }
+}
+
+function checkProfileClaudeJson(prof) {
+  const p = path.join(prof.dir, '.claude.json');
+  if (!fs.existsSync(p)) return mk('Storage', `"${prof.name}" .claude.json`, 'ok', 'not yet logged in');
+  try {
+    const raw = fs.readFileSync(p, 'utf8');
+    if (raw.trim()) JSON.parse(raw);
+    return mk('Storage', `"${prof.name}" .claude.json`, 'ok', 'valid JSON');
+  } catch (e) {
+    return mk('Storage', `"${prof.name}" .claude.json`, 'error', `parse error: ${e.message}`, {
+      safe: false,
+      description: `Back up ${path.basename(p)} and reset to {}`,
+      cmd: null,
+      apply: async () => {
+        const bak = `${p}.bak.${Date.now()}`;
+        fs.renameSync(p, bak);
+        fs.writeFileSync(p, '{}');
+        process.stdout.write(`  Backed up to ${path.basename(bak)}, reset to {}\n`);
+      },
+    });
+  }
+}
+
+function checkProfileLinks(prof) {
+  const results = [];
+  const pp = path.join(prof.dir, 'projects');
+  let isLinkNode = false;
+  try { isLinkNode = fs.lstatSync(pp).isSymbolicLink(); } catch { return results; }
+  if (!isLinkNode) return results;
+
+  try {
+    fs.statSync(pp);
+    results.push(mk('Storage', `"${prof.name}" projects/ link`, 'ok', 'valid'));
+    return results;
+  } catch { /* broken */ }
+
+  const expected = path.join(profiles.sharedDir(), 'projects');
+  const targetExists = fs.existsSync(expected);
+  results.push(mk('Storage', `"${prof.name}" projects/ link`, 'error', 'broken — target missing', {
+    safe: targetExists,
+    description: targetExists ? `Recreate junction/symlink to ${expected}` : 'Target missing',
+    cmd: targetExists ? null : `cc link ${prof.name}`,
+    apply: targetExists ? async () => {
+      try { fs.unlinkSync(pp); } catch { try { fs.rmdirSync(pp); } catch { /* ignore */ } }
+      fs.symlinkSync(expected, pp, process.platform === 'win32' ? 'junction' : 'dir');
+      process.stdout.write(`  Recreated: ${pp} -> ${expected}\n`);
+    } : null,
+  }));
+  return results;
+}
+
+// --- Platform ---
+
+function checkOneDrive() {
+  if (process.platform !== 'win32') return null;
+  if (/onedrive/i.test(os.homedir()) || /onedrive/i.test(process.env.USERPROFILE || '')) {
+    return mk('Platform', 'OneDrive home folder', 'warn',
+      'home is OneDrive-synced — can corrupt directory junctions', {
+      safe: false, description: 'Exclude ~/.claude-profiles from OneDrive sync', cmd: null, apply: null,
+    });
+  }
+  return mk('Platform', 'OneDrive home folder', 'ok', 'not OneDrive-redirected');
+}
+
+function checkWindowsAppsCc() {
+  if (process.platform !== 'win32') return null;
+  const p = path.join(process.env.LOCALAPPDATA || '', 'Microsoft', 'WindowsApps', 'cc.cmd');
+  if (!fs.existsSync(p)) return mk('Platform', 'WindowsApps cc.cmd', 'ok', 'not present');
+  return mk('Platform', 'WindowsApps cc.cmd', 'warn', `${p} may shadow npm-installed cc`, {
+    safe: false, description: 'Delete the stale stub', cmd: `del "${p}"`, apply: null,
+  });
+}
+
+function checkStaleBinCc() {
+  if (process.platform !== 'win32') return null;
+  const p = path.join(os.homedir(), 'bin', 'cc');
+  if (!fs.existsSync(p)) return null;
+  return mk('Platform', '~/bin/cc', 'warn', `${p} may be an old version shadowing npm-installed cc`, {
+    safe: false, description: 'Remove the old script', cmd: `Remove-Item "${p}"`, apply: null,
+  });
+}
+
+function checkCygpath() {
+  if (process.platform !== 'win32') return null;
+  if (!process.env.MSYSTEM && !process.env.MINGW_PREFIX) return null;
+  if (findAllOnPath('cygpath').length > 0) return mk('Platform', 'cygpath (Git Bash)', 'ok', 'available');
+  return mk('Platform', 'cygpath (Git Bash)', 'warn', 'not found — path conversion may fail', {
+    safe: false, description: 'Use Git for Windows which bundles cygpath', cmd: null, apply: null,
+  });
+}
+
+// --- Sanity ---
+
+function checkSpawnClaude() {
+  const bin = findClaude();
+  if (!bin) return null;
+  const v = getClaudeVersion(bin);
+  if (v) return mk('Sanity', 'test-spawn claude --version', 'ok', v.raw);
+  return mk('Sanity', 'test-spawn claude --version', 'error', 'no version output', {
+    safe: false, description: 'Reinstall Claude Code', cmd: 'npm install -g @anthropic-ai/claude-code', apply: null,
+  });
+}
+
+// --- Collect all ---
+
+function runChecks() {
+  const results = [
+    checkNodeVersion(),
+    checkClaudeOnPath(),
+    checkClaudeVersion(),
+    checkConflictingEnv(),
+    checkCcShadow(),
+    checkProfilesDirWritable(),
+  ];
+  for (const prof of profiles.listProfiles()) {
+    results.push(checkProfileClaudeJson(prof));
+    results.push(...checkProfileLinks(prof));
+  }
+  results.push(
+    checkOneDrive(),
+    checkWindowsAppsCc(),
+    checkStaleBinCc(),
+    checkCygpath(),
+    checkSpawnClaude(),
+  );
+  return results.filter(Boolean);
+}
+
+// --- Output formatting ---
+
+function colorIcon(status) {
+  const icon = status === 'ok' ? '✓' : status === 'warn' ? '⚠' : '✗';
+  if (!color.colorEnabled(process.stdout)) return icon;
+  if (status === 'ok') return `\x1b[32m${icon}\x1b[39m`;
+  if (status === 'warn') return `\x1b[33m${icon}\x1b[39m`;
+  return `\x1b[31m${icon}\x1b[39m`;
+}
+
+function formatText(results) {
+  const groups = {};
+  for (const g of GROUP_ORDER) groups[g] = [];
+  for (const r of results) {
+    if (groups[r.group]) groups[r.group].push(r);
+  }
+
+  const lines = [];
+  for (const g of GROUP_ORDER) {
+    if (groups[g].length === 0) continue;
+    lines.push(g);
+    for (const r of groups[g]) {
+      lines.push(`  ${colorIcon(r.status)}  ${r.name}: ${r.message}`);
+      if (r.status !== 'ok' && r.fix) {
+        if (r.fix.cmd) {
+          lines.push(`       → Run: ${r.fix.cmd}`);
+        } else if (r.fix.apply) {
+          lines.push(`       → Run: ${r.fix.safe ? 'cc doctor --fix' : 'cc doctor --fix --force'}`);
+        }
+      }
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function serializeFix(fix) {
+  if (!fix) return null;
+  return { safe: fix.safe, description: fix.description || null, cmd: fix.cmd || null };
+}
+
+function formatJson(results) {
+  const counts = { ok: 0, warn: 0, error: 0 };
+  for (const r of results) counts[r.status] = (counts[r.status] || 0) + 1;
+  return JSON.stringify({
+    summary: counts,
+    checks: results.map(r => ({
+      group: r.group, name: r.name, status: r.status, message: r.message,
+      fix: serializeFix(r.fix),
+    })),
+  }, null, 2);
+}
+
+// --- Fix runner ---
+
+async function applyFixes(results, force, promptFn) {
+  const toFix = results.filter(r => r.fix && r.fix.apply && (r.fix.safe || force));
+  if (toFix.length === 0) {
+    process.stdout.write('Nothing auto-fixable found.\n');
+    return;
+  }
+  for (const r of toFix) {
+    if (r.fix.safe) {
+      process.stdout.write(`Fixing: ${r.name}\n`);
+      await r.fix.apply();
+    } else {
+      const ans = await promptFn(`Fix "${r.name}" — ${r.fix.description || r.name}? [y/N]: `);
+      if (ans.trim().toLowerCase() === 'y') {
+        await r.fix.apply();
+      } else {
+        process.stdout.write('  Skipped.\n');
+      }
+    }
+  }
+}
+
+// --- Entry point ---
+
+async function runDoctor({ fix, force, json, prompt: promptFn }) {
+  const results = runChecks();
+
+  if (json) {
+    process.stdout.write(formatJson(results) + '\n');
+  } else {
+    process.stdout.write(formatText(results));
+  }
+
+  if (fix) {
+    if (!json) process.stdout.write('Applying fixes...\n');
+    await applyFixes(results, force, promptFn);
+  } else if (!json) {
+    const errors = results.filter(r => r.status === 'error');
+    const warns = results.filter(r => r.status === 'warn');
+    if (errors.length === 0 && warns.length === 0) {
+      process.stdout.write('All checks passed.\n');
+    } else {
+      const parts = [];
+      if (errors.length) parts.push(`${errors.length} error${errors.length !== 1 ? 's' : ''}`);
+      if (warns.length) parts.push(`${warns.length} warning${warns.length !== 1 ? 's' : ''}`);
+      process.stdout.write(`${parts.join(', ')}.\n`);
+      const hasAutoFix = results.some(r => r.fix && r.fix.apply && r.fix.safe);
+      const hasForce = results.some(r => r.fix && r.fix.apply && !r.fix.safe);
+      if (hasAutoFix) process.stdout.write('Run: cc doctor --fix\n');
+      else if (hasForce) process.stdout.write('Run: cc doctor --fix --force\n');
+    }
+  }
+
+  if (results.some(r => r.status === 'error')) return 2;
+  if (results.some(r => r.status === 'warn')) return 1;
+  return 0;
+}
+
+module.exports = { runChecks, runDoctor };

package/lib/profiles.js

@@ -13,14 +13,6 @@ const RESERVED_WIN = new Set([
 const MAX_NAME_LEN = 64;
 const INVALID_CHARS_RE = /[\\/:*?"<>|\x00-\x1f]/;
 
-const ALIAS_FILE = '.cc-alias.json';
-const ALLOWED_ALIAS_KEYS = ['email', 'org', 'name'];
-const OAUTH_FIELD_MAP = {
-  email: 'emailAddress',
-  org: 'organizationName',
-  name: 'displayName',
-};
-
 function baseDir() {
   return path.join(os.homedir(), '.claude-profiles');
 }
@@ -88,31 +80,7 @@ function ensureProfileDir(name) {
   return { dir, created };
 }
 
-function aliasPath(dir) {
-  return path.join(dir, ALIAS_FILE);
-}
-
-function readAlias(dir) {
-  try {
-    const raw = fs.readFileSync(aliasPath(dir), 'utf8');
-    if (!raw.trim()) return {};
-    const data = JSON.parse(raw);
-    if (!data || typeof data !== 'object') return {};
-    const out = {};
-    for (const k of ALLOWED_ALIAS_KEYS) {
-      if (typeof data[k] === 'string' && data[k].length > 0) out[k] = data[k];
-    }
-    return out;
-  } catch {
-    return {};
-  }
-}
-
-function writeAlias(dir, data) {
-  fs.writeFileSync(aliasPath(dir), JSON.stringify(data, null, 2));
-}
-
-function addProfile(name, aliasFlags) {
+function addProfile(name) {
   validateProfileName(name);
   const dir = profileDir(name);
   if (fs.existsSync(dir)) {
@@ -120,57 +88,9 @@ function addProfile(name, aliasFlags) {
     e.exitCode = 1;
     throw e;
   }
-  const alias = {};
-  for (const [k, v] of Object.entries(aliasFlags || {})) {
-    if (!ALLOWED_ALIAS_KEYS.includes(k)) {
-      throw usageError(`Unknown flag: --${k}. Allowed: --email, --org, --name.`);
-    }
-    if (typeof v !== 'string' || v.length === 0) {
-      throw usageError(`Flag --${k} requires a non-empty value.`);
-    }
-    alias[k] = v;
-  }
   ensureBaseDir();
   fs.mkdirSync(dir);
-  if (Object.keys(alias).length > 0) {
-    writeAlias(dir, alias);
-  }
-  return { dir, alias };
-}
-
-function applyAlias(dir) {
-  const alias = readAlias(dir);
-  if (Object.keys(alias).length === 0) return false;
-  const claudeJsonPath = path.join(dir, '.claude.json');
-  if (!fs.existsSync(claudeJsonPath)) return false;
-  let data;
-  try {
-    const raw = fs.readFileSync(claudeJsonPath, 'utf8');
-    if (!raw.trim()) return false;
-    data = JSON.parse(raw);
-  } catch {
-    return false;
-  }
-  if (!data || typeof data !== 'object') return false;
-  if (!data.oauthAccount || typeof data.oauthAccount !== 'object') return false;
-  let mutated = false;
-  for (const [k, v] of Object.entries(alias)) {
-    const oauthKey = OAUTH_FIELD_MAP[k];
-    if (!oauthKey) continue;
-    if (data.oauthAccount[oauthKey] !== v) {
-      data.oauthAccount[oauthKey] = v;
-      mutated = true;
-    }
-  }
-  if (mutated) {
-    try {
-      fs.writeFileSync(claudeJsonPath, JSON.stringify(data, null, 2));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  return false;
+  return { dir };
 }
 
 function readEmail(dir) {
@@ -214,7 +134,6 @@ function listProfiles() {
       dir,
       loggedIn: hasCredentials(dir),
       email: readEmail(dir),
-      alias: readAlias(dir),
     });
   }
   out.sort((a, b) => a.name.localeCompare(b.name));
@@ -232,9 +151,4 @@ module.exports = {
   hasCredentials,
   listProfiles,
   addProfile,
-  readAlias,
-  writeAlias,
-  applyAlias,
-  ALLOWED_ALIAS_KEYS,
-  OAUTH_FIELD_MAP,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cchost",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Host multiple isolated Claude Code accounts on one machine via the `cc` command.",
   "keywords": [
     "claude",
@@ -43,4 +43,4 @@
   "devDependencies": {
     "vitest": "^2.1.0"
   }
-}
+}