@remeic/ccm 0.3.0 → 0.5.0

package/README.md

@@ -13,16 +13,37 @@
   </table>
 </div>
 
+
 [![CI](https://github.com/remeic/ccm/actions/workflows/ci.yml/badge.svg)](https://github.com/remeic/ccm/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/%40remeic%2Fccm.svg)](https://www.npmjs.com/package/@remeic/ccm)
 [![Homebrew tap](https://img.shields.io/badge/Homebrew-tap-FBB040?logo=homebrew&logoColor=white)](https://github.com/Remeic/homebrew-tap)
 [![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/graph/badge.svg?token=E16LCLDHYV)](https://codecov.io/github/Remeic/ccm)
-[![mutation testing](https://img.shields.io/badge/mutation%20testing-100%25-brightgreen)](https://stryker-mutator.io/)
+[![Mutation testing badge](https://img.shields.io/endpoint?style=flat&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2FRemeic%2Fccm%2Fmain)](https://dashboard.stryker-mutator.io/reports/github.com/Remeic/ccm/main)
 
 Manage separate Claude Code profiles for personal, work, and client accounts without repeated logout/login cycles. `ccm` keeps each profile isolated so switching is immediate and parallel sessions stay clean.
 
+### IMPORTANT: Claude Code ToS (Multi-Terminal Use)
+
+> [!IMPORTANT]
+> **Mandatory compliance rule for this project**
+> Do **not** use the **same Claude account** from multiple terminals at the same time.
+> We enforce: **1 account = 1 person = 1 active terminal session**.
+>
+> - `ccm` isolates profiles. It does **not** grant any extra rights under Anthropic terms.
+> - For parallel work, use separate licensed accounts/seats (or API keys under Commercial Terms).
+> - No credential sharing, no shared account handoff, no "one account used by multiple people".
+> - This is an intentionally strict project rule to remove ambiguity and reduce compliance risk.
+> - The CLI also surfaces this via `ccm compliance` (alias: `ccm tos`) and after every successful `ccm create`.
+>
+> Official basis (as of April 8, 2026):
+> - [Claude Code Legal & Compliance](https://code.claude.com/docs/en/legal-and-compliance): usage limits for Pro/Max assume ordinary, individual use; Anthropic may enforce auth restrictions without notice.
+> - [Anthropic Consumer Terms](https://www.anthropic.com/legal/consumer-terms): account credentials/API keys must not be shared or made available to others; Anthropic may suspend/terminate for material breach.
+> - [Anthropic Commercial Terms](https://www.anthropic.com/legal/commercial-terms): customer is responsible for all activity under its account.
+
+
+
 <p align="center">
   <img src="./docs/assets/intro.gif" alt="ccm in action in a terminal view" width="100%" />
 </p>
@@ -35,11 +56,13 @@ Manage separate Claude Code profiles for personal, work, and client accounts wit
 - [Install](#install)
 - [Quick Start](#quick-start)
 - [Commands](#commands)
+- [Compliance Notice](#compliance-notice)
 - [Passing Flags and Environment Variables](#passing-flags-and-environment-variables)
 - [Multi-Account Login](#multi-account-login)
   - [Different Browser per Profile](#different-browser-per-profile)
   - [URL-Only Mode](#url-only-mode)
   - [API Key Auth](#api-key-auth)
+  - [Copying Config Between Profiles](#copying-config-between-profiles)
 - [How It Works](#how-it-works)
   - [Architecture Overview](#architecture-overview)
   - [Profile Isolation](#profile-isolation)
@@ -54,6 +77,7 @@ Manage separate Claude Code profiles for personal, work, and client accounts wit
 - [Comparison](#comparison)
 - [FAQ](#faq)
 - [Contributing](#contributing)
+  - [Homebrew Releases](#homebrew-releases)
 - [License](#license)
 
 ## Why
@@ -91,6 +115,11 @@ The installed command remains `ccm`.
 ```
 $ ccm create work
 ✓ Profile "work" created
+! Compliance notice
+  ccm isolates profiles but does not expand Anthropic usage rights.
+  Use each Claude account with one person and one active terminal session.
+  Do not share credentials or API keys across users or parallel operators.
+  Details: ccm compliance
   Next: ccm login work
 
 $ ccm login work
@@ -104,15 +133,34 @@ $ ccm use work
 
 | Command                                                  | Description                                                   |
 | -------------------------------------------------------- | ------------------------------------------------------------- |
-| `ccm create <name> [-l label] [-b browser]`              | Create a profile. `-b` sets the browser for OAuth             |
+| `ccm create <name> [-l label] [-b browser] [--from p]`   | Create a profile. `--from` seeds non-auth config              |
+| `ccm compliance` / `ccm tos`                             | Show the compliance notice, disclaimer, and official sources  |
 | `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 rename <old-name> <new-name>`                       | Rename a profile (config, directory, and browser wrapper)      |
+| `ccm rename <old-name> <new-name>`                       | Rename a profile (config, directory, and browser wrapper)     |
 | `ccm remove <name> [-f]`                                 | Remove a profile. `-f` skips confirmation                     |
+| `ccm copy-config <source> <target> [--only x] [--dry-run] [-f]` | Copy non-auth config (settings/hooks/skills plugins) |
 | `ccm run <name> -p <prompt>`                             | Run a prompt non-interactively                                |
 
+## Compliance Notice
+
+Every successful `ccm create` prints a short compliance warning. Users can re-open the full text at any time with:
+
+```bash
+ccm compliance
+ccm tos
+```
+
+The notice is intentionally conservative:
+
+- `ccm` is a profile-isolation tool, not a license-expansion tool.
+- This project treats each Claude account as single-user and single-session.
+- Shared credentials, shared operators, and parallel use of the same account are out of scope.
+- If a team needs parallel access, they should use separate seats/accounts or API-key-based access under applicable Anthropic commercial terms.
+- The notice is compliance guidance, not legal advice. Users remain responsible for reviewing Anthropic terms for their exact workflow.
+
 ## Passing Flags and Environment Variables
 
 Everything after `--` in `ccm use` is forwarded to `claude`. Env vars from your shell are inherited.
@@ -170,6 +218,40 @@ Suppresses auto-opening a browser. Claude prints the auth URL — copy it, open
 ccm login work --console
 ```
 
+### Copying Config Between Profiles
+
+```bash
+# Preview before applying
+ccm copy-config work personal --dry-run
+
+# Copy with interactive overwrite confirmation
+ccm copy-config work personal
+
+# Force overwrite without prompt
+ccm copy-config work personal --force
+
+# Copy only settings (or only plugins)
+ccm copy-config work personal --only settings
+ccm copy-config work personal --only plugins
+```
+
+`copy-config` is intentionally conservative. It copies only non-auth profile config paths:
+
+- `settings.json`
+- `plugins/`
+
+It does **not** copy runtime/auth state such as `.claude.json`, `sessions/`, `history.jsonl`,
+`projects/`, `session-env/`, `telemetry/`, or top-level profile cache directories.
+
+You can narrow the copy scope with `--only settings` or `--only plugins`. The option is repeatable and also supports comma-separated values (e.g. `--only settings,plugins`).
+
+You can also bootstrap at creation time:
+
+```bash
+# Create profile and seed non-auth config from an existing profile
+ccm create personal --from work
+```
+
 ## How It Works
 
 ### Architecture Overview
@@ -198,9 +280,13 @@ src/
 │   ├── config.ts            # Config file I/O with atomic writes
 │   ├── profiles.ts          # Profile directory management and validation
 │   ├── profile-store.ts     # Reconciled config/filesystem profile view
+│   ├── profile-config-copy.ts # Config copy planner + transactional apply/rollback
 │   ├── claude.ts            # Claude binary discovery, spawning, auth status
+│   ├── compliance.ts        # Centralized compliance notice text and official sources
 │   └── browsers.ts          # Browser wrapper generation and validation
 └── commands/
+    ├── copy-config.ts       # Copy non-auth config between profiles (dry-run + rollback)
+    ├── compliance.ts        # Dedicated compliance/TOS command
     ├── 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

package/dist/index.js

@@ -1,18 +1,404 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { existsSync, mkdirSync, writeFileSync, chmodSync, renameSync, rmSync, unlinkSync, readFileSync, readdirSync } from 'fs';
+import { createInterface } from 'readline';
+import { existsSync, mkdirSync, writeFileSync, chmodSync, renameSync, statSync, rmSync, unlinkSync, cpSync, 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';
 
+// src/lib/compliance.ts
+var COMPLIANCE_CHECKED_AT = "2026-04-08";
+var COMPLIANCE_SOURCES = [
+  {
+    label: "Claude Code Legal & Compliance",
+    url: "https://code.claude.com/docs/en/legal-and-compliance",
+    summary: "Pro and Max usage limits assume ordinary, individual use. Anthropic may enforce authentication restrictions without notice."
+  },
+  {
+    label: "Anthropic Consumer Terms",
+    url: "https://www.anthropic.com/legal/consumer-terms",
+    summary: "Account login information, API keys, and account credentials must not be shared or made available to anyone else."
+  },
+  {
+    label: "Anthropic Commercial Terms",
+    url: "https://www.anthropic.com/legal/commercial-terms",
+    summary: "Commercial customers are responsible for all activity and fees incurred under their account."
+  }
+];
+function buildRuleLines() {
+  return [
+    "Project compliance boundary:",
+    "- ccm isolates profiles, but it does not grant any extra rights under Anthropic terms.",
+    "- Treat each Claude account as single-user and single-session: 1 account = 1 person = 1 active terminal session.",
+    "- Do not share account credentials or API keys, and do not hand off the same account between multiple operators.",
+    "- For parallel operators, separate seats/accounts or API-key-based access under Commercial Terms are required."
+  ];
+}
+function getCompactComplianceNoticeLines() {
+  return [
+    "\x1B[33m!\x1B[0m Compliance notice",
+    "  ccm isolates profiles but does not expand Anthropic usage rights.",
+    "  Use each Claude account with one person and one active terminal session.",
+    "  Do not share credentials or API keys across users or parallel operators.",
+    "  Details: ccm compliance"
+  ];
+}
+function getFullComplianceNoticeLines() {
+  const sourceLines = COMPLIANCE_SOURCES.flatMap((source) => [
+    `- ${source.label}: ${source.url}`,
+    `  ${source.summary}`
+  ]);
+  return [
+    "Claude Code compliance notice",
+    "This project publishes an intentionally conservative operational rule to reduce misuse and ambiguity.",
+    ...buildRuleLines(),
+    "Important:",
+    "- This notice is compliance guidance for ccm users. It is not legal advice and it does not replace review of Anthropic terms for your specific use case.",
+    "- If you are building a product, automation, or shared workflow around Claude access, verify your model with Anthropic before deployment.",
+    `Official sources reviewed on ${COMPLIANCE_CHECKED_AT}:`,
+    ...sourceLines
+  ];
+}
+
+// src/commands/compliance.ts
+function registerCompliance(program2) {
+  program2.command("compliance").alias("tos").description("Show the Claude Code compliance notice and official source links").action(() => {
+    for (const line of getFullComplianceNoticeLines()) {
+      console.log(line);
+    }
+  });
+}
 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");
+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/profiles.ts
+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 renameProfileDir(oldName, newName, profilesDir = PROFILES_DIR) {
+  const oldDir = join(profilesDir, oldName);
+  const newDir = join(profilesDir, newName);
+  if (!existsSync(oldDir)) {
+    throw new Error(`Profile directory "${oldName}" does not exist`);
+  }
+  if (existsSync(newDir)) {
+    throw new Error(`Profile directory "${newName}" already exists`);
+  }
+  renameSync(oldDir, newDir);
+}
+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 getStagedPath(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 = getStagedPath(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/lib/browsers.ts
+// src/lib/profile-config-copy.ts
+var SUPPORTED_CONFIG_PATHS = ["settings.json", "plugins"];
+function planProfileConfigCopy(sourceName, targetName, profilesDir = PROFILES_DIR, options = {}) {
+  validateProfileName(sourceName);
+  validateProfileName(targetName);
+  if (sourceName === targetName) {
+    throw new Error("Source and target profiles must be different");
+  }
+  if (!profileExists(sourceName, profilesDir)) {
+    throw new Error(`Profile "${sourceName}" does not exist`);
+  }
+  if (!profileExists(targetName, profilesDir)) {
+    throw new Error(`Profile "${targetName}" does not exist`);
+  }
+  const sourceDir = getProfileDir(sourceName, profilesDir);
+  const targetDir = getProfileDir(targetName, profilesDir);
+  const selectedPaths = normalizeSelectedPaths(options.only);
+  const operations = [];
+  for (const relativePath of selectedPaths) {
+    const sourcePath = join(sourceDir, relativePath);
+    if (!existsSync(sourcePath)) {
+      continue;
+    }
+    const kind = statSync(sourcePath).isDirectory() ? "directory" : "file";
+    const targetPath = join(targetDir, relativePath);
+    operations.push({
+      sourcePath,
+      targetPath,
+      relativePath,
+      kind,
+      overwrite: existsSync(targetPath)
+    });
+  }
+  if (operations.length === 0) {
+    throw new Error(
+      `No supported configuration found in profile "${sourceName}". Supported paths: ${SUPPORTED_CONFIG_PATHS.join(", ")}`
+    );
+  }
+  const overwriteCount = operations.filter((operation) => operation.overwrite).length;
+  return {
+    sourceName,
+    targetName,
+    operations,
+    overwriteCount,
+    createCount: operations.length - overwriteCount
+  };
+}
+function normalizeSelectedPaths(only) {
+  if (!only || only.length === 0) {
+    return [...SUPPORTED_CONFIG_PATHS];
+  }
+  const selected = /* @__PURE__ */ new Set();
+  for (const entry of only) {
+    if (entry === "settings" || entry === "settings.json") {
+      selected.add("settings.json");
+      continue;
+    }
+    if (entry === "plugins") {
+      selected.add("plugins");
+      continue;
+    }
+    throw new Error(`Unsupported --only target "${entry}". Allowed values: settings, plugins.`);
+  }
+  return SUPPORTED_CONFIG_PATHS.filter((path) => selected.has(path));
+}
+function applyProfileConfigCopy(plan) {
+  const stagedTargets = [];
+  const copiedTargets = [];
+  try {
+    for (const operation of plan.operations) {
+      if (operation.overwrite) {
+        const stagedPath = getStagedPath2(operation.targetPath);
+        renameSync(operation.targetPath, stagedPath);
+        stagedTargets.push({ targetPath: operation.targetPath, stagedPath });
+      }
+      mkdirSync(dirname(operation.targetPath), { recursive: true });
+      copyOperation(operation);
+      copiedTargets.push(operation.targetPath);
+    }
+  } catch (error) {
+    const rollbackErrors = rollbackCopy(copiedTargets, stagedTargets);
+    if (rollbackErrors.length > 0) {
+      throw new Error(
+        `Failed to copy profile configuration: ${formatError(error)}. Rollback failed: ${rollbackErrors.join("; ")}`
+      );
+    }
+    throw new Error(`Failed to copy profile configuration: ${formatError(error)}`);
+  }
+  try {
+    for (const { stagedPath } of stagedTargets) {
+      rmSync(stagedPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    const rollbackErrors = rollbackCopy(copiedTargets, stagedTargets);
+    if (rollbackErrors.length > 0) {
+      throw new Error(
+        `Failed to finalize profile configuration copy: ${formatError(error)}. Rollback failed: ${rollbackErrors.join("; ")}`
+      );
+    }
+    throw new Error(`Failed to finalize profile configuration copy: ${formatError(error)}`);
+  }
+  return {
+    copiedCount: plan.operations.length,
+    overwrittenCount: plan.overwriteCount,
+    createdCount: plan.createCount
+  };
+}
+function copyOperation(operation) {
+  const baseOptions = { errorOnExist: true, force: false };
+  if (operation.kind === "directory") {
+    cpSync(operation.sourcePath, operation.targetPath, { ...baseOptions, recursive: true });
+    return;
+  }
+  cpSync(operation.sourcePath, operation.targetPath, baseOptions);
+}
+function rollbackCopy(copiedTargets, stagedTargets) {
+  const rollbackErrors = [];
+  for (const copiedPath of [...copiedTargets].reverse()) {
+    try {
+      rmSync(copiedPath, { recursive: true, force: true });
+    } catch (error) {
+      rollbackErrors.push(`remove ${copiedPath}: ${formatError(error)}`);
+    }
+  }
+  for (const { targetPath, stagedPath } of [...stagedTargets].reverse()) {
+    try {
+      if (existsSync(stagedPath)) {
+        renameSync(stagedPath, targetPath);
+      }
+    } catch (error) {
+      rollbackErrors.push(`restore ${targetPath}: ${formatError(error)}`);
+    }
+  }
+  return rollbackErrors;
+}
+function getStagedPath2(path) {
+  const parent = dirname(path);
+  const base = basename(path);
+  for (const attempt of Array.from({ length: 100 }, (_, index) => index)) {
+    const suffix = attempt === 0 ? `${process.pid}-${Date.now()}` : `${process.pid}-${Date.now()}-${attempt.toString()}`;
+    const candidate = join(parent, `.${base}.staged-${suffix}`);
+    if (!existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not allocate a temporary path for "${base}"`);
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/copy-config.ts
+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 printPlan(plan) {
+  for (const operation of plan.operations) {
+    const mode = operation.overwrite ? "overwrite" : "create";
+    console.log(`- ${operation.relativePath} (${operation.kind}, ${mode})`);
+  }
+}
+function collectOnlySelector(value, previous) {
+  const tokens = value.split(",").map((token) => token.trim());
+  if (tokens.some((token) => token.length === 0)) {
+    throw new Error("Invalid --only value. Empty entries are not allowed.");
+  }
+  return [...previous, ...tokens];
+}
+function resolvePlanOptions(only) {
+  if (!only || only.length === 0) {
+    return void 0;
+  }
+  return { only };
+}
+function registerCopyConfig(program2) {
+  program2.command("copy-config <source> <target>").description(
+    "Copy non-auth configuration (hooks, skills, settings) from one profile to another"
+  ).option(
+    "--only <path>",
+    "Copy only selected path(s): settings, plugins (repeatable or comma-separated)",
+    collectOnlySelector,
+    []
+  ).option("--dry-run", "Preview what would be copied without writing files").option("-f, --force", "Skip overwrite confirmation and apply immediately").action(
+    async (source, target, opts) => {
+      try {
+        const plan = planProfileConfigCopy(
+          source,
+          target,
+          void 0,
+          resolvePlanOptions(opts.only)
+        );
+        if (opts.dryRun) {
+          console.log(
+            `Dry run: ${plan.operations.length} item(s) would be copied from "${source}" to "${target}"`
+          );
+          printPlan(plan);
+          return;
+        }
+        if (plan.overwriteCount > 0) {
+          console.log(
+            `! ${plan.overwriteCount} existing path(s) in "${target}" will be overwritten.`
+          );
+          if (!opts.force) {
+            const ok = await confirm("Continue? (y/N) ");
+            if (!ok) {
+              console.log("Cancelled");
+              return;
+            }
+          }
+        }
+        const result = applyProfileConfigCopy(plan);
+        console.log(
+          `\x1B[32m\u2713\x1B[0m Copied ${result.copiedCount} item(s) from "${source}" to "${target}" (${result.createdCount} created, ${result.overwrittenCount} overwritten)`
+        );
+      } catch (e) {
+        console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
+        process.exit(1);
+      }
+    }
+  );
+}
 var SHELL_METACHAR = /[;|&`$(){}<>\\!\n\r]/;
 function validateBrowserCommand(cmd) {
   if (SHELL_METACHAR.test(cmd)) {
@@ -35,7 +421,7 @@ exec ${browserCommand} "$@"
   renameSync(tmp, scriptPath);
   return scriptPath;
 }
-function getStagedPath(path) {
+function getStagedPath3(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}`;
@@ -68,7 +454,7 @@ function stageBrowserWrapperRemoval(profileName, browsersDir = BROWSERS_DIR) {
   if (!existsSync(wrapperPath)) {
     return void 0;
   }
-  const stagedPath = getStagedPath(wrapperPath);
+  const stagedPath = getStagedPath3(wrapperPath);
   renameSync(wrapperPath, stagedPath);
   return stagedPath;
 }
@@ -81,28 +467,6 @@ function finalizeStagedBrowserWrapperRemoval(stagedPath) {
 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 {
@@ -154,97 +518,26 @@ function renameProfile(oldName, newName, configFile = CONFIG_FILE) {
 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 renameProfileDir(oldName, newName, profilesDir = PROFILES_DIR) {
-  const oldDir = join(profilesDir, oldName);
-  const newDir = join(profilesDir, newName);
-  if (!existsSync(oldDir)) {
-    throw new Error(`Profile directory "${oldName}" does not exist`);
-  }
-  if (existsSync(newDir)) {
-    throw new Error(`Profile directory "${newName}" already exists`);
-  }
-  renameSync(oldDir, newDir);
-}
-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) => {
+  program2.command("create <name>").description("Create a new profile").option("-l, --label <label>", "Profile label").option("-b, --browser <path>", "Browser for OAuth login").option("--from <profile>", "Initialize non-auth config from an existing profile").action((name, opts) => {
     try {
       createProfileDir(name);
-      const browser = opts.browser ? ensureBrowserWrapper(name, opts.browser) : void 0;
+      let browser;
       try {
+        browser = opts.browser ? ensureBrowserWrapper(name, opts.browser) : void 0;
+        if (opts.from) {
+          const plan = planProfileConfigCopy(opts.from, name);
+          applyProfileConfigCopy(plan);
+        }
         addProfile({
           name,
           label: opts.label,
           browser,
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-      } catch (configErr) {
+      } catch (setupErr) {
         try {
           removeProfileDir(name);
         } catch {
@@ -253,9 +546,12 @@ function registerCreate(program2) {
           removeBrowserWrapper(name);
         } catch {
         }
-        throw configErr;
+        throw setupErr;
       }
       console.log(`\x1B[32m\u2713\x1B[0m Profile "${name}" created`);
+      for (const line of getCompactComplianceNoticeLines()) {
+        console.log(line);
+      }
       console.log(`  Next: ccm login ${name}`);
     } catch (e) {
       console.error(`\x1B[31m\u2717\x1B[0m ${e instanceof Error ? e.message : String(e)}`);
@@ -374,7 +670,7 @@ function removeStoredProfile(name, configFile = CONFIG_FILE, profilesDir = PROFI
       rollbackStorage(name, stagedDir, stagedWrapper, profilesDir, browsersDir);
     } catch (rollbackError) {
       throw new Error(
-        `Failed to remove profile "${name}": ${formatError(error)}. Rollback failed: ${formatError(
+        `Failed to remove profile "${name}": ${formatError2(error)}. Rollback failed: ${formatError2(
           rollbackError
         )}`
       );
@@ -393,18 +689,18 @@ function removeStoredProfile(name, configFile = CONFIG_FILE, profilesDir = PROFI
     try {
       rollbackStorage(name, stagedDir, stagedWrapper, profilesDir, browsersDir);
     } catch (rollbackError) {
-      recoveryErrors.push(formatError(rollbackError));
+      recoveryErrors.push(formatError2(rollbackError));
     }
     if (profile.meta) {
       try {
         restoreConfigEntry(profile.meta, configFile);
       } catch (configRestoreError) {
-        recoveryErrors.push(`config: ${formatError(configRestoreError)}`);
+        recoveryErrors.push(`config: ${formatError2(configRestoreError)}`);
       }
     }
     if (recoveryErrors.length > 0) {
       throw new Error(
-        `Failed to remove profile "${name}": ${formatError(error)}. Recovery failed: ${recoveryErrors.join(
+        `Failed to remove profile "${name}": ${formatError2(error)}. Recovery failed: ${recoveryErrors.join(
           "; "
         )}`
       );
@@ -439,7 +735,7 @@ function renameStoredProfile(oldName, newName, configFile = CONFIG_FILE, profile
         rollbackRename(oldName, newName, profile.hasDirectory, false, profilesDir, browsersDir);
       } catch (rollbackError) {
         throw new Error(
-          `Failed to rename profile "${oldName}" to "${newName}": ${formatError(error)}. Rollback failed: ${formatError(rollbackError)}`
+          `Failed to rename profile "${oldName}" to "${newName}": ${formatError2(error)}. Rollback failed: ${formatError2(rollbackError)}`
         );
       }
       throw error;
@@ -452,7 +748,7 @@ function renameStoredProfile(oldName, newName, configFile = CONFIG_FILE, profile
       rollbackRename(oldName, newName, profile.hasDirectory, hadWrapper, profilesDir, browsersDir);
     } catch (rollbackError) {
       throw new Error(
-        `Failed to rename profile "${oldName}" to "${newName}": ${formatError(error)}. Rollback failed: ${formatError(rollbackError)}`
+        `Failed to rename profile "${oldName}" to "${newName}": ${formatError2(error)}. Rollback failed: ${formatError2(rollbackError)}`
       );
     }
     throw error;
@@ -464,14 +760,14 @@ function rollbackRename(oldName, newName, hadDirectory, hadWrapper, profilesDir,
     try {
       renameBrowserWrapper(newName, oldName, browsersDir);
     } catch (error) {
-      rollbackErrors.push(`browser wrapper: ${formatError(error)}`);
+      rollbackErrors.push(`browser wrapper: ${formatError2(error)}`);
     }
   }
   if (hadDirectory) {
     try {
       renameProfileDir(newName, oldName, profilesDir);
     } catch (error) {
-      rollbackErrors.push(`profile dir: ${formatError(error)}`);
+      rollbackErrors.push(`profile dir: ${formatError2(error)}`);
     }
   }
   if (rollbackErrors.length > 0) {
@@ -486,14 +782,14 @@ function rollbackStorage(name, stagedDir, stagedWrapper, profilesDir, browsersDi
     try {
       restoreStagedProfileDir(stagedDir, name, profilesDir);
     } catch (error) {
-      rollbackErrors.push(`profile dir: ${formatError(error)}`);
+      rollbackErrors.push(`profile dir: ${formatError2(error)}`);
     }
   }
   if (stagedWrapper) {
     try {
       restoreStagedBrowserWrapper(stagedWrapper, name, browsersDir);
     } catch (error) {
-      rollbackErrors.push(`browser wrapper: ${formatError(error)}`);
+      rollbackErrors.push(`browser wrapper: ${formatError2(error)}`);
     }
   }
   if (rollbackErrors.length > 0) {
@@ -506,7 +802,7 @@ function restoreConfigEntry(meta, configFile) {
   }
   addProfile(meta, configFile);
 }
-function formatError(error) {
+function formatError2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
@@ -571,7 +867,7 @@ function registerLogin(program2) {
     }
   });
 }
-function confirm(question) {
+function confirm2(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
@@ -588,7 +884,7 @@ function registerRemove(program2) {
         throw new Error(`Profile "${name}" does not exist`);
       }
       if (!opts.force) {
-        const ok = await confirm(`Remove profile "${name}"? (y/N) `);
+        const ok = await confirm2(`Remove profile "${name}"? (y/N) `);
         if (!ok) {
           console.log("Cancelled");
           return;
@@ -701,8 +997,10 @@ function registerUse(program2) {
 }
 
 // src/index.ts
-var program = new Command().name("ccm").version("0.3.0").description("Manage multiple Claude Code profiles");
+var program = new Command().name("ccm").version("0.5.0").description("Manage multiple Claude Code profiles");
 registerCreate(program);
+registerCopyConfig(program);
+registerCompliance(program);
 registerList(program);
 registerRemove(program);
 registerRename(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remeic/ccm",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "nvm-like manager for Claude Code profiles",
   "license": "MIT",
   "author": "Giulio Fagioli",