ai-profile-switch 2.2.0 → 2.2.2

package/src/commands/rename.mjs

@@ -1,14 +1,19 @@
-import { info, success, warn } from '../lib/ui.mjs';
-import { renameProfile } from '../lib/profile.mjs';
+import { color, info, success, warn } from '../lib/ui.mjs';
+import { checkRename, renameProfile } from '../lib/profile.mjs';
+import { t } from '../lib/i18n.mjs';
 
-export async function rename(oldName, newName) {
+// 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>');
-  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.');
-    }
+  checkRename(oldName, newName);
+  if (oldName === newName) {
+    info(t('rename.same', { name: oldName }));
+    return;
   }
-  if (renameProfile(oldName, newName)) success(`Renamed profile: ${oldName} → ${newName}`);
-  else info(`"${oldName}" already has that name`);
+  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

@@ -2,13 +2,14 @@ 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(`${name}: kept its own ${entry} because it differs from the shared copy. Move or delete it, then run cpf share sync.`);
+      warn(t('share.keptOwn', { name, entry }));
     }
-    for (const entry of missing) warn(`${name}: shared ${entry} is missing from _shared.`);
+    for (const entry of missing) warn(t('share.missing', { name, entry }));
   }
 }
 
@@ -16,43 +17,44 @@ 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(`  ${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(`own ${entry}`)),
-      ...result.linked.map(entry => `${entry} not linked yet`),
-      ...result.missing.map(entry => color.red(`${entry} missing`)),
+      ...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('in sync')}`);
+    console.log(`  ${result.name.padEnd(12)} ${problems.length ? problems.join(', ') : color.green(t('share.inSync'))}`);
   }
