codex-overleaf-link 1.9.10 → 1.9.12

package/extension/src/content/sessionMenuView.js

@@ -0,0 +1,218 @@
+(function initCodexOverleafSessionMenuView() {
+  'use strict';
+
+  function create(deps = {}) {
+    const {
+      commitSessionRename,
+      deleteSessionWithConfirm,
+      document,
+      formatSessionTime,
+      getActiveSession,
+      getPanel,
+      getSessionDisplayTitle,
+      getState,
+      isDisplayableSession,
+      isSessionRunning,
+      startNewSession,
+      switchSession,
+      tr
+    } = deps;
+
+    function applySessionLabel() {
+      const trigger = getPanel().querySelector('[data-session-menu-trigger]');
+      if (trigger) {
+        trigger.title = tr('sessionMenuOpen');
+        trigger.setAttribute('aria-label', tr('sessionMenuOpen'));
+      }
+      const textNode = getPanel().querySelector('[data-session-label-text]');
+      const deleteButton = getPanel().querySelector('[data-session-delete]');
+      const renameButton = getPanel().querySelector('[data-session-rename]');
+      const renameInput = getPanel().querySelector('[data-session-rename-input]');
+      const active = getActiveSession(getState());
+      if (textNode) {
+        textNode.textContent = active && isDisplayableSession(active)
+          ? getSessionDisplayTitle(active)
+          : tr('newSessionFallback');
+      }
+      if (deleteButton) {
+        const running = active ? isSessionRunning(active) : false;
+        const soleEmpty = Boolean(active) && !isDisplayableSession(active) && (getState()?.sessions || []).length <= 1;
+        deleteButton.disabled = !active || running || soleEmpty;
+        deleteButton.title = running ? tr('deleteRunningSession') : tr('deleteSession');
+        deleteButton.setAttribute('aria-label', running ? tr('deleteRunningSession') : tr('deleteSession'));
+      }
+      if (renameButton) {
+        renameButton.title = tr('renameSession');
+        renameButton.setAttribute('aria-label', tr('renameSession'));
+      }
+      renameInput?.setAttribute('aria-label', tr('renameSession'));
+    }
+
+    function bindActiveSessionHeader() {
+      getPanel().querySelector('[data-session-delete]')?.addEventListener('click', event => {
+        event.stopPropagation();
+        if (getState()?.activeSessionId) {
+          deleteSessionWithConfirm(getState().activeSessionId);
+        }
+      });
+      getPanel().querySelector('[data-session-rename]')?.addEventListener('click', event => {
+        event.stopPropagation();
+        beginActiveSessionRename();
+      });
+      getPanel().querySelector('[data-session-menu-trigger]')?.addEventListener('click', event => {
+        event.stopPropagation();
+        toggleSessionMenu();
+      });
+      document.addEventListener('click', event => {
+        const menu = getPanel()?.querySelector('[data-session-menu]');
+        if (!menu || menu.hidden) {
+          return;
+        }
+        const trigger = getPanel()?.querySelector('[data-session-menu-trigger]');
+        if (menu.contains(event.target) || trigger?.contains(event.target)) {
+          return;
+        }
+        closeSessionMenu();
+      }, true);
+      document.addEventListener('keydown', event => {
+        if (event.key === 'Escape') {
+          closeSessionMenu();
+        }
+      }, true);
+    }
+
+    function toggleSessionMenu() {
+      const menu = getPanel()?.querySelector('[data-session-menu]');
+      if (!menu) {
+        return;
+      }
+      if (menu.hidden) {
+        renderSessionMenu(menu);
+      }
+      menu.hidden = !menu.hidden;
+      getPanel()?.querySelector('[data-session-menu-trigger]')
+        ?.setAttribute('aria-expanded', menu.hidden ? 'false' : 'true');
+    }
+
+    function closeSessionMenu() {
+      const menu = getPanel()?.querySelector('[data-session-menu]');
+      if (!menu || menu.hidden) {
+        return;
+      }
+      menu.hidden = true;
+      getPanel()?.querySelector('[data-session-menu-trigger]')?.setAttribute('aria-expanded', 'false');
+    }
+
+    function renderSessionMenu(menu) {
+      menu.replaceChildren();
+      const state = getState();
+      const sessions = (state?.sessions || [])
+        .filter(isDisplayableSession)
+        .slice()
+        .sort((a, b) => String(b.updatedAt || b.createdAt || '').localeCompare(String(a.updatedAt || a.createdAt || '')));
+      for (const session of sessions) {
+        const row = document.createElement('button');
+        row.type = 'button';
+        row.className = 'codex-session-menu-item';
+        row.dataset.active = session.id === state?.activeSessionId ? 'true' : 'false';
+        row.dataset.running = isSessionRunning(session) ? 'true' : 'false';
+        const title = document.createElement('span');
+        title.className = 'codex-session-menu-item-title';
+        title.textContent = getSessionDisplayTitle(session);
+        title.title = getSessionDisplayTitle(session);
+        const time = document.createElement('time');
+        time.className = 'codex-session-menu-item-time';
+        time.textContent = formatSessionTime(session.updatedAt || session.createdAt);
+        const absoluteTs = session.updatedAt || session.createdAt;
+        if (absoluteTs) {
+          time.title = new Date(absoluteTs).toLocaleString();
+        }
+        row.append(title, time);
+        row.addEventListener('click', event => {
+          event.stopPropagation();
+          closeSessionMenu();
+          if (session.id !== getState()?.activeSessionId) {
+            switchSession(session.id);
+          }
+        });
+        menu.append(row);
+      }
+      const createButton = document.createElement('button');
+      createButton.type = 'button';
+      createButton.className = 'codex-session-menu-new';
+      createButton.textContent = `+ ${tr('newSession')}`;
+      createButton.addEventListener('click', event => {
+        event.stopPropagation();
+        closeSessionMenu();
+        startNewSession();
+      });
+      menu.append(createButton);
+    }
+
+    function beginActiveSessionRename() {
+      const active = getActiveSession(getState());
+      const wrap = getPanel().querySelector('[data-session-label]');
+      const trigger = getPanel().querySelector('[data-session-menu-trigger]');
+      const textNode = getPanel().querySelector('[data-session-label-text]');
+      const input = getPanel().querySelector('[data-session-rename-input]');
+      if (!active || !wrap || !textNode || !input) {
+        return;
+      }
+      closeSessionMenu();
+      let settled = false;
+      wrap.dataset.editing = 'true';
+      const seed = isDisplayableSession(active) ? getSessionDisplayTitle(active) : '';
+      input.value = seed;
+      input.hidden = false;
+      textNode.hidden = true;
+      if (trigger) {
+        trigger.hidden = true;
+      }
+      input.focus();
+      input.select();
+      const cleanup = () => {
+        input.removeEventListener('keydown', onKeydown);
+        input.removeEventListener('blur', onBlur);
+      };
+      const finish = commit => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        input.hidden = true;
+        textNode.hidden = false;
+        if (trigger) {
+          trigger.hidden = false;
+        }
+        delete wrap.dataset.editing;
+        if (commit && input.value.trim() !== seed.trim()) {
+          commitSessionRename(active.id, input.value);
+        }
+      };
+      const onKeydown = event => {
+        if (event.key === 'Enter') {
+          event.preventDefault();
+          finish(true);
+        } else if (event.key === 'Escape') {
+          event.preventDefault();
+          finish(false);
+        }
+      };
+      const onBlur = () => finish(true);
+      input.addEventListener('keydown', onKeydown);
+      input.addEventListener('blur', onBlur);
+    }
+
+    return {
+      applySessionLabel,
+      beginActiveSessionRename,
+      bindActiveSessionHeader,
+      closeSessionMenu,
+      renderSessionMenu,
+      toggleSessionMenu
+    };
+  }
+
+  window.CodexOverleafSessionMenuView = { create };
+})();

