codex-overleaf-link 2.3.4 → 2.3.6

package/native-host/src/releaseTransport.js

@@ -0,0 +1,154 @@
+'use strict';
+
+const { updateError } = require('./updateTrust');
+const { fetchRelease } = require('./releaseProxy');
+
+const RETRYABLE_HTTP = new Set([408, 429, 500, 502, 503, 504]);
+const CERTIFICATE_ERRORS = /CERT|TLS_CERT|SELF_SIGNED|UNABLE_TO_VERIFY|DEPTH_ZERO/;
+
+function abortable(promise, signal) {
+  if (signal.aborted) {
+    void Promise.resolve(promise).catch(() => {});
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(signal.reason);
+    signal.addEventListener('abort', abort, { once: true });
+    Promise.resolve(promise).then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+  });
+}
+
+function terminalError(code, message) {
+  return Object.assign(updateError(code, message), { retryable: false });
+}
+
+async function readBoundedBody(response, limit, signal) {
+  const declared = Number(response.headers?.get?.('content-length') || 0);
+  if (declared > limit) throw terminalError('update_download_limit', 'Update response exceeds its size limit.');
+  const reader = response.body?.getReader?.();
+  if (!reader) {
+    const bytes = Buffer.from(await abortable(response.arrayBuffer(), signal));
+    if (!bytes.length || bytes.length > limit) throw terminalError('update_download_limit', 'Update response exceeds its size limit.');
+    return bytes;
+  }
+  const chunks = [];
+  let length = 0;
+  try {
+    while (true) {
+      const chunk = await abortable(reader.read(), signal);
+      if (chunk.done) break;
+      const bytes = Buffer.from(chunk.value);
+      length += bytes.length;
+      if (length > limit) throw terminalError('update_download_limit', 'Update response exceeds its size limit.');
+      chunks.push(bytes);
+    }
+    if (!length) throw terminalError('update_download_limit', 'Update response is empty.');
+    return Buffer.concat(chunks, length);
+  } catch (error) {
+    void reader.cancel().catch(() => {});
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+function networkFailure(error, signal, callerSignal) {
+  let cause = error;
+  for (let depth = 0; depth < 8 && cause?.cause && cause.cause !== cause; depth += 1) cause = cause.cause;
+  const reason = String(typeof cause?.code === 'string' ? cause.code : cause?.name || error?.name || 'network_error');
+  if (callerSignal?.aborted) return { code: 'update_network_cancelled', reason: 'cancelled', retryable: false };
+  if (error?.retryable === false) return { code: error.code || 'update_network_failed', reason, retryable: false };
+  if (CERTIFICATE_ERRORS.test(reason)) return { code: 'update_network_certificate', reason, retryable: false };
+  if (signal.aborted || /TIMEOUT|Timeout|AbortError/.test(reason)) {
+    return { code: 'update_network_timeout', reason, retryable: true };
+  }
+  if (/ENOTFOUND|EAI_AGAIN/.test(reason)) return { code: 'update_network_dns', reason, retryable: true };
+  return { code: /^update_[a-z0-9_]+$/.test(error?.code || '') ? error.code : 'update_network_failed',
+    reason, retryable: error?.retryable !== false };
+}
+
+function retryDelay(response, fallback) {
+  const value = response?.headers?.get?.('retry-after');
+  if (!value) return fallback;
+  const seconds = Number(value);
+  const delay = Number.isFinite(seconds) ? seconds * 1000 : Date.parse(value) - Date.now();
+  return Number.isFinite(delay) ? Math.max(fallback, delay, 0) : fallback;
+}
+
+function delay(milliseconds, signal) {
+  if (!milliseconds) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const abort = () => { clearTimeout(timer); reject(signal.reason); };
+    const timer = setTimeout(() => { signal?.removeEventListener('abort', abort); resolve(); }, milliseconds);
+    if (signal?.aborted) abort();
+    else signal?.addEventListener('abort', abort, { once: true });
+  });
+}
+
+async function requestRelease(url, options = {}) {
+  const started = Date.now();
+  const deadline = options.deadlineAt || started + (options.totalTimeoutMs ?? 45000);
+  const maxAttempts = Math.max(1, Math.min(5, options.maxAttempts ?? 3));
+  const host = new URL(url).hostname;
+  let failure;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) break;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new DOMException('Update request timed out.', 'TimeoutError')),
+      Math.min(remaining, options.timeoutMs ?? 12000));
+    const cancel = () => controller.abort(options.signal.reason);
+    if (options.signal?.aborted) cancel();
+    else options.signal?.addEventListener('abort', cancel, { once: true });
+    let response;
+    let retryAfter = 0;
+    try {
+      const fetchImpl = options.fetch || ((value, init) => fetchRelease(value, init, options));
+      response = await abortable(fetchImpl(url, {
+        method: options.method || 'GET', headers: options.headers,
+        redirect: 'follow', signal: controller.signal
+      }), controller.signal);
+      const finalUrl = new URL(response.url || url);
+      if (options.allowedHosts && (finalUrl.protocol !== 'https:' || !options.allowedHosts.has(finalUrl.hostname))) {
+        throw terminalError('update_asset_redirect_forbidden', 'Release request redirected to an untrusted host.');
+      }
+      if (!response.ok && response.status !== 304) {
+        throw Object.assign(updateError(options.httpErrorCode || 'update_asset_http_error',
+          'Update request failed with HTTP ' + response.status + '.'), { retryable: RETRYABLE_HTTP.has(response.status) });
+      }
+      const bytes = options.method === 'HEAD' || response.status === 304
+        ? null : await readBoundedBody(response, options.limit ?? 32 * 1024 * 1024, controller.signal);
+      return { ok: response.ok, status: response.status, url: finalUrl.href, headers: response.headers,
+        bytes, attempts: attempt, elapsedMs: Date.now() - started };
+    } catch (error) {
+      const classified = networkFailure(error, controller.signal, options.signal);
+      const diagnostics = { stage: options.stage || 'download', host, attempt,
+        elapsedMs: Date.now() - started, reason: classified.reason, retryable: classified.retryable,
+        ...(response ? { httpStatus: response.status } : {}) };
+      const description = classified.code === 'update_network_timeout' ? 'Connection or download timed out'
+        : classified.code === 'update_network_dns' ? 'DNS lookup failed'
+          : classified.code === 'update_network_certificate' ? 'TLS certificate verification failed'
+            : classified.code === 'update_network_cancelled' ? 'Update request was cancelled'
+              : error?.retryable === false ? error.message : 'Network request failed';
+      const reason = response ? 'HTTP ' + response.status
+        : /^[A-Z][A-Z0-9_]{1,79}$/.test(classified.reason) ? classified.reason : '';
+      failure = updateError(classified.code,
+        description.replace(/\.$/, '') + ' (' + diagnostics.stage + ', ' + host + ', attempt ' + attempt +
+          (reason ? ', ' + reason : '') + ', ' + (diagnostics.elapsedMs / 1000).toFixed(1) + 's).',
+        { cause: error, network: diagnostics });
+      try { options.onDiagnostic?.(diagnostics); } catch (_error) { /* diagnostics are best effort */ }
+      if (!classified.retryable || attempt === maxAttempts) throw failure;
+      retryAfter = retryDelay(response, (options.delayMs ?? 500) * attempt);
+    } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener('abort', cancel);
+      controller.abort();
+      if (response?.body && !response.body.locked) void response.body.cancel().catch(() => {});
+    }
+    if (Date.now() + retryAfter >= deadline) break;
+    await delay(retryAfter, options.signal);
+  }
+  throw failure || updateError('update_network_timeout', 'The update network time budget was exhausted.');
+}
+
+module.exports = { requestRelease };

