claude-switch-profile 1.0.2 → 1.4.0

package/src/commands/select.js

@@ -0,0 +1,126 @@
+import { createInterface } from 'node:readline';
+import chalk from 'chalk';
+import { readProfiles, getActive } from '../profile-store.js';
+import { PROFILES_DIR } from '../constants.js';
+import { existsSync } from 'node:fs';
+import { launchCommand } from './launch.js';
+import { info, error } from '../output-helpers.js';
+
+const renderMenu = (names, profiles, active, selected) => {
+  // Move cursor up to overwrite previous render (except first render)
+  const lines = [];
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
+    const meta = profiles[name];
+    const isActive = name === active;
+    const isSelected = i === selected;
+
+    const cursor = isSelected ? chalk.cyan('❯ ') : '  ';
+    const label = isSelected ? chalk.cyan.bold(name) : isActive ? chalk.green(name) : name;
+    const activeTag = isActive ? chalk.green(' (active)') : '';
+    const desc = meta.description ? chalk.dim(` — ${meta.description}`) : '';
+    lines.push(`${cursor}${label}${activeTag}${desc}`);
+  }
+  return lines;
+};
+
+export const selectCommand = async () => {
+  if (!existsSync(PROFILES_DIR)) {
+    error('CSP not initialized. Run "csp init" to start.');
+    process.exit(1);
+  }
+
+  const profiles = readProfiles();
+  const active = getActive();
+  const names = Object.keys(profiles);
+
+  if (names.length === 0) {
+    info('No profiles found. Run "csp create <name>" to create one.');
+    return;
+  }
+
+  if (names.length === 1) {
+    info(`Only one profile: "${names[0]}". Nothing to switch to.`);
+    return;
+  }
+
+  // Non-TTY: fall back to list
+  if (!process.stdin.isTTY) {
+    info('Non-interactive terminal. Use "csp launch <name>" or "csp use <name>" directly.');
+    process.exit(1);
+  }
+
+  let selected = active ? Math.max(names.indexOf(active), 0) : 0;
+
+  console.log('');
+  console.log(chalk.bold('Select profile to launch:'));
+  console.log(chalk.dim('(↑/↓ navigate, Enter select, Esc cancel)'));
+  console.log('');
+
+  // Initial render
+  const menuLines = renderMenu(names, profiles, active, selected);
+  for (const line of menuLines) {
+    process.stdout.write(line + '\n');
+  }
+
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin });
+
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    const redraw = () => {
+      // Move up N lines and clear
+      process.stdout.write(`\x1b[${names.length}A`);
+      const lines = renderMenu(names, profiles, active, selected);
+      for (const line of lines) {
+        process.stdout.write(`\x1b[2K${line}\n`);
+      }
+    };
+
+    const cleanup = () => {
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(false);
+      }
+      rl.close();
+    };
+
+    process.stdin.on('data', async (data) => {
+      const key = data.toString();
+
+      // Escape or Ctrl+C
+      if (key === '\x1b' || key === '\x03') {
+        cleanup();
+        console.log(chalk.dim('\nCancelled.'));
+        resolve();
+        return;
+      }
+
+      // Up arrow
+      if (key === '\x1b[A' || key === 'k') {
+        selected = (selected - 1 + names.length) % names.length;
+        redraw();
+        return;
+      }
+
+      // Down arrow
+      if (key === '\x1b[B' || key === 'j') {
+        selected = (selected + 1) % names.length;
+        redraw();
+        return;
+      }
+
+      // Enter
+      if (key === '\r' || key === '\n') {
+        cleanup();
+        const chosen = names[selected];
+        console.log('');
+        await launchCommand(chosen, [], {});
+        resolve();
+        return;
+      }
+    });
+  });
+};

