cchost 0.2.1 → 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,111 @@
+# Changelog
+
+All notable changes to `cchost` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.3.1] - 2026-05-19
+
+### Changed
+
+- **Custom API endpoints are now configured through `cc add`, not `cc env`.**
+  The standalone `cc env` command (shipped in 0.3.0) is removed; endpoint
+  configuration is folded into the profile-creation command:
+  - `cc add <profile> --custom` — create a custom-endpoint profile via an
+    interactive wizard; the token is never echoed.
+  - `cc add <profile> --custom --base-url=URL --token=TOKEN [--model/--opus/--sonnet/--haiku/--subagent=NAME]`
+    — non-interactive create.
+  - Re-running `cc add <profile> --custom` on an existing endpoint profile
+    edits it in place (wizard prefills current values; with flags, only the
+    flags you pass are changed).
+  - `cc add --custom` is atomic — cancelling the wizard leaves no profile
+    behind.
+- **Endpoint inspection moved to `cc list`.** `cc env show` is replaced by
+  `cc list <profile>` — a per-profile detail view. `cc list <profile> --reveal`
+  unmasks the API token; `cc list <profile> --json` emits it as an object
+  (token always masked in JSON).
+
+### Removed
+
+- `cc env` and `cc env show` — superseded by `cc add --custom` and
+  `cc list <profile>`.
+
+### Notes
+
+- A profile is still born subscription or endpoint and stays that way:
+  `cc add --custom` refuses a profile that already has Anthropic OAuth
+  credentials. `.cc-env.json` is still never migrated and never linked, and is
+  still written with user-only file permissions.
+
+## [0.3.0] - 2026-05-19
+
+### Added
+
+- **Per-profile custom API endpoints (`cc env`).** A profile can now route
+  through any Anthropic-compatible third-party provider (Moonshot/Kimi,
+  OpenRouter, Requesty, self-hosted vLLM, corporate proxies) instead of
+  Anthropic's subscription OAuth.
+  - `cc env <profile>` — interactive wizard; the token is never echoed.
+  - `cc env <profile> --base-url=URL --token=TOKEN [--model/--opus/--sonnet/--haiku/--subagent=NAME]`
+    — non-interactive create, or partial update on an existing endpoint profile.
+  - `cc env <profile> show [--reveal]` — print the config; the token is masked
+    by default, `--reveal` prints it in full.
+- `cc use` injects the corresponding `ANTHROPIC_*` / `CLAUDE_CODE_*` env vars
+  from `.cc-env.json` and prints a one-line endpoint + billing banner to stderr.
+- `cc list` gained an `Endpoint` column (the endpoint host, or `subscription`).
+- README section "Custom endpoints (Kimi, OpenRouter, etc.)" with a billing
+  note and a worked Moonshot example.
+
+### Security
+
+- `.cc-env.json` holds a third-party API key. It is treated like
+  `.credentials.json`: written with user-only file permissions, and never
+  copied or linked by `cc migrate` / `cc link`.
+- A profile is born OAuth or endpoint and stays that way — `cc env` refuses to
+  run on a profile that already has Anthropic OAuth credentials.
+
+### Notes
+
+- Endpoint profiles bill through the third-party provider, not your Anthropic
+  subscription.
+
+## [0.2.1] - 2026-05-18
+
+### Added
+
+- `cc link` / `cc unlink` now operate on `projects/`, `skills/`, `agents/`,
+  and `commands/` (previously `projects/` only), with per-directory
+  partial-failure handling.
+- `cc migrate` extended: `default → <profile>` also copies `mcp.json`,
+  `settings.json`, and `CLAUDE.md`; `--force` overwrites instead of
+  skip-on-collision.
+- `cc list` reports shared state as `N/4`.
+- README: migrate-vs-link artifact table.
+
+## [0.2.0] - 2026-05-16
+
+### Added
+
+- `cc --version` / `cc -v` — prints the installed version.
+- `cc doctor [--fix [--force]] [--json]` — environment, storage, and platform
+  diagnostics with safe and confirmation-gated fixes.
+
+### Removed
+
+- The `cc add` alias-masking feature — Claude Code re-syncs account fields from
+  the server on every launch, so masking was not worth shipping.
+
+## [0.1.2] - 2026-05-15
+
+### Changed
+
+- `sessions/` dropped from `share`, `migrate`, and `cc list` — it is transient
+  per-process state and must stay per-profile.
+- Cross-platform claim narrowed to the verified scope (Windows and Linux).
+
+[0.3.1]: https://github.com/allenhack638/cchost/releases/tag/v0.3.1
+[0.3.0]: https://github.com/allenhack638/cchost/releases/tag/v0.3.0
+[0.2.1]: https://github.com/allenhack638/cchost/releases/tag/v0.2.1
+[0.2.0]: https://github.com/allenhack638/cchost/releases/tag/v0.2.0
+[0.1.2]: https://github.com/allenhack638/cchost/releases/tag/v0.1.2

package/README.md

@@ -16,9 +16,10 @@ Requires Node.js 18+ and Claude Code 2.1.140+ already installed. Get Claude Code
 
 | Command | What it does |
 | --- | --- |
