claude-switch-profile 1.0.1

package/src/commands/use.js

@@ -0,0 +1,102 @@
+import { getActive, setActive, profileExists, getProfileDir } from '../profile-store.js';
+import { saveSymlinks, removeSymlinks, restoreSymlinks, createSymlinks } from '../symlink-manager.js';
+import { saveFiles, removeFiles, restoreFiles } from '../file-operations.js';
+import { validateProfile, validateSourceTargets } from '../profile-validator.js';
+import { withLock, warnIfClaudeRunning, createBackup } from '../safety.js';
+import { success, error, info, warn } from '../output-helpers.js';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { SOURCE_FILE } from '../constants.js';
+
+export const useCommand = async (name, options) => {
+  if (!profileExists(name)) {
+    error(`Profile "${name}" does not exist. Run "csp list" to see available profiles.`);
+    process.exit(1);
+  }
+
+  const active = getActive();
+  if (active === name) {
+    info(`Profile "${name}" is already active.`);
+    return;
+  }
+
+  const profileDir = getProfileDir(name);
+
+  // Validate target profile
+  const validation = validateProfile(profileDir);
+  if (!validation.valid) {
+    error(`Profile "${name}" is invalid:`);
+    validation.errors.forEach((e) => error(`  ${e}`));
+    process.exit(1);
+  }
+
+  // Validate symlink targets exist
+  const sourcePath = join(profileDir, SOURCE_FILE);
+  try {
+    const sourceMap = JSON.parse(readFileSync(sourcePath, 'utf-8'));
+    const targetValidation = validateSourceTargets(sourceMap);
+    if (!targetValidation.valid) {
+      warn('Some symlink targets are missing:');
+      targetValidation.errors.forEach((e) => warn(`  ${e}`));
+      if (!options.force) {
+        error('Use --force to switch anyway.');
+        process.exit(1);
+      }
+    }
+  } catch {
+    // source.json parse error — will be caught during restore
+  }
+
+  if (options.dryRun) {
+    info(`[Dry run] Would switch from "${active || 'none'}" to "${name}"`);
+    info(`[Dry run] Profile dir: ${profileDir}`);
+    return;
+  }
+
+  warnIfClaudeRunning();
+
+  await withLock(async () => {
+    // 1. Save current state to active profile (if any)
+    if (active && profileExists(active) && options.save !== false) {
+      const activeDir = getProfileDir(active);
+      saveSymlinks(activeDir);
+      saveFiles(activeDir);
+      info(`Saved current state to "${active}"`);
+    }
+
+    // 2. Auto-backup
+    const backupPath = createBackup();
+    info(`Backup created at ${backupPath}`);
+
+    // 3. Remove managed items + restore target — with rollback on failure
+    removeSymlinks();
+    removeFiles();
+
+    try {
+      restoreSymlinks(profileDir);
+      restoreFiles(profileDir);
+    } catch (err) {
+      // Rollback: restore from backup
+      warn('Switch failed — rolling back from backup...');
+      try {
+        const backupSource = join(backupPath, SOURCE_FILE);
+        if (existsSync(backupSource)) {
+          const backupMap = JSON.parse(readFileSync(backupSource, 'utf-8'));
+          createSymlinks(backupMap);
+        }
+        restoreFiles(backupPath);
+        warn('Rollback complete. Previous config restored.');
+      } catch (rollbackErr) {
+        error(`Rollback also failed: ${rollbackErr.message}`);
+        error(`Manual recovery: restore from ${backupPath}`);
+      }
+      throw err;
+    }
+
+    // 4. Update active marker
+    setActive(name);
+
+    success(`Switched to profile "${name}"`);
+    info('Restart your Claude Code session to apply changes.');
+  });
+};

package/src/constants.js

@@ -0,0 +1,63 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+// Allow override via env for testing
+const home = process.env.CSP_HOME || homedir();
+
+export const CLAUDE_DIR = process.env.CSP_CLAUDE_DIR || join(home, '.claude');
+export const PROFILES_DIR = process.env.CSP_PROFILES_DIR || join(home, '.claude-profiles');
+
+export const ACTIVE_FILE = '.active';
+export const PROFILES_META = 'profiles.json';
+export const SOURCE_FILE = 'source.json';
+export const LOCK_FILE = '.lock';
+export const BACKUP_DIR = '.backup';
+
+// Items managed via symlinks — these point to external dirs/files
+export const SYMLINK_ITEMS = [
+  'CLAUDE.md',
+  'rules',
+  'agents',
+  'skills',
+  'hooks',
+  'statusline.cjs',
+  '.luna.json',
+];
+
+// Mutable files managed via copy
+export const COPY_ITEMS = [
+  'settings.json',
+  '.env',
+  '.ck.json',
+  '.ckignore',
+];
+
+// Directories managed via copy
+export const COPY_DIRS = [
+  'commands',
+  'plugins',
+];
+
+// Never touch these — runtime/session data
+export const NEVER_TOUCH = [
+  '.credentials.json',
+  'projects',
+  'backups',
+  'cache',
+  'debug',
+  'telemetry',
+  'shell-snapshots',
+  'paste-cache',
+  'file-history',
+  'ide',
+  'session-env',
+  'todos',
+  'tasks',
+  'teams',
+  'agent-memory',
+  'history.jsonl',
+  'plans',
+];
+
+// All managed items (symlinks + copies + copy dirs)
+export const ALL_MANAGED = [...SYMLINK_ITEMS, ...COPY_ITEMS, ...COPY_DIRS];

