codex-overleaf-link 1.9.3 → 1.9.4

package/extension/src/shared/updateConsent.js

@@ -0,0 +1,201 @@
+(function initCodexOverleafUpdateConsent(root, factory) {
+  'use strict';
+
+  const api = factory();
+  root.CodexOverleafUpdateConsent = api;
+  if (typeof module === 'object' && module?.exports) {
+    module.exports = api;
+  }
+})(typeof globalThis === 'object' ? globalThis : this, function createUpdateConsentApi() {
+  'use strict';
+
+  const UPDATE_STATES = new Set([
+    'idle',
+    'checking',
+    'update_available',
+    'downloading',
+    'staged',
+    'waiting_for_idle',
+    'applying',
+    'awaiting_health',
+    'committed',
+    'rolled_back',
+    'failed'
+  ]);
+  const EXECUTION_STATES = new Set([
+    'downloading',
+    'staged',
+    'waiting_for_idle',
+    'applying',
+    'awaiting_health'
+  ]);
+  const TERMINAL_STATES = new Set(['committed', 'rolled_back', 'failed']);
+  const QUIET_FAILURE_CODES = new Set([
+    'update_network_failed',
+    'update_network_unavailable',
+    'update_github_http_error'
+  ]);
+  const PROGRESS = Object.freeze({
+    idle: { value: 0, determinate: true, phase: 'idle' },
+    checking: { value: 0, determinate: false, phase: 'checking' },
+    update_available: { value: 0, determinate: true, phase: 'available' },
+    downloading: { value: 35, determinate: false, phase: 'downloading' },
+    staged: { value: 65, determinate: true, phase: 'staged' },
+    waiting_for_idle: { value: 65, determinate: true, phase: 'waiting' },
+    applying: { value: 82, determinate: false, phase: 'applying' },
+    awaiting_health: { value: 94, determinate: false, phase: 'health' },
+    committed: { value: 100, determinate: true, phase: 'committed' },
+    rolled_back: { value: 94, determinate: true, phase: 'rolled_back' },
+    failed: { value: 0, determinate: true, phase: 'failed' }
+  });
+
+  function normalizeUpdateState(value = {}, currentVersion = '') {
+    const blockers = Array.isArray(value.blockers)
+      ? value.blockers.map(safeToken).filter(Boolean).slice(0, 12)
+      : [safeToken(value.blocker)].filter(Boolean);
+    const state = UPDATE_STATES.has(value.state) ? value.state : 'idle';
+    return {
+      state,
+      managed: value.managed !== false,
+      currentVersion: safeVersion(value.currentVersion) || safeVersion(currentVersion),
+      latestVersion: safeVersion(value.latestVersion) || safeVersion(value.currentVersion) || safeVersion(currentVersion),
+      etag: String(value.etag || '').slice(0, 300),
+      blocker: blockers[0] || '',
+      blockers,
+      transactionId: safeId(value.transactionId),
+      lastCheckedAt: finiteNumber(value.lastCheckedAt),
+      stagedAt: finiteNumber(value.stagedAt),
+      postponeUntil: finiteNumber(value.postponeUntil),
+      code: safeToken(value.code),
+      message: String(value.message || '').replace(/\s+/g, ' ').trim().slice(0, 300)
+    };
+  }
+
+  function normalizeConsentState(value = {}) {
+    return {
+      schemaVersion: 1,
+      mode: 'consent',
+      snoozedVersion: safeVersion(value.snoozedVersion),
+      snoozedUntil: finiteNumber(value.snoozedUntil),
+      authorizedVersion: safeVersion(value.authorizedVersion),
+      authorizationId: safeId(value.authorizationId),
+      authorizedAt: finiteNumber(value.authorizedAt),
+      lastPromptedVersion: safeVersion(value.lastPromptedVersion),
+      lastPromptedAt: finiteNumber(value.lastPromptedAt)
+    };
+  }
+
+  function deriveViewModel(updateValue = {}, consentValue = {}, options = {}) {
+    const now = finiteNumber(options.now) || Date.now();
+    const state = normalizeUpdateState(updateValue, options.currentVersion);
+    const consent = normalizeConsentState(consentValue);
+    const newer = compareStableVersions(state.latestVersion, state.currentVersion) > 0;
+    const snoozed = newer &&
+      consent.snoozedVersion === state.latestVersion &&
+      consent.snoozedUntil > now;
+    const execution = EXECUTION_STATES.has(state.state);
+    const available = state.state === 'update_available' && newer;
+    const progress = getProgressModel(state);
+    const quietFailure = state.state === 'failed' && QUIET_FAILURE_CODES.has(state.code);
+
+    return {
+      state,
+      consent: {
+        mode: consent.mode,
+        snoozedVersion: consent.snoozedVersion,
+        snoozedUntil: consent.snoozedUntil,
+        authorizedVersion: consent.authorizedVersion,
+        authorizedAt: consent.authorizedAt
+      },
+      progress,
+      available,
+      snoozed,
+      execution,
+      showPanel: (available && !snoozed) || execution || state.state === 'rolled_back' ||
+        (state.state === 'failed' && !quietFailure && newer),
+      badge: getBadge(state, { available, snoozed }),
+      actions: {
+        check: ['idle', 'committed', 'rolled_back', 'failed'].includes(state.state),
+        install: available,
+        later: available || ['staged', 'waiting_for_idle'].includes(state.state),
+        retry: ['failed', 'rolled_back'].includes(state.state)
+      }
+    };
+  }
+
+  function getProgressModel(stateValue = {}) {
+    const state = normalizeUpdateState(stateValue);
+    const base = PROGRESS[state.state] || PROGRESS.idle;
+    return {
+      ...base,
+      blocker: state.blocker,
+      code: state.code,
+      message: state.message
+    };
+  }
+
+  function getBadge(state, flags) {
+    if (state.state === 'applying' || state.state === 'awaiting_health') {
+      return { text: '...', color: '#3578bd' };
+    }
+    if (state.state === 'failed' || state.state === 'rolled_back') {
+      return { text: '!', color: '#b85450' };
+    }
+    if (flags.available) {
+      return { text: 'UP', color: flags.snoozed ? '#6f6755' : '#3578bd' };
+    }
+    return { text: '', color: '#3578bd' };
+  }
+
+  function isExecutionState(value) {
+    return EXECUTION_STATES.has(String(value || ''));
+  }
+
+  function isTerminalState(value) {
+    return TERMINAL_STATES.has(String(value || ''));
+  }
+
+  function compareStableVersions(left, right) {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b) return 0;
+    for (let index = 0; index < 3; index += 1) {
+      if (a[index] !== b[index]) return a[index] > b[index] ? 1 : -1;
+    }
+    return 0;
+  }
+
+  function parseVersion(value) {
+    const match = String(value || '').match(/^(\d+)\.(\d+)\.(\d+)$/);
+    return match ? match.slice(1).map(Number) : null;
+  }
+
+  function safeVersion(value) {
+    return parseVersion(value) ? String(value) : '';
+  }
+
+  function safeToken(value) {
+    const token = String(value || '');
+    return /^[a-z0-9_.-]{1,100}$/i.test(token) ? token : '';
+  }
+
+  function safeId(value) {
+    const id = String(value || '');
+    return /^[a-z0-9-]{1,100}$/i.test(id) ? id : '';
+  }
+
+  function finiteNumber(value) {
+    const number = Number(value || 0);
+    return Number.isFinite(number) && number >= 0 ? number : 0;
+  }
+
+  return Object.freeze({
+    compareStableVersions,
+    deriveViewModel,
+    getProgressModel,
+    isExecutionState,
+    isTerminalState,
+    normalizeConsentState,
+    normalizeUpdateState
+  });
+});

