ai-profile-switch 0.0.0-stage → 2.2.0

package/src/commands/manage.mjs

@@ -0,0 +1,96 @@
+import * as prompt from '../lib/prompt.mjs';
+import { readMeta } from '../lib/config.mjs';
+import { error, warn } from '../lib/ui.mjs';
+import { add } from './add.mjs';
+import { list } from './list.mjs';
+import { use } from './use.mjs';
+import { remove } from './remove.mjs';
+import { rename } from './rename.mjs';
+import { share } from './share.mjs';
+
+function help() {
+  console.log(`Usage:
+  cpf                         Open the profile management menu
+  cpf <name>                  Switch to an existing profile
+  cpf --list                  List profiles and the active one
+  cpf add <name>              Create a profile
+  cpf rename <old> <new>       Rename a profile, keeping its data
+  cpf remove <name>           Delete a profile after confirmation
+  cpf share                   Show what every profile shares
+  cpf share add <entry>       Share CLAUDE.md, skills, agents, … across profiles
+  cpf share remove <entry>    Stop sharing; each profile keeps a copy
+  cpf --help                  Show this help
+
+Enter these commands in your terminal, outside the Claude Code chat. Use /exit to leave the chat.
+Run claude to choose a profile and launch Claude Code.
+Before renaming, close sessions using that profile; macOS may require sign-in again.
+Without shell setup, use: npx ai-profile-switch@latest manage [arguments]`);
+}
+
+export async function manage(args = []) {
+  if (args.some(arg => ['--help', '-h'].includes(arg))) {
+    help();
+    return;
+  }
+  if (args.length === 1 && args[0] === '--list') return list();
+  if (args[0] === 'share') return share(args.slice(1));
+  if (args.length === 1 && !args[0].startsWith('-')) return use(args[0]);
+  if (args.length > 0) {
+    const [command, ...names] = args;
+    const operations = { add: [1, add], remove: [1, remove], rename: [2, rename] };
+    const operation = Object.hasOwn(operations, command) ? operations[command] : undefined;
+    if (!operation || names.length !== operation[0] || names.some(name => name.startsWith('-'))) {
+      throw new Error('Invalid arguments. Run cpf --help for usage.');
+    }
+    return operation[1](...names);
+  }
+  if (!process.stdin.isTTY) {
+    help();
+    return;
+  }
+
+  while (true) {
+    const meta = readMeta();
+    const actions = meta.profiles.length ? [
+      { label: 'Switch profile', value: 'use' },
+      { label: 'List profiles', value: 'list' },
+      { label: 'Add profile', value: 'add' },
+      { label: 'Rename profile', value: 'rename' },
+      { label: 'Delete profile', value: 'remove' },
+      { label: 'Show shared items', value: 'share' },
+      { label: 'Exit', value: 'exit' },
+    ] : [
+      { label: 'Add profile', value: 'add' },
+      { label: 'Exit', value: 'exit' },
+    ];
+    const action = await prompt.select(`Manage profiles (active: ${meta.activeProfile || 'none'})`, actions);
+    if (!action || action === 'exit') return;
+    try {
+      if (action === 'list') {
+        await list();
+      } else if (action === 'share') {
+        await share();
+      } else if (action === 'add') {
+        const name = await prompt.text('New profile name (empty to cancel):');
+        if (name) await add(name);
+      } else {
+        const name = await prompt.select('Choose a profile:', meta.profiles.map(profile => ({
+          label: profile === meta.activeProfile ? `${profile} (active)` : profile,
+          value: profile,
+        })), { initial: meta.profiles.indexOf(meta.activeProfile) });
+        if (!name) return;
+        if (action === 'use') await use(name);
+        else if (action === 'remove') await remove(name);
+        else {
+          warn('Close running sessions for this profile before continuing. macOS may require sign-in again.');
+          const newName = await prompt.text('New name (empty to cancel):');
+          if (newName && await prompt.confirm(`Rename "${name}" to "${newName}"?`, false)) {
+            await rename(name, newName);
+          }
+        }
+      }
+    } catch (err) {
+      error(err.message);
+    }
+  }
+}

