codex-overleaf-link 2.1.5 → 2.2.0

package/extension/src/background.js

@@ -6,8 +6,22 @@ if (!globalThis.CodexOverleafCompatibility) {
   'use strict';
 
   const HOST_NAME = 'com.codex.overleaf';
+  const MANAGED_UPDATE_STATE_KEY = 'codex-overleaf-managed-update-state-v1';
+  const MANAGED_UPDATE_TABS_KEY = 'codex-overleaf-managed-update-tabs-v1';
+  const MANAGED_OVERLEAF_MATCHES = [
+    'https://www.overleaf.com/project',
+    'https://overleaf.com/project',
+    'https://www.overleaf.com/project/*',
+    'https://overleaf.com/project/*'
+  ];
+  const MANAGED_UPDATE_PHASE_TIMEOUT_MS = Object.freeze({
+    applying: 90 * 1000,
+    awaiting_health: 2 * 60 * 1000,
+    rolling_back: 60 * 1000
+  });
   const COMPATIBILITY_REQUIRED_METHODS = new Set([
     'codex.run',
+    'codex.steer',
     'task.run',
     'task.confirm',
     'mirror.sync',
@@ -34,16 +48,57 @@ if (!globalThis.CodexOverleafCompatibility) {
   ]);
   const CodexOverleafCompatibility = globalThis.CodexOverleafCompatibility;
   let port = null;
+  let managedUpdateExecutionLocked = false;
   const pending = new Map();
+  const runJournals = new Map();
+  const journalWrites = new Map();
+  const ownerBindings = new Map();
+  const ownerCancelTimers = new Map();
+  const RUN_JOURNAL_PREFIX = 'codex-overleaf:run-journal:';
+  const RUN_JOURNAL_MAX_EVENTS = 300;
+  const RUN_JOURNAL_MAX_BYTES = 512 * 1024;
+  const managedBootstrapRuntime = isManagedBootstrapRuntime();
   globalThis.CodexOverleafNativeBridge = Object.freeze({
-    requestInternal: payload => sendNativeRequest(payload, null, { skipCompatibility: true }),
+    requestInternal: payload => requestManagedInternal(payload),
     getPendingState: () => ({
       executionRequests: Array.from(pending.values()).filter(item => item.retryClass === 'no_silent_retry').length,
       totalRequests: pending.size
     })
   });
 
+  if (managedBootstrapRuntime) {
+    chrome.storage?.onChanged?.addListener((changes, area) => {
+      if (area !== 'local' || !changes[MANAGED_UPDATE_STATE_KEY]?.newValue) {
+        return;
+      }
+      void repairManagedUpdatePhaseMetadata(changes[MANAGED_UPDATE_STATE_KEY].newValue);
+    });
+    setTimeout(() => {
+      void reconcileManagedUpdateTransaction();
+    }, 250);
+  }
+
   chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+    if (message?.type === 'codex-overleaf/run-journal/list') {
+      if (!isAllowedOverleafSender(sender)) {
+        sendResponse({ ok: false, journals: [] });
+        return undefined;
+      }
+      listRunJournals(String(message.projectKey || ''))
+        .then(journals => sendResponse({ ok: true, journals }))
+        .catch(error => sendResponse({ ok: false, journals: [], error: getErrorMessage(error, 'Journal read failed.') }));
+      return true;
+    }
+    if (message?.type === 'codex-overleaf/run-journal/ack') {
+      if (!isAllowedOverleafSender(sender)) {
+        sendResponse({ ok: false });
+        return undefined;
+      }
+      acknowledgeRunJournal(String(message.requestId || ''))
+        .then(() => sendResponse({ ok: true }))
+        .catch(error => sendResponse({ ok: false, error: getErrorMessage(error, 'Journal cleanup failed.') }));
+      return true;
+    }
     if (message?.type !== 'codex-overleaf/native-request') {
       return undefined;
     }
@@ -103,6 +158,42 @@ if (!globalThis.CodexOverleafCompatibility) {
     return true;
   });
 
+  chrome.runtime.onConnect?.addListener(portConnection => {
+    if (portConnection.name !== 'codex-overleaf/run-owner' || !isAllowedOverleafSender(portConnection.sender)) {
+      return;
+    }
+    portConnection.onMessage.addListener(message => {
+      const requestId = String(message?.requestId || '');
+      if (!requestId) {
+        return;
+      }
+      if (message.type === 'release') {
+        ownerBindings.delete(portConnection);
+        clearTimeout(ownerCancelTimers.get(requestId));
+        ownerCancelTimers.delete(requestId);
+        return;
+      }
+      if (message.type === 'bind') {
+        ownerBindings.set(portConnection, {
+          requestId,
+          projectKey: String(message.projectKey || ''),
+          documentId: String(portConnection.sender?.documentId || '')
+        });
+        clearTimeout(ownerCancelTimers.get(requestId));
+        ownerCancelTimers.delete(requestId);
+      }
+    });
+    portConnection.onDisconnect.addListener(() => {
+      const binding = ownerBindings.get(portConnection);
+      ownerBindings.delete(portConnection);
+      if (!binding?.requestId) {
+        return;
+      }
+      const timer = setTimeout(() => interruptOwnerlessRun(binding), 150);
+      ownerCancelTimers.set(binding.requestId, timer);
+    });
+  });
+
   function getNativeRetryClass(method) {
     switch (method) {
       case 'bridge.ping':
@@ -141,6 +232,18 @@ if (!globalThis.CodexOverleafCompatibility) {
       });
     }
     const request = sanitizeNativeRequest(requestWithEvidence);
+    if (managedUpdateExecutionLocked &&
+        !request.method.startsWith('update.') &&
+        request.method !== 'codex.cancel' &&
+        getNativeRetryClass(request.method) === 'no_silent_retry') {
+      return Promise.resolve({
+        ok: false,
+        error: {
+          code: 'update_applying',
+          message: 'A managed update is activating. Retry after the extension reloads.'
+        }
+      });
+    }
 
     return new Promise((resolve, reject) => {
       const pendingRequest = {
@@ -156,6 +259,9 @@ if (!globalThis.CodexOverleafCompatibility) {
         eventForwarded: false
       };
       pending.set(id, pendingRequest);
+      if (request.method === 'codex.run') {
+        createRunJournal(id, pendingRequest);
+      }
 
       try {
         postNativeRequest(pendingRequest);
@@ -165,6 +271,213 @@ if (!globalThis.CodexOverleafCompatibility) {
     });
   }
 
+  async function requestManagedInternal(payload) {
+    if (managedBootstrapRuntime && payload?.method === 'update.apply') {
+      const gate = await verifyManagedUpdateSafety();
+      if (!gate.ok) {
+        return gate;
+      }
+      managedUpdateExecutionLocked = true;
+      try {
+        const result = await sendNativeRequest(payload, null, { skipCompatibility: true });
+        if (!result?.ok) {
+          managedUpdateExecutionLocked = false;
+        }
+        return result;
+      } catch (error) {
+        managedUpdateExecutionLocked = false;
+        throw error;
+      }
+    }
+    return sendNativeRequest(payload, null, { skipCompatibility: true });
+  }
+
+  async function verifyManagedUpdateSafety() {
+    const tabs = await chrome.tabs.query({ url: MANAGED_OVERLEAF_MATCHES }).catch(() => []);
+    const editorTabs = tabs.filter(tab => (
+      isManagedEditorTab(tab) && !tab.discarded && tab.status !== 'unloaded'
+    ));
+    const probes = await Promise.all(editorTabs.map(tab => probeManagedUpdateTab(tab.id)));
+    const nativeGate = await sendNativeRequest({
+      id: crypto.randomUUID(),
+      method: 'update.canApply',
+      params: {}
+    }, null, { skipCompatibility: true }).catch(error => ({
+      ok: false,
+      error: {
+        code: error?.code || 'native_connection_failed',
+        message: getErrorMessage(error, 'Native Host update safety check failed.')
+      }
+    }));
+    const pendingState = globalThis.CodexOverleafNativeBridge?.getPendingState?.() || {};
+    const backgroundBlockers = Number(pendingState.executionRequests || 0) > 0
+      ? ['background_execution_pending']
+      : [];
+    const blockers = [
+      ...backgroundBlockers,
+      ...(globalThis.CodexOverleafUpdateStatus?.collectBlockers(probes, nativeGate) || ['busy'])
+    ];
+    if (!blockers.length) {
+      return { ok: true };
+    }
+    return {
+      ok: false,
+      error: {
+        code: 'update_not_idle',
+        message: 'The update paused because Overleaf or the Native Host became busy. It will retry at the next safe point.',
+        blockers
+      }
+    };
+  }
+
+  async function probeManagedUpdateTab(tabId) {
+    if (!Number.isInteger(tabId)) {
+      return { idle: false, blockers: ['tab_unavailable'] };
+    }
+    try {
+      return await Promise.race([
+        chrome.tabs.sendMessage(tabId, { type: 'codex-overleaf/update-idle-probe' }),
+        new Promise(resolve => setTimeout(() => resolve({
+          idle: false,
+          blockers: ['tab_probe_timeout']
+        }), 3500))
+      ]);
+    } catch (_error) {
+      return { idle: false, blockers: ['tab_probe_unavailable'] };
+    }
+  }
+
+  function isManagedEditorTab(tab) {
+    try {
+      const url = new URL(tab?.url || '');
+      return url.protocol === 'https:' &&
+        (url.hostname === 'www.overleaf.com' || url.hostname === 'overleaf.com') &&
+        /^\/project\/[^/]+(?:\/|$)/.test(url.pathname);
+    } catch (_error) {
+      return false;
+    }
+  }
+
+  function isManagedBootstrapRuntime() {
+    if (typeof chrome.runtime?.getManifest !== 'function') {
+      return false;
+    }
+    return chrome.runtime.getManifest().background?.service_worker === 'bootstrap/background.js';
+  }
+
+  async function repairManagedUpdatePhaseMetadata(state) {
+    const timeoutMs = MANAGED_UPDATE_PHASE_TIMEOUT_MS[state?.state] || 0;
+    if (!timeoutMs || Number(state.deadlineAt || 0) > 0) {
+      return;
+    }
+    const now = Date.now();
+    await chrome.storage.local.set({
+      [MANAGED_UPDATE_STATE_KEY]: {
+        ...state,
+        phaseStartedAt: now,
+        deadlineAt: now + timeoutMs,
+        heartbeatAt: now
+      }
+    });
+  }
+
+  async function reconcileManagedUpdateTransaction() {
+    const response = await sendNativeRequest({
+      id: crypto.randomUUID(),
+      method: 'update.status',
+      params: {}
+    }, null, { skipCompatibility: true }).catch(() => null);
+    if (!response?.ok) {
+      return;
+    }
+
+    const transaction = response.result?.transaction || null;
+    const state = await getManagedUpdateState();
+    if (transaction?.state === 'rolled_back') {
+      await setManagedUpdateState({
+        ...state,
+        state: 'rolled_back',
+        currentVersion: transaction.sourceVersion || state.currentVersion,
+        transactionId: transaction.id || state.transactionId,
+        code: transaction.reasonCode || state.code || 'update_rolled_back'
+      });
+      await reloadManagedUpdateTabs();
+      return;
+    }
+    if (transaction?.state === 'committed') {
+      const targetVersion = transaction.targetVersion || state.latestVersion || state.currentVersion;
+      await setManagedUpdateState({
+        ...state,
+        state: 'committed',
+        currentVersion: targetVersion,
+        latestVersion: targetVersion,
+        transactionId: '',
+        blocker: '',
+        blockers: [],
+        code: '',
+        message: ''
+      });
+      await reloadManagedUpdateTabs();
+      return;
+    }
+    if (transaction?.state === 'staged' && ['applying', 'awaiting_health'].includes(state.state)) {
+      await setManagedUpdateState({
+        ...state,
+        state: 'staged',
+        transactionId: transaction.id || state.transactionId,
+        blocker: '',
+        blockers: [],
+        code: '',
+        message: '',
+        phaseStartedAt: 0,
+        deadlineAt: 0,
+        heartbeatAt: 0
+      });
+      setTimeout(() => {
+        void globalThis.CodexOverleafManagedUpdateExecutor?.installAuthorizedUpdate?.().catch?.(() => {});
+      }, 250);
+      return;
+    }
+    if (!transaction && ['applying', 'awaiting_health', 'rolling_back'].includes(state.state)) {
+      await setManagedUpdateState({
+        ...state,
+        state: 'failed',
+        code: 'update_transaction_lost',
+        message: 'The managed update transaction could not be recovered. Use the manual update command.',
+        phaseStartedAt: 0,
+        deadlineAt: 0,
+        heartbeatAt: 0
+      });
+    }
+  }
+
+  async function getManagedUpdateState() {
+    const stored = await chrome.storage.local.get(MANAGED_UPDATE_STATE_KEY);
+    return stored?.[MANAGED_UPDATE_STATE_KEY] || {
+      state: 'idle',
+      managed: true,
+      currentVersion: chrome.runtime.getManifest().version,
+      latestVersion: chrome.runtime.getManifest().version
+    };
+  }
+
+  async function setManagedUpdateState(state) {
+    await chrome.storage.local.set({ [MANAGED_UPDATE_STATE_KEY]: state });
+    return state;
+  }
+
+  async function reloadManagedUpdateTabs() {
+    const stored = await chrome.storage.local.get(MANAGED_UPDATE_TABS_KEY);
+    const pendingIds = Array.isArray(stored?.[MANAGED_UPDATE_TABS_KEY])
+      ? stored[MANAGED_UPDATE_TABS_KEY]
+      : [];
+    const openTabs = await chrome.tabs.query({ url: MANAGED_OVERLEAF_MATCHES }).catch(() => []);
+    const openIds = new Set(openTabs.map(tab => tab.id).filter(Number.isInteger));
+    const reloadIds = [...new Set(pendingIds.filter(tabId => Number.isInteger(tabId) && openIds.has(tabId)))];
+    await chrome.storage.local.remove(MANAGED_UPDATE_TABS_KEY);
+    await Promise.allSettled(reloadIds.map(tabId => chrome.tabs.reload(tabId)));
+  }
+
   function getNativeCompatibilityBlock(request = {}) {
     const evidence = getNativeCompatibilityEvidence(request);
     if (!evidence) {
@@ -366,15 +679,20 @@ if (!globalThis.CodexOverleafCompatibility) {
       }
       const pendingRequest = pending.get(id);
       if (message?.event) {
-        pendingRequest.eventForwarded = (
-          forwardNativeEvent(pendingRequest.tabId, id, message.event) ||
-          pendingRequest.eventForwarded
-        );
+        const { sequence, write } = appendRunJournalEvent(id, message.event);
+        Promise.resolve(write).catch(() => {}).then(() => {
+          pendingRequest.eventForwarded = (
+            forwardNativeEvent(pendingRequest.tabId, id, message.event, sequence) ||
+            pendingRequest.eventForwarded
+          );
+        });
         return;
       }
       pendingRequest.finalResponseReceived = true;
       pending.delete(id);
-      pendingRequest.resolve(message);
+      finalizeRunJournal(id, message).catch(() => {}).finally(() => {
+        pendingRequest.resolve(message);
+      });
     });
     nativePort.onDisconnect.addListener(() => {
       if (nativePort !== port) {
@@ -432,6 +750,13 @@ if (!globalThis.CodexOverleafCompatibility) {
 
   function rejectInterruptedNativeRequest(pendingId, pendingRequest, errorMessage) {
     pending.delete(pendingId);
+    finalizeRunJournal(pendingId, {
+      ok: false,
+      error: {
+        code: 'native_execution_interrupted',
+        message: errorMessage || 'Native host disconnected'
+      }
+    }).catch(() => {});
     if (pendingRequest.retryClass === 'no_silent_retry') {
       pendingRequest.reject(createNativeRequestError(
         'native_execution_interrupted',
@@ -522,7 +847,7 @@ if (!globalThis.CodexOverleafCompatibility) {
     }
   }
 
-  function forwardNativeEvent(tabId, id, event) {
+  function forwardNativeEvent(tabId, id, event, journalSeq = 0) {
     if (typeof tabId !== 'number') {
       return false;
     }
@@ -530,12 +855,186 @@ if (!globalThis.CodexOverleafCompatibility) {
     chrome.tabs.sendMessage(tabId, {
       type: 'codex-overleaf/native-event',
       id,
-      event
+      event,
+      journalSeq
     }, () => {
       void chrome.runtime.lastError;
     });
     return true;
   }
+
+  function createRunJournal(id, pendingRequest) {
+    const params = pendingRequest.request?.params || {};
+    const journal = {
+      requestId: id,
+      projectKey: String(params.projectId || params.project?.projectId || ''),
+      clientRunId: String(params.clientRunId || ''),
+      sessionId: String(params.clientSessionId || ''),
+      task: sanitizeJournalString(params.task).slice(0, 12000),
+      mode: String(params.mode || ''),
+      model: String(params.model || ''),
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      terminal: false,
+      ownerLost: false,
+      nextSequence: 1,
+      events: []
+    };
+    runJournals.set(id, journal);
+    pruneInMemoryRunJournals();
+    return queueJournalWrite(id);
+  }
+
+  function appendRunJournalEvent(id, event) {
+    const journal = runJournals.get(id);
+    if (!journal) {
+      return { sequence: 0, write: Promise.resolve() };
+    }
+    const sequence = journal.nextSequence++;
+    journal.events.push({ sequence, event: sanitizeJournalValue(event) });
+    journal.updatedAt = new Date().toISOString();
+    trimRunJournal(journal);
+    return { sequence, write: queueJournalWrite(id) };
+  }
+
+  function finalizeRunJournal(id, response) {
+    const journal = runJournals.get(id);
+    if (!journal) {
+      return Promise.resolve();
+    }
+    journal.terminal = true;
+    journal.updatedAt = new Date().toISOString();
+    journal.final = {
+      ok: response?.ok === true,
+      code: String(response?.error?.code || ''),
+      status: String(response?.result?.status || '')
+    };
+    return queueJournalWrite(id);
+  }
+
+  function trimRunJournal(journal) {
+    if (journal.events.length > RUN_JOURNAL_MAX_EVENTS) {
+      journal.events.splice(0, journal.events.length - RUN_JOURNAL_MAX_EVENTS);
+    }
+    while (journal.events.length && JSON.stringify(journal).length * 2 > RUN_JOURNAL_MAX_BYTES) {
+      journal.events.shift();
+    }
+  }
+
+  function sanitizeJournalValue(value, depth = 0) {
+    if (typeof value === 'string') {
+      return sanitizeJournalString(value);
+    }
+    if (value === null || value === undefined || typeof value === 'number' || typeof value === 'boolean') {
+      return value;
+    }
+    if (depth > 10) {
+      return '[nested value omitted]';
+    }
+    if (Array.isArray(value)) {
+      return value.slice(0, 200).map(item => sanitizeJournalValue(item, depth + 1));
+    }
+    if (typeof value === 'object') {
+      return Object.fromEntries(Object.entries(value).slice(0, 200).map(([key, item]) => [
+        sanitizeJournalString(key).slice(0, 160),
+        sanitizeJournalValue(item, depth + 1)
+      ]));
+    }
+    return String(value);
+  }
+
+  function sanitizeJournalString(value) {
+    return String(value || '')
+      .replace(/\b(?:sk|hf|glpat|npm|ghp|github_pat|AKIA|AIza)[_-]?[A-Za-z0-9_-]{12,}\b/g, '[REDACTED]')
+      .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g, '[REDACTED]')
+      .replace(/(?:file:\/\/)?\/(?:Users|home|private|var|opt|Library)\/[^\s"'<>]+/g, '[local path]')
+      .slice(0, 131072);
+  }
+
+  function queueJournalWrite(id) {
+    const storage = chrome.storage?.session;
+    if (!storage || !runJournals.has(id)) {
+      return Promise.resolve();
+    }
+    const previous = journalWrites.get(id) || Promise.resolve();
+    const snapshot = JSON.parse(JSON.stringify(runJournals.get(id)));
+    const next = previous.catch(() => {}).then(() => storage.set({
+      [RUN_JOURNAL_PREFIX + id]: snapshot
+    }));
+    journalWrites.set(id, next);
+    return next.finally(() => {
+      if (journalWrites.get(id) === next) {
+        journalWrites.delete(id);
+      }
+    });
+  }
+
+  async function listRunJournals(projectKey) {
+    await Promise.allSettled(Array.from(journalWrites.values()));
+    const storage = chrome.storage?.session;
+    if (!storage) {
+      return [];
+    }
+    const values = await storage.get(null);
+    const entries = Object.entries(values || {})
+      .filter(([key, value]) => key.startsWith(RUN_JOURNAL_PREFIX)
+        && (!projectKey || value?.projectKey === projectKey)
+        && (value?.terminal || value?.ownerLost))
+      .sort((a, b) => String(a[1]?.createdAt || '').localeCompare(String(b[1]?.createdAt || '')));
+    return entries.slice(-16).map(([_key, value]) => value);
+  }
+
+  function pruneInMemoryRunJournals() {
+    if (runJournals.size <= 16) {
+      return;
+    }
+    const oldest = Array.from(runJournals.values())
+      .filter(journal => journal?.terminal || journal?.ownerLost)
+      .sort((a, b) => String(a.createdAt || '').localeCompare(String(b.createdAt || '')))
+      .slice(0, runJournals.size - 16);
+    for (const journal of oldest) {
+      runJournals.delete(journal.requestId);
+      journalWrites.delete(journal.requestId);
+      chrome.storage?.session?.remove?.(RUN_JOURNAL_PREFIX + journal.requestId).catch?.(() => {});
+    }
+  }
+
+  async function acknowledgeRunJournal(id) {
+    if (!id) {
+      return;
+    }
+    await (journalWrites.get(id) || Promise.resolve()).catch(() => {});
+    runJournals.delete(id);
+    journalWrites.delete(id);
+    await chrome.storage?.session?.remove?.(RUN_JOURNAL_PREFIX + id);
+  }
+
+  async function interruptOwnerlessRun(binding) {
+    ownerCancelTimers.delete(binding.requestId);
+    if (Array.from(ownerBindings.values()).some(value => value.requestId === binding.requestId)) {
+      return;
+    }
+    const journal = runJournals.get(binding.requestId);
+    if (journal) {
+      journal.ownerLost = true;
+      journal.updatedAt = new Date().toISOString();
+      await queueJournalWrite(binding.requestId).catch(() => {});
+    }
+    if (!pending.has(binding.requestId)) {
+      return;
+    }
+    try {
+      sendNativeCancel({
+        method: 'codex.cancel',
+        params: {
+          requestId: binding.requestId,
+          projectKey: binding.projectKey || undefined
+        }
+      });
+    } catch (_error) {
+      // The original request disconnect path will settle the journal.
+    }
+  }
 })();
 
 (function loadConsentDrivenUpdateRuntime(root) {