codex-overleaf-link 2.3.0 → 2.3.2

package/native-host/src/nativeAssetTransfer.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { getProjectMirror } = require('./mirrorWorkspace');
+
+const MAX_ASSET_BYTES = 10 * 1024 * 1024;
+const ASSET_CHUNK_BYTES = 192 * 1024;
+const ASSET_TOKEN_TTL_MS = 15 * 60 * 1000;
+const transfers = new Map();
+
+function prepareBinaryAssetChanges({ projectId, rootDir, changes = [] } = {}) {
+  const prepared = [];
+  const unsupportedChanges = [];
+  for (const change of changes) {
+    if (change?.type !== 'binary-create' && change?.type !== 'overwrite-binary') {
+      prepared.push(change);
+      continue;
+    }
+    try {
+      prepared.push(registerAssetChange({ projectId, rootDir, change }));
+    } catch (error) {
+      unsupportedChanges.push({
+        type: 'unsupported-local-file',
+        path: change?.path || '',
+        reason: error.code || 'binary_asset_registration_failed',
+        size: change?.size,
+        attemptedChangeType: change?.type || 'binary-create'
+      });
+    }
+  }
+  return { changes: prepared, unsupportedChanges };
+}
+
+function registerAssetChange({ projectId, rootDir, change }) {
+  cleanupExpiredTransfers();
+  const mirror = getProjectMirror(projectId, { rootDir });
+  const relativePath = normalizeProjectPath(change.assetSourcePath || change.path);
+  const target = resolveSafeWorkspaceFile(mirror.workspacePath, relativePath);
+  const stat = fs.statSync(target);
+  if (!stat.isFile()) throw codedError('binary_asset_source_invalid', 'Asset source is not a file.');
+  if (stat.size > MAX_ASSET_BYTES) throw codedError('binary_file_too_large', 'Asset exceeds the 10 MiB writeback limit.');
+  const sha256 = hashFile(target);
+  if (change.sha256 && change.sha256 !== sha256) {
+    throw codedError('binary_asset_source_changed', 'Asset changed before transfer registration.');
+  }
+  const token = crypto.randomUUID();
+  const expiresAtMs = Date.now() + ASSET_TOKEN_TTL_MS;
+  transfers.set(token, {
+    token,
+    path: relativePath,
+    target,
+    size: stat.size,
+    sha256,
+    expiresAtMs
+  });
+  const { contentBase64, assetSourcePath, ...safeChange } = change;
+  return {
+    ...safeChange,
+    size: stat.size,
+    assetRef: {
+      token,
+      path: relativePath,
+      size: stat.size,
+      sha256,
+      mimeType: inferMimeType(relativePath),
+      chunkSize: ASSET_CHUNK_BYTES,
+      expiresAt: new Date(expiresAtMs).toISOString()
+    }
+  };
+}
+
+function readAssetChunk(params = {}) {
+  cleanupExpiredTransfers();
+  const transfer = getTransfer(params.token);
+  const offset = Number(params.offset || 0);
+  const requestedLength = Number(params.length || ASSET_CHUNK_BYTES);
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset > transfer.size) {
+    throw codedError('asset_chunk_offset_invalid', 'Asset chunk offset is invalid.');
+  }
+  const length = Math.min(
+    ASSET_CHUNK_BYTES,
+    Number.isSafeInteger(requestedLength) && requestedLength > 0 ? requestedLength : ASSET_CHUNK_BYTES,
+    transfer.size - offset
+  );
+  assertSourceStable(transfer);
+  const handle = fs.openSync(transfer.target, 'r');
+  try {
+    const buffer = Buffer.alloc(length);
+    const bytesRead = length ? fs.readSync(handle, buffer, 0, length, offset) : 0;
+    const nextOffset = offset + bytesRead;
+    return {
+      token: transfer.token,
+      path: transfer.path,
+      offset,
+      nextOffset,
+      size: transfer.size,
+      sha256: transfer.sha256,
+      contentBase64: buffer.subarray(0, bytesRead).toString('base64'),
+      eof: nextOffset >= transfer.size
+    };
+  } finally {
+    fs.closeSync(handle);
+  }
+}
+
+function releaseAsset(params = {}) {
+  return { released: transfers.delete(String(params.token || '')) };
+}
+
+function getTransfer(tokenValue) {
+  const token = String(tokenValue || '');
+  const transfer = transfers.get(token);
+  if (!transfer) throw codedError('asset_token_invalid', 'Asset transfer token is invalid or expired.');
+  if (transfer.expiresAtMs <= Date.now()) {
+    transfers.delete(token);
+    throw codedError('asset_token_expired', 'Asset transfer token expired.');
+  }
+  return transfer;
+}
+
+function assertSourceStable(transfer) {
+  let stat;
+  try { stat = fs.statSync(transfer.target); } catch (_error) {
+    throw codedError('binary_asset_source_missing', 'Asset source disappeared during transfer.');
+  }
+  if (!stat.isFile() || stat.size !== transfer.size) {
+    throw codedError('binary_asset_source_changed', 'Asset source changed during transfer.');
+  }
+}
+
+function resolveSafeWorkspaceFile(workspacePath, relativePath) {
+  const root = path.resolve(workspacePath);
+  const target = path.resolve(root, relativePath);
+  if (target === root || !target.startsWith(`${root}${path.sep}`)) {
+    throw codedError('binary_asset_path_unsafe', 'Asset path escapes the project workspace.');
+  }
+  if (fs.lstatSync(target).isSymbolicLink()) {
+    throw codedError('binary_asset_path_unsafe', 'Symbolic-link assets cannot be transferred.');
+  }
+  return target;
+}
+
+function normalizeProjectPath(value) {
+  const normalized = String(value || '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+  if (!normalized || normalized.split('/').some(part => !part || part === '.' || part === '..')) {
+    throw codedError('binary_asset_path_invalid', 'Asset path is not a safe project-relative path.');
+  }
+  return normalized;
+}
+
+function hashFile(target) {
+  return crypto.createHash('sha256').update(fs.readFileSync(target)).digest('hex');
+}
+
+function inferMimeType(filePath) {
+  return {
+    '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.svg': 'image/svg+xml',
+    '.webp': 'image/webp', '.eps': 'application/postscript'
+  }[path.extname(filePath).toLowerCase()] || 'application/octet-stream';
+}
+
+function cleanupExpiredTransfers() {
+  const now = Date.now();
+  for (const [token, transfer] of transfers) if (transfer.expiresAtMs <= now) transfers.delete(token);
+}
+
+function codedError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+module.exports = {
+  ASSET_CHUNK_BYTES,
+  ASSET_TOKEN_TTL_MS,
+  MAX_ASSET_BYTES,
+  prepareBinaryAssetChanges,
+  readAssetChunk,
+  releaseAsset
+};

