codex-overleaf-link 2.4.1 → 2.5.1

package/native-host/src/bootstrapMigrationContract.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Exact bytes from the published v2.5.0 Bootstrap. Unknown local modifications
+// are never converted into a migration source simply because versions agree.
+const BOOTSTRAP_MIGRATION_BASELINE = Object.freeze({
+  "bootstrap/background.js": "5e15d208f07668f96cb94a84642d5fd9ad2dd921991bb3bd5bf67cc43037c87a",
+  "bootstrap/popup.css": "0709a4b8aba5e59e95fd07afec4d29ba441bde46fae48863133a170ad12cbe58",
+  "bootstrap/popup.html": "7cbcead701cb03a4006bbd682a744aeca30d613eb8315a194f2ba751b6fd9e55",
+  "bootstrap/popup.js": "24f7171045ad7de9431d24e0e4a7d15237620f4217dd5e68772dbdf52b8ce4d8",
+  "bootstrap/popupFallback.js": null,
+  "bootstrap/runtimeContext.js": "ac04d9bb28308015ecfe296f152996521398dc0bb018416e34abe8424734a21b",
+  "bootstrap/update.css": "43a0d4345f6f35a30c792a6fd67227776ec85ba710f89cae9c167b453de72342",
+  "bootstrap/update.html": "7ce092eabcdf51564f994d8f72c474285f07777bd7a5a205eca8e5a0931964ab",
+  "bootstrap/update.js": "ee67a23d89d435f05d3e4c1ec1f9c5a7f0bdcef4449e13be4d7acbbcf182413c",
+  "bootstrap/updateStatus.js": "d2ad90e78c50367a5489bb6f5c27c7248112047aca9f05d2ad868ac3b5266b24"
+});
+const BOOTSTRAP_MIGRATION_FILES = Object.freeze(Object.keys(BOOTSTRAP_MIGRATION_BASELINE));
+const BOOTSTRAP_MIGRATION_TARGET_VERSION = '2.5.1';
+const BOOTSTRAP_MIGRATION_REVISION = '3.1';
+const BOOTSTRAP_MIGRATION_IMPLEMENTATION_FILES = Object.freeze([
+  'native-host/src/bootstrapMigrationContract.js',
+  'native-host/src/bootstrapMigration.js',
+  'native-host/src/bootstrapUpdate.js',
+  'native-host/src/bootstrapUpdateWatchdog.js',
+  'extension/src/backgroundBootstrapMigration.js'
+]);
+const BOOTSTRAP_MANIFEST_SHAPE_SHA256 = '85c2d3875196ff9b334b40bb115a42fe4b8cab4e9c37609fb65e8834284c8fbe';
+
+function isBootstrapMigrationRelease(version) {
+  return version === BOOTSTRAP_MIGRATION_TARGET_VERSION;
+}
+
+function buildBootstrapMigrationDescriptor({ packageRoot, version } = {}) {
+  if (!isBootstrapMigrationRelease(version)) return null;
+  assertBootstrapManifestShape(JSON.parse(fs.readFileSync(path.join(packageRoot,
+    'extension/bootstrap/manifest.template.json'), 'utf8')), { version });
+  const files = BOOTSTRAP_MIGRATION_FILES.map(relativePath => ({
+    path: relativePath,
+    sourceSha256: BOOTSTRAP_MIGRATION_BASELINE[relativePath],
+    targetSha256: sha256(fs.readFileSync(path.join(packageRoot, 'extension', relativePath)))
+  }));
+  return validateBootstrapMigrationDescriptor({
+    schemaVersion: 1,
+    id: 'bootstrap-v3.1-from-2.5.0',
+    bootstrapProtocol: 3,
+    sourceVersions: ['2.5.0'],
+    targetVersion: version,
+    targetRevision: BOOTSTRAP_MIGRATION_REVISION,
+    files
+  }, { targetVersion: version });
+}
+
+function validateBootstrapMigrationDescriptor(descriptor, { targetVersion } = {}) {
+  if (!descriptor || descriptor.schemaVersion !== 1 || descriptor.id !== 'bootstrap-v3.1-from-2.5.0'
+    || descriptor.bootstrapProtocol !== 3 || descriptor.targetRevision !== BOOTSTRAP_MIGRATION_REVISION
+    || descriptor.targetVersion !== BOOTSTRAP_MIGRATION_TARGET_VERSION
+    || (targetVersion && descriptor.targetVersion !== targetVersion)
+    || JSON.stringify(descriptor.sourceVersions) !== JSON.stringify(['2.5.0'])
+    || !Array.isArray(descriptor.files) || descriptor.files.length !== BOOTSTRAP_MIGRATION_FILES.length) {
+    throw new Error('Unsupported Bootstrap migration descriptor.');
+  }
+  const seen = new Set();
+  for (const file of descriptor.files) {
+    if (!file || !Object.hasOwn(BOOTSTRAP_MIGRATION_BASELINE, file.path) || seen.has(file.path)
+      || file.sourceSha256 !== BOOTSTRAP_MIGRATION_BASELINE[file.path]
+      || !/^[0-9a-f]{64}$/.test(file.targetSha256 || '')) {
+      throw new Error('Bootstrap migration file identity is invalid.');
+    }
+    seen.add(file.path);
+  }
+  return descriptor;
+}
+
+function assertBootstrapManifestShape(manifest, { version } = {}) {
+  if (!manifest || (version && manifest.version !== version)
+    || sha256(Buffer.from(stableJson({ ...manifest, version: '<release-version>' }))) !== BOOTSTRAP_MANIFEST_SHAPE_SHA256) {
+    throw new Error('Bootstrap migration cannot change the extension manifest shape or permissions.');
+  }
+  return manifest;
+}
+
+function stableJson(value) {
+  if (Array.isArray(value)) return '[' + value.map(stableJson).join(',') + ']';
+  if (value && typeof value === 'object') return '{' + Object.keys(value).sort()
+    .map(key => JSON.stringify(key) + ':' + stableJson(value[key])).join(',') + '}';
+  return JSON.stringify(value);
+}
+
+function sha256(bytes) {
+  return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+
+module.exports = {
+  BOOTSTRAP_MIGRATION_BASELINE, BOOTSTRAP_MIGRATION_FILES, BOOTSTRAP_MIGRATION_TARGET_VERSION,
+  BOOTSTRAP_MIGRATION_REVISION, isBootstrapMigrationRelease, buildBootstrapMigrationDescriptor,
+  BOOTSTRAP_MIGRATION_IMPLEMENTATION_FILES, validateBootstrapMigrationDescriptor, assertBootstrapManifestShape
+};

package/native-host/src/bootstrapUpdate.js

@@ -0,0 +1,233 @@
+'use strict';
+
+// Coordination for the one compatible 2.5.0 -> 2.5.1 Bootstrap revision.
+// All mutations run under updateManager's existing cross-process lock.
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const vm = require('node:vm');
+const { spawn } = require('node:child_process');
+const Files = require('./bootstrapMigration');
+const Contract = require('./bootstrapMigrationContract');
+const { updateError } = require('./updateTrust');
+
+const BOOTSTRAP_DEADLINE_MS = 120000;
+const BOOTSTRAP_STATES = new Set(['bootstrap_pending', 'bootstrap_rolling_back']);
+const backupRoot = context => path.join(context.updatesRoot, 'bootstrap-migrations');
+const hash = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
+
+function migrationHint(context, journal) {
+  if (!journal || !['awaiting_health', ...BOOTSTRAP_STATES].includes(journal.state)) return null;
+  if (journal.bootstrapMigration) return journal.bootstrapMigration;
+  if (journal.sourceVersion !== '2.5.0' || journal.targetVersion !== '2.5.1') return null;
+  // This exact release pair requires migration even when discovery data was
+  // lost. Missing evidence must not downgrade an update into a false success.
+  return { phase: 'pending', targetRevision: '3.1' };
+}
+
+function bindBootstrapMigration(context, journal, deps) {
+  if (journal?.state !== 'awaiting_health' || journal.bootstrapMigration || !migrationHint(context, journal)) return journal;
+  const candidate = readJson(path.join(context.updatesRoot, 'candidate.json'));
+  let verificationError = '';
+  try { deps.assertAuthorization(journal); verifiedDescriptor(journal, candidate, deps); }
+  catch (error) { verificationError = error.code || 'update_bootstrap_manifest_mismatch'; }
+  const next = { ...journal, state: 'bootstrap_pending', bootstrapMigration: {
+    phase: 'pending', targetRevision: '3.1', reloadCount: 0, verificationError,
+    manifestBase64: candidate?.manifestBase64 || '', signatureBase64: candidate?.signatureBase64 || ''
+  }, updatedAt: new Date().toISOString() };
+  deps.writeJournal(next);
+  return next;
+}
+
+function verifiedDescriptor(journal, evidence, deps) {
+  const bytes = Buffer.from(evidence?.manifestBase64 || '', 'base64');
+  if (!journal.manifestSha256 || hash(bytes) !== journal.manifestSha256) {
+    throw updateError('update_bootstrap_manifest_mismatch', 'Bootstrap migration does not match the applied release.');
+  }
+  const manifest = deps.verifyManifest(bytes, Buffer.from(evidence?.signatureBase64 || '', 'base64'));
+  if (manifest.version !== journal.targetVersion || manifest.updateBundle?.sha256 !== journal.bundleSha256
+    || manifest.updateBundle?.size !== journal.bundleSize) {
+    throw updateError('update_bootstrap_manifest_mismatch', 'Bootstrap migration does not match the update archive.');
+  }
+  const descriptor = Contract.validateBootstrapMigrationDescriptor(manifest.bootstrapMigration, { targetVersion: journal.targetVersion });
+  if (!descriptor.sourceVersions.includes(journal.sourceVersion)) {
+    throw updateError('update_bootstrap_source_version_mismatch', 'This installation has no compatible Bootstrap migration.');
+  }
+  return descriptor;
+}
+
+function payloadRootFor(context, journal) {
+  return path.join(context.nativeRoot, 'versions', journal.targetVersion, 'native-host', 'bootstrap-payload');
+}
+
+function loadPlan(context, journal) {
+  const root = backupRoot(context);
+  if (!fs.existsSync(path.join(root, journal.id, 'state.json'))) return null;
+  const plan = Files.loadBootstrapMigration({ backupRoot: root, transactionId: journal.id });
+  if (plan.extensionRoot !== context.extensionRoot || plan.payloadRoot !== payloadRootFor(context, journal)
+    || plan.sourceVersion !== journal.sourceVersion || plan.targetVersion !== journal.targetVersion) {
+    throw updateError('update_bootstrap_transaction_mismatch', 'Bootstrap recovery belongs to a different installation.');
+  }
+  return plan;
+}
+
+async function advanceBootstrapMigration(context, journal, params, deps, options = {}) {
+  if (!journal || !migrationHint(context, journal)) return { state: 'not_required' };
+  if (params.transactionId !== journal.id) throw updateError('update_transaction_mismatch', 'Bootstrap update transaction changed.');
+  journal = bindBootstrapMigration(context, journal, deps);
+  if (journal.state !== 'bootstrap_pending') {
+    throw updateError('update_transaction_state_changed', 'Bootstrap migration is no longer waiting to continue.');
+  }
+  if (deps.runningVersion !== journal.targetVersion) {
+    throw updateError('update_bootstrap_native_restart_required', 'The target Native Host must start before updating Bootstrap.');
+  }
+  deps.assertAuthorization(journal);
+  const descriptor = verifiedDescriptor(journal, journal.bootstrapMigration, deps);
+  const payloadRoot = payloadRootFor(context, journal);
+  Contract.assertBootstrapManifestShape(JSON.parse(fs.readFileSync(path.join(context.extensionRoot, 'manifest.json'), 'utf8')),
+    { version: journal.targetVersion });
+  Contract.assertBootstrapManifestShape(JSON.parse(fs.readFileSync(path.join(payloadRoot, 'manifest.template.json'), 'utf8')),
+    { version: journal.targetVersion });
+  // A syntax failure must be found before changing the only background entry.
+  for (const file of descriptor.files) {
+    const bytes = fs.readFileSync(path.join(payloadRoot, file.path));
+    if (hash(bytes) !== file.targetSha256) throw updateError('update_bootstrap_payload_mismatch', 'Bootstrap payload changed after verification.');
+    if (file.path.endsWith('.js')) new vm.Script(bytes.toString('utf8'), { filename: file.path });
+  }
+  deps.verifyArchive(journal);
+  let plan = loadPlan(context, journal);
+  if (!plan) plan = Files.prepareBootstrapMigration({
+    descriptor, payloadRoot, extensionRoot: context.extensionRoot, backupRoot: backupRoot(context),
+    transactionId: journal.id, sourceVersion: journal.sourceVersion, targetVersion: journal.targetVersion
+  });
+  if (plan.descriptorSha256 !== hash(JSON.stringify(descriptor))) {
+    throw updateError('update_bootstrap_manifest_mismatch', 'Bootstrap recovery material does not match the signed release.');
+  }
+  let migration = { ...journal.bootstrapMigration, phase: plan.state === 'applied' ? 'applied' : 'prepared',
+    targetDigest: plan.targetDigest, sourceDigest: plan.sourceDigest,
+    deadline: journal.bootstrapMigration.deadline || Date.now() + BOOTSTRAP_DEADLINE_MS };
+  if (Date.now() >= migration.deadline) throw updateError('update_bootstrap_health_timeout', 'Bootstrap update did not finish within its health window.');
+  journal = { ...journal, bootstrapMigration: migration };
+  deps.writeJournal(journal);
+  // A new connection always establishes a new monitor handshake. PID reuse
+  // alone can never authorize writing the only browser background entry.
+  {
+    const token = crypto.randomUUID();
+    migration = { ...migration, watchdogToken: token, watchdogPid: null };
+    journal = { ...journal, bootstrapMigration: migration };
+    deps.writeJournal(journal);
+    const pid = await (options.startWatchdog || startWatchdog)(context, journal, token);
+    migration = { ...migration, watchdogPid: pid };
+    journal = { ...journal, bootstrapMigration: migration };
+    deps.writeJournal(journal);
+  }
+  Files.applyBootstrapMigration(plan, options.fileHooks);
+  const observed = Files.verifyBootstrapMigration(plan);
+  migration = { ...migration, phase: 'applied', targetDigest: observed.digest };
+  if (params.bootstrapRevision === descriptor.targetRevision) {
+    migration = { ...migration, phase: 'loaded', loadedAt: new Date().toISOString() };
+    deps.writeJournal({ ...journal, state: 'awaiting_health', bootstrapMigration: migration });
+    return { state: 'awaiting_health', transactionId: journal.id, targetVersion: journal.targetVersion,
+      bootstrapRevision: descriptor.targetRevision };
+  }
+  if (migration.reloadCount >= 2) throw updateError('update_bootstrap_reload_failed', 'The new Bootstrap did not load after extension restart.');
+  migration.reloadCount += 1;
+  deps.writeJournal({ ...journal, bootstrapMigration: migration });
+  return { state: 'reload_required', transactionId: journal.id, targetVersion: journal.targetVersion,
+    bootstrapRevision: descriptor.targetRevision };
+}
+
+function assertBootstrapConfirmation(context, journal, params) {
+  if (!journal.bootstrapMigration) {
+    if (migrationHint(context, journal)) throw updateError('update_bootstrap_confirmation_pending', 'Bootstrap migration is still pending.');
+    return;
+  }
+  if (journal.bootstrapMigration.phase !== 'loaded' || params.bootstrapRevision !== journal.bootstrapMigration.targetRevision) {
+    throw updateError('update_bootstrap_confirmation_pending', 'The loaded Bootstrap did not confirm the target revision.');
+  }
+  const plan = loadPlan(context, journal);
+  if (!plan || Files.verifyBootstrapMigration(plan).digest !== journal.bootstrapMigration.targetDigest) {
+    throw updateError('update_bootstrap_target_mismatch', 'The confirmed Bootstrap bytes no longer match the target.');
+  }
+}
+
+function restoreBootstrap(context, journal) {
+  const plan = loadPlan(context, journal);
+  if (!plan) {
+    if (journal.bootstrapMigration && journal.bootstrapMigration.phase !== 'pending') {
+      throw updateError('update_bootstrap_record_missing', 'Bootstrap recovery material is missing.');
+    }
+    if (journal.bootstrapMigration) return assertSourceBootstrap(context, journal);
+  }
+  return plan ? Files.restoreBootstrapMigration(plan) : null;
+}
+
+function bootstrapEvidence(context, journal, expected) {
+  const plan = loadPlan(context, journal);
+  if (!plan && journal.bootstrapMigration) {
+    if (expected !== 'source' || !(journal.bootstrapMigration.phase === 'pending'
+      || journal.bootstrapMigration.phase === 'restored' && journal.bootstrapMigration.sourceUnchanged === true)) {
+      throw updateError('update_bootstrap_record_missing', 'Bootstrap recovery material is missing.');
+    }
+    return assertSourceBootstrap(context, journal);
+  }
+  return plan ? Files.verifyBootstrapMigration(plan, { expected }) : null;
+}
+
+function assertSourceBootstrap(context, journal) {
+  for (const [relative, expected] of Object.entries(Contract.BOOTSTRAP_MIGRATION_BASELINE)) {
+    const filename = path.join(context.extensionRoot, relative);
+    if (expected === null ? fs.existsSync(filename)
+      : !fs.existsSync(filename) || !fs.lstatSync(filename).isFile() || hash(fs.readFileSync(filename)) !== expected) {
+      throw updateError('update_bootstrap_source_mismatch', 'Bootstrap source bytes cannot be confirmed.');
+    }
+  }
+  const entries = Object.entries(Contract.BOOTSTRAP_MIGRATION_BASELINE).sort((a, b) => a[0].localeCompare(b[0]));
+  return { transactionId: journal.id, migrationId: 'bootstrap-v3.1-from-2.5.0',
+    state: 'restored', expected: 'source', digest: hash(JSON.stringify(entries)), unmodified: true };
+}
+
+function bootstrapExpired(journal, { recoveryRequested = false, context } = {}) {
+  const migration = journal?.bootstrapMigration;
+  if (!migration || !['bootstrap_pending', 'bootstrap_rolling_back', 'awaiting_health'].includes(journal.state)) return false;
+  return journal.state === 'bootstrap_rolling_back'
+    || (migration.deadline && Date.now() >= migration.deadline)
+    || (recoveryRequested && migration.phase !== 'pending' && !watchdogAlive(migration, context, journal));
+}
+
+function watchdogAlive(migration, context, journal) {
+  if (!Number.isInteger(migration?.watchdogPid) || migration.watchdogPid < 1) return false;
+  const heartbeat = context && journal && readJson(path.join(backupRoot(context), journal.id, 'watchdog.json'));
+  if (!heartbeat || heartbeat.token !== migration.watchdogToken || heartbeat.pid !== migration.watchdogPid
+    || heartbeat.transactionId !== journal.id || Date.now() - heartbeat.at > 2500 || heartbeat.at > Date.now() + 1000) return false;
+  try { process.kill(migration.watchdogPid, 0); return true; } catch (error) { return error.code === 'EPERM'; }
+}
+
+function startWatchdog(context, journal, token) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(__dirname, 'bootstrapUpdateWatchdog.js'),
+      context.nativeRoot, context.extensionRoot, journal.id, token], {
+      env: { ...context.env }, detached: true, windowsHide: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc']
+    });
+    const timer = setTimeout(() => fail(new Error('Bootstrap recovery monitor did not become ready.')), 5000);
+    let settled = false;
+    function fail(error) {
+      if (settled) return;
+      settled = true; clearTimeout(timer);
+      try { child.kill(); } catch (_) { /* A failed child may already be gone. */ }
+      reject(Object.assign(error, { code: 'update_bootstrap_monitor_unavailable' }));
+    }
+    child.on('error', fail);
+    child.on('exit', () => { if (!settled) fail(new Error('Bootstrap recovery monitor exited before readiness.')); });
+    child.on('message', message => {
+      if (settled || message?.type !== 'ready' || message.token !== token || message.pid !== child.pid) return;
+      settled = true; clearTimeout(timer); child.disconnect(); child.unref(); resolve(child.pid);
+    });
+  });
+}
+
+function readJson(filename) { try { return JSON.parse(fs.readFileSync(filename, 'utf8')); } catch (_) { return null; } }
+
+module.exports = { BOOTSTRAP_DEADLINE_MS, BOOTSTRAP_STATES, migrationHint, bindBootstrapMigration,
+  advanceBootstrapMigration, assertBootstrapConfirmation, restoreBootstrap, bootstrapEvidence,
+  bootstrapExpired, watchdogAlive };

