codexuse-cli 6.4.0 → 6.4.1

package/dist/index.js

@@ -6666,7 +6666,7 @@ function shouldEnforceProfileLimit(status) {
 
 // ../../packages/runtime-profiles/src/profiles/profile-manager.ts
 var import_node_crypto15 = require("crypto");
-var import_fs = require("fs");
+var import_fs3 = require("fs");
 var import_node_os8 = __toESM(require("os"), 1);
 var import_path = __toESM(require("path"), 1);
 var import_path2 = require("path");
@@ -6722,6 +6722,20 @@ function resolveProfileIdentityKeyFromProfile(profile) {
   return resolveProfileIdentityKey(profile) ?? `profile:${profile.name}`;
 }
 
+// ../../packages/shared/src/core/fs.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+async function syncDirectory(directoryPath) {
+  if (process.platform === "win32") {
+    return;
+  }
+  const directory = await import_promises2.default.open(directoryPath, "r");
+  try {
+    await directory.sync();
+  } finally {
+    await directory.close();
+  }
+}
+
 // ../../packages/runtime-codex/src/codex/rpc.ts
 var import_node_child_process5 = require("child_process");
 var import_node_crypto11 = require("crypto");
@@ -7016,7 +7030,7 @@ function buildCodexCommand(binaryPath, args2, env) {
 // ../../packages/runtime-codex/src/codex/home.ts
 var import_node_crypto9 = require("crypto");
 var import_node_fs6 = require("fs");
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_node_os4 = __toESM(require("os"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
 function resolveHomeDir() {
@@ -7078,11 +7092,11 @@ function resolveProfileCodexHomesRoot() {
 async function ensureProfileCodexHomesRoot() {
   const root = resolveProfileCodexHomesRoot();
   const parent = import_node_path8.default.dirname(root);
-  await (0, import_promises2.mkdir)(parent, { recursive: true, mode: 448 });
-  await (0, import_promises2.mkdir)(root, { recursive: true, mode: 448 });
+  await (0, import_promises3.mkdir)(parent, { recursive: true, mode: 448 });
+  await (0, import_promises3.mkdir)(root, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
-    await (0, import_promises2.chmod)(parent, 448);
-    await (0, import_promises2.chmod)(root, 448);
+    await (0, import_promises3.chmod)(parent, 448);
+    await (0, import_promises3.chmod)(root, 448);
   }
   return root;
 }
@@ -7102,7 +7116,7 @@ async function migrateProfileCodexHomeDir(profileHomeId) {
   }
   await ensureProfileCodexHomesRoot();
   try {
-    await (0, import_promises2.rename)(legacy, current);
+    await (0, import_promises3.rename)(legacy, current);
   } catch (error) {
     if (error.code === "EXDEV") {
       throw Object.assign(new Error("profile-home-cross-volume-unsupported"), {
@@ -7169,7 +7183,7 @@ var import_toml = __toESM(require_toml(), 1);
 
 // ../../packages/runtime-codex/src/codex/config-metadata.ts
 var import_node_child_process4 = require("child_process");
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var import_node_path9 = __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;
@@ -7361,7 +7375,7 @@ async function readSchemaFromLocal() {
   ].filter((candidate) => Boolean(candidate));
   for (const candidate of candidates) {
     try {
-      return await (0, import_promises3.readFile)(candidate, "utf8");
+      return await (0, import_promises4.readFile)(candidate, "utf8");
     } catch {
     }
   }
@@ -7462,7 +7476,7 @@ async function getCodexConfigMetadata(forceRefresh = false) {
 
 // ../../packages/runtime-codex/src/codex/config-io.ts
 var import_node_crypto10 = require("crypto");
-var import_promises4 = require("fs/promises");
+var import_promises5 = require("fs/promises");
 var import_node_path10 = __toESM(require("path"), 1);
 
 // ../../packages/runtime-codex/src/codex/config-presets.ts
@@ -7510,20 +7524,20 @@ function getConfigPath(options) {
 }
 async function ensureConfigDirExists(filePath) {
   const dir = import_node_path10.default.dirname(filePath);
-  await (0, import_promises4.mkdir)(dir, { recursive: true });
+  await (0, import_promises5.mkdir)(dir, { recursive: true });
 }
 async function resolveConfigWriteTarget(configPath) {
   try {
-    if (!(await (0, import_promises4.lstat)(configPath)).isSymbolicLink()) {
+    if (!(await (0, import_promises5.lstat)(configPath)).isSymbolicLink()) {
       return configPath;
     }
     try {
-      return await (0, import_promises4.realpath)(configPath);
+      return await (0, import_promises5.realpath)(configPath);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw error;
       }
-      return import_node_path10.default.resolve(import_node_path10.default.dirname(configPath), await (0, import_promises4.readlink)(configPath));
+      return import_node_path10.default.resolve(import_node_path10.default.dirname(configPath), await (0, import_promises5.readlink)(configPath));
     }
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -7535,19 +7549,19 @@ async function resolveConfigWriteTarget(configPath) {
 async function removeStaleConfigStagingFiles(targetPath) {
   const directory = import_node_path10.default.dirname(targetPath);
   const prefix = `${import_node_path10.default.basename(targetPath)}.tmp-`;
-  const entries3 = await (0, import_promises4.readdir)(directory).catch((error) => {
+  const entries3 = await (0, import_promises5.readdir)(directory).catch((error) => {
     if (error.code === "ENOENT") {
       return [];
     }
     throw error;
   });
   await Promise.all(
-    entries3.filter((entry) => entry.startsWith(prefix)).map((entry) => (0, import_promises4.rm)(import_node_path10.default.join(directory, entry), { force: true }))
+    entries3.filter((entry) => entry.startsWith(prefix)).map((entry) => (0, import_promises5.rm)(import_node_path10.default.join(directory, entry), { force: true }))
   );
 }
 async function resolveConfigWriteMode(targetPath) {
   try {
-    return (await (0, import_promises4.stat)(targetPath)).mode & 511;
+    return (await (0, import_promises5.stat)(targetPath)).mode & 511;
   } catch (error) {
     if (error.code === "ENOENT") {
       return 384;
@@ -7566,7 +7580,7 @@ async function readConfigContent(options) {
   return withCloudSyncTransaction(getUserDataDir(), "read", async () => {
     const configPath = getConfigPath(options);
     try {
-      const content = await (0, import_promises4.readFile)(configPath, "utf8");
+      const content = await (0, import_promises5.readFile)(configPath, "utf8");
       return {
         exists: true,
         content: normalizeLineEndings(content)
@@ -7593,25 +7607,20 @@ async function writeConfigContent(content, options) {
     const normalized = ensureTrailingNewline(normalizeLineEndings(content));
     const stagingPath = `${targetPath}.tmp-${process.pid}-${(0, import_node_crypto10.randomUUID)()}`;
     try {
-      const handle = await (0, import_promises4.open)(stagingPath, "wx", mode);
+      const handle = await (0, import_promises5.open)(stagingPath, "wx", mode);
       try {
         await handle.writeFile(normalized, "utf8");
         await handle.sync();
       } finally {
         await handle.close();
       }
-      await (0, import_promises4.rename)(stagingPath, targetPath);
+      await (0, import_promises5.rename)(stagingPath, targetPath);
       if (process.platform !== "win32") {
-        await (0, import_promises4.chmod)(targetPath, mode);
-        const directory = await (0, import_promises4.open)(import_node_path10.default.dirname(targetPath), "r");
-        try {
-          await directory.sync();
-        } finally {
-          await directory.close();
-        }
+        await (0, import_promises5.chmod)(targetPath, mode);
       }
+      await syncDirectory(import_node_path10.default.dirname(targetPath));
     } finally {
-      await (0, import_promises4.rm)(stagingPath, { force: true });
+      await (0, import_promises5.rm)(stagingPath, { force: true });
     }
   });
 }
@@ -7619,19 +7628,14 @@ async function removeConfigContent(options) {
   await withCloudSyncTransaction(getUserDataDir(), "write", async () => {
     const configPath = getConfigPath(options);
     try {
-      await (0, import_promises4.unlink)(configPath);
+      await (0, import_promises5.unlink)(configPath);
     } catch (error) {
       if (error.code === "ENOENT") {
         return;
       }
       throw error;
     }
-    const directory = await (0, import_promises4.open)(import_node_path10.default.dirname(configPath), "r");
-    try {
-      await directory.sync();
-    } finally {
-      await directory.close();
-    }
+    await syncDirectory(import_node_path10.default.dirname(configPath));
   });
 }
 async function getUpdatedAt(configPath, exists) {
@@ -7639,7 +7643,7 @@ async function getUpdatedAt(configPath, exists) {
     return null;
   }
   try {
-    const stats = await (0, import_promises4.stat)(configPath);
+    const stats = await (0, import_promises5.stat)(configPath);
     return stats.mtimeMs;
   } catch (error) {
     const nodeError = error;
@@ -25939,14 +25943,7 @@ async function writeAtomicPath(filePath, content) {
   }
   try {
     await import_node_fs7.promises.rename(tempPath, filePath);
-    if (process.platform !== "win32") {
-      const dirHandle = await import_node_fs7.promises.open(dir, "r");
-      try {
-        await dirHandle.sync();
-      } finally {
-        await dirHandle.close();
-      }
-    }
+    await syncDirectory(dir);
   } finally {
     await import_node_fs7.promises.rm(tempPath, { force: true }).catch(() => void 0);
   }
@@ -27092,7 +27089,7 @@ async function findOfficialCodexThreadRecord(profileHome, threadId, options = {}
 // ../../packages/runtime-codex/src/codex/sharedHistory.ts
 var import_node_crypto12 = require("crypto");
 var import_node_fs9 = require("fs");
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var import_node_path13 = __toESM(require("path"), 1);
 var HISTORY_MARKER = ".codexuse-shared-history-v1.json";
 var HISTORY_INDEX = "session_index.jsonl";
@@ -33694,6 +33691,9 @@ function createAppServerRequestClientExpression(options = {}) {
         } catch {
         }
         if (/^\\s*class\\b/.test(source)) continue;
+        // React hooks also mention sendRequest, and calling one outside a
+        // component throws React error #321, which failed every account read.
+        if (/\\(0,\\s*[\\w$]+\\.c\\)\\(\\d+\\)|\\buse(?:Context|State|Ref|Memo|Callback|Effect|SyncExternalStore)\\b/.test(source)) continue;
         if (source.includes(".sendRequest(") || source.includes("send-cli-request-for-host")) return value;
       }
       return null;
@@ -33736,6 +33736,95 @@ function createAppServerRequestClientExpression(options = {}) {
       }
       throw new Error("codex-app-chatgpt-api-client-not-found");
     };
+    // Codex App builds since September 2026 keep the app-server connection in
+    // a scoped store rather than in React props. An exported getter, the one
+    // that throws "AppServerManager RPC is not connected", takes the store
+    // handle a component holds and a host id.
+    const findScopedStoreHandle = () => {
+      const roots = [];
+      const codexRoot = window.__codexRoot?._internalRoot?.current;
+      if (codexRoot) roots.push(codexRoot);
+      const rootElement = document.querySelector("#root");
+      for (const key of Object.getOwnPropertyNames(rootElement || {})) {
+        if (key.startsWith("__reactContainer$") && rootElement[key]) roots.push(rootElement[key]);
+      }
+      const queue = roots.slice();
+      const seen = new WeakSet();
+      for (let cursor = 0; cursor < queue.length && cursor < 80000; cursor += 1) {
+        const value = queue[cursor];
+        if (!value || (typeof value !== "object" && typeof value !== "function") || seen.has(value)) {
+          continue;
+        }
+        seen.add(value);
+        if (
+          typeof value.get === "function" &&
+          typeof value.getOwnValue === "function" &&
+          "scope" in value &&
+          "node" in value
+        ) {
+          return value;
+        }
+        let names = [];
+        try {
+          names = Object.getOwnPropertyNames(value);
+        } catch {
+        }
+        for (const key of names) {
+          if ([
+            "window",
+            "self",
+            "globalThis",
+            "ownerDocument",
+            "defaultView",
+            "parentNode",
+            "parentElement"
+          ].includes(key)) continue;
+          let descriptor = null;
+          try {
+            descriptor = Object.getOwnPropertyDescriptor(value, key);
+          } catch {
+          }
+          const child = descriptor && "value" in descriptor ? descriptor.value : null;
+          if (
+            child &&
+            (typeof child === "object" || typeof child === "function") &&
+            !(typeof Node !== "undefined" && child instanceof Node)
+          ) {
+            queue.push(child);
+          }
+        }
+      }
+      throw new Error("codex-app-scoped-store-not-found");
+    };
+    const resolveScopedHostClient = async () => {
+      if (typeof state.scopedHostClient?.sendRequest === "function") {
+        return state.scopedHostClient;
+      }
+      const handle = findScopedStoreHandle();
+      for (const url of codexAppAssetUrls()) {
+        let module = null;
+        try {
+          module = await loadCodexAppModuleByUrl(url);
+        } catch {
+          continue;
+        }
+        for (const value of Object.values(module || {})) {
+          if (typeof value !== "function") continue;
+          let source = "";
+          try {
+            source = Function.prototype.toString.call(value);
+          } catch {
+          }
+          if (!source.includes("AppServerManager RPC is not connected")) continue;
+          const client = value(handle, "local");
+          if (typeof client?.sendRequest === "function") {
+            state.scopedHostClient = client;
+            return client;
+          }
+        }
+      }
+      throw new Error("codex-app-scoped-host-client-not-found");
+    };
     const resolveClient = async () => {
       try {
         const directHostClient = resolveDirectHostClient();
@@ -33746,6 +33835,16 @@ function createAppServerRequestClientExpression(options = {}) {
       } catch (error) {
         state.directHostError = sanitizeError(error, "direct-host-unavailable");
       }
+      try {
+        const scopedHostClient = await resolveScopedHostClient();
+        // sendRequest here is a store proxy: calling it works, .bind does not.
+        return {
+          directHost: true,
+          sendRequest: (...args) => scopedHostClient.sendRequest(...args)
+        };
+      } catch (error) {
+        state.scopedHostError = sanitizeError(error, "scoped-host-unavailable");
+      }
       try {
         const sendRequest = await resolveHostRequest();
         return { sendRequest };
@@ -37892,7 +37991,7 @@ var ProfileManager = class {
   }
   async readActiveAuthFile() {
     try {
-      const raw = await import_fs.promises.readFile(this.activeAuth, "utf8");
+      const raw = await import_fs3.promises.readFile(this.activeAuth, "utf8");
       const trimmed = raw.trim();
       if (!trimmed) {
         return null;
@@ -37914,7 +38013,7 @@ var ProfileManager = class {
   async readActiveAuthFileStrict() {
     let raw;
     try {
-      raw = await import_fs.promises.readFile(this.activeAuth, "utf8");
+      raw = await import_fs3.promises.readFile(this.activeAuth, "utf8");
     } catch (error) {
       if (this.isNotFoundError(error)) {
         return null;
@@ -37948,7 +38047,7 @@ var ProfileManager = class {
   async captureAuthSnapshotAtPath(authPath) {
     let raw;
     try {
-      raw = await import_fs.promises.readFile(authPath, "utf8");
+      raw = await import_fs3.promises.readFile(authPath, "utf8");
     } catch (error) {
       if (this.isNotFoundError(error)) {
         return this.emptyAuthSnapshot();
@@ -38370,7 +38469,7 @@ var ProfileManager = class {
   async initialize() {
     this.profileHomesRoot = resolveProfileCodexHomesRoot();
     try {
-      await import_fs.promises.mkdir(this.codexDir, { recursive: true });
+      await import_fs3.promises.mkdir(this.codexDir, { recursive: true });
     } catch (error) {
       logError("Failed to ensure Codex directory exists:", error);
       throw errorWithCause("Failed to initialize profile manager", error);
@@ -38460,7 +38559,7 @@ var ProfileManager = class {
           const targetHome = this.getProfileHomePath(nextHomeId);
           let sourceExists = true;
           try {
-            await import_fs.promises.access(sourceHome);
+            await import_fs3.promises.access(sourceHome);
           } catch (error) {
             if (!this.isNotFoundError(error)) {
               throw error;
@@ -38470,7 +38569,7 @@ var ProfileManager = class {
           if (sourceExists) {
             let targetExists = true;
             try {
-              await import_fs.promises.access(targetHome);
+              await import_fs3.promises.access(targetHome);
             } catch (error) {
               if (!this.isNotFoundError(error)) {
                 throw error;
@@ -38502,7 +38601,7 @@ var ProfileManager = class {
             } else {
               const releaseGuard = await this.acquireProfileHomeMutationGuard(record2);
               try {
-                await import_fs.promises.rename(sourceHome, targetHome);
+                await import_fs3.promises.rename(sourceHome, targetHome);
               } finally {
                 await releaseGuard();
               }
@@ -38643,11 +38742,11 @@ var ProfileManager = class {
       dir,
       `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto15.randomUUID)()}.tmp`
     );
-    await import_fs.promises.mkdir(dir, { recursive: true, mode: 448 });
+    await import_fs3.promises.mkdir(dir, { recursive: true, mode: 448 });
     if (process.platform !== "win32") {
-      await import_fs.promises.chmod(dir, 448);
+      await import_fs3.promises.chmod(dir, 448);
     }
-    const handle = await import_fs.promises.open(tempPath, "wx", 384);
+    const handle = await import_fs3.promises.open(tempPath, "wx", 384);
     try {
       await handle.writeFile(contents, "utf8");
       await handle.sync();
@@ -38656,25 +38755,18 @@ var ProfileManager = class {
     }
     try {
       if (process.platform !== "win32") {
-        await import_fs.promises.chmod(tempPath, 384);
-      }
-      await import_fs.promises.rename(tempPath, filePath);
-      if (process.platform !== "win32") {
-        const dirHandle = await import_fs.promises.open(dir, "r");
-        try {
-          await dirHandle.sync();
-        } finally {
-          await dirHandle.close();
-        }
+        await import_fs3.promises.chmod(tempPath, 384);
       }
+      await import_fs3.promises.rename(tempPath, filePath);
+      await syncDirectory(dir);
     } finally {
       try {
-        await import_fs.promises.rm(tempPath, { force: true });
+        await import_fs3.promises.rm(tempPath, { force: true });
       } catch {
       }
     }
     if (process.platform !== "win32") {
-      await import_fs.promises.chmod(filePath, 384);
+      await import_fs3.promises.chmod(filePath, 384);
     }
   }
   async writeAtomicWithReadback(filePath, contents, label) {
@@ -38706,9 +38798,9 @@ var ProfileManager = class {
   async cleanupProfileAuthCas(authPath) {
     const paths = this.profileAuthCasPaths(authPath);
     await Promise.all([
-      import_fs.promises.rm(paths.manifest, { force: true }),
-      import_fs.promises.rm(paths.backup, { force: true }),
-      import_fs.promises.rm(paths.replaced, { force: true })
+      import_fs3.promises.rm(paths.manifest, { force: true }),
+      import_fs3.promises.rm(paths.backup, { force: true }),
+      import_fs3.promises.rm(paths.replaced, { force: true })
     ]);
   }
   async rollbackProfileAuthCas(authPath, manifest) {
@@ -38733,7 +38825,7 @@ var ProfileManager = class {
       throw new Error("Profile auth rollback backup is missing.");
     }
     if (currentRaw !== null) {
-      await import_fs.promises.rename(authPath, paths.replaced);
+      await import_fs3.promises.rename(authPath, paths.replaced);
       const replacedRaw = await this.readOptionalFile(paths.replaced);
       if (this.fingerprintAuthContent(replacedRaw) !== manifest.targetFingerprint) {
         if (await this.readOptionalFile(authPath) === null && replacedRaw) {
@@ -38789,7 +38881,7 @@ var ProfileManager = class {
     let displaced = false;
     try {
       if (expectedRaw !== null) {
-        await import_fs.promises.rename(authPath, paths.backup);
+        await import_fs3.promises.rename(authPath, paths.backup);
         displaced = true;
         if (await this.readOptionalFile(paths.backup) !== expectedRaw) {
           throw new Error(
@@ -38932,7 +39024,7 @@ var ProfileManager = class {
   }
   async readOptionalFile(filePath) {
     try {
-      return await import_fs.promises.readFile(filePath, "utf8");
+      return await import_fs3.promises.readFile(filePath, "utf8");
     } catch (error) {
       if (this.isNotFoundError(error)) {
         return null;
@@ -38972,13 +39064,13 @@ var ProfileManager = class {
     return value3;
   }
   async cleanupAuthMutationFiles() {
-    await import_fs.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_MANIFEST_NAME), {
+    await import_fs3.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_MANIFEST_NAME), {
       force: true
     });
-    await import_fs.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_BACKUP_NAME), {
+    await import_fs3.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_BACKUP_NAME), {
       force: true
     });
-    await import_fs.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_REPLACED_NAME), {
+    await import_fs3.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_REPLACED_NAME), {
       force: true
     });
   }
@@ -38988,7 +39080,7 @@ var ProfileManager = class {
       dir,
       `.${import_path.default.basename(filePath)}.${process.pid}.${(0, import_node_crypto15.randomUUID)()}.install`
     );
-    const handle = await import_fs.promises.open(tempPath, "wx", 384);
+    const handle = await import_fs3.promises.open(tempPath, "wx", 384);
     try {
       await handle.writeFile(contents, "utf8");
       await handle.sync();
@@ -38996,17 +39088,10 @@ var ProfileManager = class {
       await handle.close();
     }
     try {
-      await import_fs.promises.link(tempPath, filePath);
-      if (process.platform !== "win32") {
-        const dirHandle = await import_fs.promises.open(dir, "r");
-        try {
-          await dirHandle.sync();
-        } finally {
-          await dirHandle.close();
-        }
-      }
+      await import_fs3.promises.link(tempPath, filePath);
+      await syncDirectory(dir);
     } finally {
-      await import_fs.promises.rm(tempPath, { force: true });
+      await import_fs3.promises.rm(tempPath, { force: true });
     }
   }
   async replaceActiveAuthIfCurrent(expectedSourceRaw, targetRaw) {
@@ -39019,7 +39104,7 @@ var ProfileManager = class {
         );
       }
     } else {
-      await import_fs.promises.rename(this.activeAuth, backupPath);
+      await import_fs3.promises.rename(this.activeAuth, backupPath);
       const displacedRaw2 = await this.readOptionalFile(backupPath);
       if (displacedRaw2 !== expectedSourceRaw) {
         if (displacedRaw2 !== null && await this.readOptionalFile(this.activeAuth) === null) {
@@ -39100,8 +39185,8 @@ var ProfileManager = class {
   async beginAuthMutation(operation, targetFingerprint) {
     const sourceRaw = await this.readOptionalFile(this.activeAuth);
     const backupPath = import_path.default.join(this.codexDir, AUTH_MUTATION_BACKUP_NAME);
-    await import_fs.promises.rm(backupPath, { force: true });
-    await import_fs.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_REPLACED_NAME), {
+    await import_fs3.promises.rm(backupPath, { force: true });
+    await import_fs3.promises.rm(import_path.default.join(this.codexDir, AUTH_MUTATION_REPLACED_NAME), {
       force: true
     });
     const manifest = {
@@ -39155,7 +39240,7 @@ var ProfileManager = class {
       );
     }
     if (currentRaw !== null) {
-      await import_fs.promises.rename(this.activeAuth, replacedPath);
+      await import_fs3.promises.rename(this.activeAuth, replacedPath);
       const replacedRaw = await this.readOptionalFile(replacedPath);
       if (this.fingerprintAuthContent(replacedRaw) !== manifest.targetFingerprint) {
         if (await this.readOptionalFile(this.activeAuth) === null && replacedRaw) {
@@ -39937,11 +40022,11 @@ var ProfileManager = class {
   async removeProfileHome(record2, recoverable) {
     const profileHome = this.getProfileHomePath(record2.homeId);
     if (!recoverable) {
-      await import_fs.promises.rm(profileHome, { recursive: true, force: true });
+      await import_fs3.promises.rm(profileHome, { recursive: true, force: true });
       return null;
     }
     try {
-      await import_fs.promises.access(profileHome);
+      await import_fs3.promises.access(profileHome);
     } catch (error) {
       if (this.isNotFoundError(error)) {
         return null;
@@ -39949,13 +40034,13 @@ var ProfileManager = class {
       throw error;
     }
     const trashRoot = process.platform === "darwin" ? import_path.default.join(process.env.HOME || import_node_os8.default.homedir(), ".Trash") : import_path.default.join(getUserDataDir(), "deleted-profile-homes");
-    await import_fs.promises.mkdir(trashRoot, { recursive: true, mode: 448 });
+    await import_fs3.promises.mkdir(trashRoot, { recursive: true, mode: 448 });
     const safeName = record2.name.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 48) || "profile";
     const destination = import_path.default.join(
       trashRoot,
       `CodexUse-${safeName}-${(0, import_node_crypto15.randomUUID)()}`
     );
-    await import_fs.promises.rename(profileHome, destination);
+    await import_fs3.promises.rename(profileHome, destination);
     return destination;
   }
   async deleteProfileRecordAndHome(record2, options = {}) {
@@ -40185,7 +40270,7 @@ var ProfileManager = class {
   async syncProfileTokensFromActiveAuth(profileName, baselineProfile, authPath) {
     const targetPath = authPath ?? this.activeAuth;
     try {
-      const authRaw = await import_fs.promises.readFile(targetPath, "utf8");
+      const authRaw = await import_fs3.promises.readFile(targetPath, "utf8");
       await this.syncProfileTokensFromAuthContent(profileName, baselineProfile, authRaw);
     } catch (error) {
       if (!this.isNotFoundError(error)) {
@@ -40197,7 +40282,7 @@ var ProfileManager = class {
     const authPath = import_path.default.join(this.getProfileHomePath(homeId), "auth.json");
     let fileKey;
     try {
-      const stats = await import_fs.promises.stat(authPath);
+      const stats = await import_fs3.promises.stat(authPath);
       fileKey = `${stats.mtimeMs}:${stats.size}`;
       const cached2 = this.profileHomeAuthSyncCache.get(profileName);
       const currentRecency2 = this.getProfileTokenRecencyMs(baselineProfile);
@@ -40212,7 +40297,7 @@ var ProfileManager = class {
     }
     let authRaw;
     try {
-      authRaw = await import_fs.promises.readFile(authPath, "utf8");
+      authRaw = await import_fs3.promises.readFile(authPath, "utf8");
     } catch (error) {
       if (!this.isNotFoundError(error)) {
         logWarn(`Failed to read profile-home auth for '${profileName}' while syncing tokens:`, error);
@@ -40304,7 +40389,7 @@ var ProfileManager = class {
       const source = (0, import_path2.join)(this.codexDir, file);
       const destination = (0, import_path2.join)(targetCodexHome, file);
       try {
-        await import_fs.promises.copyFile(source, destination, import_fs.constants.COPYFILE_EXCL);
+        await import_fs3.promises.copyFile(source, destination, import_fs3.constants.COPYFILE_EXCL);
         if (file === "config.toml") {
           copiedToml = true;
         }
@@ -40366,7 +40451,7 @@ var ProfileManager = class {
   }
   async isProfileHomeMutationMarkerLive(deletingPath) {
     try {
-      const owner = JSON.parse(await import_fs.promises.readFile(deletingPath, "utf8"));
+      const owner = JSON.parse(await import_fs3.promises.readFile(deletingPath, "utf8"));
       const expiresAt = typeof owner.expiresAt === "number" && Number.isFinite(owner.expiresAt) ? owner.expiresAt : null;
       const ownerId = typeof owner.ownerId === "string" ? owner.ownerId : null;
       const ownerStartedAt = typeof owner.ownerStartedAt === "number" ? owner.ownerStartedAt : null;
@@ -40387,10 +40472,10 @@ var ProfileManager = class {
     const releaseIntent = await this.acquireProfileHomeWriteIntent(record2);
     let operationError = null;
     try {
-      await import_fs.promises.mkdir(leaseDir, { recursive: true, mode: 448 });
+      await import_fs3.promises.mkdir(leaseDir, { recursive: true, mode: 448 });
       let deletingMarkerExists = true;
       try {
-        await import_fs.promises.access(deletingPath);
+        await import_fs3.promises.access(deletingPath);
       } catch (error) {
         if (this.isNotFoundError(error)) {
           deletingMarkerExists = false;
@@ -40402,10 +40487,10 @@ var ProfileManager = class {
         if (await this.isProfileHomeMutationMarkerLive(deletingPath)) {
           throw new Error(`Profile '${record2.name}' is being removed or replaced.`);
         }
-        await import_fs.promises.rm(deletingPath, { force: true });
+        await import_fs3.promises.rm(deletingPath, { force: true });
       }
       activeProfileRuntimeLeasePaths.add(leasePath);
-      const auth = await import_fs.promises.readFile(
+      const auth = await import_fs3.promises.readFile(
         (0, import_path2.join)(this.getProfileHomePath(record2.homeId), "auth.json"),
         "utf8"
       );
@@ -40421,7 +40506,7 @@ var ProfileManager = class {
         })
       );
       try {
-        await import_fs.promises.access(deletingPath);
+        await import_fs3.promises.access(deletingPath);
         throw new Error(
           `Profile '${record2.name}' is being removed or replaced.`
         );
@@ -40439,8 +40524,8 @@ var ProfileManager = class {
     );
     if (operationError || releaseError) {
       await Promise.allSettled([
-        import_fs.promises.rm(leasePath, { force: true }),
-        import_fs.promises.rm(backupPath, { force: true })
+        import_fs3.promises.rm(leasePath, { force: true }),
+        import_fs3.promises.rm(backupPath, { force: true })
       ]);
       activeProfileRuntimeLeasePaths.delete(leasePath);
       if (operationError && releaseError) {
@@ -40463,18 +40548,18 @@ var ProfileManager = class {
       this.getProfileRuntimeLeaseDir(record2.homeId),
       `${leaseId}.auth.backup`
     );
-    const backup = await import_fs.promises.readFile(backupPath, "utf8");
+    const backup = await import_fs3.promises.readFile(backupPath, "utf8");
     const releaseIntent = await this.acquireProfileHomeWriteIntent(record2);
     try {
       const leaseDir = this.getProfileRuntimeLeaseDir(record2.homeId);
-      for (const entry of await import_fs.promises.readdir(leaseDir)) {
+      for (const entry of await import_fs3.promises.readdir(leaseDir)) {
         if (!entry.endsWith(".json") || entry === `${leaseId}.json`) {
           continue;
         }
         try {
           const leasePath = (0, import_path2.join)(leaseDir, entry);
           const lease = JSON.parse(
-            await import_fs.promises.readFile(leasePath, "utf8")
+            await import_fs3.promises.readFile(leasePath, "utf8")
           );
           if (this.resolveLiveProfileRuntimeLeasePid(lease, leasePath)) {
             throw new Error(
@@ -40525,10 +40610,10 @@ var ProfileManager = class {
       const currentLeaseRaw = await this.readOptionalFile(leasePath);
       const currentLease = currentLeaseRaw ? JSON.parse(currentLeaseRaw) : null;
       if (!currentLease || currentLease.id !== leaseId || currentLease.released === true) {
-        await import_fs.promises.rm(backupPath, { force: true });
+        await import_fs3.promises.rm(backupPath, { force: true });
       }
     } catch (error) {
-      await import_fs.promises.rm(backupPath, { force: true });
+      await import_fs3.promises.rm(backupPath, { force: true });
       throw error;
     }
   }
@@ -40541,7 +40626,7 @@ var ProfileManager = class {
     try {
       let leaseRaw = null;
       try {
-        leaseRaw = await import_fs.promises.readFile(leasePath, "utf8");
+        leaseRaw = await import_fs3.promises.readFile(leasePath, "utf8");
       } catch (error) {
         if (!this.isNotFoundError(error)) {
           throw error;
@@ -40564,8 +40649,8 @@ var ProfileManager = class {
         );
       }
       const results = await Promise.allSettled([
-        import_fs.promises.rm(leasePath, { force: true }),
-        ...options.preserveBackup === true ? [] : [import_fs.promises.rm((0, import_path2.join)(leaseDir, `${leaseId}.auth.backup`), { force: true })]
+        import_fs3.promises.rm(leasePath, { force: true }),
+        ...options.preserveBackup === true ? [] : [import_fs3.promises.rm((0, import_path2.join)(leaseDir, `${leaseId}.auth.backup`), { force: true })]
       ]);
       const failed = results.find(
         (result2) => result2.status === "rejected"
@@ -40598,7 +40683,7 @@ var ProfileManager = class {
       profileName: record2.name
     });
     const openMarker = async () => {
-      const handle = await import_fs.promises.open(deletingPath, "wx", 384);
+      const handle = await import_fs3.promises.open(deletingPath, "wx", 384);
       try {
         await handle.writeFile(
           JSON.stringify({
@@ -40613,14 +40698,14 @@ var ProfileManager = class {
         );
         await handle.sync();
       } catch (error) {
-        await import_fs.promises.rm(deletingPath, { force: true });
+        await import_fs3.promises.rm(deletingPath, { force: true });
         throw error;
       } finally {
         await handle.close();
       }
     };
     try {
-      await import_fs.promises.mkdir(leaseDir, { recursive: true, mode: 448 });
+      await import_fs3.promises.mkdir(leaseDir, { recursive: true, mode: 448 });
       try {
         await openMarker();
       } catch (error) {
@@ -40634,7 +40719,7 @@ var ProfileManager = class {
             error
           );
         }
-        await import_fs.promises.rm(deletingPath, { force: true });
+        await import_fs3.promises.rm(deletingPath, { force: true });
         try {
           await openMarker();
         } catch (retryError) {
@@ -40659,7 +40744,7 @@ var ProfileManager = class {
       throw error;
     }
     try {
-      const entries3 = await import_fs.promises.readdir(leaseDir);
+      const entries3 = await import_fs3.promises.readdir(leaseDir);
       const officialInstances = await getOfficialCodexProfileInstances({
         profileNames: [record2.name]
       });
@@ -40686,12 +40771,12 @@ var ProfileManager = class {
         let leasePid = 0;
         try {
           const parsed = JSON.parse(
-            await import_fs.promises.readFile(leasePath, "utf8")
+            await import_fs3.promises.readFile(leasePath, "utf8")
           );
           if (parsed.released === true) {
             await Promise.allSettled([
-              import_fs.promises.rm(leasePath, { force: true }),
-              import_fs.promises.rm(backupPath, { force: true })
+              import_fs3.promises.rm(leasePath, { force: true }),
+              import_fs3.promises.rm(backupPath, { force: true })
             ]);
             continue;
           }
@@ -40705,14 +40790,14 @@ var ProfileManager = class {
           );
         }
         await Promise.allSettled([
-          import_fs.promises.rm(leasePath, { force: true }),
-          import_fs.promises.rm(backupPath, { force: true })
+          import_fs3.promises.rm(leasePath, { force: true }),
+          import_fs3.promises.rm(backupPath, { force: true })
         ]);
       }
     } catch (error) {
       try {
         try {
-          await import_fs.promises.rm(deletingPath, { force: true });
+          await import_fs3.promises.rm(deletingPath, { force: true });
         } finally {
           await releaseProfileHomeMutationIntent(
             record2.homeId,
@@ -40731,7 +40816,7 @@ var ProfileManager = class {
       let markerError = null;
       let ownsMarker = false;
       try {
-        const owner = JSON.parse(await import_fs.promises.readFile(deletingPath, "utf8"));
+        const owner = JSON.parse(await import_fs3.promises.readFile(deletingPath, "utf8"));
         if (owner.id !== mutationId) {
           markerError = new Error(
             `Profile '${record2.name}' mutation marker ownership changed unexpectedly.`
@@ -40747,7 +40832,7 @@ var ProfileManager = class {
       let markerReleaseError = null;
       if (ownsMarker) {
         try {
-          await import_fs.promises.rm(deletingPath);
+          await import_fs3.promises.rm(deletingPath);
         } catch (error) {
           markerReleaseError = error;
         }
@@ -40777,7 +40862,7 @@ var ProfileManager = class {
     const configPath = (0, import_path2.join)(profileHome, "config.toml");
     let raw;
     try {
-      raw = await import_fs.promises.readFile(configPath, "utf8");
+      raw = await import_fs3.promises.readFile(configPath, "utf8");
     } catch (error) {
       if (!this.isNotFoundError(error)) {
         logWarn(`Failed to read config for profile home '${profileHome}':`, error);
@@ -40807,7 +40892,7 @@ var ProfileManager = class {
       (0, import_toml2.stringify)(parsed)
     );
     try {
-      await import_fs.promises.writeFile(configPath, sanitized, "utf8");
+      await import_fs3.promises.writeFile(configPath, sanitized, "utf8");
     } catch (error) {
       logWarn(`Failed to write sanitized config.toml for profile home '${profileHome}':`, error);
     }
@@ -40825,9 +40910,9 @@ var ProfileManager = class {
       }
     }
     const profileHome = this.getProfileHomePath(record2.homeId);
-    await import_fs.promises.mkdir(profileHome, { recursive: true, mode: 448 });
+    await import_fs3.promises.mkdir(profileHome, { recursive: true, mode: 448 });
     if (process.platform !== "win32") {
-      await import_fs.promises.chmod(profileHome, 448);
+      await import_fs3.promises.chmod(profileHome, 448);
     }
     const authPath = (0, import_path2.join)(profileHome, "auth.json");
     await this.withProfileAuthFileLock(authPath, async (currentRaw) => {
@@ -40953,7 +41038,7 @@ var ProfileManager = class {
     let syncError = null;
     let finalAuthContent = null;
     try {
-      finalAuthContent = await import_fs.promises.readFile(authPath, "utf8");
+      finalAuthContent = await import_fs3.promises.readFile(authPath, "utf8");
     } catch (error) {
       if (!this.isNotFoundError(error)) {
         logWarn(`Failed to read isolated auth for '${profileName}' after action:`, error);
@@ -41090,7 +41175,7 @@ var ProfileManager = class {
         throw new Error("Profile runtime lease is no longer active.");
       }
       const lease = JSON.parse(
-        await import_fs.promises.readFile(leasePath, "utf8")
+        await import_fs3.promises.readFile(leasePath, "utf8")
       );
       if (lease.id !== leaseId || lease.ownerId !== PROCESS_OWNER_ID2 || lease.released === true) {
         throw new Error(
@@ -41126,7 +41211,7 @@ var ProfileManager = class {
           );
           let finalAuthContent = null;
           try {
-            finalAuthContent = await import_fs.promises.readFile(authPath, "utf8");
+            finalAuthContent = await import_fs3.promises.readFile(authPath, "utf8");
           } catch (error) {
             if (!this.isNotFoundError(error)) {
               logWarn(`Failed to read isolated auth for '${profileName}' while syncing runtime:`, error);
@@ -41206,7 +41291,7 @@ var ProfileManager = class {
   async readAuthFileForImport(authPath, actionLabel) {
     let authRaw;
     try {
-      authRaw = await import_fs.promises.readFile(authPath, "utf8");
+      authRaw = await import_fs3.promises.readFile(authPath, "utf8");
     } catch (error) {
       if (this.isNotFoundError(error)) {
         throw errorWithCause(
@@ -42057,7 +42142,7 @@ var ProfileManager = class {
         const profileHome = this.getProfileHomePath(record2.homeId);
         let homeExisted = true;
         try {
-          await import_fs.promises.access(profileHome);
+          await import_fs3.promises.access(profileHome);
         } catch (error) {
           if (!this.isNotFoundError(error)) {
             throw error;
@@ -42083,7 +42168,7 @@ var ProfileManager = class {
           const sourceHome = this.getProfileHomePath(sourceHomeId);
           let sourceHomeExists = true;
           try {
-            await import_fs.promises.access(sourceHome);
+            await import_fs3.promises.access(sourceHome);
           } catch (error) {
             if (!this.isNotFoundError(error)) {
               throw error;
@@ -42091,16 +42176,16 @@ var ProfileManager = class {
             sourceHomeExists = false;
           }
           if (sourceHomeExists) {
-            await import_fs.promises.cp(sourceHome, profileHome, {
+            await import_fs3.promises.cp(sourceHome, profileHome, {
               recursive: true,
               errorOnExist: true,
               force: false
             });
           }
         }
-        await import_fs.promises.mkdir(profileHome, { recursive: true, mode: 448 });
+        await import_fs3.promises.mkdir(profileHome, { recursive: true, mode: 448 });
         if (process.platform !== "win32") {
-          await import_fs.promises.chmod(profileHome, 448);
+          await import_fs3.promises.chmod(profileHome, 448);
         }
         await this.writeProfileAuthAtomic(
           (0, import_path2.join)(profileHome, "auth.json"),
@@ -42155,7 +42240,7 @@ var ProfileManager = class {
         const rollbackResults = await Promise.allSettled(
           Array.from(
             preparedHomeIds,
-            (homeId) => import_fs.promises.rm(this.getProfileHomePath(homeId), {
+            (homeId) => import_fs3.promises.rm(this.getProfileHomePath(homeId), {
               recursive: true,
               force: true
             })
@@ -42225,7 +42310,7 @@ var ProfileManager = class {
     let deleted = 0;
     for (const homeId of homeIds) {
       try {
-        await import_fs.promises.rm(this.getProfileHomePath(homeId), {
+        await import_fs3.promises.rm(this.getProfileHomePath(homeId), {
           recursive: true,
           force: true
         });
@@ -46483,14 +46568,6 @@ var JOURNAL_FILENAME = "cloud-sync-pull.journal.json";
 function getCloudSyncJournalPath() {
   return import_node_path21.default.join(getUserDataDir(), JOURNAL_FILENAME);
 }
-async function syncDirectory(dir) {
-  const directory = await import_node_fs16.promises.open(dir, "r");
-  try {
-    await directory.sync();
-  } finally {
-    await directory.close();
-  }
-}
 async function writeCloudSyncJournal(journal) {
   const target = getCloudSyncJournalPath();
   const dir = import_node_path21.default.dirname(target);
@@ -47407,7 +47484,7 @@ async function ensureCliStorageReady() {
 }
 
 // src/app/main.ts
-var VERSION = true ? "6.4.0" : "0.0.0";
+var VERSION = true ? "6.4.1" : "0.0.0";
 async function runCli() {
   const args2 = process.argv.slice(2);
   if (args2.length === 0) {