package/src/commands/mcp/index.mjs

@@ -0,0 +1,27 @@
+import { join } from 'node:path';
+import { PROFILES_DIR, SHARED_DIR } from '../../lib/constants.mjs';
+import { readMeta } from '../../lib/config.mjs';
+import { readJsonFile } from '../../lib/json-fs.mjs';
+import { info, error } from '../../lib/ui.mjs';
+
+export async function mcp(args = []) {
+  if (args.length > 1 || (args[0] && args[0] !== 'list')) {
+    error('MCP writes are no longer supported here. Use claude mcp add/remove and /mcp.');
+    process.exitCode = 1;
+    return;
+  }
+  info('Legacy MCP data is preserved. Register servers using claude mcp for the selected profile.');
+  const files = [join(SHARED_DIR, 'settings.json'),
+    ...readMeta().profiles.map(name => join(PROFILES_DIR, name, 'settings.local.json'))];
+  for (const file of files) {
+    const data = readJsonFile(file);
+    const names = Object.keys(data.mcpServers ?? {});
+    const disabled = Array.isArray(data.disabledMcpServers) ? data.disabledMcpServers : [];
+    if (names.length || disabled.length) {
+      console.log(`${file}: ${names.join(', ') || '(no servers)'}`);
+      if (disabled.length) console.log(`  Legacy disabled: ${disabled.join(', ')}`);
+    }
+  }
+  info('User servers belong in the profile .claude.json; project servers belong in .mcp.json.');
+  info('See https://code.claude.com/docs/en/mcp');
+}

package/src/commands/migrate.mjs

@@ -0,0 +1,56 @@
+import { parseArgs } from 'node:util';
+import { resolve } from 'node:path';
+import { color, success, warn } from '../lib/ui.mjs';
+import * as prompt from '../lib/prompt.mjs';
+import { readMeta } from '../lib/config.mjs';
+import { migrateDir, profileExists, validateProfileName } from '../lib/profile.mjs';
+import { existingClaudeSources } from './init.mjs';
+
+export async function migrate(profileName, argv = []) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: { from: { type: 'string' } },
+    allowPositionals: true,
+  });
+  const meta = readMeta();
+  if (meta.profiles.length === 0) {
+    throw new Error('No profiles found. Run npx ai-profile-switch@latest init first.');
+  }
+  if (positionals.length > 1) throw new Error('Usage: ai-profile-switch migrate [profile] --from <path>');
+  let target = positionals[0] || (profileName && !profileName.startsWith('-') ? profileName : undefined);
+  if (!target) target = await prompt.select('Copy into which profile?', meta.profiles);
+  if (!target) return;
+  const error = validateProfileName(target);
+  if (error) throw new Error(error);
+  if (!profileExists(target) || !meta.profiles.includes(target)) {
+    throw new Error(`Profile "${target}" does not exist.`);
+  }
+
+  let source = values.from;
+  if (source !== undefined && !source.trim()) throw new Error('Source path cannot be empty.');
+  if (!source) {
+    const choices = existingClaudeSources().map(path => ({ label: path, value: path }));
+    choices.push({ label: 'Enter a custom path', value: '__custom__' });
+    source = await prompt.select('Which configuration do you want to copy?', choices);
+    if (!source) return;
+    if (source === '__custom__') source = await prompt.text('Enter the full path to the directory:', '');
+    if (!source.trim()) throw new Error('Source path cannot be empty.');
+  }
+  source = resolve(source);
+  console.log();
+  console.log(`  Source : ${color.cyan(source)}`);
+  console.log(`  Profile: ${color.cyan(target)}`);
+  console.log('  Existing conflicting data will stop migration. The source will be preserved.');
+  warn('Close Claude sessions using the source or destination before continuing. Keep them closed until migration finishes.');
+  const confirmed = await prompt.confirm(`Copy configuration into "${target}"?`, true);
+  if (!confirmed) {
+    console.log('  Cancelled.');
+    return;
+  }
+  const { backupPath } = migrateDir(source, target, meta.shareSettings !== false);
+  success(`Copied ${source} → profile: ${target}`);
+  if (backupPath) warn(`Previous destination data backup: ${backupPath}`);
+  warn('Original configuration was preserved. macOS Keychain credentials are not copied.');
+  console.log('  Claude will check authentication when you launch this profile.');
+  console.log();
+}

