cchost 0.2.0 → 0.2.1

package/README.md

@@ -18,10 +18,10 @@ Requires Node.js 18+ and Claude Code 2.1.140+ already installed. Get Claude Code
 | --- | --- |
 | `cc add <profile>` | Create a profile directory. |
 | `cc use <profile> [...args]` | Launch Claude under that profile. Profile must already exist. Args after the name are forwarded verbatim to `claude`. |
-| `cc list [--json]` | Show every profile: login state, account email, and storage mode (`shared` / `isolated`). |
-| `cc migrate <src> <dest>` | Copy projects from `default`\|`shared` to `shared`\|`<profile>`. Skip-on-collision; credential files never copied. |
-| `cc link <profile> [<profile>...]` | Link a profile's `projects/` to `~/.claude-shared/projects`. Migrates existing content; renames on collision. |
-| `cc unlink <profile>` | Restore a profile to its own private `projects/` (copies shared content back). |
+| `cc list [--json]` | Show every profile: login state, account email, and how many artifact dirs are linked to shared (N/4). |
+| `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). |
 | `cc remove <profile>` | Delete a profile. Requires typing the profile name to confirm. |
 | `cc doctor [--fix [--force]] [--json]` | Diagnose environment, storage, and platform issues. |
 | `cc help [command]` | Print usage (top-level, or for a single command). |
@@ -40,42 +40,63 @@ cc remove old-profile
 `cc list` output:
 
 ```
-Profile   LoggedIn  Email                 Storage
-personal  true      personal@example.com  isolated
-scratch   false     -                     isolated
-work      true      work@example.com      shared
+Profile   LoggedIn  Email                 Shared
+personal  true      personal@example.com  4/4
+scratch   false     -                     0/4
+work      true      work@example.com      0/4
 ```
 
-### Migrating existing projects
+### What migrate copies and what link shares
 
-If you've been using Claude Code without profiles, your history lives in `~/.claude/projects/`. Pull it into a profile or the shared pool:
+| Artifact | `cc migrate` copies it | `cc link` shares it | Notes |
+| --- | :---: | :---: | --- |
+| `projects/` | ✓ | ✓ | Resumable conversation transcripts |
+| `skills/` | ✓ | ✓ | Custom slash-command scripts |
+| `agents/` | ✓ | ✓ | Custom agent definitions |
+| `commands/` | ✓ | ✓ | Custom command configs |
+| `mcp.json` | ✓ (default→profile only) | — | Per-profile MCP server config; may carry auth tokens |
+| `settings.json` | ✓ (default→profile only) | — | Per-profile UI/feature settings |
+| `CLAUDE.md` | ✓ (default→profile only) | — | Per-profile project instructions |
+| `sessions/` | — | — | Transient per-process state; sharing would corrupt bookkeeping |
+| `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 |
+
+`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.
+
+### Migrating existing artifacts
+
+If you've been using Claude Code without profiles, your history lives in `~/.claude/`. Pull it into a profile or the shared pool:
 
 ```bash
