codexuse-cli 2.1.0 → 2.2.0

package/README.md

@@ -8,9 +8,11 @@ npm install -g codexuse-cli
 Commands:
 ```bash
 codexuse profile list
+codexuse profile list --no-usage
+codexuse profile list --compact
 codexuse profile current
-codexuse profile add <name>
-codexuse profile refresh <name>
+codexuse profile add <name> [--skip-login] [--device-auth] [--login=browser|device]
+codexuse profile refresh <name> [--skip-login] [--device-auth] [--login=browser|device]
 codexuse profile switch <name>
 codexuse profile delete <name>
 codexuse profile rename <old> <new>
@@ -21,5 +23,9 @@ codexuse license activate <license-key>
 
 Notes:
 - Requires Codex CLI on PATH for `profile add` / `refresh` (runs `codex login`).
+- `profile list` reads live rate-limit usage via Codex CLI by default.
+- Use `--no-usage` to skip rate-limit fetch.
+- Use `--compact` for names only.
+- On headless/SSH, login defaults to device auth. Override with `--login=browser`.
 - Use `--skip-login` if you already ran `codex login`.
 - License state stored in `~/.codex/settings.json` (shared with desktop app).

package/dist/index.js

@@ -747,6 +747,9 @@ function parseCodexCliChannel(value) {
   }
   return KNOWN_CHANNELS.has(normalized) ? normalized : null;
 }
+function normalizeCodexCliChannel(value, fallback = "stable") {
+  return parseCodexCliChannel(value) ?? fallback;
+}
 
 // ../../lib/codex-settings.ts
 var KEY_LAST_PROFILE_NAME = "last_profile_name";
@@ -1076,6 +1079,10 @@ async function persistLicense(license) {
   }
   await setCodexSettings(settings);
 }
+async function getCodexCliChannel() {
+  const settings = await getCodexSettings();
+  return normalizeCodexCliChannel(settings.cliChannel);
+}
 
 // ../../lib/profile-manager.ts
 var TOKEN_EXPIRING_SOON_WINDOW_MS = 15 * 60 * 1e3;
@@ -3216,9 +3223,30 @@ function buildCodexCommand(codexPath, args) {
   const useShell = process.platform === "win32";
   return { command: codexPath, args, shell: useShell };
 }
-async function runCodexLogin() {
+function isHeadless() {
+  if (process.env.CODEXUSE_HEADLESS === "1") return true;
+  if (process.env.CI) return true;
+  if (process.env.SSH_CONNECTION || process.env.SSH_TTY) return true;
+  if (process.platform === "linux") {
+    if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return true;
+  }
+  return false;
+}
+function resolveLoginMode(preferred) {
+  if (preferred === "browser" || preferred === "device") {
+    return preferred;
+  }
+  const envMode = process.env.CODEXUSE_LOGIN_MODE;
+  if (envMode === "browser" || envMode === "device") {
+    return envMode;
+  }
+  return isHeadless() ? "device" : "browser";
+}
+async function runCodexLogin(mode) {
   const codexPath = requireCodexBinary("Codex CLI is required to login.");
-  const { command, args, shell } = buildCodexCommand(codexPath, ["login"]);
+  const resolvedMode = resolveLoginMode(mode ?? null);
+  const loginArgs = resolvedMode === "device" ? ["login", "--device-auth"] : ["login"];
+  const { command, args, shell } = buildCodexCommand(codexPath, loginArgs);
   const child = (0, import_node_child_process.spawn)(command, args, {
     stdio: "inherit",
     env: process.env,
@@ -3232,16 +3260,270 @@ async function runCodexLogin() {
   }
 }
 
+// ../../lib/codex-rpc.ts
+var import_node_child_process2 = require("child_process");
+var import_node_readline = __toESM(require("readline"));
+var import_node_events = require("events");
+var import_node_fs6 = require("fs");
+var import_node_os = __toESM(require("os"));
+var import_node_path6 = __toESM(require("path"));
+
+// ../../lib/codex-cli.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = __toESM(require("path"));
+var cachedStatus = null;
+var cachedChannel = null;
+function fileExists2(candidate) {
+  if (!candidate) {
+    return null;
+  }
+  const normalized = import_node_path5.default.resolve(candidate);
+  try {
+    const stats = (0, import_node_fs5.statSync)(normalized);
+    if (stats.isFile()) {
+      return normalized;
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveBundledCodexBinary(channel) {
+  const candidates = [];
+  const processWithResources = process;
+  const resourcesPath = processWithResources.resourcesPath;
+  const packageSegments = channel === "alpha" ? ["@openai", "codex-alpha"] : ["@openai", "codex"];
+  if (resourcesPath) {
+    candidates.push(
+      import_node_path5.default.join(resourcesPath, "app.asar.unpacked", "node_modules", ...packageSegments, "bin", "codex.js")
+    );
+    candidates.push(
+      import_node_path5.default.join(resourcesPath, "app.asar.unpacked", "node_modules", ...packageSegments, "bin", "codex")
+    );
+  }
+  const projectRoot = process.cwd();
+  candidates.push(import_node_path5.default.join(projectRoot, "node_modules", ...packageSegments, "bin", "codex.js"));
+  candidates.push(import_node_path5.default.join(projectRoot, "node_modules", ...packageSegments, "bin", "codex"));
+  for (const candidate of candidates) {
+    const resolved = fileExists2(candidate);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function resolveBundledCodexBinaryWithFallback(requestedChannel) {
+  const direct = resolveBundledCodexBinary(requestedChannel);
+  if (direct) {
+    return { path: direct, resolvedChannel: requestedChannel, fallbackUsed: false };
+  }
+  if (requestedChannel === "alpha") {
+    const stable = resolveBundledCodexBinary("stable");
+    if (stable) {
+      return { path: stable, resolvedChannel: "stable", fallbackUsed: true };
+    }
+  }
+  return { path: null, resolvedChannel: null, fallbackUsed: false };
+}
+function buildUnavailableStatus(channel) {
+  const channelLabel = channel === "alpha" ? "alpha " : "";
+  const channelSuffix = channel === "alpha" ? " Switch to Stable in Settings or reinstall CodexUse to restore the CLI." : " Reinstall CodexUse to restore the CLI.";
+  return {
+    available: false,
+    path: null,
+    reason: `Bundled ${channelLabel}Codex CLI is missing.${channelSuffix}`,
+    source: null,
+    channel,
+    requestedChannel: channel,
+    fallbackUsed: false
+  };
+}
+function evaluateCodexCliStatus(requestedChannel) {
+  const resolved = resolveBundledCodexBinaryWithFallback(requestedChannel);
+  if (resolved.path && resolved.resolvedChannel) {
+    return {
+      available: true,
+      path: resolved.path,
+      reason: null,
+      source: "bundled",
+      channel: resolved.resolvedChannel,
+      requestedChannel,
+      fallbackUsed: resolved.fallbackUsed
+    };
+  }
+  return buildUnavailableStatus(requestedChannel);
+}
+async function refreshCodexStatus() {
+  const channel = await getCodexCliChannel();
+  cachedChannel = channel;
+  cachedStatus = evaluateCodexCliStatus(channel);
+  return { ...cachedStatus };
+}
+var CodexCliMissingError = class extends Error {
+  constructor(status, message) {
+    super(message ?? status.reason ?? "Codex CLI is not available");
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "CodexCliMissingError";
+    this.status = { ...status };
+  }
+};
+async function requireCodexCli() {
+  const status = await refreshCodexStatus();
+  if (!status.available || !status.path) {
+    throw new CodexCliMissingError(status);
+  }
+  return status.path;
+}
+
+// ../../lib/codex-rpc.ts
+var RPC_TIMEOUT_MS = 1e4;
+async function sendPayload(child, payload) {
+  child.stdin?.write(JSON.stringify(payload));
+  child.stdin?.write("\n");
+}
+async function readMessage(rl, timeoutMs) {
+  const timeout = new Promise((_, reject) => {
+    const timer = setTimeout(() => {
+      clearTimeout(timer);
+      reject(new Error("codex RPC timed out"));
+    }, timeoutMs);
+  });
+  const linePromise = (0, import_node_events.once)(rl, "line").then((args) => args[0]);
+  const line = await Promise.race([linePromise, timeout]);
+  try {
+    return JSON.parse(line);
+  } catch {
+    throw new Error("codex RPC returned malformed JSON");
+  }
+}
+function toWindow(rpc) {
+  if (!rpc) return void 0;
+  const usedPercent = typeof rpc.usedPercent === "number" && Number.isFinite(rpc.usedPercent) ? rpc.usedPercent : void 0;
+  const windowMinutes = typeof rpc.windowDurationMins === "number" && Number.isFinite(rpc.windowDurationMins) ? rpc.windowDurationMins : void 0;
+  let resetsAt;
+  let resetsInSeconds;
+  if (typeof rpc.resetsAt === "number" && Number.isFinite(rpc.resetsAt)) {
+    const ms = rpc.resetsAt > 1e10 ? rpc.resetsAt : rpc.resetsAt * 1e3;
+    resetsAt = new Date(ms).toISOString();
+    resetsInSeconds = Math.max(0, Math.round((ms - Date.now()) / 1e3));
+  }
+  if (typeof usedPercent === "undefined" && typeof windowMinutes === "undefined" && typeof resetsAt === "undefined") {
+    return void 0;
+  }
+  const window = {};
+  if (typeof usedPercent === "number") {
+    window.usedPercent = usedPercent;
+  }
+  if (typeof windowMinutes === "number") {
+    window.windowMinutes = windowMinutes;
+  }
+  if (typeof resetsAt === "string") {
+    window.resetsAt = resetsAt;
+  }
+  if (typeof resetsInSeconds === "number") {
+    window.resetsInSeconds = resetsInSeconds;
+  }
+  return window;
+}
+async function fetchRateLimitsViaRpc(envOverride, options = {}) {
+  const binaryPath = options.codexPath ?? await requireCodexCli();
+  const tempHome = await import_node_fs6.promises.mkdtemp(import_node_path6.default.join(import_node_os.default.tmpdir(), "codex-rpc-"));
+  const sourceAuthPath = options.authPath ?? (envOverride?.CODEX_HOME ? import_node_path6.default.join(envOverride.CODEX_HOME, "auth.json") : import_node_path6.default.join(
+    envOverride?.HOME ?? process.env.HOME ?? process.env.USERPROFILE ?? import_node_os.default.homedir(),
+    ".codex",
+    "auth.json"
+  ));
+  try {
+    const authContent = await import_node_fs6.promises.readFile(sourceAuthPath, "utf8").catch(() => null);
+    if (!authContent) {
+      return null;
+    }
+    await import_node_fs6.promises.writeFile(import_node_path6.default.join(tempHome, "auth.json"), authContent, "utf8");
+  } catch {
+    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    });
+    return null;
+  }
+  const child = (0, import_node_child_process2.spawn)(process.execPath, [binaryPath, "-s", "read-only", "-a", "untrusted", "app-server"], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      ...envOverride ?? {},
+      HOME: tempHome,
+      USERPROFILE: tempHome,
+      CODEX_HOME: tempHome,
+      CODEX_TELEMETRY_LABEL: "codex-rpc",
+      ELECTRON_RUN_AS_NODE: "1"
+    }
+  });
+  const rl = import_node_readline.default.createInterface({
+    input: child.stdout,
+    crlfDelay: Infinity
+  });
+  try {
+    await sendPayload(child, {
+      id: 1,
+      method: "initialize",
+      params: { clientInfo: { name: "codexuse", version: "0.0.0" } }
+    });
+    await readMessage(rl, RPC_TIMEOUT_MS);
+    await sendPayload(child, { method: "initialized", params: {} });
+    await sendPayload(child, { id: 2, method: "account/rateLimits/read", params: {} });
+    const message = await readMessage(rl, RPC_TIMEOUT_MS);
+    const result = message.result;
+    const limits = result?.rateLimits;
+    const primary = toWindow(limits?.primary ?? null);
+    const secondary = toWindow(limits?.secondary ?? null);
+    if (!primary && !secondary) {
+      return null;
+    }
+    const snapshot = {
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      source: "codex-rpc"
+    };
+    if (primary) {
+      snapshot.primary = primary;
+    }
+    if (secondary) {
+      snapshot.secondary = secondary;
+    }
+    return snapshot;
+  } finally {
+    child.kill();
+    rl.close();
+    await import_node_fs6.promises.rm(tempHome, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+
+// ../../lib/rate-limit-notifier.ts
+var DEFAULT_APPROACH_COOLDOWN_MS = 30 * 60 * 1e3;
+var DEFAULT_RESET_COOLDOWN_MS = 5 * 60 * 1e3;
+var APPROACH_RENOTIFY_FLOOR_MS = 2 * 60 * 1e3;
+var RESET_WINDOW_BUCKET_MS = 5 * 60 * 1e3;
+function maxUsedPercent(snapshot) {
+  if (!snapshot) {
+    return null;
+  }
+  const candidates = [
+    snapshot.primary?.usedPercent,
+    snapshot.secondary?.usedPercent
+  ].filter((value) => typeof value === "number" && Number.isFinite(value));
+  if (candidates.length === 0) {
+    return null;
+  }
+  return Math.max(...candidates);
+}
+
 // src/index.ts
-var VERSION = true ? "2.1.0" : "0.0.0";
+var VERSION = true ? "2.2.0" : "0.0.0";
 function printHelp() {
   console.log(`CodexUse CLI v${VERSION}
 
 Usage:
