ai-profile-switch 0.0.0-stage → 2.2.1

package/src/commands/manage.mjs

@@ -0,0 +1,152 @@
+import * as prompt from '../lib/prompt.mjs';
+import { readMeta } from '../lib/config.mjs';
+import { color, displayWidth, error, intro, sym, warn } from '../lib/ui.mjs';
+import { accountInfo } from '../lib/account.mjs';
+import { HOME } from '../lib/constants.mjs';
+import { LANGUAGE_NAMES, language as currentLanguage, relativeTime, t } from '../lib/i18n.mjs';
+import { checkRename, profileDir } from '../lib/profile.mjs';
+import { add } from './add.mjs';
+import { list } from './list.mjs';
+import { login } from './login.mjs';
+import { accountSummary, profileChoices, usageLine } from './shell.mjs';
+import { use } from './use.mjs';
+import { remove } from './remove.mjs';
+import { rename } from './rename.mjs';
+import { share } from './share.mjs';
+import { language } from './language.mjs';
+
+function help() {
+  console.log(t('manage.help'));
+}
+
+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[0] === 'language') return language(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], login: [1, login] };
+    const operation = Object.hasOwn(operations, command) ? operations[command] : undefined;
+    if (!operation || names.length !== operation[0] || names.some(name => name.startsWith('-'))) {
+      throw new Error(t('manage.invalid'));
+    }
+    return operation[1](...names);
+  }
+  if (!process.stdin.isTTY) {
+    help();
+    return;
+  }
+
+  const start = readMeta().activeProfile;
+  const email = start ? accountInfo(start).email : null;
+  intro('ai-profile-switch', start ? t('menu.current', { name: [start, email].filter(Boolean).join(' · ') }) : '');
+  while (true) {
+    const meta = readMeta();
+    const item = (value, hint) => ({ label: t(`menu.${value}`), value, hint: hint && color.dim(hint) });
+    const languageItem = item('language', LANGUAGE_NAMES[currentLanguage()]);
+    const actions = meta.profiles.length
+      ? [item('use'), item('manage', t('menu.manageHint')), item('add'), item('share'), languageItem, item('exit')]
+      : [item('add'), languageItem, item('exit')];
+    const action = await prompt.select(t('menu.question'), actions);
+    if (!action || action === 'exit') return;
+    try {
+      if (action === 'share') {
+        await share();
+      } else if (action === 'language') {
+        await language();
+      } else if (action === 'add') {
+        const name = await prompt.text(t('menu.addName'));
+        if (name) await add(name);
+      } else if (action === 'use') {
+        const name = await pickProfile(t('menu.usePick'), meta);
+        if (name) await use(name);
+      } else {
+        await manageProfiles();
+      }
+    } catch (err) {
+      error(err.message, err.hints);
+    }
+  }
+}
+
+function pickProfile(question, meta) {
+  return prompt.select(question, profileChoices(meta.profiles, meta.activeProfile), {
+    initial: Math.max(0, meta.profiles.indexOf(meta.activeProfile)), numbered: true, back: true,
+  });
+}
+
+// Pick a profile, then act on it from its detail screen until Back.
+async function manageProfiles() {
+  while (true) {
+    const meta = readMeta();
+    if (!meta.profiles.length) return;
+    const name = await pickProfile(t('menu.managePick'), meta);
+    if (!name) return;
+    let current = name;
+    while (current) {
+      try {
+        current = await profileDetail(current);
+      } catch (err) {
+        error(err.message, err.hints);
+      }
+    }
+  }
+}
+
+function detailLines(name) {
+  const account = accountInfo(name);
+  const rows = [
+    [t('detail.account'), accountSummary(account) || color.dim(t('account.notSignedIn'))],
+    ...(account.email ? [[t('detail.usage'), account.usage ? usageLine(account) : color.dim(t('detail.noUsage'))]] : []),
+    [t('detail.lastUsed'), account.lastUsed ? relativeTime(account.lastUsed) : color.dim(t('detail.never'))],
+    [t('detail.folder'), color.dim(shortPath(profileDir(name)))],
+  ];
+  const width = Math.max(...rows.map(([label]) => displayWidth(label)));
+  return [...rows.map(([label, value]) => `${color.dim(label)}${' '.repeat(width - displayWidth(label) + 2)}${value}`), ''];
+}
+
+function shortPath(path) {
+  return path.startsWith(HOME) ? `~${path.slice(HOME.length)}` : path;
+}
+
+// Returns the profile to show again, or null to go back to the list.
+async function profileDetail(name) {
+  const title = t('detail.title', { name });
+  const action = await prompt.select(color.bold(title), [
+    { label: t('detail.use'), value: 'use' },
+    { label: t('detail.rename'), value: 'rename' },
+    { label: t('detail.login'), value: 'login', hint: color.dim(t('detail.loginHint')) },
+    { label: t('detail.remove'), value: 'remove', hint: color.dim(t('menu.removeHint')) },
+    { label: t('detail.back'), value: 'back' },
+  ], { body: detailLines(name), back: true });
+  if (!action || action === 'back') return null;
+  if (action === 'use') {
+    await use(name);
+    return name;
+  }
+  if (action === 'remove') {
+    await remove(name);
+    return readMeta().profiles.includes(name) ? name : null;
+  }
+  if (action === 'rename') {
+    warn(t('rename.closeSessions', { name }));
+    const newName = await prompt.text(t('rename.newName'), undefined, t('rename.newNameHint', { name }));
+    if (!newName || newName === name) return name;
+    checkRename(name, newName);
+    if (!await prompt.confirm(t('rename.confirm', { old: name, new: newName }), false)) return name;
+    await rename(name, newName, { warned: true });
+    return newName;
+  }
+  const account = accountSummary(accountInfo(name));
+  console.log(`${color.dim(sym.rail)}  ${color.dim(t('login.current'))} ${account || color.dim(t('account.notSignedIn'))}`);
+  console.log(`${color.dim(sym.rail)}  ${color.dim(t('login.onlyThis'))}`);
+  console.log(`${color.dim(sym.rail)}  ${color.dim(t('login.browser'))}`);
+  console.log(`${color.dim(sym.rail)}  ${color.dim(t('login.closeSessions', { name }))}`);
+  if (await prompt.confirm(t('login.confirm', { name }), false)) await login(name, { explained: true });
+  return name;
+}

