codex-overleaf-link 1.1.1

package/native-host/src/nativeEnvironment.js

@@ -0,0 +1,315 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const TOOL_NAMES = ['codex', 'latexmk', 'pdflatex', 'xelatex', 'lualatex', 'bibtex', 'biber'];
+const LATEX_TOOL_NAMES = ['latexmk', 'pdflatex', 'xelatex', 'lualatex', 'bibtex', 'biber'];
+const SUPPORTED_PLATFORMS = new Set(['darwin', 'linux', 'win32']);
+
+function buildNativeRuntimeEnv(baseEnv = process.env, options = {}) {
+  const env = { ...baseEnv };
+  const runtimeOptions = { ...options, platform: getNativeRuntimePlatform(options) };
+  const loginShellEnv = options.readLoginShellEnv
+    ? options.readLoginShellEnv(baseEnv, runtimeOptions)
+    : readLoginShellEnv(baseEnv, runtimeOptions);
+  const defaultPathSegments = Object.hasOwn(options, 'defaultPathSegments')
+    ? options.defaultPathSegments
+    : getDefaultPathSegments(baseEnv, runtimeOptions);
+  const pathSegments = [
+    ...getPathValues(loginShellEnv, runtimeOptions),
+    ...getPathValues(baseEnv, runtimeOptions),
+    ...defaultPathSegments
+  ];
+
+  env.PATH = mergePathSegments(pathSegments, runtimeOptions);
+  normalizePathKeys(env, env.PATH, runtimeOptions);
+  env.CODEX_OVERLEAF_ENV_READY = '1';
+  env.CODEX_OVERLEAF_PLATFORM = runtimeOptions.platform;
+
+  for (const tool of TOOL_NAMES) {
+    env[getToolEnvName(tool)] = resolveExecutable(tool, env.PATH, { ...runtimeOptions, env }) || '';
+  }
+
+  return env;
+}
+
+function readLoginShellEnv(baseEnv = process.env, options = {}) {
+  if (getNativeRuntimePlatform(options) === 'win32') {
+    return null;
+  }
+  if (baseEnv.CODEX_OVERLEAF_DISABLE_SHELL_ENV === '1') {
+    return null;
+  }
+
+  const shell = selectLoginShell(baseEnv, options);
+  if (!shell) {
+    return null;
+  }
+
+  const command = [
+    'printf "__CODEX_OVERLEAF_ENV_START__\\n"',
+    'printf "PATH=%s\\n" "$PATH"',
+    'printf "__CODEX_OVERLEAF_ENV_END__\\n"'
+  ].join('; ');
+  const args = shouldUseLoginFlag(shell) ? ['-l', '-i', '-c', command] : ['-c', command];
+  const result = spawnSync(shell, args, {
+    env: {
+      ...baseEnv,
+      PATH: baseEnv.PATH || '/usr/bin:/bin:/usr/sbin:/sbin'
+    },
+    encoding: 'utf8',
+    timeout: 1500,
+    maxBuffer: 64 * 1024
+  });
+
+  if (result.error || result.status !== 0) {
+    return null;
+  }
+
+  return parseMarkedShellEnv(result.stdout || '');
+}
+
+function parseMarkedShellEnv(output) {
+  const match = String(output).match(/__CODEX_OVERLEAF_ENV_START__\n([\s\S]*?)\n__CODEX_OVERLEAF_ENV_END__/);
+  if (!match) {
+    return null;
+  }
+
+  const env = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const index = line.indexOf('=');
+    if (index <= 0) {
+      continue;
+    }
+    env[line.slice(0, index)] = line.slice(index + 1);
+  }
+  return env;
+}
+
+function selectLoginShell(env = process.env, options = {}) {
+  if (getNativeRuntimePlatform(options) === 'win32') {
+    return '';
+  }
+
+  const candidates = [
+    env.SHELL,
+    '/bin/zsh',
+    '/bin/bash',
+    '/bin/sh'
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (!path.isAbsolute(candidate)) {
+      continue;
+    }
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      return candidate;
+    } catch {
+      // Try the next common shell.
+    }
+  }
+  return '';
+}
+
+function shouldUseLoginFlag(shell) {
+  return ['zsh', 'bash'].includes(path.basename(shell));
+}
+
+function getDefaultPathSegments(env = process.env, options = {}) {
+  const platform = getNativeRuntimePlatform(options);
+  const platformPath = platform === 'win32' ? path.win32 : path.posix;
+  const home = env.HOME || os.homedir();
+  const commonSegments = [
+    path.dirname(process.execPath),
+    platformPath.join(home, '.local/bin'),
+    platformPath.join(home, '.npm-global/bin'),
+    platformPath.join(home, 'bin'),
+    '/usr/local/bin',
+    '/usr/local/sbin',
+    '/usr/bin',
+    '/bin',
+    '/usr/sbin',
+    '/sbin'
+  ];
+  if (platform === 'linux') {
+    return [
+      ...commonSegments.slice(0, 4),
+      '/usr/local/texlive/2026/bin/x86_64-linux',
+      '/usr/local/texlive/2025/bin/x86_64-linux',
+      '/usr/local/texlive/bin/x86_64-linux',
+      ...commonSegments.slice(4)
+    ];
+  }
+
+  if (platform === 'win32') {
+    return commonSegments;
+  }
+
+  return [
+    ...commonSegments.slice(0, 4),
+    '/Library/TeX/texbin',
+    '/opt/homebrew/bin',
+    '/opt/homebrew/sbin',
+    ...commonSegments.slice(4)
+  ];
+}
+
+function mergePathSegments(values, options = {}) {
+  const delimiter = getPathDelimiter(options);
+  const seen = new Set();
+  const merged = [];
+  for (const value of values) {
+    for (const segment of splitPathValue(value, delimiter)) {
+      const clean = segment.trim();
+      if (!clean || seen.has(clean)) {
+        continue;
+      }
+      seen.add(clean);
+      merged.push(clean);
+    }
+  }
+  return merged.join(delimiter);
+}
+
+function resolveExecutable(name, pathValue, options = {}) {
+  const delimiter = getPathDelimiter(options);
+  const executableNames = getExecutableCandidates(name, options);
+  for (const directory of splitPathValue(pathValue, delimiter)) {
+    if (!directory) {
+      continue;
+    }
+    for (const executableName of executableNames) {
+      const candidate = path.join(directory, executableName);
+      try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+      } catch {
+        // Keep searching PATH.
+      }
+    }
+  }
+  return '';
+}
+
+function summarizeNativeEnvironment(env = process.env, options = {}) {
+  const runtimeOptions = { ...options, platform: getNativeRuntimePlatform({ ...options, env }) };
+  const availableLatex = LATEX_TOOL_NAMES.filter(tool => Boolean(env[getToolEnvName(tool)]));
+  const missingLatex = LATEX_TOOL_NAMES.filter(tool => !env[getToolEnvName(tool)]);
+  return {
+    codex: {
+      ok: Boolean(env.CODEX_OVERLEAF_CODEX_PATH),
+      path: env.CODEX_OVERLEAF_CODEX_PATH || ''
+    },
+    latex: {
+      ok: availableLatex.length > 0,
+      available: availableLatex,
+      missing: missingLatex,
+      tools: Object.fromEntries(LATEX_TOOL_NAMES.map(tool => [tool, env[getToolEnvName(tool)] || '']))
+    },
+    pathPreview: splitPathValue(env.PATH, getPathDelimiter(runtimeOptions)).filter(Boolean).slice(0, 12)
+  };
+}
+
+function getToolEnvName(tool) {
+  return `CODEX_OVERLEAF_${String(tool).replace(/[^a-zA-Z0-9]/g, '_').toUpperCase()}_PATH`;
+}
+
+function getNativeRuntimePlatform(options = {}) {
+  return validateNativeRuntimePlatform(options.platform)
+    || validateNativeRuntimePlatform(options.env?.CODEX_OVERLEAF_PLATFORM)
+    || validateNativeRuntimePlatform(process.platform)
+    || 'linux';
+}
+
+function validateNativeRuntimePlatform(platform) {
+  return SUPPORTED_PLATFORMS.has(platform) ? platform : '';
+}
+
+function getPathDelimiter(options = {}) {
+  if (options.delimiter) {
+    return options.delimiter;
+  }
+  return getNativeRuntimePlatform(options) === 'win32' ? ';' : ':';
+}
+
+function getPathValues(env, options = {}) {
+  if (!env) {
+    return [];
+  }
+  if (getNativeRuntimePlatform(options) !== 'win32') {
+    return [env.PATH];
+  }
+
+  const values = [];
+  if (Object.hasOwn(env, 'Path')) {
+    values.push(env.Path);
+  }
+  if (Object.hasOwn(env, 'PATH')) {
+    values.push(env.PATH);
+  }
+  if (!values.length) {
+    for (const [key, value] of Object.entries(env)) {
+      if (key.toLowerCase() === 'path') {
+        values.push(value);
+      }
+    }
+  }
+  return values;
+}
+
+function splitPathValue(value, delimiter) {
+  return String(value || '').split(delimiter);
+}
+
+function getExecutableCandidates(name, options = {}) {
+  const candidates = [name];
+  if (getNativeRuntimePlatform(options) !== 'win32' || path.extname(name)) {
+    return candidates;
+  }
+
+  for (const extension of getWindowsPathExtensions(options.env || process.env)) {
+    candidates.push(`${name}${extension}`);
+  }
+  return [...new Set(candidates)];
+}
+
+function getWindowsPathExtensions(env) {
+  const raw = env.PATHEXT || '.COM;.EXE;.BAT;.CMD';
+  const extensions = [];
+  for (const extension of String(raw).split(';')) {
+    const clean = extension.trim();
+    if (!clean) {
+      continue;
+    }
+    extensions.push(clean.toLowerCase(), clean.toUpperCase(), clean);
+  }
+  return [...new Set(extensions)];
+}
+
+function normalizePathKeys(env, pathValue, options = {}) {
+  if (getNativeRuntimePlatform(options) !== 'win32') {
+    return;
+  }
+
+  for (const key of Object.keys(env)) {
+    if (key.toLowerCase() === 'path') {
+      delete env[key];
+    }
+  }
+  env.PATH = pathValue;
+}
+
+module.exports = {
+  buildNativeRuntimeEnv,
+  getDefaultPathSegments,
+  getNativeRuntimePlatform,
+  mergePathSegments,
+  parseMarkedShellEnv,
+  readLoginShellEnv,
+  resolveExecutable,
+  summarizeNativeEnvironment
+};

