claude-switch-profile 1.0.2 → 1.4.0

package/src/item-manager.js

@@ -0,0 +1,155 @@
+import { existsSync, readFileSync, writeFileSync, cpSync, rmSync, mkdirSync, lstatSync, copyFileSync, renameSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+import { CLAUDE_DIR, MANAGED_ITEMS, SOURCE_FILE } from './constants.js';
+
+const SKIP_PATTERNS = ['.venv', 'node_modules', '__pycache__', '.git'];
+const skipHeavyDirs = (src) => !SKIP_PATTERNS.includes(basename(src));
+
+// Rename-based move with EXDEV fallback (filtered copy + delete)
+const moveItem = (src, dest) => {
+  mkdirSync(dirname(dest), { recursive: true });
+  if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+  try {
+    renameSync(src, dest);
+  } catch (err) {
+    if (err.code === 'EXDEV') {
+      cpSync(src, dest, { recursive: true, filter: skipHeavyDirs });
+      rmSync(src, { recursive: true, force: true });
+    } else throw err;
+  }
+};
+
+// Read current managed items from ~/.claude — returns map of {item: claudeDir/item}
+export const readCurrentItems = () => {
+  const itemMap = {};
+  for (const item of MANAGED_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      if (existsSync(itemPath)) {
+        itemMap[item] = itemPath;
+      }
+    } catch {
+      // Item doesn't exist or isn't readable — skip
+    }
+  }
+  return itemMap;
+};
+
+// Remove all managed items (dirs/files) from ~/.claude
+export const removeItems = () => {
+  for (const item of MANAGED_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      if (existsSync(itemPath)) {
+        rmSync(itemPath, { recursive: true, force: true });
+      }
+    } catch {
+      // Already gone — skip
+    }
+  }
+};
+
+// Copy managed items from ~/.claude into profileDir, write source.json manifest (non-destructive)
+export const copyItems = (profileDir) => {
+  const sourceMap = {};
+  for (const item of MANAGED_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    try {
+      if (!existsSync(itemPath)) continue;
+
+      const dest = join(profileDir, item);
+      const stat = lstatSync(itemPath);
+
+      if (stat.isDirectory()) {
+        rmSync(dest, { recursive: true, force: true });
+        cpSync(itemPath, dest, { recursive: true });
+      } else if (stat.isFile()) {
+        copyFileSync(itemPath, dest);
+      }
+      sourceMap[item] = dest;
+    } catch {
+      // Not readable — skip
+    }
+  }
+  writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
+  return sourceMap;
+};
+
+// Backward-compatible alias for save.js
+export const saveItems = copyItems;
+
+// Read source.json from profileDir and copy items into ~/.claude (non-destructive)
+export const restoreItems = (profileDir) => {
+  const sourcePath = join(profileDir, SOURCE_FILE);
+  if (!existsSync(sourcePath)) return {};
+
+  const sourceMap = JSON.parse(readFileSync(sourcePath, 'utf-8'));
+
+  for (const [item, srcPath] of Object.entries(sourceMap)) {
+    if (!MANAGED_ITEMS.includes(item)) continue;
+
+    const dest = join(CLAUDE_DIR, item);
+
+    try {
+      if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+    } catch {
+      // fine
+    }
+
+    // Copy from profile (or external legacy path) into ~/.claude
+    if (existsSync(srcPath)) {
+      try {
+        const stat = lstatSync(srcPath);
+        if (stat.isDirectory()) {
+          cpSync(srcPath, dest, { recursive: true });
+        } else if (stat.isFile()) {
+          copyFileSync(srcPath, dest);
+        }
+      } catch {
+        // skip unreadable
+      }
+    }
+  }
+
+  return sourceMap;
+};
+
+// Move items from ~/.claude → profileDir (destructive — items leave ~/.claude)
+export const moveItemsToProfile = (profileDir) => {
+  mkdirSync(profileDir, { recursive: true });
+  const sourceMap = {};
+  for (const item of MANAGED_ITEMS) {
+    const itemPath = join(CLAUDE_DIR, item);
+    if (!existsSync(itemPath)) continue;
+    try {
+      const dest = join(profileDir, item);
+      moveItem(itemPath, dest);
+      sourceMap[item] = dest;
+    } catch {
+      // skip
+    }
+  }
+  writeFileSync(join(profileDir, SOURCE_FILE), JSON.stringify(sourceMap, null, 2) + '\n');
+  return sourceMap;
+};
+
+// Move items from profileDir → ~/.claude (destructive — items leave profileDir)
+export const moveItemsToClaude = (profileDir) => {
+  const sourcePath = join(profileDir, SOURCE_FILE);
+  if (!existsSync(sourcePath)) return {};
+  const sourceMap = JSON.parse(readFileSync(sourcePath, 'utf-8'));
+
+  for (const [item] of Object.entries(sourceMap)) {
+    if (!MANAGED_ITEMS.includes(item)) continue;
+    const src = join(profileDir, item);
+    const dest = join(CLAUDE_DIR, item);
+    if (!existsSync(src)) continue;
+    try {
+      if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+      moveItem(src, dest);
+    } catch {
+      // skip
+    }
+  }
+  return sourceMap;
+};

