codexuse-cli 3.8.0 → 3.9.0

package/dist/index.js

@@ -2352,7 +2352,8 @@ function createDefaultAppState() {
     autoRoll: {
       enabled: false,
       warningThreshold: 85,
-      switchThreshold: 95
+      switchThreshold: 95,
+      restartOfficialCodexOnAutoRoll: false
     },
     app: {
       lastAppVersion: null,
@@ -2479,6 +2480,9 @@ function normalizeAppState(raw) {
       Math.max(merged.autoRoll.warningThreshold + 1, 95)
     );
   }
+  if (typeof merged.autoRoll.restartOfficialCodexOnAutoRoll !== "boolean") {
+    merged.autoRoll.restartOfficialCodexOnAutoRoll = false;
+  }
   merged.app.lastAppVersion = asString(merged.app.lastAppVersion);
   merged.app.pendingUpdateVersion = asString(merged.app.pendingUpdateVersion);
   merged.app.lastProfileName = asString(merged.app.lastProfileName);
@@ -2872,6 +2876,7 @@ async function patchAppState(patch) {
 }
 
 // ../../packages/runtime-app-state/src/app/runtimeSettings.ts
+var CUSTOMER_DEFAULTS_MIGRATION_KEY = "customerRateLimitBackgroundDefaultsApplied";
 var LEGACY_APP_SETTINGS_KEYS = /* @__PURE__ */ new Set([
   "backendMode",
   "theme",
@@ -2899,12 +2904,56 @@ function stripLegacyAppSettingsKeys(settings) {
   }
   return changed ? next : settings;
 }
+function withCurrentRuntimeDefaults(settings, options) {
+  let changed = false;
+  const next = { ...settings };
+  const migrationApplied = next[CUSTOMER_DEFAULTS_MIGRATION_KEY] === true;
+  if (options.migrateLegacyDefaults && !migrationApplied) {
+    if (!("keepAppRunningAfterWindowClose" in next)) {
+      next.keepAppRunningAfterWindowClose = true;
+      changed = true;
+    }
+  } else if (!("keepAppRunningAfterWindowClose" in next)) {
+    next.keepAppRunningAfterWindowClose = true;
+    changed = true;
+  }
+  if (next.rateLimitPercentMode !== "remaining" && next.rateLimitPercentMode !== "used") {
+    next.rateLimitPercentMode = "remaining";
+    changed = true;
+  }
+  if (!migrationApplied) {
+    next[CUSTOMER_DEFAULTS_MIGRATION_KEY] = true;
+    changed = true;
+  }
+  return { settings: changed ? next : settings, changed };
+}
 async function readAppSettings() {
   const appState = await getAppState();
-  return stripLegacyAppSettingsKeys(asRecord(appState.runtimeSettings));
+  const stripped = stripLegacyAppSettingsKeys(asRecord(appState.runtimeSettings));
+  const next = withCurrentRuntimeDefaults(stripped, {
+    migrateLegacyDefaults: true
+  });
+  if (next.changed) {
+    await updateAppState(
+      (current) => ({
+        ...current,
+        runtimeSettings: next.settings
+      }),
+      {
+        mode: "replace",
+        allowBeforeMigrationComplete: false
+      }
+    );
+  }
+  return next.settings;
 }
 async function writeAppSettings(settings, onUpdated) {
-  const nextSettings = stripLegacyAppSettingsKeys(asRecord(settings));
+  const nextSettings = withCurrentRuntimeDefaults(
+    stripLegacyAppSettingsKeys(asRecord(settings)),
+    {
+      migrateLegacyDefaults: false
+    }
+  ).settings;
   await updateAppState(
     (current) => ({
       ...current,
@@ -2932,6 +2981,7 @@ var import_node_crypto2 = __toESM(require("crypto"), 1);
 var DEFAULT_AUTO_ROLL_ENABLED = false;
 var DEFAULT_AUTO_ROLL_WARNING_THRESHOLD = 85;
 var DEFAULT_AUTO_ROLL_SWITCH_THRESHOLD = 95;
+var DEFAULT_RESTART_OFFICIAL_CODEX_ON_AUTO_ROLL = false;
 var AUTO_ROLL_WARNING_MIN = 50;
 var AUTO_ROLL_WARNING_MAX = 99;
 var AUTO_ROLL_SWITCH_MAX = 100;
@@ -2975,7 +3025,8 @@ function normalizeAutoRollSettings(raw) {
   return {
     enabled,
     warningThreshold: normalizedWarning,
-    switchThreshold: normalizedSwitch
+    switchThreshold: normalizedSwitch,
+    restartOfficialCodexOnAutoRoll: raw?.restartOfficialCodexOnAutoRoll === true ? true : DEFAULT_RESTART_OFFICIAL_CODEX_ON_AUTO_ROLL
   };
 }
 
@@ -3100,7 +3151,8 @@ async function writeCodexSettingsJsonRaw(payload) {
     autoRoll: autoRoll ? {
       enabled: autoRoll.enabled,
       warningThreshold: autoRoll.warningThreshold,
-      switchThreshold: autoRoll.switchThreshold
+      switchThreshold: autoRoll.switchThreshold,
+      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll
     } : void 0,
     license: license ? {
       licenseKey: license.licenseKey ?? null,
@@ -5802,7 +5854,12 @@ function printHelp(version) {
   console.log(`CodexUse CLI v${version}
 
 Usage:
+  codexuse doctor
+  codexuse run --profile <name> -- <codex args>
+  codexuse best [--dry-run] -- <codex args>
+
   codexuse account-pool status [--runtime=desktop|daemon] [--state-dir=/abs/path] [--port=NNNN]
+  codexuse account-pool quickstart
   codexuse account-pool enable
   codexuse account-pool disable
   codexuse account-pool routing <least-used|round-robin>
@@ -5842,6 +5899,7 @@ Flags:
   --watch          Keep checking and auto-switch when threshold is reached
   --interval=SEC   Watch interval in seconds (default: 30)
   --dry-run        Print planned switch without changing active profile
+  --profile=NAME   Run Codex with one saved profile
   --runtime=NAME   Accounts Pool runtime store: desktop | daemon
   --state-dir=PATH Override the runtime state dir for Accounts Pool inspection
   --port=NNNN      Stable daemon/API port (or use with account-pool status for daemon base URL)
@@ -6053,6 +6111,7 @@ function printAccountPoolHelp(version) {
 
 Usage:
   codexuse account-pool status [--runtime=desktop|daemon] [--state-dir=/abs/path] [--port=NNNN]
+  codexuse account-pool quickstart [--runtime=desktop|daemon] [--state-dir=/abs/path] [--port=NNNN]
   codexuse account-pool enable
   codexuse account-pool disable
   codexuse account-pool routing <least-used|round-robin>
@@ -6833,6 +6892,28 @@ async function handleSessions(params, flags) {
   }
   console.log("Session mutation is intentionally not exposed here; pooled sessions belong to the live runtime owner.");
 }
+async function handleQuickstart(flags) {
+  const { runtime, stateDir } = resolveStateDir(flags);
+  const port = parseIntegerFlag(flags, "--port");
+  const summary = await readAccountPoolRuntimeSummary({ runtime, stateDir, port });
+  const baseUrl = summary.baseUrl ?? "http://127.0.0.1:<port>";
+  console.log("Accounts Pool quickstart");
+  console.log(`Runtime: ${summary.runtime}`);
+  console.log(`Enabled: ${summary.enabled ? "yes" : "no"}`);
+  console.log(`Pro: ${summary.hasProLicense ? "yes" : "no"}`);
+  console.log(`API keys: ${summary.activeApiKeyCount}`);
+  console.log(`Base URL: ${baseUrl}`);
+  console.log("");
+  console.log("1. Enable pool:");
+  console.log("   codexuse account-pool enable");
+  console.log("2. Create key:");
+  console.log(`   codexuse account-pool keys create --runtime=${summary.runtime}`);
+  console.log("3. Use OpenAI-compatible settings:");
+  console.log(`   Base URL: ${baseUrl}/v1`);
+  console.log("   API key: cux_pool_...");
+  console.log("4. Smoke:");
+  console.log(`   curl ${baseUrl}/v1/models -H 'Authorization: Bearer cux_pool_...'`);
+}
 async function handleAccountPoolCommand(args, version) {
   const flags = args.filter((arg) => arg.startsWith("-"));
   const params = stripFlags(args);
@@ -6845,6 +6926,9 @@ async function handleAccountPoolCommand(args, version) {
     case "status":
       await handleStatus(flags);
       return;
+    case "quickstart":
+      await handleQuickstart(flags);
+      return;
     case "enable":
       await handleEnable();
       return;
@@ -6899,39 +6983,404 @@ async function handleAccountPoolCommand(args, version) {
   }
 }
 
-// src/commands/daemon.ts
+// src/commands/codex.ts
 var import_node_child_process4 = require("child_process");
+
+// ../../packages/runtime-profiles/src/profiles/rate-limit-notifier.ts
+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/platform/codexCli.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_path8 = __toESM(require("path"));
+var ENV_HINTS2 = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
+function fileExists2(candidate) {
+  if (!candidate) return null;
+  const resolved = import_node_path8.default.resolve(candidate);
+  try {
+    const stat2 = (0, import_node_fs6.statSync)(resolved);
+    if (stat2.isFile()) return resolved;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolveFromEnv() {
+  for (const key of ENV_HINTS2) {
+    const value = process.env[key];
+    if (!value) continue;
+    const resolved = fileExists2(value);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+function resolveFromPath() {
+  const pathValue = process.env.PATH ?? "";
+  const entries = pathValue.split(import_node_path8.default.delimiter).filter(Boolean);
+  const names = process.platform === "win32" ? ["codex.exe", "codex.cmd", "codex.bat", "codex"] : ["codex"];
+  for (const entry of entries) {
+    for (const name of names) {
+      const candidate = fileExists2(import_node_path8.default.join(entry, name));
+      if (candidate) return candidate;
+    }
+  }
+  return null;
+}
+function resolveCodexBinary() {
+  return resolveFromEnv() || resolveFromPath();
+}
+function requireCodexBinary(context) {
+  const resolved = resolveCodexBinary();
+  if (resolved) return resolved;
+  const hint = "Install Codex CLI (npm i -g @openai/codex) or set CODEX_BINARY.";
+  const message = context ? `${context} ${hint}` : hint;
+  throw new Error(message);
+}
+function buildCodexCommand2(codexPath, args) {
+  const normalized = codexPath.toLowerCase();
+  const isJs = normalized.endsWith(".js") || normalized.endsWith(".mjs") || normalized.endsWith(".cjs");
+  if (isJs) {
+    return { command: process.execPath, args: [codexPath, ...args], shell: false };
+  }
+  const useShell = process.platform === "win32";
+  return { command: codexPath, args, shell: useShell };
+}
+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 resolvedMode = resolveLoginMode(mode ?? null);
+  const loginArgs = resolvedMode === "device" ? ["login", "--device-auth"] : ["login"];
+  const { command, args, shell } = buildCodexCommand2(codexPath, loginArgs);
+  const child = (0, import_node_child_process3.spawn)(command, args, {
+    stdio: "inherit",
+    env: process.env,
+    shell
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.on("close", (code) => resolve(code ?? 0));
+  });
+  if (exitCode !== 0) {
+    throw new Error(`Codex CLI login failed (exit code ${exitCode}).`);
+  }
+}
+
+// src/commands/codex.ts
+var DOCTOR_TIMEOUT_MS = 8e3;
+function splitCommandArgs(args) {
+  const delimiterIndex = args.indexOf("--");
+  const flags = delimiterIndex >= 0 ? args.slice(0, delimiterIndex) : args.slice();
+  const codexArgs = delimiterIndex >= 0 ? args.slice(delimiterIndex + 1) : [];
+  return { flags, codexArgs };
+}
+function readOption(flags, longName, shortName) {
+  for (let index = 0; index < flags.length; index += 1) {
+    const flag = flags[index];
+    if (flag === longName) {
+      const next = flags[index + 1];
+      return next && !next.startsWith("-") ? next : "";
+    }
+    if (flag.startsWith(`${longName}=`)) {
+      return flag.slice(longName.length + 1).trim();
+    }
+    if (shortName && flag === shortName) {
+      const next = flags[index + 1];
+      return next && !next.startsWith("-") ? next : "";
+    }
+  }
+  return null;
+}
+function firstLine(value) {
+  const line = value.split(/\r?\n/).map((entry) => entry.trim()).find(Boolean);
+  return line ?? null;
+}
+function formatUsagePercent(value) {
+  return typeof value === "number" && Number.isFinite(value) ? `${Math.round(value)}%` : "unknown";
+}
+function snapshotResetSeconds(snapshot) {
+  const values = [
+    snapshot?.primary?.resetsInSeconds,
+    snapshot?.secondary?.resetsInSeconds
+  ].filter((value) => typeof value === "number" && Number.isFinite(value));
+  return values.length > 0 ? Math.min(...values) : null;
+}
+function fallbackUsedPercent(profile) {
+  const cached = maxUsedPercent(profile.rateLimit ?? null);
+  return typeof cached === "number" && Number.isFinite(cached) ? cached : null;
+}
+function compareCandidates(left, right) {
+  const leftUsage = left.usedPercent ?? Number.POSITIVE_INFINITY;
+  const rightUsage = right.usedPercent ?? Number.POSITIVE_INFINITY;
+  if (leftUsage !== rightUsage) {
+    return leftUsage - rightUsage;
+  }
+  const leftReset = left.resetSeconds ?? Number.POSITIVE_INFINITY;
+  const rightReset = right.resetSeconds ?? Number.POSITIVE_INFINITY;
+  if (leftReset !== rightReset) {
+    return leftReset - rightReset;
+  }
+  return left.profile.name.localeCompare(right.profile.name);
+}
+async function runCommand(codexPath, args, timeoutMs) {
+  const command = buildCodexCommand2(codexPath, args);
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process4.spawn)(command.command, command.args, {
+      env: process.env,
+      shell: command.shell,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    let timer;
+    const finish = (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve({ code, stdout, stderr, timedOut });
+    };
+    timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      finish(null);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk).slice(0, 2e4);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk).slice(0, 2e4);
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code));
+  });
+}
+async function selectBestProfile(manager, profiles, codexPath) {
+  const candidates = [];
+  for (const profile of profiles) {
+    if (!profile.isValid || profile.tokenStatus?.requiresUserAction) {
+      continue;
+    }
+    try {
+      const snapshot = await manager.readLiveRateLimits(profile.name, { codexPath });
+      candidates.push({
+        profile,
+        usedPercent: typeof maxUsedPercent(snapshot) === "number" ? maxUsedPercent(snapshot) : fallbackUsedPercent(profile),
+        resetSeconds: snapshotResetSeconds(snapshot)
+      });
+    } catch {
+      candidates.push({
+        profile,
+        usedPercent: fallbackUsedPercent(profile),
+        resetSeconds: snapshotResetSeconds(profile.rateLimit ?? null)
+      });
+    }
+  }
+  return candidates.sort(compareCandidates)[0] ?? null;
+}
+async function runCodexWithProfile(manager, profileName, codexArgs) {
+  const codexPath = resolveCodexBinary();
+  if (!codexPath) {
+    throw new Error("Codex CLI not found. Install Codex CLI or set CODEX_BINARY.");
+  }
+  const runtime = await manager.prepareProfileRuntime(profileName);
+  const command = buildCodexCommand2(codexPath, codexArgs);
+  try {
+    const child = (0, import_node_child_process4.spawn)(command.command, command.args, {
+      env: runtime.env,
+      shell: command.shell,
+      stdio: "inherit"
+    });
+    const exitCode = await new Promise((resolve) => {
+      child.on("close", (code) => resolve(code ?? 0));
+    });
+    process.exitCode = exitCode;
+  } finally {
+    await manager.syncProfileRuntime(profileName, runtime.profileHome).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Warning: failed to sync profile runtime for '${profileName}': ${message}`);
+    });
+  }
+}
+async function handleDoctorCommand(args) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    console.log(`Usage:
+  codexuse doctor
+
+Checks Codex CLI, auth, saved profiles, license, and Accounts Pool readiness.`);
+    return;
+  }
+  const manager = new ProfileManager();
+  const codexPath = resolveCodexBinary();
+  const [profiles, current, license, accountPool] = await Promise.all([
+    manager.listProfiles(),
+    manager.getCurrentProfile(),
+    licenseService.getStatus().catch(() => null),
+    readAccountPoolRuntimeSummary().catch(() => null)
+  ]);
+  console.log("CodexUse Doctor");
+  if (!codexPath) {
+    console.log("Codex CLI: missing");
+  } else {
+    const version = await runCommand(codexPath, ["--version"], DOCTOR_TIMEOUT_MS);
+    const versionText = firstLine(version.stdout) ?? firstLine(version.stderr);
+    console.log(`Codex CLI: ${version.code === 0 ? "ok" : "check"} (${codexPath})`);
+    console.log(`Version: ${versionText ?? (version.timedOut ? "timed out" : "unknown")}`);
+    const auth = await runCommand(codexPath, ["login", "status"], DOCTOR_TIMEOUT_MS);
+    const authText = firstLine(auth.stdout) ?? firstLine(auth.stderr);
+    console.log(`Auth: ${auth.code === 0 ? "ok" : "check"}${authText ? ` (${authText})` : ""}`);
+  }
+  console.log(`Profiles: ${profiles.length}`);
+  console.log(`Active profile: ${current.name ?? "none"}${current.trusted ? "" : " (untrusted)"}`);
+  console.log(`License: ${license ? `${license.tier} (${license.state})` : "unknown"}`);
+  if (accountPool) {
+    console.log(
+      `Accounts Pool: ${accountPool.enabled ? "on" : "off"} | keys ${accountPool.activeApiKeyCount} | sessions ${accountPool.activeSessionCount}`
+    );
+  } else {
+    console.log("Accounts Pool: unknown");
+  }
+  const fixes = [];
+  if (!codexPath) {
+    fixes.push("Install Codex CLI or set CODEX_BINARY.");
+  }
+  if (profiles.length === 0) {
+    fixes.push("Add first profile: codexuse profile add personal");
+  }
+  if (profiles.length === 1) {
+    fixes.push("Add second profile: codexuse profile add work");
+  }
+  if (!current.name && profiles.length > 0) {
+    fixes.push(`Switch active profile: codexuse profile switch ${profiles[0]?.name}`);
+  }
+  if (accountPool && (!accountPool.enabled || accountPool.activeApiKeyCount === 0)) {
+    fixes.push("Pool quickstart: codexuse account-pool quickstart");
+  }
+  if (fixes.length > 0) {
+    console.log("Fixes:");
+    for (const fix of fixes) {
+      console.log(`- ${fix}`);
+    }
+    return;
+  }
+  console.log("Ready.");
+}
+async function handleRunCommand(args) {
+  const { flags, codexArgs } = splitCommandArgs(args);
+  if (hasFlag(flags, "--help") || hasFlag(flags, "-h")) {
+    console.log(`Usage:
+  codexuse run --profile <name> -- <codex args>
+
+Runs Codex under one saved CodexUse profile.`);
+    return;
+  }
+  const profileName = readOption(flags, "--profile", "-p");
+  if (!profileName) {
+    throw new Error("Profile is required. Use --profile <name>.");
+  }
+  const manager = new ProfileManager();
+  await runCodexWithProfile(manager, profileName, codexArgs);
+}
+async function handleBestCommand(args) {
+  const { flags, codexArgs } = splitCommandArgs(args);
+  if (hasFlag(flags, "--help") || hasFlag(flags, "-h")) {
+    console.log(`Usage:
+  codexuse best -- <codex args>
+
+Picks the healthiest saved profile, then runs Codex. Auto-run requires Pro.`);
+    return;
+  }
+  const codexPath = resolveCodexBinary();
+  if (!codexPath) {
+    throw new Error("Codex CLI not found. Install Codex CLI or set CODEX_BINARY.");
+  }
+  const manager = new ProfileManager();
+  const profiles = await manager.listProfiles();
+  const best = await selectBestProfile(manager, profiles, codexPath);
+  if (!best) {
+    throw new Error("No valid saved profiles found. Add one with `codexuse profile add <name>`.");
+  }
+  const dryRun = hasFlag(flags, "--dry-run");
+  const license = await licenseService.getStatus();
+  const summary = `${best.profile.name} (${formatUsagePercent(best.usedPercent)} used)`;
+  if (!license.isPro) {
+    console.log(`Best profile: ${summary}`);
+    console.log("Auto-run is Pro. Free path:");
+    console.log(`  codexuse run --profile ${best.profile.name} -- ${codexArgs.join(" ")}`.trimEnd());
+    return;
+  }
+  if (dryRun) {
+    console.log(`Would run with profile: ${summary}`);
+    return;
+  }
+  console.error(`CodexUse best -> ${summary}`);
+  await runCodexWithProfile(manager, best.profile.name, codexArgs);
+}
+
+// src/commands/daemon.ts
+var import_node_child_process6 = require("child_process");
 var import_node_crypto5 = require("crypto");
-var import_node_fs6 = __toESM(require("fs"));
+var import_node_fs7 = __toESM(require("fs"));
 var import_node_net = __toESM(require("net"));
 var import_node_os4 = __toESM(require("os"));
-var import_node_path9 = __toESM(require("path"));
+var import_node_path10 = __toESM(require("path"));
 
 // ../../packages/shared/src/core/internal-js-runtime.ts
-var import_node_child_process3 = require("child_process");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_child_process5 = require("child_process");
+var import_node_path9 = __toESM(require("path"), 1);
 var cachedBunBinary = null;
 function hasBunRuntime() {
   return typeof process.versions.bun === "string" && process.versions.bun.length > 0;
 }
 function buildRuntimePath(env) {
   const homeDir = env.HOME ?? env.USERPROFILE ?? "";
-  const pathHints = (env.CODEX_PATH_HINTS ?? "").split(import_node_path8.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
+  const pathHints = (env.CODEX_PATH_HINTS ?? "").split(import_node_path9.default.delimiter).map((entry) => entry.trim()).filter(Boolean);
   const entries = [
     env.PATH ?? "",
-    import_node_path8.default.join(homeDir, ".bun", "bin"),
+    import_node_path9.default.join(homeDir, ".bun", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
-    import_node_path8.default.join(homeDir, ".local", "bin"),
-    import_node_path8.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
-    import_node_path8.default.join(homeDir, ".fnm", "current", "bin"),
+    import_node_path9.default.join(homeDir, ".local", "bin"),
+    import_node_path9.default.join(homeDir, ".fnm", "aliases", "default", "bin"),
+    import_node_path9.default.join(homeDir, ".fnm", "current", "bin"),
     ...pathHints
   ];
   return Array.from(
     new Set(
-      entries.flatMap((entry) => entry.split(import_node_path8.default.delimiter)).map((entry) => entry.trim()).filter(Boolean)
+      entries.flatMap((entry) => entry.split(import_node_path9.default.delimiter)).map((entry) => entry.trim()).filter(Boolean)
     )
-  ).join(import_node_path8.default.delimiter);
+  ).join(import_node_path9.default.delimiter);
 }
 function resolveConfiguredBunBinary(env) {
   const candidates = [
@@ -6961,7 +7410,7 @@ function probeBunBinary(env) {
       [
         env.CODEXUSE_INTERNAL_BUN_BIN?.trim(),
         env.BUN_BIN?.trim(),
-        import_node_path8.default.join(homeDir, ".bun", "bin", "bun"),
+        import_node_path9.default.join(homeDir, ".bun", "bin", "bun"),
         "/opt/homebrew/bin/bun",
         "/usr/local/bin/bun",
         "bun"
@@ -6969,7 +7418,7 @@ function probeBunBinary(env) {
     )
   );
   for (const candidate of candidates) {
-    const probe = (0, import_node_child_process3.spawnSync)(candidate, ["--version"], {
+    const probe = (0, import_node_child_process5.spawnSync)(candidate, ["--version"], {
       env,
       stdio: "ignore"
     });
@@ -7022,18 +7471,18 @@ Notes:
 }
 function resolveServerEntry() {
   const candidates = [
-    import_node_path9.default.resolve(__dirname, "server", "index.mjs"),
-    import_node_path9.default.resolve(__dirname, "../../../server/dist/index.mjs")
+    import_node_path10.default.resolve(__dirname, "server", "index.mjs"),
+    import_node_path10.default.resolve(__dirname, "../../../server/dist/index.mjs")
   ];
   for (const candidate of candidates) {
-    if (import_node_fs6.default.existsSync(candidate)) {
+    if (import_node_fs7.default.existsSync(candidate)) {
       return candidate;
     }
   }
   return candidates[0];
 }
 function resolveStateDir2() {
-  return import_node_path9.default.join(import_node_os4.default.homedir(), ".codexuse", "t3-daemon");
+  return import_node_path10.default.join(import_node_os4.default.homedir(), ".codexuse", "t3-daemon");
 }
 function reserveLoopbackPort(port = 0) {
   return new Promise((resolve, reject) => {
@@ -7059,7 +7508,7 @@ function reserveLoopbackPort(port = 0) {
 }
 async function runDaemonStart(options) {
   const entry = resolveServerEntry();
-  if (!import_node_fs6.default.existsSync(entry)) {
+  if (!import_node_fs7.default.existsSync(entry)) {
     throw new Error(
       `Missing bundled T3 server build output at ${entry}. Rebuild the CLI package with \`bun run build:cli\`.`
     );
@@ -7070,7 +7519,7 @@ async function runDaemonStart(options) {
   const port = await reserveLoopbackPort(options.port ?? 0);
   const authToken = (0, import_node_crypto5.randomBytes)(24).toString("hex");
   const stateDir = resolveStateDir2();
-  const projectPath = options.projectPath ? import_node_path9.default.resolve(options.projectPath) : null;
+  const projectPath = options.projectPath ? import_node_path10.default.resolve(options.projectPath) : null;
   const childCwd = projectPath ?? process.cwd();
   const telegramBotToken = options.telegramBotToken?.trim() || null;
   const runtime = resolveInternalBunRuntime({
@@ -7087,7 +7536,7 @@ async function runDaemonStart(options) {
       CODEXUSE_TELEGRAM_BRIDGE_ENABLED: "1"
     } : {}
   });
-  const child = (0, import_node_child_process4.spawn)(runtime.bin, [entry], {
+  const child = (0, import_node_child_process6.spawn)(runtime.bin, [entry], {
     cwd: childCwd,
     env: runtime.env,
     stdio: "inherit"
@@ -7245,114 +7694,6 @@ async function assertProfileCreationAllowed(profileManager) {
   }
 }
 
-// ../../packages/runtime-profiles/src/profiles/rate-limit-notifier.ts
-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/platform/codexCli.ts
-var import_node_child_process5 = require("child_process");
-var import_node_fs7 = require("fs");
-var import_node_path10 = __toESM(require("path"));
-var ENV_HINTS2 = ["CODEX_BINARY", "CODEX_CLI_PATH", "CODEX_PATH"];
-function fileExists2(candidate) {
-  if (!candidate) return null;
-  const resolved = import_node_path10.default.resolve(candidate);
-  try {
-    const stat2 = (0, import_node_fs7.statSync)(resolved);
-    if (stat2.isFile()) return resolved;
-  } catch {
-    return null;
-  }
-  return null;
-}
-function resolveFromEnv() {
-  for (const key of ENV_HINTS2) {
-    const value = process.env[key];
-    if (!value) continue;
-    const resolved = fileExists2(value);
-    if (resolved) return resolved;
-  }
-  return null;
-}
-function resolveFromPath() {
-  const pathValue = process.env.PATH ?? "";
-  const entries = pathValue.split(import_node_path10.default.delimiter).filter(Boolean);
-  const names = process.platform === "win32" ? ["codex.exe", "codex.cmd", "codex.bat", "codex"] : ["codex"];
-  for (const entry of entries) {
-    for (const name of names) {
-      const candidate = fileExists2(import_node_path10.default.join(entry, name));
-      if (candidate) return candidate;
-    }
-  }
-  return null;
-}
-function resolveCodexBinary() {
-  return resolveFromEnv() || resolveFromPath();
-}
-function requireCodexBinary(context) {
-  const resolved = resolveCodexBinary();
-  if (resolved) return resolved;
-  const hint = "Install Codex CLI (npm i -g @openai/codex) or set CODEX_BINARY.";
-  const message = context ? `${context} ${hint}` : hint;
-  throw new Error(message);
-}
-function buildCodexCommand2(codexPath, args) {
-  const normalized = codexPath.toLowerCase();
-  const isJs = normalized.endsWith(".js");
-  if (isJs) {
-    return { command: process.execPath, args: [codexPath, ...args], shell: false };
-  }
-  const useShell = process.platform === "win32";
-  return { command: codexPath, args, shell: useShell };
-}
-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 resolvedMode = resolveLoginMode(mode ?? null);
-  const loginArgs = resolvedMode === "device" ? ["login", "--device-auth"] : ["login"];
-  const { command, args, shell } = buildCodexCommand2(codexPath, loginArgs);
-  const child = (0, import_node_child_process5.spawn)(command, args, {
-    stdio: "inherit",
-    env: process.env,
-    shell
-  });
-  const exitCode = await new Promise((resolve) => {
-    child.on("close", (code) => resolve(code ?? 0));
-  });
-  if (exitCode !== 0) {
-    throw new Error(`Codex CLI login failed (exit code ${exitCode}).`);
-  }
-}
-
 // src/commands/profile.ts
 function formatProfileLabel(name, displayName) {
   if (displayName && displayName.trim() && displayName !== name) {
@@ -8161,7 +8502,7 @@ async function pushRemoteSnapshot(licenseKey, snapshot, options) {
 var import_toml2 = __toESM(require_toml(), 1);
 
 // ../../packages/runtime-codex/src/codex/config-metadata.ts
-var import_node_child_process6 = require("child_process");
+var import_node_child_process7 = require("child_process");
 var import_promises = require("fs/promises");
 var import_node_path11 = __toESM(require("path"), 1);
 var CONFIG_SCHEMA_URL = "https://raw.githubusercontent.com/openai/codex/main/codex-rs/core/config.schema.json";
@@ -8271,9 +8612,9 @@ function isRecord5(value) {
 function uniqueSorted(values) {
   return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
 }
-async function runCommand(command, args, timeoutMs = 3e3) {
+async function runCommand2(command, args, timeoutMs = 3e3) {
   return new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process6.spawn)(command, args, {
+    const child = (0, import_node_child_process7.spawn)(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
     });
@@ -8308,7 +8649,7 @@ async function runCodexCommand(args) {
   const isJsLauncher = codexPath.endsWith(".js");
   const command = isJsLauncher ? process.execPath : codexPath;
   const commandArgs = isJsLauncher ? [codexPath, ...args] : args;
-  return runCommand(command, commandArgs);
+  return runCommand2(command, commandArgs);
 }
 function parseFeatureCatalog(output) {
   const entries = [];
@@ -9797,7 +10138,8 @@ async function loadLegacySettingsPatch() {
     autoRoll: autoRoll ? {
       enabled: autoRoll.enabled,
       warningThreshold: autoRoll.warningThreshold,
-      switchThreshold: autoRoll.switchThreshold
+      switchThreshold: autoRoll.switchThreshold,
+      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll
     } : void 0
   };
 }
@@ -9993,7 +10335,8 @@ function mergeLegacyLocalStoragePatch(payload) {
     patch.autoRoll = {
       enabled: autoRoll.enabled,
       warningThreshold: autoRoll.warningThreshold,
-      switchThreshold: autoRoll.switchThreshold
+      switchThreshold: autoRoll.switchThreshold,
+      restartOfficialCodexOnAutoRoll: autoRoll.restartOfficialCodexOnAutoRoll
     };
     markSkippedIfPresent("codex:auto-roll-settings", true);
   } else {
@@ -10267,7 +10610,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "3.8.0" : "0.0.0";
+var VERSION = true ? "3.9.0" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {
@@ -10285,6 +10628,18 @@ async function runCli() {
   const command = args[0];
   const rest = args.slice(1);
   switch (command) {
+    case "doctor":
+      await ensureCliStorageReady();
+      await handleDoctorCommand(rest);
+      return;
+    case "run":
+      await ensureCliStorageReady();
+      await handleRunCommand(rest);
+      return;
+    case "best":
+      await ensureCliStorageReady();
+      await handleBestCommand(rest);
+      return;
     case "account-pool":
     case "accounts-pool":
       await ensureCliStorageReady();