codex-overleaf-link 1.9.2 → 1.9.4

package/extension/src/backgroundUpdateCoordinator.js

@@ -0,0 +1,414 @@
+(function initCodexOverleafUpdateCoordinator(root) {
+  'use strict';
+
+  const UPDATE_STATE_KEY = 'codex-overleaf-managed-update-state-v1';
+  const CONSENT_STATE_KEY = 'codex-overleaf-update-consent-v1';
+  const CHECK_ALARM = 'codex-overleaf-consent-update-check';
+  const CHECK_INTERVAL_MINUTES = 24 * 60;
+  const SNOOZE_MS = 24 * 60 * 60 * 1000;
+  const CANDIDATE_MAX_AGE_MS = 5 * 60 * 1000;
+  const LEGACY_GUARD = Number.MAX_SAFE_INTEGER;
+  const OVERLEAF_MATCHES = [
+    'https://www.overleaf.com/project/*',
+    'https://overleaf.com/project/*'
+  ];
+  const MESSAGE_TYPES = new Set([
+    'codex-overleaf/consent-update-get-state',
+    'codex-overleaf/consent-update-check',
+    'codex-overleaf/consent-update-install',
+    'codex-overleaf/consent-update-later'
+  ]);
+
+  const policy = root.CodexOverleafUpdateConsent;
+  let nativeBridge = null;
+  let initialized = false;
+  let policyTail = Promise.resolve();
+
+  function init(options = {}) {
+    if (initialized || !policy) return;
+    initialized = true;
+    nativeBridge = options.nativeBridge || root.CodexOverleafNativeBridge;
+
+    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+      if (!MESSAGE_TYPES.has(message?.type)) return undefined;
+      if (!isAllowedSender(sender)) {
+        sendResponse({ ok: false, error: { code: 'forbidden_sender', message: 'Update actions are limited to this extension and Overleaf project tabs.' } });
+        return false;
+      }
+      enqueuePolicyAction(() => handleMessage(message))
+        .then(result => sendResponse({ ok: true, result }))
+        .catch(error => sendResponse({ ok: false, error: safeError(error) }));
+      return true;
+    });
+
+    chrome.alarms?.onAlarm?.addListener(alarm => {
+      if (alarm?.name === CHECK_ALARM) {
+        void enqueuePolicyAction(() => checkOnly({ manual: false })).catch(() => {});
+      }
+    });
+
+    chrome.storage?.onChanged?.addListener((changes, area) => {
+      if (area !== 'local' || (!changes[UPDATE_STATE_KEY] && !changes[CONSENT_STATE_KEY])) return;
+      void handleObservedStateChange();
+    });
+
+    void startup();
+  }
+
+  async function startup() {
+    chrome.alarms?.create?.(CHECK_ALARM, {
+      delayInMinutes: 0.5,
+      periodInMinutes: CHECK_INTERVAL_MINUTES
+    });
+    await settleTerminalConsent();
+    await armLegacyGuard();
+    await publishView();
+  }
+
+  async function handleMessage(message) {
+    switch (message.type) {
+      case 'codex-overleaf/consent-update-get-state':
+        return getView();
+      case 'codex-overleaf/consent-update-check':
+        return checkOnly({ manual: true });
+      case 'codex-overleaf/consent-update-install':
+        return installUpdate();
+      case 'codex-overleaf/consent-update-later':
+        return postponeUpdate();
+      default:
+        throw codedError('unknown_update_action', 'Unknown update action.');
+    }
+  }
+
+  async function checkOnly({ manual }) {
+    const [currentState, consent] = await Promise.all([getUpdateState(), getConsentState()]);
+    if (consent.authorizedVersion || policy.isExecutionState(currentState.state)) {
+      return getView();
+    }
+    await setUpdateState({
+      ...currentState,
+      state: 'checking',
+      code: '',
+      message: '',
+      blocker: '',
+      blockers: []
+    });
+
+    try {
+      const result = await requestNative('update.check', {
+        currentVersion: currentVersion(),
+        etag: currentState.etag || ''
+      });
+      const checkedAt = Date.now();
+      if (result.available) {
+        const nextConsent = result.latestVersion !== consent.snoozedVersion
+          ? { ...consent, snoozedVersion: '', snoozedUntil: 0 }
+          : consent;
+        await setConsentState({
+          ...nextConsent,
+          lastPromptedVersion: result.latestVersion,
+          lastPromptedAt: manual ? checkedAt : nextConsent.lastPromptedAt
+        });
+        await setUpdateState({
+          ...currentState,
+          state: 'update_available',
+          managed: true,
+          currentVersion: result.currentVersion || currentVersion(),
+          latestVersion: result.latestVersion,
+          etag: result.etag || currentState.etag || '',
+          lastCheckedAt: checkedAt,
+          postponeUntil: LEGACY_GUARD,
+          code: '',
+          message: ''
+        });
+      } else if (result.reason === 'not_modified' &&
+          policy.compareStableVersions(currentState.latestVersion, currentVersion()) > 0) {
+        await setUpdateState({
+          ...currentState,
+          state: 'update_available',
+          lastCheckedAt: checkedAt,
+          postponeUntil: LEGACY_GUARD,
+          code: '',
+          message: ''
+        });
+      } else {
+        await setUpdateState({
+          ...currentState,
+          state: 'idle',
+          currentVersion: result.currentVersion || currentVersion(),
+          latestVersion: result.latestVersion || result.currentVersion || currentVersion(),
+          etag: result.etag || currentState.etag || '',
+          lastCheckedAt: checkedAt,
+          postponeUntil: LEGACY_GUARD,
+          transactionId: '',
+          code: '',
+          message: ''
+        });
+      }
+      return getView();
+    } catch (error) {
+      await setUpdateState({
+        ...currentState,
+        state: 'failed',
+        postponeUntil: LEGACY_GUARD,
+        code: safeCode(error),
+        message: safeMessage(error)
+      });
+      throw error;
+    }
+  }
+
+  async function installUpdate() {
+    let state = await getUpdateState();
+    let consent = await getConsentState();
+    const candidateStale = !state.lastCheckedAt || Date.now() - state.lastCheckedAt > CANDIDATE_MAX_AGE_MS;
+    if (state.state !== 'update_available' || candidateStale) {
+      await checkOnly({ manual: true });
+      state = await getUpdateState();
+      consent = await getConsentState();
+    }
+    if (state.state !== 'update_available' ||
+        policy.compareStableVersions(state.latestVersion, currentVersion()) <= 0) {
+      throw codedError('update_candidate_missing', 'No newer signed stable update is available.');
+    }
+
+    const authorizationId = crypto.randomUUID();
+    await requestNative('update.authorize', {
+      authorizationId,
+      targetVersion: state.latestVersion,
+      currentVersion: currentVersion()
+    });
+    await setConsentState({
+      ...consent,
+      snoozedVersion: '',
+      snoozedUntil: 0,
+      authorizedVersion: state.latestVersion,
+      authorizationId,
+      authorizedAt: Date.now()
+    });
+    await setUpdateState({ ...state, postponeUntil: 0, code: '', message: '' });
+
+    try {
+      const result = await chrome.runtime.sendMessage({ type: 'codex-overleaf/update-check-now' });
+      if (result === undefined) {
+        throw codedError('update_executor_unavailable', 'The managed update executor is unavailable.');
+      }
+      return getView();
+    } catch (error) {
+      await bestEffortRevoke({
+        authorizationId,
+        targetVersion: state.latestVersion,
+        transactionId: ''
+      });
+      await setConsentState({
+        ...consent,
+        authorizedVersion: '',
+        authorizationId: '',
+        authorizedAt: 0
+      });
+      await armLegacyGuard();
+      throw error;
+    }
+  }
+
+  async function postponeUpdate() {
+    const [state, consent] = await Promise.all([getUpdateState(), getConsentState()]);
+    if (['applying', 'awaiting_health'].includes(state.state)) {
+      throw codedError('update_revoke_too_late', 'The update is already being installed.');
+    }
+    if (consent.authorizationId) {
+      try {
+        await requestNative('update.revoke', {
+          authorizationId: consent.authorizationId,
+          targetVersion: consent.authorizedVersion || state.latestVersion,
+          transactionId: state.transactionId || ''
+        });
+      } catch (error) {
+        if (error?.code === 'update_revoke_too_late') {
+          return getView();
+        }
+        throw error;
+      }
+    } else if (['staged', 'waiting_for_idle'].includes(state.state)) {
+      throw codedError('update_consent_mismatch', 'The staged update has no matching runtime authorization.');
+    }
+
+    const snoozedUntil = Date.now() + SNOOZE_MS;
+    await setUpdateState({
+      ...state,
+      state: 'update_available',
+      transactionId: '',
+      stagedAt: 0,
+      blocker: '',
+      blockers: [],
+      postponeUntil: LEGACY_GUARD,
+      code: '',
+      message: ''
+    });
+    await setConsentState({
+      ...consent,
+      snoozedVersion: state.latestVersion,
+      snoozedUntil,
+      authorizedVersion: '',
+      authorizationId: '',
+      authorizedAt: 0
+    });
+    return getView();
+  }
+
+  async function settleTerminalConsent() {
+    const [state, consent] = await Promise.all([getUpdateState(), getConsentState()]);
+    if (!policy.isTerminalState(state.state) || !consent.authorizationId) return;
+    await setConsentState({
+      ...consent,
+      authorizedVersion: '',
+      authorizationId: '',
+      authorizedAt: 0
+    });
+  }
+
+  async function handleObservedStateChange() {
+    await settleTerminalConsent();
+    const [state, consent] = await Promise.all([getUpdateState(), getConsentState()]);
+    if (!consent.authorizationId && !policy.isExecutionState(state.state)) {
+      await armLegacyGuard();
+    }
+    await publishView();
+  }
+
+  async function armLegacyGuard() {
+    const [state, consent] = await Promise.all([getUpdateState(), getConsentState()]);
+    if (consent.authorizationId || state.postponeUntil === LEGACY_GUARD) return state;
+    return setUpdateState({ ...state, postponeUntil: LEGACY_GUARD });
+  }
+
+  async function getView() {
+    const [state, consent] = await Promise.all([getUpdateState(), getConsentState()]);
+    return policy.deriveViewModel(state, consent, {
+      currentVersion: currentVersion(),
+      now: Date.now()
+    });
+  }
+
+  async function publishView() {
+    const view = await getView();
+    await setBadge(view.badge);
+    const tabs = await chrome.tabs.query({ url: OVERLEAF_MATCHES }).catch(() => []);
+    await Promise.all((tabs || []).map(tab => {
+      if (!Number.isInteger(tab?.id)) return Promise.resolve();
+      return chrome.tabs.sendMessage(tab.id, {
+        type: 'codex-overleaf/consent-update-state',
+        view
+      }).catch(() => {});
+    }));
+    return view;
+  }
+
+  async function setBadge(badge = {}) {
+    try {
+      await chrome.action.setBadgeText({ text: String(badge.text || '').slice(0, 4) });
+      if (badge.text) {
+        await chrome.action.setBadgeBackgroundColor({ color: badge.color || '#3578bd' });
+      }
+    } catch (_error) {
+      // Badge rendering is best-effort and never participates in update state.
+    }
+  }
+
+  async function getUpdateState() {
+    const stored = await chrome.storage.local.get(UPDATE_STATE_KEY);
+    return policy.normalizeUpdateState(stored?.[UPDATE_STATE_KEY], currentVersion());
+  }
+
+  async function setUpdateState(value) {
+    const next = policy.normalizeUpdateState(value, currentVersion());
+    await chrome.storage.local.set({ [UPDATE_STATE_KEY]: next });
+    return next;
+  }
+
+  async function getConsentState() {
+    const stored = await chrome.storage.local.get(CONSENT_STATE_KEY);
+    return policy.normalizeConsentState(stored?.[CONSENT_STATE_KEY]);
+  }
+
+  async function setConsentState(value) {
+    const next = policy.normalizeConsentState(value);
+    await chrome.storage.local.set({ [CONSENT_STATE_KEY]: next });
+    return next;
+  }
+
+  async function requestNative(method, params = {}) {
+    const response = await nativeBridge?.requestInternal?.({
+      id: crypto.randomUUID(),
+      method,
+      params
+    });
+    if (!response?.ok) {
+      throw codedError(
+        response?.error?.code || 'native_connection_failed',
+        response?.error?.message || 'Native Host update request failed.'
+      );
+    }
+    return response.result || {};
+  }
+
+  async function bestEffortRevoke(params) {
+    try {
+      await requestNative('update.revoke', params);
+    } catch (_error) {
+      // Native authorization remains the hard gate if cleanup cannot connect.
+    }
+  }
+
+  function enqueuePolicyAction(action) {
+    const result = policyTail.then(action, action);
+    policyTail = result.catch(() => {});
+    return result;
+  }
+
+  function isAllowedSender(sender) {
+    if (sender?.id && sender.id !== chrome.runtime.id) return false;
+    if (!sender?.tab) return true;
+    try {
+      const url = new URL(sender.tab.url || '');
+      return url.protocol === 'https:' &&
+        (url.hostname === 'www.overleaf.com' || url.hostname === 'overleaf.com') &&
+        url.pathname.startsWith('/project/');
+    } catch (_error) {
+      return false;
+    }
+  }
+
+  function currentVersion() {
+    return String(
+      root.CodexOverleafCompatibility?.BUILD_TARGET_VERSION ||
+      chrome.runtime.getManifest().version ||
+      ''
+    );
+  }
+
+  function codedError(code, message) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+  }
+
+  function safeError(error) {
+    return { code: safeCode(error), message: safeMessage(error) };
+  }
+
+  function safeCode(error) {
+    const code = String(error?.code || '');
+    return /^[a-z0-9_]{1,80}$/.test(code) ? code : 'update_failed';
+  }
+
+  function safeMessage(error) {
+    return String(error?.message || 'Update failed.')
+      .replace(/(?:file:\/\/)?(?:[A-Za-z]:[\\/]|\/Users\/|\/home\/)[^\s]*/g, '[local path]')
+      .replace(/\s+/g, ' ')
+      .trim()
+      .slice(0, 300);
+  }
+
+  root.CodexOverleafUpdateCoordinator = Object.freeze({ init });
+})(globalThis);