-  codexuse profile list
+  codexuse profile list [--no-usage] [--compact]
   codexuse profile current
-  codexuse profile add <name> [--skip-login]
-  codexuse profile refresh <name> [--skip-login]
+  codexuse profile add <name> [--skip-login] [--device-auth] [--login=browser|device]
+  codexuse profile refresh <name> [--skip-login] [--device-auth] [--login=browser|device]
   codexuse profile switch <name>
   codexuse profile delete <name>
   codexuse profile rename <old> <new>
@@ -3252,6 +3534,10 @@ Usage:
 Flags:
   -h, --help       Show help
   -v, --version    Show version
+  --no-usage       Skip rate-limit usage fetch
+  --compact        Names only
+  --device-auth    Use device auth for Codex login
+  --login=MODE     Login mode: browser | device
 `);
 }
 function hasFlag(args, flag) {
@@ -3260,12 +3546,238 @@ function hasFlag(args, flag) {
 function stripFlags(args) {
   return args.filter((arg) => !arg.startsWith("-"));
 }
+function parseLoginMode(flags) {
+  if (flags.includes("--device-auth")) return "device";
+  const explicit = flags.find((flag) => flag.startsWith("--login="));
+  if (!explicit) return null;
+  const value = explicit.split("=")[1];
+  if (value === "browser" || value === "device") {
+    return value;
+  }
+  return null;
+}
 function formatProfileLabel(name, displayName) {
   if (displayName && displayName.trim() && displayName !== name) {
     return `${displayName} (${name})`;
   }
   return name;
 }
+function toTitleCase(value) {
+  return value.replace(/\w\S*/g, (word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+}
+function formatShortDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  if (typeof Intl !== "undefined" && Intl.DateTimeFormat) {
+    return new Intl.DateTimeFormat(void 0, { month: "short", day: "numeric" }).format(date);
+  }
+  return date.toLocaleDateString();
+}
+function formatRelativeTime(value) {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return null;
+  const diffMs = parsed - Date.now();
+  const absMs = Math.abs(diffMs);
+  if (absMs < 6e4) {
+    return null;
+  }
+  const minutes = Math.round(absMs / 6e4);
+  if (minutes < 60) {
+    return diffMs >= 0 ? `in ${minutes}m` : `${minutes}m ago`;
+  }
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) {
+    return diffMs >= 0 ? `in ${hours}h` : `${hours}h ago`;
+  }
+  const days = Math.round(hours / 24);
+  return diffMs >= 0 ? `in ${days}d` : `${days}d ago`;
+}
+function formatOrganizations(organizations) {
+  if (!organizations || !Array.isArray(organizations) || organizations.length === 0) {
+    return null;
+  }
+  const parts = organizations.map((org) => {
+    if (!org) return null;
+    const name = org.title || org.id;
+    if (!name) return null;
+    return org.role ? `${name} (${org.role})` : name;
+  }).filter((value) => Boolean(value));
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+function formatWindowLabel(windowMinutes) {
+  if (typeof windowMinutes !== "number" || Number.isNaN(windowMinutes)) {
+    return null;
+  }
+  if (windowMinutes >= 2880) {
+    const days = windowMinutes / 1440;
+    const rounded = Math.round(days * 10) / 10;
+    const display = Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1);
+    return `${display.replace(/\.0$/, "")}d window`;
+  }
+  if (windowMinutes >= 60) {
+    const hours = windowMinutes / 60;
+    const rounded = Math.round(hours * 10) / 10;
+    const display = Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(1);
+    return `${display.replace(/\.0$/, "")}h window`;
+  }
+  const minutes = Math.round(windowMinutes);
+  return `${minutes}m window`;
+}
+function formatDurationFromSeconds(seconds) {
+  if (typeof seconds !== "number" || Number.isNaN(seconds)) {
+    return null;
+  }
+  if (seconds <= 0) {
+    return "now";
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes === 0) {
+    return `${Math.max(1, Math.round(seconds))}s`;
+  }
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours < 24) {
+    return remainingMinutes ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  const remainingHours = hours % 24;
+  return remainingHours ? `${days}d ${remainingHours}h` : `${days}d`;
+}
+function formatResetText(window) {
+  if (window.resetsAt) {
+    return formatRelativeTime(window.resetsAt) ?? window.resetsAt;
+  }
+  const durationText = formatDurationFromSeconds(window.resetsInSeconds);
+  if (!durationText) return null;
+  if (durationText === "now") return "now";
+  return `in ${durationText}`;
+}
+function formatWindowUsage(window) {
+  const label = formatWindowLabel(window.windowMinutes) ?? "window";
+  const usedPercent = typeof window.usedPercent === "number" && Number.isFinite(window.usedPercent) ? `${Math.round(Math.max(0, Math.min(100, window.usedPercent)))}%` : "n/a";
+  const resetText = formatResetText(window);
+  return {
+    label,
+    used: usedPercent,
+    reset: resetText ? `reset ${resetText}` : null
+  };
+}
+function fallbackUsage(profile) {
+  if (!profile.isValid) {
+    return { summary: "invalid", rows: null };
+  }
+  if (profile.tokenStatus?.requiresUserAction) {
+    return { summary: "auth required", rows: null };
+  }
+  return { summary: "n/a", rows: null };
+}
+async function resolveProfileUsage(manager, profile, codexPath) {
+  if (!profile.isValid || profile.tokenStatus?.requiresUserAction) {
+    return fallbackUsage(profile);
+  }
+  try {
+    const snapshot = await manager.runWithProfileAuth(
+      profile.name,
+      (env) => fetchRateLimitsViaRpc(env, { codexPath })
+    );
+    if (!snapshot) {
+      return { summary: "n/a", rows: null };
+    }
+    const rows = [];
+    if (snapshot.primary) {
+      const row = formatWindowUsage(snapshot.primary);
+      if (row) rows.push(row);
+    }
+    if (snapshot.secondary) {
+      const row = formatWindowUsage(snapshot.secondary);
+      if (row) rows.push(row);
+    }
+    const maxPercent = maxUsedPercent(snapshot);
+    const summary = typeof maxPercent === "number" ? `${Math.round(maxPercent)}%` : "n/a";
+    return { summary, rows: rows.length > 0 ? rows : null };
+  } catch {
+    return { summary: "n/a", rows: null };
+  }
+}
+function formatPlan(profile) {
+  const metadata = profile.metadata;
+  if (!metadata) {
+    return "No plan details";
+  }
+  const parts = [];
+  if (metadata.planType) {
+    parts.push(toTitleCase(metadata.planType));
+  }
+  const until = metadata.subscription?.activeUntil;
+  if (until) {
+    const formatted = formatShortDate(until);
+    if (formatted) {
+      parts.push(`Until ${formatted}`);
+    }
+  }
+  return parts.join(" \xB7 ") || "No plan details";
+}
+function formatAuth(profile) {
+  const metadata = profile.metadata;
+  const relative = formatRelativeTime(metadata?.tokenAuthTime);
+  if (relative) return relative;
+  if (metadata?.tokenAuthTime) return metadata.tokenAuthTime;
+  return "Not authenticated yet";
+}
+function printProfileDetails(profile, usage) {
+  const email = profile.email ?? "Unknown";
+  const plan = formatPlan(profile);
+  const orgs = formatOrganizations(profile.metadata?.organizations) ?? "No organizations";
+  const auth = formatAuth(profile);
+  const workspace = profile.workspaceName ?? profile.workspaceId ?? null;
+  const entries = [
+    { label: "email", value: email },
+    { label: "plan", value: plan },
+    { label: "orgs", value: orgs },
+    { label: "auth", value: auth }
+  ];
+  if (workspace) {
+    entries.push({ label: "workspace", value: workspace });
+  }
+  const pad = Math.max(...entries.map((entry) => entry.label.length));
+  for (const entry of entries) {
+    console.log(`  ${entry.label.padEnd(pad)} : ${entry.value}`);
+  }
+  if (usage) {
+    if (usage.rows && usage.rows.length > 0) {
+      const labelPad = Math.max(...usage.rows.map((row) => row.label.length));
+      const usedPad = Math.max(...usage.rows.map((row) => row.used.length));
+      console.log(`  rate limits:`);
+      for (const row of usage.rows) {
+        const resetText = row.reset ? `  ${row.reset}` : "";
+        console.log(`    ${row.label.padEnd(labelPad)}  ${row.used.padStart(usedPad)}${resetText}`);
+      }
+      return;
+    }
+    console.log(`  rate limits: ${usage.summary}`);
+  }
+}
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  let nextIndex = 0;
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (true) {
+      const current = nextIndex++;
+      if (current >= items.length) {
+        return;
+      }
+      results[current] = await fn(items[current], current);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
 async function handleProfile(args) {
   const flags = args.filter((arg) => arg.startsWith("-"));
   const params = stripFlags(args);
@@ -3283,10 +3795,41 @@ async function handleProfile(args) {
         console.log("No profiles found.");
         return;
       }
-      for (const profile of profiles) {
+      const compact = hasFlag(flags, "--compact");
+      const withUsage = !hasFlag(flags, "--no-usage");
+      let usageMap = null;
+      if (withUsage) {
+        usageMap = /* @__PURE__ */ new Map();
+        const codexPath = resolveCodexBinary();
+        const codexAvailable = Boolean(codexPath);
+        if (!codexAvailable || !codexPath) {
+          for (const profile of profiles) {
+            usageMap.set(profile.name, { summary: "codex cli missing", rows: null });
+          }
+        } else {
+          const limitEnv = Number.parseInt(process.env.CODEXUSE_CLI_USAGE_CONCURRENCY ?? "3", 10);
+          const limit = Number.isFinite(limitEnv) && limitEnv > 0 ? limitEnv : 3;
+          const results = await mapWithConcurrency(
+            profiles,
+            limit,
+            (profile) => resolveProfileUsage(manager, profile, codexPath)
+          );
+          for (const [index, profile] of profiles.entries()) {
+            usageMap.set(profile.name, results[index]);
+          }
+        }
+      }
+      for (const [index, profile] of profiles.entries()) {
         const marker = current.name === profile.name ? "*" : " ";
         const label = formatProfileLabel(profile.name, profile.displayName);
-        console.log(`${marker} ${label}`);
+        if (index > 0) {
+          console.log("");
+        }
+        const activeLabel = current.name === profile.name ? " (active)" : "";
+        console.log(`${marker} ${label}${activeLabel}`);
+        if (compact) continue;
+        const usage = usageMap?.get(profile.name) ?? null;
+        printProfileDetails(profile, usage);
       }
       return;
     }
@@ -3306,7 +3849,8 @@ async function handleProfile(args) {
       }
       await assertProfileCreationAllowed(manager);
       if (!hasFlag(flags, "--skip-login")) {
-        await runCodexLogin();
+        const loginMode = resolveLoginMode(parseLoginMode(flags));
+        await runCodexLogin(loginMode);
       }
       const profile = await manager.createProfile(name);
       const label = profile ? formatProfileLabel(profile.name, profile.displayName) : name;
@@ -3319,7 +3863,8 @@ async function handleProfile(args) {
         throw new Error("Profile name is required.");
       }
       if (!hasFlag(flags, "--skip-login")) {
-        await runCodexLogin();
+        const loginMode = resolveLoginMode(parseLoginMode(flags));
+        await runCodexLogin(loginMode);
       }
       const profile = await manager.refreshProfileAuth(name);
       const label = formatProfileLabel(profile.name, profile.displayName);