-  if (!shared.length) info('Nothing extra is shared yet. Example: cpf share add CLAUDE.md');
+  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('Usage: cpf share [list | add <entry> | remove <entry> | sync]');
+    throw new Error(t('share.usage'));
   }
   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.`);
+    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(`Sharing ${entry} through ~/.claude-profiles/_shared/${entry}`);
+    success(t('share.added', { entry }));
     return;
   }
   if (command === 'remove') {
     unshareEntry(entry);
-    success(`Stopped sharing ${entry}. Each profile kept its own copy.`);
+    success(t('share.removed', { entry }));
     return;
   }
-  throw new Error('Usage: cpf share [list | add <entry> | remove <entry> | sync]');
+  throw new Error(t('share.usage'));
 }

package/src/commands/shell.mjs

@@ -6,7 +6,9 @@ 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 { color, colorFor, intro, meter, outro, success, sym, userError, warn } from '../lib/ui.mjs';
+import { accountInfo, refreshUsage } 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';
@@ -37,7 +39,7 @@ export async function shell(argv = []) {
     case 'refresh':
       if (args.length) throw new Error('Usage: shell refresh');
       installAllShells();
-      success('Shell integration refreshed.');
+      success(t('shell.refreshed'));
       return;
     default:
       throw new Error('Usage: shell <launch|use|pick|refresh>');
@@ -45,7 +47,7 @@ export async function shell(argv = []) {
 }
 
 async function launch(args, selected) {
-  const profile = selected ?? await selectProfile();
+  const profile = selected ?? await selectProfile({ launching: true });
   if (!profile) {
     process.exitCode = 130;
     return;
@@ -53,15 +55,16 @@ async function launch(args, selected) {
   assertRegisteredProfile(profile);
   const bin = resolveClaudeBinary();
   if (!bin) {
-    console.error('Claude Code executable not found. See https://code.claude.com/docs/en/setup');
+    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(`Shared items not linked: ${err.message}`); }
-  process.stderr.write(`[ai-profile-switch] Profile: ${profile}\n`);
+  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 => {
@@ -80,7 +83,7 @@ async function launch(args, selected) {
     };
     child.once('error', err => {
       cleanup();
-      console.error(`Could not start Claude Code: ${err.message}`);
+      console.error(t('launch.startFailed', { message: err.message }));
       resolve(1);
     });
     child.once('close', (code, signal) => {
@@ -94,31 +97,91 @@ async function launch(args, selected) {
 function useProfile(name) {
   assertRegisteredProfile(name);
   if (getActiveProfile() !== name) setActiveProfile(name);
-  success(`Switched to profile: ${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();
+  const profile = await selectProfile({ launching: printOnly });
   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() {
+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 = [];
+  const reset = key => (usage.reset?.[key] ? ` ${color.dim(t('account.reset'))}` : '');
+  if (usage.fiveHour !== null) parts.push(`${t('account.fiveHour')} ${meter(usage.fiveHour)}${reset('fiveHour')}`);
+  if (usage.weekly !== null) parts.push(`${t('account.weekly')} ${meter(usage.weekly)}${reset('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 new Error('No profiles found. Run cpf to add one, or npx ai-profile-switch@latest init to import existing Claude settings.');
+  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 selected = !process.stdin.isTTY || profiles.length === 1
-    ? (active ?? profiles[0])
-    : await prompt.select('Select a profile:', profiles, { output: process.stderr, initial: profiles.indexOf(active) });
+  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;
+  }
+  await refreshUsage(profiles);
+  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);

package/src/commands/update.mjs

@@ -3,7 +3,8 @@ 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';
+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: {
@@ -14,10 +15,10 @@ export async function update(args = []) {
   } });
   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');
+    info(t('update.claudeManaged'));
+    info(t('update.seeSetup'));
     if (values.check) {
-      warn('Claude Code update status was not checked.');
+      warn(t('update.notChecked'));
       process.exitCode = 2;
     }
     if (!values.self) return;
@@ -35,16 +36,18 @@ export async function update(args = []) {
     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.');
+  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(`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 (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

@@ -1,14 +1,16 @@
-import { success, info } from '../lib/ui.mjs';
+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(`"${name}" is already the active profile`);
+    info(t('use.already', { profile: name }));
     return;
   }
   setActiveProfile(name);
-  success(`Switched to profile: ${name}`);
+  success(t('use.switched', { profile: name }));
+  console.log(`    ${color.dim(t('use.note'))}`);
 }

package/src/index.mjs

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { error, color } from './lib/ui.mjs';
+import { t } from './lib/i18n.mjs';
 
 const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'));
 
@@ -10,12 +11,14 @@ const COMMANDS = {
   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)),
+  login: args => import('./commands/login.mjs').then(m => m.login(args[0])),
   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)),
+  language: args => import('./commands/language.mjs').then(m => m.language(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)),
@@ -26,54 +29,29 @@ const USAGE = {
   add: 'add <name>',
   remove: 'remove <name>',
   rename: 'rename <old-name> <new-name>',
+  login: 'login <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]',
+  language: 'language [auto | en | ko]',
   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 };
+const POSITIONAL_COUNTS = { init: 0, add: 1, remove: 1, rename: 2, login: 1, list: 0, use: 1, 'install-shell': 0 };
+
+const COMMAND_NOTES = { login: 'index.helpLogin', rename: 'index.helpRename', remove: 'index.helpRemove', add: 'index.helpAdd', use: 'index.helpUse' };
 
 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.');
+    console.log(t('index.usage', { usage: USAGE[command] }));
+    if (Object.hasOwn(COMMAND_NOTES, command)) console.log(t(COMMAND_NOTES[command]));
     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.
-`);
+  console.log(t('index.help', { title: color.bold('ai-profile-switch') }));
 }
 
 export async function run(argv) {
@@ -88,7 +66,7 @@ export async function run(argv) {
     return;
   }
   if (!Object.hasOwn(COMMANDS, command)) {
-    error(`Unknown command: ${command}`);
+    error(t('index.unknown', { command }));
     showHelp();
     process.exitCode = 1;
     return;
@@ -104,11 +82,11 @@ export async function run(argv) {
     }
     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]}`);
+      throw new Error(t('index.usage', { usage: USAGE[command] }));
     }
     await COMMANDS[command](args);
   } catch (err) {
-    error(err.message);
+    error(err.message, err.hints);
     process.exitCode = 1;
   }
 }

