cchost 0.3.1 → 0.4.1

package/lib/share.js

@@ -5,11 +5,34 @@ const path = require('path');
 
 const profiles = require('./profiles');
 
-// 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.
-// plugins/ carries auth tokens and is intentionally excluded (future opt-in).
-const SHARED_SUBDIRS = ['projects', 'skills', 'agents', 'commands'];
+// v0.4.1: every profile shares 7 resources with ~/.claude/ (the pool).
+//   - 4 directories: projects/, skills/, agents/, commands/
+//   - 3 single files: mcp.json, settings.json, CLAUDE.md
+// Each resource is a symlink (junction on Windows for dirs; file symlink for
+// files — Developer Mode required on Windows or it's skipped with a warning).
+//
+// Resources are grouped into 3 buckets so callers can target a subset:
+//   --projects → projects/
+//   --tools    → skills/, agents/, commands/
+//   --config   → mcp.json, settings.json, CLAUDE.md
+//
+// sessions/ is transient per-process state — never shared.
+// plugins/ carries auth tokens — never shared.
+// .credentials.json, .claude.json, .cc-env.json stay per-profile (identity).
+const PROJECT_SUBDIRS = ['projects'];
+const TOOL_SUBDIRS = ['skills', 'agents', 'commands'];
+const CONFIG_FILES = ['mcp.json', 'settings.json', 'CLAUDE.md'];
+
+const SHARED_DIRS = [...PROJECT_SUBDIRS, ...TOOL_SUBDIRS];
+const SHARED_RESOURCES = [...SHARED_DIRS, ...CONFIG_FILES];
+
+// Legacy alias — older callers / tests expect the name SHARED_SUBDIRS for the
+// 4-dir set. Kept exported so we don't break them.
+const SHARED_SUBDIRS = SHARED_DIRS;
+
+function isFileResource(name) {
+  return CONFIG_FILES.includes(name);
+}
 
 function symlinkType() {
   return process.platform === 'win32' ? 'junction' : 'dir';
@@ -23,6 +46,45 @@ function isLink(p) {
   }
 }
 
