codex: try --profile, fall back on codex's rejection error

ucode's codex launch always ran `codex --profile ucode <args>`, but codex only
accepts the global `--profile` on runtime subcommands. Server-family
subcommands (app-server, mcp-server, exec-server, remote-control) and
utilities reject it up front:

  Error: --profile only applies to runtime commands and `codex mcp`: ...

so e.g. `ucode codex app-server` was functionally broken.

Rather than maintain a version-dependent allow-list of which subcommands
accept `--profile` (the accepted set drifts across codex releases), catch
codex's own rejection: every launch runs with `--profile` first, stderr
captured to a temp file and read once the process exits. Only a nonzero exit
whose stderr contains the rejection message relaunches without `--profile`
(swallowing the expected noise); any other outcome replays the captured
stderr and propagates the exit code unchanged, so an unrelated error is never
silently retried without ucode's routing. A file, unlike a pipe, has no
backpressure, so nothing has to read alongside the running process. The
rejection is instant and side-effect-free (verified on codex 0.137 and
0.141), so the fallback costs ~150ms once.

The helper is codex-local (_exec_or_spawn_with_fallback in codex.py) rather
than a launcher.py API — it's not generalizable yet; launcher.py is untouched.

Co-authored-by: Isaac

Author: Edwinhe03

src/ucode/agents/codex.py

@@ -4,6 +4,10 @@
 
 import os
 import re
+import signal
+import subprocess
+import sys
+import tempfile
 from pathlib import Path
 
 from ucode.agent_updates import available_npm_package_update
@@ -391,12 +395,75 @@ def _gpt_version_key(entry: tuple[str, tuple[int, int | None, int | None, str]])
     return max(parsed, key=_gpt_version_key)[0]
 
 
+# codex accepts the global --profile only on its runtime subcommands (plus the
+# bare interactive TUI); server-family subcommands (app-server, mcp-server,
+# exec-server, remote-control) and utilities reject it up front by printing
+# this to stderr and exiting nonzero. The accepted set drifts across codex
+# versions, so rather than maintain a version-dependent list we try with
+# --profile and fall back exactly on this rejection. Stable prefix verified on
+# codex 0.137 and 0.141; if a future codex rewords it, the launch fails loudly
+# with codex's own error instead of silently dropping ucode's routing.
+_PROFILE_REJECTED_MARKER = "--profile only applies to runtime commands"
+
+# How much of codex's captured stderr to scan for the marker. The rejection is
+# one short line printed first, so this is generous headroom.
+_STDERR_HEAD_LIMIT = 64 * 1024
+
+
+def _exec_or_spawn_with_fallback(
+    argv: list[str], fallback_argv: list[str], stderr_marker: str
+) -> None:
+    """``exec_or_spawn``, but relaunch as ``fallback_argv`` iff codex rejects a flag.
+
+    Runs ``argv`` with stderr captured to a temp file and reads it once the
+    process exits. Only a nonzero exit whose stderr contains ``stderr_marker``
+    — codex's own rejection message — execs ``fallback_argv`` in its place,
+    swallowing the expected rejection noise. Every other outcome (success, or
+    a failure for any other reason) replays the captured stderr and propagates
+    the exit code unchanged, so an unrelated error is never silently retried
+    with different flags.
+
+    A file, unlike a pipe, has no backpressure: codex can never block on a
+    stderr write, so nothing has to read alongside the running process. The
+    trade is that codex's stderr appears when it exits, not live.
+    """
+    with tempfile.TemporaryFile() as stderr_file:
+        proc = subprocess.Popen(argv, stderr=stderr_file)
+        try:
+            returncode = proc.wait()
+        except KeyboardInterrupt:
+            # Forward Ctrl-C and let codex decide its own exit code rather
+            # than racing it (mirrors exec_or_spawn's Windows path).
+            proc.send_signal(signal.SIGINT)
+            returncode = proc.wait()
+        stderr_file.seek(0)
+        if returncode != 0 and stderr_marker.encode() in stderr_file.read(_STDERR_HEAD_LIMIT):
+            exec_or_spawn(fallback_argv)
+            return  # unreachable in production (exec/exit); keeps tests honest
+        # Replay everything codex wrote to stderr.
+        stderr_file.seek(0)
+        for chunk in iter(lambda: stderr_file.read(65536), b""):
+            sys.stderr.write(chunk.decode(errors="replace"))
+        sys.stderr.flush()
+    sys.exit(returncode)
+
+
 def launch(state: dict, tool_args: list[str]) -> None:
     binary = SPEC["binary"]
     workspace = state.get("workspace")
     if workspace:
         os.environ["OAUTH_TOKEN"] = get_databricks_token(workspace, state.get("profile"))
-    exec_or_spawn([binary, "--profile", CODEX_PROFILE_NAME, *tool_args])
+    # Try with --profile first — the TUI and runtime subcommands
+    # (exec/resume/mcp/...) keep ucode's routing, including subcommands added
+    # by future codex versions — and relaunch without it only on codex's
+    # specific rejection error. Rejected subcommands are caller-configured
+    # anyway (e.g. omnigent runs `codex app-server` with its own CODEX_HOME),
+    # so omitting --profile there just stays out of the way.
+    _exec_or_spawn_with_fallback(
+        [binary, "--profile", CODEX_PROFILE_NAME, *tool_args],
+        [binary, *tool_args],
+        _PROFILE_REJECTED_MARKER,
+    )
 
 
 def validate_cmd(binary: str) -> list[str]:

