codex-overleaf-link 1.1.1

package/native-host/src/debugLog.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  getCodexOverleafHome,
+  getNativeHostPlatform
+} = require('./nativeHostPlatform');
+
+const MAX_FIELD_LENGTH = 8000;
+
+function getDebugLogDir(options = {}) {
+  return getCodexOverleafHome(options);
+}
+
+function getDebugLogPath(options = {}) {
+  const platformPath = getNativeHostPlatform(options) === 'win32' ? path.win32 : path.posix;
+  return platformPath.join(getDebugLogDir(options), 'native-host.log');
+}
+
+function logDebug(event, detail = {}, options = {}) {
+  try {
+    const logDir = getDebugLogDir(options);
+    const logPath = getDebugLogPath(options);
+    fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(logPath, `${JSON.stringify({
+      time: new Date().toISOString(),
+      event,
+      detail: sanitize(detail)
+    })}\n`, 'utf8');
+  } catch {
+    // Debug logging must never break the native messaging host.
+  }
+}
+
+function truncateText(value, limit = MAX_FIELD_LENGTH) {
+  const text = String(value || '');
+  if (text.length <= limit) {
+    return text;
+  }
+  return `${text.slice(0, limit)}\n...[truncated ${text.length - limit} chars]`;
+}
+
+function sanitize(value) {
+  if (typeof value === 'string') {
+    return truncateText(value);
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 20).map(sanitize);
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (key === 'content') {
+      result[key] = `[${String(item || '').length} chars]`;
+    } else if (key === 'files' && Array.isArray(item)) {
+      result[key] = item.map(file => ({
+        path: file?.path,
+        contentLength: String(file?.content || '').length
+      }));
+    } else {
+      result[key] = sanitize(item);
+    }
+  }
+  return result;
+}
+
+module.exports = {
+  getDebugLogDir,
+  getDebugLogPath,
+  get LOG_PATH() {
+    return getDebugLogPath();
+  },
+  logDebug,
+  truncateText
+};

package/native-host/src/diffEngine.js

