propagate shell config from config file to exec command

- Introduced DEFAULT_SHELL_MAX_BYTES and DEFAULT_SHELL_MAX_LINES for shell output limits.
- Updated loadConfig and saveConfig to handle new shell settings.
- Modified exec functions to utilize shell output limits from config.
- Added tests to verify loading and saving of custom shell configurations.

Author: syllogismos

codex-cli/src/utils/agent/exec.ts

@@ -1,3 +1,4 @@
+import type { AppConfig } from "../config.js";
 import type { ExecInput, ExecResult } from "./sandbox/interface.js";
 import type { SpawnOptions } from "child_process";
 import type { ParseEntry } from "shell-quote";
@@ -41,6 +42,7 @@ export function exec(
   }: ExecInput & { additionalWritableRoots: ReadonlyArray<string> },
   sandbox: SandboxType,
   abortSignal?: AbortSignal,
+  config?: AppConfig,
 ): Promise<ExecResult> {
   // This is a temporary measure to understand what are the common base commands
   // until we start persisting and uploading rollouts
@@ -59,7 +61,7 @@ export function exec(
     os.tmpdir(),
     ...additionalWritableRoots,
   ];
-  return execForSandbox(cmd, opts, writableRoots, abortSignal);
+  return execForSandbox(cmd, opts, writableRoots, abortSignal, config);
 }
 
 export function execApplyPatch(

codex-cli/src/utils/agent/handle-exec-command.ts

@@ -94,6 +94,7 @@ export async function handleExecCommand(
       /* runInSandbox */ false,
       additionalWritableRoots,
       abortSignal,
+      config,
     ).then(convertSummaryToResult);
   }
 
@@ -142,6 +143,7 @@ export async function handleExecCommand(
     runInSandbox,
     additionalWritableRoots,
     abortSignal,
+    config,
   );
   // If the operation was aborted in the meantime, propagate the cancellation
   // upward by returning an empty (no-op) result so that the agent loop will
@@ -179,6 +181,7 @@ export async function handleExecCommand(
         false,
         additionalWritableRoots,
         abortSignal,
+        config,
       );
       return convertSummaryToResult(summary);
     }
