cchost 0.3.1 → 0.4.2

package/lib/copy.js

@@ -0,0 +1,242 @@
+'use strict';
+
+// `cc copy` — copy mcp.json / settings.json / CLAUDE.md / artifact dirs from
+// ~/.claude/ (default) into a profile. Renamed from `cc migrate` in v0.4.1;
+// `cc migrate` still works as a deprecation alias.
+//
+// Only direction supported: default → <profile>. The reverse and profile→
+// profile were considered and dropped — they're rare enough that a manual
+// `cp -r` is fine and keeps the surface small.
+//
+// Most v0.4 profiles have all 7 resources symlinked into the pool, so
+// `cc copy default foo` is usually a no-op (every resource resolves to the
+// same path as the source). The command is meaningful only when a resource
+// has been unlinked via `cc unlink`.
+
+const fs = require('fs');
+const path = require('path');
+
+const profiles = require('./profiles');
+const share = require('./share');
+
+const EXCLUDED_FILES = new Set(['.credentials.json', '.claude.json', '.cc-env.json']);
+
+function defaultClaudeDir() {
+  return profiles.defaultClaudeDir();
+}
+
+function usageError(msg) {
+  const e = new Error(msg);
+  e.exitCode = 2;
+  return e;
+}
+
+function rejectSharedKeyword(role) {
+  return usageError(
+    `'shared' is not a valid copy ${role} in v0.4. ` +
+      "The shared pool is now ~/.claude/ itself, reached via per-profile " +
+      "symlinks. Use `cc link <profile>` / `cc unlink <profile>` to manage " +
+      "which resources are shared.",
+  );
+}
+
+function resolveSource(src) {
+  if (src === 'default') return { kind: 'default', dir: defaultClaudeDir() };
+  if (src === 'shared') throw rejectSharedKeyword('source');
+  throw usageError(`Invalid copy source "${src}". Allowed: default.`);
+}
+
+function resolveDest(dest) {
+  if (dest === 'shared') throw rejectSharedKeyword('destination');
+  if (dest === 'default') {
+    throw usageError('Cannot copy into "default". Allowed destination: <profile>.');
+  }
+  profiles.validateProfileName(dest);
+  return { kind: 'profile', name: dest, dir: profiles.profileDir(dest) };
+}
+
+// Return resolved real paths, or null if a path can't be realpath'd. Used to
+// detect "src and dst are the same file/dir under symlinks/hardlinks".
+function realOrNull(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return null;
+  }
+}
+
+// Compare two existing paths for "are these the same on-disk object?". Honors
+// symlinks (via realpath) and hard links (via inode comparison for files).
+function sameOnDisk(a, b) {
+  const ra = realOrNull(a);
+  const rb = realOrNull(b);
+  if (ra && rb && ra === rb) return true;
+  // Inode comparison — covers Windows hard links where realpath does not
+  // resolve to the same string but the files share an inode.
+  try {
+    const sa = fs.statSync(a);
+    const sb = fs.statSync(b);
+    if (sa.isFile() && sb.isFile() && sa.ino !== 0 && sa.ino === sb.ino && sa.dev === sb.dev) {
+      return true;
+    }
+  } catch {
+    // either side missing — not the same
+  }
+  return false;
+}
+
+// Copy directory contents item-by-item with skip-on-collision (default) or
+// overwrite (force). Returns { copied, skipped }.
+function copyDirContents(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 };
+}
+
+// Copy a single file. Returns 'copied' | 'skipped' | 'absent'.
+function copySingleFile(srcPath, dstPath, { force = false } = {}) {
+  if (!fs.existsSync(srcPath)) return 'absent';
+  if (fs.existsSync(dstPath)) {
+    if (force) {
+      fs.rmSync(dstPath, { recursive: true, force: true });
+    } else {
+      return 'skipped';
+    }
+  }
+  fs.mkdirSync(path.dirname(dstPath), { recursive: true });
+  fs.copyFileSync(srcPath, dstPath);
+  return 'copied';
+}
+
+function formatResourceLabel(resource) {
+  return share.isFileResource(resource) ? resource : `${resource}/`;
+}
+
+// Main entry: copy each of the 7 shared resources from src → dest, honoring
+// the v0.4 symlink semantics. Logs per-resource progress and a closing
+// summary line. Returns a structured result for tests.
+function copy(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}).`);
+  }
+
+  profiles.ensureProfileDir(dest.name);
+  if (!fs.existsSync(src.dir)) {
+    console.log(`Source ${src.dir} does not exist. Nothing to copy.`);
+    return { copied: 0, skipped: 0, shared: 0, results: [] };
+  }
+
+  let totalCopied = 0;
+  let totalSkipped = 0;
+  let totalShared = 0;
+  const results = [];
+
+  // Compute the column width so the per-line output aligns.
+  const maxLabel = share.SHARED_RESOURCES.reduce(
+    (m, r) => Math.max(m, formatResourceLabel(r).length),
+    0,
+  );
+
+  for (const resource of share.SHARED_RESOURCES) {
+    const label = formatResourceLabel(resource).padEnd(maxLabel + 1);
+    const srcPath = path.join(src.dir, resource);
+    const dstPath = path.join(dest.dir, resource);
+    const isFile = share.isFileResource(resource);
+
+    // Already-shared check: same on-disk target via symlink or hard link.
+    if (fs.existsSync(dstPath) && fs.existsSync(srcPath) && sameOnDisk(srcPath, dstPath)) {
+      console.log(`  ${label} shared via symlink — skipped`);
+      results.push({ resource, status: 'shared' });
+      totalShared += 1;
+      continue;
+    }
+
+    if (!fs.existsSync(srcPath)) {
+      console.log(`  ${label} not present at source`);
+      results.push({ resource, status: 'absent' });
+      continue;
+    }
+
+    if (isFile) {
+      const r = copySingleFile(srcPath, dstPath, { force });
+      if (r === 'copied') {
+        console.log(`  ${label} copied`);
+        totalCopied += 1;
+      } else if (r === 'skipped') {
+        console.log(`  ${label} skipped (already present — pass --force to overwrite)`);
+        totalSkipped += 1;
+      } else {
+        console.log(`  ${label} not present at source`);
+      }
+      results.push({ resource, status: r });
+      continue;
+    }
+
+    const { copied, skipped } = copyDirContents(srcPath, dstPath, { force });
+    if (copied === 0 && skipped === 0) {
+      console.log(`  ${label} empty at source`);
+    } else if (copied > 0) {
+      const more = skipped > 0 ? `, skipped ${skipped} (already present)` : '';
+      console.log(`  ${label} copied ${copied} item(s)${more}`);
+    } else {
+      console.log(
+        `  ${label} skipped ${skipped} item(s) (all already present — pass --force to overwrite)`,
+      );
+    }
+    totalCopied += copied;
+    totalSkipped += skipped;
+    results.push({ resource, status: 'dir', copied, skipped });
+  }
+
+  console.log('');
+  if (totalCopied === 0 && totalShared === share.SHARED_RESOURCES.length) {
+    console.log(
+      `Nothing to copy — all ${share.SHARED_RESOURCES.length} resources are already shared via symlinks.`,
+    );
+    console.log(
+      `Tip: run \`cc unlink ${dest.name}\` first if you want private copies in this profile.`,
+    );
+  } else if (totalCopied === 0) {
+    console.log(
+      `Nothing copied. ${totalShared} shared via symlink, ${totalSkipped} skipped (already present).`,
+    );
+  } else {
+    console.log(
+      `Done. Copied ${totalCopied} item(s), ${totalShared} already shared via symlinks` +
+        (totalSkipped > 0 ? `, ${totalSkipped} skipped (already present)` : '') +
+        '.',
+    );
+  }
+
+  return { copied: totalCopied, skipped: totalSkipped, shared: totalShared, results };
+}
+
+module.exports = {
+  copy,
+  defaultClaudeDir,
+  resolveSource,
+  resolveDest,
+  copyDirContents,
+  copySingleFile,
+  EXCLUDED_FILES,
+};