package/native-host/src/nativeHostPlatform.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const os = require('node:os');
+const path = require('node:path');
+const {
+  getNativeHostManifestPath,
+  getWindowsRegistryMetadata
+} = require('./manifest');
+
+function getNativeHostPlatform(options = {}) {
+  return options.platform || process.platform;
+}
+
+function getCodexOverleafHome(options = {}) {
+  const platform = getNativeHostPlatform(options);
+  if (platform === 'win32') {
+    return path.win32.join(getWindowsLocalAppData(options), 'CodexOverleaf');
+  }
+  if (platform === 'darwin' || platform === 'linux') {
+    return path.posix.join(getHomeDir(options), '.codex-overleaf');
+  }
+  throwUnsupportedPlatform(platform);
+}
+
+function getDefaultRuntimeRoot(options = {}) {
+  const platformPath = getPathModule(options);
+  return platformPath.join(getCodexOverleafHome(options), 'native-host-runtime');
+}
+
+function getDefaultBridgePath(options = {}) {
+  const platformPath = getPathModule(options);
+  const bridgeName = getNativeHostPlatform(options) === 'win32'
+    ? 'codex-overleaf-bridge.cmd'
+    : 'codex-overleaf-bridge';
+  return platformPath.join(getCodexOverleafHome(options), bridgeName);
+}
+
+function getNativeHostRegistrationTarget(options = {}) {
+  const platform = getNativeHostPlatform(options);
+  const browser = getNativeHostBrowser(options);
+  const manifestPath = getNativeHostManifestPath({ ...options, platform, browser });
+
+  if (platform === 'darwin' || platform === 'linux') {
+    return {
+      kind: 'file',
+      browser,
+      manifestPath
+    };
+  }
+
+  if (platform === 'win32') {
+    const metadata = getWindowsRegistryMetadata({ ...options, browser });
+    return {
+      kind: 'registry',
+      browser: metadata.browser,
+      root: metadata.root,
+      registryKey: metadata.registryKey,
+      manifestPath: metadata.manifestPath
+    };
+  }
+
+  throwUnsupportedPlatform(platform);
+}
+
+function getNativeManifestPath(options = {}) {
+  const platform = getNativeHostPlatform(options);
+  const browser = getNativeHostBrowser(options);
+  return getNativeHostManifestPath({ ...options, platform, browser });
+}
+
+function getNativeHostBrowser(options) {
+  const browser = options.browser || 'chrome';
+  return browser === 'auto' ? 'chrome' : browser;
+}
+
+function getHomeDir(options) {
+  const env = options.env || process.env;
+  if (getNativeHostPlatform(options) === 'win32') {
+    return options.homeDir || env.USERPROFILE || env.HOME || os.homedir();
+  }
+  return options.homeDir || env.HOME || env.USERPROFILE || os.homedir();
+}
+
+function getWindowsLocalAppData(options) {
+  const env = options.env || process.env;
+  if (env.LOCALAPPDATA) {
+    return env.LOCALAPPDATA;
+  }
+  return path.win32.join(getHomeDir(options), 'AppData', 'Local');
+}
+
+function getPathModule(options) {
+  return getNativeHostPlatform(options) === 'win32' ? path.win32 : path.posix;
+}
+
+function throwUnsupportedPlatform(platform) {
+  throw new Error(`Unsupported native host platform: ${platform}`);
+}
+
+function throwUnsupportedBrowser(platform, browser) {
+  throw new Error(`Unsupported native host browser for ${platform}: ${browser}`);
+}
+
+module.exports = {
+  getCodexOverleafHome,
+  getDefaultBridgePath,
+  getDefaultRuntimeRoot,
+  getHomeDir,
+  getNativeHostPlatform,
+  getNativeHostRegistrationTarget,
+  getNativeManifestPath
+};

