codex-overleaf-link 1.1.1

package/scripts/install-native-host.mjs

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import {
+  DEFAULT_CHROME_EXTENSION_ID,
+  buildAllowedOrigin,
+  buildHostManifest,
+  validateChromeExtensionId
+} from '../native-host/src/manifest.js';
+import { buildLauncher } from '../native-host/src/launcher.js';
+import {
+  getDefaultBridgePath,
+  getDefaultRuntimeRoot,
+  getNativeHostRegistrationTarget
+} from '../native-host/src/nativeHostPlatform.js';
+
+const require = createRequire(import.meta.url);
+const { installRuntimeFromPackage } = require('../native-host/src/runtimeInstaller.js');
+const scriptPath = fileURLToPath(import.meta.url);
+const scriptDir = path.dirname(scriptPath);
+const defaultPackageRoot = path.resolve(scriptDir, '..');
+
+export function installNativeHost(options = {}) {
+  const extensionId = options.extensionId || DEFAULT_CHROME_EXTENSION_ID;
+  if (!validateChromeExtensionId(extensionId)) {
+    throw new Error(`Invalid Chrome extension id: ${extensionId}`);
+  }
+
+  const packageRoot = path.resolve(options.packageRoot || defaultPackageRoot);
+  const extensionIds = [extensionId];
+  const platform = options.platform || process.platform;
+  const browser = options.browser || 'chrome';
+  assertSupportedBrowser(browser);
+
+  const env = options.env || process.env;
+  const platformPath = platform === 'win32' ? path.win32 : path.posix;
+  const runtimePlatformPath = options.runtimeRoot && path.isAbsolute(options.runtimeRoot) ? path : platformPath;
+  const defaultInstallRoot = getDefaultRuntimeRoot({ platform, browser, env });
+  const installRoot = resolveForPlatform(options.runtimeRoot || defaultInstallRoot, platformPath);
+  const bridgeEntryPath = platformPath.join(installRoot, 'native-host', 'src', 'index.js');
+  const agentPath = platformPath.join(installRoot, 'scripts', 'codex-json-agent.mjs');
+  const defaultBridgePath = getDefaultBridgePath({ platform, browser, env });
+  const bridgePath = resolveForPlatform(options.bridgePath || defaultBridgePath, platformPath);
+  const registrationTarget = getNativeHostRegistrationTarget({
+    platform,
+    browser,
+    env
+  });
+  const manifestPath = registrationTarget.manifestPath;
+  const manifest = buildHostManifest({
+    extensionId,
+    extensionIds,
+    bridgePath,
+    platform
+  });
+
+  const runtimeInstall = installRuntimeFromPackage({
+    packageRoot,
+    runtimeRoot: installRoot,
+    defaultRuntimeRoot: defaultInstallRoot,
+    platformPath: runtimePlatformPath
+  });
+  const runtimePackageVersion = readRuntimePackageVersion(path.join(installRoot, 'package.json'));
+
+  fs.mkdirSync(platformPath.dirname(bridgePath), { recursive: true });
+  fs.writeFileSync(bridgePath, buildLauncher({
+    platform,
+    nodePath: process.execPath,
+    bridgeEntryPath,
+    agentPath
+  }), 'utf8');
+  if (platform !== 'win32') {
+    fs.chmodSync(bridgePath, 0o755);
+  }
+
+  fs.mkdirSync(platformPath.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+  if (registrationTarget.kind === 'registry') {
+    addWindowsRegistryValue(registrationTarget.registryKey, manifestPath);
+  }
+
+  return {
+    ok: true,
+    action: runtimeInstall.action,
+    browser: registrationTarget.browser,
+    extensionId,
+    manifest: {
+      path: manifestPath,
+      allowedOrigin: buildAllowedOrigin(extensionId),
+      allowedOrigins: manifest.allowed_origins
+    },
+    bridge: {
+      path: bridgePath
+    },
+    runtime: {
+      root: installRoot,
+      action: runtimeInstall.action,
+      packageVersion: runtimePackageVersion
+    },
+    registry: registrationTarget.kind === 'registry'
+      ? { key: registrationTarget.registryKey }
+      : undefined,
+    warning: runtimeInstall.warning
+  };
+}
+
+export function formatInstallNativeHostHuman(result) {
+  const lines = [`Installed Native Messaging host manifest: ${result.manifest.path}`];
+  if (result.registry) {
+    lines.push(`Registered Native Messaging host registry key: ${result.registry.key}`);
+  }
+  lines.push(`Bridge executable: ${result.bridge.path}`);
+  lines.push(`Runtime root: ${result.runtime.root}`);
+  lines.push(`Runtime package version: ${result.runtime.packageVersion}`);
+  lines.push(`Allowed Chrome extension id: ${result.extensionId}`);
+  lines.push(`Allowed Chrome extension ids: ${result.manifest.allowedOrigins.map(origin => origin.replace(/^chrome-extension:\/\//, '').replace(/\/$/, '')).join(', ')}`);
+  if (result.warning) {
+    lines.push(`Warning: ${result.warning}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function resolveForPlatform(targetPath, platformPathModule) {
+  if (platformPathModule.isAbsolute(targetPath)) {
+    return targetPath;
+  }
+  return platformPathModule.resolve(targetPath);
+}
+
+function readRuntimePackageVersion(packagePath) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    return typeof pkg.version === 'string' && pkg.version ? pkg.version : 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+function addWindowsRegistryValue(registryKey, manifestPath) {
+  const registryCommand = getWindowsRegistryCommand();
+  const result = spawnSync(registryCommand.file, [
+    ...registryCommand.args,
+    'add',
+    registryKey,
+    '/ve',
+    '/t',
+    'REG_SZ',
+    '/d',
+    manifestPath,
+    '/f'
+  ], {
+    encoding: 'utf8'
+  });
+  if (result.error) {
+    throw new Error(`Failed to run ${registryCommand.file}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(result.stderr || result.stdout || `reg.exe add failed with status ${result.status}`);
+  }
+}
+
+function getWindowsRegistryCommand() {
+  return {
+    file: process.env.CODEX_OVERLEAF_REG_EXE || 'reg.exe',
+    args: parseStringArrayEnv(process.env.CODEX_OVERLEAF_REG_EXE_ARGS_JSON)
+  };
+}
+
+function parseStringArrayEnv(value) {
+  if (!value) {
+    return [];
+  }
+  const parsed = JSON.parse(value);
+  if (!Array.isArray(parsed) || !parsed.every(item => typeof item === 'string')) {
+    throw new Error('CODEX_OVERLEAF_REG_EXE_ARGS_JSON must be a JSON array of strings');
+  }
+  return parsed;
+}
+
+function assertSupportedBrowser(browser) {
+  if (!['auto', 'chrome', 'chromium'].includes(browser)) {
+    throw new Error('Usage: --browser must be one of chrome, chromium, or auto');
+  }
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--extension-id') {
+      parsed.extensionId = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--bridge-path') {
+      parsed.bridgePath = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--runtime-root') {
+      parsed.runtimeRoot = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--browser') {
+      parsed.browser = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--platform') {
+      parsed.platform = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--force') {
+      parsed.force = true;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--help') {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return parsed;
+}
+
+function readOptionValue(argv, index, optionName) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('--')) {
+    throw new Error(`Missing value for ${optionName}`);
+  }
+  return value;
+}
+
+function printUsage() {
+  console.log('Usage: install-native-host.mjs [--extension-id <id>] [--browser chrome|chromium|auto] [--runtime-root <path>] [--json]');
+}
+
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+      printUsage();
+      return;
+    }
+    const result = installNativeHost(args);
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      process.stdout.write(formatInstallNativeHostHuman(result));
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+if (path.resolve(process.argv[1] || '') === scriptPath) {
+  await main();
+}