package/native-host/src/bootstrapUpdateWatchdog.js

@@ -0,0 +1,44 @@
+'use strict';
+
+// Independent of the browser worker being replaced. The Native update lock
+// serializes timeout recovery with normal health confirmation.
+const fs = require('node:fs');
+const path = require('node:path');
+const [nativeRoot, extensionRoot, transactionId, token] = process.argv.slice(2);
+const { recoverBootstrapTransaction } = require('./updateManager');
+if (typeof recoverBootstrapTransaction !== 'function') throw new Error('Bootstrap recovery entry is unavailable.');
+const env = { ...process.env, CODEX_OVERLEAF_MANAGED: '1',
+  CODEX_OVERLEAF_MANAGED_NATIVE_ROOT: nativeRoot, CODEX_OVERLEAF_MANAGED_EXTENSION_ROOT: extensionRoot };
+let busy = false;
+let failures = 0;
+function heartbeat() {
+  const directory = path.join(nativeRoot, 'updates', 'bootstrap-migrations', transactionId);
+  const temporary = path.join(directory, 'watchdog-' + process.pid + '.tmp');
+  fs.writeFileSync(temporary, JSON.stringify({ transactionId, token, pid: process.pid, at: Date.now() }), { mode: 0o600 });
+  fs.renameSync(temporary, path.join(directory, 'watchdog.json'));
+}
+const timer = setInterval(async () => {
+  if (busy) return;
+  busy = true;
+  try {
+    const journal = JSON.parse(fs.readFileSync(path.join(nativeRoot, 'updates', 'transaction.json'), 'utf8'));
+    if (journal.id !== transactionId || journal.bootstrapMigration?.watchdogToken !== token
+      || ['committed', 'superseded'].includes(journal.state)
+      || journal.state === 'rolled_back' && !journal.sourceActivationPending) {
+      clearInterval(timer); return;
+    }
+    heartbeat();
+    if (journal.sourceActivationPending || journal.bootstrapMigration?.deadline && Date.now() >= journal.bootstrapMigration.deadline) {
+      await recoverBootstrapTransaction({ env }, transactionId, token);
+      clearInterval(timer);
+    }
+  } catch (_) {
+    // Retry boundedly if a filesystem/lock is temporarily unavailable. Recovery
+    // material remains durable for the next Native start or popup recovery probe.
+    if (++failures >= 20) clearInterval(timer);
+  } finally { busy = false; }
+}, 500);
+const initial = JSON.parse(fs.readFileSync(path.join(nativeRoot, 'updates', 'transaction.json'), 'utf8'));
+if (initial.id !== transactionId || initial.bootstrapMigration?.watchdogToken !== token) throw new Error('Bootstrap recovery identity changed.');
+heartbeat();
+process.send?.({ type: 'ready', token, pid: process.pid });

