codex-overleaf-link 1.8.6 → 1.9.0

package/native-host/src/updateTrust.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const UPDATE_REPOSITORY = 'Ghqqqq/codex-overleaf-link';
+const UPDATE_CHANNEL = 'stable';
+const UPDATE_MANIFEST_SCHEMA = 2;
+const BOOTSTRAP_PROTOCOL = 1;
+const TRUSTED_UPDATE_KEYS = Object.freeze({
+  'release-2026-01': [
+    '-----BEGIN PUBLIC KEY-----',
+    'MCowBQYDK2VwAyEAhqNKNHdRuggyqyMz2knkMgNYgoUZS6FEjQlnYWgyDFA=',
+    '-----END PUBLIC KEY-----',
+    ''
+  ].join('\n')
+});
+
+function verifySignedReleaseManifest(manifestBytes, signatureBytes, options = {}) {
+  const rawManifest = toBoundedBuffer(manifestBytes, 256 * 1024, 'update_manifest_too_large');
+  const rawSignature = toBoundedBuffer(signatureBytes, 16 * 1024, 'update_signature_too_large');
+  const envelope = parseJsonObject(rawSignature, 'update_signature_invalid');
+  if (envelope.algorithm !== 'Ed25519') {
+    throw updateError('update_signature_algorithm_unsupported', 'Update signature algorithm must be Ed25519.');
+  }
+  if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(String(envelope.keyId || ''))) {
+    throw updateError('update_signature_key_invalid', 'Update signature key id is invalid.');
+  }
+
+  const keys = options.publicKeys || TRUSTED_UPDATE_KEYS;
+  const publicKey = keys[envelope.keyId];
+  if (!publicKey) {
+    throw updateError('update_signature_key_unknown', 'Update signature key is not trusted.');
+  }
+
+  let signature;
+  try {
+    signature = Buffer.from(String(envelope.signature || ''), 'base64');
+  } catch (_error) {
+    throw updateError('update_signature_invalid', 'Update signature encoding is invalid.');
+  }
+  if (signature.length !== 64 || !crypto.verify(null, rawManifest, publicKey, signature)) {
+    throw updateError('update_signature_invalid', 'Update manifest signature verification failed.');
+  }
+
+  const manifest = parseJsonObject(rawManifest, 'update_manifest_invalid');
+  validateReleaseManifest(manifest, options);
+  return manifest;
+}
+
+function validateReleaseManifest(manifest, options = {}) {
+  const repository = options.repository || UPDATE_REPOSITORY;
+  const channel = options.channel || UPDATE_CHANNEL;
+  const bootstrapProtocol = Number(options.bootstrapProtocol || BOOTSTRAP_PROTOCOL);
+  if (manifest.schemaVersion !== UPDATE_MANIFEST_SCHEMA) {
+    throw updateError('update_manifest_schema_unsupported', 'Update manifest schema is not supported.');
+  }
+  if (manifest.repository !== repository || manifest.channel !== channel) {
+    throw updateError('update_manifest_origin_mismatch', 'Update manifest repository or channel does not match this installation.');
+  }
+  const version = parseSemver(manifest.version);
+  if (!version || manifest.tag !== 'v' + manifest.version) {
+    throw updateError('update_manifest_version_invalid', 'Update manifest version or tag is invalid.');
+  }
+  if (!Number.isInteger(manifest.bootstrapProtocol) || manifest.bootstrapProtocol !== bootstrapProtocol) {
+    throw updateError('update_bootstrap_upgrade_required', 'This release requires a different Bootstrap protocol.');
+  }
+  if (!/^[0-9a-f]{40}$/.test(String(manifest.gitCommit || ''))) {
+    throw updateError('update_manifest_commit_invalid', 'Update manifest commit is invalid.');
+  }
+  if (!Number.isFinite(Date.parse(String(manifest.createdAt || '')))) {
+    throw updateError('update_manifest_timestamp_invalid', 'Update manifest timestamp is invalid.');
+  }
+  const bundle = manifest.updateBundle;
+  const expectedName = 'codex-overleaf-update-v' + manifest.version + '.tar.gz';
+  if (!bundle || bundle.name !== expectedName) {
+    throw updateError('update_bundle_name_invalid', 'Update bundle name does not match the release version.');
+  }
+  if (!Number.isSafeInteger(bundle.size) || bundle.size <= 0 || bundle.size > 32 * 1024 * 1024) {
+    throw updateError('update_bundle_size_invalid', 'Update bundle size is outside the supported limit.');
+  }
+  if (!/^[0-9a-f]{64}$/.test(String(bundle.sha256 || ''))) {
+    throw updateError('update_bundle_hash_invalid', 'Update bundle hash is invalid.');
+  }
+  if (!Array.isArray(manifest.artifacts)) {
+    throw updateError('update_manifest_artifacts_invalid', 'Update manifest artifacts must be an array.');
+  }
+  return manifest;
+}
+
+function parseSemver(value) {
+  const match = String(value || '').match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/);
+  if (!match) {
+    return null;
+  }
+  return match.slice(1).map(Number);
+}
+
+function compareSemver(left, right) {
+  const a = Array.isArray(left) ? left : parseSemver(left);
+  const b = Array.isArray(right) ? right : parseSemver(right);
+  if (!a || !b) {
+    throw updateError('update_version_invalid', 'A stable semantic version was expected.');
+  }
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) {
+      return a[index] < b[index] ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
+function isNewerStableVersion(candidate, current) {
+  return compareSemver(candidate, current) > 0;
+}
+
+function parseJsonObject(bytes, code) {
+  let value;
+  try {
+    value = JSON.parse(Buffer.from(bytes).toString('utf8'));
+  } catch (_error) {
+    throw updateError(code, 'Signed update metadata is not valid JSON.');
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw updateError(code, 'Signed update metadata must be an object.');
+  }
+  return value;
+}
+
+function toBoundedBuffer(value, limit, code) {
+  const buffer = Buffer.isBuffer(value) ? value : Buffer.from(value || '');
+  if (!buffer.length || buffer.length > limit) {
+    throw updateError(code, 'Signed update metadata exceeds its size limit.');
+  }
+  return buffer;
+}
+
+function updateError(code, message, details = {}) {
+  const error = new Error(message);
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+}
+
+module.exports = {
+  BOOTSTRAP_PROTOCOL,
+  TRUSTED_UPDATE_KEYS,
+  UPDATE_CHANNEL,
+  UPDATE_MANIFEST_SCHEMA,
+  UPDATE_REPOSITORY,
+  compareSemver,
+  isNewerStableVersion,
+  parseSemver,
+  updateError,
+  validateReleaseManifest,
+  verifySignedReleaseManifest
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "1.8.6",
+  "version": "1.9.0",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",
@@ -21,6 +21,9 @@
     "verify:release": "node scripts/verify-release.mjs",
     "verify:release-artifacts": "node scripts/verify-release-artifacts.mjs",
     "build:release": "node scripts/build-release.mjs",
+    "sign:release": "node scripts/sign-release-manifest.mjs",
+    "install:managed": "node scripts/install-managed.mjs",
+    "uninstall:managed": "node scripts/uninstall-managed.mjs",
     "install:native": "node scripts/install-native-host.mjs",
     "uninstall:native": "node scripts/uninstall-native-host.mjs",
     "bridge": "node native-host/src/index.js",
@@ -37,9 +40,15 @@
   "files": [
     "bin/",
     "native-host/src/",
-    "extension/src/shared/",
+    "extension/assets/",
+    "extension/bootstrap/",
+    "extension/runtime-manifest.json",
+    "extension/src/",
+    "extension/styles/",
     "scripts/codex-json-agent.mjs",
     "scripts/install-native-host.mjs",
+    "scripts/install-managed.mjs",
+    "scripts/uninstall-managed.mjs",
     "scripts/uninstall-native-host.mjs",
     "scripts/verify-npm-package.mjs",
     "README.md",

package/scripts/install-managed.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const { installManagedDistribution } = require('../native-host/src/managedInstall.js');
+const scriptPath = fileURLToPath(import.meta.url);
+const packageRoot = path.resolve(path.dirname(scriptPath), '..');
+
+export function installManaged(options = {}) {
+  return installManagedDistribution({ ...options, packageRoot: options.packageRoot || packageRoot });
+}
+
+export function formatInstallManagedHuman(result) {
+  return [
+    'Installed managed Codex Overleaf Link v' + result.version + '.',
+    'Managed extension path: ' + result.extensionRoot,
+    'Managed native root: ' + result.nativeRoot,
+    'One-time Chrome step:',
+    '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.',
+    ''
+  ].join('\n');
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--extension-id') parsed.extensionId = readValue(argv, index++, arg);
+    else if (arg === '--browser') parsed.browser = readValue(argv, index++, arg);
+    else if (arg === '--managed-root') parsed.managedRoot = readValue(argv, index++, arg);
+    else if (arg === '--json') parsed.json = true;
+    else if (arg === '--help') parsed.help = true;
+    else throw new Error('Unknown option: ' + arg);
+  }
+  return parsed;
+}
+
+function readValue(argv, index, name) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('--')) throw new Error('Missing value for ' + name);
+  return value;
+}
+
+async function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+      console.log('Usage: install-managed [--extension-id <id>] [--browser chrome|chromium|auto] [--managed-root <path>] [--json]');
+      return;
+    }
+    const result = installManaged(args);
+    process.stdout.write(args.json ? JSON.stringify(result, null, 2) + '\n' : formatInstallManagedHuman(result));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+
+if (path.resolve(process.argv[1] || '') === scriptPath) await main();

package/scripts/uninstall-managed.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const { uninstallManagedDistribution } = require('../native-host/src/managedInstall.js');
+const scriptPath = fileURLToPath(import.meta.url);
+
+export function uninstallManaged(options = {}) {
+  return uninstallManagedDistribution(options);
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--browser') parsed.browser = readValue(argv, index++, arg);
+    else if (arg === '--managed-root') parsed.managedRoot = readValue(argv, index++, arg);
+    else if (arg === '--json') parsed.json = true;
+    else if (arg === '--help') parsed.help = true;
+    else throw new Error('Unknown option: ' + arg);
+  }
+  return parsed;
+}
+
+function readValue(argv, index, name) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('--')) throw new Error('Missing value for ' + name);
+  return value;
+}
+
+async function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+      console.log('Usage: uninstall-managed [--browser chrome|chromium|auto] [--managed-root <path>] [--json]');
+      return;
+    }
+    const result = uninstallManaged(args);
+    process.stdout.write(args.json ? JSON.stringify(result, null, 2) + '\n' : 'Removed managed Codex Overleaf Link installation.\n');
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+
+if (path.resolve(process.argv[1] || '') === scriptPath) await main();