package/scripts/npm-package-files-v1.1.1.txt

@@ -0,0 +1,52 @@
+package/LICENSE
+package/extension/src/shared/agentTranscript.js
+package/extension/src/shared/auditRecords.js
+package/native-host/src/codexArgs.js
+package/native-host/src/codexHome.js
+package/native-host/src/codexModels.js
+package/native-host/src/codexPrompt.js
+package/native-host/src/codexPromptAssembly.js
+package/native-host/src/codexSessionRunner.js
+package/native-host/src/commandApproval.js
+package/extension/src/shared/compatibility.js
+package/extension/src/shared/compileAdapter.js
+package/native-host/src/debugLog.js
+package/native-host/src/diffEngine.js
+package/extension/src/shared/governanceRules.js
+package/extension/src/shared/i18n.js
+package/native-host/src/index.js
+package/native-host/src/launcher.js
+package/native-host/src/localSkills.js
+package/native-host/src/manifest.js
+package/native-host/src/mirrorSensitiveScan.js
+package/native-host/src/mirrorWorkspace.js
+package/extension/src/shared/models.js
+package/native-host/src/nativeDoctor.js
+package/native-host/src/nativeEnvironment.js
+package/native-host/src/nativeHostPlatform.js
+package/native-host/src/nativeMessaging.js
+package/native-host/src/nativeQuotas.js
+package/native-host/src/nativeResponseBudget.js
+package/extension/src/shared/otText.js
+package/extension/src/shared/projectFiles.js
+package/extension/src/shared/reviewing.js
+package/native-host/src/runtimeInstaller.js
+package/extension/src/shared/sensitiveScan.js
+package/extension/src/shared/sessionState.js
+package/extension/src/shared/staleGuard.js
+package/extension/src/shared/storageDb.js
+package/extension/src/shared/storageKeys.js
+package/extension/src/shared/storageMigration.js
+package/extension/src/shared/summary.js
+package/native-host/src/taskRunner.js
+package/native-host/src/taskRunnerRuntime.js
+package/native-host/src/textPatch.js
+package/extension/src/shared/undoOperations.js
+package/package.json
+package/README.md
+package/scripts/codex-json-agent.mjs
+package/bin/codex-overleaf-link.mjs
+package/scripts/install-native-host.mjs
+package/scripts/uninstall-native-host.mjs
+package/scripts/verify-npm-package.mjs
+package/scripts/npm-package-files-v1.1.1.txt