package/src/file-operations.js

@@ -0,0 +1,64 @@
+import { existsSync, copyFileSync, cpSync, unlinkSync, rmSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { CLAUDE_DIR, COPY_ITEMS, COPY_DIRS } from './constants.js';
+
+// Copy COPY_ITEMS files + COPY_DIRS dirs from ~/.claude to profileDir
+export const saveFiles = (profileDir) => {
+  mkdirSync(profileDir, { recursive: true });
+
+  for (const item of COPY_ITEMS) {
+    const src = join(CLAUDE_DIR, item);
+    if (existsSync(src)) {
+      copyFileSync(src, join(profileDir, item));
+    }
+  }
+
+  for (const dir of COPY_DIRS) {
+    const src = join(CLAUDE_DIR, dir);
+    if (existsSync(src)) {
+      const dest = join(profileDir, dir);
+      rmSync(dest, { recursive: true, force: true });
+      cpSync(src, dest, { recursive: true });
+    }
+  }
+};
+
+// Copy files + dirs from profileDir back to ~/.claude
+export const restoreFiles = (profileDir) => {
+  for (const item of COPY_ITEMS) {
+    const src = join(profileDir, item);
+    if (existsSync(src)) {
+      copyFileSync(src, join(CLAUDE_DIR, item));
+    }
+  }
+
+  for (const dir of COPY_DIRS) {
+    const src = join(profileDir, dir);
+    if (existsSync(src)) {
+      const dest = join(CLAUDE_DIR, dir);
+      rmSync(dest, { recursive: true, force: true });
+      cpSync(src, dest, { recursive: true });
+    }
+  }
+};
+
+// Remove managed COPY_ITEMS files and COPY_DIRS from ~/.claude
+export const removeFiles = () => {
+  for (const item of COPY_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      if (existsSync(itemPath)) unlinkSync(itemPath);
+    } catch {
+      // Skip
+    }
+  }
+
+  for (const dir of COPY_DIRS) {
+    const dirPath = join(CLAUDE_DIR, dir);
+    try {
+      if (existsSync(dirPath)) rmSync(dirPath, { recursive: true, force: true });
+    } catch {
+      // Skip
+    }
+  }
+};

package/src/output-helpers.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+
+export const success = (msg) => console.log(chalk.green('✓'), msg);
+export const warn = (msg) => console.log(chalk.yellow('⚠'), msg);
+export const error = (msg) => console.error(chalk.red('✗'), msg);
+export const info = (msg) => console.log(chalk.blue('ℹ'), msg);
+
+export const table = (rows, headers) => {
+  if (!rows.length) return;
+
+  const cols = headers || Object.keys(rows[0]);
+  const widths = cols.map((col) => {
+    const maxData = Math.max(...rows.map((r) => String(r[col] || '').length));
+    return Math.max(col.length, maxData);
+  });
+
+  // Header
+  const headerLine = cols.map((c, i) => c.padEnd(widths[i])).join('  ');
+  console.log(chalk.bold(headerLine));
+  console.log(widths.map((w) => '─'.repeat(w)).join('──'));
+
+  // Rows
+  for (const row of rows) {
+    const line = cols.map((c, i) => String(row[c] || '').padEnd(widths[i])).join('  ');
+    console.log(line);
+  }
+};

