claude-switch-profile 1.4.2 → 1.4.3

package/CHANGELOG.md

@@ -9,6 +9,14 @@ All notable changes to `claude-switch-profile` are documented here.
 
 ---
 
+## [1.4.2] - 2026-03-31
+
+### Changed
+- Re-released the previous patch after an interrupted publish flow (OTP step).
+- No code changes from `1.4.1`; this version reflects successful npm publication and release metadata synchronization.
+
+---
+
 ## [1.4.1] - 2026-03-31
 
 ### Changed

package/README.md

@@ -550,6 +550,40 @@ Set `CSP_DEBUG_LAUNCH_ENV=1` to print extended launch diagnostics. Do not use in
 
 ---
 
+### exec
+
+Run an arbitrary command inside isolated profile runtime env. This does **not** change global active profile.
+
+```bash
+csp exec <name> -- <command> [args...]
+```
+
+**Examples:**
+
+Run any CLI tool with profile runtime env:
+```bash
+csp exec work -- env
+csp exec work -- node scripts/check-env.js
+```
+
+Run a shell function/alias defined by your interactive shell:
+```bash
+csp exec hd -- claude-hd2
+```
+
+**Behavior:**
+1. Validates target profile exists
+2. Ensures the profile snapshot exists; for legacy installs missing `default/`, guarded backfill only runs when the active profile is `default` or no active profile is set
+3. Prepares per-profile runtime under `~/.claude-profiles/.runtime/<name>`
+4. Resolves effective allowlisted `ANTHROPIC_*` launch env (`ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_MODEL`) with precedence: `settings.json env` > profile `.env` allowlist > parent process env
+5. Strips inherited `CLAUDECODE`, inherited `CLAUDE_CONFIG_DIR`, inherited `ANTHROPIC_*`, and Claude session env vars before applying resolved allowlisted values
+6. On Unix-like systems, runs the command through your interactive shell so shell functions/aliases can resolve like a normal terminal command; on Windows, keeps direct spawn behavior with `.cmd` / `.bat` wrapper detection
+7. Reasserts `CLAUDE_CONFIG_DIR` and allowlisted `ANTHROPIC_*` after shell init so profile isolation wins over shell startup overrides
+8. Inherits stdin/stdout/stderr and forwards child exit code
+9. Keeps `.active` unchanged and never mutates global `~/.claude`
+
+---
+
 ### uninstall
 
 Remove all profiles and restore Claude Code to its pre-CSP state.
@@ -688,23 +722,6 @@ Another csp operation is running (PID: 12345).
 Remove ~/.claude-profiles/.lock if stale.
 ```
 
-### Automatic Backups
-
-Every profile switch creates a timestamped backup:
-
-```
-~/.claude-profiles/.backup/
-├── 2026-03-11T14-30-45-123Z/
-│   ├── source.json
-│   ├── settings.json
-│   ├── .env
-│   └── ...
-└── 2026-03-11T15-45-22-456Z/
-    └── ...
-```
-
-Backups are pruned automatically; CSP keeps only the 2 most recent backups. You can manually restore by copying from backup directory.
-
 ### Claude Process Detection
 
 When switching profiles, CSP detects if Claude Code is running:
@@ -943,6 +960,10 @@ See [CHANGELOG.md](CHANGELOG.md) for version history and migration guidance.
 └── package.json
 ```
 
+## Planned / Future Features
+
+- Automatic backups during profile switch flow (`csp use`) with backup retention/pruning.
+
 ## License
 
 MIT

package/bin/csp.js

@@ -16,7 +16,7 @@ import { importCommand } from '../src/commands/import.js';
 import { diffCommand } from '../src/commands/diff.js';
 import { initCommand } from '../src/commands/init.js';
 import { uninstallCommand } from '../src/commands/uninstall.js';
-import { launchCommand } from '../src/commands/launch.js';
+import { launchCommand, execCommand } from '../src/commands/launch.js';
 import { deactivateCommand } from '../src/commands/deactivate.js';
 import { toggleCommand } from '../src/commands/toggle.js';
 import { statusCommand } from '../src/commands/status.js';
