codex-overleaf-link 2.2.1 → 2.3.1

package/extension/src/shared/i18n.js

@@ -266,8 +266,6 @@
       writeMode: 'Write mode',
       modeAsk: 'Ask',
       modeAskTitle: 'Read and analyze only. Do not write to Overleaf.',
-      modeConfirm: 'Suggest',
-      modeConfirmTitle: 'Show a change plan first, then write after approval.',
       modeAuto: 'Auto',
       modeAutoTitle: 'Write directly after authorization. Deletes still require confirmation.',
       addContext: 'Add @ context',
@@ -403,6 +401,7 @@
       refreshProbeDone: 'Refreshed: {status}',
       refreshProbeFailed: 'Refresh failed. Reload Overleaf and try again.',
       processedFailed: 'Failed {elapsed}',
+      processedCancelled: 'Cancelled {elapsed}',
       processing: 'Running {elapsed}',
       processed: 'Done {elapsed}',
       restoredRunStoppedTitle: 'Stopped tracking this run after a page refresh',
@@ -779,8 +778,6 @@
       writeMode: '写入模式',
       modeAsk: '只问不改',
       modeAskTitle: '只读取和分析，不写入 Overleaf',
-      modeConfirm: '建议修改',
-      modeConfirmTitle: '先给出修改方案，确认后写入',
       modeAuto: '自动写入',
       modeAutoTitle: '授权后直接写入，删除仍需确认',
       addContext: '添加 @ 上下文',
@@ -916,6 +913,7 @@
       refreshProbeDone: '已重新检测：{status}',
       refreshProbeFailed: '检测失败：请刷新 Overleaf 页面后重试',
       processedFailed: '处理失败 {elapsed}',
+      processedCancelled: '已取消 {elapsed}',
       processing: '处理中 {elapsed}',
       processed: '已处理 {elapsed}',
       restoredRunStoppedTitle: '页面刷新后已停止跟踪这轮任务',

package/extension/src/shared/managedUpdateProjection.js

