claude-switch-profile 1.0.2 → 1.4.0

package/src/runtime-instance-manager.js

@@ -0,0 +1,190 @@
+import { existsSync, mkdirSync, cpSync, rmSync, lstatSync, statSync, copyFileSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { MANAGED_ITEMS, COPY_ITEMS, COPY_DIRS, CLAUDE_DIR, DEFAULT_PROFILE } from './constants.js';
+import {
+  getActive,
+  getProfileDir,
+  getProfileMeta,
+  getRuntimeDir,
+  markRuntimeInitialized,
+  markProfileLaunched,
+} from './profile-store.js';
+
+const removePath = (targetPath) => {
+  if (!existsSync(targetPath)) return;
+  rmSync(targetPath, { recursive: true, force: true });
+};
+
+const shouldSyncDir = (src, dest) => {
+  if (!existsSync(dest)) return true;
+
+  try {
+    const pending = [[src, dest]];
+
+    while (pending.length > 0) {
+      const [srcDir, destDir] = pending.pop();
+      const srcEntries = readdirSync(srcDir, { withFileTypes: true });
+      const destEntries = readdirSync(destDir, { withFileTypes: true });
+
+      if (srcEntries.length !== destEntries.length) return true;
+
+      const destMap = new Map(destEntries.map((entry) => [entry.name, entry]));
+
+      for (const srcEntry of srcEntries) {
+        const destEntry = destMap.get(srcEntry.name);
+        if (!destEntry) return true;
+
+        const srcPath = join(srcDir, srcEntry.name);
+        const destPath = join(destDir, srcEntry.name);
+
+        if (srcEntry.isDirectory()) {
+          if (!destEntry.isDirectory()) return true;
+          pending.push([srcPath, destPath]);
+          continue;
+        }
+
+        if (srcEntry.isFile()) {
+          if (!destEntry.isFile()) return true;
+          const srcStat = statSync(srcPath);
+          const destStat = statSync(destPath);
+          if (srcStat.size !== destStat.size) return true;
+          if (srcStat.mtimeMs !== destStat.mtimeMs) return true;
+        }
+      }
+    }
+
+    return false;
+  } catch {
+    return true;
+  }
+};
+
+const replacePathVariants = (content, fromPath, toPath) => {
+  const fromEscaped = fromPath.replaceAll('\\', '\\\\');
+  const toEscaped = toPath.replaceAll('\\', '\\\\');
+  const fromFwd = fromPath.replaceAll('\\', '/');
+  const toFwd = toPath.replaceAll('\\', '/');
+
+  let updated = content;
+  updated = updated.replaceAll(fromEscaped, toEscaped);
+  updated = updated.replaceAll(fromFwd, toFwd);
+  if (fromPath !== fromEscaped) {
+    updated = updated.replaceAll(fromPath, toPath);
+  }
+
+  return updated;
+};
+
+const rewriteSettingsForRuntime = (runtimeDir, sourceDir) => {
+  const settingsPath = join(runtimeDir, 'settings.json');
+  if (!existsSync(settingsPath)) return;
+
+  try {
+    const raw = readFileSync(settingsPath, 'utf-8');
+    let updated = raw;
+
+    updated = replacePathVariants(updated, sourceDir, runtimeDir);
+    updated = replacePathVariants(updated, CLAUDE_DIR, runtimeDir);
+
+    if (updated !== raw) {
+      writeFileSync(settingsPath, updated);
+    }
+  } catch {
+    // Best effort
+  }
+};
+
+const getStaticItems = () => {
+  return [...new Set([...MANAGED_ITEMS, ...COPY_ITEMS, ...COPY_DIRS])];
+};
+
+const resolveSourceDir = (profileName) => {
+  if (profileName === DEFAULT_PROFILE) {
+    return CLAUDE_DIR;
+  }
+
+  const active = getActive();
+  if (active === profileName) {
+    return CLAUDE_DIR;
+  }
+
+  return getProfileDir(profileName);
+};
+
+const resolveItemSource = (profileName, item) => {
+  const profileDir = profileName === DEFAULT_PROFILE ? null : getProfileDir(profileName);
+  const active = getActive();
+  const profileIsActive = active === profileName;
+
+  // When profile is active or default, items live in CLAUDE_DIR
+  if (profileIsActive || profileName === DEFAULT_PROFILE) {
+    const claudePath = join(CLAUDE_DIR, item);
+    if (existsSync(claudePath)) return claudePath;
+    // Fallback: items may still be in profileDir (not yet moved by `use`)
+    if (profileDir) {
+      const profilePath = join(profileDir, item);
+      if (existsSync(profilePath)) return profilePath;
+    }
+    return null;
+  }
+
+  // Profile is NOT active — items should be in profileDir
+  const profilePath = join(profileDir, item);
+  if (existsSync(profilePath)) return profilePath;
+
+  return null;
+};
+
+export const syncStaticConfig = (profileName, runtimeDir) => {
+  const sourceDir = resolveSourceDir(profileName);
+  const staticItems = getStaticItems();
+
+  mkdirSync(runtimeDir, { recursive: true });
+
+  for (const item of staticItems) {
+    const src = resolveItemSource(profileName, item);
+    const dest = join(runtimeDir, item);
+
+    if (!src) {
+      // Source doesn't exist anywhere — skip (don't delete existing runtime items)
+      continue;
+    }
+
+    const stat = lstatSync(src);
+
+    if (stat.isDirectory()) {
+      if (!shouldSyncDir(src, dest)) continue;
+      removePath(dest);
+      cpSync(src, dest, { recursive: true });
+      continue;
+    }
+
+    if (stat.isFile()) {
+      mkdirSync(dirname(dest), { recursive: true });
+      copyFileSync(src, dest);
+    }
+  }
+
+  rewriteSettingsForRuntime(runtimeDir, sourceDir);
+
+  return { runtimeDir, sourceDir };
+};
+
+export const seedRuntimeIfNeeded = (profileName) => {
+  const meta = getProfileMeta(profileName);
+  const runtimeDir = meta?.runtimeDir || getRuntimeDir(profileName);
+
+  syncStaticConfig(profileName, runtimeDir);
+
+  if (!meta || !meta.runtimeInitializedAt || meta.runtimeDir !== runtimeDir) {
+    markRuntimeInitialized(profileName, runtimeDir);
+  } else {
+    markProfileLaunched(profileName);
+  }
+
+  return runtimeDir;
+};
+
+export const ensureRuntimeInstance = (profileName) => {
+  return seedRuntimeIfNeeded(profileName);
+};

package/src/safety.js

@@ -1,39 +1,45 @@
 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 { readCurrentItems } from './item-manager.js';
+import { findProcess } from './platform.js';
 import { warn } from './output-helpers.js';
 
+const CLAUDE_RUNNING_ERROR = 'Claude Code appears to be running. Close all Claude sessions before switching profiles.';
+
 const MAX_BACKUPS = 2;
 
-// Acquire a lock file — atomic O_EXCL prevents TOCTOU race
-export const acquireLock = () => {
-  const lockPath = join(PROFILES_DIR, LOCK_FILE);
+const isProcessRunning = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const acquireLockFile = (lockPath) => {
+  mkdirSync(PROFILES_DIR, { recursive: true });
 
   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;
+    if (err.code !== 'EEXIST') throw err;
+
+    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' });
+      return;
     }
+
+    throw new Error(`Another csp operation is running (PID: ${content}). Remove ${lockPath} if stale.`);
   }
 };
 