-cc migrate default work        # copy ~/.claude/projects → ~/.claude-profiles/work/projects
-cc migrate default shared      # copy ~/.claude/projects → ~/.claude-shared/projects
-cc migrate shared personal     # copy ~/.claude-shared/projects → ~/.claude-profiles/personal/projects
+cc migrate default work        # copy ~/.claude/* → ~/.claude-profiles/work/
+cc migrate default shared      # copy ~/.claude/projects,skills,agents,commands → ~/.claude-shared/
+cc migrate shared personal     # copy ~/.claude-shared/* → ~/.claude-profiles/personal/
+cc migrate default work --force  # same as first, overwriting anything that already exists
 ```
 
-This is a **copy** — the source is left untouched. If an entry already exists at the destination, the source entry is skipped (no overwrite). Credential files (`.credentials.json`, `.claude.json`) are never copied: each profile keeps its own auth state.
+This is a **copy** — the source is left untouched. By default, if an entry already exists at the destination it is silently skipped. Pass `--force` to overwrite instead — existing destination content will be cleared.
+
+Credential files (`.credentials.json`, `.claude.json`) are never copied: each profile keeps its own auth state.
 
-### Shared history across profiles
+### Shared artifacts across profiles
 
-If you want each profile to keep separate credentials but share project history (e.g. rotate accounts on the same project when usage limits hit):
+If you want each profile to keep separate credentials but share project history and skills (e.g. rotate accounts on the same project when usage limits hit):
 
 ```bash
 cc link work
 cc link personal
 ```
 
-`work/projects` and `personal/projects` become links to `~/.claude-shared/projects`. On Windows this uses directory junctions (no admin/Developer Mode required); on macOS/Linux, regular symlinks.
+`work/` and `personal/` each get four linked dirs (`projects`, `skills`, `agents`, `commands`) pointing to `~/.claude-shared/`. On Windows this uses directory junctions (no admin/Developer Mode required); on macOS/Linux, regular symlinks.
 
-**Only `projects/` is shared.** That's the directory Claude Code uses for resumable conversation transcripts (`projects/<project>/<session>.jsonl`). The sibling `sessions/` folder holds transient per-process registry state — PID, working directory, status, timestamps — and is **never** linked, migrated, or copied across profiles. Sharing it would corrupt Claude's running-process bookkeeping. `sessions/` stays per-profile under `~/.claude-profiles/<name>/sessions/`.
+`sessions/` is **never** linked. It holds transient per-process registry state — PID, working directory, status, timestamps — and sharing it would corrupt Claude's running-process bookkeeping. It stays per-profile under `~/.claude-profiles/<name>/sessions/`.
 
 `cc link a b c` links several profiles at once; per-profile failures are reported but don't abort the rest of the batch.
 
 If two profiles share history and you launch them against the same project at the same time, both will write to the same session files (last write wins). Don't do that.
 
-`cc remove` is safe with shared profiles — it deletes only the link, never recursing into the shared target.
+`cc remove` is safe with shared profiles — it deletes only the links, never recursing into the shared target.
 
 ## How it works
 

package/lib/cli.js

@@ -16,10 +16,10 @@ const HELP = `cc - Multi-profile launcher for Claude Code
 Usage:
   cc add <profile>                                 Create a profile directory
   cc use <profile> [...args]                       Launch Claude under a named profile
-  cc list [--json]                                 Show all profiles: login state, email, storage (shared/isolated)
-  cc migrate <src> <dest>                          Copy projects from default|shared to shared|<profile>
-  cc link <p>...                                   Replace each profile's projects/ with a link to shared
-  cc unlink <profile>                              Restore a profile's private projects/
+  cc list [--json]                                 Show all profiles: login state, email, shared-dir count (N/4)
+  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
   cc remove <profile>                              Delete a profile and all its data (typed confirmation)
   cc doctor [--fix [--force]] [--json]             Diagnose environment, storage, and platform issues
   cc help [command]                                Show usage (optionally for a single command)
@@ -58,47 +58,64 @@ Columns:
   Profile   - profile name
   LoggedIn  - true if .credentials.json exists
   Email     - account email from .claude.json; - if not yet logged in
