minecodex 1.2.0 → 1.2.2

package/packages/runtime-host/src/codex-runtime.mjs

@@ -1,3 +1,4 @@
+import { cloudImagesAction } from "./cloud-images.mjs";
 // CodexRuntime：Codex Renderer 生命周期与 host action 执行。
 // 注入源（createInjectionSource）与 CDP 客户端分别在 codex-injection.mjs / codex-cdp.mjs。
 
@@ -44,6 +45,19 @@ export {
   responsiveSummaryDisplayMode,
   responsiveSummaryVisibleSurface,
 } from "./codex-injection.mjs";
+
+export const SESSION_STATUS_THREAD_ID_EXPRESSION = `(() => {
+  const composer = document.querySelector('[data-codex-composer="true"][contenteditable="true"]')
+    ?? document.querySelector('[contenteditable="true"][role="textbox"]');
+  const card = composer?.closest('[data-codex-composer-root]');
+  const portal = card?.querySelector('[data-above-composer-portal]');
+  if (portal) return portal.getAttribute('data-above-composer-conversation-id');
+  if (card?.getAttribute('data-composer-placement') === 'home') return null;
+  const selected = document.querySelector('[data-app-action-sidebar-thread-selected="true"]');
+  return selected?.getAttribute('data-app-action-sidebar-thread-id')
+    ?? location.pathname + location.search + location.hash;
+})()`;
+
 export class CodexRuntime {
   constructor({
     features,
@@ -90,6 +104,8 @@ export class CodexRuntime {
     this.scriptIds = new Map();
     this.bindingTokens = new Map();
     this.hostActionChains = new Map();
+    this.sessionStatusUpdates = new Map();
+    this.sessionStatusRevision = 0;
     this.refreshPromise = null;
     this.stopping = false;
     this.monitorPromise = null;
@@ -277,7 +293,9 @@ export class CodexRuntime {
   }
 
   async startTargetDiscovery() {
-    const response = await this.fetchImpl(`http://127.0.0.1:${this.cdpPort}/json/version`);
+    const response = await this.fetchImpl(`http://127.0.0.1:${this.cdpPort}/json/version`, {
+      signal: AbortSignal.timeout(3_000),
+    });
     if (!response?.ok) {
       throw new Error(`Codex CDP version returned HTTP ${response?.status ?? "error"}`);
     }
@@ -342,7 +360,9 @@ export class CodexRuntime {
 
   async isAvailable() {
     try {
-      const response = await this.fetchImpl(`http://127.0.0.1:${this.cdpPort}/json/version`);
+      const response = await this.fetchImpl(`http://127.0.0.1:${this.cdpPort}/json/version`, {
+        signal: AbortSignal.timeout(3_000),
+      });
       if (!response?.ok) return false;
       requireCdpWebSocketUrl(await response.json(), this.cdpPort);
       return true;
@@ -505,6 +525,12 @@ export class CodexRuntime {
     }
     if (request.token !== this.bindingTokens.get(targetId) || typeof request.requestId !== "string") return;
     const feature = this.features.find((candidate) => candidate.id === request.featureId);
+    if (feature?.id === "session-status" && request.action === "refresh-session-status") {
+      if (this.sessionStatusReader && this.clients.get(targetId) === client && !this.stopping) {
+        await this.publishSessionStatus(targetId);
+      }
+      return;
+    }
     if (feature && request.action === SURFACE_LOAD_ACTION) {
       try {
         const result = await this.loadSurfaceIntoFrame(client, feature, request.payload);
@@ -528,6 +554,18 @@ export class CodexRuntime {
       await this.importGeneratedImage(feature, request.payload);
       return;
     }
+    if (["list-cloud-images", "import-cloud-image"].includes(request.action)) {
+      try {
+        let result = await cloudImagesAction(client, request.action === "list-cloud-images" ? "list" : "import", request.payload);
+        if (request.action === "import-cloud-image" && !result.skipped) {
+          result = await this.importGeneratedImage(feature, result);
+        }
+        await this.resolveHostAction(client, request.requestId, { ok: true, result });
+      } catch (error) {
+        await this.resolveHostAction(client, request.requestId, { ok: false, error: { code: "CLOUD_IMAGES_FAILED", message: error.message } });
+      }
+      return;
+    }
     try {
       const result = request.action === "create-image-edit-thread"
         ? await this.createImageEditThread(client, feature, request.payload, request.requestId)
@@ -555,12 +593,15 @@ export class CodexRuntime {
     if (!response?.ok) {
       throw new Error(`Generated image import returned HTTP ${response?.status ?? "error"}`);
     }
+    return response.json();
   }
 
   async refreshTargets() {
     let response;
     try {
-      response = await this.fetchImpl(`http://127.0.0.1:${this.cdpPort}/json/list`);
+      response = await this.fetchImpl(`http://127.0.0.1:${this.cdpPort}/json/list`, {
+        signal: AbortSignal.timeout(3_000),
+      });
     } catch (error) {
       throw this.markCodexUnavailable(error);
     }
@@ -591,7 +632,8 @@ export class CodexRuntime {
       ...this.targetFailures.keys(),
     ]);
     for (const id of trackedTargetIds) {
-      if (liveRendererIds.has(id)) continue;
+      const socketState = this.clients.get(id)?.socket.readyState;
+      if (liveRendererIds.has(id) && (socketState == null || socketState === 1)) continue;
       removedTarget = true;
       this.clients.get(id)?.socket.close();
       this.clients.delete(id);
@@ -627,7 +669,13 @@ export class CodexRuntime {
         const bindingToken = randomBytes(24).toString("hex");
         this.bindingTokens.set(target.id, bindingToken);
         client.on?.("Runtime.bindingCalled", (params) => {
-          this.enqueueHostAction(target.id, () => this.handleBindingCalled(target.id, client, params))
+          let action;
+          try { action = JSON.parse(params.payload)?.action; } catch { return; }
+          // 统计读取独立合并，避免排在图片等用户操作后面。
+          const work = action === "refresh-session-status"
+            ? this.handleBindingCalled(target.id, client, params)
+            : this.enqueueHostAction(target.id, () => this.handleBindingCalled(target.id, client, params));
+          work
             .catch((error) => this.logger.warn?.("Codex Host action failed", error.message));
         });
         const source = createInjectionSource(this.features, {
@@ -680,26 +728,43 @@ export class CodexRuntime {
     this.notifyStatusChange();
   }
 
-  async publishSessionStatus() {
+  async publishSessionStatus(onlyTargetId = null) {
     for (const [targetId, client] of this.clients) {
+      if (onlyTargetId && targetId !== onlyTargetId) continue;
       if (!this.injectedTargets.has(targetId)) continue;
-      try {
-        const response = await client.send("Runtime.evaluate", {
-          expression: `(() => {
-            const selected = document.querySelector('[data-app-action-sidebar-thread-selected="true"]');
-            return selected?.getAttribute('data-app-action-sidebar-thread-id')
-              ?? location.pathname + location.search;
-          })()`,
-          returnByValue: true,
-        });
-        const threadId = threadIdFromLocation(response.result?.value);
-        const snapshot = threadId ? await this.sessionStatusReader.read(threadId) : null;
-        await client.send("Runtime.evaluate", {
-          expression: `window.__minecodexSessionStatus?.update(${JSON.stringify(snapshot)})`,
-          returnByValue: true,
-        });
-      } catch (error) {
-        this.logger.warn?.("Session Status update failed", error.message);
+      const pending = this.sessionStatusUpdates.get(targetId);
+      if (pending) { await pending; continue; }
+      const revision = ++this.sessionStatusRevision;
+      const update = (async () => {
+        try {
+          const response = await client.send("Runtime.evaluate", {
+            expression: SESSION_STATUS_THREAD_ID_EXPRESSION,
+            returnByValue: true,
+          }, { timeoutMs: 3_000 });
+          const threadId = threadIdFromLocation(response.result?.value);
+          const data = threadId ? await this.sessionStatusReader.read(threadId) : null;
+          const snapshot = data ?? (threadId ? {
+            threadId,
+            retryAfterMs: this.sessionStatusReader.retryAfterMs?.(threadId) ?? 500,
+          } : null);
+          if (this.stopping || this.clients.get(targetId) !== client) return;
+          await client.send("Runtime.evaluate", {
+            expression: `window.__minecodexSessionStatus?.update(${JSON.stringify(snapshot)}, ${revision})`,
+            returnByValue: true,
+          }, { timeoutMs: 3_000 });
+        } catch (error) {
+          this.logger.warn?.("Session Status update failed", error.message);
+          if (this.clients.get(targetId) === client) {
+            client.socket.close();
+            this.injectedTargets.delete(targetId);
+            this.notifyStatusChange();
+          }
+        }
+      })();
+      this.sessionStatusUpdates.set(targetId, update);
+      try { await update; }
+      finally {
+        if (this.sessionStatusUpdates.get(targetId) === update) this.sessionStatusUpdates.delete(targetId);
       }
     }
   }

package/packages/runtime-host/src/feature-registry.mjs

@@ -13,6 +13,8 @@ const HOST_ACTIONS = new Set([
   "open-sidebar",
   "resolve-file-paths",
   "import-generated-image",
+  "list-cloud-images",
+  "import-cloud-image",
   "create-image-edit-thread",
 ]);
 

package/packages/runtime-host/src/session-status-reader.mjs

@@ -62,6 +62,7 @@ function emptyState(filePath) {
     offset: 0,
     pending: "",
     turns: new Set(),
+    runningTurns: new Set(),
     responses: new Set(),
     hasResponseUsage: false,
     total: null,
@@ -134,7 +135,14 @@ export function applySessionStatusEvent(state, event) {
   }
   if (event?.type === "event_msg") {
     if (payload.type === "context_compacted") state.compactionEvents += 1;
-    if (payload.type === "task_started" && payload.turn_id) state.turns.add(payload.turn_id);
+    if (payload.type === "task_started" && payload.turn_id) {
+      state.turns.add(payload.turn_id);
+      state.runningTurns.add(payload.turn_id);
+    }
+    if (["task_complete", "task_interrupted", "turn_aborted"].includes(payload.type)) {
+      if (payload.turn_id) state.runningTurns.delete(payload.turn_id);
+      else state.runningTurns.clear();
+    }
     if (payload.type === "task_complete" && Number.isFinite(payload.time_to_first_token_ms)) {
       state.ttftTotalMs += payload.time_to_first_token_ms;
       state.ttftSamples += 1;
@@ -200,6 +208,7 @@ export function sessionStatusSnapshot(state, threadId) {
   const contextWindow = state.contextWindow > 0 ? state.contextWindow : null;
   return {
     threadId,
+    isRunning: state.runningTurns.size > 0,
     turns: state.turns.size,
     steps: state.responses.size,
     totalTokens: total?.total_tokens ?? null,
@@ -248,24 +257,32 @@ async function findLog(directory, threadId) {
 }
 
 export class SessionStatusReader {
-  constructor({ sessionsDir = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex"), "sessions") } = {}) {
+  constructor({ sessionsDir = path.join(process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex"), "sessions"), now = Date.now } = {}) {
     this.sessionsDir = sessionsDir;
+    this.now = now;
     this.states = new Map();
-    this.missingCheckedAt = new Map();
+    this.missingChecks = new Map();
+  }
+
+  retryAfterMs(threadId) {
+    return Math.max(0, (this.missingChecks.get(threadId)?.nextCheckAt ?? 0) - this.now());
   }
 
   async read(threadId) {
     if (!THREAD_ID.test(threadId ?? "")) return null;
     let state = this.states.get(threadId);
     if (!state) {
-      const lastCheck = this.missingCheckedAt.get(threadId) ?? 0;
-      if (Date.now() - lastCheck < 10_000) return null;
-      this.missingCheckedAt.set(threadId, Date.now());
+      if (this.retryAfterMs(threadId) > 0) return null;
       const filePath = await findLog(this.sessionsDir, threadId);
-      if (!filePath) return null;
+      if (!filePath) {
+        const attempts = this.missingChecks.get(threadId)?.attempts ?? 0;
+        const delay = [500, 1000, 2000][attempts] ?? 10_000;
+        this.missingChecks.set(threadId, { attempts: attempts + 1, nextCheckAt: this.now() + delay });
+        return null;
+      }
       state = emptyState(filePath);
       this.states.set(threadId, state);
-      this.missingCheckedAt.delete(threadId);
+      this.missingChecks.delete(threadId);
     }
     let info;
     try { info = await stat(state.filePath); }