codex-overleaf-link 1.1.1

package/native-host/src/nativeQuotas.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const NATIVE_REQUEST_QUOTAS = Object.freeze({
+  maxProjectFiles: 1000,
+  maxProjectTextBytes: 32 * 1024 * 1024,
+  maxProjectBinaryBytes: 32 * 1024 * 1024,
+  maxOperations: 1000,
+  maxCompileLogBytes: 512 * 1024,
+  maxAttachmentCount: 8,
+  maxAttachmentBytes: 12 * 1024 * 1024,
+  maxAttachmentTotalBytes: 8 * 12 * 1024 * 1024,
+  maxSkillContentBytes: 64 * 1024
+});
+
+function validateNativeRequestQuotas(request = {}) {
+  const params = request.params || {};
+  switch (request.method) {
+    case 'codex.run':
+      return firstQuotaViolation([
+        validateProjectSnapshotQuota(params.project),
+        validateOperationListQuota(params.fileOverlays, 'fileOverlays'),
+        validateFilePayloadQuota(params.fileOverlays, 'fileOverlays'),
+        validateCompileLogQuota(params),
+        validateAttachmentQuota(params.attachments),
+        validateSkillContentQuota(params.skillContent)
+      ]);
+    case 'mirror.sync':
+      return validateProjectSnapshotQuota(params.project);
+    case 'mirror.patchFiles':
+      return firstQuotaViolation([
+        validateOperationListQuota(params.files, 'files'),
+        validatePatchFileTextQuota(params.files)
+      ]);
+    case 'task.run':
+      return firstQuotaViolation([
+        validateProjectSnapshotQuota(params.project),
+        validateOperationListQuota(params.fileOverlays, 'fileOverlays'),
+        validateFilePayloadQuota(params.fileOverlays, 'fileOverlays'),
+        validateOperationListQuota(params.proposedOperations, 'proposedOperations'),
+        validateOperationPayloadQuota(params.proposedOperations, 'proposedOperations'),
+        validateOperationListQuota(params.operations, 'operations'),
+        validateOperationPayloadQuota(params.operations, 'operations'),
+        validateCompileLogQuota(params)
+      ]);
+    case 'skills.install':
+      return validateSkillContentQuota(params.content);
+    default:
+      return null;
+  }
+}
+
+function firstQuotaViolation(violations) {
+  return violations.find(Boolean) || null;
+}
+
+function validateProjectSnapshotQuota(project = {}) {
+  const files = Array.isArray(project?.files) ? project.files : [];
+  if (files.length > NATIVE_REQUEST_QUOTAS.maxProjectFiles) {
+    return quotaViolation('project.files', NATIVE_REQUEST_QUOTAS.maxProjectFiles, files.length, 'too many project files');
+  }
+
+  return validateFilePayloadQuota(files, 'project.files');
+}
+
+function validateFilePayloadQuota(files, fieldPrefix) {
+  let textBytes = 0;
+  let binaryBytes = 0;
+  for (const file of Array.isArray(files) ? files : []) {
+    for (const key of ['content', 'nextContent']) {
+      if (typeof file?.[key] === 'string') {
+        textBytes += Buffer.byteLength(file[key], 'utf8');
+      }
+    }
+    if (typeof file?.contentBase64 === 'string') {
+      binaryBytes += getDeclaredOrEstimatedBinaryBytes(file);
+    }
+  }
+  if (textBytes > NATIVE_REQUEST_QUOTAS.maxProjectTextBytes) {
+    return quotaViolation(
+      `${fieldPrefix}.content`,
+      NATIVE_REQUEST_QUOTAS.maxProjectTextBytes,
+      textBytes,
+      `${fieldPrefix} text is too large`
+    );
+  }
+  if (binaryBytes > NATIVE_REQUEST_QUOTAS.maxProjectBinaryBytes) {
+    return quotaViolation(
+      `${fieldPrefix}.contentBase64`,
+      NATIVE_REQUEST_QUOTAS.maxProjectBinaryBytes,
+      binaryBytes,
+      `${fieldPrefix} binary payload is too large`
+    );
+  }
+  return null;
+}
+
+function validatePatchFileTextQuota(files) {
+  let textBytes = 0;
+  for (const file of Array.isArray(files) ? files : []) {
+    for (const key of ['nextContent', 'content']) {
+      if (typeof file?.[key] === 'string') {
+        textBytes += Buffer.byteLength(file[key], 'utf8');
+      }
+    }
+  }
+  return textBytes > NATIVE_REQUEST_QUOTAS.maxProjectTextBytes
+    ? quotaViolation('files.content', NATIVE_REQUEST_QUOTAS.maxProjectTextBytes, textBytes, 'patch text is too large')
+    : null;
+}
+
+function validateOperationListQuota(value, field) {
+  const operations = Array.isArray(value) ? value : [];
+  return operations.length > NATIVE_REQUEST_QUOTAS.maxOperations
+    ? quotaViolation(field, NATIVE_REQUEST_QUOTAS.maxOperations, operations.length, 'too many operations')
+    : null;
+}
+
+function validateOperationPayloadQuota(value, fieldPrefix) {
+  const operations = Array.isArray(value) ? value : [];
+  const { textBytes, binaryBytes } = measureOperationPayloads(operations);
+  if (textBytes > NATIVE_REQUEST_QUOTAS.maxProjectTextBytes) {
+    return quotaViolation(
+      `${fieldPrefix}.content`,
+      NATIVE_REQUEST_QUOTAS.maxProjectTextBytes,
+      textBytes,
+      `${fieldPrefix} text payload is too large`
+    );
+  }
+  if (binaryBytes > NATIVE_REQUEST_QUOTAS.maxProjectBinaryBytes) {
+    return quotaViolation(
+      `${fieldPrefix}.contentBase64`,
+      NATIVE_REQUEST_QUOTAS.maxProjectBinaryBytes,
+      binaryBytes,
+      `${fieldPrefix} binary payload is too large`
+    );
+  }
+  return null;
+}
+
+function measureOperationPayloads(operations = []) {
+  const totals = { textBytes: 0, binaryBytes: 0 };
+  const seen = new Set();
+  for (const operation of operations) {
+    measureOperationPayloadValue(operation, '', totals, seen);
+  }
+  return totals;
+}
+
+function measureOperationPayloadValue(value, key, totals, seen) {
+  if (value === null || value === undefined) {
+    return;
+  }
+  if (typeof value === 'string') {
+    if (isBase64PayloadKey(key)) {
+      return;
+    }
+    totals.textBytes += Buffer.byteLength(value, 'utf8');
+    return;
+  }
+  if (typeof value !== 'object') {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+
+  if (typeof value.contentBase64 === 'string') {
+    totals.binaryBytes += getDeclaredOrEstimatedBinaryBytes(value);
+  } else if (isBinarySizedOperationPayload(value)) {
+    totals.binaryBytes += Number(value.size);
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      measureOperationPayloadValue(item, '', totals, seen);
+    }
+    return;
+  }
+
+  for (const [childKey, childValue] of Object.entries(value)) {
+    if (isBase64PayloadKey(childKey)) {
+      continue;
+    }
+    measureOperationPayloadValue(childValue, childKey, totals, seen);
+  }
+}
+
+function isBase64PayloadKey(key) {
+  return key === 'contentBase64';
+}
+
+function isBinarySizedOperationPayload(value = {}) {
+  const size = Number(value.size);
+  if (!Number.isFinite(size) || size <= 0) {
+    return false;
+  }
+  return String(value.type || '').includes('binary')
+    || String(value.kind || '') === 'binary'
+    || Object.prototype.hasOwnProperty.call(value, 'contentBase64');
+}
+
+function validateCompileLogQuota(params = {}) {
+  const bytes = Buffer.byteLength(String(params.compileLog || ''), 'utf8')
+    + byteLengthOfStringArray(params.compileErrors)
+    + byteLengthOfStringArray(params.compileWarnings);
+  return bytes > NATIVE_REQUEST_QUOTAS.maxCompileLogBytes
+    ? quotaViolation('compileLog', NATIVE_REQUEST_QUOTAS.maxCompileLogBytes, bytes, 'compile log context is too large')
+    : null;
+}
+
+function validateAttachmentQuota(attachments) {
+  const items = Array.isArray(attachments) ? attachments : [];
+  if (items.length > NATIVE_REQUEST_QUOTAS.maxAttachmentCount) {
+    return quotaViolation('attachments', NATIVE_REQUEST_QUOTAS.maxAttachmentCount, items.length, 'too many attachments');
+  }
+
+  let totalBytes = 0;
+  for (const item of items) {
+    const bytes = getDeclaredOrEstimatedBinaryBytes(item);
+    if (bytes > NATIVE_REQUEST_QUOTAS.maxAttachmentBytes) {
+      return quotaViolation(
+        'attachments.contentBase64',
+        NATIVE_REQUEST_QUOTAS.maxAttachmentBytes,
+        bytes,
+        'attachment payload is too large'
+      );
+    }
+    totalBytes += bytes;
+  }
+  return totalBytes > NATIVE_REQUEST_QUOTAS.maxAttachmentTotalBytes
+    ? quotaViolation('attachments', NATIVE_REQUEST_QUOTAS.maxAttachmentTotalBytes, totalBytes, 'attachment payload is too large')
+    : null;
+}
+
+function validateSkillContentQuota(content) {
+  if (content === undefined || content === null) {
+    return null;
+  }
+  const bytes = typeof content === 'string'
+    ? Buffer.byteLength(content, 'utf8')
+    : Buffer.byteLength(String(content), 'utf8');
+  return bytes > NATIVE_REQUEST_QUOTAS.maxSkillContentBytes
+    ? quotaViolation('content', NATIVE_REQUEST_QUOTAS.maxSkillContentBytes, bytes, 'skill content is too large')
+    : null;
+}
+
+function getDeclaredOrEstimatedBinaryBytes(value = {}) {
+  const declared = Number(value.size);
+  const estimated = typeof value.contentBase64 === 'string'
+    ? estimateBase64DecodedBytes(value.contentBase64)
+    : 0;
+  return Math.max(Number.isFinite(declared) && declared > 0 ? declared : 0, estimated);
+}
+
+function estimateBase64DecodedBytes(value) {
+  const clean = String(value || '').replace(/\s+/g, '');
+  if (!clean) {
+    return 0;
+  }
+  const padding = clean.endsWith('==') ? 2 : clean.endsWith('=') ? 1 : 0;
+  return Math.max(0, Math.floor(clean.length * 3 / 4) - padding);
+}
+
+function byteLengthOfStringArray(value) {
+  return (Array.isArray(value) ? value : [])
+    .reduce((sum, item) => sum + Buffer.byteLength(String(item || ''), 'utf8'), 0);
+}
+
+function quotaViolation(field, limit, actual, reason) {
+  return {
+    field,
+    limit,
+    actual,
+    reason
+  };
+}
+
+module.exports = {
+  NATIVE_REQUEST_QUOTAS,
+  estimateBase64DecodedBytes,
+  firstQuotaViolation,
+  measureOperationPayloads,
+  quotaViolation,
+  validateAttachmentQuota,
+  validateCompileLogQuota,
+  validateFilePayloadQuota,
+  validateNativeRequestQuotas,
+  validateOperationListQuota,
+  validateOperationPayloadQuota,
+  validatePatchFileTextQuota,
+  validateProjectSnapshotQuota,
+  validateSkillContentQuota
+};