-  Storage   - 'shared' if projects/ is linked to ~/.claude-shared, 'isolated' otherwise
+  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, storage}.
+With --json, emits an array of {name, dir, loggedIn, email, shared}.
 `,
-  migrate: `cc migrate <src> <dest>
+  migrate: `cc migrate <src> <dest> [--force]
 
-Copy projects/ from a source to a destination. sessions/ (transient per-process
-registry state) is never migrated. This is a COPY — the source is left untouched.
+Copy artifact directories from a source to a destination. This is a COPY — the
+source is left untouched. sessions/ is never migrated (transient per-process state).
 
   <src>:   default | shared
            default = ~/.claude/        (Claude's built-in non-profile data)
            shared  = ~/.claude-shared/ (the cc shared pool)
   <dest>:  shared | <profile-name>
 
-On collisions, existing entries at the destination are left alone (the source
-entry is skipped). Credential files (.credentials.json, .claude.json) are
-never copied — the destination keeps its own auth state.
+Directories copied in all cases:
+  projects/, skills/, agents/, commands/
+
+Extra files copied only when src=default and dest=<profile>:
+  mcp.json, settings.json, CLAUDE.md
+  (These carry per-profile config and are NOT copied to shared.)
+
+Never copied: .credentials.json, .claude.json, sessions/, plugins/
+
+Collision behavior (default): existing entries at the destination are silently
+skipped — the source entry is left alone.
+
+--force  Overwrite existing entries instead of skipping.
+         Warning: existing content at the destination will be cleared.
 
 Examples:
-  cc migrate default work     # ~/.claude/projects -> ~/.claude-profiles/work/projects
-  cc migrate default shared   # ~/.claude/projects -> ~/.claude-shared/projects
-  cc migrate shared work      # ~/.claude-shared/projects -> ~/.claude-profiles/work/projects
+  cc migrate default work            # copy ~/.claude/* to ~/.claude-profiles/work/
+  cc migrate default shared          # copy dirs to ~/.claude-shared/
+  cc migrate shared work             # copy shared dirs to ~/.claude-profiles/work/
+  cc migrate default work --force    # same, overwriting any existing items
 `,
   link: `cc link <profile> [<profile>...]
 
-Replace each profile's projects/ with a link to ~/.claude-shared/projects/.
-Existing content is migrated into shared first; collisions are renamed with a
-__<profile> suffix (never overwritten). sessions/ (transient per-process state)
-is intentionally never linked — it stays per-profile.
+Replace each profile's artifact directories with links to ~/.claude-shared/:
+  projects/, skills/, agents/, commands/
+
+Existing content in each directory is migrated into shared first; collisions
+are renamed with a __<profile> suffix (never overwritten). sessions/ (transient
+per-process state) is intentionally never linked — it stays per-profile.
 
 On Windows, link uses directory junctions (no admin/Developer Mode needed).
 On macOS/Linux, regular symlinks.
 
-Multiple profiles can be linked at once: 'cc link a b c'. Per-profile failures
-are reported but don't abort the rest of the batch.
+Multiple profiles can be linked at once: 'cc link a b c'. Failures are handled
+per directory and per profile: one directory failing does not stop the other
+three, and one profile failing does not stop the rest of the batch. A
+per-directory summary is printed; exit code is 1 if anything failed.
 `,
   unlink: `cc unlink <profile>
 
-Remove a profile's projects/ link to ~/.claude-shared/ and copy shared content
-back into the profile as a private dir.
+Remove each linked artifact directory (projects/, skills/, agents/, commands/)
+and copy the shared content back into the profile as private dirs.
 `,
   remove: `cc remove <profile>
 
@@ -240,15 +257,18 @@ async function cmdUse(rest) {
 function cmdList(rest) {
   const { flags } = parseFlagsStrict(rest, ['--json']);
   const list = profiles.listProfiles();
+  const total = share.SHARED_SUBDIRS.length;
 
   const enriched = list.map((p) => {
-    const storage = isLinkLike(path.join(p.dir, 'projects')) ? 'shared' : 'isolated';
+    const sharedCount = share.SHARED_SUBDIRS.filter(sub =>
+      isLinkLike(path.join(p.dir, sub))
+    ).length;
     return {
       name: p.name,
       dir: p.dir,
       loggedIn: p.loggedIn,
       email: p.email,
-      storage,
+      shared: sharedCount,
     };
   });
 
@@ -263,13 +283,13 @@ function cmdList(rest) {
     return 0;
   }
 
-  const rows = [['Profile', 'LoggedIn', 'Email', 'Storage']];
+  const rows = [['Profile', 'LoggedIn', 'Email', 'Shared']];
   for (const p of enriched) {
     rows.push([
       p.name,
       p.loggedIn ? 'true' : 'false',
       p.email ? p.email : '-',
-      p.storage,
+      `${p.shared}/${total}`,
     ]);
   }
   console.log(renderTable(rows));
@@ -311,29 +331,67 @@ async function cmdRemove(rest) {
 
 async function cmdLink(rest) {
   if (rest.length === 0) throw usageError('Usage: cc link <profile> [<profile>...]');
-  const failures = [];
+  const multi = rest.length > 1;
+  const summary = [];
   for (const name of rest) {
-    if (rest.length > 1) console.log(`\n[${name}]`);
+    if (multi) console.log(`\n[${name}]`);
+    let results;
     try {
-      share.shareLink(name);
+      results = share.shareLink(name);
     } catch (err) {
+      // Profile-level failure (invalid name, profile missing) — nothing linked.
       process.stderr.write(color.stderr.red(`  error: ${err.message}`) + '\n');
-      failures.push({ name, message: err.message });
+      summary.push({ name, linked: 0, total: share.SHARED_SUBDIRS.length, error: err.message });
+      continue;
+    }
+    for (const r of results) {
+      if (r.status === 'failed') {
+        process.stderr.write(color.stderr.red(`  ${r.sub}: failed — ${r.message}`) + '\n');
+      } else if (r.status === 'already-linked') {
+        console.log(`  ${r.sub}: already linked`);
+      } else {
+        const note = r.moved ? ` (migrated ${r.moved} item(s) into shared)` : '';
+        console.log(`  ${r.sub}: linked${note}`);
+      }
     }
+    const failed = results.filter((r) => r.status === 'failed');
+    const linked = results.length - failed.length;
+    console.log(`  ${linked}/${results.length} directories linked${failed.length ? `, ${failed.length} failed` : ''}.`);
+    summary.push({ name, linked, total: results.length, failed: failed.map((f) => f.sub) });
   }
-  if (rest.length > 1) {
-    const ok = rest.length - failures.length;
-    console.log(`\nSummary: ${ok} succeeded, ${failures.length} failed.`);
-    for (const f of failures) console.log(`  ${f.name}: ${f.message}`);
+
+  const anyFailure = summary.some((s) => s.error || (s.failed && s.failed.length));
+  if (multi) {
+    console.log('\nSummary:');
+    for (const s of summary) {
+      if (s.error) {
+        console.log(`  ${s.name}: error — ${s.error}`);
+      } else if (s.failed && s.failed.length) {
+        console.log(`  ${s.name}: ${s.linked}/${s.total} linked (failed: ${s.failed.join(', ')})`);
+      } else {
+        console.log(`  ${s.name}: ${s.linked}/${s.total} linked`);
+      }
+    }
   }
-  return failures.length === 0 ? 0 : 1;
+  return anyFailure ? 1 : 0;
 }
 
 async function cmdUnlink(rest) {
   const [name] = rest;
   if (!name) throw usageError('Usage: cc unlink <profile>');
-  share.shareUnlink(name);
-  return 0;
+  const results = share.shareUnlink(name);
+  let anyFailure = false;
+  for (const r of results) {
+    if (r.status === 'failed') {
+      anyFailure = true;
+      process.stderr.write(color.stderr.red(`  ${r.sub}: failed — ${r.message}`) + '\n');
+    } else if (r.status === 'not-linked') {
+      console.log(`  ${r.sub}: not linked, skipping`);
+    } else {
+      console.log(`  ${r.sub}: unlinked, content copied back`);
+    }
+  }
+  return anyFailure ? 1 : 0;
 }
 
 async function cmdDoctor(rest) {
@@ -347,10 +405,15 @@ async function cmdDoctor(rest) {
 }
 
 async function cmdMigrate(rest) {
-  const [src, dest, ...extra] = rest;
-  if (!src || !dest) throw usageError('Usage: cc migrate <src> <dest>');
+  const { flags, positional } = parseFlagsStrict(rest, ['--force'], { allowPositional: true });
+  const [src, dest, ...extra] = positional;
+  if (!src || !dest) throw usageError('Usage: cc migrate <src> <dest> [--force]');
   if (extra.length > 0) throw usageError(`Unexpected extra arguments: ${extra.join(' ')}`);
-  migrateLib.migrate(src, dest);
+  const force = flags.has('--force');
+  if (force) {
+    process.stdout.write('Warning: --force is set. Existing items at the destination will be overwritten and their current content will be cleared.\n');
+  }
+  migrateLib.migrate(src, dest, { force });
   return 0;
 }
 

package/lib/migrate.js

@@ -6,9 +6,14 @@ const os = require('os');
 
 const profiles = require('./profiles');
 
-// Only projects/ holds the resumable conversation transcripts. sessions/ is transient
-// per-process state and is intentionally not migrated.
-const SUBDIRS = ['projects'];
+// sessions/ is transient per-process state — intentionally not migrated.
+// plugins/ carries auth tokens — excluded until an explicit opt-in flag is added.
+const SUBDIRS = ['projects', 'skills', 'agents', 'commands'];
+
+// Single files copied only when src=default and dest=<profile>.
+// 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']);
 
 function defaultClaudeDir() {
@@ -36,7 +41,7 @@ function resolveDest(dest) {
   return { kind: 'profile', name: dest, dir: profiles.profileDir(dest) };
 }
 
-function copyTreeSkipCollisions(srcRoot, dstRoot) {
+function copyTreeSkipCollisions(srcRoot, dstRoot, { force = false } = {}) {
   if (!fs.existsSync(srcRoot)) return { copied: 0, skipped: 0 };
   fs.mkdirSync(dstRoot, { recursive: true });
   let copied = 0;
@@ -46,8 +51,12 @@ function copyTreeSkipCollisions(srcRoot, dstRoot) {
     const from = path.join(srcRoot, ent.name);
     const to = path.join(dstRoot, ent.name);
     if (fs.existsSync(to)) {
-      skipped += 1;
-      continue;
+      if (force) {
+        fs.rmSync(to, { recursive: true, force: true });
+      } else {
+        skipped += 1;
+        continue;
+      }
     }
     fs.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
     copied += 1;
@@ -55,7 +64,23 @@ function copyTreeSkipCollisions(srcRoot, dstRoot) {
   return { copied, skipped };
 }
 
-function migrate(srcArg, destArg) {
+// Returns 'copied', 'skipped', or 'absent'.
+function copySingleFile(srcDir, dstDir, fileName, { force = false } = {}) {
+  const from = path.join(srcDir, fileName);
+  if (!fs.existsSync(from)) return 'absent';
+  const to = path.join(dstDir, fileName);
+  if (fs.existsSync(to)) {
+    if (force) {
+      fs.rmSync(to, { recursive: true, force: true });
+    } else {
+      return 'skipped';
+    }
+  }
+  fs.copyFileSync(from, to);
+  return 'copied';
+}
+
+function migrate(srcArg, destArg, { force = false } = {}) {
   const src = resolveSource(srcArg);
   const dest = resolveDest(destArg);
 
@@ -71,7 +96,7 @@ function migrate(srcArg, destArg) {
 
   if (!fs.existsSync(src.dir)) {
     console.log(`Source ${src.dir} does not exist. Nothing to migrate.`);
-    return { copied: 0, skipped: 0 };
+    return { copied: 0, skipped: 0, files: {} };
   }
 
   let totalCopied = 0;
@@ -80,13 +105,27 @@ function migrate(srcArg, destArg) {
     const srcSub = path.join(src.dir, sub);
     const dstSub = path.join(dest.dir, sub);
     if (!fs.existsSync(srcSub)) continue;
-    const { copied, skipped } = copyTreeSkipCollisions(srcSub, dstSub);
+    const { copied, skipped } = copyTreeSkipCollisions(srcSub, dstSub, { force });
     console.log(`  ${sub}: copied ${copied}, skipped ${skipped}`);
     totalCopied += copied;
     totalSkipped += skipped;
   }
+
+  // Single config files: only when migrating from default into a profile.
+  const fileResults = {};
+  if (src.kind === 'default' && dest.kind === 'profile') {
+    for (const f of SINGLE_FILES) {
+      const result = copySingleFile(src.dir, dest.dir, f, { force });
+      fileResults[f] = result;
+      const label = result === 'absent' ? 'not present at source' : result;
+      console.log(`  ${f}: ${label}`);
+      if (result === 'copied') totalCopied += 1;
+      else if (result === 'skipped') totalSkipped += 1;
+    }
+  }
+
   console.log(`Done. Total copied: ${totalCopied}, total skipped (already present): ${totalSkipped}.`);
-  return { copied: totalCopied, skipped: totalSkipped };
+  return { copied: totalCopied, skipped: totalSkipped, files: fileResults };
 }
 
 module.exports = {
@@ -95,6 +134,8 @@ module.exports = {
   resolveSource,
   resolveDest,
   copyTreeSkipCollisions,
+  copySingleFile,
   SUBDIRS,
+  SINGLE_FILES,
   EXCLUDED_FILES,
 };

package/lib/share.js

@@ -5,10 +5,11 @@ const path = require('path');
 
 const profiles = require('./profiles');
 
-// Only projects/ holds the resumable conversation transcripts (projects/<proj>/<session>.jsonl).
+// Artifact directories that are safe to share across profiles via junctions/symlinks.
 // sessions/ is transient per-process registry state (PID, cwd, status, timestamps) and
 // must stay per-profile — sharing it would corrupt Claude's running-process bookkeeping.
-const SHARED_SUBDIRS = ['projects'];
+// plugins/ carries auth tokens and is intentionally excluded (future opt-in).
+const SHARED_SUBDIRS = ['projects', 'skills', 'agents', 'commands'];
 
 function symlinkType() {
   return process.platform === 'win32' ? 'junction' : 'dir';
@@ -70,6 +71,11 @@ function migrateIntoShared(profileName, src, sharedTarget) {
   return moved;
 }
 
+// Links each of the four artifact dirs independently. A failure on one
+// directory is recorded and the remaining directories are still attempted —
+// callers get a per-directory result and decide how to report it.
+// Returns [{ sub, status, moved?, message? }]; status is one of:
+//   'linked' | 'already-linked' | 'failed'
 function shareLink(profileName) {
   profiles.validateProfileName(profileName);
   const pdir = profiles.profileDir(profileName);
@@ -79,26 +85,31 @@ function shareLink(profileName) {
     throw err;
   }
   ensureSharedDirs();
+  const results = [];
   for (const sub of SHARED_SUBDIRS) {
     const target = path.join(profiles.sharedDir(), sub);
     const link = path.join(pdir, sub);
-    if (isLink(link)) {
-      console.log(`  ${sub}: already linked`);
-      continue;
-    }
-    if (fs.existsSync(link)) {
-      const moved = migrateIntoShared(profileName, link, target);
-      console.log(`  ${sub}: migrated ${moved} item(s) into shared`);
-    }
     try {
+      if (isLink(link)) {
+        results.push({ sub, status: 'already-linked' });
+        continue;
+      }
+      let moved = 0;
+      if (fs.existsSync(link)) {
+        moved = migrateIntoShared(profileName, link, target);
+      }
       fs.symlinkSync(target, link, symlinkType());
+      results.push({ sub, status: 'linked', moved });
     } catch (err) {
-      throw new Error(`Cannot link ${link} -> ${target}: ${err.message}`);
+      results.push({ sub, status: 'failed', message: err.message });
     }
-    console.log(`  ${sub}: linked -> ${target}`);
   }
+  return results;
 }
 
+// Mirror of shareLink: each directory is restored independently.
+// Returns [{ sub, status, message? }]; status is one of:
+//   'unlinked' | 'not-linked' | 'failed'
 function shareUnlink(profileName) {
   profiles.validateProfileName(profileName);
   const pdir = profiles.profileDir(profileName);
@@ -107,22 +118,28 @@ function shareUnlink(profileName) {
     err.exitCode = 1;
     throw err;
   }
+  const results = [];
   for (const sub of SHARED_SUBDIRS) {
     const link = path.join(pdir, sub);
     const target = path.join(profiles.sharedDir(), sub);
-    if (!isLink(link)) {
-      console.log(`  ${sub}: not linked, skipping`);
-      continue;
-    }
-    removeLink(link);
-    fs.mkdirSync(link, { recursive: true });
-    if (fs.existsSync(target)) {
-      for (const ent of fs.readdirSync(target)) {
-        copyRecursive(path.join(target, ent), path.join(link, ent));
+    try {
+      if (!isLink(link)) {
+        results.push({ sub, status: 'not-linked' });
+        continue;
       }
+      removeLink(link);
+      fs.mkdirSync(link, { recursive: true });
+      if (fs.existsSync(target)) {
+        for (const ent of fs.readdirSync(target)) {
+          copyRecursive(path.join(target, ent), path.join(link, ent));
+        }
+      }
+      results.push({ sub, status: 'unlinked' });
+    } catch (err) {
+      results.push({ sub, status: 'failed', message: err.message });
     }
-    console.log(`  ${sub}: unlinked, content copied back`);
   }
+  return results;
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cchost",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Host multiple isolated Claude Code accounts on one machine via the `cc` command.",
   "keywords": [
     "claude",