@codexhost/cli-linux-x64 0.2.3 → 0.2.5

package/app/renderer-extension.js

@@ -17275,14 +17275,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var SIDEBAR_THREAD_ID_ATTRIBUTE = "data-app-action-sidebar-thread-id";
   var SIDEBAR_THREAD_HOST_ID_ATTRIBUTE = "data-app-action-sidebar-thread-host-id";
   var SIDEBAR_AGENT_ICON_ATTRIBUTE = "data-codexhost-sidebar-agent-icon";
+  var OWNERSHIP_RETRY_DELAYS_MS = [100, 300, 800, 1500, 3e3];
   function isRecord2(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
-  function threadIdFromSidebarRowElement(element) {
+  function sidebarThreadAttributes(element) {
     const taskKey = element.getAttribute(SIDEBAR_THREAD_ID_ATTRIBUTE);
     const hostId = element.getAttribute(SIDEBAR_THREAD_HOST_ID_ATTRIBUTE);
     const rowMarker = element.getAttribute(SIDEBAR_THREAD_ROW_ATTRIBUTE);
     if (taskKey === null || hostId === null || rowMarker === null) return null;
+    return { taskKey, hostId, rowMarker };
+  }
+  function draftIdFromSidebarRowElement(element) {
+    const attributes = sidebarThreadAttributes(element);
+    if (!attributes) return null;
+    const hostPrefix = `${attributes.hostId}:`;
+    const taskKey = attributes.taskKey.startsWith(hostPrefix) ? attributes.taskKey.slice(hostPrefix.length) : attributes.taskKey;
+    return taskKey.startsWith("client-new-thread:") ? taskKey : null;
+  }
+  function threadIdFromSidebarRowElement(element) {
+    const attributes = sidebarThreadAttributes(element);
+    if (!attributes) return null;
+    const { taskKey, hostId, rowMarker } = attributes;
     const fiberNames = Object.getOwnPropertyNames(element).filter(
       (name) => name.startsWith("__reactFiber$")
     );
@@ -17324,6 +17338,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     threadId() {
       return threadIdFromSidebarRowElement(this.element);
     }
+    draftId() {
+      return draftIdFromSidebarRowElement(this.element);
+    }
     render(agent) {
       const titleTrigger = this.element.querySelector("[data-thread-title-trigger]");
       const title = titleTrigger?.querySelector("[data-thread-title]");
@@ -17403,6 +17420,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     const ownershipByThread = /* @__PURE__ */ new Map();
     const pending = /* @__PURE__ */ new Set();
     const failed = /* @__PURE__ */ new Set();
+    const provisionalCodex = /* @__PURE__ */ new Set();
+    const ownershipRetryAttempts = /* @__PURE__ */ new Map();
+    const ownershipRetryTimers = /* @__PURE__ */ new Map();
     let disposed = false;
     let scanScheduled = false;
     const scheduleScan = () => {
@@ -17410,6 +17430,30 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       scanScheduled = true;
       queueMicrotask(scan);
     };
+    const clearOwnershipRetry = (threadId) => {
+      const timer = ownershipRetryTimers.get(threadId);
+      if (timer !== void 0) clearTimeout(timer);
+      ownershipRetryTimers.delete(threadId);
+      ownershipRetryAttempts.delete(threadId);
+      provisionalCodex.delete(threadId);
+    };
+    const scheduleOwnershipRetry = (threadId) => {
+      if (disposed || !provisionalCodex.has(threadId) || pending.has(threadId) || ownershipRetryTimers.has(threadId)) {
+        return;
+      }
+      const attempt = ownershipRetryAttempts.get(threadId) ?? 0;
+      const delay = OWNERSHIP_RETRY_DELAYS_MS[attempt];
+      if (delay === void 0) return;
+      ownershipRetryAttempts.set(threadId, attempt + 1);
+      const timer = setTimeout(() => {
+        ownershipRetryTimers.delete(threadId);
+        if (disposed) return;
+        failed.delete(threadId);
+        ownershipByThread.delete(threadId);
+        scheduleScan();
+      }, delay);
+      ownershipRetryTimers.set(threadId, timer);
+    };
     const requestOwnership = (threadIds, client) => {
       for (const threadId of threadIds) pending.add(threadId);
       let succeeded = false;
@@ -17418,6 +17462,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         for (const ownership of threads) {
           ownershipByThread.set(ownership.threadId, rendererAgentForThreadOwnership(ownership));
           failed.delete(ownership.threadId);
+          if (ownership.owner === "codex") {
+            provisionalCodex.add(ownership.threadId);
+            scheduleOwnershipRetry(ownership.threadId);
+          } else {
+            clearOwnershipRetry(ownership.threadId);
+          }
         }
         succeeded = true;
       }).catch(() => {
@@ -17425,6 +17475,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         for (const threadId of threadIds) failed.add(threadId);
       }).finally(() => {
         for (const threadId of threadIds) pending.delete(threadId);
+        for (const threadId of threadIds) scheduleOwnershipRetry(threadId);
         if (succeeded) scheduleScan();
       });
     };
@@ -17433,8 +17484,25 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (disposed) return;
       const unresolved = /* @__PURE__ */ new Set();
       for (const row of dom.rows()) {
+        if (!row.isConnected()) {
+          row.clear();
+          continue;
+        }
         const threadId = hostThreadIdSchema.safeParse(row.threadId());
-        if (!row.isConnected() || !threadId.success) {
+        const localAgent = options.getLocalAgent?.({
+          threadId: threadId.success ? threadId.data : null,
+          draftId: row.draftId()
+        });
+        if (localAgent !== null && localAgent !== void 0) {
+          if (threadId.success) {
+            ownershipByThread.set(threadId.data, localAgent === "codex" ? null : localAgent);
+            clearOwnershipRetry(threadId.data);
+          }
+          if (localAgent === "codex") row.clear();
+          else row.render(localAgent);
+          continue;
+        }
+        if (!threadId.success) {
           row.clear();
           continue;
         }
@@ -17461,6 +17529,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return {
       refresh() {
         failed.clear();
+        for (const threadId of provisionalCodex) {
+          const timer = ownershipRetryTimers.get(threadId);
+          if (timer !== void 0) clearTimeout(timer);
+          ownershipRetryTimers.delete(threadId);
+          ownershipRetryAttempts.delete(threadId);
+          ownershipByThread.delete(threadId);
+        }
         scheduleScan();
       },
       dispose() {
@@ -17471,6 +17546,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         ownershipByThread.clear();
         pending.clear();
         failed.clear();
+        provisionalCodex.clear();
+        for (const timer of ownershipRetryTimers.values()) clearTimeout(timer);
+        ownershipRetryTimers.clear();
+        ownershipRetryAttempts.clear();
       }
     };
   }
@@ -17916,6 +17995,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return source.includes("send-cli-request-for-host") && hasPrewarmMethod(value.requestClient);
   }
   function matchesCurrentPrewarmSignature(target) {
+    const bridge = target.requestClient ?? target;
+    const stableApiShape = bridge.hostId === "local" && typeof bridge.sendRequest === "function" && typeof bridge.prewarmThreadStart === "function" && typeof bridge.enqueueRequest === "function";
+    if (stableApiShape) return true;
     const prewarm = target.prewarmThreadStart ?? target.requestClient?.prewarmThreadStart;
     if (!prewarm) return false;
     const source = Function.prototype.toString.call(prewarm);
@@ -20177,8 +20259,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     let applyAdapterAgent = null;
     let modelControl = null;
     let usageNotificationDispose = null;
+    const localAgentForSidebarThread = (input) => {
+      for (const mounted of mountedByComposer.values()) {
+        const target = mounted.modelTarget;
+        if (target?.[0] === "default" && input.draftId !== null && target[1] === input.draftId) {
+          return controller.get(mounted.composer).agent;
+        }
+        if (target?.[0] === "conversation" && input.threadId !== null && target[1] === input.threadId && mounted.ownershipStatus === "ready") {
+          return controller.get(mounted.composer).agent;
+        }
+      }
+      return null;
+    };
     const sidebarAgentIcons = installRendererSidebarAgentIcons({
-      getClient: () => modelControl
+      getClient: () => modelControl,
+      getLocalAgent: localAgentForSidebarThread
     });
     const settingsLifecycle = installRendererSettingsLifecycle(window, {
       getUpdateClient: () => modelControl
@@ -20194,6 +20289,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     );
     let availabilityRequestGeneration = 0;
     let availabilityRequest = null;
+    let availabilityRetryTimer = null;
+    let availabilityRetryAttempt = 0;
+    const availabilityRetryDelays = [500, 1e3, 2e3, 4e3, 8e3];
     const usageRefreshTimers = /* @__PURE__ */ new Map();
     const usageRefreshAttempts = /* @__PURE__ */ new Map();
     const isMountedComposer = (composer) => composer.isConnected && composer.matches(CODEX_COMPOSER_SELECTOR) && mountedByComposer.has(composer);
@@ -20366,6 +20464,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       } finally {
         if (isCurrentOwnershipRequest(mounted, generation)) {
           renderMounted(mounted);
+          sidebarAgentIcons.refresh();
           if (mounted.ownershipStatus !== "error" && shouldRetryExternalThreadUsage(
             controller.get(mounted.composer).agent,
             mounted.usage,
@@ -20411,6 +20510,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         if (previousTarget?.[0] === "conversation") renderMounted(mounted);
         void loadThreadOwnership(mounted);
       }
+      sidebarAgentIcons.refresh();
       return true;
     };
     const loadExternalCatalog = async (mounted) => {
@@ -20921,6 +21021,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           mounted.modelView = { status: "idle" };
           mounted.permissionModeView = { status: "idle" };
         }
+        sidebarAgentIcons.refresh();
         return switched;
       } catch {
         adapterStatus = {
@@ -20940,7 +21041,26 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const url2 = RENDERER_AGENT_INSTALL_URLS[agent];
       window.open(url2, "_blank", "noopener,noreferrer");
     };
-    const refreshHarnessAvailability = (refresh = false) => {
+    const resetHarnessAvailabilityRetry = () => {
+      if (availabilityRetryTimer !== null) {
+        window.clearTimeout(availabilityRetryTimer);
+        availabilityRetryTimer = null;
+      }
+      availabilityRetryAttempt = 0;
+    };
+    const scheduleHarnessAvailabilityRetry = () => {
+      if (disposed || availabilityRetryTimer !== null || availabilityRetryAttempt >= availabilityRetryDelays.length) {
+        return;
+      }
+      const delay = availabilityRetryDelays[availabilityRetryAttempt];
+      availabilityRetryAttempt += 1;
+      availabilityRetryTimer = window.setTimeout(() => {
+        availabilityRetryTimer = null;
+        void refreshHarnessAvailability(true, true);
+      }, delay);
+    };
+    const refreshHarnessAvailability = (refresh = false, retry = false) => {
+      if (!retry) resetHarnessAvailabilityRetry();
       if (!modelControl) return Promise.resolve();
       const client = modelControl;
       if (availabilityRequest?.client === client) return availabilityRequest.promise;
@@ -20982,6 +21102,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }
           })
         );
+        if (externalAgents.every((agent) => harnessAvailability[agent] === "ready")) {
+          resetHarnessAvailabilityRetry();
+        } else {
+          scheduleHarnessAvailabilityRetry();
+        }
       })();
       const request = { client, promise: promise2 };
       availabilityRequest = request;
@@ -21060,6 +21185,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         );
       }
       renderMounted(mounted);
+      sidebarAgentIcons.refresh();
       if (threadIdFromComposerModelTarget(modelTarget) && !inherited) {
         void loadThreadOwnership(mounted);
       } else if (threadIdFromComposerModelTarget(modelTarget) && inherited && shouldRetryExternalThreadUsage(state.agent, mounted.usage, mounted.accountCredits)) {
@@ -21384,6 +21510,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         document.removeEventListener("click", onClick, true);
         window.removeEventListener("codexhost:renderer-adapter-status", onAdapterStatus);
         window.removeEventListener("focus", onWindowFocus);
+        resetHarnessAvailabilityRetry();
         for (const timer of usageRefreshTimers.values()) window.clearTimeout(timer);
         usageRefreshTimers.clear();
         for (const mounted of mountedByComposer.values()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexhost/cli-linux-x64",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Run Pi and Claude Code as first-class external harnesses inside Codex Desktop.",
   "type": "module",
   "files": [