package/native-host/src/nativeResponseBudget.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const { MAX_NATIVE_OUTPUT_MESSAGE_BYTES } = require('./nativeMessaging');
+
+const NATIVE_OK_RESPONSE_BUDGET_BYTES = MAX_NATIVE_OUTPUT_MESSAGE_BYTES - (64 * 1024);
+const NATIVE_RESPONSE_ESTIMATE_ID = 'response-budget-estimate';
+
+function enforceNativeOkResponseBudget(result) {
+  const next = {
+    ...result,
+    syncChanges: Array.isArray(result.syncChanges) ? [...result.syncChanges] : [],
+    unsupportedChanges: Array.isArray(result.unsupportedChanges) ? [...result.unsupportedChanges] : []
+  };
+
+  while (estimateNativeOkResponseBytes(next) > NATIVE_OK_RESPONSE_BUDGET_BYTES) {
+    const textIndex = findLargestInlineTextChangeIndex(next.syncChanges);
+    if (textIndex >= 0) {
+      const [change] = next.syncChanges.splice(textIndex, 1);
+      next.unsupportedChanges.push(buildOversizedTextPayloadChange(change));
+      continue;
+    }
+
+    const binaryIndex = findLargestInlineBinaryChangeIndex(next.syncChanges);
+    if (binaryIndex >= 0) {
+      const [change] = next.syncChanges.splice(binaryIndex, 1);
+      next.unsupportedChanges.push(buildOversizedBinaryPayloadChange(change));
+      continue;
+    }
+
+    if (typeof next.assistantMessage === 'string' && next.assistantMessage) {
+      next.assistantMessage = shrinkAssistantMessageForNativeResponse(next.assistantMessage, next);
+      continue;
+    }
+
+    return compactNativeResponseForBudget(next);
+  }
+
+  next.unsupportedChanges.sort((left, right) => String(left.path || '').localeCompare(String(right.path || '')));
+  return next;
+}
+
+function estimateNativeOkResponseBytes(result) {
+  return Buffer.byteLength(JSON.stringify({
+    id: NATIVE_RESPONSE_ESTIMATE_ID,
+    ok: true,
+    result
+  }), 'utf8');
+}
+
+function findLargestInlineTextChangeIndex(changes = []) {
+  let largestIndex = -1;
+  let largestBytes = -1;
+  for (let index = 0; index < changes.length; index += 1) {
+    const change = changes[index];
+    if (!hasInlineTextPayload(change)) {
+      continue;
+    }
+    const bytes = Buffer.byteLength(JSON.stringify(change), 'utf8');
+    if (bytes > largestBytes) {
+      largestBytes = bytes;
+      largestIndex = index;
+    }
+  }
+  return largestIndex;
+}
+
+function hasInlineTextPayload(change) {
+  return change
+    && change.type !== 'binary-create'
+    && change.type !== 'overwrite-binary'
+    && (
+      typeof change.content === 'string'
+      || typeof change.previousContent === 'string'
+      || Array.isArray(change.diff)
+      || Array.isArray(change.patches)
+    );
+}
+
+function findLargestInlineBinaryChangeIndex(changes = []) {
+  let largestIndex = -1;
+  let largestBytes = -1;
+  for (let index = 0; index < changes.length; index += 1) {
+    const change = changes[index];
+    if (
+      (change?.type !== 'binary-create' && change?.type !== 'overwrite-binary')
+      || typeof change.contentBase64 !== 'string'
+    ) {
+      continue;
+    }
+    const bytes = Buffer.byteLength(change.contentBase64, 'utf8');
+    if (bytes > largestBytes) {
+      largestBytes = bytes;
+      largestIndex = index;
+    }
+  }
+  return largestIndex;
+}
+
+function buildOversizedTextPayloadChange(change = {}) {
+  const contentBytes = typeof change.content === 'string' ? Buffer.byteLength(change.content, 'utf8') : 0;
+  const previousBytes = typeof change.previousContent === 'string' ? Buffer.byteLength(change.previousContent, 'utf8') : 0;
+  return {
+    type: 'unsupported-local-file',
+    path: change.path || '',
+    reason: 'text_payload_exceeds_native_message_limit',
+    size: contentBytes,
+    previousSize: previousBytes,
+    attemptedChangeType: change.type || 'write',
+    previousExists: change.previousExists === true,
+    nativeOutputLimit: MAX_NATIVE_OUTPUT_MESSAGE_BYTES,
+    responseBudget: NATIVE_OK_RESPONSE_BUDGET_BYTES,
+    guidance: 'The text writeback payload is too large for native messaging after adding review diff and patch data. Apply the change in Overleaf directly, split the edit into smaller files, or rerun with a narrower focus.'
+  };
+}
+
+function buildOversizedBinaryPayloadChange(change = {}) {
+  return {
+    type: 'unsupported-local-file',
+    path: change.path || '',
+    reason: 'binary_payload_exceeds_native_message_limit',
+    size: Number.isFinite(Number(change.size)) ? Number(change.size) : estimateBase64Size(change.contentBase64),
+    attemptedChangeType: change.type || 'binary-create',
+    previousExists: change.previousExists === true,
+    previousKind: change.previousKind || '',
+    previousSize: change.previousSize,
+    nativeOutputLimit: MAX_NATIVE_OUTPUT_MESSAGE_BYTES,
+    responseBudget: NATIVE_OK_RESPONSE_BUDGET_BYTES,
+    guidance: 'The binary writeback payload would exceed the native messaging response budget. Update the file in Overleaf directly or reduce the asset size before retrying.'
+  };
+}
+
+function estimateBase64Size(value) {
+  const clean = String(value || '').replace(/\s+/g, '');
+  if (!clean) {
+    return 0;
+  }
+  const padding = clean.endsWith('==') ? 2 : clean.endsWith('=') ? 1 : 0;
+  return Math.max(0, Math.floor(clean.length * 3 / 4) - padding);
+}
+
+function shrinkAssistantMessageForNativeResponse(message, result) {
+  const currentBytes = Buffer.byteLength(message, 'utf8');
+  const overflowBytes = estimateNativeOkResponseBytes(result) - NATIVE_OK_RESPONSE_BUDGET_BYTES;
+  const targetBytes = Math.max(0, currentBytes - overflowBytes - 1024);
+  return truncateUtf8Text(message, targetBytes, '\n...[truncated to fit native response budget]');
+}
+
+function truncateUtf8Text(value, maxBytes, suffix = '') {
+  const text = String(value || '');
+  if (maxBytes <= 0) {
+    return '';
+  }
+  if (Buffer.byteLength(text, 'utf8') <= maxBytes) {
+    return text;
+  }
+  const suffixBytes = Buffer.byteLength(suffix, 'utf8');
+  const suffixToUse = suffixBytes < maxBytes ? suffix : '';
+  const bodyLimit = Math.max(0, maxBytes - Buffer.byteLength(suffixToUse, 'utf8'));
+  let output = '';
+  let outputBytes = 0;
+  for (const char of text) {
+    const charBytes = Buffer.byteLength(char, 'utf8');
+    if (outputBytes + charBytes > bodyLimit) {
+      break;
+    }
+    output += char;
+    outputBytes += charBytes;
+  }
+  return `${output}${suffixToUse}`;
+}
+
+function compactNativeResponseForBudget(result) {
+  return {
+    ...result,
+    assistantMessage: truncateUtf8Text(result.assistantMessage || '', 4096),
+    syncChanges: [],
+    unsupportedChanges: [{
+      type: 'unsupported-local-file',
+      path: '',
+      reason: 'native_response_payload_exceeds_native_message_limit',
+      nativeOutputLimit: MAX_NATIVE_OUTPUT_MESSAGE_BYTES,
+      responseBudget: NATIVE_OK_RESPONSE_BUDGET_BYTES,
+      guidance: 'The native response payload remained too large after inline payload degradation. Rerun with a narrower focus or apply the local changes directly in Overleaf.'
+    }]
+  };
+}
+
+module.exports = {
+  NATIVE_OK_RESPONSE_BUDGET_BYTES,
+  compactNativeResponseForBudget,
+  enforceNativeOkResponseBudget,
+  estimateNativeOkResponseBytes,
+  truncateUtf8Text
+};