package/src/commands/mcp/index.mjs

@@ -0,0 +1,28 @@
+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';
+import { t } from '../../lib/i18n.mjs';
+
+export async function mcp(args = []) {
+  if (args.length > 1 || (args[0] && args[0] !== 'list')) {
+    error(t('mcp.noWrites'));
+    process.exitCode = 1;
+    return;
+  }
+  info(t('mcp.preserved'));
+  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(', ') || t('mcp.noServers')}`);
+      if (disabled.length) console.log(`  ${t('mcp.disabled', { list: disabled.join(', ') })}`);
+    }
+  }
+  info(t('mcp.where'));
+  info(t('mcp.see'));
+}

package/src/commands/migrate.mjs

@@ -0,0 +1,57 @@
+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 { t } from '../lib/i18n.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(t('migrate.noProfiles'));
+  }
+  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(t('migrate.target'), 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(t('profile.notFound', { name: target }));
+  }
+
+  let source = values.from;
+  if (source !== undefined && !source.trim()) throw new Error(t('migrate.emptySource'));
+  if (!source) {
+    const choices = existingClaudeSources().map(path => ({ label: path, value: path }));
+    choices.push({ label: t('migrate.customPath'), value: '__custom__' });
+    source = await prompt.select(t('migrate.which'), choices);
+    if (!source) return;
+    if (source === '__custom__') source = await prompt.text(t('migrate.enterPath'), '');
+    if (!source.trim()) throw new Error(t('migrate.emptySource'));
+  }
+  source = resolve(source);
+  console.log();
+  console.log(`  ${color.dim(t('migrate.source'))} ${color.cyan(source)}`);
+  console.log(`  ${color.dim(t('migrate.profile'))} ${color.cyan(target)}`);
+  console.log(`  ${t('migrate.conflictNote')}`);
+  warn(t('migrate.closeSessions'));
+  const confirmed = await prompt.confirm(t('migrate.confirm', { name: target }), true);
+  if (!confirmed) {
+    console.log(`  ${t('common.cancelled')}`);
+    return;
+  }
+  const { backupPath } = migrateDir(source, target, meta.shareSettings !== false);
+  success(t('migrate.copied', { source, name: target }));
+  if (backupPath) warn(t('migrate.backup', { path: backupPath }));
+  warn(t('migrate.preserved'));
+  console.log(`  ${t('migrate.signIn')}`);
+  console.log();
+}

package/src/commands/remove.mjs

@@ -0,0 +1,34 @@
+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';
+import { t } from '../lib/i18n.mjs';
+
+export async function remove(name) {
+  if (!name) throw new Error('Usage: cpf remove <name>');
+
+  assertRegisteredProfile(name);
+
+  const active = getActiveProfile();
+  if (name === active) {
+    warn(t('remove.activeWarn', { name }));
+  }
+
+  const yes = await confirm(t('remove.confirm', { name }), false);
+  if (!yes) {
+    console.log(`  ${t('common.cancelled')}`);
+    return;
+  }
+
+  removeProfile(name);
+  success(t('remove.done', { name }));
+
+  if (name === active) {
+    const newActive = getActiveProfile();
+    if (newActive) {
+      success(t('remove.newActive', { name: newActive }));
+    } else {
+      warn(`${t('remove.none')} ${t('hint.add')} cpf add work · ${t('hint.setup')} npx ai-profile-switch@latest init`);
+    }
+  }
+}

package/src/commands/rename.mjs

@@ -0,0 +1,19 @@
+import { color, info, success, warn } from '../lib/ui.mjs';
+import { checkRename, renameProfile } from '../lib/profile.mjs';
+import { t } from '../lib/i18n.mjs';
+
+// warned: the caller already asked to close sessions, so do not say it twice.
+export async function rename(oldName, newName, { warned = false } = {}) {
+  if (!oldName || !newName) throw new Error('Usage: cpf rename <old-name> <new-name>');
+  checkRename(oldName, newName);
+  if (oldName === newName) {
+    info(t('rename.same', { name: oldName }));
+    return;
+  }
+  if (!warned) warn(t('rename.closeSessions', { name: oldName }));
+  renameProfile(oldName, newName);
+  success(t('rename.done', { old: oldName, new: color.bold(newName) }));
+  const kept = process.platform === 'darwin' ? `${t('rename.kept')} ${t('rename.macSignIn')}` : t('rename.kept');
+  console.log(`    ${color.dim(kept)}`);
+  console.log(`    ${t('rename.next', { command: color.cyan('claude'), name: color.bold(newName) })}`);
+}

package/src/commands/share.mjs

@@ -0,0 +1,60 @@
+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';
+import { t } from '../lib/i18n.mjs';
+
+export function reportConflicts(results) {
+  for (const { name, conflicts, missing } of results) {
+    for (const entry of conflicts) {
+      warn(t('share.keptOwn', { name, entry }));
+    }
+    for (const entry of missing) warn(t('share.missing', { name, entry }));
+  }
+}
+
+function status() {
+  const meta = readMeta();
+  const shared = meta.shared ?? [];
+  console.log();
+  console.log(`  ${color.bold(t('share.title'))} ${[...SHARED_FILES, ...SHARED_DIRS, ...shared].join(', ')}`);
+  const more = SHAREABLE_ENTRIES.filter(entry => !shared.includes(entry)).join(', ') || t('share.nothingLeft');
+  console.log(`  ${color.dim(t('share.canAlso', { list: more }))}`);
+  console.log();
+  for (const result of syncShared(meta.profiles, { dryRun: true })) {
+    const problems = [
+      ...result.conflicts.map(entry => color.yellow(t('share.own', { entry }))),
+      ...result.linked.map(entry => t('share.notLinked', { entry })),
+      ...result.missing.map(entry => color.red(t('share.missingShort', { entry }))),
+    ];
+    console.log(`  ${result.name.padEnd(12)} ${problems.length ? problems.join(', ') : color.green(t('share.inSync'))}`);
+  }
+  if (!shared.length) info(t('share.nothingExtra'));
+  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(t('share.usage'));
+  }
+  if (!command || command === 'list') return status();
+  if (command === 'sync') {
+    const results = syncShared();
+    reportConflicts(results);
+    success(t('share.linked', { count: results.reduce((count, result) => count + result.linked.length, 0) }));
+    return;
+  }
+  if (command === 'add') {
+    const results = shareEntry(entry);
+    reportConflicts(results);
+    success(t('share.added', { entry }));
+    return;
+  }
+  if (command === 'remove') {
+    unshareEntry(entry);
+    success(t('share.removed', { entry }));
+    return;
+  }
+  throw new Error(t('share.usage'));
+}

package/src/commands/shell.mjs

@@ -0,0 +1,220 @@
+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 { color, colorFor, intro, meter, outro, success, sym, userError, warn } from '../lib/ui.mjs';
+import { accountInfo } from '../lib/account.mjs';
+import { relativeTime, t } from '../lib/i18n.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(t('shell.refreshed'));
+      return;
+    default:
+      throw new Error('Usage: shell <launch|use|pick|refresh>');
+  }
+}
+
+async function launch(args, selected) {
+  const profile = selected ?? await selectProfile({ launching: true });
+  if (!profile) {
+    process.exitCode = 130;
+    return;
+  }
+  assertRegisteredProfile(profile);
+  const bin = resolveClaudeBinary();
+  if (!bin) {
+    console.error(`${t('launch.notFound')} ${t('launch.install')} 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(t('launch.sharedFailed', { message: err.message })); }
+  // The picker already told a person which account starts; logs still get a plain line.
+  if (!process.stderr.isTTY) 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(t('launch.startFailed', { message: 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(t('use.switched', { profile: name }));
+}
+
+// The claude shell function runs `pick --print` and then launches the printed profile.
+async function pickProfile(printOnly) {
+  const profile = await selectProfile({ launching: printOnly });
+  if (!profile) {
+    process.exitCode = 130;
+    return;
+  }
+  if (getActiveProfile() !== profile) setActiveProfile(profile);
+  if (printOnly) process.stdout.write(profile + '\n');
+}
+
+export function accountSummary({ email, plan }) {
+  return [email, plan].filter(Boolean).join(' · ');
+}
+
+export function usageLine({ usage }) {
+  if (!usage) return color.dim(t('account.noUsage'));
+  const parts = [];
+  if (usage.fiveHour !== null) parts.push(`${t('account.fiveHour')} ${meter(usage.fiveHour)}`);
+  if (usage.weekly !== null) parts.push(`${t('account.weekly')} ${meter(usage.weekly)}`);
+  if (usage.savedAt) parts.push(color.dim(t('account.savedAt', { time: relativeTime(usage.savedAt) })));
+  return parts.join('   ');
+}
+
+// One picker row per profile: name, in use or last used, then account and usage lines.
+export function profileChoices(profiles, active) {
+  const width = Math.max(...profiles.map(name => name.length));
+  return profiles.map(name => profileChoice(name, active, width));
+}
+
+function profileChoice(name, active, width) {
+  const account = accountInfo(name);
+  const hint = name === active
+    ? color.green(`${sym.bulletOn} ${t('picker.inUse')}`)
+    : account.lastUsed ? color.dim(relativeTime(account.lastUsed)) : '';
+  const summary = accountSummary(account);
+  const details = summary
+    ? [color.dim(summary), usageLine(account)]
+    : [color.dim(t('account.notSignedIn'))];
+  return { label: name.padEnd(width), value: name, hint, details, summary };
+}
+
+async function selectProfile({ launching = false } = {}) {
+  const profiles = listProfiles();
+  if (!profiles.length) {
+    throw userError(t('profiles.none'), [
+      { label: t('hint.add'), command: 'cpf add work' },
+      { label: t('hint.setup'), command: 'npx ai-profile-switch@latest init' },
+    ]);
+  }
+  const active = getActiveProfile();
+  const output = process.stderr;
+  colorFor(output);
+  if (!process.stdin.isTTY || profiles.length === 1) {
+    const selected = active ?? profiles[0];
+    assertRegisteredProfile(selected);
+    if (launching && output.isTTY) {
+      const summary = accountSummary(accountInfo(selected));
+      output.write(`${color.green(sym.stepDone)}  ${t('picker.starting', { profile: color.bold(selected) })}${summary ? `  ${color.dim(summary)}` : ''}\n`);
+    }
+    return selected;
+  }
+  const choices = profileChoices(profiles, active);
+  intro('ai-profile-switch', '', output);
+  const selected = await prompt.select(t('picker.question'), choices, {
+    output, initial: profiles.indexOf(active), numbered: true,
+    done: name => {
+      const { summary } = choices.find(choice => choice.value === name);
+      const message = t(launching ? 'picker.starting' : 'picker.switched', { profile: color.bold(name) });
+      return `${message}${summary ? `  ${color.dim(summary)}` : ''}`;
+    },
+  });
+  outro(selected && launching ? t('launch.opening') : '', output);
+  if (selected) assertRegisteredProfile(selected);
+  return selected;
+}
+
+// Declared below; the Windows resolver test runs that part on its own.
+export { resolveClaudeBinary };
+
+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,53 @@
+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 { displayWidth, info, warn, error } from '../lib/ui.mjs';
+import { t } from '../lib/i18n.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(t('update.claudeManaged'));
+    info(t('update.seeSetup'));
+    if (values.check) {
+      warn(t('update.notChecked'));
+      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;
+  }
+  const table = [[t('update.package'), t('update.installed'), t('update.latest')], [self.pkg, self.installed, self.latest]];
+  const widths = [0, 1].map(column => Math.max(...table.map(row => displayWidth(row[column]))) + 3);
+  for (const row of table) console.log(row.map((cell, column) => cell + ' '.repeat(Math.max(0, (widths[column] ?? 0) - displayWidth(cell)))).join('').trimEnd());
+  if (!self.hasUpdate) info(t('update.upToDate'));
+  else if (values.check) info(t('update.runToInstall'));
+  else {
+    const result = await runSelfUpdate({ force: true, computePlan: async () => ({ self }) });
+    if (result.action === 'updated') info(t('update.updated', { version: result.version }));
+    else if (result.reason === 'not-installed') info(t('update.notInstalled'));
+    else if (result.reason === 'busy') { warn(t('update.busy')); process.exitCode = 2; }
+    else if (result.action === 'failed') { error(t('update.failed', { error: 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,16 @@
+import { color, success, info } from '../lib/ui.mjs';
+import { assertRegisteredProfile } from '../lib/profile.mjs';
+import { setActiveProfile, getActiveProfile } from '../lib/config.mjs';
+import { t } from '../lib/i18n.mjs';
+
+export async function use(name) {
+  assertRegisteredProfile(name);
+  const current = getActiveProfile();
+  if (current === name) {
+    info(t('use.already', { profile: name }));
+    return;
+  }
+  setActiveProfile(name);
+  success(t('use.switched', { profile: name }));
+  console.log(`    ${color.dim(t('use.note'))}`);
+}