package/src/launch-effective-env-resolver.js

@@ -0,0 +1,192 @@
+import { LAUNCH_ANTHROPIC_ENV_KEYS, LAUNCH_CONFIG_ENV } from './constants.js';
+
+const RESERVED_PARENT_ENV_KEYS = new Set(['CLAUDECODE', LAUNCH_CONFIG_ENV]);
+const ANTHROPIC_KEY_SET = new Set(LAUNCH_ANTHROPIC_ENV_KEYS);
+
+// Claude Code internal env vars that carry session/auth state between instances.
+// These MUST be stripped to prevent a running default instance from leaking
+// credentials into a profile-specific launch.
+const CLAUDE_SESSION_ENV_PREFIXES = ['CLAUDE_CODE_OAUTH', 'CLAUDE_CODE_SESSION'];
+const CLAUDE_SESSION_ENV_EXACT = new Set([
+  'CLAUDE_CODE_ENTRYPOINT',
+  'CLAUDE_CODE_REMOTE',
+  'CLAUDE_CODE_REMOTE_SESSION_ID',
+  'CLAUDE_CODE_CONTAINER_ID',
+  'CLAUDE_CODE_API_KEY_FILE_DESCRIPTOR',
+]);
+
+const toUpperKey = (key) => String(key || '').toUpperCase();
+const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+
+const sanitizeValue = (value) => {
+  if (value === undefined || value === null) return undefined;
+  return String(value);
+};
+
+const collectAnthropicValues = (source = {}) => {
+  const collected = {};
+
+  for (const [rawKey, rawValue] of Object.entries(source || {})) {
+    const key = toUpperKey(rawKey);
+    if (!ANTHROPIC_KEY_SET.has(key)) continue;
+
+    const value = sanitizeValue(rawValue);
+    if (value === undefined) continue;
+
+    collected[key] = value;
+  }
+
+  return collected;
+};
+
+export const sanitizeInheritedLaunchEnv = (env = {}) => {
+  const sanitized = {};
+
+  for (const [key, value] of Object.entries(env || {})) {
+    if (RESERVED_PARENT_ENV_KEYS.has(toUpperKey(key))) continue;
+    sanitized[key] = value;
+  }
+
+  return sanitized;
+};
+
+const stripAnthropicKeys = (env = {}) => {
+  const sanitized = {};
+
+  for (const [key, value] of Object.entries(env || {})) {
+    const upper = toUpperKey(key);
+    // Strip all ANTHROPIC_* keys (will be re-added from profile settings)
+    if (upper.startsWith('ANTHROPIC_')) continue;
+    // Strip Claude Code session/auth env vars to prevent cross-instance leakage
+    if (CLAUDE_SESSION_ENV_EXACT.has(upper)) continue;
+    if (CLAUDE_SESSION_ENV_PREFIXES.some((prefix) => upper.startsWith(prefix))) continue;
+    sanitized[key] = value;
+  }
+
+  return sanitized;
+};
+
+export const parseSettingsLaunchEnv = (settingsInput) => {
+  if (!settingsInput) return {};
+
+  let settings = settingsInput;
+
+  if (typeof settingsInput === 'string') {
+    settings = JSON.parse(settingsInput);
+  }
+
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
+    return {};
+  }
+
+  const envBlock = settings.env;
+  if (!envBlock || typeof envBlock !== 'object' || Array.isArray(envBlock)) {
+    return {};
+  }
+
+  return collectAnthropicValues(envBlock);
+};
+
+const stripUnquotedInlineComment = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return trimmed;
+
+  if (trimmed.startsWith("'") || trimmed.startsWith('"')) {
+    return trimmed;
+  }
+
+  const commentIndex = trimmed.indexOf('#');
+  if (commentIndex === -1) return trimmed;
+
+  return trimmed.slice(0, commentIndex).trimEnd();
+};
+
+const unquoteDotEnvValue = (value) => {
+  const withoutInlineComment = stripUnquotedInlineComment(value);
+  const trimmed = withoutInlineComment.trim();
+  if (trimmed.length < 2) return trimmed;
+
+  const startsWithSingle = trimmed.startsWith("'") && trimmed.endsWith("'");
+  const startsWithDouble = trimmed.startsWith('"') && trimmed.endsWith('"');
+
+  if (!startsWithSingle && !startsWithDouble) return trimmed;
+
+  return trimmed.slice(1, -1);
+};
+
+export const parseDotEnvLaunchEnv = (content = '') => {
+  const parsed = {};
+
+  for (const rawLine of String(content).split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+
+    const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+
+    const [, rawKey, rawValue] = match;
+    const key = toUpperKey(rawKey);
+    if (!ANTHROPIC_KEY_SET.has(key)) continue;
+
+    parsed[key] = unquoteDotEnvValue(rawValue);
+  }
+
+  return parsed;
+};
+
+const resolveAnthropicValuesByPrecedence = ({ parentValues, dotEnvValues, settingsValues, launchOverrides }) => {
+  // Highest -> lowest precedence:
+  // launchOverrides > profile settings.env > profile .env (allowlist) > parent env
+  const resolvedValues = {};
+  const resolvedSources = {};
+
+  const sources = [
+    ['parent', parentValues],
+    ['profile-dotenv', dotEnvValues],
+    ['profile-settings', settingsValues],
+    ['launch-override', launchOverrides],
+  ];
+
+  for (const [sourceName, sourceValues] of sources) {
+    for (const key of LAUNCH_ANTHROPIC_ENV_KEYS) {
+      if (!hasOwn(sourceValues, key)) continue;
+      resolvedValues[key] = sourceValues[key];
+      resolvedSources[key] = sourceName;
+    }
+  }
+
+  return { resolvedValues, resolvedSources };
+};
+
+export const buildEffectiveLaunchEnv = ({
+  parentEnv = process.env,
+  profileSettingsEnv = {},
+  profileDotEnvEnv = {},
+  launchOverrides = {},
+} = {}) => {
+  const sanitizedParentEnv = sanitizeInheritedLaunchEnv(parentEnv);
+  const baseEnv = stripAnthropicKeys(sanitizedParentEnv);
+
+  const parentValues = collectAnthropicValues(parentEnv);
+  const dotEnvValues = collectAnthropicValues(profileDotEnvEnv);
+  const settingsValues = collectAnthropicValues(profileSettingsEnv);
+  const overrideValues = collectAnthropicValues(launchOverrides);
+
+  const { resolvedValues, resolvedSources } = resolveAnthropicValuesByPrecedence({
+    parentValues,
+    dotEnvValues,
+    settingsValues,
+    launchOverrides: overrideValues,
+  });
+
+  return {
+    launchEnv: {
+      ...baseEnv,
+      ...resolvedValues,
+    },
+    diagnostics: {
+      anthropicKeys: Object.keys(resolvedValues),
+      anthropicKeySources: resolvedSources,
+    },
+  };
+};

