@remeic/ccm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Giulio Fagioli
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,385 @@
+# ccm
+
+> Multi-profile manager for Claude Code
+
+[![CI](https://github.com/remeic/ccm-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/remeic/ccm-cli/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/%40remeic%2Fccm.svg)](https://www.npmjs.com/package/@remeic/ccm)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org)
+[![codecov](https://codecov.io/github/Remeic/ccm-cli/graph/badge.svg?token=E16LCLDHYV)](https://codecov.io/github/Remeic/ccm-cli)
+[![mutation testing](https://img.shields.io/badge/mutation%20testing-100%25-brightgreen)](https://stryker-mutator.io/)
+
+Switch between Claude Code accounts instantly. Like `nvm` for Claude Code profiles.
+
+## Table of Contents
+
+- [Why](#why)
+- [Prerequisites](#prerequisites)
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [Commands](#commands)
+- [How It Works](#how-it-works)
+  - [Architecture Overview](#architecture-overview)
+  - [Profile Isolation](#profile-isolation)
+  - [Profile Lifecycle](#profile-lifecycle)
+  - [Launching Claude](#launching-claude)
+  - [Authentication](#authentication)
+  - [Removing Profiles](#removing-profiles)
+  - [Config Persistence](#config-persistence)
+  - [Claude Binary Discovery](#claude-binary-discovery)
+- [Configuration](#configuration)
+- [Privacy](#privacy)
+- [Comparison](#comparison)
+- [FAQ](#faq)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Why
+
+Claude Code stores authentication in a single config directory. If you use multiple Anthropic accounts (personal, work, client projects), you need to log out and back in every time you switch. **ccm** manages isolated profile directories so you can switch instantly — or run multiple accounts simultaneously.
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org) >= 18
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed and available on your `PATH`
+
+## Install
+
+```sh
+npm i -g @remeic/ccm
+```
+
+Or run without installing:
+
+```sh
+npx @remeic/ccm <command>
+```
+
+The installed command remains `ccm`.
+
+## Quick Start
+
+```
+$ ccm create work
+✓ Profile "work" created
+  Next: ccm login work
+
+$ ccm login work
+# Opens Claude auth flow in browser...
+
+$ ccm use work
+# Launches Claude Code with the "work" profile
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `ccm create <name> [-l label] [-b browser]` | Create a profile. `-b` sets the browser for OAuth |
+| `ccm list` | List all profiles with auth status, including drifted entries |
+| `ccm use <name> [-- args]` | Launch Claude Code. Args after `--` are passed to Claude |
+| `ccm login <name> [--console] [-b browser] [--url-only]` | Authenticate a profile |
+| `ccm status [name]` | Show auth status and storage state for one or all profiles |
+| `ccm remove <name> [-f]` | Remove a profile. `-f` skips confirmation |
+| `ccm run <name> -p <prompt>` | Run a prompt non-interactively |
+
+## Passing Flags and Environment Variables
+
+Everything after `--` in `ccm use` is forwarded to `claude`. Env vars from your shell are inherited.
+
+```bash
+# Pass flags
+ccm use work -- --dangerously-skip-permissions
+
+# Env vars + flags
+CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 ccm use work -- --dangerously-skip-permissions
+
+# Non-interactive with env vars
+CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 ccm run work -p "explain this codebase"
+```
+
+For combos you use often, set up shell aliases:
+
+```bash
+# ~/.zshrc or ~/.bashrc
+alias cwork='CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 ccm use work -- --dangerously-skip-permissions'
+alias cpersonal='ccm use personal -- --dangerously-skip-permissions'
+```
+
+## Multi-Account Login
+
+Each profile has isolated auth. Claude Code manages credentials in macOS Keychain; ccm stores nothing.
+
+`ccm login` launches the interactive Claude TUI which supports both auto-redirect (localhost callback) and manual code paste.
+
+### Different Browser per Profile
+
+```bash
+# Specify browser for this login
+ccm login work --browser firefox
+
+# Persist browser in the profile
+ccm create work --browser "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+ccm login work  # always opens Chrome
+
+# Chrome with a specific profile directory
+ccm create client --browser "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome --profile-directory=Profile\ 2"
+```
+
+### URL-Only Mode
+
+```bash
+ccm login work --url-only
+```
+
+Suppresses auto-opening a browser. Claude prints the auth URL — copy it, open in whichever browser you want. After ~3 seconds the TUI shows "Paste code here if prompted >" where you paste the code from the browser.
+
+### API Key Auth
+
+```bash
+ccm login work --console
+```
+
+## How It Works
+
+### Architecture Overview
+
+ccm stores all data under `~/.ccm/`:
+
+```
+~/.ccm/
+├── config.json              # Profile metadata (name, label, createdAt)
+├── browsers/                # Browser wrapper scripts (when browser has args)
+└── profiles/
+    ├── work/                # Isolated Claude config directory
+    └── personal/            # Isolated Claude config directory
+```
+
+Each profile directory acts as a standalone Claude Code config directory. A central `config.json` tracks metadata. Runtime dependencies are [Commander.js](https://github.com/tj/commander.js) for CLI parsing and [Zod](https://zod.dev) for schema validation and type inference; everything else uses Node.js built-ins.
+
+Source code follows a clean separation between library logic and CLI wiring:
+
+```
+src/
+├── index.ts                 # Entry point — registers all commands
+├── types.ts                 # Zod schemas and inferred TypeScript types
+├── lib/
+│   ├── constants.ts         # Path constants (~/.ccm, profiles dir, config file)
+│   ├── config.ts            # Config file I/O with atomic writes
+│   ├── profiles.ts          # Profile directory management and validation
+│   ├── profile-store.ts     # Reconciled config/filesystem profile view
+│   ├── claude.ts            # Claude binary discovery, spawning, auth status
+│   └── browsers.ts          # Browser wrapper generation and validation
+└── commands/
+    ├── create.ts            # Create profile (with rollback on failure)
+    ├── list.ts              # List profiles with auth status and drift state
+    ├── login.ts             # Authenticate via Claude TUI or --console
+    ├── use.ts               # Launch Claude with profile config dir
+    ├── status.ts            # Show auth status and drift state
+    ├── remove.ts            # Remove profile with staged rollback
+    └── run.ts               # Run prompt with specific profile
+```
+
+### Profile Isolation
+
+Claude Code reads auth tokens, settings, and project data from whatever directory `CLAUDE_CONFIG_DIR` points to. ccm exploits this by creating a separate directory per profile and setting this environment variable when spawning Claude:
+
+```ts
+spawn(claudeBinary, args, {
+  env: { ...process.env, CLAUDE_CONFIG_DIR: profileDir },
+  stdio: 'inherit',
+})
+```
+
+No symlinks, no file copying, no modification of Claude's own config directory. Profiles are fully independent — logging in with one profile does not affect another. You can run multiple profiles simultaneously in different terminals.
+
+### Profile Lifecycle
+
+When you create a profile, ccm validates the name, creates the directory, creates a browser wrapper if needed, and writes metadata to `config.json`. If the config write fails, any partially created on-disk state is rolled back.
+
+```mermaid
+flowchart TD
+    A["ccm create &lt;name&gt; [-l label]"] --> B{"Validate name
+    (a-z, 0-9, -, _; max 64 chars)"}
+    B -->|Invalid| ERR1["Exit with error"]
+    B -->|Valid| C["Create directory
+    ~/.ccm/profiles/&lt;name&gt;/"]
+    C -->|Already exists| ERR2["Exit with error"]
+    C -->|Created| D{"Write metadata
+    to config.json"}
+    D -->|Success| E["Profile ready
+    ✓ Next: ccm login &lt;name&gt;"]
+    D -->|Failure| F["Rollback: remove
+    directory and wrapper"]
+    F --> ERR3["Exit with error"]
+```
+
+Profile names must match `[a-zA-Z0-9_-]+` and cannot exceed 64 characters.
+
+`ccm list` and `ccm status` reconcile `config.json` with `~/.ccm/profiles/` instead of trusting just one source. Each profile is surfaced with one of these states:
+
+- `ready`: config entry and profile directory both exist
+- `orphaned`: directory exists but metadata is missing from `config.json`
+- `config-only`: metadata exists but the profile directory is missing
+
+### Launching Claude
+
+Both `ccm use` and `ccm run` resolve the profile directory, locate the Claude binary, and spawn it with the isolated config.
+
+```mermaid
+flowchart TD
+    A["ccm use &lt;name&gt; [-- args]
+    ccm run &lt;name&gt; -p &lt;prompt&gt;"] --> B{"Profile
+    exists?"}
+    B -->|No| ERR["Exit with error"]
+    B -->|Yes| C["Resolve profile directory
+    ~/.ccm/profiles/&lt;name&gt;/"]
+    C --> D["Find Claude binary
+    (CLAUDE_BIN or PATH)"]
+    D --> E["Spawn claude with
+    CLAUDE_CONFIG_DIR=profile_dir"]
+    E --> F["Inherit stdio
+    Forward exit code"]
+```
+
+`use` launches an interactive Claude session. Any args after `--` are passed through directly. `run` sends a prompt non-interactively via `-p`.
+
+### Authentication
+
+Login delegates entirely to Claude's own auth flow. OAuth launches the interactive Claude TUI directly; `--console` uses `claude auth login --console`. Status checks use `claude auth status --json` with a 10-second timeout.
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant ccm
+    participant Claude
+
+    User->>ccm: ccm login work
+    ccm->>ccm: Verify profile exists
+    ccm->>Claude: spawn "claude"<br/>CLAUDE_CONFIG_DIR=~/.ccm/profiles/work/
+    Claude-->>User: Interactive TUI for OAuth (or --console for API key)
+    Note over Claude: Auth tokens stored<br/>in profile directory
+
+    User->>ccm: ccm status work
+    ccm->>Claude: spawn "claude auth status --json"<br/>(10s timeout)
+    Claude-->>ccm: JSON response
+    ccm-->>User: Display: logged in, method, email, org
+    Note over ccm: On timeout or error:<br/>reports "unknown" gracefully
+```
+
+The `--console` flag on `login` enables API key authentication instead of the browser flow.
+
+### Removing Profiles
+
+Removal deletes the config entry, the profile directory, and any browser wrapper script. By default, it asks for confirmation.
+
+To avoid leaving config and filesystem out of sync, removal is staged: ccm temporarily renames on-disk assets, updates `config.json`, and only then finalizes deletion. If the config update fails, the staged assets are restored.
+
+```mermaid
+flowchart TD
+    A["ccm remove &lt;name&gt; [-f]"] --> B{"Profile
+    exists in config or filesystem?"}
+    B -->|No| ERR["Exit with error"]
+    B -->|Yes| C{"--force
+    flag?"}
+    C -->|Yes| E["Stage profile directory
+    and browser wrapper"]
+    C -->|No| D["Prompt: Remove profile? (y/N)"]
+    D -->|N| CANCEL["Cancelled"]
+    D -->|y| E
+    E --> F["Remove config entry
+    if present"]
+    F -->|Success| G["Finalize deletion"]
+    F -->|Failure| H["Restore staged assets"]
+    G --> I["✓ Profile removed"]
+```
+
+### Config Persistence
+
+ccm uses an atomic write pattern to prevent config corruption. Data is written to a temporary file, then atomically renamed:
+
+```ts
+const tmp = `${configFile}.tmp`
+writeFileSync(tmp, JSON.stringify(config, null, 2))
+renameSync(tmp, configFile)  // Atomic on POSIX filesystems
+```
+
+If the process crashes mid-write, the original config file remains intact. The config schema:
+
+```json
+{
+  "profiles": {
+    "work": {
+      "name": "work",
+      "label": "Work account",
+      "browser": "/path/to/browser",
+      "createdAt": "2025-03-15T10:30:00.000Z"
+    }
+  }
+}
+```
+
+On read errors (missing file, malformed JSON, invalid structure), ccm gracefully falls back to a default empty config rather than crashing.
+
+### Claude Binary Discovery
+
+ccm locates the Claude binary using the following strategy:
+
+1. Check the `CLAUDE_BIN` environment variable (explicit override)
+2. Use `which claude` (Unix/macOS) or `where claude` (Windows) to search `PATH`
+3. If neither succeeds, exit with a clear installation message
+
+## Configuration
+
+| Variable | Description |
+|---|---|
+| `CLAUDE_BIN` | Override the path to the Claude binary. Useful if Claude is installed in a non-standard location |
+
+All ccm data is stored in `~/.ccm/`. This includes the config file and all profile directories.
+
+## Privacy
+
+**ccm does not collect, store, or transmit any user data.** There is no telemetry, no analytics, no network calls of any kind.
+
+Everything stays on your machine:
+
+- **Profile metadata** (name, label, creation date) is stored locally in `~/.ccm/config.json`
+- **Auth tokens** are managed entirely by Claude Code inside each profile directory — ccm never reads or touches them
+- **No outbound connections** — ccm only spawns the local Claude binary, it never contacts any remote server
+
+You can verify this yourself: the runtime dependencies are [Commander.js](https://github.com/tj/commander.js) for CLI parsing and [Zod](https://zod.dev) for schema validation and type inference, and the CLI still makes zero HTTP requests.
+
+## Comparison
+
+| | Without ccm | With ccm |
+|---|---|---|
+| Switch accounts | `claude auth logout` then `claude auth login` | `ccm use work` |
+| Multiple sessions | Not possible simultaneously | Each profile runs independently |
+| Config mixing risk | High — single config directory | None — full isolation |
+| Setup per account | Manual every time | One-time `create` + `login` |
+
+## FAQ
+
+**Can I use two profiles at the same time?**
+
+Yes. Each profile has its own config directory. Run `ccm use work` in one terminal and `ccm use personal` in another — they are fully independent.
+
+**Does ccm modify Claude Code itself?**
+
+No. ccm only sets the `CLAUDE_CONFIG_DIR` environment variable when spawning Claude. It never modifies Claude's files or installation.
+
+**What happens if I delete `~/.ccm/`?**
+
+All profiles and their auth tokens are lost. Claude Code itself is unaffected.
+
+**Is Windows supported?**
+
+ccm uses cross-platform binary discovery (`which`/`where`) and standard Node.js filesystem APIs. It works on macOS, Linux, and Windows.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+[MIT](LICENSE)

package/dist/index.js

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { existsSync, mkdirSync, writeFileSync, chmodSync, renameSync, rmSync, unlinkSync, readFileSync, readdirSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { homedir } from 'os';
+import { z } from 'zod';
+import { spawn, execFileSync } from 'child_process';
+import { createInterface } from 'readline';
+
+var CCM_HOME = join(homedir(), ".ccm");
+var PROFILES_DIR = join(CCM_HOME, "profiles");
+var CONFIG_FILE = join(CCM_HOME, "config.json");
+var BROWSERS_DIR = join(CCM_HOME, "browsers");
+
+// src/lib/browsers.ts
+var SHELL_METACHAR = /[;|&`$(){}<>\\!\n\r]/;
+function validateBrowserCommand(cmd) {
+  if (SHELL_METACHAR.test(cmd)) {
+    throw new Error(
+      `Unsafe browser command "${cmd}". Shell metacharacters (;|&\`$(){}<>\\!) are not allowed.`
+    );
+  }
+}
+function ensureBrowserWrapper(profileName, browserCommand, browsersDir = BROWSERS_DIR) {
+  validateBrowserCommand(browserCommand);
+  if (!browserCommand.includes(" ")) return browserCommand;
+  if (!existsSync(browsersDir)) mkdirSync(browsersDir, { recursive: true });
+  const scriptPath = join(browsersDir, `${profileName}.sh`);
+  const content = `#!/bin/sh
+exec ${browserCommand} "$@"
+`;
+  const tmp = `${scriptPath}.tmp`;
+  writeFileSync(tmp, content);
+  chmodSync(tmp, 493);
+  renameSync(tmp, scriptPath);
+  return scriptPath;
+}
+function getStagedPath(path) {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const suffix = attempt === 0 ? `${process.pid}-${Date.now()}` : `${process.pid}-${Date.now()}-${attempt.toString()}`;
+    const candidate = `${path}.staged-${suffix}`;
+    if (!existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not allocate a temporary path for "${path}"`);
+}
+function getBrowserWrapperPath(profileName, browsersDir = BROWSERS_DIR) {
+  return join(browsersDir, `${profileName}.sh`);
+}
+function removeBrowserWrapper(profileName, browsersDir = BROWSERS_DIR) {
+  const wrapperPath = getBrowserWrapperPath(profileName, browsersDir);
+  if (!existsSync(wrapperPath)) {
+    return;
+  }
+  unlinkSync(wrapperPath);
+}
+function stageBrowserWrapperRemoval(profileName, browsersDir = BROWSERS_DIR) {
+  const wrapperPath = getBrowserWrapperPath(profileName, browsersDir);
+  if (!existsSync(wrapperPath)) {
+    return void 0;
+  }
+  const stagedPath = getStagedPath(wrapperPath);
+  renameSync(wrapperPath, stagedPath);
+  return stagedPath;
+}
+function restoreStagedBrowserWrapper(stagedPath, profileName, browsersDir = BROWSERS_DIR) {
+  renameSync(stagedPath, getBrowserWrapperPath(profileName, browsersDir));
+}
+function finalizeStagedBrowserWrapperRemoval(stagedPath) {
+  rmSync(stagedPath, { force: true });
+}
+function resolveBrowser(cliOverride, meta) {
+  return cliOverride ?? meta?.browser;
+}
+var MAX_PROFILE_NAME_LENGTH = 64;
+var PROFILE_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var ProfileNameSchema = z.string().min(1).max(MAX_PROFILE_NAME_LENGTH).regex(PROFILE_NAME_PATTERN);
+var ProfileMetaSchema = z.object({
+  name: ProfileNameSchema,
+  label: z.string().optional(),
+  browser: z.string().optional(),
+  createdAt: z.string()
+}).passthrough();
+var CcmConfigSchema = z.object({
+  profiles: z.record(z.string(), ProfileMetaSchema)
+}).passthrough();
+var ClaudeAuthStatusSchema = z.object({
+  loggedIn: z.boolean(),
+  authMethod: z.string(),
+  email: z.string().optional(),
+  orgName: z.string().optional(),
+  subscriptionType: z.string().optional(),
+  apiKeySource: z.string().optional()
+}).passthrough();
+
+// src/lib/config.ts
+var DEFAULT_CONFIG = { profiles: {} };
+function loadConfig(configFile = CONFIG_FILE) {
+  try {
+    const raw = readFileSync(configFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    const result = CcmConfigSchema.safeParse(parsed);
+    return result.success ? result.data : { ...DEFAULT_CONFIG, profiles: {} };
+  } catch {
+    return { ...DEFAULT_CONFIG, profiles: {} };
+  }
+}
+function saveConfig(config, configFile = CONFIG_FILE) {
+  const validatedConfig = CcmConfigSchema.parse(config);
+  const dir = dirname(configFile);
+  mkdirSync(dir, { recursive: true });
+  const tmp = `${configFile}.tmp`;
+  writeFileSync(tmp, JSON.stringify(validatedConfig, null, 2), { mode: 384 });
+  renameSync(tmp, configFile);
+}
+function addProfile(meta, configFile = CONFIG_FILE) {
+  const config = loadConfig(configFile);
+  const validatedMeta = ProfileMetaSchema.parse(meta);
+  if (config.profiles[validatedMeta.name]) {
+    throw new Error(`Profile "${validatedMeta.name}" already exists`);
+  }
+  config.profiles[validatedMeta.name] = validatedMeta;
+  saveConfig(config, configFile);
+}
+function removeProfile(name, configFile = CONFIG_FILE) {
+  const config = loadConfig(configFile);
+  if (!config.profiles[name]) {
+    throw new Error(`Profile "${name}" not found`);
+  }
+  delete config.profiles[name];
+  saveConfig(config, configFile);
+}
+function getProfile(name, configFile = CONFIG_FILE) {
+  return loadConfig(configFile).profiles[name];
+}
+function validateProfileName(name) {
+  const result = ProfileNameSchema.safeParse(name);
+  if (result.success) {
+    return;
+  }
+  if (name.length > MAX_PROFILE_NAME_LENGTH) {
+    throw new Error(`Profile name too long (max ${MAX_PROFILE_NAME_LENGTH} chars).`);
+  }
+  throw new Error(
+    `Invalid profile name "${name}". Use only letters, numbers, hyphens, underscores.`
+  );
+}
+function createProfileDir(name, profilesDir = PROFILES_DIR) {
+  validateProfileName(name);
+  const dir = join(profilesDir, name);
+  if (existsSync(dir)) {
+    throw new Error(`Profile directory "${name}" already exists`);
+  }
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function removeProfileDir(name, profilesDir = PROFILES_DIR) {
+  const dir = join(profilesDir, name);
+  if (!existsSync(dir)) {
+    throw new Error(`Profile directory "${name}" does not exist`);
+  }
+  rmSync(dir, { recursive: true });
+}
+function getStagedPath2(path) {
+  const parentDir = dirname(path);
+  const baseName = basename(path);
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const suffix = attempt === 0 ? `${process.pid}-${Date.now()}` : `${process.pid}-${Date.now()}-${attempt.toString()}`;
+    const candidate = join(parentDir, `.${baseName}.staged-${suffix}`);
+    if (!existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not allocate a temporary path for "${baseName}"`);
+}
+function stageProfileDirRemoval(name, profilesDir = PROFILES_DIR) {
+  const dir = join(profilesDir, name);
+  if (!existsSync(dir)) {
+    throw new Error(`Profile directory "${name}" does not exist`);
+  }
+  const stagedDir = getStagedPath2(dir);
+  renameSync(dir, stagedDir);
+  return stagedDir;
+}
+function restoreStagedProfileDir(stagedDir, name, profilesDir = PROFILES_DIR) {
+  renameSync(stagedDir, join(profilesDir, name));
+}
+function finalizeStagedProfileDirRemoval(stagedDir) {
+  rmSync(stagedDir, { recursive: true });
+}
+function getProfileDir(name, profilesDir = PROFILES_DIR) {
+  return join(profilesDir, name);
+}
+function profileExists(name, profilesDir = PROFILES_DIR) {
+  return existsSync(join(profilesDir, name));
+}
+function listProfileDirs(profilesDir = PROFILES_DIR) {
+  if (!existsSync(profilesDir)) return [];
+  return readdirSync(profilesDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
+}
+
+// src/commands/create.ts
+function registerCreate(program2) {
+  program2.command("create <name>").description("Create a new profile").option("-l, --label <label>", "Profile label").option("-b, --browser <path>", "Browser for OAuth login").action((name, opts) => {
+    try {
+      createProfileDir(name);
+      const browser = opts.browser ? ensureBrowserWrapper(name, opts.browser) : void 0;
+      try {
+        addProfile({
+          name,
+          label: opts.label,
+          browser,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (configErr) {
+        try {
+          removeProfileDir(name);
+        } catch {
+        }
+        try {
+          removeBrowserWrapper(name);
+        } catch {
+        }
+        throw configErr;
+      }
+      console.log(`\x1B[32m\u2713\x1B[0m Profile "${name}" created`);
+      console.log(`  Next: ccm login ${name}`);
+    } catch (e) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  });
+}
+var UNKNOWN_AUTH_STATUS = { loggedIn: false, authMethod: "unknown" };
+function findClaudeBinary() {
+  if (process.env.CLAUDE_BIN) return process.env.CLAUDE_BIN;
+  const cmd = process.platform === "win32" ? "where" : "which";
+  try {
+    const result = execFileSync(cmd, ["claude"], { encoding: "utf-8" }).trim().split("\n")[0];
+    if (!result) throw new Error("not found");
+    return result;
+  } catch {
+    throw new Error("Claude Code not found. Install: npm i -g @anthropic-ai/claude-code");
+  }
+}
+function spawnClaude(profileDir, args, opts) {
+  const bin = findClaudeBinary();
+  const env = {
+    ...process.env,
+    CLAUDE_CONFIG_DIR: profileDir
+  };
+  if (opts?.browser) env.BROWSER = opts.browser;
+  return spawn(bin, args, { env, stdio: "inherit" });
+}
+function getAuthStatus(profileDir) {
+  const bin = findClaudeBinary();
+  return new Promise((resolve) => {
+    const child = spawn(bin, ["auth", "status", "--json"], {
+      env: { ...process.env, CLAUDE_CONFIG_DIR: profileDir },
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    let stdout = "";
+    if (!child.stdout) {
+      resolve(UNKNOWN_AUTH_STATUS);
+      return;
+    }
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve(UNKNOWN_AUTH_STATUS);
+    }, 1e4);
+    child.on("close", () => {
+      clearTimeout(timeout);
+      try {
+        const parsed = JSON.parse(stdout);
+        const result = ClaudeAuthStatusSchema.safeParse(parsed);
+        resolve(result.success ? result.data : UNKNOWN_AUTH_STATUS);
+      } catch {
+        resolve(UNKNOWN_AUTH_STATUS);
+      }
+    });
+    child.on("error", () => {
+      clearTimeout(timeout);
+      resolve(UNKNOWN_AUTH_STATUS);
+    });
+  });
+}
+
+// src/lib/profile-store.ts
+function getProfileState(hasConfig, hasDirectory) {
+  if (hasConfig && hasDirectory) return "ready";
+  if (hasDirectory) return "orphaned";
+  return "config-only";
+}
+function listStoredProfiles(configFile = CONFIG_FILE, profilesDir = PROFILES_DIR) {
+  const config = loadConfig(configFile);
+  const dirNames = new Set(listProfileDirs(profilesDir));
+  const names = /* @__PURE__ */ new Set([...Object.keys(config.profiles), ...dirNames]);
+  return [...names].sort((left, right) => left.localeCompare(right)).map((name) => {
+    const meta = config.profiles[name];
+    const hasConfig = meta !== void 0;
+    const hasDirectory = dirNames.has(name);
+    return {
+      name,
+      dir: getProfileDir(name, profilesDir),
+      meta,
+      state: getProfileState(hasConfig, hasDirectory),
+      hasConfig,
+      hasDirectory
+    };
+  });
+}
+function getStoredProfile(name, configFile = CONFIG_FILE, profilesDir = PROFILES_DIR) {
+  const meta = getProfile(name, configFile);
+  const hasConfig = meta !== void 0;
+  const hasDirectory = profileExists(name, profilesDir);
+  if (!hasConfig && !hasDirectory) {
+    return void 0;
+  }
+  return {
+    name,
+    dir: getProfileDir(name, profilesDir),
+    meta,
+    state: getProfileState(hasConfig, hasDirectory),
+    hasConfig,
+    hasDirectory
+  };
+}
+function removeStoredProfile(name, configFile = CONFIG_FILE, profilesDir = PROFILES_DIR, browsersDir = BROWSERS_DIR) {
+  const profile = getStoredProfile(name, configFile, profilesDir);
+  if (!profile) {
+    throw new Error(`Profile "${name}" does not exist`);
+  }
+  const stagedDir = profile.hasDirectory ? stageProfileDirRemoval(name, profilesDir) : void 0;
+  const stagedWrapper = stageBrowserWrapperRemoval(name, browsersDir);
+  try {
+    if (profile.hasConfig) {
+      removeProfile(name, configFile);
+    }
+  } catch (error) {
+    try {
+      rollbackStorage(name, stagedDir, stagedWrapper, profilesDir, browsersDir);
+    } catch (rollbackError) {
+      throw new Error(
+        `Failed to remove profile "${name}": ${formatError(error)}. Rollback failed: ${formatError(
+          rollbackError
+        )}`
+      );
+    }
+    throw error;
+  }
+  try {
+    if (stagedDir) {
+      finalizeStagedProfileDirRemoval(stagedDir);
+    }
+    if (stagedWrapper) {
+      finalizeStagedBrowserWrapperRemoval(stagedWrapper);
+    }
+  } catch (error) {
+    const recoveryErrors = [];
+    try {
+      rollbackStorage(name, stagedDir, stagedWrapper, profilesDir, browsersDir);
+    } catch (rollbackError) {
+      recoveryErrors.push(formatError(rollbackError));
+    }
+    if (profile.meta) {
+      try {
+        restoreConfigEntry(profile.meta, configFile);
+      } catch (configRestoreError) {
+        recoveryErrors.push(`config: ${formatError(configRestoreError)}`);
+      }
+    }
+    if (recoveryErrors.length > 0) {
+      throw new Error(
+        `Failed to remove profile "${name}": ${formatError(error)}. Recovery failed: ${recoveryErrors.join(
+          "; "
+        )}`
+      );
+    }
+    throw error;
+  }
+}
+function rollbackStorage(name, stagedDir, stagedWrapper, profilesDir, browsersDir) {
+  const rollbackErrors = [];
+  if (stagedDir) {
+    try {
+      restoreStagedProfileDir(stagedDir, name, profilesDir);
+    } catch (error) {
+      rollbackErrors.push(`profile dir: ${formatError(error)}`);
+    }
+  }
+  if (stagedWrapper) {
+    try {
+      restoreStagedBrowserWrapper(stagedWrapper, name, browsersDir);
+    } catch (error) {
+      rollbackErrors.push(`browser wrapper: ${formatError(error)}`);
+    }
+  }
+  if (rollbackErrors.length > 0) {
+    throw new Error(`Rollback failed for profile "${name}": ${rollbackErrors.join("; ")}`);
+  }
+}
+function restoreConfigEntry(meta, configFile) {
+  if (getProfile(meta.name, configFile)) {
+    return;
+  }
+  addProfile(meta, configFile);
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/list.ts
+function registerList(program2) {
+  program2.command("list").description("List all profiles, including drifted config/filesystem entries").action(async () => {
+    const profiles = listStoredProfiles();
+    if (profiles.length === 0) {
+      console.log("No profiles. Create one: ccm create <name>");
+      return;
+    }
+    const statuses = await Promise.all(
+      profiles.map(async (profile) => {
+        const status = profile.hasDirectory ? await getAuthStatus(profile.dir) : void 0;
+        return { profile, status };
+      })
+    );
+    console.log(
+      `${"NAME".padEnd(20)}${"STATE".padEnd(14)}${"AUTH".padEnd(15)}${"ACCOUNT".padEnd(
+        35
+      )}CREATED`
+    );
+    console.log("\u2500".repeat(99));
+    for (const { profile, status } of statuses) {
+      const account = status?.email ?? status?.apiKeySource ?? "\u2014";
+      const authMethod = status?.authMethod ?? "unavailable";
+      const created = profile.meta?.createdAt.slice(0, 10) ?? "\u2014";
+      console.log(
+        `${profile.name.padEnd(20)}${profile.state.padEnd(14)}${authMethod.padEnd(
+          15
+        )}${account.padEnd(35)}${created}`
+      );
+    }
+  });
+}
+
+// src/commands/login.ts
+function registerLogin(program2) {
+  program2.command("login <name>").description("Login to Claude Code with a profile").option("--console", "Use Anthropic Console (API key) auth").option("-b, --browser <path>", "Browser to use for OAuth").option("--url-only", "Print login URL without opening browser (supports code paste)").action((name, opts) => {
+    try {
+      if (!profileExists(name)) {
+        throw new Error(`Profile "${name}" does not exist. Create it first: ccm create ${name}`);
+      }
+      const dir = getProfileDir(name);
+      const meta = getProfile(name);
+      let browser;
+      if (opts.urlOnly) {
+        browser = "true";
+      } else {
+        browser = resolveBrowser(opts.browser, meta);
+      }
+      if (opts.console) {
+        const child = spawnClaude(dir, ["auth", "login", "--console"], { browser });
+        child.on("close", (code) => process.exit(code ?? 0));
+      } else {
+        const child = spawnClaude(dir, [], { browser });
+        child.on("close", (code) => process.exit(code ?? 0));
+      }
+    } catch (e) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  });
+}
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+function registerRemove(program2) {
+  program2.command("remove <name>").description("Remove a profile").option("-f, --force", "Skip confirmation").action(async (name, opts) => {
+    try {
+      const profile = getStoredProfile(name);
+      if (!profile) {
+        throw new Error(`Profile "${name}" does not exist`);
+      }
+      if (!opts.force) {
+        const ok = await confirm(`Remove profile "${name}"? (y/N) `);
+        if (!ok) {
+          console.log("Cancelled");
+          return;
+        }
+      }
+      removeStoredProfile(name);
+      const stateSuffix = profile.state === "ready" ? "" : ` (${profile.state})`;
+      console.log(`\x1B[32m\u2713\x1B[0m Profile "${name}" removed${stateSuffix}`);
+    } catch (e) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/run.ts
+function registerRun(program2) {
+  program2.command("run <name>").description("Run Claude Code with a prompt using a profile").requiredOption("-p, --prompt <prompt>", "Prompt to send").action((name, opts) => {
+    try {
+      if (!profileExists(name)) {
+        throw new Error(`Profile "${name}" does not exist`);
+      }
+      const dir = getProfileDir(name);
+      const child = spawnClaude(dir, ["-p", opts.prompt]);
+      child.on("close", (code) => process.exit(code ?? 0));
+    } catch (e) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/status.ts
+function registerStatus(program2) {
+  program2.command("status [name]").description("Show auth status for a profile (or all profiles)").action(async (name) => {
+    try {
+      if (name) {
+        const profile = getStoredProfile(name);
+        if (!profile) {
+          throw new Error(`Profile "${name}" does not exist`);
+        }
+        const status = profile.hasDirectory ? await getAuthStatus(profile.dir) : void 0;
+        console.log(`Profile: ${name}`);
+        console.log(`State: ${profile.state}`);
+        console.log(`Logged in: ${status?.loggedIn ?? "unknown"}`);
+        console.log(`Auth method: ${status?.authMethod ?? "unavailable"}`);
+        if (profile.meta?.createdAt) console.log(`Created: ${profile.meta.createdAt}`);
+        if (!profile.hasDirectory) console.log("Directory: missing");
+        if (status?.email) console.log(`Email: ${status.email}`);
+        if (status?.orgName) console.log(`Org: ${status.orgName}`);
+        if (status?.subscriptionType) console.log(`Subscription: ${status.subscriptionType}`);
+      } else {
+        const profiles = listStoredProfiles();
+        if (profiles.length === 0) {
+          console.log("No profiles.");
+          return;
+        }
+        const statuses = await Promise.all(
+          profiles.map(async (profile) => ({
+            profile,
+            status: profile.hasDirectory ? await getAuthStatus(profile.dir) : void 0
+          }))
+        );
+        for (const { profile, status } of statuses) {
+          const icon = status?.loggedIn === true ? "\x1B[32m\u25CF\x1B[0m" : "\x1B[31m\u25CF\x1B[0m";
+          const account = status?.email ?? status?.apiKeySource ?? "\u2014";
+          const authMethod = status?.authMethod ?? "unavailable";
+          const stateSuffix = profile.state === "ready" ? "" : ` [${profile.state}]`;
+          console.log(
+            `${icon} ${profile.name.padEnd(20)} ${authMethod.padEnd(15)} ${account}${stateSuffix}`
+          );
+        }
+      }
+    } catch (e) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/use.ts
+function registerUse(program2) {
+  program2.command("use <name>").description("Launch Claude Code with a profile").allowUnknownOption().helpOption(false).action((name, _opts, cmd) => {
+    try {
+      if (!profileExists(name)) {
+        throw new Error(`Profile "${name}" does not exist. Create it first: ccm create ${name}`);
+      }
+      const dir = getProfileDir(name);
+      const passthroughArgs = cmd.args.slice(1);
+      const child = spawnClaude(dir, passthroughArgs);
+      child.on("close", (code) => process.exit(code ?? 0));
+    } catch (e) {
+      console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command().name("ccm").version("0.1.0").description("Manage multiple Claude Code profiles");
+registerCreate(program);
+registerList(program);
+registerRemove(program);
+registerLogin(program);
+registerStatus(program);
+registerUse(program);
+registerRun(program);
+program.parse();

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@remeic/ccm",
+  "version": "0.1.0",
+  "description": "nvm-like manager for Claude Code profiles",
+  "license": "MIT",
+  "author": "Giulio Fagioli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/remeic/ccm-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/remeic/ccm-cli/issues"
+  },
+  "homepage": "https://github.com/remeic/ccm-cli#readme",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "profile-manager",
+    "cli",
+    "multi-account",
+    "anthropic"
+  ],
+  "type": "module",
+  "bin": {
+    "ccm": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:mutation": "stryker run",
+    "lint": "biome check src tests",
+    "format": "biome format --write src tests",
+    "lint:fix": "biome check --write src tests",
+    "prepublishOnly": "bun run build",
+    "prepare": "husky"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.10",
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
+    "@stryker-mutator/core": "^9.6.0",
+    "@stryker-mutator/typescript-checker": "^9.6.0",
+    "@stryker-mutator/vitest-runner": "^9.6.0",
+    "@vitest/coverage-v8": "^3.1.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  }
+}