+// True if `linkPath` is currently sharing `targetPath` — either via a symlink
+// that resolves to it, or (Windows fallback only) via a hard link to the same
+// inode. Used for "Shared: N/7" counting and for the doctor check.
+function isSharedResource(profileDir, resource) {
+  const linkPath = path.join(profileDir, resource);
+  const targetPath = path.join(poolDir(), resource);
+  let lstat;
+  try {
+    lstat = fs.lstatSync(linkPath);
+  } catch {
+    return false;
+  }
+  if (lstat.isSymbolicLink()) {
+    try {
+      return fs.realpathSync(linkPath) === fs.realpathSync(targetPath);
+    } catch {
+      return false;
+    }
+  }
+  // Hard link fallback: a file resource may have been hard-linked on Windows
+  // when symlink creation failed. Compare inodes.
+  if (lstat.isFile() && isFileResource(resource)) {
+    try {
+      const targetStat = fs.statSync(targetPath);
+      return (
+        lstat.ino !== 0 &&
+        lstat.ino === targetStat.ino &&
+        lstat.dev === targetStat.dev
+      );
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+// Windows junctions are removed via rmdir, not unlink. POSIX symlinks via
+// unlink. File symlinks via unlink on both platforms. removeLink tries unlink
+// first and falls back to rmdir on Windows. The link target is untouched.
 function removeLink(p) {
   try {
     fs.unlinkSync(p);
@@ -37,80 +99,160 @@ function copyRecursive(src, dst) {
   fs.cpSync(src, dst, { recursive: true, verbatimSymlinks: true });
 }
 
-function ensureSharedDirs() {
-  const base = profiles.sharedDir();
-  for (const sub of SHARED_SUBDIRS) {
+// Resolve which resources to operate on. Default (no flags) = all 7.
+function resolveSubset({ tools, projects, config } = {}) {
+  const any = tools || projects || config;
+  if (!any) return SHARED_RESOURCES.slice();
+  const out = [];
+  if (projects) out.push(...PROJECT_SUBDIRS);
+  if (tools) out.push(...TOOL_SUBDIRS);
+  if (config) out.push(...CONFIG_FILES);
+  return out;
+}
+
+function poolDir() {
+  return profiles.defaultClaudeDir();
+}
+
+// Make sure the pool side of each requested resource exists. Dirs are mkdir'd;
+// files get an empty placeholder if missing so the symlink has something to
+// point at.
+function ensurePoolResources(subset = SHARED_RESOURCES) {
+  const base = poolDir();
+  try {
+    fs.mkdirSync(base, { recursive: true });
+  } catch (err) {
+    throw new Error(`Cannot create ${base}: ${err.message}`);
+  }
+  for (const resource of subset) {
+    const target = path.join(base, resource);
     try {
-      fs.mkdirSync(path.join(base, sub), { recursive: true });
+      if (isFileResource(resource)) {
+        if (!fs.existsSync(target)) fs.writeFileSync(target, '');
+      } else {
+        fs.mkdirSync(target, { recursive: true });
+      }
     } catch (err) {
-      throw new Error(`Cannot create ${path.join(base, sub)}: ${err.message}`);
+      throw new Error(`Cannot create ${target}: ${err.message}`);
     }
   }
   return base;
 }
 
-function migrateIntoShared(profileName, src, sharedTarget) {
-  if (!fs.existsSync(src)) return 0;
-  fs.mkdirSync(sharedTarget, { recursive: true });
-  let moved = 0;
-  for (const ent of fs.readdirSync(src)) {
-    const from = path.join(src, ent);
-    let to = path.join(sharedTarget, ent);
-    if (fs.existsSync(to)) {
-      to = path.join(sharedTarget, `${ent}__${profileName}`);
-      let i = 2;
-      while (fs.existsSync(to)) {
-        to = path.join(sharedTarget, `${ent}__${profileName}_${i}`);
-        i += 1;
-      }
+// Create the symlink for one resource. For dirs uses junction (Windows) or dir
+// symlink (POSIX). For files attempts a file symlink first; on Windows without
+// Developer Mode this fails with EPERM/UNKNOWN and we fall back to a hard
+// link, which works without elevation and behaves identically for normal
+// edit-in-place flows (the leak: `rm + create` breaks the link).
+function createResourceLink(target, link, resource) {
+  if (!isFileResource(resource)) {
+    fs.symlinkSync(target, link, symlinkType());
+    return { kind: 'symlink' };
+  }
+  try {
+    fs.symlinkSync(target, link, 'file');
+    return { kind: 'symlink' };
+  } catch (err) {
+    if (
+      process.platform === 'win32' &&
+      (err.code === 'EPERM' || err.code === 'UNKNOWN' || err.code === 'EACCES')
+    ) {
+      fs.linkSync(target, link);
+      return { kind: 'hardlink' };
     }
-    fs.renameSync(from, to);
-    moved += 1;
+    throw err;
   }
-  fs.rmdirSync(src);
-  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) {
+// Link each requested resource of a profile into the shared pool (~/.claude/).
+// Each resource is attempted independently — one failure doesn't abort the
+// rest. Returns [{ resource, status, ... }]; status ∈
+//   'linked' | 'already-linked' | 'refused' | 'failed'
+//
+// 'refused' is the v0.4.1 behavior when the profile holds private content at
+// the resource path: we do NOT auto-move it into the pool (was the v0.4.0
+// behavior for dirs). The user must move/remove it manually.
+function shareLink(profileName, opts = {}) {
   profiles.validateProfileName(profileName);
   const pdir = profiles.profileDir(profileName);
   if (!fs.existsSync(pdir)) {
-    const err = new Error(`Profile "${profileName}" does not exist. Create it with \`cc add ${profileName}\` first.`);
+    const err = new Error(
+      `Profile "${profileName}" does not exist. Create it with \`cc add ${profileName}\` first.`,
+    );
     err.exitCode = 1;
     throw err;
   }
-  ensureSharedDirs();
+  const subset = resolveSubset(opts);
+  ensurePoolResources(subset);
+  const pool = poolDir();
+  const legacyPool = profiles.sharedDir();
   const results = [];
-  for (const sub of SHARED_SUBDIRS) {
-    const target = path.join(profiles.sharedDir(), sub);
-    const link = path.join(pdir, sub);
+  for (const resource of subset) {
+    const target = path.join(pool, resource);
+    const link = path.join(pdir, resource);
     try {
+      // Case 1: already a symlink.
       if (isLink(link)) {
-        results.push({ sub, status: 'already-linked' });
+        const current = fs.readlinkSync(link);
+        const resolved = path.resolve(pdir, current);
+        if (resolved === target) {
+          results.push({ resource, status: 'already-linked' });
+          continue;
+        }
+        if (resolved === path.join(legacyPool, resource)) {
+          // Legacy v0.3 pointer — silently relink to the new pool location.
+          removeLink(link);
+          const r = createResourceLink(target, link, resource);
+          results.push({ resource, status: 'linked', relinkedFromLegacy: true, kind: r.kind });
+          continue;
+        }
+        // Points somewhere unexpected — don't touch it.
+        results.push({ resource, status: 'already-linked' });
+        continue;
+      }
+
+      // Case 2: already linked via hard link (Windows file fallback).
+      if (isSharedResource(pdir, resource)) {
+        results.push({ resource, status: 'already-linked' });
         continue;
       }
-      let moved = 0;
+
+      // Case 3: a real path exists at the link location — private content.
       if (fs.existsSync(link)) {
-        moved = migrateIntoShared(profileName, link, target);
+        const hasContent = isFileResource(resource)
+          ? true // any private file counts as content
+          : (() => {
+              try { return fs.readdirSync(link).length > 0; } catch { return false; }
+            })();
+        if (hasContent) {
+          results.push({
+            resource,
+            status: 'refused',
+            message:
+              `private content exists at ${link} — move or remove it manually, ` +
+              `then re-run \`cc link ${profileName}\``,
+          });
+          continue;
+        }
+        // Empty private dir — safe to remove and replace with a symlink.
+        try { fs.rmdirSync(link); } catch { /* fall through; create will fail clearly */ }
       }
-      fs.symlinkSync(target, link, symlinkType());
-      results.push({ sub, status: 'linked', moved });
+
+      const r = createResourceLink(target, link, resource);
+      results.push({ resource, status: 'linked', kind: r.kind });
     } catch (err) {
-      results.push({ sub, status: 'failed', message: err.message });
+      results.push({ resource, status: 'failed', message: err.message });
     }
   }
   return results;
 }
 
-// Mirror of shareLink: each directory is restored independently.
-// Returns [{ sub, status, message? }]; status is one of:
+// Mirror of shareLink: each requested resource is restored to a private real
+// directory or file. Content is copied from the pool (skip same-name
+// collisions, defensive) so the profile keeps its current view.
+// Returns [{ resource, status, ... }]; status ∈
 //   'unlinked' | 'not-linked' | 'failed'
-function shareUnlink(profileName) {
+function shareUnlink(profileName, opts = {}) {
   profiles.validateProfileName(profileName);
   const pdir = profiles.profileDir(profileName);
   if (!fs.existsSync(pdir)) {
@@ -118,34 +260,178 @@ function shareUnlink(profileName) {
     err.exitCode = 1;
     throw err;
   }
+  const subset = resolveSubset(opts);
+  const pool = poolDir();
   const results = [];
-  for (const sub of SHARED_SUBDIRS) {
-    const link = path.join(pdir, sub);
-    const target = path.join(profiles.sharedDir(), sub);
+  for (const resource of subset) {
+    const link = path.join(pdir, resource);
+    const target = path.join(pool, resource);
     try {
-      if (!isLink(link)) {
-        results.push({ sub, status: 'not-linked' });
+      const symLinked = isLink(link);
+      const hardLinked = !symLinked && isSharedResource(pdir, resource);
+      if (!symLinked && !hardLinked) {
+        results.push({ resource, status: 'not-linked' });
         continue;
       }
+
+      // Read pool content BEFORE removing the link (in case the link is the
+      // only path to it... well, not really — target is reachable directly —
+      // but reading first means we can fail without leaving a deleted link).
+      if (isFileResource(resource)) {
+        // Files: read current content, then replace link with a real file.
+        let buf = null;
+        if (fs.existsSync(target)) {
+          try { buf = fs.readFileSync(target); } catch { buf = null; }
+        }
+        // For a hard link, unlink decrements ref count — target file in pool
+        // survives. For a symlink, unlink removes the link only.
+        removeLink(link);
+        if (buf != null) {
+          fs.writeFileSync(link, buf);
+        } else {
+          fs.writeFileSync(link, '');
+        }
+        results.push({ resource, status: 'unlinked' });
+        continue;
+      }
+
+      // Dirs: replace symlink with a real dir, then copy contents (skip
+      // same-name collisions — defensive, dir is fresh so collisions
+      // shouldn't happen).
       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));
+          const from = path.join(target, ent);
+          const to = path.join(link, ent);
+          if (fs.existsSync(to)) continue; // skip same-name
+          copyRecursive(from, to);
         }
       }
-      results.push({ sub, status: 'unlinked' });
+      results.push({ resource, status: 'unlinked' });
     } catch (err) {
-      results.push({ sub, status: 'failed', message: err.message });
+      results.push({ resource, status: 'failed', message: err.message });
     }
   }
   return results;
 }
 
+// One-time migration from the v0.2/v0.3 legacy pool at ~/.claude-shared/ to
+// the v0.4 pool at ~/.claude/. Idempotent: a second call is a no-op once the
+// legacy dir is gone. Non-destructive: existing entries in ~/.claude/ survive
+// via the `__legacy` collision rename used here.
+//
+// Returns { migrated, moves: [...], relinked: [...], failures: [...] }
+function migrateLegacyPool({ log = () => {} } = {}) {
+  const legacy = profiles.sharedDir();
+  if (!fs.existsSync(legacy)) {
+    return { migrated: false, moves: [], relinked: [], failures: [] };
+  }
+  const pool = poolDir();
+  const moves = [];
+  const relinked = [];
+  const failures = [];
+
+  // Legacy pool only ever held the 4 dirs — config files are new in v0.4.1.
+  for (const sub of SHARED_DIRS) {
+    const legacySub = path.join(legacy, sub);
+    if (!fs.existsSync(legacySub)) continue;
+    try {
+      fs.mkdirSync(path.join(pool, sub), { recursive: true });
+    } catch (err) {
+      failures.push({ kind: 'mkdir', sub, message: err.message });
+      continue;
+    }
+    let entries;
+    try {
+      entries = fs.readdirSync(legacySub);
+    } catch (err) {
+      failures.push({ kind: 'readdir', sub, message: err.message });
+      continue;
+    }
+    for (const ent of entries) {
+      const from = path.join(legacySub, ent);
+      let to = path.join(pool, sub, ent);
+      if (fs.existsSync(to)) {
+        to = path.join(pool, sub, `${ent}__legacy`);
+        let i = 2;
+        while (fs.existsSync(to)) {
+          to = path.join(pool, sub, `${ent}__legacy_${i}`);
+          i += 1;
+        }
+      }
+      try {
+        fs.renameSync(from, to);
+        moves.push({ sub, name: ent, to });
+        log(`  ${sub}/${ent} → ${to}`);
+      } catch (err) {
+        failures.push({ kind: 'move', sub, name: ent, message: err.message });
+      }
+    }
+    try {
+      if (fs.readdirSync(legacySub).length === 0) fs.rmdirSync(legacySub);
+    } catch {
+      // best-effort
+    }
+  }
+
+  // Re-point any existing profile symlinks from legacy/<sub> to pool/<sub>.
+  let allProfiles;
+  try {
+    allProfiles = profiles.listProfiles();
+  } catch {
+    allProfiles = [];
+  }
+  for (const p of allProfiles) {
+    for (const sub of SHARED_DIRS) {
+      const link = path.join(p.dir, sub);
+      if (!isLink(link)) continue;
+      let resolved;
+      try {
+        resolved = path.resolve(p.dir, fs.readlinkSync(link));
+      } catch {
+        continue;
+      }
+      if (resolved !== path.join(legacy, sub)) continue;
+      try {
+        removeLink(link);
+        fs.symlinkSync(path.join(pool, sub), link, symlinkType());
+        relinked.push({ profile: p.name, sub });
+        log(`  ${p.name}/${sub}: relinked → ~/.claude/${sub}/`);
+      } catch (err) {
+        failures.push({ kind: 'relink', profile: p.name, sub, message: err.message });
+      }
+    }
+  }
+
+  // Remove the legacy pool dir if it ended up empty.
+  try {
+    if (fs.existsSync(legacy) && fs.readdirSync(legacy).length === 0) {
+      fs.rmdirSync(legacy);
+      log('  removed empty ~/.claude-shared/');
+    }
+  } catch {
+    // best-effort
+  }
+
+  return { migrated: true, moves, relinked, failures };
+}
+
 module.exports = {
-  SHARED_SUBDIRS,
+  SHARED_RESOURCES,
+  SHARED_DIRS,
+  SHARED_SUBDIRS, // legacy alias for SHARED_DIRS
+  TOOL_SUBDIRS,
+  PROJECT_SUBDIRS,
+  CONFIG_FILES,
+  isFileResource,
   isLink,
+  isSharedResource,
   removeLink,
   shareLink,
   shareUnlink,
+  resolveSubset,
+  poolDir,
+  ensurePoolResources,
+  migrateLegacyPool,
 };

package/package.json

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

package/lib/migrate.js

@@ -1,145 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const profiles = require('./profiles');
-
-// 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'];
-
-// .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');
-}
-
-function usageError(msg) {
-  const e = new Error(msg);
-  e.exitCode = 2;
-  return e;
-}
-
-function resolveSource(src) {
-  if (src === 'default') return { kind: 'default', dir: defaultClaudeDir() };
-  if (src === 'shared') return { kind: 'shared', dir: profiles.sharedDir() };
-  throw usageError(`Invalid migrate source "${src}". Allowed: default, shared.`);
-}
-
-function resolveDest(dest) {
-  if (dest === 'shared') return { kind: 'shared', dir: profiles.sharedDir() };
-  if (dest === 'default') {
-    throw usageError('Cannot migrate into "default". Allowed destinations: shared, <profile>.');
-  }
-  profiles.validateProfileName(dest);
-  return { kind: 'profile', name: dest, dir: profiles.profileDir(dest) };
-}
-
-function copyTreeSkipCollisions(srcRoot, dstRoot, { force = false } = {}) {
-  if (!fs.existsSync(srcRoot)) return { copied: 0, skipped: 0 };
-  fs.mkdirSync(dstRoot, { recursive: true });
-  let copied = 0;
-  let skipped = 0;
-  for (const ent of fs.readdirSync(srcRoot, { withFileTypes: true })) {
-    if (EXCLUDED_FILES.has(ent.name)) continue;
-    const from = path.join(srcRoot, ent.name);
-    const to = path.join(dstRoot, ent.name);
-    if (fs.existsSync(to)) {
-      if (force) {
-        fs.rmSync(to, { recursive: true, force: true });
-      } else {
-        skipped += 1;
-        continue;
-      }
-    }
-    fs.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
-    copied += 1;
-  }
-  return { copied, skipped };
-}
-
-// 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);
-
-  if (path.resolve(src.dir) === path.resolve(dest.dir)) {
-    throw usageError(`Source and destination resolve to the same directory (${src.dir}).`);
-  }
-
-  if (dest.kind === 'profile') {
-    profiles.ensureProfileDir(dest.name);
-  } else {
-    fs.mkdirSync(dest.dir, { recursive: true });
-  }
-
-  if (!fs.existsSync(src.dir)) {
-    console.log(`Source ${src.dir} does not exist. Nothing to migrate.`);
-    return { copied: 0, skipped: 0, files: {} };
-  }
-
-  let totalCopied = 0;
-  let totalSkipped = 0;
-  for (const sub of SUBDIRS) {
-    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, { 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, files: fileResults };
-}
-
-module.exports = {
-  migrate,
-  defaultClaudeDir,
-  resolveSource,
-  resolveDest,
-  copyTreeSkipCollisions,
-  copySingleFile,
-  SUBDIRS,
-  SINGLE_FILES,
-  EXCLUDED_FILES,
-};