@ralphkrauss/codex-account-switcher 0.1.0

package/src/cli.ts

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import {
+  CxError,
+  authFileExists,
+  getCodexPaths,
+  inspectDoctor,
+  listAccounts,
+  loginAccount,
+  removeAccount,
+  renameAccount,
+  runCodex,
+  saveAccount,
+  useAccount,
+  validateAccountName,
+  type AccountList,
+  type DoctorReport,
+} from './index.js';
+
+const PACKAGE_NAME = '@ralphkrauss/codex-account-switcher';
+const SUBCOMMANDS = new Set([
+  'doctor',
+  'help',
+  'login',
+  'ls',
+  'rename',
+  'rm',
+  'run',
+  'save',
+  'use',
+]);
+
+interface CliIo {
+  readonly stdout: NodeJS.WritableStream;
+  readonly stderr: NodeJS.WritableStream;
+}
+
+interface ParsedForceArgs {
+  readonly force: boolean;
+  readonly positionals: readonly string[];
+}
+
+function write(stream: NodeJS.WritableStream, text: string): void {
+  stream.write(text.endsWith('\n') ? text : `${text}\n`);
+}
+
+async function readPackageMetadata(): Promise<{ name: string; version: string }> {
+  try {
+    const packageJson = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8')) as {
+      name?: unknown;
+      version?: unknown;
+    };
+    return {
+      name: typeof packageJson.name === 'string' ? packageJson.name : PACKAGE_NAME,
+      version: typeof packageJson.version === 'string' ? packageJson.version : '0.0.0',
+    };
+  } catch {
+    return { name: PACKAGE_NAME, version: '0.0.0' };
+  }
+}
+
+function helpText(metadata: { readonly name: string; readonly version: string }): string {
+  return `cx ${metadata.version} — safe Codex CLI account switcher
+
+Usage:
+  cx ls
+  cx save <name> [--force]
+  cx use <name>
+  cx login <name> [--force]
+  cx rename <old> <new> [--force]
+  cx rm <name>
+  cx run [name] -- [codex args...]
+  cx doctor [--json]
+  cx --help
+  cx --version
+
+Backward-friendly shortcuts:
+  cx <account> [codex args...]   switch to <account>, then run codex
+  cx                             run codex with the current auth.json when present
+
+Data layout:
+  Uses CODEX_HOME when set, otherwise ~/.codex.
+  Accounts are stored as CODEX_HOME/accounts/<name>.json.
+  The active account marker is CODEX_HOME/.current-account.
+
+Account names may contain letters, numbers, dot, underscore, and dash only.`;
+}
+
+function parseForceArgs(args: readonly string[]): ParsedForceArgs {
+  let force = false;
+  const positionals: string[] = [];
+  for (const arg of args) {
+    if (arg === '--force') {
+      force = true;
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      throw new CxError(`unknown option '${arg}'`, 2);
+    }
+    positionals.push(arg);
+  }
+  return { force, positionals };
+}
+
+function requireArity(command: string, positionals: readonly string[], expected: number): void {
+  if (positionals.length !== expected) {
+    throw new CxError(`usage: cx ${command}`, 2);
+  }
+}
+
+function formatAccounts(list: AccountList): string {
+  const lines = [`Codex accounts (home: ${list.home}):`];
+  if (list.accounts.length === 0) {
+    lines.push('  (none yet — run: cx save <name> to register the current login, or cx login <name>)');
+  } else {
+    for (const account of list.accounts) {
+      lines.push(account.active ? `  * ${account.name}  (active)` : `    ${account.name}`);
+    }
+  }
+
+  if (list.currentMarker.state === 'invalid') {
+    lines.push('warning: .current-account is invalid; writeback will be skipped until fixed.');
+  } else if (list.currentMarker.state === 'valid' && list.current === null) {
+    lines.push(`warning: current marker '${list.currentMarker.name}' has no matching stored account.`);
+  }
+
+  return lines.join('\n');
+}
+
+function formatDoctor(report: DoctorReport): string {
+  const current = report.current.state === 'valid'
+    ? `${report.current.name ?? '(none)'} (${report.current.slotExists ? 'slot ok' : 'slot missing'})`
+    : report.current.state;
+  const lines = [
+    'Codex Account Switcher doctor',
+    `package: ${report.packageName}@${report.version}`,
+    `node: ${report.nodeVersion}`,
+    `platform: ${report.platform}`,
+    `codex home: ${report.codexHome}`,
+    `home exists: ${report.homeExists ? 'yes' : 'no'}`,
+    `accounts dir: ${report.accountsDir}`,
+    `accounts dir exists: ${report.accountsDirExists ? 'yes' : 'no'}`,
+    `accounts: ${report.accounts.length === 0 ? '(none)' : report.accounts.join(', ')}`,
+    `current account: ${current}`,
+    `auth.json: ${report.authJson.exists ? `${report.authJson.size} bytes (${report.authJson.looksNonEmpty ? 'usable for save/writeback' : 'too small for save/writeback'})` : 'missing'}`,
+    `codex executable: ${report.codexExecutable ?? 'not found'}`,
+  ];
+
+  if (report.current.reason) {
+    lines.push(`current marker note: ${report.current.reason}`);
+  }
+  if (report.warnings.length > 0) {
+    lines.push('warnings:');
+    for (const warning of report.warnings) {
+      lines.push(`  - ${warning}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+async function printList(io: CliIo, env: NodeJS.ProcessEnv): Promise<void> {
+  write(io.stdout, formatAccounts(await listAccounts(getCodexPaths(env))));
+}
+
+function parseRunArgs(args: readonly string[]): { account: string | null; codexArgs: readonly string[] } {
+  const separatorIndex = args.indexOf('--');
+  if (separatorIndex >= 0) {
+    const beforeSeparator = args.slice(0, separatorIndex);
+    if (beforeSeparator.length > 1) {
+      throw new CxError('usage: cx run [name] -- [codex args...]', 2);
+    }
+    return {
+      account: beforeSeparator[0] ?? null,
+      codexArgs: args.slice(separatorIndex + 1),
+    };
+  }
+
+  if (args.length === 0) {
+    return { account: null, codexArgs: [] };
+  }
+  const [account, ...codexArgs] = args;
+  if (!account || account.startsWith('-')) {
+    throw new CxError("usage: cx run [name] -- [codex args...] (use '--' before codex flags)", 2);
+  }
+  return { account, codexArgs };
+}
+
+export async function main(
+  argv: readonly string[] = process.argv.slice(2),
+  env: NodeJS.ProcessEnv = process.env,
+  io: CliIo = { stdout: process.stdout, stderr: process.stderr },
+): Promise<number> {
+  const metadata = await readPackageMetadata();
+  const [first, ...rest] = argv;
+
+  if (first === '--help' || first === '-h' || first === 'help') {
+    write(io.stdout, helpText(metadata));
+    return 0;
+  }
+
+  if (first === '--version' || first === '-v') {
+    write(io.stdout, metadata.version);
+    return 0;
+  }
+
+  if (!first) {
+    const paths = getCodexPaths(env);
+    if (await authFileExists(paths)) {
+      return await runCodex([], { env });
+    }
+
+    write(io.stdout, helpText(metadata));
+    write(io.stdout, '');
+    write(io.stdout, `No live auth.json found at ${paths.authFile}.`);
+    write(io.stdout, 'Use cx ls, cx use <name>, cx save <name>, or cx login <name>.');
+    write(io.stdout, '');
+    write(io.stdout, formatAccounts(await listAccounts(paths)));
+    return 0;
+  }
+
+  if (!SUBCOMMANDS.has(first)) {
+    if (first.startsWith('-')) {
+      throw new CxError(`unknown option '${first}'`, 2);
+    }
+
+    validateAccountName(first);
+    await useAccount(first, { paths: getCodexPaths(env) });
+    write(io.stdout, `→ codex on '${first}'`);
+    return await runCodex(rest, { env });
+  }
+
+  switch (first) {
+    case 'ls': {
+      if (rest.length > 0) {
+        throw new CxError('usage: cx ls', 2);
+      }
+      await printList(io, env);
+      return 0;
+    }
+
+    case 'save': {
+      const parsed = parseForceArgs(rest);
+      requireArity('save <name> [--force]', parsed.positionals, 1);
+      const name = parsed.positionals[0] ?? '';
+      await saveAccount(name, { force: parsed.force, paths: getCodexPaths(env) });
+      write(io.stdout, `saved current login as '${name}'`);
+      return 0;
+    }
+
+    case 'use': {
+      requireArity('use <name>', rest, 1);
+      const name = rest[0] ?? '';
+      await useAccount(name, { paths: getCodexPaths(env) });
+      write(io.stdout, `active codex account: ${name}`);
+      return 0;
+    }
+
+    case 'login': {
+      const parsed = parseForceArgs(rest);
+      requireArity('login <name> [--force]', parsed.positionals, 1);
+      const name = parsed.positionals[0] ?? '';
+      await loginAccount(name, { force: parsed.force, env, paths: getCodexPaths(env) });
+      write(io.stdout, `logged in and saved as '${name}'`);
+      return 0;
+    }
+
+    case 'rename': {
+      const parsed = parseForceArgs(rest);
+      requireArity('rename <old> <new> [--force]', parsed.positionals, 2);
+      const oldName = parsed.positionals[0] ?? '';
+      const newName = parsed.positionals[1] ?? '';
+      await renameAccount(oldName, newName, { force: parsed.force, paths: getCodexPaths(env) });
+      write(io.stdout, `renamed '${oldName}' -> '${newName}'`);
+      return 0;
+    }
+
+    case 'rm': {
+      requireArity('rm <name>', rest, 1);
+      const name = rest[0] ?? '';
+      const result = await removeAccount(name, { paths: getCodexPaths(env) });
+      write(io.stdout, `removed '${name}'`);
+      if (result.wasActive) {
+        write(io.stderr, `warning: '${name}' was active; live auth.json was left in place until you switch or login.`);
+      }
+      return 0;
+    }
+
+    case 'run': {
+      const parsed = parseRunArgs(rest);
+      if (parsed.account) {
+        await useAccount(parsed.account, { paths: getCodexPaths(env) });
+        write(io.stdout, `→ codex on '${parsed.account}'`);
+      }
+      return await runCodex(parsed.codexArgs, { env });
+    }
+
+    case 'doctor': {
+      const json = rest.length === 1 && rest[0] === '--json';
+      if (rest.length > (json ? 1 : 0)) {
+        throw new CxError('usage: cx doctor [--json]', 2);
+      }
+      const report = await inspectDoctor({ packageName: metadata.name, version: metadata.version }, env);
+      write(io.stdout, json ? JSON.stringify(report, null, 2) : formatDoctor(report));
+      return 0;
+    }
+
+    default:
+      throw new CxError(`unknown command '${first}'`, 2);
+  }
+}
+
+function isEntrypoint(): boolean {
+  const invokedPath = process.argv[1];
+  if (!invokedPath) {
+    return false;
+  }
+
+  try {
+    return realpathSync(invokedPath) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return import.meta.url === pathToFileURL(invokedPath).href;
+  }
+}
+
+if (isEntrypoint()) {
+  try {
+    process.exitCode = await main();
+  } catch (error) {
+    if (error instanceof CxError) {
+      write(process.stderr, error.message);
+      process.exitCode = error.exitCode;
+    } else if (error instanceof Error) {
+      write(process.stderr, error.message);
+      process.exitCode = 1;
+    } else {
+      write(process.stderr, String(error));
+      process.exitCode = 1;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+export {
+  ACCOUNT_NAME_PATTERN,
+  AUTH_NON_EMPTY_BYTES,
+  CxError,
+  accountPathForName,
+  authFileExists,
+  authLooksNonEmpty,
+  getCodexHome,
+  getCodexPaths,
+  inspectDoctor,
+  listAccountNames,
+  listAccounts,
+  loginAccount,
+  readCurrentMarker,
+  removeAccount,
+  renameAccount,
+  resolveExecutable,
+  runCodex,
+  saveAccount,
+  switchAndRunCodex,
+  useAccount,
+  validateAccountName,
+  writebackCurrentAccount,
+} from './accounts.js';
+
+export type {
+  AccountEntry,
+  AccountList,
+  CodexPaths,
+  CurrentMarker,
+  DoctorReport,
+  ForceOptions,
+  OperationOptions,
+  RemoveResult,
+  RenameResult,
+  SpawnCodexOptions,
+  WritebackResult,
+} from './accounts.js';