-| `cc add <profile>` | Create a profile directory. |
+| `cc add <profile>` | Create a subscription profile (logs in with Anthropic OAuth on first use). |
+| `cc add <profile> --custom [...]` | Create — or, if it already exists, edit — a profile routed through a custom API endpoint. Opens a wizard, or takes `--base-url=URL --token=TOKEN [--model=…]`. See [Custom endpoints](#custom-endpoints-kimi-openrouter-etc). |
 | `cc use <profile> [...args]` | Launch Claude under that profile. Profile must already exist. Args after the name are forwarded verbatim to `claude`. |
-| `cc list [--json]` | Show every profile: login state, account email, and how many artifact dirs are linked to shared (N/4). |
+| `cc list [<profile>] [--json] [--reveal]` | List every profile (login state, email, shared dirs N/4, endpoint), or show one profile in detail. `--reveal` unmasks a custom endpoint's API token. |
 | `cc migrate <src> <dest> [--force]` | Copy artifacts from `default`\|`shared` to `shared`\|`<profile>`. Skip-on-collision by default; `--force` overwrites. |
 | `cc link <profile> [<profile>...]` | Link a profile's artifact dirs to `~/.claude-shared/`. Migrates existing content; renames on collision. |
 | `cc unlink <profile>` | Restore a profile to its own private artifact dirs (copies shared content back). |
@@ -40,12 +41,36 @@ cc remove old-profile
 `cc list` output:
 
 ```
-Profile   LoggedIn  Email                 Shared
-personal  true      personal@example.com  4/4
-scratch   false     -                     0/4
-work      true      work@example.com      0/4
+Profile   LoggedIn  Email                 Shared  Endpoint
+kimi      false     -                     0/4     api.moonshot.ai
+personal  true      personal@example.com  4/4     subscription
+scratch   false     -                     0/4     subscription
+work      true      work@example.com      0/4     subscription
 ```
 
+The **Shared** column is a count: how many of the 4 shareable directories
+(`projects`, `skills`, `agents`, `commands`) are linked to `~/.claude-shared/`.
+
+- `0/4` — fully isolated; the profile keeps its own private copies.
+- `4/4` — fully shared; all four point at the common pool.
+- `1/4`, `2/4`, `3/4` — **partial**, and not a normal state. `cc link` links
+  all four at once and `cc unlink` unlinks all four at once, so you should
+  normally see only `0/4` or `4/4`.
+
+A partial count has two causes:
+
+1. **A link partially failed** — one directory could not be linked (a
+   permission issue, or it was locked) while the others succeeded. `cc link`
+   reports per-directory failures so this is never silent.
+2. **An upgrade from an older cchost.** Versions before `0.2.1` linked only
+   `projects/` — the other three shareable directories did not exist yet. A
+   profile linked under an older version therefore shows `1/4` after you
+   upgrade.
+
+In both cases the fix is the same — re-run `cc link <profile>`. Already-linked
+directories are skipped and the missing ones are linked, bringing the profile
+to `4/4`.
+
 ### What migrate copies and what link shares
 
 | Artifact | `cc migrate` copies it | `cc link` shares it | Notes |
@@ -61,6 +86,7 @@ work      true      work@example.com      0/4
 | `plugins/` | — | — | Carries auth tokens; deferred to a future opt-in flag |
 | `.credentials.json` | — | — | Never touched — each profile keeps its own auth |
 | `.claude.json` | — | — | Never touched — re-synced from server on every launch |
+| `.cc-env.json` | — | — | Per-profile custom-endpoint config; holds an API key. Never migrated, never linked. |
 
 `mcp.json`, `settings.json`, and `CLAUDE.md` are **not** copied to `shared` and are **not** linked because they typically carry auth tokens or per-profile configuration that should not leak across accounts.
 
@@ -98,6 +124,66 @@ 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 links, never recursing into the shared target.
 
+## Custom endpoints (Kimi, OpenRouter, etc.)
+
+A profile can route through any Anthropic-compatible API endpoint instead of Anthropic's subscription OAuth — Moonshot/Kimi, OpenRouter, Requesty, a self-hosted vLLM, or a corporate proxy. You declare this when you create the profile, with `cc add <profile> --custom`.
+
+> **Billing:** a custom-endpoint profile bills through the **third-party provider**, using the API key you supply — **not** your Anthropic subscription. You are responsible for that provider's usage charges. A subscription profile is unaffected.
+
+A custom-endpoint profile and a subscription profile are mutually exclusive: a profile is born one or the other and stays that way. `cc add --custom` refuses to run on a profile that already has Anthropic OAuth credentials — create custom-endpoint profiles fresh.
+
+### Worked example — Moonshot / Kimi
+
+```bash
+cc add kimi --custom --base-url=https://api.moonshot.ai/anthropic \
+                     --token=sk-your-moonshot-key \
+                     --model=kimi-k2.5
+cc use kimi
+```
+
+Moonshot's endpoint URL ends in `/anthropic` — Claude Code appends `/v1/messages` itself, so do **not** add `/v1`. Most third-party providers serve a single model name; pass it as `--model` and it is applied to every tier (opus/sonnet/haiku/subagent). To override a tier, pass `--opus=`, `--sonnet=`, `--haiku=`, or `--subagent=`.
+
+Run `cc add <profile> --custom` with no value flags for an interactive wizard instead — it prompts for every field and never echoes the token. `cc add --custom` is atomic: if you cancel the wizard, no profile is left behind.
+
+### Editing a custom-endpoint profile
+
+Re-run `cc add <profile> --custom` on a profile that already has a custom endpoint and it switches to **edit mode**: the wizard prefills current values, and with flags only the flags you pass are changed.
+
+```bash
+cc add kimi --custom --model=kimi-k3      # change just the model
+cc add kimi --custom --token=sk-rotated   # rotate the API key
+```
+
+Inspect a config with `cc list <profile>` — the API token is masked:
+
+```
+Profile:   kimi
+Directory: /home/you/.claude-profiles/kimi
+LoggedIn:  false
+Email:     -
+Shared:    0/4
+Endpoint:  api.moonshot.ai
+  Base URL:  https://api.moonshot.ai/anthropic
+  Token:     sk-you...key9 (32 chars)
+  Model:     kimi-k2.5
+  Opus:      kimi-k2.5
+  Sonnet:    kimi-k2.5
+  Haiku:     kimi-k2.5
+  Subagent:  kimi-k2.5
+```
+
+`cc list <profile> --reveal` prints the full API key instead — do not paste that output anywhere.
+
+There is no way to convert a custom-endpoint profile back to a subscription profile. To stop using an endpoint, `cc remove` the profile and recreate it.
+
+When you launch a custom-endpoint profile, `cc use` prints a one-line reminder to stderr:
+
+```
+[cchost] Profile 'kimi' → api.moonshot.ai (custom endpoint billing applies)
+```
+
+The config lives at `~/.claude-profiles/<profile>/.cc-env.json` with user-only file permissions. It contains your API key — see [Sensitive data](#sensitive-data).
+
 ## How it works
 
 `cc` is a Node CLI with **zero runtime dependencies**. For `cc use` it:
@@ -113,6 +199,8 @@ The env var is set on the child process only — that's all `claude` needs.
 
 `~/.claude-profiles/<profile>/` holds real OAuth credentials. Treat it like SSH keys: don't commit it, don't share it, don't sync it to public cloud storage. The `.gitignore` shipped with this project excludes profile directories from anywhere they might land. `cc migrate` and `cc link` never copy `.credentials.json` or `.claude.json` across profiles.
 
+`.cc-env.json` (custom-endpoint config) contains a third-party **API key** — treat it exactly like `.credentials.json`. It is written with user-only file permissions, and `cc migrate`/`cc link` never copy or link it across profiles. `cc list <profile>` masks the token; only `cc list <profile> --reveal` prints it in full.
+
 ## Troubleshooting
 
 **`Claude Code does not appear to be installed`**

package/lib/cli.js

@@ -7,6 +7,7 @@ const readline = require('readline');
 const profiles = require('./profiles');
 const share = require('./share');
 const migrateLib = require('./migrate');
+const envLib = require('./env');
 const { spawnClaude } = require('./spawn');
 const { renderTable } = require('./format');
 const color = require('./color');
@@ -14,9 +15,9 @@ const color = require('./color');
 const HELP = `cc - Multi-profile launcher for Claude Code
 
 Usage:
-  cc add <profile>                                 Create a profile directory
+  cc add <profile> [--custom [...]]                Create a profile (--custom: route through a custom API endpoint)
   cc use <profile> [...args]                       Launch Claude under a named profile
-  cc list [--json]                                 Show all profiles: login state, email, shared-dir count (N/4)
+  cc list [<profile>] [--json] [--reveal]          List all profiles, or show one profile in detail
   cc migrate <src> <dest> [--force]                Copy artifact dirs (and config files) between profiles
   cc link <p>...                                   Link each profile's artifact dirs to ~/.claude-shared/
   cc unlink <profile>                              Restore a profile's private artifact dirs
@@ -30,13 +31,43 @@ for that launch. Args after the profile name are forwarded verbatim to claude.
 `;
 
 const HELP_BY_CMD = {
-  add: `cc add <profile>
+  add: `cc add <profile> [--custom [--base-url=URL --token=TOKEN ...]]
 
 Create a new profile directory without launching Claude.
 
+  cc add <profile>
+      Create a regular profile. It logs in with your Anthropic
+      subscription (OAuth) on the first 'cc use'.
+
+  cc add <profile> --custom
+      Create a profile routed through a custom, Anthropic-compatible API
+      endpoint — Moonshot/Kimi, OpenRouter, a self-hosted vLLM, a corporate
+      proxy, and so on. Opens an interactive wizard; the API token is never
+      echoed to the screen.
+
+  cc add <profile> --custom --base-url=URL --token=TOKEN
+                          [--model=NAME] [--opus=NAME] [--sonnet=NAME]
+                          [--haiku=NAME] [--subagent=NAME]
+      Same, non-interactive. --base-url and --token are required.
+
+Re-running 'cc add <profile> --custom' on an existing endpoint profile
+EDITS its configuration: the wizard prefills current values, and with
+flags only the flags you pass are changed. View a config with
+'cc list <profile>'.
+
+Billing: a custom-endpoint profile bills through the third-party provider,
+NOT your Anthropic subscription. A profile is born subscription or endpoint
+and stays that way — 'cc add --custom' refuses a profile that already has
+Anthropic OAuth credentials.
+
+The endpoint config lives at ~/.claude-profiles/<profile>/.cc-env.json with
+user-only permissions. It is never migrated and never linked.
+
 Examples:
   cc add work
-  cc add personal
+  cc add kimi --custom
+  cc add kimi --custom --base-url=https://api.moonshot.ai/anthropic --token=sk-... --model=kimi-k2.5
+  cc add kimi --custom --model=kimi-k3       # edit just the model later
 `,
   use: `cc use <profile> [...args]
 
@@ -52,7 +83,9 @@ Examples:
   cc use work --resume
   cc use personal -p "summarize this codebase"
 `,
-  list: `cc list [--json]
+  list: `cc list [<profile>] [--json] [--reveal]
+
+Without a profile name: list every profile as a table.
 
 Columns:
   Profile   - profile name
@@ -61,8 +94,18 @@ Columns:
   Shared    - N/4 linked to ~/.claude-shared/ (projects, skills, agents, commands)
               4/4 = fully shared, 0/4 = fully isolated
               (sessions/ is transient per-process state and is never shared)
-
-With --json, emits an array of {name, dir, loggedIn, email, shared}.
+  Endpoint  - custom-endpoint host from .cc-env.json, or "subscription" if the
+              profile uses Anthropic's subscription OAuth
+
+With a profile name: print that one profile's detail, including its custom
+endpoint configuration if it has one. The API token is masked by default;
+--reveal prints it in full — do not paste that output anywhere.
+
+  cc list                      Table of all profiles
+  cc list --json               Same, as a JSON array
+  cc list <profile>            Detail for a single profile
+  cc list <profile> --reveal   Detail with the full API token shown
+  cc list <profile> --json     Detail as a JSON object (token always masked)
 `,
   migrate: `cc migrate <src> <dest> [--force]
 
@@ -231,14 +274,104 @@ function parseFlagsStrict(args, flagNames, { allowPositional = false } = {}) {
   return { flags, positional };
 }
 
+// Flag name -> .cc-env.json field, for `cc add --custom`.
+const ENDPOINT_VALUE_FLAGS = {
+  '--base-url': 'base_url',
+  '--token': 'auth_token',
+  '--model': 'model',
+  '--opus': 'opus',
+  '--sonnet': 'sonnet',
+  '--haiku': 'haiku',
+  '--subagent': 'subagent',
+};
+
 async function cmdAdd(rest) {
-  const [name, ...extra] = rest;
-  if (!name) throw usageError('Usage: cc add <profile>');
+  const positional = [];
+  const provided = {};
+  let custom = false;
+
+  for (const a of rest) {
+    if (a.startsWith('-')) {
+      const eq = a.indexOf('=');
+      const flagName = eq === -1 ? a : a.slice(0, eq);
+      if (flagName === '--custom') {
+        custom = true;
+        continue;
+      }
+      if (Object.prototype.hasOwnProperty.call(ENDPOINT_VALUE_FLAGS, flagName)) {
+        if (eq === -1) {
+          throw usageError(`Flag ${flagName} requires a value: ${flagName}=VALUE`);
+        }
+        provided[ENDPOINT_VALUE_FLAGS[flagName]] = a.slice(eq + 1);
+        continue;
+      }
+      throw usageError(`Unknown flag: ${flagName}`);
+    }
+    positional.push(a);
+  }
+
+  const [name, ...extra] = positional;
+  if (!name) {
+    throw usageError('Usage: cc add <profile> [--custom [--base-url=URL --token=TOKEN ...]]');
+  }
   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}.`);
-  console.log(`Next: cc use ${name}`);
-  return 0;
+  profiles.validateProfileName(name);
+
+  if (Object.keys(provided).length > 0 && !custom) {
+    throw usageError(
+      'Endpoint flags (--base-url, --token, --model, ...) require --custom: ' +
+        `cc add ${name} --custom ...`,
+    );
+  }
+
+  // Plain subscription profile.
+  if (!custom) {
+    const { dir } = profiles.addProfile(name);
+    console.log(`Created profile "${name}" at ${dir}.`);
+    console.log(`Next: cc use ${name}`);
+    return 0;
+  }
+
+  // Custom endpoint profile. A fresh profile is created and configured; an
+  // existing endpoint profile is edited in place. Either way the directory
+  // must exist before runConfigure reads/writes .cc-env.json inside it.
+  const dir = profiles.profileDir(name);
+  const existed = fs.existsSync(dir);
+  if (!existed) profiles.addProfile(name);
+
+  let result;
+  try {
+    result = await envLib.runConfigure(name, dir, provided);
+  } catch (err) {
+    // A freshly-created profile that could not be configured leaves nothing
+    // behind — `cc add --custom` is atomic.
+    if (!existed) {
+      try {
+        removeRecursivelyPreservingLinks(dir);
+      } catch {
+        // best-effort cleanup
+      }
+    }
+    throw err;
+  }
+
+  if (!result.written) {
+    // Wizard cancelled.
+    if (!existed) {
+      try {
+        removeRecursivelyPreservingLinks(dir);
+      } catch {
+        // best-effort cleanup
+      }
+      console.log(`Cancelled. Profile "${name}" was not created.`);
+    } else {
+      console.log('Cancelled. No changes written.');
+    }
+    return result.code;
+  }
+
+  if (!existed) console.log(`Next: cc use ${name}`);
+  return result.code;
 }
 
 async function cmdUse(rest) {
@@ -251,11 +384,128 @@ async function cmdUse(rest) {
     err.exitCode = 1;
     throw err;
   }
-  return spawnClaude({ args: passthrough, profileDir: dir });
+
+  // If the profile carries a custom-endpoint config, inject the corresponding
+  // env vars so Claude Code routes through the third-party provider.
+  let extraEnv = {};
+  const envConfig = envLib.readEnvConfig(dir); // throws on a malformed file
+  if (envConfig) {
+    extraEnv = envLib.buildEnvVars(envConfig);
+    const host = envConfig.base_url ? envLib.hostOf(envConfig.base_url) : '(unknown)';
+    process.stderr.write(
+      `[cchost] Profile '${name}' → ${host} (custom endpoint billing applies)\n`,
+    );
+  }
+  return spawnClaude({ args: passthrough, profileDir: dir, extraEnv });
+}
+
+// `cc list <profile>` — detail for a single profile, including its custom
+// endpoint configuration if it has one.
+function cmdListOne(name, { json, reveal }) {
+  if (json && reveal) {
+    throw usageError('--reveal cannot be combined with --json.');
+  }
+  profiles.validateProfileName(name);
+  const dir = profiles.profileDir(name);
+  if (!fs.existsSync(dir)) {
+    const e = new Error(`Profile "${name}" does not exist. Create it with: cc add ${name}`);
+    e.exitCode = 1;
+    throw e;
+  }
+
+  const total = share.SHARED_SUBDIRS.length;
+  const sharedCount = share.SHARED_SUBDIRS.filter((sub) =>
+    isLinkLike(path.join(dir, sub)),
+  ).length;
+  const loggedIn = profiles.hasCredentials(dir);
+  const email = profiles.readEmail(dir);
+
+  let config = null;
+  let configError = false;
+  try {
+    config = envLib.readEnvConfig(dir);
+  } catch {
+    configError = true;
+  }
+
+  if (json) {
+    const obj = {
+      name,
+      dir,
+      loggedIn,
+      email,
+      shared: sharedCount,
+      endpoint: envLib.endpointSummary(dir),
+    };
+    if (config) {
+      obj.endpointConfig = {
+        base_url: config.base_url || null,
+        // The token is always masked in JSON output — scripts never need it.
+        auth_token: config.auth_token ? envLib.maskToken(config.auth_token) : null,
+        model: config.model || null,
+        opus: config.opus || config.model || null,
+        sonnet: config.sonnet || config.model || null,
+        haiku: config.haiku || config.model || null,
+        subagent: config.subagent || config.model || null,
+      };
+    }
+    process.stdout.write(JSON.stringify(obj, null, 2) + '\n');
+    return 0;
+  }
+
+  console.log(`Profile:   ${name}`);
+  console.log(`Directory: ${dir}`);
+  console.log(`LoggedIn:  ${loggedIn ? 'true' : 'false'}`);
+  console.log(`Email:     ${email || '-'}`);
+  console.log(`Shared:    ${sharedCount}/${total}`);
+
+  if (configError) {
+    console.log('Endpoint:  (invalid config — .cc-env.json is malformed)');
+    return 0;
+  }
+  if (!config) {
+    console.log('Endpoint:  subscription');
+    return 0;
+  }
+
+  console.log(
+    `Endpoint:  ${config.base_url ? envLib.hostOf(config.base_url) : '(invalid config)'}`,
+  );
+  console.log(`  Base URL:  ${config.base_url || '-'}`);
+  if (reveal) {
+    console.log(`  Token:     ${config.auth_token || '-'}`);
+  } else {
+    console.log(`  Token:     ${config.auth_token ? envLib.maskToken(config.auth_token) : '-'}`);
+  }
+  console.log(`  Model:     ${config.model || '-'}`);
+  console.log(`  Opus:      ${config.opus || config.model || '-'}`);
+  console.log(`  Sonnet:    ${config.sonnet || config.model || '-'}`);
+  console.log(`  Haiku:     ${config.haiku || config.model || '-'}`);
+  console.log(`  Subagent:  ${config.subagent || config.model || '-'}`);
+  if (reveal) {
+    console.log('');
+    console.log('WARNING: the full API key is printed above. Do not paste this output');
+    console.log('into chats, issues, screenshots, or logs.');
+  }
+  return 0;
 }
 
 function cmdList(rest) {
-  const { flags } = parseFlagsStrict(rest, ['--json']);
+  const { flags, positional } = parseFlagsStrict(rest, ['--json', '--reveal'], {
+    allowPositional: true,
+  });
+  const json = flags.has('--json');
+  const reveal = flags.has('--reveal');
+  const [name, ...extra] = positional;
+  if (extra.length > 0) throw usageError(`Unexpected argument: ${extra[0]}`);
+
+  if (name) {
+    return cmdListOne(name, { json, reveal });
+  }
+  if (reveal) {
+    throw usageError('--reveal requires a profile name: cc list <profile> --reveal');
+  }
+
   const list = profiles.listProfiles();
   const total = share.SHARED_SUBDIRS.length;
 
@@ -269,6 +519,7 @@ function cmdList(rest) {
       loggedIn: p.loggedIn,
       email: p.email,
       shared: sharedCount,
+      endpoint: envLib.endpointSummary(p.dir),
     };
   });
 