package/src/platform.js

@@ -0,0 +1,24 @@
+import { execFileSync } from 'node:child_process';
+
+export const isWindows = process.platform === 'win32';
+
+/**
+ * Check if a process with the given name is running.
+ * Windows: uses tasklist. Unix: uses pgrep.
+ */
+export const findProcess = (name) => {
+  try {
+    if (isWindows) {
+      const result = execFileSync('tasklist', ['/FI', `IMAGENAME eq ${name}.exe`, '/NH'], {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      return result.includes(`${name}.exe`);
+    } else {
+      const result = execFileSync('pgrep', ['-x', name], { encoding: 'utf-8' });
+      return result.trim().length > 0;
+    }
+  } catch {
+    return false;
+  }
+};

package/src/profile-store.js

@@ -1,6 +1,14 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
-import { PROFILES_DIR, ACTIVE_FILE, PROFILES_META } from './constants.js';
+import {
+  PROFILES_DIR,
+  ACTIVE_FILE,
+  PROFILES_META,
+  CLAUDE_DIR,
+  DEFAULT_PROFILE,
+  PROFILES_SCHEMA_VERSION,
+  RUNTIMES_DIR,
+} from './constants.js';
 
 export const ensureProfilesDir = () => {
   if (!existsSync(PROFILES_DIR)) {
@@ -8,15 +16,69 @@ export const ensureProfilesDir = () => {
   }
 };
 
+const normalizeProfileMeta = (name, meta = {}) => {
+  const created = typeof meta.created === 'string' ? meta.created : new Date().toISOString();
+  const description = typeof meta.description === 'string' ? meta.description : '';
+  const mode =
+    meta.mode === 'legacy' || meta.mode === 'account-session'
+      ? meta.mode
+      : name === DEFAULT_PROFILE
+        ? 'legacy'
+        : 'account-session';
+  const runtimeDir = typeof meta.runtimeDir === 'string' && meta.runtimeDir ? meta.runtimeDir : getRuntimeDir(name);
+  const runtimeInitializedAt = typeof meta.runtimeInitializedAt === 'string' ? meta.runtimeInitializedAt : null;
+  const lastLaunchAt = typeof meta.lastLaunchAt === 'string' ? meta.lastLaunchAt : null;
+
+  return {
+    ...meta,
+    created,
+    description,
+    mode,
+    runtimeDir,
+    runtimeInitializedAt,
+    lastLaunchAt,
+  };
+};
+
+const normalizeProfiles = (raw) => {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const legacyProfiles = raw.profiles && typeof raw.profiles === 'object' ? raw.profiles : raw;
+
+  const normalized = {};
+  for (const [name, meta] of Object.entries(legacyProfiles)) {
+    if (!meta || typeof meta !== 'object' || Array.isArray(meta)) continue;
+    normalized[name] = normalizeProfileMeta(name, meta);
+  }
+
+  return normalized;
+};
+
 export const readProfiles = () => {
   const metaPath = join(PROFILES_DIR, PROFILES_META);
   if (!existsSync(metaPath)) return {};
-  return JSON.parse(readFileSync(metaPath, 'utf-8'));
+
+  try {
+    const raw = JSON.parse(readFileSync(metaPath, 'utf-8'));
+    return normalizeProfiles(raw);
+  } catch {
+    return {};
+  }
 };
 
-export const writeProfiles = (data) => {
+export const writeProfiles = (profiles) => {
   ensureProfilesDir();
-  writeFileSync(join(PROFILES_DIR, PROFILES_META), JSON.stringify(data, null, 2) + '\n');
+
+  const normalized = {};
+  for (const [name, meta] of Object.entries(profiles || {})) {
+    normalized[name] = normalizeProfileMeta(name, meta);
+  }
+
+  const payload = {
+    version: PROFILES_SCHEMA_VERSION,
+    profiles: normalized,
+  };
+
+  writeFileSync(join(PROFILES_DIR, PROFILES_META), JSON.stringify(payload, null, 2) + '\n');
 };
 
 export const getActive = () => {
@@ -30,13 +92,35 @@ export const setActive = (name) => {
   writeFileSync(join(PROFILES_DIR, ACTIVE_FILE), name + '\n');
 };
 
+export const clearActive = () => {
+  const activePath = join(PROFILES_DIR, ACTIVE_FILE);
+  try {
+    if (existsSync(activePath)) unlinkSync(activePath);
+  } catch {
+    // Best effort
+  }
+};
+
+const PREVIOUS_FILE = '.previous';
+
+export const getPrevious = () => {
+  const prevPath = join(PROFILES_DIR, PREVIOUS_FILE);
+  if (!existsSync(prevPath)) return null;
+  return readFileSync(prevPath, 'utf-8').trim() || null;
+};
+
+export const setPrevious = (name) => {
+  ensureProfilesDir();
+  writeFileSync(join(PROFILES_DIR, PREVIOUS_FILE), name + '\n');
+};
+
 export const addProfile = (name, metadata = {}) => {
   const profiles = readProfiles();
-  profiles[name] = {
+  profiles[name] = normalizeProfileMeta(name, {
     created: new Date().toISOString(),
     description: '',
     ...metadata,
-  };
+  });
   writeProfiles(profiles);
 };
 
@@ -47,6 +131,7 @@ export const removeProfile = (name) => {
 };
 
 export const profileExists = (name) => {
+  if (name === DEFAULT_PROFILE) return true;
   return existsSync(getProfileDir(name));
 };
 
@@ -63,6 +148,53 @@ export const getProfileDir = (name) => {
   return join(PROFILES_DIR, name);
 };
 
+export const getRuntimeDir = (name) => {
+  validateName(name);
+  return join(RUNTIMES_DIR, name);
+};
+
+export const getProfileMeta = (name) => {
+  const profiles = readProfiles();
+  return profiles[name] || null;
+};
+
+export const updateProfileMeta = (name, patch) => {
+  const profiles = readProfiles();
+  if (!profiles[name]) return null;
+
+  const next = typeof patch === 'function' ? patch({ ...profiles[name] }) : { ...profiles[name], ...patch };
+  profiles[name] = normalizeProfileMeta(name, next);
+  writeProfiles(profiles);
+  return profiles[name];
+};
+
+export const markRuntimeInitialized = (name, runtimeDir) => {
+  const now = new Date().toISOString();
+  return updateProfileMeta(name, {
+    runtimeDir,
+    runtimeInitializedAt: now,
+    lastLaunchAt: now,
+    mode: 'account-session',
+  });
+};
+
+export const markProfileLaunched = (name) => {
+  return updateProfileMeta(name, {
+    lastLaunchAt: new Date().toISOString(),
+    mode: 'account-session',
+  });
+};
+
 export const listProfileNames = () => {
   return Object.keys(readProfiles());
 };
+
+// Returns the directory containing a profile's actual files.
+// If profile is active, items were moved to CLAUDE_DIR during switch.
+// If profile is not active, items are in profileDir.
+export const getEffectiveDir = (name) => {
+  if (name === DEFAULT_PROFILE) return CLAUDE_DIR;
+  const active = getActive();
+  if (active === name) return CLAUDE_DIR;
+  return getProfileDir(name);
+};

package/src/profile-validator.js

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