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: run the launch with `--profile` first, stderr captured
to a temp file, and read it 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 bare interactive TUI (no subcommand token — a subcommand never starts
with "-") still execs directly with --profile, which every codex version
accepts.

Co-authored-by: Isaac

Author: Edwinhe03

src/ucode/agents/codex.py

@@ -20,7 +20,7 @@
     build_tool_base_url,
     get_databricks_token,
 )
-from ucode.launcher import exec_or_spawn
+from ucode.launcher import exec_or_spawn, run_with_stderr_fallback
 from ucode.state import mark_tool_managed, save_state
 from ucode.telemetry import agent_version, ucode_version
 
@@ -391,12 +391,38 @@ 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"
+
+
 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])
+    with_profile = [binary, "--profile", CODEX_PROFILE_NAME, *tool_args]
+    if all(arg.startswith("-") for arg in tool_args):
+        # No subcommand token (a subcommand never starts with "-"), so this is
+        # the interactive TUI, which always accepts --profile: hand over the
+        # terminal directly. A flag value without a dash (e.g. `--model gpt-5`)
+        # merely routes the TUI through the supervised fallback below, which
+        # accepts --profile just the same — never the reverse.
+        exec_or_spawn(with_profile)
+        return
+    # A subcommand may reject the global --profile. Try with it first — so
+    # runtime subcommands (exec/resume/mcp/...) keep ucode's routing, including
+    # ones 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.
+    run_with_stderr_fallback(with_profile, [binary, *tool_args], _PROFILE_REJECTED_MARKER)
 
 
 def validate_cmd(binary: str) -> list[str]:

src/ucode/launcher.py

@@ -6,6 +6,12 @@
 import signal
 import subprocess
 import sys
+import tempfile
+
+# How much of the child's captured stderr to scan for the marker in
+# run_with_stderr_fallback. A flag-rejection error is one short line printed
+# first, so this is generous headroom.
+_STDERR_HEAD_LIMIT = 64 * 1024
 
 
 def exec_or_spawn(argv: list[str]) -> None:
@@ -34,3 +40,41 @@ def exec_or_spawn(argv: list[str]) -> None:
         proc.send_signal(signal.SIGINT)
         returncode = proc.wait()
     sys.exit(returncode)
+
+
+def run_with_stderr_fallback(argv: list[str], fallback_argv: list[str], stderr_marker: str) -> None:
+    """Run ``argv``; hand the terminal to ``fallback_argv`` iff it rejects a flag.
+
+    For launches where the binary may reject one of our flags depending on its
+    version or subcommand (e.g. codex's global ``--profile``): run the preferred
+    ``argv`` with stderr captured to a temp file, and read it once the process
+    exits. Only when it exits nonzero *and* that stderr contains
+    ``stderr_marker`` — the binary's own rejection message — is ``fallback_argv``
+    exec'd 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 child's exit code unchanged, so an unrelated
+    error is never silently retried with different flags.
+
+    A file, unlike a pipe, has no backpressure: the child can never block on a
+    stderr write, so nothing has to read alongside the running process. The
+    trade is that the child'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 the child 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 the child 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)

tests/test_agent_codex.py

@@ -436,3 +436,59 @@ def fake_execvp(binary: str, args: list[str]) -> None:
 
         assert os.environ["OAUTH_TOKEN"] == "fresh-token"
         assert exec_calls == [("codex", ["codex", "--profile", "ucode", "--search"])]
+
+
+class TestCodexLaunchProfileRouting:
+    """launch() hands the interactive TUI straight to exec with --profile; any
+    invocation with a subcommand token goes through the try-with-profile /
+    fall-back-on-rejection path instead of a version-dependent allow-list."""
+
+    @staticmethod
+    def _capture(monkeypatch):
+        exec_calls: list[list[str]] = []
+        fallback_calls: list[tuple[list[str], list[str], str]] = []
+        monkeypatch.setattr(codex, "exec_or_spawn", lambda argv: exec_calls.append(argv))
+        monkeypatch.setattr(
+            codex,
+            "run_with_stderr_fallback",
+            lambda argv, fallback_argv, marker: fallback_calls.append(
+                (argv, fallback_argv, marker)
+            ),
+        )
+        monkeypatch.setattr(codex, "get_databricks_token", lambda workspace, profile=None: "tok")
+        return exec_calls, fallback_calls
+
+    def test_bare_tui_execs_with_profile(self, monkeypatch):
+        exec_calls, fallback_calls = self._capture(monkeypatch)
+        codex.launch({"workspace": WS}, [])
+        assert exec_calls == [["codex", "--profile", "ucode"]]
+        assert fallback_calls == []
+
+    def test_flags_only_tui_execs_with_profile(self, monkeypatch):
+        exec_calls, fallback_calls = self._capture(monkeypatch)
+        codex.launch({"workspace": WS}, ["--search"])
+        assert exec_calls == [["codex", "--profile", "ucode", "--search"]]
+        assert fallback_calls == []
+
+    def test_subcommand_tries_profile_with_rejection_fallback(self, monkeypatch):
+        for sub in ("exec", "resume", "mcp", "app-server", "mcp-server", "remote-control"):
+            exec_calls, fallback_calls = self._capture(monkeypatch)
+            codex.launch({"workspace": WS}, [sub, "--listen", "u"])
+            assert exec_calls == []
+            assert fallback_calls == [
+                (
+                    ["codex", "--profile", "ucode", sub, "--listen", "u"],
+                    ["codex", sub, "--listen", "u"],
+                    codex._PROFILE_REJECTED_MARKER,
+                )
+            ]
+
+    def test_dashless_flag_value_routes_through_fallback(self, monkeypatch):
+        # `--model gpt-5` is still the TUI; the conservative classifier sends it
+        # through the fallback path, whose first attempt carries --profile — so
+        # behavior is identical, just supervised.
+        exec_calls, fallback_calls = self._capture(monkeypatch)
+        codex.launch({"workspace": WS}, ["--model", "gpt-5"])
+        assert exec_calls == []
+        assert fallback_calls[0][0] == ["codex", "--profile", "ucode", "--model", "gpt-5"]
+        assert fallback_calls[0][1] == ["codex", "--model", "gpt-5"]

tests/test_launcher.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import sys
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -61,3 +62,59 @@ def test_windows_keyboard_interrupt_forwards_sigint(self):
                 launcher.exec_or_spawn(["claude.exe"])
         proc.send_signal.assert_called_once_with(launcher.signal.SIGINT)
         assert exc.value.code == 130
+
+
+class TestRunWithStderrFallback:
+    """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(launcher, "exec_or_spawn", lambda argv: calls.append(argv))
+        launcher.run_with_stderr_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(launcher, "exec_or_spawn", lambda argv: pytest.fail("fallback fired"))
+        with pytest.raises(SystemExit) as exc:
+            launcher.run_with_stderr_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 the preferred argv's routing.
+        monkeypatch.setattr(launcher, "exec_or_spawn", lambda argv: pytest.fail("fallback fired"))
+        with pytest.raises(SystemExit) as exc:
+            launcher.run_with_stderr_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(launcher, "exec_or_spawn", lambda argv: pytest.fail("fallback fired"))
+        with pytest.raises(SystemExit) as exc:
+            launcher.run_with_stderr_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