@@ -0,0 +1,337 @@
+(function initCodexOverleafManagedUpdateProjection(root) {
+  'use strict';
+
+  const PHASE_ALIASES = Object.freeze({
+    waiting: 'waiting_for_idle',
+    waiting_for_safe_point: 'waiting_for_idle',
+    awaiting_health_check: 'awaiting_health',
+    health_checking: 'awaiting_health'
+  });
+
+  const PHASES = Object.freeze([
+    'idle',
+    'up_to_date',
+    'checking',
+    'update_available',
+    'downloading',
+    'staged',
+    'waiting_for_idle',
+    'applying',
+    'awaiting_health',
+    'committed',
+    'failed',
+    'rolling_back',
+    'rolled_back',
+    'deferred'
+  ]);
+
+  const PHASE_TIMEOUTS = Object.freeze({
+    checking: 30 * 1000,
+    downloading: 2 * 60 * 1000,
+    applying: 90 * 1000,
+    awaiting_health: 2 * 60 * 1000,
+    rolling_back: 60 * 1000
+  });
+
+  const PROGRESS = Object.freeze({
+    checking: 8,
+    update_available: 0,
+    downloading: 25,
+    staged: 48,
+    waiting_for_idle: 55,
+    applying: 75,
+    awaiting_health: 90,
+    committed: 100,
+    rolled_back: 100
+  });
+
+  const ACTIVE_STAGE = Object.freeze({
+    downloading: 0,
+    staged: 1,
+    waiting_for_idle: 1,
+    applying: 2,
+    awaiting_health: 2,
+    committed: 3
+  });
+
+  const ACTIVE_PHASES = Object.freeze({
+    update_page: Object.freeze([
+      'checking',
+      'downloading',
+      'staged',
+      'waiting_for_idle',
+      'applying',
+      'awaiting_health'
+    ]),
+    panel: Object.freeze([
+      'downloading',
+      'staged',
+      'waiting_for_idle',
+      'applying',
+      'awaiting_health'
+    ])
+  });
+
+  const TRANSITIONS = Object.freeze({
+    idle: Object.freeze(['checking']),
+    up_to_date: Object.freeze(['checking', 'idle']),
+    checking: Object.freeze(['idle', 'up_to_date', 'update_available', 'failed']),
+    update_available: Object.freeze(['checking', 'downloading', 'deferred', 'failed']),
+    downloading: Object.freeze(['staged', 'failed']),
+    staged: Object.freeze(['waiting_for_idle', 'applying', 'update_available', 'deferred', 'failed']),
+    waiting_for_idle: Object.freeze(['applying', 'update_available', 'deferred', 'failed']),
+    applying: Object.freeze(['staged', 'awaiting_health', 'rolling_back', 'failed']),
+    awaiting_health: Object.freeze(['staged', 'committed', 'rolling_back', 'failed']),
+    committed: Object.freeze(['checking', 'idle']),
+    failed: Object.freeze(['checking', 'rolling_back', 'update_available', 'idle']),
+    rolling_back: Object.freeze(['rolled_back', 'failed']),
+    rolled_back: Object.freeze(['checking', 'idle']),
+    deferred: Object.freeze(['checking', 'update_available', 'idle'])
+  });
+
+  function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  }
+
+  function unwrap(value) {
+    const source = asObject(value);
+    return source.state && typeof source.state === 'object' && !Array.isArray(source.state)
+      ? source.state
+      : source;
+  }
+
+  function normalizePhase(value) {
+    const normalized = String(value || 'idle').trim().toLowerCase().replace(/[- ]+/g, '_');
+    return PHASE_ALIASES[normalized] || normalized || 'idle';
+  }
+
+  function phaseOf(value) {
+    if (typeof value === 'string') {
+      return normalizePhase(value);
+    }
+    const source = unwrap(value);
+    return normalizePhase(source.phase || source.status || source.state || source.lifecycle || 'idle');
+  }
+
+  function normalizeBlockers(values, normalizeFn) {
+    if (typeof normalizeFn === 'function') {
+      return normalizeFn(values);
+    }
+    const result = [];
+    const seen = new Set();
+    for (const value of Array.isArray(values) ? values : [values]) {
+      const code = String(value || '').trim();
+      if (!code || seen.has(code)) continue;
+      seen.add(code);
+      result.push(code);
+    }
+    return result;
+  }
+
+  function normalize(value, options = {}) {
+    const source = unwrap(value);
+    const currentVersion = String(
+      source.currentVersion || options.currentVersion || source.latestVersion || ''
+    ).replace(/^v/i, '');
+    const latestVersion = String(
+      source.latestVersion || source.targetVersion || currentVersion
+    ).replace(/^v/i, '');
+    const blockers = normalizeBlockers(
+      Array.isArray(source.blockers) ? source.blockers : (source.blocker ? [source.blocker] : []),
+      options.normalizeBlockers
+    );
+    return {
+      ...source,
+      state: phaseOf(source),
+      managed: source.managed !== false,
+      currentVersion,
+      latestVersion,
+      etag: String(source.etag || ''),
+      lastCheckedAt: Number(source.lastCheckedAt || 0),
+      stagedAt: Number(source.stagedAt || 0),
+      postponeUntil: Number(source.postponeUntil || 0),
+      transactionId: String(source.transactionId || ''),
+      blocker: blockers[0] || '',
+      blockers,
+      code: String(source.code || ''),
+      message: String(source.message || '').slice(0, 300),
+      phaseStartedAt: Number(source.phaseStartedAt || 0),
+      deadlineAt: Number(source.deadlineAt || 0),
+      heartbeatAt: Number(source.heartbeatAt || 0)
+    };
+  }
+
+  function getPhaseTimeoutMs(value) {
+    return Number(PHASE_TIMEOUTS[phaseOf(value)] || 0);
+  }
+
+  function ensurePhaseMetadata(value, options = {}) {
+    const normalized = normalize(value, options);
+    const phase = phaseOf(normalized);
+    const timeoutMs = getPhaseTimeoutMs(phase);
+    if (!timeoutMs) {
+      return {
+        ...normalized,
+        phaseStartedAt: 0,
+        deadlineAt: 0,
+        heartbeatAt: 0
+      };
+    }
+    const now = Number(options.now || Date.now());
+    const phaseStartedAt = Number(normalized.phaseStartedAt || now);
+    return {
+      ...normalized,
+      phaseStartedAt,
+      deadlineAt: Number(normalized.deadlineAt || (phaseStartedAt + timeoutMs)),
+      heartbeatAt: Number(normalized.heartbeatAt || now)
+    };
+  }
+
+  function transition(previous, patch, options = {}) {
+    const prior = normalize(previous, options);
+    const nextSource = buildTransitionSource(prior, patch, options);
+    const nextPhase = phaseOf(nextSource);
+    const previousPhase = phaseOf(prior);
+    if (nextPhase !== previousPhase) {
+      nextSource.phaseStartedAt = 0;
+      nextSource.deadlineAt = 0;
+      nextSource.heartbeatAt = 0;
+    }
+    const transitioned = ensurePhaseMetadata(nextSource, options);
+    if (getPhaseTimeoutMs(nextPhase)) {
+      transitioned.heartbeatAt = Number(options.now || Date.now());
+    }
+    return transitioned;
+  }
+
+  function transitionCommand(previous, patch, options = {}) {
+    const prior = normalize(previous, options);
+    const nextSource = buildTransitionSource(prior, patch, options);
+    const previousPhase = phaseOf(prior);
+    const nextPhase = phaseOf(nextSource);
+    if (!isLegalTransition(previousPhase, nextPhase)) {
+      const error = new Error(`Illegal managed update transition: ${previousPhase} -> ${nextPhase}`);
+      error.code = 'managed_update_transition_invalid';
+      error.from = previousPhase;
+      error.to = nextPhase;
+      throw error;
+    }
+    return transition(prior, nextSource, { ...options, merge: false });
+  }
+
+  function buildTransitionSource(prior, patch, options = {}) {
+    return options.merge === false
+      ? asObject(patch)
+      : { ...prior, ...asObject(patch) };
+  }
+
+  function isLegalTransition(from, to) {
+    const fromPhase = phaseOf(from);
+    const toPhase = phaseOf(to);
+    if (fromPhase === toPhase) return true;
+    return (TRANSITIONS[fromPhase] || []).includes(toPhase);
+  }
+
+  function reconcile(value, transaction, options = {}) {
+    const state = normalize(value, options);
+    const native = asObject(transaction);
+    if (native.state === 'rolled_back') {
+      return {
+        action: 'reload_tabs',
+        state: transition(state, {
+          state: 'rolled_back',
+          currentVersion: native.sourceVersion || state.currentVersion,
+          transactionId: native.id || state.transactionId,
+          code: native.reasonCode || state.code || 'update_rolled_back'
+        }, options)
+      };
+    }
+    if (native.state === 'committed') {
+      const targetVersion = native.targetVersion || state.latestVersion || state.currentVersion;
+      return {
+        action: 'reload_tabs',
+        state: transition(state, {
+          state: 'committed',
+          currentVersion: targetVersion,
+          latestVersion: targetVersion,
+          transactionId: '',
+          blocker: '',
+          blockers: [],
+          code: '',
+          message: ''
+        }, options)
+      };
+    }
+    if (native.state === 'staged' && ['applying', 'awaiting_health'].includes(phaseOf(state))) {
+      return {
+        action: 'retry_install',
+        state: transition(state, {
+          state: 'staged',
+          transactionId: native.id || state.transactionId,
+          blocker: '',
+          blockers: [],
+          code: '',
+          message: ''
+        }, options)
+      };
+    }
+    if (!native.state && ['applying', 'awaiting_health', 'rolling_back'].includes(phaseOf(state))) {
+      return {
+        action: 'none',
+        state: transition(state, {
+          state: 'failed',
+          code: 'update_transaction_lost',
+          message: options.transactionLostMessage
+            || 'The managed update transaction could not be recovered. Use the manual update command.'
+        }, options)
+      };
+    }
+    return { action: 'none', state };
+  }
+
+  function progressFor(value) {
+    const source = asObject(value);
+    const raw = asObject(source.progress).percent
+      ?? asObject(source.progress).value
+      ?? source.progressPercent
+      ?? (typeof source.progress === 'number' ? source.progress : undefined);
+    if (Number.isFinite(Number(raw))) {
+      const numeric = Number(raw);
+      return Math.max(0, Math.min(100, numeric <= 1 ? numeric * 100 : numeric));
+    }
+    return Number(PROGRESS[phaseOf(value)] || 0);
+  }
+
+  function activeStageFor(value) {
+    return ACTIVE_STAGE[phaseOf(value)] ?? -1;
+  }
+
+  function activePhases(surface = 'update_page') {
+    return [...(ACTIVE_PHASES[surface] || ACTIVE_PHASES.update_page)];
+  }
+
+  function isActive(value, surface = 'update_page') {
+    return activePhases(surface).includes(phaseOf(value));
+  }
+
+  root.CodexOverleafManagedUpdateProjection = Object.freeze({
+    ACTIVE_PHASES,
+    PHASE_ALIASES,
+    PHASE_TIMEOUTS,
+    PHASES,
+    PROGRESS,
+    TRANSITIONS,
+    activePhases,
+    activeStageFor,
+    ensurePhaseMetadata,
+    getPhaseTimeoutMs,
+    isActive,
+    isLegalTransition,
+    normalize,
+    phaseOf,
+    progressFor,
+    reconcile,
+    transition,
+    transitionCommand
+  });
+})(typeof window !== 'undefined' ? window : globalThis);