package/extension/src/content/updateIdle.js

@@ -41,7 +41,7 @@
       } catch (_error) {
         saveResult = { ok: false, state: 'unavailable' };
       }
-      const saved = saveResult?.ok === true && saveResult?.state === 'verified_saved';
+      const saved = saveResult?.ok === true && ['verified_saved', 'verified_quiet'].includes(saveResult?.state);
       if (saved) {
         stableSavedSince = stableSavedSince || Date.now();
       } else {

package/extension/src/page/saveState.js

@@ -0,0 +1,292 @@
+(function initCodexOverleafSaveState(root) {
+  'use strict';
+
+  function create(deps = {}) {
+    const {
+      delay,
+      detectEditor,
+      document,
+      getActiveFilePath,
+      readActiveEditorText
+    } = deps;
+    const pageWindow = deps.window || root;
+
+    async function waitForSaveState(params = {}) {
+      const deadlineMs = Number.isFinite(Number(params.deadlineMs)) ? Number(params.deadlineMs) : 5000;
+      const pollInterval = Number.isFinite(Number(params.pollIntervalMs)) ? Number(params.pollIntervalMs) : 100;
+      const quietFallbackMs = Number.isFinite(Number(params.quietFallbackMs)) ? Number(params.quietFallbackMs) : 1000;
+      const deadline = Date.now() + Math.max(0, deadlineMs);
+      let lastState = { state: 'unknown', reason: 'Overleaf save state has not been checked yet.' };
+      let quietSignature = '';
+      let quietSince = 0;
+
+      do {
+        let current;
+        try {
+          current = getOverleafSaveState();
+        } catch (error) {
+          return {
+            ok: false,
+            state: 'unavailable',
+            reason: `Could not check Overleaf save state: ${error.message}`
+          };
+        }
+        if (current.state === 'verified_saved') {
+          return { ok: true, state: 'verified_saved' };
+        }
+        if (current.state === 'unavailable') {
+          return {
+            ok: false,
+            state: 'unavailable',
+            reason: current.reason || 'Overleaf save state is unavailable.'
+          };
+        }
+        const quietEligible = params.allowQuietEditorFallback === true
+          && current.state === 'unknown'
+          && /save indicator was not found/i.test(current.reason || '')
+          && pageWindow.navigator?.onLine !== false
+          && detectEditor()?.ok === true;
+        if (quietEligible) {
+          const text = String(readActiveEditorText() || '');
+          const signature = `${getActiveFilePath()}:${text.length}:${text.slice(0, 80)}:${text.slice(-80)}`;
+          if (signature === quietSignature && Date.now() - quietSince >= Math.max(0, quietFallbackMs)) {
+            return { ok: true, state: 'verified_quiet', evidence: 'stable_editor_snapshot_without_save_indicator' };
+          }
+          if (signature !== quietSignature) {
+            quietSignature = signature;
+            quietSince = Date.now();
+          }
+        } else {
+          quietSignature = '';
+          quietSince = 0;
+        }
+        lastState = current;
+        if (Date.now() >= deadline) {
+          break;
+        }
+        await delay(Math.min(Math.max(1, pollInterval), Math.max(1, deadline - Date.now())));
+      } while (Date.now() < deadline);
+
+      return {
+        ok: false,
+        state: 'unknown_timeout',
+        reason: buildSaveStateTimeoutReason(lastState)
+      };
+    }
+
+    function getOverleafSaveState() {
+      if (!document || typeof document.querySelectorAll !== 'function') {
+        return {
+          state: 'unavailable',
+          reason: 'Overleaf document is unavailable for save-state detection.'
+        };
+      }
+      const selectors = [
+        '.toolbar-header [class*="save" i]',
+        '[class*="saving-status" i]',
+        '[class*="save-status" i]',
+        '[data-testid*="save" i]',
+        '[aria-label*="save" i]'
+      ];
+      let sawSaveCandidate = false;
+      let sawVerifiedSaved = false;
+      let sawNegativeState = false;
+      let sawSavingState = false;
+      for (const selector of selectors) {
+        const elements = document.querySelectorAll(selector);
+        for (const el of elements) {
+          if (isHiddenSaveIndicatorNode(el)) {
+            continue;
+          }
+          const texts = readSaveIndicatorTexts(el);
+          if (!texts.length) {
+            continue;
+          }
+          const combinedText = texts.join(' ');
+          if (isAnySaveIndicatorText(texts, combinedText, isNegativeSaveStateText)) {
+            sawNegativeState = true;
+            sawSaveCandidate = true;
+            continue;
+          }
+          if (isAnySaveIndicatorText(texts, combinedText, isSavingStateText)) {
+            sawSavingState = true;
+            sawSaveCandidate = true;
+            continue;
+          }
+          if (texts.some(isVerifiedSavedText)) {
+            sawVerifiedSaved = true;
+            continue;
+          }
+          if (isAnySaveIndicatorText(texts, combinedText, isSaveIndicatorCandidateText)) {
+            sawSaveCandidate = true;
+          }
+        }
+      }
+      if (sawNegativeState) {
+        return {
+          state: 'unknown',
+          reason: 'Overleaf save indicator reports changes are not saved.'
+        };
+      }
+      if (sawSavingState) {
+        return {
+          state: 'saving',
+          reason: 'Overleaf is still saving or syncing changes.'
+        };
+      }
+      if (sawVerifiedSaved) {
+        return { state: 'verified_saved' };
+      }
+      return {
+        state: 'unknown',
+        reason: sawSaveCandidate
+          ? 'Overleaf save indicator was present, but did not verify that all changes are saved.'
+          : 'Overleaf save indicator was not found.'
+      };
+    }
+
+    function isHiddenSaveIndicatorNode(node) {
+      if (!node) {
+        return true;
+      }
+      if (node.hidden === true || node.inert === true) {
+        return true;
+      }
+      if (hasSaveIndicatorAttribute(node, 'hidden') || hasSaveIndicatorAttribute(node, 'inert')) {
+        return true;
+      }
+      if (/^true$/i.test(String(node.getAttribute?.('aria-hidden') || ''))) {
+        return true;
+      }
+      if (hasHiddenSaveIndicatorAncestor(node)) {
+        return true;
+      }
+      if (isHiddenStyle(node.style)) {
+        return true;
+      }
+      if (isHiddenStyle(getComputedStyleForSaveIndicator(node))) {
+        return true;
+      }
+      return hasZeroSaveIndicatorLayout(node);
+    }
+
+    function hasHiddenSaveIndicatorAncestor(node) {
+      if (typeof node.closest === 'function') {
+        try {
+          if (node.closest('[hidden],[inert],[aria-hidden="true"]')) {
+            return true;
+          }
+        } catch (_error) {
+          // Fall back to walking parentElement below.
+        }
+      }
+      let current = node.parentElement;
+      while (current) {
+        if (current.hidden === true || current.inert === true) {
+          return true;
+        }
+        if (hasSaveIndicatorAttribute(current, 'hidden') || hasSaveIndicatorAttribute(current, 'inert')) {
+          return true;
+        }
+        if (/^true$/i.test(String(current.getAttribute?.('aria-hidden') || ''))) {
+          return true;
+        }
+        current = current.parentElement;
+      }
+      return false;
+    }
+
+    function hasSaveIndicatorAttribute(node, attribute) {
+      if (typeof node.hasAttribute === 'function') {
+        try {
+          return node.hasAttribute(attribute);
+        } catch (_error) {
+          return false;
+        }
+      }
+      const value = node.getAttribute?.(attribute);
+      return value != null && value !== '';
+    }
+
+    function isHiddenStyle(style) {
+      if (!style) {
+        return false;
+      }
+      return /^none$/i.test(String(style.display || ''))
+        || /^(hidden|collapse)$/i.test(String(style.visibility || ''));
+    }
+
+    function getComputedStyleForSaveIndicator(node) {
+      try {
+        const ownerWindow = node.ownerDocument?.defaultView || null;
+        return (ownerWindow || pageWindow)?.getComputedStyle?.(node) || null;
+      } catch (_error) {
+        return null;
+      }
+    }
+
+    function hasZeroSaveIndicatorLayout(node) {
+      if (typeof node.getClientRects !== 'function') {
+        return false;
+      }
+      try {
+        const rects = node.getClientRects();
+        if (rects && rects.length > 0) {
+          return false;
+        }
+        return node.offsetWidth === 0 && node.offsetHeight === 0;
+      } catch (_error) {
+        return false;
+      }
+    }
+
+    function readSaveIndicatorTexts(node) {
+      const parts = [
+        node.textContent,
+        node.innerText,
+        node.getAttribute?.('aria-label'),
+        node.getAttribute?.('title'),
+        node.getAttribute?.('value')
+      ].map(value => String(value || '').replace(/\s+/g, ' ').trim()).filter(Boolean);
+      return Array.from(new Set(parts));
+    }
+
+    function isAnySaveIndicatorText(texts, combinedText, predicate) {
+      return predicate(combinedText) || texts.some(predicate);
+    }
+
+    function isNegativeSaveStateText(text) {
+      return /\bnot\b[\s\S]{0,40}\bsaved\b|\b(?:unsaved|save failed|failed to save|could not save|unable to save)\b|未保存|保存失败/i.test(text);
+    }
+
+    function isSavingStateText(text) {
+      return /\b(saving|syncing|compiling)\b|保存中|正在保存|同步中/i.test(text);
+    }
+
+    function isVerifiedSavedText(text) {
+      if (isNegativeSaveStateText(text)) {
+        return false;
+      }
+      return /^\s*(?:all changes saved|changes saved|saved)[\s.!]*$/i.test(text)
+        || /已保存/i.test(text);
+    }
+
+    function isSaveIndicatorCandidateText(text) {
+      return /\bsave\b|\bsaved\b|\bsaving\b|保存/i.test(text);
+    }
+
+    function buildSaveStateTimeoutReason(lastState = {}) {
+      if (lastState.state === 'saving') {
+        return `Timed out waiting for Overleaf to finish saving changes. ${lastState.reason || ''}`.trim();
+      }
+      return `Timed out waiting for a verified Overleaf save state. ${lastState.reason || ''}`.trim();
+    }
+
+    return {
+      getOverleafSaveState,
+      waitForSaveState
+    };
+  }
+
+  root.CodexOverleafSaveState = { create };
+})(typeof window !== 'undefined' ? window : globalThis);