package/lib/doctor.js

@@ -5,6 +5,7 @@ const path = require('path');
 const os = require('os');
 
 const profiles = require('./profiles');
+const share = require('./share');
 const { findClaude, getClaudeVersion, compareVersion, MIN_VERSION } = require('./spawn');
 const color = require('./color');
 
@@ -157,32 +158,162 @@ function checkProfileClaudeJson(prof) {
 
 function checkProfileLinks(prof) {
   const results = [];
-  const pp = path.join(prof.dir, 'projects');
-  let isLinkNode = false;
-  try { isLinkNode = fs.lstatSync(pp).isSymbolicLink(); } catch { return results; }
-  if (!isLinkNode) return results;
+  for (const resource of share.SHARED_RESOURCES) {
+    const pp = path.join(prof.dir, resource);
+    const isFile = share.isFileResource(resource);
+    const label = isFile ? resource : `${resource}/`;
+    const expected = path.join(profiles.defaultClaudeDir(), resource);
+
+    let stat;
+    try { stat = fs.lstatSync(pp); } catch { stat = null; }
+
+    if (!stat) {
+      // Resource missing entirely — safe to auto-create the link.
+      results.push(
+        mk('Storage', `"${prof.name}" ${label}`, 'warn', 'missing — not linked', {
+          safe: true,
+          description: `Create link to ~/.claude/${resource}`,
+          cmd: null,
+          apply: async () => {
+            const r = share.shareLink(prof.name, subsetForResource(resource))[0];
+            if (r && r.status === 'linked') {
+              process.stdout.write(`  Linked: ${pp} -> ${expected}\n`);
+            } else if (r) {
+              process.stdout.write(`  Could not link ${pp}: ${r.message || r.status}\n`);
+            }
+          },
+        }),
+      );
+      continue;
+    }
 
-  try {
-    fs.statSync(pp);
-    results.push(mk('Storage', `"${prof.name}" projects/ link`, 'ok', 'valid'));
-    return results;
-  } catch { /* broken */ }
-
-  const expected = path.join(profiles.sharedDir(), 'projects');
-  const targetExists = fs.existsSync(expected);
-  results.push(mk('Storage', `"${prof.name}" projects/ link`, 'error', 'broken — target missing', {
-    safe: targetExists,
-    description: targetExists ? `Recreate junction/symlink to ${expected}` : 'Target missing',
-    cmd: targetExists ? null : `cc link ${prof.name}`,
-    apply: targetExists ? async () => {
-      try { fs.unlinkSync(pp); } catch { try { fs.rmdirSync(pp); } catch { /* ignore */ } }
-      fs.symlinkSync(expected, pp, process.platform === 'win32' ? 'junction' : 'dir');
-      process.stdout.write(`  Recreated: ${pp} -> ${expected}\n`);
-    } : null,
-  }));
+    if (stat.isSymbolicLink()) {
+      // Symlink — check it resolves correctly.
+      if (share.isSharedResource(prof.dir, resource)) {
+        results.push(mk('Storage', `"${prof.name}" ${label} link`, 'ok', 'valid'));
+        continue;
+      }
+      // Broken or points elsewhere.
+      results.push(
+        mk('Storage', `"${prof.name}" ${label} link`, 'error', 'broken — target missing or wrong', {
+          safe: true,
+          description: `Recreate link to ${expected}`,
+          cmd: null,
+          apply: async () => {
+            share.removeLink(pp);
+            const r = share.shareLink(prof.name, subsetForResource(resource))[0];
+            if (r && (r.status === 'linked' || r.status === 'already-linked')) {
+              process.stdout.write(`  Recreated: ${pp} -> ${expected}\n`);
+            } else if (r) {
+              process.stdout.write(`  Could not recreate ${pp}: ${r.message || r.status}\n`);
+            }
+          },
+        }),
+      );
+      continue;
+    }
+
+    // Not a symlink. Could be (a) hard link sharing (Windows file fallback)
+    // → ok, or (b) genuinely private content → warn (no auto-fix).
+    if (share.isSharedResource(prof.dir, resource)) {
+      results.push(mk('Storage', `"${prof.name}" ${label} link`, 'ok', 'valid (hard link)'));
+      continue;
+    }
+
+    // Private — distinguish empty (safe to auto-link) from has-content (warn).
+    let hasContent = false;
+    try {
+      if (isFile) hasContent = stat.size > 0;
+      else hasContent = fs.readdirSync(pp).length > 0;
+    } catch { hasContent = true; }
+
+    if (!hasContent) {
+      results.push(
+        mk('Storage', `"${prof.name}" ${label}`, 'warn', 'private (empty) — not linked', {
+          safe: true,
+          description: `Replace with link to ~/.claude/${resource}`,
+          cmd: null,
+          apply: async () => {
+            try {
+              if (isFile) fs.unlinkSync(pp);
+              else fs.rmdirSync(pp);
+            } catch { /* fall through */ }
+            const r = share.shareLink(prof.name, subsetForResource(resource))[0];
+            if (r && r.status === 'linked') {
+              process.stdout.write(`  Linked: ${pp} -> ${expected}\n`);
+            } else if (r) {
+              process.stdout.write(`  Could not link ${pp}: ${r.message || r.status}\n`);
+            }
+          },
+        }),
+      );
+      continue;
+    }
+
+    results.push(
+      mk('Storage', `"${prof.name}" ${label}`, 'warn', 'private (has content) — not linked', {
+        safe: false,
+        description: 'Move or remove the private content, then re-run cc link',
+        cmd: `cc copy default ${prof.name}  # if you want to merge it the other way; ` +
+          `or manually move ${pp} aside, then: cc link ${prof.name}`,
+        apply: null,
+      }),
+    );
+  }
   return results;
 }
 
+// Build the share.shareLink opts to target exactly one resource.
+function subsetForResource(resource) {
+  if (share.PROJECT_SUBDIRS.includes(resource)) return { projects: true };
+  if (share.TOOL_SUBDIRS.includes(resource)) {
+    // shareLink with {tools:true} targets all 3 tool dirs; that's fine for
+    // backfilling, the others are no-ops if already linked.
+    return { tools: true };
+  }
+  if (share.CONFIG_FILES.includes(resource)) return { config: true };
+  return {};
+}
+
+// v0.3 → v0.4 migration nudge. If the legacy ~/.claude-shared/ pool still
+// exists, surface it as a warning with a safe auto-fix that runs the
+// one-time migration.
+function checkLegacyPool() {
+  const legacy = profiles.sharedDir();
+  if (!fs.existsSync(legacy)) return null;
+  let hasContent = false;
+  try {
+    hasContent = fs.readdirSync(legacy).length > 0;
+  } catch {
+    // Unreadable — still flag it.
+    hasContent = true;
+  }
+  if (!hasContent) {
+    // Empty dir — safe to remove silently.
+    return mk('Storage', '~/.claude-shared/ (legacy)', 'warn', 'empty dir from a prior cchost version', {
+      safe: true,
+      description: 'Remove the empty legacy pool',
+      cmd: null,
+      apply: async () => {
+        try { fs.rmdirSync(legacy); process.stdout.write(`  Removed ${legacy}\n`); } catch (e) {
+          process.stdout.write(`  Could not remove ${legacy}: ${e.message}\n`);
+        }
+      },
+    });
+  }
+  return mk('Storage', '~/.claude-shared/ (legacy)', 'warn', 'pre-v0.4 pool with content — migrate into ~/.claude/', {
+    safe: true,
+    description: 'Move legacy pool contents into ~/.claude/ and re-point profile symlinks',
+    cmd: null,
+    apply: async () => {
+      const result = share.migrateLegacyPool({ log: (line) => process.stdout.write(`  ${line}\n`) });
+      process.stdout.write(
+        `  Done: ${result.moves.length} item(s) moved, ${result.relinked.length} link(s) repointed.\n`,
+      );
+    },
+  });
+}
+
 // --- Platform ---
 
 function checkOneDrive() {
@@ -246,6 +377,7 @@ function runChecks() {
     checkCcShadow(),
     checkProfilesDirWritable(),
   ];
+  results.push(checkLegacyPool());
   for (const prof of profiles.listProfiles()) {
     results.push(checkProfileClaudeJson(prof));
     results.push(...checkProfileLinks(prof));

package/lib/env.js

@@ -194,6 +194,25 @@ function maskToken(token) {
   return `${token.slice(0, 6)}...${token.slice(-4)} (${n} chars)`;
 }
 
+// Mask an email so it's safe to paste in screenshots/logs.
+//   allen@cyber.co.in → a*************.in
+// Keeps the first character and the final TLD (everything after the last dot);
+// everything in between is replaced with `*` of the original length so the
+// width matches the original. If there's no usable TLD, mask everything after
+// the first char.
+function maskEmail(email) {
+  if (!email || typeof email !== 'string') return email;
+  if (email.length < 2) return '***';
+  const lastDot = email.lastIndexOf('.');
+  const first = email[0];
+  if (lastDot < 1 || lastDot === email.length - 1) {
+    return first + '*'.repeat(email.length - 1);
+  }
+  const tld = email.slice(lastDot); // includes the leading dot
+  const middleLen = lastDot - 1;
+  return first + '*'.repeat(middleLen) + tld;
+}
+
 function validateBaseUrl(url, warn) {
   if (!/^https?:\/\/.+/.test(url)) {
     throw usageError(`Invalid base_url "${url}": must start with http:// or https://`);
@@ -446,6 +465,7 @@ module.exports = {
   hostOf,
   endpointSummary,
   maskToken,
+  maskEmail,
   validateBaseUrl,
   validateToken,
   validateField,

package/lib/profiles.js

@@ -17,6 +17,15 @@ function baseDir() {
   return path.join(os.homedir(), '.claude-profiles');
 }
 
+// ~/.claude/ — Claude Code's own default config dir. Since v0.4 this is also
+// the shared artifact pool: every profile's projects/skills/agents/commands
+// symlink back here, so one set of tools is visible to every profile.
+function defaultClaudeDir() {
+  return path.join(os.homedir(), '.claude');
+}
+
+// ~/.claude-shared/ — legacy pool from v0.2/0.3. Kept for migration detection
+// only; new symlinks go to defaultClaudeDir(). Removed once migration runs.
 function sharedDir() {
   return path.join(os.homedir(), '.claude-shared');
 }
@@ -143,6 +152,7 @@ function listProfiles() {
 module.exports = {
   baseDir,
   sharedDir,
+  defaultClaudeDir,
   profileDir,
   validateProfileName,
   ensureBaseDir,