codex-overleaf-link 1.1.1

package/native-host/src/textPatch.js

@@ -0,0 +1,287 @@
+'use strict';
+
+function computeTextPatches(oldText, newText) {
+  const oldValue = String(oldText ?? '');
+  const newValue = String(newText ?? '');
+  if (oldValue === newValue) {
+    return [];
+  }
+
+  const linePatches = computeLineAnchoredPatches(oldValue, newValue);
+  if (linePatches.length) {
+    return linePatches;
+  }
+
+  return [computeSingleTextPatch(oldValue, newValue)];
+}
+
+function computeSingleTextPatch(oldValue, newValue, offset = 0) {
+  let prefixLength = 0;
+  const sharedLength = Math.min(oldValue.length, newValue.length);
+  while (prefixLength < sharedLength && oldValue[prefixLength] === newValue[prefixLength]) {
+    prefixLength += 1;
+  }
+
+  let oldEnd = oldValue.length;
+  let newEnd = newValue.length;
+  while (
+    oldEnd > prefixLength
+    && newEnd > prefixLength
+    && oldValue[oldEnd - 1] === newValue[newEnd - 1]
+  ) {
+    oldEnd -= 1;
+    newEnd -= 1;
+  }
+
+  return {
+    from: offset + prefixLength,
+    to: offset + oldEnd,
+    expected: oldValue.slice(prefixLength, oldEnd),
+    insert: newValue.slice(prefixLength, newEnd)
+  };
+}
+
+function computeLineAnchoredPatches(oldValue, newValue) {
+  const oldParts = splitTextParts(oldValue);
+  const newParts = splitTextParts(newValue);
+  const MAX_PARTS = 5000;
+  const MAX_PRODUCT = 4000000;
+
+  if (
+    oldParts.length === 0
+    || newParts.length === 0
+    || oldParts.length > MAX_PARTS
+    || newParts.length > MAX_PARTS
+    || oldParts.length * newParts.length > MAX_PRODUCT
+  ) {
+    return [];
+  }
+
+  const edits = computePartEdits(oldParts, newParts);
+  const patches = [];
+  let oldOffset = 0;
+  let newOffset = 0;
+  let group = null;
+
+  for (const edit of edits) {
+    if (edit.type === 'equal') {
+      flushGroup();
+      oldOffset += oldParts[edit.oldIndex].length;
+      newOffset += newParts[edit.newIndex].length;
+      continue;
+    }
+
+    if (!group) {
+      group = {
+        oldStart: oldOffset,
+        oldText: '',
+        newText: ''
+      };
+    }
+
+    if (edit.type === 'remove') {
+      const text = oldParts[edit.oldIndex];
+      group.oldText += text;
+      oldOffset += text.length;
+    } else if (edit.type === 'add') {
+      const text = newParts[edit.newIndex];
+      group.newText += text;
+      newOffset += text.length;
+    }
+  }
+  flushGroup();
+
+  return patches;
+
+  function flushGroup() {
+    if (!group) {
+      return;
+    }
+    if (group.oldText !== group.newText) {
+      const tokenPatches = computeTokenAnchoredPatches(group.oldText, group.newText, group.oldStart);
+      if (tokenPatches) {
+        patches.push(...tokenPatches);
+      } else {
+        patches.push(computeSingleTextPatch(group.oldText, group.newText, group.oldStart));
+      }
+    }
+    group = null;
+  }
+}
+
+function computeTokenAnchoredPatches(oldValue, newValue, offset = 0) {
+  const MAX_GROUP_CHARS = 20000;
+  const MAX_TOKENS = 3000;
+  const MAX_PRODUCT = 4000000;
+  const MAX_PATCHES = 80;
+
+  if (
+    oldValue.length > MAX_GROUP_CHARS
+    || newValue.length > MAX_GROUP_CHARS
+  ) {
+    return null;
+  }
+
+  const oldTokens = splitTextTokens(oldValue);
+  const newTokens = splitTextTokens(newValue);
+  if (
+    oldTokens.length === 0
+    || newTokens.length === 0
+    || oldTokens.length > MAX_TOKENS
+    || newTokens.length > MAX_TOKENS
+    || oldTokens.length * newTokens.length > MAX_PRODUCT
+  ) {
+    return null;
+  }
+
+  const edits = computePartEdits(
+    oldTokens.map(token => token.text),
+    newTokens.map(token => token.text)
+  );
+  const patches = [];
+  let oldOffset = 0;
+  let newOffset = 0;
+  let group = null;
+
+  for (const edit of edits) {
+    if (edit.type === 'equal') {
+      flushGroup();
+      oldOffset = oldTokens[edit.oldIndex].end;
+      newOffset = newTokens[edit.newIndex].end;
+      continue;
+    }
+
+    if (!group) {
+      group = {
+        oldStart: oldOffset,
+        newStart: newOffset,
+        oldEnd: oldOffset,
+        newEnd: newOffset
+      };
+    }
+
+    if (edit.type === 'remove') {
+      group.oldEnd = oldTokens[edit.oldIndex].end;
+      oldOffset = group.oldEnd;
+    } else if (edit.type === 'add') {
+      group.newEnd = newTokens[edit.newIndex].end;
+      newOffset = group.newEnd;
+    }
+  }
+  flushGroup();
+
+  if (!patches.length || patches.length > MAX_PATCHES) {
+    return null;
+  }
+  return patches;
+
+  function flushGroup() {
+    if (!group) {
+      return;
+    }
+    const oldText = oldValue.slice(group.oldStart, group.oldEnd);
+    const newText = newValue.slice(group.newStart, group.newEnd);
+    if (oldText !== newText) {
+      patches.push({
+        from: offset + group.oldStart,
+        to: offset + group.oldEnd,
+        expected: oldText,
+        insert: newText
+      });
+    }
+    group = null;
+  }
+}
+
+function splitTextTokens(text) {
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    const start = index;
+    const char = text[index];
+    if (/\s/.test(char)) {
+      index += 1;
+      while (index < text.length && /\s/.test(text[index])) {
+        index += 1;
+      }
+    } else if (char === '\\') {
+      index += 1;
+      if (index < text.length && /[A-Za-z@]/.test(text[index])) {
+        while (index < text.length && /[A-Za-z@]/.test(text[index])) {
+          index += 1;
+        }
+      } else if (index < text.length) {
+        index += 1;
+      }
+    } else if (/[A-Za-z0-9_]/.test(char)) {
+      index += 1;
+      while (index < text.length && /[A-Za-z0-9_]/.test(text[index])) {
+        index += 1;
+      }
+    } else {
+      index += 1;
+      while (
+        index < text.length
+        && !/\s/.test(text[index])
+        && text[index] !== '\\'
+        && !/[A-Za-z0-9_]/.test(text[index])
+      ) {
+        index += 1;
+      }
+    }
+    tokens.push({
+      text: text.slice(start, index),
+      start,
+      end: index
+    });
+  }
+  return tokens;
+}
+
+function splitTextParts(text) {
+  return String(text || '').match(/[^\n]*\n|[^\n]+/g) || [];
+}
+
+function computePartEdits(oldParts, newParts) {
+  const n = oldParts.length;
+  const m = newParts.length;
+  const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+
+  for (let i = n - 1; i >= 0; i -= 1) {
+    for (let j = m - 1; j >= 0; j -= 1) {
+      dp[i][j] = oldParts[i] === newParts[j]
+        ? dp[i + 1][j + 1] + 1
+        : Math.max(dp[i + 1][j], dp[i][j + 1]);
+    }
+  }
+
+  const edits = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (oldParts[i] === newParts[j]) {
+      edits.push({ type: 'equal', oldIndex: i, newIndex: j });
+      i += 1;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      edits.push({ type: 'remove', oldIndex: i });
+      i += 1;
+      continue;
+    } else {
+      edits.push({ type: 'add', newIndex: j });
+    }
+    j += 1;
+  }
+  while (i < n) {
+    edits.push({ type: 'remove', oldIndex: i });
+    i += 1;
+  }
+  while (j < m) {
+    edits.push({ type: 'add', newIndex: j });
+    j += 1;
+  }
+  return edits;
+}
+
+module.exports = {
+  computeTextPatches
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "codex-overleaf-link",
+  "version": "1.1.1",
+  "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
+  "license": "MIT",
+  "type": "commonjs",
+  "scripts": {
+    "agent:codex": "node scripts/codex-json-agent.mjs",
+    "test": "node scripts/run-tests.mjs",
+    "check:architecture": "node scripts/check-architecture-budget.mjs --enforce-target",
+    "benchmark:large": "node scripts/benchmark-large-project.mjs --gate",
+    "smoke:extension": "node scripts/smoke-extension.mjs",
+    "verify:release": "node scripts/verify-release.mjs",
+    "build:release": "node scripts/build-release.mjs",
+    "install:native": "node scripts/install-native-host.mjs",
+    "uninstall:native": "node scripts/uninstall-native-host.mjs",
+    "bridge": "node native-host/src/index.js",
+    "verify:npm-package": "node scripts/verify-npm-package.mjs",
+    "pack:npm": "node scripts/verify-npm-package.mjs --pack"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "npm@11.11.0",
+  "bin": {
+    "codex-overleaf-link": "bin/codex-overleaf-link.mjs"
+  },
+  "files": [
+    "bin/",
+    "native-host/src/",
+    "extension/src/shared/",
+    "scripts/codex-json-agent.mjs",
+    "scripts/install-native-host.mjs",
+    "scripts/uninstall-native-host.mjs",
+    "scripts/verify-npm-package.mjs",
+    "scripts/npm-package-files-v1.1.1.txt",
+    "README.md",
+    "package.json"
+  ]
+}

package/scripts/codex-json-agent.mjs

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { buildCodexPrompt, buildOutputSchema } = require('../native-host/src/codexPrompt');
+const { buildCodexExecArgs } = require('../native-host/src/codexArgs');
+
+const input = await readStdin();
+const request = JSON.parse(input || '{}');
+const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-overleaf-agent-'));
+const schemaPath = path.join(tempDir, 'output-schema.json');
+const outputPath = path.join(tempDir, 'last-message.json');
+
+try {
+  emitEvent('agent.snapshot.preparing', 'Preparing project snapshot for Codex', {
+    fileCount: request.project?.files?.length || 0,
+    totalChars: (request.project?.files || []).reduce((sum, file) => sum + String(file?.content || '').length, 0)
+  });
+  fs.writeFileSync(schemaPath, JSON.stringify(buildOutputSchema(), null, 2), 'utf8');
+  writeSnapshotFiles(tempDir, request.project?.files || []);
+  emitEvent('agent.snapshot.ready', 'Project snapshot written to temp workspace', {
+    tempDir,
+    fileCount: request.project?.files?.length || 0
+  });
+
+  const prompt = buildCodexPrompt(request);
+  emitEvent('codex.prompt.ready', 'Codex prompt prepared', {
+    taskLength: String(request.task || '').length,
+    promptLength: prompt.length,
+    model: request.model,
+    reasoningEffort: request.reasoningEffort,
+    speedTier: request.speedTier
+  });
+  const result = await runCodexExec({
+    cwd: tempDir,
+    prompt,
+    schemaPath,
+    outputPath,
+    model: request.model,
+    reasoningEffort: request.reasoningEffort,
+    speedTier: request.speedTier
+  });
+
+  process.stdout.write(JSON.stringify(result));
+} finally {
+  if (process.env.CODEX_OVERLEAF_KEEP_TEMP !== '1') {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+function emitEvent(type, title, detail = {}, status = 'running') {
+  process.stderr.write(`CODEX_OVERLEAF_EVENT ${JSON.stringify({
+    type,
+    title,
+    status,
+    detail,
+    timestamp: new Date().toISOString()
+  })}\n`);
+}
+
+function readStdin() {
+  return new Promise(resolve => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(data));
+  });
+}
+
+function writeSnapshotFiles(root, files) {
+  for (const file of files) {
+    if (!file?.path || typeof file.content !== 'string') {
+      continue;
+    }
+
+    const target = path.resolve(root, file.path);
+    if (!target.startsWith(root + path.sep)) {
+      continue;
+    }
+
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, file.content, 'utf8');
+  }
+}
+
+function runCodexExec({ cwd, prompt, schemaPath, outputPath, model, reasoningEffort, speedTier }) {
+  return new Promise((resolve, reject) => {
+    const codexCommand = process.env.CODEX_OVERLEAF_CODEX_PATH || 'codex';
+    const child = spawn(codexCommand, buildCodexExecArgs({
+      cwd,
+      schemaPath,
+      outputPath,
+      model,
+      reasoningEffort,
+      speedTier
+    }), {
+      shell: shouldUseShellForCommand(codexCommand),
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stderr = '';
+    let stdoutRemainder = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', chunk => {
+      const parsed = parseCodexJsonLines(`${stdoutRemainder}${chunk}`);
+      stdoutRemainder = parsed.remainder;
+      for (const event of parsed.events) {
+        emitCodexRuntimeEvent(event);
+      }
+    });
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', chunk => {
+      stderr += chunk;
+    });
+    child.on('error', reject);
+    child.on('close', code => {
+      if (stdoutRemainder) {
+        const parsed = parseCodexJsonLines(`${stdoutRemainder}\n`);
+        stdoutRemainder = '';
+        for (const event of parsed.events) {
+          emitCodexRuntimeEvent(event);
+        }
+      }
+      emitEvent('codex.exec.completed', 'Codex exec exited', {
+        code,
+        stderrLength: stderr.length
+      }, code === 0 ? 'completed' : 'failed');
+      if (code !== 0) {
+        reject(new Error(stderr || `codex exec exited with code ${code}`));
+        return;
+      }
+
+      try {
+        resolve(JSON.parse(fs.readFileSync(outputPath, 'utf8')));
+      } catch (error) {
+        reject(new Error(`Could not parse Codex output: ${error.message}`));
+      }
+    });
+
+    emitEvent('codex.exec.started', 'Codex exec started', {
+      pid: child.pid,
+      cwd,
+      model,
+      reasoningEffort,
+      speedTier
+    });
+    child.stdin.end(prompt);
+  });
+}
+
+function shouldUseShellForCommand(command) {
+  if (process.platform !== 'win32') {
+    return false;
+  }
+  const text = String(command || '');
+  return text === 'codex' || /\.(?:cmd|bat)$/i.test(text);
+}
+
+function parseCodexJsonLines(text) {
+  const lines = text.split(/\r?\n/);
+  const remainder = lines.pop() || '';
+  const events = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+      emitEvent('codex.stdout.line', 'Codex produced non-JSON output', {
+        text: truncateInline(trimmed, 500)
+      }, 'running');
+    }
+  }
+
+  return { events, remainder };
+}
+
+function emitCodexRuntimeEvent(event) {
+  if (event?.type === 'item.completed' || event?.type === 'item.started') {
+    emitCodexItemEvent(event);
+    return;
+  }
+
+  if (event?.type === 'turn.started') {
+    emitEvent('codex.turn.started', 'Codex started this turn', {}, 'running');
+    return;
+  }
+
+  if (event?.type === 'turn.completed') {
+    emitEvent('codex.turn.completed', 'Codex completed this turn', {
+      usage: event.usage || {}
+    }, 'completed');
+    return;
+  }
+
+  emitEvent(`codex.${event?.type || 'event'}`, event?.type || 'Codex event', {
+    event
+  }, 'running');
+}
+
+function emitCodexItemEvent(event) {
+  const item = event.item || {};
+
+  if (item.type === 'agent_message') {
+    const text = String(item.text || '').trim();
+    if (!text) {
+      return;
+    }
+    if (looksLikeStructuredFinalMessage(text)) {
+      emitEvent('codex.agent.result', 'Codex generated structured result', {
+        textLength: text.length
+      }, 'completed');
+      return;
+    }
+    emitEvent('codex.agent.message', truncateInline(text, 160), {
+      text
+    }, 'completed');
+    return;
+  }
+
+  if (item.type === 'command_execution') {
+    if (event.type === 'item.started') {
+      emitEvent('codex.command.started', `Codex is running: ${truncateInline(item.command, 120)}`, {
+        command: item.command || ''
+      }, 'running');
+      return;
+    }
+
+    emitEvent('codex.command.completed', item.exit_code === 0
+      ? `Command completed: ${truncateInline(item.command, 120)}`
+      : `Command failed: ${truncateInline(item.command, 120)}`, {
+      command: item.command || '',
+      output: item.aggregated_output || '',
+      exitCode: item.exit_code,
+      status: item.status || ''
+    }, item.exit_code === 0 ? 'completed' : 'failed');
+    return;
+  }
+
+  emitEvent('codex.item.completed', `Codex item: ${item.type || 'unknown'}`, {
+    item
+  }, event.type === 'item.completed' ? 'completed' : 'running');
+}
+
+function looksLikeStructuredFinalMessage(text) {
+  try {
+    const value = JSON.parse(text);
+    return value && typeof value === 'object' && (
+      Object.prototype.hasOwnProperty.call(value, 'operations') ||
+      Object.prototype.hasOwnProperty.call(value, 'status')
+    );
+  } catch {
+    return false;
+  }
+}
+
+function truncateInline(text, maxLength) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}