-// Release the lock file
-export const releaseLock = () => {
-  const lockPath = join(PROFILES_DIR, LOCK_FILE);
+const releaseLockFile = (lockPath) => {
   try {
     if (existsSync(lockPath)) unlinkSync(lockPath);
   } catch {
@@ -41,6 +47,18 @@ export const releaseLock = () => {
   }
 };
 
+// Acquire a lock file — atomic O_EXCL prevents TOCTOU race
+export const acquireLock = () => {
+  const lockPath = join(PROFILES_DIR, LOCK_FILE);
+  acquireLockFile(lockPath);
+};
+
+// Release the lock file
+export const releaseLock = () => {
+  const lockPath = join(PROFILES_DIR, LOCK_FILE);
+  releaseLockFile(lockPath);
+};
+
 // Wrapper that acquires/releases lock around async function
 export const withLock = async (fn) => {
   acquireLock();
@@ -51,24 +69,37 @@ export const withLock = async (fn) => {
   }
 };
 
-// Check if a PID is still running
-const isProcessRunning = (pid) => {
+const runtimeLockName = (profileName) => {
+  return `.runtime.${profileName}.lock`;
+};
+
+export const acquireRuntimeLock = (profileName) => {
+  const lockPath = join(PROFILES_DIR, runtimeLockName(profileName));
+  acquireLockFile(lockPath);
+};
+
+export const releaseRuntimeLock = (profileName) => {
+  const lockPath = join(PROFILES_DIR, runtimeLockName(profileName));
+  releaseLockFile(lockPath);
+};
+
+export const withRuntimeLock = async (profileName, fn) => {
+  acquireRuntimeLock(profileName);
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+    return await fn();
+  } finally {
+    releaseRuntimeLock(profileName);
   }
 };
 
-// Check if claude process is running
+// Check if claude process is running (cross-platform)
 export const isClaudeRunning = () => {
-  try {
-    const result = execFileSync('pgrep', ['-x', 'claude'], { encoding: 'utf-8' });
-    return result.trim().length > 0;
-  } catch {
-    return false;
+  if (process.env.NODE_ENV === 'test') {
+    if (process.env.CSP_TEST_CLAUDE_RUNNING === '1') return true;
+    if (process.env.CSP_TEST_CLAUDE_RUNNING === '0') return false;
   }
+
+  return findProcess('claude');
 };
 
 // Print warning if Claude is detected running
@@ -78,6 +109,12 @@ export const warnIfClaudeRunning = () => {
   }
 };
 
+export const assertClaudeNotRunning = (processChecker = isClaudeRunning) => {
+  if (processChecker()) {
+    throw new Error(CLAUDE_RUNNING_ERROR);
+  }
+};
+
 // Create backup of current managed items, prune old backups
 export const createBackup = () => {
   const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
@@ -85,8 +122,8 @@ export const createBackup = () => {
   const backupPath = join(backupBase, timestamp);
   mkdirSync(backupPath, { recursive: true });
 
-  // Save symlink targets
-  const sourceMap = readCurrentSymlinks();
+  // Save managed item map
+  const sourceMap = readCurrentItems();
   writeFileSync(join(backupPath, 'source.json'), JSON.stringify(sourceMap, null, 2) + '\n');
 
   // Copy mutable files

package/src/symlink-manager.js

@@ -1,69 +0,0 @@
-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;
-};