@@ -283,13 +534,14 @@ function cmdList(rest) {
     return 0;
   }
 
-  const rows = [['Profile', 'LoggedIn', 'Email', 'Shared']];
+  const rows = [['Profile', 'LoggedIn', 'Email', 'Shared', 'Endpoint']];
   for (const p of enriched) {
     rows.push([
       p.name,
       p.loggedIn ? 'true' : 'false',
       p.email ? p.email : '-',
       `${p.shared}/${total}`,
+      p.endpoint,
     ]);
   }
   console.log(renderTable(rows));
@@ -432,6 +684,16 @@ async function run(argv) {
     printHelp(rest[0]);
     return 0;
   }
+  if (action === 'env') {
+    // `cc env` was removed in v0.3.1 — point upgraders at the new commands.
+    process.stderr.write(
+      color.stderr.red(
+        "'cc env' was removed in v0.3.1. Configure a custom endpoint with " +
+          "'cc add <profile> --custom', and view it with 'cc list <profile>'.",
+      ) + '\n',
+    );
+    return 2;
+  }
   switch (action) {
     case 'add':
       return await cmdAdd(rest);

package/lib/env.js

@@ -0,0 +1,455 @@
+'use strict';
+
+// Per-profile custom API endpoints.
+//
+// A profile may carry a `.cc-env.json` file that routes Claude Code through an
+// Anthropic-compatible third-party provider (Moonshot/Kimi, OpenRouter, vLLM,
+// corporate proxies) instead of Anthropic's subscription OAuth. The file holds
+// an API key and is treated with the same care as `.credentials.json`: it is
+// never migrated, never linked, and written with user-only file permissions.
+//
+// Endpoint profiles are created and edited through `cc add <profile> --custom`;
+// this module supplies the configuration logic that command delegates to.
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { spawnSync } = require('child_process');
+
+const ENV_FILE = '.cc-env.json';
+
+// Persisted fields, in canonical serialization order.
+const FIELDS = ['base_url', 'auth_token', 'model', 'opus', 'sonnet', 'haiku', 'subagent'];
+const TIER_FIELDS = ['opus', 'sonnet', 'haiku', 'subagent'];
+
+// File field -> env var(s) injected into the spawned child.
+const TIER_ENV = {
+  opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  subagent: 'CLAUDE_CODE_SUBAGENT_MODEL',
+};
+
+// Wizard layout: the index here is the review-screen number (1-based).
+const WIZARD_FIELDS = [
+  { key: 'base_url', label: 'Base URL', hidden: false, required: true },
+  { key: 'auth_token', label: 'Auth token', hidden: true, required: true },
+  { key: 'model', label: 'Main model', hidden: false, required: false },
+  { key: 'opus', label: 'Opus tier', hidden: false, required: false, tier: true },
+  { key: 'sonnet', label: 'Sonnet tier', hidden: false, required: false, tier: true },
+  { key: 'haiku', label: 'Haiku tier', hidden: false, required: false, tier: true },
+  { key: 'subagent', label: 'Subagent model', hidden: false, required: false, tier: true },
+];
+
+function usageError(msg) {
+  const e = new Error(msg);
+  e.exitCode = 2;
+  return e;
+}
+
+function stateError(msg) {
+  const e = new Error(msg);
+  e.exitCode = 1;
+  return e;
+}
+
+function envFilePath(profileDir) {
+  return path.join(profileDir, ENV_FILE);
+}
+
+function hasEnvConfig(profileDir) {
+  return fs.existsSync(envFilePath(profileDir));
+}
+
+// Reads and parses `.cc-env.json`. Returns the parsed object, or null if the
+// file does not exist. Throws (exitCode 1, `.malformed` set) if the file is
+// present but is not a JSON object.
+function readEnvConfig(profileDir) {
+  const p = envFilePath(profileDir);
+  if (!fs.existsSync(p)) return null;
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch (err) {
+    const e = stateError(`${ENV_FILE} is malformed JSON: ${err.message}`);
+    e.malformed = true;
+    throw e;
+  }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    const e = stateError(`${ENV_FILE} is malformed: expected a JSON object.`);
+    e.malformed = true;
+    throw e;
+  }
+  return data;
+}
+
+// True if the profile shows any prior OAuth (subscription) state — either a
+// `.credentials.json` file, or a `.claude.json` with a non-null `oauthAccount`.
+// Such a profile can never be converted to an endpoint profile (Rule 1).
+function hasOAuthState(profileDir) {
+  if (fs.existsSync(path.join(profileDir, '.credentials.json'))) return true;
+  try {
+    const raw = fs.readFileSync(path.join(profileDir, '.claude.json'), 'utf8');
+    if (raw.trim()) {
+      const data = JSON.parse(raw);
+      if (data && data.oauthAccount != null) return true;
+    }
+  } catch {
+    // Missing or unreadable .claude.json is not OAuth state.
+  }
+  return false;
+}
+
+// Locks a file down to the current user only. Mirrors how Claude Code itself
+// protects `.credentials.json`.
+function secureFile(filePath) {
+  if (process.platform === 'win32') {
+    const user = process.env.USERNAME;
+    if (!user) return;
+    // Qualify the principal as DOMAIN\user. A bare username that collides with
+    // the computer name (common on workgroup machines) resolves to a broken
+    // principal, which would lock the file's own owner out — verified.
+    const domain = process.env.USERDOMAIN;
+    const principal = domain ? `${domain}\\${user}` : user;
+    spawnSync('icacls', [filePath, '/inheritance:r', '/grant:r', `${principal}:F`], {
+      stdio: 'ignore',
+    });
+  } else {
+    fs.chmodSync(filePath, 0o600);
+  }
+}
+
+// Writes `.cc-env.json` atomically (temp file + rename) so a cancel or crash
+// never leaves a partial file. Only defined, non-empty fields are persisted.
+function writeEnvConfig(profileDir, config) {
+  const out = {};
+  for (const f of FIELDS) {
+    if (config[f] != null && config[f] !== '') out[f] = config[f];
+  }
+  const target = envFilePath(profileDir);
+  const tmp = path.join(profileDir, `${ENV_FILE}.tmp-${process.pid}`);
+  // Write to a temp file then rename, so a crash never leaves a partial file.
+  // Permissions are locked down after the rename: restricting the temp file's
+  // ACL first makes the subsequent rename fail with EPERM on Windows.
+  fs.writeFileSync(tmp, JSON.stringify(out, null, 2) + '\n');
+  try {
+    fs.renameSync(tmp, target);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+      // best effort cleanup
+    }
+    throw err;
+  }
+  secureFile(target);
+  return out;
+}
+
+// Maps a config object to the ANTHROPIC_*/CLAUDE_CODE_* env vars injected into
+// the spawned child. Per-tier model vars fall back to `model`; if `model` is
+// also missing, the var is omitted so Claude Code uses its built-in defaults.
+function buildEnvVars(config) {
+  const env = {};
+  if (config.base_url) env.ANTHROPIC_BASE_URL = config.base_url;
+  if (config.auth_token) {
+    // Different providers read different vars — set both.
+    env.ANTHROPIC_AUTH_TOKEN = config.auth_token;
+    env.ANTHROPIC_API_KEY = config.auth_token;
+  }
+  if (config.model) env.ANTHROPIC_MODEL = config.model;
+  for (const tier of TIER_FIELDS) {
+    const val = config[tier] || config.model;
+    if (val) env[TIER_ENV[tier]] = val;
+  }
+  return env;
+}
+
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+
+// Endpoint summary for `cc list`. Returns the base-url host, 'subscription'
+// (no endpoint config), or '(invalid config)' for a malformed file — never
+// throws, so a single bad profile cannot break the whole table.
+function endpointSummary(profileDir) {
+  let config;
+  try {
+    config = readEnvConfig(profileDir);
+  } catch {
+    return '(invalid config)';
+  }
+  if (!config) return 'subscription';
+  if (!config.base_url) return '(invalid config)';
+  return hostOf(config.base_url);
+}
+
+function maskToken(token) {
+  const n = token.length;
+  if (n <= 10) return `${'*'.repeat(n)} (${n} chars)`;
+  return `${token.slice(0, 6)}...${token.slice(-4)} (${n} chars)`;
+}
+
+function validateBaseUrl(url, warn) {
+  if (!/^https?:\/\/.+/.test(url)) {
+    throw usageError(`Invalid base_url "${url}": must start with http:// or https://`);
+  }
+  let u = null;
+  try {
+    u = new URL(url);
+  } catch {
+    throw usageError(`Invalid base_url "${url}": not a parseable URL.`);
+  }
+  if (u.pathname.replace(/\/+$/, '').endsWith('/v1')) {
+    warn('cchost: base_url ending in /v1 is unusual; most Anthropic-compatible endpoints end in / or /anthropic');
+  }
+  if (u.protocol === 'http:' && u.hostname !== 'localhost' && u.hostname !== '127.0.0.1') {
+    warn('cchost: base_url uses http:// to a non-local host; the auth token will be sent unencrypted');
+  }
+}
+
+function validateToken(token) {
+  if (typeof token !== 'string' || token.length === 0) {
+    throw usageError('Auth token must not be empty.');
+  }
+  if (token !== token.trim()) {
+    throw usageError('Auth token must not have leading or trailing whitespace.');
+  }
+  if (/[\r\n]/.test(token)) {
+    throw usageError('Auth token must not contain newlines.');
+  }
+}
+
+function validateModelField(label, val) {
+  if (typeof val !== 'string' || val.length === 0) {
+    throw usageError(`${label} must not be empty if provided.`);
+  }
+}
+
+// Validates one provided field by key. base_url warnings go through `warn`.
+function validateField(key, value, warn) {
+  if (key === 'base_url') validateBaseUrl(value, warn);
+  else if (key === 'auth_token') validateToken(value);
+  else validateModelField(key, value);
+}
+
+// ---------------------------------------------------------------------------
+// Wizard
+// ---------------------------------------------------------------------------
+
+// Default terminal IO for the wizard. `readHidden` writes the prompt, then
+// suppresses echo of typed characters so the token never appears on screen.
+function defaultWizardIo() {
+  return {
+    write: (s) => process.stdout.write(s),
+    readLine: (q) =>
+      new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(q, (a) => {
+          rl.close();
+          resolve(a);
+        });
+      }),
+    readHidden: (q) =>
+      new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        let muted = false;
+        rl._writeToOutput = (s) => {
+          if (!muted) rl.output.write(s);
+        };
+        rl.question(q, (a) => {
+          rl.close();
+          process.stdout.write('\n');
+          resolve(a);
+        });
+        // The prompt was written above (still unmuted); from here, suppress
+        // the echo of whatever the user types.
+        muted = true;
+      }),
+  };
+}
+
+function reviewValue(field, config) {
+  if (field.key === 'auth_token') {
+    return config.auth_token ? maskToken(config.auth_token) : '-';
+  }
+  if (field.tier) {
+    return config[field.key] || config.model || '-';
+  }
+  return config[field.key] || '-';
+}
+
+function renderReview(config, io) {
+  io.write('\nReview:\n');
+  WIZARD_FIELDS.forEach((field, i) => {
+    const label = `${field.label}:`.padEnd(16);
+    io.write(`  ${i + 1}. ${label}${reviewValue(field, config)}\n`);
+  });
+}
+
+// Prompts for one field, looping until the input is valid. An empty input
+// keeps the current value; a required field with no current value re-prompts.
+async function promptOne(field, config, io, isEdit) {
+  for (;;) {
+    let placeholder = '';
+    let promptText;
+    if (field.hidden) {
+      promptText = `${field.label}${isEdit && config[field.key] ? ' [keep current]' : ''}: `;
+    } else {
+      if (field.tier) placeholder = config[field.key] || config.model || '';
+      else placeholder = config[field.key] || '';
+      promptText = `${field.label} [${placeholder}]: `;
+    }
+
+    const raw = field.hidden
+      ? await io.readHidden(promptText)
+      : await io.readLine(promptText);
+    const value = raw.trim();
+
+    if (value === '') {
+      // Keep the current value. base_url/auth_token must end up set.
+      if (field.required && !config[field.key]) {
+        io.write(`${field.label} is required.\n`);
+        continue;
+      }
+      return;
+    }
+
+    try {
+      validateField(field.key, value, (m) => io.write(m + '\n'));
+    } catch (err) {
+      io.write(err.message + '\n');
+      continue;
+    }
+    config[field.key] = value;
+    return;
+  }
+}
+
+// Runs the interactive wizard. Returns the collected config on submit, or
+// null if the user cancelled. Never writes the file itself.
+async function runWizard(name, existing, io) {
+  const isEdit = !!existing;
+  const config = {};
+  if (existing) {
+    for (const f of FIELDS) {
+      if (existing[f] != null) config[f] = existing[f];
+    }
+  }
+
+  io.write(`\ncchost endpoint configuration for profile '${name}'${isEdit ? ' (editing)' : ''}\n\n`);
+  for (const field of WIZARD_FIELDS) {
+    await promptOne(field, config, io, isEdit);
+  }
+
+  for (;;) {
+    renderReview(config, io);
+    const ans = (await io.readLine('\n[s]ubmit, [e]dit N, [c]ancel: ')).trim().toLowerCase();
+    if (ans === 's') return config;
+    if (ans === 'c') return null;
+    const m = /^e\s+([1-7])$/.exec(ans);
+    if (m) {
+      await promptOne(WIZARD_FIELDS[Number(m[1]) - 1], config, io, isEdit);
+    }
+    // Anything else: silently re-display the review.
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command orchestration (called from cli.js)
+// ---------------------------------------------------------------------------
+
+// Configures a profile's custom endpoint. Called by `cc add <profile> --custom`
+// (both for first-time creation and for editing an existing endpoint profile).
+// `provided` is a partial config of fields supplied via flags.
+// `opts.io` injects wizard IO (tests); `opts.isTTY` overrides TTY detection.
+//
+// Returns `{ code, written }`: `written` is false only when the interactive
+// wizard was cancelled, so the caller can clean up a freshly-created profile.
+async function runConfigure(name, profileDir, provided, opts = {}) {
+  if (!fs.existsSync(profileDir)) {
+    throw stateError(`Profile "${name}" does not exist. Create it with: cc add ${name}`);
+  }
+  if (hasOAuthState(profileDir)) {
+    throw stateError(
+      `Profile '${name}' has OAuth credentials and cannot be converted to a custom endpoint.\n` +
+        'A profile is born subscription or endpoint and stays that way.\n' +
+        'Create a fresh endpoint profile instead:\n' +
+        '  cc add <new-name> --custom',
+    );
+  }
+
+  const existing = readEnvConfig(profileDir); // throws on malformed file
+  const editing = existing != null;
+  const nonInteractive = Object.keys(provided).length > 0;
+
+  if (nonInteractive) {
+    const warn = (m) => process.stderr.write(m + '\n');
+    // Creating: base_url and auth_token are mandatory.
+    if (!editing) {
+      const merged = { ...provided };
+      if (!merged.base_url || !merged.auth_token) {
+        throw usageError(
+          'Creating an endpoint profile requires both --base-url and --token.',
+        );
+      }
+    }
+    for (const [key, value] of Object.entries(provided)) {
+      validateField(key, value, warn);
+    }
+    const merged = { ...(existing || {}), ...provided };
+    writeEnvConfig(profileDir, merged);
+    console.log(
+      `${editing ? 'Updated' : 'Created'} endpoint config for profile '${name}' → ${hostOf(merged.base_url)}.`,
+    );
+    return { code: 0, written: true };
+  }
+
+  // Interactive wizard.
+  let io = opts.io;
+  if (!io) {
+    const isTTY = opts.isTTY != null ? opts.isTTY : process.stdin.isTTY;
+    if (!isTTY) {
+      throw usageError(
+        'cc add --custom requires either endpoint flags or an interactive terminal.',
+      );
+    }
+    io = defaultWizardIo();
+  }
+
+  const result = await runWizard(name, existing, io);
+  if (result == null) {
+    return { code: 0, written: false };
+  }
+  writeEnvConfig(profileDir, result);
+  console.log(
+    `${editing ? 'Updated' : 'Created'} endpoint config for profile '${name}' → ${hostOf(result.base_url)}.`,
+  );
+  return { code: 0, written: true };
+}
+
+module.exports = {
+  ENV_FILE,
+  FIELDS,
+  TIER_FIELDS,
+  envFilePath,
+  hasEnvConfig,
+  readEnvConfig,
+  hasOAuthState,
+  secureFile,
+  writeEnvConfig,
+  buildEnvVars,
+  hostOf,
+  endpointSummary,
+  maskToken,
+  validateBaseUrl,
+  validateToken,
+  validateField,
+  runWizard,
+  runConfigure,
+  defaultWizardIo,
+};

package/lib/migrate.js

@@ -14,7 +14,11 @@ const SUBDIRS = ['projects', 'skills', 'agents', 'commands'];
 // Not copied to shared: these carry per-profile config / auth tokens.
 const SINGLE_FILES = ['mcp.json', 'settings.json', 'CLAUDE.md'];
 
-const EXCLUDED_FILES = new Set(['.credentials.json', '.claude.json']);
+// .cc-env.json carries a third-party API key — same security category as
+// .credentials.json. It must NEVER be copied to a shared pool or another
+// profile, so it is excluded explicitly here (it also lives at the profile
+// root, outside SUBDIRS, but this guards against any future copy path).
+const EXCLUDED_FILES = new Set(['.credentials.json', '.claude.json', '.cc-env.json']);
 
 function defaultClaudeDir() {
   return path.join(os.homedir(), '.claude');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cchost",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Host multiple isolated Claude Code accounts on one machine via the `cc` command.",
   "keywords": [
     "claude",
@@ -32,6 +32,7 @@
     "bin",
     "lib",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "main": "lib/cli.js",