package/src/lib/account.mjs

@@ -0,0 +1,122 @@
+// Reads what Claude Code saved in a profile, for display only. Nothing is written,
+// and any field with an unexpected shape is left out instead of failing.
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { PROFILES_DIR } from './constants.mjs';
+
+const PLANS = { claude_max: 'Max', claude_pro: 'Pro', claude_team: 'Team', claude_enterprise: 'Enterprise' };
+
+function readConfig(dir) {
+  try {
+    const config = JSON.parse(readFileSync(join(dir, '.claude.json'), 'utf8'));
+    return config && typeof config === 'object' ? config : {};
+  } catch {
+    return {};
+  }
+}
+
+function percent(window) {
+  const value = window?.utilization;
+  return typeof value === 'number' && Number.isFinite(value) ? Math.min(100, Math.max(0, Math.round(value))) : null;
+}
+
+// A window whose reset time has passed starts again from zero.
+function hasReset(window, now) {
+  const resetsAt = typeof window?.resets_at === 'string' ? Date.parse(window.resets_at) : NaN;
+  return Number.isFinite(resetsAt) && resetsAt <= now;
+}
+
+// Claude Code keeps usage in an undocumented cache; it may change or disappear.
+function usage(cached, account, now = Date.now()) {
+  if (!cached || typeof cached !== 'object') return null;
+  if (typeof cached.accountUuid === 'string' && typeof account.accountUuid === 'string'
+    && cached.accountUuid !== account.accountUuid) return null;
+  const windows = { fiveHour: cached.utilization?.five_hour, weekly: cached.utilization?.seven_day };
+  const reset = { fiveHour: false, weekly: false };
+  const values = {};
+  for (const [key, window] of Object.entries(windows)) {
+    values[key] = percent(window);
+    if (values[key] !== null && hasReset(window, now)) [values[key], reset[key]] = [0, true];
+  }
+  if (values.fiveHour === null && values.weekly === null) return null;
+  const savedAt = Number.isFinite(cached.fetchedAtMs) ? cached.fetchedAtMs : null;
+  return { fiveHour: values.fiveHour, weekly: values.weekly, savedAt, reset };
+}
+
+// Usage fetched in this run, by profile name. It wins over the saved cache.
+const live = new Map();
+const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const FRESH_MS = 60_000;
+
+// Claude Code stores each config folder's sign-in under a keychain item named
+// after the folder path; elsewhere, or without a keychain, in .credentials.json.
+function keychainService(dir) {
+  return `Claude Code-credentials-${createHash('sha256').update(dir).digest('hex').slice(0, 8)}`;
+}
+
+function readKeychain(dir) {
+  return new Promise(resolve => {
+    execFile('security', ['find-generic-password', '-s', keychainService(dir), '-w'], { timeout: 1000 },
+      (err, stdout) => resolve(err ? null : stdout));
+  });
+}
+
+async function readCredentials(dir) {
+  const fromKeychain = process.platform === 'darwin' ? await readKeychain(dir) : null;
+  return fromKeychain ?? readFile(join(dir, '.credentials.json'), 'utf8').catch(() => null);
+}
+
+// An expired token is skipped, not refreshed: refreshing could sign Claude Code out.
+function accessToken(raw, now) {
+  try {
+    const oauth = JSON.parse(raw)?.claudeAiOauth;
+    if (typeof oauth?.accessToken !== 'string' || !oauth.accessToken) return null;
+    if (Number.isFinite(oauth.expiresAt) && oauth.expiresAt <= now + FRESH_MS) return null;
+    return oauth.accessToken;
+  } catch {
+    return null;
+  }
+}
+
+// Asks the usage API for each signed-in profile at once. Anything slow or failing
+// keeps the saved value, so the screen never waits more than timeoutMs.
+export async function refreshUsage(names, { read = readCredentials, request = fetch, timeoutMs = 1500 } = {}) {
+  const now = Date.now();
+  const signal = AbortSignal.timeout(timeoutMs);
+  const due = names.filter(name => !(now - (live.get(name)?.fetchedAtMs ?? 0) < FRESH_MS)
+    && readConfig(join(PROFILES_DIR, name)).oauthAccount);
+  const fetchOne = async name => {
+    try {
+      const token = accessToken(await read(join(PROFILES_DIR, name)), now);
+      if (!token || signal.aborted) return;
+      const response = await request(USAGE_URL, {
+        headers: { Authorization: `Bearer ${token}`, 'anthropic-beta': 'oauth-2025-04-20' }, signal,
+      });
+      const utilization = response.ok ? await response.json() : null;
+      if (utilization && typeof utilization === 'object' && !signal.aborted) {
+        live.set(name, { utilization, fetchedAtMs: Date.now() });
+      }
+    } catch { /* keep the saved value */ }
+  };
+  let timer;
+  const deadline = new Promise(resolve => { timer = setTimeout(resolve, timeoutMs); });
+  await Promise.race([Promise.all(due.map(fetchOne)), deadline]);
+  clearTimeout(timer);
+}
+
+export function accountInfo(name) {
+  const dir = join(PROFILES_DIR, name);
+  const config = readConfig(dir);
+  const account = config.oauthAccount && typeof config.oauthAccount === 'object' ? config.oauthAccount : {};
+  let lastUsed = null;
+  try { lastUsed = statSync(join(dir, 'history.jsonl')).mtimeMs; } catch { /* never used */ }
+  return {
+    email: typeof account.emailAddress === 'string' && account.emailAddress ? account.emailAddress : null,
+    plan: Object.hasOwn(PLANS, account.organizationType) ? PLANS[account.organizationType] : null,
+    usage: usage(live.get(name) ?? config.cachedUsageUtilization, account),
+    lastUsed,
+  };
+}