package/native-host/src/chatBridgeResponse.js

@@ -295,6 +295,7 @@ function completeMessage(state, res) {
 }
 
 function completeTool(state, res, tool) {
+  assertCompleteToolArguments(tool.arguments);
   if (!tool.opened) openTool(state, res, tool);
   tool.item.status = 'completed';
   if (tool.kind === 'custom') {
@@ -419,6 +420,7 @@ function normalizeToolCalls(values, toolKinds) {
     const name = normalizeText(value?.function?.name) || 'tool';
     const callId = normalizeText(value?.id) || randomId('call');
     const argumentsText = normalizeText(value?.function?.arguments) || '{}';
+    assertCompleteToolArguments(argumentsText);
     const spec = toolKinds?.get(name);
     const kind = (typeof spec === 'object' ? spec.kind : spec) === 'custom' ? 'custom' : 'function';
     const originalName = typeof spec === 'object' ? spec.name || name : name;
@@ -533,6 +535,14 @@ function unwrapCustomArguments(value) {
   }
 }
 
+function assertCompleteToolArguments(value) {
+  try {
+    JSON.parse(value || '{}');
+  } catch (_error) {
+    throw responseError('The provider returned incomplete or invalid JSON tool arguments.');
+  }
+}
+
 function reserveItem(state, item) {
   const index = state.items.length;
   state.items.push(item);

package/native-host/src/chatCompletionsBridge.js

@@ -11,6 +11,7 @@ const {
 const { requiresReasoningContentReplay } = require('./providerReasoning');
 const { classifyResponsesRoute } = require('./providerBridgeRoutes');
 const { providerError } = require('./providerProfile');
+const { fetchProvider, readProviderText, readProviderJson } = require('./providerHttp');
 const { sanitizeProviderMessage } = require('./providerRedaction');
 const { logDebug } = require('./debugLog');
 const {
@@ -118,15 +119,19 @@ async function handleRequest({
   const startedAt = Date.now();
   const previousResponseId = String(requestBody.previous_response_id || '');
   const previous = history.get(previousResponseId);
-  const fallbackAnchor = previous
+  const fallbackAllowed = !previousResponseId || previousResponseId === continuationState.responseId;
+  const fallbackAnchor = previous || !fallbackAllowed
     ? []
     : continuationState.anchorMessages;
+  const continuationAttempts = previous
+    ? Number(previous.continuationAttempts) || 0
+    : fallbackAllowed ? continuationState.attempts : 0;
   const translated = buildChatRequest({
     requestBody,
     launch,
     historyMessages: previous?.messages || fallbackAnchor
   });
-  assertReasoningContinuationBudget(translated.messages, continuationState.attempts);
+  assertReasoningContinuationBudget(translated.messages, continuationAttempts);
   const idleTimeoutMs = resolveProviderIdleTimeoutMs(launch);
   const totalTimeoutMs = resolveProviderTotalTimeoutMs(launch, idleTimeoutMs);
   logDebug('provider.bridge.request', {
@@ -141,7 +146,7 @@ async function handleRequest({
     usedFallbackAnchor: fallbackAnchor.length > 0,
     inputItemCount: Array.isArray(requestBody.input) ? requestBody.input.length : requestBody.input ? 1 : 0,
     messageCount: translated.messages.length,
-    continuationAttempts: continuationState.attempts,
+    continuationAttempts,
     idleTimeoutMs,
     totalTimeoutMs
   });
@@ -161,15 +166,15 @@ async function handleRequest({
   res.on('close', onClientClose);
   lifecycle.start();
   try {
-    const upstream = await fetch(buildChatCompletionsUrl(launch.baseUrl, launch), {
+    const upstream = await fetchProvider(buildChatCompletionsUrl(launch.baseUrl, launch), {
       method: 'POST',
       headers: buildUpstreamHeaders(launch),
       body: JSON.stringify(translated.body),
       signal: controller.signal
-    });
+    }, launch);
     lifecycle.touch();
     if (!upstream.ok) {
-      await forwardUpstreamError(upstream, res, launch.apiKey);
+      await forwardUpstreamError(upstream, res, launch.apiKey, lifecycle.touch);
       return;
     }
     const context = {
@@ -193,7 +198,7 @@ async function handleRequest({
         : 0;
       if (anchored) {
         continuationState.anchorMessages = continuation;
-        continuationState.attempts += 1;
+        continuationState.attempts = continuationAttempts + 1;
         continuationState.responseId = converted.response.id;
       } else {
         continuationState.anchorMessages = [];
@@ -217,7 +222,7 @@ async function handleRequest({
       rememberHistory(history, converted.response.id, [
         ...translated.messages,
         ...continuation
-      ]);
+      ], { continuationAttempts: anchored ? continuationAttempts + 1 : 0 });
     };
     if (requestBody.stream !== false) {
       const contentType = String(upstream.headers.get('content-type') || '').toLowerCase();
@@ -231,11 +236,11 @@ async function handleRequest({
           recoverInterrupted: lifecycle.recoverInterrupted
         });
       } else {
-        const converted = convertChatResponse(await upstream.json(), context);
+        const converted = convertChatResponse(await readProviderJson(upstream, lifecycle.touch), context);
         writeConvertedResponseAsSse(res, converted, context, remember);
       }
     } else {
-      const converted = convertChatResponse(await upstream.json(), context);
+      const converted = convertChatResponse(await readProviderJson(upstream, lifecycle.touch), context);
       remember(converted);
       sendJson(res, 200, converted.response);
     }
@@ -376,7 +381,8 @@ function normalizeBridgeErrorCode(value) {
     'provider_agent_tools_incompatible',
     'provider_reasoning_continuation_exhausted',
     'provider_stream_tool_parse_failed',
-    'provider_protocol_incompatible'
+    'provider_protocol_incompatible',
+    'provider_upstream_error'
   ].includes(value) ? value : 'provider_bridge_failed';
 }
 
@@ -386,8 +392,8 @@ function bridgeErrorMessage(code) {
     : 'The local provider bridge failed.';
 }
 
-async function forwardUpstreamError(upstream, res, apiKey) {
-  const text = (await upstream.text()).slice(0, MAX_ERROR_BYTES);
+async function forwardUpstreamError(upstream, res, apiKey, onActivity) {
+  const text = (await readProviderText(upstream, onActivity)).slice(0, MAX_ERROR_BYTES);
   let message = `Provider returned HTTP ${upstream.status}.`;
   try {
     const parsed = JSON.parse(text);
@@ -396,9 +402,9 @@ async function forwardUpstreamError(upstream, res, apiKey) {
   sendJsonError(res, upstream.status, 'provider_upstream_error', sanitizeProviderMessage(message, [apiKey]));
 }
 
-function rememberHistory(history, responseId, messages) {
+function rememberHistory(history, responseId, messages, metadata = {}) {
   history.delete(responseId);
-  history.set(responseId, { messages });
+  history.set(responseId, { messages, ...metadata });
   while (history.size > MAX_HISTORY_ENTRIES) {
     history.delete(history.keys().next().value);
   }

package/native-host/src/codexConfigPaths.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const path = require('node:path');
+const { splitTomlStatements, readTomlStatementPath } = require('./tomlStatements');
+
+// These fields are paths resolved against the defining configuration layer by
+// Codex. Moving that layer into an execution scope must preserve its old anchor.
+const ROOT_PATHS = new Set(['sqlite_home', 'log_dir', 'model_catalog_json', 'model_instructions_file', 'experimental_compact_prompt_file']);
+const PROFILE_PATHS = new Set(['model_catalog_json', 'model_instructions_file', 'experimental_compact_prompt_file']);
+const TLS_PATHS = new Set(['ca-certificate', 'client-certificate', 'client-private-key']);
+
+function isConfigPath(keys) {
+  if (keys.length === 1 && ROOT_PATHS.has(keys[0])) return true;
+  if (keys.length === 3 && keys[0] === 'profiles' && PROFILE_PATHS.has(keys[2])) return true;
+  if (keys.length === 3 && keys[0] === 'agents' && keys[2] === 'config_file') return true;
+  if (keys.length === 3 && keys[0] === 'skills' && keys[1] === 'config' && keys[2] === 'path') return true;
+  if (keys.length === 2 && keys[0] === 'sandbox_workspace_write' && keys[1] === 'writable_roots') return true;
+  if (keys.length === 4 && keys[0] === 'model_providers' && keys[2] === 'auth' && keys[3] === 'cwd') return true;
+  return keys[0] === 'otel' && keys.includes('tls') && TLS_PATHS.has(keys.at(-1));
+}
+
+function rebaseCodexConfigPaths(content, originalDirectory) {
+  let section = [];
+  return splitTomlStatements(content).map(statement => {
+    const parsed = readTomlStatementPath(statement);
+    if (!parsed) return statement;
+    if (parsed.table) { section = parsed.keys; return statement; }
+    const edits = [];
+    visitValue(statement, parsed.valueStart, [...section, ...parsed.keys], edits, originalDirectory);
+    for (const edit of edits.reverse()) statement = statement.slice(0, edit.start) + edit.text + statement.slice(edit.end);
+    return statement;
+  }).join('');
+}
+
+function skipTrivia(text, position) {
+  while (position < text.length) {
+    if (/\s/.test(text[position])) { position++; continue; }
+    if (text[position] !== '#') break;
+    while (position < text.length && text[position] !== '\n') position++;
+  }
+  return position;
+}
+
+function visitValue(text, start, keys, edits, directory) {
+  start = skipTrivia(text, start);
+  if (text[start] === '"' || text[start] === "'") {
+    const value = readString(text, start);
+    if (isConfigPath(keys) && !path.isAbsolute(value.value) && !/^~(?:[/\\]|$)/.test(value.value) && !/^[a-z][a-z\d+.-]*:\/\//i.test(value.value)) {
+      edits.push({ start, end: value.end, text: JSON.stringify(path.resolve(directory, value.value)) });
+    }
+    return value.end;
+  }
+  if (text[start] === '[' || text[start] === '{') {
+    const table = text[start] === '{', end = table ? '}' : ']';
+    let cursor = start + 1;
+    while ((cursor = skipTrivia(text, cursor)) < text.length && text[cursor] !== end) {
+      let childKeys = keys;
+      if (table) {
+        const key = readTomlStatementPath(text.slice(cursor));
+        if (!key || key.table) throw new Error('Codex configuration contains an invalid inline TOML key.');
+        childKeys = [...keys, ...key.keys]; cursor += key.valueStart;
+      }
+      const next = visitValue(text, cursor, childKeys, edits, directory);
+      if (next <= cursor) break;
+      cursor = skipTrivia(text, next);
+      if (text[cursor] === ',') cursor++;
+    }
+    return cursor + 1;
+  }
+  let end = start;
+  while (end < text.length && ![',', ']', '}', '#', '\n'].includes(text[end])) end++;
+  return end;
+}
+
+function readString(text, start) {
+  const quote = text[start], triple = text.slice(start, start + 3) === quote.repeat(3);
+  let cursor = start + (triple ? 3 : 1), raw = '';
+  if (triple && text[cursor] === '\n') cursor++;
+  while (cursor < text.length) {
+    if (text[cursor] === quote && (!triple || text.slice(cursor, cursor + 3) === quote.repeat(3))) {
+      let count = triple ? 3 : 1;
+      if (triple) while (count < 5 && text[cursor + count] === quote) count++;
+      raw += triple ? quote.repeat(count - 3) : '';
+      return { value: raw, end: cursor + count };
+    }
+    const char = text[cursor++];
+    if (quote !== '"' || char !== '\\') { raw += char; continue; }
+    const escaped = text[cursor++];
+    if (triple && /\s/.test(escaped)) {
+      while (/\s/.test(text[cursor] || '') && cursor < text.length) cursor++;
+      continue;
+    }
+    const simple = { b: '\b', t: '\t', n: '\n', f: '\f', r: '\r', '"': '"', '\\': '\\' };
+    if (Object.prototype.hasOwnProperty.call(simple, escaped)) { raw += simple[escaped]; continue; }
+    const count = escaped === 'u' ? 4 : escaped === 'U' ? 8 : 0;
+    const hex = text.slice(cursor, cursor + count);
+    const point = Number.parseInt(hex, 16);
+    if (!count || !/^[\da-f]+$/i.test(hex) || hex.length !== count || point > 0x10ffff || (point >= 0xd800 && point <= 0xdfff)) {
+      throw new Error('Codex configuration contains an invalid TOML string escape.');
+    }
+    raw += String.fromCodePoint(point); cursor += count;
+  }
+  throw new Error('Codex configuration contains an unterminated TOML string.');
+}
+
+module.exports = { rebaseCodexConfigPaths };