package/native-host/src/taskRunnerRuntime.js

@@ -3,7 +3,6 @@
 const { buildCodexRuntimeEvent } = require('./codexRuntimeIdentity');
 
 const { spawn } = require('node:child_process');
-const crypto = require('node:crypto');
 const { buildOperationSummary, splitDeletePlan } = require('../../extension/src/shared/summary');
 const {
   MIN_COMPATIBLE_EXTENSION_VERSION,
@@ -20,6 +19,8 @@ const {
   resolveRunProviderForRun
 } = require('./providerRuntime');
 const { clearPluginCodexHistory } = require('./codexHome');
+const { forkCodexThread } = require('./codexThreadFork');
+const { readAssetChunk, releaseAsset } = require('./nativeAssetTransfer');
 const { logDebug, truncateText } = require('./debugLog');
 const { HOST_NAME } = require('./manifest');
 const { getNativeRuntimePlatform, summarizeNativeEnvironment } = require('./nativeEnvironment');
@@ -40,8 +41,6 @@ const activeRunEntries = new Map();
 // Overleaf tab was reloaded — the requestId lived in content-side JS state
 // and is gone, but the native-host-side controller is still running).
 const activeRunByProject = new Map();
-const pendingPlans = new Map();
-const PENDING_PLAN_TTL_MS = 30 * 60 * 1000;
 const CODEX_RUN_PASSTHROUGH_ERROR_CODES = new Set(['thread_resume_failed', 'codex_no_usable_result']);
 
 async function handleRequest(request, env = process.env, emit = () => {}) {
@@ -119,6 +118,26 @@ async function handleRequest(request, env = process.env, emit = () => {}) {
     return handleCodexHistoryClear(request, env);
   }
 
+  if (request.method === 'codex.thread.fork') {
+    try {
+      return okResponse(request.id, await forkCodexThread(request.params || {}, env));
+    } catch (error) {
+      return errorResponse(request.id, error.code || 'codex_thread_fork_failed', error.message);
+    }
+  }
+
+  if (request.method === 'asset.readChunk') {
+    try {
+      return okResponse(request.id, readAssetChunk(request.params || {}));
+    } catch (error) {
+      return errorResponse(request.id, error.code || 'asset_chunk_read_failed', error.message);
+    }
+  }
+
+  if (request.method === 'asset.release') {
+    return okResponse(request.id, releaseAsset(request.params || {}));
+  }
+
   if (request.method === 'skills.list') {
     return handleSkillsList(request, env);
   }
@@ -136,7 +155,7 @@ async function handleRequest(request, env = process.env, emit = () => {}) {
   }
 
   if (request.method === 'task.confirm') {
-    return handleTaskConfirm(request);
+    return errorResponse(request.id, 'suggest_mode_removed', 'Suggest mode has been removed. Reload the extension and choose Ask or Auto.');
   }
 
   return errorResponse(request.id, 'method_not_found', `Unknown method: ${request.method}`);
@@ -716,8 +735,11 @@ async function handleTaskRun(request, env, emit) {
   const params = request.params || {};
   const mode = params.mode;
 
-  if (!['ask', 'confirm', 'auto'].includes(mode)) {
-    return errorResponse(request.id, 'invalid_mode', 'Mode must be "ask", "confirm", or "auto"');
+  if (mode === 'confirm') {
+    return errorResponse(request.id, 'suggest_mode_removed', 'Suggest mode has been removed. Choose Ask or Auto.');
+  }
+  if (!['ask', 'auto'].includes(mode)) {
+    return errorResponse(request.id, 'invalid_mode', 'Mode must be "ask" or "auto"');
   }
 
   if (mode === 'auto' && !params.checkpoint?.ok && !isVerifiedReviewing(params.reviewing)) {
@@ -805,24 +827,6 @@ function isVerifiedReviewing(reviewing) {
   return reviewing?.ok === true && reviewing.status !== 'manual-override';
 }
 
-async function handleTaskConfirm(request) {
-  const planId = request.params?.planId;
-  purgeExpiredPendingPlans();
-  if (!planId || !pendingPlans.has(planId)) {
-    return errorResponse(request.id, 'plan_not_found', 'No pending task plan matched the supplied planId');
-  }
-
-  const plan = pendingPlans.get(planId);
-  pendingPlans.delete(planId);
-
-  return okResponse(request.id, {
-    status: 'confirmed',
-    notes: plan.notes || '',
-    userReport: plan.userReport,
-    operations: plan.operations
-  });
-}
-
 function buildDefaultTaskResult(mode, operations, params = {}) {
   if (mode === 'ask') {
     return {
@@ -836,16 +840,6 @@ function buildDefaultTaskResult(mode, operations, params = {}) {
 
   const summary = buildOperationSummary(operations);
 
-  if (mode === 'confirm') {
-    return {
-      status: 'requires_task_confirmation',
-      summary,
-      notes: '',
-      userReport: buildDefaultUserReport(mode, operations, params),
-      operations
-    };
-  }
-
   const split = splitDeletePlan(operations);
   if (split.needsConfirmation.length > 0) {
     return {
@@ -889,7 +883,7 @@ function normalizeAgentResult(mode, result, params = {}) {
   };
 
   if (!normalized.status) {
-    normalized.status = mode === 'confirm' ? 'requires_task_confirmation' : 'completed';
+    normalized.status = 'completed';
   }
 
   return normalized;
@@ -911,40 +905,7 @@ function prepareResultForResponse(mode, result) {
     }
   }
 
-  const confirmOperations = mode === 'confirm' ? collectResultOperations(result) : [];
-  if (confirmOperations.length > 0) {
-    result = {
-      ...result,
-      status: 'requires_task_confirmation',
-      summary: buildOperationSummary(confirmOperations),
-      operations: confirmOperations
-    };
-  }
-
-  if (mode !== 'confirm' || result.status !== 'requires_task_confirmation') {
-    return result;
-  }
-
-  purgeExpiredPendingPlans();
-  const planId = `plan_${crypto.randomUUID()}`;
-  pendingPlans.set(planId, {
-    createdAt: Date.now(),
-    expiresAt: Date.now() + PENDING_PLAN_TTL_MS,
-    notes: result.notes || '',
-    userReport: result.userReport,
-    operations: Array.isArray(result.operations) ? result.operations : []
-  });
-
-  const {
-    operations: _operations,
-    pendingOperations: _pendingOperations,
-    deletePlan: _deletePlan,
-    ...redacted
-  } = result;
-  return {
-    ...redacted,
-    planId
-  };
+  return result;
 }
 
 function validateTaskResultOperationQuotas(result = {}) {
@@ -965,7 +926,7 @@ function buildDefaultUserReport(mode, operations = [], params = {}) {
 
   return {
     conclusion: hasOperations
-      ? reportText(locale, 'Codex prepared proposed changes and is waiting for confirmation or writeback.', 'Codex 已准备好建议修改，等待确认或写入。')
+      ? reportText(locale, 'Codex prepared changes for writeback.', 'Codex 已准备好写回修改。')
       : reportText(locale, 'This task completed without writing Overleaf files.', '这轮任务已完成，没有写入 Overleaf 文件。'),
     checked,
     findings: [],
@@ -975,7 +936,7 @@ function buildDefaultUserReport(mode, operations = [], params = {}) {
       ? ''
       : (mode === 'ask' ? reportText(locale, 'This run was Ask mode.', '这轮是只问不改。') : ''),
     nextStep: hasOperations
-      ? reportText(locale, 'Review and confirm the proposed changes before writing them to Overleaf.', '请确认修改方案后写入 Overleaf。')
+      ? reportText(locale, 'Review the written changes in Overleaf.', '请在 Overleaf 中检查写入的修改。')
       : reportText(locale, 'Continue the conversation, or add more @context and run another check.', '可以继续追问，或加入更多 @context 后再检查。')
   };
 }
@@ -1193,14 +1154,6 @@ function runExternalAgent(agentSpec, params, emit = () => {}, options = {}) {
   });
 }
 
-function purgeExpiredPendingPlans(now = Date.now()) {
-  for (const [planId, plan] of pendingPlans.entries()) {
-    if (Number.isFinite(plan?.expiresAt) && plan.expiresAt <= now) {
-      pendingPlans.delete(planId);
-    }
-  }
-}
-
 function parsePositiveInteger(value, fallback) {
   const parsed = Number.parseInt(value, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -1295,6 +1248,5 @@ module.exports = {
   buildDefaultTaskResult,
   getActiveNativeWorkState,
   handleRequest,
-  parseAgentEventLines,
-  purgeExpiredPendingPlans
+  parseAgentEventLines
 };

package/native-host/src/updateManager.js

@@ -743,6 +743,8 @@ function cleanupOrphanStageRoots(updatesRoot, retainedRoots = []) {
 
 function recoverAndReadStatus(context) {
   let journal = readJournal(context);
+  const alignedVersion = readAlignedManagedVersion(context);
+  journal = supersedeObsoleteJournal(context, journal, alignedVersion);
   if (journal?.state === 'activation_pending') {
     journal = { ...journal, state: 'staged', reasonCode: 'update_activation_interrupted', updatedAt: new Date().toISOString() };
     writeJournal(context, journal);
@@ -753,7 +755,7 @@ function recoverAndReadStatus(context) {
     writeJournal(context, journal);
     settleAuthorization(context, journal.authorizationId, 'revoked');
   }
-  if (journal?.state === 'rolled_back') {
+  if (journal?.state === 'rolled_back' || journal?.state === 'superseded') {
     pruneNativeVersions(context.nativeRoot, new Set([
       readVersionPointer(context.nativeRoot, 'active-version'),
       readVersionPointer(context.nativeRoot, 'previous-version')
@@ -768,6 +770,36 @@ function recoverAndReadStatus(context) {
   };
 }
 
+function readAlignedManagedVersion(context) {
+  try {
+    return assertManagedLayout(context);
+  } catch (_error) {
+    return '';
+  }
+}
+
+function supersedeObsoleteJournal(context, journal, activeVersion) {
+  if (!journal || journal.state === 'superseded' || !parseSemver(activeVersion) ||
+      !parseSemver(journal.sourceVersion) || !parseSemver(journal.targetVersion) ||
+      compareSemver(activeVersion, journal.sourceVersion) <= 0 ||
+      compareSemver(activeVersion, journal.targetVersion) <= 0) {
+    return journal;
+  }
+  const timestamp = new Date().toISOString();
+  const superseded = {
+    ...journal,
+    state: 'superseded',
+    supersededFromState: journal.state,
+    supersededByVersion: activeVersion,
+    supersededAt: timestamp,
+    updatedAt: timestamp
+  };
+  writeJournal(context, superseded);
+  cleanupStage(journal.stageRoot);
+  cleanupOrphanStageRoots(context.updatesRoot);
+  return superseded;
+}
+
 function pruneNativeVersions(nativeRoot, retainedVersions) {
   const versionsRoot = path.join(nativeRoot, 'versions');
   let entries = [];
@@ -960,6 +992,9 @@ function publicTransaction(journal) {
     appliedAt: journal.appliedAt,
     confirmedAt: journal.confirmedAt,
     rolledBackAt: journal.rolledBackAt,
+    supersededAt: journal.supersededAt,
+    supersededByVersion: journal.supersededByVersion,
+    supersededFromState: journal.supersededFromState,
     reasonCode: journal.reasonCode || ''
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-overleaf-link",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Cross-platform Chrome bridge that connects Codex to the active Overleaf project.",
   "license": "MIT",
   "type": "commonjs",