package/src/commands/remove.mjs

@@ -0,0 +1,33 @@
+import { success, warn } from '../lib/ui.mjs';
+import { confirm } from '../lib/prompt.mjs';
+import { assertRegisteredProfile, removeProfile } from '../lib/profile.mjs';
+import { getActiveProfile } from '../lib/config.mjs';
+
+export async function remove(name) {
+  if (!name) throw new Error('Usage: cpf remove <name>');
+
+  assertRegisteredProfile(name);
+
+  const active = getActiveProfile();
+  if (name === active) {
+    warn(`"${name}" is the currently active profile`);
+  }
+
+  const yes = await confirm(`Delete profile "${name}"? This cannot be undone`, false);
+  if (!yes) {
+    console.log('  Cancelled.');
+    return;
+  }
+
+  removeProfile(name);
+  success(`Removed profile: ${name}`);
+
+  if (name === active) {
+    const newActive = getActiveProfile();
+    if (newActive) {
+      success(`Active profile switched to: ${newActive}`);
+    } else {
+      warn('No profiles remaining. Run cpf to add a profile, or npx ai-profile-switch@latest init to set up again.');
+    }
+  }
+}

package/src/commands/rename.mjs

@@ -0,0 +1,14 @@
+import { info, success, warn } from '../lib/ui.mjs';
+import { renameProfile } from '../lib/profile.mjs';
+
+export async function rename(oldName, newName) {
+  if (!oldName || !newName) throw new Error('Usage: cpf rename <old-name> <new-name>');
+  if (oldName !== newName) {
+    warn(`Close running Claude sessions using "${oldName}" before renaming; they still use the old configuration path.`);
+    if (process.platform === 'darwin') {
+      warn('macOS may require signing in again after the configuration path changes.');
+    }
+  }
+  if (renameProfile(oldName, newName)) success(`Renamed profile: ${oldName} → ${newName}`);
+  else info(`"${oldName}" already has that name`);
+}

package/src/commands/share.mjs

@@ -0,0 +1,58 @@
+import { color, info, success, warn } from '../lib/ui.mjs';
+import { SHAREABLE_ENTRIES, SHARED_FILES, SHARED_DIRS } from '../lib/constants.mjs';
+import { readMeta } from '../lib/config.mjs';
+import { shareEntry, syncShared, unshareEntry } from '../lib/shared.mjs';
+
+export function reportConflicts(results) {
+  for (const { name, conflicts, missing } of results) {
+    for (const entry of conflicts) {
+      warn(`${name}: kept its own ${entry} because it differs from the shared copy. Move or delete it, then run cpf share sync.`);
+    }
+    for (const entry of missing) warn(`${name}: shared ${entry} is missing from _shared.`);
+  }
+}
+
+function status() {
+  const meta = readMeta();
+  const shared = meta.shared ?? [];
+  console.log();
+  console.log(`  ${color.bold('Shared by every profile:')} ${[...SHARED_FILES, ...SHARED_DIRS, ...shared].join(', ')}`);
+  console.log(`  ${color.dim(`Can also share: ${SHAREABLE_ENTRIES.filter(entry => !shared.includes(entry)).join(', ') || 'nothing left'}`)}`);
+  console.log();
+  for (const result of syncShared(meta.profiles, { dryRun: true })) {
+    const problems = [
+      ...result.conflicts.map(entry => color.yellow(`own ${entry}`)),
+      ...result.linked.map(entry => `${entry} not linked yet`),
+      ...result.missing.map(entry => color.red(`${entry} missing`)),
+    ];
+    console.log(`  ${result.name.padEnd(12)} ${problems.length ? problems.join(', ') : color.green('in sync')}`);
+  }
+  if (!shared.length) info('Nothing extra is shared yet. Example: cpf share add CLAUDE.md');
+  console.log();
+}
+
+export async function share(args = []) {
+  const [command, entry, ...rest] = args;
+  if (rest.length || (['add', 'remove'].includes(command) ? !entry : entry !== undefined)) {
+    throw new Error('Usage: cpf share [list | add <entry> | remove <entry> | sync]');
+  }
+  if (!command || command === 'list') return status();
+  if (command === 'sync') {
+    const results = syncShared();
+    reportConflicts(results);
+    success(`Linked ${results.reduce((count, result) => count + result.linked.length, 0)} entries.`);
+    return;
+  }
+  if (command === 'add') {
+    const results = shareEntry(entry);
+    reportConflicts(results);
+    success(`Sharing ${entry} through ~/.claude-profiles/_shared/${entry}`);
+    return;
+  }
+  if (command === 'remove') {
+    unshareEntry(entry);
+    success(`Stopped sharing ${entry}. Each profile kept its own copy.`);
+    return;
+  }
+  throw new Error('Usage: cpf share [list | add <entry> | remove <entry> | sync]');
+}