@@ -0,0 +1,247 @@
+'use strict';
+
+function computeLineDiff(oldText, newText, contextLines = 3) {
+  const oldLines = splitLines(oldText);
+  const newLines = splitLines(newText);
+
+  if (oldLines.join('\n') === newLines.join('\n')) {
+    return [];
+  }
+
+  const MAX_LINES = 5000;
+  const MAX_DIFF_PRODUCT = 4000000;
+
+  if (oldLines.length > MAX_LINES || newLines.length > MAX_LINES || oldLines.length * newLines.length > MAX_DIFF_PRODUCT) {
+    return buildTruncatedResult(oldLines.length, newLines.length);
+  }
+
+  const edits = myersDiff(oldLines, newLines);
+  if (edits === null) {
+    return buildTruncatedResult(oldLines.length, newLines.length);
+  }
+
+  return buildHunks(oldLines, newLines, edits, contextLines);
+}
+
+function buildTruncatedResult(oldCount, newCount) {
+  return [{
+    startA: 1,
+    startB: 1,
+    truncated: true,
+    lines: [{ type: 'context', text: `文件改动较大（${oldCount} → ${newCount} 行），请在 Overleaf 中查看完整差异。` }]
+  }];
+}
+
+function splitLines(text) {
+  const lines = String(text || '').split('\n');
+  if (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  return lines;
+}
+
+function myersDiff(oldLines, newLines) {
+  const n = oldLines.length;
+  const m = newLines.length;
+  const max = n + m;
+
+  if (max === 0) {
+    return [];
+  }
+
+  const vSize = 2 * max + 1;
+  let v = new Array(vSize).fill(0);
+  const trace = [];
+
+  const MAX_EDIT_DISTANCE = 1500;
+
+  for (let d = 0; d <= max; d++) {
+    if (d > MAX_EDIT_DISTANCE) {
+      return null;
+    }
+    trace.push([...v]);
+    const newV = [...v];
+    for (let k = -d; k <= d; k += 2) {
+      const kIndex = k + max;
+      let x;
+      if (k === -d || (k !== d && v[kIndex - 1] < v[kIndex + 1])) {
+        x = v[kIndex + 1];
+      } else {
+        x = v[kIndex - 1] + 1;
+      }
+      let y = x - k;
+
+      while (x < n && y < m && oldLines[x] === newLines[y]) {
+        x++;
+        y++;
+      }
+
+      newV[kIndex] = x;
+
+      if (x >= n && y >= m) {
+        trace[d] = newV;
+        return backtrack(trace, oldLines, newLines, d, max);
+      }
+    }
+    v = newV;
+  }
+
+  return buildFallbackEdits(oldLines, newLines);
+}
+
+function backtrack(trace, oldLines, newLines, finalD, max) {
+  const edits = [];
+  let x = oldLines.length;
+  let y = newLines.length;
+
+  for (let d = finalD; d >= 0; d--) {
+    const k = x - y;
+
+    let prevK, prevX, prevY;
+    if (d === 0) {
+      prevX = 0;
+      prevY = 0;
+    } else {
+      const prevVState = trace[d];
+      if (k === -d || (k !== d && prevVState[k - 1 + max] < prevVState[k + 1 + max])) {
+        prevK = k + 1;
+      } else {
+        prevK = k - 1;
+      }
+      prevX = prevVState[prevK + max];
+      prevY = prevX - prevK;
+    }
+
+    // Snake: diagonal moves after the edit
+    const midX = d > 0 ? (prevK < k ? prevX + 1 : prevX) : 0;
+    const midY = d > 0 ? (prevK > k ? prevY + 1 : prevY) : 0;
+
+    while (x > midX && y > midY) {
+      x--;
+      y--;
+      edits.unshift({ type: 'equal', oldIndex: x, newIndex: y });
+    }
+
+    // The edit move itself
+    if (d > 0) {
+      if (prevK < k) {
+        // Moved right: deletion
+        x--;
+        edits.unshift({ type: 'remove', oldIndex: x });
+      } else {
+        // Moved down: insertion
+        y--;
+        edits.unshift({ type: 'add', newIndex: y });
+      }
+    }
+  }
+
+  // Initial diagonal at d=0
+  while (x > 0 && y > 0) {
+    x--;
+    y--;
+    edits.unshift({ type: 'equal', oldIndex: x, newIndex: y });
+  }
+
+  return edits;
+}
+
+function buildFallbackEdits(oldLines, newLines) {
+  const edits = [];
+  for (let i = 0; i < oldLines.length; i++) {
+    edits.push({ type: 'remove', oldIndex: i });
+  }
+  for (let i = 0; i < newLines.length; i++) {
+    edits.push({ type: 'add', newIndex: i });
+  }
+  return edits;
+}
+
+function buildHunks(oldLines, newLines, edits, contextLines) {
+  const changes = edits.filter(e => e.type !== 'equal');
+  if (!changes.length) {
+    return [];
+  }
+
+  const changeIndices = [];
+  for (let i = 0; i < edits.length; i++) {
+    if (edits[i].type !== 'equal') {
+      changeIndices.push(i);
+    }
+  }
+
+  const groups = [];
+  let currentGroup = [changeIndices[0]];
+
+  for (let i = 1; i < changeIndices.length; i++) {
+    const gap = changeIndices[i] - changeIndices[i - 1] - 1;
+    if (gap <= contextLines * 2) {
+      currentGroup.push(changeIndices[i]);
+    } else {
+      groups.push(currentGroup);
+      currentGroup = [changeIndices[i]];
+    }
+  }
+  groups.push(currentGroup);
+
+  const hunks = [];
+  for (const group of groups) {
+    const firstIdx = Math.max(0, group[0] - contextLines);
+    const lastIdx = Math.min(edits.length - 1, group[group.length - 1] + contextLines);
+    const hunkEdits = edits.slice(firstIdx, lastIdx + 1);
+
+    const lines = [];
+    let startA = -1;
+    let startB = -1;
+
+    for (const edit of hunkEdits) {
+      if (edit.type === 'equal') {
+        if (startA === -1) {
+          startA = edit.oldIndex;
+          startB = edit.newIndex;
+        }
+        lines.push({ type: 'context', text: oldLines[edit.oldIndex] });
+      } else if (edit.type === 'remove') {
+        if (startA === -1) {
+          startA = edit.oldIndex;
+          startB = findNewIndex(edits, firstIdx, edit.oldIndex);
+        }
+        lines.push({ type: 'remove', text: oldLines[edit.oldIndex] });
+      } else if (edit.type === 'add') {
+        if (startA === -1) {
+          startA = findOldIndex(edits, firstIdx, edit.newIndex);
+          startB = edit.newIndex;
+        }
+        lines.push({ type: 'add', text: newLines[edit.newIndex] });
+      }
+    }
+
+    hunks.push({
+      startA: startA >= 0 ? startA + 1 : 1,
+      startB: startB >= 0 ? startB + 1 : 1,
+      lines
+    });
+  }
+
+  return hunks;
+}
+
+function findNewIndex(edits, startFrom, oldIndex) {
+  for (let i = startFrom; i < edits.length; i++) {
+    if (edits[i].newIndex !== undefined) {
+      return edits[i].newIndex;
+    }
+  }
+  return 0;
+}
+
+function findOldIndex(edits, startFrom, newIndex) {
+  for (let i = startFrom; i < edits.length; i++) {
+    if (edits[i].oldIndex !== undefined) {
+      return edits[i].oldIndex;
+    }
+  }
+  return 0;
+}
+
+module.exports = { computeLineDiff };

package/native-host/src/index.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+'use strict';
+
+const { decodeFrames, encodeMessage } = require('./nativeMessaging');
+const { logDebug } = require('./debugLog');
+const { handleRequest } = require('./taskRunner');
+const { buildNativeRuntimeEnv, summarizeNativeEnvironment } = require('./nativeEnvironment');
+
+let buffered = Buffer.alloc(0);
+const runtimeEnv = buildNativeRuntimeEnv(process.env);
+Object.assign(process.env, runtimeEnv);
+logDebug('environment.ready', summarizeNativeEnvironment(runtimeEnv));
+
+process.stdin.on('data', chunk => {
+  logDebug('stdin.data', { bytes: chunk.length, bufferedBytes: buffered.length });
+  buffered = Buffer.concat([buffered, chunk]);
+
+  let decoded;
+  try {
+    decoded = decodeFrames(buffered);
+  } catch (error) {
+    writeResponse({
+      ok: false,
+      error: {
+        code: 'invalid_native_message',
+        message: error.message
+      }
+    });
+    buffered = Buffer.alloc(0);
+    return;
+  }
+
+  buffered = decoded.remainder;
+  for (const message of decoded.messages) {
+    handleDecodedMessage(message);
+  }
+});
+
+async function handleDecodedMessage(message) {
+  try {
+    logDebug('request.received', summarizeRequest(message));
+    const response = await handleRequest(message, runtimeEnv, event => {
+      writeResponse({
+        id: message?.id,
+        ok: true,
+        event
+      });
+    });
+    logDebug('response.ready', summarizeResponse(response));
+    writeResponse(response);
+  } catch (error) {
+    const response = {
+      id: message?.id,
+      ok: false,
+      error: {
+        code: 'internal_error',
+        message: error.message
+      }
+    };
+    logDebug('response.internal_error', summarizeResponse(response));
+    writeResponse(response);
+  }
+}
+
+process.stdin.on('error', error => {
+  logDebug('stdin.error', { message: error.message });
+  console.error(`stdin error: ${error.message}`);
+});
+
+process.on('uncaughtException', error => {
+  logDebug('process.uncaught_exception', {
+    message: error.message,
+    stack: error.stack
+  });
+  process.exit(1);
+});
+
+process.on('unhandledRejection', reason => {
+  logDebug('process.unhandled_rejection', {
+    message: reason?.message || String(reason),
+    stack: reason?.stack
+  });
+  process.exit(1);
+});
+
+function writeResponse(response) {
+  const frame = encodeMessage(response);
+  logDebug('stdout.write', { bytes: frame.length, ok: response?.ok, code: response?.error?.code });
+  process.stdout.write(frame);
+}
+
+function summarizeRequest(message) {
+  const params = message?.params || {};
+  return {
+    id: message?.id,
+    method: message?.method,
+    mode: params.mode,
+    model: params.model,
+    reasoningEffort: params.reasoningEffort,
+    taskLength: String(params.task || '').length,
+    reviewingOk: params.reviewing?.ok,
+    checkpointOk: params.checkpoint?.ok,
+    activePath: params.project?.activePath,
+    fileCount: Array.isArray(params.project?.files) ? params.project.files.length : 0,
+    fileSummary: summarizeProjectFiles(params.project?.files)
+  };
+}
+
+function summarizeProjectFiles(files) {
+  return (Array.isArray(files) ? files : []).slice(0, 50).map(file => ({
+    path: file?.path,
+    kind: file?.kind || (file?.contentBase64 ? 'binary' : 'text'),
+    size: Number(file?.size || file?.byteLength || 0) || stringByteLength(file?.content)
+  }));
+}
+
+function stringByteLength(value) {
+  return typeof value === 'string' ? Buffer.byteLength(value, 'utf8') : 0;
+}
+
+function summarizeResponse(response) {
+  return {
+    id: response?.id,
+    ok: response?.ok,
+    code: response?.error?.code,
+    message: response?.error?.message,
+    status: response?.result?.status,
+    operationCount: Array.isArray(response?.result?.operations) ? response.result.operations.length : 0,
+    hasDeletePlan: Boolean(response?.result?.deletePlan),
+    hasPlanId: Boolean(response?.result?.planId)
+  };
+}

package/native-host/src/launcher.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const DEFAULT_POSIX_PATH_SEGMENTS = [
+  '/Library/TeX/texbin',
+  '/opt/homebrew/bin',
+  '/usr/local/bin',
+  '/usr/bin',
+  '/bin',
+  '/usr/sbin',
+  '/sbin'
+];
+
+function buildLauncher({ platform = process.platform, nodePath, bridgeEntryPath, agentPath, defaultPathSegments }) {
+  if (platform === 'win32') {
+    return buildWindowsLauncherScript({ nodePath, bridgeEntryPath, agentPath });
+  }
+  if (platform === 'darwin' || platform === 'linux') {
+    return buildLauncherScript({ nodePath, bridgeEntryPath, agentPath, defaultPathSegments });
+  }
+  throw new Error(`Unsupported launcher platform: ${platform}`);
+}
+
+function buildLauncherScript({ nodePath, bridgeEntryPath, agentPath, defaultPathSegments = DEFAULT_POSIX_PATH_SEGMENTS }) {
+  const launcherPath = defaultPathSegments.join(':');
+  return [
+    '#!/bin/sh',
+    'set -eu',
+    'HOME_DIR="${HOME:-/tmp}"',
+    'LOG_DIR="$HOME_DIR/.codex-overleaf"',
+    'mkdir -p "$LOG_DIR" 2>/dev/null || true',
+    '{',
+    '  printf \'%s launcher.start pid=%s ppid=%s home=%s path=%s\\n\' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$$" "${PPID:-}" "$HOME_DIR" "${PATH:-}"',
+    '  printf \'%s launcher.node=%s\\n\' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "' + escapeShellSingleQuoted(nodePath) + '"',
+    '} >> "$LOG_DIR/native-host-launcher.log" 2>/dev/null || true',
+    `export PATH="${escapeDoubleQuoted(launcherPath)}:\${PATH:-}"`,
+    `export CODEX_OVERLEAF_AGENT_FILE=${shellSingleQuoted(nodePath)}`,
+    `export CODEX_OVERLEAF_AGENT_ARGS_JSON=${shellSingleQuoted(JSON.stringify([agentPath]))}`,
+    `exec "${escapeDoubleQuoted(nodePath)}" "${escapeDoubleQuoted(bridgeEntryPath)}"`,
+    ''
+  ].join('\n');
+}
+
+function buildWindowsLauncherScript({ nodePath, bridgeEntryPath, agentPath }) {
+  return [
+    '@echo off',
+    'setlocal',
+    `set "CODEX_OVERLEAF_AGENT_FILE=${escapeBatchSetValue(nodePath)}"`,
+    `set CODEX_OVERLEAF_AGENT_ARGS_JSON=${escapeBatchRawSetValue(JSON.stringify([agentPath]))}`,
+    `"${escapeBatchCommandArg(nodePath)}" "${escapeBatchCommandArg(bridgeEntryPath)}"`,
+    ''
+  ].join('\r\n');
+}
+
+function escapeDoubleQuoted(value) {
+  return String(value).replace(/(["\\$`])/g, '\\$1');
+}
+
+function escapeShellSingleQuoted(value) {
+  return String(value).replace(/'/g, "'\\''");
+}
+
+function shellSingleQuoted(value) {
+  return `'${escapeShellSingleQuoted(value)}'`;
+}
+
+function escapeBatchSetValue(value) {
+  return String(value).replace(/%/g, '%%').replace(/"/g, '""');
+}
+
+function escapeBatchCommandArg(value) {
+  return String(value).replace(/%/g, '%%').replace(/"/g, '""');
+}
+
+function escapeBatchRawSetValue(value) {
+  return String(value).replace(/%/g, '%%').replace(/[\r\n]/g, '');
+}
+
+module.exports = {
+  buildLauncher,
+  buildLauncherScript
+};