codexuse-cli 5.0.8 → 5.1.0

package/dist/index.js

@@ -2023,7 +2023,7 @@ var require_toml = __commonJS({
 
 // src/commands/accountPool.ts
 var import_node_crypto4 = require("crypto");
-var import_node_path6 = __toESM(require("path"));
+var import_node_path7 = __toESM(require("path"));
 
 // ../../packages/contracts/src/settings/types.ts
 var DEFAULT_ACCOUNT_POOL_EXPOSED_MODELS = [
@@ -4862,7 +4862,7 @@ function parseRateLimitSnapshotFromOAuthUsage(value) {
   }
   return {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-    source: "codex-oauth",
+    source: "codex-oauth-estimate",
     ...primary ? { primary } : {},
     ...secondary ? { secondary } : {},
     ...extraWindows.length > 0 ? { extraWindows } : {}
@@ -5291,6 +5291,120 @@ async function activateResetWindowViaRpc(envOverride, options = {}) {
   }
 }
 
+// ../../packages/runtime-profiles/src/profiles/rate-limit-cache.ts
+var import_node_fs4 = require("fs");
+var import_node_path6 = __toESM(require("path"), 1);
+var memorySnapshots = /* @__PURE__ */ new Map();
+var persistedSnapshotWriteLock = Promise.resolve();
+var RATE_LIMIT_SNAPSHOT_CACHE_FILE = "rate-limit-snapshots.json";
+function cloneSnapshot(snapshot) {
+  return JSON.parse(JSON.stringify(snapshot));
+}
+function snapshotCachePath() {
+  return import_node_path6.default.join(getUserDataDir(), RATE_LIMIT_SNAPSHOT_CACHE_FILE);
+}
+async function loadPersistedSnapshots() {
+  let raw;
+  try {
+    raw = (await import_node_fs4.promises.readFile(snapshotCachePath(), "utf8")).trim();
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  if (!raw) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return /* @__PURE__ */ new Map();
+    }
+    return new Map(
+      Object.entries(parsed).flatMap(
+        ([key, value]) => {
+          if (!key || !value || typeof value !== "object") {
+            return [];
+          }
+          const snapshot = value;
+          if (typeof snapshot.lastUpdated !== "string") {
+            return [];
+          }
+          return [[key, cloneSnapshot(snapshot)]];
+        }
+      )
+    );
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function writePersistedSnapshots(snapshots) {
+  const filePath = snapshotCachePath();
+  const tmpPath = `${filePath}.tmp`;
+  const payload = JSON.stringify(
+    Object.fromEntries(
+      Array.from(snapshots.entries()).map(([key, snapshot]) => [
+        key,
+        cloneSnapshot(snapshot)
+      ])
+    ),
+    null,
+    2
+  );
+  try {
+    await import_node_fs4.promises.mkdir(import_node_path6.default.dirname(filePath), { recursive: true });
+    await import_node_fs4.promises.writeFile(tmpPath, `${payload}
+`, "utf8");
+    await import_node_fs4.promises.rename(tmpPath, filePath);
+  } catch {
+    try {
+      await import_node_fs4.promises.rm(tmpPath, { force: true });
+    } catch {
+    }
+  }
+}
+async function mutatePersistedSnapshots(mutate) {
+  persistedSnapshotWriteLock = persistedSnapshotWriteLock.then(async () => {
+    const persistedSnapshots = await loadPersistedSnapshots();
+    if (!mutate(persistedSnapshots)) {
+      return;
+    }
+    await writePersistedSnapshots(persistedSnapshots);
+  });
+  await persistedSnapshotWriteLock;
+}
+async function deleteRateLimitSnapshots(keys) {
+  const snapshotKeys = Array.from(new Set(keys.map((key) => key.trim()).filter(Boolean)));
+  if (snapshotKeys.length === 0) {
+    return;
+  }
+  for (const key of snapshotKeys) {
+    memorySnapshots.delete(key);
+  }
+  await mutatePersistedSnapshots((persistedSnapshots) => {
+    let changed = false;
+    for (const key of snapshotKeys) {
+      changed = persistedSnapshots.delete(key) || changed;
+    }
+    return changed;
+  });
+}
+async function pruneRateLimitSnapshots(allowedKeys) {
+  const allowed = new Set(allowedKeys.map((key) => key.trim()).filter(Boolean));
+  for (const key of Array.from(memorySnapshots.keys())) {
+    if (!allowed.has(key)) {
+      memorySnapshots.delete(key);
+    }
+  }
+  await mutatePersistedSnapshots((persistedSnapshots) => {
+    let changed = false;
+    for (const key of Array.from(persistedSnapshots.keys())) {
+      if (!allowed.has(key)) {
+        changed = persistedSnapshots.delete(key) || changed;
+      }
+    }
+    return changed;
+  });
+}
+
 // ../../packages/runtime-profiles/src/profiles/profile-manager.ts
 var TOKEN_EXPIRING_SOON_WINDOW_MS = 15 * 60 * 1e3;
 var REFRESH_TOKEN_REDEEMED_SNIPPET2 = "refresh token was already used";
@@ -5449,6 +5563,20 @@ var ProfileManager = class {
     delete map[name];
     await this.writeProfilesStateMap(map);
   }
+  rateLimitSnapshotKeysForRecord(record) {
+    return Array.from(
+      /* @__PURE__ */ new Set([
+        this.resolveProfileIdentityFromRecord(record),
+        resolveFallbackAccountKey(record.name)
+      ])
+    );
+  }
+  rateLimitSnapshotKeysForStateMap(map) {
+    return Object.entries(map).flatMap(([name, raw]) => {
+      const record = this.fromStateRecord(name, raw);
+      return record ? this.rateLimitSnapshotKeysForRecord(record) : [];
+    });
+  }
   resolveAuthMethod(data) {
     const raw = typeof data?.auth_method === "string" ? data.auth_method.trim().toLowerCase() : "";
     return raw || "codex-cli";
@@ -6179,6 +6307,7 @@ var ProfileManager = class {
   }
   async deleteProfileRecordAndHome(record) {
     const profileName = this.normalizeProfileName(record.name);
+    const snapshotKeys = this.rateLimitSnapshotKeysForRecord(record);
     if (!record.accountId) {
       const dashboardState = await this.readProfileDashboardState();
       delete dashboardState.customGroupsByAccountKey[resolveFallbackAccountKey(profileName)];
@@ -6192,6 +6321,7 @@ var ProfileManager = class {
       }
     }
     await this.deleteProfileRecord(profileName);
+    await deleteRateLimitSnapshots(snapshotKeys);
   }
   buildProfileFromData(name, data, fallback) {
     const metadata = fallback?.metadata ?? this.extractProfileMetadata(data);
@@ -6918,6 +7048,25 @@ var ProfileManager = class {
       });
     }
   }
+  async readConfirmedRateLimits(name, options = {}) {
+    const profileName = this.normalizeProfileName(name);
+    try {
+      return await this.enqueueProfileOperation(
+        profileName,
+        () => this.runWithPreparedProfileHome(
+          profileName,
+          (env) => fetchRateLimitsViaRpc(env, { codexPath: options.codexPath }),
+          { syncFromActiveAuthBeforeAction: false }
+        )
+      );
+    } finally {
+      await this.enqueueAuthSwap(async () => {
+        await this.syncActiveAuthFromProfileIfCurrent(profileName);
+      }).catch((error) => {
+        logWarn(`Failed to sync active auth after rate-limit confirmation for '${profileName}':`, error);
+      });
+    }
+  }
   async activateResetWindow(name, options = {}) {
     const profileName = this.normalizeProfileName(name);
     try {
@@ -7105,6 +7254,7 @@ var ProfileManager = class {
     }
     if (removed.length > 0) {
       await this.writeProfilesStateMap(nextMap);
+      await pruneRateLimitSnapshots(this.rateLimitSnapshotKeysForStateMap(nextMap));
     }
     return removed;
   }
@@ -7247,6 +7397,7 @@ var ProfileManager = class {
       nextMap[record.name] = this.toStateRecord(record);
     }
     await this.writeProfilesStateMap(nextMap);
+    await pruneRateLimitSnapshots(this.rateLimitSnapshotKeysForStateMap(nextMap));
     let removed = 0;
     for (const name of existingNames) {
       if (normalized.has(name)) {
@@ -7720,7 +7871,7 @@ function pruneStore(store) {
   return store;
 }
 function resolveAccountPoolDbPath(stateDir) {
-  return import_node_path6.default.join(stateDir, "state.sqlite");
+  return import_node_path7.default.join(stateDir, "state.sqlite");
 }
 async function readStore(stateDir) {
   const dbPath = resolveAccountPoolDbPath(stateDir);
@@ -7823,9 +7974,9 @@ async function listSessions(stateDir) {
 }
 function resolveRuntimeStateDir(runtime, explicitStateDir) {
   if (explicitStateDir) {
-    return import_node_path6.default.resolve(explicitStateDir);
+    return import_node_path7.default.resolve(explicitStateDir);
   }
-  return import_node_path6.default.join(getUserDataDir(), DESKTOP_RPC_STATE_DIR);
+  return import_node_path7.default.join(getUserDataDir(), DESKTOP_RPC_STATE_DIR);
 }
 function resolveStateDir(flags) {
   const runtimeFlag = parseStringFlag(flags, "--runtime")?.trim().toLowerCase();
@@ -8282,8 +8433,7 @@ function maxUsedPercent(snapshot) {
   }
   const candidates = [
     snapshot.primary?.usedPercent,
-    snapshot.secondary?.usedPercent,
-    ...(snapshot.extraWindows ?? []).map((window) => window.usedPercent)
+    snapshot.secondary?.usedPercent
   ].filter((value) => typeof value === "number" && Number.isFinite(value));
   if (candidates.length === 0) {
     return null;
@@ -8293,14 +8443,14 @@ function maxUsedPercent(snapshot) {
 
 // src/platform/codexCli.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs4 = require("fs");
-var import_node_path7 = __toESM(require("path"));
+var import_node_fs5 = 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_path7.default.resolve(candidate);
+  const resolved = import_node_path8.default.resolve(candidate);
   try {
-    const stat2 = (0, import_node_fs4.statSync)(resolved);
+    const stat2 = (0, import_node_fs5.statSync)(resolved);
     if (stat2.isFile()) return resolved;
   } catch {
     return null;
@@ -8318,9 +8468,9 @@ function resolveFromEnv() {
 }
 function resolveFromPath() {
   const pathValue = process.env.PATH ?? "";
-  const entries = pathValue.split(import_node_path7.default.delimiter).filter(Boolean);
+  const entries = pathValue.split(import_node_path8.default.delimiter).filter(Boolean);
   for (const entry of entries) {
-    const candidate = fileExists2(import_node_path7.default.join(entry, "codex"));
+    const candidate = fileExists2(import_node_path8.default.join(entry, "codex"));
     if (candidate) return candidate;
   }
   return null;
@@ -8412,8 +8562,7 @@ function formatUsagePercent(value) {
 function snapshotResetSeconds(snapshot) {
   const values = [
     snapshot?.primary?.resetsInSeconds,
-    snapshot?.secondary?.resetsInSeconds,
-    ...(snapshot?.extraWindows ?? []).map((window) => window.resetsInSeconds)
+    snapshot?.secondary?.resetsInSeconds
   ].filter((value) => typeof value === "number" && Number.isFinite(value));
   return values.length > 0 ? Math.min(...values) : null;
 }
@@ -8698,14 +8847,14 @@ async function assertProfileCreationAllowed(profileManager) {
 // ../../packages/runtime-codex/src/codex/officialAppRestart.ts
 var import_node_child_process5 = require("child_process");
 var import_node_crypto5 = require("crypto");
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_os3 = require("os");
 var import_node_net = __toESM(require("net"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/threadUsage.ts
-var import_node_fs5 = require("fs");
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_fs6 = require("fs");
+var import_node_path9 = __toESM(require("path"), 1);
 var ROLLOUT_DIRS = ["sessions", "archived_sessions"];
 function isRecord5(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -8715,7 +8864,7 @@ async function collectRolloutFiles(root) {
   async function visit(dir) {
     let entries;
     try {
-      entries = await import_node_fs5.promises.readdir(dir, {
+      entries = await import_node_fs6.promises.readdir(dir, {
         withFileTypes: true,
         encoding: "utf8"
       });
@@ -8725,7 +8874,7 @@ async function collectRolloutFiles(root) {
     const childVisits = [];
     for (const entry of entries) {
       const entryName = String(entry.name);
-      const entryPath = import_node_path8.default.join(dir, entryName);
+      const entryPath = import_node_path9.default.join(dir, entryName);
       if (entry.isDirectory()) {
         childVisits.push(visit(entryPath));
         continue;
@@ -8744,14 +8893,14 @@ async function findRolloutFileByScan(profileHome, threadId) {
   let best = null;
   const variants = threadIdVariants(threadId);
   for (const dirname of ROLLOUT_DIRS) {
-    const root = import_node_path8.default.join(profileHome, dirname);
+    const root = import_node_path9.default.join(profileHome, dirname);
     const files = await collectRolloutFiles(root);
     for (const file of files) {
-      const basename = import_node_path8.default.basename(file);
+      const basename = import_node_path9.default.basename(file);
       if (!variants.some((variant) => basename.includes(variant))) {
         continue;
       }
-      const stat2 = await import_node_fs5.promises.stat(file).catch(() => null);
+      const stat2 = await import_node_fs6.promises.stat(file).catch(() => null);
       const updatedAtMs = stat2 && Number.isFinite(stat2.mtimeMs) ? stat2.mtimeMs : null;
       if (!best || (updatedAtMs ?? 0) > (best.updatedAtMs ?? 0) || (updatedAtMs ?? 0) === (best.updatedAtMs ?? 0) && file > best.path) {
         best = { path: file, updatedAtMs };
@@ -8823,12 +8972,12 @@ function resolveRolloutPath(profileHome, rolloutPath) {
   if (!rolloutPath) {
     return null;
   }
-  return import_node_path8.default.isAbsolute(rolloutPath) ? rolloutPath : import_node_path8.default.join(profileHome, rolloutPath);
+  return import_node_path9.default.isAbsolute(rolloutPath) ? rolloutPath : import_node_path9.default.join(profileHome, rolloutPath);
 }
 async function readThreadRecordFromStateDb(profileHome, threadId) {
-  const dbPath = import_node_path8.default.join(profileHome, "state_5.sqlite");
+  const dbPath = import_node_path9.default.join(profileHome, "state_5.sqlite");
   try {
-    await import_node_fs5.promises.access(dbPath);
+    await import_node_fs6.promises.access(dbPath);
   } catch {
     return null;
   }
@@ -12935,18 +13084,18 @@ function startOfficialCodexBridgeActionListener(args) {
         if (!requestId || !rememberBridgeActionId(requestId)) {
           return;
         }
-        const path14 = typeof payload.path === "string" ? payload.path.trim().slice(0, 64) : "";
+        const path15 = typeof payload.path === "string" ? payload.path.trim().slice(0, 64) : "";
         const requestHandler = officialCodexBridgeRequestHandler;
         void (async () => {
           let result;
-          if (!path14) {
+          if (!path15) {
             result = { status: "failed", reason: "missing-path" };
           } else if (!requestHandler) {
             result = { status: "failed", reason: "no-request-handler" };
           } else {
             try {
               result = await requestHandler({
-                path: path14,
+                path: path15,
                 payload: payload.payload ?? null,
                 sourceProfileName: profileName
               });
@@ -13364,7 +13513,7 @@ async function readProcessRows() {
   });
 }
 function getMainExecutablePath(candidate) {
-  return import_node_path9.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
+  return import_node_path10.default.join(candidate.appPath, "Contents", "MacOS", candidate.executableName);
 }
 function isMainProcessRow(row, candidate) {
   return row.args.includes(getMainExecutablePath(candidate));
@@ -13586,15 +13735,15 @@ function classifyOpenCodexLaunchFailure(error) {
 }
 async function openCodexWithProfileHome(candidate, profileHome, profileName, cdpPort, previousPids, options = {}) {
   const executablePath = getMainExecutablePath(candidate);
-  if (!(0, import_node_fs6.existsSync)(executablePath)) {
+  if (!(0, import_node_fs7.existsSync)(executablePath)) {
     return { opened: false, pid: null, reason: "app-executable-missing" };
   }
   const telemetryLabel = `codexuse-profile-${encodeURIComponent(profileName)}`;
-  const appUserDataDir = options.useDefaultUserData === false ? import_node_path9.default.join(profileHome, "codex-app-user-data") : null;
+  const appUserDataDir = options.useDefaultUserData === false ? import_node_path10.default.join(profileHome, "codex-app-user-data") : null;
   let child;
   try {
     if (appUserDataDir) {
-      (0, import_node_fs6.mkdirSync)(appUserDataDir, { recursive: true });
+      (0, import_node_fs7.mkdirSync)(appUserDataDir, { recursive: true });
     }
     child = (0, import_node_child_process5.spawn)(
       "/usr/bin/open",
@@ -13652,8 +13801,8 @@ async function openCodexWithProfileHome(candidate, profileHome, profileName, cdp
   };
 }
 async function readBundleString(appPath, key) {
-  const plistPath = import_node_path9.default.join(appPath, "Contents", "Info.plist");
-  if (!(0, import_node_fs6.existsSync)(plistPath)) {
+  const plistPath = import_node_path10.default.join(appPath, "Contents", "Info.plist");
+  if (!(0, import_node_fs7.existsSync)(plistPath)) {
     return null;
   }
   const result = await runCommand2("/usr/bin/plutil", [
@@ -13673,7 +13822,7 @@ async function readBundleString(appPath, key) {
 async function collectCodexAppCandidates(rawPaths) {
   const candidates = [];
   for (const appPath of rawPaths) {
-    if (!(0, import_node_fs6.existsSync)(appPath) || import_node_path9.default.basename(appPath) !== "Codex.app") {
+    if (!(0, import_node_fs7.existsSync)(appPath) || import_node_path10.default.basename(appPath) !== "Codex.app") {
       continue;
     }
     const bundleId = await readBundleString(appPath, "CFBundleIdentifier");
@@ -13690,7 +13839,7 @@ async function collectCodexAppCandidates(rawPaths) {
   return candidates.sort((a, b) => a.appPath.localeCompare(b.appPath));
 }
 function addCodexAppPathsFromDirectory(rawPaths, rootPath, maxDepth = 2) {
-  if (!(0, import_node_fs6.existsSync)(rootPath)) {
+  if (!(0, import_node_fs7.existsSync)(rootPath)) {
     return;
   }
   const pending = [{ directory: rootPath, depth: 0 }];
@@ -13698,7 +13847,7 @@ function addCodexAppPathsFromDirectory(rawPaths, rootPath, maxDepth = 2) {
     const current = pending.shift();
     let entries;
     try {
-      entries = (0, import_node_fs6.readdirSync)(current.directory, { withFileTypes: true });
+      entries = (0, import_node_fs7.readdirSync)(current.directory, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -13706,7 +13855,7 @@ function addCodexAppPathsFromDirectory(rawPaths, rootPath, maxDepth = 2) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const childPath = import_node_path9.default.join(current.directory, entry.name);
+      const childPath = import_node_path10.default.join(current.directory, entry.name);
       if (entry.name === "Codex.app") {
         rawPaths.add(childPath);
         continue;
@@ -13729,9 +13878,9 @@ async function discoverCodexAppCandidates() {
     rawPaths.add(envPath);
   }
   rawPaths.add("/Applications/Codex.app");
-  rawPaths.add(import_node_path9.default.join((0, import_node_os3.homedir)(), "Applications", "Codex.app"));
+  rawPaths.add(import_node_path10.default.join((0, import_node_os3.homedir)(), "Applications", "Codex.app"));
   addCodexAppPathsFromDirectory(rawPaths, "/Applications");
-  addCodexAppPathsFromDirectory(rawPaths, import_node_path9.default.join((0, import_node_os3.homedir)(), "Applications"));
+  addCodexAppPathsFromDirectory(rawPaths, import_node_path10.default.join((0, import_node_os3.homedir)(), "Applications"));
   const sorted = await collectCodexAppCandidates(rawPaths);
   appDiscoveryCache = {
     envPath,
@@ -13742,7 +13891,7 @@ async function discoverCodexAppCandidates() {
 }
 function getRunningCodexPidsFromRows(candidate, rows) {
   const pids = /* @__PURE__ */ new Set();
-  const appContentsRoot = `${import_node_path9.default.join(candidate.appPath, "Contents")}${import_node_path9.default.sep}`;
+  const appContentsRoot = `${import_node_path10.default.join(candidate.appPath, "Contents")}${import_node_path10.default.sep}`;
   for (const row of rows) {
     if (row.args.includes(appContentsRoot)) {
       pids.add(row.pid);
@@ -13752,7 +13901,7 @@ function getRunningCodexPidsFromRows(candidate, rows) {
 }
 function getRunningCodexMainPidsFromRows(candidate, rows) {
   const pids = /* @__PURE__ */ new Set();
-  const executablePath = import_node_path9.default.join(
+  const executablePath = import_node_path10.default.join(
     candidate.appPath,
     "Contents",
     "MacOS",
@@ -13783,7 +13932,7 @@ async function resolveCodexAppTarget() {
   const mainPids = getRunningCodexMainPidsFromRows(fallback, rows);
   return { candidate: fallback, runningPids, mainPids };
 }
-var SHARED_CODEX_HOME = import_node_path9.default.join((0, import_node_os3.homedir)(), ".codex");
+var SHARED_CODEX_HOME = import_node_path10.default.join((0, import_node_os3.homedir)(), ".codex");
 function toIso(value) {
   return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : null;
 }
@@ -15544,7 +15693,7 @@ var import_toml3 = __toESM(require_toml(), 1);
 // ../../packages/runtime-codex/src/codex/config-metadata.ts
 var import_node_child_process6 = require("child_process");
 var import_promises = require("fs/promises");
-var import_node_path10 = __toESM(require("path"), 1);
+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";
 var METADATA_CACHE_TTL_MS = 6e4;
 var FALLBACK_SCHEMA_TOP_LEVEL_KEYS = [
@@ -15730,8 +15879,8 @@ function parseSchemaKeys(schemaRaw) {
 async function readSchemaFromLocal() {
   const candidates = [
     process.env.CODEX_CONFIG_SCHEMA_PATH,
-    import_node_path10.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
-    import_node_path10.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
+    import_node_path11.default.join(process.cwd(), "codex-rs", "core", "config.schema.json"),
+    import_node_path11.default.join(process.cwd(), "node_modules", "@openai", "codex", "codex-rs", "core", "config.schema.json")
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
     try {
@@ -15836,11 +15985,11 @@ async function getCodexConfigMetadata(forceRefresh = false) {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 var import_promises2 = require("fs/promises");
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/home.ts
 var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 function resolveHomeDir() {
   return process.env.HOME || import_node_os4.default.homedir();
 }
@@ -15849,7 +15998,7 @@ function expandHomePrefix(input, homeDir) {
     return homeDir;
   }
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return import_node_path11.default.join(homeDir, input.slice(2));
+    return import_node_path12.default.join(homeDir, input.slice(2));
   }
   return input;
 }
@@ -15865,10 +16014,10 @@ function normalizeCodexHomePath(input) {
   if (!configured) {
     return null;
   }
-  return import_node_path11.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
+  return import_node_path12.default.resolve(expandHomePrefix(configured, resolveHomeDir()));
 }
 function resolveDefaultCodexHomeDir() {
-  return import_node_path11.default.join(resolveHomeDir(), ".codex");
+  return import_node_path12.default.join(resolveHomeDir(), ".codex");
 }
 function resolveCodexHomeDir(options) {
   return normalizeCodexHomePath(options?.codexHomePath) ?? resolveDefaultCodexHomeDir();
@@ -15941,10 +16090,10 @@ var YOLO_PRESET = {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 function getConfigPath(options) {
-  return import_node_path12.default.join(resolveCodexHomeDir(options), "config.toml");
+  return import_node_path13.default.join(resolveCodexHomeDir(options), "config.toml");
 }
 async function ensureConfigDirExists(filePath) {
-  const dir = import_node_path12.default.dirname(filePath);
+  const dir = import_node_path13.default.dirname(filePath);
   await (0, import_promises2.mkdir)(dir, { recursive: true });
 }
 function normalizeLineEndings(content) {
@@ -17103,7 +17252,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "5.0.8" : "0.0.0";
+var VERSION = true ? "5.1.0" : "0.0.0";
 async function runCli() {
   const args = process.argv.slice(2);
   if (args.length === 0) {