codexuse-cli 6.0.0 → 6.0.2

package/dist/index.js

@@ -5175,7 +5175,19 @@ var LicenseService = class {
     this.verificationPromise = null;
   }
   async getCachedStatus() {
-    return this.getStatus({ allowStale: true, refreshInBackground: true });
+    try {
+      return await this.getStatus({ allowStale: true, refreshInBackground: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "License status could not be loaded.";
+      console.warn("Cached license status unavailable:", error);
+      return toLicenseStatus(null, {
+        state: "error",
+        profileLimit: null,
+        profilesRemaining: null,
+        message: "License status is temporarily unavailable.",
+        error: message
+      });
+    }
   }
   async getStatus(options = {}) {
     const forceRefresh = Boolean(options.forceRefresh);
@@ -5661,10 +5673,15 @@ function resolveProfileCodexHomeDir(profileHomeId) {
   const currentExists = (0, import_node_fs3.existsSync)(current);
   const legacyExists = (0, import_node_fs3.existsSync)(legacy);
   if (currentExists && legacyExists) {
-    throw new Error("profile-home-location-conflict");
+    return current;
   }
   return legacyExists ? legacy : current;
 }
+function findProfileCodexHomeLocationConflict(profileHomeId) {
+  const current = resolveCurrentProfileCodexHomeDir(profileHomeId);
+  const legacy = import_node_path5.default.join(resolveLegacyProfileCodexHomesRoot(), profileHomeId);
+  return (0, import_node_fs3.existsSync)(current) && (0, import_node_fs3.existsSync)(legacy) ? { current, legacy } : null;
+}
 function resolveProfileCodexHomesRoot() {
   return import_node_path5.default.join(resolveHomeDir(), ".codexuse", "p");
 }
@@ -5688,7 +5705,7 @@ async function migrateProfileCodexHomeDir(profileHomeId) {
   const currentExists = (0, import_node_fs3.existsSync)(current);
   const legacyExists = (0, import_node_fs3.existsSync)(legacy);
   if (currentExists && legacyExists) {
-    throw new Error("profile-home-location-conflict");
+    return current;
   }
   if (currentExists || !legacyExists) {
     return current;
@@ -36330,11 +36347,18 @@ var ProfileManager = class {
   }
   async migrateCredentialsToProfileHomes() {
     const source = await this.readProfilesStateSource();
+    await this.reconcileProfileHomeLocationConflicts(source);
     const homeIdsByProfileName = /* @__PURE__ */ new Map();
     const profileNamesByHomeId = /* @__PURE__ */ new Map();
     for (const [profileName, raw] of Object.entries(source)) {
-      const homeId = normalizeProfileHomeId(raw.homeId);
-      if (!homeId) {
+      let record2;
+      try {
+        record2 = this.fromStateRecord(profileName, raw);
+      } catch {
+        continue;
+      }
+      const homeId = record2 ? normalizeProfileHomeId(raw.homeId) : null;
+      if (!record2 || !homeId) {
         continue;
       }
       const collisionKey = homeId.toLowerCase();
@@ -36471,6 +36495,74 @@ var ProfileManager = class {
       );
     }
   }
+  async reconcileProfileHomeLocationConflicts(source) {
+    for (const [profileName, raw] of Object.entries(source)) {
+      try {
+        const record2 = this.fromStateRecord(profileName, raw);
+        if (!record2) {
+          continue;
+        }
+        const conflict = findProfileCodexHomeLocationConflict(record2.homeId);
+        if (!conflict) {
+          continue;
+        }
+        const currentAuthPath = (0, import_path2.join)(conflict.current, "auth.json");
+        const legacyAuthPath = (0, import_path2.join)(conflict.legacy, "auth.json");
+        await this.withProfileAuthFileLock(currentAuthPath, async (currentRaw) => {
+          await this.withProfileAuthFileLock(legacyAuthPath, async (legacyRaw) => {
+            if (!legacyRaw?.trim()) {
+              return;
+            }
+            let legacyAuth;
+            try {
+              legacyAuth = JSON.parse(legacyRaw);
+            } catch (error) {
+              throw errorWithCause("Legacy profile auth is invalid.", error);
+            }
+            if (!this.activeAuthMatchesRecord(legacyAuth, record2)) {
+              throw new Error("Legacy profile auth has a different identity.");
+            }
+            if (!currentRaw?.trim()) {
+              await this.replaceProfileAuthPathIfCurrent(
+                currentAuthPath,
+                currentRaw,
+                legacyRaw
+              );
+              return;
+            }
+            let currentAuth;
+            try {
+              currentAuth = JSON.parse(currentRaw);
+            } catch (error) {
+              throw errorWithCause("Current profile auth is invalid.", error);
+            }
+            if (!this.activeAuthMatchesRecord(currentAuth, record2)) {
+              throw new Error("Current profile auth has a different identity.");
+            }
+            const currentRecency = this.getProfileTokenRecencyMs(
+              this.normalizeProfileData(currentAuth)
+            );
+            const legacyRecency = this.getProfileTokenRecencyMs(
+              this.normalizeProfileData(legacyAuth)
+            );
+            if (typeof legacyRecency !== "number" || typeof currentRecency === "number" && legacyRecency <= currentRecency) {
+              return;
+            }
+            await this.replaceProfileAuthPathIfCurrent(
+              currentAuthPath,
+              currentRaw,
+              legacyRaw
+            );
+          });
+        });
+      } catch (error) {
+        logWarn(
+          `Could not reconcile the upgrade profile home for '${profileName}':`,
+          error
+        );
+      }
+    }
+  }
   enqueueAuthSwap(task) {
     const run2 = globalAuthSwapLock.then(task, task);
     globalAuthSwapLock = run2.then(
@@ -37077,22 +37169,43 @@ var ProfileManager = class {
     const byIdentityWorkspace = /* @__PURE__ */ new Map();
     let cacheable = true;
     for (const [profileName, raw] of Object.entries(source)) {
-      const storedRecord = this.fromStateRecord(profileName, raw);
+      let storedRecord;
+      try {
+        storedRecord = this.fromStateRecord(profileName, raw);
+      } catch (error) {
+        logWarn(`Failed to read saved profile '${profileName}':`, error);
+        cacheable = false;
+        continue;
+      }
       if (!storedRecord) {
         continue;
       }
-      const hydration = await this.hydrateProfileRecordWithStatus(storedRecord);
+      let hydration;
+      try {
+        hydration = await this.hydrateProfileRecordWithStatus(storedRecord);
+      } catch (error) {
+        logWarn(
+          `Failed to hydrate profile '${profileName}'; using its saved metadata:`,
+          error
+        );
+        hydration = { record: storedRecord, cacheable: false };
+      }
       const record2 = hydration.record;
       cacheable = cacheable && hydration.cacheable;
       records.push(record2);
-      const identityKey = this.resolveProfileIdentityFromRecord(record2);
-      const workspaceId = record2.workspaceId ?? record2.data.workspace_id ?? DEFAULT_WORKSPACE_ID;
-      const key = this.identityWorkspaceIndexKey(identityKey, workspaceId);
-      const bucket = byIdentityWorkspace.get(key);
-      if (bucket) {
-        bucket.push(record2);
-      } else {
-        byIdentityWorkspace.set(key, [record2]);
+      try {
+        const identityKey = this.resolveProfileIdentityFromRecord(record2);
+        const workspaceId = record2.workspaceId ?? record2.data.workspace_id ?? DEFAULT_WORKSPACE_ID;
+        const key = this.identityWorkspaceIndexKey(identityKey, workspaceId);
+        const bucket = byIdentityWorkspace.get(key);
+        if (bucket) {
+          bucket.push(record2);
+        } else {
+          byIdentityWorkspace.set(key, [record2]);
+        }
+      } catch (error) {
+        logWarn(`Failed to index saved profile '${profileName}':`, error);
+        cacheable = false;
       }
     }
     const index2 = { sourceFingerprint, records, byIdentityWorkspace };
@@ -37107,7 +37220,13 @@ var ProfileManager = class {
     if (migrationError) {
       return { record: record2, cacheable: false };
     }
-    const authPath = import_path.default.join(this.getProfileHomePath(record2.homeId), "auth.json");
+    let authPath;
+    try {
+      authPath = import_path.default.join(this.getProfileHomePath(record2.homeId), "auth.json");
+    } catch (error) {
+      logWarn(`Failed to resolve profile home for '${record2.name}':`, error);
+      return { record: record2, cacheable: false };
+    }
     let authRaw;
     try {
       const recovered = await this.readProfileAuthFile(authPath);
@@ -38692,7 +38811,18 @@ var ProfileManager = class {
     await this.initialize();
     try {
       const records = await this.listProfileRecords();
-      return records.map((record2) => this.buildProfileFromRow(record2)).filter((profile) => !profile.authMethod || profile.authMethod === "codex-cli").sort((a, b) => {
+      const profiles = [];
+      for (const record2 of records) {
+        try {
+          const profile = this.buildProfileFromRow(record2);
+          if (!profile.authMethod || profile.authMethod === "codex-cli") {
+            profiles.push(profile);
+          }
+        } catch (error) {
+          logWarn(`Failed to build saved profile '${record2.name}':`, error);
+        }
+      }
+      return profiles.sort((a, b) => {
         const aLabel = a.displayName ?? a.name;
         const bLabel = b.displayName ?? b.name;
         const base2 = aLabel.localeCompare(bLabel);
@@ -38700,7 +38830,7 @@ var ProfileManager = class {
       });
     } catch (error) {
       logError("Error reading profiles from disk:", error);
-      return [];
+      throw error;
     }
   }
   async runWithPreparedProfileHome(name, action, options = {}) {
@@ -40038,9 +40168,11 @@ async function listManagedProfiles(profileManager) {
     return labelOrder !== 0 ? labelOrder : left.name.localeCompare(right.name);
   });
 }
-async function getCurrentManagedProfile(profileManager) {
+async function getCurrentManagedProfile(profileManager, activeCodexAuth) {
   const [currentOpenAiProfile, state] = await Promise.all([
-    profileManager.getCurrentProfile(),
+    activeCodexAuth ? Promise.resolve(
+      activeCodexAuth.state === "matched" && activeCodexAuth.profileName ? { name: activeCodexAuth.profileName, trusted: true } : { name: null, trusted: false }
+    ) : profileManager.getCurrentProfile(),
     getAppState()
   ]);
   const lastProfileName = state.app.lastProfileName?.trim() || null;
@@ -44640,7 +44772,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "6.0.0" : "0.0.0";
+var VERSION = true ? "6.0.2" : "0.0.0";
 async function runCli() {
   const args2 = process.argv.slice(2);
   if (args2.length === 0) {