codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/page/compileBridge.js

@@ -8,13 +8,21 @@
   'use strict';
 
   const COMPILE_TEMPLATE_TTL_MS = 5 * 60 * 1000;
+  const MAX_RECENT_COMPILE_CAPTURES = 8;
+  const COMPILE_LOG_MAX_AGE_MS = 30000;
   const GLOBAL_STATE_KEY = '__codexOverleafCompileBridgeState';
+  const FETCH_WRAPPER_REVISION = '2026-10-17-compile-capture-v4';
 
   function create(deps = {}) {
     const pageWindow = deps.window || window;
     const pageDocument = deps.document || document;
     let installed = false;
-    const state = pageWindow[GLOBAL_STATE_KEY] || {
+    const previousState = pageWindow[GLOBAL_STATE_KEY];
+    // A buried wrapper still closes over its old state. Isolate its counters and
+    // late responses while keeping the other script's fetch chain intact.
+    const replaceWrapper = previousState?.wrappedFetch
+      && (previousState.wrapperRevision !== FETCH_WRAPPER_REVISION || pageWindow.fetch !== previousState.wrappedFetch);
+    const state = replaceWrapper ? { ...previousState, inputListenerInstalled: false } : previousState || {
       capturedRequestTemplate: null,
       lastCompileResponse: null,
       lastCompileAt: 0,
@@ -24,6 +32,15 @@
       wrappedFetch: null,
       inputListenerInstalled: false
     };
+    if (replaceWrapper && previousState.inputListener) {
+      pageDocument.removeEventListener?.('input', previousState.inputListener, true);
+    }
+    state.compileRequestSequence ||= 0;
+    // Keep completed captures isolated from a detached older wrapper.
+    state.recentCompileCaptures = (state.recentCompileCaptures || []).slice(0, MAX_RECENT_COMPILE_CAPTURES);
+    // Busy tokens alone survive reinjection: old requests can release their own
+    // tokens without advancing the new wrapper's capture counters or results.
+    state.inFlightCompileRequests ||= new Set();
     pageWindow[GLOBAL_STATE_KEY] = state;
 
     function install() {
@@ -34,24 +51,28 @@
       interceptCompileRequests();
       if (typeof pageDocument.addEventListener === 'function' && state.inputListenerInstalled !== true) {
         pageDocument.addEventListener('input', markSourceEditFromInput, true);
+        state.inputListener = markSourceEditFromInput;
         state.inputListenerInstalled = true;
       }
     }
 
     function interceptCompileRequests() {
-      if (state.wrappedFetch && pageWindow.fetch === state.wrappedFetch) {
+      if (state.wrapperRevision === FETCH_WRAPPER_REVISION && state.wrappedFetch && pageWindow.fetch === state.wrappedFetch) {
         return;
       }
       if (!state.originalFetch || pageWindow.fetch !== state.wrappedFetch) {
         state.originalFetch = pageWindow.fetch;
       }
       const originalFetch = state.originalFetch;
+      state.wrapperRevision = FETCH_WRAPPER_REVISION;
       state.wrappedFetch = async function codexOverleafCompileFetchWrapper(...args) {
         const [resource, init] = args;
         const url = typeof resource === 'string' ? resource : (resource?.url || '');
-        const method = (init?.method || 'GET').toUpperCase();
-        const isCompileRequest = /\/project\/[^/]+\/compile\b/.test(url) && method === 'POST';
+        const method = (init?.method || resource?.method || 'GET').toUpperCase();
+        const isCompileRequest = /\/project\/[^/]+\/compile(?:[?#]|$)/.test(url) && method === 'POST';
+        const captureId = isCompileRequest ? ++state.compileRequestSequence : 0;
         const compileSourceChangeTimestamp = isCompileRequest ? state.lastKnownSourceEditTimestamp : 0;
+        const pendingRequest = isCompileRequest ? {} : null;
 
         if (isCompileRequest) {
           state.capturedRequestTemplate = {
@@ -67,29 +88,46 @@
           };
         }
 
-        const response = await originalFetch.apply(this, args);
-
-        if (isCompileRequest && response.ok) {
-          try {
-            const clone = response.clone();
-            const json = await clone.json();
-            const CompileAdapter = pageWindow.CodexOverleafCompileAdapter;
-            if (CompileAdapter) {
-              state.lastCompileResponse = CompileAdapter.parseCompileResponse(json);
-              state.lastCompileAt = Date.now();
-              state.lastCompileSourceChangeTimestamp = compileSourceChangeTimestamp;
-            }
-          } catch (_e) { /* ignore parse errors */ }
+        if (pendingRequest) state.inFlightCompileRequests.add(pendingRequest);
+        try {
+          const response = await originalFetch.apply(this, args);
+
+          if (isCompileRequest && response.ok) {
+            try {
+              const clone = response.clone();
+              const json = await clone.json();
+              const CompileAdapter = pageWindow.CodexOverleafCompileAdapter;
+              if (CompileAdapter) {
+                const capture = {
+                  compile: { ...CompileAdapter.parseCompileResponse(json), captureId },
+                  compiledAt: Date.now(),
+                  sourceChangeTimestamp: compileSourceChangeTimestamp
+                };
+                state.recentCompileCaptures = [capture, ...state.recentCompileCaptures]
+                  .sort((a, b) => b.compile.captureId - a.compile.captureId).slice(0, MAX_RECENT_COMPILE_CAPTURES);
+                // Preserve request order even if an older response finishes last.
+                if (captureId > (state.lastCompileResponse?.captureId || 0)) {
+                  state.lastCompileResponse = capture.compile;
+                  state.lastCompileAt = capture.compiledAt;
+                  state.lastCompileSourceChangeTimestamp = capture.sourceChangeTimestamp;
+                }
+              }
+            } catch (_e) { /* ignore parse errors */ }
+          }
+          return response;
+        } finally {
+          if (pendingRequest) state.inFlightCompileRequests.delete(pendingRequest);
         }
-
-        return response;
       };
       pageWindow.fetch = state.wrappedFetch;
     }
 
     async function triggerCompile(params = {}) {
+      const sourceAtTrigger = state.lastKnownSourceEditTimestamp;
       const saveResult = await waitForCompileSaveState(params);
-      if (params.requireVerifiedSave !== false && saveResult.state !== 'verified_saved') {
+      // Current Overleaf shows no save indicator while idle; a quiet editor is
+      // the same weaker evidence the update-idle check accepts.
+      if (params.requireVerifiedSave !== false && !['verified_saved', 'verified_quiet'].includes(saveResult.state)) {
         return {
           ok: false,
           reason: saveResult.reason || 'Overleaf save state was not verified.',
@@ -98,74 +136,29 @@
         };
       }
       const saveMetadata = buildSaveStateMetadata(saveResult);
-      const sourceChangeTimestamp = state.lastKnownSourceEditTimestamp;
-      if (params.preferUiClick === true) {
-        const clicked = clickOverleafCompileButton();
-        if (clicked) {
-          const captured = await waitForCapturedCompile(params.captureTimeoutMs || 60000);
-          if (captured.ok) {
-            return {
-              ok: true,
-              compile: state.lastCompileResponse,
-              ...saveMetadata,
-              triggeredBy: 'overleaf-button'
-            };
-          }
-          return {
-            ok: true,
-            compile: { ok: true, status: 'triggered' },
-            resultCaptured: false,
-            reason: captured.reason,
-            ...saveMetadata,
-            triggeredBy: 'overleaf-button'
-          };
-        }
-      }
+      const startCaptureId = state.compileRequestSequence;
       const template = state.capturedRequestTemplate;
-      if (!template) {
-        const clicked = clickOverleafCompileButton();
-        if (!clicked) {
-          return {
-            ok: false,
-            reason: 'No Overleaf Recompile button or compile request template is available.',
-            ...saveMetadata
-          };
-        }
-        const captured = await waitForCapturedCompile(params.captureTimeoutMs || 60000);
-        if (!captured.ok) {
-          return {
-            ...captured,
-            ...saveMetadata
-          };
-        }
+      const button = findOverleafCompileButton();
+      // Busy UI or observed requests forbid the template fallback too. Waiting
+      // can reuse the in-flight result or click the main button once it is idle.
+      if (isCompileBusy(button) || (button && (params.preferUiClick === true || !isFreshCapturedRequestTemplate(template)))) {
+        const captured = await waitForCapturedCompile(params.captureTimeoutMs || 60000, sourceAtTrigger);
         return {
           ok: true,
-          compile: state.lastCompileResponse,
+          compile: captured.compile || { ok: true, status: 'triggered' },
+          resultCaptured: captured.ok,
+          reason: captured.reason || '',
           ...saveMetadata,
-          triggeredBy: 'overleaf-button'
+          ...(captured.clicked ? { triggeredBy: 'overleaf-button' } : {})
         };
       }
-      if (!isFreshCapturedRequestTemplate(template)) {
-        const clicked = clickOverleafCompileButton();
-        if (!clicked) {
-          return {
-            ok: false,
-            reason: 'Stored compile request template expired. Please click Overleaf Recompile once, then retry.',
-            ...saveMetadata
-          };
-        }
-        const captured = await waitForCapturedCompile(params.captureTimeoutMs || 60000);
-        if (!captured.ok) {
-          return {
-            ...captured,
-            ...saveMetadata
-          };
-        }
+      if (!template || !isFreshCapturedRequestTemplate(template)) {
         return {
-          ok: true,
-          compile: state.lastCompileResponse,
-          ...saveMetadata,
-          triggeredBy: 'overleaf-button'
+          ok: false,
+          reason: template
+            ? 'Stored compile request template expired. Please click Overleaf Recompile once, then retry.'
+            : 'No Overleaf Recompile button or compile request template is available.',
+          ...saveMetadata
         };
       }
 
@@ -183,17 +176,12 @@
             ...saveMetadata
           };
         }
-        const json = await response.json();
-        const CompileAdapter = pageWindow.CodexOverleafCompileAdapter;
-        const parsed = CompileAdapter
-          ? CompileAdapter.parseCompileResponse(json)
-          : { ok: false, reason: 'CompileAdapter not available' };
-        state.lastCompileResponse = parsed;
-        state.lastCompileAt = Date.now();
-        state.lastCompileSourceChangeTimestamp = sourceChangeTimestamp;
+        const captured = findEligibleCapture(sourceAtTrigger, startCaptureId)?.compile;
         return {
           ok: true,
-          compile: parsed,
+          compile: captured || { ok: false, status: 'triggered' },
+          resultCaptured: Boolean(captured),
+          reason: captured ? '' : 'compile_capture_missing',
           ...saveMetadata
         };
       } catch (error) {
@@ -215,7 +203,9 @@
       }
       try {
         return normalizeSaveStateResult(
-          await deps.waitForSaveState({ deadlineMs: resolveWaitForSaveMs(params.waitForSaveMs) })
+          await deps.waitForSaveState({ deadlineMs: resolveWaitForSaveMs(params.waitForSaveMs),
+            // Only a caller that requires save evidence may settle for a quiet editor.
+            allowQuietEditorFallback: params.requireVerifiedSave !== false, quietFallbackMs: 1000 })
         );
       } catch (error) {
         return {
@@ -269,18 +259,16 @@
         return { ok: false, reason: 'CompileAdapter not loaded' };
       }
 
-      const maxAgeMs = params.maxAgeMs || 30000;
-      const compileLogFresh = CompileAdapter.isCompileLogFresh(
-        { sourceChangeTimestamp: state.lastCompileSourceChangeTimestamp },
-        state.lastKnownSourceEditTimestamp
-      );
-      const needsFreshCompile = !state.lastCompileResponse?.ok
-        || (Date.now() - state.lastCompileAt > maxAgeMs)
-        || !compileLogFresh;
+      const maxAgeMs = params.maxAgeMs ?? COMPILE_LOG_MAX_AGE_MS;
+      let capture = params.captureId != null
+        ? state.recentCompileCaptures.find(item => item.compile.captureId === params.captureId)
+        : state.recentCompileCaptures[0];
+      const needsFreshCompile = !capture?.compile.ok || Boolean(captureFreshnessReason(capture, maxAgeMs));
 
-      if (needsFreshCompile && params.triggerIfStale !== false) {
+      // A named capture must never silently switch to another compile's log.
+      if (needsFreshCompile && params.captureId == null && params.triggerIfStale !== false) {
         const compileResult = await triggerCompile({ waitForSaveMs: resolveWaitForSaveMs(params.waitForSaveMs) });
-        if (!compileResult.ok) {
+        if (!compileResult.ok || !compileResult.resultCaptured) {
           return {
             ok: false,
             reason: `Could not get fresh compile: ${compileResult.reason}`,
@@ -288,38 +276,70 @@
             saveState: compileResult.saveState
           };
         }
+        capture = state.recentCompileCaptures.find(item => item.compile.captureId === compileResult.compile?.captureId);
       }
 
-      const compiled = state.lastCompileResponse;
+      if (!capture) return { ok: false, reason: 'compile_capture_missing' };
+      const { compile: compiled, compiledAt } = capture;
+      const freshnessReason = captureFreshnessReason(capture, maxAgeMs);
+      if (freshnessReason) return { ok: false, captureId: compiled.captureId, fresh: false, reason: freshnessReason };
       if (!compiled?.ok || !compiled.logUrl) {
-        return { ok: false, reason: 'No compile log URL available' };
+        return { ok: false, reason: compiled?.reason || 'No compile log URL available' };
       }
 
+      const candidates = [];
+      if (compiled.build && compiled.pdfDownloadDomain) {
+        // pdfDownloadDomain already includes Overleaf's outputUrlPrefix.
+        candidates.push({ route: 'download', url: `${compiled.pdfDownloadDomain}${compiled.logUrl}` });
+      }
       try {
-        const logUrl = compiled.logUrl.startsWith('/')
-          ? `${pageWindow.location.origin}${compiled.logUrl}`
-          : compiled.logUrl;
-        const response = await pageWindow.fetch(logUrl, { credentials: 'same-origin' });
-        if (!response.ok) {
-          return { ok: false, reason: `Failed to fetch compile log: ${response.status}` };
+        const url = new URL(compiled.logUrl, pageWindow.location.origin);
+        if (url.origin === pageWindow.location.origin) {
+          if (compiled.clsiServerId) url.searchParams.set('clsiserverid', compiled.clsiServerId);
+          if (!candidates.some(candidate => candidate.url === url.href)) candidates.push({ route: 'origin', url: url.href });
+        }
+      } catch (_error) { /* invalid log URL is reported below */ }
+      const failures = [];
+      for (const { route, url } of candidates) {
+        try {
+          const credentials = new URL(url).origin === pageWindow.location.origin ? 'same-origin' : 'omit';
+          const response = await pageWindow.fetch(url, { credentials, cache: 'no-store' });
+          if (!response.ok) {
+            failures.push(`${route} HTTP ${response.status}`);
+            continue;
+          }
+          const logContent = await response.text();
+          const parsed = CompileAdapter.parseLogErrors(logContent);
+          const reason = captureFreshnessReason(capture, maxAgeMs);
+          return {
+            ok: logContent.trim().length > 0,
+            captureId: compiled.captureId,
+            log: CompileAdapter.truncateLogForContext(logContent),
+            errors: parsed.errors,
+            warnings: parsed.warnings,
+            compiledAt,
+            fresh: !reason,
+            reason: reason || (logContent.trim() ? '' : 'compile_log_empty')
+          };
+        } catch (_error) {
+          failures.push(`${route} network error`);
         }
-        const logContent = await response.text();
-        const truncated = CompileAdapter.truncateLogForContext(logContent);
-        const parsed = CompileAdapter.parseLogErrors(logContent);
-        return {
-          ok: true,
-          log: truncated,
-          errors: parsed.errors,
-          warnings: parsed.warnings,
-          compiledAt: state.lastCompileAt,
-          fresh: CompileAdapter.isCompileLogFresh(
-            { sourceChangeTimestamp: state.lastCompileSourceChangeTimestamp },
-            state.lastKnownSourceEditTimestamp
-          )
-        };
-      } catch (error) {
-        return { ok: false, reason: `Log fetch error: ${error.message}` };
       }
+      const reason = captureFreshnessReason(capture, maxAgeMs);
+      return { ok: false, captureId: compiled.captureId, fresh: !reason,
+        reason: reason || (failures.length ? `compile_log_fetch: ${failures.join('; ')}` : 'compile_log_url_invalid') };
+    }
+
+    function captureFreshnessReason(capture, maxAgeMs = COMPILE_LOG_MAX_AGE_MS) {
+      if (!capture) return 'compile_capture_missing';
+      if (!(capture.sourceChangeTimestamp >= state.lastKnownSourceEditTimestamp)) return 'compile_log_stale_source';
+      if (!(Date.now() - capture.compiledAt <= maxAgeMs)) return 'compile_log_expired';
+      return '';
+    }
+
+    function findEligibleCapture(sourceAtTrigger, afterCaptureId = 0) {
+      return state.recentCompileCaptures.find(capture => capture.compile.captureId > afterCaptureId
+        && capture.sourceChangeTimestamp >= sourceAtTrigger && !captureFreshnessReason(capture));
     }
 
     function getCompileState() {
@@ -341,7 +361,7 @@
     }
 
     function markSourceEdited(timestamp = Date.now()) {
-      state.lastKnownSourceEditTimestamp = timestamp;
+      state.lastKnownSourceEditTimestamp = Math.max(timestamp, state.lastKnownSourceEditTimestamp + 1);
     }
 
     function markSourceEditFromInput(event) {
@@ -359,56 +379,50 @@
       markSourceEdited();
     }
 
-    function clickOverleafCompileButton() {
-      const candidates = findOverleafCompileButtons();
-      for (const candidate of candidates) {
-        if (isDisabled(candidate)) {
-          continue;
-        }
-        if (typeof candidate.click === 'function') {
-          candidate.click();
+    function clickOverleafCompileButton(button) {
+      if (!button || isCompileBusy(button)) return false;
+      if (typeof button.click === 'function') {
+        button.click();
+        return true;
+      }
+      if (typeof button.dispatchEvent === 'function') {
+        const EventCtor = pageWindow.MouseEvent || pageWindow.Event;
+        if (EventCtor) {
+          button.dispatchEvent(new EventCtor('click', { bubbles: true, cancelable: true }));
           return true;
         }
-        if (typeof candidate.dispatchEvent === 'function') {
-          const EventCtor = pageWindow.MouseEvent || pageWindow.Event;
-          if (EventCtor) {
-            candidate.dispatchEvent(new EventCtor('click', { bubbles: true, cancelable: true }));
-            return true;
-          }
-        }
       }
       return false;
     }
 
-    function findOverleafCompileButtons() {
-      if (typeof pageDocument.querySelectorAll !== 'function') {
-        return [];
-      }
-      const selectors = [
-        'button',
-        '[role="button"]',
-        '[aria-label*="compile" i]',
-        '[title*="compile" i]',
-        '[data-testid*="compile" i]'
-      ];
-      const nodes = [];
-      for (const selector of selectors) {
-        try {
-          nodes.push(...Array.from(pageDocument.querySelectorAll(selector)));
-        } catch (_e) { /* ignore unsupported selectors in tests/older browsers */ }
-      }
-      return uniqueNodes(nodes).filter(isCompileButton);
+    function findOverleafCompileButton() {
+      if (typeof pageDocument.querySelectorAll !== 'function') return null;
+      const nodes = Array.from(pageDocument.querySelectorAll('button, [role="button"]')).filter(isCompileControl);
+      // Keep the main button selected while busy; never fall through to the
+      // enabled split toggle, menu entries or another label containing "compile".
+      return nodes.find(node => node.classList?.contains('compile-button'))
+        || nodes.find(node => /^(?:recompile|compile|重新编译|编译)$/i.test(compileButtonLabel(node))) || null;
     }
 
-    function isCompileButton(node) {
-      const text = [
-        node.textContent,
-        node.innerText,
-        node.getAttribute?.('aria-label'),
-        node.getAttribute?.('title'),
-        node.getAttribute?.('data-testid')
-      ].filter(Boolean).join(' ').toLowerCase();
-      return /\b(recompile|compile)\b/.test(text) || /重新编译|编译/.test(text);
+    function isCompileControl(node) {
+      const extensionRoot = node.closest?.('#codex-overleaf-panel, [data-codex-overleaf-root], [id^="codex-"], [class^="codex-"], [class*=" codex-"]');
+      // The extension's mounted-state classes on html/body are not UI roots.
+      if (extensionRoot && !['HTML', 'BODY'].includes(extensionRoot.tagName)) return false;
+      if (node.closest?.('.compile-dropdown-toggle, #pdf-recompile-dropdown, .dropdown-menu, [role="menu"], [role="menuitem"], [role="menuitemcheckbox"], [role="menuitemradio"], [hidden], [inert], [aria-hidden="true"]')) return false;
+      const popup = node.getAttribute?.('aria-haspopup');
+      if ((popup && popup !== 'false') || node.getAttribute?.('data-toggle') === 'dropdown'
+        || node.getAttribute?.('data-bs-toggle') === 'dropdown') return false;
+      return !/^(?:stop\b|停止编译|终止编译)/i.test(compileButtonLabel(node));
+    }
+
+    function compileButtonLabel(node) {
+      return [node?.textContent, node?.innerText, node?.getAttribute?.('aria-label'), node?.getAttribute?.('title')]
+        .map(value => String(value || '').replace(/\s+/g, ' ').trim()).find(Boolean) || '';
+    }
+
+    function isCompileBusy(button) {
+      return state.inFlightCompileRequests.size > 0 || Boolean(button && (isDisabled(button)
+        || /^(?:compiling|正在编译|编译中)\s*[.。…]*$/i.test(compileButtonLabel(button))));
     }
 
     function isDisabled(node) {
@@ -417,16 +431,19 @@
         || node.getAttribute?.('aria-disabled') === 'true');
     }
 
-    async function waitForCapturedCompile(timeoutMs) {
-      const startCompileAt = state.lastCompileAt;
+    async function waitForCapturedCompile(timeoutMs, sourceAtTrigger) {
       const deadline = Date.now() + timeoutMs;
-      while (Date.now() < deadline) {
-        if (state.lastCompileAt > startCompileAt && state.lastCompileResponse) {
-          return { ok: true };
-        }
-        await delay(100);
+      let clicked = false;
+      while (true) {
+        const capture = findEligibleCapture(sourceAtTrigger);
+        if (capture) return { ok: true, compile: capture.compile, clicked };
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) break;
+        if (!clicked) clicked = clickOverleafCompileButton(findOverleafCompileButton());
+        await delay(Math.min(100, remainingMs));
       }
-      return { ok: false, reason: 'Clicked Overleaf Recompile, but no compile result was captured.' };
+      return { ok: false, clicked, reason: clicked
+        ? 'Clicked Overleaf Recompile, but no compile result was captured.' : 'compile_capture_missing' };
     }
 
     return {
@@ -448,10 +465,6 @@
     return new Promise(resolve => setTimeout(resolve, ms));
   }
 
-  function uniqueNodes(nodes) {
-    return Array.from(new Set(nodes.filter(Boolean)));
-  }
-
   return {
     COMPILE_TEMPLATE_TTL_MS,
     create,