package/scripts/uninstall-native-host.mjs

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import {
+  getDefaultBridgePath,
+  getDefaultRuntimeRoot,
+  getNativeHostRegistrationTarget
+} from '../native-host/src/nativeHostPlatform.js';
+
+const require = createRequire(import.meta.url);
+const { uninstallManagedRuntime } = require('../native-host/src/runtimeInstaller.js');
+const scriptPath = fileURLToPath(import.meta.url);
+
+export function uninstallNativeHost(options = {}) {
+  const platform = options.platform || process.platform;
+  const browser = options.browser || 'chrome';
+  assertSupportedBrowser(browser);
+
+  const env = options.env || process.env;
+  const platformPath = platform === 'win32' ? path.win32 : path.posix;
+  const runtimePlatformPath = options.runtimeRoot && path.isAbsolute(options.runtimeRoot) ? path : platformPath;
+  const defaultInstallRoot = getDefaultRuntimeRoot({ platform, browser, env });
+  const installRoot = resolveForPlatform(options.runtimeRoot || defaultInstallRoot, platformPath);
+  const defaultBridgePath = getDefaultBridgePath({ platform, browser, env });
+  const bridgePath = resolveForPlatform(options.bridgePath || defaultBridgePath, platformPath);
+  const registrationTarget = getNativeHostRegistrationTarget({
+    platform,
+    browser,
+    env
+  });
+  const manifestPath = registrationTarget.manifestPath;
+
+  let runtimeResult;
+  if (options.keepRuntime) {
+    runtimeResult = {
+      ok: true,
+      action: fs.existsSync(installRoot) ? 'kept' : 'not-found',
+      runtimeRoot: installRoot,
+      removed: false,
+      kept: fs.existsSync(installRoot)
+    };
+  } else {
+    uninstallManagedRuntime({
+      runtimeRoot: installRoot,
+      defaultRuntimeRoot: defaultInstallRoot,
+      platformPath: runtimePlatformPath,
+      keepRuntime: true
+    });
+  }
+
+  const manifest = removeManifestPath(manifestPath);
+  const registry = registrationTarget.kind === 'registry'
+    ? removeRegistryValue(registrationTarget.registryKey)
+    : undefined;
+  const bridge = removeBridgePath(bridgePath);
+  if (!options.keepRuntime) {
+    runtimeResult = uninstallManagedRuntime({
+      runtimeRoot: installRoot,
+      defaultRuntimeRoot: defaultInstallRoot,
+      platformPath: runtimePlatformPath
+    });
+  }
+  const runtime = summarizeRuntimeResult(runtimeResult);
+
+  return {
+    ok: true,
+    status: deriveStatus({ manifest, runtime, keepRuntime: Boolean(options.keepRuntime) }),
+    keepRuntime: Boolean(options.keepRuntime),
+    browser: registrationTarget.browser,
+    manifest,
+    registry,
+    bridge,
+    runtime
+  };
+}
+
+export function formatUninstallNativeHostHuman(result) {
+  const lines = [];
+  if (result.manifest.removed) {
+    lines.push(`Removed Native Messaging host manifest: ${result.manifest.path}`);
+  } else {
+    lines.push(`Native Messaging host manifest not found: ${result.manifest.path}`);
+  }
+  if (result.registry) {
+    if (result.registry.removed) {
+      lines.push(`Removed Native Messaging host registry key: ${result.registry.key}`);
+    } else {
+      lines.push(`Native Messaging host registry key not found: ${result.registry.key}`);
+    }
+  }
+  if (result.bridge.action === 'kept') {
+    lines.push(`Kept Bridge executable: ${result.bridge.path}`);
+  } else if (result.bridge.removed) {
+    lines.push(`Removed Bridge executable: ${result.bridge.path}`);
+  } else {
+    lines.push(`Bridge executable not found: ${result.bridge.path}`);
+  }
+  if (result.runtime.action === 'not-found') {
+    lines.push(`Runtime root not found: ${result.runtime.root}`);
+  } else if (result.runtime.kept) {
+    lines.push(`Kept Runtime root: ${result.runtime.root}`);
+  } else if (result.runtime.removed) {
+    lines.push(`Removed Runtime root: ${result.runtime.root}`);
+  }
+  lines.push('Codex Overleaf native host uninstall finished.');
+  lines.push('Project mirrors and plugin Codex history under ~/.codex-overleaf are left intact.');
+  return `${lines.join('\n')}\n`;
+}
+
+function resolveForPlatform(targetPath, platformPathModule) {
+  if (platformPathModule.isAbsolute(targetPath)) {
+    return targetPath;
+  }
+  return platformPathModule.resolve(targetPath);
+}
+
+function removeManifestPath(target) {
+  let stat;
+  try {
+    stat = fs.lstatSync(target);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { path: target, action: 'not-found', removed: false };
+    }
+    throw error;
+  }
+
+  if (stat.isDirectory()) {
+    throw new Error(`Refusing to remove Native Messaging host manifest directory: ${target}`);
+  }
+
+  fs.rmSync(target, { force: true });
+  return { path: target, action: 'removed', removed: true };
+}
+
+function removeBridgePath(target) {
+  let stat;
+  try {
+    stat = fs.lstatSync(target);
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { path: target, action: 'not-found', removed: false };
+    }
+    throw error;
+  }
+
+  if (stat.isDirectory()) {
+    throw new Error(`Refusing to remove bridge directory: ${target}`);
+  }
+
+  fs.rmSync(target, { force: true });
+  return { path: target, action: 'removed', removed: true };
+}
+
+function removeRegistryValue(registryKey) {
+  if (deleteWindowsRegistryValue(registryKey)) {
+    return { key: registryKey, action: 'removed', removed: true };
+  }
+  return { key: registryKey, action: 'not-found', removed: false };
+}
+
+function deleteWindowsRegistryValue(registryKey) {
+  const registryCommand = getWindowsRegistryCommand();
+  const result = spawnSync(registryCommand.file, [
+    ...registryCommand.args,
+    'delete',
+    registryKey,
+    '/f'
+  ], {
+    encoding: 'utf8'
+  });
+  if (result.error) {
+    throw new Error(`Failed to run ${registryCommand.file}: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    const output = `${result.stderr || ''}\n${result.stdout || ''}`;
+    if (/unable to find the specified registry key or value/i.test(output)) {
+      return false;
+    }
+    throw new Error(result.stderr || result.stdout || `reg.exe delete failed with status ${result.status}`);
+  }
+  return true;
+}
+
+function getWindowsRegistryCommand() {
+  return {
+    file: process.env.CODEX_OVERLEAF_REG_EXE || 'reg.exe',
+    args: parseStringArrayEnv(process.env.CODEX_OVERLEAF_REG_EXE_ARGS_JSON)
+  };
+}
+
+function parseStringArrayEnv(value) {
+  if (!value) {
+    return [];
+  }
+  const parsed = JSON.parse(value);
+  if (!Array.isArray(parsed) || !parsed.every(item => typeof item === 'string')) {
+    throw new Error('CODEX_OVERLEAF_REG_EXE_ARGS_JSON must be a JSON array of strings');
+  }
+  return parsed;
+}
+
+function summarizeRuntimeResult(result) {
+  return {
+    root: result.runtimeRoot,
+    action: result.action,
+    removed: Boolean(result.removed),
+    kept: Boolean(result.kept),
+    markerManagedBy: result.marker && result.marker.managedBy,
+    markerVersion: result.marker && result.marker.version
+  };
+}
+
+function deriveStatus({ manifest, runtime, keepRuntime }) {
+  if (keepRuntime) {
+    return manifest.removed ? 'manifest-removed-runtime-kept' : 'manifest-not-found-runtime-kept';
+  }
+  if (manifest.action === 'not-found' && runtime.action === 'not-found') {
+    return 'not-found';
+  }
+  return 'uninstalled';
+}
+
+function assertSupportedBrowser(browser) {
+  if (!['auto', 'chrome', 'chromium'].includes(browser)) {
+    throw new Error('Usage: --browser must be one of chrome, chromium, or auto');
+  }
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--bridge-path') {
+      parsed.bridgePath = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--runtime-root') {
+      parsed.runtimeRoot = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--keep-runtime') {
+      parsed.keepRuntime = true;
+    } else if (arg === '--browser') {
+      parsed.browser = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--platform') {
+      parsed.platform = readOptionValue(argv, index, arg);
+      index += 1;
+    } else if (arg === '--force') {
+      parsed.force = true;
+    } else if (arg === '--json') {
+      parsed.json = true;
+    } else if (arg === '--help') {
+      parsed.help = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return parsed;
+}
+
+function readOptionValue(argv, index, optionName) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('--')) {
+    throw new Error(`Missing value for ${optionName}`);
+  }
+  return value;
+}
+
+function printUsage() {
+  console.log('Usage: uninstall-native-host.mjs [--browser chrome|chromium|auto] [--runtime-root <path>] [--keep-runtime] [--json]');
+}
+
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+      printUsage();
+      return;
+    }
+    const result = uninstallNativeHost(args);
+    if (args.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      process.stdout.write(formatUninstallNativeHostHuman(result));
+    }
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+if (path.resolve(process.argv[1] || '') === scriptPath) {
+  await main();
+}