fix(codex): edit Codex config.toml through one parser-checked writer (1/2)

config/packaged-runtime-node-modules.cjs

@@ -28,6 +28,8 @@ const PACKAGED_RUNTIME_PACKAGE_ROOTS = [
   // serve-sim (for CLI JS entry + closure + state/middleware + to make packaged require('serve-sim') + its internal relatives work; mirrors other runtime JS like ws/yaml/zod. Natives/dylibs still via extraResources + the node_modules/serve-sim copy in resources from builder. Client if added too.
   'serve-sim',
   'qrcode',
+  // smol-toml: Codex config.toml reads/validation in main and the CLI.
+  'smol-toml',
   'ssh2',
   'tweetnacl',
   'ws',

config/scripts/relay-codex-config-toml-bundle.test.mjs

@@ -0,0 +1,89 @@
+import { build } from 'esbuild'
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { parse } from 'smol-toml'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+// Why: relay hosts run the esbuild bundle with no node_modules, so the Codex config
+// parser must be inlined; a runtime-resolved require only fails on a real SSH host.
+let root
+let applyRelayAgentWorkspaceTrust
+
+beforeAll(async () => {
+  root = realpathSync.native(mkdtempSync(join(tmpdir(), 'orca-relay-codex-toml-')))
+  const outfile = join(root, 'bundle', 'agent-workspace-trust-spawn.js')
+  // Same options as build-relay.mjs uses for relay.js.
+  await build({
+    entryPoints: [resolve('src/relay/agent-workspace-trust-spawn.ts')],
+    outfile,
+    bundle: true,
+    platform: 'node',
+    target: 'node18',
+    format: 'cjs',
+    external: ['node-pty', '@parcel/watcher', 'electron'],
+    logLevel: 'silent'
+  })
+  ;({ applyRelayAgentWorkspaceTrust } = createRequire(outfile)(outfile))
+})
+
+afterAll(() => {
+  rmSync(root, { recursive: true, force: true })
+})
+
+describe('relay bundle Codex trust write', () => {
+  it('loads outside any node_modules and edits a quoted ["projects"."…"] table in place', async () => {
+    const codexHome = join(root, 'codex-home')
+    const workspace = join(root, 'wt')
+    mkdirSync(codexHome)
+    mkdirSync(workspace)
+    const configPath = join(codexHome, 'config.toml')
+    writeFileSync(configPath, `["projects"."${workspace}"]\ntrust_level = "untrusted"\n`)
+
+    await applyRelayAgentWorkspaceTrust(
+      { workspacePath: workspace },
+      'codex',
+      { HOME: root, CODEX_HOME: codexHome },
+      { wslShell: false }
+    )
+
+    expect(readFileSync(configPath, 'utf-8')).toBe(
+      `["projects"."${workspace}"]\ntrust_level = "trusted"\n`
+    )
+  })
+
+  it('repairs a duplicate an older Orca wrote using only Node 18 array methods', async () => {
+    const codexHome = join(root, 'codex-home-node18')
+    const workspace = join(root, 'wt-node18')
+    mkdirSync(codexHome)
+    mkdirSync(workspace)
+    const configPath = join(codexHome, 'config.toml')
+    writeFileSync(
+      configPath,
+      `["projects"."${workspace}"]\ntrust_level = "trusted"\n\n[projects."${workspace}"]\ntrust_level = "trusted"\n`
+    )
+    // Why: SSH hosts may run the relay on Node 18, which lacks the Node 20 copy-array methods.
+    const node20Methods = ['toReversed', 'toSorted', 'toSpliced', 'with']
+    const saved = node20Methods.map((name) => [name, Array.prototype[name]])
+    for (const name of node20Methods) {
+      delete Array.prototype[name]
+    }
+    try {
+      await applyRelayAgentWorkspaceTrust(
+        { workspacePath: workspace },
+        'codex',
+        { HOME: root, CODEX_HOME: codexHome },
+        { wslShell: false }
+      )
+    } finally {
+      for (const [name, method] of saved) {
+        Array.prototype[name] = method
+      }
+    }
+
+    const repaired = readFileSync(configPath, 'utf-8')
+    expect(parse(repaired).projects[workspace].trust_level).toBe('trusted')
+    expect(repaired.match(/trust_level/g)).toHaveLength(1)
+  })
+})

config/tsconfig.cli.json

@@ -117,7 +117,13 @@
     "../src/main/codex/codex-app-server-record-reader.ts",
     "../src/main/codex/codex-app-server-session.ts",
     "../src/main/codex/codex-config-mirror.ts",
+    "../src/main/codex/codex-config-legacy-shared-home-mirror.ts",
     "../src/main/codex/codex-config-mirror-merge.ts",
+    "../src/main/codex/codex-config-mirror-source.ts",
+    "../src/main/codex/codex-config-toml-checked-edit.ts",
+    "../src/main/codex/codex-config-toml-document.ts",
+    "../src/main/codex/codex-config-toml-repair.ts",
+    "../src/main/codex/codex-config-toml-structure.ts",
     "../src/main/codex/codex-config-path-reference-rewrite.ts",
     "../src/main/codex/codex-config-settings-preservation.ts",
     "../src/main/codex/codex-config-settings-removal.ts",
@@ -153,6 +159,7 @@
     "../src/main/codex/codex-real-home-hook-sweep.ts",
     "../src/main/codex/codex-real-home-hook-withdrawal.ts",
     "../src/main/codex/codex-real-home-hooks-json.ts",
+    "../src/main/codex/codex-retired-hook-sweep-trust.ts",
     "../src/main/codex/codex-state-db.ts",
     "../src/main/codex/codex-trust-identity.ts",
     "../src/main/codex/codex-trust-config-mutation-queue.ts",

package.json

@@ -193,6 +193,7 @@
     "react-i18next": "17.0.15",
     "serve-sim": "0.1.40",
     "sherpa-onnx": "1.12.37",
+    "smol-toml": "1.8.0",
     "ssh2": "^1.17.0",
     "tldts": "7.4.14",
     "tweetnacl": "^1.0.3",

src/main/agent-trust-presets.test.ts

@@ -392,6 +392,38 @@ describe('markCodexProjectTrusted', () => {
     }
   })
 