@@ -130,6 +130,26 @@ program
     launchCommand(name, claudeArgs, options);
   });
 
+program
+  .command('exec <name> [args...]')
+  .description('Run arbitrary command inside isolated profile runtime environment')
+  .allowUnknownOption(true)
+  .enablePositionalOptions(true)
+  .passThroughOptions(true)
+  .action((name, args, _options, cmd) => {
+    const passthrough = [...(args || [])];
+    const unknown = cmd.args.filter((a) => a !== name && !passthrough.includes(a));
+    const tokens = [...passthrough, ...unknown];
+
+    while (tokens[0] === '--') {
+      tokens.shift();
+    }
+
+    const command = tokens[0];
+    const commandArgs = tokens.slice(1);
+    execCommand(name, command, commandArgs);
+  });
+
 program
   .command('uninstall')
   .description('Remove all profiles and restore Claude Code to pre-CSP state')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-switch-profile",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "CLI tool for managing multiple Claude Code profiles",
   "type": "module",
   "bin": {

package/src/commands/launch.js

@@ -1,14 +1,21 @@
 import { execFileSync, spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { profileExists, ensureDefaultProfileSnapshot } from '../profile-store.js';
+import { basename, join } from 'node:path';
+import { accessSync, constants as fsConstants, existsSync } from 'node:fs';
+import { info, error } from '../output-helpers.js';
 import { useCommand } from './use.js';
-import { ensureRuntimeInstance } from '../runtime-instance-manager.js';
-import { withRuntimeLock } from '../safety.js';
-import { error, info, warn } from '../output-helpers.js';
 import { isWindows } from '../platform.js';
-import { LAUNCH_CONFIG_ENV, DEFAULT_PROFILE } from '../constants.js';
-import { buildEffectiveLaunchEnv, parseDotEnvLaunchEnv, parseSettingsLaunchEnv, sanitizeInheritedLaunchEnv } from '../launch-effective-env-resolver.js';
+import { LAUNCH_CONFIG_ENV } from '../constants.js';
+import {
+  ensureLaunchProfileReady,
+  formatLaunchEnvDiagnostics,
+  resolveIsolatedLaunchContext,
+  stripInheritedLaunchEnv,
+} from '../isolated-launch-context.js';
+
+export { ensureLaunchProfileReady, formatLaunchEnvDiagnostics, resolveIsolatedLaunchContext, stripInheritedLaunchEnv };
+
+const SHELL_REASSERT_ENV_KEYS = [LAUNCH_CONFIG_ENV, 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_MODEL'];
+const SAFE_SHELL_COMMAND = /^[A-Za-z0-9_./:@%+-]+$/;
 
 const isTruthyDebugValue = (value) => {
   if (value === undefined || value === null) return false;
@@ -61,161 +68,187 @@ export const resolveClaudeLaunchTarget = (env = process.env, dependencies = {})
     return { command: 'claude', shell: true };
   }
 
-  const requiresShell = /\.(cmd|bat)$/i.test(resolvedPath);
-
   return {
-    command: requiresShell ? `"${resolvedPath}"` : resolvedPath,
-    shell: requiresShell,
+    command: /\.(cmd|bat)$/i.test(resolvedPath) ? `"${resolvedPath}"` : resolvedPath,
+    shell: /\.(cmd|bat)$/i.test(resolvedPath),
   };
 };
 
-const readProfileSettingsLaunchEnv = (profileDir) => {
-  const settingsPath = join(profileDir, 'settings.json');
-  if (!existsSync(settingsPath)) return {};
-
-  try {
-    const rawSettings = readFileSync(settingsPath, 'utf-8');
-    return parseSettingsLaunchEnv(rawSettings);
-  } catch {
-    warn(`Could not parse launch env from ${settingsPath}; falling back to inherited env.`);
-    return {};
+export const resolveExecTarget = (command, env = process.env, dependencies = {}) => {
+  const windows = dependencies.isWindows ?? isWindows;
+  if (!windows) {
+    return { command, shell: false };
   }
-};
 
-const readProfileDotEnvLaunchEnv = (profileDir) => {
-  const dotEnvPath = join(profileDir, '.env');
-  if (!existsSync(dotEnvPath)) return {};
+  const execRunner = dependencies.execFileSync || execFileSync;
+  const fileName = basename(command || '').toLowerCase();
+  if (/\.(cmd|bat)$/i.test(command || '') || fileName === 'cmd' || fileName === 'cmd.exe') {
+    return {
+      command: /\s/.test(command || '') ? `"${command}"` : command,
+      shell: true,
+    };
+  }
 
   try {
-    const rawDotEnv = readFileSync(dotEnvPath, 'utf-8');
-    return parseDotEnvLaunchEnv(rawDotEnv);
+    const resolvedPath = execRunner('where.exe', [command], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      env,
+    })
+      .trim()
+      .split(/\r?\n/)
+      .map((entry) => entry.trim())
+      .find(Boolean);
+
+    if (resolvedPath && /\.(cmd|bat)$/i.test(resolvedPath)) {
+      return { command, shell: true };
+    }
   } catch {
-    warn(`Could not parse launch env from ${dotEnvPath}; falling back to inherited env.`);
-    return {};
+    // Fall back to default non-shell spawn behavior.
   }
+
+  return { command, shell: false };
 };
 
-const readProfileLaunchEnvSources = (runtimeDir) => {
-  return {
-    profileSettingsEnv: readProfileSettingsLaunchEnv(runtimeDir),
-    profileDotEnvEnv: readProfileDotEnvLaunchEnv(runtimeDir),
+const runSpawnedCommand = ({ command, args = [], env, shell = false, errorLabel }) => {
+  const child = spawn(command, args, {
+    stdio: 'inherit',
+    shell,
+    detached: false,
+    env,
+  });
+
+  const forwardSignal = (sig) => {
+    try {
+      child.kill(sig);
+    } catch {
+      // Child may have already exited
+    }
   };
-};
 
-const formatLaunchEnvDiagnostics = (diagnostics = {}) => {
-  const keys = diagnostics.anthropicKeys || [];
-  const sources = diagnostics.anthropicKeySources || {};
+  process.on('SIGINT', forwardSignal);
+  process.on('SIGTERM', forwardSignal);
 
-  if (!keys.length) {
-    return 'ANTHROPIC_* keys: none';
-  }
+  child.on('error', (err) => {
+    error(`${errorLabel}: ${err.message}`);
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    process.removeListener('SIGINT', forwardSignal);
+    process.removeListener('SIGTERM', forwardSignal);
+    process.exit(code || 0);
+  });
 
-  const keyDetails = keys
-    .map((key) => `${key}<=${sources[key] || 'unknown'}`)
-    .join(', ');
+  return new Promise(() => {});
+};
 
-  return `ANTHROPIC_* keys: ${keyDetails}`;
+const formatCommand = (command, args = []) => {
+  return [command, ...args].filter((part) => part !== undefined && part !== null && String(part).length > 0).join(' ');
 };
 
-export const stripInheritedLaunchEnv = (env = process.env) => {
-  const sanitized = sanitizeInheritedLaunchEnv(env);
-  for (const key of Object.keys(sanitized)) {
-    if (key.toUpperCase().startsWith('ANTHROPIC_')) {
-      delete sanitized[key];
-    }
+const quoteShellToken = (value) => `'${String(value).replaceAll("'", `'"'"'`)}'`;
+const formatShellCommandToken = (value) => (SAFE_SHELL_COMMAND.test(String(value || '')) ? String(value) : quoteShellToken(value));
+const isExecutableFile = (filePath) => {
+  if (!filePath) return false;
+  try {
+    accessSync(filePath, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
   }
-  return sanitized;
+};
+const getInteractiveShellPath = (env = process.env) => {
+  if (isExecutableFile(env.SHELL)) return env.SHELL;
+  return '/bin/sh';
 };
 
-export const launchCommand = async (name, claudeArgs, options = {}) => {
-  if (name === DEFAULT_PROFILE) {
-    try {
-      ensureDefaultProfileSnapshot();
-    } catch (err) {
-      error(err.message);
-      process.exit(1);
+const buildShellEvalCommand = (command, args = []) => {
+  return [formatShellCommandToken(command), ...args.map((arg) => quoteShellToken(arg))].join(' ');
+};
+
+const buildShellEnvReassertion = (env) => {
+  return SHELL_REASSERT_ENV_KEYS.map((key) => {
+    if (Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined) {
+      return `export ${key}=${quoteShellToken(env[key])}`;
     }
-  }
+    return `unset ${key}`;
+  }).join('; ');
+};
 
-  if (!profileExists(name)) {
-    error(`Profile "${name}" does not exist. Run "csp list" to see available profiles.`);
-    process.exit(1);
-  }
+const executeViaInteractiveShell = ({ command, args = [], launchEnv, errorLabel }) => {
+  const shellPath = getInteractiveShellPath(launchEnv);
+  const shellEnv = { ...launchEnv, CSP_EXEC_CMD: buildShellEvalCommand(command, args) };
+  const shellScript = `${buildShellEnvReassertion(launchEnv)}; eval "$CSP_EXEC_CMD"`;
 
-  let args = [...(claudeArgs || [])];
-  const legacyFromArgs = args.includes('--legacy-global');
-  if (legacyFromArgs) {
-    args = args.filter((a) => a !== '--legacy-global');
-  }
+  return runSpawnedCommand({
+    command: shellPath,
+    args: ['-ic', shellScript],
+    env: shellEnv,
+    errorLabel,
+  });
+};
 
-  let launchEnv = { ...process.env };
+export const launchCommand = async (name, claudeArgs, options = {}) => {
+  ensureLaunchProfileReady(name);
 
-  if (options.legacyGlobal || legacyFromArgs) {
+  let args = [...(claudeArgs || [])];
+  if (options.legacyGlobal || args.includes('--legacy-global')) {
+    args = args.filter((arg) => arg !== '--legacy-global');
     await useCommand(name, { save: true, skipClaudeCheck: true });
     info(`Launching legacy/global mode: claude ${args.join(' ')}`.trim());
-  } else {
-    const runtimeDir = await withRuntimeLock(name, async () => ensureRuntimeInstance(name));
-    const { profileSettingsEnv, profileDotEnvEnv } = readProfileLaunchEnvSources(runtimeDir);
-    const { launchEnv: resolvedLaunchEnv, diagnostics } = buildEffectiveLaunchEnv({
-      parentEnv: process.env,
-      profileSettingsEnv,
-      profileDotEnvEnv,
-    });
-
-    launchEnv = {
-      ...resolvedLaunchEnv,
-      [LAUNCH_CONFIG_ENV]: runtimeDir,
-    };
-
-    // CLAUDE_CONFIG_DIR already redirects user-level config lookups to the
-    // runtime dir, so the "user" settings source reads {runtimeDir}/settings.json
-    // — which is the correct profile-specific settings. We do NOT exclude "user"
-    // because Claude Code gates skill/hook discovery on it being enabled.
+    return runSpawnedCommand({ command: 'claude', args, env: { ...process.env }, errorLabel: 'Failed to launch Claude' });
+  }
 
-    // Always show launch diagnostics for debugging credential issues
-    info(`Launch env diagnostics (${name}): ${formatLaunchEnvDiagnostics(diagnostics)}`);
-    info(`CLAUDE_CONFIG_DIR=${launchEnv[LAUNCH_CONFIG_ENV]}`);
-    info(`ANTHROPIC_AUTH_TOKEN=${launchEnv.ANTHROPIC_AUTH_TOKEN ? launchEnv.ANTHROPIC_AUTH_TOKEN.slice(0, 8) + '...' : '(not set)'}`);
-    info(`ANTHROPIC_BASE_URL=${launchEnv.ANTHROPIC_BASE_URL || '(not set)'}`);
+  const isolated = await resolveIsolatedLaunchContext(name, process.env);
+  const launchEnv = isolated.launchEnv;
 
-    if (isTruthyDebugValue(process.env.CSP_DEBUG_LAUNCH_ENV)) {
-      info(`[DEBUG] Full launch env ANTHROPIC keys: ${JSON.stringify(Object.fromEntries(Object.entries(launchEnv).filter(([k]) => k.startsWith('ANTHROPIC_'))))}`);
-    }
+  info(`Launch env diagnostics (${name}): ${formatLaunchEnvDiagnostics(isolated.diagnostics)}`);
+  info(`CLAUDE_CONFIG_DIR=${launchEnv[LAUNCH_CONFIG_ENV]}`);
+  info(`ANTHROPIC_AUTH_TOKEN=${launchEnv.ANTHROPIC_AUTH_TOKEN ? `${launchEnv.ANTHROPIC_AUTH_TOKEN.slice(0, 8)}...` : '(not set)'}`);
+  info(`ANTHROPIC_BASE_URL=${launchEnv.ANTHROPIC_BASE_URL || '(not set)'}`);
 
-    info(`Launching isolated session for profile "${name}": claude ${args.join(' ')}`.trim());
+  if (isTruthyDebugValue(process.env.CSP_DEBUG_LAUNCH_ENV)) {
+    info(`[DEBUG] Full launch env ANTHROPIC keys: ${JSON.stringify(Object.fromEntries(Object.entries(launchEnv).filter(([key]) => key.startsWith('ANTHROPIC_'))))}`);
   }
 
+  info(`Launching isolated session for profile "${name}": claude ${args.join(' ')}`.trim());
+
   const launchTarget = resolveClaudeLaunchTarget(launchEnv);
+  return runSpawnedCommand({ command: launchTarget.command, args, env: launchEnv, shell: launchTarget.shell, errorLabel: 'Failed to launch Claude' });
+};
 
-  const child = spawn(launchTarget.command, args, {
-    stdio: 'inherit',
-    shell: launchTarget.shell,
-    detached: false,
-    env: launchEnv,
-  });
+export const execCommand = async (name, command, commandArgs = []) => {
+  ensureLaunchProfileReady(name);
 
-  // Forward signals to child instead of killing parent
-  const forwardSignal = (sig) => {
-    try {
-      child.kill(sig);
-    } catch {
-      // Child may have already exited
-    }
-  };
-  process.on('SIGINT', forwardSignal);
-  process.on('SIGTERM', forwardSignal);
-
-  child.on('error', (err) => {
-    error(`Failed to launch Claude: ${err.message}`);
+  const normalizedCommand = typeof command === 'string' ? command.trim() : '';
+  if (!normalizedCommand) {
+    error('Missing command. Usage: csp exec <name> -- <cmd> [args...]');
     process.exit(1);
-  });
+  }
 
-  child.on('exit', (code) => {
-    process.removeListener('SIGINT', forwardSignal);
-    process.removeListener('SIGTERM', forwardSignal);
-    process.exit(code || 0);
-  });
+  const isolated = await resolveIsolatedLaunchContext(name, process.env);
+  const launchEnv = isolated.launchEnv;
 
-  // Keep process alive while Claude runs
-  return new Promise(() => {});
+  info(`Launch env diagnostics (${name}): ${formatLaunchEnvDiagnostics(isolated.diagnostics)}`);
+  info(`CLAUDE_CONFIG_DIR=${launchEnv[LAUNCH_CONFIG_ENV]}`);
+  info(`Executing isolated command for profile "${name}": ${formatCommand(normalizedCommand, commandArgs)}`);
+
+  if (!isWindows) {
+    return executeViaInteractiveShell({
+      command: normalizedCommand,
+      args: commandArgs,
+      launchEnv,
+      errorLabel: `Failed to execute command "${normalizedCommand}"`,
+    });
+  }
+
+  const execTarget = resolveExecTarget(normalizedCommand, launchEnv);
+  return runSpawnedCommand({
+    command: execTarget.command,
+    args: commandArgs,
+    env: launchEnv,
+    shell: execTarget.shell,
+    errorLabel: `Failed to execute command "${normalizedCommand}"`,
+  });
 };

package/src/isolated-launch-context.js

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { profileExists, ensureDefaultProfileSnapshot } from './profile-store.js';
+import { ensureRuntimeInstance } from './runtime-instance-manager.js';
+import { withRuntimeLock } from './safety.js';
+import { error, warn } from './output-helpers.js';
+import { LAUNCH_CONFIG_ENV, DEFAULT_PROFILE } from './constants.js';
+import {
+  buildEffectiveLaunchEnv,
+  parseDotEnvLaunchEnv,
+  parseSettingsLaunchEnv,
+  sanitizeInheritedLaunchEnv,
+} from './launch-effective-env-resolver.js';
+
+const readProfileSettingsLaunchEnv = (profileDir) => {
+  const settingsPath = join(profileDir, 'settings.json');
+  if (!existsSync(settingsPath)) return {};
+
+  try {
+    return parseSettingsLaunchEnv(readFileSync(settingsPath, 'utf-8'));
+  } catch {
+    warn(`Could not parse launch env from ${settingsPath}; falling back to inherited env.`);
+    return {};
+  }
+};
+
+const readProfileDotEnvLaunchEnv = (profileDir) => {
+  const dotEnvPath = join(profileDir, '.env');
+  if (!existsSync(dotEnvPath)) return {};
+
+  try {
+    return parseDotEnvLaunchEnv(readFileSync(dotEnvPath, 'utf-8'));
+  } catch {
+    warn(`Could not parse launch env from ${dotEnvPath}; falling back to inherited env.`);
+    return {};
+  }
+};
+
+const readProfileLaunchEnvSources = (runtimeDir) => {
+  return {
+    profileSettingsEnv: readProfileSettingsLaunchEnv(runtimeDir),
+    profileDotEnvEnv: readProfileDotEnvLaunchEnv(runtimeDir),
+  };
+};
+
+export const formatLaunchEnvDiagnostics = (diagnostics = {}) => {
+  const keys = diagnostics.anthropicKeys || [];
+  const sources = diagnostics.anthropicKeySources || {};
+
+  if (!keys.length) {
+    return 'ANTHROPIC_* keys: none';
+  }
+
+  return `ANTHROPIC_* keys: ${keys.map((key) => `${key}<=${sources[key] || 'unknown'}`).join(', ')}`;
+};
+
+export const stripInheritedLaunchEnv = (env = process.env) => {
+  const sanitized = sanitizeInheritedLaunchEnv(env);
+  for (const key of Object.keys(sanitized)) {
+    if (key.toUpperCase().startsWith('ANTHROPIC_')) {
+      delete sanitized[key];
+    }
+  }
+  return sanitized;
+};
+
+export const ensureLaunchProfileReady = (name) => {
+  if (name === DEFAULT_PROFILE) {
+    try {
+      ensureDefaultProfileSnapshot();
+    } catch (err) {
+      error(err.message);
+      process.exit(1);
+    }
+  }
+
+  if (!profileExists(name)) {
+    error(`Profile "${name}" does not exist. Run "csp list" to see available profiles.`);
+    process.exit(1);
+  }
+};
+
+export const resolveIsolatedLaunchContext = async (name, parentEnv = process.env) => {
+  const runtimeDir = await withRuntimeLock(name, async () => ensureRuntimeInstance(name));
+  const { profileSettingsEnv, profileDotEnvEnv } = readProfileLaunchEnvSources(runtimeDir);
+  const { launchEnv: resolvedLaunchEnv, diagnostics } = buildEffectiveLaunchEnv({
+    parentEnv,
+    profileSettingsEnv,
+    profileDotEnvEnv,
+  });
+
+  return {
+    runtimeDir,
+    diagnostics,
+    launchEnv: {
+      ...resolvedLaunchEnv,
+      [LAUNCH_CONFIG_ENV]: runtimeDir,
+    },
+  };
+};