package/src/commands/status.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { readProfiles, getActive } from '../profile-store.js';
+import { isClaudeRunning } from '../safety.js';
+import { PROFILES_DIR } from '../constants.js';
+import { existsSync } from 'node:fs';
+
+export const statusCommand = () => {
+  if (!existsSync(PROFILES_DIR)) {
+    console.log(chalk.yellow('CSP not initialized. Run "csp init" to start.'));
+    return;
+  }
+
+  const profiles = readProfiles();
+  const active = getActive();
+  const names = Object.keys(profiles);
+  const claudeRunning = isClaudeRunning();
+
+  console.log('');
+  console.log(chalk.bold('Claude Switch Profile'));
+  console.log(chalk.dim('─'.repeat(40)));
+
+  // Active profile
+  if (active) {
+    console.log(`  ${chalk.bold('Active:')}   ${chalk.green(active)}`);
+  } else {
+    console.log(`  ${chalk.bold('Active:')}   ${chalk.dim('none')}`);
+  }
+
+  // Profile count
+  console.log(`  ${chalk.bold('Profiles:')} ${names.length} (${names.join(', ')})`);
+
+  // Last launch info
+  const launched = names
+    .filter((n) => profiles[n].lastLaunchAt)
+    .sort((a, b) => (profiles[b].lastLaunchAt || '').localeCompare(profiles[a].lastLaunchAt || ''));
+  if (launched.length > 0) {
+    const last = launched[0];
+    const ts = profiles[last].lastLaunchAt.split('T')[0];
+    console.log(`  ${chalk.bold('Last launch:')} ${last} (${ts})`);
+  }
+
+  // Claude running
+  const runIcon = claudeRunning ? chalk.yellow('⚠ running') : chalk.green('not running');
+  console.log(`  ${chalk.bold('Claude:')}   ${runIcon}`);
+
+  console.log(chalk.dim('─'.repeat(40)));
+  console.log('');
+};

package/src/commands/toggle.js

@@ -0,0 +1,25 @@
+import { getPrevious, getActive, profileExists } from '../profile-store.js';
+import { launchCommand } from './launch.js';
+import { error, info } from '../output-helpers.js';
+
+export const toggleCommand = async () => {
+  const previous = getPrevious();
+  const active = getActive();
+
+  if (!previous) {
+    error('No previous profile to toggle to. Switch profiles first.');
+    process.exit(1);
+  }
+
+  if (previous === active) {
+    info(`Already on "${active}" — no previous profile to toggle to.`);
+    return;
+  }
+
+  if (!profileExists(previous)) {
+    error(`Previous profile "${previous}" no longer exists.`);
+    process.exit(1);
+  }
+
+  await launchCommand(previous, [], {});
+};

package/src/commands/uninstall.js

@@ -0,0 +1,99 @@
+import { existsSync, rmSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { getActive, profileExists, getProfileDir } from '../profile-store.js';
+import { removeItems, restoreItems } from '../item-manager.js';
+import { removeFiles, restoreFiles } from '../file-operations.js';
+import { withLock, createBackup, warnIfClaudeRunning } from '../safety.js';
+import { PROFILES_DIR, DEFAULT_PROFILE } from '../constants.js';
+import { success, error, info, warn } from '../output-helpers.js';
+
+const confirm = (question) => {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase().startsWith('y'));
+    });
+  });
+};
+
+export const uninstallCommand = async (options) => {
+  const active = getActive();
+
+  if (!existsSync(PROFILES_DIR)) {
+    info('No profiles directory found. CSP is not initialized.');
+    info('To remove the CLI: npm uninstall -g claude-switch-profile');
+    return;
+  }
+
+  // Show what will happen
+  console.log('');
+  info('This will:');
+  if (options.profile && profileExists(options.profile)) {
+    info(`  1. Restore profile "${options.profile}" to ~/.claude`);
+  } else if (active && active !== DEFAULT_PROFILE && profileExists(active)) {
+    info(`  1. Restore active profile "${active}" to ~/.claude (use --profile <name> to choose)`);
+  } else if (active === DEFAULT_PROFILE) {
+    info('  1. Default profile — ~/.claude already in correct state');
+  } else {
+    warn('  1. No profile to restore (managed items will be removed)');
+  }
+  info(`  2. Remove all profiles: ${PROFILES_DIR}`);
+  info('  3. You can then run: npm uninstall -g claude-switch-profile');
+  console.log('');
+
+  if (!options.force) {
+    const confirmed = await confirm('Uninstall CSP and remove all profiles? This cannot be undone. (y/N) ');
+    if (!confirmed) {
+      warn('Cancelled.');
+      return;
+    }
+  }
+
+  warnIfClaudeRunning();
+
+  await withLock(async () => {
+    // 1. Create final backup before uninstall
+    try {
+      const backupPath = createBackup();
+      info(`Final backup created at ${backupPath}`);
+    } catch {
+      // Non-critical — profiles dir may be empty
+    }
+
+    // 2. Determine which profile to restore
+    const restoreProfile = options.profile || active;
+
+    // 3. Remove current managed items from ~/.claude (skip for default — items live there)
+    if (restoreProfile !== DEFAULT_PROFILE) {
+      removeItems();
+      removeFiles();
+    }
+
+    // 4. Restore the chosen profile's config
+    if (restoreProfile === DEFAULT_PROFILE) {
+      info('Default profile — ~/.claude already in correct state.');
+    } else if (restoreProfile && profileExists(restoreProfile)) {
+      const profileDir = getProfileDir(restoreProfile);
+      // If restoring the active profile: items already in ~/.claude (moved there on switch)
+      // If restoring a different profile: need to restore from profileDir
+      if (restoreProfile !== active) {
+        restoreItems(profileDir);
+        restoreFiles(profileDir);
+      }
+      success(`Restored "${restoreProfile}" profile to ~/.claude`);
+    } else {
+      warn('No profile restored. ~/.claude managed items have been cleared.');
+    }
+  });
+
+  // 5. Remove profiles directory (after lock is released)
+  rmSync(PROFILES_DIR, { recursive: true, force: true });
+  success('Removed all profiles and CSP data.');
+
+  console.log('');
+  info('To complete uninstall, run:');
+  info('  npm uninstall -g claude-switch-profile');
+  info('');
+  info('Restart your Claude Code session to apply changes.');
+};