package/src/commands/shell.mjs

@@ -0,0 +1,159 @@
+import { spawn, execFileSync } from 'node:child_process';
+import { accessSync, constants, statSync } from 'node:fs';
+import { constants as osConstants } from 'node:os';
+import { join, delimiter } from 'node:path';
+import { getActiveProfile, setActiveProfile } from '../lib/config.mjs';
+import { HOME, IS_WINDOWS } from '../lib/constants.mjs';
+import { installAllShells } from '../lib/shell.mjs';
+import { listProfiles, profileDir, assertRegisteredProfile } from '../lib/profile.mjs';
+import { success, warn } from '../lib/ui.mjs';
+import { syncShared } from '../lib/shared.mjs';
+import { reportConflicts } from './share.mjs';
+import * as prompt from '../lib/prompt.mjs';
+import { scheduleSelfUpdate } from '../lib/self-update.mjs';
+
+export async function shell(argv = []) {
+  const [subcommand, ...args] = argv;
+  switch (subcommand) {
+    case 'launch': {
+      let profile;
+      let forwarded = args;
+      if (args[0] === '--profile') {
+        if (!args[1] || args[2] !== '--') throw new Error('Expected shell launch --profile <name> -- <args>');
+        profile = args[1];
+        forwarded = args.slice(3);
+      }
+      await launch(forwarded, profile);
+      return;
+    }
+    case 'use':
+      if (args.length !== 1) throw new Error('Usage: cpf <profile-name>');
+      useProfile(args[0]);
+      return;
+    case 'pick':
+      if (args.length && (args.length !== 1 || args[0] !== '--print')) throw new Error('Usage: shell pick [--print]');
+      await pickProfile(args[0] === '--print');
+      return;
+    case 'refresh':
+      if (args.length) throw new Error('Usage: shell refresh');
+      installAllShells();
+      success('Shell integration refreshed.');
+      return;
+    default:
+      throw new Error('Usage: shell <launch|use|pick|refresh>');
+  }
+}
+
+async function launch(args, selected) {
+  const profile = selected ?? await selectProfile();
+  if (!profile) {
+    process.exitCode = 130;
+    return;
+  }
+  assertRegisteredProfile(profile);
+  const bin = resolveClaudeBinary();
+  if (!bin) {
+    console.error('Claude Code executable not found. See https://code.claude.com/docs/en/setup');
+    process.exitCode = 127;
+    return;
+  }
+  scheduleSelfUpdate();
+  if (getActiveProfile() !== profile) setActiveProfile(profile);
+  // Sharing is a convenience; a broken link must not stop Claude from starting.
+  try { reportConflicts(syncShared([profile])); } catch (err) { warn(`Shared items not linked: ${err.message}`); }
+  process.stderr.write(`[ai-profile-switch] Profile: ${profile}\n`);
+  const cmd = bin.endsWith('.js') ? process.execPath : bin;
+  const childArgs = bin.endsWith('.js') ? [bin, ...args] : args;
+  const result = await new Promise(resolve => {
+    const child = spawn(cmd, childArgs, {
+      stdio: 'inherit', shell: false,
+      env: { ...process.env, CLAUDE_CONFIG_DIR: profileDir(profile) },
+    });
+    let interrupted;
+    const onInt = () => { interrupted = 'SIGINT'; child.kill('SIGINT'); };
+    const onTerm = () => { interrupted = 'SIGTERM'; child.kill('SIGTERM'); };
+    process.on('SIGINT', onInt);
+    process.on('SIGTERM', onTerm);
+    const cleanup = () => {
+      process.removeListener('SIGINT', onInt);
+      process.removeListener('SIGTERM', onTerm);
+    };
+    child.once('error', err => {
+      cleanup();
+      console.error(`Could not start Claude Code: ${err.message}`);
+      resolve(1);
+    });
+    child.once('close', (code, signal) => {
+      cleanup();
+      resolve(interrupted ? 128 + osConstants.signals[interrupted] : code ?? (128 + (osConstants.signals[signal] ?? 1)));
+    });
+  });
+  process.exitCode = result;
+}
+
+function useProfile(name) {
+  assertRegisteredProfile(name);
+  if (getActiveProfile() !== name) setActiveProfile(name);
+  success(`Switched to profile: ${name}`);
+}
+
+async function pickProfile(printOnly) {
+  const profile = await selectProfile();
+  if (!profile) {
+    process.exitCode = 130;
+    return;
+  }
+  if (getActiveProfile() !== profile) setActiveProfile(profile);
+  if (printOnly) process.stdout.write(profile + '\n');
+  else success(`Switched to profile: ${profile}`);
+}
+
+async function selectProfile() {
+  const profiles = listProfiles();
+  if (!profiles.length) throw new Error('No profiles found. Run cpf to add one, or npx ai-profile-switch@latest init to import existing Claude settings.');
+  const active = getActiveProfile();
+  const selected = !process.stdin.isTTY || profiles.length === 1
+    ? (active ?? profiles[0])
+    : await prompt.select('Select a profile:', profiles, { output: process.stderr, initial: profiles.indexOf(active) });
+  if (selected) assertRegisteredProfile(selected);
+  return selected;
+}
+
+function executable(file) {
+  try {
+    accessSync(file, IS_WINDOWS ? constants.F_OK : constants.X_OK);
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function resolveClaudeBinary() {
+  const names = IS_WINDOWS ? ['claude.exe'] : ['claude'];
+  for (const directory of (process.env.PATH ?? '').split(delimiter).filter(Boolean)) {
+    for (const name of names) {
+      const file = join(directory, name);
+      if (executable(file)) return file;
+    }
+  }
+  const binName = IS_WINDOWS ? 'claude.exe' : 'claude';
+  const native = [join(HOME, '.local/bin', binName), join(HOME, '.claude/local', binName)];
+  if (!IS_WINDOWS) native.push('/opt/homebrew/bin/claude', '/usr/local/bin/claude');
+  const found = native.find(executable);
+  if (found) return found;
+  try {
+    const npmRoot = execFileSync(IS_WINDOWS ? 'npm.cmd' : 'npm', ['root', '-g'], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, shell: IS_WINDOWS,
+    }).trim();
+    const candidates = IS_WINDOWS ? ['bin/claude.exe', 'cli.js'] : ['bin/claude', 'cli.js'];
+    return candidates
+      .map(file => join(npmRoot, '@anthropic-ai/claude-code', file))
+      .find(file => executable(file) || (file.endsWith('.js') && executable(process.execPath) && exists(file))) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function exists(file) {
+  try { accessSync(file); return statSync(file).isFile(); } catch { return false; }
+}

package/src/commands/update.mjs

@@ -0,0 +1,50 @@
+import { parseArgs } from 'node:util';
+import { computeUpdatePlan, compareSemver } from '../lib/updater.mjs';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { installedRuntimeDirectory, runSelfUpdate } from '../lib/self-update.mjs';
+import { info, warn, error } from '../lib/ui.mjs';
+
+export async function update(args = []) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options: {
+    check: { type: 'boolean', short: 'n' },
+    self: { type: 'boolean' },
+    'claude-code': { type: 'boolean' },
+    yes: { type: 'boolean', short: 'y' },
+  } });
+  if (positionals.length) throw new Error('Usage: update [--check] [--self]');
+  if (values['claude-code']) {
+    info('Claude Code manages its own updates. Run claude update (or your package manager).');
+    info('See https://code.claude.com/docs/en/setup');
+    if (values.check) {
+      warn('Claude Code update status was not checked.');
+      process.exitCode = 2;
+    }
+    if (!values.self) return;
+  }
+  let self;
+  try {
+    ({ self } = await computeUpdatePlan());
+    const runtime = installedRuntimeDirectory();
+    if (runtime) {
+      self.installed = JSON.parse(readFileSync(join(runtime, 'package.json'), 'utf8')).version;
+      self.hasUpdate = compareSemver(self.installed, self.latest) < 0;
+    }
+  } catch (err) {
+    error(err.message);
+    process.exitCode = 2;
+    return;
+  }
+  console.log('Package                 Installed   Latest');
+  console.log(`${self.pkg}   ${self.installed}       ${self.latest}`);
+  if (!self.hasUpdate) info('This package is up to date.');
+  else if (values.check) info('Run npx ai-profile-switch@latest update to install.');
+  else {
+    const result = await runSelfUpdate({ force: true, computePlan: async () => ({ self }) });
+    if (result.action === 'updated') info(`Updated to ${result.version}. New launches use this version; active sessions keep their files.`);
+    else if (result.reason === 'not-installed') info('Local runtime is not installed; no installation was run. Run: npx ai-profile-switch@latest install-shell');
+    else if (result.reason === 'busy') { warn('An update is already running.'); process.exitCode = 2; }
+    else if (result.action === 'failed') { error(`Update failed; existing runtime retained: ${result.error}`); process.exitCode = 2; }
+  }
+  if (values.check && !values['claude-code']) process.exitCode = self.hasUpdate ? 1 : 0;
+}