+  // Why both orders: the lock order writes the managed home first, so each home must survive the other refusing.
+  it.each([
+    ['the managed home', '~/.codex', 'system'],
+    ['~/.codex', 'the managed home', 'runtime']
+  ] as const)('still trusts %s when %s cannot be parsed', async (_trusted, _broken, brokenHome) => {
+    const workspace = mkdtempSync(join(tmpdir(), 'orca-codex-ws-'))
+    try {
+      const homes = {
+        system: join(testState.fakeHomeDir, '.codex'),
+        runtime: join(testState.userDataDir, 'codex-runtime-home', 'home')
+      }
+      const trustedHome = brokenHome === 'system' ? homes.runtime : homes.system
+      mkdirSync(homes[brokenHome], { recursive: true })
+      const brokenConfig = 'model = "o3"\nmodel_reasoning_effort = \n'
+      writeFileSync(join(homes[brokenHome], 'config.toml'), brokenConfig, 'utf-8')
+
+      await expect(
+        markCodexProjectTrusted(workspace, getLocalCodexTrustConfigFiles(testState.fakeHomeDir))
+      ).rejects.toMatchObject({
+        name: 'CodexConfigTomlEditRefusedError',
+        reason: 'input-invalid'
+      })
+
+      expect(readFileSync(join(homes[brokenHome], 'config.toml'), 'utf-8')).toBe(brokenConfig)
+      expect(readFileSync(join(trustedHome, 'config.toml'), 'utf-8')).toContain(
+        `[projects."${escapeTomlBasicString(realpathSync.native(workspace))}"]`
+      )
+    } finally {
+      rmSync(workspace, { recursive: true, force: true })
+    }
+  })
+
   it('preserves existing config keys and updates an existing project block', async () => {
     const workspace = mkdtempSync(join(tmpdir(), 'orca-codex-ws-'))
     const realpath = realpathSync.native(workspace)

src/main/agent-trust-presets.ts

@@ -176,8 +176,23 @@ export function markCodexProjectTrusted(
   const write = configFiles.reduceRight<() => Promise<void>>(
     (inner, configFile) => () => runExclusivelyForCodexTrustConfig(configFile, inner),
     async () => {
+      // Why: a config.toml Orca refuses to edit must not also leave Codex's other homes untrusted.
+      const failures: unknown[] = []
       for (const configFile of configFiles) {
-        upsertProjectTrustLevel(configFile, absPath, 'trusted')
+        try {
+          upsertProjectTrustLevel(configFile, absPath, 'trusted')
+        } catch (error) {
+          failures.push(error)
+        }
+      }
+      if (failures.length === 1) {
+        throw failures[0]
+      }
+      if (failures.length > 1) {
+        throw new AggregateError(
+          failures,
+          'Orca could not mark the project trusted in several Codex homes'
+        )
       }
     }
   )

src/main/codex/codex-config-legacy-shared-home-mirror.ts

@@ -0,0 +1,80 @@
+import { join } from 'node:path'
+import {
+  recoverInterruptedGuardedFileOperation,
+  writeFileAtomicallyIfUnchanged
+} from '../codex-accounts/fs-utils'
+import { observeAgentStateFile } from './codex-path-observation'
+import { getOrcaManagedCodexHomePath, getSystemCodexHomePath } from './codex-home-paths'
+import type { CodexSettingsPromotionHomes } from './config-settings-promotion'
+import { applyCodexDaemonSocketGuard } from './codex-daemon-socket-path-guard'
+import { refuseUnreadableCodexConfigResult } from './codex-config-toml-checked-edit'
+import { mergeSystemCodexConfigIntoRuntime } from './codex-config-mirror-merge'
+import {
+  prepareSystemConfigForFreshRuntimeMirror,
+  prepareSystemConfigForRuntimeMirror,
+  resolveCodexConfigMirrorSourceDirectory
+} from './codex-config-mirror-source'
+
+/**
+ * Refreshes the retired shared home for PTYs that survived real-home rollout.
+ *
+ * This is deliberately one-way: a retained PTY may hold pre-rollout settings,
+ * so treating that home as a promotion source could overwrite the live config.
+ */
+export function syncSystemConfigIntoLegacySharedCodexHome(
+  homes: CodexSettingsPromotionHomes = {
+    runtimeHomePath: getOrcaManagedCodexHomePath(),
+    systemHomePath: getSystemCodexHomePath()
+  }
+): void {
+  const systemConfigPath = join(homes.systemHomePath, 'config.toml')
+  const runtimeConfigPath = join(homes.runtimeHomePath, 'config.toml')
+  recoverInterruptedGuardedFileOperation(runtimeConfigPath)
+  const systemConfigObservation = observeAgentStateFile(systemConfigPath)
+  if (systemConfigObservation.kind === 'indeterminate') {
+    throw systemConfigObservation.error
+  }
+  const rawSystemConfig =
+    systemConfigObservation.kind === 'present' ? systemConfigObservation.value : ''
+  const runtimeConfigObservation = observeAgentStateFile(runtimeConfigPath)
+  if (runtimeConfigObservation.kind === 'indeterminate') {
+    throw runtimeConfigObservation.error
+  }
+  const runtimeConfigBeforeMirror =
+    runtimeConfigObservation.kind === 'present' ? runtimeConfigObservation.value : null
+  // Why: a missing cloud-synced source is not proof the user cleared config.
+  let mirroredRuntimeConfig = runtimeConfigBeforeMirror ?? ''
+  if (rawSystemConfig.trim() !== '') {
+    const sourceConfigDir = resolveCodexConfigMirrorSourceDirectory(homes.systemHomePath)
+    // The retired home has no ownership baseline; its entire MCP root stays canonical.
+    mirroredRuntimeConfig =
+      runtimeConfigBeforeMirror !== null
+        ? mergeSystemCodexConfigIntoRuntime(
+            runtimeConfigBeforeMirror,
+            prepareSystemConfigForRuntimeMirror(rawSystemConfig, sourceConfigDir),
+            sourceConfigDir,
+            new Set(),
+            true
+          )
+        : prepareSystemConfigForFreshRuntimeMirror(rawSystemConfig, sourceConfigDir)
+  }
+  // Why: retained pre-rollout panes still use this home, so a refresh must keep the daemon guard.
+  const nextRuntimeConfig = applyCodexDaemonSocketGuard(
+    mirroredRuntimeConfig,
+    homes.runtimeHomePath
+  )
+  if (
+    (runtimeConfigBeforeMirror ?? '') === nextRuntimeConfig ||
+    refuseUnreadableCodexConfigResult({
+      configPath: runtimeConfigPath,
+      result: nextRuntimeConfig,
+      inputs: [rawSystemConfig, runtimeConfigBeforeMirror],
+      context: 'Skipped mirroring the Codex config into a managed home'
+    })
+  ) {
+    return
+  }
+  // Why: stage first, then compare immediately before replace so a retained
+  // Codex trust write during mirror preparation wins.
+  writeFileAtomicallyIfUnchanged(runtimeConfigPath, runtimeConfigBeforeMirror, nextRuntimeConfig)
+}