cchost 0.1.0

package/lib/migrate.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const profiles = require('./profiles');
+
+const SUBDIRS = ['projects', 'sessions'];
+const EXCLUDED_FILES = new Set(['.credentials.json', '.claude.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) {
+  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)) {
+      skipped += 1;
+      continue;
+    }
+    fs.cpSync(from, to, { recursive: true, verbatimSymlinks: true });
+    copied += 1;
+  }
+  return { copied, skipped };
+}
+
+function migrate(srcArg, destArg) {
+  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 };
+  }
+
+  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);
+    console.log(`  ${sub}: copied ${copied}, skipped ${skipped}`);
+    totalCopied += copied;
+    totalSkipped += skipped;
+  }
+  console.log(`Done. Total copied: ${totalCopied}, total skipped (already present): ${totalSkipped}.`);
+  return { copied: totalCopied, skipped: totalSkipped };
+}
+
+module.exports = {
+  migrate,
+  defaultClaudeDir,
+  resolveSource,
+  resolveDest,
+  copyTreeSkipCollisions,
+  SUBDIRS,
+  EXCLUDED_FILES,
+};

package/lib/profiles.js

@@ -0,0 +1,240 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const RESERVED_WIN = new Set([
+  'CON', 'PRN', 'AUX', 'NUL',
+  'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
+  'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9',
+]);
+
+const MAX_NAME_LEN = 64;
+const INVALID_CHARS_RE = /[\\/:*?"<>|\x00-\x1f]/;
+
+const ALIAS_FILE = '.cc-alias.json';
+const ALLOWED_ALIAS_KEYS = ['email', 'org', 'name'];
+const OAUTH_FIELD_MAP = {
+  email: 'emailAddress',
+  org: 'organizationName',
+  name: 'displayName',
+};
+
+function baseDir() {
+  return path.join(os.homedir(), '.claude-profiles');
+}
+
+function sharedDir() {
+  return path.join(os.homedir(), '.claude-shared');
+}
+
+function profileDir(name) {
+  return path.join(baseDir(), name);
+}
+
+function usageError(msg) {
+  const e = new Error(msg);
+  e.exitCode = 2;
+  return e;
+}
+
+function validateProfileName(name) {
+  if (typeof name !== 'string' || name.length === 0) {
+    throw usageError('Profile name is required.');
+  }
+  if (name.length > MAX_NAME_LEN) {
+    throw usageError(`Profile name must be ${MAX_NAME_LEN} characters or fewer.`);
+  }
+  if (/\s/.test(name)) {
+    throw usageError('Profile name cannot contain whitespace.');
+  }
+  if (INVALID_CHARS_RE.test(name)) {
+    throw usageError('Profile name contains disallowed characters (path separators, quotes, or control chars).');
+  }
+  if (name === '.' || name === '..' || name.startsWith('.')) {
+    throw usageError('Profile name cannot start with a dot.');
+  }
+  if (name.startsWith('-')) {
+    throw usageError(`Profile name cannot start with "-" (looks like a flag): ${name}`);
+  }
+  if (RESERVED_WIN.has(name.toUpperCase())) {
+    throw usageError(`"${name}" is a reserved name on Windows.`);
+  }
+  return name;
+}
+
+function ensureBaseDir() {
+  try {
+    fs.mkdirSync(baseDir(), { recursive: true });
+  } catch (err) {
+    throw new Error(`Cannot create profile base directory ${baseDir()}: ${err.message}`);
+  }
+}
+
+function ensureProfileDir(name) {
+  validateProfileName(name);
+  ensureBaseDir();
+  const dir = profileDir(name);
+  let created = false;
+  if (!fs.existsSync(dir)) {
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch (err) {
+      throw new Error(`Cannot create profile directory ${dir}: ${err.message}`);
+    }
+    created = true;
+  }
+  return { dir, created };
+}
+
+function aliasPath(dir) {
+  return path.join(dir, ALIAS_FILE);
+}
+
+function readAlias(dir) {
+  try {
+    const raw = fs.readFileSync(aliasPath(dir), 'utf8');
+    if (!raw.trim()) return {};
+    const data = JSON.parse(raw);
+    if (!data || typeof data !== 'object') return {};
+    const out = {};
+    for (const k of ALLOWED_ALIAS_KEYS) {
+      if (typeof data[k] === 'string' && data[k].length > 0) out[k] = data[k];
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+function writeAlias(dir, data) {
+  fs.writeFileSync(aliasPath(dir), JSON.stringify(data, null, 2));
+}
+
+function addProfile(name, aliasFlags) {
+  validateProfileName(name);
+  const dir = profileDir(name);
+  if (fs.existsSync(dir)) {
+    const e = new Error(`Profile "${name}" already exists at ${dir}.`);
+    e.exitCode = 1;
+    throw e;
+  }
+  const alias = {};
+  for (const [k, v] of Object.entries(aliasFlags || {})) {
+    if (!ALLOWED_ALIAS_KEYS.includes(k)) {
+      throw usageError(`Unknown flag: --${k}. Allowed: --email, --org, --name.`);
+    }
+    if (typeof v !== 'string' || v.length === 0) {
+      throw usageError(`Flag --${k} requires a non-empty value.`);
+    }
+    alias[k] = v;
+  }
+  ensureBaseDir();
+  fs.mkdirSync(dir);
+  if (Object.keys(alias).length > 0) {
+    writeAlias(dir, alias);
+  }
+  return { dir, alias };
+}
+
+function applyAlias(dir) {
+  const alias = readAlias(dir);
+  if (Object.keys(alias).length === 0) return false;
+  const claudeJsonPath = path.join(dir, '.claude.json');
+  if (!fs.existsSync(claudeJsonPath)) return false;
+  let data;
+  try {
+    const raw = fs.readFileSync(claudeJsonPath, 'utf8');
+    if (!raw.trim()) return false;
+    data = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  if (!data || typeof data !== 'object') return false;
+  if (!data.oauthAccount || typeof data.oauthAccount !== 'object') return false;
+  let mutated = false;
+  for (const [k, v] of Object.entries(alias)) {
+    const oauthKey = OAUTH_FIELD_MAP[k];
+    if (!oauthKey) continue;
+    if (data.oauthAccount[oauthKey] !== v) {
+      data.oauthAccount[oauthKey] = v;
+      mutated = true;
+    }
+  }
+  if (mutated) {
+    try {
+      fs.writeFileSync(claudeJsonPath, JSON.stringify(data, null, 2));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+function readEmail(dir) {
+  try {
+    const raw = fs.readFileSync(path.join(dir, '.claude.json'), 'utf8');
+    if (!raw.trim()) return '';
+    const data = JSON.parse(raw);
+    if (data && data.oauthAccount && typeof data.oauthAccount.emailAddress === 'string') {
+      return data.oauthAccount.emailAddress;
+    }
+    return '';
+  } catch {
+    return '';
+  }
+}
+
+function hasCredentials(dir) {
+  try {
+    return fs.existsSync(path.join(dir, '.credentials.json'));
+  } catch {
+    return false;
+  }
+}
+
+function listProfiles() {
+  const base = baseDir();
+  if (!fs.existsSync(base)) return [];
+  let entries;
+  try {
+    entries = fs.readdirSync(base, { withFileTypes: true });
+  } catch (err) {
+    throw new Error(`Cannot read ${base}: ${err.message}`);
+  }
+  const out = [];
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    const name = ent.name;
+    const dir = path.join(base, name);
+    out.push({
+      name,
+      dir,
+      loggedIn: hasCredentials(dir),
+      email: readEmail(dir),
+      alias: readAlias(dir),
+    });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+
+module.exports = {
+  baseDir,
+  sharedDir,
+  profileDir,
+  validateProfileName,
+  ensureBaseDir,
+  ensureProfileDir,
+  readEmail,
+  hasCredentials,
+  listProfiles,
+  addProfile,
+  readAlias,
+  writeAlias,
+  applyAlias,
+  ALLOWED_ALIAS_KEYS,
+  OAUTH_FIELD_MAP,
+};

package/lib/share.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const profiles = require('./profiles');
+
+const SHARED_SUBDIRS = ['projects', 'sessions'];
+
+function symlinkType() {
+  return process.platform === 'win32' ? 'junction' : 'dir';
+}
+
+function isLink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function removeLink(p) {
+  try {
+    fs.unlinkSync(p);
+    return;
+  } catch (err) {
+    if (process.platform !== 'win32') throw err;
+  }
+  fs.rmdirSync(p);
+}
+
+function copyRecursive(src, dst) {
+  fs.cpSync(src, dst, { recursive: true, verbatimSymlinks: true });
+}
+
+function ensureSharedDirs() {
+  const base = profiles.sharedDir();
+  for (const sub of SHARED_SUBDIRS) {
+    try {
+      fs.mkdirSync(path.join(base, sub), { recursive: true });
+    } catch (err) {
+      throw new Error(`Cannot create ${path.join(base, sub)}: ${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;
+      }
+    }
+    fs.renameSync(from, to);
+    moved += 1;
+  }
+  fs.rmdirSync(src);
+  return moved;
+}
+
+function shareLink(profileName) {
+  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.`);
+    err.exitCode = 1;
+    throw err;
+  }
+  ensureSharedDirs();
+  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 {
+      fs.symlinkSync(target, link, symlinkType());
+    } catch (err) {
+      throw new Error(`Cannot link ${link} -> ${target}: ${err.message}`);
+    }
+    console.log(`  ${sub}: linked -> ${target}`);
+  }
+}
+
+function shareUnlink(profileName) {
+  profiles.validateProfileName(profileName);
+  const pdir = profiles.profileDir(profileName);
+  if (!fs.existsSync(pdir)) {
+    const err = new Error(`Profile "${profileName}" does not exist.`);
+    err.exitCode = 1;
+    throw err;
+  }
+  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));
+      }
+    }
+    console.log(`  ${sub}: unlinked, content copied back`);
+  }
+}
+
+module.exports = {
+  SHARED_SUBDIRS,
+  isLink,
+  removeLink,
+  shareLink,
+  shareUnlink,
+};

package/lib/spawn.js

@@ -0,0 +1,229 @@
+'use strict';
+
+const { spawn, spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const color = require('./color');
+
+const MIN_VERSION = [2, 1, 140];
+const MIN_VERSION_STR = MIN_VERSION.join('.');
+const CMD_META_RE = /([()\][%!^"`<>&|;, *?])/g;
+const CACHE_FILE = path.join(os.homedir(), '.claude-profiles', '.cc-cache.json');
+
+function pathListSep() {
+  return process.platform === 'win32' ? ';' : ':';
+}
+
+function pathExt() {
+  if (process.platform !== 'win32') return [''];
+  const raw = process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD';
+  return raw.split(';').map((s) => s.trim()).filter(Boolean);
+}
+
+function findClaude() {
+  const PATH = process.env.PATH || process.env.Path || '';
+  if (!PATH) return null;
+  const dirs = PATH.split(pathListSep()).filter(Boolean);
+  const exts = pathExt();
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const full = path.join(dir, 'claude' + ext);
+      try {
+        const st = fs.statSync(full);
+        if (st.isFile()) return full;
+      } catch {
+        // not found, keep scanning
+      }
+    }
+  }
+  return null;
+}
+
+function parseVersion(text) {
+  if (!text) return null;
+  const m = String(text).match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!m) return null;
+  return { major: +m[1], minor: +m[2], patch: +m[3], raw: m[0] };
+}
+
+function compareVersion(v, target) {
+  if (!v) return 0;
+  const [a, b, c] = target;
+  if (v.major !== a) return v.major - a;
+  if (v.minor !== b) return v.minor - b;
+  return v.patch - c;
+}
+
+function getClaudeVersion(bin) {
+  try {
+    const opts = { encoding: 'utf8', timeout: 5000 };
+    let res;
+    if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(bin)) {
+      const cmdLine = [escapeCommandWin(bin), escapeArgWin('--version')].join(' ');
+      res = spawnSync(process.env.COMSPEC || 'cmd.exe', ['/d', '/s', '/c', `"${cmdLine}"`], { ...opts, windowsVerbatimArguments: true });
+    } else {
+      res = spawnSync(bin, ['--version'], opts);
+    }
+    if (!res || res.status !== 0) return null;
+    return parseVersion(res.stdout);
+  } catch {
+    return null;
+  }
+}
+
+function readCache() {
+  try {
+    const raw = fs.readFileSync(CACHE_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(data) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(data));
+  } catch {
+    // cache is best-effort; ignore write failures
+  }
+}
+
+function cachedClaudeVersion(bin) {
+  let mtimeMs = 0;
+  try {
+    mtimeMs = fs.statSync(bin).mtimeMs;
+  } catch {
+    return getClaudeVersion(bin);
+  }
+  const cache = readCache();
+  if (
+    cache &&
+    cache.binPath === bin &&
+    cache.binMtimeMs === mtimeMs &&
+    cache.minVersion === MIN_VERSION_STR &&
+    cache.version
+  ) {
+    return cache.version;
+  }
+  const v = getClaudeVersion(bin);
+  if (v) {
+    writeCache({
+      binPath: bin,
+      binMtimeMs: mtimeMs,
+      minVersion: MIN_VERSION_STR,
+      version: v,
+      checkedAt: new Date().toISOString(),
+    });
+  }
+  return v;
+}
+
+function warnIfOld(bin, write) {
+  const w = write || ((s) => process.stderr.write(s + '\n'));
+  const v = cachedClaudeVersion(bin);
+  if (v && compareVersion(v, MIN_VERSION) < 0) {
+    const msg = `warning: Claude Code ${v.raw} is older than ${MIN_VERSION_STR}. CLAUDE_CONFIG_DIR isolation has known bugs in this range. Run \`claude update\` before relying on profiles.`;
+    w(color.stderr.yellow(msg));
+  }
+}
+
+function escapeArgWin(arg) {
+  let s = String(arg);
+  s = s.replace(/(\\*)"/g, '$1$1\\"');
+  s = s.replace(/(\\*)$/, '$1$1');
+  s = `"${s}"`;
+  s = s.replace(CMD_META_RE, '^$1');
+  return s;
+}
+
+function escapeCommandWin(cmd) {
+  return cmd.replace(CMD_META_RE, '^$1');
+}
+
+function platformSpawn(bin, args, opts) {
+  if (process.platform === 'win32' && /\.(cmd|bat)$/i.test(bin)) {
+    const cmdLine = [escapeCommandWin(bin), ...args.map(escapeArgWin)].join(' ');
+    return spawn(
+      process.env.COMSPEC || 'cmd.exe',
+      ['/d', '/s', '/c', `"${cmdLine}"`],
+      { ...opts, windowsVerbatimArguments: true },
+    );
+  }
+  return spawn(bin, args, opts);
+}
+
+function spawnClaude({ args = [], profileDir = null, activeProfile = null, extraEnv = {} } = {}) {
+  const bin = findClaude();
+  if (!bin) {
+    const err = new Error(
+      'Claude Code does not appear to be installed (no `claude` on PATH).\n' +
+      'Install it:  npm install -g @anthropic-ai/claude-code\n' +
+      'Docs:        https://code.claude.com',
+    );
+    err.exitCode = 127;
+    throw err;
+  }
+  warnIfOld(bin);
+
+  const childEnv = { ...process.env, ...extraEnv };
+  if (profileDir) {
+    childEnv.CLAUDE_CONFIG_DIR = profileDir;
+  } else {
+    delete childEnv.CLAUDE_CONFIG_DIR;
+  }
+  if (activeProfile) {
+    childEnv.CC_ACTIVE_PROFILE = activeProfile;
+  } else {
+    delete childEnv.CC_ACTIVE_PROFILE;
+  }
+
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = platformSpawn(bin, args, {
+        stdio: 'inherit',
+        env: childEnv,
+        windowsHide: false,
+      });
+    } catch (err) {
+      console.error(`Failed to launch claude: ${err.message}`);
+      resolve(127);
+      return;
+    }
+
+    child.on('error', (err) => {
+      console.error(`Failed to launch claude: ${err.message}`);
+      resolve(127);
+    });
+
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        try {
+          process.kill(process.pid, signal);
+        } catch {
+          resolve(128);
+        }
+      } else {
+        resolve(code == null ? 0 : code);
+      }
+    });
+  });
+}
+
+module.exports = {
+  findClaude,
+  getClaudeVersion,
+  cachedClaudeVersion,
+  parseVersion,
+  compareVersion,
+  warnIfOld,
+  platformSpawn,
+  spawnClaude,
+  escapeArgWin,
+  escapeCommandWin,
+  MIN_VERSION,
+  CACHE_FILE,
+};