package/extension/src/shared/nativeRequestIdentity.js

@@ -0,0 +1,60 @@
+(function initNativeRequestIdentity(root, factory) {
+  const api = factory();
+  if (typeof module === "object" && module.exports) {
+    module.exports = api;
+  }
+  if (root) {
+    root.CodexOverleafNativeRequestIdentity = api;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : this, function createNativeRequestIdentity() {
+  "use strict";
+
+  const MAX_REQUEST_ID_CHARS = 160;
+
+  function invalidIdentity(value) {
+    return {
+      ok: false,
+      error: {
+        code: "native_request_id_invalid",
+        message:
+          `Native request id must be a finite number or a non-empty string no longer than ${MAX_REQUEST_ID_CHARS} characters.`,
+        details: {
+          actualType: value === null ? "null" : typeof value,
+          actualLength: typeof value === "string" ? value.length : null,
+          limit: MAX_REQUEST_ID_CHARS
+        }
+      }
+    };
+  }
+
+  function validate(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? { ok: true, id: value } : invalidIdentity(value);
+    }
+    if (typeof value !== "string" || value.length === 0 || value.length > MAX_REQUEST_ID_CHARS) {
+      return invalidIdentity(value);
+    }
+    return { ok: true, id: value };
+  }
+
+  function resolve(value, randomUUID) {
+    if (value === undefined || value === null || value === "") {
+      const generate =
+        typeof randomUUID === "function"
+          ? randomUUID
+          : typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+            ? () => crypto.randomUUID()
+            : null;
+      if (!generate) {
+        return invalidIdentity(value);
+      }
+      return validate(generate());
+    }
+    return validate(value);
+  }
+
+  return Object.freeze({
+    MAX_REQUEST_ID_CHARS,
+    resolve
+  });
+});

package/extension/src/shared/otText.js

@@ -274,28 +274,9 @@
 
   function hashText(text) {
     const value = String(text ?? '');
-    const nodeCrypto = getNodeCrypto();
-    if (nodeCrypto) {
-      return nodeCrypto.createHash('sha256').update(value, 'utf8').digest('hex');
-    }
     return sha256Hex(utf8Bytes(value));
   }
 
-  function getNodeCrypto() {
-    if (typeof require !== 'function') {
-      return null;
-    }
-    try {
-      return require('node:crypto');
-    } catch (error) {
-      try {
-        return require('crypto');
-      } catch (fallbackError) {
-        return null;
-      }
-    }
-  }
-
   function normalizePath(value) {
     return String(value || '')
       .replace(/\s+/g, ' ')

package/extension/src/shared/pageRpcContract.js

@@ -0,0 +1,136 @@
+(function (root, factory) {
+  var api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafPageRpcContract = api;
+})(typeof window !== 'undefined' ? window : (typeof globalThis !== 'undefined' ? globalThis : this), function () {
+  'use strict';
+
+  var REVISION = '2026-07-31-page-rpc-contract-v14';
+  var METHODS = freezeCatalog({
+    initializeCapability: entry('bridge.initialize', 'control', 'none', 'default', false, 'none'),
+    probe: entry('bridge.probe', 'read', 'none', 'default', false, 'safe'),
+    cancelActiveWrite: entry('write.cancel', 'control', 'none', 'default', false, 'idempotent'),
+    getProjectSnapshot: entry('snapshot.read', 'read', 'none', 'snapshot', true, 'safe'),
+    getProjectFileList: entry('snapshot.list', 'read', 'none', 'file_list', true, 'safe'),
+    invalidateProjectSnapshot: entry('snapshot.invalidate', 'cache', 'none', 'default', false, 'idempotent'),
+    createCheckpoint: entry('checkpoint.create', 'page_state', 'none', 'default', false, 'no_retry'),
+    ensureReviewing: entry('reviewing.enable', 'page_state', 'optional', 'default', true, 'idempotent'),
+    ensureEditing: entry('reviewing.disable', 'page_state', 'optional', 'default', true, 'idempotent'),
+    applyOperations: entry('document.write', 'document', 'required', 'writeback', true, 'no_retry'),
+    jumpToPosition: entry('editor.navigate', 'navigation', 'required', 'default', false, 'idempotent'),
+    rejectTrackedChanges: entry('tracked_changes.reject', 'document', 'required', 'lifecycle', true, 'no_retry'),
+    acceptTrackedChanges: entry('tracked_changes.accept', 'document', 'required', 'lifecycle', true, 'no_retry'),
+    triggerCompile: entry('compile.trigger', 'page_state', 'required', 'compile', false, 'no_retry'),
+    getCompileLog: entry('compile.log', 'read', 'required', 'compile', true, 'safe'),
+    getCompileState: entry('compile.state', 'read', 'none', 'default', false, 'safe'),
+    waitForSaveState: entry('save.wait', 'read', 'none', 'default', true, 'safe'),
+    startOtObserver: entry('ot.start', 'observer', 'none', 'default', false, 'idempotent'),
+    stopOtObserver: entry('ot.stop', 'observer', 'none', 'default', false, 'idempotent'),
+    getOtStatus: entry('ot.status', 'read', 'none', 'default', false, 'safe'),
+    drainOtEvents: entry('ot.drain', 'observer', 'none', 'default', false, 'no_retry')
+  });
+
+  function entry(capability, mutation, projectIdentity, timeoutClass, cancellable, retryClass) {
+    return {
+      capability: capability,
+      mutation: mutation,
+      projectIdentity: projectIdentity,
+      timeoutClass: timeoutClass,
+      cancellation: cancellable ? 'content_abort' : 'none',
+      retryClass: retryClass,
+      failureClass: mutation === 'document' ? 'write' : mutation
+    };
+  }
+
+  function getMethod(name) {
+    return typeof name === 'string' && METHODS[name] ? METHODS[name] : null;
+  }
+
+  function listMethods() {
+    return Object.keys(METHODS);
+  }
+
+  function isCancellable(name) {
+    return getMethod(name)?.cancellation === 'content_abort';
+  }
+
+  function requiresProjectIdentity(name) {
+    return getMethod(name)?.projectIdentity === 'required';
+  }
+
+  function resolveTimeoutMs(name, overrides) {
+    overrides = overrides || {};
+    var timeoutClass = getMethod(name)?.timeoutClass || 'default';
+    var defaults = {
+      default: 8000,
+      snapshot: 70000,
+      file_list: 35000,
+      compile: 75000,
+      lifecycle: 120000,
+      writeback: 45000
+    };
+    var candidate = Number(overrides[timeoutClass]);
+    return Number.isFinite(candidate) && candidate > 0 ? candidate : defaults[timeoutClass];
+  }
+
+  function resolveDispatchPolicy(name, overrides) {
+    var method = getMethod(name);
+    return Object.freeze({
+      timeoutMs: resolveTimeoutMs(name, overrides),
+      cancellation: method ? method.cancellation : 'none',
+      retryClass: method ? method.retryClass : 'none',
+      automaticAttempts: 1
+    });
+  }
+
+  function capabilityReport() {
+    var report = {};
+    listMethods().forEach(function (name) {
+      var method = METHODS[name];
+      report[name] = {
+        capability: method.capability,
+        mutation: method.mutation,
+        projectIdentity: method.projectIdentity,
+        retryClass: method.retryClass,
+        timeoutClass: method.timeoutClass,
+        cancellation: method.cancellation
+      };
+    });
+    return report;
+  }
+
+  function withCapabilityReport(capabilities) {
+    return Object.assign({}, capabilities || {}, { pageRpc: capabilityReport() });
+  }
+
+  function normalizeFailure(method, error) {
+    var contract = getMethod(method);
+    var message = error && error.message ? error.message : String(error || 'Page bridge request failed');
+    return {
+      ok: false,
+      code: 'page_bridge_dispatch_failed',
+      error: message,
+      rpcMethod: typeof method === 'string' ? method : '',
+      failureClass: contract ? contract.failureClass : 'unknown'
+    };
+  }
+
+  function freezeCatalog(catalog) {
+    Object.keys(catalog).forEach(function (name) { Object.freeze(catalog[name]); });
+    return Object.freeze(catalog);
+  }
+
+  return Object.freeze({
+    METHODS: METHODS,
+    REVISION: REVISION,
+    capabilityReport: capabilityReport,
+    getMethod: getMethod,
+    isCancellable: isCancellable,
+    listMethods: listMethods,
+    normalizeFailure: normalizeFailure,
+    requiresProjectIdentity: requiresProjectIdentity,
+    resolveDispatchPolicy: resolveDispatchPolicy,
+    resolveTimeoutMs: resolveTimeoutMs,
+    withCapabilityReport: withCapabilityReport
+  });
+});