tests/test_agent_codex.py

@@ -3,6 +3,9 @@
 from __future__ import annotations
 
 import os
+import sys
+
+import pytest
 
 from ucode.agents import codex
 from ucode.config_io import read_toml_safe
@@ -416,23 +419,94 @@ def test_skips_git_repo_check(self):
 
 
 class TestCodexLaunch:
-    def test_sets_oauth_token_and_ucode_profile_before_exec(self, monkeypatch):
-        exec_calls: list[tuple[str, list[str]]] = []
+    """Every launch goes through the try-with-profile / fall-back-on-rejection
+    path instead of a version-dependent allow-list."""
 
-        def fake_execvp(binary: str, args: list[str]) -> None:
-            exec_calls.append((binary, args))
-            raise RuntimeError("stop")
+    @staticmethod
+    def _capture(monkeypatch):
+        calls: list[tuple[list[str], list[str], str]] = []
+        monkeypatch.setattr(
+            codex,
+            "_exec_or_spawn_with_fallback",
+            lambda argv, fallback_argv, marker: calls.append((argv, fallback_argv, marker)),
+        )
+        monkeypatch.setattr(codex, "get_databricks_token", lambda workspace, profile=None: "tok")
+        return calls
 
+    def test_sets_oauth_token_before_launch(self, monkeypatch):
         monkeypatch.delenv("OAUTH_TOKEN", raising=False)
+        calls = self._capture(monkeypatch)
         monkeypatch.setattr(
             codex, "get_databricks_token", lambda workspace, profile=None: "fresh-token"
         )
-        monkeypatch.setattr(os, "execvp", fake_execvp)
-
-        try:
-            codex.launch({"workspace": WS}, ["--search"])
-        except RuntimeError as exc:
-            assert str(exc) == "stop"
-
+        codex.launch({"workspace": WS}, ["--search"])
         assert os.environ["OAUTH_TOKEN"] == "fresh-token"
-        assert exec_calls == [("codex", ["codex", "--profile", "ucode", "--search"])]
+        assert calls[0][0] == ["codex", "--profile", "ucode", "--search"]
+
+    def test_tries_profile_first_with_no_profile_fallback(self, monkeypatch):
+        for args in ([], ["--search"], ["exec", "say hi"], ["app-server", "--listen", "u"]):
+            calls = self._capture(monkeypatch)
+            codex.launch({"workspace": WS}, args)
+            assert calls == [
+                (
+                    ["codex", "--profile", "ucode", *args],
+                    ["codex", *args],
+                    codex._PROFILE_REJECTED_MARKER,
+                )
+            ]
+
+
+class TestExecOrSpawnWithFallback:
+    """Real-subprocess tests: stderr is captured to a file and read at exit."""
+
+    @staticmethod
+    def _script(code: str) -> list[str]:
+        return [sys.executable, "-c", code]
+
+    def test_marked_failure_execs_fallback_and_swallows_rejection(self, monkeypatch, capsys):
+        calls: list[list[str]] = []
+        monkeypatch.setattr(codex, "exec_or_spawn", lambda argv: calls.append(argv))
+        codex._exec_or_spawn_with_fallback(
+            self._script("import sys; sys.stderr.write('Error: MARKER hit\\n'); sys.exit(1)"),
+            ["fallback", "argv"],
+            "MARKER",
+        )
+        assert calls == [["fallback", "argv"]]
+        # The expected rejection is noise once we relaunch — swallowed.
+        assert capsys.readouterr().err == ""
+
+    def test_success_propagates_and_replays_stderr(self, monkeypatch, capsys):
+        monkeypatch.setattr(codex, "exec_or_spawn", lambda argv: pytest.fail("fallback fired"))
+        with pytest.raises(SystemExit) as exc:
+            codex._exec_or_spawn_with_fallback(
+                self._script("import sys; sys.stderr.write('warn: heads up\\n')"),
+                ["fallback"],
+                "MARKER",
+            )
+        assert exc.value.code == 0
+        # Whatever the child said on stderr reaches the caller at exit.
+        assert "warn: heads up" in capsys.readouterr().err
+
+    def test_unrelated_failure_propagates_without_fallback(self, monkeypatch, capsys):
+        # An unmarked failure must NOT retry with different flags — retrying
+        # would silently drop --profile and ucode's routing with it.
+        monkeypatch.setattr(codex, "exec_or_spawn", lambda argv: pytest.fail("fallback fired"))
+        with pytest.raises(SystemExit) as exc:
+            codex._exec_or_spawn_with_fallback(
+                self._script("import sys; sys.stderr.write('boom\\n'); sys.exit(3)"),
+                ["fallback"],
+                "MARKER",
+            )
+        assert exc.value.code == 3
+        assert "boom" in capsys.readouterr().err
+
+    def test_marker_on_success_does_not_fall_back(self, monkeypatch, capsys):
+        monkeypatch.setattr(codex, "exec_or_spawn", lambda argv: pytest.fail("fallback fired"))
+        with pytest.raises(SystemExit) as exc:
+            codex._exec_or_spawn_with_fallback(
+                self._script("import sys; sys.stderr.write('mentions MARKER\\n'); sys.exit(0)"),
+                ["fallback"],
+                "MARKER",
+            )
+        assert exc.value.code == 0
+        assert "mentions MARKER" in capsys.readouterr().err