package/native-host/src/updateManager.js

@@ -11,6 +11,8 @@ const {
   verifySignedReleaseManifest
 } = require('./updateTrust');
 const { extractVerifiedUpdateBundle } = require('./updateArchive');
+const { requestRelease } = require('./releaseTransport');
+const RUNNING_VERSION = require('../../package.json').version;
 
 const GITHUB_LATEST_URL = 'https://github.com/Ghqqqq/codex-overleaf-link/releases/latest';
 const GITHUB_RELEASE_DOWNLOAD_ROOT = 'https://github.com/Ghqqqq/codex-overleaf-link/releases/download';
@@ -175,11 +177,11 @@ function delay(milliseconds) {
 }
 
 async function checkForUpdate(context, params = {}, options = {}) {
-  const fetchImpl = options.fetch || globalThis.fetch;
-  if (typeof fetchImpl !== 'function') {
-    throw updateError('update_network_unavailable', 'This Node runtime cannot check GitHub Releases.');
-  }
+  const fetchImpl = options.fetch;
+  const network = { ...options.network, deadlineAt: Date.now() + 40000 };
   const currentVersion = normalizeCurrentVersion(params.currentVersion, context);
+  const authorized = readAuthorizedCandidate(context, currentVersion);
+  if (authorized) return authorized;
   const headers = {
     Accept: 'text/html,application/xhtml+xml',
     'User-Agent': 'codex-overleaf-link-updater'
@@ -187,11 +189,13 @@ async function checkForUpdate(context, params = {}, options = {}) {
   if (params.etag && typeof params.etag === 'string' && params.etag.length < 300) {
     headers['If-None-Match'] = params.etag;
   }
-  const releaseResponse = await fetchWithTimeout(fetchImpl, GITHUB_LATEST_URL, {
+  const releaseResponse = await requestRelease(GITHUB_LATEST_URL, {
+    ...network, fetch: fetchImpl, stage: 'version_check',
     headers,
     method: 'HEAD',
-    redirect: 'follow'
-  }, 12000);
+    allowedHosts: new Set(['github.com']),
+    httpErrorCode: 'update_github_http_error'
+  });
   if (releaseResponse.status === 304) {
     const candidate = readJsonSafe(path.join(context.updatesRoot, CANDIDATE_FILE), null);
     if (candidate?.manifestBase64 && candidate?.signatureBase64) {
@@ -247,12 +251,12 @@ async function checkForUpdate(context, params = {}, options = {}) {
   const manifestBytes = await fetchReleaseAsset(
     fetchImpl,
     buildReleaseAssetUrl(releaseTag, 'release-manifest.json'),
-    256 * 1024
+    256 * 1024, { ...network, stage: 'release_manifest' }
   );
   const signatureBytes = await fetchReleaseAsset(
     fetchImpl,
     buildReleaseAssetUrl(releaseTag, 'release-manifest.sig'),
-    16 * 1024
+    16 * 1024, { ...network, stage: 'release_signature' }
   );
   const manifest = verifySignedReleaseManifest(manifestBytes, signatureBytes);
   if (manifest.version !== latestVersion || manifest.tag !== releaseTag) {
@@ -271,6 +275,24 @@ async function checkForUpdate(context, params = {}, options = {}) {
   return { managed: true, available: true, currentVersion, latestVersion, etag: candidate.etag };
 }
 
+function readAuthorizedCandidate(context, currentVersion) {
+  const authorization = readAuthorization(context);
+  if (!authorization || !['authorized', 'bound'].includes(authorization.state)) return null;
+  const candidate = readJsonSafe(path.join(context.updatesRoot, CANDIDATE_FILE), null);
+  if (!candidate) throw updateError('update_candidate_missing', 'The authorized update candidate is missing.');
+  const manifest = verifySignedReleaseManifest(
+    Buffer.from(candidate.manifestBase64 || '', 'base64'),
+    Buffer.from(candidate.signatureBase64 || '', 'base64')
+  );
+  if (candidate.latestVersion !== manifest.version || authorization.targetVersion !== manifest.version ||
+      authorization.sourceVersion !== currentVersion || !isNewerStableVersion(manifest.version, currentVersion)) {
+    throw updateError('update_consent_mismatch', 'The signed candidate no longer matches the authorized update.');
+  }
+  requireAuthorization(context, manifest.version, ['authorized', 'bound']);
+  return { managed: true, available: true, currentVersion, latestVersion: manifest.version,
+    etag: candidate.etag || '', cached: true, authorized: true };
+}
+
 function parseStableReleaseTag(value) {
   try {
     const url = new URL(String(value || ''));
@@ -388,8 +410,8 @@ async function stageCandidate(context, options = {}) {
   fs.mkdirSync(stageRoot, { recursive: true, mode: 0o700 });
   try {
     const archivePath = path.join(stageRoot, manifest.updateBundle.name);
-    const fetchImpl = options.fetch || globalThis.fetch;
-    const bundleBytes = await fetchReleaseAsset(fetchImpl, candidate.bundleUrl, manifest.updateBundle.size + 1);
+    const bundleBytes = await fetchReleaseAsset(options.fetch, candidate.bundleUrl, manifest.updateBundle.size + 1,
+      { ...options.network, totalTimeoutMs: 90000, timeoutMs: 30000, stage: 'update_bundle' });
     if (bundleBytes.length !== manifest.updateBundle.size) {
       throw updateError('update_bundle_size_mismatch', 'Downloaded update bundle size does not match the signed manifest.');
     }
@@ -764,6 +786,8 @@ function recoverAndReadStatus(context) {
   return {
     managed: true,
     activeVersion: readVersionPointer(context.nativeRoot, 'active-version'),
+    runtimeVersion: context.env?.CODEX_OVERLEAF_ACTIVE_VERSION || RUNNING_VERSION,
+    installedAligned: Boolean(alignedVersion),
     previousVersion: readVersionPointer(context.nativeRoot, 'previous-version'),
     transaction: journal ? publicTransaction(journal) : null,
     authorization: publicAuthorization(readAuthorization(context))
@@ -941,38 +965,15 @@ function rewriteManagedManifestVersion(manifestPath, version) {
   atomicWriteText(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
 }
 
-async function fetchReleaseAsset(fetchImpl, url, limit) {
+async function fetchReleaseAsset(fetchImpl, url, limit, network = {}) {
   const parsed = new URL(String(url || ''));
   if (parsed.protocol !== 'https:' || parsed.hostname !== 'github.com' || !parsed.pathname.startsWith('/Ghqqqq/codex-overleaf-link/releases/download/')) {
     throw updateError('update_asset_url_forbidden', 'Release asset URL is outside the trusted repository.');
   }
-  const response = await fetchWithTimeout(fetchImpl, parsed.href, { redirect: 'follow' }, 20000);
-  if (!response.ok) throw updateError('update_asset_http_error', 'Release asset download failed with HTTP ' + response.status + '.');
-  const finalUrl = new URL(response.url || parsed.href);
-  if (finalUrl.protocol !== 'https:' || !RELEASE_ASSET_HOSTS.has(finalUrl.hostname)) {
-    throw updateError('update_asset_redirect_forbidden', 'Release asset redirected to an untrusted host.');
-  }
-  return readResponseBytes(response, limit);
-}
-
-async function fetchWithTimeout(fetchImpl, url, options, timeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetchImpl(url, { ...options, signal: controller.signal });
-  } catch (error) {
-    throw updateError('update_network_failed', 'Update network request failed.', { cause: error });
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function readResponseBytes(response, limit) {
-  const declared = Number(response.headers?.get?.('content-length') || 0);
-  if (declared > limit) throw updateError('update_download_limit', 'Update response exceeds its size limit.');
-  const buffer = Buffer.from(await response.arrayBuffer());
-  if (!buffer.length || buffer.length > limit) throw updateError('update_download_limit', 'Update response exceeds its size limit.');
-  return buffer;
+  const response = await requestRelease(parsed.href, {
+    timeoutMs: 20000, ...network, fetch: fetchImpl, limit, allowedHosts: RELEASE_ASSET_HOSTS
+  });
+  return response.bytes;
 }
 
 function findReleaseAsset(assets, name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",

package/scripts/install-managed.mjs

@@ -21,7 +21,7 @@ export function formatInstallManagedHuman(result) {
     '1. Open chrome://extensions and enable Developer mode.',
     '2. Remove the previous Codex Overleaf Link entry if Chrome shows a duplicate.',
     '3. Choose Load unpacked and select: ' + result.loadUnpackedPath,
-    'Future stable extension and native-host updates will install automatically when Overleaf is saved and idle.',
+    'Future signed stable updates are checked automatically. Choose Update now to authorize a version; installation waits until Overleaf is saved and idle.',
     ''
   ].join('\n');
 }