package/native-host/src/nativeMessaging.js

@@ -0,0 +1,60 @@
+'use strict';
+
+const MAX_NATIVE_OUTPUT_MESSAGE_BYTES = 1024 * 1024;
+const MAX_NATIVE_INPUT_MESSAGE_BYTES = 128 * 1024 * 1024;
+const MAX_NATIVE_BUFFER_BYTES = 160 * 1024 * 1024;
+
+function encodeMessage(message) {
+  const payload = Buffer.from(JSON.stringify(message), 'utf8');
+  if (payload.length > MAX_NATIVE_OUTPUT_MESSAGE_BYTES) {
+    throw new Error(`Native message frame is too large: ${payload.length} bytes`);
+  }
+  const frame = Buffer.alloc(4 + payload.length);
+  frame.writeUInt32LE(payload.length, 0);
+  payload.copy(frame, 4);
+  return frame;
+}
+
+function decodeFrames(buffer) {
+  if (buffer.length > MAX_NATIVE_BUFFER_BYTES) {
+    throw new Error(`Native message buffer is too large: ${buffer.length} bytes`);
+  }
+
+  const messages = [];
+  let offset = 0;
+
+  while (buffer.length - offset >= 4) {
+    const length = buffer.readUInt32LE(offset);
+    if (length > MAX_NATIVE_INPUT_MESSAGE_BYTES) {
+      throw new Error(`Native message frame is too large: ${length} bytes`);
+    }
+    const frameStart = offset + 4;
+    const frameEnd = frameStart + length;
+
+    if (buffer.length < frameEnd) {
+      break;
+    }
+
+    const payload = buffer.subarray(frameStart, frameEnd).toString('utf8');
+    try {
+      messages.push(JSON.parse(payload));
+    } catch (error) {
+      throw new Error(`Invalid JSON in native message: ${error.message}`);
+    }
+    offset = frameEnd;
+  }
+
+  return {
+    messages,
+    remainder: buffer.subarray(offset)
+  };
+}
+
+module.exports = {
+  MAX_NATIVE_BUFFER_BYTES,
+  MAX_NATIVE_INPUT_MESSAGE_BYTES,
+  MAX_NATIVE_MESSAGE_BYTES: MAX_NATIVE_OUTPUT_MESSAGE_BYTES,
+  MAX_NATIVE_OUTPUT_MESSAGE_BYTES,
+  decodeFrames,
+  encodeMessage
+};