package/src/profile-store.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { PROFILES_DIR, ACTIVE_FILE, PROFILES_META } from './constants.js';
+
+export const ensureProfilesDir = () => {
+  if (!existsSync(PROFILES_DIR)) {
+    mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+};
+
+export const readProfiles = () => {
+  const metaPath = join(PROFILES_DIR, PROFILES_META);
+  if (!existsSync(metaPath)) return {};
+  return JSON.parse(readFileSync(metaPath, 'utf-8'));
+};
+
+export const writeProfiles = (data) => {
+  ensureProfilesDir();
+  writeFileSync(join(PROFILES_DIR, PROFILES_META), JSON.stringify(data, null, 2) + '\n');
+};
+
+export const getActive = () => {
+  const activePath = join(PROFILES_DIR, ACTIVE_FILE);
+  if (!existsSync(activePath)) return null;
+  return readFileSync(activePath, 'utf-8').trim() || null;
+};
+
+export const setActive = (name) => {
+  ensureProfilesDir();
+  writeFileSync(join(PROFILES_DIR, ACTIVE_FILE), name + '\n');
+};
+
+export const addProfile = (name, metadata = {}) => {
+  const profiles = readProfiles();
+  profiles[name] = {
+    created: new Date().toISOString(),
+    description: '',
+    ...metadata,
+  };
+  writeProfiles(profiles);
+};
+
+export const removeProfile = (name) => {
+  const profiles = readProfiles();
+  delete profiles[name];
+  writeProfiles(profiles);
+};
+
+export const profileExists = (name) => {
+  return existsSync(getProfileDir(name));
+};
+
+// Validate profile name — prevent path traversal and injection
+const SAFE_NAME = /^[a-zA-Z0-9_-]+$/;
+export const validateName = (name) => {
+  if (!name || !SAFE_NAME.test(name)) {
+    throw new Error(`Invalid profile name: "${name}". Use only letters, numbers, hyphens, underscores.`);
+  }
+};
+
+export const getProfileDir = (name) => {
+  validateName(name);
+  return join(PROFILES_DIR, name);
+};
+
+export const listProfileNames = () => {
+  return Object.keys(readProfiles());
+};

package/src/profile-validator.js

@@ -0,0 +1,50 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { SOURCE_FILE, SYMLINK_ITEMS } from './constants.js';
+
+// Validate a profile directory
+export const validateProfile = (profileDir) => {
+  const errors = [];
+
+  if (!existsSync(profileDir)) {
+    return { valid: false, errors: ['Profile directory does not exist'] };
+  }
+
+  const sourcePath = join(profileDir, SOURCE_FILE);
+  if (!existsSync(sourcePath)) {
+    errors.push('Missing source.json — no symlink targets defined');
+  }
+
+  return { valid: errors.length === 0, errors };
+};
+
+// Check all symlink targets in sourceMap actually exist on disk
+export const validateSourceTargets = (sourceMap) => {
+  const errors = [];
+  for (const [item, target] of Object.entries(sourceMap)) {
+    if (!existsSync(target)) {
+      errors.push(`${item}: target does not exist → ${target}`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+};
+
+// List what files/symlinks a profile contains
+export const listManagedItems = (profileDir) => {
+  if (!existsSync(profileDir)) return { symlinks: [], files: [], dirs: [] };
+
+  const entries = readdirSync(profileDir, { withFileTypes: true });
+  const items = { symlinks: [], files: [], dirs: [] };
+
+  for (const entry of entries) {
+    if (entry.name === SOURCE_FILE) {
+      items.files.push(entry.name);
+    } else if (entry.isDirectory()) {
+      items.dirs.push(entry.name);
+    } else {
+      items.files.push(entry.name);
+    }
+  }
+
+  return items;
+};

package/src/safety.js

@@ -0,0 +1,116 @@
+import { existsSync, writeFileSync, readFileSync, unlinkSync, mkdirSync, cpSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { PROFILES_DIR, LOCK_FILE, BACKUP_DIR, CLAUDE_DIR, COPY_ITEMS, COPY_DIRS } from './constants.js';
+import { readCurrentSymlinks } from './symlink-manager.js';
+import { warn } from './output-helpers.js';
+
+const MAX_BACKUPS = 5;
+
+// Acquire a lock file — atomic O_EXCL prevents TOCTOU race
+export const acquireLock = () => {
+  const lockPath = join(PROFILES_DIR, LOCK_FILE);
+
+  try {
+    writeFileSync(lockPath, String(process.pid) + '\n', { flag: 'wx' });
+  } catch (err) {
+    if (err.code === 'EEXIST') {
+      // Lock exists — check if stale
+      const content = readFileSync(lockPath, 'utf-8').trim();
+      const pid = parseInt(content, 10);
+
+      if (pid && !isProcessRunning(pid)) {
+        unlinkSync(lockPath);
+        writeFileSync(lockPath, String(process.pid) + '\n', { flag: 'wx' });
+      } else {
+        throw new Error(`Another csp operation is running (PID: ${content}). Remove ${lockPath} if stale.`);
+      }
+    } else {
+      throw err;
+    }
+  }
+};
+
+// Release the lock file
+export const releaseLock = () => {
+  const lockPath = join(PROFILES_DIR, LOCK_FILE);
+  try {
+    if (existsSync(lockPath)) unlinkSync(lockPath);
+  } catch {
+    // Best effort
+  }
+};
+
+// Wrapper that acquires/releases lock around async function
+export const withLock = async (fn) => {
+  acquireLock();
+  try {
+    return await fn();
+  } finally {
+    releaseLock();
+  }
+};
+
+// Check if a PID is still running
+const isProcessRunning = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// Check if claude process is running
+export const isClaudeRunning = () => {
+  try {
+    const result = execFileSync('pgrep', ['-x', 'claude'], { encoding: 'utf-8' });
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+};
+
+// Print warning if Claude is detected running
+export const warnIfClaudeRunning = () => {
+  if (isClaudeRunning()) {
+    warn('Claude Code appears to be running. Restart your Claude session after switching profiles.');
+  }
+};
+
+// Create backup of current managed items, prune old backups
+export const createBackup = () => {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupBase = join(PROFILES_DIR, BACKUP_DIR);
+  const backupPath = join(backupBase, timestamp);
+  mkdirSync(backupPath, { recursive: true });
+
+  // Save symlink targets
+  const sourceMap = readCurrentSymlinks();
+  writeFileSync(join(backupPath, 'source.json'), JSON.stringify(sourceMap, null, 2) + '\n');
+
+  // Copy mutable files
+  for (const item of COPY_ITEMS) {
+    const src = join(CLAUDE_DIR, item);
+    if (existsSync(src)) cpSync(src, join(backupPath, item));
+  }
+
+  // Copy dirs
+  for (const dir of COPY_DIRS) {
+    const src = join(CLAUDE_DIR, dir);
+    if (existsSync(src)) cpSync(src, join(backupPath, dir), { recursive: true });
+  }
+
+  // Prune old backups — keep only MAX_BACKUPS most recent
+  try {
+    const backups = readdirSync(backupBase).sort();
+    while (backups.length > MAX_BACKUPS) {
+      const oldest = backups.shift();
+      rmSync(join(backupBase, oldest), { recursive: true, force: true });
+    }
+  } catch {
+    // Non-critical — skip pruning
+  }
+
+  return backupPath;
+};

package/src/symlink-manager.js

@@ -0,0 +1,69 @@
+import { existsSync, readlinkSync, symlinkSync, unlinkSync, lstatSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { CLAUDE_DIR, SYMLINK_ITEMS, SOURCE_FILE } from './constants.js';
+
+// Read current symlink targets from ~/.claude for all SYMLINK_ITEMS
+export const readCurrentSymlinks = () => {
+  const sourceMap = {};
+  for (const item of SYMLINK_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      if (existsSync(itemPath) && lstatSync(itemPath).isSymbolicLink()) {
+        sourceMap[item] = resolve(CLAUDE_DIR, readlinkSync(itemPath));
+      }
+    } catch {
+      // Item doesn't exist or isn't readable — skip
+    }
+  }
+  return sourceMap;
+};
+
+// Remove all managed symlinks from ~/.claude
+export const removeSymlinks = () => {
+  for (const item of SYMLINK_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      if (existsSync(itemPath) && lstatSync(itemPath).isSymbolicLink()) {
+        unlinkSync(itemPath);
+      }
+    } catch {
+      // Already gone or not a symlink — skip
+    }
+  }
+};
+
+// Create symlinks in ~/.claude from a sourceMap object
+export const createSymlinks = (sourceMap) => {
+  for (const [item, target] of Object.entries(sourceMap)) {
+    if (!SYMLINK_ITEMS.includes(item)) continue;
+    const itemPath = join(CLAUDE_DIR, item);
+
+    // Remove existing if present
+    try {
+      if (lstatSync(itemPath)) unlinkSync(itemPath);
+    } catch {
+      // Doesn't exist — fine
+    }
+
+    // Only create if target exists
+    if (existsSync(target)) {
+      symlinkSync(target, itemPath);
+    }
+  }
+};
+
+// Save current symlink targets to profileDir/source.json
+export const saveSymlinks = (profileDir) => {
+  const sourceMap = readCurrentSymlinks();
+  writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
+  return sourceMap;
+};
+
+// Read source.json from profileDir and create symlinks
+export const restoreSymlinks = (profileDir) => {
+  const sourcePath = join(profileDir, SOURCE_FILE);
+  if (!existsSync(sourcePath)) return {};
+  const sourceMap = JSON.parse(readFileSync(sourcePath, 'utf-8'));
+  createSymlinks(sourceMap);
+  return sourceMap;
+};