package/src/lib/config.mjs

@@ -1,5 +1,5 @@
 import {
-  META_FILE, PROFILE_NAME_REGEX, PROFILE_NAME_MAX_LENGTH, RESERVED_NAMES, SHAREABLE_ENTRIES,
+  LANGUAGES, META_FILE, PROFILE_NAME_REGEX, PROFILE_NAME_MAX_LENGTH, RESERVED_NAMES, SHAREABLE_ENTRIES,
 } from './constants.mjs';
 import { readJsonFile, writeJsonFile } from './json-fs.mjs';
 
@@ -19,6 +19,7 @@ export function readMeta() {
     || new Set(meta.profiles).size !== meta.profiles.length
     || (meta.activeProfile !== null && !meta.profiles.includes(meta.activeProfile))
     || typeof meta.shareSettings !== 'boolean'
+    || (meta.language !== undefined && !LANGUAGES.includes(meta.language))
     || (meta.shared !== undefined && (!Array.isArray(meta.shared)
       || meta.shared.some(entry => !SHAREABLE_ENTRIES.includes(entry))
       || new Set(meta.shared).size !== meta.shared.length))) {
@@ -61,6 +62,12 @@ export function setSharedEntries(entries) {
   writeMeta({ ...meta, shared: entries });
 }
 
+// null clears the choice so the system language is used again.
+export function setLanguagePreference(language) {
+  const { language: _previous, ...meta } = readMeta();
+  writeMeta(language ? { ...meta, language } : meta);
+}
+
 export function removeProfileFromMeta(name) {
   const meta = readMeta();
   meta.profiles = meta.profiles.filter(p => p !== name);

package/src/lib/constants.mjs

@@ -38,3 +38,7 @@ export const SHAREABLE_FILES = ['CLAUDE.md', 'keybindings.json'];
 export const ACCOUNT_SKILL_ENTRIES = ['synced'];
 
 export const SELF_PKG = 'ai-profile-switch';
+
+// Screen languages; English is the fallback for anything missing.
+export const LANGUAGES = ['en', 'ko'];
+export const LANGUAGE_ENV = 'AI_PROFILE_SWITCH_LANG';