package/extension/styles/panel.css

@@ -4046,3 +4046,149 @@
 #codex-overleaf-panel .recent-projects-degraded [data-recent-projects-retry] {
   margin-top: 8px;
 }
+
+/* v1.9.4: consent-driven coordinated update notice. */
+#codex-overleaf-panel .codex-update-notice {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 14px;
+  align-items: center;
+  margin: 0;
+  padding: 11px 13px;
+  border-bottom: 1px solid var(--tl-border, #2a2f2c);
+  background:
+    linear-gradient(100deg, rgba(53, 120, 189, 0.13), transparent 58%),
+    var(--tl-surface-1, #181a19);
+}
+
+#codex-overleaf-panel .codex-update-notice[hidden] {
+  display: none;
+}
+
+#codex-overleaf-panel .codex-update-notice-body {
+  display: grid;
+  min-width: 0;
+  gap: 2px;
+}
+
+#codex-overleaf-panel .codex-update-notice-eyebrow {
+  color: #7fb5e9;
+  font-size: 10px;
+  font-weight: 750;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+}
+
+#codex-overleaf-panel .codex-update-notice strong {
+  color: var(--tl-fg-1, #eceeec);
+  font-size: 12.5px;
+}
+
+#codex-overleaf-panel .codex-update-notice-detail {
+  overflow: hidden;
+  color: var(--tl-fg-3, #9da39e);
+  font-size: 11px;
+  line-height: 1.35;
+  text-overflow: ellipsis;
+}
+
+#codex-overleaf-panel .codex-update-notice-actions {
+  display: flex;
+  gap: 6px;
+  align-items: center;
+}
+
+#codex-overleaf-panel .codex-update-notice-actions button {
+  width: auto;
+  min-width: 58px;
+  margin: 0;
+  padding: 5px 8px;
+  border: 1px solid var(--tl-border-strong, #414844);
+  border-radius: 5px;
+  background: transparent;
+  color: var(--tl-fg-2, #d5dad6);
+  font-size: 10.5px;
+  font-weight: 700;
+  cursor: pointer;
+}
+
+#codex-overleaf-panel .codex-update-notice-actions button.is-primary {
+  border-color: #4a91d7;
+  background: #3578bd;
+  color: #fff;
+}
+
+#codex-overleaf-panel .codex-update-notice-actions button:focus-visible {
+  outline: 2px solid #79b8f2;
+  outline-offset: 2px;
+}
+
+#codex-overleaf-panel .codex-update-notice-progress {
+  position: relative;
+  height: 3px;
+  margin-top: 6px;
+  overflow: hidden;
+  border-radius: 999px;
+  background: #2c312e;
+}
+
+#codex-overleaf-panel .codex-update-notice-progress > span {
+  display: block;
+  height: 100%;
+  border-radius: inherit;
+  background: #4f9ee8;
+  transition: width 250ms ease;
+}
+
+#codex-overleaf-panel .codex-update-notice-progress.is-indeterminate > span {
+  width: 42% !important;
+  animation: codex-update-notice-progress 1.25s ease-in-out infinite;
+}
+
+#codex-overleaf-panel .codex-update-notice[data-state="waiting_for_idle"] {
+  background:
+    linear-gradient(100deg, rgba(199, 160, 83, 0.13), transparent 58%),
+    var(--tl-surface-1, #181a19);
+}
+
+#codex-overleaf-panel .codex-update-notice[data-state="waiting_for_idle"] .codex-update-notice-eyebrow {
+  color: #d4b86f;
+}
+
+#codex-overleaf-panel .codex-update-notice[data-state="committed"] .codex-update-notice-eyebrow {
+  color: var(--tl-ok, #7fd58a);
+}
+
+#codex-overleaf-panel .codex-update-notice[data-state="failed"],
+#codex-overleaf-panel .codex-update-notice[data-state="rolled_back"] {
+  background:
+    linear-gradient(100deg, rgba(184, 84, 80, 0.12), transparent 58%),
+    var(--tl-surface-1, #181a19);
+}
+
+#codex-overleaf-panel .codex-update-notice[data-state="failed"] .codex-update-notice-eyebrow,
+#codex-overleaf-panel .codex-update-notice[data-state="rolled_back"] .codex-update-notice-eyebrow {
+  color: var(--tl-fail, #d87972);
+}
+
+@keyframes codex-update-notice-progress {
+  0% { transform: translateX(-110%); }
+  100% { transform: translateX(240%); }
+}
+
+@media (max-width: 720px) {
+  #codex-overleaf-panel .codex-update-notice {
+    grid-template-columns: 1fr;
+  }
+
+  #codex-overleaf-panel .codex-update-notice-actions {
+    justify-content: flex-end;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  #codex-overleaf-panel .codex-update-notice-progress.is-indeterminate > span {
+    width: 65% !important;
+    animation: none;
+  }
+}