@@ -213,6 +216,7 @@ async function execCommand(
   runInSandbox: boolean,
   additionalWritableRoots: ReadonlyArray<string>,
   abortSignal?: AbortSignal,
+  config?: AppConfig,
 ): Promise<ExecCommandSummary> {
   let { workdir } = execInput;
   if (workdir) {
@@ -252,6 +256,7 @@ async function execCommand(
           { ...execInput, additionalWritableRoots },
           await getSandbox(runInSandbox),
           abortSignal,
+          config,
         );
   const duration = Date.now() - start;
   const { stdout, stderr, exitCode } = execResult;

codex-cli/src/utils/agent/sandbox/create-truncating-collector.ts

@@ -1,7 +1,6 @@
 // Maximum output cap: either MAX_OUTPUT_LINES lines or MAX_OUTPUT_BYTES bytes,
 // whichever limit is reached first.
-const MAX_OUTPUT_BYTES = 1024 * 10; // 10 KB
-const MAX_OUTPUT_LINES = 256;
+import { DEFAULT_SHELL_MAX_BYTES, DEFAULT_SHELL_MAX_LINES } from "../../config";
 
 /**
  * Creates a collector that accumulates data Buffers from a stream up to
@@ -10,8 +9,8 @@ const MAX_OUTPUT_LINES = 256;
  */
 export function createTruncatingCollector(
   stream: NodeJS.ReadableStream,
-  byteLimit: number = MAX_OUTPUT_BYTES,
-  lineLimit: number = MAX_OUTPUT_LINES,
+  byteLimit: number = DEFAULT_SHELL_MAX_BYTES,
+  lineLimit: number = DEFAULT_SHELL_MAX_LINES,
 ): {
   getString: () => string;
   hit: boolean;

codex-cli/src/utils/agent/sandbox/macos-seatbelt.ts

@@ -1,4 +1,5 @@
 import type { ExecResult } from "./interface.js";
+import type { AppConfig } from "../../config.js";
 import type { SpawnOptions } from "child_process";
 
 import { exec } from "./raw-exec.js";
@@ -17,6 +18,7 @@ export function execWithSeatbelt(
   opts: SpawnOptions,
   writableRoots: ReadonlyArray<string>,
   abortSignal?: AbortSignal,
+  config?: AppConfig,
 ): Promise<ExecResult> {
   let scopedWritePolicy: string;
   let policyTemplateParams: Array<string>;
@@ -64,7 +66,7 @@ export function execWithSeatbelt(
     "--",
     ...cmd,
   ];
-  return exec(fullCommand, opts, writableRoots, abortSignal);
+  return exec(fullCommand, opts, writableRoots, abortSignal, config);
 }
 
 const READ_ONLY_SEATBELT_POLICY = `

codex-cli/src/utils/agent/sandbox/raw-exec.ts

@@ -1,4 +1,5 @@
 import type { ExecResult } from "./interface";
+import type { AppConfig } from "../../config";
 import type {
   ChildProcess,
   SpawnOptions,
@@ -22,6 +23,7 @@ export function exec(
   options: SpawnOptions,
   _writableRoots: ReadonlyArray<string>,
   abortSignal?: AbortSignal,
+  config?: AppConfig,
 ): Promise<ExecResult> {
   // Adapt command for the current platform (e.g., convert 'ls' to 'dir' on Windows)
   const adaptedCommand = adaptCommandForPlatform(command);
@@ -143,9 +145,21 @@ export function exec(
   // ExecResult object so the rest of the agent loop can carry on gracefully.
 
   return new Promise<ExecResult>((resolve) => {
+    // Get shell output limits from config if available
+    const maxBytes = config?.tools?.shell?.maxBytes;
+    const maxLines = config?.tools?.shell?.maxLines;
+
     // Collect stdout and stderr up to configured limits.
-    const stdoutCollector = createTruncatingCollector(child.stdout!);
-    const stderrCollector = createTruncatingCollector(child.stderr!);
+    const stdoutCollector = createTruncatingCollector(
+      child.stdout!,
+      maxBytes,
+      maxLines,
+    );
+    const stderrCollector = createTruncatingCollector(
+      child.stderr!,
+      maxBytes,
+      maxLines,
+    );
 
     child.on("exit", (code, signal) => {
       const stdout = stdoutCollector.getString();

codex-cli/src/utils/config.ts

@@ -21,6 +21,10 @@ export const DEFAULT_FULL_CONTEXT_MODEL = "gpt-4.1";
 export const DEFAULT_APPROVAL_MODE = AutoApprovalMode.SUGGEST;
 export const DEFAULT_INSTRUCTIONS = "";
 
+// Default shell output limits
+export const DEFAULT_SHELL_MAX_BYTES = 1024 * 10; // 10 KB
+export const DEFAULT_SHELL_MAX_LINES = 256;
+
 export const CONFIG_DIR = join(homedir(), ".codex");
 export const CONFIG_JSON_FILEPATH = join(CONFIG_DIR, "config.json");
 export const CONFIG_YAML_FILEPATH = join(CONFIG_DIR, "config.yaml");
@@ -108,6 +112,12 @@ export type StoredConfig = {
     saveHistory?: boolean;
     sensitivePatterns?: Array<string>;
   };
+  tools?: {
+    shell?: {
+      maxBytes?: number;
+      maxLines?: number;
+    };
+  };
 };
 
 // Minimal config written on first run.  An *empty* model string ensures that
@@ -145,6 +155,12 @@ export type AppConfig = {
     saveHistory: boolean;
     sensitivePatterns: Array<string>;
   };
+  tools?: {
+    shell?: {
+      maxBytes: number;
+      maxLines: number;
+    };
+  };
 };
 
 // Formatting (quiet mode-only).
@@ -332,6 +348,15 @@ export const loadConfig = (
     notify: storedConfig.notify === true,
     approvalMode: storedConfig.approvalMode,
     disableResponseStorage: storedConfig.disableResponseStorage ?? false,
+    // Add default tools config
+    tools: {
+      shell: {
+        maxBytes:
+          storedConfig.tools?.shell?.maxBytes ?? DEFAULT_SHELL_MAX_BYTES,
+        maxLines:
+          storedConfig.tools?.shell?.maxLines ?? DEFAULT_SHELL_MAX_LINES,
+      },
+    },
   };
 
   // -----------------------------------------------------------------------
@@ -457,6 +482,18 @@ export const saveConfig = (
     };
   }
 
+  // Add tools settings if they exist
+  if (config.tools) {
+    configToSave.tools = {
+      shell: config.tools.shell
+        ? {
+            maxBytes: config.tools.shell.maxBytes,
+            maxLines: config.tools.shell.maxLines,
+          }
+        : undefined,
+    };
+  }
+
   if (ext === ".yaml" || ext === ".yml") {
     writeFileSync(targetPath, dumpYaml(configToSave), "utf-8");
   } else {

codex-cli/tests/config.test.tsx

@@ -1,6 +1,11 @@
 import type * as fsType from "fs";
 
-import { loadConfig, saveConfig } from "../src/utils/config.js"; // parent import first
+import {
+  loadConfig,
+  saveConfig,
+  DEFAULT_SHELL_MAX_BYTES,
+  DEFAULT_SHELL_MAX_LINES,
+} from "../src/utils/config.js"; // parent import first
 import { AutoApprovalMode } from "../src/utils/auto-approval-mode.js";
 import { tmpdir } from "os";
 import { join } from "path";
@@ -275,3 +280,84 @@ test("handles empty user instructions when saving with project doc separator", (
   });
   expect(loadedConfig.instructions).toBe("");
 });
+
+test("loads default shell config when not specified", () => {
+  // Setup config without shell settings
+  memfs[testConfigPath] = JSON.stringify(
+    {
+      model: "mymodel",
+    },
+    null,
+    2,
+  );
+  memfs[testInstructionsPath] = "test instructions";
+
+  // Load config and verify default shell settings
+  const loadedConfig = loadConfig(testConfigPath, testInstructionsPath, {
+    disableProjectDoc: true,
+  });
+
+  // Check shell settings were loaded with defaults
+  expect(loadedConfig.tools).toBeDefined();
+  expect(loadedConfig.tools?.shell).toBeDefined();
+  expect(loadedConfig.tools?.shell?.maxBytes).toBe(DEFAULT_SHELL_MAX_BYTES);
+  expect(loadedConfig.tools?.shell?.maxLines).toBe(DEFAULT_SHELL_MAX_LINES);
+});
+
+test("loads and saves custom shell config", () => {
+  // Setup config with custom shell settings
+  const customMaxBytes = 12410;
+  const customMaxLines = 500;
+
+  memfs[testConfigPath] = JSON.stringify(
+    {
+      model: "mymodel",
+      tools: {
+        shell: {
+          maxBytes: customMaxBytes,
+          maxLines: customMaxLines,
+        },
+      },
+    },
+    null,
+    2,
+  );
+  memfs[testInstructionsPath] = "test instructions";
+
+  // Load config and verify custom shell settings
+  const loadedConfig = loadConfig(testConfigPath, testInstructionsPath, {
+    disableProjectDoc: true,
+  });
+
+  // Check shell settings were loaded correctly
+  expect(loadedConfig.tools?.shell?.maxBytes).toBe(customMaxBytes);
+  expect(loadedConfig.tools?.shell?.maxLines).toBe(customMaxLines);
+
+  // Modify shell settings and save
+  const updatedMaxBytes = 20000;
+  const updatedMaxLines = 1000;
+
+  const updatedConfig = {
+    ...loadedConfig,
+    tools: {
+      shell: {
+        maxBytes: updatedMaxBytes,
+        maxLines: updatedMaxLines,
+      },
+    },
+  };
+
+  saveConfig(updatedConfig, testConfigPath, testInstructionsPath);
+
+  // Verify saved config contains updated shell settings
+  expect(memfs[testConfigPath]).toContain(`"maxBytes": ${updatedMaxBytes}`);
+  expect(memfs[testConfigPath]).toContain(`"maxLines": ${updatedMaxLines}`);
+
+  // Load again and verify updated values
+  const reloadedConfig = loadConfig(testConfigPath, testInstructionsPath, {
+    disableProjectDoc: true,
+  });
+
+  expect(reloadedConfig.tools?.shell?.maxBytes).toBe(updatedMaxBytes);
+  expect(reloadedConfig.tools?.shell?.maxLines).toBe(updatedMaxLines);
+});