package/src/commands/use.js

@@ -1,14 +1,18 @@
-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 { getActive, setActive, profileExists, getProfileDir, getProfileMeta, setPrevious } from '../profile-store.js';
+import { moveItemsToProfile, moveItemsToClaude, saveItems, removeItems } from '../item-manager.js';
+import { saveFiles, removeFiles, restoreFiles, updateSettingsPaths, moveDirsToProfile, moveDirsToClaude } from '../file-operations.js';
+import { validateProfile } from '../profile-validator.js';
+import { withLock, assertClaudeNotRunning } 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';
+import { CLAUDE_DIR, DEFAULT_PROFILE } from '../constants.js';
 
 export const useCommand = async (name, options) => {
+  // Warn about legacy behavior (skip if called internally from launch --legacy-global)
+  if (!options.skipClaudeCheck) {
+    warn('Note: "csp use" modifies ~/.claude directly (legacy mode).');
+    info('Prefer "csp launch <name>" for isolated sessions that never touch ~/.claude.');
+  }
+
   if (!profileExists(name)) {
     error(`Profile "${name}" does not exist. Run "csp list" to see available profiles.`);
     process.exit(1);
@@ -21,30 +25,21 @@ export const useCommand = async (name, options) => {
   }
 
   const profileDir = getProfileDir(name);
+  const meta = getProfileMeta(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);
+  if (meta?.lastLaunchAt) {
+    warn(`Profile "${name}" was used in isolated launch mode recently (${meta.lastLaunchAt}).`);
+    info('Legacy "csp use" mutates global ~/.claude state.');
   }
 
-  // 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);
-      }
+  // Validate target profile (skip for default — it's a pass-through)
+  if (name !== DEFAULT_PROFILE) {
+    const validation = validateProfile(profileDir);
+    if (!validation.valid) {
+      error(`Profile "${name}" is invalid:`);
+      validation.errors.forEach((e) => error(`  ${e}`));
+      process.exit(1);
     }
-  } catch {
-    // source.json parse error — will be caught during restore
   }
 
   if (options.dryRun) {
@@ -53,50 +48,64 @@ export const useCommand = async (name, options) => {
     return;
   }
 
-  warnIfClaudeRunning();
+  if (!options.skipClaudeCheck) {
+    try {
+      assertClaudeNotRunning();
+    } catch (err) {
+      error(err.message);
+      process.exit(1);
+    }
+  }
 
   await withLock(async () => {
-    // 1. Save current state to active profile (if any)
-    if (active && profileExists(active) && options.save !== false) {
+    // 1. Save current state (skip if from=default — ~/.claude IS default)
+    if (active && active !== DEFAULT_PROFILE && profileExists(active) && options.save !== false) {
       const activeDir = getProfileDir(active);
-      saveSymlinks(activeDir);
-      saveFiles(activeDir);
+      if (name === DEFAULT_PROFILE) {
+        saveItems(activeDir);
+        saveFiles(activeDir);
+      } else {
+        moveItemsToProfile(activeDir);
+        saveFiles(activeDir);
+        moveDirsToProfile(activeDir);
+      }
+      updateSettingsPaths(activeDir, 'save');
       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();
+    // 2. Remove leftovers only when switching to non-default
+    if (name !== DEFAULT_PROFILE) {
+      if (active !== DEFAULT_PROFILE) {
+        removeItems();
+      }
+      removeFiles();
+    }
 
-    try {
-      restoreSymlinks(profileDir);
-      restoreFiles(profileDir);
-    } catch (err) {
-      // Rollback: restore from backup
-      warn('Switch failed — rolling back from backup...');
+    // 3. Restore target (skip if to=default — ~/.claude already correct)
+    if (name !== DEFAULT_PROFILE) {
       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}`);
+        moveItemsToClaude(profileDir);
+        restoreFiles(profileDir);
+        moveDirsToClaude(profileDir);
+        updateSettingsPaths(CLAUDE_DIR, 'restore', profileDir);
+      } catch (err) {
+        warn(`Switch failed: ${err.message}`);
+        error('Manual recovery: re-run "csp use <profile>" or restore from profile directory.');
+        throw err;
       }
-      throw err;
     }
 
+    // Track previous profile for toggle
+    if (active) setPrevious(active);
+
     // 4. Update active marker
     setActive(name);
 
     success(`Switched to profile "${name}"`);
-    info('Restart your Claude Code session to apply changes.');
+    if (name === DEFAULT_PROFILE) {
+      info('Using ~/.claude directly (default profile).');
+    } else {
+      info('Restart your Claude Code session to apply changes.');
+    }
   });
 };

package/src/constants.js

@@ -12,20 +12,28 @@ export const PROFILES_META = 'profiles.json';
 export const SOURCE_FILE = 'source.json';
 export const LOCK_FILE = '.lock';
 export const BACKUP_DIR = '.backup';
+export const DEFAULT_PROFILE = 'default';
+export const PROFILES_SCHEMA_VERSION = 2;
+export const RUNTIME_DIR_NAME = '.runtime';
+export const RUNTIMES_DIR = join(PROFILES_DIR, RUNTIME_DIR_NAME);
+export const LAUNCH_CONFIG_ENV = 'CLAUDE_CONFIG_DIR';
+export const LAUNCH_ANTHROPIC_ENV_KEYS = ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_MODEL'];
 
-// Items managed via symlinks — these point to external dirs/files
-export const SYMLINK_ITEMS = [
+// Items managed via copy (formerly symlinks — now always copied)
+export const MANAGED_ITEMS = [
   'CLAUDE.md',
   'rules',
   'agents',
   'skills',
   'hooks',
   'statusline.cjs',
+  'statusline.sh',
+  'statusline.ps1',
   '.luna.json',
 ];
 
-// Directory-type symlink items (auto-created in new profiles)
-export const SYMLINK_DIRS = ['rules', 'agents', 'skills', 'hooks'];
+// Directory-type managed items (auto-created in new profiles)
+export const MANAGED_DIRS = ['rules', 'agents', 'skills', 'hooks'];
 
 // Mutable files managed via copy
 export const COPY_ITEMS = [
@@ -33,34 +41,53 @@ export const COPY_ITEMS = [
   '.env',
   '.ck.json',
   '.ckignore',
+  '.mcp.json',
+  '.mcp.json.example',
+  '.env.example',
+  '.gitignore',
 ];
 
 // Directories managed via copy
 export const COPY_DIRS = [
   'commands',
   'plugins',
+  'workflows',
+  'scripts',
+  'output-styles',
+  'schemas',
 ];
 
-// Never touch these — runtime/session data
-export const NEVER_TOUCH = [
+// Items to NEVER clone (runtime/cache/tracking)
+export const NEVER_CLONE = [
   '.credentials.json',
   'projects',
-  'backups',
+  'sessions',
+  'session-env',
+  'ide',
   'cache',
-  'debug',
-  'telemetry',
-  'shell-snapshots',
   'paste-cache',
-  'file-history',
-  'ide',
-  'session-env',
+  'downloads',
+  'stats-cache.json',
+  'active-plan',
+  'history.jsonl',
+  'metadata.json',
+  'telemetry',
+  'debug',
+  'statsig',
+  'backups',
+  'command-archive',
+  'commands-archived',
   'todos',
   'tasks',
   'teams',
   'agent-memory',
-  'history.jsonl',
   'plans',
+  'file-history',
+  'shell-snapshots',
 ];
 
-// All managed items (symlinks + copies + copy dirs)
-export const ALL_MANAGED = [...SYMLINK_ITEMS, ...COPY_ITEMS, ...COPY_DIRS];
+// Never touch these — runtime/session data (same scope as NEVER_CLONE)
+export const NEVER_TOUCH = [...NEVER_CLONE];
+
+// All managed items (managed + copies + copy dirs)
+export const ALL_MANAGED = [...MANAGED_ITEMS, ...COPY_ITEMS, ...COPY_DIRS];

package/src/file-operations.js

@@ -1,7 +1,20 @@
-import { existsSync, copyFileSync, cpSync, unlinkSync, rmSync, mkdirSync } from 'node:fs';
+import { existsSync, copyFileSync, cpSync, unlinkSync, rmSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { CLAUDE_DIR, COPY_ITEMS, COPY_DIRS } from './constants.js';
 
+// Rename-based dir move with EXDEV fallback
+const moveDir = (src, dest) => {
+  if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+  try {
+    renameSync(src, dest);
+  } catch (err) {
+    if (err.code === 'EXDEV') {
+      cpSync(src, dest, { recursive: true });
+      rmSync(src, { recursive: true, force: true });
+    } else throw err;
+  }
+};
+
 // Copy COPY_ITEMS files + COPY_DIRS dirs from ~/.claude to profileDir
 export const saveFiles = (profileDir) => {
   mkdirSync(profileDir, { recursive: true });
@@ -62,3 +75,69 @@ export const removeFiles = () => {
     }
   }
 };
+
+// Move COPY_DIRS from ~/.claude → profileDir (destructive, for use command)
+// COPY_ITEMS always copied (tiny files, not worth move complexity)
+export const moveDirsToProfile = (profileDir) => {
+  mkdirSync(profileDir, { recursive: true });
+  for (const dir of COPY_DIRS) {
+    const src = join(CLAUDE_DIR, dir);
+    if (existsSync(src)) {
+      moveDir(src, join(profileDir, dir));
+    }
+  }
+};
+
+// Move COPY_DIRS from profileDir → ~/.claude (destructive, for use command)
+export const moveDirsToClaude = (profileDir) => {
+  for (const dir of COPY_DIRS) {
+    const src = join(profileDir, dir);
+    if (existsSync(src)) {
+      moveDir(src, join(CLAUDE_DIR, dir));
+    }
+  }
+};
+
+/**
+ * Update absolute paths in settings.json.
+ * Direction: 'save' replaces CLAUDE_DIR → profileDir, 'restore' replaces profileDir → CLAUDE_DIR.
+ * @param {string} targetDir - The directory containing settings.json to update
+ * @param {'save'|'restore'} direction - Direction of path replacement
+ * @param {string} [profileDir] - Profile directory (required for 'restore' mode)
+ */
+export const updateSettingsPaths = (targetDir, direction = 'save', profileDir = null) => {
+  const settingsPath = join(targetDir, 'settings.json');
+  if (!existsSync(settingsPath)) return;
+
+  try {
+    const raw = readFileSync(settingsPath, 'utf-8');
+    let updated = raw;
+
+    let fromPath, toPath;
+    if (direction === 'save') {
+      fromPath = CLAUDE_DIR;
+      toPath = targetDir;
+    } else {
+      // restore: replace profileDir refs with CLAUDE_DIR
+      fromPath = profileDir || targetDir;
+      toPath = CLAUDE_DIR;
+    }
+
+    // Handle both backslash (Windows JSON-escaped) and forward-slash variants
+    const fromEscaped = fromPath.replaceAll('\\', '\\\\');
+    const toEscaped = toPath.replaceAll('\\', '\\\\');
+    const fromFwd = fromPath.replaceAll('\\', '/');
+    const toFwd = toPath.replaceAll('\\', '/');
+
+    updated = updated.replaceAll(fromEscaped, toEscaped);
+    updated = updated.replaceAll(fromFwd, toFwd);
+    // Also handle raw backslash paths (single backslash in non-JSON context)
+    if (fromPath !== fromEscaped) {
+      updated = updated.replaceAll(fromPath, toPath);
+    }
+
+    if (updated !== raw) {
+      writeFileSync(settingsPath, updated);
+    }
+  } catch { /* parse error — skip */ }
+};