package/extension/src/content/contentRuntime.js

@@ -778,6 +778,9 @@
     storageKey = getProjectStorageKey(LEGACY_STORAGE_KEY, window.location.href);
     state = normalizePanelState(await loadStoredState(), { restoreRunningRuns: true });
     ensurePanelOpen();
+    root.CodexOverleafUpdateNotice?.mount?.(panel?.panelEl || panel, {
+      getLocale: () => state?.locale || 'en'
+    });
     // v1.8.1: on a non-editor route the panel must NEVER first paint the
     // per-project session UI (composer + probe line) and then swap — mount
     // the dashboard shell synchronously; the account-scope resolution below

package/extension/src/content/updateNotice.js

@@ -0,0 +1,248 @@
+(function initCodexOverleafUpdateNotice(root) {
+  'use strict';
+
+  let notice = null;
+  let currentView = null;
+  let mountedPanel = null;
+  let actionInFlight = false;
+  let completionTimer = null;
+  let listenerInstalled = false;
+  let getLocale = () => '';
+
+  function mount(panelLike, options = {}) {
+    if (typeof options.getLocale === 'function') {
+      getLocale = options.getLocale;
+    }
+    const panel = panelLike?.panelEl || panelLike;
+    if (!panel) return;
+    if (mountedPanel === panel) {
+      render();
+      return;
+    }
+    mountedPanel = panel;
+    notice?.remove();
+    notice = document.createElement('section');
+    notice.className = 'codex-update-notice';
+    notice.hidden = true;
+    notice.setAttribute('aria-label', tx('Stable update', '稳定版更新'));
+    const header = panel.querySelector('[data-panel-header]');
+    if (typeof header?.insertAdjacentElement === 'function') {
+      header.insertAdjacentElement('afterend', notice);
+    } else if (typeof header?.after === 'function') {
+      header.after(notice);
+    } else if (typeof panel.prepend === 'function') {
+      panel.prepend(notice);
+    } else {
+      panel.append?.(notice);
+    }
+    notice.addEventListener('click', handleClick);
+
+    if (!listenerInstalled) {
+      listenerInstalled = true;
+      chrome.runtime.onMessage.addListener(message => {
+        if (message?.type !== 'codex-overleaf/consent-update-state') return;
+        currentView = message.view;
+        render();
+      });
+    }
+    request('codex-overleaf/consent-update-get-state')
+      .then(view => {
+        currentView = view;
+        render();
+      })
+      .catch(() => {});
+  }
+
+  async function handleClick(event) {
+    const action = event.target?.closest?.('[data-update-notice-action]')?.dataset?.updateNoticeAction;
+    if (!action || actionInFlight) return;
+    actionInFlight = true;
+    render();
+    try {
+      currentView = await request({
+        install: 'codex-overleaf/consent-update-install',
+        later: 'codex-overleaf/consent-update-later',
+        retry: 'codex-overleaf/consent-update-check'
+      }[action]);
+    } catch (error) {
+      currentView = {
+        ...(currentView || {}),
+        state: {
+          ...(currentView?.state || {}),
+          state: 'failed',
+          code: error?.code || 'update_failed',
+          message: error?.message || tx('Update failed.', '更新失败。')
+        },
+        progress: { value: 0, determinate: true, phase: 'failed' },
+        showPanel: true
+      };
+    } finally {
+      actionInFlight = false;
+      render();
+    }
+  }
+
+  async function request(type) {
+    if (!type) throw new Error('Unknown update action.');
+    const response = await chrome.runtime.sendMessage({ type });
+    if (!response?.ok) {
+      const error = new Error(response?.error?.message || tx('Update action failed.', '更新操作失败。'));
+      error.code = response?.error?.code || 'update_failed';
+      throw error;
+    }
+    return response.result;
+  }
+
+  function render() {
+    if (!notice || !currentView) return;
+    clearTimeout(completionTimer);
+    if (!currentView.showPanel) {
+      notice.hidden = true;
+      notice.replaceChildren();
+      return;
+    }
+
+    const focusedAction = document.activeElement?.dataset?.updateNoticeAction || '';
+    const state = currentView.state || {};
+    const progress = currentView.progress || {};
+    const copy = getCopy(state);
+    notice.hidden = false;
+    notice.dataset.state = state.state || 'idle';
+
+    const body = document.createElement('div');
+    body.className = 'codex-update-notice-body';
+    const eyebrow = document.createElement('span');
+    eyebrow.className = 'codex-update-notice-eyebrow';
+    eyebrow.textContent = copy.eyebrow;
+    const title = document.createElement('strong');
+    title.textContent = copy.title;
+    const detail = document.createElement('span');
+    detail.className = 'codex-update-notice-detail';
+    detail.textContent = copy.detail;
+    body.append(eyebrow, title, detail);
+
+    if (!['update_available', 'failed', 'rolled_back'].includes(state.state)) {
+      const bar = document.createElement('div');
+      bar.className = 'codex-update-notice-progress' + (progress.determinate ? '' : ' is-indeterminate');
+      bar.setAttribute('role', 'progressbar');
+      bar.setAttribute('aria-valuemin', '0');
+      bar.setAttribute('aria-valuemax', '100');
+      bar.setAttribute('aria-valuetext', copy.detail);
+      if (progress.determinate) bar.setAttribute('aria-valuenow', String(progress.value || 0));
+      const fill = document.createElement('span');
+      fill.style.width = Math.max(0, Math.min(100, Number(progress.value || 0))) + '%';
+      bar.append(fill);
+      body.append(bar);
+    }
+
+    const actions = document.createElement('div');
+    actions.className = 'codex-update-notice-actions';
+    for (const action of visibleActions(state.state)) {
+      const button = document.createElement('button');
+      button.type = 'button';
+      button.dataset.updateNoticeAction = action.id;
+      button.className = action.primary ? 'is-primary' : '';
+      button.textContent = action.label;
+      button.disabled = actionInFlight;
+      actions.append(button);
+    }
+    notice.replaceChildren(body, actions);
+    if (focusedAction) {
+      notice.querySelector('[data-update-notice-action="' + focusedAction + '"]:not(:disabled)')?.focus();
+    }
+    if (state.state === 'committed') {
+      completionTimer = setTimeout(() => {
+        if (notice?.dataset.state === 'committed') notice.hidden = true;
+      }, 5000);
+    }
+  }
+
+  function visibleActions(state) {
+    if (actionInFlight) return [];
+    if (state === 'update_available') {
+      return [
+        { id: 'later', label: tx('Later', '稍后'), primary: false },
+        { id: 'install', label: tx('Update now', '立即更新'), primary: true }
+      ];
+    }
+    if (['staged', 'waiting_for_idle'].includes(state)) {
+      return [{ id: 'later', label: tx('Later', '稍后'), primary: false }];
+    }
+    if (['failed', 'rolled_back'].includes(state)) {
+      return [{ id: 'retry', label: tx('Retry', '重试'), primary: true }];
+    }
+    return [];
+  }
+
+  function getCopy(state) {
+    const target = state.latestVersion ? 'v' + state.latestVersion : '';
+    const blocker = blockerCopy(state.blocker);
+    return {
+      update_available: {
+        eyebrow: tx('Update available', '发现新版本'),
+        title: target,
+        detail: tx('Signed stable update for the extension and Native Host.', '扩展与 Native Host 的签名稳定更新。')
+      },
+      downloading: {
+        eyebrow: tx('Updating Codex Overleaf Link', '正在更新 Codex Overleaf Link'),
+        title: target,
+        detail: tx('Downloading and verifying the coordinated update.', '正在下载并验证协调更新。')
+      },
+      staged: {
+        eyebrow: tx('Update ready', '更新已就绪'),
+        title: target,
+        detail: tx('Verified and ready to install at a safe point.', '已完成验证，将在安全时机安装。')
+      },
+      waiting_for_idle: {
+        eyebrow: tx('Waiting for a safe point', '正在等待安全时机'),
+        title: target,
+        detail: blocker
+      },
+      applying: {
+        eyebrow: tx('Installing update', '正在安装更新'),
+        title: target,
+        detail: tx('Installing extension and Native Host.', '正在安装扩展与 Native Host。')
+      },
+      awaiting_health: {
+        eyebrow: tx('Checking updated components', '正在检查更新后的组件'),
+        title: target,
+        detail: tx('Restarting and checking both components.', '正在重启并检查两个组件。')
+      },
+      committed: {
+        eyebrow: tx('Update complete', '更新完成'),
+        title: target,
+        detail: tx('Both components passed health confirmation.', '两个组件均已通过健康检查。')
+      },
+      rolled_back: {
+        eyebrow: tx('Previous version restored', '已恢复上一版本'),
+        title: state.currentVersion ? 'v' + state.currentVersion : '',
+        detail: tx('The replacement failed its health check.', '替换版本未通过健康检查。')
+      },
+      failed: {
+        eyebrow: tx('Update could not continue', '更新无法继续'),
+        title: target,
+        detail: state.message || tx('Review the update details and retry.', '请查看更新详情后重试。')
+      }
+    }[state.state] || { eyebrow: '', title: '', detail: '' };
+  }
+
+  function blockerCopy(value) {
+    return {
+      unsaved: tx('Overleaf has not confirmed that this document is saved.', 'Overleaf 尚未确认当前文档已保存。'),
+      active_run: tx('A Codex task is still running.', 'Codex 任务仍在运行。'),
+      cancelling: tx('Cancellation is still settling.', '取消操作仍在收尾。'),
+      storage_write: tx('Extension state is still being saved.', '扩展状态仍在保存。'),
+      review_action: tx('Accept or Undo is still running.', '接受或撤销操作仍在进行。'),
+      dialog_open: tx('A confirmation dialog is open.', '确认对话框仍处于打开状态。'),
+      native_project_locked: tx('Native Host still holds a project lock.', 'Native Host 仍持有项目锁。'),
+      native_run_active: tx('Native Host is still processing a task.', 'Native Host 仍在处理任务。')
+    }[value] || tx('Waiting until every Overleaf tab is saved and idle.', '正在等待所有 Overleaf 标签页完成保存并进入空闲状态。');
+  }
+
+  function tx(english, chinese) {
+    const locale = String(getLocale() || document.documentElement?.lang || 'en');
+    return /^zh\b/i.test(locale) ? chinese : english;
+  }
+
+  root.CodexOverleafUpdateNotice = Object.freeze({ mount });
+})(window);