package/src/commands/use.mjs

@@ -0,0 +1,14 @@
+import { success, info } from '../lib/ui.mjs';
+import { assertRegisteredProfile } from '../lib/profile.mjs';
+import { setActiveProfile, getActiveProfile } from '../lib/config.mjs';
+
+export async function use(name) {
+  assertRegisteredProfile(name);
+  const current = getActiveProfile();
+  if (current === name) {
+    info(`"${name}" is already the active profile`);
+    return;
+  }
+  setActiveProfile(name);
+  success(`Switched to profile: ${name}`);
+}

package/src/index.mjs

@@ -0,0 +1,114 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { error, color } from './lib/ui.mjs';
+
+const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'));
+
+const COMMANDS = {
+  init: () => import('./commands/init.mjs').then(m => m.init()),
+  add: args => import('./commands/add.mjs').then(m => m.add(args[0])),
+  remove: args => import('./commands/remove.mjs').then(m => m.remove(args[0])),
+  rename: args => import('./commands/rename.mjs').then(m => m.rename(...args)),
+  list: () => import('./commands/list.mjs').then(m => m.list()),
+  use: args => import('./commands/use.mjs').then(m => m.use(args[0])),
+  manage: args => import('./commands/manage.mjs').then(m => m.manage(args)),
+  'install-shell': () => import('./commands/install-shell.mjs').then(m => m.installShell()),
+  migrate: args => import('./commands/migrate.mjs').then(m => m.migrate(undefined, args)),
+  share: args => import('./commands/share.mjs').then(m => m.share(args)),
+  mcp: args => import('./commands/mcp/index.mjs').then(m => m.mcp(args)),
+  update: args => import('./commands/update.mjs').then(m => m.update(args)),
+  shell: args => import('./commands/shell.mjs').then(m => m.shell(args)),
+};
+
+const USAGE = {
+  init: 'init',
+  add: 'add <name>',
+  remove: 'remove <name>',
+  rename: 'rename <old-name> <new-name>',
+  list: 'list',
+  use: 'use <name>',
+  manage: 'manage [profile | add <name> | rename <old-name> <new-name> | remove <name> | --list]',
+  'install-shell': 'install-shell',
+  migrate: 'migrate [profile] [--from <path>]',
+  share: 'share [list | add <entry> | remove <entry> | sync]',
+  mcp: 'mcp [list]',
+  update: 'update [--check] [--self] [--claude-code] [--yes]',
+  shell: 'shell <launch|use|pick|refresh>',
+};
+const POSITIONAL_COUNTS = { init: 0, add: 1, remove: 1, rename: 2, list: 0, use: 1, 'install-shell': 0 };
+
+function showHelp(command) {
+  if (command) {
+    console.log(`Usage: npx ai-profile-switch@latest ${USAGE[command]}`);
+    if (command === 'rename') console.log('Close running sessions for this profile first. Its history and settings are kept; macOS may require sign-in again.');
+    if (command === 'remove') console.log('Deletes a registered profile after confirmation. This cannot be undone.');
+    if (command === 'add') console.log('Creates a profile. Run claude, choose it, and sign in to the intended account.');
+    if (command === 'use') console.log('Changes the active profile for future launches; existing sessions keep their profile.');
+    return;
+  }
+  console.log(`
+  ${color.bold('ai-profile-switch')} — Profile switching for Claude Code
+
+  Everyday commands (in your terminal, after shell setup):
+    claude                 Select a profile and launch Claude Code
+    cpf                    Open the profile management menu
+    cpf work               Switch to an existing profile
+    cpf --help             Show short management commands
+
+  Usage: npx ai-profile-switch@latest <command> [options]
+
+  Commands:
+    init                   First setup; show existing setup on repeated runs
+    add <name>             Create a profile
+    remove <name>          Remove a profile after confirmation
+    rename <old> <new>      Rename a profile, keeping its data
+    list                   List profiles
+    use <name>             Change the active profile
+    manage                 Open the same menu as cpf
+    install-shell          Install or repair shell integration
+    migrate [name]         Import existing settings (--from <path>)
+    update [--check]        Update this tool; --check only checks
+    share [add|remove]     Share CLAUDE.md, skills, agents, … across profiles
+    mcp [list]             Show legacy MCP migration guidance
+
+  Run any command with --help for its usage.
+`);
+}
+
+export async function run(argv) {
+  const [command, ...args] = argv;
+  if (!command || ['help', '--help', '-h'].includes(command)) {
+    if (command === 'help' && args.length === 1 && Object.hasOwn(COMMANDS, args[0])) showHelp(args[0]);
+    else showHelp();
+    return;
+  }
+  if (['--version', '-v'].includes(command)) {
+    console.log(pkg.version);
+    return;
+  }
+  if (!Object.hasOwn(COMMANDS, command)) {
+    error(`Unknown command: ${command}`);
+    showHelp();
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    // Claude's forwarded arguments must reach it unchanged.
+    const wantsHelp = command === 'shell'
+      ? ['--help', '-h'].includes(args[0])
+      : command !== 'manage' && args.some(arg => ['--help', '-h'].includes(arg));
+    if (wantsHelp) {
+      showHelp(command);
+      return;
+    }
+    if (Object.hasOwn(POSITIONAL_COUNTS, command)
+      && (args.length !== POSITIONAL_COUNTS[command] || args.some(arg => arg.startsWith('-')))) {
+      throw new Error(`Usage: npx ai-profile-switch@latest ${USAGE[command]}`);
+    }
+    await COMMANDS[command](args);
+  } catch (err) {
+    error(err.message);
+    process.exitCode = 1;
+  }
+}