diff --git a/.bazelrc b/.bazelrc index 3a49a22c20..fb6e93e58c 100644 --- a/.bazelrc +++ b/.bazelrc @@ -82,6 +82,8 @@ build:clippy --@rules_rust//rust/settings:clippy.toml=//codex-rs:clippy.toml # in their own `Cargo.toml`, but `rules_rust` Bazel clippy does not read Cargo lint levels. # `clippy.toml` can configure lint behavior, but it cannot set allow/warn/deny/forbid levels. build:clippy --@rules_rust//rust/settings:clippy_flag=-Dwarnings +build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::await_holding_invalid_type +build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::await_holding_lock build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::expect_used build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::identity_op build:clippy --@rules_rust//rust/settings:clippy_flag=--deny=clippy::manual_clamp diff --git a/.codex/skills/code-review-breaking-changes/SKILL.md b/.codex/skills/code-review-breaking-changes/SKILL.md new file mode 100644 index 0000000000..d0bddf281e --- /dev/null +++ b/.codex/skills/code-review-breaking-changes/SKILL.md @@ -0,0 +1,12 @@ +--- +name: code-breaking-changes +description: Breaking changes +--- + +Search for breaking changes in external integration surfaces: +- app-server APIs +- CLI parameters +- configuration loading +- resuming sessions from existing rollouts + +Do not stop after finding one issue; analyze all possible ways breaking changes can happen. diff --git a/.codex/skills/code-review-change-size/SKILL.md b/.codex/skills/code-review-change-size/SKILL.md new file mode 100644 index 0000000000..4e8048dcd4 --- /dev/null +++ b/.codex/skills/code-review-change-size/SKILL.md @@ -0,0 +1,11 @@ +--- +name: code-review-change-size +description: Change size guidance (800 lines) +--- + +Unless the change is mechanical the total number of changed lines should not exceed 800 lines. +For complex logic changes the size should be under 500 lines. + +If the change is larger, explain whether it can be split into reviewable stages and identify the smallest coherent stage to land first. +Base the staging suggestion on the actual diff, dependencies, and affected call sites. + diff --git a/.codex/skills/code-review-context/SKILL.md b/.codex/skills/code-review-context/SKILL.md new file mode 100644 index 0000000000..3d33192ec5 --- /dev/null +++ b/.codex/skills/code-review-context/SKILL.md @@ -0,0 +1,12 @@ +--- +name: code-review-context +description: Model visible context +--- + +Codex maintains a context (history of messages) that is sent to the model in inference requests. + +1. No history rewrite - the context must be built up incrementally. +2. Avoid frequent changes to context that cause cache misses. +3. No unbounded items - everything injected in the model context must have a bounded size and a hard cap. +4. No items larger than 10K tokens. +5. Highlight new individual items that can cross >1k tokens as P0. These need an additional manual review. diff --git a/.codex/skills/code-review-testing/SKILL.md b/.codex/skills/code-review-testing/SKILL.md new file mode 100644 index 0000000000..c8d99e13cd --- /dev/null +++ b/.codex/skills/code-review-testing/SKILL.md @@ -0,0 +1,14 @@ +--- +name: code-review-testing +description: Test authoring guidance +--- + +For agent changes prefer integration tests over unit tests. Integration tests are under `core/suite` and use `test_codex` to set up a test instance of codex. + +Features that change the agent logic MUST add an integration test: +- Provide a list of major logic changes and user-facing behaviors that need to be tested. + +If unit tests are needed, put them in a dedicated test file (*_tests.rs). +Avoid test-only functions in the main implementation. + +Check whether there are existing helpers to make tests more streamlined and readable. diff --git a/.codex/skills/code-review/SKILL.md b/.codex/skills/code-review/SKILL.md new file mode 100644 index 0000000000..eec0787c20 --- /dev/null +++ b/.codex/skills/code-review/SKILL.md @@ -0,0 +1,14 @@ +--- +name: code-review +description: Run a final code review on a pull request +--- + +Use subagents to review code using all code-review-* skills in this repository other than this orchestrator. One subagent per skill. Pass full skill path to subagents. Use xhigh reasoning. + +You must return every single issue from every subagent. You can return an unlimited number of findings. +Use raw Markdown to report findings. +Number findings for ease of reference. +Each finding must include a specific file path and line number. + +If the GitHub user running the review is the owner of the pull request add a `code-reviewed` label. +Do not leave GitHub comments unless explicitly asked. diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000..0f1c1b413d --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +codex-rs/app-server-protocol/schema/** linguist-generated diff --git a/.github/blob-size-allowlist.txt b/.github/blob-size-allowlist.txt index 6d329e6d4f..9375b49c27 100644 --- a/.github/blob-size-allowlist.txt +++ b/.github/blob-size-allowlist.txt @@ -7,3 +7,4 @@ codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json codex-rs/tui/tests/fixtures/oss-story.jsonl codex-rs/tui_app_server/tests/fixtures/oss-story.jsonl +codex-rs/tui/src/app.rs diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 057498eaea..b085bb68b4 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -831,6 +831,7 @@ "dispatch2_0.3.0": "{\"dependencies\":[{\"default_features\":false,\"features\":[\"std\"],\"name\":\"bitflags\",\"req\":\"^2.5.0\"},{\"default_features\":false,\"features\":[\"alloc\"],\"name\":\"block2\",\"optional\":true,\"req\":\">=0.6.1, <0.8.0\"},{\"default_features\":false,\"name\":\"libc\",\"optional\":true,\"req\":\"^0.2.80\"},{\"default_features\":false,\"features\":[\"std\"],\"name\":\"objc2\",\"optional\":true,\"req\":\">=0.6.1, <0.8.0\"},{\"kind\":\"dev\",\"name\":\"static_assertions\",\"req\":\"^1.1.0\"}],\"features\":{\"alloc\":[],\"block2\":[\"dep:block2\"],\"default\":[\"std\",\"block2\",\"libc\",\"objc2\"],\"libc\":[\"dep:libc\"],\"objc2\":[\"dep:objc2\"],\"std\":[\"alloc\"]}}", "display_container_0.9.0": "{\"dependencies\":[{\"name\":\"either\",\"req\":\"^1.8\"},{\"name\":\"indenter\",\"req\":\"^0.3.3\"}],\"features\":{}}", "displaydoc_0.2.5": "{\"dependencies\":[{\"default_features\":false,\"kind\":\"dev\",\"name\":\"libc\",\"req\":\"^0.2\"},{\"kind\":\"dev\",\"name\":\"pretty_assertions\",\"req\":\"^0.6.1\"},{\"name\":\"proc-macro2\",\"req\":\"^1.0\"},{\"name\":\"quote\",\"req\":\"^1.0\"},{\"kind\":\"dev\",\"name\":\"rustversion\",\"req\":\"^1.0.0\"},{\"kind\":\"dev\",\"name\":\"static_assertions\",\"req\":\"^1.1\"},{\"name\":\"syn\",\"req\":\"^2.0\"},{\"kind\":\"dev\",\"name\":\"thiserror\",\"req\":\"^1.0.24\"},{\"kind\":\"dev\",\"name\":\"trybuild\",\"req\":\"^1.0\"}],\"features\":{\"default\":[\"std\"],\"std\":[]}}", + "dns-lookup_3.0.1": "{\"dependencies\":[{\"name\":\"cfg-if\",\"req\":\"^1.0\"},{\"name\":\"libc\",\"req\":\"^0.2\",\"target\":\"cfg(unix)\"},{\"name\":\"socket2\",\"req\":\"^0.6.0\"},{\"features\":[\"Win32_Networking_WinSock\",\"Win32_Foundation\"],\"name\":\"windows-sys\",\"req\":\"^0.60\",\"target\":\"cfg(windows)\"}],\"features\":{}}", "dotenvy_0.15.7": "{\"dependencies\":[{\"name\":\"clap\",\"optional\":true,\"req\":\"^3.2\"},{\"kind\":\"dev\",\"name\":\"once_cell\",\"req\":\"^1.16.0\"},{\"kind\":\"dev\",\"name\":\"tempfile\",\"req\":\"^3.3.0\"}],\"features\":{\"cli\":[\"clap\"]}}", "downcast-rs_1.2.1": "{\"dependencies\":[],\"features\":{\"default\":[\"std\"],\"std\":[]}}", "dtor-proc-macro_0.0.6": "{\"dependencies\":[],\"features\":{\"default\":[]}}", diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lock index e7eb7fc80c..15ca924a8b 100644 --- a/codex-rs/Cargo.lock +++ b/codex-rs/Cargo.lock @@ -449,7 +449,7 @@ dependencies = [ "objc2-foundation", "parking_lot", "percent-encoding", - "windows-sys 0.59.0", + "windows-sys 0.60.2", "wl-clipboard-rs", "x11rb", ] @@ -1372,7 +1372,7 @@ checksum = "af491d569909a7e4dee0ad7db7f5341fef5c614d5b8ec8cf765732aba3cff681" dependencies = [ "serde", "termcolor", - "unicode-width 0.1.14", + "unicode-width 0.2.1", ] [[package]] @@ -1464,6 +1464,7 @@ dependencies = [ "codex-git-utils", "codex-login", "codex-mcp", + "codex-model-provider-info", "codex-models-manager", "codex-otel", "codex-protocol", @@ -1518,6 +1519,7 @@ dependencies = [ "codex-app-server", "codex-app-server-protocol", "codex-arg0", + "codex-config", "codex-core", "codex-exec-server", "codex-feedback", @@ -1866,6 +1868,7 @@ name = "codex-config" version = "0.0.0" dependencies = [ "anyhow", + "async-trait", "codex-app-server-protocol", "codex-execpolicy", "codex-features", @@ -1874,7 +1877,10 @@ dependencies = [ "codex-protocol", "codex-utils-absolute-path", "codex-utils-path", + "dns-lookup", "futures", + "gethostname", + "libc", "multimap", "pretty_assertions", "schemars 0.8.22", @@ -1889,6 +1895,7 @@ dependencies = [ "toml_edit 0.24.0+spec-1.1.0", "tracing", "wildmatch", + "winapi-util", ] [[package]] @@ -1934,7 +1941,6 @@ dependencies = [ "codex-feedback", "codex-git-utils", "codex-hooks", - "codex-instructions", "codex-login", "codex-mcp", "codex-model-provider", @@ -2067,7 +2073,6 @@ dependencies = [ "codex-app-server-protocol", "codex-config", "codex-exec-server", - "codex-instructions", "codex-login", "codex-otel", "codex-protocol", @@ -2312,15 +2317,6 @@ dependencies = [ "tempfile", ] -[[package]] -name = "codex-instructions" -version = "0.0.0" -dependencies = [ - "codex-protocol", - "pretty_assertions", - "serde", -] - [[package]] name = "codex-keyring-store" version = "0.0.0" @@ -2891,10 +2887,11 @@ name = "codex-stdio-to-uds" version = "0.0.0" dependencies = [ "anyhow", + "codex-uds", "codex-utils-cargo-bin", "pretty_assertions", "tempfile", - "uds_windows", + "tokio", ] [[package]] @@ -3058,6 +3055,18 @@ dependencies = [ "winsplit", ] +[[package]] +name = "codex-uds" +version = "0.0.0" +dependencies = [ + "async-io", + "pretty_assertions", + "tempfile", + "tokio", + "tokio-util", + "uds_windows", +] + [[package]] name = "codex-utils-absolute-path" version = "0.0.0" @@ -4308,6 +4317,18 @@ dependencies = [ "syn 2.0.114", ] +[[package]] +name = "dns-lookup" +version = "3.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e39034cee21a2f5bbb66ba0e3689819c4bb5d00382a282006e802a7ffa6c41d" +dependencies = [ + "cfg-if", + "libc", + "socket2 0.6.2", + "windows-sys 0.60.2", +] + [[package]] name = "dotenvy" version = "0.15.7" @@ -4532,7 +4553,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -5094,7 +5115,7 @@ dependencies = [ "gobject-sys", "libc", "system-deps", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -5538,7 +5559,7 @@ dependencies = [ "libc", "percent-encoding", "pin-project-lite", - "socket2 0.5.10", + "socket2 0.6.2", "system-configuration", "tokio", "tower-service", @@ -5624,7 +5645,7 @@ dependencies = [ "js-sys", "log", "wasm-bindgen", - "windows-core 0.58.0", + "windows-core 0.62.2", ] [[package]] @@ -6044,7 +6065,7 @@ checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ "hermit-abi", "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -7534,7 +7555,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" dependencies = [ "libc", - "windows-sys 0.48.0", + "windows-sys 0.61.2", ] [[package]] @@ -8221,7 +8242,7 @@ dependencies = [ "quinn-udp", "rustc-hash 2.1.1", "rustls", - "socket2 0.5.10", + "socket2 0.6.2", "thiserror 2.0.18", "tokio", "tracing", @@ -8258,9 +8279,9 @@ dependencies = [ "cfg_aliases 0.2.1", "libc", "once_cell", - "socket2 0.5.10", + "socket2 0.6.2", "tracing", - "windows-sys 0.59.0", + "windows-sys 0.60.2", ] [[package]] @@ -9102,7 +9123,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys 0.11.0", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -10561,7 +10582,7 @@ dependencies = [ "getrandom 0.3.4", "once_cell", "rustix 1.1.3", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -10970,6 +10991,7 @@ checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" dependencies = [ "bytes", "futures-core", + "futures-io", "futures-sink", "futures-util", "pin-project-lite", diff --git a/codex-rs/Cargo.toml b/codex-rs/Cargo.toml index b1a8ae000a..f4be9c1abc 100644 --- a/codex-rs/Cargo.toml +++ b/codex-rs/Cargo.toml @@ -31,7 +31,6 @@ members = [ "core-plugins", "core-skills", "hooks", - "instructions", "secrets", "exec", "exec-server", @@ -90,6 +89,7 @@ members = [ "terminal-detection", "test-binary-support", "thread-store", + "uds", "codex-experimental-api-macros", "plugin", "model-provider", @@ -142,7 +142,6 @@ codex-install-context = { path = "install-context" } codex-file-search = { path = "file-search" } codex-git-utils = { path = "git-utils" } codex-hooks = { path = "hooks" } -codex-instructions = { path = "instructions" } codex-keyring-store = { path = "keyring-store" } codex-linux-sandbox = { path = "linux-sandbox" } codex-lmstudio = { path = "lmstudio" } @@ -175,6 +174,7 @@ codex-test-binary-support = { path = "test-binary-support" } codex-thread-store = { path = "thread-store" } codex-tools = { path = "tools" } codex-tui = { path = "tui" } +codex-uds = { path = "uds" } codex-utils-absolute-path = { path = "utils/absolute-path" } codex-utils-approval-presets = { path = "utils/approval-presets" } codex-utils-cache = { path = "utils/cache" } @@ -212,6 +212,7 @@ arc-swap = "1.9.0" assert_cmd = "2" assert_matches = "1.5.0" async-channel = "2.3.1" +async-io = "2.6.0" async-stream = "0.3.6" async-trait = "0.1.89" axum = { version = "0.8", default-features = false } @@ -233,6 +234,7 @@ deno_core_icudata = "0.77.0" derive_more = "2" diffy = "0.4.2" dirs = "6" +dns-lookup = "3.0.1" dotenvy = "0.15.7" dunce = "1.0.4" ed25519-dalek = { version = "2.2.0", features = ["pkcs8"] } @@ -370,6 +372,7 @@ webbrowser = "1.0" which = "8" whoami = "1.6.1" wildmatch = "2.6.1" +winapi-util = "0.1.11" zip = "2.4.2" zstd = "0.13" @@ -380,6 +383,8 @@ zeroize = "1.8.2" rust = {} [workspace.lints.clippy] +await_holding_invalid_type = "deny" +await_holding_lock = "deny" expect_used = "deny" identity_op = "deny" manual_clamp = "deny" diff --git a/codex-rs/app-server-client/Cargo.toml b/codex-rs/app-server-client/Cargo.toml index 063b91c07c..d9c1ade097 100644 --- a/codex-rs/app-server-client/Cargo.toml +++ b/codex-rs/app-server-client/Cargo.toml @@ -15,6 +15,7 @@ workspace = true codex-app-server = { workspace = true } codex-app-server-protocol = { workspace = true } codex-arg0 = { workspace = true } +codex-config = { workspace = true } codex-core = { workspace = true } codex-exec-server = { workspace = true } codex-feedback = { workspace = true } diff --git a/codex-rs/app-server-client/src/lib.rs b/codex-rs/app-server-client/src/lib.rs index be6bf52ad6..c6f678c2aa 100644 --- a/codex-rs/app-server-client/src/lib.rs +++ b/codex-rs/app-server-client/src/lib.rs @@ -41,6 +41,7 @@ use codex_app_server_protocol::Result as JsonRpcResult; use codex_app_server_protocol::ServerNotification; use codex_app_server_protocol::ServerRequest; use codex_arg0::Arg0DispatchPaths; +use codex_config::NoopThreadConfigLoader; use codex_core::config::Config; use codex_core::config_loader::CloudRequirementsLoader; use codex_core::config_loader::LoaderOverrides; @@ -385,6 +386,7 @@ impl InProcessClientStartArgs { cli_overrides: self.cli_overrides, loader_overrides: self.loader_overrides, cloud_requirements: self.cloud_requirements, + thread_config_loader: Arc::new(NoopThreadConfigLoader), feedback: self.feedback, log_db: self.log_db, environment_manager: self.environment_manager, diff --git a/codex-rs/app-server-protocol/schema/json/ClientRequest.json b/codex-rs/app-server-protocol/schema/json/ClientRequest.json index f9cdca83e3..43871d74a0 100644 --- a/codex-rs/app-server-protocol/schema/json/ClientRequest.json +++ b/codex-rs/app-server-protocol/schema/json/ClientRequest.json @@ -532,6 +532,12 @@ "inputSchema": true, "name": { "type": "string" + }, + "namespace": { + "type": [ + "string", + "null" + ] } }, "required": [ @@ -1304,7 +1310,10 @@ "type": "string" }, "threadId": { - "type": "string" + "type": [ + "string", + "null" + ] }, "uri": { "type": "string" @@ -1312,7 +1321,6 @@ }, "required": [ "server", - "threadId", "uri" ], "type": "object" diff --git a/codex-rs/app-server-protocol/schema/json/CommandExecutionRequestApprovalParams.json b/codex-rs/app-server-protocol/schema/json/CommandExecutionRequestApprovalParams.json index b55e14f4ad..3968da2a39 100644 --- a/codex-rs/app-server-protocol/schema/json/CommandExecutionRequestApprovalParams.json +++ b/codex-rs/app-server-protocol/schema/json/CommandExecutionRequestApprovalParams.json @@ -16,6 +16,14 @@ "null" ] }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, "read": { "items": { "$ref": "#/definitions/AbsolutePathBuf" diff --git a/codex-rs/app-server-protocol/schema/json/DynamicToolCallParams.json b/codex-rs/app-server-protocol/schema/json/DynamicToolCallParams.json index 2ccc94ca06..0aa8b9c571 100644 --- a/codex-rs/app-server-protocol/schema/json/DynamicToolCallParams.json +++ b/codex-rs/app-server-protocol/schema/json/DynamicToolCallParams.json @@ -5,6 +5,12 @@ "callId": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "threadId": { "type": "string" }, @@ -24,4 +30,4 @@ ], "title": "DynamicToolCallParams", "type": "object" -} \ No newline at end of file +} diff --git a/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalParams.json b/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalParams.json index 2c8bfba83c..e389983bfa 100644 --- a/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalParams.json +++ b/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalParams.json @@ -16,6 +16,14 @@ "null" ] }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, "read": { "items": { "$ref": "#/definitions/AbsolutePathBuf" diff --git a/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalResponse.json b/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalResponse.json index 4564138527..11cce8c88c 100644 --- a/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalResponse.json +++ b/codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalResponse.json @@ -16,6 +16,14 @@ "null" ] }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, "read": { "items": { "$ref": "#/definitions/AbsolutePathBuf" diff --git a/codex-rs/app-server-protocol/schema/json/ServerNotification.json b/codex-rs/app-server-protocol/schema/json/ServerNotification.json index 0a5a99b3d3..dc629735d0 100644 --- a/codex-rs/app-server-protocol/schema/json/ServerNotification.json +++ b/codex-rs/app-server-protocol/schema/json/ServerNotification.json @@ -64,6 +64,57 @@ }, "type": "object" }, + "AdditionalFileSystemPermissions": { + "properties": { + "entries": { + "items": { + "$ref": "#/definitions/FileSystemSandboxEntry" + }, + "type": [ + "array", + "null" + ] + }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, + "read": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + }, + "write": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + } + }, + "type": "object" + }, + "AdditionalNetworkPermissions": { + "properties": { + "enabled": { + "type": [ + "boolean", + "null" + ] + } + }, + "type": "object" + }, "AgentMessageDeltaNotification": { "properties": { "delta": { @@ -1019,6 +1070,217 @@ ], "type": "object" }, + "FileSystemAccessMode": { + "enum": [ + "read", + "write", + "none" + ], + "type": "string" + }, + "FileSystemPath": { + "oneOf": [ + { + "properties": { + "path": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": { + "enum": [ + "path" + ], + "title": "PathFileSystemPathType", + "type": "string" + } + }, + "required": [ + "path", + "type" + ], + "title": "PathFileSystemPath", + "type": "object" + }, + { + "properties": { + "pattern": { + "type": "string" + }, + "type": { + "enum": [ + "glob_pattern" + ], + "title": "GlobPatternFileSystemPathType", + "type": "string" + } + }, + "required": [ + "pattern", + "type" + ], + "title": "GlobPatternFileSystemPath", + "type": "object" + }, + { + "properties": { + "type": { + "enum": [ + "special" + ], + "title": "SpecialFileSystemPathType", + "type": "string" + }, + "value": { + "$ref": "#/definitions/FileSystemSpecialPath" + } + }, + "required": [ + "type", + "value" + ], + "title": "SpecialFileSystemPath", + "type": "object" + } + ] + }, + "FileSystemSandboxEntry": { + "properties": { + "access": { + "$ref": "#/definitions/FileSystemAccessMode" + }, + "path": { + "$ref": "#/definitions/FileSystemPath" + } + }, + "required": [ + "access", + "path" + ], + "type": "object" + }, + "FileSystemSpecialPath": { + "oneOf": [ + { + "properties": { + "kind": { + "enum": [ + "root" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "RootFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "minimal" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "MinimalFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "current_working_directory" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "CurrentWorkingDirectoryFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "project_roots" + ], + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind" + ], + "title": "KindFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "tmpdir" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "TmpdirFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "slash_tmp" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "SlashTmpFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "unknown" + ], + "type": "string" + }, + "path": { + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind", + "path" + ], + "type": "object" + } + ] + }, "FileUpdateChange": { "properties": { "diff": { @@ -1368,6 +1630,32 @@ ], "title": "McpToolCallGuardianApprovalReviewAction", "type": "object" + }, + { + "properties": { + "permissions": { + "$ref": "#/definitions/RequestPermissionProfile" + }, + "reason": { + "type": [ + "string", + "null" + ] + }, + "type": { + "enum": [ + "requestPermissions" + ], + "title": "RequestPermissionsGuardianApprovalReviewActionType", + "type": "string" + } + }, + "required": [ + "permissions", + "type" + ], + "title": "RequestPermissionsGuardianApprovalReviewAction", + "type": "object" } ] }, @@ -2285,6 +2573,32 @@ } ] }, + "RequestPermissionProfile": { + "additionalProperties": false, + "properties": { + "fileSystem": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalFileSystemPermissions" + }, + { + "type": "null" + } + ] + }, + "network": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalNetworkPermissions" + }, + { + "type": "null" + } + ] + } + }, + "type": "object" + }, "ServerRequestResolvedNotification": { "properties": { "requestId": { @@ -3029,6 +3343,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/ServerRequest.json b/codex-rs/app-server-protocol/schema/json/ServerRequest.json index b778ae0205..6bd386b6a1 100644 --- a/codex-rs/app-server-protocol/schema/json/ServerRequest.json +++ b/codex-rs/app-server-protocol/schema/json/ServerRequest.json @@ -16,6 +16,14 @@ "null" ] }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, "read": { "items": { "$ref": "#/definitions/AbsolutePathBuf" @@ -426,6 +434,12 @@ "callId": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "threadId": { "type": "string" }, diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json index 32abd66064..d32af787a3 100644 --- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json +++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json @@ -5,55 +5,12 @@ "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.", "type": "string" }, - "AdditionalFileSystemPermissions": { - "properties": { - "entries": { - "items": { - "$ref": "#/definitions/FileSystemSandboxEntry" - }, - "type": [ - "array", - "null" - ] - }, - "read": { - "items": { - "$ref": "#/definitions/v2/AbsolutePathBuf" - }, - "type": [ - "array", - "null" - ] - }, - "write": { - "items": { - "$ref": "#/definitions/v2/AbsolutePathBuf" - }, - "type": [ - "array", - "null" - ] - } - }, - "type": "object" - }, - "AdditionalNetworkPermissions": { - "properties": { - "enabled": { - "type": [ - "boolean", - "null" - ] - } - }, - "type": "object" - }, "AdditionalPermissionProfile": { "properties": { "fileSystem": { "anyOf": [ { - "$ref": "#/definitions/AdditionalFileSystemPermissions" + "$ref": "#/definitions/v2/AdditionalFileSystemPermissions" }, { "type": "null" @@ -63,7 +20,7 @@ "network": { "anyOf": [ { - "$ref": "#/definitions/AdditionalNetworkPermissions" + "$ref": "#/definitions/v2/AdditionalNetworkPermissions" }, { "type": "null" @@ -2008,6 +1965,12 @@ "callId": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "threadId": { "type": "string" }, @@ -2260,217 +2223,6 @@ "title": "FileChangeRequestApprovalResponse", "type": "object" }, - "FileSystemAccessMode": { - "enum": [ - "read", - "write", - "none" - ], - "type": "string" - }, - "FileSystemPath": { - "oneOf": [ - { - "properties": { - "path": { - "$ref": "#/definitions/v2/AbsolutePathBuf" - }, - "type": { - "enum": [ - "path" - ], - "title": "PathFileSystemPathType", - "type": "string" - } - }, - "required": [ - "path", - "type" - ], - "title": "PathFileSystemPath", - "type": "object" - }, - { - "properties": { - "pattern": { - "type": "string" - }, - "type": { - "enum": [ - "glob_pattern" - ], - "title": "GlobPatternFileSystemPathType", - "type": "string" - } - }, - "required": [ - "pattern", - "type" - ], - "title": "GlobPatternFileSystemPath", - "type": "object" - }, - { - "properties": { - "type": { - "enum": [ - "special" - ], - "title": "SpecialFileSystemPathType", - "type": "string" - }, - "value": { - "$ref": "#/definitions/FileSystemSpecialPath" - } - }, - "required": [ - "type", - "value" - ], - "title": "SpecialFileSystemPath", - "type": "object" - } - ] - }, - "FileSystemSandboxEntry": { - "properties": { - "access": { - "$ref": "#/definitions/FileSystemAccessMode" - }, - "path": { - "$ref": "#/definitions/FileSystemPath" - } - }, - "required": [ - "access", - "path" - ], - "type": "object" - }, - "FileSystemSpecialPath": { - "oneOf": [ - { - "properties": { - "kind": { - "enum": [ - "root" - ], - "type": "string" - } - }, - "required": [ - "kind" - ], - "title": "RootFileSystemSpecialPath", - "type": "object" - }, - { - "properties": { - "kind": { - "enum": [ - "minimal" - ], - "type": "string" - } - }, - "required": [ - "kind" - ], - "title": "MinimalFileSystemSpecialPath", - "type": "object" - }, - { - "properties": { - "kind": { - "enum": [ - "current_working_directory" - ], - "type": "string" - } - }, - "required": [ - "kind" - ], - "title": "CurrentWorkingDirectoryFileSystemSpecialPath", - "type": "object" - }, - { - "properties": { - "kind": { - "enum": [ - "project_roots" - ], - "type": "string" - }, - "subpath": { - "type": [ - "string", - "null" - ] - } - }, - "required": [ - "kind" - ], - "title": "KindFileSystemSpecialPath", - "type": "object" - }, - { - "properties": { - "kind": { - "enum": [ - "tmpdir" - ], - "type": "string" - } - }, - "required": [ - "kind" - ], - "title": "TmpdirFileSystemSpecialPath", - "type": "object" - }, - { - "properties": { - "kind": { - "enum": [ - "slash_tmp" - ], - "type": "string" - } - }, - "required": [ - "kind" - ], - "title": "SlashTmpFileSystemSpecialPath", - "type": "object" - }, - { - "properties": { - "kind": { - "enum": [ - "unknown" - ], - "type": "string" - }, - "path": { - "type": "string" - }, - "subpath": { - "type": [ - "string", - "null" - ] - } - }, - "required": [ - "kind", - "path" - ], - "type": "object" - } - ] - }, "FuzzyFileSearchMatchType": { "enum": [ "file", @@ -2603,7 +2355,7 @@ "fileSystem": { "anyOf": [ { - "$ref": "#/definitions/AdditionalFileSystemPermissions" + "$ref": "#/definitions/v2/AdditionalFileSystemPermissions" }, { "type": "null" @@ -2613,7 +2365,7 @@ "network": { "anyOf": [ { - "$ref": "#/definitions/AdditionalNetworkPermissions" + "$ref": "#/definitions/v2/AdditionalNetworkPermissions" }, { "type": "null" @@ -3612,7 +3364,7 @@ "type": "string" }, "permissions": { - "$ref": "#/definitions/RequestPermissionProfile" + "$ref": "#/definitions/v2/RequestPermissionProfile" }, "reason": { "type": [ @@ -3670,32 +3422,6 @@ ], "title": "RequestId" }, - "RequestPermissionProfile": { - "additionalProperties": false, - "properties": { - "fileSystem": { - "anyOf": [ - { - "$ref": "#/definitions/AdditionalFileSystemPermissions" - }, - { - "type": "null" - } - ] - }, - "network": { - "anyOf": [ - { - "$ref": "#/definitions/AdditionalNetworkPermissions" - }, - { - "type": "null" - } - ] - } - }, - "type": "object" - }, "ReviewDecision": { "description": "User's decision in response to an ExecApprovalRequest.", "oneOf": [ @@ -5405,6 +5131,57 @@ ], "type": "string" }, + "AdditionalFileSystemPermissions": { + "properties": { + "entries": { + "items": { + "$ref": "#/definitions/v2/FileSystemSandboxEntry" + }, + "type": [ + "array", + "null" + ] + }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, + "read": { + "items": { + "$ref": "#/definitions/v2/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + }, + "write": { + "items": { + "$ref": "#/definitions/v2/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + } + }, + "type": "object" + }, + "AdditionalNetworkPermissions": { + "properties": { + "enabled": { + "type": [ + "boolean", + "null" + ] + } + }, + "type": "object" + }, "AgentMessageDeltaNotification": { "$schema": "http://json-schema.org/draft-07/schema#", "properties": { @@ -7610,6 +7387,12 @@ "inputSchema": true, "name": { "type": "string" + }, + "namespace": { + "type": [ + "string", + "null" + ] } }, "required": [ @@ -8033,6 +7816,217 @@ "title": "FileChangePatchUpdatedNotification", "type": "object" }, + "FileSystemAccessMode": { + "enum": [ + "read", + "write", + "none" + ], + "type": "string" + }, + "FileSystemPath": { + "oneOf": [ + { + "properties": { + "path": { + "$ref": "#/definitions/v2/AbsolutePathBuf" + }, + "type": { + "enum": [ + "path" + ], + "title": "PathFileSystemPathType", + "type": "string" + } + }, + "required": [ + "path", + "type" + ], + "title": "PathFileSystemPath", + "type": "object" + }, + { + "properties": { + "pattern": { + "type": "string" + }, + "type": { + "enum": [ + "glob_pattern" + ], + "title": "GlobPatternFileSystemPathType", + "type": "string" + } + }, + "required": [ + "pattern", + "type" + ], + "title": "GlobPatternFileSystemPath", + "type": "object" + }, + { + "properties": { + "type": { + "enum": [ + "special" + ], + "title": "SpecialFileSystemPathType", + "type": "string" + }, + "value": { + "$ref": "#/definitions/v2/FileSystemSpecialPath" + } + }, + "required": [ + "type", + "value" + ], + "title": "SpecialFileSystemPath", + "type": "object" + } + ] + }, + "FileSystemSandboxEntry": { + "properties": { + "access": { + "$ref": "#/definitions/v2/FileSystemAccessMode" + }, + "path": { + "$ref": "#/definitions/v2/FileSystemPath" + } + }, + "required": [ + "access", + "path" + ], + "type": "object" + }, + "FileSystemSpecialPath": { + "oneOf": [ + { + "properties": { + "kind": { + "enum": [ + "root" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "RootFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "minimal" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "MinimalFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "current_working_directory" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "CurrentWorkingDirectoryFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "project_roots" + ], + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind" + ], + "title": "KindFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "tmpdir" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "TmpdirFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "slash_tmp" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "SlashTmpFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "unknown" + ], + "type": "string" + }, + "path": { + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind", + "path" + ], + "type": "object" + } + ] + }, "FileUpdateChange": { "properties": { "diff": { @@ -8826,6 +8820,32 @@ ], "title": "McpToolCallGuardianApprovalReviewAction", "type": "object" + }, + { + "properties": { + "permissions": { + "$ref": "#/definitions/v2/RequestPermissionProfile" + }, + "reason": { + "type": [ + "string", + "null" + ] + }, + "type": { + "enum": [ + "requestPermissions" + ], + "title": "RequestPermissionsGuardianApprovalReviewActionType", + "type": "string" + } + }, + "required": [ + "permissions", + "type" + ], + "title": "RequestPermissionsGuardianApprovalReviewAction", + "type": "object" } ] }, @@ -9677,7 +9697,10 @@ "type": "string" }, "threadId": { - "type": "string" + "type": [ + "string", + "null" + ] }, "uri": { "type": "string" @@ -9685,7 +9708,6 @@ }, "required": [ "server", - "threadId", "uri" ], "title": "McpResourceReadParams", @@ -11631,6 +11653,32 @@ } ] }, + "RequestPermissionProfile": { + "additionalProperties": false, + "properties": { + "fileSystem": { + "anyOf": [ + { + "$ref": "#/definitions/v2/AdditionalFileSystemPermissions" + }, + { + "type": "null" + } + ] + }, + "network": { + "anyOf": [ + { + "$ref": "#/definitions/v2/AdditionalNetworkPermissions" + }, + { + "type": "null" + } + ] + } + }, + "type": "object" + }, "ResidencyRequirement": { "enum": [ "us" @@ -14049,6 +14097,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "null", + "string" + ] + }, "status": { "$ref": "#/definitions/v2/DynamicToolCallStatus" }, @@ -16558,4 +16612,4 @@ }, "title": "CodexAppServerProtocol", "type": "object" -} \ No newline at end of file +} diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json index 56140727ab..b0c141ec8c 100644 --- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json +++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json @@ -128,6 +128,57 @@ ], "type": "string" }, + "AdditionalFileSystemPermissions": { + "properties": { + "entries": { + "items": { + "$ref": "#/definitions/FileSystemSandboxEntry" + }, + "type": [ + "array", + "null" + ] + }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, + "read": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + }, + "write": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + } + }, + "type": "object" + }, + "AdditionalNetworkPermissions": { + "properties": { + "enabled": { + "type": [ + "boolean", + "null" + ] + } + }, + "type": "object" + }, "AgentMessageDeltaNotification": { "$schema": "http://json-schema.org/draft-07/schema#", "properties": { @@ -3947,6 +3998,12 @@ "inputSchema": true, "name": { "type": "string" + }, + "namespace": { + "type": [ + "string", + "null" + ] } }, "required": [ @@ -4370,6 +4427,217 @@ "title": "FileChangePatchUpdatedNotification", "type": "object" }, + "FileSystemAccessMode": { + "enum": [ + "read", + "write", + "none" + ], + "type": "string" + }, + "FileSystemPath": { + "oneOf": [ + { + "properties": { + "path": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": { + "enum": [ + "path" + ], + "title": "PathFileSystemPathType", + "type": "string" + } + }, + "required": [ + "path", + "type" + ], + "title": "PathFileSystemPath", + "type": "object" + }, + { + "properties": { + "pattern": { + "type": "string" + }, + "type": { + "enum": [ + "glob_pattern" + ], + "title": "GlobPatternFileSystemPathType", + "type": "string" + } + }, + "required": [ + "pattern", + "type" + ], + "title": "GlobPatternFileSystemPath", + "type": "object" + }, + { + "properties": { + "type": { + "enum": [ + "special" + ], + "title": "SpecialFileSystemPathType", + "type": "string" + }, + "value": { + "$ref": "#/definitions/FileSystemSpecialPath" + } + }, + "required": [ + "type", + "value" + ], + "title": "SpecialFileSystemPath", + "type": "object" + } + ] + }, + "FileSystemSandboxEntry": { + "properties": { + "access": { + "$ref": "#/definitions/FileSystemAccessMode" + }, + "path": { + "$ref": "#/definitions/FileSystemPath" + } + }, + "required": [ + "access", + "path" + ], + "type": "object" + }, + "FileSystemSpecialPath": { + "oneOf": [ + { + "properties": { + "kind": { + "enum": [ + "root" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "RootFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "minimal" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "MinimalFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "current_working_directory" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "CurrentWorkingDirectoryFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "project_roots" + ], + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind" + ], + "title": "KindFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "tmpdir" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "TmpdirFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "slash_tmp" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "SlashTmpFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "unknown" + ], + "type": "string" + }, + "path": { + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind", + "path" + ], + "type": "object" + } + ] + }, "FileUpdateChange": { "properties": { "diff": { @@ -5274,6 +5542,32 @@ ], "title": "McpToolCallGuardianApprovalReviewAction", "type": "object" + }, + { + "properties": { + "permissions": { + "$ref": "#/definitions/RequestPermissionProfile" + }, + "reason": { + "type": [ + "string", + "null" + ] + }, + "type": { + "enum": [ + "requestPermissions" + ], + "title": "RequestPermissionsGuardianApprovalReviewActionType", + "type": "string" + } + }, + "required": [ + "permissions", + "type" + ], + "title": "RequestPermissionsGuardianApprovalReviewAction", + "type": "object" } ] }, @@ -6169,7 +6463,10 @@ "type": "string" }, "threadId": { - "type": "string" + "type": [ + "string", + "null" + ] }, "uri": { "type": "string" @@ -6177,7 +6474,6 @@ }, "required": [ "server", - "threadId", "uri" ], "title": "McpResourceReadParams", @@ -8123,6 +8419,32 @@ } ] }, + "RequestPermissionProfile": { + "additionalProperties": false, + "properties": { + "fileSystem": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalFileSystemPermissions" + }, + { + "type": "null" + } + ] + }, + "network": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalNetworkPermissions" + }, + { + "type": "null" + } + ] + } + }, + "type": "object" + }, "ResidencyRequirement": { "enum": [ "us" @@ -11673,6 +11995,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ItemCompletedNotification.json b/codex-rs/app-server-protocol/schema/json/v2/ItemCompletedNotification.json index c5a84c4272..0831483a32 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ItemCompletedNotification.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ItemCompletedNotification.json @@ -854,6 +854,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewCompletedNotification.json b/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewCompletedNotification.json index cc8b2a6832..27716e59b0 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewCompletedNotification.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewCompletedNotification.json @@ -5,6 +5,57 @@ "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.", "type": "string" }, + "AdditionalFileSystemPermissions": { + "properties": { + "entries": { + "items": { + "$ref": "#/definitions/FileSystemSandboxEntry" + }, + "type": [ + "array", + "null" + ] + }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, + "read": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + }, + "write": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + } + }, + "type": "object" + }, + "AdditionalNetworkPermissions": { + "properties": { + "enabled": { + "type": [ + "boolean", + "null" + ] + } + }, + "type": "object" + }, "AutoReviewDecisionSource": { "description": "[UNSTABLE] Source that produced a terminal approval auto-review decision.", "enum": [ @@ -12,6 +63,217 @@ ], "type": "string" }, + "FileSystemAccessMode": { + "enum": [ + "read", + "write", + "none" + ], + "type": "string" + }, + "FileSystemPath": { + "oneOf": [ + { + "properties": { + "path": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": { + "enum": [ + "path" + ], + "title": "PathFileSystemPathType", + "type": "string" + } + }, + "required": [ + "path", + "type" + ], + "title": "PathFileSystemPath", + "type": "object" + }, + { + "properties": { + "pattern": { + "type": "string" + }, + "type": { + "enum": [ + "glob_pattern" + ], + "title": "GlobPatternFileSystemPathType", + "type": "string" + } + }, + "required": [ + "pattern", + "type" + ], + "title": "GlobPatternFileSystemPath", + "type": "object" + }, + { + "properties": { + "type": { + "enum": [ + "special" + ], + "title": "SpecialFileSystemPathType", + "type": "string" + }, + "value": { + "$ref": "#/definitions/FileSystemSpecialPath" + } + }, + "required": [ + "type", + "value" + ], + "title": "SpecialFileSystemPath", + "type": "object" + } + ] + }, + "FileSystemSandboxEntry": { + "properties": { + "access": { + "$ref": "#/definitions/FileSystemAccessMode" + }, + "path": { + "$ref": "#/definitions/FileSystemPath" + } + }, + "required": [ + "access", + "path" + ], + "type": "object" + }, + "FileSystemSpecialPath": { + "oneOf": [ + { + "properties": { + "kind": { + "enum": [ + "root" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "RootFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "minimal" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "MinimalFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "current_working_directory" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "CurrentWorkingDirectoryFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "project_roots" + ], + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind" + ], + "title": "KindFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "tmpdir" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "TmpdirFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "slash_tmp" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "SlashTmpFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "unknown" + ], + "type": "string" + }, + "path": { + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind", + "path" + ], + "type": "object" + } + ] + }, "GuardianApprovalReview": { "description": "[UNSTABLE] Temporary approval auto-review payload used by `item/autoApprovalReview/*` notifications. This shape is expected to change soon.", "properties": { @@ -217,6 +479,32 @@ ], "title": "McpToolCallGuardianApprovalReviewAction", "type": "object" + }, + { + "properties": { + "permissions": { + "$ref": "#/definitions/RequestPermissionProfile" + }, + "reason": { + "type": [ + "string", + "null" + ] + }, + "type": { + "enum": [ + "requestPermissions" + ], + "title": "RequestPermissionsGuardianApprovalReviewActionType", + "type": "string" + } + }, + "required": [ + "permissions", + "type" + ], + "title": "RequestPermissionsGuardianApprovalReviewAction", + "type": "object" } ] }, @@ -266,6 +554,32 @@ "socks5Udp" ], "type": "string" + }, + "RequestPermissionProfile": { + "additionalProperties": false, + "properties": { + "fileSystem": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalFileSystemPermissions" + }, + { + "type": "null" + } + ] + }, + "network": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalNetworkPermissions" + }, + { + "type": "null" + } + ] + } + }, + "type": "object" } }, "description": "[UNSTABLE] Temporary notification payload for approval auto-review. This shape is expected to change soon.", diff --git a/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewStartedNotification.json b/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewStartedNotification.json index 1cd6b30160..c039f2191a 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewStartedNotification.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewStartedNotification.json @@ -5,6 +5,268 @@ "description": "A path that is guaranteed to be absolute and normalized (though it is not guaranteed to be canonicalized or exist on the filesystem).\n\nIMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set using [AbsolutePathBufGuard::new]. If no base path is set, the deserialization will fail unless the path being deserialized is already absolute.", "type": "string" }, + "AdditionalFileSystemPermissions": { + "properties": { + "entries": { + "items": { + "$ref": "#/definitions/FileSystemSandboxEntry" + }, + "type": [ + "array", + "null" + ] + }, + "globScanMaxDepth": { + "format": "uint", + "minimum": 1.0, + "type": [ + "integer", + "null" + ] + }, + "read": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + }, + "write": { + "items": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": [ + "array", + "null" + ] + } + }, + "type": "object" + }, + "AdditionalNetworkPermissions": { + "properties": { + "enabled": { + "type": [ + "boolean", + "null" + ] + } + }, + "type": "object" + }, + "FileSystemAccessMode": { + "enum": [ + "read", + "write", + "none" + ], + "type": "string" + }, + "FileSystemPath": { + "oneOf": [ + { + "properties": { + "path": { + "$ref": "#/definitions/AbsolutePathBuf" + }, + "type": { + "enum": [ + "path" + ], + "title": "PathFileSystemPathType", + "type": "string" + } + }, + "required": [ + "path", + "type" + ], + "title": "PathFileSystemPath", + "type": "object" + }, + { + "properties": { + "pattern": { + "type": "string" + }, + "type": { + "enum": [ + "glob_pattern" + ], + "title": "GlobPatternFileSystemPathType", + "type": "string" + } + }, + "required": [ + "pattern", + "type" + ], + "title": "GlobPatternFileSystemPath", + "type": "object" + }, + { + "properties": { + "type": { + "enum": [ + "special" + ], + "title": "SpecialFileSystemPathType", + "type": "string" + }, + "value": { + "$ref": "#/definitions/FileSystemSpecialPath" + } + }, + "required": [ + "type", + "value" + ], + "title": "SpecialFileSystemPath", + "type": "object" + } + ] + }, + "FileSystemSandboxEntry": { + "properties": { + "access": { + "$ref": "#/definitions/FileSystemAccessMode" + }, + "path": { + "$ref": "#/definitions/FileSystemPath" + } + }, + "required": [ + "access", + "path" + ], + "type": "object" + }, + "FileSystemSpecialPath": { + "oneOf": [ + { + "properties": { + "kind": { + "enum": [ + "root" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "RootFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "minimal" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "MinimalFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "current_working_directory" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "CurrentWorkingDirectoryFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "project_roots" + ], + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind" + ], + "title": "KindFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "tmpdir" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "TmpdirFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "slash_tmp" + ], + "type": "string" + } + }, + "required": [ + "kind" + ], + "title": "SlashTmpFileSystemSpecialPath", + "type": "object" + }, + { + "properties": { + "kind": { + "enum": [ + "unknown" + ], + "type": "string" + }, + "path": { + "type": "string" + }, + "subpath": { + "type": [ + "string", + "null" + ] + } + }, + "required": [ + "kind", + "path" + ], + "type": "object" + } + ] + }, "GuardianApprovalReview": { "description": "[UNSTABLE] Temporary approval auto-review payload used by `item/autoApprovalReview/*` notifications. This shape is expected to change soon.", "properties": { @@ -210,6 +472,32 @@ ], "title": "McpToolCallGuardianApprovalReviewAction", "type": "object" + }, + { + "properties": { + "permissions": { + "$ref": "#/definitions/RequestPermissionProfile" + }, + "reason": { + "type": [ + "string", + "null" + ] + }, + "type": { + "enum": [ + "requestPermissions" + ], + "title": "RequestPermissionsGuardianApprovalReviewActionType", + "type": "string" + } + }, + "required": [ + "permissions", + "type" + ], + "title": "RequestPermissionsGuardianApprovalReviewAction", + "type": "object" } ] }, @@ -259,6 +547,32 @@ "socks5Udp" ], "type": "string" + }, + "RequestPermissionProfile": { + "additionalProperties": false, + "properties": { + "fileSystem": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalFileSystemPermissions" + }, + { + "type": "null" + } + ] + }, + "network": { + "anyOf": [ + { + "$ref": "#/definitions/AdditionalNetworkPermissions" + }, + { + "type": "null" + } + ] + } + }, + "type": "object" } }, "description": "[UNSTABLE] Temporary notification payload for approval auto-review. This shape is expected to change soon.", diff --git a/codex-rs/app-server-protocol/schema/json/v2/ItemStartedNotification.json b/codex-rs/app-server-protocol/schema/json/v2/ItemStartedNotification.json index cb9201f0a6..16bfeece14 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ItemStartedNotification.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ItemStartedNotification.json @@ -854,6 +854,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/McpResourceReadParams.json b/codex-rs/app-server-protocol/schema/json/v2/McpResourceReadParams.json index 0242d4148b..2fe58155d2 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/McpResourceReadParams.json +++ b/codex-rs/app-server-protocol/schema/json/v2/McpResourceReadParams.json @@ -5,7 +5,10 @@ "type": "string" }, "threadId": { - "type": "string" + "type": [ + "string", + "null" + ] }, "uri": { "type": "string" @@ -13,7 +16,6 @@ }, "required": [ "server", - "threadId", "uri" ], "title": "McpResourceReadParams", diff --git a/codex-rs/app-server-protocol/schema/json/v2/ReviewStartResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ReviewStartResponse.json index 53fbee0a31..9a50640fb8 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ReviewStartResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ReviewStartResponse.json @@ -997,6 +997,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadForkResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadForkResponse.json index bdb63481df..4e1e80694b 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadForkResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadForkResponse.json @@ -1511,6 +1511,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadListResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadListResponse.json index 4be1e6b2e4..4c1c2efa89 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadListResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadListResponse.json @@ -1273,6 +1273,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadMetadataUpdateResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadMetadataUpdateResponse.json index 52ded34d73..1fe7a12d24 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadMetadataUpdateResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadMetadataUpdateResponse.json @@ -1273,6 +1273,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadReadResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadReadResponse.json index a61a67c03a..e1dc64b988 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadReadResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadReadResponse.json @@ -1273,6 +1273,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadResumeResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadResumeResponse.json index a92d282ef0..f776b676ff 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadResumeResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadResumeResponse.json @@ -1511,6 +1511,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadRollbackResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadRollbackResponse.json index f2c87d9b2d..c2c9b3a14d 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadRollbackResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadRollbackResponse.json @@ -1273,6 +1273,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadStartParams.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadStartParams.json index 21f4d7ef74..9b1cba6d1a 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadStartParams.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadStartParams.json @@ -70,6 +70,12 @@ "inputSchema": true, "name": { "type": "string" + }, + "namespace": { + "type": [ + "string", + "null" + ] } }, "required": [ diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadStartResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadStartResponse.json index 9fabbc3a14..f4f71dbf24 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadStartResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadStartResponse.json @@ -1511,6 +1511,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadStartedNotification.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadStartedNotification.json index 295ac5b086..af81c86f5b 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadStartedNotification.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadStartedNotification.json @@ -1273,6 +1273,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadTurnsListResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadTurnsListResponse.json index 2c1dfb14f8..8d4ee72e17 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadTurnsListResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadTurnsListResponse.json @@ -997,6 +997,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/ThreadUnarchiveResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ThreadUnarchiveResponse.json index 93ac0c9ff7..1f6c9987c8 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/ThreadUnarchiveResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/ThreadUnarchiveResponse.json @@ -1273,6 +1273,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/TurnCompletedNotification.json b/codex-rs/app-server-protocol/schema/json/v2/TurnCompletedNotification.json index c8c384965a..1aab9ad372 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/TurnCompletedNotification.json +++ b/codex-rs/app-server-protocol/schema/json/v2/TurnCompletedNotification.json @@ -997,6 +997,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/TurnStartResponse.json b/codex-rs/app-server-protocol/schema/json/v2/TurnStartResponse.json index 16903c4375..a6ecf5c75c 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/TurnStartResponse.json +++ b/codex-rs/app-server-protocol/schema/json/v2/TurnStartResponse.json @@ -997,6 +997,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/json/v2/TurnStartedNotification.json b/codex-rs/app-server-protocol/schema/json/v2/TurnStartedNotification.json index eaf29da0f2..0a2bec35e0 100644 --- a/codex-rs/app-server-protocol/schema/json/v2/TurnStartedNotification.json +++ b/codex-rs/app-server-protocol/schema/json/v2/TurnStartedNotification.json @@ -997,6 +997,12 @@ "id": { "type": "string" }, + "namespace": { + "type": [ + "string", + "null" + ] + }, "status": { "$ref": "#/definitions/DynamicToolCallStatus" }, diff --git a/codex-rs/app-server-protocol/schema/typescript/v2/AdditionalFileSystemPermissions.ts b/codex-rs/app-server-protocol/schema/typescript/v2/AdditionalFileSystemPermissions.ts index 21af5dda71..2be8f7f0e7 100644 --- a/codex-rs/app-server-protocol/schema/typescript/v2/AdditionalFileSystemPermissions.ts +++ b/codex-rs/app-server-protocol/schema/typescript/v2/AdditionalFileSystemPermissions.ts @@ -4,4 +4,4 @@ import type { AbsolutePathBuf } from "../AbsolutePathBuf"; import type { FileSystemSandboxEntry } from "./FileSystemSandboxEntry"; -export type AdditionalFileSystemPermissions = { read: Array | null, write: Array | null, entries?: Array, }; +export type AdditionalFileSystemPermissions = { read: Array | null, write: Array | null, globScanMaxDepth?: number, entries?: Array, }; diff --git a/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolCallParams.ts b/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolCallParams.ts index 2659da3505..0823ac66cd 100644 --- a/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolCallParams.ts +++ b/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolCallParams.ts @@ -3,4 +3,4 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. import type { JsonValue } from "../serde_json/JsonValue"; -export type DynamicToolCallParams = { threadId: string, turnId: string, callId: string, tool: string, arguments: JsonValue, }; +export type DynamicToolCallParams = { threadId: string, turnId: string, callId: string, namespace: string | null, tool: string, arguments: JsonValue, }; diff --git a/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolSpec.ts b/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolSpec.ts index 18596e31b9..db486bf927 100644 --- a/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolSpec.ts +++ b/codex-rs/app-server-protocol/schema/typescript/v2/DynamicToolSpec.ts @@ -3,4 +3,4 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. import type { JsonValue } from "../serde_json/JsonValue"; -export type DynamicToolSpec = { name: string, description: string, inputSchema: JsonValue, deferLoading?: boolean, }; +export type DynamicToolSpec = { namespace?: string, name: string, description: string, inputSchema: JsonValue, deferLoading?: boolean, }; diff --git a/codex-rs/app-server-protocol/schema/typescript/v2/GuardianApprovalReviewAction.ts b/codex-rs/app-server-protocol/schema/typescript/v2/GuardianApprovalReviewAction.ts index 4bbfe24190..4f00e37d20 100644 --- a/codex-rs/app-server-protocol/schema/typescript/v2/GuardianApprovalReviewAction.ts +++ b/codex-rs/app-server-protocol/schema/typescript/v2/GuardianApprovalReviewAction.ts @@ -4,5 +4,6 @@ import type { AbsolutePathBuf } from "../AbsolutePathBuf"; import type { GuardianCommandSource } from "./GuardianCommandSource"; import type { NetworkApprovalProtocol } from "./NetworkApprovalProtocol"; +import type { RequestPermissionProfile } from "./RequestPermissionProfile"; -export type GuardianApprovalReviewAction = { "type": "command", source: GuardianCommandSource, command: string, cwd: AbsolutePathBuf, } | { "type": "execve", source: GuardianCommandSource, program: string, argv: Array, cwd: AbsolutePathBuf, } | { "type": "applyPatch", cwd: AbsolutePathBuf, files: Array, } | { "type": "networkAccess", target: string, host: string, protocol: NetworkApprovalProtocol, port: number, } | { "type": "mcpToolCall", server: string, toolName: string, connectorId: string | null, connectorName: string | null, toolTitle: string | null, }; +export type GuardianApprovalReviewAction = { "type": "command", source: GuardianCommandSource, command: string, cwd: AbsolutePathBuf, } | { "type": "execve", source: GuardianCommandSource, program: string, argv: Array, cwd: AbsolutePathBuf, } | { "type": "applyPatch", cwd: AbsolutePathBuf, files: Array, } | { "type": "networkAccess", target: string, host: string, protocol: NetworkApprovalProtocol, port: number, } | { "type": "mcpToolCall", server: string, toolName: string, connectorId: string | null, connectorName: string | null, toolTitle: string | null, } | { "type": "requestPermissions", reason: string | null, permissions: RequestPermissionProfile, }; diff --git a/codex-rs/app-server-protocol/schema/typescript/v2/McpResourceReadParams.ts b/codex-rs/app-server-protocol/schema/typescript/v2/McpResourceReadParams.ts index 51d650d9bb..c48795f27e 100644 --- a/codex-rs/app-server-protocol/schema/typescript/v2/McpResourceReadParams.ts +++ b/codex-rs/app-server-protocol/schema/typescript/v2/McpResourceReadParams.ts @@ -2,4 +2,4 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. -export type McpResourceReadParams = { threadId: string, server: string, uri: string, }; +export type McpResourceReadParams = { threadId?: string | null, server: string, uri: string, }; diff --git a/codex-rs/app-server-protocol/schema/typescript/v2/ThreadItem.ts b/codex-rs/app-server-protocol/schema/typescript/v2/ThreadItem.ts index 747a70c54d..f7880c9d32 100644 --- a/codex-rs/app-server-protocol/schema/typescript/v2/ThreadItem.ts +++ b/codex-rs/app-server-protocol/schema/typescript/v2/ThreadItem.ts @@ -57,7 +57,7 @@ durationMs: number | null, } | { "type": "fileChange", id: string, changes: Arra /** * The duration of the MCP tool call in milliseconds. */ -durationMs: number | null, } | { "type": "dynamicToolCall", id: string, tool: string, arguments: JsonValue, status: DynamicToolCallStatus, contentItems: Array | null, success: boolean | null, +durationMs: number | null, } | { "type": "dynamicToolCall", id: string, namespace: string | null, tool: string, arguments: JsonValue, status: DynamicToolCallStatus, contentItems: Array | null, success: boolean | null, /** * The duration of the dynamic tool call in milliseconds. */ diff --git a/codex-rs/app-server-protocol/src/protocol/common.rs b/codex-rs/app-server-protocol/src/protocol/common.rs index 6253315610..aa3ff8331c 100644 --- a/codex-rs/app-server-protocol/src/protocol/common.rs +++ b/codex-rs/app-server-protocol/src/protocol/common.rs @@ -2056,6 +2056,7 @@ mod tests { file_system: Some(v2::AdditionalFileSystemPermissions { read: Some(vec![absolute_path("/tmp/allowed")]), write: None, + glob_scan_max_depth: None, entries: None, }), }), diff --git a/codex-rs/app-server-protocol/src/protocol/item_builders.rs b/codex-rs/app-server-protocol/src/protocol/item_builders.rs index f69c414b02..546fb1b679 100644 --- a/codex-rs/app-server-protocol/src/protocol/item_builders.rs +++ b/codex-rs/app-server-protocol/src/protocol/item_builders.rs @@ -199,7 +199,8 @@ pub fn build_item_from_guardian_event( } GuardianAssessmentAction::ApplyPatch { .. } | GuardianAssessmentAction::NetworkAccess { .. } - | GuardianAssessmentAction::McpToolCall { .. } => None, + | GuardianAssessmentAction::McpToolCall { .. } + | GuardianAssessmentAction::RequestPermissions { .. } => None, } } diff --git a/codex-rs/app-server-protocol/src/protocol/thread_history.rs b/codex-rs/app-server-protocol/src/protocol/thread_history.rs index 886d9c2557..bd3911d0d2 100644 --- a/codex-rs/app-server-protocol/src/protocol/thread_history.rs +++ b/codex-rs/app-server-protocol/src/protocol/thread_history.rs @@ -470,6 +470,7 @@ impl ThreadHistoryBuilder { ) { let item = ThreadItem::DynamicToolCall { id: payload.call_id.clone(), + namespace: payload.namespace.clone(), tool: payload.tool.clone(), arguments: payload.arguments.clone(), status: DynamicToolCallStatus::InProgress, @@ -493,6 +494,7 @@ impl ThreadHistoryBuilder { let duration_ms = i64::try_from(payload.duration.as_millis()).ok(); let item = ThreadItem::DynamicToolCall { id: payload.call_id.clone(), + namespace: payload.namespace.clone(), tool: payload.tool.clone(), arguments: payload.arguments.clone(), status, @@ -1975,6 +1977,7 @@ mod tests { codex_protocol::dynamic_tools::DynamicToolCallRequest { call_id: "dyn-1".into(), turn_id: "turn-1".into(), + namespace: Some("codex_app".into()), tool: "lookup_ticket".into(), arguments: serde_json::json!({"id":"ABC-123"}), }, @@ -1982,6 +1985,7 @@ mod tests { EventMsg::DynamicToolCallResponse(DynamicToolCallResponseEvent { call_id: "dyn-1".into(), turn_id: "turn-1".into(), + namespace: Some("codex_app".into()), tool: "lookup_ticket".into(), arguments: serde_json::json!({"id":"ABC-123"}), content_items: vec![CoreDynamicToolCallOutputContentItem::InputText { @@ -2004,6 +2008,7 @@ mod tests { turns[0].items[1], ThreadItem::DynamicToolCall { id: "dyn-1".into(), + namespace: Some("codex_app".into()), tool: "lookup_ticket".into(), arguments: serde_json::json!({"id":"ABC-123"}), status: DynamicToolCallStatus::Completed, diff --git a/codex-rs/app-server-protocol/src/protocol/v2.rs b/codex-rs/app-server-protocol/src/protocol/v2.rs index 7eb2a66e98..13e0d0f15d 100644 --- a/codex-rs/app-server-protocol/src/protocol/v2.rs +++ b/codex-rs/app-server-protocol/src/protocol/v2.rs @@ -1,5 +1,6 @@ use std::collections::BTreeMap; use std::collections::HashMap; +use std::num::NonZeroUsize; use std::path::PathBuf; use crate::RequestId; @@ -612,6 +613,8 @@ pub struct ToolsV2 { #[serde(rename_all = "camelCase")] #[ts(export_to = "v2/")] pub struct DynamicToolSpec { + #[ts(optional)] + pub namespace: Option, pub name: String, pub description: String, pub input_schema: JsonValue, @@ -622,6 +625,7 @@ pub struct DynamicToolSpec { #[derive(Deserialize)] #[serde(rename_all = "camelCase")] struct DynamicToolSpecDe { + namespace: Option, name: String, description: String, input_schema: JsonValue, @@ -635,6 +639,7 @@ impl<'de> Deserialize<'de> for DynamicToolSpec { D: serde::Deserializer<'de>, { let DynamicToolSpecDe { + namespace, name, description, input_schema, @@ -643,6 +648,7 @@ impl<'de> Deserialize<'de> for DynamicToolSpec { } = DynamicToolSpecDe::deserialize(deserializer)?; Ok(Self { + namespace, name, description, input_schema, @@ -1162,6 +1168,9 @@ pub struct AdditionalFileSystemPermissions { pub write: Option>, #[serde(default, skip_serializing_if = "Option::is_none")] #[ts(optional)] + pub glob_scan_max_depth: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + #[ts(optional)] pub entries: Option>, } @@ -1171,12 +1180,14 @@ impl From for AdditionalFileSystemPermissions { Self { read, write, + glob_scan_max_depth: None, entries: None, } } else { Self { read: None, write: None, + glob_scan_max_depth: value.glob_scan_max_depth, entries: Some( value .entries @@ -1191,16 +1202,19 @@ impl From for AdditionalFileSystemPermissions { impl From for CoreFileSystemPermissions { fn from(value: AdditionalFileSystemPermissions) -> Self { - if let Some(entries) = value.entries { + let mut permissions = if let Some(entries) = value.entries { Self { entries: entries .into_iter() .map(CoreFileSystemSandboxEntry::from) .collect(), + glob_scan_max_depth: None, } } else { CoreFileSystemPermissions::from_read_write_roots(value.read, value.write) - } + }; + permissions.glob_scan_max_depth = value.glob_scan_max_depth; + permissions } } @@ -2232,7 +2246,8 @@ pub struct ListMcpServerStatusResponse { #[serde(rename_all = "camelCase")] #[ts(export_to = "v2/")] pub struct McpResourceReadParams { - pub thread_id: String, + #[ts(optional = nullable)] + pub thread_id: Option, pub server: String, pub uri: String, } @@ -4878,6 +4893,7 @@ pub enum ThreadItem { #[ts(rename_all = "camelCase")] DynamicToolCall { id: String, + namespace: Option, tool: String, arguments: JsonValue, status: DynamicToolCallStatus, @@ -5133,6 +5149,14 @@ pub struct GuardianMcpToolCallReviewAction { pub tool_title: Option, } +#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)] +#[serde(rename_all = "camelCase")] +#[ts(export_to = "v2/")] +pub struct GuardianRequestPermissionsReviewAction { + pub reason: Option, + pub permissions: RequestPermissionProfile, +} + #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)] #[serde(tag = "type", rename_all = "camelCase")] #[ts(tag = "type", rename_all = "camelCase")] @@ -5176,6 +5200,12 @@ pub enum GuardianApprovalReviewAction { connector_name: Option, tool_title: Option, }, + #[serde(rename_all = "camelCase")] + #[ts(rename_all = "camelCase")] + RequestPermissions { + reason: Option, + permissions: RequestPermissionProfile, + }, } impl From for GuardianApprovalReviewAction { @@ -5228,6 +5258,13 @@ impl From for GuardianApprovalReviewAction { connector_name, tool_title, }, + CoreGuardianAssessmentAction::RequestPermissions { + reason, + permissions, + } => Self::RequestPermissions { + reason, + permissions: permissions.into(), + }, } } } @@ -5282,6 +5319,13 @@ impl From for CoreGuardianAssessmentAction { connector_name, tool_title, }, + GuardianApprovalReviewAction::RequestPermissions { + reason, + permissions, + } => Self::RequestPermissions { + reason, + permissions: permissions.into(), + }, } } } @@ -6613,6 +6657,7 @@ pub struct DynamicToolCallParams { pub thread_id: String, pub turn_id: String, pub call_id: String, + pub namespace: Option, pub tool: String, pub arguments: JsonValue, } @@ -6951,6 +6996,7 @@ mod tests { use codex_utils_absolute_path::test_support::test_path_buf; use pretty_assertions::assert_eq; use serde_json::json; + use std::num::NonZeroUsize; use std::path::PathBuf; fn absolute_path_string(path: &str) -> String { @@ -7085,6 +7131,7 @@ mod tests { AbsolutePathBuf::try_from(PathBuf::from(read_write_path)) .expect("path must be absolute"), ]), + glob_scan_max_depth: None, entries: None, }), } @@ -7156,6 +7203,7 @@ mod tests { access: CoreFileSystemAccessMode::None, }, ], + glob_scan_max_depth: NonZeroUsize::new(2), }; let permissions = AdditionalFileSystemPermissions::from(core_permissions.clone()); @@ -7164,6 +7212,7 @@ mod tests { AdditionalFileSystemPermissions { read: None, write: None, + glob_scan_max_depth: NonZeroUsize::new(2), entries: Some(vec![ FileSystemSandboxEntry { path: FileSystemPath::Special { @@ -7186,6 +7235,17 @@ mod tests { ); } + #[test] + fn additional_file_system_permissions_rejects_zero_glob_scan_depth() { + serde_json::from_value::(json!({ + "read": null, + "write": null, + "globScanMaxDepth": 0, + "entries": [], + })) + .expect_err("zero glob scan depth should fail deserialization"); + } + #[test] fn permissions_request_approval_response_uses_granted_permission_profile_without_macos() { let read_only_path = if cfg!(windows) { @@ -7226,6 +7286,7 @@ mod tests { AbsolutePathBuf::try_from(PathBuf::from(read_write_path)) .expect("path must be absolute"), ]), + glob_scan_max_depth: None, entries: None, }), } @@ -9250,6 +9311,7 @@ mod tests { assert_eq!( actual, DynamicToolSpec { + namespace: None, name: "lookup_ticket".to_string(), description: "Fetch a ticket".to_string(), input_schema: json!({ diff --git a/codex-rs/app-server/Cargo.toml b/codex-rs/app-server/Cargo.toml index 097abdb713..f354539640 100644 --- a/codex-rs/app-server/Cargo.toml +++ b/codex-rs/app-server/Cargo.toml @@ -97,6 +97,7 @@ axum = { workspace = true, default-features = false, features = [ "tokio", ] } core_test_support = { workspace = true } +codex-model-provider-info = { workspace = true } codex-utils-cargo-bin = { workspace = true } opentelemetry = { workspace = true } opentelemetry_sdk = { workspace = true } diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.md index 3c69127e5b..4d0f37eb10 100644 --- a/codex-rs/app-server/README.md +++ b/codex-rs/app-server/README.md @@ -147,7 +147,7 @@ Example with notification opt-out: - `thread/memoryMode/set` — experimental; set a thread’s persisted memory eligibility to `"enabled"` or `"disabled"` for either a loaded thread or a stored rollout; returns `{}` on success. - `memory/reset` — experimental; clear the current `CODEX_HOME/memories` directory and reset persisted memory stage data in sqlite while preserving existing thread memory modes; returns `{}` on success. - `thread/status/changed` — notification emitted when a loaded thread’s status changes (`threadId` + new `status`). -- `thread/archive` — move a thread’s rollout file into the archived directory; returns `{}` on success and emits `thread/archived`. +- `thread/archive` — move a thread’s rollout file into the archived directory and attempt to move any spawned descendant thread rollout files; returns `{}` on success and emits `thread/archived` for each archived thread. - `thread/unsubscribe` — unsubscribe this connection from thread turn/item events. If this was the last subscriber, the server keeps the thread loaded and unloads it only after it has had no subscribers and no thread activity for 30 minutes, then emits `thread/closed`. - `thread/name/set` — set or update a thread’s user-facing name for either a loaded thread or a persisted rollout; returns `{}` on success and emits `thread/name/updated` to initialized, opted-in clients. Thread names are not required to be unique; name lookups resolve to the most recently updated thread. - `thread/unarchive` — move an archived rollout file back into the sessions directory; returns the restored `thread` on success and emits `thread/unarchived`. @@ -197,7 +197,7 @@ Example with notification opt-out: - `tool/requestUserInput` — prompt the user with 1–3 short questions for a tool call and return their answers (experimental). - `config/mcpServer/reload` — reload MCP server config from disk and queue a refresh for loaded threads (applied on each thread's next active turn); returns `{}`. Use this after editing `config.toml` without restarting the server. - `mcpServerStatus/list` — enumerate configured MCP servers with their tools and auth status, plus resources/resource templates for `full` detail; supports cursor+limit pagination. If `detail` is omitted, the server defaults to `full`. -- `mcpServer/resource/read` — read a resource from a thread's configured MCP server by `threadId`, `server`, and `uri`, returning text/blob resource `contents`. +- `mcpServer/resource/read` — read a resource from a configured MCP server by optional `threadId`, `server`, and `uri`, returning text/blob resource `contents`. If `threadId` is omitted, the server reads from the latest MCP config directly. - `mcpServer/tool/call` — call a tool on a thread's configured MCP server by `threadId`, `server`, `tool`, optional `arguments`, and optional `_meta`, returning the MCP tool result. - `windowsSandbox/setupStart` — start Windows sandbox setup for the selected mode (`elevated` or `unelevated`); accepts an optional absolute `cwd` to target setup for a specific workspace, returns `{ started: true }` immediately, and later emits `windowsSandbox/setupCompleted`. - `feedback/upload` — submit a feedback report (classification + optional reason/logs, conversation_id, and optional `extraLogFiles` attachments array); returns the tracking thread id. @@ -448,7 +448,7 @@ Experimental: use `memory/reset` to clear local memory artifacts and sqlite-back ### Example: Archive a thread -Use `thread/archive` to move the persisted rollout (stored as a JSONL file on disk) into the archived sessions directory. +Use `thread/archive` to move the persisted rollout (stored as a JSONL file on disk) into the archived sessions directory and attempt to move any spawned descendant thread rollouts. ```json { "method": "thread/archive", "id": 21, "params": { "threadId": "thr_b" } } diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs index 9868c4c64b..d8700a9137 100644 --- a/codex-rs/app-server/src/bespoke_event_handling.rs +++ b/codex-rs/app-server/src/bespoke_event_handling.rs @@ -510,7 +510,8 @@ pub(crate) async fn apply_bespoke_event_handling( )) .await; } - RealtimeEvent::ConversationItemDone { .. } => {} + RealtimeEvent::ConversationItemDone { .. } + | RealtimeEvent::NoopRequested(_) => {} RealtimeEvent::HandoffRequested(handoff) => { let notification = ThreadRealtimeItemAddedNotification { thread_id: conversation_id.to_string(), @@ -953,10 +954,12 @@ pub(crate) async fn apply_bespoke_event_handling( if matches!(api_version, ApiVersion::V2) { let call_id = request.call_id; let turn_id = request.turn_id; + let namespace = request.namespace; let tool = request.tool; let arguments = request.arguments; let item = ThreadItem::DynamicToolCall { id: call_id.clone(), + namespace: namespace.clone(), tool: tool.clone(), arguments: arguments.clone(), status: DynamicToolCallStatus::InProgress, @@ -976,6 +979,7 @@ pub(crate) async fn apply_bespoke_event_handling( thread_id: conversation_id.to_string(), turn_id: turn_id.clone(), call_id: call_id.clone(), + namespace, tool: tool.clone(), arguments: arguments.clone(), }; @@ -1014,6 +1018,7 @@ pub(crate) async fn apply_bespoke_event_handling( let duration_ms = i64::try_from(response.duration.as_millis()).ok(); let item = ThreadItem::DynamicToolCall { id: response.call_id, + namespace: response.namespace, tool: response.tool, arguments: response.arguments, status, diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index 51b1c48c83..7a2ada0765 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -213,6 +213,7 @@ use codex_backend_client::AddCreditsNudgeCreditType as BackendAddCreditsNudgeCre use codex_backend_client::Client as BackendClient; use codex_chatgpt::connectors; use codex_cloud_requirements::cloud_requirements_loader; +use codex_config::ThreadConfigLoader; use codex_config::types::McpServerTransportConfig; use codex_core::CodexThread; use codex_core::ForkSnapshot; @@ -289,6 +290,7 @@ use codex_mcp::McpSnapshotDetail; use codex_mcp::collect_mcp_server_status_snapshot_with_detail_and_authorization_header; use codex_mcp::discover_supported_scopes; use codex_mcp::effective_mcp_servers_with_authorization_header; +use codex_mcp::read_mcp_resource as read_mcp_resource_without_thread; use codex_mcp::resolve_oauth_scopes; use codex_models_manager::collaboration_mode_presets::CollaborationModesConfig; use codex_protocol::ThreadId; @@ -337,6 +339,7 @@ use codex_thread_store::ArchiveThreadParams as StoreArchiveThreadParams; use codex_thread_store::ListThreadsParams as StoreListThreadsParams; use codex_thread_store::LocalThreadStore; use codex_thread_store::ReadThreadParams as StoreReadThreadParams; +use codex_thread_store::RemoteThreadStore; use codex_thread_store::SortDirection as StoreSortDirection; use codex_thread_store::StoredThread; use codex_thread_store::ThreadMetadataPatch as StoreThreadMetadataPatch; @@ -474,10 +477,11 @@ pub(crate) struct CodexMessageProcessor { analytics_events_client: AnalyticsEventsClient, arg0_paths: Arg0DispatchPaths, config: Arc, - thread_store: LocalThreadStore, + thread_store: Arc, cli_overrides: Arc>>, runtime_feature_enablement: Arc>>, cloud_requirements: Arc>, + thread_config_loader: Arc, active_login: Arc>>, pending_thread_unloads: Arc>>, thread_state_manager: ThreadStateManager, @@ -638,10 +642,20 @@ pub(crate) struct CodexMessageProcessorArgs { pub(crate) cli_overrides: Arc>>, pub(crate) runtime_feature_enablement: Arc>>, pub(crate) cloud_requirements: Arc>, + pub(crate) thread_config_loader: Arc, pub(crate) feedback: CodexFeedback, pub(crate) log_db: Option, } +fn configured_thread_store(config: &Config) -> Arc { + match config.experimental_thread_store_endpoint.as_deref() { + Some(endpoint) => Arc::new(RemoteThreadStore::new(endpoint)), + None => Arc::new(LocalThreadStore::new( + codex_rollout::RolloutConfig::from_view(config), + )), + } +} + impl CodexMessageProcessor { async fn instruction_sources_from_config(config: &Config) -> Vec { codex_core::AgentsMdManager::new(config) @@ -716,6 +730,7 @@ impl CodexMessageProcessor { cli_overrides, runtime_feature_enablement, cloud_requirements, + thread_config_loader, feedback, log_db, } = args; @@ -725,11 +740,12 @@ impl CodexMessageProcessor { outgoing: outgoing.clone(), analytics_events_client, arg0_paths, - thread_store: LocalThreadStore::new(codex_rollout::RolloutConfig::from_view(&config)), + thread_store: configured_thread_store(&config), config, cli_overrides, runtime_feature_enablement, cloud_requirements, + thread_config_loader, active_login: Arc::new(Mutex::new(None)), pending_thread_unloads: Arc::new(Mutex::new(HashSet::new())), thread_state_manager: ThreadStateManager::new(), @@ -2423,12 +2439,14 @@ impl CodexMessageProcessor { }; let request_trace = request_context.request_trace(); let runtime_feature_enablement = self.current_runtime_feature_enablement(); + let thread_config_loader = Arc::clone(&self.thread_config_loader); let thread_start_task = async move { Self::thread_start_task( listener_task_context, cli_overrides, runtime_feature_enablement, cloud_requirements, + thread_config_loader, request_id, app_server_client_name, app_server_client_version, @@ -2505,6 +2523,7 @@ impl CodexMessageProcessor { cli_overrides: Vec<(String, TomlValue)>, runtime_feature_enablement: BTreeMap, cloud_requirements: CloudRequirementsLoader, + thread_config_loader: Arc, request_id: ConnectionRequestId, app_server_client_name: Option, app_server_client_version: Option, @@ -2522,6 +2541,7 @@ impl CodexMessageProcessor { &cli_overrides, config_overrides.clone(), typesafe_overrides.clone(), + Arc::clone(&thread_config_loader), &cloud_requirements, &listener_task_context.codex_home, &runtime_feature_enablement, @@ -2603,6 +2623,7 @@ impl CodexMessageProcessor { cli_overrides_for_reload, config_overrides, typesafe_overrides, + thread_config_loader, &cloud_requirements, &listener_task_context.codex_home, &runtime_feature_enablement, @@ -2641,6 +2662,7 @@ impl CodexMessageProcessor { dynamic_tools .into_iter() .map(|tool| CoreDynamicToolSpec { + namespace: tool.namespace, name: tool.name, description: tool.description, input_schema: tool.input_schema, @@ -2851,8 +2873,36 @@ impl CodexMessageProcessor { } }; - let thread_id_str = thread_id.to_string(); - if let Err(err) = self + let mut thread_ids = vec![thread_id]; + if let Some(state_db_ctx) = get_state_db(&self.config).await { + let descendants = match state_db_ctx.list_thread_spawn_descendants(thread_id).await { + Ok(descendants) => descendants, + Err(err) => { + self.outgoing + .send_error( + request_id, + JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: format!( + "failed to list spawned descendants for thread id {thread_id}: {err}" + ), + data: None, + }, + ) + .await; + return; + } + }; + let mut seen = HashSet::from([thread_id]); + for descendant_id in descendants { + if seen.insert(descendant_id) { + thread_ids.push(descendant_id); + } + } + } + + let mut archive_thread_ids = Vec::new(); + match self .thread_store .read_thread(StoreReadThreadParams { thread_id, @@ -2861,34 +2911,98 @@ impl CodexMessageProcessor { }) .await { - self.outgoing - .send_error(request_id, thread_store_archive_error("archive", err)) - .await; - return; - } - self.prepare_thread_for_archive(thread_id).await; - - match self - .thread_store - .archive_thread(StoreArchiveThreadParams { thread_id }) - .await - { - Ok(()) => { - let response = ThreadArchiveResponse {}; - self.outgoing.send_response(request_id, response).await; - let notification = ThreadArchivedNotification { - thread_id: thread_id_str, - }; - self.outgoing - .send_server_notification(ServerNotification::ThreadArchived(notification)) - .await; + Ok(thread) => { + if thread.archived_at.is_none() { + archive_thread_ids.push(thread_id); + } } Err(err) => { self.outgoing .send_error(request_id, thread_store_archive_error("archive", err)) .await; + return; } } + for descendant_thread_id in thread_ids.into_iter().skip(1) { + match self + .thread_store + .read_thread(StoreReadThreadParams { + thread_id: descendant_thread_id, + include_archived: true, + include_history: false, + }) + .await + { + Ok(thread) => { + if thread.archived_at.is_none() { + archive_thread_ids.push(descendant_thread_id); + } + } + Err(err) => { + warn!( + "failed to read spawned descendant thread {descendant_thread_id} while archiving {thread_id}: {err}" + ); + } + } + } + + let mut archived_thread_ids = Vec::new(); + let Some((parent_thread_id, descendant_thread_ids)) = archive_thread_ids.split_first() + else { + self.outgoing + .send_response(request_id, ThreadArchiveResponse {}) + .await; + return; + }; + + self.prepare_thread_for_archive(*parent_thread_id).await; + match self + .thread_store + .archive_thread(StoreArchiveThreadParams { + thread_id: *parent_thread_id, + }) + .await + { + Ok(()) => { + archived_thread_ids.push(parent_thread_id.to_string()); + } + Err(err) => { + self.outgoing + .send_error(request_id, thread_store_archive_error("archive", err)) + .await; + return; + } + } + + for descendant_thread_id in descendant_thread_ids.iter().rev().copied() { + self.prepare_thread_for_archive(descendant_thread_id).await; + match self + .thread_store + .archive_thread(StoreArchiveThreadParams { + thread_id: descendant_thread_id, + }) + .await + { + Ok(()) => { + archived_thread_ids.push(descendant_thread_id.to_string()); + } + Err(err) => { + warn!( + "failed to archive spawned descendant thread {descendant_thread_id} while archiving {thread_id}: {err}" + ); + } + } + } + + self.outgoing + .send_response(request_id, ThreadArchiveResponse {}) + .await; + for thread_id in archived_thread_ids { + let notification = ThreadArchivedNotification { thread_id }; + self.outgoing + .send_server_notification(ServerNotification::ThreadArchived(notification)) + .await; + } } async fn thread_increment_elicitation( @@ -5110,62 +5224,62 @@ impl CodexMessageProcessor { request_id: ConnectionRequestId, params: GetConversationSummaryParams, ) { - if let GetConversationSummaryParams::ThreadId { conversation_id } = ¶ms - && let Some(summary) = - read_summary_from_state_db_by_thread_id(&self.config, *conversation_id).await - { - let response = GetConversationSummaryResponse { summary }; - self.outgoing.send_response(request_id, response).await; - return; - } - - let path = match params { - GetConversationSummaryParams::RolloutPath { rollout_path } => { - if rollout_path.is_relative() { - self.config.codex_home.join(&rollout_path).to_path_buf() - } else { - rollout_path - } - } - GetConversationSummaryParams::ThreadId { conversation_id } => { - match codex_core::find_thread_path_by_id_str( - &self.config.codex_home, - &conversation_id.to_string(), - ) + let fallback_provider = self.config.model_provider_id.as_str(); + let read_result = match params { + GetConversationSummaryParams::ThreadId { conversation_id } => self + .thread_store + .read_thread(StoreReadThreadParams { + thread_id: conversation_id, + include_archived: true, + include_history: false, + }) .await - { - Ok(Some(p)) => p, - _ => { - let error = JSONRPCErrorError { - code: INVALID_REQUEST_ERROR_CODE, - message: format!( - "no rollout found for conversation id {conversation_id}" - ), - data: None, - }; - self.outgoing.send_error(request_id, error).await; - return; - } - } + .map_err(|err| conversation_summary_thread_id_read_error(conversation_id, err)), + GetConversationSummaryParams::RolloutPath { rollout_path } => { + let Some(local_thread_store) = self + .thread_store + .as_any() + .downcast_ref::() + else { + let error = JSONRPCErrorError { + code: INVALID_REQUEST_ERROR_CODE, + message: + "rollout path queries are only supported with the local thread store" + .to_string(), + data: None, + }; + return self.outgoing.send_error(request_id, error).await; + }; + + local_thread_store + .read_thread_by_rollout_path( + rollout_path.clone(), + /*include_archived*/ true, + /*include_history*/ false, + ) + .await + .map_err(|err| conversation_summary_rollout_path_read_error(&rollout_path, err)) } }; - let fallback_provider = self.config.model_provider_id.as_str(); - match read_summary_from_rollout(&path, fallback_provider).await { - Ok(summary) => { + match read_result { + Ok(stored_thread) => { + let Some(summary) = summary_from_stored_thread(stored_thread, fallback_provider) + else { + let error = JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: + "failed to load conversation summary: thread is missing rollout path" + .to_string(), + data: None, + }; + self.outgoing.send_error(request_id, error).await; + return; + }; let response = GetConversationSummaryResponse { summary }; self.outgoing.send_response(request_id, response).await; } - Err(err) => { - let error = JSONRPCErrorError { - code: INTERNAL_ERROR_CODE, - message: format!( - "failed to load conversation summary from {}: {}", - path.display(), - err - ), - data: None, - }; + Err(error) => { self.outgoing.send_error(request_id, error).await; } } @@ -5810,50 +5924,115 @@ impl CodexMessageProcessor { params: McpResourceReadParams, ) { let outgoing = Arc::clone(&self.outgoing); - let (_, thread) = match self.load_thread(¶ms.thread_id).await { - Ok(thread) => thread, + let McpResourceReadParams { + thread_id, + server, + uri, + } = params; + + if let Some(thread_id) = thread_id { + let (_, thread) = match self.load_thread(&thread_id).await { + Ok(thread) => thread, + Err(error) => { + self.outgoing.send_error(request_id, error).await; + return; + } + }; + + tokio::spawn(async move { + let result = thread.read_mcp_resource(&server, &uri).await; + Self::send_mcp_resource_read_response(outgoing, request_id, result).await; + }); + return; + } + + let config = match self.load_latest_config(/*fallback_cwd*/ None).await { + Ok(config) => config, Err(error) => { self.outgoing.send_error(request_id, error).await; return; } }; + let mcp_config = config + .to_mcp_config(self.thread_manager.plugins_manager().as_ref()) + .await; + let auth = self.auth_manager.auth().await; + let runtime_environment = match self.thread_manager.environment_manager().current().await { + Ok(Some(environment)) => { + // Resource reads without a thread have no turn cwd. This fallback + // is used only by executor-backed stdio MCPs whose config omits `cwd`. + McpRuntimeEnvironment::new(environment, config.cwd.to_path_buf()) + } + Ok(None) => McpRuntimeEnvironment::new( + Arc::new(codex_exec_server::Environment::default()), + config.cwd.to_path_buf(), + ), + Err(err) => { + let error = JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: format!("failed to create environment: {err}"), + data: None, + }; + self.outgoing.send_error(request_id, error).await; + return; + } + }; tokio::spawn(async move { - let result = thread.read_mcp_resource(¶ms.server, ¶ms.uri).await; - match result { - Ok(result) => match serde_json::from_value::(result) { - Ok(response) => { - outgoing.send_response(request_id, response).await; - } - Err(error) => { - outgoing - .send_error( - request_id, - JSONRPCErrorError { - code: INTERNAL_ERROR_CODE, - message: format!( - "failed to deserialize MCP resource read response: {error}" - ), - data: None, - }, - ) - .await; - } - }, + let result = match read_mcp_resource_without_thread( + &mcp_config, + auth.as_ref(), + runtime_environment, + &server, + &uri, + ) + .await + { + Ok(result) => serde_json::to_value(result).map_err(anyhow::Error::from), + Err(error) => Err(error), + }; + Self::send_mcp_resource_read_response(outgoing, request_id, result).await; + }); + } + + async fn send_mcp_resource_read_response( + outgoing: Arc, + request_id: ConnectionRequestId, + result: anyhow::Result, + ) { + match result { + Ok(result) => match serde_json::from_value::(result) { + Ok(response) => { + outgoing.send_response(request_id, response).await; + } Err(error) => { outgoing .send_error( request_id, JSONRPCErrorError { code: INTERNAL_ERROR_CODE, - message: format!("{error:#}"), + message: format!( + "failed to deserialize MCP resource read response: {error}" + ), data: None, }, ) .await; } + }, + Err(error) => { + outgoing + .send_error( + request_id, + JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: format!("{error:#}"), + data: None, + }, + ) + .await; } - }); + } } async fn call_mcp_server_tool( @@ -6399,6 +6578,7 @@ impl CodexMessageProcessor { } }; let cli_overrides = self.current_cli_overrides(); + let host_name = codex_config::host_name(); let mut data = Vec::new(); for cwd in cwds { let extra_roots = extra_roots_by_cwd @@ -6426,6 +6606,8 @@ impl CodexMessageProcessor { &cli_overrides, LoaderOverrides::default(), CloudRequirementsLoader::default(), + self.thread_config_loader.as_ref(), + host_name.as_deref(), ) .await { @@ -7945,6 +8127,10 @@ impl CodexMessageProcessor { .await } + #[expect( + clippy::await_holding_invalid_type, + reason = "listener subscription must be serialized against pending thread unloads" + )] async fn ensure_conversation_listener_task( listener_task_context: ListenerTaskContext, conversation_id: ThreadId, @@ -8752,6 +8938,10 @@ async fn handle_thread_listener_command( } #[allow(clippy::too_many_arguments)] +#[expect( + clippy::await_holding_invalid_type, + reason = "running-thread resume subscription must be serialized against pending unloads" +)] async fn handle_pending_thread_resume_request( conversation_id: ThreadId, conversation: &Arc, @@ -9287,9 +9477,37 @@ fn validate_dynamic_tools(tools: &[ApiDynamicToolSpec]) -> Result<(), String> { if name == "mcp" || name.starts_with("mcp__") { return Err(format!("dynamic tool name is reserved: {name}")); } - if !seen.insert(name.to_string()) { + let namespace = tool.namespace.as_deref().map(str::trim); + if let Some(namespace) = namespace { + if namespace.is_empty() { + return Err(format!( + "dynamic tool namespace must not be empty for {name}" + )); + } + if Some(namespace) != tool.namespace.as_deref() { + return Err(format!( + "dynamic tool namespace has leading/trailing whitespace for {name}: {namespace}", + )); + } + if namespace == "mcp" || namespace.starts_with("mcp__") { + return Err(format!( + "dynamic tool namespace is reserved for {name}: {namespace}" + )); + } + } + if !seen.insert((namespace, name)) { + if let Some(namespace) = namespace { + return Err(format!( + "duplicate dynamic tool name in namespace {namespace}: {name}" + )); + } return Err(format!("duplicate dynamic tool name: {name}")); } + if tool.defer_loading && namespace.is_none() { + return Err(format!( + "deferred dynamic tool must include a namespace: {name}" + )); + } if let Err(err) = codex_tools::parse_tool_input_schema(&tool.input_schema) { return Err(format!( @@ -9350,6 +9568,7 @@ async fn derive_config_from_params( cli_overrides: &[(String, TomlValue)], request_overrides: Option>, typesafe_overrides: ConfigOverrides, + thread_config_loader: Arc, cloud_requirements: &CloudRequirementsLoader, codex_home: &Path, runtime_feature_enablement: &BTreeMap, @@ -9370,6 +9589,7 @@ async fn derive_config_from_params( .cli_overrides(merged_cli_overrides) .harness_overrides(typesafe_overrides) .cloud_requirements(cloud_requirements.clone()) + .thread_config_loader(thread_config_loader) .build() .await?; apply_runtime_feature_enablement(&mut config, runtime_feature_enablement); @@ -9531,6 +9751,61 @@ fn thread_store_list_error(err: ThreadStoreError) -> JSONRPCErrorError { } } +fn conversation_summary_thread_id_read_error( + conversation_id: ThreadId, + err: ThreadStoreError, +) -> JSONRPCErrorError { + let no_rollout_message = format!("no rollout found for thread id {conversation_id}"); + match err { + ThreadStoreError::InvalidRequest { message } if message == no_rollout_message => { + conversation_summary_not_found_error(conversation_id) + } + ThreadStoreError::ThreadNotFound { thread_id } if thread_id == conversation_id => { + conversation_summary_not_found_error(conversation_id) + } + ThreadStoreError::InvalidRequest { message } => JSONRPCErrorError { + code: INVALID_REQUEST_ERROR_CODE, + message, + data: None, + }, + err => JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: format!("failed to load conversation summary for {conversation_id}: {err}"), + data: None, + }, + } +} + +fn conversation_summary_not_found_error(conversation_id: ThreadId) -> JSONRPCErrorError { + JSONRPCErrorError { + code: INVALID_REQUEST_ERROR_CODE, + message: format!("no rollout found for conversation id {conversation_id}"), + data: None, + } +} + +fn conversation_summary_rollout_path_read_error( + path: &Path, + err: ThreadStoreError, +) -> JSONRPCErrorError { + match err { + ThreadStoreError::InvalidRequest { message } => JSONRPCErrorError { + code: INVALID_REQUEST_ERROR_CODE, + message, + data: None, + }, + err => JSONRPCErrorError { + code: INTERNAL_ERROR_CODE, + message: format!( + "failed to load conversation summary from {}: {}", + path.display(), + err + ), + data: None, + }, + } +} + fn thread_store_write_error(operation: &str, err: ThreadStoreError) -> JSONRPCErrorError { match err { ThreadStoreError::ThreadNotFound { thread_id } => JSONRPCErrorError { @@ -10245,6 +10520,11 @@ mod tests { use chrono::Utc; use codex_app_server_protocol::ServerRequestPayload; use codex_app_server_protocol::ToolRequestUserInputParams; + use codex_config::SessionThreadConfig; + use codex_config::StaticThreadConfigLoader; + use codex_config::ThreadConfigSource; + use codex_model_provider_info::ModelProviderInfo; + use codex_model_provider_info::WireApi; use codex_protocol::ThreadId; use codex_protocol::openai_models::ReasoningEffort; use codex_protocol::protocol::AskForApproval; @@ -10257,11 +10537,13 @@ mod tests { use pretty_assertions::assert_eq; use serde_json::json; use std::path::PathBuf; + use std::sync::Arc; use tempfile::TempDir; #[test] fn validate_dynamic_tools_rejects_unsupported_input_schema() { let tools = vec![ApiDynamicToolSpec { + namespace: None, name: "my_tool".to_string(), description: "test".to_string(), input_schema: json!({"type": "null"}), @@ -10274,6 +10556,7 @@ mod tests { #[test] fn validate_dynamic_tools_accepts_sanitizable_input_schema() { let tools = vec![ApiDynamicToolSpec { + namespace: None, name: "my_tool".to_string(), description: "test".to_string(), // Missing `type` is common; core sanitizes these to a supported schema. @@ -10286,6 +10569,7 @@ mod tests { #[test] fn validate_dynamic_tools_accepts_nullable_field_schema() { let tools = vec![ApiDynamicToolSpec { + namespace: None, name: "my_tool".to_string(), description: "test".to_string(), input_schema: json!({ @@ -10301,6 +10585,102 @@ mod tests { validate_dynamic_tools(&tools).expect("valid schema"); } + #[test] + fn validate_dynamic_tools_accepts_same_name_in_different_namespaces() { + let tools = vec![ + ApiDynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ApiDynamicToolSpec { + namespace: Some("other_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ]; + validate_dynamic_tools(&tools).expect("valid schema"); + } + + #[test] + fn validate_dynamic_tools_rejects_duplicate_name_in_same_namespace() { + let tools = vec![ + ApiDynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ApiDynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: true, + }, + ]; + let err = validate_dynamic_tools(&tools).expect_err("duplicate name"); + assert!(err.contains("codex_app"), "unexpected error: {err}"); + assert!(err.contains("my_tool"), "unexpected error: {err}"); + } + + #[test] + fn validate_dynamic_tools_rejects_empty_namespace() { + let tools = vec![ApiDynamicToolSpec { + namespace: Some("".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: false, + }]; + let err = validate_dynamic_tools(&tools).expect_err("empty namespace"); + assert!(err.contains("my_tool"), "unexpected error: {err}"); + assert!(err.contains("namespace"), "unexpected error: {err}"); + } + + #[test] + fn validate_dynamic_tools_rejects_reserved_namespace() { + let tools = vec![ApiDynamicToolSpec { + namespace: Some("mcp__server__".to_string()), + name: "my_tool".to_string(), + description: "test".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + defer_loading: false, + }]; + let err = validate_dynamic_tools(&tools).expect_err("reserved namespace"); + assert!(err.contains("my_tool"), "unexpected error: {err}"); + assert!(err.contains("reserved"), "unexpected error: {err}"); + } + #[test] fn summary_from_stored_thread_preserves_millisecond_precision() { let created_at = @@ -10409,6 +10789,65 @@ mod tests { ); } + #[tokio::test] + async fn derive_config_from_params_uses_session_thread_config_model_provider() -> Result<()> { + let temp_dir = TempDir::new()?; + let session_provider = ModelProviderInfo { + name: "session".to_string(), + base_url: Some("http://127.0.0.1:8061/api/codex".to_string()), + env_key: None, + env_key_instructions: None, + experimental_bearer_token: None, + auth: None, + aws: None, + wire_api: WireApi::Responses, + query_params: None, + http_headers: None, + env_http_headers: None, + request_max_retries: None, + stream_max_retries: None, + stream_idle_timeout_ms: None, + websocket_connect_timeout_ms: None, + requires_openai_auth: false, + supports_websockets: true, + }; + let config = derive_config_from_params( + &[], + Some(HashMap::from([ + ("model_provider".to_string(), json!("request")), + ("features.plugins".to_string(), json!(true)), + ( + "model_providers.session".to_string(), + json!({ + "name": "request", + "base_url": "http://127.0.0.1:9999/api/codex", + "wire_api": "responses", + }), + ), + ])), + ConfigOverrides::default(), + Arc::new(StaticThreadConfigLoader::new(vec![ + ThreadConfigSource::Session(SessionThreadConfig { + model_provider: Some("session".to_string()), + model_providers: HashMap::from([( + "session".to_string(), + session_provider.clone(), + )]), + features: BTreeMap::from([("plugins".to_string(), false)]), + }), + ])), + &CloudRequirementsLoader::default(), + temp_dir.path(), + &BTreeMap::new(), + ) + .await?; + + assert_eq!(config.model_provider_id, "session"); + assert_eq!(config.model_provider, session_provider); + assert!(!config.features.enabled(Feature::Plugins)); + Ok(()) + } + #[test] fn collect_resume_override_mismatches_includes_service_tier() { let request = ThreadResumeParams { diff --git a/codex-rs/app-server/src/config_api.rs b/codex-rs/app-server/src/config_api.rs index feb1cc7884..c57d3893c1 100644 --- a/codex-rs/app-server/src/config_api.rs +++ b/codex-rs/app-server/src/config_api.rs @@ -108,6 +108,7 @@ impl ConfigApi { self.current_cli_overrides(), self.loader_overrides.clone(), self.current_cloud_requirements(), + codex_config::host_name(), ) } @@ -563,6 +564,7 @@ mod tests { CoreSandboxModeRequirement::ReadOnly, CoreSandboxModeRequirement::ExternalSandbox, ]), + remote_sandbox_config: None, allowed_web_search_modes: Some(vec![ codex_core::config_loader::WebSearchModeRequirement::Cached, ]), @@ -675,6 +677,7 @@ mod tests { allowed_approval_policies: None, allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -733,6 +736,7 @@ mod tests { allowed_approval_policies: None, allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: Some(Vec::new()), guardian_policy_config: None, feature_requirements: None, diff --git a/codex-rs/app-server/src/in_process.rs b/codex-rs/app-server/src/in_process.rs index 4458bce89d..e73124c0d3 100644 --- a/codex-rs/app-server/src/in_process.rs +++ b/codex-rs/app-server/src/in_process.rs @@ -75,6 +75,7 @@ use codex_app_server_protocol::Result; use codex_app_server_protocol::ServerNotification; use codex_app_server_protocol::ServerRequest; use codex_arg0::Arg0DispatchPaths; +use codex_config::ThreadConfigLoader; use codex_core::config::Config; use codex_core::config_loader::CloudRequirementsLoader; use codex_core::config_loader::LoaderOverrides; @@ -116,6 +117,8 @@ pub struct InProcessStartArgs { pub loader_overrides: LoaderOverrides, /// Preloaded cloud requirements provider. pub cloud_requirements: CloudRequirementsLoader, + /// Loader used to fetch typed thread config sources before a thread starts. + pub thread_config_loader: Arc, /// Feedback sink used by app-server/core telemetry and logs. pub feedback: CodexFeedback, /// SQLite tracing layer used to flush recently emitted logs before feedback upload. @@ -397,6 +400,7 @@ fn start_uninitialized(args: InProcessStartArgs) -> InProcessClientHandle { cli_overrides: args.cli_overrides, loader_overrides: args.loader_overrides, cloud_requirements: args.cloud_requirements, + thread_config_loader: args.thread_config_loader, feedback: args.feedback, log_db: args.log_db, config_warnings: args.config_warnings, @@ -731,6 +735,7 @@ mod tests { cli_overrides: Vec::new(), loader_overrides: LoaderOverrides::default(), cloud_requirements: CloudRequirementsLoader::default(), + thread_config_loader: Arc::new(codex_config::NoopThreadConfigLoader), feedback: CodexFeedback::new(), log_db: None, environment_manager: Arc::new(EnvironmentManager::new(/*exec_server_url*/ None)), diff --git a/codex-rs/app-server/src/lib.rs b/codex-rs/app-server/src/lib.rs index b7b099960b..d9c108033f 100644 --- a/codex-rs/app-server/src/lib.rs +++ b/codex-rs/app-server/src/lib.rs @@ -2,6 +2,7 @@ use codex_arg0::Arg0DispatchPaths; use codex_cloud_requirements::cloud_requirements_loader; +use codex_config::NoopThreadConfigLoader; use codex_core::config::Config; use codex_core::config::ConfigBuilder; use codex_core::config_loader::CloudRequirementsLoader; @@ -416,6 +417,7 @@ pub async fn run_main_with_transport( } }; let loader_overrides_for_config_api = loader_overrides.clone(); + let thread_config_loader = Arc::new(NoopThreadConfigLoader); let mut config_warnings = Vec::new(); let config = match ConfigBuilder::default() .cli_overrides(cli_kv_overrides.clone()) @@ -659,6 +661,7 @@ pub async fn run_main_with_transport( cli_overrides, loader_overrides, cloud_requirements: cloud_requirements.clone(), + thread_config_loader, feedback: feedback.clone(), log_db, config_warnings, diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rs index da72af81c5..2032eb61cd 100644 --- a/codex-rs/app-server/src/message_processor.rs +++ b/codex-rs/app-server/src/message_processor.rs @@ -63,6 +63,7 @@ use codex_app_server_protocol::ServerRequestPayload; use codex_app_server_protocol::experimental_required_message; use codex_arg0::Arg0DispatchPaths; use codex_chatgpt::connectors; +use codex_config::ThreadConfigLoader; use codex_core::ThreadManager; use codex_core::config::Config; use codex_core::config_loader::CloudRequirementsLoader; @@ -235,6 +236,7 @@ pub(crate) struct MessageProcessorArgs { pub(crate) cli_overrides: Vec<(String, TomlValue)>, pub(crate) loader_overrides: LoaderOverrides, pub(crate) cloud_requirements: CloudRequirementsLoader, + pub(crate) thread_config_loader: Arc, pub(crate) feedback: CodexFeedback, pub(crate) log_db: Option, pub(crate) config_warnings: Vec, @@ -256,6 +258,7 @@ impl MessageProcessor { cli_overrides, loader_overrides, cloud_requirements, + thread_config_loader, feedback, log_db, config_warnings, @@ -301,6 +304,7 @@ impl MessageProcessor { cli_overrides: cli_overrides.clone(), runtime_feature_enablement: runtime_feature_enablement.clone(), cloud_requirements: cloud_requirements.clone(), + thread_config_loader, feedback, log_db, }); diff --git a/codex-rs/app-server/src/message_processor/tracing_tests.rs b/codex-rs/app-server/src/message_processor/tracing_tests.rs index c1bb995bab..83f8bc98d7 100644 --- a/codex-rs/app-server/src/message_processor/tracing_tests.rs +++ b/codex-rs/app-server/src/message_processor/tracing_tests.rs @@ -245,6 +245,7 @@ fn build_test_processor( cli_overrides: Vec::new(), loader_overrides: LoaderOverrides::default(), cloud_requirements: CloudRequirementsLoader::default(), + thread_config_loader: Arc::new(codex_config::NoopThreadConfigLoader), feedback: CodexFeedback::new(), log_db: None, config_warnings: Vec::new(), @@ -504,6 +505,10 @@ where } #[tokio::test(flavor = "current_thread")] +#[expect( + clippy::await_holding_invalid_type, + reason = "test serializes access to global tracing state for its full duration" +)] async fn thread_start_jsonrpc_span_exports_server_span_and_parents_children() -> Result<()> { let _guard = tracing_test_guard().lock().await; let mut harness = TracingHarness::new().await?; @@ -583,6 +588,10 @@ async fn thread_start_jsonrpc_span_exports_server_span_and_parents_children() -> } #[tokio::test(flavor = "current_thread")] +#[expect( + clippy::await_holding_invalid_type, + reason = "test serializes access to global tracing state for its full duration" +)] async fn turn_start_jsonrpc_span_parents_core_turn_spans() -> Result<()> { let _guard = tracing_test_guard().lock().await; let mut harness = TracingHarness::new().await?; diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rs index 1f02fca326..3c5bef3ea4 100644 --- a/codex-rs/app-server/src/outgoing_message.rs +++ b/codex-rs/app-server/src/outgoing_message.rs @@ -1067,6 +1067,7 @@ mod tests { thread_id: thread_id.to_string(), turn_id: "turn-1".to_string(), call_id: "call-0".to_string(), + namespace: None, tool: "tool".to_string(), arguments: json!({}), }, @@ -1124,6 +1125,7 @@ mod tests { thread_id: thread_id.to_string(), turn_id: "turn-1".to_string(), call_id: "call-0".to_string(), + namespace: None, tool: "tool".to_string(), arguments: json!({}), }, diff --git a/codex-rs/app-server/src/transport/mod.rs b/codex-rs/app-server/src/transport/mod.rs index d12107b1d8..a07bd44188 100644 --- a/codex-rs/app-server/src/transport/mod.rs +++ b/codex-rs/app-server/src/transport/mod.rs @@ -781,6 +781,7 @@ mod tests { codex_app_server_protocol::AdditionalFileSystemPermissions { read: Some(vec![absolute_path("/tmp/allowed")]), write: None, + glob_scan_max_depth: None, entries: None, }, ), @@ -844,6 +845,7 @@ mod tests { codex_app_server_protocol::AdditionalFileSystemPermissions { read: Some(vec![absolute_path("/tmp/allowed")]), write: None, + glob_scan_max_depth: None, entries: None, }, ), diff --git a/codex-rs/app-server/src/transport/remote_control/websocket.rs b/codex-rs/app-server/src/transport/remote_control/websocket.rs index ac91882f52..dee177d30e 100644 --- a/codex-rs/app-server/src/transport/remote_control/websocket.rs +++ b/codex-rs/app-server/src/transport/remote_control/websocket.rs @@ -205,6 +205,10 @@ impl RemoteControlWebsocket { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "remote-control client shutdown must serialize tracker state" + )] pub(crate) async fn run( mut self, app_server_client_name_rx: Option>, @@ -416,6 +420,10 @@ impl RemoteControlWebsocket { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "remote-control server event receiver is shared across reconnects" + )] async fn run_server_writer_inner( state: Arc>, server_event_rx: Arc>>, @@ -557,6 +565,10 @@ impl RemoteControlWebsocket { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "remote-control client tracking must stay serialized while processing inbound events" + )] async fn run_websocket_reader_inner( client_tracker: Arc>, state: Arc>, diff --git a/codex-rs/app-server/tests/suite/conversation_summary.rs b/codex-rs/app-server/tests/suite/conversation_summary.rs index 4690a44ca3..b05cee8230 100644 --- a/codex-rs/app-server/tests/suite/conversation_summary.rs +++ b/codex-rs/app-server/tests/suite/conversation_summary.rs @@ -6,6 +6,7 @@ use app_test_support::to_response; use codex_app_server_protocol::ConversationSummary; use codex_app_server_protocol::GetConversationSummaryParams; use codex_app_server_protocol::GetConversationSummaryResponse; +use codex_app_server_protocol::JSONRPCError; use codex_app_server_protocol::JSONRPCResponse; use codex_app_server_protocol::RequestId; use codex_protocol::ThreadId; @@ -18,16 +19,18 @@ use tokio::time::timeout; const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10); const FILENAME_TS: &str = "2025-01-02T12-00-00"; const META_RFC3339: &str = "2025-01-02T12:00:00Z"; +const CREATED_AT_RFC3339: &str = "2025-01-02T12:00:00.000Z"; const UPDATED_AT_RFC3339: &str = "2025-01-02T12:00:00.000Z"; const PREVIEW: &str = "Summarize this conversation"; const MODEL_PROVIDER: &str = "openai"; +const INVALID_REQUEST_ERROR_CODE: i64 = -32600; fn expected_summary(conversation_id: ThreadId, path: PathBuf) -> ConversationSummary { ConversationSummary { conversation_id, path, preview: PREVIEW.to_string(), - timestamp: Some(META_RFC3339.to_string()), + timestamp: Some(CREATED_AT_RFC3339.to_string()), updated_at: Some(UPDATED_AT_RFC3339.to_string()), model_provider: MODEL_PROVIDER.to_string(), cwd: PathBuf::from("/"), @@ -77,6 +80,37 @@ async fn get_conversation_summary_by_thread_id_reads_rollout() -> Result<()> { Ok(()) } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn get_conversation_summary_by_rollout_path_rejects_remote_thread_store() -> Result<()> { + let codex_home = TempDir::new()?; + std::fs::write( + codex_home.path().join("config.toml"), + r#"experimental_thread_store_endpoint = "http://127.0.0.1:1" +"#, + )?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let request_id = mcp + .send_get_conversation_summary_request(GetConversationSummaryParams::RolloutPath { + rollout_path: PathBuf::from("sessions/2025/01/02/rollout.jsonl"), + }) + .await?; + let error: JSONRPCError = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_error_message(RequestId::Integer(request_id)), + ) + .await??; + + assert_eq!(error.error.code, INVALID_REQUEST_ERROR_CODE); + assert_eq!( + error.error.message, + "rollout path queries are only supported with the local thread store" + ); + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn get_conversation_summary_by_relative_rollout_path_resolves_from_codex_home() -> Result<()> { diff --git a/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs b/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs index 50dd071d84..7ee21a2068 100644 --- a/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs +++ b/codex-rs/app-server/tests/suite/v2/dynamic_tools.rs @@ -64,6 +64,7 @@ async fn thread_start_injects_dynamic_tools_into_model_requests() -> Result<()> "additionalProperties": false, }); let dynamic_tool = DynamicToolSpec { + namespace: None, name: "demo_tool".to_string(), description: "Demo dynamic tool".to_string(), input_schema: input_schema.clone(), @@ -137,6 +138,7 @@ async fn thread_start_keeps_hidden_dynamic_tools_out_of_model_requests() -> Resu timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; let dynamic_tool = DynamicToolSpec { + namespace: Some("codex_app".to_string()), name: "hidden_tool".to_string(), description: "Hidden dynamic tool".to_string(), input_schema: json!({ @@ -197,10 +199,51 @@ async fn thread_start_keeps_hidden_dynamic_tools_out_of_model_requests() -> Resu Ok(()) } +#[tokio::test] +async fn thread_start_rejects_hidden_dynamic_tools_without_namespace() -> Result<()> { + let server = MockServer::start().await; + + let codex_home = TempDir::new()?; + create_config_toml(codex_home.path(), &server.uri())?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let dynamic_tool = DynamicToolSpec { + namespace: None, + name: "hidden_tool".to_string(), + description: "Hidden dynamic tool".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false, + }), + defer_loading: true, + }; + + let thread_req = mcp + .send_thread_start_request(ThreadStartParams { + dynamic_tools: Some(vec![dynamic_tool]), + ..Default::default() + }) + .await?; + let error = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_error_message(RequestId::Integer(thread_req)), + ) + .await??; + assert_eq!(error.error.code, -32600); + assert!(error.error.message.contains("hidden_tool")); + assert!(error.error.message.contains("namespace")); + + Ok(()) +} + /// Exercises the full dynamic tool call path (server request, client response, model output). #[tokio::test] async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Result<()> { let call_id = "dyn-call-1"; + let tool_namespace = "codex_app"; let tool_name = "demo_tool"; let tool_args = json!({ "city": "Paris" }); let tool_call_arguments = serde_json::to_string(&tool_args)?; @@ -209,7 +252,16 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res let responses = vec![ responses::sse(vec![ responses::ev_response_created("resp-1"), - responses::ev_function_call(call_id, tool_name, &tool_call_arguments), + json!({ + "type": "response.output_item.done", + "item": { + "type": "function_call", + "call_id": call_id, + "namespace": tool_namespace, + "name": tool_name, + "arguments": tool_call_arguments, + } + }), responses::ev_completed("resp-1"), ]), create_final_assistant_message_sse_response("Done")?, @@ -223,6 +275,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; let dynamic_tool = DynamicToolSpec { + namespace: Some(tool_namespace.to_string()), name: tool_name.to_string(), description: "Demo dynamic tool".to_string(), input_schema: json!({ @@ -274,6 +327,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res assert_eq!(started.turn_id, turn_id.clone()); let ThreadItem::DynamicToolCall { id, + namespace, tool, arguments, status, @@ -285,6 +339,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res panic!("expected dynamic tool call item"); }; assert_eq!(id, call_id); + assert_eq!(namespace.as_deref(), Some(tool_namespace)); assert_eq!(tool, tool_name); assert_eq!(arguments, tool_args); assert_eq!(status, DynamicToolCallStatus::InProgress); @@ -307,6 +362,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res thread_id: thread_id.clone(), turn_id: turn_id.clone(), call_id: call_id.to_string(), + namespace: Some(tool_namespace.to_string()), tool: tool_name.to_string(), arguments: tool_args.clone(), }; @@ -327,6 +383,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res assert_eq!(completed.turn_id, turn_id); let ThreadItem::DynamicToolCall { id, + namespace, tool, arguments, status, @@ -338,6 +395,7 @@ async fn dynamic_tool_call_round_trip_sends_text_content_items_to_model() -> Res panic!("expected dynamic tool call item"); }; assert_eq!(id, call_id); + assert_eq!(namespace.as_deref(), Some(tool_namespace)); assert_eq!(tool, tool_name); assert_eq!(arguments, tool_args); assert_eq!(status, DynamicToolCallStatus::Completed); @@ -392,6 +450,7 @@ async fn dynamic_tool_call_round_trip_sends_content_items_to_model() -> Result<( timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; let dynamic_tool = DynamicToolSpec { + namespace: None, name: tool_name.to_string(), description: "Demo dynamic tool".to_string(), input_schema: json!({ @@ -455,6 +514,7 @@ async fn dynamic_tool_call_round_trip_sends_content_items_to_model() -> Result<( thread_id, turn_id: turn_id.clone(), call_id: call_id.to_string(), + namespace: None, tool: tool_name.to_string(), arguments: tool_args, }; diff --git a/codex-rs/app-server/tests/suite/v2/mcp_resource.rs b/codex-rs/app-server/tests/suite/v2/mcp_resource.rs index b0ff8888a4..c26b456fa9 100644 --- a/codex-rs/app-server/tests/suite/v2/mcp_resource.rs +++ b/codex-rs/app-server/tests/suite/v2/mcp_resource.rs @@ -43,6 +43,7 @@ use rmcp::transport::StreamableHttpService; use rmcp::transport::streamable_http_server::session::local::LocalSessionManager; use tempfile::TempDir; use tokio::net::TcpListener; +use tokio::task::JoinHandle; use tokio::time::timeout; const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(10); @@ -54,19 +55,7 @@ const TEST_RESOURCE_TEXT: &str = "Resource body from the MCP server."; #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn mcp_resource_read_returns_resource_contents() -> Result<()> { let responses_server = responses::start_mock_server().await; - let listener = TcpListener::bind("127.0.0.1:0").await?; - let addr = listener.local_addr()?; - let apps_server_url = format!("http://{addr}"); - - let mcp_service = StreamableHttpService::new( - move || Ok(ResourceAppsMcpServer), - Arc::new(LocalSessionManager::default()), - StreamableHttpServerConfig::default(), - ); - let router = Router::new().nest_service("/api/codex/apps", mcp_service); - let apps_server_handle = tokio::spawn(async move { - let _ = axum::serve(listener, router).await; - }); + let (apps_server_url, apps_server_handle) = start_resource_apps_mcp_server().await?; let codex_home = TempDir::new()?; let responses_server_uri = responses_server.uri(); @@ -121,7 +110,7 @@ stream_max_retries = 0 let read_request_id = mcp .send_mcp_resource_read_request(McpResourceReadParams { - thread_id: thread.id, + thread_id: Some(thread.id), server: "codex_apps".to_string(), uri: TEST_RESOURCE_URI.to_string(), }) @@ -134,22 +123,59 @@ stream_max_retries = 0 assert_eq!( to_response::(read_response)?, - McpResourceReadResponse { - contents: vec![ - McpResourceContent::Text { - uri: TEST_RESOURCE_URI.to_string(), - mime_type: Some("text/markdown".to_string()), - text: TEST_RESOURCE_TEXT.to_string(), - meta: None, - }, - McpResourceContent::Blob { - uri: TEST_BLOB_RESOURCE_URI.to_string(), - mime_type: Some("application/octet-stream".to_string()), - blob: TEST_RESOURCE_BLOB.to_string(), - meta: None, - }, - ], - } + expected_resource_read_response() + ); + + apps_server_handle.abort(); + let _ = apps_server_handle.await; + Ok(()) +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn mcp_resource_read_returns_resource_contents_without_thread() -> Result<()> { + let (apps_server_url, apps_server_handle) = start_resource_apps_mcp_server().await?; + + let codex_home = TempDir::new()?; + std::fs::write( + codex_home.path().join("config.toml"), + format!( + r#" +chatgpt_base_url = "{apps_server_url}" +mcp_oauth_credentials_store = "file" + +[features] +apps = true +"# + ), + )?; + write_chatgpt_auth( + codex_home.path(), + ChatGptAuthFixture::new("chatgpt-token") + .account_id("account-123") + .chatgpt_user_id("user-123") + .chatgpt_account_id("account-123"), + AuthCredentialsStoreMode::File, + )?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let read_request_id = mcp + .send_mcp_resource_read_request(McpResourceReadParams { + thread_id: None, + server: "codex_apps".to_string(), + uri: TEST_RESOURCE_URI.to_string(), + }) + .await?; + let read_response: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(read_request_id)), + ) + .await??; + + assert_eq!( + to_response::(read_response)?, + expected_resource_read_response() ); apps_server_handle.abort(); @@ -175,6 +201,7 @@ async fn mcp_resource_read_returns_error_for_unknown_thread() -> Result<()> { cli_overrides: Vec::new(), loader_overrides, cloud_requirements: CloudRequirementsLoader::default(), + thread_config_loader: Arc::new(codex_config::NoopThreadConfigLoader), feedback: CodexFeedback::new(), log_db: None, environment_manager: Arc::new(EnvironmentManager::new(/*exec_server_url*/ None)), @@ -197,7 +224,7 @@ async fn mcp_resource_read_returns_error_for_unknown_thread() -> Result<()> { .request(ClientRequest::McpResourceRead { request_id: RequestId::Integer(1), params: McpResourceReadParams { - thread_id: "00000000-0000-4000-8000-000000000000".to_string(), + thread_id: Some("00000000-0000-4000-8000-000000000000".to_string()), server: "codex_apps".to_string(), uri: TEST_RESOURCE_URI.to_string(), }, @@ -217,6 +244,43 @@ async fn mcp_resource_read_returns_error_for_unknown_thread() -> Result<()> { Ok(()) } +async fn start_resource_apps_mcp_server() -> Result<(String, JoinHandle<()>)> { + let listener = TcpListener::bind("127.0.0.1:0").await?; + let addr = listener.local_addr()?; + let apps_server_url = format!("http://{addr}"); + + let mcp_service = StreamableHttpService::new( + move || Ok(ResourceAppsMcpServer), + Arc::new(LocalSessionManager::default()), + StreamableHttpServerConfig::default(), + ); + let router = Router::new().nest_service("/api/codex/apps", mcp_service); + let apps_server_handle = tokio::spawn(async move { + let _ = axum::serve(listener, router).await; + }); + + Ok((apps_server_url, apps_server_handle)) +} + +fn expected_resource_read_response() -> McpResourceReadResponse { + McpResourceReadResponse { + contents: vec![ + McpResourceContent::Text { + uri: TEST_RESOURCE_URI.to_string(), + mime_type: Some("text/markdown".to_string()), + text: TEST_RESOURCE_TEXT.to_string(), + meta: None, + }, + McpResourceContent::Blob { + uri: TEST_BLOB_RESOURCE_URI.to_string(), + mime_type: Some("application/octet-stream".to_string()), + blob: TEST_RESOURCE_BLOB.to_string(), + meta: None, + }, + ], + } +} + #[derive(Clone, Default)] struct ResourceAppsMcpServer; diff --git a/codex-rs/app-server/tests/suite/v2/realtime_conversation.rs b/codex-rs/app-server/tests/suite/v2/realtime_conversation.rs index e5676b55ff..dfc3fea318 100644 --- a/codex-rs/app-server/tests/suite/v2/realtime_conversation.rs +++ b/codex-rs/app-server/tests/suite/v2/realtime_conversation.rs @@ -1155,7 +1155,7 @@ async fn realtime_webrtc_start_emits_sdp_notification() -> Result<()> { Some("multipart/form-data; boundary=codex-realtime-call-boundary") ); let body = String::from_utf8(request.body).context("multipart body should be utf-8")?; - let session = r#"{"tool_choice":"auto","type":"realtime","model":"gpt-realtime-1.5","instructions":"backend prompt\n\nstartup context","output_modalities":["audio"],"audio":{"input":{"format":{"type":"audio/pcm","rate":24000},"noise_reduction":{"type":"near_field"},"transcription":{"model":"gpt-4o-mini-transcribe"},"turn_detection":{"type":"server_vad","interrupt_response":true,"create_response":true,"silence_duration_ms":500}},"output":{"format":{"type":"audio/pcm","rate":24000},"voice":"marin"}},"tools":[{"type":"function","name":"background_agent","description":"Send a user request to the background agent. Use this as the default action. Do not rephrase the user's ask or rewrite it in your own words; pass along the user's own words. If the background agent is idle, this starts a new task and returns the final result to the user. If the background agent is already working on a task, this sends the request as guidance to steer that previous task. If the user asks to do something next, later, after this, or once current work finishes, call this tool so the work is actually queued instead of merely promising to do it later.","parameters":{"type":"object","properties":{"prompt":{"type":"string","description":"The user request to delegate to the background agent."}},"required":["prompt"],"additionalProperties":false}}]}"#; + let session = r#"{"tool_choice":"auto","type":"realtime","model":"gpt-realtime-1.5","instructions":"backend prompt\n\nstartup context","output_modalities":["audio"],"audio":{"input":{"format":{"type":"audio/pcm","rate":24000},"noise_reduction":{"type":"near_field"},"transcription":{"model":"gpt-4o-mini-transcribe"},"turn_detection":{"type":"server_vad","interrupt_response":true,"create_response":true,"silence_duration_ms":500}},"output":{"format":{"type":"audio/pcm","rate":24000},"voice":"marin"}},"tools":[{"type":"function","name":"background_agent","description":"Send a user request to the background agent. Use this as the default action. Do not rephrase the user's ask or rewrite it in your own words; pass along the user's own words. If the background agent is idle, this starts a new task and returns the final result to the user. If the background agent is already working on a task, this sends the request as guidance to steer that previous task. If the user asks to do something next, later, after this, or once current work finishes, call this tool so the work is actually queued instead of merely promising to do it later.","parameters":{"type":"object","properties":{"prompt":{"type":"string","description":"The user request to delegate to the background agent."}},"required":["prompt"],"additionalProperties":false}},{"type":"function","name":"remain_silent","description":"Call this when the best response is to say nothing. Use it instead of speaking after hidden system/control messages, after background agent updates in silent modes, or whenever acknowledging aloud would be distracting. This tool has no user-visible effect.","parameters":{"type":"object","properties":{},"additionalProperties":false}}]}"#; let session = normalized_json_string(session)?; assert_eq!( body, @@ -2260,6 +2260,10 @@ fn assert_v2_session_update(request: &Value) -> Result<()> { request["session"]["tools"][0]["name"].as_str(), Some("background_agent") ); + assert_eq!( + request["session"]["tools"][1]["name"].as_str(), + Some("remain_silent") + ); assert_eq!( request["session"]["audio"]["input"]["transcription"]["model"].as_str(), Some("gpt-4o-mini-transcribe") diff --git a/codex-rs/app-server/tests/suite/v2/request_permissions.rs b/codex-rs/app-server/tests/suite/v2/request_permissions.rs index 05a45011de..295ac96a3b 100644 --- a/codex-rs/app-server/tests/suite/v2/request_permissions.rs +++ b/codex-rs/app-server/tests/suite/v2/request_permissions.rs @@ -93,6 +93,7 @@ async fn request_permissions_round_trip() -> Result<()> { file_system: Some(codex_app_server_protocol::AdditionalFileSystemPermissions { read: None, write: Some(vec![requested_writes[0].clone()]), + glob_scan_max_depth: None, entries: None, }), }, diff --git a/codex-rs/app-server/tests/suite/v2/thread_archive.rs b/codex-rs/app-server/tests/suite/v2/thread_archive.rs index 20fd6fd884..7d884c9a7d 100644 --- a/codex-rs/app-server/tests/suite/v2/thread_archive.rs +++ b/codex-rs/app-server/tests/suite/v2/thread_archive.rs @@ -1,5 +1,6 @@ use anyhow::Result; use app_test_support::McpProcess; +use app_test_support::create_fake_rollout; use app_test_support::create_mock_responses_server_repeating_assistant; use app_test_support::to_response; use codex_app_server_protocol::JSONRPCError; @@ -19,7 +20,11 @@ use codex_app_server_protocol::TurnStartParams; use codex_app_server_protocol::TurnStartResponse; use codex_app_server_protocol::UserInput; use codex_core::ARCHIVED_SESSIONS_SUBDIR; +use codex_core::find_archived_thread_path_by_id_str; use codex_core::find_thread_path_by_id_str; +use codex_protocol::ThreadId; +use codex_state::DirectionalThreadSpawnEdgeStatus; +use codex_state::StateRuntime; use pretty_assertions::assert_eq; use std::path::Path; use tempfile::TempDir; @@ -160,6 +165,311 @@ async fn thread_archive_requires_materialized_rollout() -> Result<()> { Ok(()) } +#[tokio::test] +async fn thread_archive_archives_spawned_descendants() -> Result<()> { + let server = create_mock_responses_server_repeating_assistant("Done").await; + let codex_home = TempDir::new()?; + create_config_toml(codex_home.path(), &server.uri())?; + + let parent_id = create_fake_rollout( + codex_home.path(), + "2025-01-01T00-00-00", + "2025-01-01T00:00:00Z", + "parent", + Some("mock_provider"), + /*git_info*/ None, + )?; + let child_id = create_fake_rollout( + codex_home.path(), + "2025-01-01T00-01-00", + "2025-01-01T00:01:00Z", + "child", + Some("mock_provider"), + /*git_info*/ None, + )?; + let grandchild_id = create_fake_rollout( + codex_home.path(), + "2025-01-01T00-02-00", + "2025-01-01T00:02:00Z", + "grandchild", + Some("mock_provider"), + /*git_info*/ None, + )?; + + let parent_thread_id = ThreadId::from_string(&parent_id)?; + let child_thread_id = ThreadId::from_string(&child_id)?; + let grandchild_thread_id = ThreadId::from_string(&grandchild_id)?; + let state_db = + StateRuntime::init(codex_home.path().to_path_buf(), "mock_provider".into()).await?; + state_db + .mark_backfill_complete(/*last_watermark*/ None) + .await?; + state_db + .upsert_thread_spawn_edge( + parent_thread_id, + child_thread_id, + DirectionalThreadSpawnEdgeStatus::Closed, + ) + .await?; + state_db + .upsert_thread_spawn_edge( + child_thread_id, + grandchild_thread_id, + DirectionalThreadSpawnEdgeStatus::Open, + ) + .await?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let archive_id = mcp + .send_thread_archive_request(ThreadArchiveParams { + thread_id: parent_id.clone(), + }) + .await?; + let archive_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(archive_id)), + ) + .await??; + let _: ThreadArchiveResponse = to_response::(archive_resp)?; + + let mut archived_ids = Vec::new(); + for _ in 0..3 { + let notification = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_notification_message("thread/archived"), + ) + .await??; + let archived_notification: ThreadArchivedNotification = serde_json::from_value( + notification + .params + .expect("thread/archived notification params"), + )?; + archived_ids.push(archived_notification.thread_id); + } + assert_eq!(archived_ids, vec![parent_id, grandchild_id, child_id]); + + for thread_id in [parent_thread_id, child_thread_id, grandchild_thread_id] { + assert!( + find_thread_path_by_id_str(codex_home.path(), &thread_id.to_string()) + .await? + .is_none(), + "expected active rollout for {thread_id} to be archived" + ); + assert!( + find_archived_thread_path_by_id_str(codex_home.path(), &thread_id.to_string()) + .await? + .is_some(), + "expected archived rollout for {thread_id} to exist" + ); + } + + Ok(()) +} + +#[tokio::test] +async fn thread_archive_succeeds_when_descendant_archive_fails() -> Result<()> { + let server = create_mock_responses_server_repeating_assistant("Done").await; + let codex_home = TempDir::new()?; + create_config_toml(codex_home.path(), &server.uri())?; + + let parent_id = create_fake_rollout( + codex_home.path(), + "2025-01-01T00-00-00", + "2025-01-01T00:00:00Z", + "parent", + Some("mock_provider"), + /*git_info*/ None, + )?; + let child_id = create_fake_rollout( + codex_home.path(), + "2025-01-01T00-01-00", + "2025-01-01T00:01:00Z", + "child", + Some("mock_provider"), + /*git_info*/ None, + )?; + let grandchild_id = create_fake_rollout( + codex_home.path(), + "2025-01-01T00-02-00", + "2025-01-01T00:02:00Z", + "grandchild", + Some("mock_provider"), + /*git_info*/ None, + )?; + + let parent_thread_id = ThreadId::from_string(&parent_id)?; + let child_thread_id = ThreadId::from_string(&child_id)?; + let grandchild_thread_id = ThreadId::from_string(&grandchild_id)?; + let state_db = + StateRuntime::init(codex_home.path().to_path_buf(), "mock_provider".into()).await?; + state_db + .mark_backfill_complete(/*last_watermark*/ None) + .await?; + state_db + .upsert_thread_spawn_edge( + parent_thread_id, + child_thread_id, + DirectionalThreadSpawnEdgeStatus::Closed, + ) + .await?; + state_db + .upsert_thread_spawn_edge( + child_thread_id, + grandchild_thread_id, + DirectionalThreadSpawnEdgeStatus::Open, + ) + .await?; + + let child_rollout_path = find_thread_path_by_id_str(codex_home.path(), &child_id) + .await? + .expect("child rollout path"); + let archived_child_path = codex_home + .path() + .join(ARCHIVED_SESSIONS_SUBDIR) + .join(child_rollout_path.file_name().expect("rollout file name")); + std::fs::create_dir_all(&archived_child_path)?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let archive_id = mcp + .send_thread_archive_request(ThreadArchiveParams { + thread_id: parent_id.clone(), + }) + .await?; + let archive_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(archive_id)), + ) + .await??; + let _: ThreadArchiveResponse = to_response::(archive_resp)?; + + let mut archived_ids = Vec::new(); + for _ in 0..2 { + let notification = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_notification_message("thread/archived"), + ) + .await??; + let archived_notification: ThreadArchivedNotification = serde_json::from_value( + notification + .params + .expect("thread/archived notification params"), + )?; + archived_ids.push(archived_notification.thread_id); + } + assert_eq!(archived_ids, vec![parent_id, grandchild_id]); + + assert!( + timeout( + std::time::Duration::from_millis(250), + mcp.read_stream_until_notification_message("thread/archived"), + ) + .await + .is_err() + ); + + assert!( + child_rollout_path.exists(), + "child should stay active after descendant archive failure" + ); + assert!( + archived_child_path.is_dir(), + "test conflict should remain in archived sessions" + ); + for thread_id in [parent_thread_id, grandchild_thread_id] { + assert!( + find_thread_path_by_id_str(codex_home.path(), &thread_id.to_string()) + .await? + .is_none(), + "expected active rollout for {thread_id} to be archived" + ); + assert!( + find_archived_thread_path_by_id_str(codex_home.path(), &thread_id.to_string()) + .await? + .is_some(), + "expected archived rollout for {thread_id} to exist" + ); + } + + Ok(()) +} + +#[tokio::test] +async fn thread_archive_succeeds_when_spawned_descendant_is_missing() -> Result<()> { + let server = create_mock_responses_server_repeating_assistant("Done").await; + let codex_home = TempDir::new()?; + create_config_toml(codex_home.path(), &server.uri())?; + + let parent_id = create_fake_rollout( + codex_home.path(), + "2025-01-01T00-00-00", + "2025-01-01T00:00:00Z", + "parent", + Some("mock_provider"), + /*git_info*/ None, + )?; + let parent_thread_id = ThreadId::from_string(&parent_id)?; + let missing_child_thread_id = ThreadId::from_string("00000000-0000-0000-0000-000000000901")?; + + let state_db = + StateRuntime::init(codex_home.path().to_path_buf(), "mock_provider".into()).await?; + state_db + .mark_backfill_complete(/*last_watermark*/ None) + .await?; + state_db + .upsert_thread_spawn_edge( + parent_thread_id, + missing_child_thread_id, + DirectionalThreadSpawnEdgeStatus::Closed, + ) + .await?; + + let mut mcp = McpProcess::new(codex_home.path()).await?; + timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??; + + let archive_id = mcp + .send_thread_archive_request(ThreadArchiveParams { + thread_id: parent_id.clone(), + }) + .await?; + let archive_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(archive_id)), + ) + .await??; + let _: ThreadArchiveResponse = to_response::(archive_resp)?; + + let notification = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_notification_message("thread/archived"), + ) + .await??; + let archived_notification: ThreadArchivedNotification = serde_json::from_value( + notification + .params + .expect("thread/archived notification params"), + )?; + assert_eq!(archived_notification.thread_id, parent_id); + + assert!( + find_thread_path_by_id_str(codex_home.path(), &parent_id) + .await? + .is_none(), + "parent should be archived even when a descendant is missing" + ); + assert!( + find_archived_thread_path_by_id_str(codex_home.path(), &parent_id) + .await? + .is_some(), + "parent should be moved into archived sessions" + ); + + Ok(()) +} + #[tokio::test] async fn thread_archive_clears_stale_subscriptions_before_resume() -> Result<()> { let server = create_mock_responses_server_repeating_assistant("Done").await; diff --git a/codex-rs/app-server/tests/suite/v2/thread_unsubscribe.rs b/codex-rs/app-server/tests/suite/v2/thread_unsubscribe.rs index 303e166879..c0188add8c 100644 --- a/codex-rs/app-server/tests/suite/v2/thread_unsubscribe.rs +++ b/codex-rs/app-server/tests/suite/v2/thread_unsubscribe.rs @@ -127,6 +127,7 @@ async fn thread_unsubscribe_during_turn_keeps_turn_running() -> Result<()> { .send_thread_start_request(ThreadStartParams { model: Some("mock-model".to_string()), dynamic_tools: Some(vec![DynamicToolSpec { + namespace: None, name: tool_name.to_string(), description: "Deterministic wait tool".to_string(), input_schema: json!({ @@ -194,6 +195,7 @@ async fn thread_unsubscribe_during_turn_keeps_turn_running() -> Result<()> { thread_id: thread_id.clone(), turn_id: started.turn_id, call_id: call_id.to_string(), + namespace: None, tool: tool_name.to_string(), arguments: tool_args, } diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rs index 849e8b104b..9852a2cd5f 100644 --- a/codex-rs/cli/src/main.rs +++ b/codex-rs/cli/src/main.rs @@ -717,6 +717,9 @@ async fn cli_main(arg0_paths: Arg0DispatchPaths) -> anyhow::Result<()> { root_remote_auth_token_env.as_deref(), "exec", )?; + exec_cli + .shared + .inherit_exec_root_options(&interactive.shared); prepend_config_flags( &mut exec_cli.config_overrides, root_config_overrides.clone(), @@ -1090,8 +1093,7 @@ async fn cli_main(arg0_paths: Arg0DispatchPaths) -> anyhow::Result<()> { "stdio-to-uds", )?; let socket_path = cmd.socket_path; - tokio::task::spawn_blocking(move || codex_stdio_to_uds::run(socket_path.as_path())) - .await??; + codex_stdio_to_uds::run(socket_path.as_path()).await?; } Some(Subcommand::ExecServer(cmd)) => { reject_remote_mode_for_subcommand( @@ -1242,6 +1244,7 @@ async fn run_debug_prompt_input_command( interactive: TuiCli, arg0_paths: Arg0DispatchPaths, ) -> anyhow::Result<()> { + let shared = interactive.shared.into_inner(); let mut cli_kv_overrides = root_config_overrides .parse_overrides() .map_err(anyhow::Error::msg)?; @@ -1252,38 +1255,38 @@ async fn run_debug_prompt_input_command( )); } - let approval_policy = if interactive.full_auto { + let approval_policy = if shared.full_auto { Some(AskForApproval::OnRequest) - } else if interactive.dangerously_bypass_approvals_and_sandbox { + } else if shared.dangerously_bypass_approvals_and_sandbox { Some(AskForApproval::Never) } else { interactive.approval_policy.map(Into::into) }; - let sandbox_mode = if interactive.full_auto { + let sandbox_mode = if shared.full_auto { Some(codex_protocol::config_types::SandboxMode::WorkspaceWrite) - } else if interactive.dangerously_bypass_approvals_and_sandbox { + } else if shared.dangerously_bypass_approvals_and_sandbox { Some(codex_protocol::config_types::SandboxMode::DangerFullAccess) } else { - interactive.sandbox_mode.map(Into::into) + shared.sandbox_mode.map(Into::into) }; let overrides = ConfigOverrides { - model: interactive.model, - config_profile: interactive.config_profile, + model: shared.model, + config_profile: shared.config_profile, approval_policy, sandbox_mode, - cwd: interactive.cwd, + cwd: shared.cwd, codex_self_exe: arg0_paths.codex_self_exe, codex_linux_sandbox_exe: arg0_paths.codex_linux_sandbox_exe, main_execve_wrapper_exe: arg0_paths.main_execve_wrapper_exe, - show_raw_agent_reasoning: interactive.oss.then_some(true), + show_raw_agent_reasoning: shared.oss.then_some(true), ephemeral: Some(true), - additional_writable_roots: interactive.add_dir, + additional_writable_roots: shared.add_dir, ..Default::default() }; let config = Config::load_with_cli_overrides_and_harness_overrides(cli_kv_overrides, overrides).await?; - let mut input = interactive + let mut input = shared .images .into_iter() .chain(cmd.images) @@ -1554,40 +1557,24 @@ fn finalize_fork_interactive( /// root-level flags. Only overrides fields explicitly set on the subcommand-scoped /// CLI. Also appends `-c key=value` overrides with highest precedence. fn merge_interactive_cli_flags(interactive: &mut TuiCli, subcommand_cli: TuiCli) { - if let Some(model) = subcommand_cli.model { - interactive.model = Some(model); - } - if subcommand_cli.oss { - interactive.oss = true; - } - if let Some(profile) = subcommand_cli.config_profile { - interactive.config_profile = Some(profile); - } - if let Some(sandbox) = subcommand_cli.sandbox_mode { - interactive.sandbox_mode = Some(sandbox); - } - if let Some(approval) = subcommand_cli.approval_policy { + let TuiCli { + shared, + approval_policy, + web_search, + prompt, + config_overrides, + .. + } = subcommand_cli; + interactive + .shared + .apply_subcommand_overrides(shared.into_inner()); + if let Some(approval) = approval_policy { interactive.approval_policy = Some(approval); } - if subcommand_cli.full_auto { - interactive.full_auto = true; - } - if subcommand_cli.dangerously_bypass_approvals_and_sandbox { - interactive.dangerously_bypass_approvals_and_sandbox = true; - } - if let Some(cwd) = subcommand_cli.cwd { - interactive.cwd = Some(cwd); - } - if subcommand_cli.web_search { + if web_search { interactive.web_search = true; } - if !subcommand_cli.images.is_empty() { - interactive.images = subcommand_cli.images; - } - if !subcommand_cli.add_dir.is_empty() { - interactive.add_dir.extend(subcommand_cli.add_dir); - } - if let Some(prompt) = subcommand_cli.prompt { + if let Some(prompt) = prompt { // Normalize CRLF/CR to LF so CLI-provided text can't leak `\r` into TUI state. interactive.prompt = Some(prompt.replace("\r\n", "\n").replace('\r', "\n")); } @@ -1595,7 +1582,7 @@ fn merge_interactive_cli_flags(interactive: &mut TuiCli, subcommand_cli: TuiCli) interactive .config_overrides .raw_overrides - .extend(subcommand_cli.config_overrides.raw_overrides); + .extend(config_overrides.raw_overrides); } fn print_completion(cmd: CompletionCommand) { @@ -1715,6 +1702,19 @@ mod tests { assert_eq!(args.prompt.as_deref(), Some("re-review")); } + #[test] + fn dangerous_bypass_conflicts_with_approval_policy() { + let err = MultitoolCli::try_parse_from([ + "codex", + "--dangerously-bypass-approvals-and-sandbox", + "--ask-for-approval", + "on-request", + ]) + .expect_err("conflicting permission flags should be rejected"); + + assert_eq!(err.kind(), clap::error::ErrorKind::ArgumentConflict); + } + fn app_server_from_args(args: &[&str]) -> AppServerCommand { let cli = MultitoolCli::try_parse_from(args).expect("parse"); let Subcommand::AppServer(app_server) = cli.subcommand.expect("app-server present") else { diff --git a/codex-rs/clippy.toml b/codex-rs/clippy.toml index a2aae6591b..2feed8a487 100644 --- a/codex-rs/clippy.toml +++ b/codex-rs/clippy.toml @@ -1,5 +1,10 @@ allow-expect-in-tests = true allow-unwrap-in-tests = true +await-holding-invalid-types = [ + "tokio::sync::MutexGuard", + "tokio::sync::RwLockReadGuard", + "tokio::sync::RwLockWriteGuard", +] disallowed-methods = [ { path = "ratatui::style::Color::Rgb", reason = "Use ANSI colors, which work better in various terminal themes." }, { path = "ratatui::style::Color::Indexed", reason = "Use ANSI colors, which work better in various terminal themes." }, diff --git a/codex-rs/cloud-requirements/src/lib.rs b/codex-rs/cloud-requirements/src/lib.rs index 60a7af20e3..23be6f410d 100644 --- a/codex-rs/cloud-requirements/src/lib.rs +++ b/codex-rs/cloud-requirements/src/lib.rs @@ -1187,6 +1187,7 @@ mod tests { allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1217,6 +1218,7 @@ mod tests { allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1247,6 +1249,7 @@ mod tests { allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1294,6 +1297,7 @@ mod tests { allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1377,6 +1381,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1450,6 +1455,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1521,6 +1527,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1719,6 +1726,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1755,6 +1763,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1811,6 +1820,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::OnRequest]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1862,6 +1872,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::OnRequest]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1917,6 +1928,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -1973,6 +1985,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -2029,6 +2042,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -2118,6 +2132,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, @@ -2146,6 +2161,7 @@ enabled = false allowed_approval_policies: Some(vec![AskForApproval::OnRequest]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, guardian_policy_config: None, feature_requirements: None, diff --git a/codex-rs/codex-api/src/endpoint/realtime_websocket/methods.rs b/codex-rs/codex-api/src/endpoint/realtime_websocket/methods.rs index a4ddb5dee4..3c1fd7bd91 100644 --- a/codex-rs/codex-api/src/endpoint/realtime_websocket/methods.rs +++ b/codex-rs/codex-api/src/endpoint/realtime_websocket/methods.rs @@ -1,4 +1,4 @@ -use crate::endpoint::realtime_websocket::methods_common::conversation_handoff_append_message; +use crate::endpoint::realtime_websocket::methods_common::conversation_function_call_output_message; use crate::endpoint::realtime_websocket::methods_common::conversation_item_create_message; use crate::endpoint::realtime_websocket::methods_common::normalized_session_mode; use crate::endpoint::realtime_websocket::methods_common::session_update_session; @@ -217,6 +217,7 @@ pub struct RealtimeWebsocketEvents { #[derive(Default)] struct ActiveTranscriptState { entries: Vec, + last_handoff_entry_count: usize, new_input_entry: bool, new_output_entry: bool, } @@ -230,13 +231,13 @@ impl RealtimeWebsocketConnection { self.writer.send_conversation_item_create(text).await } - pub async fn send_conversation_handoff_append( + pub async fn send_conversation_function_call_output( &self, - handoff_id: String, + call_id: String, output_text: String, ) -> Result<(), ApiError> { self.writer - .send_conversation_handoff_append(handoff_id, output_text) + .send_conversation_function_call_output(call_id, output_text) .await } @@ -290,14 +291,14 @@ impl RealtimeWebsocketWriter { .await } - pub async fn send_conversation_handoff_append( + pub async fn send_conversation_function_call_output( &self, - handoff_id: String, + call_id: String, output_text: String, ) -> Result<(), ApiError> { - self.send_json(&conversation_handoff_append_message( + self.send_json(&conversation_function_call_output_message( self.event_parser, - handoff_id, + call_id, output_text, )) .await @@ -459,7 +460,10 @@ impl RealtimeWebsocketEvents { } RealtimeEvent::HandoffRequested(handoff) => { append_handoff_input(&mut active_transcript.entries, &handoff.input_transcript); - handoff.active_transcript = active_transcript.entries.clone(); + handoff.active_transcript = active_transcript.entries + [active_transcript.last_handoff_entry_count..] + .to_vec(); + active_transcript.last_handoff_entry_count = active_transcript.entries.len(); active_transcript.new_input_entry = true; active_transcript.new_output_entry = true; } @@ -471,6 +475,7 @@ impl RealtimeWebsocketEvents { | RealtimeEvent::ResponseCancelled(_) | RealtimeEvent::ResponseDone(_) | RealtimeEvent::ConversationItemDone { .. } + | RealtimeEvent::NoopRequested(_) | RealtimeEvent::ConversationItemAdded(_) | RealtimeEvent::Error(_) => {} } @@ -825,6 +830,7 @@ mod tests { use crate::endpoint::realtime_websocket::protocol::RealtimeTranscriptEntry; use codex_protocol::protocol::RealtimeHandoffRequested; use codex_protocol::protocol::RealtimeInputAudioSpeechStarted; + use codex_protocol::protocol::RealtimeNoopRequested; use codex_protocol::protocol::RealtimeResponseCancelled; use codex_protocol::protocol::RealtimeResponseCreated; use codex_protocol::protocol::RealtimeResponseDone; @@ -1090,6 +1096,29 @@ mod tests { ); } + #[test] + fn parse_realtime_v2_noop_tool_call_event() { + let payload = json!({ + "type": "conversation.item.done", + "item": { + "id": "item_silent", + "type": "function_call", + "name": "remain_silent", + "call_id": "call_silent", + "arguments": "{}" + } + }) + .to_string(); + + assert_eq!( + parse_realtime_event(payload.as_str(), RealtimeEventParser::RealtimeV2), + Some(RealtimeEvent::NoopRequested(RealtimeNoopRequested { + call_id: "call_silent".to_string(), + item_id: "item_silent".to_string(), + })) + ); + } + #[test] fn parse_realtime_v2_input_audio_transcription_delta_event() { let payload = json!({ @@ -1689,7 +1718,7 @@ mod tests { .await .expect("send item"); connection - .send_conversation_handoff_append( + .send_conversation_function_call_output( "handoff_1".to_string(), "hello from background agent".to_string(), ) @@ -1850,6 +1879,18 @@ mod tests { first_json["session"]["tools"][0]["parameters"]["required"], json!(["prompt"]) ); + assert_eq!( + first_json["session"]["tools"][1]["type"], + Value::String("function".to_string()) + ); + assert_eq!( + first_json["session"]["tools"][1]["name"], + Value::String("remain_silent".to_string()) + ); + assert_eq!( + first_json["session"]["tools"][1]["parameters"]["properties"], + json!({}) + ); assert_eq!( first_json["session"]["tool_choice"], Value::String("auto".to_string()) @@ -1961,7 +2002,10 @@ mod tests { .await .expect("send text item"); connection - .send_conversation_handoff_append("call_1".to_string(), "delegated result".to_string()) + .send_conversation_function_call_output( + "call_1".to_string(), + "delegated result".to_string(), + ) .await .expect("send handoff output"); diff --git a/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_common.rs b/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_common.rs index c0efcce165..1e47fb6fbf 100644 --- a/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_common.rs +++ b/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_common.rs @@ -2,7 +2,7 @@ use crate::endpoint::realtime_websocket::methods_v1::conversation_handoff_append use crate::endpoint::realtime_websocket::methods_v1::conversation_item_create_message as v1_conversation_item_create_message; use crate::endpoint::realtime_websocket::methods_v1::session_update_session as v1_session_update_session; use crate::endpoint::realtime_websocket::methods_v1::websocket_intent as v1_websocket_intent; -use crate::endpoint::realtime_websocket::methods_v2::conversation_handoff_append_message as v2_conversation_handoff_append_message; +use crate::endpoint::realtime_websocket::methods_v2::conversation_function_call_output_message as v2_conversation_function_call_output_message; use crate::endpoint::realtime_websocket::methods_v2::conversation_item_create_message as v2_conversation_item_create_message; use crate::endpoint::realtime_websocket::methods_v2::session_update_session as v2_session_update_session; use crate::endpoint::realtime_websocket::methods_v2::websocket_intent as v2_websocket_intent; @@ -40,18 +40,18 @@ pub(super) fn conversation_item_create_message( } } -pub(super) fn conversation_handoff_append_message( +pub(super) fn conversation_function_call_output_message( event_parser: RealtimeEventParser, - handoff_id: String, + call_id: String, output_text: String, ) -> RealtimeOutboundMessage { match event_parser { RealtimeEventParser::V1 => v1_conversation_handoff_append_message( - handoff_id, + call_id, format!("{AGENT_FINAL_MESSAGE_PREFIX}{output_text}"), ), RealtimeEventParser::RealtimeV2 => { - v2_conversation_handoff_append_message(handoff_id, output_text) + v2_conversation_function_call_output_message(call_id, output_text) } } } diff --git a/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_v2.rs b/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_v2.rs index b1f50b02be..2920677483 100644 --- a/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_v2.rs +++ b/codex-rs/codex-api/src/endpoint/realtime_websocket/methods_v2.rs @@ -32,6 +32,8 @@ const REALTIME_V2_OUTPUT_MODALITY_TEXT: &str = "text"; const REALTIME_V2_TOOL_CHOICE: &str = "auto"; const REALTIME_V2_BACKGROUND_AGENT_TOOL_NAME: &str = "background_agent"; const REALTIME_V2_BACKGROUND_AGENT_TOOL_DESCRIPTION: &str = "Send a user request to the background agent. Use this as the default action. Do not rephrase the user's ask or rewrite it in your own words; pass along the user's own words. If the background agent is idle, this starts a new task and returns the final result to the user. If the background agent is already working on a task, this sends the request as guidance to steer that previous task. If the user asks to do something next, later, after this, or once current work finishes, call this tool so the work is actually queued instead of merely promising to do it later."; +const REALTIME_V2_SILENCE_TOOL_NAME: &str = "remain_silent"; +const REALTIME_V2_SILENCE_TOOL_DESCRIPTION: &str = "Call this when the best response is to say nothing. Use it instead of speaking after hidden system/control messages, after background agent updates in silent modes, or whenever acknowledging aloud would be distracting. This tool has no user-visible effect."; const REALTIME_V2_INPUT_TRANSCRIPTION_MODEL: &str = "gpt-4o-mini-transcribe"; pub(super) fn conversation_item_create_message(text: String) -> RealtimeOutboundMessage { @@ -47,14 +49,14 @@ pub(super) fn conversation_item_create_message(text: String) -> RealtimeOutbound } } -pub(super) fn conversation_handoff_append_message( - handoff_id: String, +pub(super) fn conversation_function_call_output_message( + call_id: String, output_text: String, ) -> RealtimeOutboundMessage { RealtimeOutboundMessage::ConversationItemCreate { item: ConversationItemPayload::FunctionCallOutput(ConversationFunctionCallOutputItem { r#type: ConversationItemType::FunctionCallOutput, - call_id: handoff_id, + call_id, output: output_text, }), } @@ -100,22 +102,34 @@ pub(super) fn session_update_session( voice, }), }, - tools: Some(vec![SessionFunctionTool { - r#type: SessionToolType::Function, - name: REALTIME_V2_BACKGROUND_AGENT_TOOL_NAME.to_string(), - description: REALTIME_V2_BACKGROUND_AGENT_TOOL_DESCRIPTION.to_string(), - parameters: json!({ - "type": "object", - "properties": { - "prompt": { - "type": "string", - "description": "The user request to delegate to the background agent." - } - }, - "required": ["prompt"], - "additionalProperties": false - }), - }]), + tools: Some(vec![ + SessionFunctionTool { + r#type: SessionToolType::Function, + name: REALTIME_V2_BACKGROUND_AGENT_TOOL_NAME.to_string(), + description: REALTIME_V2_BACKGROUND_AGENT_TOOL_DESCRIPTION.to_string(), + parameters: json!({ + "type": "object", + "properties": { + "prompt": { + "type": "string", + "description": "The user request to delegate to the background agent." + } + }, + "required": ["prompt"], + "additionalProperties": false + }), + }, + SessionFunctionTool { + r#type: SessionToolType::Function, + name: REALTIME_V2_SILENCE_TOOL_NAME.to_string(), + description: REALTIME_V2_SILENCE_TOOL_DESCRIPTION.to_string(), + parameters: json!({ + "type": "object", + "properties": {}, + "additionalProperties": false + }), + }, + ]), tool_choice: Some(REALTIME_V2_TOOL_CHOICE.to_string()), }, RealtimeSessionMode::Transcription => SessionUpdateSession { diff --git a/codex-rs/codex-api/src/endpoint/realtime_websocket/protocol_v2.rs b/codex-rs/codex-api/src/endpoint/realtime_websocket/protocol_v2.rs index 9aa535757c..ee0bba9946 100644 --- a/codex-rs/codex-api/src/endpoint/realtime_websocket/protocol_v2.rs +++ b/codex-rs/codex-api/src/endpoint/realtime_websocket/protocol_v2.rs @@ -7,6 +7,7 @@ use codex_protocol::protocol::RealtimeAudioFrame; use codex_protocol::protocol::RealtimeEvent; use codex_protocol::protocol::RealtimeHandoffRequested; use codex_protocol::protocol::RealtimeInputAudioSpeechStarted; +use codex_protocol::protocol::RealtimeNoopRequested; use codex_protocol::protocol::RealtimeResponseCancelled; use codex_protocol::protocol::RealtimeResponseCreated; use codex_protocol::protocol::RealtimeResponseDone; @@ -15,6 +16,7 @@ use serde_json::Value; use tracing::debug; const BACKGROUND_AGENT_TOOL_NAME: &str = "background_agent"; +const SILENCE_TOOL_NAME: &str = "remain_silent"; const DEFAULT_AUDIO_SAMPLE_RATE: u32 = 24_000; const DEFAULT_AUDIO_CHANNELS: u16 = 1; const TOOL_ARGUMENT_KEYS: [&str; 5] = ["input_transcript", "input", "text", "prompt", "query"]; @@ -127,6 +129,9 @@ fn parse_conversation_item_done_event(parsed: &Value) -> Option { if let Some(handoff) = parse_handoff_requested_event(item) { return Some(handoff); } + if let Some(noop) = parse_noop_requested_event(item) { + return Some(noop); + } item.get("id") .and_then(Value::as_str) @@ -160,6 +165,29 @@ fn parse_handoff_requested_event(item: &JsonMap) -> Option) -> Option { + let item_type = item.get("type").and_then(Value::as_str); + let item_name = item.get("name").and_then(Value::as_str); + if item_type != Some("function_call") || item_name != Some(SILENCE_TOOL_NAME) { + return None; + } + + let call_id = item + .get("call_id") + .and_then(Value::as_str) + .or_else(|| item.get("id").and_then(Value::as_str))?; + let item_id = item + .get("id") + .and_then(Value::as_str) + .unwrap_or(call_id) + .to_string(); + + Some(RealtimeEvent::NoopRequested(RealtimeNoopRequested { + call_id: call_id.to_string(), + item_id, + })) +} + fn extract_input_transcript(arguments: &str) -> String { if arguments.is_empty() { return String::new(); diff --git a/codex-rs/codex-api/src/endpoint/responses_websocket.rs b/codex-rs/codex-api/src/endpoint/responses_websocket.rs index bc72aee411..aea9b917fb 100644 --- a/codex-rs/codex-api/src/endpoint/responses_websocket.rs +++ b/codex-rs/codex-api/src/endpoint/responses_websocket.rs @@ -229,6 +229,10 @@ impl ResponsesWebsocketConnection { let current_span = Span::current(); tokio::spawn( + #[expect( + clippy::await_holding_invalid_type, + reason = "the guard serializes exclusive use of the websocket stream for the lifetime of the response stream" + )] async move { if let Some(model) = server_model { let _ = tx_event.send(Ok(ResponseEvent::ServerModel(model))).await; diff --git a/codex-rs/codex-mcp/src/lib.rs b/codex-rs/codex-mcp/src/lib.rs index 5fb634d906..760fc64cfd 100644 --- a/codex-rs/codex-mcp/src/lib.rs +++ b/codex-rs/codex-mcp/src/lib.rs @@ -32,6 +32,7 @@ pub use mcp::group_tools_by_server; pub use mcp::mcp_permission_prompt_is_auto_approved; pub use mcp::oauth_login_support; pub use mcp::qualified_mcp_tool_name_prefix; +pub use mcp::read_mcp_resource; pub use mcp::resolve_oauth_scopes; pub use mcp::should_retry_without_scopes; pub use mcp::split_qualified_tool_name; diff --git a/codex-rs/codex-mcp/src/mcp/mod.rs b/codex-rs/codex-mcp/src/mcp/mod.rs index 6a8d9c0a97..3118c7c171 100644 --- a/codex-rs/codex-mcp/src/mcp/mod.rs +++ b/codex-rs/codex-mcp/src/mcp/mod.rs @@ -32,6 +32,8 @@ use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::McpAuthStatus; use codex_protocol::protocol::McpListToolsResponseEvent; use codex_protocol::protocol::SandboxPolicy; +use rmcp::model::ReadResourceRequestParams; +use rmcp::model::ReadResourceResult; use serde_json::Value; use crate::mcp_connection_manager::McpConnectionManager; @@ -354,6 +356,47 @@ pub fn tool_plugin_provenance(config: &McpConfig) -> ToolPluginProvenance { ToolPluginProvenance::from_capability_summaries(&config.plugin_capability_summaries) } +pub async fn read_mcp_resource( + config: &McpConfig, + auth: Option<&CodexAuth>, + runtime_environment: McpRuntimeEnvironment, + server: &str, + uri: &str, +) -> anyhow::Result { + let mut mcp_servers = effective_mcp_servers(config, auth); + mcp_servers.retain(|name, _| name == server); + let auth_statuses = + compute_auth_statuses(mcp_servers.iter(), config.mcp_oauth_credentials_store_mode).await; + let (tx_event, rx_event) = unbounded(); + drop(rx_event); + let (manager, cancel_token) = McpConnectionManager::new( + &mcp_servers, + config.mcp_oauth_credentials_store_mode, + auth_statuses, + &config.approval_policy, + String::new(), + tx_event, + SandboxPolicy::new_read_only_policy(), + runtime_environment, + config.codex_home.clone(), + codex_apps_tools_cache_key(auth), + tool_plugin_provenance(config), + ) + .await; + + let result = manager + .read_resource( + server, + ReadResourceRequestParams { + meta: None, + uri: uri.to_string(), + }, + ) + .await; + cancel_token.cancel(); + result +} + pub async fn collect_mcp_snapshot( config: &McpConfig, auth: Option<&CodexAuth>, diff --git a/codex-rs/config/Cargo.toml b/codex-rs/config/Cargo.toml index 93ca283b86..a7a50b0720 100644 --- a/codex-rs/config/Cargo.toml +++ b/codex-rs/config/Cargo.toml @@ -9,6 +9,7 @@ workspace = true [dependencies] anyhow = { workspace = true } +async-trait = { workspace = true } codex-app-server-protocol = { workspace = true } codex-execpolicy = { workspace = true } codex-features = { workspace = true } @@ -18,6 +19,7 @@ codex-protocol = { workspace = true } codex-utils-absolute-path = { workspace = true } codex-utils-path = { workspace = true } futures = { workspace = true, features = ["alloc", "std"] } +gethostname = { workspace = true } multimap = { workspace = true } schemars = { workspace = true } serde = { workspace = true, features = ["derive"] } @@ -31,6 +33,13 @@ toml_edit = { workspace = true } tracing = { workspace = true } wildmatch = { workspace = true } +[target.'cfg(unix)'.dependencies] +dns-lookup = { workspace = true } +libc = { workspace = true } + +[target.'cfg(target_os = "windows")'.dependencies] +winapi-util = { workspace = true } + [dev-dependencies] pretty_assertions = { workspace = true } tempfile = { workspace = true } diff --git a/codex-rs/config/src/config_requirements.rs b/codex-rs/config/src/config_requirements.rs index 7cf22f69eb..57ee0601e9 100644 --- a/codex-rs/config/src/config_requirements.rs +++ b/codex-rs/config/src/config_requirements.rs @@ -11,6 +11,7 @@ use serde::de::value::Error as ValueDeserializerError; use serde::de::value::StrDeserializer; use std::collections::BTreeMap; use std::fmt; +use wildmatch::WildMatchPattern; use super::requirements_exec_policy::RequirementsExecPolicy; use super::requirements_exec_policy::RequirementsExecPolicyToml; @@ -620,6 +621,7 @@ pub struct ConfigRequirementsToml { pub allowed_approval_policies: Option>, pub allowed_approvals_reviewers: Option>, pub allowed_sandbox_modes: Option>, + pub remote_sandbox_config: Option>, pub allowed_web_search_modes: Option>, #[serde(rename = "features", alias = "feature_requirements")] pub feature_requirements: Option, @@ -633,6 +635,12 @@ pub struct ConfigRequirementsToml { pub guardian_policy_config: Option, } +#[derive(Deserialize, Debug, Clone, PartialEq)] +pub struct RemoteSandboxConfigToml { + pub hostname_patterns: Vec, + pub allowed_sandbox_modes: Vec, +} + /// Value paired with the requirement source it came from, for better error /// messages. #[derive(Debug, Clone, PartialEq)] @@ -693,6 +701,7 @@ impl ConfigRequirementsWithSources { allowed_approval_policies: _, allowed_approvals_reviewers: _, allowed_sandbox_modes: _, + remote_sandbox_config: _, allowed_web_search_modes: _, feature_requirements: _, mcp_servers: _, @@ -759,6 +768,7 @@ impl ConfigRequirementsWithSources { allowed_approval_policies: allowed_approval_policies.map(|sourced| sourced.value), allowed_approvals_reviewers: allowed_approvals_reviewers.map(|sourced| sourced.value), allowed_sandbox_modes: allowed_sandbox_modes.map(|sourced| sourced.value), + remote_sandbox_config: None, allowed_web_search_modes: allowed_web_search_modes.map(|sourced| sourced.value), feature_requirements: feature_requirements.map(|sourced| sourced.value), mcp_servers: mcp_servers.map(|sourced| sourced.value), @@ -772,6 +782,19 @@ impl ConfigRequirementsWithSources { } } +fn normalize_hostname(hostname: &str) -> Option { + let hostname = hostname.trim().trim_end_matches('.'); + (!hostname.is_empty()).then(|| hostname.to_ascii_lowercase()) +} + +fn hostname_matches_any_pattern(hostname: &str, patterns: &[String]) -> bool { + patterns.iter().any(|pattern| { + normalize_hostname(pattern) + .map(|pattern| WildMatchPattern::<'*', '?'>::new_case_insensitive(&pattern)) + .is_some_and(|pattern| pattern.matches(hostname)) + }) +} + /// Currently, `external-sandbox` is not supported in config.toml, but it is /// supported through programmatic use. #[derive(Deserialize, Debug, Clone, Copy, PartialEq)] @@ -806,10 +829,27 @@ pub enum ResidencyRequirement { } impl ConfigRequirementsToml { + pub fn apply_remote_sandbox_config(&mut self, hostname: Option<&str>) { + let Some(hostname) = hostname.and_then(normalize_hostname) else { + return; + }; + let Some(remote_sandbox_config) = self.remote_sandbox_config.as_ref() else { + return; + }; + let Some(matched_config) = remote_sandbox_config + .iter() + .find(|config| hostname_matches_any_pattern(&hostname, &config.hostname_patterns)) + else { + return; + }; + self.allowed_sandbox_modes = Some(matched_config.allowed_sandbox_modes.clone()); + } + pub fn is_empty(&self) -> bool { self.allowed_approval_policies.is_none() && self.allowed_approvals_reviewers.is_none() && self.allowed_sandbox_modes.is_none() + && self.remote_sandbox_config.is_none() && self.allowed_web_search_modes.is_none() && self .feature_requirements @@ -1099,6 +1139,7 @@ mod tests { allowed_approval_policies, allowed_approvals_reviewers, allowed_sandbox_modes, + remote_sandbox_config: _, allowed_web_search_modes, feature_requirements, mcp_servers, @@ -1161,6 +1202,7 @@ mod tests { allowed_approval_policies: Some(allowed_approval_policies.clone()), allowed_approvals_reviewers: Some(allowed_approvals_reviewers.clone()), allowed_sandbox_modes: Some(allowed_sandbox_modes.clone()), + remote_sandbox_config: None, allowed_web_search_modes: Some(allowed_web_search_modes.clone()), feature_requirements: Some(feature_requirements.clone()), mcp_servers: None, @@ -1883,6 +1925,172 @@ allowed_approvals_reviewers = ["user"] Ok(()) } + #[test] + fn deserialize_remote_sandbox_config_requires_hostname_patterns_list() -> Result<()> { + let toml_str = r#" + [[remote_sandbox_config]] + hostname_patterns = ["*.org", "runner-??.ci"] + allowed_sandbox_modes = ["read-only", "workspace-write"] + "#; + let config: ConfigRequirementsToml = from_str(toml_str)?; + + assert_eq!( + config.remote_sandbox_config, + Some(vec![RemoteSandboxConfigToml { + hostname_patterns: vec!["*.org".to_string(), "runner-??.ci".to_string()], + allowed_sandbox_modes: vec![ + SandboxModeRequirement::ReadOnly, + SandboxModeRequirement::WorkspaceWrite, + ], + }]) + ); + + let err = from_str::( + r#" + [[remote_sandbox_config]] + hostname_patterns = "*.org" + allowed_sandbox_modes = ["read-only"] + "#, + ) + .expect_err("hostname_patterns should be list-only"); + assert!( + err.to_string().contains("invalid type: string"), + "unexpected error: {err}" + ); + + Ok(()) + } + + #[test] + fn remote_sandbox_config_first_match_overrides_top_level() -> Result<()> { + let source = RequirementSource::CloudRequirements; + let mut requirements_toml: ConfigRequirementsToml = from_str( + r#" + allowed_sandbox_modes = ["read-only"] + + [[remote_sandbox_config]] + hostname_patterns = ["build-*.example.com"] + allowed_sandbox_modes = ["read-only", "workspace-write"] + + [[remote_sandbox_config]] + hostname_patterns = ["build-01.example.com"] + allowed_sandbox_modes = ["read-only", "danger-full-access"] + "#, + )?; + requirements_toml.apply_remote_sandbox_config(Some("BUILD-01.EXAMPLE.COM.")); + let mut requirements_with_sources = ConfigRequirementsWithSources::default(); + requirements_with_sources.merge_unset_fields(source.clone(), requirements_toml); + + assert_eq!( + requirements_with_sources + .allowed_sandbox_modes + .as_ref() + .map(|sourced| sourced.value.clone()), + Some(vec![ + SandboxModeRequirement::ReadOnly, + SandboxModeRequirement::WorkspaceWrite, + ]) + ); + + let requirements = ConfigRequirements::try_from(requirements_with_sources)?; + let root = if cfg!(windows) { "C:\\repo" } else { "/repo" }; + assert!( + requirements + .sandbox_policy + .can_set(&SandboxPolicy::WorkspaceWrite { + writable_roots: vec![AbsolutePathBuf::from_absolute_path(root)?], + read_only_access: Default::default(), + network_access: false, + exclude_tmpdir_env_var: false, + exclude_slash_tmp: false, + }) + .is_ok() + ); + assert_eq!( + requirements + .sandbox_policy + .can_set(&SandboxPolicy::DangerFullAccess), + Err(ConstraintError::InvalidValue { + field_name: "sandbox_mode", + candidate: "DangerFullAccess".into(), + allowed: "[ReadOnly, WorkspaceWrite]".into(), + requirement_source: source, + }) + ); + + Ok(()) + } + + #[test] + fn remote_sandbox_config_non_match_preserves_top_level() -> Result<()> { + let mut requirements_toml: ConfigRequirementsToml = from_str( + r#" + allowed_sandbox_modes = ["read-only"] + + [[remote_sandbox_config]] + hostname_patterns = ["build-*.example.com"] + allowed_sandbox_modes = ["read-only", "workspace-write"] + "#, + )?; + requirements_toml.apply_remote_sandbox_config(Some("laptop.example.com")); + let mut requirements_with_sources = ConfigRequirementsWithSources::default(); + requirements_with_sources.merge_unset_fields(RequirementSource::Unknown, requirements_toml); + let requirements = ConfigRequirements::try_from(requirements_with_sources)?; + + assert_eq!( + requirements + .sandbox_policy + .can_set(&SandboxPolicy::DangerFullAccess), + Err(ConstraintError::InvalidValue { + field_name: "sandbox_mode", + candidate: "DangerFullAccess".into(), + allowed: "[ReadOnly]".into(), + requirement_source: RequirementSource::Unknown, + }) + ); + + Ok(()) + } + + #[test] + fn remote_sandbox_config_does_not_override_higher_precedence_sandbox_modes() -> Result<()> { + let high_source = RequirementSource::CloudRequirements; + let mut high_precedence: ConfigRequirementsToml = from_str( + r#" + allowed_sandbox_modes = ["read-only"] + "#, + )?; + high_precedence.apply_remote_sandbox_config(Some("runner-01.ci.example.com")); + + let mut low_precedence: ConfigRequirementsToml = from_str( + r#" + [[remote_sandbox_config]] + hostname_patterns = ["runner-*.ci.example.com"] + allowed_sandbox_modes = ["read-only", "workspace-write"] + "#, + )?; + low_precedence.apply_remote_sandbox_config(Some("runner-01.ci.example.com")); + + let mut requirements_with_sources = ConfigRequirementsWithSources::default(); + requirements_with_sources.merge_unset_fields(high_source.clone(), high_precedence); + requirements_with_sources.merge_unset_fields(RequirementSource::Unknown, low_precedence); + let requirements = ConfigRequirements::try_from(requirements_with_sources)?; + + assert_eq!( + requirements + .sandbox_policy + .can_set(&SandboxPolicy::new_workspace_write_policy()), + Err(ConstraintError::InvalidValue { + field_name: "sandbox_mode", + candidate: "WorkspaceWrite".into(), + allowed: "[ReadOnly]".into(), + requirement_source: high_source, + }) + ); + + Ok(()) + } + #[test] fn deserialize_allowed_web_search_modes() -> Result<()> { let toml_str = r#" diff --git a/codex-rs/config/src/config_toml.rs b/codex-rs/config/src/config_toml.rs index 6556ca73e3..0c8e14c16d 100644 --- a/codex-rs/config/src/config_toml.rs +++ b/codex-rs/config/src/config_toml.rs @@ -29,6 +29,7 @@ use crate::types::WindowsToml; use codex_app_server_protocol::Tools; use codex_app_server_protocol::UserSavedConfig; use codex_features::FeaturesToml; +use codex_model_provider_info::AMAZON_BEDROCK_PROVIDER_ID; use codex_model_provider_info::LEGACY_OLLAMA_CHAT_PROVIDER_ID; use codex_model_provider_info::LMSTUDIO_OSS_PROVIDER_ID; use codex_model_provider_info::ModelProviderInfo; @@ -56,7 +57,8 @@ use serde::Deserialize; use serde::Deserializer; use serde::Serialize; -const RESERVED_MODEL_PROVIDER_IDS: [&str; 3] = [ +const RESERVED_MODEL_PROVIDER_IDS: [&str; 4] = [ + AMAZON_BEDROCK_PROVIDER_ID, OPENAI_PROVIDER_ID, OLLAMA_OSS_PROVIDER_ID, LMSTUDIO_OSS_PROVIDER_ID, @@ -302,6 +304,10 @@ pub struct ConfigToml { /// instructions inserted into developer messages when realtime becomes /// active. pub experimental_realtime_start_instructions: Option, + + /// Experimental / do not use. When set, app-server uses a remote thread + /// store at this endpoint instead of the local filesystem/SQLite store. + pub experimental_thread_store_endpoint: Option, pub projects: Option>, /// Controls the web search tool mode: disabled, cached, or live. @@ -776,7 +782,10 @@ pub fn validate_reserved_model_provider_ids( ) -> Result<(), String> { let mut conflicts = model_providers .keys() - .filter(|key| RESERVED_MODEL_PROVIDER_IDS.contains(&key.as_str())) + .filter(|key| { + key.as_str() != AMAZON_BEDROCK_PROVIDER_ID + && RESERVED_MODEL_PROVIDER_IDS.contains(&key.as_str()) + }) .map(|key| format!("`{key}`")) .collect::>(); conflicts.sort_unstable(); @@ -796,6 +805,19 @@ pub fn validate_model_providers( ) -> Result<(), String> { validate_reserved_model_provider_ids(model_providers)?; for (key, provider) in model_providers { + if key == AMAZON_BEDROCK_PROVIDER_ID { + continue; + } + if provider.aws.is_some() { + return Err(format!( + "model_providers.{key}: provider aws is only supported for `{AMAZON_BEDROCK_PROVIDER_ID}`" + )); + } + if provider.name.trim().is_empty() { + return Err(format!( + "model_providers.{key}: provider name must not be empty" + )); + } provider .validate() .map_err(|message| format!("model_providers.{key}: {message}"))?; diff --git a/codex-rs/config/src/host_name.rs b/codex-rs/config/src/host_name.rs new file mode 100644 index 0000000000..dcd34b0ba3 --- /dev/null +++ b/codex-rs/config/src/host_name.rs @@ -0,0 +1,97 @@ +#[cfg(unix)] +use dns_lookup::AddrInfoHints; +#[cfg(unix)] +use dns_lookup::getaddrinfo; +use std::sync::LazyLock; +#[cfg(windows)] +use winapi_util::sysinfo::ComputerNameKind; +#[cfg(windows)] +use winapi_util::sysinfo::get_computer_name; + +static HOST_NAME: LazyLock> = LazyLock::new(compute_host_name); + +pub fn host_name() -> Option { + HOST_NAME.clone() +} + +fn compute_host_name() -> Option { + let kernel_hostname = gethostname::gethostname(); + let kernel_hostname = normalize_host_name(&kernel_hostname.to_string_lossy())?; + + // Remote sandbox requirements are meant to target remote hosts by DNS name, + // so prefer the canonical FQDN when the local resolver can provide one. + // This is best-effort host classification, not authenticated device proof. + if let Some(fqdn) = local_fqdn_for_hostname(&kernel_hostname) { + return Some(fqdn); + } + + // Some machines have only a short local hostname or resolver setup that + // does not return AI_CANONNAME. Keep matching behavior best-effort by + // falling back to the cleaned kernel hostname instead of returning None. + Some(kernel_hostname) +} + +fn normalize_host_name(hostname: &str) -> Option { + let hostname = hostname.trim().trim_end_matches('.'); + (!hostname.is_empty()).then(|| hostname.to_ascii_lowercase()) +} + +#[cfg(unix)] +fn local_fqdn_for_hostname(hostname: &str) -> Option { + let hints = AddrInfoHints { + flags: libc::AI_CANONNAME, + ..AddrInfoHints::default() + }; + + getaddrinfo(Some(hostname), /*service*/ None, Some(hints)) + .ok()? + .filter_map(Result::ok) + .filter_map(|addr| addr.canonname) + // getaddrinfo may return the short hostname as canonname when no FQDN + // is available. Treat only DNS-qualified names as an FQDN result. + .find_map(|hostname| normalize_fqdn_candidate(&hostname)) +} + +#[cfg(windows)] +fn local_fqdn_for_hostname(_hostname: &str) -> Option { + get_computer_name(ComputerNameKind::PhysicalDnsFullyQualified) + .ok() + .and_then(|hostname| hostname.into_string().ok()) + .and_then(|hostname| normalize_fqdn_candidate(&hostname)) +} + +#[cfg(not(any(unix, windows)))] +fn local_fqdn_for_hostname(_hostname: &str) -> Option { + None +} + +fn normalize_fqdn_candidate(hostname: &str) -> Option { + normalize_host_name(hostname).filter(|hostname| hostname.contains('.')) +} + +#[cfg(test)] +mod tests { + use super::normalize_fqdn_candidate; + use pretty_assertions::assert_eq; + + #[test] + fn normalize_fqdn_candidate_accepts_dns_qualified_name() { + assert_eq!( + normalize_fqdn_candidate("runner-01.ci.example.com"), + Some("runner-01.ci.example.com".to_string()) + ); + } + + #[test] + fn normalize_fqdn_candidate_rejects_short_name() { + assert_eq!(normalize_fqdn_candidate("runner-01"), None); + } + + #[test] + fn normalize_fqdn_candidate_trims_trailing_dot_and_normalizes_case() { + assert_eq!( + normalize_fqdn_candidate("RUNNER-01.CI.EXAMPLE.COM."), + Some("runner-01.ci.example.com".to_string()) + ); + } +} diff --git a/codex-rs/config/src/lib.rs b/codex-rs/config/src/lib.rs index a26d5afe0a..e70550f009 100644 --- a/codex-rs/config/src/lib.rs +++ b/codex-rs/config/src/lib.rs @@ -4,6 +4,7 @@ pub mod config_toml; mod constraint; mod diagnostics; mod fingerprint; +mod host_name; mod key_aliases; mod marketplace_edit; mod mcp_edit; @@ -18,6 +19,7 @@ pub mod schema; pub mod shell_environment; mod skills_config; mod state; +mod thread_config; pub mod types; pub const CONFIG_TOML_FILE: &str = "config.toml"; @@ -42,6 +44,7 @@ pub use config_requirements::NetworkDomainPermissionsToml; pub use config_requirements::NetworkRequirementsToml; pub use config_requirements::NetworkUnixSocketPermissionToml; pub use config_requirements::NetworkUnixSocketPermissionsToml; +pub use config_requirements::RemoteSandboxConfigToml; pub use config_requirements::RequirementSource; pub use config_requirements::ResidencyRequirement; pub use config_requirements::SandboxModeRequirement; @@ -62,6 +65,7 @@ pub use diagnostics::format_config_error; pub use diagnostics::format_config_error_with_source; pub use diagnostics::io_error_from_config_error; pub use fingerprint::version_for_toml; +pub use host_name::host_name; pub use marketplace_edit::MarketplaceConfigUpdate; pub use marketplace_edit::RemoveMarketplaceConfigOutcome; pub use marketplace_edit::record_user_marketplace; @@ -93,5 +97,14 @@ pub use state::ConfigLayerEntry; pub use state::ConfigLayerStack; pub use state::ConfigLayerStackOrdering; pub use state::LoaderOverrides; +pub use thread_config::NoopThreadConfigLoader; +pub use thread_config::SessionThreadConfig; +pub use thread_config::StaticThreadConfigLoader; +pub use thread_config::ThreadConfigContext; +pub use thread_config::ThreadConfigLoadError; +pub use thread_config::ThreadConfigLoadErrorCode; +pub use thread_config::ThreadConfigLoader; +pub use thread_config::ThreadConfigSource; +pub use thread_config::UserThreadConfig; pub use codex_app_server_protocol::ConfigLayerSource; diff --git a/codex-rs/config/src/thread_config.rs b/codex-rs/config/src/thread_config.rs new file mode 100644 index 0000000000..e1e598708e --- /dev/null +++ b/codex-rs/config/src/thread_config.rs @@ -0,0 +1,314 @@ +use std::collections::BTreeMap; +use std::collections::HashMap; + +use async_trait::async_trait; +use codex_app_server_protocol::ConfigLayerSource; +use codex_model_provider_info::ModelProviderInfo; +use codex_utils_absolute_path::AbsolutePathBuf; +use thiserror::Error; +use toml::Value as TomlValue; + +use crate::ConfigLayerEntry; + +/// Context available to implementations when loading thread-scoped config. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct ThreadConfigContext { + pub thread_id: Option, + pub cwd: Option, +} + +/// Config values owned by the service that starts or manages the session. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct SessionThreadConfig { + pub model_provider: Option, + pub model_providers: HashMap, + pub features: BTreeMap, +} + +/// Config values owned by the authenticated user. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct UserThreadConfig {} + +/// A typed config payload paired with the authority that produced it. +#[derive(Clone, Debug, PartialEq)] +pub enum ThreadConfigSource { + Session(SessionThreadConfig), + User(UserThreadConfig), +} + +/// Stable category for failures returned while loading thread config. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum ThreadConfigLoadErrorCode { + Auth, + Timeout, + Parse, + RequestFailed, + Internal, +} + +#[derive(Clone, Debug, Eq, Error, PartialEq)] +#[error("{message}")] +pub struct ThreadConfigLoadError { + code: ThreadConfigLoadErrorCode, + message: String, + status_code: Option, +} + +impl ThreadConfigLoadError { + pub fn new( + code: ThreadConfigLoadErrorCode, + status_code: Option, + message: impl Into, + ) -> Self { + Self { + code, + message: message.into(), + status_code, + } + } + + pub fn code(&self) -> ThreadConfigLoadErrorCode { + self.code + } + + pub fn status_code(&self) -> Option { + self.status_code + } +} + +/// Loads typed config sources for a new thread. +/// +/// Implementations should fetch only the source-specific config they own and +/// return typed payloads without applying precedence or merge rules. Callers +/// are responsible for resolving the returned sources into the effective +/// runtime config. +#[async_trait] +pub trait ThreadConfigLoader: Send + Sync { + /// Load source-specific typed config. + /// + /// Implementations should keep this method focused on fetching and parsing + /// their owned sources. Most callers should use [`Self::load_config_layers`] + /// so precedence and merging continue through the ordinary config layer + /// stack. + async fn load( + &self, + context: ThreadConfigContext, + ) -> Result, ThreadConfigLoadError>; + + async fn load_config_layers( + &self, + context: ThreadConfigContext, + ) -> Result, ThreadConfigLoadError> { + let sources = self.load(context).await?; + sources + .into_iter() + .map(thread_config_source_to_layer) + .collect::, _>>() + .map(|layers| layers.into_iter().flatten().collect()) + } +} + +/// Loader backed by a static set of typed thread config sources. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct StaticThreadConfigLoader { + sources: Vec, +} + +impl StaticThreadConfigLoader { + pub fn new(sources: Vec) -> Self { + Self { sources } + } +} + +#[async_trait] +impl ThreadConfigLoader for StaticThreadConfigLoader { + async fn load( + &self, + _context: ThreadConfigContext, + ) -> Result, ThreadConfigLoadError> { + Ok(self.sources.clone()) + } +} + +/// Loader used when no external thread config source is configured. +#[derive(Clone, Debug, Default)] +pub struct NoopThreadConfigLoader; + +#[async_trait] +impl ThreadConfigLoader for NoopThreadConfigLoader { + async fn load( + &self, + _context: ThreadConfigContext, + ) -> Result, ThreadConfigLoadError> { + Ok(Vec::new()) + } +} + +fn thread_config_source_to_layer( + source: ThreadConfigSource, +) -> Result, ThreadConfigLoadError> { + match source { + ThreadConfigSource::Session(config) => { + let config = session_thread_config_to_toml(config)?; + if is_empty_table(&config) { + Ok(None) + } else { + Ok(Some(ConfigLayerEntry::new( + ConfigLayerSource::SessionFlags, + config, + ))) + } + } + // UserThreadConfig has no TOML-backed fields yet. When it grows one, + // fold it into the existing user layer instead of adding another + // ConfigLayerSource variant. + ThreadConfigSource::User(_config) => Ok(None), + } +} + +fn is_empty_table(config: &TomlValue) -> bool { + config.as_table().is_some_and(toml::map::Map::is_empty) +} + +fn session_thread_config_to_toml( + config: SessionThreadConfig, +) -> Result { + let mut table = toml::map::Map::new(); + + if let Some(model_provider) = config.model_provider { + table.insert( + "model_provider".to_string(), + TomlValue::String(model_provider), + ); + } + + if !config.model_providers.is_empty() { + let model_providers = TomlValue::try_from(config.model_providers).map_err(|err| { + ThreadConfigLoadError::new( + ThreadConfigLoadErrorCode::Parse, + /*status_code*/ None, + format!("failed to convert session model providers to config TOML: {err}"), + ) + })?; + table.insert("model_providers".to_string(), model_providers); + } + + if !config.features.is_empty() { + let features = config + .features + .into_iter() + .map(|(feature, enabled)| (feature, TomlValue::Boolean(enabled))) + .collect(); + table.insert("features".to_string(), TomlValue::Table(features)); + } + + Ok(TomlValue::Table(table)) +} + +#[cfg(test)] +mod tests { + use codex_model_provider_info::ModelProviderInfo; + use codex_model_provider_info::WireApi; + use pretty_assertions::assert_eq; + + use super::*; + + #[tokio::test] + async fn loader_returns_session_and_user_sources() { + let loader = StaticThreadConfigLoader::new(vec![ + ThreadConfigSource::Session(SessionThreadConfig { + model_provider: Some("local".to_string()), + model_providers: HashMap::from([("local".to_string(), test_provider("local"))]), + features: BTreeMap::from([("plugins".to_string(), false)]), + }), + ThreadConfigSource::User(UserThreadConfig::default()), + ]); + + let sources = loader + .load(ThreadConfigContext { + thread_id: Some("thread-1".to_string()), + ..Default::default() + }) + .await + .expect("thread config loads"); + + assert_eq!( + sources, + vec![ + ThreadConfigSource::Session(SessionThreadConfig { + model_provider: Some("local".to_string()), + model_providers: HashMap::from([("local".to_string(), test_provider("local"))]), + features: BTreeMap::from([("plugins".to_string(), false)]), + }), + ThreadConfigSource::User(UserThreadConfig::default()), + ] + ); + } + + #[tokio::test] + async fn loader_translates_sources_to_config_layers() { + let loader = StaticThreadConfigLoader::new(vec![ + ThreadConfigSource::User(UserThreadConfig::default()), + ThreadConfigSource::Session(SessionThreadConfig { + model_provider: Some("local".to_string()), + model_providers: HashMap::from([("local".to_string(), test_provider("local"))]), + features: BTreeMap::from([("plugins".to_string(), false)]), + }), + ]); + let layers = loader + .load_config_layers(ThreadConfigContext { + cwd: Some( + AbsolutePathBuf::from_absolute_path_checked( + std::env::temp_dir().join("project"), + ) + .expect("absolute cwd"), + ), + ..Default::default() + }) + .await + .expect("thread config layers load"); + + assert_eq!( + layers, + vec![ConfigLayerEntry::new( + ConfigLayerSource::SessionFlags, + toml::toml! { + model_provider = "local" + + [model_providers.local] + name = "local" + base_url = "http://127.0.0.1:8061/api/codex" + wire_api = "responses" + requires_openai_auth = false + supports_websockets = true + + [features] + plugins = false + } + .into() + )] + ); + } + + fn test_provider(name: &str) -> ModelProviderInfo { + ModelProviderInfo { + name: name.to_string(), + base_url: Some("http://127.0.0.1:8061/api/codex".to_string()), + env_key: None, + env_key_instructions: None, + experimental_bearer_token: None, + auth: None, + aws: None, + wire_api: WireApi::Responses, + query_params: None, + http_headers: None, + env_http_headers: None, + request_max_retries: None, + stream_max_retries: None, + stream_idle_timeout_ms: None, + websocket_connect_timeout_ms: None, + requires_openai_auth: false, + supports_websockets: true, + } + } +} diff --git a/codex-rs/connectors/src/lib.rs b/codex-rs/connectors/src/lib.rs index e13270a78c..e6260d0e1d 100644 --- a/codex-rs/connectors/src/lib.rs +++ b/codex-rs/connectors/src/lib.rs @@ -446,6 +446,10 @@ mod tests { } #[tokio::test] + #[expect( + clippy::await_holding_invalid_type, + reason = "test serializes access to the shared connector cache for its full duration" + )] async fn list_all_connectors_uses_shared_cache() -> anyhow::Result<()> { let _cache_guard = ALL_CONNECTORS_CACHE_TEST_LOCK.lock().await; @@ -486,6 +490,10 @@ mod tests { } #[tokio::test] + #[expect( + clippy::await_holding_invalid_type, + reason = "test serializes access to the shared connector cache for its full duration" + )] async fn list_all_connectors_merges_and_normalizes_directory_apps() -> anyhow::Result<()> { let _cache_guard = ALL_CONNECTORS_CACHE_TEST_LOCK.lock().await; diff --git a/codex-rs/core-plugins/src/loader.rs b/codex-rs/core-plugins/src/loader.rs index f3e5f8d4f1..21c5aa6b43 100644 --- a/codex-rs/core-plugins/src/loader.rs +++ b/codex-rs/core-plugins/src/loader.rs @@ -67,11 +67,26 @@ pub fn log_plugin_load_errors(outcome: &PluginLoadOutcome) { #[derive(Debug, Default, Deserialize)] #[serde(rename_all = "camelCase")] -struct PluginMcpFile { - #[serde(default)] +struct PluginMcpServersFile { mcp_servers: HashMap, } +#[derive(Debug, Deserialize)] +#[serde(untagged)] +enum PluginMcpFile { + McpServersObject(PluginMcpServersFile), + ServerMap(HashMap), +} + +impl PluginMcpFile { + fn into_mcp_servers(self) -> HashMap { + match self { + Self::McpServersObject(file) => file.mcp_servers, + Self::ServerMap(mcp_servers) => mcp_servers, + } + } +} + #[derive(Debug, Default, Deserialize)] #[serde(rename_all = "camelCase")] struct PluginAppFile { @@ -775,7 +790,7 @@ async fn load_mcp_servers_from_file( }; normalize_plugin_mcp_servers( plugin_root, - parsed.mcp_servers, + parsed.into_mcp_servers(), mcp_config_path.to_string_lossy().as_ref(), ) } @@ -988,6 +1003,82 @@ mod tests { use super::*; use pretty_assertions::assert_eq; + #[test] + fn plugin_mcp_file_supports_mcp_servers_object_format() { + let parsed = serde_json::from_str::( + r#"{ + "mcpServers": { + "sample": { + "command": "sample-mcp" + } + } +}"#, + ) + .expect("parse wrapped plugin mcp config") + .into_mcp_servers(); + + assert_eq!( + parsed, + HashMap::from([( + "sample".to_string(), + serde_json::json!({ + "command": "sample-mcp" + }), + )]) + ); + } + + #[test] + fn plugin_mcp_file_supports_mcp_servers_object_format_with_metadata() { + let parsed = serde_json::from_str::( + r#"{ + "$schema": "https://example.com/plugin-mcp.schema.json", + "mcpServers": { + "sample": { + "command": "sample-mcp" + } + } +}"#, + ) + .expect("parse plugin mcp config with metadata") + .into_mcp_servers(); + + assert_eq!( + parsed, + HashMap::from([( + "sample".to_string(), + serde_json::json!({ + "command": "sample-mcp" + }), + )]) + ); + } + + #[test] + fn plugin_mcp_file_supports_top_level_server_map_format() { + let parsed = serde_json::from_str::( + r#"{ + "linear": { + "type": "http", + "url": "https://mcp.linear.app/mcp" + } +}"#, + ) + .expect("parse flat plugin mcp config") + .into_mcp_servers(); + + assert_eq!( + parsed, + HashMap::from([( + "linear".to_string(), + serde_json::json!({ + "type": "http", + "url": "https://mcp.linear.app/mcp" + }), + )]) + ); + } + #[test] fn materialize_git_subdir_uses_sparse_checkout() { let codex_home = tempfile::tempdir().expect("create codex home"); diff --git a/codex-rs/core-skills/Cargo.toml b/codex-rs/core-skills/Cargo.toml index 09278c8d0e..355374114a 100644 --- a/codex-rs/core-skills/Cargo.toml +++ b/codex-rs/core-skills/Cargo.toml @@ -18,7 +18,6 @@ codex-analytics = { workspace = true } codex-app-server-protocol = { workspace = true } codex-config = { workspace = true } codex-exec-server = { workspace = true } -codex-instructions = { workspace = true } codex-login = { workspace = true } codex-otel = { workspace = true } codex-protocol = { workspace = true } diff --git a/codex-rs/core-skills/src/injection.rs b/codex-rs/core-skills/src/injection.rs index 1ccd447cf0..ed06cc578e 100644 --- a/codex-rs/core-skills/src/injection.rs +++ b/codex-rs/core-skills/src/injection.rs @@ -10,19 +10,24 @@ use codex_analytics::InvocationType; use codex_analytics::SkillInvocation; use codex_analytics::TrackEventsContext; use codex_exec_server::LOCAL_FS; -use codex_instructions::SkillInstructions; use codex_otel::SessionTelemetry; -use codex_protocol::models::ResponseItem; use codex_protocol::user_input::UserInput; use codex_utils_absolute_path::AbsolutePathBuf; use codex_utils_plugins::mention_syntax::TOOL_MENTION_SIGIL; #[derive(Debug, Default)] pub struct SkillInjections { - pub items: Vec, + pub items: Vec, pub warnings: Vec, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SkillInjection { + pub name: String, + pub path: String, + pub contents: String, +} + pub async fn build_skill_injections( mentioned_skills: &[SkillMetadata], loaded_skills: Option<&SkillLoadOutcome>, @@ -56,11 +61,11 @@ pub async fn build_skill_injections( skill_path: skill.path_to_skills_md.to_path_buf(), invocation_type: InvocationType::Explicit, }); - result.items.push(ResponseItem::from(SkillInstructions { + result.items.push(SkillInjection { name: skill.name.clone(), path: skill.path_to_skills_md.to_string_lossy().into_owned(), contents, - })); + }); } Err(err) => { emit_skill_injected_metric(otel, skill, "error"); diff --git a/codex-rs/core/Cargo.toml b/codex-rs/core/Cargo.toml index 8770aaf487..6ef6741fd9 100644 --- a/codex-rs/core/Cargo.toml +++ b/codex-rs/core/Cargo.toml @@ -48,7 +48,6 @@ codex-shell-command = { workspace = true } codex-execpolicy = { workspace = true } codex-git-utils = { workspace = true } codex-hooks = { workspace = true } -codex-instructions = { workspace = true } codex-network-proxy = { workspace = true } codex-otel = { workspace = true } codex-plugin = { workspace = true } diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.json index a2d7b28a86..b0faea2b56 100644 --- a/codex-rs/core/config.schema.json +++ b/codex-rs/core/config.schema.json @@ -1027,6 +1027,17 @@ ], "type": "object" }, + "ModelProviderAwsAuthInfo": { + "additionalProperties": false, + "description": "AWS SigV4 auth configuration for a model provider.", + "properties": { + "profile": { + "description": "AWS profile name to use. When unset, the AWS SDK default chain decides.", + "type": "string" + } + }, + "type": "object" + }, "ModelProviderInfo": { "additionalProperties": false, "description": "Serializable representation of a provider definition.", @@ -1039,6 +1050,14 @@ ], "description": "Command-backed bearer-token configuration for this provider." }, + "aws": { + "allOf": [ + { + "$ref": "#/definitions/ModelProviderAwsAuthInfo" + } + ], + "description": "AWS SigV4 auth configuration for this provider." + }, "base_url": { "description": "Base URL for the provider's OpenAI-compatible API.", "type": "string" @@ -1070,6 +1089,7 @@ "type": "object" }, "name": { + "default": "", "description": "Friendly display name.", "type": "string" }, @@ -1124,9 +1144,6 @@ "description": "Which wire protocol this provider expects." } }, - "required": [ - "name" - ], "type": "object" }, "MultiAgentV2ConfigToml": { @@ -2299,6 +2316,10 @@ "description": "Experimental / do not use. Replaces the synthesized realtime startup context appended to websocket session instructions. An empty string disables startup context injection entirely.", "type": "string" }, + "experimental_thread_store_endpoint": { + "description": "Experimental / do not use. When set, app-server uses a remote thread store at this endpoint instead of the local filesystem/SQLite store.", + "type": "string" + }, "experimental_use_freeform_apply_patch": { "type": "boolean" }, @@ -2957,4 +2978,4 @@ }, "title": "ConfigToml", "type": "object" -} +} \ No newline at end of file diff --git a/codex-rs/core/src/agent/control_tests.rs b/codex-rs/core/src/agent/control_tests.rs index ccfc304cfb..8a96f89c39 100644 --- a/codex-rs/core/src/agent/control_tests.rs +++ b/codex-rs/core/src/agent/control_tests.rs @@ -5,7 +5,8 @@ use crate::agent::agent_status_from_event; use crate::config::AgentRoleConfig; use crate::config::Config; use crate::config::ConfigBuilder; -use crate::contextual_user_message::SUBAGENT_NOTIFICATION_OPEN_TAG; +use crate::context::ContextualUserFragment; +use crate::context::SubagentNotification; use assert_matches::assert_matches; use codex_features::Feature; use codex_login::CodexAuth; @@ -127,7 +128,7 @@ fn has_subagent_notification(history_items: &[ResponseItem]) -> bool { } content.iter().any(|content_item| match content_item { ContentItem::InputText { text } | ContentItem::OutputText { text } => { - text.contains(SUBAGENT_NOTIFICATION_OPEN_TAG) + SubagentNotification::matches_text(text) } ContentItem::InputImage { .. } => false, }) diff --git a/codex-rs/core/src/arc_monitor_tests.rs b/codex-rs/core/src/arc_monitor_tests.rs index 6bf1aa98f0..5fd691b930 100644 --- a/codex-rs/core/src/arc_monitor_tests.rs +++ b/codex-rs/core/src/arc_monitor_tests.rs @@ -1,5 +1,6 @@ use std::env; use std::ffi::OsStr; +use std::path::PathBuf; use std::sync::Arc; use pretty_assertions::assert_eq; @@ -16,6 +17,7 @@ use wiremock::matchers::path; use super::*; use crate::agent_identity::AgentIdentityManager; use crate::agent_identity::RegisteredAgentTask; +use crate::context::ContextualUserFragment; use crate::session::tests::make_session_and_context; use chrono::Utc; use codex_login::AuthCredentialsStoreMode; @@ -143,11 +145,16 @@ async fn build_arc_monitor_request_includes_relevant_history_and_null_policies() .await; session .record_into_history( - &[ - crate::contextual_user_message::ENVIRONMENT_CONTEXT_FRAGMENT.into_message( - "\n/tmp\n".to_string(), + &[ContextualUserFragment::into( + crate::context::EnvironmentContext::new( + Some(PathBuf::from("/tmp")), + "zsh".to_string(), + /*current_date*/ None, + /*timezone*/ None, + /*network*/ None, + /*subagents*/ None, ), - ], + )], &turn_context, ) .await; diff --git a/codex-rs/core/src/codex_delegate.rs b/codex-rs/core/src/codex_delegate.rs index 5d67223b33..be021fe6aa 100644 --- a/codex-rs/core/src/codex_delegate.rs +++ b/codex-rs/core/src/codex_delegate.rs @@ -26,15 +26,14 @@ use codex_protocol::user_input::UserInput; use serde_json::Value; use std::time::Duration; use tokio::sync::Mutex; -use tokio::sync::oneshot; use tokio::time::timeout; use tokio_util::sync::CancellationToken; use crate::config::Config; use crate::guardian::GuardianApprovalRequest; use crate::guardian::new_guardian_review_id; -use crate::guardian::review_approval_request_with_cancel; use crate::guardian::routes_approval_to_guardian; +use crate::guardian::spawn_approval_request_review; use crate::mcp_tool_call::MCP_TOOL_APPROVAL_ACCEPT; use crate::mcp_tool_call::MCP_TOOL_APPROVAL_ACCEPT_FOR_SESSION; use crate::mcp_tool_call::MCP_TOOL_APPROVAL_DECLINE_SYNTHETIC; @@ -457,7 +456,7 @@ async fn handle_exec_approval( } = event; let decision = if routes_approval_to_guardian(parent_ctx) { let review_cancel = cancel_token.child_token(); - let review_rx = spawn_guardian_review( + let review_rx = spawn_approval_request_review( Arc::clone(parent_session), Arc::clone(parent_ctx), new_guardian_review_id(), @@ -565,7 +564,7 @@ async fn handle_patch_approval( }) .collect::>() .join("\n"); - let review_rx = spawn_guardian_review( + let review_rx = spawn_approval_request_review( Arc::clone(parent_session), Arc::clone(parent_ctx), new_guardian_review_id(), @@ -686,7 +685,7 @@ async fn maybe_auto_review_mcp_request_user_input( ) .await; let review_cancel = cancel_token.child_token(); - let review_rx = spawn_guardian_review( + let review_rx = spawn_approval_request_review( Arc::clone(parent_session), Arc::clone(parent_ctx), new_guardian_review_id(), @@ -730,36 +729,6 @@ async fn maybe_auto_review_mcp_request_user_input( }) } -fn spawn_guardian_review( - session: Arc, - turn: Arc, - review_id: String, - request: GuardianApprovalRequest, - retry_reason: Option, - cancel_token: CancellationToken, -) -> oneshot::Receiver { - let (tx, rx) = oneshot::channel(); - std::thread::spawn(move || { - let Ok(runtime) = tokio::runtime::Builder::new_current_thread() - .enable_all() - .build() - else { - let _ = tx.send(ReviewDecision::Denied); - return; - }; - let decision = runtime.block_on(review_approval_request_with_cancel( - &session, - &turn, - review_id, - request, - retry_reason, - cancel_token, - )); - let _ = tx.send(decision); - }); - rx -} - async fn handle_request_permissions( codex: &Codex, parent_session: &Arc, @@ -772,7 +741,8 @@ async fn handle_request_permissions( reason: event.reason, permissions: event.permissions, }; - let response_fut = parent_session.request_permissions(parent_ctx, call_id.clone(), args); + let response_fut = + parent_session.request_permissions(parent_ctx, call_id.clone(), args, cancel_token.clone()); let response = await_request_permissions_with_cancel(response_fut, parent_session, &call_id, cancel_token) .await; diff --git a/codex-rs/core/src/compact_tests.rs b/codex-rs/core/src/compact_tests.rs index ed2fd8487d..fbdfdb051d 100644 --- a/codex-rs/core/src/compact_tests.rs +++ b/codex-rs/core/src/compact_tests.rs @@ -198,6 +198,7 @@ fn should_use_remote_compact_task_for_azure_provider() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rs index 413423518e..e7c7aa31dd 100644 --- a/codex-rs/core/src/config/config_tests.rs +++ b/codex-rs/core/src/config/config_tests.rs @@ -369,6 +369,108 @@ command = "print-token" ); } +#[test] +fn rejects_provider_aws_for_custom_provider() { + let err = toml::from_str::( + r#" +[model_providers.custom] +name = "Custom Provider" + +[model_providers.custom.aws] +profile = "codex-bedrock" +"#, + ) + .unwrap_err(); + + assert!( + err.to_string().contains( + "model_providers.custom: provider aws is only supported for `amazon-bedrock`" + ) + ); +} + +#[test] +fn accepts_amazon_bedrock_aws_profile_override() { + let cfg = toml::from_str::( + r#" +[model_providers.amazon-bedrock.aws] +profile = "codex-bedrock" +"#, + ) + .expect("Amazon Bedrock AWS profile override should deserialize"); + + assert_eq!( + cfg.model_providers + .get("amazon-bedrock") + .and_then(|provider| provider.aws.as_ref()) + .and_then(|aws| aws.profile.as_deref()), + Some("codex-bedrock") + ); +} + +#[tokio::test] +async fn load_config_applies_amazon_bedrock_aws_profile_override() { + let cfg = toml::from_str::( + r#" +model_provider = "amazon-bedrock" + +[model_providers.amazon-bedrock.aws] +profile = "codex-bedrock" +"#, + ) + .expect("Amazon Bedrock AWS profile override should deserialize"); + + let config = Config::load_from_base_config_with_overrides( + cfg, + ConfigOverrides::default(), + tempdir().expect("tempdir").abs(), + ) + .await + .expect("load config"); + + assert_eq!(config.model_provider_id, "amazon-bedrock"); + assert_eq!( + config + .model_provider + .aws + .as_ref() + .and_then(|aws| aws.profile.as_deref()), + Some("codex-bedrock") + ); +} + +#[tokio::test] +async fn load_config_rejects_unsupported_amazon_bedrock_overrides() { + let cfg = toml::from_str::( + r#" +model_provider = "amazon-bedrock" + +[model_providers.amazon-bedrock] +name = "Custom Bedrock" +base_url = "https://bedrock.example.com/v1" +requires_openai_auth = true +supports_websockets = true + +[model_providers.amazon-bedrock.aws] +profile = "codex-bedrock" +"#, + ) + .expect("Amazon Bedrock unsupported overrides should deserialize"); + + let err = Config::load_from_base_config_with_overrides( + cfg, + ConfigOverrides::default(), + tempdir().expect("tempdir").abs(), + ) + .await + .unwrap_err(); + + assert_eq!(err.kind(), std::io::ErrorKind::InvalidData); + assert!(err.to_string().contains( + "model_providers.amazon-bedrock only supports changing `aws.profile`; other non-default provider fields are not supported" + )); +} + #[test] fn config_toml_deserializes_model_availability_nux() { let toml = r#" @@ -2110,6 +2212,8 @@ async fn managed_config_overrides_oauth_store_mode() -> anyhow::Result<()> { &Vec::new(), overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; let cfg = @@ -2244,6 +2348,8 @@ async fn managed_config_wins_over_cli_overrides() -> anyhow::Result<()> { &[("model".to_string(), TomlValue::String("cli".to_string()))], overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -4753,6 +4859,7 @@ model_verbosity = "high" env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, query_params: None, http_headers: None, env_http_headers: None, @@ -4887,6 +4994,7 @@ async fn test_precedence_fixture_with_o3_profile() -> std::io::Result<()> { realtime: RealtimeConfig::default(), experimental_realtime_ws_backend_prompt: None, experimental_realtime_ws_startup_context: None, + experimental_thread_store_endpoint: None, base_instructions: None, developer_instructions: None, guardian_policy_config: None, @@ -5038,6 +5146,7 @@ async fn test_precedence_fixture_with_gpt3_profile() -> std::io::Result<()> { realtime: RealtimeConfig::default(), experimental_realtime_ws_backend_prompt: None, experimental_realtime_ws_startup_context: None, + experimental_thread_store_endpoint: None, base_instructions: None, developer_instructions: None, guardian_policy_config: None, @@ -5187,6 +5296,7 @@ async fn test_precedence_fixture_with_zdr_profile() -> std::io::Result<()> { realtime: RealtimeConfig::default(), experimental_realtime_ws_backend_prompt: None, experimental_realtime_ws_startup_context: None, + experimental_thread_store_endpoint: None, base_instructions: None, developer_instructions: None, guardian_policy_config: None, @@ -5321,6 +5431,7 @@ async fn test_precedence_fixture_with_gpt5_profile() -> std::io::Result<()> { realtime: RealtimeConfig::default(), experimental_realtime_ws_backend_prompt: None, experimental_realtime_ws_startup_context: None, + experimental_thread_store_endpoint: None, base_instructions: None, developer_instructions: None, guardian_policy_config: None, @@ -5375,6 +5486,7 @@ async fn test_requirements_web_search_mode_allowlist_does_not_warn_when_unset() allowed_approval_policies: None, allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: Some(vec![ crate::config_loader::WebSearchModeRequirement::Cached, ]), @@ -6051,6 +6163,7 @@ async fn explicit_sandbox_mode_falls_back_when_disallowed_by_requirements() -> s allowed_approval_policies: None, allowed_approvals_reviewers: None, allowed_sandbox_modes: Some(vec![crate::config_loader::SandboxModeRequirement::ReadOnly]), + remote_sandbox_config: None, allowed_web_search_modes: None, feature_requirements: None, mcp_servers: None, diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rs index 2fef40a427..a6240fdcb3 100644 --- a/codex-rs/core/src/config/mod.rs +++ b/codex-rs/core/src/config/mod.rs @@ -21,6 +21,7 @@ use crate::unified_exec::MIN_EMPTY_YIELD_TIME_MS; use crate::windows_sandbox::WindowsSandboxLevelExt; use crate::windows_sandbox::resolve_windows_sandbox_mode; use crate::windows_sandbox::resolve_windows_sandbox_private_desktop; +use codex_config::ThreadConfigLoader; use codex_config::config_toml::ConfigToml; use codex_config::config_toml::ProjectConfig; use codex_config::config_toml::RealtimeAudioConfig; @@ -64,6 +65,7 @@ use codex_model_provider_info::LEGACY_OLLAMA_CHAT_PROVIDER_ID; use codex_model_provider_info::ModelProviderInfo; use codex_model_provider_info::OLLAMA_CHAT_PROVIDER_REMOVED_ERROR; use codex_model_provider_info::built_in_model_providers; +use codex_model_provider_info::merge_configured_model_providers; use codex_models_manager::ModelsManagerConfig; use codex_protocol::config_types::AltScreenMode; use codex_protocol::config_types::ForcedLoginMethod; @@ -90,6 +92,7 @@ use std::collections::HashMap; use std::io::ErrorKind; use std::path::Path; use std::path::PathBuf; +use std::sync::Arc; use crate::config::permissions::compile_permission_profile; use crate::config::permissions::get_readable_roots_required_for_codex_runtime; @@ -527,6 +530,10 @@ pub struct Config { /// instructions inserted into developer messages when realtime becomes /// active. pub experimental_realtime_start_instructions: Option, + + /// Experimental / do not use. When set, app-server uses a remote thread + /// store at this endpoint instead of the local filesystem/SQLite store. + pub experimental_thread_store_endpoint: Option, /// When set, restricts ChatGPT login to a specific workspace identifier. pub forced_chatgpt_workspace_id: Option, @@ -642,14 +649,31 @@ impl AuthManagerConfig for Config { } } -#[derive(Debug, Clone, Default)] +#[derive(Clone)] pub struct ConfigBuilder { codex_home: Option, cli_overrides: Option>, harness_overrides: Option, loader_overrides: Option, cloud_requirements: CloudRequirementsLoader, + thread_config_loader: Option>, fallback_cwd: Option, + host_name: Option, +} + +impl Default for ConfigBuilder { + fn default() -> Self { + Self { + codex_home: None, + cli_overrides: None, + harness_overrides: None, + loader_overrides: None, + cloud_requirements: CloudRequirementsLoader::default(), + thread_config_loader: None, + fallback_cwd: None, + host_name: codex_config::host_name(), + } + } } impl ConfigBuilder { @@ -678,11 +702,24 @@ impl ConfigBuilder { self } + pub fn thread_config_loader( + mut self, + thread_config_loader: Arc, + ) -> Self { + self.thread_config_loader = Some(thread_config_loader); + self + } + pub fn fallback_cwd(mut self, fallback_cwd: Option) -> Self { self.fallback_cwd = fallback_cwd; self } + pub fn host_name(mut self, host_name: Option) -> Self { + self.host_name = host_name; + self + } + pub async fn build(self) -> std::io::Result { let Self { codex_home, @@ -690,7 +727,9 @@ impl ConfigBuilder { harness_overrides, loader_overrides, cloud_requirements, + thread_config_loader, fallback_cwd, + host_name, } = self; let codex_home = match codex_home { Some(codex_home) => AbsolutePathBuf::from_absolute_path(codex_home)?, @@ -712,6 +751,10 @@ impl ConfigBuilder { &cli_overrides, loader_overrides, cloud_requirements, + thread_config_loader + .as_deref() + .unwrap_or(&codex_config::NoopThreadConfigLoader), + host_name.as_deref(), ) .await?; let merged_toml = config_layer_stack.effective_config(); @@ -890,6 +933,8 @@ pub async fn load_config_as_toml_with_cli_and_loader_overrides( &cli_overrides, loader_overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -1061,6 +1106,8 @@ pub async fn load_global_mcp_servers( &cli_overrides, LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; let merged_toml = config_layer_stack.effective_config(); @@ -1800,11 +1847,9 @@ impl Config { .clone() .filter(|value| !value.is_empty()); - let mut model_providers = built_in_model_providers(openai_base_url); - // Merge user-defined providers into the built-in list. - for (key, provider) in cfg.model_providers.into_iter() { - model_providers.entry(key).or_insert(provider); - } + let model_providers = + merge_configured_model_providers(built_in_model_providers(openai_base_url), cfg.model_providers) + .map_err(|message| std::io::Error::new(std::io::ErrorKind::InvalidData, message))?; let model_provider_id = model_provider .or(config_profile.model_provider) @@ -2273,6 +2318,7 @@ impl Config { experimental_realtime_ws_backend_prompt: cfg.experimental_realtime_ws_backend_prompt, experimental_realtime_ws_startup_context: cfg.experimental_realtime_ws_startup_context, experimental_realtime_start_instructions: cfg.experimental_realtime_start_instructions, + experimental_thread_store_endpoint: cfg.experimental_thread_store_endpoint, forced_chatgpt_workspace_id, forced_login_method, include_apply_patch_tool: include_apply_patch_tool_flag, diff --git a/codex-rs/core/src/config/service.rs b/codex-rs/core/src/config/service.rs index 51288e60b9..e9546ef4db 100644 --- a/codex-rs/core/src/config/service.rs +++ b/codex-rs/core/src/config/service.rs @@ -115,6 +115,7 @@ pub struct ConfigService { cli_overrides: Vec<(String, TomlValue)>, loader_overrides: LoaderOverrides, cloud_requirements: CloudRequirementsLoader, + host_name: Option, } impl ConfigService { @@ -123,12 +124,14 @@ impl ConfigService { cli_overrides: Vec<(String, TomlValue)>, loader_overrides: LoaderOverrides, cloud_requirements: CloudRequirementsLoader, + host_name: Option, ) -> Self { Self { codex_home, cli_overrides, loader_overrides, cloud_requirements, + host_name, } } @@ -138,6 +141,7 @@ impl ConfigService { cli_overrides: Vec::new(), loader_overrides: LoaderOverrides::default(), cloud_requirements: CloudRequirementsLoader::default(), + host_name: codex_config::host_name(), } } @@ -148,6 +152,7 @@ impl ConfigService { Vec::new(), LoaderOverrides::without_managed_config_for_tests(), CloudRequirementsLoader::default(), + /*host_name*/ None, ) } @@ -166,6 +171,7 @@ impl ConfigService { .loader_overrides(self.loader_overrides.clone()) .fallback_cwd(Some(cwd.to_path_buf())) .cloud_requirements(self.cloud_requirements.clone()) + .host_name(self.host_name.clone()) .build() .await .map_err(|err| { @@ -431,6 +437,8 @@ impl ConfigService { &self.cli_overrides, self.loader_overrides.clone(), self.cloud_requirements.clone(), + &codex_config::NoopThreadConfigLoader, + self.host_name.as_deref(), ) .await } diff --git a/codex-rs/core/src/config/service_tests.rs b/codex-rs/core/src/config/service_tests.rs index 34378fe14d..ceb801c456 100644 --- a/codex-rs/core/src/config/service_tests.rs +++ b/codex-rs/core/src/config/service_tests.rs @@ -223,6 +223,7 @@ async fn read_includes_origins_and_layers() { vec![], LoaderOverrides::with_managed_config_path_for_tests(managed_path.clone()), CloudRequirementsLoader::default(), + /*host_name*/ None, ); let response = service @@ -301,6 +302,7 @@ writable_roots = ["~/code"] vec![], loader_overrides, CloudRequirementsLoader::default(), + /*host_name*/ None, ); let response = service @@ -341,6 +343,7 @@ async fn write_value_reports_override() { vec![], LoaderOverrides::with_managed_config_path_for_tests(managed_path.clone()), CloudRequirementsLoader::default(), + /*host_name*/ None, ); let result = service @@ -440,6 +443,7 @@ async fn invalid_user_value_rejected_even_if_overridden_by_managed() { vec![], LoaderOverrides::with_managed_config_path_for_tests(managed_path.clone()), CloudRequirementsLoader::default(), + /*host_name*/ None, ); let error = service @@ -507,6 +511,7 @@ async fn write_value_rejects_feature_requirement_conflict() { ..Default::default() })) }), + /*host_name*/ None, ); let error = service @@ -553,6 +558,7 @@ async fn write_value_rejects_profile_feature_requirement_conflict() { ..Default::default() })) }), + /*host_name*/ None, ); let error = service @@ -603,6 +609,7 @@ async fn read_reports_managed_overrides_user_and_session_flags() { cli_overrides, LoaderOverrides::with_managed_config_path_for_tests(managed_path.clone()), CloudRequirementsLoader::default(), + /*host_name*/ None, ); let response = service @@ -656,6 +663,7 @@ async fn write_value_reports_managed_override() { vec![], LoaderOverrides::with_managed_config_path_for_tests(managed_path.clone()), CloudRequirementsLoader::default(), + /*host_name*/ None, ); let result = service diff --git a/codex-rs/core/src/config_loader/README.md b/codex-rs/core/src/config_loader/README.md index 44a514a10a..6ee445421f 100644 --- a/codex-rs/core/src/config_loader/README.md +++ b/codex-rs/core/src/config_loader/README.md @@ -10,7 +10,7 @@ This module is the canonical place to **load and describe Codex configuration la Exported from `codex_core::config_loader`: -- `load_config_layers_state(fs, codex_home, cwd_opt, cli_overrides, overrides, cloud_requirements) -> ConfigLayerStack` +- `load_config_layers_state(fs, codex_home, cwd_opt, cli_overrides, overrides, cloud_requirements, thread_config_loader, host_name) -> ConfigLayerStack` - `ConfigLayerStack` - `effective_config() -> toml::Value` - `origins() -> HashMap` @@ -29,6 +29,9 @@ Precedence is **top overrides bottom**: 3. **Session flags** (CLI overrides, applied as dotted-path TOML writes) 4. **User** config (`config.toml`) +Thread config entries supplied by `thread_config_loader` are inserted according +to their translated `ConfigLayerSource` precedence. + Layers with a `disabled_reason` are still surfaced for UI, but are ignored when computing the effective config and origins metadata. This is what `ConfigLayerStack::effective_config()` implements. @@ -38,9 +41,8 @@ computing the effective config and origins metadata. This is what Most callers want the effective config plus metadata: ```rust -use codex_core::config_loader::{ - CloudRequirementsLoader, LoaderOverrides, load_config_layers_state, -}; +use codex_core::config_loader::{CloudRequirementsLoader, LoaderOverrides, load_config_layers_state}; +use codex_config::NoopThreadConfigLoader; use codex_exec_server::LOCAL_FS; use codex_utils_absolute_path::AbsolutePathBuf; use toml::Value as TomlValue; @@ -54,6 +56,8 @@ let layers = load_config_layers_state( &cli_overrides, LoaderOverrides::default(), CloudRequirementsLoader::default(), + &NoopThreadConfigLoader, + /*host_name*/ None, ).await?; let effective = layers.effective_config(); diff --git a/codex-rs/core/src/config_loader/macos.rs b/codex-rs/core/src/config_loader/macos.rs index d94b1930b7..977a09a9c5 100644 --- a/codex-rs/core/src/config_loader/macos.rs +++ b/codex-rs/core/src/config_loader/macos.rs @@ -1,6 +1,7 @@ use super::ConfigRequirementsToml; use super::ConfigRequirementsWithSources; use super::RequirementSource; +use super::merge_requirements_with_remote_sandbox_config; use base64::Engine; use base64::prelude::BASE64_STANDARD; use core_foundation::base::TCFType; @@ -64,6 +65,7 @@ fn load_managed_admin_config() -> io::Result> { pub(crate) async fn load_managed_admin_requirements_toml( target: &mut ConfigRequirementsWithSources, override_base64: Option<&str>, + host_name: Option<&str>, ) -> io::Result<()> { if let Some(encoded) = override_base64 { let trimmed = encoded.trim(); @@ -71,9 +73,11 @@ pub(crate) async fn load_managed_admin_requirements_toml( return Ok(()); } - target.merge_unset_fields( + merge_requirements_with_remote_sandbox_config( + target, managed_preferences_requirements_source(), parse_managed_requirements_base64(trimmed)?, + host_name, ); return Ok(()); } @@ -81,7 +85,12 @@ pub(crate) async fn load_managed_admin_requirements_toml( match task::spawn_blocking(load_managed_admin_requirements).await { Ok(result) => { if let Some(requirements) = result? { - target.merge_unset_fields(managed_preferences_requirements_source(), requirements); + merge_requirements_with_remote_sandbox_config( + target, + managed_preferences_requirements_source(), + requirements, + host_name, + ); } Ok(()) } diff --git a/codex-rs/core/src/config_loader/mod.rs b/codex-rs/core/src/config_loader/mod.rs index 436759c72e..3b08de32a2 100644 --- a/codex-rs/core/src/config_loader/mod.rs +++ b/codex-rs/core/src/config_loader/mod.rs @@ -9,6 +9,8 @@ use crate::config_loader::layer_io::LoadedConfigLayers; use codex_app_server_protocol::ConfigLayerSource; use codex_config::CONFIG_TOML_FILE; use codex_config::ConfigRequirementsWithSources; +use codex_config::ThreadConfigContext; +use codex_config::ThreadConfigLoader; use codex_config::config_toml::ConfigToml; use codex_config::config_toml::ProjectConfig; use codex_exec_server::ExecutorFileSystem; @@ -52,6 +54,7 @@ pub use codex_config::NetworkDomainPermissionsToml; pub use codex_config::NetworkRequirementsToml; pub use codex_config::NetworkUnixSocketPermissionToml; pub use codex_config::NetworkUnixSocketPermissionsToml; +pub use codex_config::RemoteSandboxConfigToml; pub use codex_config::RequirementSource; pub use codex_config::ResidencyRequirement; pub use codex_config::SandboxModeRequirement; @@ -120,6 +123,7 @@ pub(crate) async fn first_layer_config_error_from_entries( /// associated with it such that `cwd` should be `Some(...)`. Only for /// thread-agnostic config loading (e.g., for the app server's `/config` /// endpoint) should `cwd` be `None`. +#[allow(clippy::too_many_arguments)] pub async fn load_config_layers_state( fs: &dyn ExecutorFileSystem, codex_home: &Path, @@ -127,6 +131,8 @@ pub async fn load_config_layers_state( cli_overrides: &[(String, TomlValue)], overrides: LoaderOverrides, cloud_requirements: CloudRequirementsLoader, + thread_config_loader: &dyn ThreadConfigLoader, + host_name: Option<&str>, ) -> io::Result { let ignore_user_config = overrides.ignore_user_config; let ignore_user_and_project_exec_policy_rules = @@ -134,8 +140,12 @@ pub async fn load_config_layers_state( let mut config_requirements_toml = ConfigRequirementsWithSources::default(); if let Some(requirements) = cloud_requirements.get().await.map_err(io::Error::other)? { - config_requirements_toml - .merge_unset_fields(RequirementSource::CloudRequirements, requirements); + merge_requirements_with_remote_sandbox_config( + &mut config_requirements_toml, + RequirementSource::CloudRequirements, + requirements, + host_name, + ); } #[cfg(target_os = "macos")] @@ -144,12 +154,19 @@ pub async fn load_config_layers_state( overrides .macos_managed_config_requirements_base64 .as_deref(), + host_name, ) .await?; // Honor the system requirements.toml location. let requirements_toml_file = system_requirements_toml_file()?; - load_requirements_toml(fs, &mut config_requirements_toml, &requirements_toml_file).await?; + load_requirements_toml( + fs, + &mut config_requirements_toml, + &requirements_toml_file, + host_name, + ) + .await?; // Make a best-effort to support the legacy `managed_config.toml` as a // requirements specification. @@ -158,9 +175,19 @@ pub async fn load_config_layers_state( load_requirements_from_legacy_scheme( &mut config_requirements_toml, loaded_config_layers.clone(), + host_name, ) .await?; + let thread_config_context = ThreadConfigContext { + thread_id: None, + cwd: cwd.clone(), + }; + let thread_config_layers = thread_config_loader + .load_config_layers(thread_config_context) + .await + .map_err(io::Error::other)?; + let mut layers = Vec::::new(); let cli_overrides_layer = if cli_overrides.is_empty() { @@ -283,6 +310,10 @@ pub async fn load_config_layers_state( )); } + for thread_config_layer in thread_config_layers { + insert_layer_by_precedence(&mut layers, thread_config_layer); + } + // Make a best-effort to support the legacy `managed_config.toml` as a // config layer on top of everything else. For fields in // `managed_config.toml` that do not have an equivalent in @@ -332,6 +363,16 @@ pub async fn load_config_layers_state( .with_user_and_project_exec_policy_rules_ignored(ignore_user_and_project_exec_policy_rules)) } +fn insert_layer_by_precedence(layers: &mut Vec, layer: ConfigLayerEntry) { + match layers + .iter() + .position(|existing| existing.name.precedence() > layer.name.precedence()) + { + Some(index) => layers.insert(index, layer), + None => layers.push(layer), + } +} + /// Attempts to load a config.toml file from `config_toml`. /// - If the file exists and is valid TOML, passes the parsed `toml::Value` to /// `create_entry` and returns the resulting layer entry. @@ -387,6 +428,7 @@ async fn load_requirements_toml( fs: &dyn ExecutorFileSystem, config_requirements_toml: &mut ConfigRequirementsWithSources, requirements_toml_file: &AbsolutePathBuf, + host_name: Option<&str>, ) -> io::Result<()> { match fs .read_file_text(requirements_toml_file, /*sandbox*/ None) @@ -413,11 +455,13 @@ async fn load_requirements_toml( ), ) })?; - config_requirements_toml.merge_unset_fields( + merge_requirements_with_remote_sandbox_config( + config_requirements_toml, RequirementSource::SystemRequirementsToml { file: requirements_toml_file.clone(), }, requirements_config, + host_name, ); } Err(e) => { @@ -532,6 +576,7 @@ fn windows_program_data_dir_from_known_folder() -> io::Result { async fn load_requirements_from_legacy_scheme( config_requirements_toml: &mut ConfigRequirementsWithSources, loaded_config_layers: LoadedConfigLayers, + host_name: Option<&str>, ) -> io::Result<()> { // In this implementation, earlier layers cannot be overwritten by later // layers, so list managed_config_from_mdm first because it has the highest @@ -564,13 +609,27 @@ async fn load_requirements_from_legacy_scheme( ) })?; - let new_requirements_toml = ConfigRequirementsToml::from(legacy_config); - config_requirements_toml.merge_unset_fields(source, new_requirements_toml); + merge_requirements_with_remote_sandbox_config( + config_requirements_toml, + source, + ConfigRequirementsToml::from(legacy_config), + host_name, + ); } Ok(()) } +pub(super) fn merge_requirements_with_remote_sandbox_config( + target: &mut ConfigRequirementsWithSources, + source: RequirementSource, + mut requirements: ConfigRequirementsToml, + host_name: Option<&str>, +) { + requirements.apply_remote_sandbox_config(host_name); + target.merge_unset_fields(source, requirements); +} + struct ProjectTrustContext { project_root: AbsolutePathBuf, project_root_key: String, diff --git a/codex-rs/core/src/config_loader/tests.rs b/codex-rs/core/src/config_loader/tests.rs index edc642ec39..337960f1b9 100644 --- a/codex-rs/core/src/config_loader/tests.rs +++ b/codex-rs/core/src/config_loader/tests.rs @@ -15,13 +15,15 @@ use crate::config_loader::RequirementSource; use crate::config_loader::load_requirements_toml; use crate::config_loader::version_for_toml; use codex_config::CONFIG_TOML_FILE; +use codex_config::SessionThreadConfig; +use codex_config::StaticThreadConfigLoader; +use codex_config::ThreadConfigSource; use codex_config::config_toml::ConfigToml; use codex_config::config_toml::ProjectConfig; use codex_exec_server::LOCAL_FS; use codex_protocol::config_types::TrustLevel; use codex_protocol::config_types::WebSearchMode; use codex_protocol::protocol::AskForApproval; -#[cfg(target_os = "macos")] use codex_protocol::protocol::SandboxPolicy; use codex_utils_absolute_path::AbsolutePathBuf; use pretty_assertions::assert_eq; @@ -100,6 +102,8 @@ async fn returns_config_error_for_invalid_user_config_toml() { &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await .expect_err("expected error"); @@ -131,6 +135,8 @@ async fn ignore_user_config_keeps_empty_user_layer() -> std::io::Result<()> { ..Default::default() }, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -161,6 +167,8 @@ async fn ignore_rules_marks_config_stack_for_exec_policy_rule_skip() -> std::io: ..Default::default() }, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -185,6 +193,8 @@ async fn returns_config_error_for_invalid_managed_config_toml() { &[] as &[(String, TomlValue)], overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await .expect_err("expected error"); @@ -270,6 +280,8 @@ extra = true &[] as &[(String, TomlValue)], overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await .expect("load config"); @@ -303,6 +315,8 @@ async fn returns_empty_when_all_layers_missing() { &[] as &[(String, TomlValue)], overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await .expect("load layers"); @@ -354,6 +368,57 @@ async fn returns_empty_when_all_layers_missing() { } } +#[tokio::test] +async fn includes_thread_config_layers_in_stack() -> anyhow::Result<()> { + let tmp = tempdir()?; + let cwd_dir = tmp.path().join("project"); + tokio::fs::create_dir_all(&cwd_dir).await?; + let cwd = AbsolutePathBuf::from_absolute_path(&cwd_dir)?; + let layers = load_config_layers_state( + LOCAL_FS.as_ref(), + tmp.path(), + Some(cwd), + &[("features.plugins".to_string(), TomlValue::Boolean(true))], + LoaderOverrides::without_managed_config_for_tests(), + CloudRequirementsLoader::default(), + &StaticThreadConfigLoader::new(vec![ThreadConfigSource::Session(SessionThreadConfig { + features: BTreeMap::from([("plugins".to_string(), false)]), + ..Default::default() + })]), + /*host_name*/ None, + ) + .await?; + + let layer_sources = layers + .layers_high_to_low() + .into_iter() + .map(|layer| layer.name.clone()) + .collect::>(); + assert_eq!( + layer_sources, + vec![ + super::ConfigLayerSource::SessionFlags, + super::ConfigLayerSource::SessionFlags, + super::ConfigLayerSource::User { + file: AbsolutePathBuf::resolve_path_against_base(CONFIG_TOML_FILE, tmp.path()), + }, + super::ConfigLayerSource::System { + file: super::system_config_toml_file()?, + }, + ] + ); + assert_eq!( + layers + .effective_config() + .get("features") + .and_then(TomlValue::as_table) + .and_then(|features| features.get("plugins")), + Some(&TomlValue::Boolean(false)) + ); + + Ok(()) +} + #[cfg(target_os = "macos")] #[tokio::test] async fn managed_preferences_take_highest_precedence() { @@ -396,6 +461,8 @@ flag = false &[] as &[(String, TomlValue)], overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await .expect("load config"); @@ -498,6 +565,8 @@ allowed_sandbox_modes = ["read-only"] &[] as &[(String, TomlValue)], loader_overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -560,6 +629,8 @@ allowed_approval_policies = ["never"] &[] as &[(String, TomlValue)], loader_overrides, CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -601,6 +672,7 @@ personality = true LOCAL_FS.as_ref(), &mut config_requirements_toml, &requirements_file, + /*host_name*/ None, ) .await?; @@ -702,6 +774,7 @@ allowed_approval_policies = ["on-request"] allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, feature_requirements: None, mcp_servers: None, @@ -713,6 +786,8 @@ allowed_approval_policies = ["on-request"] guardian_policy_config: None, })) }), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -755,6 +830,7 @@ allowed_approval_policies = ["on-request"] allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, feature_requirements: None, mcp_servers: None, @@ -770,6 +846,7 @@ allowed_approval_policies = ["on-request"] LOCAL_FS.as_ref(), &mut config_requirements_toml, &AbsolutePathBuf::try_from(requirements_file)?, + /*host_name*/ None, ) .await?; @@ -791,6 +868,54 @@ allowed_approval_policies = ["on-request"] Ok(()) } +#[tokio::test(flavor = "current_thread")] +async fn system_remote_sandbox_config_keeps_cloud_sandbox_modes() -> anyhow::Result<()> { + let tmp = tempdir()?; + let requirements_file = tmp.path().join("requirements.toml"); + tokio::fs::write( + &requirements_file, + r#" +[[remote_sandbox_config]] +hostname_patterns = ["runner-*.ci.example.com"] +allowed_sandbox_modes = ["read-only", "workspace-write"] +"#, + ) + .await?; + + let cloud_source = RequirementSource::CloudRequirements; + let mut config_requirements_toml = ConfigRequirementsWithSources::default(); + config_requirements_toml.merge_unset_fields( + cloud_source.clone(), + toml::from_str( + r#" +allowed_sandbox_modes = ["read-only"] +"#, + )?, + ); + load_requirements_toml( + LOCAL_FS.as_ref(), + &mut config_requirements_toml, + &AbsolutePathBuf::try_from(requirements_file)?, + Some("runner-01.ci.example.com"), + ) + .await?; + let config_requirements: ConfigRequirements = config_requirements_toml.try_into()?; + + assert_eq!( + config_requirements + .sandbox_policy + .can_set(&SandboxPolicy::new_workspace_write_policy()), + Err(ConstraintError::InvalidValue { + field_name: "sandbox_mode", + candidate: "WorkspaceWrite".into(), + allowed: "[ReadOnly]".into(), + requirement_source: cloud_source, + }) + ); + + Ok(()) +} + #[tokio::test(flavor = "current_thread")] async fn load_requirements_toml_resolves_deny_read_against_parent() -> anyhow::Result<()> { let tmp = tempdir()?; @@ -812,6 +937,7 @@ deny_read = ["./sensitive", "../shared/secret.txt"] LOCAL_FS.as_ref(), &mut config_requirements_toml, &requirements_file, + /*host_name*/ None, ) .await?; @@ -866,6 +992,7 @@ deny_read = ["./sensitive/**/*.txt"] LOCAL_FS.as_ref(), &mut config_requirements_toml, &requirements_file, + /*host_name*/ None, ) .await?; @@ -911,6 +1038,7 @@ async fn load_config_layers_includes_cloud_requirements() -> anyhow::Result<()> allowed_approval_policies: Some(vec![AskForApproval::Never]), allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: None, feature_requirements: None, mcp_servers: None, @@ -931,6 +1059,8 @@ async fn load_config_layers_includes_cloud_requirements() -> anyhow::Result<()> &[] as &[(String, TomlValue)], LoaderOverrides::default(), cloud_requirements, + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -954,6 +1084,53 @@ async fn load_config_layers_includes_cloud_requirements() -> anyhow::Result<()> Ok(()) } +#[tokio::test] +async fn load_config_layers_applies_matching_remote_sandbox_config() -> anyhow::Result<()> { + let tmp = tempdir()?; + let codex_home = tmp.path().join("home"); + tokio::fs::create_dir_all(&codex_home).await?; + let cwd = AbsolutePathBuf::from_absolute_path(tmp.path())?; + + let requirements: ConfigRequirementsToml = toml::from_str( + r#" + allowed_sandbox_modes = ["read-only"] + + [[remote_sandbox_config]] + hostname_patterns = ["runner-*.ci.example.com"] + allowed_sandbox_modes = ["read-only", "workspace-write"] + "#, + )?; + let cloud_requirements = CloudRequirementsLoader::new(async move { Ok(Some(requirements)) }); + let layers = load_config_layers_state( + LOCAL_FS.as_ref(), + &codex_home, + Some(cwd), + &[] as &[(String, TomlValue)], + LoaderOverrides::default(), + cloud_requirements, + &codex_config::NoopThreadConfigLoader, + Some("runner-01.ci.example.com"), + ) + .await?; + + assert_eq!( + layers.requirements_toml().allowed_sandbox_modes, + Some(vec![ + crate::config_loader::SandboxModeRequirement::ReadOnly, + crate::config_loader::SandboxModeRequirement::WorkspaceWrite, + ]) + ); + assert!( + layers + .requirements() + .sandbox_policy + .can_set(&SandboxPolicy::new_workspace_write_policy()) + .is_ok() + ); + + Ok(()) +} + #[tokio::test] async fn load_config_layers_fails_when_cloud_requirements_loader_fails() -> anyhow::Result<()> { let tmp = tempdir()?; @@ -974,6 +1151,8 @@ async fn load_config_layers_fails_when_cloud_requirements_loader_fails() -> anyh "cloud requirements failed", )) }), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await .expect_err("cloud requirements failure should fail closed"); @@ -1021,6 +1200,8 @@ async fn project_layers_prefer_closest_cwd() -> std::io::Result<()> { &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -1166,6 +1347,8 @@ async fn project_layer_is_added_when_dot_codex_exists_without_config_toml() -> s &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -1206,6 +1389,8 @@ async fn codex_home_is_not_loaded_as_project_layer_from_home_dir() -> std::io::R &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -1263,6 +1448,8 @@ async fn codex_home_within_project_tree_is_not_double_loaded() -> std::io::Resul &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -1334,6 +1521,8 @@ async fn project_layers_disabled_when_untrusted_or_unknown() -> std::io::Result< &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; let project_layers_untrusted: Vec<_> = layers_untrusted @@ -1373,6 +1562,8 @@ async fn project_layers_disabled_when_untrusted_or_unknown() -> std::io::Result< &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; let project_layers_unknown: Vec<_> = layers_unknown @@ -1439,6 +1630,8 @@ async fn project_trust_does_not_match_configured_alias_for_canonical_cwd() -> st &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -1592,6 +1785,8 @@ async fn invalid_project_config_ignored_when_untrusted_or_unknown() -> std::io:: &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; let project_layers: Vec<_> = layers @@ -1660,6 +1855,8 @@ async fn project_layer_without_config_toml_is_disabled_when_untrusted_or_unknown &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; let project_layers: Vec<_> = layers @@ -1720,6 +1917,8 @@ async fn cli_overrides_with_relative_paths_do_not_break_trust_check() -> std::io &cli_overrides, LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; @@ -1763,6 +1962,8 @@ async fn project_root_markers_supports_alternate_markers() -> std::io::Result<() &[] as &[(String, TomlValue)], LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await?; diff --git a/codex-rs/core/src/contextual_user_message.rs b/codex-rs/core/src/context/contextual_user_message.rs similarity index 50% rename from codex-rs/core/src/contextual_user_message.rs rename to codex-rs/core/src/context/contextual_user_message.rs index 68a86cc885..aeb54d61d7 100644 --- a/codex-rs/core/src/contextual_user_message.rs +++ b/codex-rs/core/src/context/contextual_user_message.rs @@ -1,50 +1,47 @@ -use codex_instructions::AGENTS_MD_FRAGMENT; -use codex_instructions::ContextualUserFragmentDefinition; -use codex_instructions::SKILL_FRAGMENT; use codex_protocol::items::HookPromptItem; use codex_protocol::items::parse_hook_prompt_fragment; use codex_protocol::models::ContentItem; -use codex_protocol::protocol::ENVIRONMENT_CONTEXT_CLOSE_TAG; -use codex_protocol::protocol::ENVIRONMENT_CONTEXT_OPEN_TAG; -pub(crate) const USER_SHELL_COMMAND_OPEN_TAG: &str = ""; -pub(crate) const USER_SHELL_COMMAND_CLOSE_TAG: &str = ""; -pub(crate) const TURN_ABORTED_OPEN_TAG: &str = ""; -pub(crate) const TURN_ABORTED_CLOSE_TAG: &str = ""; -pub(crate) const SUBAGENT_NOTIFICATION_OPEN_TAG: &str = ""; -pub(crate) const SUBAGENT_NOTIFICATION_CLOSE_TAG: &str = ""; +use super::EnvironmentContext; +use super::FragmentRegistration; +use super::FragmentRegistrationProxy; +use super::SkillInstructions; +use super::SubagentNotification; +use super::TurnAborted; +use super::UserInstructions; +use super::UserShellCommand; -pub(crate) const ENVIRONMENT_CONTEXT_FRAGMENT: ContextualUserFragmentDefinition = - ContextualUserFragmentDefinition::new( - ENVIRONMENT_CONTEXT_OPEN_TAG, - ENVIRONMENT_CONTEXT_CLOSE_TAG, - ); -pub(crate) const USER_SHELL_COMMAND_FRAGMENT: ContextualUserFragmentDefinition = - ContextualUserFragmentDefinition::new( - USER_SHELL_COMMAND_OPEN_TAG, - USER_SHELL_COMMAND_CLOSE_TAG, - ); -pub(crate) const TURN_ABORTED_FRAGMENT: ContextualUserFragmentDefinition = - ContextualUserFragmentDefinition::new(TURN_ABORTED_OPEN_TAG, TURN_ABORTED_CLOSE_TAG); -pub(crate) const SUBAGENT_NOTIFICATION_FRAGMENT: ContextualUserFragmentDefinition = - ContextualUserFragmentDefinition::new( - SUBAGENT_NOTIFICATION_OPEN_TAG, - SUBAGENT_NOTIFICATION_CLOSE_TAG, - ); +static USER_INSTRUCTIONS_REGISTRATION: FragmentRegistrationProxy = + FragmentRegistrationProxy::new(); +static ENVIRONMENT_CONTEXT_REGISTRATION: FragmentRegistrationProxy = + FragmentRegistrationProxy::new(); +static SKILL_INSTRUCTIONS_REGISTRATION: FragmentRegistrationProxy = + FragmentRegistrationProxy::new(); +static USER_SHELL_COMMAND_REGISTRATION: FragmentRegistrationProxy = + FragmentRegistrationProxy::new(); +static TURN_ABORTED_REGISTRATION: FragmentRegistrationProxy = + FragmentRegistrationProxy::new(); +static SUBAGENT_NOTIFICATION_REGISTRATION: FragmentRegistrationProxy = + FragmentRegistrationProxy::new(); -const CONTEXTUAL_USER_FRAGMENTS: &[ContextualUserFragmentDefinition] = &[ - AGENTS_MD_FRAGMENT, - ENVIRONMENT_CONTEXT_FRAGMENT, - SKILL_FRAGMENT, - USER_SHELL_COMMAND_FRAGMENT, - TURN_ABORTED_FRAGMENT, - SUBAGENT_NOTIFICATION_FRAGMENT, +static CONTEXTUAL_USER_FRAGMENTS: &[&dyn FragmentRegistration] = &[ + &USER_INSTRUCTIONS_REGISTRATION, + &ENVIRONMENT_CONTEXT_REGISTRATION, + &SKILL_INSTRUCTIONS_REGISTRATION, + &USER_SHELL_COMMAND_REGISTRATION, + &TURN_ABORTED_REGISTRATION, + &SUBAGENT_NOTIFICATION_REGISTRATION, +]; + +static MEMORY_EXCLUDED_CONTEXTUAL_USER_FRAGMENTS: &[&dyn FragmentRegistration] = &[ + &USER_INSTRUCTIONS_REGISTRATION, + &SKILL_INSTRUCTIONS_REGISTRATION, ]; fn is_standard_contextual_user_text(text: &str) -> bool { CONTEXTUAL_USER_FRAGMENTS .iter() - .any(|definition| definition.matches_text(text)) + .any(|fragment| fragment.matches_text(text)) } /// Returns whether a contextual user fragment should be omitted from memory @@ -59,7 +56,9 @@ pub(crate) fn is_memory_excluded_contextual_user_fragment(content_item: &Content let ContentItem::InputText { text } = content_item else { return false; }; - AGENTS_MD_FRAGMENT.matches_text(text) || SKILL_FRAGMENT.matches_text(text) + MEMORY_EXCLUDED_CONTEXTUAL_USER_FRAGMENTS + .iter() + .any(|fragment| fragment.matches_text(text)) } pub(crate) fn is_contextual_user_fragment(content_item: &ContentItem) -> bool { diff --git a/codex-rs/core/src/contextual_user_message_tests.rs b/codex-rs/core/src/context/contextual_user_message_tests.rs similarity index 94% rename from codex-rs/core/src/contextual_user_message_tests.rs rename to codex-rs/core/src/context/contextual_user_message_tests.rs index 406f03c27f..d52cf27adb 100644 --- a/codex-rs/core/src/contextual_user_message_tests.rs +++ b/codex-rs/core/src/context/contextual_user_message_tests.rs @@ -1,4 +1,5 @@ use super::*; +use crate::context::ContextualUserFragment; use codex_protocol::items::HookPromptFragment; use codex_protocol::items::build_hook_prompt_message; use codex_protocol::models::ResponseItem; @@ -20,10 +21,9 @@ fn detects_agents_instructions_fragment() { #[test] fn detects_subagent_notification_fragment_case_insensitively() { - assert!( - SUBAGENT_NOTIFICATION_FRAGMENT - .matches_text("{}") - ); + assert!(SubagentNotification::matches_text( + "{}" + )); } #[test] diff --git a/codex-rs/core/src/environment_context.rs b/codex-rs/core/src/context/environment_context.rs similarity index 61% rename from codex-rs/core/src/environment_context.rs rename to codex-rs/core/src/context/environment_context.rs index 44929b8947..c676bfb9d9 100644 --- a/codex-rs/core/src/environment_context.rs +++ b/codex-rs/core/src/context/environment_context.rs @@ -1,34 +1,40 @@ -use crate::contextual_user_message::ENVIRONMENT_CONTEXT_FRAGMENT; use crate::session::turn_context::TurnContext; use crate::shell::Shell; -use codex_protocol::models::ResponseItem; use codex_protocol::protocol::TurnContextItem; use codex_protocol::protocol::TurnContextNetworkItem; -use serde::Deserialize; -use serde::Serialize; use std::path::PathBuf; -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -#[serde(rename = "environment_context", rename_all = "snake_case")] +use super::ContextualUserFragment; + +#[derive(Debug, Clone, PartialEq)] pub(crate) struct EnvironmentContext { - pub cwd: Option, - pub shell: Shell, - pub current_date: Option, - pub timezone: Option, - pub network: Option, - pub subagents: Option, + pub(crate) cwd: Option, + pub(crate) shell: String, + pub(crate) current_date: Option, + pub(crate) timezone: Option, + pub(crate) network: Option, + pub(crate) subagents: Option, } -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)] +#[derive(Debug, Clone, PartialEq, Eq, Default)] pub(crate) struct NetworkContext { allowed_domains: Vec, denied_domains: Vec, } +impl NetworkContext { + pub(crate) fn new(allowed_domains: Vec, denied_domains: Vec) -> Self { + Self { + allowed_domains, + denied_domains, + } + } +} + impl EnvironmentContext { - pub fn new( + pub(crate) fn new( cwd: Option, - shell: Shell, + shell: String, current_date: Option, timezone: Option, network: Option, @@ -47,7 +53,7 @@ impl EnvironmentContext { /// Compares two environment contexts, ignoring the shell. Useful when /// comparing turn to turn, since the initial environment_context will /// include the shell, and then it is not configurable from turn to turn. - pub fn equals_except_shell(&self, other: &EnvironmentContext) -> bool { + pub(crate) fn equals_except_shell(&self, other: &EnvironmentContext) -> bool { let EnvironmentContext { cwd, current_date, @@ -63,39 +69,34 @@ impl EnvironmentContext { && self.subagents == *subagents } - pub fn diff_from_turn_context_item( + pub(crate) fn diff_from_turn_context_item( before: &TurnContextItem, - after: &TurnContext, - shell: &Shell, + after: &EnvironmentContext, ) -> Self { let before_network = Self::network_from_turn_context_item(before); - let after_network = Self::network_from_turn_context(after); - let cwd = if before.cwd.as_path() != after.cwd.as_path() { - Some(after.cwd.to_path_buf()) - } else { - None + let cwd = match &after.cwd { + Some(cwd) if before.cwd.as_path() != cwd.as_path() => Some(cwd.clone()), + _ => None, }; - let current_date = after.current_date.clone(); - let timezone = after.timezone.clone(); - let network = if before_network != after_network { - after_network + let network = if before_network != after.network { + after.network.clone() } else { before_network }; EnvironmentContext::new( cwd, - shell.clone(), - current_date, - timezone, + after.shell.clone(), + after.current_date.clone(), + after.timezone.clone(), network, /*subagents*/ None, ) } - pub fn from_turn_context(turn_context: &TurnContext, shell: &Shell) -> Self { + pub(crate) fn from_turn_context(turn_context: &TurnContext, shell: &Shell) -> Self { Self::new( Some(turn_context.cwd.to_path_buf()), - shell.clone(), + shell.name().to_string(), turn_context.current_date.clone(), turn_context.timezone.clone(), Self::network_from_turn_context(turn_context), @@ -103,10 +104,13 @@ impl EnvironmentContext { ) } - pub fn from_turn_context_item(turn_context_item: &TurnContextItem, shell: &Shell) -> Self { + pub(crate) fn from_turn_context_item( + turn_context_item: &TurnContextItem, + shell: String, + ) -> Self { Self::new( Some(turn_context_item.cwd.clone()), - shell.clone(), + shell, turn_context_item.current_date.clone(), turn_context_item.timezone.clone(), Self::network_from_turn_context_item(turn_context_item), @@ -114,7 +118,7 @@ impl EnvironmentContext { ) } - pub fn with_subagents(mut self, subagents: String) -> Self { + pub(crate) fn with_subagents(mut self, subagents: String) -> Self { if !subagents.is_empty() { self.subagents = Some(subagents); } @@ -129,18 +133,18 @@ impl EnvironmentContext { .network .as_ref()?; - Some(NetworkContext { - allowed_domains: network + Some(NetworkContext::new( + network .domains .as_ref() .and_then(codex_config::NetworkDomainPermissionsToml::allowed_domains) .unwrap_or_default(), - denied_domains: network + network .domains .as_ref() .and_then(codex_config::NetworkDomainPermissionsToml::denied_domains) .unwrap_or_default(), - }) + )) } fn network_from_turn_context_item( @@ -150,40 +154,33 @@ impl EnvironmentContext { allowed_domains, denied_domains, } = turn_context_item.network.as_ref()?; - Some(NetworkContext { - allowed_domains: allowed_domains.clone(), - denied_domains: denied_domains.clone(), - }) + Some(NetworkContext::new( + allowed_domains.clone(), + denied_domains.clone(), + )) } } -impl EnvironmentContext { - /// Serializes the environment context to XML. Libraries like `quick-xml` - /// require custom macros to handle Enums with newtypes, so we just do it - /// manually, to keep things simple. Output looks like: - /// - /// ```xml - /// - /// ... - /// ... - /// - /// ``` - pub fn serialize_to_xml(self) -> String { +impl ContextualUserFragment for EnvironmentContext { + const ROLE: &'static str = "user"; + const START_MARKER: &'static str = codex_protocol::protocol::ENVIRONMENT_CONTEXT_OPEN_TAG; + const END_MARKER: &'static str = codex_protocol::protocol::ENVIRONMENT_CONTEXT_CLOSE_TAG; + + fn body(&self) -> String { let mut lines = Vec::new(); - if let Some(cwd) = self.cwd { + if let Some(cwd) = &self.cwd { lines.push(format!(" {}", cwd.to_string_lossy())); } - let shell_name = self.shell.name(); - lines.push(format!(" {shell_name}")); - if let Some(current_date) = self.current_date { + lines.push(format!(" {}", self.shell)); + if let Some(current_date) = &self.current_date { lines.push(format!(" {current_date}")); } - if let Some(timezone) = self.timezone { + if let Some(timezone) = &self.timezone { lines.push(format!(" {timezone}")); } - match self.network { - Some(ref network) => { + match &self.network { + Some(network) => { lines.push(" ".to_string()); for allowed in &network.allowed_domains { lines.push(format!(" {allowed}")); @@ -198,18 +195,12 @@ impl EnvironmentContext { // lines.push(" ".to_string()); } } - if let Some(subagents) = self.subagents { + if let Some(subagents) = &self.subagents { lines.push(" ".to_string()); lines.extend(subagents.lines().map(|line| format!(" {line}"))); lines.push(" ".to_string()); } - ENVIRONMENT_CONTEXT_FRAGMENT.wrap(lines.join("\n")) - } -} - -impl From for ResponseItem { - fn from(ec: EnvironmentContext) -> Self { - ENVIRONMENT_CONTEXT_FRAGMENT.into_message(ec.serialize_to_xml()) + format!("\n{}", lines.join("\n")) } } diff --git a/codex-rs/core/src/environment_context_tests.rs b/codex-rs/core/src/context/environment_context_tests.rs similarity index 56% rename from codex-rs/core/src/environment_context_tests.rs rename to codex-rs/core/src/context/environment_context_tests.rs index 073f1fe169..84f8c0d99f 100644 --- a/codex-rs/core/src/environment_context_tests.rs +++ b/codex-rs/core/src/context/environment_context_tests.rs @@ -3,13 +3,15 @@ use crate::shell::ShellType; use super::*; use core_test_support::test_path_buf; use pretty_assertions::assert_eq; +use std::path::PathBuf; -fn fake_shell() -> Shell { - Shell { +fn fake_shell_name() -> String { + let shell = crate::shell::Shell { shell_type: ShellType::Bash, shell_path: PathBuf::from("/bin/bash"), shell_snapshot: crate::shell::empty_shell_snapshot_receiver(), - } + }; + shell.name().to_string() } #[test] @@ -17,7 +19,7 @@ fn serialize_workspace_write_environment_context() { let cwd = test_path_buf("/repo"); let context = EnvironmentContext::new( Some(cwd.clone()), - fake_shell(), + fake_shell_name(), Some("2026-02-26".to_string()), Some("America/Los_Angeles".to_string()), /*network*/ None, @@ -34,18 +36,18 @@ fn serialize_workspace_write_environment_context() { cwd = cwd.display(), ); - assert_eq!(context.serialize_to_xml(), expected); + assert_eq!(context.render(), expected); } #[test] fn serialize_environment_context_with_network() { - let network = NetworkContext { - allowed_domains: vec!["api.example.com".to_string(), "*.openai.com".to_string()], - denied_domains: vec!["blocked.example.com".to_string()], - }; + let network = NetworkContext::new( + vec!["api.example.com".to_string(), "*.openai.com".to_string()], + vec!["blocked.example.com".to_string()], + ); let context = EnvironmentContext::new( Some(test_path_buf("/repo")), - fake_shell(), + fake_shell_name(), Some("2026-02-26".to_string()), Some("America/Los_Angeles".to_string()), Some(network), @@ -67,14 +69,14 @@ fn serialize_environment_context_with_network() { test_path_buf("/repo").display() ); - assert_eq!(context.serialize_to_xml(), expected); + assert_eq!(context.render(), expected); } #[test] fn serialize_read_only_environment_context() { let context = EnvironmentContext::new( /*cwd*/ None, - fake_shell(), + fake_shell_name(), Some("2026-02-26".to_string()), Some("America/Los_Angeles".to_string()), /*network*/ None, @@ -87,74 +89,14 @@ fn serialize_read_only_environment_context() { America/Los_Angeles "#; - assert_eq!(context.serialize_to_xml(), expected); -} - -#[test] -fn serialize_external_sandbox_environment_context() { - let context = EnvironmentContext::new( - /*cwd*/ None, - fake_shell(), - Some("2026-02-26".to_string()), - Some("America/Los_Angeles".to_string()), - /*network*/ None, - /*subagents*/ None, - ); - - let expected = r#" - bash - 2026-02-26 - America/Los_Angeles -"#; - - assert_eq!(context.serialize_to_xml(), expected); -} - -#[test] -fn serialize_external_sandbox_with_restricted_network_environment_context() { - let context = EnvironmentContext::new( - /*cwd*/ None, - fake_shell(), - Some("2026-02-26".to_string()), - Some("America/Los_Angeles".to_string()), - /*network*/ None, - /*subagents*/ None, - ); - - let expected = r#" - bash - 2026-02-26 - America/Los_Angeles -"#; - - assert_eq!(context.serialize_to_xml(), expected); -} - -#[test] -fn serialize_full_access_environment_context() { - let context = EnvironmentContext::new( - /*cwd*/ None, - fake_shell(), - Some("2026-02-26".to_string()), - Some("America/Los_Angeles".to_string()), - /*network*/ None, - /*subagents*/ None, - ); - - let expected = r#" - bash - 2026-02-26 - America/Los_Angeles -"#; - - assert_eq!(context.serialize_to_xml(), expected); + assert_eq!(context.render(), expected); } #[test] fn equals_except_shell_compares_cwd() { let context1 = EnvironmentContext::new( Some(PathBuf::from("/repo")), - fake_shell(), + fake_shell_name(), /*current_date*/ None, /*timezone*/ None, /*network*/ None, @@ -162,7 +104,7 @@ fn equals_except_shell_compares_cwd() { ); let context2 = EnvironmentContext::new( Some(PathBuf::from("/repo")), - fake_shell(), + fake_shell_name(), /*current_date*/ None, /*timezone*/ None, /*network*/ None, @@ -171,33 +113,11 @@ fn equals_except_shell_compares_cwd() { assert!(context1.equals_except_shell(&context2)); } -#[test] -fn equals_except_shell_ignores_sandbox_policy() { - let context1 = EnvironmentContext::new( - Some(PathBuf::from("/repo")), - fake_shell(), - /*current_date*/ None, - /*timezone*/ None, - /*network*/ None, - /*subagents*/ None, - ); - let context2 = EnvironmentContext::new( - Some(PathBuf::from("/repo")), - fake_shell(), - /*current_date*/ None, - /*timezone*/ None, - /*network*/ None, - /*subagents*/ None, - ); - - assert!(context1.equals_except_shell(&context2)); -} - #[test] fn equals_except_shell_compares_cwd_differences() { let context1 = EnvironmentContext::new( Some(PathBuf::from("/repo1")), - fake_shell(), + fake_shell_name(), /*current_date*/ None, /*timezone*/ None, /*network*/ None, @@ -205,7 +125,7 @@ fn equals_except_shell_compares_cwd_differences() { ); let context2 = EnvironmentContext::new( Some(PathBuf::from("/repo2")), - fake_shell(), + fake_shell_name(), /*current_date*/ None, /*timezone*/ None, /*network*/ None, @@ -219,11 +139,7 @@ fn equals_except_shell_compares_cwd_differences() { fn equals_except_shell_ignores_shell() { let context1 = EnvironmentContext::new( Some(PathBuf::from("/repo")), - Shell { - shell_type: ShellType::Bash, - shell_path: "/bin/bash".into(), - shell_snapshot: crate::shell::empty_shell_snapshot_receiver(), - }, + "bash".to_string(), /*current_date*/ None, /*timezone*/ None, /*network*/ None, @@ -231,11 +147,7 @@ fn equals_except_shell_ignores_shell() { ); let context2 = EnvironmentContext::new( Some(PathBuf::from("/repo")), - Shell { - shell_type: ShellType::Zsh, - shell_path: "/bin/zsh".into(), - shell_snapshot: crate::shell::empty_shell_snapshot_receiver(), - }, + "zsh".to_string(), /*current_date*/ None, /*timezone*/ None, /*network*/ None, @@ -249,7 +161,7 @@ fn equals_except_shell_ignores_shell() { fn serialize_environment_context_with_subagents() { let context = EnvironmentContext::new( Some(test_path_buf("/repo")), - fake_shell(), + fake_shell_name(), Some("2026-02-26".to_string()), Some("America/Los_Angeles".to_string()), /*network*/ None, @@ -270,5 +182,5 @@ fn serialize_environment_context_with_subagents() { test_path_buf("/repo").display() ); - assert_eq!(context.serialize_to_xml(), expected); + assert_eq!(context.render(), expected); } diff --git a/codex-rs/core/src/context/fragment.rs b/codex-rs/core/src/context/fragment.rs new file mode 100644 index 0000000000..e0e6d03303 --- /dev/null +++ b/codex-rs/core/src/context/fragment.rs @@ -0,0 +1,82 @@ +use codex_protocol::models::ContentItem; +use codex_protocol::models::ResponseItem; +use std::marker::PhantomData; + +/// Type-erased registration for a contextual user fragment. +/// +/// Implementations are used by context filtering code to recognize injected +/// fragments without constructing the concrete context payload. +pub(crate) trait FragmentRegistration: Sync { + fn matches_text(&self, text: &str) -> bool; +} + +pub(crate) struct FragmentRegistrationProxy { + _marker: PhantomData T>, +} + +impl FragmentRegistrationProxy { + pub(crate) const fn new() -> Self { + Self { + _marker: PhantomData, + } + } +} + +impl FragmentRegistration for FragmentRegistrationProxy { + fn matches_text(&self, text: &str) -> bool { + T::matches_text(text) + } +} + +/// Context payload that is injected as a user-authored message fragment. +/// +/// Implementations own the response role, start/end markers used to recognize +/// the fragment, and provide the fragment body appended directly after the +/// start marker. The default helpers wrap that body and convert it into the +/// response item shape expected by model input assembly. +pub(crate) trait ContextualUserFragment { + const ROLE: &'static str; + const START_MARKER: &'static str; + const END_MARKER: &'static str; + + fn body(&self) -> String; + + fn matches_text(text: &str) -> bool + where + Self: Sized, + { + let trimmed = text.trim_start(); + let starts_with_marker = trimmed + .get(..Self::START_MARKER.len()) + .is_some_and(|candidate| candidate.eq_ignore_ascii_case(Self::START_MARKER)); + let trimmed = trimmed.trim_end(); + let ends_with_marker = trimmed + .get(trimmed.len().saturating_sub(Self::END_MARKER.len())..) + .is_some_and(|candidate| candidate.eq_ignore_ascii_case(Self::END_MARKER)); + starts_with_marker && ends_with_marker + } + + fn render(&self) -> String { + format!( + "{}{}\n{}", + Self::START_MARKER, + self.body(), + Self::END_MARKER + ) + } + + fn into(self) -> ResponseItem + where + Self: Sized, + { + ResponseItem::Message { + id: None, + role: Self::ROLE.to_string(), + content: vec![ContentItem::InputText { + text: self.render(), + }], + end_turn: None, + phase: None, + } + } +} diff --git a/codex-rs/core/src/context/mod.rs b/codex-rs/core/src/context/mod.rs new file mode 100644 index 0000000000..94c5849f9d --- /dev/null +++ b/codex-rs/core/src/context/mod.rs @@ -0,0 +1,21 @@ +mod contextual_user_message; +mod environment_context; +mod fragment; +mod skill_instructions; +mod subagent_notification; +mod turn_aborted; +mod user_instructions; +mod user_shell_command; + +pub(crate) use contextual_user_message::is_contextual_user_fragment; +pub(crate) use contextual_user_message::is_memory_excluded_contextual_user_fragment; +pub(crate) use contextual_user_message::parse_visible_hook_prompt_message; +pub(crate) use environment_context::EnvironmentContext; +pub(crate) use fragment::ContextualUserFragment; +pub(crate) use fragment::FragmentRegistration; +pub(crate) use fragment::FragmentRegistrationProxy; +pub(crate) use skill_instructions::SkillInstructions; +pub(crate) use subagent_notification::SubagentNotification; +pub(crate) use turn_aborted::TurnAborted; +pub(crate) use user_instructions::UserInstructions; +pub(crate) use user_shell_command::UserShellCommand; diff --git a/codex-rs/core/src/context/skill_instructions.rs b/codex-rs/core/src/context/skill_instructions.rs new file mode 100644 index 0000000000..90271b807e --- /dev/null +++ b/codex-rs/core/src/context/skill_instructions.rs @@ -0,0 +1,33 @@ +use codex_core_skills::injection::SkillInjection; + +use super::ContextualUserFragment; + +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct SkillInstructions { + pub(crate) name: String, + pub(crate) path: String, + pub(crate) contents: String, +} + +impl From<&SkillInjection> for SkillInstructions { + fn from(skill: &SkillInjection) -> Self { + Self { + name: skill.name.clone(), + path: skill.path.clone(), + contents: skill.contents.clone(), + } + } +} + +impl ContextualUserFragment for SkillInstructions { + const ROLE: &'static str = "user"; + const START_MARKER: &'static str = ""; + const END_MARKER: &'static str = ""; + + fn body(&self) -> String { + format!( + "\n{}\n{}\n{}", + self.name, self.path, self.contents + ) + } +} diff --git a/codex-rs/core/src/context/subagent_notification.rs b/codex-rs/core/src/context/subagent_notification.rs new file mode 100644 index 0000000000..16f7fb4747 --- /dev/null +++ b/codex-rs/core/src/context/subagent_notification.rs @@ -0,0 +1,34 @@ +use codex_protocol::protocol::AgentStatus; + +use super::ContextualUserFragment; + +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct SubagentNotification { + pub(crate) agent_reference: String, + pub(crate) status: AgentStatus, +} + +impl SubagentNotification { + pub(crate) fn new(agent_reference: impl Into, status: AgentStatus) -> Self { + Self { + agent_reference: agent_reference.into(), + status, + } + } +} + +impl ContextualUserFragment for SubagentNotification { + const ROLE: &'static str = "user"; + const START_MARKER: &'static str = ""; + const END_MARKER: &'static str = ""; + + fn body(&self) -> String { + format!( + "\n{}", + serde_json::json!({ + "agent_path": &self.agent_reference, + "status": &self.status, + }) + ) + } +} diff --git a/codex-rs/core/src/context/turn_aborted.rs b/codex-rs/core/src/context/turn_aborted.rs new file mode 100644 index 0000000000..69620c0042 --- /dev/null +++ b/codex-rs/core/src/context/turn_aborted.rs @@ -0,0 +1,26 @@ +use super::ContextualUserFragment; + +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct TurnAborted { + pub(crate) guidance: String, +} + +impl TurnAborted { + pub(crate) const INTERRUPTED_GUIDANCE: &'static str = "The user interrupted the previous turn on purpose. Any running unified exec processes may still be running in the background. If any tools/commands were aborted, they may have partially executed."; + + pub(crate) fn new(guidance: impl Into) -> Self { + Self { + guidance: guidance.into(), + } + } +} + +impl ContextualUserFragment for TurnAborted { + const ROLE: &'static str = "user"; + const START_MARKER: &'static str = ""; + const END_MARKER: &'static str = ""; + + fn body(&self) -> String { + format!("\n{}", self.guidance) + } +} diff --git a/codex-rs/core/src/context/user_instructions.rs b/codex-rs/core/src/context/user_instructions.rs new file mode 100644 index 0000000000..97efc4f45c --- /dev/null +++ b/codex-rs/core/src/context/user_instructions.rs @@ -0,0 +1,17 @@ +use super::ContextualUserFragment; + +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct UserInstructions { + pub(crate) directory: String, + pub(crate) text: String, +} + +impl ContextualUserFragment for UserInstructions { + const ROLE: &'static str = "user"; + const START_MARKER: &'static str = "# AGENTS.md instructions for "; + const END_MARKER: &'static str = ""; + + fn body(&self) -> String { + format!("{}\n\n\n{}", self.directory, self.text) + } +} diff --git a/codex-rs/core/src/context/user_shell_command.rs b/codex-rs/core/src/context/user_shell_command.rs new file mode 100644 index 0000000000..8bbbb952d8 --- /dev/null +++ b/codex-rs/core/src/context/user_shell_command.rs @@ -0,0 +1,40 @@ +use std::time::Duration; + +use super::ContextualUserFragment; + +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct UserShellCommand { + pub(crate) command: String, + pub(crate) exit_code: i32, + pub(crate) duration_seconds: f64, + pub(crate) output: String, +} + +impl UserShellCommand { + pub(crate) fn new( + command: impl Into, + exit_code: i32, + duration: Duration, + output: impl Into, + ) -> Self { + Self { + command: command.into(), + exit_code, + duration_seconds: duration.as_secs_f64(), + output: output.into(), + } + } +} + +impl ContextualUserFragment for UserShellCommand { + const ROLE: &'static str = "user"; + const START_MARKER: &'static str = ""; + const END_MARKER: &'static str = ""; + + fn body(&self) -> String { + format!( + "\n\n{}\n\n\nExit code: {}\nDuration: {:.4} seconds\nOutput:\n{}\n", + self.command, self.exit_code, self.duration_seconds, self.output, + ) + } +} diff --git a/codex-rs/core/src/context_manager/updates.rs b/codex-rs/core/src/context_manager/updates.rs index 5ced481530..a3ccf49f83 100644 --- a/codex-rs/core/src/context_manager/updates.rs +++ b/codex-rs/core/src/context_manager/updates.rs @@ -1,4 +1,5 @@ -use crate::environment_context::EnvironmentContext; +use crate::context::ContextualUserFragment; +use crate::context::EnvironmentContext; use crate::session::PreviousTurnSettings; use crate::session::turn_context::TurnContext; use crate::shell::Shell; @@ -21,14 +22,14 @@ fn build_environment_update_item( } let prev = previous?; - let prev_context = EnvironmentContext::from_turn_context_item(prev, shell); + let prev_context = EnvironmentContext::from_turn_context_item(prev, shell.name().to_string()); let next_context = EnvironmentContext::from_turn_context(next, shell); if prev_context.equals_except_shell(&next_context) { return None; } - Some(ResponseItem::from( - EnvironmentContext::diff_from_turn_context_item(prev, next, shell), + Some(ContextualUserFragment::into( + EnvironmentContext::diff_from_turn_context_item(prev, &next_context), )) } diff --git a/codex-rs/core/src/event_mapping.rs b/codex-rs/core/src/event_mapping.rs index 21e13f6c15..e7c79e6dd2 100644 --- a/codex-rs/core/src/event_mapping.rs +++ b/codex-rs/core/src/event_mapping.rs @@ -20,8 +20,8 @@ use codex_protocol::user_input::UserInput; use tracing::warn; use uuid::Uuid; -use crate::contextual_user_message::is_contextual_user_fragment; -use crate::contextual_user_message::parse_visible_hook_prompt_message; +use crate::context::is_contextual_user_fragment; +use crate::context::parse_visible_hook_prompt_message; use crate::web_search::web_search_action_detail; const CONTEXTUAL_DEVELOPER_PREFIXES: &[&str] = &[ diff --git a/codex-rs/core/src/guardian/approval_request.rs b/codex-rs/core/src/guardian/approval_request.rs index 6d1d3f76af..7478377381 100644 --- a/codex-rs/core/src/guardian/approval_request.rs +++ b/codex-rs/core/src/guardian/approval_request.rs @@ -4,6 +4,7 @@ use codex_protocol::approvals::GuardianAssessmentAction; use codex_protocol::approvals::GuardianCommandSource; use codex_protocol::approvals::NetworkApprovalProtocol; use codex_protocol::models::PermissionProfile; +use codex_protocol::request_permissions::RequestPermissionProfile; use codex_utils_absolute_path::AbsolutePathBuf; use serde::Serialize; use serde_json::Value; @@ -65,6 +66,12 @@ pub(crate) enum GuardianApprovalRequest { tool_description: Option, annotations: Option, }, + RequestPermissions { + id: String, + turn_id: String, + reason: Option, + permissions: RequestPermissionProfile, + }, } #[derive(Debug, Clone, PartialEq, Eq, Serialize)] @@ -123,6 +130,15 @@ struct McpToolCallApprovalAction<'a> { annotations: Option<&'a GuardianMcpAnnotations>, } +#[derive(Serialize)] +struct RequestPermissionsApprovalAction<'a> { + tool: &'static str, + turn_id: &'a str, + #[serde(skip_serializing_if = "Option::is_none")] + reason: Option<&'a String>, + permissions: &'a RequestPermissionProfile, +} + fn serialize_guardian_action(value: impl Serialize) -> serde_json::Result { serde_json::to_value(value) } @@ -293,6 +309,17 @@ pub(crate) fn guardian_approval_request_to_json( tool_description: tool_description.as_ref(), annotations: annotations.as_ref(), }), + GuardianApprovalRequest::RequestPermissions { + id: _, + turn_id, + reason, + permissions, + } => serialize_guardian_action(RequestPermissionsApprovalAction { + tool: "request_permissions", + turn_id, + reason: reason.as_ref(), + permissions, + }), } } @@ -352,6 +379,14 @@ pub(crate) fn guardian_assessment_action( connector_name: connector_name.clone(), tool_title: tool_title.clone(), }, + GuardianApprovalRequest::RequestPermissions { + reason, + permissions, + .. + } => GuardianAssessmentAction::RequestPermissions { + reason: reason.clone(), + permissions: permissions.clone(), + }, } } @@ -360,7 +395,8 @@ pub(crate) fn guardian_request_target_item_id(request: &GuardianApprovalRequest) GuardianApprovalRequest::Shell { id, .. } | GuardianApprovalRequest::ExecCommand { id, .. } | GuardianApprovalRequest::ApplyPatch { id, .. } - | GuardianApprovalRequest::McpToolCall { id, .. } => Some(id), + | GuardianApprovalRequest::McpToolCall { id, .. } + | GuardianApprovalRequest::RequestPermissions { id, .. } => Some(id), GuardianApprovalRequest::NetworkAccess { .. } => None, #[cfg(unix)] GuardianApprovalRequest::Execve { id, .. } => Some(id), @@ -372,7 +408,8 @@ pub(crate) fn guardian_request_turn_id<'a>( default_turn_id: &'a str, ) -> &'a str { match request { - GuardianApprovalRequest::NetworkAccess { turn_id, .. } => turn_id, + GuardianApprovalRequest::NetworkAccess { turn_id, .. } + | GuardianApprovalRequest::RequestPermissions { turn_id, .. } => turn_id, GuardianApprovalRequest::Shell { .. } | GuardianApprovalRequest::ExecCommand { .. } | GuardianApprovalRequest::ApplyPatch { .. } diff --git a/codex-rs/core/src/guardian/mod.rs b/codex-rs/core/src/guardian/mod.rs index f31f21344c..db0b7eec38 100644 --- a/codex-rs/core/src/guardian/mod.rs +++ b/codex-rs/core/src/guardian/mod.rs @@ -31,8 +31,10 @@ pub(crate) use review::guardian_timeout_message; pub(crate) use review::is_guardian_reviewer_source; pub(crate) use review::new_guardian_review_id; pub(crate) use review::review_approval_request; +#[cfg(test)] pub(crate) use review::review_approval_request_with_cancel; pub(crate) use review::routes_approval_to_guardian; +pub(crate) use review::spawn_approval_request_review; pub(crate) use review_session::GuardianReviewSessionManager; const GUARDIAN_PREFERRED_MODEL: &str = "codex-auto-review"; diff --git a/codex-rs/core/src/guardian/review.rs b/codex-rs/core/src/guardian/review.rs index ea52114a09..486c079f31 100644 --- a/codex-rs/core/src/guardian/review.rs +++ b/codex-rs/core/src/guardian/review.rs @@ -11,6 +11,7 @@ use codex_protocol::protocol::GuardianUserAuthorization; use codex_protocol::protocol::ReviewDecision; use codex_protocol::protocol::SubAgentSource; use codex_protocol::protocol::WarningEvent; +use tokio::sync::oneshot; use tokio_util::sync::CancellationToken; use crate::session::session::Session; @@ -89,12 +90,14 @@ fn guardian_risk_level_str(level: GuardianRiskLevel) -> &'static str { } } -/// Whether this turn should route `on-request` approval prompts through the -/// guardian reviewer instead of surfacing them to the user. ARC may still -/// block actions earlier in the flow. +/// Whether this turn should route allowed approval prompts through the guardian +/// reviewer instead of surfacing them to the user. ARC may still block actions +/// earlier in the flow. pub(crate) fn routes_approval_to_guardian(turn: &TurnContext) -> bool { - turn.approval_policy.value() == AskForApproval::OnRequest - && turn.config.approvals_reviewer == ApprovalsReviewer::GuardianSubagent + matches!( + turn.approval_policy.value(), + AskForApproval::OnRequest | AskForApproval::Granular(_) + ) && turn.config.approvals_reviewer == ApprovalsReviewer::GuardianSubagent } pub(crate) fn is_guardian_reviewer_source( @@ -335,6 +338,36 @@ pub(crate) async fn review_approval_request_with_cancel( .await } +pub(crate) fn spawn_approval_request_review( + session: Arc, + turn: Arc, + review_id: String, + request: GuardianApprovalRequest, + retry_reason: Option, + cancel_token: CancellationToken, +) -> oneshot::Receiver { + let (tx, rx) = oneshot::channel(); + std::thread::spawn(move || { + let Ok(runtime) = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + else { + let _ = tx.send(ReviewDecision::Denied); + return; + }; + let decision = runtime.block_on(review_approval_request_with_cancel( + &session, + &turn, + review_id, + request, + retry_reason, + cancel_token, + )); + let _ = tx.send(decision); + }); + rx +} + /// Runs the guardian in a locked-down reusable review session. /// /// The guardian itself should not mutate state or trigger further approvals, so diff --git a/codex-rs/core/src/guardian/review_session.rs b/codex-rs/core/src/guardian/review_session.rs index 5bb3e9d1b8..5754d090b4 100644 --- a/codex-rs/core/src/guardian/review_session.rs +++ b/codex-rs/core/src/guardian/review_session.rs @@ -265,6 +265,10 @@ impl GuardianReviewSessionManager { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "review session selection and trunk spawning must stay serialized" + )] pub(crate) async fn run_review( &self, params: GuardianReviewSessionParams, @@ -770,8 +774,8 @@ pub(crate) fn build_guardian_review_session_config( ) })?; if guardian_config.features.enabled(feature) { - anyhow::bail!( - "guardian review session requires `features.{}` to be disabled", + warn!( + "guardian review session could not disable `features.{}`; continuing with the feature enabled", feature.key() ); } diff --git a/codex-rs/core/src/guardian/tests.rs b/codex-rs/core/src/guardian/tests.rs index 098e0f047a..d1ec5ae889 100644 --- a/codex-rs/core/src/guardian/tests.rs +++ b/codex-rs/core/src/guardian/tests.rs @@ -28,6 +28,7 @@ use codex_protocol::models::ContentItem; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::EventMsg; +use codex_protocol::protocol::GranularApprovalConfig; use codex_protocol::protocol::GuardianAssessmentStatus; use codex_protocol::protocol::GuardianRiskLevel; use codex_protocol::protocol::GuardianUserAuthorization; @@ -741,7 +742,7 @@ fn guardian_timeout_message_distinguishes_timeout_from_policy_denial() { } #[tokio::test] -async fn routes_approval_to_guardian_requires_auto_only_review_policy() { +async fn routes_approval_to_guardian_requires_guardian_reviewer() { let (_session, mut turn) = crate::session::tests::make_session_and_context().await; let mut config = (*turn.config).clone(); config.approvals_reviewer = ApprovalsReviewer::User; @@ -755,6 +756,25 @@ async fn routes_approval_to_guardian_requires_auto_only_review_policy() { assert!(routes_approval_to_guardian(&turn)); } +#[tokio::test] +async fn routes_approval_to_guardian_allows_granular_review_policy() { + let (_session, mut turn) = crate::session::tests::make_session_and_context().await; + let mut config = (*turn.config).clone(); + config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; + turn.config = Arc::new(config); + turn.approval_policy + .set(AskForApproval::Granular(GranularApprovalConfig { + sandbox_approval: true, + rules: true, + skill_approval: true, + request_permissions: true, + mcp_elicitations: true, + })) + .expect("test setup should allow updating approval policy"); + + assert!(routes_approval_to_guardian(&turn)); +} + #[test] fn build_guardian_transcript_reserves_separate_budget_for_tool_evidence() { let repeated = "signal ".repeat(8_000); @@ -1721,7 +1741,7 @@ async fn guardian_review_session_config_disables_mcp_apps_and_plugins() { } #[tokio::test] -async fn guardian_review_session_config_rejects_pinned_collab_feature() { +async fn guardian_review_session_config_allows_pinned_disabled_feature() { let mut parent_config = test_config().await; parent_config.features = ManagedFeatures::from_configured( parent_config.features.get().clone(), @@ -1734,18 +1754,17 @@ async fn guardian_review_session_config_rejects_pinned_collab_feature() { ) .expect("managed features"); - let err = build_guardian_review_session_config_for_test( + let guardian_config = build_guardian_review_session_config_for_test( &parent_config, /*live_network_config*/ None, "active-model", /*reasoning_effort*/ None, ) - .expect_err("guardian config should fail when collab is pinned on"); + .expect("guardian config should continue when a disabled feature is pinned on"); - assert!( - err.to_string() - .contains("guardian review session requires `features.multi_agent` to be disabled") - ); + assert!(guardian_config.features.enabled(Feature::Collab)); + assert!(guardian_config.mcp_servers.get().is_empty()); + assert!(!guardian_config.include_apps_instructions); } #[tokio::test] diff --git a/codex-rs/core/src/instructions/mod.rs b/codex-rs/core/src/instructions/mod.rs deleted file mode 100644 index a1f77ba5e8..0000000000 --- a/codex-rs/core/src/instructions/mod.rs +++ /dev/null @@ -1 +0,0 @@ -pub(crate) use codex_instructions::UserInstructions; diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rs index 1809789a8e..fc96aceaf9 100644 --- a/codex-rs/core/src/lib.rs +++ b/codex-rs/core/src/lib.rs @@ -27,9 +27,8 @@ mod commit_attribution; pub mod config; pub mod config_loader; pub mod connectors; +mod context; mod context_manager; -mod contextual_user_message; -mod environment_context; pub mod exec; pub mod exec_env; mod exec_policy; @@ -41,7 +40,6 @@ mod git_info_tests; mod guardian; mod hook_runtime; mod installation_id; -pub(crate) mod instructions; pub(crate) mod landlock; pub use landlock::spawn_command_under_linux_sandbox; pub(crate) mod mcp; diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rs index 32c7cf879e..c5d4068d27 100644 --- a/codex-rs/core/src/mcp_tool_call.rs +++ b/codex-rs/core/src/mcp_tool_call.rs @@ -494,6 +494,10 @@ async fn execute_mcp_tool_call( ) } +#[expect( + clippy::await_holding_invalid_type, + reason = "MCP sandbox metadata reads through the session-owned manager guard" +)] async fn augment_mcp_tool_request_meta_with_sandbox_state( sess: &Session, turn_context: &TurnContext, @@ -1067,6 +1071,10 @@ fn mcp_tool_approval_callsite_mode( } } +#[expect( + clippy::await_holding_invalid_type, + reason = "MCP approval metadata reads through the session-owned manager guard" +)] pub(crate) async fn lookup_mcp_tool_metadata( sess: &Session, turn_context: &TurnContext, @@ -1149,6 +1157,10 @@ fn get_mcp_app_resource_uri( }) } +#[expect( + clippy::await_holding_invalid_type, + reason = "MCP app metadata reads through the session-owned manager guard" +)] async fn lookup_mcp_app_usage_metadata( sess: &Session, server: &str, diff --git a/codex-rs/core/src/memories/phase1.rs b/codex-rs/core/src/memories/phase1.rs index 9d46374f68..4f19caa5c5 100644 --- a/codex-rs/core/src/memories/phase1.rs +++ b/codex-rs/core/src/memories/phase1.rs @@ -1,7 +1,7 @@ use crate::Prompt; use crate::RolloutRecorder; use crate::config::Config; -use crate::contextual_user_message::is_memory_excluded_contextual_user_fragment; +use crate::context::is_memory_excluded_contextual_user_fragment; use crate::memories::metrics; use crate::memories::phase_one; use crate::memories::phase_one::PRUNE_BATCH_SIZE; diff --git a/codex-rs/core/src/network_proxy_loader.rs b/codex-rs/core/src/network_proxy_loader.rs index af4280bfb4..78428fabf3 100644 --- a/codex-rs/core/src/network_proxy_loader.rs +++ b/codex-rs/core/src/network_proxy_loader.rs @@ -53,6 +53,8 @@ async fn build_config_state_with_mtimes() -> Result<(ConfigState, Vec { writer - .send_conversation_handoff_append(handoff_id, output_text) + .send_conversation_function_call_output(handoff_id, output_text) .await } }, @@ -1129,7 +1129,7 @@ async fn handle_handoff_output( output_text: _, } => { if let Err(err) = writer - .send_conversation_handoff_append( + .send_conversation_function_call_output( handoff_id, REALTIME_V2_HANDOFF_COMPLETE_ACKNOWLEDGEMENT.to_string(), ) @@ -1263,7 +1263,7 @@ async fn handle_realtime_server_event( match active_handoff { Some(_) => { if let Err(err) = writer - .send_conversation_handoff_append( + .send_conversation_function_call_output( handoff.handoff_id.clone(), REALTIME_V2_STEER_ACKNOWLEDGEMENT.to_string(), ) @@ -1292,6 +1292,27 @@ async fn handle_realtime_server_event( } false } + RealtimeEvent::NoopRequested(noop) => { + *output_audio_state = None; + + match session_kind { + RealtimeSessionKind::V1 => {} + RealtimeSessionKind::V2 => { + if let Err(err) = writer + .send_conversation_function_call_output(noop.call_id.clone(), String::new()) + .await + { + let mapped_error = map_api_error(err); + warn!("failed to send realtime noop function output: {mapped_error}"); + let _ = events_tx + .send(RealtimeEvent::Error(mapped_error.to_string())) + .await; + return Err(mapped_error.into()); + } + } + } + false + } RealtimeEvent::Error(_) => true, RealtimeEvent::SessionUpdated { session_id, .. } => { info!(realtime_session_id = %session_id, "realtime session updated"); diff --git a/codex-rs/core/src/session/handlers.rs b/codex-rs/core/src/session/handlers.rs index b45b6fc10e..71efd23326 100644 --- a/codex-rs/core/src/session/handlers.rs +++ b/codex-rs/core/src/session/handlers.rs @@ -468,6 +468,10 @@ pub async fn reload_user_config(sess: &Arc) { sess.reload_user_config_layer().await; } +#[expect( + clippy::await_holding_invalid_type, + reason = "MCP tool listing reads through the session-owned manager guard" +)] pub async fn list_mcp_tools(sess: &Session, config: &Arc, sub_id: String) { let mcp_connection_manager = sess.services.mcp_connection_manager.read().await; let auth = sess.services.auth_manager.auth().await; @@ -545,6 +549,8 @@ pub async fn list_skills(sess: &Session, sub_id: String, cwds: Vec, for empty_cli_overrides, LoaderOverrides::default(), CloudRequirementsLoader::default(), + &codex_config::NoopThreadConfigLoader, + /*host_name*/ None, ) .await { diff --git a/codex-rs/core/src/session/mcp.rs b/codex-rs/core/src/session/mcp.rs index d15ca2cae8..be7504d9e7 100644 --- a/codex-rs/core/src/session/mcp.rs +++ b/codex-rs/core/src/session/mcp.rs @@ -1,6 +1,10 @@ use super::*; impl Session { + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn request_mcp_server_elicitation( &self, turn_context: &TurnContext, @@ -80,6 +84,10 @@ impl Session { rx_response.await.ok() } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and manager fallback must stay serialized" + )] pub async fn resolve_elicitation( &self, server_name: String, @@ -111,6 +119,10 @@ impl Session { .await } + #[expect( + clippy::await_holding_invalid_type, + reason = "MCP resource calls are serialized through the session-owned manager guard" + )] pub async fn list_resources( &self, server: &str, @@ -124,6 +136,10 @@ impl Session { .await } + #[expect( + clippy::await_holding_invalid_type, + reason = "MCP resource calls are serialized through the session-owned manager guard" + )] pub async fn list_resource_templates( &self, server: &str, @@ -137,6 +153,10 @@ impl Session { .await } + #[expect( + clippy::await_holding_invalid_type, + reason = "MCP resource calls are serialized through the session-owned manager guard" + )] pub async fn read_resource( &self, server: &str, @@ -150,6 +170,10 @@ impl Session { .await } + #[expect( + clippy::await_holding_invalid_type, + reason = "MCP tool calls are serialized through the session-owned manager guard" + )] pub async fn call_tool( &self, server: &str, @@ -165,6 +189,10 @@ impl Session { .await } + #[expect( + clippy::await_holding_invalid_type, + reason = "MCP tool metadata reads through the session-owned manager guard" + )] pub(crate) async fn resolve_mcp_tool_info(&self, tool_name: &ToolName) -> Option { self.services .mcp_connection_manager diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs index f159546575..46d0c248b8 100644 --- a/codex-rs/core/src/session/mod.rs +++ b/codex-rs/core/src/session/mod.rs @@ -19,6 +19,7 @@ use crate::commit_attribution::commit_message_trailer_instruction; use crate::compact; use crate::config::ManagedFeatures; use crate::connectors; +use crate::context::ContextualUserFragment; use crate::default_skill_metadata_budget; use crate::exec_policy::ExecPolicyManager; use crate::installation_id::resolve_installation_id; @@ -153,7 +154,6 @@ use crate::config::StartedNetworkProxy; use crate::config::resolve_web_search_mode_for_turn; use crate::context_manager::ContextManager; use crate::context_manager::TotalTokenUsageBreakdown; -use crate::environment_context::EnvironmentContext; use crate::thread_rollout_truncation::initial_history_has_prior_user_turns; use codex_config::CONFIG_TOML_FILE; use codex_config::types::McpServerConfig; @@ -249,9 +249,9 @@ use crate::SkillLoadOutcome; use crate::SkillMetadata; use crate::SkillsManager; use crate::agents_md::AgentsMdManager; +use crate::context::UserInstructions; use crate::exec_policy::ExecPolicyUpdateError; use crate::guardian::GuardianReviewSessionManager; -use crate::instructions::UserInstructions; use crate::mcp::McpManager; use crate::memories; use crate::network_policy_decision::execpolicy_network_rule_amendment; @@ -1786,6 +1786,10 @@ impl Session { /// be used to derive the available decisions via /// [ExecApprovalRequestEvent::default_available_decisions]. #[allow(clippy::too_many_arguments)] + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn request_command_approval( &self, turn_context: &TurnContext, @@ -1857,6 +1861,10 @@ impl Session { rx_approve.await.unwrap_or(ReviewDecision::Abort) } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn request_patch_approval( &self, turn_context: &TurnContext, @@ -1893,13 +1901,18 @@ impl Session { rx_approve } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn request_permissions( - &self, - turn_context: &TurnContext, + self: &Arc, + turn_context: &Arc, call_id: String, args: RequestPermissionsArgs, + cancellation_token: CancellationToken, ) -> Option { - match turn_context.approval_policy.value() { + match turn_context.as_ref().approval_policy.value() { AskForApproval::Never => { return Some(RequestPermissionsResponse { permissions: RequestPermissionProfile::default(), @@ -1920,6 +1933,72 @@ impl Session { | AskForApproval::Granular(_) => {} } + if crate::guardian::routes_approval_to_guardian(turn_context.as_ref()) { + let requested_permissions = args.permissions; + let originating_turn_state = { + let active = self.active_turn.lock().await; + active.as_ref().map(|active| Arc::clone(&active.turn_state)) + }; + let review_id = crate::guardian::new_guardian_review_id(); + let session = Arc::clone(self); + let turn = Arc::clone(turn_context); + let request = crate::guardian::GuardianApprovalRequest::RequestPermissions { + id: call_id, + turn_id: turn_context.sub_id.clone(), + reason: args.reason, + permissions: requested_permissions.clone(), + }; + let review_rx = crate::guardian::spawn_approval_request_review( + session, + turn, + review_id, + request, + /*retry_reason*/ None, + cancellation_token.clone(), + ); + let decision = tokio::select! { + biased; + _ = cancellation_token.cancelled() => return None, + decision = review_rx => decision.unwrap_or(ReviewDecision::Denied), + }; + let response = match decision { + ReviewDecision::Approved | ReviewDecision::ApprovedExecpolicyAmendment { .. } => { + RequestPermissionsResponse { + permissions: requested_permissions, + scope: PermissionGrantScope::Turn, + } + } + ReviewDecision::ApprovedForSession => RequestPermissionsResponse { + permissions: requested_permissions, + scope: PermissionGrantScope::Session, + }, + ReviewDecision::NetworkPolicyAmendment { + network_policy_amendment, + } => match network_policy_amendment.action { + NetworkPolicyRuleAction::Allow => RequestPermissionsResponse { + permissions: requested_permissions, + scope: PermissionGrantScope::Turn, + }, + NetworkPolicyRuleAction::Deny => RequestPermissionsResponse { + permissions: RequestPermissionProfile::default(), + scope: PermissionGrantScope::Turn, + }, + }, + ReviewDecision::Abort | ReviewDecision::Denied | ReviewDecision::TimedOut => { + RequestPermissionsResponse { + permissions: RequestPermissionProfile::default(), + scope: PermissionGrantScope::Turn, + } + } + }; + self.record_granted_request_permissions_for_turn( + &response, + originating_turn_state.as_ref(), + ) + .await; + return Some(response); + } + let (tx_response, rx_response) = oneshot::channel(); let prev_entry = { let mut active = self.active_turn.lock().await; @@ -1935,19 +2014,31 @@ impl Session { warn!("Overwriting existing pending request_permissions for call_id: {call_id}"); } - // TODO(ccunningham): Support auto-review for request_permissions / - // with_additional_permissions. V0 still routes this surface through - // the existing manual RequestPermissions event flow. let event = EventMsg::RequestPermissions(RequestPermissionsEvent { - call_id, + call_id: call_id.clone(), turn_id: turn_context.sub_id.clone(), reason: args.reason, permissions: args.permissions, }); - self.send_event(turn_context, event).await; - rx_response.await.ok() + self.send_event(turn_context.as_ref(), event).await; + tokio::select! { + biased; + _ = cancellation_token.cancelled() => { + let mut active = self.active_turn.lock().await; + if let Some(at) = active.as_mut() { + let mut ts = at.turn_state.lock().await; + let _ = ts.remove_pending_request_permissions(&call_id); + } + None + } + response = rx_response => response.ok(), + } } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn request_user_input( &self, turn_context: &TurnContext, @@ -1980,6 +2071,10 @@ impl Session { rx_response.await.ok() } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn notify_user_input_response( &self, sub_id: &str, @@ -2005,36 +2100,33 @@ impl Session { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn notify_request_permissions_response( &self, call_id: &str, response: RequestPermissionsResponse, ) { - let mut granted_for_session = None; - let entry = { + let (entry, originating_turn_state) = { let mut active = self.active_turn.lock().await; match active.as_mut() { Some(at) => { let mut ts = at.turn_state.lock().await; let entry = ts.remove_pending_request_permissions(call_id); - if entry.is_some() && !response.permissions.is_empty() { - match response.scope { - PermissionGrantScope::Turn => { - ts.record_granted_permissions(response.permissions.clone().into()); - } - PermissionGrantScope::Session => { - granted_for_session = Some(response.permissions.clone()); - } - } - } - entry + let originating_turn_state = entry.as_ref().map(|_| Arc::clone(&at.turn_state)); + (entry, originating_turn_state) } - None => None, + None => (None, None), } }; - if let Some(permissions) = granted_for_session { - let mut state = self.state.lock().await; - state.record_granted_permissions(permissions.into()); + if entry.is_some() { + self.record_granted_request_permissions_for_turn( + &response, + originating_turn_state.as_ref(), + ) + .await; } match entry { Some(tx_response) => { @@ -2046,6 +2138,32 @@ impl Session { } } + async fn record_granted_request_permissions_for_turn( + &self, + response: &RequestPermissionsResponse, + originating_turn_state: Option<&Arc>>, + ) { + if response.permissions.is_empty() { + return; + } + match response.scope { + PermissionGrantScope::Turn => { + if let Some(turn_state) = originating_turn_state { + let mut ts = turn_state.lock().await; + ts.record_granted_permissions(response.permissions.clone().into()); + } + } + PermissionGrantScope::Session => { + let mut state = self.state.lock().await; + state.record_granted_permissions(response.permissions.clone().into()); + } + } + } + + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn reads must stay consistent with the matching turn state" + )] pub(crate) async fn granted_turn_permissions(&self) -> Option { let active = self.active_turn.lock().await; let active = active.as_ref()?; @@ -2058,6 +2176,10 @@ impl Session { state.granted_permissions() } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn notify_dynamic_tool_response(&self, call_id: &str, response: DynamicToolResponse) { let entry = { let mut active = self.active_turn.lock().await; @@ -2079,6 +2201,10 @@ impl Session { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn notify_approval(&self, approval_id: &str, decision: ReviewDecision) { let entry = { let mut active = self.active_turn.lock().await; @@ -2239,6 +2365,10 @@ impl Session { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "MCP app context rendering reads through the session-owned manager guard" + )] pub(crate) async fn build_initial_context( &self, turn_context: &TurnContext, @@ -2397,7 +2527,7 @@ impl Session { text: user_instructions.to_string(), directory: turn_context.cwd.to_string_lossy().into_owned(), } - .serialize_to_text(), + .render(), ); } if turn_context.config.include_environment_context { @@ -2407,9 +2537,9 @@ impl Session { .format_environment_context_subagents(self.conversation_id) .await; contextual_user_sections.push( - EnvironmentContext::from_turn_context(turn_context, shell.as_ref()) + crate::context::EnvironmentContext::from_turn_context(turn_context, shell.as_ref()) .with_subagents(subagents) - .serialize_to_xml(), + .render(), ); } @@ -2701,6 +2831,10 @@ impl Session { /// Inject additional user input into the currently active turn. /// /// Returns the active turn id when accepted. + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn steer_input( &self, input: Vec, @@ -2760,6 +2894,10 @@ impl Session { } /// Returns the input if there was no task running to inject into. + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn inject_response_items( &self, input: Vec, @@ -2833,6 +2971,10 @@ impl Session { self.mailbox_rx.lock().await.has_pending_trigger_turn() } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn prepend_pending_input(&self, input: Vec) -> Result<(), ()> { let mut active = self.active_turn.lock().await; match active.as_mut() { @@ -2845,6 +2987,10 @@ impl Session { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state updates must remain atomic" + )] pub async fn get_pending_input(&self) -> Vec { let (pending_input, accepts_mailbox_delivery) = { let mut active = self.active_turn.lock().await; @@ -2900,6 +3046,10 @@ impl Session { !self.idle_pending_input.lock().await.is_empty() } + #[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and turn state reads must remain atomic" + )] pub async fn has_pending_input(&self) -> bool { let (has_turn_pending_input, accepts_mailbox_delivery) = { let active = self.active_turn.lock().await; diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rs index a2080bbeab..16e86e3aea 100644 --- a/codex-rs/core/src/session/session.rs +++ b/codex-rs/core/src/session/session.rs @@ -209,6 +209,10 @@ pub(crate) struct AppServerClientMetadata { impl Session { #[instrument(name = "session_init", level = "info", skip_all)] #[allow(clippy::too_many_arguments)] + #[expect( + clippy::await_holding_invalid_type, + reason = "session initialization must serialize access through session-owned manager guards" + )] pub(crate) async fn new( mut session_configuration: SessionConfiguration, config: Arc, diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs index bd41da9f20..97b6eba8b3 100644 --- a/codex-rs/core/src/session/tests.rs +++ b/codex-rs/core/src/session/tests.rs @@ -11,6 +11,8 @@ use crate::config_loader::NetworkDomainPermissionsToml; use crate::config_loader::RequirementSource; use crate::config_loader::Sourced; use crate::config_loader::project_trust_key; +use crate::context::ContextualUserFragment; +use crate::context::TurnAborted; use crate::exec::ExecCapturePolicy; use crate::function_tool::FunctionCallError; use crate::shell::default_user_shell; @@ -3438,6 +3440,41 @@ async fn notify_request_permissions_response_ignores_unmatched_call_id() { assert_eq!(session.granted_turn_permissions().await, None); } +#[tokio::test] +async fn record_granted_request_permissions_for_turn_uses_originating_turn() { + let (session, _turn_context) = make_session_and_context().await; + let originating_active_turn = ActiveTurn::default(); + let originating_turn_state = Arc::clone(&originating_active_turn.turn_state); + *session.active_turn.lock().await = Some(originating_active_turn); + + let current_active_turn = ActiveTurn::default(); + let current_turn_state = Arc::clone(¤t_active_turn.turn_state); + *session.active_turn.lock().await = Some(current_active_turn); + + let requested_permissions = RequestPermissionProfile { + network: Some(codex_protocol::models::NetworkPermissions { + enabled: Some(true), + }), + ..RequestPermissionProfile::default() + }; + session + .record_granted_request_permissions_for_turn( + &codex_protocol::request_permissions::RequestPermissionsResponse { + permissions: requested_permissions.clone(), + scope: PermissionGrantScope::Turn, + }, + Some(&originating_turn_state), + ) + .await; + + assert_eq!( + originating_turn_state.lock().await.granted_permissions(), + Some(requested_permissions.into()) + ); + assert_eq!(current_turn_state.lock().await.granted_permissions(), None); + assert_eq!(session.granted_turn_permissions().await, None); +} + #[tokio::test] async fn request_permissions_emits_event_when_granular_policy_allows_requests() { let (session, mut turn_context, rx) = make_session_and_context_with_rx().await; @@ -3474,7 +3511,7 @@ async fn request_permissions_emits_event_when_granular_policy_allows_requests() async move { session .request_permissions( - turn_context.as_ref(), + &turn_context, call_id, codex_protocol::request_permissions::RequestPermissionsArgs { reason: Some("need network".to_string()), @@ -3485,6 +3522,7 @@ async fn request_permissions_emits_event_when_granular_policy_allows_requests() ..RequestPermissionProfile::default() }, }, + CancellationToken::new(), ) .await } @@ -3532,7 +3570,7 @@ async fn request_permissions_is_auto_denied_when_granular_policy_blocks_tool_req let call_id = "call-1".to_string(); let response = session .request_permissions( - turn_context.as_ref(), + &turn_context, call_id, codex_protocol::request_permissions::RequestPermissionsArgs { reason: Some("need network".to_string()), @@ -3543,6 +3581,7 @@ async fn request_permissions_is_auto_denied_when_granular_policy_blocks_tool_req ..RequestPermissionProfile::default() }, }, + CancellationToken::new(), ) .await; @@ -6312,7 +6351,7 @@ async fn abort_review_task_emits_exited_then_aborted_and_records_history() { let ContentItem::InputText { text } = content_item else { return false; }; - text.contains(crate::contextual_user_message::TURN_ABORTED_OPEN_TAG) + TurnAborted::matches_text(text) }) }), "expected a model-visible turn aborted marker in history after interrupt" @@ -6320,6 +6359,10 @@ async fn abort_review_task_emits_exited_then_aborted_and_records_history() { } #[tokio::test] +#[expect( + clippy::await_holding_invalid_type, + reason = "test builds a router from session-owned MCP manager state" +)] async fn fatal_tool_error_stops_turn_and_reports_error() { let (session, turn_context, _rx) = make_session_and_context_with_rx().await; let tools = { @@ -6360,6 +6403,7 @@ async fn fatal_tool_error_stops_turn_and_reports_error() { .dispatch_tool_call_with_code_mode_result( Arc::clone(&session), Arc::clone(&turn_context), + CancellationToken::new(), tracker, call, ToolCallSource::Direct, @@ -6602,6 +6646,7 @@ async fn rejects_escalated_permissions_when_policy_not_on_request() { .handle(ToolInvocation { session: Arc::clone(&session), turn: Arc::clone(&turn_context), + cancellation_token: CancellationToken::new(), tracker: Arc::clone(&turn_diff_tracker), call_id, tool_name: codex_tools::ToolName::plain(tool_name), @@ -6680,6 +6725,7 @@ async fn unified_exec_rejects_escalated_permissions_when_policy_not_on_request() .handle(ToolInvocation { session: Arc::clone(&session), turn: Arc::clone(&turn_context), + cancellation_token: CancellationToken::new(), tracker: Arc::clone(&tracker), call_id: "exec-call".to_string(), tool_name: codex_tools::ToolName::plain("exec_command"), diff --git a/codex-rs/core/src/session/tests/guardian_tests.rs b/codex-rs/core/src/session/tests/guardian_tests.rs index 9ccd6eb4e0..9b1172d578 100644 --- a/codex-rs/core/src/session/tests/guardian_tests.rs +++ b/codex-rs/core/src/session/tests/guardian_tests.rs @@ -17,6 +17,7 @@ use codex_execpolicy::Evaluation; use codex_execpolicy::RuleMatch; use codex_features::Feature; use codex_model_provider::create_model_provider; +use codex_protocol::config_types::ApprovalsReviewer; use codex_protocol::models::ContentItem; use codex_protocol::models::NetworkPermissions; use codex_protocol::models::PermissionProfile; @@ -25,26 +26,214 @@ use codex_protocol::models::function_call_output_content_items_to_text; use codex_protocol::permissions::FileSystemSandboxPolicy; use codex_protocol::permissions::NetworkSandboxPolicy; use codex_protocol::protocol::AskForApproval; +use codex_protocol::request_permissions::PermissionGrantScope; +use codex_protocol::request_permissions::RequestPermissionProfile; +use codex_protocol::request_permissions::RequestPermissionsArgs; +use codex_protocol::request_permissions::RequestPermissionsResponse; use core_test_support::PathExt; use core_test_support::TempDirExt; use core_test_support::codex_linux_sandbox_exe_or_skip; use core_test_support::responses::ev_assistant_message; use core_test_support::responses::ev_completed; use core_test_support::responses::ev_response_created; +use core_test_support::responses::mount_response_once; use core_test_support::responses::mount_sse_once; use core_test_support::responses::sse; +use core_test_support::responses::sse_response; use core_test_support::responses::start_mock_server; use pretty_assertions::assert_eq; use serde::Deserialize; use std::collections::HashMap; use std::fs; use std::sync::Arc; +use std::time::Duration; use tempfile::tempdir; +use tokio_util::sync::CancellationToken; fn expect_text_output(output: &FunctionToolOutput) -> String { function_call_output_content_items_to_text(&output.body).unwrap_or_default() } +#[tokio::test] +async fn request_permissions_routes_to_guardian_when_reviewer_is_enabled() { + let server = start_mock_server().await; + let guardian_request_log = mount_sse_once( + &server, + sse(vec![ + ev_response_created("resp-guardian"), + ev_assistant_message( + "msg-guardian", + &serde_json::json!({ + "risk_level": "low", + "user_authorization": "high", + "outcome": "allow", + "rationale": "The request grants narrowly scoped network access for this turn.", + }) + .to_string(), + ), + ev_completed("resp-guardian"), + ]), + ) + .await; + + let (mut session, mut turn_context_raw) = make_session_and_context().await; + *session.active_turn.lock().await = Some(ActiveTurn::default()); + turn_context_raw + .approval_policy + .set(AskForApproval::OnRequest) + .expect("test setup should allow updating approval policy"); + turn_context_raw + .features + .enable(Feature::GuardianApproval) + .expect("test setup should allow enabling guardian approvals"); + let mut config = (*turn_context_raw.config).clone(); + config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; + config.model_provider.base_url = Some(format!("{}/v1", server.uri())); + let config = Arc::new(config); + let models_manager = Arc::new(crate::test_support::models_manager_with_provider( + config.codex_home.to_path_buf(), + Arc::clone(&session.services.auth_manager), + config.model_provider.clone(), + )); + session.services.models_manager = models_manager; + turn_context_raw.config = Arc::clone(&config); + turn_context_raw.provider = create_model_provider( + config.model_provider.clone(), + turn_context_raw.auth_manager.clone(), + ); + let session = Arc::new(session); + let turn_context = Arc::new(turn_context_raw); + + let requested_permissions = RequestPermissionProfile { + network: Some(NetworkPermissions { + enabled: Some(true), + }), + ..RequestPermissionProfile::default() + }; + let response = tokio::time::timeout( + Duration::from_secs(45), + session.request_permissions( + &turn_context, + "perm-call-1".to_string(), + RequestPermissionsArgs { + reason: Some("need network".to_string()), + permissions: requested_permissions.clone(), + }, + CancellationToken::new(), + ), + ) + .await + .expect("request_permissions should not wait for a client approval"); + + assert_eq!( + response, + Some(RequestPermissionsResponse { + permissions: requested_permissions.clone(), + scope: PermissionGrantScope::Turn, + }) + ); + assert_eq!( + session.granted_turn_permissions().await, + Some(requested_permissions.into()) + ); + + let guardian_request = guardian_request_log.single_request(); + assert_eq!(guardian_request.path(), "/v1/responses"); + assert!(guardian_request.body_contains_text("request_permissions")); + assert!(guardian_request.body_contains_text("need network")); +} + +#[tokio::test] +async fn request_permissions_guardian_review_stops_when_cancelled() { + let server = start_mock_server().await; + let _guardian_request_log = mount_response_once( + &server, + sse_response(sse(vec![ev_response_created("resp-guardian-delayed")])) + .set_delay(Duration::from_secs(60)), + ) + .await; + + let (mut session, mut turn_context, rx_event) = make_session_and_context_with_rx().await; + *session.active_turn.lock().await = Some(ActiveTurn::default()); + let turn_context_raw = Arc::get_mut(&mut turn_context).expect("single turn context ref"); + turn_context_raw + .approval_policy + .set(AskForApproval::OnRequest) + .expect("test setup should allow updating approval policy"); + turn_context_raw + .features + .enable(Feature::GuardianApproval) + .expect("test setup should allow enabling guardian approvals"); + let mut config = (*turn_context_raw.config).clone(); + config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; + config.model_provider.base_url = Some(format!("{}/v1", server.uri())); + let config = Arc::new(config); + let models_manager = Arc::new(crate::test_support::models_manager_with_provider( + config.codex_home.to_path_buf(), + Arc::clone(&session.services.auth_manager), + config.model_provider.clone(), + )); + Arc::get_mut(&mut session) + .expect("single session ref") + .services + .models_manager = models_manager; + turn_context_raw.config = Arc::clone(&config); + turn_context_raw.provider = create_model_provider( + config.model_provider.clone(), + turn_context_raw.auth_manager.clone(), + ); + + let requested_permissions = RequestPermissionProfile { + network: Some(NetworkPermissions { + enabled: Some(true), + }), + ..RequestPermissionProfile::default() + }; + let cancellation_token = CancellationToken::new(); + let request_handle = tokio::spawn({ + let session = Arc::clone(&session); + let turn_context = Arc::clone(&turn_context); + let requested_permissions = requested_permissions.clone(); + let cancellation_token = cancellation_token.clone(); + async move { + session + .request_permissions( + &turn_context, + "perm-call-cancelled".to_string(), + RequestPermissionsArgs { + reason: Some("need network".to_string()), + permissions: requested_permissions, + }, + cancellation_token, + ) + .await + } + }); + + timeout(Duration::from_secs(5), async { + loop { + let event = rx_event.recv().await.expect("event channel should be open"); + if matches!( + event.msg, + codex_protocol::protocol::EventMsg::GuardianAssessment(_) + ) { + break; + } + } + }) + .await + .expect("guardian review should start before cancellation"); + + cancellation_token.cancel(); + + let response = timeout(Duration::from_secs(5), request_handle) + .await + .expect("request_permissions should stop when cancelled") + .expect("request_permissions task should not panic"); + assert_eq!(response, None); + assert_eq!(session.granted_turn_permissions().await, None); +} + #[tokio::test] async fn guardian_allows_shell_additional_permissions_requests_past_policy_validation() { let server = start_mock_server().await; @@ -146,6 +335,7 @@ async fn guardian_allows_shell_additional_permissions_requests_past_policy_valid .handle(ToolInvocation { session: Arc::clone(&session), turn: Arc::clone(&turn_context), + cancellation_token: CancellationToken::new(), tracker: Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new())), call_id: "test-call".to_string(), tool_name: codex_tools::ToolName::plain("shell"), @@ -212,6 +402,7 @@ async fn guardian_allows_unified_exec_additional_permissions_requests_past_polic .handle(ToolInvocation { session: Arc::clone(&session), turn: Arc::clone(&turn_context), + cancellation_token: CancellationToken::new(), tracker: Arc::clone(&tracker), call_id: "exec-call".to_string(), tool_name: codex_tools::ToolName::plain("exec_command"), @@ -298,6 +489,10 @@ async fn process_compacted_history_preserves_separate_guardian_developer_message #[tokio::test] #[cfg(unix)] +#[expect( + clippy::await_holding_invalid_type, + reason = "test mutates active turn state directly to seed granted permissions" +)] async fn shell_handler_allows_sticky_turn_permissions_without_inline_request_permissions_feature() { let (mut session, turn_context_raw) = make_session_and_context().await; session @@ -325,6 +520,7 @@ async fn shell_handler_allows_sticky_turn_permissions_without_inline_request_per .handle(ToolInvocation { session: Arc::clone(&session), turn: Arc::clone(&turn_context), + cancellation_token: CancellationToken::new(), tracker: Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new())), call_id: "sticky-turn-grant".to_string(), tool_name: codex_tools::ToolName::plain("shell"), diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index efbcca6716..7b27c8080a 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -16,6 +16,7 @@ use crate::compact::run_inline_auto_compact_task; use crate::compact::should_use_remote_compact_task; use crate::compact_remote::run_inline_remote_auto_compact_task; use crate::connectors; +use crate::context::ContextualUserFragment; use crate::feedback_tags; use crate::hook_runtime::PendingInputHookDisposition; use crate::hook_runtime::emit_hook_completed_events; @@ -93,7 +94,9 @@ use codex_protocol::protocol::ReasoningRawContentDeltaEvent; use codex_protocol::protocol::TurnDiffEvent; use codex_protocol::protocol::WarningEvent; use codex_protocol::user_input::UserInput; +use codex_tools::ResponsesApiNamespaceTool; use codex_tools::ToolName; +use codex_tools::ToolSpec; use codex_tools::filter_tool_suggest_discoverable_tools_for_client; use codex_utils_stream_parser::AssistantTextChunk; use codex_utils_stream_parser::AssistantTextStreamParser; @@ -127,6 +130,10 @@ use tracing::warn; /// - If the model sends only an assistant message, we record it in the /// conversation history and consider the turn complete. /// +#[expect( + clippy::await_holding_invalid_type, + reason = "turn execution must keep active-turn state transitions atomic" +)] pub(crate) async fn run_turn( sess: Arc, turn_context: Arc, @@ -241,7 +248,7 @@ pub(crate) async fn run_turn( turn_context.sub_id.clone(), ); let SkillInjections { - items: skill_items, + items: skill_injections, warnings: skill_warnings, } = build_skill_injections( &mentioned_skills, @@ -257,6 +264,11 @@ pub(crate) async fn run_turn( .await; } + let skill_items: Vec = skill_injections + .iter() + .map(|skill| ContextualUserFragment::into(crate::context::SkillInstructions::from(skill))) + .collect(); + let plugin_items = build_plugin_injections(&mentioned_plugins, &mcp_tools, &available_connectors); let mentioned_plugin_metadata = mentioned_plugins @@ -969,7 +981,7 @@ pub(crate) fn build_prompt( .dynamic_tools .iter() .filter(|tool| tool.defer_loading) - .map(|tool| tool.name.as_str()) + .map(|tool| ToolName::new(tool.namespace.clone(), tool.name.clone())) .collect::>(); let tools = if deferred_dynamic_tools.is_empty() { router.model_visible_specs() @@ -977,7 +989,7 @@ pub(crate) fn build_prompt( router .model_visible_specs() .into_iter() - .filter(|spec| !deferred_dynamic_tools.contains(spec.name())) + .filter_map(|spec| filter_deferred_dynamic_tool_spec(spec, &deferred_dynamic_tools)) .collect() }; @@ -991,6 +1003,35 @@ pub(crate) fn build_prompt( } } +fn filter_deferred_dynamic_tool_spec( + spec: ToolSpec, + deferred_dynamic_tools: &HashSet, +) -> Option { + match spec { + ToolSpec::Function(tool) => { + if deferred_dynamic_tools.contains(&ToolName::plain(tool.name.as_str())) { + None + } else { + Some(ToolSpec::Function(tool)) + } + } + ToolSpec::Namespace(mut namespace) => { + let namespace_name = namespace.name.clone(); + namespace.tools.retain(|tool| match tool { + ResponsesApiNamespaceTool::Function(tool) => !deferred_dynamic_tools.contains( + &ToolName::namespaced(namespace_name.as_str(), tool.name.as_str()), + ), + }); + if namespace.tools.is_empty() { + None + } else { + Some(ToolSpec::Namespace(namespace)) + } + } + spec => Some(spec), + } +} + #[allow(clippy::too_many_arguments)] #[instrument(level = "trace", skip_all, @@ -1143,6 +1184,10 @@ async fn run_sampling_request( } } +#[expect( + clippy::await_holding_invalid_type, + reason = "tool router construction reads through the session-owned manager guard" +)] pub(crate) async fn built_tools( sess: &Session, turn_context: &TurnContext, diff --git a/codex-rs/core/src/session_prefix.rs b/codex-rs/core/src/session_prefix.rs index 42f213a1d3..b50d1f9070 100644 --- a/codex-rs/core/src/session_prefix.rs +++ b/codex-rs/core/src/session_prefix.rs @@ -1,20 +1,17 @@ use codex_protocol::protocol::AgentStatus; -/// Helpers for model-visible session state markers that are stored in user-role -/// messages but are not user intent. -use crate::contextual_user_message::SUBAGENT_NOTIFICATION_FRAGMENT; +use crate::context::ContextualUserFragment; +use crate::context::SubagentNotification; + +// Helpers for model-visible session state markers that are stored in user-role +// messages but are not user intent. // TODO(jif) unify with structured schema pub(crate) fn format_subagent_notification_message( agent_reference: &str, status: &AgentStatus, ) -> String { - let payload_json = serde_json::json!({ - "agent_path": agent_reference, - "status": status, - }) - .to_string(); - SUBAGENT_NOTIFICATION_FRAGMENT.wrap(payload_json) + SubagentNotification::new(agent_reference, status.clone()).render() } pub(crate) fn format_subagent_context_line( diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index e7030d1d94..9c19087204 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -19,8 +19,7 @@ use tracing::info_span; use tracing::trace; use tracing::warn; -use crate::contextual_user_message::TURN_ABORTED_CLOSE_TAG; -use crate::contextual_user_message::TURN_ABORTED_OPEN_TAG; +use crate::context::ContextualUserFragment; use crate::hook_runtime::PendingInputHookDisposition; use crate::hook_runtime::inspect_pending_input; use crate::hook_runtime::record_additional_contexts; @@ -39,7 +38,6 @@ use codex_otel::TURN_MEMORY_METRIC; use codex_otel::TURN_NETWORK_PROXY_METRIC; use codex_otel::TURN_TOKEN_USAGE_METRIC; use codex_otel::TURN_TOOL_CALL_METRIC; -use codex_protocol::models::ContentItem; use codex_protocol::models::ResponseInputItem; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::EventMsg; @@ -62,22 +60,13 @@ pub(crate) use user_shell::UserShellCommandTask; pub(crate) use user_shell::execute_user_shell_command; const GRACEFULL_INTERRUPTION_TIMEOUT_MS: u64 = 100; -const TURN_ABORTED_INTERRUPTED_GUIDANCE: &str = "The user interrupted the previous turn on purpose. Any running unified exec processes may still be running in the background. If any tools/commands were aborted, they may have partially executed."; /// Shared model-visible marker used by both the real interrupt path and /// interrupted fork snapshots. pub(crate) fn interrupted_turn_history_marker() -> ResponseItem { - ResponseItem::Message { - id: None, - role: "user".to_string(), - content: vec![ContentItem::InputText { - text: format!( - "{TURN_ABORTED_OPEN_TAG}\n{TURN_ABORTED_INTERRUPTED_GUIDANCE}\n{TURN_ABORTED_CLOSE_TAG}" - ), - }], - end_turn: None, - phase: None, - } + ContextualUserFragment::into(crate::context::TurnAborted::new( + crate::context::TurnAborted::INTERRUPTED_GUIDANCE, + )) } fn emit_turn_network_proxy_metric( diff --git a/codex-rs/core/src/tools/code_mode/mod.rs b/codex-rs/core/src/tools/code_mode/mod.rs index 5049836393..575d3f9a89 100644 --- a/codex-rs/core/src/tools/code_mode/mod.rs +++ b/codex-rs/core/src/tools/code_mode/mod.rs @@ -259,6 +259,10 @@ pub(super) async fn build_enabled_tools( collect_code_mode_tool_definitions(&specs) } +#[expect( + clippy::await_holding_invalid_type, + reason = "nested tool router construction reads through the session-owned manager guard" +)] async fn build_nested_router(exec: &ExecContext) -> ToolRouter { let nested_tools_config = exec.turn.tools_config.for_code_mode_nested_tools(); let listed_mcp_tools = exec diff --git a/codex-rs/core/src/tools/context.rs b/codex-rs/core/src/tools/context.rs index 4e144b5507..0060d58973 100644 --- a/codex-rs/core/src/tools/context.rs +++ b/codex-rs/core/src/tools/context.rs @@ -15,8 +15,8 @@ use codex_protocol::models::ResponseInputItem; use codex_protocol::models::SearchToolCallParams; use codex_protocol::models::ShellToolCallParams; use codex_protocol::models::function_call_output_content_items_to_text; +use codex_tools::LoadableToolSpec; use codex_tools::ToolName; -use codex_tools::ToolSearchOutputTool; use codex_utils_output_truncation::TruncationPolicy; use codex_utils_output_truncation::formatted_truncate_text; use codex_utils_string::take_bytes_at_char_boundary; @@ -26,6 +26,7 @@ use std::borrow::Cow; use std::sync::Arc; use std::time::Duration; use tokio::sync::Mutex; +use tokio_util::sync::CancellationToken; pub type SharedTurnDiffTracker = Arc>; @@ -40,6 +41,7 @@ pub enum ToolCallSource { pub struct ToolInvocation { pub session: Arc, pub turn: Arc, + pub cancellation_token: CancellationToken, pub tracker: SharedTurnDiffTracker, pub call_id: String, pub tool_name: ToolName, @@ -184,7 +186,7 @@ impl McpToolOutput { #[derive(Clone)] pub struct ToolSearchOutput { - pub tools: Vec, + pub tools: Vec, } impl ToolOutput for ToolSearchOutput { diff --git a/codex-rs/core/src/tools/context_tests.rs b/codex-rs/core/src/tools/context_tests.rs index c62328dff5..4b903347ab 100644 --- a/codex-rs/core/src/tools/context_tests.rs +++ b/codex-rs/core/src/tools/context_tests.rs @@ -284,20 +284,18 @@ fn tool_search_payloads_roundtrip_as_tool_search_outputs() { }, }; let response = ToolSearchOutput { - tools: vec![ToolSearchOutputTool::Function( - codex_tools::ResponsesApiTool { - name: "create_event".to_string(), - description: String::new(), - strict: false, - defer_loading: Some(true), - parameters: codex_tools::JsonSchema::object( - /*properties*/ Default::default(), - /*required*/ None, - /*additional_properties*/ None, - ), - output_schema: None, - }, - )], + tools: vec![LoadableToolSpec::Function(codex_tools::ResponsesApiTool { + name: "create_event".to_string(), + description: String::new(), + strict: false, + defer_loading: Some(true), + parameters: codex_tools::JsonSchema::object( + /*properties*/ Default::default(), + /*required*/ None, + /*additional_properties*/ None, + ), + output_schema: None, + })], } .to_response_item("search-1", &payload); diff --git a/codex-rs/core/src/tools/handlers/dynamic.rs b/codex-rs/core/src/tools/handlers/dynamic.rs index 140d586be9..b7e07090dc 100644 --- a/codex-rs/core/src/tools/handlers/dynamic.rs +++ b/codex-rs/core/src/tools/handlers/dynamic.rs @@ -12,6 +12,7 @@ use codex_protocol::dynamic_tools::DynamicToolResponse; use codex_protocol::models::FunctionCallOutputContentItem; use codex_protocol::protocol::DynamicToolCallResponseEvent; use codex_protocol::protocol::EventMsg; +use codex_tools::ToolName; use serde_json::Value; use std::time::Instant; use tokio::sync::oneshot; @@ -50,14 +51,13 @@ impl ToolHandler for DynamicToolHandler { }; let args: Value = parse_arguments(&arguments)?; - let response = - request_dynamic_tool(&session, turn.as_ref(), call_id, tool_name.display(), args) - .await - .ok_or_else(|| { - FunctionCallError::RespondToModel( - "dynamic tool call was cancelled before receiving a response".to_string(), - ) - })?; + let response = request_dynamic_tool(&session, turn.as_ref(), call_id, tool_name, args) + .await + .ok_or_else(|| { + FunctionCallError::RespondToModel( + "dynamic tool call was cancelled before receiving a response".to_string(), + ) + })?; let DynamicToolResponse { content_items, @@ -71,13 +71,19 @@ impl ToolHandler for DynamicToolHandler { } } +#[expect( + clippy::await_holding_invalid_type, + reason = "active turn checks and dynamic tool response registration must remain atomic" +)] async fn request_dynamic_tool( session: &Session, turn_context: &TurnContext, call_id: String, - tool: String, + tool_name: ToolName, arguments: Value, ) -> Option { + let namespace = tool_name.namespace; + let tool = tool_name.name; let turn_id = turn_context.sub_id.clone(); let (tx_response, rx_response) = oneshot::channel(); let event_id = call_id.clone(); @@ -99,6 +105,7 @@ async fn request_dynamic_tool( let event = EventMsg::DynamicToolCallRequest(DynamicToolCallRequest { call_id: call_id.clone(), turn_id: turn_id.clone(), + namespace: namespace.clone(), tool: tool.clone(), arguments: arguments.clone(), }); @@ -109,6 +116,7 @@ async fn request_dynamic_tool( Some(response) => EventMsg::DynamicToolCallResponse(DynamicToolCallResponseEvent { call_id, turn_id, + namespace, tool, arguments, content_items: response.content_items.clone(), @@ -119,6 +127,7 @@ async fn request_dynamic_tool( None => EventMsg::DynamicToolCallResponse(DynamicToolCallResponseEvent { call_id, turn_id, + namespace, tool, arguments, content_items: Vec::new(), diff --git a/codex-rs/core/src/tools/handlers/js_repl.rs b/codex-rs/core/src/tools/handlers/js_repl.rs index 64e6ea29fe..906e1bb637 100644 --- a/codex-rs/core/src/tools/handlers/js_repl.rs +++ b/codex-rs/core/src/tools/handlers/js_repl.rs @@ -109,6 +109,7 @@ impl ToolHandler for JsReplHandler { let ToolInvocation { session, turn, + cancellation_token, tracker, payload, call_id, @@ -134,7 +135,13 @@ impl ToolHandler for JsReplHandler { let started_at = Instant::now(); emit_js_repl_exec_begin(session.as_ref(), turn.as_ref(), &call_id).await; let result = manager - .execute(Arc::clone(&session), Arc::clone(&turn), tracker, args) + .execute_with_cancellation( + Arc::clone(&session), + Arc::clone(&turn), + cancellation_token, + tracker, + args, + ) .await; let result = match result { Ok(result) => result, diff --git a/codex-rs/core/src/tools/handlers/mcp_resource.rs b/codex-rs/core/src/tools/handlers/mcp_resource.rs index 67f44cb699..fa4a066741 100644 --- a/codex-rs/core/src/tools/handlers/mcp_resource.rs +++ b/codex-rs/core/src/tools/handlers/mcp_resource.rs @@ -240,6 +240,10 @@ impl ToolHandler for McpResourceHandler { } } +#[expect( + clippy::await_holding_invalid_type, + reason = "MCP resource listing reads through the session-owned manager guard" +)] async fn handle_list_resources( session: Arc, turn: Arc, @@ -344,6 +348,10 @@ async fn handle_list_resources( } } +#[expect( + clippy::await_holding_invalid_type, + reason = "MCP resource template listing reads through the session-owned manager guard" +)] async fn handle_list_resource_templates( session: Arc, turn: Arc, diff --git a/codex-rs/core/src/tools/handlers/multi_agents_tests.rs b/codex-rs/core/src/tools/handlers/multi_agents_tests.rs index 3a525e69eb..c46e98bce2 100644 --- a/codex-rs/core/src/tools/handlers/multi_agents_tests.rs +++ b/codex-rs/core/src/tools/handlers/multi_agents_tests.rs @@ -68,6 +68,7 @@ fn invocation( ToolInvocation { session, turn, + cancellation_token: CancellationToken::new(), tracker: Arc::new(Mutex::new(TurnDiffTracker::default())), call_id: "call-1".to_string(), tool_name: codex_tools::ToolName::plain(tool_name), diff --git a/codex-rs/core/src/tools/handlers/request_permissions.rs b/codex-rs/core/src/tools/handlers/request_permissions.rs index 440bb18ca1..56facee658 100644 --- a/codex-rs/core/src/tools/handlers/request_permissions.rs +++ b/codex-rs/core/src/tools/handlers/request_permissions.rs @@ -22,6 +22,7 @@ impl ToolHandler for RequestPermissionsHandler { let ToolInvocation { session, turn, + cancellation_token, call_id, payload, .. @@ -48,7 +49,7 @@ impl ToolHandler for RequestPermissionsHandler { } let response = session - .request_permissions(turn.as_ref(), call_id, args) + .request_permissions(&turn, call_id, args, cancellation_token) .await .ok_or_else(|| { FunctionCallError::RespondToModel( diff --git a/codex-rs/core/src/tools/handlers/request_user_input_tests.rs b/codex-rs/core/src/tools/handlers/request_user_input_tests.rs index 1f9db34b26..e0a0907668 100644 --- a/codex-rs/core/src/tools/handlers/request_user_input_tests.rs +++ b/codex-rs/core/src/tools/handlers/request_user_input_tests.rs @@ -27,6 +27,7 @@ async fn multi_agent_v2_request_user_input_rejects_subagent_threads() { .handle(ToolInvocation { session: Arc::new(session), turn: Arc::new(turn), + cancellation_token: tokio_util::sync::CancellationToken::new(), tracker: Arc::new(Mutex::new(TurnDiffTracker::default())), call_id: "call-1".to_string(), tool_name: codex_tools::ToolName::plain(REQUEST_USER_INPUT_TOOL_NAME), diff --git a/codex-rs/core/src/tools/handlers/shell_tests.rs b/codex-rs/core/src/tools/handlers/shell_tests.rs index 652b305688..1cb79affb4 100644 --- a/codex-rs/core/src/tools/handlers/shell_tests.rs +++ b/codex-rs/core/src/tools/handlers/shell_tests.rs @@ -225,6 +225,7 @@ async fn shell_pre_tool_use_payload_uses_joined_command() { handler.pre_tool_use_payload(&ToolInvocation { session: session.into(), turn: turn.into(), + cancellation_token: tokio_util::sync::CancellationToken::new(), tracker: Arc::new(Mutex::new(TurnDiffTracker::new())), call_id: "call-41".to_string(), tool_name: codex_tools::ToolName::plain("shell"), @@ -250,6 +251,7 @@ async fn shell_command_pre_tool_use_payload_uses_raw_command() { handler.pre_tool_use_payload(&ToolInvocation { session: session.into(), turn: turn.into(), + cancellation_token: tokio_util::sync::CancellationToken::new(), tracker: Arc::new(Mutex::new(TurnDiffTracker::new())), call_id: "call-42".to_string(), tool_name: codex_tools::ToolName::plain("shell_command"), diff --git a/codex-rs/core/src/tools/handlers/tool_search.rs b/codex-rs/core/src/tools/handlers/tool_search.rs index 7103023d9d..f38b4ee883 100644 --- a/codex-rs/core/src/tools/handlers/tool_search.rs +++ b/codex-rs/core/src/tools/handlers/tool_search.rs @@ -9,9 +9,10 @@ use bm25::Document; use bm25::Language; use bm25::SearchEngine; use bm25::SearchEngineBuilder; +use codex_tools::LoadableToolSpec; use codex_tools::TOOL_SEARCH_DEFAULT_LIMIT; use codex_tools::TOOL_SEARCH_TOOL_NAME; -use codex_tools::ToolSearchOutputTool; +use codex_tools::coalesce_loadable_tool_specs; use std::collections::HashMap; const COMPUTER_USE_MCP_SERVER_NAME: &str = "computer-use"; @@ -93,7 +94,7 @@ impl ToolSearchHandler { query: &str, limit: usize, use_default_limit: bool, - ) -> Result, FunctionCallError> { + ) -> Result, FunctionCallError> { let results = self.search_result_entries(query, limit, use_default_limit); self.search_output_tools(results) } @@ -135,34 +136,10 @@ impl ToolSearchHandler { fn search_output_tools<'a>( &self, results: impl IntoIterator, - ) -> Result, FunctionCallError> { - let mut tools = Vec::new(); - // Preserve search order: group namespace children, emit standalone tools directly. - for entry in results { - match &entry.output { - ToolSearchOutputTool::Function(tool) => { - tools.push(ToolSearchOutputTool::Function(tool.clone())); - } - ToolSearchOutputTool::Namespace(namespace) => { - if let Some(output) = tools.iter_mut().find_map(|tool| match tool { - ToolSearchOutputTool::Namespace(output) - if output.name == namespace.name => - { - Some(output) - } - ToolSearchOutputTool::Namespace(_) | ToolSearchOutputTool::Function(_) => { - None - } - }) { - output.tools.extend(namespace.tools.clone()); - } else { - tools.push(ToolSearchOutputTool::Namespace(namespace.clone())); - } - } - } - } - - Ok(tools) + ) -> Result, FunctionCallError> { + Ok(coalesce_loadable_tool_specs( + results.into_iter().map(|entry| entry.output.clone()), + )) } } @@ -209,6 +186,7 @@ mod tests { #[test] fn mixed_search_results_coalesce_mcp_namespaces() { let dynamic_tools = vec![DynamicToolSpec { + namespace: Some("codex_app".to_string()), name: "automation_update".to_string(), description: "Create, update, view, or delete recurring automations.".to_string(), input_schema: serde_json::json!({ @@ -247,7 +225,7 @@ mod tests { assert_eq!( tools, vec![ - ToolSearchOutputTool::Namespace(ResponsesApiNamespace { + LoadableToolSpec::Namespace(ResponsesApiNamespace { name: "mcp__calendar__".to_string(), description: "Tools in the mcp__calendar__ namespace.".to_string(), tools: vec![ @@ -277,21 +255,25 @@ mod tests { }), ], }), - ToolSearchOutputTool::Function(ResponsesApiTool { - name: "automation_update".to_string(), - description: "Create, update, view, or delete recurring automations." - .to_string(), - strict: false, - defer_loading: Some(true), - parameters: codex_tools::JsonSchema::object( - std::collections::BTreeMap::from([( - "mode".to_string(), - codex_tools::JsonSchema::string(/*description*/ None), - )]), - Some(vec!["mode".to_string()]), - Some(false.into()), - ), - output_schema: None, + LoadableToolSpec::Namespace(ResponsesApiNamespace { + name: "codex_app".to_string(), + description: "Tools in the codex_app namespace.".to_string(), + tools: vec![ResponsesApiNamespaceTool::Function(ResponsesApiTool { + name: "automation_update".to_string(), + description: "Create, update, view, or delete recurring automations." + .to_string(), + strict: false, + defer_loading: Some(true), + parameters: codex_tools::JsonSchema::object( + std::collections::BTreeMap::from([( + "mode".to_string(), + codex_tools::JsonSchema::string(/*description*/ None), + )]), + Some(vec!["mode".to_string()]), + Some(false.into()), + ), + output_schema: None, + })], }), ], ); diff --git a/codex-rs/core/src/tools/handlers/tool_suggest.rs b/codex-rs/core/src/tools/handlers/tool_suggest.rs index cc433601bc..5c51c90d66 100644 --- a/codex-rs/core/src/tools/handlers/tool_suggest.rs +++ b/codex-rs/core/src/tools/handlers/tool_suggest.rs @@ -34,6 +34,10 @@ impl ToolHandler for ToolSuggestHandler { ToolKind::Function } + #[expect( + clippy::await_holding_invalid_type, + reason = "tool suggestion discovery reads through the session-owned manager guard" + )] async fn handle(&self, invocation: ToolInvocation) -> Result { let ToolInvocation { payload, @@ -193,6 +197,10 @@ async fn verify_tool_suggestion_completed( } } +#[expect( + clippy::await_holding_invalid_type, + reason = "connector cache refresh reads through the session-owned manager guard" +)] async fn refresh_missing_suggested_connectors( session: &crate::session::session::Session, turn: &crate::session::turn_context::TurnContext, diff --git a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs b/codex-rs/core/src/tools/handlers/unified_exec_tests.rs index da3308771c..988d224838 100644 --- a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs +++ b/codex-rs/core/src/tools/handlers/unified_exec_tests.rs @@ -210,6 +210,7 @@ async fn exec_command_pre_tool_use_payload_uses_raw_command() { handler.pre_tool_use_payload(&ToolInvocation { session: session.into(), turn: turn.into(), + cancellation_token: tokio_util::sync::CancellationToken::new(), tracker: Arc::new(Mutex::new(TurnDiffTracker::new())), call_id: "call-43".to_string(), tool_name: codex_tools::ToolName::plain("exec_command"), @@ -233,6 +234,7 @@ async fn exec_command_pre_tool_use_payload_skips_write_stdin() { handler.pre_tool_use_payload(&ToolInvocation { session: session.into(), turn: turn.into(), + cancellation_token: tokio_util::sync::CancellationToken::new(), tracker: Arc::new(Mutex::new(TurnDiffTracker::new())), call_id: "call-44".to_string(), tool_name: codex_tools::ToolName::plain("write_stdin"), diff --git a/codex-rs/core/src/tools/js_repl/mod.rs b/codex-rs/core/src/tools/js_repl/mod.rs index 23f4906e5f..d38ecae44c 100644 --- a/codex-rs/core/src/tools/js_repl/mod.rs +++ b/codex-rs/core/src/tools/js_repl/mod.rs @@ -132,6 +132,7 @@ struct KernelState { struct ExecContext { session: Arc, turn: Arc, + cancellation_token: CancellationToken, tracker: SharedTurnDiffTracker, } @@ -836,12 +837,29 @@ impl JsReplManager { } } + #[cfg(test)] pub async fn execute( &self, session: Arc, turn: Arc, tracker: SharedTurnDiffTracker, args: JsReplArgs, + ) -> Result { + self.execute_with_cancellation(session, turn, CancellationToken::new(), tracker, args) + .await + } + + #[expect( + clippy::await_holding_invalid_type, + reason = "js_repl kernel initialization must be serialized with kernel state" + )] + pub async fn execute_with_cancellation( + &self, + session: Arc, + turn: Arc, + cancellation_token: CancellationToken, + tracker: SharedTurnDiffTracker, + args: JsReplArgs, ) -> Result { let _permit = self.exec_lock.clone().acquire_owned().await.map_err(|_| { FunctionCallError::RespondToModel("js_repl execution unavailable".to_string()) @@ -892,6 +910,7 @@ impl JsReplManager { ExecContext { session: Arc::clone(&session), turn: Arc::clone(&turn), + cancellation_token, tracker, }, ); @@ -1162,6 +1181,10 @@ impl JsReplManager { Ok(kernel_path) } + #[expect( + clippy::await_holding_invalid_type, + reason = "js_repl stdin writes must be serialized per kernel" + )] async fn write_message( stdin: &Arc>, msg: &HostToKernel, @@ -1209,6 +1232,10 @@ impl JsReplManager { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "js_repl child shutdown must serialize process inspection and termination" + )] async fn kill_kernel_child(child: &Arc>, reason: &'static str) { let mut guard = child.lock().await; let pid = guard.id(); @@ -1532,6 +1559,10 @@ impl JsReplManager { } } + #[expect( + clippy::await_holding_invalid_type, + reason = "nested js_repl tool routing reads through the session-owned manager guard" + )] async fn run_tool_request(exec: ExecContext, req: RunToolRequest) -> RunToolResult { if is_js_repl_internal_tool(&req.tool_name) { let error = "js_repl cannot invoke itself".to_string(); @@ -1588,7 +1619,11 @@ impl JsReplManager { ResponsesApiNamespaceTool::Function(tool) => { let tool_name = ToolName::namespaced(namespace.name.clone(), tool.name.clone()); - (tool_name.display() == req.tool_name).then_some(tool_name) + let code_mode_name = + codex_tools::code_mode_name_for_tool_name(&tool_name); + (code_mode_name == req.tool_name + || tool_name.display() == req.tool_name) + .then_some(tool_name) } }) } @@ -1640,12 +1675,14 @@ impl JsReplManager { let session = Arc::clone(&exec.session); let turn = Arc::clone(&exec.turn); + let cancellation_token = exec.cancellation_token.clone(); let tracker = Arc::clone(&exec.tracker); match router .dispatch_tool_call_with_code_mode_result( session, turn, + cancellation_token, tracker, call, crate::tools::router::ToolCallSource::JsRepl, diff --git a/codex-rs/core/src/tools/js_repl/mod_tests.rs b/codex-rs/core/src/tools/js_repl/mod_tests.rs index af53a59757..7c6a2d070a 100644 --- a/codex-rs/core/src/tools/js_repl/mod_tests.rs +++ b/codex-rs/core/src/tools/js_repl/mod_tests.rs @@ -1819,6 +1819,7 @@ async fn js_repl_emit_image_rejects_mixed_content() -> anyhow::Result<()> { let (session, turn, rx_event) = make_session_and_context_with_dynamic_tools_and_rx(vec![DynamicToolSpec { + namespace: None, name: "inline_image".to_string(), description: "Returns inline text and image content.".to_string(), input_schema: serde_json::json!({ @@ -1918,6 +1919,7 @@ async fn js_repl_dynamic_tool_response_preserves_js_line_separator_text() -> any ] { let (session, turn, rx_event) = make_session_and_context_with_dynamic_tools_and_rx(vec![DynamicToolSpec { + namespace: None, name: tool_name.to_string(), description: description.to_string(), input_schema: serde_json::json!({ @@ -1993,6 +1995,7 @@ async fn js_repl_can_call_hidden_dynamic_tools() -> anyhow::Result<()> { let (session, turn, rx_event) = make_session_and_context_with_dynamic_tools_and_rx(vec![DynamicToolSpec { + namespace: Some("codex_app".to_string()), name: "hidden_dynamic_tool".to_string(), description: "A hidden dynamic tool.".to_string(), input_schema: serde_json::json!({ @@ -2012,7 +2015,7 @@ async fn js_repl_can_call_hidden_dynamic_tools() -> anyhow::Result<()> { let tracker = Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::default())); let manager = turn.js_repl.manager().await?; let code = r#" -const out = await codex.tool("hidden_dynamic_tool", { city: "Paris" }); +const out = await codex.tool("codex_app_hidden_dynamic_tool", { city: "Paris" }); console.log(JSON.stringify(out)); "#; diff --git a/codex-rs/core/src/tools/parallel.rs b/codex-rs/core/src/tools/parallel.rs index 41aaece468..4b3f87ae95 100644 --- a/codex-rs/core/src/tools/parallel.rs +++ b/codex-rs/core/src/tools/parallel.rs @@ -93,6 +93,7 @@ impl ToolCallRuntime { let turn = Arc::clone(&self.turn_context); let tracker = Arc::clone(&self.tracker); let lock = Arc::clone(&self.parallel_execution); + let invocation_cancellation_token = cancellation_token.clone(); let started = Instant::now(); let display_name = call.tool_name.display(); let join_error_call = call.clone(); @@ -124,6 +125,7 @@ impl ToolCallRuntime { .dispatch_tool_call_with_code_mode_result( session, turn, + invocation_cancellation_token, tracker, call.clone(), source, diff --git a/codex-rs/core/src/tools/registry.rs b/codex-rs/core/src/tools/registry.rs index 4c0e3fbea8..aca1d10144 100644 --- a/codex-rs/core/src/tools/registry.rs +++ b/codex-rs/core/src/tools/registry.rs @@ -239,6 +239,10 @@ impl ToolRegistry { // } // } + #[expect( + clippy::await_holding_invalid_type, + reason = "tool dispatch must keep active-turn accounting atomic" + )] pub(crate) async fn dispatch_any( &self, invocation: ToolInvocation, diff --git a/codex-rs/core/src/tools/router.rs b/codex-rs/core/src/tools/router.rs index fa2633bc31..c3b4b86d36 100644 --- a/codex-rs/core/src/tools/router.rs +++ b/codex-rs/core/src/tools/router.rs @@ -24,6 +24,7 @@ use codex_tools::ToolsConfig; use std::collections::HashMap; use std::collections::HashSet; use std::sync::Arc; +use tokio_util::sync::CancellationToken; use tracing::instrument; pub use crate::tools::context::ToolCallSource; @@ -267,6 +268,7 @@ impl ToolRouter { &self, session: Arc, turn: Arc, + cancellation_token: CancellationToken, tracker: SharedTurnDiffTracker, call: ToolCall, source: ToolCallSource, @@ -292,6 +294,7 @@ impl ToolRouter { let invocation = ToolInvocation { session, turn, + cancellation_token, tracker, call_id, tool_name, diff --git a/codex-rs/core/src/tools/router_tests.rs b/codex-rs/core/src/tools/router_tests.rs index 1a59f1e1ba..c83c65fc4e 100644 --- a/codex-rs/core/src/tools/router_tests.rs +++ b/codex-rs/core/src/tools/router_tests.rs @@ -7,6 +7,7 @@ use crate::tools::context::ToolPayload; use crate::turn_diff_tracker::TurnDiffTracker; use codex_protocol::models::ResponseItem; use codex_tools::ToolName; +use tokio_util::sync::CancellationToken; use super::ToolCall; use super::ToolCallSource; @@ -14,6 +15,10 @@ use super::ToolRouter; use super::ToolRouterParams; #[tokio::test] +#[expect( + clippy::await_holding_invalid_type, + reason = "test builds a router from session-owned MCP manager state" +)] async fn js_repl_tools_only_blocks_direct_tool_calls() -> anyhow::Result<()> { let (session, mut turn) = make_session_and_context().await; turn.tools_config.js_repl_tools_only = true; @@ -52,6 +57,7 @@ async fn js_repl_tools_only_blocks_direct_tool_calls() -> anyhow::Result<()> { .dispatch_tool_call_with_code_mode_result( session, turn, + CancellationToken::new(), tracker, call, ToolCallSource::Direct, @@ -68,6 +74,10 @@ async fn js_repl_tools_only_blocks_direct_tool_calls() -> anyhow::Result<()> { } #[tokio::test] +#[expect( + clippy::await_holding_invalid_type, + reason = "test builds a router from session-owned MCP manager state" +)] async fn js_repl_tools_only_allows_js_repl_source_calls() -> anyhow::Result<()> { let (session, mut turn) = make_session_and_context().await; turn.tools_config.js_repl_tools_only = true; @@ -106,6 +116,7 @@ async fn js_repl_tools_only_allows_js_repl_source_calls() -> anyhow::Result<()> .dispatch_tool_call_with_code_mode_result( session, turn, + CancellationToken::new(), tracker, call, ToolCallSource::JsRepl, @@ -155,6 +166,7 @@ async fn js_repl_tools_only_blocks_namespaced_js_repl_tool() -> anyhow::Result<( .dispatch_tool_call_with_code_mode_result( session, turn, + CancellationToken::new(), tracker, call, ToolCallSource::Direct, @@ -171,6 +183,10 @@ async fn js_repl_tools_only_blocks_namespaced_js_repl_tool() -> anyhow::Result<( } #[tokio::test] +#[expect( + clippy::await_holding_invalid_type, + reason = "test builds a router from session-owned MCP manager state" +)] async fn parallel_support_does_not_match_namespaced_local_tool_names() -> anyhow::Result<()> { let (session, turn) = make_session_and_context().await; let mcp_tools = session diff --git a/codex-rs/core/src/tools/runtimes/mod.rs b/codex-rs/core/src/tools/runtimes/mod.rs index 466a01effb..2246fa18f5 100644 --- a/codex-rs/core/src/tools/runtimes/mod.rs +++ b/codex-rs/core/src/tools/runtimes/mod.rs @@ -8,6 +8,12 @@ use crate::exec_env::CODEX_THREAD_ID_ENV_VAR; use crate::path_utils; use crate::shell::Shell; use crate::tools::sandboxing::ToolError; +#[cfg(target_os = "macos")] +use codex_network_proxy::CODEX_PROXY_GIT_SSH_COMMAND_MARKER; +use codex_network_proxy::PROXY_ACTIVE_ENV_KEY; +use codex_network_proxy::PROXY_ENV_KEYS; +#[cfg(target_os = "macos")] +use codex_network_proxy::PROXY_GIT_SSH_COMMAND_ENV_KEY; use codex_protocol::models::PermissionProfile; use codex_sandboxing::SandboxCommand; use codex_utils_absolute_path::AbsolutePathBuf; @@ -102,6 +108,9 @@ pub(crate) fn maybe_wrap_shell_lc_with_snapshot( override_env.insert(CODEX_THREAD_ID_ENV_VAR.to_string(), thread_id.clone()); } let (override_captures, override_exports) = build_override_exports(&override_env); + let (proxy_captures, proxy_exports) = build_proxy_env_exports(); + let override_captures = join_shell_blocks([override_captures, proxy_captures]); + let override_exports = join_shell_blocks([override_exports, proxy_exports]); let rewritten_script = if override_exports.is_empty() { format!( "if . '{snapshot_path}' >/dev/null 2>&1; then :; fi\n\nexec '{original_shell}' -c '{original_script}'{trailing_args}" @@ -118,10 +127,59 @@ pub(crate) fn maybe_wrap_shell_lc_with_snapshot( fn build_override_exports(explicit_env_overrides: &HashMap) -> (String, String) { let mut keys = explicit_env_overrides .keys() + .map(String::as_str) .filter(|key| is_valid_shell_variable_name(key)) .collect::>(); keys.sort_unstable(); + build_override_exports_for_keys("__CODEX_SNAPSHOT_OVERRIDE", &keys) +} + +fn build_proxy_env_exports() -> (String, String) { + let mut keys = PROXY_ENV_KEYS + .iter() + .copied() + .filter(|key| is_valid_shell_variable_name(key)) + .collect::>(); + keys.sort_unstable(); + keys.dedup(); + + let (captures, restores) = + build_override_exports_for_keys("__CODEX_SNAPSHOT_PROXY_OVERRIDE", &keys); + let key = PROXY_ACTIVE_ENV_KEY; + let proxy_blocks = ( + format!("{captures}\n__CODEX_SNAPSHOT_PROXY_ENV_SET=\"${{{key}+x}}\""), + format!( + "if [ -n \"$__CODEX_SNAPSHOT_PROXY_ENV_SET\" ] || [ -n \"${{{key}+x}}\" ]; then\n{restores}\nfi" + ), + ); + let git_blocks = build_codex_proxy_git_ssh_command_exports(); + ( + join_shell_blocks([proxy_blocks.0, git_blocks.0]), + join_shell_blocks([proxy_blocks.1, git_blocks.1]), + ) +} + +#[cfg(target_os = "macos")] +fn build_codex_proxy_git_ssh_command_exports() -> (String, String) { + let key = PROXY_GIT_SSH_COMMAND_ENV_KEY; + let marker_pattern = format!("{}\\ *", CODEX_PROXY_GIT_SSH_COMMAND_MARKER.trim_end()); + ( + format!( + "__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_SET=\"${{{key}+x}}\"\n__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND=\"${{{key}-}}\"\ncase \"$__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND\" in\n {marker_pattern}) __CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_LIVE_MARKED=1 ;;\n *) __CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_LIVE_MARKED= ;;\nesac" + ), + format!( + "case \"${{{key}-}}\" in\n {marker_pattern}) __CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_AFTER_MARKED=1 ;;\n *) __CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_AFTER_MARKED= ;;\nesac\nif [ -n \"$__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_LIVE_MARKED\" ]; then\n if [ -z \"${{{key}+x}}\" ] || [ -n \"$__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_AFTER_MARKED\" ]; then\n export {key}=\"$__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND\"\n fi\nelif [ -n \"$__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_AFTER_MARKED\" ]; then\n if [ -n \"$__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND_SET\" ]; then\n export {key}=\"$__CODEX_SNAPSHOT_PROXY_GIT_SSH_COMMAND\"\n else\n unset {key}\n fi\nfi" + ), + ) +} + +#[cfg(not(target_os = "macos"))] +fn build_codex_proxy_git_ssh_command_exports() -> (String, String) { + (String::new(), String::new()) +} + +fn build_override_exports_for_keys(variable_prefix: &str, keys: &[&str]) -> (String, String) { if keys.is_empty() { return (String::new(), String::new()); } @@ -130,9 +188,9 @@ fn build_override_exports(explicit_env_overrides: &HashMap) -> ( .iter() .enumerate() .map(|(idx, key)| { - format!( - "__CODEX_SNAPSHOT_OVERRIDE_SET_{idx}=\"${{{key}+x}}\"\n__CODEX_SNAPSHOT_OVERRIDE_{idx}=\"${{{key}-}}\"" - ) + let set_var = format!("{variable_prefix}_SET_{idx}"); + let value_var = format!("{variable_prefix}_{idx}"); + format!("{set_var}=\"${{{key}+x}}\"\n{value_var}=\"${{{key}-}}\"") }) .collect::>() .join("\n"); @@ -140,8 +198,10 @@ fn build_override_exports(explicit_env_overrides: &HashMap) -> ( .iter() .enumerate() .map(|(idx, key)| { + let set_var = format!("{variable_prefix}_SET_{idx}"); + let value_var = format!("{variable_prefix}_{idx}"); format!( - "if [ -n \"${{__CODEX_SNAPSHOT_OVERRIDE_SET_{idx}}}\" ]; then export {key}=\"${{__CODEX_SNAPSHOT_OVERRIDE_{idx}}}\"; else unset {key}; fi" + "if [ -n \"${{{set_var}}}\" ]; then export {key}=\"${{{value_var}}}\"; else unset {key}; fi" ) }) .collect::>() @@ -150,6 +210,14 @@ fn build_override_exports(explicit_env_overrides: &HashMap) -> ( (captures, restores) } +fn join_shell_blocks(blocks: impl IntoIterator) -> String { + blocks + .into_iter() + .filter(|block| !block.is_empty()) + .collect::>() + .join("\n") +} + fn is_valid_shell_variable_name(name: &str) -> bool { let mut chars = name.chars(); let Some(first) = chars.next() else { diff --git a/codex-rs/core/src/tools/runtimes/mod_tests.rs b/codex-rs/core/src/tools/runtimes/mod_tests.rs index aee70d233b..0c9acd4137 100644 --- a/codex-rs/core/src/tools/runtimes/mod_tests.rs +++ b/codex-rs/core/src/tools/runtimes/mod_tests.rs @@ -1,6 +1,11 @@ use super::*; use crate::shell::ShellType; use crate::shell_snapshot::ShellSnapshot; +#[cfg(target_os = "macos")] +use codex_network_proxy::CODEX_PROXY_GIT_SSH_COMMAND_MARKER; +use codex_network_proxy::PROXY_ACTIVE_ENV_KEY; +#[cfg(target_os = "macos")] +use codex_network_proxy::PROXY_GIT_SSH_COMMAND_ENV_KEY; use codex_utils_absolute_path::AbsolutePathBuf; use core_test_support::PathBufExt; use core_test_support::PathExt; @@ -325,6 +330,289 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_codex_thread_id_from_env() { assert_eq!(String::from_utf8_lossy(&output.stdout), "nested-thread"); } +#[test] +fn maybe_wrap_shell_lc_with_snapshot_restores_proxy_env_from_process_env() { + let dir = tempdir().expect("create temp dir"); + let snapshot_path = dir.path().join("snapshot.sh"); + std::fs::write( + &snapshot_path, + "# Snapshot file\n\ + export PIP_PROXY='http://127.0.0.1:8080'\n\ + export HTTP_PROXY='http://127.0.0.1:8080'\n\ + export http_proxy='http://127.0.0.1:8080'\n\ + export GIT_SSH_COMMAND='ssh -o ProxyCommand=stale'\n", + ) + .expect("write snapshot"); + let session_shell = shell_with_snapshot( + ShellType::Bash, + "/bin/bash", + snapshot_path.abs(), + dir.path().abs(), + ); + let command = vec![ + "/bin/bash".to_string(), + "-lc".to_string(), + "printf '%s\\n%s\\n%s\\n%s' \"$PIP_PROXY\" \"$HTTP_PROXY\" \"$http_proxy\" \"$GIT_SSH_COMMAND\"" + .to_string(), + ]; + let rewritten = maybe_wrap_shell_lc_with_snapshot( + &command, + &session_shell, + &dir.path().abs(), + &HashMap::new(), + &HashMap::new(), + ); + let output = Command::new(&rewritten[0]) + .args(&rewritten[1..]) + .env(PROXY_ACTIVE_ENV_KEY, "1") + .env("PIP_PROXY", "http://127.0.0.1:4321") + .env("HTTP_PROXY", "http://127.0.0.1:4321") + .env("http_proxy", "http://127.0.0.1:4321") + .env("GIT_SSH_COMMAND", "ssh -o ProxyCommand=fresh") + .output() + .expect("run rewritten command"); + + assert!(output.status.success(), "command failed: {output:?}"); + assert_eq!( + String::from_utf8_lossy(&output.stdout), + "http://127.0.0.1:4321\n\ + http://127.0.0.1:4321\n\ + http://127.0.0.1:4321\n\ + ssh -o ProxyCommand=stale" + ); +} + +#[cfg(target_os = "macos")] +#[test] +fn maybe_wrap_shell_lc_with_snapshot_refreshes_codex_proxy_git_ssh_command() { + let dir = tempdir().expect("create temp dir"); + let snapshot_path = dir.path().join("snapshot.sh"); + let stale_command = format!( + "{CODEX_PROXY_GIT_SSH_COMMAND_MARKER}ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'" + ); + let fresh_command = format!( + "{CODEX_PROXY_GIT_SSH_COMMAND_MARKER}ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:48081 %h %p'" + ); + std::fs::write( + &snapshot_path, + format!( + "# Snapshot file\nexport {PROXY_GIT_SSH_COMMAND_ENV_KEY}='{}'\n", + shell_single_quote(&stale_command) + ), + ) + .expect("write snapshot"); + let session_shell = shell_with_snapshot( + ShellType::Bash, + "/bin/bash", + snapshot_path.abs(), + dir.path().abs(), + ); + let command = vec![ + "/bin/bash".to_string(), + "-lc".to_string(), + format!("printf '%s' \"${PROXY_GIT_SSH_COMMAND_ENV_KEY}\""), + ]; + let rewritten = maybe_wrap_shell_lc_with_snapshot( + &command, + &session_shell, + &dir.path().abs(), + &HashMap::new(), + &HashMap::new(), + ); + let output = Command::new(&rewritten[0]) + .args(&rewritten[1..]) + .env(PROXY_GIT_SSH_COMMAND_ENV_KEY, &fresh_command) + .output() + .expect("run rewritten command"); + + assert!(output.status.success(), "command failed: {output:?}"); + assert_eq!(String::from_utf8_lossy(&output.stdout), fresh_command); +} + +#[cfg(target_os = "macos")] +#[test] +fn maybe_wrap_shell_lc_with_snapshot_restores_custom_git_ssh_command() { + let dir = tempdir().expect("create temp dir"); + let snapshot_path = dir.path().join("snapshot.sh"); + let stale_command = format!( + "{CODEX_PROXY_GIT_SSH_COMMAND_MARKER}ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'" + ); + let custom_command = "ssh -o ProxyCommand='tsh proxy ssh --cluster=dev %r@%h:%p'"; + std::fs::write( + &snapshot_path, + format!( + "# Snapshot file\nexport {PROXY_GIT_SSH_COMMAND_ENV_KEY}='{}'\n", + shell_single_quote(&stale_command) + ), + ) + .expect("write snapshot"); + let session_shell = shell_with_snapshot( + ShellType::Bash, + "/bin/bash", + snapshot_path.abs(), + dir.path().abs(), + ); + let command = vec![ + "/bin/bash".to_string(), + "-lc".to_string(), + format!("printf '%s' \"${PROXY_GIT_SSH_COMMAND_ENV_KEY}\""), + ]; + let rewritten = maybe_wrap_shell_lc_with_snapshot( + &command, + &session_shell, + &dir.path().abs(), + &HashMap::new(), + &HashMap::new(), + ); + let output = Command::new(&rewritten[0]) + .args(&rewritten[1..]) + .env(PROXY_GIT_SSH_COMMAND_ENV_KEY, custom_command) + .output() + .expect("run rewritten command"); + + assert!(output.status.success(), "command failed: {output:?}"); + assert_eq!(String::from_utf8_lossy(&output.stdout), custom_command); +} + +#[cfg(target_os = "macos")] +#[test] +fn maybe_wrap_shell_lc_with_snapshot_clears_stale_codex_git_ssh_command_without_live_command() { + let dir = tempdir().expect("create temp dir"); + let snapshot_path = dir.path().join("snapshot.sh"); + let stale_command = format!( + "{CODEX_PROXY_GIT_SSH_COMMAND_MARKER}ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'" + ); + std::fs::write( + &snapshot_path, + format!( + "# Snapshot file\nexport {PROXY_GIT_SSH_COMMAND_ENV_KEY}='{}'\n", + shell_single_quote(&stale_command) + ), + ) + .expect("write snapshot"); + let session_shell = shell_with_snapshot( + ShellType::Bash, + "/bin/bash", + snapshot_path.abs(), + dir.path().abs(), + ); + let command = vec![ + "/bin/bash".to_string(), + "-lc".to_string(), + format!( + "if [ \"${{{PROXY_GIT_SSH_COMMAND_ENV_KEY}+x}}\" = x ]; then printf 'set'; else printf 'unset'; fi" + ), + ]; + let rewritten = maybe_wrap_shell_lc_with_snapshot( + &command, + &session_shell, + &dir.path().abs(), + &HashMap::new(), + &HashMap::new(), + ); + let output = Command::new(&rewritten[0]) + .args(&rewritten[1..]) + .env_remove(PROXY_GIT_SSH_COMMAND_ENV_KEY) + .output() + .expect("run rewritten command"); + + assert!(output.status.success(), "command failed: {output:?}"); + assert_eq!(String::from_utf8_lossy(&output.stdout), "unset"); +} + +#[test] +fn maybe_wrap_shell_lc_with_snapshot_keeps_user_proxy_env_when_proxy_inactive() { + let dir = tempdir().expect("create temp dir"); + let snapshot_path = dir.path().join("snapshot.sh"); + std::fs::write( + &snapshot_path, + "# Snapshot file\nexport HTTP_PROXY='http://user.proxy:8080'\n", + ) + .expect("write snapshot"); + let session_shell = shell_with_snapshot( + ShellType::Bash, + "/bin/bash", + snapshot_path.abs(), + dir.path().abs(), + ); + let command = vec![ + "/bin/bash".to_string(), + "-lc".to_string(), + "printf '%s' \"$HTTP_PROXY\"".to_string(), + ]; + let rewritten = maybe_wrap_shell_lc_with_snapshot( + &command, + &session_shell, + &dir.path().abs(), + &HashMap::new(), + &HashMap::new(), + ); + let output = Command::new(&rewritten[0]) + .args(&rewritten[1..]) + .output() + .expect("run rewritten command"); + + assert!(output.status.success(), "command failed: {output:?}"); + assert_eq!( + String::from_utf8_lossy(&output.stdout), + "http://user.proxy:8080" + ); +} + +#[test] +fn maybe_wrap_shell_lc_with_snapshot_restores_live_env_when_snapshot_proxy_active() { + let dir = tempdir().expect("create temp dir"); + let snapshot_path = dir.path().join("snapshot.sh"); + std::fs::write( + &snapshot_path, + format!( + "# Snapshot file\n\ + export {PROXY_ACTIVE_ENV_KEY}='1'\n\ + export PIP_PROXY='http://127.0.0.1:8080'\n\ + export HTTP_PROXY='http://127.0.0.1:8080'\n" + ), + ) + .expect("write snapshot"); + let session_shell = shell_with_snapshot( + ShellType::Bash, + "/bin/bash", + snapshot_path.abs(), + dir.path().abs(), + ); + let command = vec![ + "/bin/bash".to_string(), + "-lc".to_string(), + format!( + "if [ \"${{PIP_PROXY+x}}\" = x ]; then printf 'pip:%s\\n' \"$PIP_PROXY\"; else printf 'pip:unset\\n'; fi; \ + printf 'http:%s\\n' \"$HTTP_PROXY\"; \ + if [ \"${{{PROXY_ACTIVE_ENV_KEY}+x}}\" = x ]; then printf 'active:%s' \"${PROXY_ACTIVE_ENV_KEY}\"; else printf 'active:unset'; fi" + ), + ]; + let rewritten = maybe_wrap_shell_lc_with_snapshot( + &command, + &session_shell, + &dir.path().abs(), + &HashMap::new(), + &HashMap::from([( + "HTTP_PROXY".to_string(), + "http://user.proxy:8080".to_string(), + )]), + ); + let output = Command::new(&rewritten[0]) + .args(&rewritten[1..]) + .env("HTTP_PROXY", "http://user.proxy:8080") + .env_remove("PIP_PROXY") + .env_remove(PROXY_ACTIVE_ENV_KEY) + .output() + .expect("run rewritten command"); + + assert!(output.status.success(), "command failed: {output:?}"); + assert_eq!( + String::from_utf8_lossy(&output.stdout), + "pip:unset\nhttp:http://user.proxy:8080\nactive:unset" + ); +} + #[test] fn maybe_wrap_shell_lc_with_snapshot_keeps_snapshot_path_without_override() { let dir = tempdir().expect("create temp dir"); diff --git a/codex-rs/core/src/tools/spec_tests.rs b/codex-rs/core/src/tools/spec_tests.rs index d37d94c13f..a1e685df75 100644 --- a/codex-rs/core/src/tools/spec_tests.rs +++ b/codex-rs/core/src/tools/spec_tests.rs @@ -742,10 +742,11 @@ async fn spawn_agent_description_omits_usage_hint_when_disabled() { assert_regex_match( r#"(?sx) ^\s* - No\ picker-visible\ models\ are\ currently\ loaded\. + No\ picker-visible\ model\ overrides\ are\ currently\ loaded\. \s+Spawns\ an\ agent\ to\ work\ on\ the\ specified\ task\.\ If\ your\ current\ task\ is\ `/root/task1`\ and\ you\ spawn_agent\ with\ task_name\ "task_3"\ the\ agent\ will\ have\ canonical\ task\ name\ `/root/task1/task_3`\. \s+You\ are\ then\ able\ to\ refer\ to\ this\ agent\ as\ `task_3`\ or\ `/root/task1/task_3`\ interchangeably\.\ However\ an\ agent\ `/root/task2/task_3`\ would\ only\ be\ able\ to\ communicate\ with\ this\ agent\ via\ its\ canonical\ name\ `/root/task1/task_3`\. \s+The\ spawned\ agent\ will\ have\ the\ same\ tools\ as\ you\ and\ the\ ability\ to\ spawn\ its\ own\ subagents\. + \s+Spawned\ agents\ inherit\ your\ current\ model\ by\ default\.\ Omit\ `model`\ to\ use\ that\ preferred\ default;\ set\ `model`\ only\ when\ an\ explicit\ override\ is\ needed\. \s+It\ will\ be\ able\ to\ send\ you\ and\ other\ running\ agents\ messages,\ and\ its\ final\ answer\ will\ be\ provided\ to\ you\ when\ it\ finishes\. \s+The\ new\ agent's\ canonical\ task\ name\ will\ be\ provided\ to\ it\ along\ with\ the\ message\. \s*$ @@ -766,10 +767,11 @@ async fn spawn_agent_description_uses_configured_usage_hint_text() { assert_regex_match( r#"(?sx) ^\s* - No\ picker-visible\ models\ are\ currently\ loaded\. + No\ picker-visible\ model\ overrides\ are\ currently\ loaded\. \s+Spawns\ an\ agent\ to\ work\ on\ the\ specified\ task\.\ If\ your\ current\ task\ is\ `/root/task1`\ and\ you\ spawn_agent\ with\ task_name\ "task_3"\ the\ agent\ will\ have\ canonical\ task\ name\ `/root/task1/task_3`\. \s+You\ are\ then\ able\ to\ refer\ to\ this\ agent\ as\ `task_3`\ or\ `/root/task1/task_3`\ interchangeably\.\ However\ an\ agent\ `/root/task2/task_3`\ would\ only\ be\ able\ to\ communicate\ with\ this\ agent\ via\ its\ canonical\ name\ `/root/task1/task_3`\. \s+The\ spawned\ agent\ will\ have\ the\ same\ tools\ as\ you\ and\ the\ ability\ to\ spawn\ its\ own\ subagents\. + \s+Spawned\ agents\ inherit\ your\ current\ model\ by\ default\.\ Omit\ `model`\ to\ use\ that\ preferred\ default;\ set\ `model`\ only\ when\ an\ explicit\ override\ is\ needed\. \s+It\ will\ be\ able\ to\ send\ you\ and\ other\ running\ agents\ messages,\ and\ its\ final\ answer\ will\ be\ provided\ to\ you\ when\ it\ finishes\. \s+The\ new\ agent's\ canonical\ task\ name\ will\ be\ provided\ to\ it\ along\ with\ the\ message\. \s+Custom\ delegation\ guidance\ only\. diff --git a/codex-rs/core/src/tools/tool_search_entry.rs b/codex-rs/core/src/tools/tool_search_entry.rs index 6fa493132a..23535439f6 100644 --- a/codex-rs/core/src/tools/tool_search_entry.rs +++ b/codex-rs/core/src/tools/tool_search_entry.rs @@ -1,15 +1,15 @@ use codex_mcp::ToolInfo; use codex_protocol::dynamic_tools::DynamicToolSpec; -use codex_tools::ToolSearchOutputTool; +use codex_tools::LoadableToolSpec; use codex_tools::ToolSearchResultSource; -use codex_tools::dynamic_tool_to_responses_api_tool; -use codex_tools::tool_search_result_source_to_output_tool; +use codex_tools::dynamic_tool_to_loadable_tool_spec; +use codex_tools::tool_search_result_source_to_loadable_tool_spec; use std::collections::HashMap; #[derive(Clone)] pub(crate) struct ToolSearchEntry { pub(crate) search_text: String, - pub(crate) output: ToolSearchOutputTool, + pub(crate) output: LoadableToolSpec, pub(crate) limit_bucket: Option, } @@ -36,7 +36,7 @@ pub(crate) fn build_tool_search_entries( } let mut dynamic_tools = dynamic_tools.iter().collect::>(); - dynamic_tools.sort_by(|a, b| a.name.cmp(&b.name)); + dynamic_tools.sort_by(|a, b| a.namespace.cmp(&b.namespace).then(a.name.cmp(&b.name))); for tool in dynamic_tools { match dynamic_tool_search_entry(tool) { Ok(entry) => entries.push(entry), @@ -55,7 +55,7 @@ pub(crate) fn build_tool_search_entries( fn mcp_tool_search_entry(info: &ToolInfo) -> Result { Ok(ToolSearchEntry { search_text: build_mcp_search_text(info), - output: tool_search_result_source_to_output_tool(ToolSearchResultSource { + output: tool_search_result_source_to_loadable_tool_spec(ToolSearchResultSource { server_name: info.server_name.as_str(), tool_namespace: info.callable_namespace.as_str(), tool_name: info.callable_name.as_str(), @@ -70,7 +70,7 @@ fn mcp_tool_search_entry(info: &ToolInfo) -> Result Result { Ok(ToolSearchEntry { search_text: build_dynamic_search_text(tool), - output: ToolSearchOutputTool::Function(dynamic_tool_to_responses_api_tool(tool)?), + output: dynamic_tool_to_loadable_tool_spec(tool)?, limit_bucket: None, }) } @@ -135,6 +135,10 @@ fn build_dynamic_search_text(tool: &DynamicToolSpec) -> String { tool.description.clone(), ]; + if let Some(namespace) = &tool.namespace { + parts.push(namespace.clone()); + } + parts.extend( tool.input_schema .get("properties") diff --git a/codex-rs/core/src/user_shell_command.rs b/codex-rs/core/src/user_shell_command.rs index e244be0d2a..cf034faca0 100644 --- a/codex-rs/core/src/user_shell_command.rs +++ b/codex-rs/core/src/user_shell_command.rs @@ -1,45 +1,27 @@ -use std::time::Duration; - use codex_protocol::exec_output::ExecToolCallOutput; use codex_protocol::models::ResponseItem; -use crate::contextual_user_message::USER_SHELL_COMMAND_FRAGMENT; +use crate::context::ContextualUserFragment; +use crate::context::UserShellCommand; use crate::session::turn_context::TurnContext; use crate::tools::format_exec_output_str; -fn format_duration_line(duration: Duration) -> String { - let duration_seconds = duration.as_secs_f64(); - format!("Duration: {duration_seconds:.4} seconds") -} - -fn format_user_shell_command_body( +fn user_shell_command_fragment( command: &str, exec_output: &ExecToolCallOutput, turn_context: &TurnContext, -) -> String { - let mut sections = Vec::new(); - sections.push("".to_string()); - sections.push(command.to_string()); - sections.push("".to_string()); - sections.push("".to_string()); - sections.push(format!("Exit code: {}", exec_output.exit_code)); - sections.push(format_duration_line(exec_output.duration)); - sections.push("Output:".to_string()); - sections.push(format_exec_output_str( - exec_output, - turn_context.truncation_policy, - )); - sections.push("".to_string()); - sections.join("\n") +) -> UserShellCommand { + let output = format_exec_output_str(exec_output, turn_context.truncation_policy); + UserShellCommand::new(command, exec_output.exit_code, exec_output.duration, output) } +#[cfg(test)] pub fn format_user_shell_command_record( command: &str, exec_output: &ExecToolCallOutput, turn_context: &TurnContext, ) -> String { - let body = format_user_shell_command_body(command, exec_output, turn_context); - USER_SHELL_COMMAND_FRAGMENT.wrap(body) + user_shell_command_fragment(command, exec_output, turn_context).render() } pub fn user_shell_command_record_item( @@ -47,7 +29,7 @@ pub fn user_shell_command_record_item( exec_output: &ExecToolCallOutput, turn_context: &TurnContext, ) -> ResponseItem { - USER_SHELL_COMMAND_FRAGMENT.into_message(format_user_shell_command_record( + ContextualUserFragment::into(user_shell_command_fragment( command, exec_output, turn_context, diff --git a/codex-rs/core/src/user_shell_command_tests.rs b/codex-rs/core/src/user_shell_command_tests.rs index 7e68ca5fee..996d66919a 100644 --- a/codex-rs/core/src/user_shell_command_tests.rs +++ b/codex-rs/core/src/user_shell_command_tests.rs @@ -1,16 +1,18 @@ use super::*; +use crate::context::ContextualUserFragment; +use crate::context::UserShellCommand; use crate::session::tests::make_session_and_context; use codex_protocol::exec_output::StreamOutput; use codex_protocol::models::ContentItem; use pretty_assertions::assert_eq; +use std::time::Duration; #[test] fn detects_user_shell_command_text_variants() { - assert!( - USER_SHELL_COMMAND_FRAGMENT - .matches_text("\necho hi\n") - ); - assert!(!USER_SHELL_COMMAND_FRAGMENT.matches_text("echo hi")); + assert!(UserShellCommand::matches_text( + "\necho hi\n" + )); + assert!(!UserShellCommand::matches_text("echo hi")); } #[tokio::test] diff --git a/codex-rs/core/tests/responses_headers.rs b/codex-rs/core/tests/responses_headers.rs index db4dc794be..85b23af31f 100644 --- a/codex-rs/core/tests/responses_headers.rs +++ b/codex-rs/core/tests/responses_headers.rs @@ -57,6 +57,7 @@ async fn responses_stream_includes_subagent_header_on_review() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, @@ -181,6 +182,7 @@ async fn responses_stream_includes_subagent_header_on_other() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, @@ -290,6 +292,7 @@ async fn responses_respects_model_info_overrides_from_config() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, diff --git a/codex-rs/core/tests/suite/client.rs b/codex-rs/core/tests/suite/client.rs index 13a6073fa0..2086367b21 100644 --- a/codex-rs/core/tests/suite/client.rs +++ b/codex-rs/core/tests/suite/client.rs @@ -841,6 +841,7 @@ async fn send_provider_auth_request(server: &MockServer, auth: ModelProviderAuth env_key_instructions: None, experimental_bearer_token: None, auth: Some(auth), + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, @@ -2132,6 +2133,7 @@ async fn azure_responses_request_includes_store_and_reasoning_ids() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, @@ -2750,6 +2752,7 @@ async fn azure_overrides_assign_properties_used_for_responses_url() { env_key: Some(EXISTING_ENV_VAR_WITH_NON_EMPTY_VALUE.to_string()), experimental_bearer_token: None, auth: None, + aws: None, query_params: Some(std::collections::HashMap::from([( "api-version".to_string(), "2025-04-01-preview".to_string(), @@ -2841,6 +2844,7 @@ async fn env_var_overrides_loaded_auth() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, http_headers: Some(std::collections::HashMap::from([( "Custom-Header".to_string(), diff --git a/codex-rs/core/tests/suite/client_websockets.rs b/codex-rs/core/tests/suite/client_websockets.rs index 883a244ad0..f6cfd0d913 100755 --- a/codex-rs/core/tests/suite/client_websockets.rs +++ b/codex-rs/core/tests/suite/client_websockets.rs @@ -1736,6 +1736,7 @@ fn websocket_provider_with_connect_timeout( env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, diff --git a/codex-rs/core/tests/suite/code_mode.rs b/codex-rs/core/tests/suite/code_mode.rs index 40a13467e7..3371ff45d6 100644 --- a/codex-rs/core/tests/suite/code_mode.rs +++ b/codex-rs/core/tests/suite/code_mode.rs @@ -2556,6 +2556,7 @@ async fn code_mode_can_call_hidden_dynamic_tools() -> Result<()> { .start_thread_with_tools( base_test.config.clone(), vec![DynamicToolSpec { + namespace: Some("codex_app".to_string()), name: "hidden_dynamic_tool".to_string(), description: "A hidden dynamic tool.".to_string(), input_schema: serde_json::json!({ @@ -2576,8 +2577,8 @@ async fn code_mode_can_call_hidden_dynamic_tools() -> Result<()> { test.session_configured = new_thread.session_configured; let code = r#" -const tool = ALL_TOOLS.find(({ name }) => name === "hidden_dynamic_tool"); -const out = await tools.hidden_dynamic_tool({ city: "Paris" }); +const tool = ALL_TOOLS.find(({ name }) => name === "codex_app_hidden_dynamic_tool"); +const out = await tools.codex_app_hidden_dynamic_tool({ city: "Paris" }); text( JSON.stringify({ name: tool?.name ?? null, @@ -2636,6 +2637,7 @@ text( _ => None, }) .await; + assert_eq!(request.namespace.as_deref(), Some("codex_app")); assert_eq!(request.tool, "hidden_dynamic_tool"); assert_eq!(request.arguments, serde_json::json!({ "city": "Paris" })); test.codex @@ -2669,7 +2671,7 @@ text( )?; assert_eq!( parsed.get("name"), - Some(&Value::String("hidden_dynamic_tool".to_string())) + Some(&Value::String("codex_app_hidden_dynamic_tool".to_string())) ); assert_eq!( parsed.get("out"), @@ -2682,7 +2684,7 @@ text( .is_some_and(|description| { description.contains("A hidden dynamic tool.") && description.contains("declare const tools:") - && description.contains("hidden_dynamic_tool(args:") + && description.contains("codex_app_hidden_dynamic_tool(args:") }) ); diff --git a/codex-rs/core/tests/suite/realtime_conversation.rs b/codex-rs/core/tests/suite/realtime_conversation.rs index 0d6e130564..60167a1558 100644 --- a/codex-rs/core/tests/suite/realtime_conversation.rs +++ b/codex-rs/core/tests/suite/realtime_conversation.rs @@ -22,6 +22,7 @@ use codex_protocol::protocol::RealtimeAudioFrame; use codex_protocol::protocol::RealtimeConversationRealtimeEvent; use codex_protocol::protocol::RealtimeConversationVersion; use codex_protocol::protocol::RealtimeEvent; +use codex_protocol::protocol::RealtimeNoopRequested; use codex_protocol::protocol::RealtimeOutputModality; use codex_protocol::protocol::RealtimeVoice; use codex_protocol::protocol::RolloutItem; @@ -176,6 +177,11 @@ fn run_realtime_conversation_test_in_subprocess( .arg("--exact") .arg(test_name) .env(REALTIME_CONVERSATION_TEST_SUBPROCESS_ENV_VAR, "1"); + // The child talks to a loopback websocket server; parent proxy settings can + // route that connection away from the test server in Bazel environments. + for &key in codex_network_proxy::PROXY_ENV_KEYS { + command.env_remove(key); + } match openai_api_key { Some(openai_api_key) => { command.env(OPENAI_API_KEY_ENV_VAR, openai_api_key); @@ -2121,6 +2127,92 @@ async fn conversation_user_text_turn_is_capped_when_mirrored_to_realtime() -> Re Ok(()) } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn realtime_v2_noop_tool_call_returns_empty_function_output_without_response() -> Result<()> { + skip_if_no_network!(Ok(())); + + let api_server = start_mock_server().await; + let realtime_server = start_websocket_server(vec![vec![ + vec![ + json!({ + "type": "session.updated", + "session": { "id": "sess_silent", "instructions": "backend prompt" } + }), + json!({ + "type": "conversation.item.done", + "item": { + "id": "item_silent", + "type": "function_call", + "name": "remain_silent", + "call_id": "call_silent", + "arguments": "{}" + } + }), + ], + vec![], + ]]) + .await; + + let mut builder = test_codex().with_config({ + let realtime_base_url = realtime_server.uri().to_string(); + move |config| { + config.experimental_realtime_ws_base_url = Some(realtime_base_url); + config.realtime.version = RealtimeWsVersion::V2; + } + }); + let test = builder.build(&api_server).await?; + + test.codex + .submit(Op::RealtimeConversationStart(ConversationStartParams { + output_modality: RealtimeOutputModality::Audio, + prompt: Some(Some("backend prompt".to_string())), + session_id: None, + transport: None, + voice: None, + })) + .await?; + + let _ = wait_for_event_match(&test.codex, |msg| match msg { + EventMsg::RealtimeConversationRealtime(RealtimeConversationRealtimeEvent { + payload: RealtimeEvent::NoopRequested(RealtimeNoopRequested { call_id, .. }), + }) if call_id == "call_silent" => Some(()), + _ => None, + }) + .await; + + let function_output = realtime_server + .wait_for_request(/*connection_index*/ 0, /*request_index*/ 1) + .await; + assert_eq!( + function_output.body_json(), + json!({ + "type": "conversation.item.create", + "item": { + "type": "function_call_output", + "call_id": "call_silent", + "output": "" + } + }) + ); + + let realtime_response_create = timeout(Duration::from_millis(200), async { + wait_for_matching_websocket_request( + &realtime_server, + "unexpected realtime response request for noop tool call", + |request| request.body_json()["type"].as_str() == Some("response.create"), + ) + .await + }) + .await; + assert!( + realtime_response_create.is_err(), + "noop tool calls should not request a realtime response" + ); + + realtime_server.shutdown().await; + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn conversation_mirrors_assistant_message_text_to_realtime_handoff() -> Result<()> { skip_if_no_network!(Ok(())); @@ -2569,7 +2661,7 @@ async fn inbound_handoff_request_uses_active_transcript() -> Result<()> { } #[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn inbound_handoff_request_keeps_transcript_history_after_each_handoff() -> Result<()> { +async fn inbound_handoff_request_sends_transcript_delta_after_each_handoff() -> Result<()> { skip_if_no_network!(Ok(())); let api_server = start_mock_server().await; @@ -2681,9 +2773,9 @@ async fn inbound_handoff_request_keeps_transcript_history_after_each_handoff() - let second_user_texts = requests[1].message_input_texts("user"); assert!(second_user_texts.iter().any(|text| text - == "\n second question\n user: first question\nuser: second question\n")); + == "\n second question\n user: second question\n")); assert!(!second_user_texts.iter().any(|text| text - == "\n second question\n user: first questionsecond question\n")); + == "\n second question\n user: first question\nuser: second question\n")); realtime_server.shutdown().await; Ok(()) diff --git a/codex-rs/core/tests/suite/search_tool.rs b/codex-rs/core/tests/suite/search_tool.rs index ea87287473..2f24fba33e 100644 --- a/codex-rs/core/tests/suite/search_tool.rs +++ b/codex-rs/core/tests/suite/search_tool.rs @@ -730,6 +730,7 @@ async fn tool_search_returns_deferred_dynamic_tool_and_routes_follow_up_call() - "item": { "type": "function_call", "call_id": dynamic_call_id, + "namespace": "codex_app", "name": tool_name, "arguments": tool_call_arguments, } @@ -754,6 +755,7 @@ async fn tool_search_returns_deferred_dynamic_tool_and_routes_follow_up_call() - "additionalProperties": false, }); let dynamic_tool = DynamicToolSpec { + namespace: Some("codex_app".to_string()), name: tool_name.to_string(), description: tool_description.to_string(), input_schema: input_schema.clone(), @@ -793,6 +795,7 @@ async fn tool_search_returns_deferred_dynamic_tool_and_routes_follow_up_call() - unreachable!("event guard guarantees DynamicToolCallRequest"); }; assert_eq!(request.call_id, dynamic_call_id); + assert_eq!(request.namespace.as_deref(), Some("codex_app")); assert_eq!(request.tool, tool_name); assert_eq!(request.arguments, tool_args); @@ -832,12 +835,17 @@ async fn tool_search_returns_deferred_dynamic_tool_and_routes_follow_up_call() - assert_eq!( tools, vec![json!({ - "type": "function", - "name": tool_name, - "description": tool_description, - "strict": false, - "defer_loading": true, - "parameters": input_schema, + "type": "namespace", + "name": "codex_app", + "description": "Tools in the codex_app namespace.", + "tools": [{ + "type": "function", + "name": tool_name, + "description": tool_description, + "strict": false, + "defer_loading": true, + "parameters": input_schema, + }], })] ); diff --git a/codex-rs/core/tests/suite/spawn_agent_description.rs b/codex-rs/core/tests/suite/spawn_agent_description.rs index 1d2bd1ed05..a8b3bab952 100644 --- a/codex-rs/core/tests/suite/spawn_agent_description.rs +++ b/codex-rs/core/tests/suite/spawn_agent_description.rs @@ -170,6 +170,23 @@ async fn spawn_agent_description_lists_visible_models_and_reasoning_efforts() -> description.contains("- Visible Model (`visible-model`): Fast and capable"), "expected visible model summary in spawn_agent description: {description:?}" ); + assert!( + description + .contains("Available model overrides (optional; inherited parent model is preferred):"), + "expected model choices to be framed as overrides in spawn_agent description: {description:?}" + ); + assert!( + description.contains( + "Spawned agents inherit your current model by default. Omit `model` to use that preferred default; set `model` only when an explicit override is needed." + ), + "expected inherited-model guidance in spawn_agent description: {description:?}" + ); + assert!( + description.contains( + "Do not set the `model` field unless the user explicitly asks for a different model or there is a clear task-specific reason." + ), + "expected model override usage guidance in spawn_agent description: {description:?}" + ); assert!( description.contains("Default reasoning effort: medium."), "expected default reasoning effort in spawn_agent description: {description:?}" @@ -200,6 +217,10 @@ async fn spawn_agent_description_lists_visible_models_and_reasoning_efforts() -> ), "expected agent-role clarification in spawn_agent description: {description:?}" ); + assert!( + !description.contains("A mini model can solve many tasks faster than the main model."), + "spawn_agent description should not encourage choosing a smaller model by default: {description:?}" + ); Ok(()) } diff --git a/codex-rs/core/tests/suite/sqlite_state.rs b/codex-rs/core/tests/suite/sqlite_state.rs index e7125210b2..52f1f4648a 100644 --- a/codex-rs/core/tests/suite/sqlite_state.rs +++ b/codex-rs/core/tests/suite/sqlite_state.rs @@ -103,6 +103,7 @@ async fn backfill_scans_existing_rollouts() -> Result<()> { let dynamic_tools = vec![ DynamicToolSpec { + namespace: Some("codex_app".to_string()), name: "geo_lookup".to_string(), description: "lookup a city".to_string(), input_schema: json!({ @@ -113,6 +114,7 @@ async fn backfill_scans_existing_rollouts() -> Result<()> { defer_loading: true, }, DynamicToolSpec { + namespace: None, name: "weather_lookup".to_string(), description: "lookup weather".to_string(), input_schema: json!({ diff --git a/codex-rs/core/tests/suite/stream_error_allows_next_turn.rs b/codex-rs/core/tests/suite/stream_error_allows_next_turn.rs index 254ac7b12d..950306e97d 100644 --- a/codex-rs/core/tests/suite/stream_error_allows_next_turn.rs +++ b/codex-rs/core/tests/suite/stream_error_allows_next_turn.rs @@ -70,6 +70,7 @@ async fn continue_after_stream_error() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, diff --git a/codex-rs/core/tests/suite/stream_no_completed.rs b/codex-rs/core/tests/suite/stream_no_completed.rs index 149ba1c53d..2dd73e0f63 100644 --- a/codex-rs/core/tests/suite/stream_no_completed.rs +++ b/codex-rs/core/tests/suite/stream_no_completed.rs @@ -54,6 +54,7 @@ async fn retries_on_early_close() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, diff --git a/codex-rs/exec-server/src/client.rs b/codex-rs/exec-server/src/client.rs index 18cddfe84c..4e282c8fd3 100644 --- a/codex-rs/exec-server/src/client.rs +++ b/codex-rs/exec-server/src/client.rs @@ -2,12 +2,15 @@ use std::collections::BTreeMap; use std::collections::HashMap; use std::sync::Arc; use std::sync::Mutex as StdMutex; +use std::sync::OnceLock; +use std::sync::atomic::AtomicU64; use std::time::Duration; use arc_swap::ArcSwap; use codex_app_server_protocol::JSONRPCNotification; use serde_json::Value; use tokio::sync::Mutex; +use tokio::sync::mpsc; use tokio::sync::watch; use tokio::time::timeout; @@ -54,6 +57,8 @@ use crate::protocol::FsRemoveParams; use crate::protocol::FsRemoveResponse; use crate::protocol::FsWriteFileParams; use crate::protocol::FsWriteFileResponse; +use crate::protocol::HTTP_REQUEST_BODY_DELTA_METHOD; +use crate::protocol::HttpRequestBodyDeltaNotification; use crate::protocol::INITIALIZE_METHOD; use crate::protocol::INITIALIZED_METHOD; use crate::protocol::InitializeParams; @@ -69,6 +74,8 @@ use crate::rpc::RpcCallError; use crate::rpc::RpcClient; use crate::rpc::RpcClientEvent; +pub(crate) mod http_client; + const CONNECT_TIMEOUT: Duration = Duration::from_secs(10); const INITIALIZE_TIMEOUT: Duration = Duration::from_secs(10); const PROCESS_EVENT_CHANNEL_CAPACITY: usize = 256; @@ -140,6 +147,18 @@ struct Inner { // need serialization so concurrent register/remove operations do not // overwrite each other's copy-on-write updates. sessions_write_lock: Mutex<()>, + // Once the transport closes, every executor operation should fail quickly + // with the same canonical message. This client never reconnects, so the + // latch only moves from unset to set once. + disconnected: OnceLock, + // Streaming HTTP responses are keyed by a client-generated request id + // because they share the same connection-global notification channel as + // process output. Keep the routing table local to the client so higher + // layers can consume body chunks like a normal byte stream. + http_body_streams: ArcSwap>>, + http_body_stream_failures: ArcSwap>, + http_body_streams_write_lock: Mutex<()>, + http_body_stream_next_id: AtomicU64, session_id: std::sync::RwLock>, reader_task: tokio::task::JoinHandle<()>, } @@ -171,6 +190,8 @@ pub enum ExecServerError { InitializeTimedOut { timeout: Duration }, #[error("exec-server transport closed")] Closed, + #[error("{0}")] + Disconnected(String), #[error("failed to serialize or deserialize exec-server JSON: {0}")] Json(#[from] serde_json::Error), #[error("exec-server protocol error: {0}")] @@ -246,19 +267,11 @@ impl ExecServerClient { } pub async fn exec(&self, params: ExecParams) -> Result { - self.inner - .client - .call(EXEC_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(EXEC_METHOD, ¶ms).await } pub async fn read(&self, params: ReadParams) -> Result { - self.inner - .client - .call(EXEC_READ_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(EXEC_READ_METHOD, ¶ms).await } pub async fn write( @@ -266,107 +279,73 @@ impl ExecServerClient { process_id: &ProcessId, chunk: Vec, ) -> Result { - self.inner - .client - .call( - EXEC_WRITE_METHOD, - &WriteParams { - process_id: process_id.clone(), - chunk: chunk.into(), - }, - ) - .await - .map_err(Into::into) + self.call( + EXEC_WRITE_METHOD, + &WriteParams { + process_id: process_id.clone(), + chunk: chunk.into(), + }, + ) + .await } pub async fn terminate( &self, process_id: &ProcessId, ) -> Result { - self.inner - .client - .call( - EXEC_TERMINATE_METHOD, - &TerminateParams { - process_id: process_id.clone(), - }, - ) - .await - .map_err(Into::into) + self.call( + EXEC_TERMINATE_METHOD, + &TerminateParams { + process_id: process_id.clone(), + }, + ) + .await } pub async fn fs_read_file( &self, params: FsReadFileParams, ) -> Result { - self.inner - .client - .call(FS_READ_FILE_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(FS_READ_FILE_METHOD, ¶ms).await } pub async fn fs_write_file( &self, params: FsWriteFileParams, ) -> Result { - self.inner - .client - .call(FS_WRITE_FILE_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(FS_WRITE_FILE_METHOD, ¶ms).await } pub async fn fs_create_directory( &self, params: FsCreateDirectoryParams, ) -> Result { - self.inner - .client - .call(FS_CREATE_DIRECTORY_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(FS_CREATE_DIRECTORY_METHOD, ¶ms).await } pub async fn fs_get_metadata( &self, params: FsGetMetadataParams, ) -> Result { - self.inner - .client - .call(FS_GET_METADATA_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(FS_GET_METADATA_METHOD, ¶ms).await } pub async fn fs_read_directory( &self, params: FsReadDirectoryParams, ) -> Result { - self.inner - .client - .call(FS_READ_DIRECTORY_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(FS_READ_DIRECTORY_METHOD, ¶ms).await } pub async fn fs_remove( &self, params: FsRemoveParams, ) -> Result { - self.inner - .client - .call(FS_REMOVE_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(FS_REMOVE_METHOD, ¶ms).await } pub async fn fs_copy(&self, params: FsCopyParams) -> Result { - self.inner - .client - .call(FS_COPY_METHOD, ¶ms) - .await - .map_err(Into::into) + self.call(FS_COPY_METHOD, ¶ms).await } pub(crate) async fn register_session( @@ -411,18 +390,21 @@ impl ExecServerClient { && let Err(err) = handle_server_notification(&inner, notification).await { - fail_all_sessions( + let message = record_disconnected( &inner, format!("exec-server notification handling failed: {err}"), - ) - .await; + ); + fail_all_in_flight_work(&inner, message).await; return; } } RpcClientEvent::Disconnected { reason } => { if let Some(inner) = weak.upgrade() { - fail_all_sessions(&inner, disconnected_message(reason.as_deref())) - .await; + let message = record_disconnected( + &inner, + disconnected_message(reason.as_deref()), + ); + fail_all_in_flight_work(&inner, message).await; } return; } @@ -434,6 +416,11 @@ impl ExecServerClient { client: rpc_client, sessions: ArcSwap::from_pointee(HashMap::new()), sessions_write_lock: Mutex::new(()), + disconnected: OnceLock::new(), + http_body_streams: ArcSwap::from_pointee(HashMap::new()), + http_body_stream_failures: ArcSwap::from_pointee(HashMap::new()), + http_body_streams_write_lock: Mutex::new(()), + http_body_stream_next_id: AtomicU64::new(1), session_id: std::sync::RwLock::new(None), reader_task, } @@ -451,6 +438,36 @@ impl ExecServerClient { .await .map_err(ExecServerError::Json) } + + async fn call(&self, method: &str, params: &P) -> Result + where + P: serde::Serialize, + T: serde::de::DeserializeOwned, + { + // Reject new work before allocating a JSON-RPC request id. MCP tool + // calls, process writes, and fs operations all pass through here, so + // this is the shared low-level failure path after executor disconnect. + if let Some(error) = self.inner.disconnected_error() { + return Err(error); + } + + match self.inner.client.call(method, params).await { + Ok(response) => Ok(response), + Err(error) => { + let error = ExecServerError::from(error); + if is_transport_closed_error(&error) { + // A call can race with disconnect after the preflight + // check. Only the reader task drains sessions so queued + // process notifications stay ordered before disconnect. + let message = disconnected_message(/*reason*/ None); + let message = record_disconnected(&self.inner, message); + Err(ExecServerError::Disconnected(message)) + } else { + Err(error) + } + } + } + } } impl From for ExecServerError { @@ -630,6 +647,20 @@ impl Session { } impl Inner { + fn disconnected_error(&self) -> Option { + self.disconnected + .get() + .cloned() + .map(ExecServerError::Disconnected) + } + + fn set_disconnected(&self, message: String) -> Option { + match self.disconnected.set(message.clone()) { + Ok(()) => Some(message), + Err(_) => None, + } + } + fn get_session(&self, process_id: &ProcessId) -> Option> { self.sessions.load().get(process_id).cloned() } @@ -640,6 +671,12 @@ impl Inner { session: Arc, ) -> Result<(), ExecServerError> { let _sessions_write_guard = self.sessions_write_lock.lock().await; + // Do not register a process session that can never receive executor + // notifications. Without this check, remote MCP startup could create a + // dead session and wait for process output that will never arrive. + if let Some(error) = self.disconnected_error() { + return Err(error); + } let sessions = self.sessions.load(); if sessions.contains_key(process_id) { return Err(ExecServerError::Protocol(format!( @@ -680,24 +717,46 @@ fn disconnected_message(reason: Option<&str>) -> String { } fn is_transport_closed_error(error: &ExecServerError) -> bool { - matches!(error, ExecServerError::Closed) - || matches!( - error, - ExecServerError::Server { - code: -32000, - message, - } if message == "JSON-RPC transport closed" - ) + matches!( + error, + ExecServerError::Closed | ExecServerError::Disconnected(_) + ) || matches!( + error, + ExecServerError::Server { + code: -32000, + message, + } if message == "JSON-RPC transport closed" + ) +} + +fn record_disconnected(inner: &Arc, message: String) -> String { + // The first observer records the canonical disconnect reason. Session + // draining stays with the reader task so it can preserve notification + // ordering before publishing the terminal failure. + if let Some(message) = inner.set_disconnected(message.clone()) { + message + } else { + inner.disconnected.get().cloned().unwrap_or(message) + } } async fn fail_all_sessions(inner: &Arc, message: String) { let sessions = inner.take_all_sessions().await; for (_, session) in sessions { + // Sessions synthesize a closed read response and emit a pushed Failed + // event. That covers both polling consumers and streaming consumers + // such as executor-backed MCP stdio. session.set_failure(message.clone()).await; } } +/// Fails all in-flight work that depends on the shared JSON-RPC transport. +async fn fail_all_in_flight_work(inner: &Arc, message: String) { + fail_all_sessions(inner, message.clone()).await; + inner.fail_all_http_body_streams(message).await; +} + async fn handle_server_notification( inner: &Arc, notification: JSONRPCNotification, @@ -748,6 +807,11 @@ async fn handle_server_notification( } } } + HTTP_REQUEST_BODY_DELTA_METHOD => { + inner + .handle_http_body_delta_notification(notification.params) + .await?; + } other => { debug!("ignoring unknown exec-server notification: {other}"); } diff --git a/codex-rs/exec-server/src/client/http_client.rs b/codex-rs/exec-server/src/client/http_client.rs new file mode 100644 index 0000000000..a02a8be9a3 --- /dev/null +++ b/codex-rs/exec-server/src/client/http_client.rs @@ -0,0 +1,322 @@ +use std::collections::HashMap; +use std::sync::Arc; +use std::sync::atomic::Ordering; + +use serde_json::Value; +use serde_json::from_value; +use tokio::runtime::Handle; +use tokio::sync::mpsc; +use tokio::sync::mpsc::error::TrySendError; +use tracing::debug; + +use super::ExecServerClient; +use super::ExecServerError; +use super::Inner; +use crate::protocol::HTTP_REQUEST_METHOD; +use crate::protocol::HttpRequestBodyDeltaNotification; +use crate::protocol::HttpRequestParams; +use crate::protocol::HttpRequestResponse; + +/// Maximum queued body frames per streamed executor HTTP response. +const HTTP_BODY_DELTA_CHANNEL_CAPACITY: usize = 256; + +/// Request-scoped stream of body chunks for an executor HTTP response. +/// +/// The initial `http/request` call returns status and headers. This stream then +/// receives the ordered `http/request/bodyDelta` notifications for that request +/// id until EOF or a terminal error. +pub struct HttpResponseBodyStream { + inner: Arc, + request_id: String, + next_seq: u64, + rx: mpsc::Receiver, + // Terminal frames can carry a final chunk; return that once, then EOF. + pending_eof: bool, + closed: bool, +} + +impl HttpResponseBodyStream { + /// Receives the next response-body chunk. + /// + /// Returns `Ok(None)` at EOF and converts sequence gaps or executor-side + /// stream errors into protocol errors. + pub async fn recv(&mut self) -> Result>, ExecServerError> { + if self.pending_eof { + self.pending_eof = false; + self.finish().await; + return Ok(None); + } + + let Some(delta) = self.rx.recv().await else { + self.finish().await; + if let Some(error) = self + .inner + .take_http_body_stream_failure(&self.request_id) + .await + { + return Err(ExecServerError::Protocol(format!( + "http response stream `{}` failed: {error}", + self.request_id + ))); + } + return Ok(None); + }; + if delta.seq != self.next_seq { + self.finish().await; + return Err(ExecServerError::Protocol(format!( + "http response stream `{}` received seq {}, expected {}", + self.request_id, delta.seq, self.next_seq + ))); + } + self.next_seq += 1; + let chunk = delta.delta.into_inner(); + + if let Some(error) = delta.error { + self.finish().await; + return Err(ExecServerError::Protocol(format!( + "http response stream `{}` failed: {error}", + self.request_id + ))); + } + if delta.done { + self.finish().await; + if chunk.is_empty() { + return Ok(None); + } + self.pending_eof = true; + } + Ok(Some(chunk)) + } + + /// Removes this stream from the connection routing table once it reaches EOF. + async fn finish(&mut self) { + if self.closed { + return; + } + self.closed = true; + self.inner.remove_http_body_stream(&self.request_id).await; + } +} + +impl Drop for HttpResponseBodyStream { + /// Schedules stream-route removal if the consumer drops before EOF. + fn drop(&mut self) { + if self.closed { + return; + } + self.closed = true; + spawn_remove_http_body_stream(Arc::clone(&self.inner), self.request_id.clone()); + } +} + +/// Active route registration owned while `http_request_stream` awaits headers. +struct HttpBodyStreamRegistration { + inner: Arc, + request_id: String, + active: bool, +} + +impl Drop for HttpBodyStreamRegistration { + /// Removes the route if the stream request future is cancelled before headers return. + fn drop(&mut self) { + if self.active { + spawn_remove_http_body_stream(Arc::clone(&self.inner), self.request_id.clone()); + } + } +} + +impl ExecServerClient { + /// Performs an executor-side HTTP request and buffers the response body. + pub async fn http_request( + &self, + mut params: HttpRequestParams, + ) -> Result { + params.stream_response = false; + params.request_id = None; + self.call(HTTP_REQUEST_METHOD, ¶ms).await + } + + /// Performs an executor-side HTTP request and returns a body stream. + /// + /// The method sets `stream_response` and replaces any caller-supplied + /// `request_id` with a connection-local id, so late deltas from abandoned + /// streams cannot be confused with later requests. + pub async fn http_request_stream( + &self, + mut params: HttpRequestParams, + ) -> Result<(HttpRequestResponse, HttpResponseBodyStream), ExecServerError> { + params.stream_response = true; + let request_id = self.inner.next_http_body_stream_request_id(); + params.request_id = Some(request_id.clone()); + let (tx, rx) = mpsc::channel(HTTP_BODY_DELTA_CHANNEL_CAPACITY); + self.inner + .insert_http_body_stream(request_id.clone(), tx) + .await?; + let mut registration = HttpBodyStreamRegistration { + inner: Arc::clone(&self.inner), + request_id: request_id.clone(), + active: true, + }; + let response = match self.call(HTTP_REQUEST_METHOD, ¶ms).await { + Ok(response) => response, + Err(error) => { + self.inner.remove_http_body_stream(&request_id).await; + registration.active = false; + return Err(error); + } + }; + registration.active = false; + Ok(( + response, + HttpResponseBodyStream { + inner: Arc::clone(&self.inner), + request_id, + next_seq: 1, + rx, + pending_eof: false, + closed: false, + }, + )) + } +} + +impl Inner { + /// Routes one streamed HTTP body notification into its request-local receiver. + pub(super) async fn handle_http_body_delta_notification( + &self, + params: Option, + ) -> Result<(), ExecServerError> { + let params: HttpRequestBodyDeltaNotification = from_value(params.unwrap_or(Value::Null))?; + // Unknown request ids are ignored intentionally: a stream may have already + // reached EOF and released its route. + if let Some(tx) = self + .http_body_streams + .load() + .get(¶ms.request_id) + .cloned() + { + let request_id = params.request_id.clone(); + let terminal_delta = params.done || params.error.is_some(); + match tx.try_send(params) { + Ok(()) => { + if terminal_delta { + self.remove_http_body_stream(&request_id).await; + } + } + Err(TrySendError::Closed(_)) => { + self.remove_http_body_stream(&request_id).await; + debug!("http response stream receiver dropped before body delta delivery"); + } + Err(TrySendError::Full(_)) => { + self.record_http_body_stream_failure( + &request_id, + "body delta channel filled before delivery".to_string(), + ) + .await; + self.remove_http_body_stream(&request_id).await; + debug!( + "closing http response stream `{request_id}` after body delta backpressure" + ); + } + } + } + Ok(()) + } + + /// Fails active streamed HTTP bodies so callers do not wait forever after a + /// transport disconnect or notification handling failure. + pub(super) async fn fail_all_http_body_streams(&self, message: String) { + let _streams_write_guard = self.http_body_streams_write_lock.lock().await; + let streams = self.http_body_streams.load(); + let streams = streams.as_ref().clone(); + self.http_body_streams.store(Arc::new(HashMap::new())); + for (request_id, tx) in streams { + let _ = tx.try_send(HttpRequestBodyDeltaNotification { + request_id, + seq: 1, + delta: Vec::new().into(), + done: true, + error: Some(message.clone()), + }); + } + } + + /// Allocates a connection-local streamed HTTP response id. + fn next_http_body_stream_request_id(&self) -> String { + let id = self + .http_body_stream_next_id + .fetch_add(1, Ordering::Relaxed); + format!("http-{id}") + } + + /// Registers a request id before issuing an executor streaming HTTP call. + async fn insert_http_body_stream( + &self, + request_id: String, + tx: mpsc::Sender, + ) -> Result<(), ExecServerError> { + let _streams_write_guard = self.http_body_streams_write_lock.lock().await; + let streams = self.http_body_streams.load(); + if streams.contains_key(&request_id) { + return Err(ExecServerError::Protocol(format!( + "http response stream already registered for request {request_id}" + ))); + } + let mut next_streams = streams.as_ref().clone(); + next_streams.insert(request_id.clone(), tx); + self.http_body_streams.store(Arc::new(next_streams)); + let failures = self.http_body_stream_failures.load(); + if failures.contains_key(&request_id) { + let mut next_failures = failures.as_ref().clone(); + next_failures.remove(&request_id); + self.http_body_stream_failures + .store(Arc::new(next_failures)); + } + Ok(()) + } + + /// Removes a request id after EOF, terminal error, or request failure. + async fn remove_http_body_stream( + &self, + request_id: &str, + ) -> Option> { + let _streams_write_guard = self.http_body_streams_write_lock.lock().await; + let streams = self.http_body_streams.load(); + let stream = streams.get(request_id).cloned(); + stream.as_ref()?; + let mut next_streams = streams.as_ref().clone(); + next_streams.remove(request_id); + self.http_body_streams.store(Arc::new(next_streams)); + stream + } + + async fn record_http_body_stream_failure(&self, request_id: &str, message: String) { + let _streams_write_guard = self.http_body_streams_write_lock.lock().await; + let failures = self.http_body_stream_failures.load(); + let mut next_failures = failures.as_ref().clone(); + next_failures.insert(request_id.to_string(), message); + self.http_body_stream_failures + .store(Arc::new(next_failures)); + } + + async fn take_http_body_stream_failure(&self, request_id: &str) -> Option { + let _streams_write_guard = self.http_body_streams_write_lock.lock().await; + let failures = self.http_body_stream_failures.load(); + let error = failures.get(request_id).cloned(); + error.as_ref()?; + let mut next_failures = failures.as_ref().clone(); + next_failures.remove(request_id); + self.http_body_stream_failures + .store(Arc::new(next_failures)); + error + } +} + +/// Schedules HTTP body route removal from synchronous drop paths. +fn spawn_remove_http_body_stream(inner: Arc, request_id: String) { + if let Ok(handle) = Handle::try_current() { + handle.spawn(async move { + inner.remove_http_body_stream(&request_id).await; + }); + } +} diff --git a/codex-rs/exec-server/src/lib.rs b/codex-rs/exec-server/src/lib.rs index 1d024fb5aa..067fa0a7c1 100644 --- a/codex-rs/exec-server/src/lib.rs +++ b/codex-rs/exec-server/src/lib.rs @@ -65,6 +65,10 @@ pub use protocol::FsRemoveParams; pub use protocol::FsRemoveResponse; pub use protocol::FsWriteFileParams; pub use protocol::FsWriteFileResponse; +pub use protocol::HttpHeader; +pub use protocol::HttpRequestBodyDeltaNotification; +pub use protocol::HttpRequestParams; +pub use protocol::HttpRequestResponse; pub use protocol::InitializeParams; pub use protocol::InitializeResponse; pub use protocol::ProcessOutputChunk; diff --git a/codex-rs/exec-server/src/protocol.rs b/codex-rs/exec-server/src/protocol.rs index 9f4234e649..24d1ee1c1e 100644 --- a/codex-rs/exec-server/src/protocol.rs +++ b/codex-rs/exec-server/src/protocol.rs @@ -26,6 +26,10 @@ pub const FS_GET_METADATA_METHOD: &str = "fs/getMetadata"; pub const FS_READ_DIRECTORY_METHOD: &str = "fs/readDirectory"; pub const FS_REMOVE_METHOD: &str = "fs/remove"; pub const FS_COPY_METHOD: &str = "fs/copy"; +/// JSON-RPC request method for executor-side HTTP requests. +pub const HTTP_REQUEST_METHOD: &str = "http/request"; +/// JSON-RPC notification method for streamed executor HTTP response bodies. +pub const HTTP_REQUEST_BODY_DELTA_METHOD: &str = "http/request/bodyDelta"; #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[serde(transparent)] @@ -254,6 +258,83 @@ pub struct FsCopyParams { #[serde(rename_all = "camelCase")] pub struct FsCopyResponse {} +/// HTTP header represented in the executor protocol. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct HttpHeader { + /// Header name as it appears on the HTTP wire. + pub name: String, + /// Header value after UTF-8 conversion. + pub value: String, +} + +/// Executor-side HTTP request envelope. +/// +/// This intentionally stays transport-shaped rather than MCP-shaped so callers +/// can use it for Streamable HTTP, OAuth discovery, and future executor-owned +/// HTTP probes without introducing one protocol method per higher-level use. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct HttpRequestParams { + /// HTTP method, for example `GET`, `POST`, or `DELETE`. + pub method: String, + /// Absolute `http://` or `https://` URL. + pub url: String, + /// Ordered request headers. Repeated header names are preserved. + #[serde(default)] + pub headers: Vec, + /// Optional request body bytes. + #[serde(default, rename = "bodyBase64")] + pub body: Option, + /// Optional request timeout in milliseconds. + #[serde(default)] + pub timeout_ms: Option, + /// Caller-chosen stream id for `http/request/bodyDelta` notifications. + /// + /// The id must remain unique on a connection until the terminal body delta + /// arrives, even if the caller stops reading the stream earlier. + #[serde(default)] + pub request_id: Option, + /// Return after response headers and stream the response body as deltas. + #[serde(default)] + pub stream_response: bool, +} + +/// HTTP response envelope returned from an executor `http/request` call. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct HttpRequestResponse { + /// Numeric HTTP response status code. + pub status: u16, + /// Ordered response headers. Repeated header names are preserved. + pub headers: Vec, + /// Buffered response body bytes. Empty when `streamResponse` is true. + #[serde(rename = "bodyBase64")] + pub body: ByteChunk, +} + +/// Ordered response-body frame for `streamResponse` HTTP requests. +/// +/// Headers are returned in the `http/request` response so the caller can choose +/// a parser immediately; body bytes then arrive on this notification stream. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct HttpRequestBodyDeltaNotification { + /// Request id from the streamed `http/request` call. + pub request_id: String, + /// Monotonic one-based body frame sequence number. + pub seq: u64, + /// Response-body bytes carried by this frame. + #[serde(rename = "deltaBase64")] + pub delta: ByteChunk, + /// Marks response-body EOF. No later deltas are expected for this request. + #[serde(default)] + pub done: bool, + /// Terminal stream error. Set only on the final notification. + #[serde(default)] + pub error: Option, +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub enum ExecOutputStream { diff --git a/codex-rs/exec-server/src/remote_file_system.rs b/codex-rs/exec-server/src/remote_file_system.rs index 111e8d6037..d6a32ba4d5 100644 --- a/codex-rs/exec-server/src/remote_file_system.rs +++ b/codex-rs/exec-server/src/remote_file_system.rs @@ -195,9 +195,46 @@ fn map_remote_error(error: ExecServerError) -> io::Error { io::Error::new(io::ErrorKind::InvalidInput, message) } ExecServerError::Server { message, .. } => io::Error::other(message), - ExecServerError::Closed => { + ExecServerError::Closed | ExecServerError::Disconnected(_) => { io::Error::new(io::ErrorKind::BrokenPipe, "exec-server transport closed") } _ => io::Error::other(error.to_string()), } } + +#[cfg(test)] +mod tests { + use pretty_assertions::assert_eq; + + use super::*; + + #[test] + fn transport_errors_map_to_broken_pipe() { + let errors = [ + ExecServerError::Closed, + ExecServerError::Disconnected("exec-server transport disconnected".to_string()), + ]; + + let mapped_errors = errors + .into_iter() + .map(|error| { + let error = map_remote_error(error); + (error.kind(), error.to_string()) + }) + .collect::>(); + + assert_eq!( + mapped_errors, + vec![ + ( + io::ErrorKind::BrokenPipe, + "exec-server transport closed".to_string() + ), + ( + io::ErrorKind::BrokenPipe, + "exec-server transport closed".to_string() + ), + ] + ); + } +} diff --git a/codex-rs/exec-server/src/rpc.rs b/codex-rs/exec-server/src/rpc.rs index 30a3f70bbf..e82b4a0ea2 100644 --- a/codex-rs/exec-server/src/rpc.rs +++ b/codex-rs/exec-server/src/rpc.rs @@ -18,12 +18,23 @@ use serde_json::Value; use tokio::sync::Mutex; use tokio::sync::mpsc; use tokio::sync::oneshot; +use tokio::sync::watch; use tokio::task::JoinHandle; use crate::connection::JsonRpcConnection; use crate::connection::JsonRpcConnectionEvent; -type PendingRequest = oneshot::Sender>; +#[derive(Debug)] +pub(crate) enum RpcCallError { + /// The underlying JSON-RPC transport closed before this call completed. + Closed, + /// The response bytes were valid JSON-RPC but not the expected result type. + Json(serde_json::Error), + /// The executor returned a JSON-RPC error response for this call. + Server(JSONRPCErrorError), +} + +type PendingRequest = oneshot::Sender>; type BoxFuture = Pin + Send + 'static>>; type RequestRoute = Box, JSONRPCRequest) -> BoxFuture + Send + Sync>; @@ -172,6 +183,10 @@ where pub(crate) struct RpcClient { write_tx: mpsc::Sender, pending: Arc>>, + // Shared transport state from `JsonRpcConnection`. Calls use this to fail + // immediately when the socket closes, even if no JSON-RPC error response + // can be delivered for their request id. + disconnected_rx: watch::Receiver, next_request_id: AtomicI64, transport_tasks: Vec>, reader_task: JoinHandle<()>, @@ -179,8 +194,7 @@ pub(crate) struct RpcClient { impl RpcClient { pub(crate) fn new(connection: JsonRpcConnection) -> (Self, mpsc::Receiver) { - let (write_tx, mut incoming_rx, _disconnected_rx, transport_tasks) = - connection.into_parts(); + let (write_tx, mut incoming_rx, disconnected_rx, transport_tasks) = connection.into_parts(); let pending = Arc::new(Mutex::new(HashMap::::new())); let (event_tx, event_rx) = mpsc::channel(128); @@ -218,6 +232,7 @@ impl RpcClient { Self { write_tx, pending, + disconnected_rx, next_request_id: AtomicI64::new(1), transport_tasks, reader_task, @@ -253,10 +268,16 @@ impl RpcClient { { let request_id = RequestId::Integer(self.next_request_id.fetch_add(1, Ordering::SeqCst)); let (response_tx, response_rx) = oneshot::channel(); - self.pending - .lock() - .await - .insert(request_id.clone(), response_tx); + { + let mut pending = self.pending.lock().await; + // Registering the pending request and checking disconnect must be + // atomic with the reader's drain_pending path. Otherwise a call + // can sneak in after the drain and wait forever. + if *self.disconnected_rx.borrow() { + return Err(RpcCallError::Closed); + } + pending.insert(request_id.clone(), response_tx); + } let params = match serde_json::to_value(params) { Ok(params) => params, @@ -280,10 +301,17 @@ impl RpcClient { return Err(RpcCallError::Closed); } - let result = response_rx.await.map_err(|_| RpcCallError::Closed)?; + // Do not race in-flight requests directly against the transport-close + // watch value. The connection reader receives JSON-RPC messages and + // the terminal disconnect event on one ordered queue, then drains any + // still-pending requests. Awaiting this receiver preserves that order: + // responses already read before EOF still win, and truly pending calls + // are failed once the reader observes the disconnect. + let result: Result = + response_rx.await.map_err(|_| RpcCallError::Closed)?; let response = match result { Ok(response) => response, - Err(error) => return Err(RpcCallError::Server(error)), + Err(error) => return Err(error), }; serde_json::from_value(response).map_err(RpcCallError::Json) } @@ -304,13 +332,6 @@ impl Drop for RpcClient { } } -#[derive(Debug)] -pub(crate) enum RpcCallError { - Closed, - Json(serde_json::Error), - Server(JSONRPCErrorError), -} - pub(crate) fn encode_server_message( message: RpcServerOutboundMessage, ) -> Result { @@ -417,7 +438,7 @@ async fn handle_server_message( } JSONRPCMessage::Error(JSONRPCError { id, error }) => { if let Some(pending) = pending.lock().await.remove(&id) { - let _ = pending.send(Err(error)); + let _ = pending.send(Err(RpcCallError::Server(error))); } } JSONRPCMessage::Notification(notification) => { @@ -445,11 +466,7 @@ async fn drain_pending(pending: &Mutex>) { .collect::>() }; for pending in pending { - let _ = pending.send(Err(JSONRPCErrorError { - code: -32000, - data: None, - message: "JSON-RPC transport closed".to_string(), - })); + let _ = pending.send(Err(RpcCallError::Closed)); } } diff --git a/codex-rs/exec-server/tests/exec_process.rs b/codex-rs/exec-server/tests/exec_process.rs index 94e78b42b0..d449315c8d 100644 --- a/codex-rs/exec-server/tests/exec_process.rs +++ b/codex-rs/exec-server/tests/exec_process.rs @@ -4,6 +4,7 @@ mod common; use std::sync::Arc; +use anyhow::Context; use anyhow::Result; use codex_exec_server::Environment; use codex_exec_server::ExecBackend; @@ -484,6 +485,16 @@ async fn remote_exec_process_reports_transport_disconnect() -> Result<()> { let process = Arc::clone(&session.process); let mut events = process.subscribe_events(); + let process_for_pending_read = Arc::clone(&process); + let pending_read = tokio::spawn(async move { + process_for_pending_read + .read( + /*after_seq*/ None, + /*max_bytes*/ None, + /*wait_ms*/ Some(60_000), + ) + .await + }); let server = context .server .as_mut() @@ -499,6 +510,15 @@ async fn remote_exec_process_reports_transport_disconnect() -> Result<()> { "unexpected failure event: {event_message}" ); + let pending_response = timeout(Duration::from_secs(2), pending_read).await???; + let pending_message = pending_response + .failure + .expect("pending read should surface disconnect as a failure"); + assert!( + pending_message.starts_with("exec-server transport disconnected"), + "unexpected pending failure message: {pending_message}" + ); + let mut wake_rx = process.subscribe_wake(); let response = read_process_until_change(process, &mut wake_rx, /*after_seq*/ None).await?; let message = response @@ -513,6 +533,20 @@ async fn remote_exec_process_reports_transport_disconnect() -> Result<()> { "disconnect should close the process session" ); + let write_result = timeout( + Duration::from_secs(2), + session.process.write(b"hello".to_vec()), + ) + .await + .context("timed out waiting for write after disconnect")?; + let write_error = write_result.expect_err("write after disconnect should fail"); + assert!( + write_error + .to_string() + .starts_with("exec-server transport disconnected"), + "unexpected write error: {write_error}" + ); + Ok(()) } diff --git a/codex-rs/exec-server/tests/http_client.rs b/codex-rs/exec-server/tests/http_client.rs new file mode 100644 index 0000000000..1462c80168 --- /dev/null +++ b/codex-rs/exec-server/tests/http_client.rs @@ -0,0 +1,1026 @@ +use std::future::Future; +use std::time::Duration; + +use anyhow::Context; +use anyhow::Result; +use anyhow::bail; +use codex_app_server_protocol::JSONRPCMessage; +use codex_app_server_protocol::JSONRPCNotification; +use codex_app_server_protocol::JSONRPCRequest; +use codex_app_server_protocol::JSONRPCResponse; +use codex_app_server_protocol::RequestId; +use codex_exec_server::ExecServerClient; +use codex_exec_server::HttpHeader; +use codex_exec_server::HttpRequestBodyDeltaNotification; +use codex_exec_server::HttpRequestParams; +use codex_exec_server::HttpRequestResponse; +use codex_exec_server::InitializeParams; +use codex_exec_server::InitializeResponse; +use codex_exec_server::RemoteExecServerConnectArgs; +use futures::SinkExt; +use futures::StreamExt; +use pretty_assertions::assert_eq; +use serde::Serialize; +use serde::de::DeserializeOwned; +use serde_json::from_slice; +use serde_json::from_str; +use serde_json::from_value; +use serde_json::to_string; +use serde_json::to_value; +use tokio::net::TcpListener; +use tokio::net::TcpStream; +use tokio::sync::oneshot; +use tokio::task::JoinHandle; +use tokio::time::timeout; +use tokio_tungstenite::WebSocketStream; +use tokio_tungstenite::accept_async; +use tokio_tungstenite::tungstenite::Message; + +const CLIENT_NAME: &str = "test-exec-server-client"; +const HTTP_REQUEST_METHOD: &str = "http/request"; +const HTTP_REQUEST_BODY_DELTA_METHOD: &str = "http/request/bodyDelta"; +const INITIALIZE_METHOD: &str = "initialize"; +const INITIALIZED_METHOD: &str = "initialized"; +const TEST_TIMEOUT: Duration = Duration::from_secs(5); +const OVERFLOWING_BODY_DELTA_FRAMES: u64 = 1_024; + +/// What this tests: the buffered HTTP helper always sends a buffered +/// `http/request`, even when a caller accidentally provides streaming flags. +#[tokio::test] +async fn http_request_forces_buffered_request_params() -> Result<()> { + // Phase 1: start a fake WebSocket exec-server so the test covers the + // public client connection path without depending on the HTTP runner. + let server = spawn_scripted_exec_server(|mut peer| async move { + // Phase 2: verify the buffered helper strips streaming-only fields + // before it sends the JSON-RPC call. + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/buffered".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: None, + stream_response: false, + } + ); + + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: b"buffered".to_vec().into(), + }, + ) + .await + }) + .await?; + let client = server.connect_client().await?; + + // Phase 3: call the buffered helper with streaming-only fields populated + // and assert callers still receive the buffered response body. + let response = timeout( + TEST_TIMEOUT, + client.http_request(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/buffered".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("ignored-stream-id".to_string()), + stream_response: true, + }), + ) + .await + .context("buffered http/request should complete")??; + assert_eq!( + response, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: b"buffered".to_vec().into(), + } + ); + + drop(client); + server.finish().await?; + Ok(()) +} + +/// What this tests: streamed executor HTTP response frames are routed by the +/// client's generated request id, delivered in sequence, and concatenated by +/// the caller. +#[tokio::test] +async fn http_response_body_stream_uses_generated_ids_and_receives_ordered_deltas() -> Result<()> { + // Phase 1: script two requests. The caller supplies reusable ids, but the + // client replaces them with connection-local ids on the wire. + let server = spawn_scripted_exec_server(|mut peer| async move { + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp".to_string(), + headers: vec![HttpHeader { + name: "accept".to_string(), + value: "text/event-stream".to_string(), + }], + body: None, + timeout_ms: None, + request_id: Some("http-1".to_string()), + stream_response: true, + } + ); + + // Phase 2: return headers first, then body notifications in the order + // the public body stream should expose them. + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: vec![HttpHeader { + name: "content-type".to_string(), + value: "text/event-stream".to_string(), + }], + body: Vec::new().into(), + }, + ) + .await?; + for delta in [ + HttpRequestBodyDeltaNotification { + request_id: "http-1".to_string(), + seq: 1, + delta: b"hello ".to_vec().into(), + done: false, + error: None, + }, + HttpRequestBodyDeltaNotification { + request_id: "http-1".to_string(), + seq: 2, + delta: b"world".to_vec().into(), + done: false, + error: None, + }, + HttpRequestBodyDeltaNotification { + request_id: "http-1".to_string(), + seq: 3, + delta: b"!".to_vec().into(), + done: true, + error: None, + }, + ] { + peer.write_body_delta(delta).await?; + } + + // Phase 3: accept the next generated request id after EOF. + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/reuse".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-2".to_string()), + stream_response: true, + } + ); + peer.write_response( + request_id, + HttpRequestResponse { + status: 204, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await + }) + .await?; + let client = server.connect_client().await?; + + // Phase 4: start a streaming HTTP request through the public client API. + let (response, mut body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp".to_string(), + headers: vec![HttpHeader { + name: "accept".to_string(), + value: "text/event-stream".to_string(), + }], + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("streamed http/request should return headers")??; + assert_eq!( + response, + HttpRequestResponse { + status: 200, + headers: vec![HttpHeader { + name: "content-type".to_string(), + value: "text/event-stream".to_string(), + }], + body: Vec::new().into(), + } + ); + + // Phase 5: drain the body stream and verify the caller-visible byte order. + let mut body = Vec::new(); + while let Some(chunk) = timeout(TEST_TIMEOUT, body_stream.recv()) + .await + .context("http response body delta should arrive")?? + { + body.extend_from_slice(&chunk); + } + assert_eq!(body, b"hello world!".to_vec()); + + // Phase 6: start another stream through the public API to validate cleanup + // after EOF without reaching into the client routing table. + let (reuse_response, _reuse_body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/reuse".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("second streamed http/request should return headers")??; + assert_eq!( + reuse_response, + HttpRequestResponse { + status: 204, + headers: Vec::new(), + body: Vec::new().into(), + } + ); + + drop(client); + server.finish().await?; + Ok(()) +} + +/// What this tests: dropping a body stream with a queued terminal frame removes +/// the old route while the next stream gets a fresh generated id. +#[tokio::test] +async fn http_response_body_stream_drops_queued_terminal_before_next_generated_id() -> Result<()> { + // Phase 1: send terminal EOF before the header response so the public body + // stream starts with EOF already queued but unread. + let server = spawn_scripted_exec_server(|mut peer| async move { + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/queued-terminal".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-1".to_string()), + stream_response: true, + } + ); + peer.write_body_delta(HttpRequestBodyDeltaNotification { + request_id: "http-1".to_string(), + seq: 1, + delta: Vec::new().into(), + done: true, + error: None, + }) + .await?; + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await?; + + // Phase 2: accept another stream after the client drops the unread + // body. The second request receives a distinct generated id. + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/retry-queued-terminal".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-2".to_string()), + stream_response: true, + } + ); + peer.write_response( + request_id, + HttpRequestResponse { + status: 204, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await + }) + .await?; + let client = server.connect_client().await?; + + // Phase 3: drop the body stream without reading the queued EOF frame. + let (response, body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/queued-terminal".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("streamed http/request should return headers")??; + assert_eq!( + response, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + } + ); + drop(body_stream); + + // Phase 4: start another stream through the public API. The caller-provided + // id is ignored, so the request uses the next generated route id. + let params = HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/retry-queued-terminal".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }; + let (reuse_response, _reuse_body_stream) = + timeout(TEST_TIMEOUT, client.http_request_stream(params)) + .await + .context("second streamed http/request should return headers")??; + assert_eq!( + reuse_response, + HttpRequestResponse { + status: 204, + headers: Vec::new(), + body: Vec::new().into(), + } + ); + + drop(client); + server.finish().await?; + Ok(()) +} + +/// What this tests: cancelling a streaming HTTP request while it is waiting for +/// headers drops its route, and a later stream gets a fresh generated id. +#[tokio::test] +async fn http_response_body_stream_ignores_late_deltas_after_cancelled_request() -> Result<()> { + // Phase 1: coordinate cancellation after the fake server observes the + // first request but before it returns headers. The server later sends a + // stale delta for the cancelled id before serving the fresh stream. + let (request_seen_tx, request_seen_rx) = oneshot::channel(); + let server = spawn_scripted_exec_server(|mut peer| async move { + let (_request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/cancel".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-1".to_string()), + stream_response: true, + } + ); + request_seen_tx + .send(()) + .expect("test should wait for the first request"); + + // Phase 2: the next stream uses a new generated id. A late body delta + // for the cancelled id is ignored by the client-side router. + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/retry-cancelled".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-2".to_string()), + stream_response: true, + } + ); + peer.write_body_delta(HttpRequestBodyDeltaNotification { + request_id: "http-1".to_string(), + seq: 1, + delta: b"stale".to_vec().into(), + done: false, + error: None, + }) + .await?; + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await?; + peer.write_body_delta(HttpRequestBodyDeltaNotification { + request_id: "http-2".to_string(), + seq: 1, + delta: b"fresh".to_vec().into(), + done: true, + error: None, + }) + .await + }) + .await?; + let client = server.connect_client().await?; + + // Phase 3: start a streaming request and abort the caller future while it + // is blocked waiting for response headers. + let client_for_request = client.clone(); + let stream_task = tokio::spawn(async move { + let _ = client_for_request + .http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/cancel".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }) + .await; + }); + request_seen_rx + .await + .expect("server should observe the first http/request"); + stream_task.abort(); + let _ = stream_task.await; + + // Phase 4: start a new stream immediately. It receives only the fresh body + // bytes for its generated id. + let (response, mut body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/retry-cancelled".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("second streamed http/request should return headers")??; + assert_eq!( + response, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + } + ); + let mut body = Vec::new(); + while let Some(chunk) = timeout(TEST_TIMEOUT, body_stream.recv()) + .await + .context("fresh http response body delta should arrive")?? + { + body.extend_from_slice(&chunk); + } + assert_eq!(body, b"fresh".to_vec()); + + drop(client); + server.finish().await?; + Ok(()) +} + +/// What this tests: dropping a returned body stream before EOF removes its +/// route and prevents stale body deltas from reaching the next stream. +#[tokio::test] +async fn http_response_body_stream_ignores_late_deltas_after_drop() -> Result<()> { + // Phase 1: script two requests. The first returns only headers; after the + // client drops its body receiver, the server sends a stale body delta. + let (body_dropped_tx, body_dropped_rx) = oneshot::channel(); + let (stale_delta_sent_tx, stale_delta_sent_rx) = oneshot::channel(); + let server = spawn_scripted_exec_server(|mut peer| async move { + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/drop".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-1".to_string()), + stream_response: true, + } + ); + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await?; + body_dropped_rx + .await + .expect("test should drop the first body stream"); + peer.write_body_delta(HttpRequestBodyDeltaNotification { + request_id: "http-1".to_string(), + seq: 1, + delta: b"stale".to_vec().into(), + done: false, + error: None, + }) + .await?; + stale_delta_sent_tx + .send(()) + .expect("test should wait for the stale delta"); + + // Phase 2: accept the next request with a new generated id. The new + // stream must receive only fresh body bytes. + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/retry-dropped".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-2".to_string()), + stream_response: true, + } + ); + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await?; + peer.write_body_delta(HttpRequestBodyDeltaNotification { + request_id: "http-2".to_string(), + seq: 1, + delta: b"fresh".to_vec().into(), + done: true, + error: None, + }) + .await + }) + .await?; + let client = server.connect_client().await?; + + // Phase 3: receive headers for the first stream, then drop the body stream + // without reading any body frames. + let (response, body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/drop".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("streamed http/request should return headers")??; + assert_eq!( + response, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + } + ); + drop(body_stream); + body_dropped_tx + .send(()) + .expect("server should wait for the body stream drop"); + stale_delta_sent_rx + .await + .expect("server should send one stale nonterminal delta"); + + // Phase 4: start the next stream immediately. The caller-provided id is + // ignored, and the fresh generated id isolates it from stale bytes. + let (reuse_response, mut reuse_body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/retry-dropped".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("second streamed http/request should return headers")??; + assert_eq!( + reuse_response, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + } + ); + let mut body = Vec::new(); + while let Some(chunk) = timeout(TEST_TIMEOUT, reuse_body_stream.recv()) + .await + .context("fresh http response body delta should arrive")?? + { + body.extend_from_slice(&chunk); + } + assert_eq!(body, b"fresh".to_vec()); + + drop(client); + server.finish().await?; + Ok(()) +} + +/// What this tests: an in-flight streamed HTTP body is failed when the shared +/// JSON-RPC transport disconnects before a terminal body frame. +#[tokio::test] +async fn http_response_body_stream_fails_when_transport_disconnects() -> Result<()> { + // Phase 1: return response headers for a streaming request, then drop the + // fake server transport without sending EOF. + let server = spawn_scripted_exec_server(|mut peer| async move { + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/disconnect".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-1".to_string()), + stream_response: true, + } + ); + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await + }) + .await?; + let client = server.connect_client().await?; + + // Phase 2: start a streaming HTTP request and receive headers. + let (_response, mut body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/disconnect".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("streamed http/request should return headers")??; + + // Phase 3: assert transport disconnect wakes the body stream with a + // terminal error instead of hanging. + let error = timeout(TEST_TIMEOUT, body_stream.recv()) + .await + .context("disconnect should wake http body stream")? + .expect_err("disconnect should fail the http body stream"); + let error_message = error.to_string(); + assert_eq!( + error_message.starts_with( + "exec-server protocol error: http response stream `http-1` failed: exec-server transport disconnected" + ), + true + ); + + drop(client); + server.finish().await?; + Ok(()) +} + +/// What this tests: body-delta backpressure closes the public body stream as +/// an error rather than letting callers accept a truncated body as clean EOF. +#[tokio::test] +async fn http_response_body_stream_reports_backpressure_truncation() -> Result<()> { + // Phase 1: send enough body frames before headers to overflow the bounded + // client-side route while the public request future is still pending. + let (finish_tx, finish_rx) = oneshot::channel(); + let server = spawn_scripted_exec_server(|mut peer| async move { + let (request_id, params) = peer.read_http_request().await?; + assert_eq!( + params, + HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/backpressure".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("http-1".to_string()), + stream_response: true, + } + ); + for seq in 1..=OVERFLOWING_BODY_DELTA_FRAMES { + peer.write_body_delta(HttpRequestBodyDeltaNotification { + request_id: "http-1".to_string(), + seq, + delta: b"x".to_vec().into(), + done: false, + error: None, + }) + .await?; + } + peer.write_response( + request_id, + HttpRequestResponse { + status: 200, + headers: Vec::new(), + body: Vec::new().into(), + }, + ) + .await?; + + // Phase 2: keep the transport connected so the body stream reports the + // backpressure failure rather than a disconnect. + finish_rx.await.expect("test should finish server task"); + Ok(()) + }) + .await?; + let client = server.connect_client().await?; + + // Phase 3: start the streaming request; the server overfills the route + // before returning the body stream to this consumer. + let (_response, mut body_stream) = timeout( + TEST_TIMEOUT, + client.http_request_stream(HttpRequestParams { + method: "GET".to_string(), + url: "https://example.test/mcp/backpressure".to_string(), + headers: Vec::new(), + body: None, + timeout_ms: None, + request_id: Some("caller-stream-id".to_string()), + stream_response: false, + }), + ) + .await + .context("streamed http/request should return headers")??; + + // Phase 4: drain queued chunks and assert the truncated stream ends in an + // explicit error, not a clean EOF. + let mut chunks = 0; + let error = loop { + match timeout(TEST_TIMEOUT, body_stream.recv()) + .await + .context("backpressure should close http body stream")? + { + Ok(Some(_chunk)) => { + chunks += 1; + } + Ok(None) => bail!("backpressure truncation should not look like clean EOF"), + Err(error) => break error, + } + }; + assert_eq!( + ( + chunks < OVERFLOWING_BODY_DELTA_FRAMES as usize, + error.to_string(), + ), + ( + true, + "exec-server protocol error: http response stream `http-1` failed: body delta channel filled before delivery".to_string(), + ) + ); + + finish_tx + .send(()) + .expect("server task should wait for test completion"); + drop(client); + server.finish().await?; + Ok(()) +} + +/// Fake WebSocket exec-server used by the integration tests. +/// +/// The helper exercises `ExecServerClient::connect_websocket`, including the +/// initialize handshake, while each test controls the exact JSON-RPC traffic +/// that follows. +struct ScriptedExecServer { + websocket_url: String, + task: JoinHandle>, +} + +impl ScriptedExecServer { + /// Connects the public exec-server client to this fake WebSocket endpoint. + async fn connect_client(&self) -> Result { + ExecServerClient::connect_websocket(RemoteExecServerConnectArgs::new( + self.websocket_url.clone(), + CLIENT_NAME.to_string(), + )) + .await + .context("client should connect to fake exec-server") + } + + /// Waits for the scripted fake server to finish. + async fn finish(self) -> Result<()> { + self.task + .await + .context("fake exec-server task should join")??; + Ok(()) + } +} + +/// Starts a fake exec-server that accepts one WebSocket client. +async fn spawn_scripted_exec_server(script: F) -> Result +where + F: FnOnce(JsonRpcPeer) -> Fut + Send + 'static, + Fut: Future> + Send + 'static, +{ + let listener = TcpListener::bind("127.0.0.1:0") + .await + .context("fake exec-server should bind")?; + let websocket_url = format!("ws://{}", listener.local_addr()?); + let task = tokio::spawn(async move { + let (stream, _) = timeout(TEST_TIMEOUT, listener.accept()) + .await + .context("fake exec-server should accept a client")??; + let websocket = accept_async(stream) + .await + .context("fake exec-server websocket handshake should complete")?; + let mut peer = JsonRpcPeer { websocket }; + peer.complete_initialize().await?; + script(peer).await + }); + Ok(ScriptedExecServer { + websocket_url, + task, + }) +} + +/// JSON-RPC peer for the fake exec-server WebSocket. +struct JsonRpcPeer { + websocket: WebSocketStream, +} + +impl JsonRpcPeer { + /// Completes and validates the client initialize handshake. + async fn complete_initialize(&mut self) -> Result<()> { + let request = self.read_request(INITIALIZE_METHOD).await?; + let params: InitializeParams = decode_request_params(&request)?; + assert_eq!( + params, + InitializeParams { + client_name: CLIENT_NAME.to_string(), + resume_session_id: None, + } + ); + self.write_response( + request.id, + InitializeResponse { + session_id: "session-1".to_string(), + }, + ) + .await?; + self.read_notification(INITIALIZED_METHOD).await?; + Ok(()) + } + + /// Reads one typed `http/request` call from the client. + async fn read_http_request(&mut self) -> Result<(RequestId, HttpRequestParams)> { + let request = self.read_request(HTTP_REQUEST_METHOD).await?; + let params = decode_request_params(&request)?; + Ok((request.id, params)) + } + + /// Reads a JSON-RPC request and validates its method. + async fn read_request(&mut self, expected_method: &str) -> Result { + let message = self.read_message().await?; + let JSONRPCMessage::Request(request) = message else { + bail!("expected JSON-RPC request `{expected_method}`, got {message:?}"); + }; + if request.method != expected_method { + bail!( + "expected JSON-RPC request `{expected_method}`, got `{}`", + request.method + ); + } + Ok(request) + } + + /// Reads a JSON-RPC notification and validates its method. + async fn read_notification(&mut self, expected_method: &str) -> Result { + let message = self.read_message().await?; + let JSONRPCMessage::Notification(notification) = message else { + bail!("expected JSON-RPC notification `{expected_method}`, got {message:?}"); + }; + if notification.method != expected_method { + bail!( + "expected JSON-RPC notification `{expected_method}`, got `{}`", + notification.method + ); + } + Ok(notification) + } + + /// Sends a successful JSON-RPC response. + async fn write_response(&mut self, id: RequestId, result: T) -> Result<()> + where + T: Serialize, + { + self.write_message(JSONRPCMessage::Response(JSONRPCResponse { + id, + result: to_value(result)?, + })) + .await + } + + /// Sends one streamed HTTP body notification. + async fn write_body_delta(&mut self, delta: HttpRequestBodyDeltaNotification) -> Result<()> { + self.write_message(JSONRPCMessage::Notification(JSONRPCNotification { + method: HTTP_REQUEST_BODY_DELTA_METHOD.to_string(), + params: Some(to_value(delta)?), + })) + .await + } + + /// Reads one WebSocket JSON-RPC message. + async fn read_message(&mut self) -> Result { + let message = timeout(TEST_TIMEOUT, self.websocket.next()) + .await + .context("timed out waiting for JSON-RPC message")? + .context("client websocket closed before JSON-RPC message arrived")? + .context("failed to read websocket message")?; + match message { + Message::Text(text) => from_str(text.as_ref()).context("text JSON-RPC"), + Message::Binary(bytes) => from_slice(bytes.as_ref()).context("binary JSON-RPC"), + Message::Close(frame) => bail!("client websocket closed: {frame:?}"), + other => bail!("expected text or binary JSON-RPC message, got {other:?}"), + } + } + + /// Writes one WebSocket JSON-RPC message. + async fn write_message(&mut self, message: JSONRPCMessage) -> Result<()> { + let encoded = to_string(&message)?; + timeout( + TEST_TIMEOUT, + self.websocket.send(Message::Text(encoded.into())), + ) + .await + .context("timed out writing JSON-RPC message")? + .context("failed to write JSON-RPC message") + } +} + +/// Decodes a request params object into its typed protocol payload. +fn decode_request_params(request: &JSONRPCRequest) -> Result +where + T: DeserializeOwned, +{ + let params = request + .params + .clone() + .context("JSON-RPC request should include params")?; + from_value(params).context("JSON-RPC request params should decode") +} diff --git a/codex-rs/exec/src/cli.rs b/codex-rs/exec/src/cli.rs index 4d34e7f365..cbdf695562 100644 --- a/codex-rs/exec/src/cli.rs +++ b/codex-rs/exec/src/cli.rs @@ -3,6 +3,7 @@ use clap::FromArgMatches; use clap::Parser; use clap::ValueEnum; use codex_utils_cli::CliConfigOverrides; +use codex_utils_cli::SharedCliOptions; use std::path::PathBuf; #[derive(Parser, Debug)] @@ -15,65 +16,13 @@ pub struct Cli { #[command(subcommand)] pub command: Option, - /// Optional image(s) to attach to the initial prompt. - #[arg( - long = "image", - short = 'i', - value_name = "FILE", - value_delimiter = ',', - num_args = 1.. - )] - pub images: Vec, - - /// Model the agent should use. - #[arg(long, short = 'm', global = true)] - pub model: Option, - - /// Use open-source provider. - #[arg(long = "oss", default_value_t = false)] - pub oss: bool, - - /// Specify which local provider to use (lmstudio or ollama). - /// If not specified with --oss, will use config default or show selection. - #[arg(long = "local-provider")] - pub oss_provider: Option, - - /// Select the sandbox policy to use when executing model-generated shell - /// commands. - #[arg(long = "sandbox", short = 's', value_enum)] - pub sandbox_mode: Option, - - /// Configuration profile from config.toml to specify default options. - #[arg(long = "profile", short = 'p')] - pub config_profile: Option, - - /// Convenience alias for low-friction sandboxed automatic execution (--sandbox workspace-write). - #[arg(long = "full-auto", default_value_t = false, global = true)] - pub full_auto: bool, - - /// Skip all confirmation prompts and execute commands without sandboxing. - /// EXTREMELY DANGEROUS. Intended solely for running in environments that are externally sandboxed. - #[arg( - long = "dangerously-bypass-approvals-and-sandbox", - alias = "yolo", - default_value_t = false, - global = true, - conflicts_with = "full_auto" - )] - pub dangerously_bypass_approvals_and_sandbox: bool, - - /// Tell the agent to use the specified directory as its working root. - #[clap(long = "cd", short = 'C', value_name = "DIR")] - pub cwd: Option, + #[clap(flatten)] + pub shared: ExecSharedCliOptions, /// Allow running Codex outside a Git repository. #[arg(long = "skip-git-repo-check", global = true, default_value_t = false)] pub skip_git_repo_check: bool, - /// Additional directories that should be writable alongside the primary workspace. - #[arg(long = "add-dir", value_name = "DIR", value_hint = clap::ValueHint::DirPath)] - pub add_dir: Vec, - /// Run without persisting session files to disk. #[arg(long = "ephemeral", global = true, default_value_t = false)] pub ephemeral: bool, @@ -122,6 +71,71 @@ pub struct Cli { pub prompt: Option, } +impl std::ops::Deref for Cli { + type Target = SharedCliOptions; + + fn deref(&self) -> &Self::Target { + &self.shared.0 + } +} + +impl std::ops::DerefMut for Cli { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.shared.0 + } +} + +#[derive(Debug, Default)] +pub struct ExecSharedCliOptions(SharedCliOptions); + +impl ExecSharedCliOptions { + pub fn into_inner(self) -> SharedCliOptions { + self.0 + } +} + +impl std::ops::Deref for ExecSharedCliOptions { + type Target = SharedCliOptions; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl std::ops::DerefMut for ExecSharedCliOptions { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl Args for ExecSharedCliOptions { + fn augment_args(cmd: clap::Command) -> clap::Command { + mark_exec_global_args(SharedCliOptions::augment_args(cmd)) + } + + fn augment_args_for_update(cmd: clap::Command) -> clap::Command { + mark_exec_global_args(SharedCliOptions::augment_args_for_update(cmd)) + } +} + +impl FromArgMatches for ExecSharedCliOptions { + fn from_arg_matches(matches: &clap::ArgMatches) -> Result { + SharedCliOptions::from_arg_matches(matches).map(Self) + } + + fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> { + self.0.update_from_arg_matches(matches) + } +} + +fn mark_exec_global_args(cmd: clap::Command) -> clap::Command { + cmd.mut_arg("model", |arg| arg.global(true)) + .mut_arg("full_auto", |arg| arg.global(true)) + .mut_arg("dangerously_bypass_approvals_and_sandbox", |arg| { + arg.global(true) + }) +} + #[derive(Debug, clap::Subcommand)] pub enum Command { /// Resume a previous session by id or pick the most recent with --last. diff --git a/codex-rs/exec/src/lib.rs b/codex-rs/exec/src/lib.rs index 9e4ef89a48..16d7ae9cfd 100644 --- a/codex-rs/exec/src/lib.rs +++ b/codex-rs/exec/src/lib.rs @@ -86,6 +86,7 @@ use codex_protocol::protocol::SessionSource; use codex_protocol::user_input::UserInput; use codex_utils_absolute_path::AbsolutePathBuf; use codex_utils_absolute_path::canonicalize_existing_preserving_symlinks; +use codex_utils_cli::SharedCliOptions; use codex_utils_oss::ensure_oss_provider_ready; use codex_utils_oss::get_default_model_for_oss_provider; use event_processor_with_human_output::EventProcessorWithHumanOutput; @@ -224,27 +225,31 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Result let Cli { command, - images, - model: model_cli_arg, - oss, - oss_provider, - config_profile, - full_auto, - dangerously_bypass_approvals_and_sandbox, - cwd, + shared, skip_git_repo_check, - add_dir, ephemeral, ignore_user_config, ignore_rules, color, last_message_file, json: json_mode, - sandbox_mode: sandbox_mode_cli_arg, prompt, output_schema: output_schema_path, config_overrides, } = cli; + let shared = shared.into_inner(); + let SharedCliOptions { + images, + model: model_cli_arg, + oss, + oss_provider, + config_profile, + sandbox_mode: sandbox_mode_cli_arg, + full_auto, + dangerously_bypass_approvals_and_sandbox, + cwd, + add_dir, + } = shared; let (_stdout_with_ansi, stderr_with_ansi) = match color { cli::Color::Always => (true, true), diff --git a/codex-rs/instructions/BUILD.bazel b/codex-rs/instructions/BUILD.bazel deleted file mode 100644 index d3cdbd19d1..0000000000 --- a/codex-rs/instructions/BUILD.bazel +++ /dev/null @@ -1,16 +0,0 @@ -load("//:defs.bzl", "codex_rust_crate") - -codex_rust_crate( - name = "instructions", - crate_name = "codex_instructions", - compile_data = glob( - include = ["**"], - exclude = [ - "BUILD.bazel", - "Cargo.toml", - ], - allow_empty = True, - ) + [ - "//codex-rs:node-version.txt", - ], -) diff --git a/codex-rs/instructions/Cargo.toml b/codex-rs/instructions/Cargo.toml deleted file mode 100644 index cdaa3d7368..0000000000 --- a/codex-rs/instructions/Cargo.toml +++ /dev/null @@ -1,20 +0,0 @@ -[package] -edition.workspace = true -license.workspace = true -name = "codex-instructions" -version.workspace = true - -[lib] -doctest = false -name = "codex_instructions" -path = "src/lib.rs" - -[lints] -workspace = true - -[dependencies] -codex-protocol = { workspace = true } -serde = { workspace = true, features = ["derive"] } - -[dev-dependencies] -pretty_assertions = { workspace = true } diff --git a/codex-rs/instructions/src/fragment.rs b/codex-rs/instructions/src/fragment.rs deleted file mode 100644 index 590dac379b..0000000000 --- a/codex-rs/instructions/src/fragment.rs +++ /dev/null @@ -1,61 +0,0 @@ -use codex_protocol::models::ContentItem; -use codex_protocol::models::ResponseItem; - -pub(crate) const AGENTS_MD_START_MARKER: &str = "# AGENTS.md instructions for "; -pub(crate) const AGENTS_MD_END_MARKER: &str = ""; -pub(crate) const SKILL_OPEN_TAG: &str = ""; -pub(crate) const SKILL_CLOSE_TAG: &str = ""; - -#[derive(Clone, Copy)] -pub struct ContextualUserFragmentDefinition { - start_marker: &'static str, - end_marker: &'static str, -} - -impl ContextualUserFragmentDefinition { - pub const fn new(start_marker: &'static str, end_marker: &'static str) -> Self { - Self { - start_marker, - end_marker, - } - } - - pub fn matches_text(&self, text: &str) -> bool { - let trimmed = text.trim_start(); - let starts_with_marker = trimmed - .get(..self.start_marker.len()) - .is_some_and(|candidate| candidate.eq_ignore_ascii_case(self.start_marker)); - let trimmed = trimmed.trim_end(); - let ends_with_marker = trimmed - .get(trimmed.len().saturating_sub(self.end_marker.len())..) - .is_some_and(|candidate| candidate.eq_ignore_ascii_case(self.end_marker)); - starts_with_marker && ends_with_marker - } - - pub const fn start_marker(&self) -> &'static str { - self.start_marker - } - - pub const fn end_marker(&self) -> &'static str { - self.end_marker - } - - pub fn wrap(&self, body: String) -> String { - format!("{}\n{}\n{}", self.start_marker, body, self.end_marker) - } - - pub fn into_message(self, text: String) -> ResponseItem { - ResponseItem::Message { - id: None, - role: "user".to_string(), - content: vec![ContentItem::InputText { text }], - end_turn: None, - phase: None, - } - } -} - -pub const AGENTS_MD_FRAGMENT: ContextualUserFragmentDefinition = - ContextualUserFragmentDefinition::new(AGENTS_MD_START_MARKER, AGENTS_MD_END_MARKER); -pub const SKILL_FRAGMENT: ContextualUserFragmentDefinition = - ContextualUserFragmentDefinition::new(SKILL_OPEN_TAG, SKILL_CLOSE_TAG); diff --git a/codex-rs/instructions/src/lib.rs b/codex-rs/instructions/src/lib.rs deleted file mode 100644 index 1b1f81550c..0000000000 --- a/codex-rs/instructions/src/lib.rs +++ /dev/null @@ -1,11 +0,0 @@ -//! User and skill instruction payloads and contextual user fragment markers for Codex prompts. - -mod fragment; -mod user_instructions; - -pub use fragment::AGENTS_MD_FRAGMENT; -pub use fragment::ContextualUserFragmentDefinition; -pub use fragment::SKILL_FRAGMENT; -pub use user_instructions::SkillInstructions; -pub use user_instructions::USER_INSTRUCTIONS_PREFIX; -pub use user_instructions::UserInstructions; diff --git a/codex-rs/instructions/src/user_instructions.rs b/codex-rs/instructions/src/user_instructions.rs deleted file mode 100644 index 4fd266e766..0000000000 --- a/codex-rs/instructions/src/user_instructions.rs +++ /dev/null @@ -1,56 +0,0 @@ -use serde::Deserialize; -use serde::Serialize; - -use codex_protocol::models::ResponseItem; - -use crate::fragment::AGENTS_MD_FRAGMENT; -use crate::fragment::AGENTS_MD_START_MARKER; -use crate::fragment::SKILL_FRAGMENT; - -pub const USER_INSTRUCTIONS_PREFIX: &str = AGENTS_MD_START_MARKER; - -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -#[serde(rename = "user_instructions", rename_all = "snake_case")] -pub struct UserInstructions { - pub directory: String, - pub text: String, -} - -impl UserInstructions { - pub fn serialize_to_text(&self) -> String { - format!( - "{prefix}{directory}\n\n\n{contents}\n{suffix}", - prefix = AGENTS_MD_FRAGMENT.start_marker(), - directory = self.directory, - contents = self.text, - suffix = AGENTS_MD_FRAGMENT.end_marker(), - ) - } -} - -impl From for ResponseItem { - fn from(ui: UserInstructions) -> Self { - AGENTS_MD_FRAGMENT.into_message(ui.serialize_to_text()) - } -} - -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -#[serde(rename = "skill_instructions", rename_all = "snake_case")] -pub struct SkillInstructions { - pub name: String, - pub path: String, - pub contents: String, -} - -impl From for ResponseItem { - fn from(si: SkillInstructions) -> Self { - SKILL_FRAGMENT.into_message(SKILL_FRAGMENT.wrap(format!( - "{}\n{}\n{}", - si.name, si.path, si.contents - ))) - } -} - -#[cfg(test)] -#[path = "user_instructions_tests.rs"] -mod tests; diff --git a/codex-rs/instructions/src/user_instructions_tests.rs b/codex-rs/instructions/src/user_instructions_tests.rs deleted file mode 100644 index 75f35d11b0..0000000000 --- a/codex-rs/instructions/src/user_instructions_tests.rs +++ /dev/null @@ -1,72 +0,0 @@ -use super::*; -use codex_protocol::models::ContentItem; -use codex_protocol::models::ResponseItem; -use pretty_assertions::assert_eq; - -use crate::fragment::AGENTS_MD_FRAGMENT; -use crate::fragment::SKILL_FRAGMENT; - -#[test] -fn test_user_instructions() { - let user_instructions = UserInstructions { - directory: "test_directory".to_string(), - text: "test_text".to_string(), - }; - let response_item: ResponseItem = user_instructions.into(); - - let ResponseItem::Message { role, content, .. } = response_item else { - panic!("expected ResponseItem::Message"); - }; - - assert_eq!(role, "user"); - - let [ContentItem::InputText { text }] = content.as_slice() else { - panic!("expected one InputText content item"); - }; - - assert_eq!( - text, - "# AGENTS.md instructions for test_directory\n\n\ntest_text\n", - ); -} - -#[test] -fn test_is_user_instructions() { - assert!(AGENTS_MD_FRAGMENT.matches_text( - "# AGENTS.md instructions for test_directory\n\n\ntest_text\n" - )); - assert!(!AGENTS_MD_FRAGMENT.matches_text("test_text")); -} - -#[test] -fn test_skill_instructions() { - let skill_instructions = SkillInstructions { - name: "demo-skill".to_string(), - path: "skills/demo/SKILL.md".to_string(), - contents: "body".to_string(), - }; - let response_item: ResponseItem = skill_instructions.into(); - - let ResponseItem::Message { role, content, .. } = response_item else { - panic!("expected ResponseItem::Message"); - }; - - assert_eq!(role, "user"); - - let [ContentItem::InputText { text }] = content.as_slice() else { - panic!("expected one InputText content item"); - }; - - assert_eq!( - text, - "\ndemo-skill\nskills/demo/SKILL.md\nbody\n", - ); -} - -#[test] -fn test_is_skill_instructions() { - assert!(SKILL_FRAGMENT.matches_text( - "\ndemo-skill\nskills/demo/SKILL.md\nbody\n" - )); - assert!(!SKILL_FRAGMENT.matches_text("regular text")); -} diff --git a/codex-rs/login/src/auth/external_bearer.rs b/codex-rs/login/src/auth/external_bearer.rs index c179f48619..c528596014 100644 --- a/codex-rs/login/src/auth/external_bearer.rs +++ b/codex-rs/login/src/auth/external_bearer.rs @@ -33,6 +33,10 @@ impl ExternalAuth for BearerTokenRefresher { AuthMode::ApiKey } + #[expect( + clippy::await_holding_invalid_type, + reason = "external bearer cache misses intentionally hold cached_token across the provider command to avoid duplicate refreshes" + )] async fn resolve(&self) -> io::Result> { let access_token = { let mut cached = self.state.cached_token.lock().await; diff --git a/codex-rs/login/src/auth_env_telemetry.rs b/codex-rs/login/src/auth_env_telemetry.rs index f8824268a4..3cec5a4ce3 100644 --- a/codex-rs/login/src/auth_env_telemetry.rs +++ b/codex-rs/login/src/auth_env_telemetry.rs @@ -65,6 +65,7 @@ mod tests { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, diff --git a/codex-rs/model-provider-info/src/lib.rs b/codex-rs/model-provider-info/src/lib.rs index 80fb705605..97b1e166d6 100644 --- a/codex-rs/model-provider-info/src/lib.rs +++ b/codex-rs/model-provider-info/src/lib.rs @@ -34,6 +34,9 @@ const MAX_REQUEST_MAX_RETRIES: u64 = 100; const OPENAI_PROVIDER_NAME: &str = "OpenAI"; pub const OPENAI_PROVIDER_ID: &str = "openai"; +const AMAZON_BEDROCK_PROVIDER_NAME: &str = "Amazon Bedrock"; +pub const AMAZON_BEDROCK_PROVIDER_ID: &str = "amazon-bedrock"; +pub const AMAZON_BEDROCK_DEFAULT_BASE_URL: &str = "https://bedrock-mantle.us-east-1.api.aws/v1"; const CHAT_WIRE_API_REMOVED_ERROR: &str = "`wire_api = \"chat\"` is no longer supported.\nHow to fix: set `wire_api = \"responses\"` in your provider config.\nMore info: https://github.com/openai/codex/discussions/7782"; pub const LEGACY_OLLAMA_CHAT_PROVIDER_ID: &str = "ollama-chat"; pub const OLLAMA_CHAT_PROVIDER_REMOVED_ERROR: &str = "`ollama-chat` is no longer supported.\nHow to fix: replace `ollama-chat` with `ollama` in `model_provider`, `oss_provider`, or `--local-provider`.\nMore info: https://github.com/openai/codex/discussions/7782"; @@ -71,10 +74,11 @@ impl<'de> Deserialize<'de> for WireApi { } /// Serializable representation of a provider definition. -#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, JsonSchema)] +#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq, JsonSchema)] #[schemars(deny_unknown_fields)] pub struct ModelProviderInfo { /// Friendly display name. + #[serde(default)] pub name: String, /// Base URL for the provider's OpenAI-compatible API. pub base_url: Option, @@ -90,6 +94,8 @@ pub struct ModelProviderInfo { pub experimental_bearer_token: Option, /// Command-backed bearer-token configuration for this provider. pub auth: Option, + /// AWS SigV4 auth configuration for this provider. + pub aws: Option, /// Which wire protocol this provider expects. #[serde(default)] pub wire_api: WireApi, @@ -124,8 +130,46 @@ pub struct ModelProviderInfo { pub supports_websockets: bool, } +/// AWS SigV4 auth configuration for a model provider. +#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, JsonSchema)] +#[schemars(deny_unknown_fields)] +pub struct ModelProviderAwsAuthInfo { + /// AWS profile name to use. When unset, the AWS SDK default chain decides. + pub profile: Option, +} + impl ModelProviderInfo { pub fn validate(&self) -> std::result::Result<(), String> { + if self.aws.is_some() { + if self.supports_websockets { + // TODO(celia-oai): Support AWS SigV4 signing for WebSocket + // upgrade requests before allowing AWS-authenticated providers + // to enable Responses-over-WebSocket. + return Err("provider aws cannot be combined with supports_websockets".to_string()); + } + + let mut conflicts = Vec::new(); + if self.env_key.is_some() { + conflicts.push("env_key"); + } + if self.experimental_bearer_token.is_some() { + conflicts.push("experimental_bearer_token"); + } + if self.auth.is_some() { + conflicts.push("auth"); + } + if self.requires_openai_auth { + conflicts.push("requires_openai_auth"); + } + + if !conflicts.is_empty() { + return Err(format!( + "provider aws cannot be combined with {}", + conflicts.join(", ") + )); + } + } + let Some(auth) = self.auth.as_ref() else { return Ok(()); }; @@ -269,6 +313,7 @@ impl ModelProviderInfo { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: Some( @@ -297,10 +342,38 @@ impl ModelProviderInfo { } } + pub fn create_amazon_bedrock_provider( + aws: Option, + ) -> ModelProviderInfo { + ModelProviderInfo { + name: AMAZON_BEDROCK_PROVIDER_NAME.into(), + base_url: Some(AMAZON_BEDROCK_DEFAULT_BASE_URL.into()), + env_key: None, + env_key_instructions: None, + experimental_bearer_token: None, + auth: None, + aws: Some(aws.unwrap_or(ModelProviderAwsAuthInfo { profile: None })), + wire_api: WireApi::Responses, + query_params: None, + http_headers: None, + env_http_headers: None, + request_max_retries: None, + stream_max_retries: None, + stream_idle_timeout_ms: None, + websocket_connect_timeout_ms: None, + requires_openai_auth: false, + supports_websockets: false, + } + } + pub fn is_openai(&self) -> bool { self.name == OPENAI_PROVIDER_NAME } + pub fn is_amazon_bedrock(&self) -> bool { + self.name == AMAZON_BEDROCK_PROVIDER_NAME + } + pub fn supports_remote_compaction(&self) -> bool { self.is_openai() || is_azure_responses_provider(&self.name, self.base_url.as_deref()) } @@ -322,6 +395,7 @@ pub fn built_in_model_providers( ) -> HashMap { use ModelProviderInfo as P; let openai_provider = P::create_openai_provider(openai_base_url); + let amazon_bedrock_provider = P::create_amazon_bedrock_provider(/*aws*/ None); // We do not want to be in the business of adjucating which third-party // providers are bundled with Codex CLI, so we only include the OpenAI and @@ -329,6 +403,7 @@ pub fn built_in_model_providers( // `model_providers` in config.toml to add their own providers. [ (OPENAI_PROVIDER_ID, openai_provider), + (AMAZON_BEDROCK_PROVIDER_ID, amazon_bedrock_provider), ( OLLAMA_OSS_PROVIDER_ID, create_oss_provider(DEFAULT_OLLAMA_PORT, WireApi::Responses), @@ -343,6 +418,39 @@ pub fn built_in_model_providers( .collect() } +/// Merge configured providers into the built-in provider catalog. +/// +/// Configured providers extend the built-in set. Built-in providers are not +/// generally overridable, but the built-in Amazon Bedrock provider allows the +/// user to set `aws.profile`. +pub fn merge_configured_model_providers( + mut model_providers: HashMap, + configured_model_providers: HashMap, +) -> Result, String> { + for (key, mut provider) in configured_model_providers { + if key == AMAZON_BEDROCK_PROVIDER_ID { + let aws_override = provider.aws.take(); + if provider != ModelProviderInfo::default() { + return Err(format!( + "model_providers.{AMAZON_BEDROCK_PROVIDER_ID} only supports changing \ +`aws.profile`; other non-default provider fields are not supported" + )); + } + + if let Some(profile) = aws_override.and_then(|aws| aws.profile) + && let Some(built_in) = model_providers.get_mut(AMAZON_BEDROCK_PROVIDER_ID) + && let Some(aws) = built_in.aws.as_mut() + { + aws.profile = Some(profile); + } + } else { + model_providers.entry(key).or_insert(provider); + } + } + + Ok(model_providers) +} + pub fn create_oss_provider(default_provider_port: u16, wire_api: WireApi) -> ModelProviderInfo { // These CODEX_OSS_ environment variables are experimental: we may // switch to reading values from config.toml instead. @@ -370,6 +478,7 @@ pub fn create_oss_provider_with_base_url(base_url: &str, wire_api: WireApi) -> M env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api, query_params: None, http_headers: None, diff --git a/codex-rs/model-provider-info/src/model_provider_info_tests.rs b/codex-rs/model-provider-info/src/model_provider_info_tests.rs index 6cd1ef2366..20440de32c 100644 --- a/codex-rs/model-provider-info/src/model_provider_info_tests.rs +++ b/codex-rs/model-provider-info/src/model_provider_info_tests.rs @@ -18,6 +18,7 @@ base_url = "http://localhost:11434/v1" env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, @@ -49,6 +50,7 @@ query_params = { api-version = "2025-04-01-preview" } env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: Some(maplit::hashmap! { "api-version".to_string() => "2025-04-01-preview".to_string(), @@ -83,6 +85,7 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" } env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: Some(maplit::hashmap! { @@ -145,6 +148,7 @@ fn test_supports_remote_compaction_for_azure_name() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, @@ -169,6 +173,7 @@ fn test_supports_remote_compaction_for_non_openai_non_azure_provider() { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, @@ -212,6 +217,190 @@ args = ["--format=text"] ); } +#[test] +fn test_deserialize_provider_aws_config() { + let provider_toml = r#" +name = "Amazon Bedrock" +base_url = "https://bedrock.example.com/v1" + +[aws] +profile = "codex-bedrock" + "#; + + let provider: ModelProviderInfo = toml::from_str(provider_toml).unwrap(); + + assert_eq!( + provider.aws, + Some(ModelProviderAwsAuthInfo { + profile: Some("codex-bedrock".to_string()), + }) + ); +} + +#[test] +fn test_create_amazon_bedrock_provider() { + assert_eq!( + ModelProviderInfo::create_amazon_bedrock_provider(/*aws*/ None), + ModelProviderInfo { + name: "Amazon Bedrock".to_string(), + base_url: Some("https://bedrock-mantle.us-east-1.api.aws/v1".to_string()), + env_key: None, + env_key_instructions: None, + experimental_bearer_token: None, + auth: None, + aws: Some(ModelProviderAwsAuthInfo { profile: None }), + wire_api: WireApi::Responses, + query_params: None, + http_headers: None, + env_http_headers: None, + request_max_retries: None, + stream_max_retries: None, + stream_idle_timeout_ms: None, + websocket_connect_timeout_ms: None, + requires_openai_auth: false, + supports_websockets: false, + } + ); +} + +#[test] +fn test_built_in_model_providers_include_amazon_bedrock() { + let providers = built_in_model_providers(/*openai_base_url*/ None); + + assert_eq!( + providers + .get(AMAZON_BEDROCK_PROVIDER_ID) + .map(ModelProviderInfo::is_amazon_bedrock), + Some(true) + ); +} + +#[test] +fn test_merge_configured_model_providers_adds_custom_provider() { + let custom_provider = ModelProviderInfo { + name: "Custom".to_string(), + base_url: Some("https://example.com/v1".to_string()), + ..ModelProviderInfo::default() + }; + let configured_model_providers = + std::collections::HashMap::from([("custom".to_string(), custom_provider.clone())]); + + let mut expected = built_in_model_providers(/*openai_base_url*/ None); + expected.insert("custom".to_string(), custom_provider); + + assert_eq!( + merge_configured_model_providers( + built_in_model_providers(/*openai_base_url*/ None), + configured_model_providers, + ), + Ok(expected) + ); +} + +#[test] +fn test_merge_configured_model_providers_applies_amazon_bedrock_profile_override() { + let configured_model_providers = std::collections::HashMap::from([( + AMAZON_BEDROCK_PROVIDER_ID.to_string(), + ModelProviderInfo { + aws: Some(ModelProviderAwsAuthInfo { + profile: Some("codex-bedrock".to_string()), + }), + ..ModelProviderInfo::default() + }, + )]); + + let mut expected = built_in_model_providers(/*openai_base_url*/ None); + expected + .get_mut(AMAZON_BEDROCK_PROVIDER_ID) + .expect("Amazon Bedrock provider should be built in") + .aws = Some(ModelProviderAwsAuthInfo { + profile: Some("codex-bedrock".to_string()), + }); + + assert_eq!( + merge_configured_model_providers( + built_in_model_providers(/*openai_base_url*/ None), + configured_model_providers, + ), + Ok(expected) + ); +} + +#[test] +fn test_merge_configured_model_providers_rejects_amazon_bedrock_non_default_fields() { + let configured_model_providers = std::collections::HashMap::from([( + AMAZON_BEDROCK_PROVIDER_ID.to_string(), + ModelProviderInfo { + name: "Custom Bedrock".to_string(), + aws: Some(ModelProviderAwsAuthInfo { + profile: Some("codex-bedrock".to_string()), + }), + ..ModelProviderInfo::default() + }, + )]); + + assert_eq!( + merge_configured_model_providers( + built_in_model_providers(/*openai_base_url*/ None), + configured_model_providers, + ), + Err( + "model_providers.amazon-bedrock only supports changing `aws.profile`; other non-default provider fields are not supported" + .to_string() + ) + ); +} + +#[test] +fn test_merge_configured_model_providers_allows_amazon_bedrock_default_fields() { + let configured_model_providers = std::collections::HashMap::from([( + AMAZON_BEDROCK_PROVIDER_ID.to_string(), + ModelProviderInfo { + aws: Some(ModelProviderAwsAuthInfo { profile: None }), + wire_api: WireApi::Responses, + ..ModelProviderInfo::default() + }, + )]); + + assert_eq!( + merge_configured_model_providers( + built_in_model_providers(/*openai_base_url*/ None), + configured_model_providers, + ), + Ok(built_in_model_providers(/*openai_base_url*/ None)) + ); +} + +#[test] +fn test_validate_provider_aws_rejects_conflicting_auth() { + let provider = ModelProviderInfo { + aws: Some(ModelProviderAwsAuthInfo { profile: None }), + env_key: Some("AWS_BEARER_TOKEN_BEDROCK".to_string()), + supports_websockets: false, + ..ModelProviderInfo::create_openai_provider(/*base_url*/ None) + }; + + assert_eq!( + provider.validate(), + Err("provider aws cannot be combined with env_key, requires_openai_auth".to_string()) + ); +} + +#[test] +fn test_validate_provider_aws_rejects_websockets() { + let provider = ModelProviderInfo { + aws: Some(ModelProviderAwsAuthInfo { profile: None }), + requires_openai_auth: false, + supports_websockets: true, + ..ModelProviderInfo::create_openai_provider(/*base_url*/ None) + }; + + assert_eq!( + provider.validate(), + Err("provider aws cannot be combined with supports_websockets".to_string()) + ); +} + #[test] fn test_deserialize_provider_auth_config_allows_zero_refresh_interval() { let base_dir = tempdir().unwrap(); diff --git a/codex-rs/models-manager/src/manager_tests.rs b/codex-rs/models-manager/src/manager_tests.rs index a70f46567e..d004dd8943 100644 --- a/codex-rs/models-manager/src/manager_tests.rs +++ b/codex-rs/models-manager/src/manager_tests.rs @@ -94,6 +94,7 @@ fn provider_for(base_url: String) -> ModelProviderInfo { env_key_instructions: None, experimental_bearer_token: None, auth: None, + aws: None, wire_api: WireApi::Responses, query_params: None, http_headers: None, diff --git a/codex-rs/network-proxy/src/lib.rs b/codex-rs/network-proxy/src/lib.rs index 4fb313805c..760b09e21e 100644 --- a/codex-rs/network-proxy/src/lib.rs +++ b/codex-rs/network-proxy/src/lib.rs @@ -33,11 +33,17 @@ pub use policy::normalize_host; pub use proxy::ALL_PROXY_ENV_KEYS; pub use proxy::ALLOW_LOCAL_BINDING_ENV_KEY; pub use proxy::Args; +#[cfg(target_os = "macos")] +pub use proxy::CODEX_PROXY_GIT_SSH_COMMAND_MARKER; pub use proxy::DEFAULT_NO_PROXY_VALUE; pub use proxy::NO_PROXY_ENV_KEYS; pub use proxy::NetworkProxy; pub use proxy::NetworkProxyBuilder; pub use proxy::NetworkProxyHandle; +pub use proxy::PROXY_ACTIVE_ENV_KEY; +pub use proxy::PROXY_ENV_KEYS; +#[cfg(target_os = "macos")] +pub use proxy::PROXY_GIT_SSH_COMMAND_ENV_KEY; pub use proxy::PROXY_URL_ENV_KEYS; pub use proxy::has_proxy_url_env_vars; pub use proxy::proxy_url_env_value; diff --git a/codex-rs/network-proxy/src/proxy.rs b/codex-rs/network-proxy/src/proxy.rs index 97ea6735f4..426e14ddd2 100644 --- a/codex-rs/network-proxy/src/proxy.rs +++ b/codex-rs/network-proxy/src/proxy.rs @@ -363,7 +363,50 @@ pub const PROXY_URL_ENV_KEYS: &[&str] = &[ ]; pub const ALL_PROXY_ENV_KEYS: &[&str] = &["ALL_PROXY", "all_proxy"]; +pub const PROXY_ACTIVE_ENV_KEY: &str = "CODEX_NETWORK_PROXY_ACTIVE"; pub const ALLOW_LOCAL_BINDING_ENV_KEY: &str = "CODEX_NETWORK_ALLOW_LOCAL_BINDING"; +const ELECTRON_GET_USE_PROXY_ENV_KEY: &str = "ELECTRON_GET_USE_PROXY"; +#[cfg(any(target_os = "macos", test))] +const GIT_SSH_COMMAND_ENV_KEY: &str = "GIT_SSH_COMMAND"; +pub const PROXY_ENV_KEYS: &[&str] = &[ + PROXY_ACTIVE_ENV_KEY, + ALLOW_LOCAL_BINDING_ENV_KEY, + ELECTRON_GET_USE_PROXY_ENV_KEY, + "HTTP_PROXY", + "HTTPS_PROXY", + "http_proxy", + "https_proxy", + "YARN_HTTP_PROXY", + "YARN_HTTPS_PROXY", + "npm_config_http_proxy", + "npm_config_https_proxy", + "npm_config_proxy", + "NPM_CONFIG_HTTP_PROXY", + "NPM_CONFIG_HTTPS_PROXY", + "NPM_CONFIG_PROXY", + "BUNDLE_HTTP_PROXY", + "BUNDLE_HTTPS_PROXY", + "PIP_PROXY", + "DOCKER_HTTP_PROXY", + "DOCKER_HTTPS_PROXY", + "WS_PROXY", + "WSS_PROXY", + "ws_proxy", + "wss_proxy", + "NO_PROXY", + "no_proxy", + "npm_config_noproxy", + "NPM_CONFIG_NOPROXY", + "YARN_NO_PROXY", + "BUNDLE_NO_PROXY", + "ALL_PROXY", + "all_proxy", + "FTP_PROXY", + "ftp_proxy", +]; + +#[cfg(target_os = "macos")] +pub const PROXY_GIT_SSH_COMMAND_ENV_KEY: &str = GIT_SSH_COMMAND_ENV_KEY; const FTP_PROXY_ENV_KEYS: &[&str] = &["FTP_PROXY", "ftp_proxy"]; const WEBSOCKET_PROXY_ENV_KEYS: &[&str] = &["WS_PROXY", "WSS_PROXY", "ws_proxy", "wss_proxy"]; @@ -385,6 +428,14 @@ pub const DEFAULT_NO_PROXY_VALUE: &str = concat!( "192.168.0.0/16" ); +#[cfg(target_os = "macos")] +pub const CODEX_PROXY_GIT_SSH_COMMAND_MARKER: &str = "CODEX_PROXY_GIT_SSH_COMMAND=1 "; +#[cfg(target_os = "macos")] +const CODEX_PROXY_GIT_SSH_COMMAND_PREFIX: &str = + "CODEX_PROXY_GIT_SSH_COMMAND=1 ssh -o ProxyCommand='nc -X 5 -x "; +#[cfg(target_os = "macos")] +const CODEX_PROXY_GIT_SSH_COMMAND_SUFFIX: &str = " %h %p'"; + pub fn proxy_url_env_value<'a>( env: &'a HashMap, canonical_key: &str, @@ -408,6 +459,17 @@ fn set_env_keys(env: &mut HashMap, keys: &[&str], value: &str) { } } +#[cfg(target_os = "macos")] +fn codex_proxy_git_ssh_command(socks_addr: SocketAddr) -> String { + format!("{CODEX_PROXY_GIT_SSH_COMMAND_PREFIX}{socks_addr}{CODEX_PROXY_GIT_SSH_COMMAND_SUFFIX}") +} + +#[cfg(target_os = "macos")] +fn is_codex_proxy_git_ssh_command(command: &str) -> bool { + command.starts_with(CODEX_PROXY_GIT_SSH_COMMAND_PREFIX) + && command.ends_with(CODEX_PROXY_GIT_SSH_COMMAND_SUFFIX) +} + fn apply_proxy_env_overrides( env: &mut HashMap, http_addr: SocketAddr, @@ -417,6 +479,7 @@ fn apply_proxy_env_overrides( ) { let http_proxy_url = format!("http://{http_addr}"); let socks_proxy_url = format!("socks5h://{socks_addr}"); + env.insert(PROXY_ACTIVE_ENV_KEY.to_string(), "1".to_string()); env.insert( ALLOW_LOCAL_BINDING_ENV_KEY.to_string(), if allow_local_binding { @@ -459,7 +522,10 @@ fn apply_proxy_env_overrides( // locally instead of letting the proxy resolve them. set_env_keys(env, NO_PROXY_ENV_KEYS, DEFAULT_NO_PROXY_VALUE); - env.insert("ELECTRON_GET_USE_PROXY".to_string(), "true".to_string()); + env.insert( + ELECTRON_GET_USE_PROXY_ENV_KEY.to_string(), + "true".to_string(), + ); // Keep HTTP_PROXY/HTTPS_PROXY as HTTP endpoints. A lot of clients break if // those vars contain SOCKS URLs. We only switch ALL_PROXY here. @@ -475,9 +541,17 @@ fn apply_proxy_env_overrides( #[cfg(target_os = "macos")] if socks_enabled { // Preserve existing SSH wrappers (for example: Secretive/Teleport setups) - // and only provide a SOCKS ProxyCommand fallback when one is not present. - env.entry("GIT_SSH_COMMAND".to_string()) - .or_insert_with(|| format!("ssh -o ProxyCommand='nc -X 5 -x {socks_addr} %h %p'")); + // but refresh a previously injected Codex fallback so it cannot point + // at a stale proxy port after the proxy is restarted. + match env.get(GIT_SSH_COMMAND_ENV_KEY) { + Some(command) if !is_codex_proxy_git_ssh_command(command) => {} + _ => { + env.insert( + GIT_SSH_COMMAND_ENV_KEY.to_string(), + codex_proxy_git_ssh_command(socks_addr), + ); + } + } } } @@ -936,15 +1010,43 @@ mod tests { assert!(no_proxy.contains("172.16.0.0/12")); assert!(no_proxy.contains("192.168.0.0/16")); assert!(no_proxy.contains("169.254.0.0/16")); + assert_eq!(env.get(PROXY_ACTIVE_ENV_KEY), Some(&"1".to_string())); assert_eq!(env.get(ALLOW_LOCAL_BINDING_ENV_KEY), Some(&"0".to_string())); - assert_eq!(env.get("ELECTRON_GET_USE_PROXY"), Some(&"true".to_string())); + assert_eq!( + env.get(ELECTRON_GET_USE_PROXY_ENV_KEY), + Some(&"true".to_string()) + ); #[cfg(target_os = "macos")] assert_eq!( - env.get("GIT_SSH_COMMAND"), - Some(&"ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'".to_string()) + env.get(GIT_SSH_COMMAND_ENV_KEY), + Some( + &"CODEX_PROXY_GIT_SSH_COMMAND=1 ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'" + .to_string() + ) ); #[cfg(not(target_os = "macos"))] - assert_eq!(env.get("GIT_SSH_COMMAND"), None); + assert_eq!(env.get(GIT_SSH_COMMAND_ENV_KEY), None); + } + + #[test] + fn apply_proxy_env_overrides_sets_only_expected_env_keys() { + let mut env = HashMap::new(); + apply_proxy_env_overrides( + &mut env, + SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 3128), + SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8081), + /*socks_enabled*/ true, + /*allow_local_binding*/ false, + ); + + for key in env.keys() { + let is_managed_git_ssh_key = + cfg!(target_os = "macos") && key == GIT_SSH_COMMAND_ENV_KEY; + assert!( + PROXY_ENV_KEYS.contains(&key.as_str()) || is_managed_git_ssh_key, + "proxy env writer set unexpected key: {key}" + ); + } } #[test] @@ -998,11 +1100,14 @@ mod tests { ); #[cfg(target_os = "macos")] assert_eq!( - env.get("GIT_SSH_COMMAND"), - Some(&"ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'".to_string()) + env.get(GIT_SSH_COMMAND_ENV_KEY), + Some( + &"CODEX_PROXY_GIT_SSH_COMMAND=1 ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'" + .to_string() + ) ); #[cfg(not(target_os = "macos"))] - assert_eq!(env.get("GIT_SSH_COMMAND"), None); + assert_eq!(env.get(GIT_SSH_COMMAND_ENV_KEY), None); } #[cfg(target_os = "macos")] @@ -1010,7 +1115,7 @@ mod tests { fn apply_proxy_env_overrides_preserves_existing_git_ssh_command() { let mut env = HashMap::new(); env.insert( - "GIT_SSH_COMMAND".to_string(), + GIT_SSH_COMMAND_ENV_KEY.to_string(), "ssh -o ProxyCommand='tsh proxy ssh --cluster=dev %r@%h:%p'".to_string(), ); apply_proxy_env_overrides( @@ -1022,8 +1127,56 @@ mod tests { ); assert_eq!( - env.get("GIT_SSH_COMMAND"), + env.get(GIT_SSH_COMMAND_ENV_KEY), Some(&"ssh -o ProxyCommand='tsh proxy ssh --cluster=dev %r@%h:%p'".to_string()) ); } + + #[cfg(target_os = "macos")] + #[test] + fn apply_proxy_env_overrides_preserves_unmarked_git_ssh_command_with_proxy_shape() { + let mut env = HashMap::new(); + env.insert( + GIT_SSH_COMMAND_ENV_KEY.to_string(), + "ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'".to_string(), + ); + apply_proxy_env_overrides( + &mut env, + SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 3128), + SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 48081), + /*socks_enabled*/ true, + /*allow_local_binding*/ false, + ); + + assert_eq!( + env.get(GIT_SSH_COMMAND_ENV_KEY), + Some(&"ssh -o ProxyCommand='nc -X 5 -x 127.0.0.1:8081 %h %p'".to_string()) + ); + } + + #[cfg(target_os = "macos")] + #[test] + fn apply_proxy_env_overrides_refreshes_previous_codex_proxy_git_ssh_command() { + let mut env = HashMap::new(); + env.insert( + GIT_SSH_COMMAND_ENV_KEY.to_string(), + codex_proxy_git_ssh_command(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 8081)), + ); + + apply_proxy_env_overrides( + &mut env, + SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 43128), + SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 48081), + /*socks_enabled*/ true, + /*allow_local_binding*/ false, + ); + + assert_eq!( + env.get(GIT_SSH_COMMAND_ENV_KEY), + Some(&codex_proxy_git_ssh_command(SocketAddr::new( + IpAddr::V4(Ipv4Addr::LOCALHOST), + 48081, + ))) + ); + } } diff --git a/codex-rs/network-proxy/src/runtime.rs b/codex-rs/network-proxy/src/runtime.rs index da090a69d4..daafeec737 100644 --- a/codex-rs/network-proxy/src/runtime.rs +++ b/codex-rs/network-proxy/src/runtime.rs @@ -420,32 +420,29 @@ impl NetworkProxyState { let blocked_for_observer = entry.clone(); let blocked_request_observer = self.blocked_request_observer.read().await.clone(); let violation_line = blocked_request_violation_log_line(&entry); - let mut guard = self.state.write().await; let host = entry.host.clone(); let reason = entry.reason.clone(); let decision = entry.decision.clone(); let source = entry.source.clone(); let protocol = entry.protocol.clone(); let port = entry.port; - guard.blocked.push_back(entry); - guard.blocked_total = guard.blocked_total.saturating_add(1); - let total = guard.blocked_total; - while guard.blocked.len() > MAX_BLOCKED_EVENTS { - guard.blocked.pop_front(); - } + let (total, buffered) = { + let mut guard = self.state.write().await; + guard.blocked.push_back(entry); + guard.blocked_total = guard.blocked_total.saturating_add(1); + let total = guard.blocked_total; + while guard.blocked.len() > MAX_BLOCKED_EVENTS { + guard.blocked.pop_front(); + } + (total, guard.blocked.len()) + }; debug!( - "recorded blocked request telemetry (total={}, host={}, reason={}, decision={:?}, source={:?}, protocol={}, port={:?}, buffered={})", - total, - host, - reason, - decision, - source, - protocol, - port, - guard.blocked.len() + "recorded blocked request telemetry (\ + total={total}, host={host}, reason={reason}, \ + decision={decision:?}, source={source:?}, \ + protocol={protocol}, port={port:?}, buffered={buffered})" ); debug!("{violation_line}"); - drop(guard); if let Some(observer) = blocked_request_observer { observer.on_blocked_request(blocked_for_observer).await; diff --git a/codex-rs/protocol/src/approvals.rs b/codex-rs/protocol/src/approvals.rs index b8839b51b6..8799db4a6e 100644 --- a/codex-rs/protocol/src/approvals.rs +++ b/codex-rs/protocol/src/approvals.rs @@ -6,6 +6,7 @@ use crate::permissions::NetworkSandboxPolicy; use crate::protocol::FileChange; use crate::protocol::ReviewDecision; use crate::protocol::SandboxPolicy; +use crate::request_permissions::RequestPermissionProfile; use codex_utils_absolute_path::AbsolutePathBuf; use schemars::JsonSchema; use serde::Deserialize; @@ -163,6 +164,10 @@ pub enum GuardianAssessmentAction { connector_name: Option, tool_title: Option, }, + RequestPermissions { + reason: Option, + permissions: RequestPermissionProfile, + }, } #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, JsonSchema, TS)] diff --git a/codex-rs/protocol/src/dynamic_tools.rs b/codex-rs/protocol/src/dynamic_tools.rs index 8572bb5e81..2bee24972b 100644 --- a/codex-rs/protocol/src/dynamic_tools.rs +++ b/codex-rs/protocol/src/dynamic_tools.rs @@ -8,6 +8,8 @@ use ts_rs::TS; #[derive(Debug, Clone, Serialize, PartialEq, JsonSchema, TS)] #[serde(rename_all = "camelCase")] pub struct DynamicToolSpec { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub namespace: Option, pub name: String, pub description: String, pub input_schema: JsonValue, @@ -20,6 +22,8 @@ pub struct DynamicToolSpec { pub struct DynamicToolCallRequest { pub call_id: String, pub turn_id: String, + #[serde(default)] + pub namespace: Option, pub tool: String, pub arguments: JsonValue, } @@ -44,6 +48,7 @@ pub enum DynamicToolCallOutputContentItem { #[derive(Deserialize)] #[serde(rename_all = "camelCase")] struct DynamicToolSpecDe { + namespace: Option, name: String, description: String, input_schema: JsonValue, @@ -57,6 +62,7 @@ impl<'de> Deserialize<'de> for DynamicToolSpec { D: Deserializer<'de>, { let DynamicToolSpecDe { + namespace, name, description, input_schema, @@ -65,6 +71,7 @@ impl<'de> Deserialize<'de> for DynamicToolSpec { } = DynamicToolSpecDe::deserialize(deserializer)?; Ok(Self { + namespace, name, description, input_schema, @@ -99,6 +106,7 @@ mod tests { assert_eq!( actual, DynamicToolSpec { + namespace: None, name: "lookup_ticket".to_string(), description: "Fetch a ticket".to_string(), input_schema: json!({ diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rs index 25c44fae09..b0134630f3 100644 --- a/codex-rs/protocol/src/models.rs +++ b/codex-rs/protocol/src/models.rs @@ -1,6 +1,7 @@ use std::collections::HashMap; use std::fmt; use std::io; +use std::num::NonZeroUsize; use std::path::Path; use std::path::PathBuf; use std::sync::LazyLock; @@ -146,6 +147,7 @@ impl SandboxPermissions { #[derive(Debug, Clone, Default, Eq, Hash, PartialEq, JsonSchema, TS)] pub struct FileSystemPermissions { pub entries: Vec, + pub glob_scan_max_depth: Option, } pub type LegacyReadWriteRoots = (Option>, Option>); @@ -172,7 +174,10 @@ impl FileSystemPermissions { access: FileSystemAccessMode::Write, })); } - Self { entries } + Self { + entries, + glob_scan_max_depth: None, + } } pub fn explicit_path_entries( @@ -190,6 +195,10 @@ impl FileSystemPermissions { } fn as_legacy_permissions(&self) -> Option { + if self.glob_scan_max_depth.is_some() { + return None; + } + let mut read = Vec::new(); let mut write = Vec::new(); @@ -225,6 +234,8 @@ struct LegacyFileSystemPermissions { struct CanonicalFileSystemPermissions { #[serde(default, skip_serializing_if = "Vec::is_empty")] entries: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + glob_scan_max_depth: Option, } #[derive(Debug, Clone, Deserialize)] @@ -244,6 +255,7 @@ impl Serialize for FileSystemPermissions { } else { CanonicalFileSystemPermissions { entries: self.entries.clone(), + glob_scan_max_depth: self.glob_scan_max_depth, } .serialize(serializer) } @@ -256,9 +268,13 @@ impl<'de> Deserialize<'de> for FileSystemPermissions { D: Deserializer<'de>, { match FileSystemPermissionsDe::deserialize(deserializer)? { - FileSystemPermissionsDe::Canonical(CanonicalFileSystemPermissions { entries }) => { - Ok(Self { entries }) - } + FileSystemPermissionsDe::Canonical(CanonicalFileSystemPermissions { + entries, + glob_scan_max_depth, + }) => Ok(Self { + entries, + glob_scan_max_depth, + }), FileSystemPermissionsDe::Legacy(LegacyFileSystemPermissions { read, write }) => { Ok(Self::from_read_write_roots(read, write)) } @@ -352,13 +368,18 @@ impl From<&FileSystemSandboxPolicy> for FileSystemPermissions { }] } }; - Self { entries } + Self { + entries, + glob_scan_max_depth: value.glob_scan_max_depth.and_then(NonZeroUsize::new), + } } } impl From<&FileSystemPermissions> for FileSystemSandboxPolicy { fn from(value: &FileSystemPermissions) -> Self { - FileSystemSandboxPolicy::restricted(value.entries.clone()) + let mut policy = FileSystemSandboxPolicy::restricted(value.entries.clone()); + policy.glob_scan_max_depth = value.glob_scan_max_depth.map(usize::from); + policy } } @@ -1828,6 +1849,69 @@ mod tests { assert_eq!(permission_profile.is_empty(), false); } + #[test] + fn permission_profile_round_trip_preserves_glob_scan_max_depth() { + let mut file_system_sandbox_policy = + FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry { + path: FileSystemPath::GlobPattern { + pattern: "**/*.env".to_string(), + }, + access: FileSystemAccessMode::None, + }]); + file_system_sandbox_policy.glob_scan_max_depth = Some(2); + + let permission_profile = PermissionProfile::from_runtime_permissions( + &file_system_sandbox_policy, + NetworkSandboxPolicy::Restricted, + ); + + assert_eq!( + permission_profile.file_system_sandbox_policy(), + file_system_sandbox_policy + ); + } + + #[test] + fn file_system_permissions_with_glob_scan_depth_uses_canonical_json() -> Result<()> { + let path = AbsolutePathBuf::try_from(PathBuf::from(if cfg!(windows) { + r"C:\tmp\allowed" + } else { + "/tmp/allowed" + })) + .expect("absolute path"); + let file_system_permissions = FileSystemPermissions { + entries: vec![FileSystemSandboxEntry { + path: FileSystemPath::Path { path }, + access: FileSystemAccessMode::Read, + }], + glob_scan_max_depth: NonZeroUsize::new(2), + }; + + let serialized = serde_json::to_value(&file_system_permissions)?; + + assert_eq!(serialized.get("read"), None); + assert_eq!(serialized.get("write"), None); + assert_eq!( + serialized.get("glob_scan_max_depth"), + Some(&serde_json::json!(2)) + ); + assert!(serialized.get("entries").is_some()); + assert_eq!( + serde_json::from_value::(serialized)?, + file_system_permissions + ); + Ok(()) + } + + #[test] + fn file_system_permissions_rejects_zero_glob_scan_depth() { + serde_json::from_value::(serde_json::json!({ + "entries": [], + "glob_scan_max_depth": 0, + })) + .expect_err("zero glob scan depth should fail deserialization"); + } + #[test] fn convert_mcp_content_to_items_builds_data_urls_when_missing_prefix() { let contents = vec![serde_json::json!({ diff --git a/codex-rs/protocol/src/protocol.rs b/codex-rs/protocol/src/protocol.rs index 475d2941c3..b9a7a1395f 100644 --- a/codex-rs/protocol/src/protocol.rs +++ b/codex-rs/protocol/src/protocol.rs @@ -329,6 +329,12 @@ pub struct RealtimeHandoffRequested { pub active_transcript: Vec, } +#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, JsonSchema, TS)] +pub struct RealtimeNoopRequested { + pub call_id: String, + pub item_id: String, +} + #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, JsonSchema, TS)] pub struct RealtimeInputAudioSpeechStarted { pub item_id: Option, @@ -369,6 +375,7 @@ pub enum RealtimeEvent { item_id: String, }, HandoffRequested(RealtimeHandoffRequested), + NoopRequested(RealtimeNoopRequested), Error(String), } @@ -2434,6 +2441,9 @@ pub struct DynamicToolCallResponseEvent { pub call_id: String, /// Turn ID that this dynamic tool call belongs to. pub turn_id: String, + /// Dynamic tool namespace, when one was provided. + #[serde(default)] + pub namespace: Option, /// Dynamic tool name. pub tool: String, /// Dynamic tool call arguments. diff --git a/codex-rs/rmcp-client/src/oauth.rs b/codex-rs/rmcp-client/src/oauth.rs index 979a7ad217..5adfae9347 100644 --- a/codex-rs/rmcp-client/src/oauth.rs +++ b/codex-rs/rmcp-client/src/oauth.rs @@ -283,6 +283,10 @@ impl OAuthPersistor { /// Persists the latest stored credentials if they have changed. /// Deletes the credentials if they are no longer present. + #[expect( + clippy::await_holding_invalid_type, + reason = "AuthorizationManager async access must be serialized through its mutex" + )] pub(crate) async fn persist_if_needed(&self) -> Result<()> { let (client_id, maybe_credentials) = { let manager = self.inner.authorization_manager.clone(); @@ -335,6 +339,10 @@ impl OAuthPersistor { Ok(()) } + #[expect( + clippy::await_holding_invalid_type, + reason = "AuthorizationManager async access must be serialized through its mutex" + )] pub(crate) async fn refresh_if_needed(&self) -> Result<()> { let expires_at = { let guard = self.inner.last_credentials.lock().await; diff --git a/codex-rs/sandboxing/src/policy_transforms.rs b/codex-rs/sandboxing/src/policy_transforms.rs index aa0ccc267b..2b8c01eaae 100644 --- a/codex-rs/sandboxing/src/policy_transforms.rs +++ b/codex-rs/sandboxing/src/policy_transforms.rs @@ -13,6 +13,7 @@ use codex_protocol::protocol::SandboxPolicy; use codex_utils_absolute_path::AbsolutePathBuf; use codex_utils_absolute_path::canonicalize_preserving_symlinks; use std::collections::HashSet; +use std::num::NonZeroUsize; #[derive(Debug, Clone, PartialEq, Eq)] pub struct EffectiveSandboxPermissions { @@ -45,6 +46,7 @@ pub fn normalize_additional_permissions( let file_system = match additional_permissions.file_system { Some(file_system) => { let mut entries = Vec::with_capacity(file_system.entries.len()); + let glob_scan_max_depth = file_system.glob_scan_max_depth; for entry in file_system.entries { if matches!(&entry.path, FileSystemPath::GlobPattern { .. }) && entry.access != FileSystemAccessMode::None @@ -73,7 +75,10 @@ pub fn normalize_additional_permissions( entries.push(normalized_entry); } } - let file_system = FileSystemPermissions { entries }; + let file_system = FileSystemPermissions { + entries, + glob_scan_max_depth, + }; (!file_system.is_empty()).then_some(file_system) } None => None, @@ -114,6 +119,13 @@ pub fn merge_permission_profiles( let file_system = match (base.file_system.as_ref(), permissions.file_system.as_ref()) { (Some(base), Some(permissions)) => Some(FileSystemPermissions { entries: merge_permission_entries(&base.entries, &permissions.entries), + glob_scan_max_depth: merge_glob_scan_max_depth( + &base.entries, + base.glob_scan_max_depth.map(usize::from), + &permissions.entries, + permissions.glob_scan_max_depth.map(usize::from), + ) + .and_then(NonZeroUsize::new), }) .filter(|file_system| !file_system.is_empty()), (Some(base), None) => Some(base.clone()), @@ -139,12 +151,21 @@ pub fn intersect_permission_profiles( .file_system .map(|requested_file_system| { let granted_file_system = granted.file_system.unwrap_or_default(); - let entries = requested_file_system + let entries: Vec<_> = requested_file_system .entries .into_iter() .filter(|entry| granted_file_system.entries.contains(entry)) .collect(); - FileSystemPermissions { entries } + FileSystemPermissions { + glob_scan_max_depth: merge_glob_scan_max_depth( + &entries, + requested_file_system.glob_scan_max_depth.map(usize::from), + &entries, + granted_file_system.glob_scan_max_depth.map(usize::from), + ) + .and_then(NonZeroUsize::new), + entries, + } }) .filter(|file_system| !file_system.is_empty()); let network = match (requested.network, granted.network) { @@ -167,6 +188,48 @@ pub fn intersect_permission_profiles( } } +fn merge_glob_scan_max_depth( + left_entries: &[FileSystemSandboxEntry], + left_depth: Option, + right_entries: &[FileSystemSandboxEntry], + right_depth: Option, +) -> Option { + let left_depth = effective_glob_scan_depth(left_entries, left_depth); + let right_depth = effective_glob_scan_depth(right_entries, right_depth); + + match (left_depth, right_depth) { + (Some(GlobScanDepth::Unbounded), _) | (_, Some(GlobScanDepth::Unbounded)) => None, + (Some(GlobScanDepth::Bounded(left)), Some(GlobScanDepth::Bounded(right))) => { + Some(left.max(right)) + } + (Some(GlobScanDepth::Bounded(depth)), None) + | (None, Some(GlobScanDepth::Bounded(depth))) => Some(depth), + (None, None) => None, + } +} + +fn effective_glob_scan_depth( + entries: &[FileSystemSandboxEntry], + depth: Option, +) -> Option { + entries + .iter() + .any(|entry| { + entry.access == FileSystemAccessMode::None + && matches!(&entry.path, FileSystemPath::GlobPattern { .. }) + }) + .then_some(match depth { + Some(depth) => GlobScanDepth::Bounded(depth), + None => GlobScanDepth::Unbounded, + }) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +enum GlobScanDepth { + Bounded(usize), + Unbounded, +} + fn merge_permission_entries( base: &[FileSystemSandboxEntry], permissions: &[FileSystemSandboxEntry], @@ -234,6 +297,12 @@ fn merge_file_system_policy_with_additional_permissions( merged_policy.entries.push(entry.clone()); } } + merged_policy.glob_scan_max_depth = merge_glob_scan_max_depth( + &file_system_policy.entries, + file_system_policy.glob_scan_max_depth, + &additional_permissions.entries, + additional_permissions.glob_scan_max_depth.map(usize::from), + ); merged_policy } FileSystemSandboxKind::Unrestricted | FileSystemSandboxKind::ExternalSandbox => { diff --git a/codex-rs/sandboxing/src/policy_transforms_tests.rs b/codex-rs/sandboxing/src/policy_transforms_tests.rs index 5de8a5cd5a..8fcff965fe 100644 --- a/codex-rs/sandboxing/src/policy_transforms_tests.rs +++ b/codex-rs/sandboxing/src/policy_transforms_tests.rs @@ -171,6 +171,7 @@ fn normalize_additional_permissions_rejects_glob_read_grants() { }, access: FileSystemAccessMode::Read, }], + glob_scan_max_depth: None, }), ..Default::default() }) @@ -192,6 +193,7 @@ fn normalize_additional_permissions_preserves_deny_globs() { }, access: FileSystemAccessMode::None, }], + glob_scan_max_depth: std::num::NonZeroUsize::new(2), }), ..Default::default() }) @@ -207,6 +209,7 @@ fn normalize_additional_permissions_preserves_deny_globs() { }, access: FileSystemAccessMode::None, }], + glob_scan_max_depth: std::num::NonZeroUsize::new(2), }), ..Default::default() } @@ -288,6 +291,76 @@ fn intersect_permission_profiles_drops_explicit_empty_reads_without_grant() { ); } +#[test] +fn intersect_permission_profiles_uses_granted_bounded_glob_scan_depth() { + let deny_env_files = FileSystemSandboxEntry { + path: FileSystemPath::GlobPattern { + pattern: "**/*.env".to_string(), + }, + access: FileSystemAccessMode::None, + }; + let requested = PermissionProfile { + file_system: Some(FileSystemPermissions { + entries: vec![deny_env_files.clone()], + glob_scan_max_depth: std::num::NonZeroUsize::new(2), + }), + ..Default::default() + }; + let granted = PermissionProfile { + file_system: Some(FileSystemPermissions { + entries: vec![deny_env_files.clone()], + glob_scan_max_depth: std::num::NonZeroUsize::new(4), + }), + ..Default::default() + }; + + assert_eq!( + intersect_permission_profiles(requested, granted), + PermissionProfile { + file_system: Some(FileSystemPermissions { + entries: vec![deny_env_files], + glob_scan_max_depth: std::num::NonZeroUsize::new(4), + }), + ..Default::default() + } + ); +} + +#[test] +fn intersect_permission_profiles_uses_granted_unbounded_glob_scan_depth() { + let deny_env_files = FileSystemSandboxEntry { + path: FileSystemPath::GlobPattern { + pattern: "**/*.env".to_string(), + }, + access: FileSystemAccessMode::None, + }; + let requested = PermissionProfile { + file_system: Some(FileSystemPermissions { + entries: vec![deny_env_files.clone()], + glob_scan_max_depth: std::num::NonZeroUsize::new(2), + }), + ..Default::default() + }; + let granted = PermissionProfile { + file_system: Some(FileSystemPermissions { + entries: vec![deny_env_files.clone()], + glob_scan_max_depth: None, + }), + ..Default::default() + }; + + assert_eq!( + intersect_permission_profiles(requested, granted), + PermissionProfile { + file_system: Some(FileSystemPermissions { + entries: vec![deny_env_files], + glob_scan_max_depth: None, + }), + ..Default::default() + } + ); +} + #[test] fn read_only_additional_permissions_can_enable_network_without_writes() { let temp_dir = TempDir::new().expect("create temp dir"); @@ -402,6 +475,42 @@ fn merge_file_system_policy_with_additional_permissions_preserves_unreadable_roo ); } +#[test] +fn merge_file_system_policy_with_additional_permissions_carries_bounded_glob_scan_depth() { + let deny_env_files = FileSystemSandboxEntry { + path: FileSystemPath::GlobPattern { + pattern: "**/*.env".to_string(), + }, + access: FileSystemAccessMode::None, + }; + let merged_policy = merge_file_system_policy_with_additional_permissions( + &FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry { + path: FileSystemPath::Special { + value: FileSystemSpecialPath::Root, + }, + access: FileSystemAccessMode::Write, + }]), + &FileSystemPermissions { + entries: vec![deny_env_files.clone()], + glob_scan_max_depth: std::num::NonZeroUsize::new(2), + }, + ); + + assert_eq!(merged_policy, { + let mut policy = FileSystemSandboxPolicy::restricted(vec![ + FileSystemSandboxEntry { + path: FileSystemPath::Special { + value: FileSystemSpecialPath::Root, + }, + access: FileSystemAccessMode::Write, + }, + deny_env_files, + ]); + policy.glob_scan_max_depth = Some(2); + policy + }); +} + #[test] fn effective_file_system_sandbox_policy_returns_base_policy_without_additional_permissions() { let temp_dir = TempDir::new().expect("create temp dir"); diff --git a/codex-rs/state/migrations/0026_thread_dynamic_tools_namespace.sql b/codex-rs/state/migrations/0026_thread_dynamic_tools_namespace.sql new file mode 100644 index 0000000000..56518d5597 --- /dev/null +++ b/codex-rs/state/migrations/0026_thread_dynamic_tools_namespace.sql @@ -0,0 +1,2 @@ +ALTER TABLE thread_dynamic_tools +ADD COLUMN namespace TEXT; diff --git a/codex-rs/state/src/runtime/threads.rs b/codex-rs/state/src/runtime/threads.rs index 5592ca54df..ec094a7339 100644 --- a/codex-rs/state/src/runtime/threads.rs +++ b/codex-rs/state/src/runtime/threads.rs @@ -56,7 +56,7 @@ WHERE threads.id = ? ) -> anyhow::Result>> { let rows = sqlx::query( r#" -SELECT name, description, input_schema, defer_loading +SELECT namespace, name, description, input_schema, defer_loading FROM thread_dynamic_tools WHERE thread_id = ? ORDER BY position ASC @@ -73,6 +73,7 @@ ORDER BY position ASC let input_schema: String = row.try_get("input_schema")?; let input_schema = serde_json::from_str::(input_schema.as_str())?; tools.push(DynamicToolSpec { + namespace: row.try_get("namespace")?, name: row.try_get("name")?, description: row.try_get("description")?, input_schema, @@ -145,6 +146,17 @@ ON CONFLICT(child_thread_id) DO UPDATE SET .await } + /// List all spawned descendants of `root_thread_id`. + /// + /// Descendants are returned breadth-first by depth, then by thread id for stable ordering. + pub async fn list_thread_spawn_descendants( + &self, + root_thread_id: ThreadId, + ) -> anyhow::Result> { + self.list_thread_spawn_descendants_matching(root_thread_id, /*status*/ None) + .await + } + /// Find a direct spawned child of `parent_thread_id` by canonical agent path. pub async fn find_thread_spawn_child_by_path( &self, @@ -767,16 +779,18 @@ ON CONFLICT(id) DO UPDATE SET INSERT INTO thread_dynamic_tools ( thread_id, position, + namespace, name, description, input_schema, defer_loading -) VALUES (?, ?, ?, ?, ?, ?) +) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(thread_id, position) DO NOTHING "#, ) .bind(thread_id.as_str()) .bind(position) + .bind(tool.namespace.as_deref()) .bind(tool.name.as_str()) .bind(tool.description.as_str()) .bind(input_schema) @@ -1761,5 +1775,11 @@ mod tests { .await .expect("open descendants from child should load"); assert_eq!(open_descendants_from_child, vec![grandchild_thread_id]); + + let all_descendants = runtime + .list_thread_spawn_descendants(parent_thread_id) + .await + .expect("all descendants should load"); + assert_eq!(all_descendants, vec![child_thread_id, grandchild_thread_id]); } } diff --git a/codex-rs/stdio-to-uds/Cargo.toml b/codex-rs/stdio-to-uds/Cargo.toml index bc62ee8d25..76d2176927 100644 --- a/codex-rs/stdio-to-uds/Cargo.toml +++ b/codex-rs/stdio-to-uds/Cargo.toml @@ -17,9 +17,13 @@ workspace = true [dependencies] anyhow = { workspace = true } - -[target.'cfg(target_os = "windows")'.dependencies] -uds_windows = { workspace = true } +codex-uds = { workspace = true } +tokio = { workspace = true, features = [ + "io-std", + "io-util", + "macros", + "rt-multi-thread", +] } [dev-dependencies] codex-utils-cargo-bin = { workspace = true } diff --git a/codex-rs/stdio-to-uds/README.md b/codex-rs/stdio-to-uds/README.md index 96ac67960b..9fe838e300 100644 --- a/codex-rs/stdio-to-uds/README.md +++ b/codex-rs/stdio-to-uds/README.md @@ -17,4 +17,4 @@ Unfortunately, the Rust standard library does not provide support for UNIX domai https://github.com/rust-lang/rust/issues/56533 -As a workaround, this crate leverages https://crates.io/crates/uds_windows as a dependency on Windows. +As a workaround, this crate uses `codex-uds`, which provides a cross-platform async UDS API backed by https://crates.io/crates/uds_windows on Windows. diff --git a/codex-rs/stdio-to-uds/src/lib.rs b/codex-rs/stdio-to-uds/src/lib.rs index 9d2cb6c0f0..a103de3312 100644 --- a/codex-rs/stdio-to-uds/src/lib.rs +++ b/codex-rs/stdio-to-uds/src/lib.rs @@ -1,56 +1,46 @@ #![deny(clippy::print_stdout)] use std::io; -use std::io::Write; -use std::net::Shutdown; use std::path::Path; -use std::thread; use anyhow::Context; -use anyhow::anyhow; - -#[cfg(unix)] -use std::os::unix::net::UnixStream; - -#[cfg(windows)] -use uds_windows::UnixStream; +use codex_uds::UnixStream; +use tokio::io::AsyncWriteExt; /// Connects to the Unix Domain Socket at `socket_path` and relays data between /// standard input/output and the socket. -pub fn run(socket_path: &Path) -> anyhow::Result<()> { - let mut stream = UnixStream::connect(socket_path) +pub async fn run(socket_path: &Path) -> anyhow::Result<()> { + let stream = UnixStream::connect(socket_path) + .await .with_context(|| format!("failed to connect to socket at {}", socket_path.display()))?; + let (mut socket_reader, mut socket_writer) = tokio::io::split(stream); - let mut reader = stream - .try_clone() - .context("failed to clone socket for reading")?; - - let stdout_thread = thread::spawn(move || -> io::Result<()> { - let stdout = io::stdout(); - let mut handle = stdout.lock(); - io::copy(&mut reader, &mut handle)?; - handle.flush()?; + let copy_socket_to_stdout = async { + let mut stdout = tokio::io::stdout(); + tokio::io::copy(&mut socket_reader, &mut stdout).await?; + stdout.flush().await?; Ok(()) - }); + }; + let copy_stdin_to_socket = async { + let mut stdin = tokio::io::stdin(); + tokio::io::copy(&mut stdin, &mut socket_writer) + .await + .context("failed to copy data from stdin to socket")?; - let stdin = io::stdin(); - { - let mut handle = stdin.lock(); - io::copy(&mut handle, &mut stream).context("failed to copy data from stdin to socket")?; - } + // The peer can close immediately after sending its response; in that + // race, half-closing our write side can report NotConnected on some + // platforms. + if let Err(err) = socket_writer.shutdown().await + && err.kind() != io::ErrorKind::NotConnected + { + return Err(err).context("failed to shutdown socket writer"); + } - // The peer can close immediately after sending its response; in that race, - // half-closing our write side can report NotConnected on some platforms. - if let Err(err) = stream.shutdown(Shutdown::Write) - && err.kind() != io::ErrorKind::NotConnected - { - return Err(err).context("failed to shutdown socket writer"); - } + anyhow::Ok(()) + }; - let stdout_result = stdout_thread - .join() - .map_err(|_| anyhow!("thread panicked while copying socket data to stdout"))?; - stdout_result.context("failed to copy data from socket to stdout")?; + tokio::try_join!(copy_stdin_to_socket, copy_socket_to_stdout) + .context("failed to relay data between stdio and socket")?; Ok(()) } diff --git a/codex-rs/stdio-to-uds/src/main.rs b/codex-rs/stdio-to-uds/src/main.rs index 69987c31be..2cbf041559 100644 --- a/codex-rs/stdio-to-uds/src/main.rs +++ b/codex-rs/stdio-to-uds/src/main.rs @@ -2,7 +2,8 @@ use std::env; use std::path::PathBuf; use std::process; -fn main() -> anyhow::Result<()> { +#[tokio::main] +async fn main() -> anyhow::Result<()> { let mut args = env::args_os().skip(1); let Some(socket_path) = args.next() else { eprintln!("Usage: codex-stdio-to-uds "); @@ -15,5 +16,5 @@ fn main() -> anyhow::Result<()> { } let socket_path = PathBuf::from(socket_path); - codex_stdio_to_uds::run(&socket_path) + codex_stdio_to_uds::run(&socket_path).await } diff --git a/codex-rs/stdio-to-uds/tests/stdio_to_uds.rs b/codex-rs/stdio-to-uds/tests/stdio_to_uds.rs index af8fd59226..0bc4b0c7f3 100644 --- a/codex-rs/stdio-to-uds/tests/stdio_to_uds.rs +++ b/codex-rs/stdio-to-uds/tests/stdio_to_uds.rs @@ -1,7 +1,7 @@ use std::io::ErrorKind; use std::io::Read; -use std::io::Write; use std::process::Command; +use std::process::ExitStatus; use std::process::Stdio; use std::sync::mpsc; use std::thread; @@ -9,17 +9,13 @@ use std::time::Duration; use std::time::Instant; use anyhow::Context; -use anyhow::anyhow; +use codex_uds::UnixListener; use pretty_assertions::assert_eq; +use tokio::io::AsyncReadExt; +use tokio::io::AsyncWriteExt; -#[cfg(unix)] -use std::os::unix::net::UnixListener; - -#[cfg(windows)] -use uds_windows::UnixListener; - -#[test] -fn pipes_stdin_and_stdout_through_socket() -> anyhow::Result<()> { +#[tokio::test] +async fn pipes_stdin_and_stdout_through_socket() -> anyhow::Result<()> { // This test intentionally avoids `read_to_end()` on the server side because // waiting for EOF can race with socket half-close behavior on slower runners. // Reading the exact request length keeps the test deterministic. @@ -32,7 +28,7 @@ fn pipes_stdin_and_stdout_through_socket() -> anyhow::Result<()> { let request = b"request"; let request_path = dir.path().join("request.txt"); std::fs::write(&request_path, request).context("failed to write child stdin fixture")?; - let listener = match UnixListener::bind(&socket_path) { + let listener = match UnixListener::bind(&socket_path).await { Ok(listener) => listener, Err(err) if err.kind() == ErrorKind::PermissionDenied => { eprintln!("skipping test: failed to bind unix socket: {err}"); @@ -43,105 +39,119 @@ fn pipes_stdin_and_stdout_through_socket() -> anyhow::Result<()> { } }; - let (tx, rx) = mpsc::channel(); let (event_tx, event_rx) = mpsc::channel(); - let server_thread = thread::spawn(move || -> anyhow::Result<()> { + let server_task = tokio::spawn(async move { + let mut listener = listener; let _ = event_tx.send("waiting for accept".to_string()); - let (mut connection, _) = listener + let mut connection = listener .accept() + .await .context("failed to accept test connection")?; let _ = event_tx.send("accepted connection".to_string()); let mut received = vec![0; request.len()]; connection .read_exact(&mut received) + .await .context("failed to read data from client")?; let _ = event_tx.send(format!("read {} bytes", received.len())); - tx.send(received) - .map_err(|_| anyhow!("failed to send received bytes to test thread"))?; connection .write_all(b"response") + .await .context("failed to write response to client")?; let _ = event_tx.send("wrote response".to_string()); - Ok(()) + anyhow::Ok(received) }); - let stdin = std::fs::File::open(&request_path).context("failed to open child stdin fixture")?; - let mut child = Command::new(codex_utils_cargo_bin::cargo_bin("codex-stdio-to-uds")?) - .arg(&socket_path) - .stdin(Stdio::from(stdin)) - .stdout(Stdio::piped()) - .stderr(Stdio::piped()) - .spawn() - .context("failed to spawn codex-stdio-to-uds")?; + struct ChildOutput { + status: ExitStatus, + stdout: Vec, + stderr: Vec, + server_events: Vec, + } - let mut child_stdout = child.stdout.take().context("missing child stdout")?; - let mut child_stderr = child.stderr.take().context("missing child stderr")?; - let (stdout_tx, stdout_rx) = mpsc::channel(); - let (stderr_tx, stderr_rx) = mpsc::channel(); - thread::spawn(move || { - let mut stdout = Vec::new(); - let result = child_stdout.read_to_end(&mut stdout).map(|_| stdout); - let _ = stdout_tx.send(result); - }); - thread::spawn(move || { - let mut stderr = Vec::new(); - let result = child_stderr.read_to_end(&mut stderr).map(|_| stderr); - let _ = stderr_tx.send(result); + let child_task = tokio::task::spawn_blocking(move || -> anyhow::Result { + let stdin = + std::fs::File::open(&request_path).context("failed to open child stdin fixture")?; + let mut child = Command::new(codex_utils_cargo_bin::cargo_bin("codex-stdio-to-uds")?) + .arg(&socket_path) + .stdin(Stdio::from(stdin)) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .spawn() + .context("failed to spawn codex-stdio-to-uds")?; + + let mut child_stdout = child.stdout.take().context("missing child stdout")?; + let mut child_stderr = child.stderr.take().context("missing child stderr")?; + let (stdout_tx, stdout_rx) = mpsc::channel(); + let (stderr_tx, stderr_rx) = mpsc::channel(); + thread::spawn(move || { + let mut stdout = Vec::new(); + let result = child_stdout.read_to_end(&mut stdout).map(|_| stdout); + let _ = stdout_tx.send(result); + }); + thread::spawn(move || { + let mut stderr = Vec::new(); + let result = child_stderr.read_to_end(&mut stderr).map(|_| stderr); + let _ = stderr_tx.send(result); + }); + + let mut server_events = Vec::new(); + let deadline = Instant::now() + Duration::from_secs(5); + let status = loop { + while let Ok(event) = event_rx.try_recv() { + server_events.push(event); + } + + if let Some(status) = child.try_wait().context("failed to poll child status")? { + break status; + } + + if Instant::now() >= deadline { + let _ = child.kill(); + let _ = child.wait(); + let stderr = stderr_rx + .recv_timeout(Duration::from_secs(1)) + .context("timed out waiting for child stderr after kill")? + .context("failed to read child stderr")?; + anyhow::bail!( + "codex-stdio-to-uds did not exit in time; server events: {:?}; stderr: {}", + server_events, + String::from_utf8_lossy(&stderr).trim_end() + ); + } + + thread::sleep(Duration::from_millis(25)); + }; + + let stdout = stdout_rx + .recv_timeout(Duration::from_secs(1)) + .context("timed out waiting for child stdout")? + .context("failed to read child stdout")?; + let stderr = stderr_rx + .recv_timeout(Duration::from_secs(1)) + .context("timed out waiting for child stderr")? + .context("failed to read child stderr")?; + + Ok(ChildOutput { + status, + stdout, + stderr, + server_events, + }) }); - let mut server_events = Vec::new(); - let deadline = Instant::now() + Duration::from_secs(5); - let status = loop { - while let Ok(event) = event_rx.try_recv() { - server_events.push(event); - } - - if let Some(status) = child.try_wait().context("failed to poll child status")? { - break status; - } - - if Instant::now() >= deadline { - let _ = child.kill(); - let _ = child.wait(); - let stderr = stderr_rx - .recv_timeout(Duration::from_secs(1)) - .context("timed out waiting for child stderr after kill")? - .context("failed to read child stderr")?; - anyhow::bail!( - "codex-stdio-to-uds did not exit in time; server events: {:?}; stderr: {}", - server_events, - String::from_utf8_lossy(&stderr).trim_end() - ); - } - - thread::sleep(Duration::from_millis(25)); - }; - - let stdout = stdout_rx - .recv_timeout(Duration::from_secs(1)) - .context("timed out waiting for child stdout")? - .context("failed to read child stdout")?; - let stderr = stderr_rx - .recv_timeout(Duration::from_secs(1)) - .context("timed out waiting for child stderr")? - .context("failed to read child stderr")?; + let child_output = child_task.await.context("child task panicked")??; assert!( - status.success(), + child_output.status.success(), "codex-stdio-to-uds exited with {status}; server events: {:?}; stderr: {}", - server_events, - String::from_utf8_lossy(&stderr).trim_end() + child_output.server_events, + String::from_utf8_lossy(&child_output.stderr).trim_end(), + status = child_output.status ); - assert_eq!(stdout, b"response"); + assert_eq!(child_output.stdout, b"response"); - let received = rx - .recv_timeout(Duration::from_secs(1)) - .context("server did not receive data in time")?; + let received = server_task.await.context("server task panicked")??; assert_eq!(received, request); - let server_result = server_thread - .join() - .map_err(|_| anyhow!("server thread panicked"))?; - server_result.context("server failed")?; - Ok(()) } diff --git a/codex-rs/thread-store/src/local/mod.rs b/codex-rs/thread-store/src/local/mod.rs index 4867580a78..c7c62f4cfa 100644 --- a/codex-rs/thread-store/src/local/mod.rs +++ b/codex-rs/thread-store/src/local/mod.rs @@ -38,10 +38,30 @@ impl LocalThreadStore { pub fn new(config: RolloutConfig) -> Self { Self { config } } + + /// Read a local rollout-backed thread by path. + pub async fn read_thread_by_rollout_path( + &self, + rollout_path: std::path::PathBuf, + include_archived: bool, + include_history: bool, + ) -> ThreadStoreResult { + read_thread::read_thread_by_rollout_path( + self, + rollout_path, + include_archived, + include_history, + ) + .await + } } #[async_trait] impl ThreadStore for LocalThreadStore { + fn as_any(&self) -> &dyn std::any::Any { + self + } + async fn create_thread( &self, _params: CreateThreadParams, diff --git a/codex-rs/thread-store/src/local/read_thread.rs b/codex-rs/thread-store/src/local/read_thread.rs index 33a41336b2..751a940158 100644 --- a/codex-rs/thread-store/src/local/read_thread.rs +++ b/codex-rs/thread-store/src/local/read_thread.rs @@ -31,15 +31,7 @@ pub(super) async fn read_thread( && (params.include_archived || metadata.archived_at.is_none()) { let mut thread = stored_thread_from_sqlite_metadata(store, metadata).await; - if params.include_history { - let Some(path) = thread.rollout_path.clone() else { - return Err(ThreadStoreError::Internal { - message: format!("failed to locate rollout for thread {thread_id}"), - }); - }; - let items = load_history_items(&path).await?; - thread.history = Some(StoredThreadHistory { thread_id, items }); - } + attach_history_if_requested(&mut thread, params.include_history).await?; return Ok(thread); } @@ -49,19 +41,60 @@ pub(super) async fn read_thread( message: format!("no rollout found for thread id {thread_id}"), })?; - let mut thread = read_thread_from_rollout_path(store, thread_id, path).await?; - if params.include_history { - let Some(path) = thread.rollout_path.clone() else { - return Err(ThreadStoreError::Internal { - message: format!("failed to load thread history for thread {thread_id}"), - }); - }; - let items = load_history_items(&path).await?; - thread.history = Some(StoredThreadHistory { thread_id, items }); - } + let mut thread = read_thread_from_rollout_path(store, path).await?; + attach_history_if_requested(&mut thread, params.include_history).await?; Ok(thread) } +pub(super) async fn read_thread_by_rollout_path( + store: &LocalThreadStore, + rollout_path: std::path::PathBuf, + include_archived: bool, + include_history: bool, +) -> ThreadStoreResult { + let path = resolve_requested_rollout_path(store, rollout_path)?; + let mut thread = read_thread_from_rollout_path(store, path).await?; + if !include_archived && thread.archived_at.is_some() { + return Err(ThreadStoreError::InvalidRequest { + message: format!("thread {} is archived", thread.thread_id), + }); + } + attach_history_if_requested(&mut thread, include_history).await?; + Ok(thread) +} + +fn resolve_requested_rollout_path( + store: &LocalThreadStore, + rollout_path: std::path::PathBuf, +) -> ThreadStoreResult { + let path = if rollout_path.is_relative() { + store.config.codex_home.join(rollout_path) + } else { + rollout_path + }; + std::fs::canonicalize(&path).map_err(|err| ThreadStoreError::InvalidRequest { + message: format!("failed to resolve rollout path `{}`: {err}", path.display()), + }) +} + +async fn attach_history_if_requested( + thread: &mut StoredThread, + include_history: bool, +) -> ThreadStoreResult<()> { + if !include_history { + return Ok(()); + } + let thread_id = thread.thread_id; + let Some(path) = thread.rollout_path.clone() else { + return Err(ThreadStoreError::Internal { + message: format!("failed to load thread history for thread {thread_id}"), + }); + }; + let items = load_history_items(&path).await?; + thread.history = Some(StoredThreadHistory { thread_id, items }); + Ok(()) +} + async fn resolve_rollout_path( store: &LocalThreadStore, thread_id: codex_protocol::ThreadId, @@ -94,7 +127,6 @@ async fn resolve_rollout_path( async fn read_thread_from_rollout_path( store: &LocalThreadStore, - thread_id: codex_protocol::ThreadId, path: std::path::PathBuf, ) -> ThreadStoreResult { let Some(item) = read_thread_item_from_rollout(path.clone()).await else { @@ -116,7 +148,7 @@ async fn read_thread_from_rollout_path( .ok() .and_then(|meta_line| meta_line.meta.forked_from_id); if let Ok(Some(title)) = - find_thread_name_by_id(store.config.codex_home.as_path(), &thread_id).await + find_thread_name_by_id(store.config.codex_home.as_path(), &thread.thread_id).await { set_thread_name_from_title(&mut thread, title); } @@ -348,6 +380,36 @@ mod tests { ); } + #[tokio::test] + async fn read_thread_returns_rollout_path_summary() { + let home = TempDir::new().expect("temp dir"); + let store = LocalThreadStore::new(test_config(home.path())); + let uuid = Uuid::from_u128(211); + let thread_id = ThreadId::from_string(&uuid.to_string()).expect("valid thread id"); + let active_path = + write_session_file(home.path(), "2025-01-03T12-00-00", uuid).expect("session file"); + let relative_path = active_path + .strip_prefix(home.path()) + .expect("path should be under codex home") + .to_path_buf(); + + let thread = store + .read_thread_by_rollout_path( + relative_path, + /*include_archived*/ false, + /*include_history*/ false, + ) + .await + .expect("read thread by rollout path"); + + assert_eq!(thread.thread_id, thread_id); + assert_eq!( + thread.rollout_path, + Some(std::fs::canonicalize(active_path).expect("canonical path")) + ); + assert_eq!(thread.preview, "Hello from user"); + } + #[tokio::test] async fn read_thread_returns_archived_rollout_when_requested() { let home = TempDir::new().expect("temp dir"); diff --git a/codex-rs/thread-store/src/remote/mod.rs b/codex-rs/thread-store/src/remote/mod.rs index 760a2dce65..5be760870e 100644 --- a/codex-rs/thread-store/src/remote/mod.rs +++ b/codex-rs/thread-store/src/remote/mod.rs @@ -48,6 +48,10 @@ impl RemoteThreadStore { #[async_trait] impl ThreadStore for RemoteThreadStore { + fn as_any(&self) -> &dyn std::any::Any { + self + } + async fn create_thread( &self, _params: CreateThreadParams, diff --git a/codex-rs/thread-store/src/store.rs b/codex-rs/thread-store/src/store.rs index 5331242c88..56cbd05f5c 100644 --- a/codex-rs/thread-store/src/store.rs +++ b/codex-rs/thread-store/src/store.rs @@ -1,3 +1,5 @@ +use std::any::Any; + use async_trait::async_trait; use crate::AppendThreadItemsParams; @@ -16,7 +18,11 @@ use crate::UpdateThreadMetadataParams; /// Storage-neutral thread persistence boundary. #[async_trait] -pub trait ThreadStore: Send + Sync { +pub trait ThreadStore: Any + Send + Sync { + /// Return this store as [`Any`] so callers at API boundaries can reject requests that only + /// make sense for a concrete store implementation. + fn as_any(&self) -> &dyn Any; + /// Creates a new thread and returns a live recorder for future appends. async fn create_thread( &self, diff --git a/codex-rs/tools/README.md b/codex-rs/tools/README.md index cafb4b89ac..474f35e6ac 100644 --- a/codex-rs/tools/README.md +++ b/codex-rs/tools/README.md @@ -16,7 +16,7 @@ schema and Responses API tool primitives that no longer need to live in - `ResponsesApiTool` - `FreeformTool` - `FreeformToolFormat` -- `ToolSearchOutputTool` +- `LoadableToolSpec` - `ResponsesApiWebSearchFilters` - `ResponsesApiWebSearchUserLocation` - `ResponsesApiNamespace` @@ -35,6 +35,7 @@ schema and Responses API tool primitives that no longer need to live in - `create_tools_json_for_responses_api()` - `mcp_call_tool_result_output_schema()` - `tool_definition_to_responses_api_tool()` +- `dynamic_tool_to_loadable_tool_spec()` - `dynamic_tool_to_responses_api_tool()` - `mcp_tool_to_responses_api_tool()` - `mcp_tool_to_deferred_responses_api_tool()` diff --git a/codex-rs/tools/src/agent_tool.rs b/codex-rs/tools/src/agent_tool.rs index aa1699a4e0..346eaf8aef 100644 --- a/codex-rs/tools/src/agent_tool.rs +++ b/codex-rs/tools/src/agent_tool.rs @@ -6,6 +6,9 @@ use serde_json::Value; use serde_json::json; use std::collections::BTreeMap; +const SPAWN_AGENT_INHERITED_MODEL_GUIDANCE: &str = "Spawned agents inherit your current model by default. Omit `model` to use that preferred default; set `model` only when an explicit override is needed."; +const SPAWN_AGENT_MODEL_OVERRIDE_DESCRIPTION: &str = "Optional model override for the new agent. Leave unset to inherit the same model as the parent, which is the preferred default. Only set this when the user explicitly asks for a different model or the task clearly requires one."; + #[derive(Debug, Clone)] pub struct SpawnAgentToolOptions<'a> { pub available_models: &'a [ModelPreset], @@ -527,8 +530,7 @@ fn spawn_agent_common_properties_v1(agent_type_description: &str) -> BTreeMap BTreeMap String { let visible_models: Vec<&ModelPreset> = models.iter().filter(|model| model.show_in_picker).collect(); if visible_models.is_empty() { - return "No picker-visible models are currently loaded.".to_string(); + return "No picker-visible model overrides are currently loaded.".to_string(); } - visible_models + let model_descriptions = visible_models .into_iter() .map(|model| { let efforts = model @@ -706,7 +708,10 @@ fn spawn_agent_models_description(models: &[ModelPreset]) -> String { ) }) .collect::>() - .join("\n") + .join("\n"); + format!( + "Available model overrides (optional; inherited parent model is preferred):\n{model_descriptions}" + ) } fn wait_agent_tool_parameters_v1(options: WaitAgentTimeoutOptions) -> JsonSchema { diff --git a/codex-rs/tools/src/agent_tool_tests.rs b/codex-rs/tools/src/agent_tool_tests.rs index e592e2b69d..e9fd3546b4 100644 --- a/codex-rs/tools/src/agent_tool_tests.rs +++ b/codex-rs/tools/src/agent_tool_tests.rs @@ -61,6 +61,11 @@ fn spawn_agent_tool_v2_requires_task_name_and_lists_visible_models() { .expect("spawn_agent should use object params"); assert!(description.contains("Spawns an agent to work on the specified task.")); assert!(description.contains("The spawned agent will have the same tools as you")); + assert!(description.contains(SPAWN_AGENT_INHERITED_MODEL_GUIDANCE)); + assert!( + description + .contains("Available model overrides (optional; inherited parent model is preferred):") + ); assert!(description.contains("visible display (`visible-model`)")); assert!(!description.contains("hidden display (`hidden-model`)")); assert!(properties.contains_key("task_name")); @@ -72,6 +77,12 @@ fn spawn_agent_tool_v2_requires_task_name_and_lists_visible_models() { properties.get("agent_type"), Some(&JsonSchema::string(Some("role help".to_string()))) ); + assert_eq!( + properties + .get("model") + .and_then(|schema| schema.description.as_deref()), + Some(SPAWN_AGENT_MODEL_OVERRIDE_DESCRIPTION) + ); assert_eq!( parameters.required.as_ref(), Some(&vec!["task_name".to_string(), "message".to_string()]) @@ -106,6 +117,12 @@ fn spawn_agent_tool_v1_keeps_legacy_fork_context_field() { assert!(properties.contains_key("fork_context")); assert!(!properties.contains_key("fork_turns")); + assert_eq!( + properties + .get("model") + .and_then(|schema| schema.description.as_deref()), + Some(SPAWN_AGENT_MODEL_OVERRIDE_DESCRIPTION) + ); } #[test] diff --git a/codex-rs/tools/src/code_mode.rs b/codex-rs/tools/src/code_mode.rs index e8a73c40a9..459eb7e460 100644 --- a/codex-rs/tools/src/code_mode.rs +++ b/codex-rs/tools/src/code_mode.rs @@ -37,7 +37,7 @@ pub fn augment_tool_spec_for_code_mode(spec: ToolSpec) -> ToolSpec { let tool_name = ToolName::namespaced(namespace.name.clone(), tool.name.clone()); let definition = CodeModeToolDefinition { - name: tool_name.display(), + name: code_mode_name_for_tool_name(&tool_name), tool_name, description: tool.description.clone(), kind: CodeModeToolKind::Function, @@ -208,7 +208,7 @@ fn code_mode_tool_definitions_for_spec(spec: &ToolSpec) -> Vec { let tool_name = ToolName::namespaced(namespace.name.clone(), tool.name.clone()); CodeModeToolDefinition { - name: tool_name.display(), + name: code_mode_name_for_tool_name(&tool_name), tool_name, description: tool.description.clone(), kind: CodeModeToolKind::Function, @@ -225,6 +225,16 @@ fn code_mode_tool_definitions_for_spec(spec: &ToolSpec) -> Vec String { + match tool_name.namespace.as_deref() { + Some(namespace) if namespace.ends_with('_') || tool_name.name.starts_with('_') => { + format!("{namespace}{}", tool_name.name) + } + Some(namespace) => format!("{namespace}_{}", tool_name.name), + None => tool_name.name.clone(), + } +} + #[cfg(test)] #[path = "code_mode_tests.rs"] mod tests; diff --git a/codex-rs/tools/src/dynamic_tool.rs b/codex-rs/tools/src/dynamic_tool.rs index 372dbce29d..af74a3c1e3 100644 --- a/codex-rs/tools/src/dynamic_tool.rs +++ b/codex-rs/tools/src/dynamic_tool.rs @@ -3,18 +3,12 @@ use crate::parse_tool_input_schema; use codex_protocol::dynamic_tools::DynamicToolSpec; pub fn parse_dynamic_tool(tool: &DynamicToolSpec) -> Result { - let DynamicToolSpec { - name, - description, - input_schema, - defer_loading, - } = tool; Ok(ToolDefinition { - name: name.clone(), - description: description.clone(), - input_schema: parse_tool_input_schema(input_schema)?, + name: tool.name.clone(), + description: tool.description.clone(), + input_schema: parse_tool_input_schema(&tool.input_schema)?, output_schema: None, - defer_loading: *defer_loading, + defer_loading: tool.defer_loading, }) } diff --git a/codex-rs/tools/src/dynamic_tool_tests.rs b/codex-rs/tools/src/dynamic_tool_tests.rs index 42afd46279..077a0622ce 100644 --- a/codex-rs/tools/src/dynamic_tool_tests.rs +++ b/codex-rs/tools/src/dynamic_tool_tests.rs @@ -8,6 +8,7 @@ use std::collections::BTreeMap; #[test] fn parse_dynamic_tool_sanitizes_input_schema() { let tool = DynamicToolSpec { + namespace: None, name: "lookup_ticket".to_string(), description: "Fetch a ticket".to_string(), input_schema: serde_json::json!({ @@ -42,6 +43,7 @@ fn parse_dynamic_tool_sanitizes_input_schema() { #[test] fn parse_dynamic_tool_preserves_defer_loading() { let tool = DynamicToolSpec { + namespace: None, name: "lookup_ticket".to_string(), description: "Fetch a ticket".to_string(), input_schema: serde_json::json!({ diff --git a/codex-rs/tools/src/lib.rs b/codex-rs/tools/src/lib.rs index 07e98ab5a9..2dc7c165d5 100644 --- a/codex-rs/tools/src/lib.rs +++ b/codex-rs/tools/src/lib.rs @@ -44,6 +44,7 @@ pub use apply_patch_tool::ApplyPatchToolArgs; pub use apply_patch_tool::create_apply_patch_freeform_tool; pub use apply_patch_tool::create_apply_patch_json_tool; pub use code_mode::augment_tool_spec_for_code_mode; +pub use code_mode::code_mode_name_for_tool_name; pub use code_mode::collect_code_mode_exec_prompt_tool_definitions; pub use code_mode::collect_code_mode_tool_definitions; pub use code_mode::create_code_mode_tool; @@ -82,11 +83,13 @@ pub use request_user_input_tool::request_user_input_tool_description; pub use request_user_input_tool::request_user_input_unavailable_message; pub use responses_api::FreeformTool; pub use responses_api::FreeformToolFormat; +pub use responses_api::LoadableToolSpec; pub use responses_api::ResponsesApiNamespace; pub use responses_api::ResponsesApiNamespaceTool; pub use responses_api::ResponsesApiTool; -pub use responses_api::ToolSearchOutputTool; +pub use responses_api::coalesce_loadable_tool_specs; pub(crate) use responses_api::default_namespace_description; +pub use responses_api::dynamic_tool_to_loadable_tool_spec; pub use responses_api::dynamic_tool_to_responses_api_tool; pub use responses_api::mcp_tool_to_deferred_responses_api_tool; pub use responses_api::mcp_tool_to_responses_api_tool; @@ -114,7 +117,7 @@ pub use tool_discovery::collect_tool_suggest_entries; pub use tool_discovery::create_tool_search_tool; pub use tool_discovery::create_tool_suggest_tool; pub use tool_discovery::filter_tool_suggest_discoverable_tools_for_client; -pub use tool_discovery::tool_search_result_source_to_output_tool; +pub use tool_discovery::tool_search_result_source_to_loadable_tool_spec; pub use tool_registry_plan::build_tool_registry_plan; pub use tool_registry_plan_types::ToolHandlerKind; pub use tool_registry_plan_types::ToolHandlerSpec; diff --git a/codex-rs/tools/src/responses_api.rs b/codex-rs/tools/src/responses_api.rs index 5317a082f1..c3643fbba6 100644 --- a/codex-rs/tools/src/responses_api.rs +++ b/codex-rs/tools/src/responses_api.rs @@ -40,7 +40,7 @@ pub struct ResponsesApiTool { #[derive(Debug, Clone, Serialize, PartialEq)] #[serde(tag = "type")] #[allow(clippy::large_enum_variant)] -pub enum ToolSearchOutputTool { +pub enum LoadableToolSpec { #[allow(dead_code)] #[serde(rename = "function")] Function(ResponsesApiTool), @@ -74,6 +74,51 @@ pub fn dynamic_tool_to_responses_api_tool( )?)) } +pub fn dynamic_tool_to_loadable_tool_spec( + tool: &DynamicToolSpec, +) -> Result { + let output_tool = dynamic_tool_to_responses_api_tool(tool)?; + Ok(match tool.namespace.as_ref() { + Some(namespace) => LoadableToolSpec::Namespace(ResponsesApiNamespace { + name: namespace.clone(), + // the user doesn't provide a description for dynamic tools, so we use the default + description: default_namespace_description(namespace), + tools: vec![ResponsesApiNamespaceTool::Function(output_tool)], + }), + None => LoadableToolSpec::Function(output_tool), + }) +} + +pub fn coalesce_loadable_tool_specs( + specs: impl IntoIterator, +) -> Vec { + let mut coalesced_specs = Vec::new(); + for spec in specs { + match spec { + LoadableToolSpec::Function(tool) => { + coalesced_specs.push(LoadableToolSpec::Function(tool)); + } + LoadableToolSpec::Namespace(mut namespace) => { + if let Some(existing_namespace) = + coalesced_specs.iter_mut().find_map(|spec| match spec { + LoadableToolSpec::Namespace(existing_namespace) + if existing_namespace.name == namespace.name => + { + Some(existing_namespace) + } + LoadableToolSpec::Function(_) | LoadableToolSpec::Namespace(_) => None, + }) + { + existing_namespace.tools.append(&mut namespace.tools); + } else { + coalesced_specs.push(LoadableToolSpec::Namespace(namespace)); + } + } + } + } + coalesced_specs +} + pub fn mcp_tool_to_responses_api_tool( tool_name: &ToolName, tool: &rmcp::model::Tool, diff --git a/codex-rs/tools/src/responses_api_tests.rs b/codex-rs/tools/src/responses_api_tests.rs index 799a2385d2..3ce13ebfe8 100644 --- a/codex-rs/tools/src/responses_api_tests.rs +++ b/codex-rs/tools/src/responses_api_tests.rs @@ -1,7 +1,7 @@ +use super::LoadableToolSpec; use super::ResponsesApiNamespace; use super::ResponsesApiNamespaceTool; use super::ResponsesApiTool; -use super::ToolSearchOutputTool; use super::dynamic_tool_to_responses_api_tool; use super::mcp_tool_to_deferred_responses_api_tool; use super::tool_definition_to_responses_api_tool; @@ -51,6 +51,7 @@ fn tool_definition_to_responses_api_tool_omits_false_defer_loading() { #[test] fn dynamic_tool_to_responses_api_tool_preserves_defer_loading() { let tool = DynamicToolSpec { + namespace: None, name: "lookup_order".to_string(), description: "Look up an order".to_string(), input_schema: json!({ @@ -130,8 +131,8 @@ fn mcp_tool_to_deferred_responses_api_tool_sets_defer_loading() { } #[test] -fn tool_search_output_namespace_serializes_with_deferred_child_tools() { - let namespace = ToolSearchOutputTool::Namespace(ResponsesApiNamespace { +fn loadable_tool_spec_namespace_serializes_with_deferred_child_tools() { + let namespace = LoadableToolSpec::Namespace(ResponsesApiNamespace { name: "mcp__codex_apps__calendar".to_string(), description: "Plan events".to_string(), tools: vec![ResponsesApiNamespaceTool::Function(ResponsesApiTool { diff --git a/codex-rs/tools/src/tool_discovery.rs b/codex-rs/tools/src/tool_discovery.rs index 359b1d792f..ddcd2f1ce3 100644 --- a/codex-rs/tools/src/tool_discovery.rs +++ b/codex-rs/tools/src/tool_discovery.rs @@ -1,9 +1,9 @@ use crate::JsonSchema; +use crate::LoadableToolSpec; use crate::ResponsesApiNamespace; use crate::ResponsesApiNamespaceTool; use crate::ResponsesApiTool; use crate::ToolName; -use crate::ToolSearchOutputTool; use crate::ToolSpec; use crate::default_namespace_description; use crate::mcp_tool_to_deferred_responses_api_tool; @@ -203,10 +203,10 @@ pub fn create_tool_search_tool( } } -pub fn tool_search_result_source_to_output_tool( +pub fn tool_search_result_source_to_loadable_tool_spec( source: ToolSearchResultSource<'_>, -) -> Result { - Ok(ToolSearchOutputTool::Namespace(ResponsesApiNamespace { +) -> Result { + Ok(LoadableToolSpec::Namespace(ResponsesApiNamespace { name: source.tool_namespace.to_string(), description: tool_search_result_source_namespace_description(source), tools: vec![tool_search_result_source_to_namespace_tool(source)?], diff --git a/codex-rs/tools/src/tool_registry_plan.rs b/codex-rs/tools/src/tool_registry_plan.rs index 79ec8bb350..d3b075f5ab 100644 --- a/codex-rs/tools/src/tool_registry_plan.rs +++ b/codex-rs/tools/src/tool_registry_plan.rs @@ -8,6 +8,7 @@ use crate::TOOL_SEARCH_DEFAULT_LIMIT; use crate::TOOL_SEARCH_TOOL_NAME; use crate::TOOL_SUGGEST_TOOL_NAME; use crate::ToolHandlerKind; +use crate::ToolName; use crate::ToolRegistryPlan; use crate::ToolRegistryPlanParams; use crate::ToolSearchSource; @@ -16,6 +17,7 @@ use crate::ToolSpec; use crate::ToolsConfig; use crate::ViewImageToolOptions; use crate::WebSearchToolOptions; +use crate::coalesce_loadable_tool_specs; use crate::collect_code_mode_exec_prompt_tool_definitions; use crate::collect_tool_search_source_infos; use crate::collect_tool_suggest_entries; @@ -57,7 +59,7 @@ use crate::create_wait_tool; use crate::create_web_search_tool; use crate::create_write_stdin_tool; use crate::default_namespace_description; -use crate::dynamic_tool_to_responses_api_tool; +use crate::dynamic_tool_to_loadable_tool_spec; use crate::mcp_tool_to_responses_api_tool; use crate::request_permissions_tool_description; use crate::request_user_input_tool_description; @@ -555,15 +557,13 @@ pub fn build_tool_registry_plan( } } + let mut dynamic_tool_specs = Vec::new(); for tool in params.dynamic_tools { - match dynamic_tool_to_responses_api_tool(tool) { - Ok(converted_tool) => { - plan.push_spec( - ToolSpec::Function(converted_tool), - /*supports_parallel_tool_calls*/ false, - config.code_mode_enabled, - ); - plan.register_handler(tool.name.clone(), ToolHandlerKind::DynamicTool); + match dynamic_tool_to_loadable_tool_spec(tool) { + Ok(loadable_tool) => { + let handler_name = ToolName::new(tool.namespace.clone(), tool.name.clone()); + dynamic_tool_specs.push(loadable_tool); + plan.register_handler(handler_name, ToolHandlerKind::DynamicTool); } Err(error) => { tracing::error!( @@ -573,6 +573,13 @@ pub fn build_tool_registry_plan( } } } + for spec in coalesce_loadable_tool_specs(dynamic_tool_specs) { + plan.push_spec( + spec.into(), + /*supports_parallel_tool_calls*/ false, + config.code_mode_enabled, + ); + } plan } diff --git a/codex-rs/tools/src/tool_registry_plan_tests.rs b/codex-rs/tools/src/tool_registry_plan_tests.rs index 798f7ec85f..0b94ef64ca 100644 --- a/codex-rs/tools/src/tool_registry_plan_tests.rs +++ b/codex-rs/tools/src/tool_registry_plan_tests.rs @@ -1423,23 +1423,36 @@ fn search_tool_registers_for_deferred_dynamic_tools() { sandbox_policy: &SandboxPolicy::DangerFullAccess, windows_sandbox_level: WindowsSandboxLevel::Disabled, }); - let dynamic_tool = DynamicToolSpec { - name: "automation_update".to_string(), - description: "Create, update, view, or delete recurring automations.".to_string(), - input_schema: json!({ - "type": "object", - "properties": { - "mode": { "type": "string" }, - }, - }), - defer_loading: true, - }; + let dynamic_tools = vec![ + DynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "automation_update".to_string(), + description: "Create, update, view, or delete recurring automations.".to_string(), + input_schema: json!({ + "type": "object", + "properties": { + "mode": { "type": "string" }, + }, + }), + defer_loading: true, + }, + DynamicToolSpec { + namespace: Some("codex_app".to_string()), + name: "automation_list".to_string(), + description: "List recurring automations.".to_string(), + input_schema: json!({ + "type": "object", + "properties": {}, + }), + defer_loading: true, + }, + ]; let (tools, handlers) = build_specs( &tools_config, /*mcp_tools*/ None, /*deferred_mcp_tools*/ None, - &[dynamic_tool], + &dynamic_tools, ); let search_tool = find_tool(&tools, TOOL_SEARCH_TOOL_NAME); @@ -1447,13 +1460,35 @@ fn search_tool_registers_for_deferred_dynamic_tools() { panic!("expected tool_search tool"); }; assert!(description.contains("- Dynamic tools: Tools provided by the current Codex thread.")); - assert_contains_tool_names(&tools, &[TOOL_SEARCH_TOOL_NAME, "automation_update"]); + assert_contains_tool_names(&tools, &[TOOL_SEARCH_TOOL_NAME, "codex_app"]); + assert_eq!( + tools + .iter() + .filter(|tool| tool.name() == "codex_app") + .count(), + 1 + ); + assert_eq!( + namespace_function_names(&tools, "codex_app"), + vec![ + "automation_update".to_string(), + "automation_list".to_string() + ] + ); + for tool_name in ["automation_update", "automation_list"] { + let dynamic_tool = find_namespace_function_tool(&tools, "codex_app", tool_name); + assert_eq!(dynamic_tool.defer_loading, Some(true)); + } assert!(handlers.contains(&ToolHandlerSpec { name: ToolName::plain(TOOL_SEARCH_TOOL_NAME), kind: ToolHandlerKind::ToolSearch, })); assert!(handlers.contains(&ToolHandlerSpec { - name: ToolName::plain("automation_update"), + name: ToolName::namespaced("codex_app", "automation_update"), + kind: ToolHandlerKind::DynamicTool, + })); + assert!(handlers.contains(&ToolHandlerSpec { + name: ToolName::namespaced("codex_app", "automation_list"), kind: ToolHandlerKind::DynamicTool, })); } diff --git a/codex-rs/tools/src/tool_spec.rs b/codex-rs/tools/src/tool_spec.rs index 81db2f5584..4236dcaa61 100644 --- a/codex-rs/tools/src/tool_spec.rs +++ b/codex-rs/tools/src/tool_spec.rs @@ -1,5 +1,6 @@ use crate::FreeformTool; use crate::JsonSchema; +use crate::LoadableToolSpec; use crate::ResponsesApiNamespace; use crate::ResponsesApiTool; use codex_protocol::config_types::WebSearchConfig; @@ -70,6 +71,15 @@ impl ToolSpec { } } +impl From for ToolSpec { + fn from(value: LoadableToolSpec) -> Self { + match value { + LoadableToolSpec::Function(tool) => ToolSpec::Function(tool), + LoadableToolSpec::Namespace(namespace) => ToolSpec::Namespace(namespace), + } + } +} + pub fn create_local_shell_tool() -> ToolSpec { ToolSpec::LocalShell {} } diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs index dc8ca2784c..80e8f4a0f1 100644 --- a/codex-rs/tui/src/app.rs +++ b/codex-rs/tui/src/app.rs @@ -1,3 +1,8 @@ +//! Top-level TUI application state and runtime wiring. +//! +//! This module owns the `App` struct, shared imports, and the high-level run loop that coordinates +//! the focused app submodules. + use crate::app_backtrack::BacktrackState; use crate::app_command::AppCommand; use crate::app_command::AppCommandView; @@ -176,19 +181,35 @@ use uuid::Uuid; mod agent_navigation; mod app_server_adapter; pub(crate) mod app_server_requests; +mod background_requests; +mod config_persistence; +mod event_dispatch; +mod history_ui; +mod input; mod loaded_threads; mod pending_interactive_replay; +mod platform_actions; mod replay_filter; +mod session_lifecycle; mod side; +mod startup_prompts; +mod thread_events; +mod thread_routing; +mod thread_session_state; use self::agent_navigation::AgentNavigationDirection; use self::agent_navigation::AgentNavigationState; use self::app_server_requests::PendingAppServerRequests; +#[cfg(test)] +use self::background_requests::*; use self::loaded_threads::find_loaded_subagent_threads_for_primary; use self::pending_interactive_replay::PendingInteractiveReplayState; +use self::platform_actions::*; use self::side::SideParentStatus; use self::side::SideParentStatusChange; use self::side::SideThreadState; +use self::startup_prompts::*; +use self::thread_events::*; const EXTERNAL_EDITOR_HINT: &str = "Save and close external editor to continue."; const THREAD_EVENT_CHANNEL_CAPACITY: usize = 32768; @@ -462,566 +483,12 @@ fn list_skills_response_to_core(response: SkillsListResponse) -> ListSkillsRespo } } -fn emit_skill_load_warnings(app_event_tx: &AppEventSender, errors: &[SkillErrorInfo]) { - if errors.is_empty() { - return; - } - - let error_count = errors.len(); - app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( - crate::history_cell::new_warning_event(format!( - "Skipped loading {error_count} skill(s) due to invalid SKILL.md files." - )), - ))); - - for error in errors { - let path = error.path.display(); - let message = error.message.as_str(); - app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( - crate::history_cell::new_warning_event(format!("{path}: {message}")), - ))); - } -} - -fn emit_project_config_warnings(app_event_tx: &AppEventSender, config: &Config) { - let mut disabled_folders = Vec::new(); - - for layer in config.config_layer_stack.get_layers( - ConfigLayerStackOrdering::LowestPrecedenceFirst, - /*include_disabled*/ true, - ) { - let ConfigLayerSource::Project { dot_codex_folder } = &layer.name else { - continue; - }; - let Some(disabled_reason) = &layer.disabled_reason else { - continue; - }; - disabled_folders.push(( - dot_codex_folder.as_path().display().to_string(), - disabled_reason.clone(), - )); - } - - if disabled_folders.is_empty() { - return; - } - - let mut message = concat!( - "Project-local config, hooks, and exec policies are disabled in the following folders ", - "until the project is trusted, but skills still load.\n", - ) - .to_string(); - for (index, (folder, reason)) in disabled_folders.iter().enumerate() { - let display_index = index + 1; - message.push_str(&format!(" {display_index}. {folder}\n")); - message.push_str(&format!(" {reason}\n")); - } - - app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( - history_cell::new_warning_event(message), - ))); -} - -fn emit_system_bwrap_warning(app_event_tx: &AppEventSender, config: &Config) { - let Some(message) = - crate::legacy_core::config::system_bwrap_warning(config.permissions.sandbox_policy.get()) - else { - return; - }; - - app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( - history_cell::new_warning_event(message), - ))); -} - #[derive(Debug, Clone, PartialEq, Eq)] struct SessionSummary { usage_line: Option, resume_command: Option, } -#[derive(Debug, Clone)] -struct ThreadEventSnapshot { - session: Option, - turns: Vec, - events: Vec, - input_state: Option, -} - -#[derive(Debug, Clone)] -enum ThreadBufferedEvent { - Notification(ServerNotification), - Request(ServerRequest), - HistoryEntryResponse(GetHistoryEntryResponseEvent), - FeedbackSubmission(FeedbackThreadEvent), -} - -#[derive(Debug, Clone, PartialEq, Eq)] -struct FeedbackThreadEvent { - category: FeedbackCategory, - include_logs: bool, - feedback_audience: FeedbackAudience, - result: Result, -} - -#[derive(Debug)] -struct ThreadEventStore { - session: Option, - turns: Vec, - buffer: VecDeque, - pending_interactive_replay: PendingInteractiveReplayState, - active_turn_id: Option, - input_state: Option, - capacity: usize, - active: bool, -} - -impl ThreadEventStore { - fn event_survives_session_refresh(event: &ThreadBufferedEvent) -> bool { - matches!( - event, - ThreadBufferedEvent::Request(_) - | ThreadBufferedEvent::Notification(ServerNotification::HookStarted(_)) - | ThreadBufferedEvent::Notification(ServerNotification::HookCompleted(_)) - | ThreadBufferedEvent::FeedbackSubmission(_) - ) - } - - fn new(capacity: usize) -> Self { - Self { - session: None, - turns: Vec::new(), - buffer: VecDeque::new(), - pending_interactive_replay: PendingInteractiveReplayState::default(), - active_turn_id: None, - input_state: None, - capacity, - active: false, - } - } - - #[cfg_attr(not(test), allow(dead_code))] - fn new_with_session(capacity: usize, session: ThreadSessionState, turns: Vec) -> Self { - let mut store = Self::new(capacity); - store.session = Some(session); - store.set_turns(turns); - store - } - - fn set_session(&mut self, session: ThreadSessionState, turns: Vec) { - self.session = Some(session); - self.set_turns(turns); - } - - fn rebase_buffer_after_session_refresh(&mut self) { - self.buffer.retain(Self::event_survives_session_refresh); - } - - fn set_turns(&mut self, turns: Vec) { - self.active_turn_id = turns - .iter() - .rev() - .find(|turn| matches!(turn.status, TurnStatus::InProgress)) - .map(|turn| turn.id.clone()); - self.turns = turns; - } - - fn push_notification(&mut self, notification: ServerNotification) { - self.pending_interactive_replay - .note_server_notification(¬ification); - match ¬ification { - ServerNotification::TurnStarted(turn) => { - self.active_turn_id = Some(turn.turn.id.clone()); - } - ServerNotification::TurnCompleted(turn) => { - if self.active_turn_id.as_deref() == Some(turn.turn.id.as_str()) { - self.active_turn_id = None; - } - } - ServerNotification::ThreadClosed(_) => { - self.active_turn_id = None; - } - _ => {} - } - self.buffer - .push_back(ThreadBufferedEvent::Notification(notification)); - if self.buffer.len() > self.capacity - && let Some(removed) = self.buffer.pop_front() - && let ThreadBufferedEvent::Request(request) = &removed - { - self.pending_interactive_replay - .note_evicted_server_request(request); - } - } - - fn push_request(&mut self, request: ServerRequest) { - self.pending_interactive_replay - .note_server_request(&request); - self.buffer.push_back(ThreadBufferedEvent::Request(request)); - if self.buffer.len() > self.capacity - && let Some(removed) = self.buffer.pop_front() - && let ThreadBufferedEvent::Request(request) = &removed - { - self.pending_interactive_replay - .note_evicted_server_request(request); - } - } - - fn pending_replay_requests(&self) -> Vec { - self.buffer - .iter() - .filter_map(|event| match event { - ThreadBufferedEvent::Request(request) - if self - .pending_interactive_replay - .should_replay_snapshot_request(request) => - { - Some(request.clone()) - } - ThreadBufferedEvent::Request(_) - | ThreadBufferedEvent::Notification(_) - | ThreadBufferedEvent::HistoryEntryResponse(_) - | ThreadBufferedEvent::FeedbackSubmission(_) => None, - }) - .collect() - } - - fn apply_thread_rollback(&mut self, response: &ThreadRollbackResponse) { - self.turns = response.thread.turns.clone(); - self.buffer.clear(); - self.pending_interactive_replay = PendingInteractiveReplayState::default(); - self.active_turn_id = None; - } - - fn snapshot(&self) -> ThreadEventSnapshot { - ThreadEventSnapshot { - session: self.session.clone(), - turns: self.turns.clone(), - // Thread switches replay buffered events into a rebuilt ChatWidget. Only replay - // interactive prompts that are still pending, or answered approvals/input will reappear. - events: self - .buffer - .iter() - .filter(|event| match event { - ThreadBufferedEvent::Request(request) => self - .pending_interactive_replay - .should_replay_snapshot_request(request), - ThreadBufferedEvent::Notification(_) - | ThreadBufferedEvent::HistoryEntryResponse(_) - | ThreadBufferedEvent::FeedbackSubmission(_) => true, - }) - .cloned() - .collect(), - input_state: self.input_state.clone(), - } - } - - fn note_outbound_op(&mut self, op: T) - where - T: Into, - { - self.pending_interactive_replay.note_outbound_op(op); - } - - fn op_can_change_pending_replay_state(op: T) -> bool - where - T: Into, - { - PendingInteractiveReplayState::op_can_change_state(op) - } - - fn has_pending_thread_approvals(&self) -> bool { - self.pending_interactive_replay - .has_pending_thread_approvals() - } - - fn side_parent_pending_status(&self) -> Option { - if self - .pending_interactive_replay - .has_pending_thread_user_input() - { - Some(SideParentStatus::NeedsInput) - } else if self - .pending_interactive_replay - .has_pending_thread_approvals() - { - Some(SideParentStatus::NeedsApproval) - } else { - None - } - } - - fn active_turn_id(&self) -> Option<&str> { - self.active_turn_id.as_deref() - } - - fn clear_active_turn_id(&mut self) { - self.active_turn_id = None; - } -} - -#[derive(Debug)] -struct ThreadEventChannel { - sender: mpsc::Sender, - receiver: Option>, - store: Arc>, -} - -impl ThreadEventChannel { - fn new(capacity: usize) -> Self { - let (sender, receiver) = mpsc::channel(capacity); - Self { - sender, - receiver: Some(receiver), - store: Arc::new(Mutex::new(ThreadEventStore::new(capacity))), - } - } - - #[cfg_attr(not(test), allow(dead_code))] - fn new_with_session(capacity: usize, session: ThreadSessionState, turns: Vec) -> Self { - let (sender, receiver) = mpsc::channel(capacity); - Self { - sender, - receiver: Some(receiver), - store: Arc::new(Mutex::new(ThreadEventStore::new_with_session( - capacity, session, turns, - ))), - } - } -} - -fn should_show_model_migration_prompt( - current_model: &str, - target_model: &str, - seen_migrations: &BTreeMap, - available_models: &[ModelPreset], -) -> bool { - if target_model == current_model { - return false; - } - - if let Some(seen_target) = seen_migrations.get(current_model) - && seen_target == target_model - { - return false; - } - - if !available_models - .iter() - .any(|preset| preset.model == target_model && preset.show_in_picker) - { - return false; - } - - if available_models - .iter() - .any(|preset| preset.model == current_model && preset.upgrade.is_some()) - { - return true; - } - - if available_models - .iter() - .any(|preset| preset.upgrade.as_ref().map(|u| u.id.as_str()) == Some(target_model)) - { - return true; - } - - false -} - -fn migration_prompt_hidden(config: &Config, migration_config_key: &str) -> bool { - match migration_config_key { - HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG => config - .notices - .hide_gpt_5_1_codex_max_migration_prompt - .unwrap_or(false), - HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG => { - config.notices.hide_gpt5_1_migration_prompt.unwrap_or(false) - } - _ => false, - } -} - -fn target_preset_for_upgrade<'a>( - available_models: &'a [ModelPreset], - target_model: &str, -) -> Option<&'a ModelPreset> { - available_models - .iter() - .find(|preset| preset.model == target_model && preset.show_in_picker) -} - -const MODEL_AVAILABILITY_NUX_MAX_SHOW_COUNT: u32 = 4; - -#[derive(Debug, Clone, PartialEq, Eq)] -struct StartupTooltipOverride { - model_slug: String, - message: String, -} - -fn select_model_availability_nux( - available_models: &[ModelPreset], - nux_config: &ModelAvailabilityNuxConfig, -) -> Option { - available_models.iter().find_map(|preset| { - let ModelAvailabilityNux { message } = preset.availability_nux.as_ref()?; - let shown_count = nux_config - .shown_count - .get(&preset.model) - .copied() - .unwrap_or_default(); - (shown_count < MODEL_AVAILABILITY_NUX_MAX_SHOW_COUNT).then(|| StartupTooltipOverride { - model_slug: preset.model.clone(), - message: message.clone(), - }) - }) -} - -async fn prepare_startup_tooltip_override( - config: &mut Config, - available_models: &[ModelPreset], - is_first_run: bool, -) -> Option { - if is_first_run || !config.show_tooltips { - return None; - } - - let tooltip_override = - select_model_availability_nux(available_models, &config.model_availability_nux)?; - - let shown_count = config - .model_availability_nux - .shown_count - .get(&tooltip_override.model_slug) - .copied() - .unwrap_or_default(); - let next_count = shown_count.saturating_add(1); - let mut updated_shown_count = config.model_availability_nux.shown_count.clone(); - updated_shown_count.insert(tooltip_override.model_slug.clone(), next_count); - - if let Err(err) = ConfigEditsBuilder::new(&config.codex_home) - .set_model_availability_nux_count(&updated_shown_count) - .apply() - .await - { - tracing::error!( - error = %err, - model = %tooltip_override.model_slug, - "failed to persist model availability nux count" - ); - return Some(tooltip_override.message); - } - - config.model_availability_nux.shown_count = updated_shown_count; - Some(tooltip_override.message) -} - -async fn handle_model_migration_prompt_if_needed( - tui: &mut tui::Tui, - config: &mut Config, - model: &str, - app_event_tx: &AppEventSender, - available_models: &[ModelPreset], -) -> Option { - let upgrade = available_models - .iter() - .find(|preset| preset.model == model) - .and_then(|preset| preset.upgrade.as_ref()); - - if let Some(ModelUpgrade { - id: target_model, - reasoning_effort_mapping, - migration_config_key, - model_link, - upgrade_copy, - migration_markdown, - }) = upgrade - { - if migration_prompt_hidden(config, migration_config_key.as_str()) { - return None; - } - - let target_model = target_model.to_string(); - if !should_show_model_migration_prompt( - model, - &target_model, - &config.notices.model_migrations, - available_models, - ) { - return None; - } - - let current_preset = available_models.iter().find(|preset| preset.model == model); - let target_preset = target_preset_for_upgrade(available_models, &target_model); - let target_preset = target_preset?; - let target_display_name = target_preset.display_name.clone(); - let heading_label = if target_display_name == model { - target_model.clone() - } else { - target_display_name.clone() - }; - let target_description = - (!target_preset.description.is_empty()).then(|| target_preset.description.clone()); - let can_opt_out = current_preset.is_some(); - let prompt_copy = migration_copy_for_models( - model, - &target_model, - model_link.clone(), - upgrade_copy.clone(), - migration_markdown.clone(), - heading_label, - target_description, - can_opt_out, - ); - match run_model_migration_prompt(tui, prompt_copy).await { - ModelMigrationOutcome::Accepted => { - app_event_tx.send(AppEvent::PersistModelMigrationPromptAcknowledged { - from_model: model.to_string(), - to_model: target_model.clone(), - }); - - let mapped_effort = if let Some(reasoning_effort_mapping) = reasoning_effort_mapping - && let Some(reasoning_effort) = config.model_reasoning_effort - { - reasoning_effort_mapping - .get(&reasoning_effort) - .cloned() - .or(config.model_reasoning_effort) - } else { - config.model_reasoning_effort - }; - - config.model = Some(target_model.clone()); - config.model_reasoning_effort = mapped_effort; - app_event_tx.send(AppEvent::UpdateModel(target_model.clone())); - app_event_tx.send(AppEvent::UpdateReasoningEffort(mapped_effort)); - app_event_tx.send(AppEvent::PersistModelSelection { - model: target_model.clone(), - effort: mapped_effort, - }); - } - ModelMigrationOutcome::Rejected => { - app_event_tx.send(AppEvent::PersistModelMigrationPromptAcknowledged { - from_model: model.to_string(), - to_model: target_model.clone(), - }); - } - ModelMigrationOutcome::Exit => { - return Some(AppExitInfo { - token_usage: TokenUsage::default(), - thread_id: None, - thread_name: None, - update_action: None, - exit_reason: ExitReason::UserRequested, - }); - } - } - } - - None -} - pub(crate) struct App { model_catalog: Arc, pub(crate) session_telemetry: SessionTelemetry, @@ -1097,30 +564,6 @@ pub(crate) struct App { pending_plugin_enabled_writes: HashMap>, } -#[derive(Default)] -struct WindowsSandboxState { - setup_started_at: Option, - // One-shot suppression of the next world-writable scan after user confirmation. - skip_world_writable_scan_once: bool, -} - -fn normalize_harness_overrides_for_cwd( - mut overrides: ConfigOverrides, - base_cwd: &AbsolutePathBuf, -) -> Result { - if overrides.additional_writable_roots.is_empty() { - return Ok(overrides); - } - - let mut normalized = Vec::with_capacity(overrides.additional_writable_roots.len()); - for root in overrides.additional_writable_roots.drain(..) { - let absolute = base_cwd.join(root); - normalized.push(absolute.into_path_buf()); - } - overrides.additional_writable_roots = normalized; - Ok(overrides) -} - fn active_turn_not_steerable_turn_error(error: &TypedRequestError) -> Option { let TypedRequestError::Server { source, .. } = error else { return None; @@ -1191,2850 +634,6 @@ impl App { } } - async fn rebuild_config_for_cwd(&self, cwd: PathBuf) -> Result { - let mut overrides = self.harness_overrides.clone(); - overrides.cwd = Some(cwd.clone()); - let cwd_display = cwd.display().to_string(); - ConfigBuilder::default() - .codex_home(self.config.codex_home.to_path_buf()) - .cli_overrides(self.cli_kv_overrides.clone()) - .harness_overrides(overrides) - .build() - .await - .wrap_err_with(|| format!("Failed to rebuild config for cwd {cwd_display}")) - } - - async fn refresh_in_memory_config_from_disk(&mut self) -> Result<()> { - let mut config = self - .rebuild_config_for_cwd(self.chat_widget.config_ref().cwd.to_path_buf()) - .await?; - self.apply_runtime_policy_overrides(&mut config); - self.config = config; - self.chat_widget.sync_plugin_mentions_config(&self.config); - Ok(()) - } - - async fn refresh_in_memory_config_from_disk_best_effort(&mut self, action: &str) { - if let Err(err) = self.refresh_in_memory_config_from_disk().await { - tracing::warn!( - error = %err, - action, - "failed to refresh config before thread transition; continuing with current in-memory config" - ); - } - } - - async fn rebuild_config_for_resume_or_fallback( - &mut self, - current_cwd: &Path, - resume_cwd: PathBuf, - ) -> Result { - match self.rebuild_config_for_cwd(resume_cwd.clone()).await { - Ok(config) => Ok(config), - Err(err) => { - if crate::cwds_differ(current_cwd, &resume_cwd) { - Err(err) - } else { - let resume_cwd_display = resume_cwd.display().to_string(); - tracing::warn!( - error = %err, - cwd = %resume_cwd_display, - "failed to rebuild config for same-cwd resume; using current in-memory config" - ); - Ok(self.config.clone()) - } - } - } - } - - fn apply_runtime_policy_overrides(&mut self, config: &mut Config) { - if let Some(policy) = self.runtime_approval_policy_override.as_ref() - && let Err(err) = config.permissions.approval_policy.set(*policy) - { - tracing::warn!(%err, "failed to carry forward approval policy override"); - self.chat_widget.add_error_message(format!( - "Failed to carry forward approval policy override: {err}" - )); - } - if let Some(policy) = self.runtime_sandbox_policy_override.as_ref() - && let Err(err) = config.permissions.sandbox_policy.set(policy.clone()) - { - tracing::warn!(%err, "failed to carry forward sandbox policy override"); - self.chat_widget.add_error_message(format!( - "Failed to carry forward sandbox policy override: {err}" - )); - } - } - - fn set_approvals_reviewer_in_app_and_widget(&mut self, reviewer: ApprovalsReviewer) { - self.config.approvals_reviewer = reviewer; - self.chat_widget.set_approvals_reviewer(reviewer); - } - - fn try_set_approval_policy_on_config( - &mut self, - config: &mut Config, - policy: AskForApproval, - user_message_prefix: &str, - log_message: &str, - ) -> bool { - if let Err(err) = config.permissions.approval_policy.set(policy) { - tracing::warn!(error = %err, "{log_message}"); - self.chat_widget - .add_error_message(format!("{user_message_prefix}: {err}")); - return false; - } - - true - } - - fn try_set_sandbox_policy_on_config( - &mut self, - config: &mut Config, - policy: SandboxPolicy, - user_message_prefix: &str, - log_message: &str, - ) -> bool { - if let Err(err) = config.permissions.sandbox_policy.set(policy) { - tracing::warn!(error = %err, "{log_message}"); - self.chat_widget - .add_error_message(format!("{user_message_prefix}: {err}")); - return false; - } - - true - } - - async fn update_feature_flags(&mut self, updates: Vec<(Feature, bool)>) { - if updates.is_empty() { - return; - } - - let guardian_approvals_preset = guardian_approvals_mode(); - let mut next_config = self.config.clone(); - let active_profile = self.active_profile.clone(); - let scoped_segments = |key: &str| { - if let Some(profile) = active_profile.as_deref() { - vec!["profiles".to_string(), profile.to_string(), key.to_string()] - } else { - vec![key.to_string()] - } - }; - let windows_sandbox_changed = updates.iter().any(|(feature, _)| { - matches!( - feature, - Feature::WindowsSandbox | Feature::WindowsSandboxElevated - ) - }); - let mut approval_policy_override = None; - let mut approvals_reviewer_override = None; - let mut sandbox_policy_override = None; - let mut feature_updates_to_apply = Vec::with_capacity(updates.len()); - // Auto-Review owns `approvals_reviewer`, but disabling the feature - // from inside a profile should not silently clear a value configured at - // the root scope. - let (root_approvals_reviewer_blocks_profile_disable, profile_approvals_reviewer_configured) = { - let effective_config = next_config.config_layer_stack.effective_config(); - let root_blocks_disable = effective_config - .as_table() - .and_then(|table| table.get("approvals_reviewer")) - .is_some_and(|value| value != &TomlValue::String("user".to_string())); - let profile_configured = active_profile.as_deref().is_some_and(|profile| { - effective_config - .as_table() - .and_then(|table| table.get("profiles")) - .and_then(TomlValue::as_table) - .and_then(|profiles| profiles.get(profile)) - .and_then(TomlValue::as_table) - .is_some_and(|profile_config| profile_config.contains_key("approvals_reviewer")) - }); - (root_blocks_disable, profile_configured) - }; - let mut permissions_history_label: Option<&'static str> = None; - let mut builder = ConfigEditsBuilder::new(&self.config.codex_home) - .with_profile(self.active_profile.as_deref()); - - for (feature, enabled) in updates { - let feature_key = feature.key(); - let mut feature_edits = Vec::new(); - if feature == Feature::GuardianApproval - && !enabled - && self.active_profile.is_some() - && root_approvals_reviewer_blocks_profile_disable - { - self.chat_widget.add_error_message( - "Cannot disable Auto-review in this profile because `approvals_reviewer` is configured outside the active profile.".to_string(), - ); - continue; - } - let mut feature_config = next_config.clone(); - if let Err(err) = feature_config.features.set_enabled(feature, enabled) { - tracing::error!( - error = %err, - feature = feature_key, - "failed to update constrained feature flags" - ); - self.chat_widget.add_error_message(format!( - "Failed to update experimental feature `{feature_key}`: {err}" - )); - continue; - } - let effective_enabled = feature_config.features.enabled(feature); - if feature == Feature::GuardianApproval { - let previous_approvals_reviewer = feature_config.approvals_reviewer; - if effective_enabled { - // Persist the reviewer setting so future sessions keep the - // experiment's matching `/approvals` mode until the user - // changes it explicitly. - feature_config.approvals_reviewer = - guardian_approvals_preset.approvals_reviewer; - feature_edits.push(ConfigEdit::SetPath { - segments: scoped_segments("approvals_reviewer"), - value: guardian_approvals_preset - .approvals_reviewer - .to_string() - .into(), - }); - if previous_approvals_reviewer != guardian_approvals_preset.approvals_reviewer { - permissions_history_label = Some("Auto-review"); - } - } else if !effective_enabled { - if profile_approvals_reviewer_configured || self.active_profile.is_none() { - feature_edits.push(ConfigEdit::ClearPath { - segments: scoped_segments("approvals_reviewer"), - }); - } - feature_config.approvals_reviewer = ApprovalsReviewer::User; - if previous_approvals_reviewer != ApprovalsReviewer::User { - permissions_history_label = Some("Default"); - } - } - approvals_reviewer_override = Some(feature_config.approvals_reviewer); - } - if feature == Feature::GuardianApproval && effective_enabled { - // The feature flag alone is not enough for the live session. - // We also align approval policy + sandbox to the Auto-review - // preset so enabling the experiment immediately - // makes guardian review observable in the current thread. - if !self.try_set_approval_policy_on_config( - &mut feature_config, - guardian_approvals_preset.approval_policy, - "Failed to enable Auto-review", - "failed to set guardian approvals approval policy on staged config", - ) { - continue; - } - if !self.try_set_sandbox_policy_on_config( - &mut feature_config, - guardian_approvals_preset.sandbox_policy.clone(), - "Failed to enable Auto-review", - "failed to set guardian approvals sandbox policy on staged config", - ) { - continue; - } - feature_edits.extend([ - ConfigEdit::SetPath { - segments: scoped_segments("approval_policy"), - value: "on-request".into(), - }, - ConfigEdit::SetPath { - segments: scoped_segments("sandbox_mode"), - value: "workspace-write".into(), - }, - ]); - approval_policy_override = Some(guardian_approvals_preset.approval_policy); - sandbox_policy_override = Some(guardian_approvals_preset.sandbox_policy.clone()); - } - next_config = feature_config; - feature_updates_to_apply.push((feature, effective_enabled)); - builder = builder - .with_edits(feature_edits) - .set_feature_enabled(feature_key, effective_enabled); - } - - // Persist first so the live session does not diverge from disk if the - // config edit fails. Runtime/UI state is patched below only after the - // durable config update succeeds. - if let Err(err) = builder.apply().await { - tracing::error!(error = %err, "failed to persist feature flags"); - self.chat_widget - .add_error_message(format!("Failed to update experimental features: {err}")); - return; - } - - let memory_tool_was_enabled = self.config.features.enabled(Feature::MemoryTool); - self.config = next_config; - let show_memory_enable_notice = - feature_updates_to_apply.iter().any(|(feature, enabled)| { - *feature == Feature::MemoryTool && *enabled && !memory_tool_was_enabled - }); - for (feature, effective_enabled) in feature_updates_to_apply { - self.chat_widget - .set_feature_enabled(feature, effective_enabled); - } - if show_memory_enable_notice { - self.chat_widget.add_memories_enable_notice(); - } - if approvals_reviewer_override.is_some() { - self.set_approvals_reviewer_in_app_and_widget(self.config.approvals_reviewer); - } - if approval_policy_override.is_some() { - self.chat_widget - .set_approval_policy(self.config.permissions.approval_policy.value()); - } - if sandbox_policy_override.is_some() - && let Err(err) = self - .chat_widget - .set_sandbox_policy(self.config.permissions.sandbox_policy.get().clone()) - { - tracing::error!( - error = %err, - "failed to set guardian approvals sandbox policy on chat config" - ); - self.chat_widget - .add_error_message(format!("Failed to enable Auto-review: {err}")); - } - - if approval_policy_override.is_some() - || approvals_reviewer_override.is_some() - || sandbox_policy_override.is_some() - { - // This uses `OverrideTurnContext` intentionally: toggling the - // experiment should update the active thread's effective approval - // settings immediately, just like a `/approvals` selection. Without - // this runtime patch, the config edit would only affect future - // sessions or turns recreated from disk. - let op = AppCommand::override_turn_context( - /*cwd*/ None, - approval_policy_override, - approvals_reviewer_override, - sandbox_policy_override, - /*windows_sandbox_level*/ None, - /*model*/ None, - /*effort*/ None, - /*summary*/ None, - /*service_tier*/ None, - /*collaboration_mode*/ None, - /*personality*/ None, - ); - let replay_state_op = - ThreadEventStore::op_can_change_pending_replay_state(&op).then(|| op.clone()); - let submitted = self.chat_widget.submit_op(op); - if submitted && let Some(op) = replay_state_op.as_ref() { - self.note_active_thread_outbound_op(op).await; - self.refresh_pending_thread_approvals().await; - } - } - - if windows_sandbox_changed { - #[cfg(target_os = "windows")] - { - let windows_sandbox_level = WindowsSandboxLevel::from_config(&self.config); - self.app_event_tx.send(AppEvent::CodexOp( - AppCommand::override_turn_context( - /*cwd*/ None, - /*approval_policy*/ None, - /*approvals_reviewer*/ None, - /*sandbox_policy*/ None, - #[cfg(target_os = "windows")] - Some(windows_sandbox_level), - /*model*/ None, - /*effort*/ None, - /*summary*/ None, - /*service_tier*/ None, - /*collaboration_mode*/ None, - /*personality*/ None, - ) - .into_core(), - )); - } - } - - if let Some(label) = permissions_history_label { - self.chat_widget.add_info_message( - format!("Permissions updated to {label}"), - /*hint*/ None, - ); - } - } - - async fn update_memory_settings( - &mut self, - use_memories: bool, - generate_memories: bool, - ) -> bool { - let active_profile = self.active_profile.clone(); - let scoped_memory_segments = |key: &str| { - if let Some(profile) = active_profile.as_deref() { - vec![ - "profiles".to_string(), - profile.to_string(), - "memories".to_string(), - key.to_string(), - ] - } else { - vec!["memories".to_string(), key.to_string()] - } - }; - let edits = [ - ConfigEdit::SetPath { - segments: scoped_memory_segments("use_memories"), - value: use_memories.into(), - }, - ConfigEdit::SetPath { - segments: scoped_memory_segments("generate_memories"), - value: generate_memories.into(), - }, - ]; - - if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) - .with_edits(edits) - .apply() - .await - { - tracing::error!(error = %err, "failed to persist memory settings"); - self.chat_widget - .add_error_message(format!("Failed to save memory settings: {err}")); - return false; - } - - self.config.memories.use_memories = use_memories; - self.config.memories.generate_memories = generate_memories; - self.chat_widget - .set_memory_settings(use_memories, generate_memories); - true - } - - async fn update_memory_settings_with_app_server( - &mut self, - app_server: &mut AppServerSession, - use_memories: bool, - generate_memories: bool, - ) { - let previous_generate_memories = self.config.memories.generate_memories; - if !self - .update_memory_settings(use_memories, generate_memories) - .await - { - return; - } - - if previous_generate_memories == generate_memories { - return; - } - - let Some(thread_id) = self.current_displayed_thread_id() else { - return; - }; - - let mode = if generate_memories { - ThreadMemoryMode::Enabled - } else { - ThreadMemoryMode::Disabled - }; - - if let Err(err) = app_server.thread_memory_mode_set(thread_id, mode).await { - tracing::error!(error = %err, %thread_id, "failed to update thread memory mode"); - self.chat_widget.add_error_message(format!( - "Saved memory settings, but failed to update the current thread: {err}" - )); - } - } - - async fn reset_memories_with_app_server(&mut self, app_server: &mut AppServerSession) { - if let Err(err) = app_server.memory_reset().await { - tracing::error!(error = %err, "failed to reset memories"); - self.chat_widget - .add_error_message(format!("Failed to reset memories: {err}")); - return; - } - - self.chat_widget - .add_info_message("Reset local memories.".to_string(), /*hint*/ None); - } - - fn open_url_in_browser(&mut self, url: String) { - if let Err(err) = webbrowser::open(&url) { - self.chat_widget - .add_error_message(format!("Failed to open browser for {url}: {err}")); - return; - } - - self.chat_widget - .add_info_message(format!("Opened {url} in your browser."), /*hint*/ None); - } - - fn clear_ui_header_lines_with_version( - &self, - width: u16, - version: &'static str, - ) -> Vec> { - history_cell::SessionHeaderHistoryCell::new( - self.chat_widget.current_model().to_string(), - self.chat_widget.current_reasoning_effort(), - self.chat_widget.should_show_fast_status( - self.chat_widget.current_model(), - self.chat_widget.current_service_tier(), - ), - self.config.cwd.to_path_buf(), - version, - ) - .with_yolo_mode(history_cell::is_yolo_mode(&self.config)) - .display_lines(width) - } - - fn clear_ui_header_lines(&self, width: u16) -> Vec> { - self.clear_ui_header_lines_with_version(width, CODEX_CLI_VERSION) - } - - fn queue_clear_ui_header(&mut self, tui: &mut tui::Tui) { - let width = tui.terminal.last_known_screen_size.width; - let header_lines = self.clear_ui_header_lines(width); - if !header_lines.is_empty() { - tui.insert_history_lines(header_lines); - self.has_emitted_history_lines = true; - } - } - - fn clear_terminal_ui(&mut self, tui: &mut tui::Tui, redraw_header: bool) -> Result<()> { - let is_alt_screen_active = tui.is_alt_screen_active(); - - // Drop queued history insertions so stale transcript lines cannot be flushed after /clear. - tui.clear_pending_history_lines(); - - if is_alt_screen_active { - tui.terminal.clear_visible_screen()?; - } else { - // Some terminals (Terminal.app, Warp) do not reliably drop scrollback when purge and - // clear are emitted as separate backend commands. Prefer a single ANSI sequence. - tui.terminal.clear_scrollback_and_visible_screen_ansi()?; - } - - let mut area = tui.terminal.viewport_area; - if area.y > 0 { - // After a full clear, anchor the inline viewport at the top and redraw a fresh header - // box. `insert_history_lines()` will shift the viewport down by the rendered height. - area.y = 0; - tui.terminal.set_viewport_area(area); - } - self.has_emitted_history_lines = false; - - if redraw_header { - self.queue_clear_ui_header(tui); - } - Ok(()) - } - - fn reset_app_ui_state_after_clear(&mut self) { - self.overlay = None; - self.transcript_cells.clear(); - self.deferred_history_lines.clear(); - self.has_emitted_history_lines = false; - self.backtrack = BacktrackState::default(); - self.backtrack_render_pending = false; - } - - async fn shutdown_current_thread(&mut self, app_server: &mut AppServerSession) { - if let Some(thread_id) = self.chat_widget.thread_id() { - // Clear any in-flight rollback guard when switching threads. - self.backtrack.pending_rollback = None; - if let Err(err) = app_server.thread_unsubscribe(thread_id).await { - tracing::warn!("failed to unsubscribe thread {thread_id}: {err}"); - } - self.abort_thread_event_listener(thread_id); - } - } - - fn abort_thread_event_listener(&mut self, thread_id: ThreadId) { - if let Some(handle) = self.thread_event_listener_tasks.remove(&thread_id) { - handle.abort(); - } - } - - fn abort_all_thread_event_listeners(&mut self) { - for handle in self - .thread_event_listener_tasks - .drain() - .map(|(_, handle)| handle) - { - handle.abort(); - } - } - - fn ensure_thread_channel(&mut self, thread_id: ThreadId) -> &mut ThreadEventChannel { - self.thread_event_channels - .entry(thread_id) - .or_insert_with(|| ThreadEventChannel::new(THREAD_EVENT_CHANNEL_CAPACITY)) - } - - async fn set_thread_active(&mut self, thread_id: ThreadId, active: bool) { - if let Some(channel) = self.thread_event_channels.get_mut(&thread_id) { - let mut store = channel.store.lock().await; - store.active = active; - } - } - - async fn activate_thread_channel(&mut self, thread_id: ThreadId) { - if self.active_thread_id.is_some() { - return; - } - self.set_thread_active(thread_id, /*active*/ true).await; - let receiver = if let Some(channel) = self.thread_event_channels.get_mut(&thread_id) { - channel.receiver.take() - } else { - None - }; - self.active_thread_id = Some(thread_id); - self.active_thread_rx = receiver; - self.refresh_pending_thread_approvals().await; - } - - async fn store_active_thread_receiver(&mut self) { - let Some(active_id) = self.active_thread_id else { - return; - }; - let input_state = self.chat_widget.capture_thread_input_state(); - if let Some(channel) = self.thread_event_channels.get_mut(&active_id) { - let receiver = self.active_thread_rx.take(); - let mut store = channel.store.lock().await; - store.active = false; - store.input_state = input_state; - if let Some(receiver) = receiver { - channel.receiver = Some(receiver); - } - } - } - - async fn activate_thread_for_replay( - &mut self, - thread_id: ThreadId, - ) -> Option<(mpsc::Receiver, ThreadEventSnapshot)> { - let channel = self.thread_event_channels.get_mut(&thread_id)?; - let receiver = channel.receiver.take()?; - let mut store = channel.store.lock().await; - store.active = true; - let snapshot = store.snapshot(); - Some((receiver, snapshot)) - } - - async fn clear_active_thread(&mut self) { - if let Some(active_id) = self.active_thread_id.take() { - self.set_thread_active(active_id, /*active*/ false).await; - } - self.active_thread_rx = None; - self.refresh_pending_thread_approvals().await; - } - - async fn note_thread_outbound_op(&mut self, thread_id: ThreadId, op: &AppCommand) { - let Some(channel) = self.thread_event_channels.get(&thread_id) else { - return; - }; - let mut store = channel.store.lock().await; - store.note_outbound_op(op); - } - - async fn note_active_thread_outbound_op(&mut self, op: &AppCommand) { - if !ThreadEventStore::op_can_change_pending_replay_state(op) { - return; - } - let Some(thread_id) = self.active_thread_id else { - return; - }; - self.note_thread_outbound_op(thread_id, op).await; - } - - async fn active_turn_id_for_thread(&self, thread_id: ThreadId) -> Option { - let channel = self.thread_event_channels.get(&thread_id)?; - let store = channel.store.lock().await; - store.active_turn_id().map(ToOwned::to_owned) - } - - fn thread_label(&self, thread_id: ThreadId) -> String { - let is_primary = self.primary_thread_id == Some(thread_id); - let fallback_label = if is_primary { - "Main [default]".to_string() - } else { - let thread_id = thread_id.to_string(); - let short_id: String = thread_id.chars().take(8).collect(); - format!("Agent ({short_id})") - }; - if let Some(entry) = self.agent_navigation.get(&thread_id) { - let label = format_agent_picker_item_name( - entry.agent_nickname.as_deref(), - entry.agent_role.as_deref(), - is_primary, - ); - if label == "Agent" { - let thread_id = thread_id.to_string(); - let short_id: String = thread_id.chars().take(8).collect(); - format!("{label} ({short_id})") - } else { - label - } - } else { - fallback_label - } - } - - /// Returns the thread whose transcript is currently on screen. - /// - /// `active_thread_id` is the source of truth during steady state, but the widget can briefly - /// lag behind thread bookkeeping during transitions. The footer label and adjacent-thread - /// navigation both follow what the user is actually looking at, not whichever thread most - /// recently began switching. - fn current_displayed_thread_id(&self) -> Option { - self.active_thread_id.or(self.chat_widget.thread_id()) - } - - fn ignore_same_thread_resume( - &mut self, - target_session: &crate::resume_picker::SessionTarget, - ) -> bool { - if self.active_thread_id != Some(target_session.thread_id) { - return false; - }; - - self.chat_widget.add_info_message( - format!("Already viewing {}.", target_session.display_label()), - /*hint*/ None, - ); - true - } - - /// Mirrors the visible thread into the contextual footer row. - /// - /// The footer sometimes shows ambient context instead of an instructional hint. In multi-agent - /// sessions, that contextual row includes the currently viewed agent label. The label is - /// intentionally hidden until there is more than one known thread so single-thread sessions do - /// not spend footer space restating that the user is already on the main conversation. - fn sync_active_agent_label(&mut self) { - let label = self - .agent_navigation - .active_agent_label(self.current_displayed_thread_id(), self.primary_thread_id); - self.chat_widget.set_active_agent_label(label); - self.sync_side_thread_ui(); - } - - async fn thread_cwd(&self, thread_id: ThreadId) -> Option { - let channel = self.thread_event_channels.get(&thread_id)?; - let store = channel.store.lock().await; - store.session.as_ref().map(|session| session.cwd.clone()) - } - - async fn interactive_request_for_thread_request( - &self, - thread_id: ThreadId, - request: &ServerRequest, - ) -> Option { - let thread_label = Some(self.thread_label(thread_id)); - match request { - ServerRequest::CommandExecutionRequestApproval { params, .. } => { - let network_approval_context = params - .network_approval_context - .clone() - .map(network_approval_context_to_core); - let additional_permissions = params.additional_permissions.clone().map(Into::into); - let proposed_execpolicy_amendment = params - .proposed_execpolicy_amendment - .clone() - .map(codex_app_server_protocol::ExecPolicyAmendment::into_core); - let proposed_network_policy_amendments = params - .proposed_network_policy_amendments - .clone() - .map(|amendments| { - amendments - .into_iter() - .map(codex_app_server_protocol::NetworkPolicyAmendment::into_core) - .collect::>() - }); - Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Exec { - thread_id, - thread_label, - id: params - .approval_id - .clone() - .unwrap_or_else(|| params.item_id.clone()), - command: params - .command - .as_deref() - .map(split_command_string) - .unwrap_or_default(), - reason: params.reason.clone(), - available_decisions: params - .available_decisions - .clone() - .map(|decisions| { - decisions - .into_iter() - .map(command_execution_decision_to_review_decision) - .collect() - }) - .unwrap_or_else(|| { - default_exec_approval_decisions( - network_approval_context.as_ref(), - proposed_execpolicy_amendment.as_ref(), - proposed_network_policy_amendments.as_deref(), - additional_permissions.as_ref(), - ) - }), - network_approval_context, - additional_permissions, - })) - } - ServerRequest::FileChangeRequestApproval { params, .. } => Some( - ThreadInteractiveRequest::Approval(ApprovalRequest::ApplyPatch { - thread_id, - thread_label, - id: params.item_id.clone(), - reason: params.reason.clone(), - cwd: self - .thread_cwd(thread_id) - .await - .unwrap_or_else(|| self.config.cwd.clone()), - changes: HashMap::new(), - }), - ), - ServerRequest::McpServerElicitationRequest { request_id, params } => { - if let Some(request) = McpServerElicitationFormRequest::from_app_server_request( - thread_id, - app_server_request_id_to_mcp_request_id(request_id), - params.clone(), - ) { - Some(ThreadInteractiveRequest::McpServerElicitation(request)) - } else { - Some(ThreadInteractiveRequest::Approval( - ApprovalRequest::McpElicitation { - thread_id, - thread_label, - server_name: params.server_name.clone(), - request_id: app_server_request_id_to_mcp_request_id(request_id), - message: match ¶ms.request { - codex_app_server_protocol::McpServerElicitationRequest::Form { - message, - .. - } - | codex_app_server_protocol::McpServerElicitationRequest::Url { - message, - .. - } => message.clone(), - }, - }, - )) - } - } - ServerRequest::PermissionsRequestApproval { params, .. } => Some( - ThreadInteractiveRequest::Approval(ApprovalRequest::Permissions { - thread_id, - thread_label, - call_id: params.item_id.clone(), - reason: params.reason.clone(), - permissions: params.permissions.clone().into(), - }), - ), - _ => None, - } - } - - fn push_thread_interactive_request(&mut self, request: ThreadInteractiveRequest) { - match request { - ThreadInteractiveRequest::Approval(request) => { - self.chat_widget.push_approval_request(request); - } - ThreadInteractiveRequest::McpServerElicitation(request) => { - self.chat_widget - .push_mcp_server_elicitation_request(request); - } - } - } - - async fn pending_inactive_thread_requests(&self) -> Vec<(ThreadId, ServerRequest)> { - let channels: Vec<(ThreadId, Arc>)> = self - .thread_event_channels - .iter() - .map(|(thread_id, channel)| (*thread_id, Arc::clone(&channel.store))) - .collect(); - - let mut requests = Vec::new(); - for (thread_id, store) in channels { - if Some(thread_id) == self.active_thread_id { - continue; - } - - let store = store.lock().await; - requests.extend( - store - .pending_replay_requests() - .into_iter() - .map(|request| (thread_id, request)), - ); - } - requests - } - - pub(super) async fn surface_pending_inactive_thread_interactive_requests(&mut self) { - if self.active_side_parent_thread_id().is_some() { - return; - } - - let requests = self.pending_inactive_thread_requests().await; - for (thread_id, request) in requests { - if let Some(request) = self - .interactive_request_for_thread_request(thread_id, &request) - .await - { - self.push_thread_interactive_request(request); - } - } - } - - async fn submit_active_thread_op( - &mut self, - app_server: &mut AppServerSession, - op: AppCommand, - ) -> Result<()> { - let Some(thread_id) = self.active_thread_id else { - self.chat_widget - .add_error_message("No active thread is available.".to_string()); - return Ok(()); - }; - - self.submit_thread_op(app_server, thread_id, op).await - } - - async fn submit_thread_op( - &mut self, - app_server: &mut AppServerSession, - thread_id: ThreadId, - op: AppCommand, - ) -> Result<()> { - crate::session_log::log_outbound_op(&op); - - if self.try_handle_local_history_op(thread_id, &op).await? { - return Ok(()); - } - - if self - .try_resolve_app_server_request(app_server, thread_id, &op) - .await? - { - return Ok(()); - } - - if self - .try_submit_active_thread_op_via_app_server(app_server, thread_id, &op) - .await? - { - if ThreadEventStore::op_can_change_pending_replay_state(&op) { - self.note_thread_outbound_op(thread_id, &op).await; - self.refresh_pending_thread_approvals().await; - self.refresh_side_parent_status_from_store(thread_id).await; - } - return Ok(()); - } - - self.chat_widget - .add_error_message(format!("Not available in TUI yet for thread {thread_id}.")); - Ok(()) - } - - /// Spawn a background task that fetches MCP server status from the app-server - /// via paginated RPCs, then delivers the result back through - /// `AppEvent::McpInventoryLoaded`. - /// - /// The spawned task is fire-and-forget: no `JoinHandle` is stored, so a stale - /// result may arrive after the user has moved on. We currently accept that - /// tradeoff because the effect is limited to stale inventory output in history, - /// while request-token invalidation would add cross-cutting async state for a - /// low-severity path. - fn fetch_mcp_inventory( - &mut self, - app_server: &AppServerSession, - detail: McpServerStatusDetail, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let result = fetch_all_mcp_server_statuses(request_handle, detail) - .await - .map_err(|err| err.to_string()); - app_event_tx.send(AppEvent::McpInventoryLoaded { result, detail }); - }); - } - - /// Spawns a background task to fetch account rate limits and deliver the - /// result as a `RateLimitsLoaded` event. - /// - /// The `origin` is forwarded to the completion handler so it can distinguish - /// a startup prefetch (which only updates cached snapshots and schedules a - /// frame) from a `/status`-triggered refresh (which must finalize the - /// corresponding status card). - fn refresh_rate_limits( - &mut self, - app_server: &AppServerSession, - origin: RateLimitRefreshOrigin, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let result = fetch_account_rate_limits(request_handle) - .await - .map_err(|err| err.to_string()); - app_event_tx.send(AppEvent::RateLimitsLoaded { origin, result }); - }); - } - - fn send_add_credits_nudge_email( - &mut self, - app_server: &AppServerSession, - credit_type: AddCreditsNudgeCreditType, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let result = send_add_credits_nudge_email(request_handle, credit_type) - .await - .map_err(|err| err.to_string()); - app_event_tx.send(AppEvent::AddCreditsNudgeEmailFinished { result }); - }); - } - - /// Starts the initial skills refresh without delaying the first interactive frame. - /// - /// Startup only needs skill metadata to populate skill mentions and the skills UI; the prompt can be - /// rendered before that metadata arrives. The result is routed through the normal app event queue so - /// the same response handler updates the chat widget and emits invalid `SKILL.md` warnings once the - /// app-server RPC finishes. User-initiated skills refreshes still use the blocking app command path so - /// callers that explicitly asked for fresh skill state do not race ahead of their own refresh. - fn refresh_startup_skills(&mut self, app_server: &AppServerSession) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - let cwd = self.config.cwd.to_path_buf(); - tokio::spawn(async move { - let result = fetch_skills_list(request_handle, cwd) - .await - .map_err(|err| format!("{err:#}")); - app_event_tx.send(AppEvent::SkillsListLoaded { result }); - }); - } - - fn fetch_plugins_list(&mut self, app_server: &AppServerSession, cwd: PathBuf) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let result = fetch_plugins_list(request_handle, cwd.clone()) - .await - .map_err(|err| err.to_string()); - app_event_tx.send(AppEvent::PluginsLoaded { cwd, result }); - }); - } - - fn fetch_plugin_detail( - &mut self, - app_server: &AppServerSession, - cwd: PathBuf, - params: PluginReadParams, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let result = fetch_plugin_detail(request_handle, params) - .await - .map_err(|err| err.to_string()); - app_event_tx.send(AppEvent::PluginDetailLoaded { cwd, result }); - }); - } - - fn fetch_plugin_install( - &mut self, - app_server: &AppServerSession, - cwd: PathBuf, - marketplace_path: AbsolutePathBuf, - plugin_name: String, - plugin_display_name: String, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let cwd_for_event = cwd.clone(); - let marketplace_path_for_event = marketplace_path.clone(); - let plugin_name_for_event = plugin_name.clone(); - let result = fetch_plugin_install(request_handle, marketplace_path, plugin_name) - .await - .map_err(|err| format!("Failed to install plugin: {err}")); - app_event_tx.send(AppEvent::PluginInstallLoaded { - cwd: cwd_for_event, - marketplace_path: marketplace_path_for_event, - plugin_name: plugin_name_for_event, - plugin_display_name, - result, - }); - }); - } - - fn fetch_plugin_uninstall( - &mut self, - app_server: &AppServerSession, - cwd: PathBuf, - plugin_id: String, - plugin_display_name: String, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let cwd_for_event = cwd.clone(); - let plugin_id_for_event = plugin_id.clone(); - let result = fetch_plugin_uninstall(request_handle, plugin_id) - .await - .map_err(|err| format!("Failed to uninstall plugin: {err}")); - app_event_tx.send(AppEvent::PluginUninstallLoaded { - cwd: cwd_for_event, - plugin_id: plugin_id_for_event, - plugin_display_name, - result, - }); - }); - } - - fn set_plugin_enabled( - &mut self, - app_server: &AppServerSession, - cwd: PathBuf, - plugin_id: String, - enabled: bool, - ) { - if let Some(queued_enabled) = self.pending_plugin_enabled_writes.get_mut(&plugin_id) { - *queued_enabled = Some(enabled); - return; - } - - self.pending_plugin_enabled_writes - .insert(plugin_id.clone(), None); - self.spawn_plugin_enabled_write(app_server, cwd, plugin_id, enabled); - } - - fn spawn_plugin_enabled_write( - &mut self, - app_server: &AppServerSession, - cwd: PathBuf, - plugin_id: String, - enabled: bool, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let cwd_for_event = cwd.clone(); - let plugin_id_for_event = plugin_id.clone(); - let result = write_plugin_enabled(request_handle, plugin_id, enabled) - .await - .map(|_| ()) - .map_err(|err| format!("Failed to update plugin config: {err}")); - app_event_tx.send(AppEvent::PluginEnabledSet { - cwd: cwd_for_event, - plugin_id: plugin_id_for_event, - enabled, - result, - }); - }); - } - - fn refresh_plugin_mentions(&mut self) { - let config = self.config.clone(); - let app_event_tx = self.app_event_tx.clone(); - if !config.features.enabled(Feature::Plugins) { - app_event_tx.send(AppEvent::PluginMentionsLoaded { plugins: None }); - return; - } - - tokio::spawn(async move { - let plugins = PluginsManager::new(config.codex_home.to_path_buf()) - .plugins_for_config(&config) - .await - .capability_summaries() - .to_vec(); - app_event_tx.send(AppEvent::PluginMentionsLoaded { - plugins: Some(plugins), - }); - }); - } - - fn submit_feedback( - &mut self, - app_server: &AppServerSession, - category: FeedbackCategory, - reason: Option, - turn_id: Option, - include_logs: bool, - ) { - let request_handle = app_server.request_handle(); - let app_event_tx = self.app_event_tx.clone(); - let origin_thread_id = self.chat_widget.thread_id(); - let rollout_path = if include_logs { - self.chat_widget.rollout_path() - } else { - None - }; - let params = build_feedback_upload_params( - origin_thread_id, - rollout_path, - category, - reason, - turn_id, - include_logs, - ); - tokio::spawn(async move { - let result = fetch_feedback_upload(request_handle, params) - .await - .map(|response| response.thread_id) - .map_err(|err| err.to_string()); - app_event_tx.send(AppEvent::FeedbackSubmitted { - origin_thread_id, - category, - include_logs, - result, - }); - }); - } - - fn handle_feedback_thread_event(&mut self, event: FeedbackThreadEvent) { - match event.result { - Ok(thread_id) => { - self.chat_widget - .add_to_history(crate::bottom_pane::feedback_success_cell( - event.category, - event.include_logs, - &thread_id, - event.feedback_audience, - )) - } - Err(err) => self - .chat_widget - .add_to_history(history_cell::new_error_event(format!( - "Failed to upload feedback: {err}" - ))), - } - } - - async fn enqueue_thread_feedback_event( - &mut self, - thread_id: ThreadId, - event: FeedbackThreadEvent, - ) { - let (sender, store) = { - let channel = self.ensure_thread_channel(thread_id); - (channel.sender.clone(), Arc::clone(&channel.store)) - }; - - let should_send = { - let mut guard = store.lock().await; - guard - .buffer - .push_back(ThreadBufferedEvent::FeedbackSubmission(event.clone())); - if guard.buffer.len() > guard.capacity - && let Some(removed) = guard.buffer.pop_front() - && let ThreadBufferedEvent::Request(request) = &removed - { - guard - .pending_interactive_replay - .note_evicted_server_request(request); - } - guard.active - }; - - if should_send { - match sender.try_send(ThreadBufferedEvent::FeedbackSubmission(event)) { - Ok(()) => {} - Err(TrySendError::Full(event)) => { - tokio::spawn(async move { - if let Err(err) = sender.send(event).await { - tracing::warn!("thread {thread_id} event channel closed: {err}"); - } - }); - } - Err(TrySendError::Closed(_)) => { - tracing::warn!("thread {thread_id} event channel closed"); - } - } - } - } - - async fn handle_feedback_submitted( - &mut self, - origin_thread_id: Option, - category: FeedbackCategory, - include_logs: bool, - result: Result, - ) { - let event = FeedbackThreadEvent { - category, - include_logs, - feedback_audience: self.feedback_audience, - result, - }; - if let Some(thread_id) = origin_thread_id { - self.enqueue_thread_feedback_event(thread_id, event).await; - } else { - self.handle_feedback_thread_event(event); - } - } - - /// Process the completed MCP inventory fetch: clear the loading spinner, then - /// render either the full tool/resource listing or an error into chat history. - /// - /// When both the local config and the app-server report zero servers, a special - /// "empty" cell is shown instead of the full table. - fn handle_mcp_inventory_result( - &mut self, - result: Result, String>, - detail: McpServerStatusDetail, - ) { - let config = self.chat_widget.config_ref().clone(); - self.chat_widget.clear_mcp_inventory_loading(); - self.clear_committed_mcp_inventory_loading(); - - let statuses = match result { - Ok(statuses) => statuses, - Err(err) => { - self.chat_widget - .add_error_message(format!("Failed to load MCP inventory: {err}")); - return; - } - }; - - if config.mcp_servers.get().is_empty() && statuses.is_empty() { - self.chat_widget - .add_to_history(history_cell::empty_mcp_output()); - return; - } - - self.chat_widget - .add_to_history(history_cell::new_mcp_tools_output_from_statuses( - &config, &statuses, detail, - )); - } - - fn clear_committed_mcp_inventory_loading(&mut self) { - let Some(index) = self - .transcript_cells - .iter() - .rposition(|cell| cell.as_any().is::()) - else { - return; - }; - - self.transcript_cells.remove(index); - if let Some(Overlay::Transcript(overlay)) = &mut self.overlay { - overlay.replace_cells(self.transcript_cells.clone()); - } - } - - /// Intercept composer-history operations and handle them locally against - /// `$CODEX_HOME/history.jsonl`, bypassing the app-server RPC layer. - async fn try_handle_local_history_op( - &mut self, - thread_id: ThreadId, - op: &AppCommand, - ) -> Result { - match op.view() { - AppCommandView::Other(Op::AddToHistory { text }) => { - let text = text.clone(); - let config = self.chat_widget.config_ref().clone(); - tokio::spawn(async move { - if let Err(err) = append_message_history_entry(&text, &thread_id, &config).await - { - tracing::warn!( - thread_id = %thread_id, - error = %err, - "failed to append to message history" - ); - } - }); - Ok(true) - } - AppCommandView::Other(Op::GetHistoryEntryRequest { offset, log_id }) => { - let offset = *offset; - let log_id = *log_id; - let config = self.chat_widget.config_ref().clone(); - let app_event_tx = self.app_event_tx.clone(); - tokio::spawn(async move { - let entry_opt = tokio::task::spawn_blocking(move || { - lookup_message_history_entry(log_id, offset, &config) - }) - .await - .unwrap_or_else(|err| { - tracing::warn!(error = %err, "history lookup task failed"); - None - }); - - app_event_tx.send(AppEvent::ThreadHistoryEntryResponse { - thread_id, - event: GetHistoryEntryResponseEvent { - offset, - log_id, - entry: entry_opt.map(|entry| { - codex_protocol::message_history::HistoryEntry { - conversation_id: entry.session_id, - ts: entry.ts, - text: entry.text, - } - }), - }, - }); - }); - Ok(true) - } - _ => Ok(false), - } - } - - async fn try_submit_active_thread_op_via_app_server( - &mut self, - app_server: &mut AppServerSession, - thread_id: ThreadId, - op: &AppCommand, - ) -> Result { - match op.view() { - AppCommandView::Interrupt => { - if let Some(turn_id) = self.active_turn_id_for_thread(thread_id).await { - app_server.turn_interrupt(thread_id, turn_id).await?; - } else { - app_server.startup_interrupt(thread_id).await?; - } - Ok(true) - } - AppCommandView::UserTurn { - items, - cwd, - approval_policy, - approvals_reviewer, - sandbox_policy, - model, - effort, - summary, - service_tier, - final_output_json_schema, - collaboration_mode, - personality, - } => { - let mut should_start_turn = true; - if let Some(turn_id) = self.active_turn_id_for_thread(thread_id).await { - let mut steer_turn_id = turn_id; - let mut retried_after_turn_mismatch = false; - loop { - match app_server - .turn_steer(thread_id, steer_turn_id.clone(), items.to_vec()) - .await - { - Ok(_) => return Ok(true), - Err(error) => { - if let Some(turn_error) = - active_turn_not_steerable_turn_error(&error) - { - if !self.chat_widget.enqueue_rejected_steer() { - self.chat_widget.add_error_message(turn_error.message); - } - return Ok(true); - } - match active_turn_steer_race(&error) { - Some(ActiveTurnSteerRace::Missing) => { - if let Some(channel) = - self.thread_event_channels.get(&thread_id) - { - let mut store = channel.store.lock().await; - store.clear_active_turn_id(); - } - should_start_turn = true; - break; - } - Some(ActiveTurnSteerRace::ExpectedTurnMismatch { - actual_turn_id, - }) if !retried_after_turn_mismatch - && actual_turn_id != steer_turn_id => - { - // Review flows can swap the active turn before the TUI - // processes the corresponding notification. Retry once with - // the server-reported turn id so non-steerable review turns - // still fall through to the existing queueing behavior. - if let Some(channel) = - self.thread_event_channels.get(&thread_id) - { - let mut store = channel.store.lock().await; - store.active_turn_id = Some(actual_turn_id.clone()); - } - steer_turn_id = actual_turn_id; - retried_after_turn_mismatch = true; - } - Some(ActiveTurnSteerRace::ExpectedTurnMismatch { - actual_turn_id, - }) => { - if let Some(channel) = - self.thread_event_channels.get(&thread_id) - { - let mut store = channel.store.lock().await; - store.active_turn_id = Some(actual_turn_id); - } - return Err(error.into()); - } - None => return Err(error.into()), - } - } - } - } - } - if should_start_turn { - app_server - .turn_start( - thread_id, - items.to_vec(), - cwd.clone(), - approval_policy, - approvals_reviewer - .unwrap_or(self.chat_widget.config_ref().approvals_reviewer), - sandbox_policy.clone(), - model.to_string(), - effort, - *summary, - *service_tier, - collaboration_mode.clone(), - *personality, - final_output_json_schema.clone(), - ) - .await?; - } - Ok(true) - } - AppCommandView::ListSkills { cwds, force_reload } => { - self.handle_skills_list_result( - app_server - .skills_list(codex_app_server_protocol::SkillsListParams { - cwds: cwds.to_vec(), - force_reload, - per_cwd_extra_user_roots: None, - }) - .await, - "failed to refresh skills", - ); - Ok(true) - } - AppCommandView::Compact => { - app_server.thread_compact_start(thread_id).await?; - Ok(true) - } - AppCommandView::SetThreadName { name } => { - app_server - .thread_set_name(thread_id, name.to_string()) - .await?; - Ok(true) - } - AppCommandView::ThreadRollback { num_turns } => { - let response = match app_server.thread_rollback(thread_id, num_turns).await { - Ok(response) => response, - Err(err) => { - self.handle_backtrack_rollback_failed(); - return Err(err); - } - }; - self.handle_thread_rollback_response(thread_id, num_turns, &response) - .await; - Ok(true) - } - AppCommandView::Review { review_request } => { - app_server - .review_start(thread_id, review_request.clone()) - .await?; - Ok(true) - } - AppCommandView::CleanBackgroundTerminals => { - app_server - .thread_background_terminals_clean(thread_id) - .await?; - Ok(true) - } - AppCommandView::RealtimeConversationStart(params) => { - app_server - .thread_realtime_start(thread_id, params.clone()) - .await?; - Ok(true) - } - AppCommandView::RealtimeConversationAudio(params) => { - app_server - .thread_realtime_audio(thread_id, params.clone()) - .await?; - Ok(true) - } - AppCommandView::RealtimeConversationText(params) => { - app_server - .thread_realtime_text(thread_id, params.clone()) - .await?; - Ok(true) - } - AppCommandView::RealtimeConversationClose => { - app_server.thread_realtime_stop(thread_id).await?; - Ok(true) - } - AppCommandView::RunUserShellCommand { command } => { - app_server - .thread_shell_command(thread_id, command.to_string()) - .await?; - Ok(true) - } - AppCommandView::ReloadUserConfig => { - app_server.reload_user_config().await?; - Ok(true) - } - AppCommandView::OverrideTurnContext { .. } => Ok(true), - _ => Ok(false), - } - } - - fn handle_skills_list_result( - &mut self, - result: Result, - failure_message: &str, - ) { - match result { - Ok(response) => self.handle_skills_list_response(response), - Err(err) => { - tracing::warn!("{failure_message}: {err:#}"); - self.chat_widget - .add_error_message(format!("{failure_message}: {err:#}")); - } - } - } - - async fn try_resolve_app_server_request( - &mut self, - app_server: &AppServerSession, - thread_id: ThreadId, - op: &AppCommand, - ) -> Result { - let Some(resolution) = self - .pending_app_server_requests - .take_resolution(op) - .map_err(|err| color_eyre::eyre::eyre!(err))? - else { - return Ok(false); - }; - - match app_server - .resolve_server_request(resolution.request_id, resolution.result) - .await - { - Ok(()) => { - if ThreadEventStore::op_can_change_pending_replay_state(op) { - self.note_thread_outbound_op(thread_id, op).await; - self.refresh_pending_thread_approvals().await; - self.refresh_side_parent_status_from_store(thread_id).await; - } - Ok(true) - } - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to resolve app-server request for thread {thread_id}: {err}" - )); - Ok(false) - } - } - } - - async fn refresh_pending_thread_approvals(&mut self) { - let side_parent_thread_id = self.active_side_parent_thread_id(); - let channels: Vec<(ThreadId, Arc>)> = self - .thread_event_channels - .iter() - .map(|(thread_id, channel)| (*thread_id, Arc::clone(&channel.store))) - .collect(); - - let mut pending_thread_ids = Vec::new(); - for (thread_id, store) in channels { - if Some(thread_id) == self.active_thread_id || Some(thread_id) == side_parent_thread_id - { - continue; - } - - let store = store.lock().await; - if store.has_pending_thread_approvals() { - pending_thread_ids.push(thread_id); - } - } - - pending_thread_ids.sort_by_key(ThreadId::to_string); - - let threads = pending_thread_ids - .into_iter() - .map(|thread_id| self.thread_label(thread_id)) - .collect(); - - self.chat_widget.set_pending_thread_approvals(threads); - } - - async fn refresh_side_parent_status_from_store(&mut self, thread_id: ThreadId) { - let Some(channel) = self.thread_event_channels.get(&thread_id) else { - return; - }; - let status = { - let store = channel.store.lock().await; - store.side_parent_pending_status() - }; - if let Some(status) = status { - self.set_side_parent_status(thread_id, Some(status)); - } else { - self.clear_side_parent_action_status(thread_id); - } - } - - async fn enqueue_thread_notification( - &mut self, - thread_id: ThreadId, - notification: ServerNotification, - ) -> Result<()> { - let inferred_session = self - .infer_session_for_thread_notification(thread_id, ¬ification) - .await; - let (sender, store) = { - let channel = self.ensure_thread_channel(thread_id); - (channel.sender.clone(), Arc::clone(&channel.store)) - }; - - let (should_send, pending_status) = { - let mut guard = store.lock().await; - if guard.session.is_none() - && let Some(session) = inferred_session - { - guard.session = Some(session); - } - guard.push_notification(notification.clone()); - (guard.active, guard.side_parent_pending_status()) - }; - let notification_status_change = SideParentStatusChange::for_notification(¬ification); - - if should_send { - match sender.try_send(ThreadBufferedEvent::Notification(notification)) { - Ok(()) => {} - Err(TrySendError::Full(event)) => { - tokio::spawn(async move { - if let Err(err) = sender.send(event).await { - tracing::warn!("thread {thread_id} event channel closed: {err}"); - } - }); - } - Err(TrySendError::Closed(_)) => { - tracing::warn!("thread {thread_id} event channel closed"); - } - } - } - if let Some(status) = pending_status { - self.set_side_parent_status(thread_id, Some(status)); - } else if let Some(change) = notification_status_change { - self.apply_side_parent_status_change(thread_id, change); - } - self.refresh_pending_thread_approvals().await; - Ok(()) - } - - /// Eagerly fetches nickname and role for receiver threads referenced by a collab notification. - /// - /// This runs on every buffered thread notification before it reaches rendering. For each - /// receiver thread id that the navigation cache does not yet have metadata for, it issues a - /// `thread/read` RPC and registers the result in both `AgentNavigationState` and the - /// `ChatWidget` metadata map. Threads that already have a nickname or role cached are skipped, - /// so the cost is at most one RPC per thread over the lifetime of a session. - /// - /// Failures are logged and silently ignored -- the worst outcome is that a rendered item shows - /// a thread id instead of a human-readable name, which is the same behavior the TUI had before - /// this change. - async fn hydrate_collab_agent_metadata_for_notification( - &mut self, - app_server: &mut AppServerSession, - notification: &ServerNotification, - ) { - let Some(receiver_thread_ids) = collab_receiver_thread_ids(notification) else { - return; - }; - - for receiver_thread_id in receiver_thread_ids { - let Ok(thread_id) = ThreadId::from_string(receiver_thread_id) else { - tracing::warn!( - thread_id = receiver_thread_id, - "ignoring collab receiver with invalid thread id during metadata hydration" - ); - continue; - }; - - if self - .agent_navigation - .get(&thread_id) - .is_some_and(|entry| entry.agent_nickname.is_some() || entry.agent_role.is_some()) - { - continue; - } - - match app_server - .thread_read(thread_id, /*include_turns*/ false) - .await - { - Ok(thread) => { - self.upsert_agent_picker_thread( - thread_id, - thread.agent_nickname, - thread.agent_role, - /*is_closed*/ false, - ); - } - Err(err) => { - tracing::warn!( - thread_id = %thread_id, - error = %err, - "failed to hydrate collab receiver thread metadata" - ); - } - } - } - } - - async fn infer_session_for_thread_notification( - &mut self, - thread_id: ThreadId, - notification: &ServerNotification, - ) -> Option { - let ServerNotification::ThreadStarted(notification) = notification else { - return None; - }; - let mut session = self.primary_session_configured.clone()?; - session.thread_id = thread_id; - session.thread_name = notification.thread.name.clone(); - session.model_provider_id = notification.thread.model_provider.clone(); - session.cwd = notification.thread.cwd.clone(); - let rollout_path = notification.thread.path.clone(); - if let Some(model) = - read_session_model(&self.config, thread_id, rollout_path.as_deref()).await - { - session.model = model; - } else if rollout_path.is_some() { - session.model.clear(); - } - session.history_log_id = 0; - session.history_entry_count = 0; - session.rollout_path = rollout_path; - self.upsert_agent_picker_thread( - thread_id, - notification.thread.agent_nickname.clone(), - notification.thread.agent_role.clone(), - /*is_closed*/ false, - ); - Some(session) - } - - async fn enqueue_thread_request( - &mut self, - thread_id: ThreadId, - request: ServerRequest, - ) -> Result<()> { - let inactive_interactive_request = if self.active_thread_id != Some(thread_id) { - self.interactive_request_for_thread_request(thread_id, &request) - .await - } else { - None - }; - let (sender, store) = { - let channel = self.ensure_thread_channel(thread_id); - (channel.sender.clone(), Arc::clone(&channel.store)) - }; - - let (should_send, pending_status) = { - let mut guard = store.lock().await; - guard.push_request(request.clone()); - (guard.active, guard.side_parent_pending_status()) - }; - let request_status = SideParentStatus::for_request(&request); - - if should_send { - match sender.try_send(ThreadBufferedEvent::Request(request)) { - Ok(()) => {} - Err(TrySendError::Full(event)) => { - tokio::spawn(async move { - if let Err(err) = sender.send(event).await { - tracing::warn!("thread {thread_id} event channel closed: {err}"); - } - }); - } - Err(TrySendError::Closed(_)) => { - tracing::warn!("thread {thread_id} event channel closed"); - } - } - } else if self.active_side_parent_thread_id().is_none() - && let Some(request) = inactive_interactive_request - { - self.push_thread_interactive_request(request); - } - if let Some(status) = pending_status.or(request_status) { - self.set_side_parent_status(thread_id, Some(status)); - } - self.refresh_pending_thread_approvals().await; - Ok(()) - } - - async fn enqueue_thread_history_entry_response( - &mut self, - thread_id: ThreadId, - event: GetHistoryEntryResponseEvent, - ) -> Result<()> { - let (sender, store) = { - let channel = self.ensure_thread_channel(thread_id); - (channel.sender.clone(), Arc::clone(&channel.store)) - }; - - let should_send = { - let mut guard = store.lock().await; - guard - .buffer - .push_back(ThreadBufferedEvent::HistoryEntryResponse(event.clone())); - if guard.buffer.len() > guard.capacity - && let Some(removed) = guard.buffer.pop_front() - && let ThreadBufferedEvent::Request(request) = &removed - { - guard - .pending_interactive_replay - .note_evicted_server_request(request); - } - guard.active - }; - - if should_send { - match sender.try_send(ThreadBufferedEvent::HistoryEntryResponse(event)) { - Ok(()) => {} - Err(TrySendError::Full(event)) => { - tokio::spawn(async move { - if let Err(err) = sender.send(event).await { - tracing::warn!("thread {thread_id} event channel closed: {err}"); - } - }); - } - Err(TrySendError::Closed(_)) => { - tracing::warn!("thread {thread_id} event channel closed"); - } - } - } - Ok(()) - } - - async fn enqueue_primary_thread_session( - &mut self, - session: ThreadSessionState, - turns: Vec, - ) -> Result<()> { - let thread_id = session.thread_id; - self.primary_thread_id = Some(thread_id); - self.primary_session_configured = Some(session.clone()); - self.upsert_agent_picker_thread( - thread_id, /*agent_nickname*/ None, /*agent_role*/ None, - /*is_closed*/ false, - ); - let channel = self.ensure_thread_channel(thread_id); - { - let mut store = channel.store.lock().await; - store.set_session(session.clone(), turns.clone()); - } - self.activate_thread_channel(thread_id).await; - self.chat_widget - .set_initial_user_message_submit_suppressed(/*suppressed*/ true); - self.chat_widget.handle_thread_session(session); - self.chat_widget - .replay_thread_turns(turns, ReplayKind::ResumeInitialMessages); - let pending = std::mem::take(&mut self.pending_primary_events); - for pending_event in pending { - match pending_event { - ThreadBufferedEvent::Notification(notification) => { - self.enqueue_thread_notification(thread_id, notification) - .await?; - } - ThreadBufferedEvent::Request(request) => { - self.enqueue_thread_request(thread_id, request).await?; - } - ThreadBufferedEvent::HistoryEntryResponse(event) => { - self.enqueue_thread_history_entry_response(thread_id, event) - .await?; - } - ThreadBufferedEvent::FeedbackSubmission(event) => { - self.enqueue_thread_feedback_event(thread_id, event).await; - } - } - } - self.chat_widget - .set_initial_user_message_submit_suppressed(/*suppressed*/ false); - self.chat_widget.submit_initial_user_message_if_pending(); - Ok(()) - } - - async fn enqueue_primary_thread_notification( - &mut self, - notification: ServerNotification, - ) -> Result<()> { - if let Some(thread_id) = self.primary_thread_id { - return self - .enqueue_thread_notification(thread_id, notification) - .await; - } - self.pending_primary_events - .push_back(ThreadBufferedEvent::Notification(notification)); - Ok(()) - } - - async fn enqueue_primary_thread_request(&mut self, request: ServerRequest) -> Result<()> { - if let Some(thread_id) = self.primary_thread_id { - return self.enqueue_thread_request(thread_id, request).await; - } - self.pending_primary_events - .push_back(ThreadBufferedEvent::Request(request)); - Ok(()) - } - - async fn refresh_snapshot_session_if_needed( - &mut self, - app_server: &mut AppServerSession, - thread_id: ThreadId, - is_replay_only: bool, - snapshot: &mut ThreadEventSnapshot, - ) { - if !self.should_refresh_snapshot_session(thread_id, is_replay_only, snapshot) { - return; - } - - match app_server - .resume_thread(self.config.clone(), thread_id) - .await - { - Ok(started) => { - self.apply_refreshed_snapshot_thread(thread_id, started, snapshot) - .await - } - Err(err) => { - tracing::warn!( - thread_id = %thread_id, - error = %err, - "failed to refresh inferred thread session before replay" - ); - } - } - } - - fn should_refresh_snapshot_session( - &self, - thread_id: ThreadId, - is_replay_only: bool, - snapshot: &ThreadEventSnapshot, - ) -> bool { - !is_replay_only - && !self.side_threads.contains_key(&thread_id) - && snapshot.session.as_ref().is_none_or(|session| { - session.model.trim().is_empty() || session.rollout_path.is_none() - }) - } - - async fn apply_refreshed_snapshot_thread( - &mut self, - thread_id: ThreadId, - started: AppServerStartedThread, - snapshot: &mut ThreadEventSnapshot, - ) { - let AppServerStartedThread { session, turns } = started; - if let Some(channel) = self.thread_event_channels.get(&thread_id) { - let mut store = channel.store.lock().await; - store.set_session(session.clone(), turns.clone()); - store.rebase_buffer_after_session_refresh(); - } - snapshot.session = Some(session); - snapshot.turns = turns; - snapshot - .events - .retain(ThreadEventStore::event_survives_session_refresh); - } - - /// Opens the `/agent` picker after refreshing cached labels for known threads. - /// - /// The picker state is derived from long-lived thread channels plus best-effort metadata - /// refreshes from the backend. Refresh failures are treated as "thread is only inspectable by - /// historical id now" and converted into closed picker entries instead of deleting them, so - /// the stable traversal order remains intact for review and keyboard navigation. - async fn open_agent_picker(&mut self, app_server: &mut AppServerSession) { - let mut thread_ids = self.agent_navigation.tracked_thread_ids(); - for thread_id in self.thread_event_channels.keys().copied() { - if !thread_ids.contains(&thread_id) { - thread_ids.push(thread_id); - } - } - for thread_id in thread_ids { - if self.side_threads.contains_key(&thread_id) { - continue; - } - if !self - .refresh_agent_picker_thread_liveness(app_server, thread_id) - .await - { - continue; - } - } - - let has_non_primary_agent_thread = self - .agent_navigation - .has_non_primary_thread(self.primary_thread_id); - if !self.config.features.enabled(Feature::Collab) && !has_non_primary_agent_thread { - self.chat_widget.open_multi_agent_enable_prompt(); - return; - } - - if self.agent_navigation.is_empty() { - self.chat_widget - .add_info_message("No agents available yet.".to_string(), /*hint*/ None); - return; - } - - let mut initial_selected_idx = None; - let items: Vec = self - .agent_navigation - .ordered_threads() - .iter() - .enumerate() - .map(|(idx, (thread_id, entry))| { - if self.active_thread_id == Some(*thread_id) { - initial_selected_idx = Some(idx); - } - let id = *thread_id; - let is_primary = self.primary_thread_id == Some(*thread_id); - let name = format_agent_picker_item_name( - entry.agent_nickname.as_deref(), - entry.agent_role.as_deref(), - is_primary, - ); - let uuid = thread_id.to_string(); - SelectionItem { - name: name.clone(), - name_prefix_spans: agent_picker_status_dot_spans(entry.is_closed), - description: Some(uuid.clone()), - is_current: self.active_thread_id == Some(*thread_id), - actions: vec![Box::new(move |tx| { - tx.send(AppEvent::SelectAgentThread(id)); - })], - dismiss_on_select: true, - search_value: Some(format!("{name} {uuid}")), - ..Default::default() - } - }) - .collect(); - - self.chat_widget.show_selection_view(SelectionViewParams { - title: Some("Subagents".to_string()), - subtitle: Some(AgentNavigationState::picker_subtitle()), - footer_hint: Some(standard_popup_hint_line()), - items, - initial_selected_idx, - ..Default::default() - }); - } - - fn is_terminal_thread_read_error(err: &color_eyre::Report) -> bool { - err.chain() - .any(|cause| cause.to_string().contains("thread not loaded:")) - } - - fn closed_state_for_thread_read_error( - err: &color_eyre::Report, - existing_is_closed: Option, - ) -> bool { - Self::is_terminal_thread_read_error(err) || existing_is_closed.unwrap_or(false) - } - - fn can_fallback_from_include_turns_error(err: &color_eyre::Report) -> bool { - err.chain().any(|cause| { - let message = cause.to_string(); - message.contains("includeTurns is unavailable before first user message") - || message.contains("ephemeral threads do not support includeTurns") - }) - } - - /// Updates cached picker metadata and then mirrors any visible-label change into the footer. - /// - /// These two writes stay paired so the picker rows and contextual footer continue to describe - /// the same displayed thread after nickname or role updates. - fn upsert_agent_picker_thread( - &mut self, - thread_id: ThreadId, - agent_nickname: Option, - agent_role: Option, - is_closed: bool, - ) { - self.chat_widget.set_collab_agent_metadata( - thread_id, - agent_nickname.clone(), - agent_role.clone(), - ); - self.agent_navigation - .upsert(thread_id, agent_nickname, agent_role, is_closed); - self.sync_active_agent_label(); - } - - /// Marks a cached picker thread closed and recomputes the contextual footer label. - /// - /// Closing a thread is not the same as removing it: users can still inspect finished agent - /// transcripts, and the stable next/previous traversal order should not collapse around them. - fn mark_agent_picker_thread_closed(&mut self, thread_id: ThreadId) { - self.agent_navigation.mark_closed(thread_id); - self.sync_active_agent_label(); - } - - async fn refresh_agent_picker_thread_liveness( - &mut self, - app_server: &mut AppServerSession, - thread_id: ThreadId, - ) -> bool { - let existing_entry = self.agent_navigation.get(&thread_id).cloned(); - let has_replay_channel = self.thread_event_channels.contains_key(&thread_id); - match app_server - .thread_read(thread_id, /*include_turns*/ false) - .await - { - Ok(thread) => { - self.upsert_agent_picker_thread( - thread_id, - thread.agent_nickname.or_else(|| { - existing_entry - .as_ref() - .and_then(|entry| entry.agent_nickname.clone()) - }), - thread.agent_role.or_else(|| { - existing_entry - .as_ref() - .and_then(|entry| entry.agent_role.clone()) - }), - matches!( - thread.status, - codex_app_server_protocol::ThreadStatus::NotLoaded - ), - ); - true - } - Err(err) => { - if Self::is_terminal_thread_read_error(&err) && !has_replay_channel { - self.agent_navigation.remove(thread_id); - return false; - } - let is_closed = Self::closed_state_for_thread_read_error( - &err, - existing_entry.as_ref().map(|entry| entry.is_closed), - ); - if let Some(entry) = existing_entry { - self.upsert_agent_picker_thread( - thread_id, - entry.agent_nickname, - entry.agent_role, - is_closed, - ); - } else { - self.upsert_agent_picker_thread( - thread_id, /*agent_nickname*/ None, /*agent_role*/ None, - is_closed, - ); - } - true - } - } - } - - async fn session_state_for_thread_read( - &self, - thread_id: ThreadId, - thread: &codex_app_server_protocol::Thread, - ) -> ThreadSessionState { - let mut session = self - .primary_session_configured - .clone() - .unwrap_or(ThreadSessionState { - thread_id, - forked_from_id: None, - thread_name: None, - model: self.chat_widget.current_model().to_string(), - model_provider_id: self.config.model_provider_id.clone(), - service_tier: self.chat_widget.current_service_tier(), - approval_policy: self.config.permissions.approval_policy.value(), - approvals_reviewer: self.config.approvals_reviewer, - sandbox_policy: self.config.permissions.sandbox_policy.get().clone(), - cwd: thread.cwd.clone(), - instruction_source_paths: Vec::new(), - reasoning_effort: self.chat_widget.current_reasoning_effort(), - history_log_id: 0, - history_entry_count: 0, - network_proxy: None, - rollout_path: thread.path.clone(), - }); - session.thread_id = thread_id; - session.thread_name = thread.name.clone(); - session.model_provider_id = thread.model_provider.clone(); - session.cwd = thread.cwd.clone(); - session.instruction_source_paths = Vec::new(); - session.rollout_path = thread.path.clone(); - if let Some(model) = - read_session_model(&self.config, thread_id, thread.path.as_deref()).await - { - session.model = model; - } else if thread.path.is_some() { - session.model.clear(); - } - session.history_log_id = 0; - session.history_entry_count = 0; - session - } - - /// Materializes a live thread into local replay state when the picker knows about it but the - /// TUI has not cached a local event channel yet. - /// - /// Resume-time backfill intentionally avoids creating empty placeholder channels, because those - /// placeholders make stale `/agent` entries open blank transcripts. When a user later selects a - /// still-live discovered thread, attach it on demand with a real resumed snapshot. - async fn attach_live_thread_for_selection( - &mut self, - app_server: &mut AppServerSession, - thread_id: ThreadId, - ) -> Result { - if self.thread_event_channels.contains_key(&thread_id) { - return Ok(true); - } - - let (session, turns, live_attached) = match app_server - .resume_thread(self.config.clone(), thread_id) - .await - { - Ok(started) => (started.session, started.turns, true), - Err(resume_err) => { - tracing::warn!( - thread_id = %thread_id, - error = %resume_err, - "failed to resume live thread for selection; falling back to thread/read" - ); - let (thread, turns) = match app_server - .thread_read(thread_id, /*include_turns*/ true) - .await - { - Ok(thread) => { - let turns = thread.turns.clone(); - (thread, turns) - } - Err(err) if Self::can_fallback_from_include_turns_error(&err) => { - let thread = app_server - .thread_read(thread_id, /*include_turns*/ false) - .await?; - (thread, Vec::new()) - } - Err(err) => return Err(err), - }; - if turns.is_empty() { - // A `thread/read` fallback without turns would create a blank local replay - // channel with no live listener attached, which blocks later real re-attach. - return Err(color_eyre::eyre::eyre!( - "Agent thread {thread_id} is not yet available for replay or live attach." - )); - } - let mut session = self.session_state_for_thread_read(thread_id, &thread).await; - // `thread/read` can seed replay state, but it does not attach the app-server - // listener that `thread/resume` establishes, so treat this path as replay-only. - session.model.clear(); - (session, turns, false) - } - }; - let channel = self.ensure_thread_channel(thread_id); - let mut store = channel.store.lock().await; - store.set_session(session, turns); - Ok(live_attached) - } - - /// Replaces the chat widget and re-seeds the new widget's collab metadata from the navigation - /// cache. - /// - /// Thread switches reconstruct the `ChatWidget`, which loses the `collab_agent_metadata` map. - /// This helper copies every known nickname/role from `AgentNavigationState` into the - /// replacement widget so that replayed collab items render agent names immediately. - fn replace_chat_widget(&mut self, mut chat_widget: ChatWidget) { - // Transfer the last-written terminal title to the replacement widget - // so it knows what OSC title is currently displayed. Without this, the - // new widget would redundantly clear and rewrite the same title, causing - // a visible flicker in some terminals. - let previous_terminal_title = self.chat_widget.last_terminal_title.take(); - if chat_widget.last_terminal_title.is_none() { - chat_widget.last_terminal_title = previous_terminal_title; - } - for (thread_id, entry) in self.agent_navigation.ordered_threads() { - chat_widget.set_collab_agent_metadata( - thread_id, - entry.agent_nickname.clone(), - entry.agent_role.clone(), - ); - } - self.chat_widget = chat_widget; - self.sync_active_agent_label(); - } - - async fn select_agent_thread( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - thread_id: ThreadId, - ) -> Result<()> { - if self.active_thread_id == Some(thread_id) { - return Ok(()); - } - - if !self - .refresh_agent_picker_thread_liveness(app_server, thread_id) - .await - { - self.chat_widget - .add_error_message(format!("Agent thread {thread_id} is no longer available.")); - return Ok(()); - } - - let mut is_replay_only = self - .agent_navigation - .get(&thread_id) - .is_some_and(|entry| entry.is_closed); - let mut attached_replay_only = false; - if self.should_attach_live_thread_for_selection(thread_id) { - match self - .attach_live_thread_for_selection(app_server, thread_id) - .await - { - Ok(live_attached) => { - attached_replay_only = !live_attached; - if attached_replay_only { - is_replay_only = true; - } - } - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to attach to agent thread {thread_id}: {err}" - )); - return Ok(()); - } - } - } else if !self.thread_event_channels.contains_key(&thread_id) && is_replay_only { - self.chat_widget - .add_error_message(format!("Agent thread {thread_id} is no longer available.")); - return Ok(()); - } - - let previous_thread_id = self.active_thread_id; - self.store_active_thread_receiver().await; - self.active_thread_id = None; - let Some((receiver, mut snapshot)) = self.activate_thread_for_replay(thread_id).await - else { - self.chat_widget - .add_error_message(format!("Agent thread {thread_id} is already active.")); - if let Some(previous_thread_id) = previous_thread_id { - self.activate_thread_channel(previous_thread_id).await; - } - return Ok(()); - }; - - self.refresh_snapshot_session_if_needed( - app_server, - thread_id, - is_replay_only, - &mut snapshot, - ) - .await; - - self.active_thread_id = Some(thread_id); - self.active_thread_rx = Some(receiver); - - let init = self.chatwidget_init_for_forked_or_resumed_thread( - tui, - self.config.clone(), - /*initial_user_message*/ None, - ); - self.replace_chat_widget(ChatWidget::new_with_app_event(init)); - - self.reset_for_thread_switch(tui)?; - self.replay_thread_snapshot(snapshot, !is_replay_only); - if is_replay_only { - let message = if attached_replay_only { - format!( - "Agent thread {thread_id} could not be resumed live. Replaying saved transcript." - ) - } else { - format!("Agent thread {thread_id} is closed. Replaying saved transcript.") - }; - self.chat_widget.add_info_message(message, /*hint*/ None); - } - self.drain_active_thread_events(tui).await?; - self.refresh_pending_thread_approvals().await; - - Ok(()) - } - - fn should_attach_live_thread_for_selection(&self, thread_id: ThreadId) -> bool { - !self.thread_event_channels.contains_key(&thread_id) - && self - .agent_navigation - .get(&thread_id) - .is_none_or(|entry| !entry.is_closed) - } - - fn reset_for_thread_switch(&mut self, tui: &mut tui::Tui) -> Result<()> { - self.overlay = None; - self.transcript_cells.clear(); - self.deferred_history_lines.clear(); - tui.clear_pending_history_lines(); - self.has_emitted_history_lines = false; - self.backtrack = BacktrackState::default(); - self.backtrack_render_pending = false; - Self::clear_terminal_for_thread_switch(&mut tui.terminal)?; - Ok(()) - } - - fn clear_terminal_for_thread_switch( - terminal: &mut crate::custom_terminal::Terminal, - ) -> Result<()> - where - B: Backend + Write, - { - terminal.clear_scrollback_and_visible_screen_ansi()?; - let mut area = terminal.viewport_area; - if area.y > 0 { - area.y = 0; - terminal.set_viewport_area(area); - } - Ok(()) - } - - fn reset_thread_event_state(&mut self) { - self.abort_all_thread_event_listeners(); - self.thread_event_channels.clear(); - self.agent_navigation.clear(); - self.side_threads.clear(); - self.active_thread_id = None; - self.active_thread_rx = None; - self.primary_thread_id = None; - self.last_subagent_backfill_attempt = None; - self.primary_session_configured = None; - self.pending_primary_events.clear(); - self.pending_app_server_requests.clear(); - self.chat_widget.set_pending_thread_approvals(Vec::new()); - self.sync_active_agent_label(); - } - - async fn start_fresh_session_with_summary_hint( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - session_start_source: Option, - initial_user_message: Option, - ) { - // Start a fresh in-memory session while preserving resumability via persisted rollout - // history. If an initial message is provided, `enqueue_primary_thread_session` suppresses it - // until the new session is configured and any replayed turns have been rendered. - self.refresh_in_memory_config_from_disk_best_effort("starting a new thread") - .await; - let model = self.chat_widget.current_model().to_string(); - let config = self.fresh_session_config(); - let summary = session_summary( - self.chat_widget.token_usage(), - self.chat_widget.thread_id(), - self.chat_widget.thread_name(), - self.chat_widget.rollout_path().as_deref(), - ); - self.shutdown_current_thread(app_server).await; - let tracked_thread_ids: Vec = - self.thread_event_channels.keys().copied().collect(); - for thread_id in tracked_thread_ids { - if let Err(err) = app_server.thread_unsubscribe(thread_id).await { - tracing::warn!("failed to unsubscribe tracked thread {thread_id}: {err}"); - } - } - self.config = config.clone(); - match app_server - .start_thread_with_session_start_source(&config, session_start_source) - .await - { - Ok(started) => { - if let Err(err) = self - .replace_chat_widget_with_app_server_thread( - tui, - app_server, - started, - initial_user_message, - ) - .await - { - self.chat_widget.add_error_message(format!( - "Failed to attach to fresh app-server thread: {err}" - )); - } else if let Some(summary) = summary { - let mut lines: Vec> = Vec::new(); - if let Some(usage_line) = summary.usage_line { - lines.push(usage_line.into()); - } - if let Some(command) = summary.resume_command { - let spans = vec!["To continue this session, run ".into(), command.cyan()]; - lines.push(spans.into()); - } - self.chat_widget.add_plain_history_lines(lines); - } - } - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to start a fresh session through the app server: {err}" - )); - self.config.model = Some(model); - } - } - tui.frame_requester().schedule_frame(); - } - - async fn replace_chat_widget_with_app_server_thread( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - started: AppServerStartedThread, - initial_user_message: Option, - ) -> Result<()> { - // Initial messages are for freshly attached primary threads only. Thread switches and - // resume/fork flows pass `None` so they cannot replay old history and then auto-submit a new - // user turn by accident. - self.reset_thread_event_state(); - let init = self.chatwidget_init_for_forked_or_resumed_thread( - tui, - self.config.clone(), - initial_user_message, - ); - self.replace_chat_widget(ChatWidget::new_with_app_event(init)); - self.enqueue_primary_thread_session(started.session, started.turns) - .await?; - self.backfill_loaded_subagent_threads(app_server).await; - Ok(()) - } - - /// Fetches all loaded threads from the app server and registers descendants of the primary - /// thread in the navigation cache and chat widget metadata. - /// - /// Called after `replace_chat_widget_with_app_server_thread` during resume, fork, and new - /// thread creation so that the `/agent` picker and keyboard navigation are pre-populated even - /// if the TUI did not witness the original spawn events. - /// - /// The loaded-thread list is fetched in full (no pagination) and the spawn tree is walked - /// by `find_loaded_subagent_threads_for_primary`. Each discovered subagent is registered via - /// `upsert_agent_picker_thread`, which writes to both `AgentNavigationState` and the - /// `ChatWidget` metadata map. - async fn backfill_loaded_subagent_threads( - &mut self, - app_server: &mut AppServerSession, - ) -> bool { - let Some(primary_thread_id) = self.primary_thread_id else { - return false; - }; - - let loaded_thread_ids = match app_server - .thread_loaded_list(ThreadLoadedListParams { - cursor: None, - limit: None, - }) - .await - { - Ok(response) => response.data, - Err(err) => { - tracing::warn!(%err, "failed to list loaded threads for subagent backfill"); - return false; - } - }; - - let mut threads = Vec::new(); - let mut had_read_error = false; - for thread_id in loaded_thread_ids { - let Ok(thread_id) = ThreadId::from_string(&thread_id) else { - tracing::warn!("ignoring loaded thread with invalid id during subagent backfill"); - continue; - }; - - if thread_id == primary_thread_id { - continue; - } - - match app_server - .thread_read(thread_id, /*include_turns*/ false) - .await - { - Ok(thread) => threads.push(thread), - Err(err) => { - had_read_error = true; - tracing::warn!(thread_id = %thread_id, %err, "failed to read loaded thread"); - } - } - } - - for thread in find_loaded_subagent_threads_for_primary(threads, primary_thread_id) { - self.upsert_agent_picker_thread( - thread.thread_id, - thread.agent_nickname, - thread.agent_role, - /*is_closed*/ false, - ); - } - - !had_read_error - } - - /// Returns the adjacent thread id for keyboard navigation, backfilling from the server if the - /// local cache has no neighbor. - /// - /// Tries the fast path first: ask `AgentNavigationState` directly. If it returns `None` (no - /// adjacent entry exists, typically because the cache was never populated with remote - /// subagents), performs a full `backfill_loaded_subagent_threads` and retries. This ensures the - /// first next/previous keypress in a resumed remote session discovers subagents on demand - /// without requiring the user to wait for a proactive fetch. - async fn adjacent_thread_id_with_backfill( - &mut self, - app_server: &mut AppServerSession, - direction: AgentNavigationDirection, - ) -> Option { - let current_thread = self.current_displayed_thread_id(); - if let Some(thread_id) = self - .agent_navigation - .adjacent_thread_id(current_thread, direction) - { - return Some(thread_id); - } - - let primary_thread_id = self.primary_thread_id?; - if self.last_subagent_backfill_attempt == Some(primary_thread_id) { - return None; - } - - if self.backfill_loaded_subagent_threads(app_server).await { - self.last_subagent_backfill_attempt = Some(primary_thread_id); - } - self.agent_navigation - .adjacent_thread_id(self.current_displayed_thread_id(), direction) - } - - fn fresh_session_config(&self) -> Config { - let mut config = self.config.clone(); - config.service_tier = self.chat_widget.current_service_tier(); - config - } - - async fn drain_active_thread_events(&mut self, tui: &mut tui::Tui) -> Result<()> { - let Some(mut rx) = self.active_thread_rx.take() else { - return Ok(()); - }; - - let mut disconnected = false; - loop { - match rx.try_recv() { - Ok(event) => self.handle_thread_event_now(event), - Err(TryRecvError::Empty) => break, - Err(TryRecvError::Disconnected) => { - disconnected = true; - break; - } - } - } - - if !disconnected { - self.active_thread_rx = Some(rx); - } else { - self.clear_active_thread().await; - } - - if self.backtrack_render_pending { - tui.frame_requester().schedule_frame(); - } - Ok(()) - } - - /// Returns `(closed_thread_id, primary_thread_id)` when a non-primary active - /// thread has died and we should fail over to the primary thread. - /// - /// A user-requested shutdown (`ExitMode::ShutdownFirst`) sets - /// `pending_shutdown_exit_thread_id`; matching shutdown completions are ignored - /// here so Ctrl+C-like exits don't accidentally resurrect the main thread. - /// - /// Failover is only eligible when all of these are true: - /// 1. the event is `thread/closed`; - /// 2. the active thread differs from the primary thread; - /// 3. the active thread is not the pending shutdown-exit thread. - fn active_non_primary_shutdown_target( - &self, - notification: &ServerNotification, - ) -> Option<(ThreadId, ThreadId)> { - if !matches!(notification, ServerNotification::ThreadClosed(_)) { - return None; - } - let active_thread_id = self.active_thread_id?; - let primary_thread_id = self.primary_thread_id?; - if self.pending_shutdown_exit_thread_id == Some(active_thread_id) { - return None; - } - (active_thread_id != primary_thread_id).then_some((active_thread_id, primary_thread_id)) - } - - fn replay_thread_snapshot( - &mut self, - snapshot: ThreadEventSnapshot, - resume_restored_queue: bool, - ) { - let suppress_replay_notices = - replay_filter::snapshot_has_pending_interactive_request(&snapshot); - if let Some(session) = snapshot.session { - if self.side_threads.contains_key(&session.thread_id) { - self.chat_widget.handle_side_thread_session(session); - } else if suppress_replay_notices { - self.chat_widget.handle_thread_session_quiet(session); - } else { - self.chat_widget.handle_thread_session(session); - } - } - self.chat_widget - .set_queue_autosend_suppressed(/*suppressed*/ true); - self.chat_widget - .restore_thread_input_state(snapshot.input_state); - if !snapshot.turns.is_empty() { - self.chat_widget - .replay_thread_turns(snapshot.turns, ReplayKind::ThreadSnapshot); - } - for event in snapshot.events { - if suppress_replay_notices && replay_filter::event_is_notice(&event) { - continue; - } - self.handle_thread_event_replay(event); - } - self.chat_widget - .set_queue_autosend_suppressed(/*suppressed*/ false); - self.chat_widget - .set_initial_user_message_submit_suppressed(/*suppressed*/ false); - self.chat_widget.submit_initial_user_message_if_pending(); - if resume_restored_queue { - self.chat_widget.maybe_send_next_queued_input(); - } - self.refresh_status_line(); - } - - fn should_wait_for_initial_session(session_selection: &SessionSelection) -> bool { - matches!( - session_selection, - SessionSelection::StartFresh | SessionSelection::Exit - ) - } - - fn should_handle_active_thread_events( - waiting_for_initial_session_configured: bool, - has_active_thread_receiver: bool, - ) -> bool { - has_active_thread_receiver && !waiting_for_initial_session_configured - } - - fn should_stop_waiting_for_initial_session( - waiting_for_initial_session_configured: bool, - primary_thread_id: Option, - ) -> bool { - waiting_for_initial_session_configured && primary_thread_id.is_some() - } - #[allow(clippy::too_many_arguments)] pub async fn run( tui: &mut tui::Tui, @@ -4543,2501 +1142,6 @@ impl App { } Ok(AppRunControl::Continue) } - - async fn resume_target_session( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - target_session: SessionTarget, - ) -> Result { - if self.ignore_same_thread_resume(&target_session) { - tui.frame_requester().schedule_frame(); - return Ok(AppRunControl::Continue); - } - - let current_cwd = self.config.cwd.to_path_buf(); - let resume_cwd = if self.remote_app_server_url.is_some() { - current_cwd.clone() - } else { - match crate::resolve_cwd_for_resume_or_fork( - tui, - &self.config, - ¤t_cwd, - target_session.thread_id, - target_session.path.as_deref(), - CwdPromptAction::Resume, - /*allow_prompt*/ true, - ) - .await? - { - crate::ResolveCwdOutcome::Continue(Some(cwd)) => cwd, - crate::ResolveCwdOutcome::Continue(None) => current_cwd.clone(), - crate::ResolveCwdOutcome::Exit => { - return Ok(AppRunControl::Exit(ExitReason::UserRequested)); - } - } - }; - - let mut resume_config = match self - .rebuild_config_for_resume_or_fallback(¤t_cwd, resume_cwd) - .await - { - Ok(cfg) => cfg, - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to rebuild configuration for resume: {err}" - )); - return Ok(AppRunControl::Continue); - } - }; - self.apply_runtime_policy_overrides(&mut resume_config); - - let summary = session_summary( - self.chat_widget.token_usage(), - self.chat_widget.thread_id(), - self.chat_widget.thread_name(), - self.chat_widget.rollout_path().as_deref(), - ); - match app_server - .resume_thread(resume_config.clone(), target_session.thread_id) - .await - { - Ok(resumed) => { - self.shutdown_current_thread(app_server).await; - self.config = resume_config; - tui.set_notification_settings( - self.config.tui_notifications.method, - self.config.tui_notifications.condition, - ); - self.file_search - .update_search_dir(self.config.cwd.to_path_buf()); - match self - .replace_chat_widget_with_app_server_thread( - tui, app_server, resumed, /*initial_user_message*/ None, - ) - .await - { - Ok(()) => { - if let Some(summary) = summary { - let mut lines: Vec> = Vec::new(); - if let Some(usage_line) = summary.usage_line { - lines.push(usage_line.into()); - } - if let Some(command) = summary.resume_command { - let spans = - vec!["To continue this session, run ".into(), command.cyan()]; - lines.push(spans.into()); - } - self.chat_widget.add_plain_history_lines(lines); - } - } - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to attach to resumed app-server thread: {err}" - )); - } - } - } - Err(err) => { - let path_display = target_session.display_label(); - self.chat_widget.add_error_message(format!( - "Failed to resume session from {path_display}: {err}" - )); - } - } - - Ok(AppRunControl::Continue) - } - - async fn handle_event( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - event: AppEvent, - ) -> Result { - match event { - AppEvent::NewSession => { - self.start_fresh_session_with_summary_hint( - tui, app_server, /*session_start_source*/ None, - /*initial_user_message*/ None, - ) - .await; - } - AppEvent::ClearUi => { - self.clear_terminal_ui(tui, /*redraw_header*/ false)?; - self.reset_app_ui_state_after_clear(); - - self.start_fresh_session_with_summary_hint( - tui, - app_server, - Some(ThreadStartSource::Clear), - /*initial_user_message*/ None, - ) - .await; - } - AppEvent::ClearUiAndSubmitUserMessage { text } => { - self.clear_terminal_ui(tui, /*redraw_header*/ false)?; - self.reset_app_ui_state_after_clear(); - - self.start_fresh_session_with_summary_hint( - tui, - app_server, - Some(ThreadStartSource::Clear), - crate::chatwidget::create_initial_user_message( - Some(text), - Vec::new(), - Vec::new(), - ), - ) - .await; - } - AppEvent::OpenResumePicker => { - let picker_app_server = match crate::start_app_server_for_picker( - &self.config, - &match self.remote_app_server_url.clone() { - Some(websocket_url) => crate::AppServerTarget::Remote { - websocket_url, - auth_token: self.remote_app_server_auth_token.clone(), - }, - None => crate::AppServerTarget::Embedded, - }, - self.environment_manager.clone(), - ) - .await - { - Ok(app_server) => app_server, - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to start TUI session picker: {err}" - )); - return Ok(AppRunControl::Continue); - } - }; - match crate::resume_picker::run_resume_picker_with_app_server( - tui, - &self.config, - /*show_all*/ false, - /*include_non_interactive*/ false, - picker_app_server, - ) - .await? - { - SessionSelection::Resume(target_session) => { - match self - .resume_target_session(tui, app_server, target_session) - .await? - { - AppRunControl::Continue => {} - AppRunControl::Exit(reason) => { - return Ok(AppRunControl::Exit(reason)); - } - } - } - SessionSelection::Exit - | SessionSelection::StartFresh - | SessionSelection::Fork(_) => {} - } - - // Leaving alt-screen may blank the inline viewport; force a redraw either way. - tui.frame_requester().schedule_frame(); - } - AppEvent::ResumeSessionByIdOrName(id_or_name) => { - match crate::lookup_session_target_with_app_server(app_server, &id_or_name).await? { - Some(target_session) => { - return self - .resume_target_session(tui, app_server, target_session) - .await; - } - None => { - self.chat_widget.add_error_message(format!( - "No saved chat found matching '{id_or_name}'." - )); - } - } - } - AppEvent::ForkCurrentSession => { - self.session_telemetry.counter( - "codex.thread.fork", - /*inc*/ 1, - &[("source", "slash_command")], - ); - let summary = session_summary( - self.chat_widget.token_usage(), - self.chat_widget.thread_id(), - self.chat_widget.thread_name(), - self.chat_widget.rollout_path().as_deref(), - ); - self.chat_widget - .add_plain_history_lines(vec!["/fork".magenta().into()]); - if let Some(thread_id) = self.chat_widget.thread_id() { - self.refresh_in_memory_config_from_disk_best_effort("forking the thread") - .await; - match app_server.fork_thread(self.config.clone(), thread_id).await { - Ok(forked) => { - self.shutdown_current_thread(app_server).await; - match self - .replace_chat_widget_with_app_server_thread( - tui, app_server, forked, /*initial_user_message*/ None, - ) - .await - { - Ok(()) => { - if let Some(summary) = summary { - let mut lines: Vec> = Vec::new(); - if let Some(usage_line) = summary.usage_line { - lines.push(usage_line.into()); - } - if let Some(command) = summary.resume_command { - let spans = vec![ - "To continue this session, run ".into(), - command.cyan(), - ]; - lines.push(spans.into()); - } - self.chat_widget.add_plain_history_lines(lines); - } - } - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to attach to forked app-server thread: {err}" - )); - } - } - } - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to fork current session through the app server: {err}" - )); - } - } - } else { - self.chat_widget.add_error_message( - "A thread must contain at least one turn before it can be forked." - .to_string(), - ); - } - - tui.frame_requester().schedule_frame(); - } - AppEvent::InsertHistoryCell(cell) => { - let cell: Arc = cell.into(); - if let Some(Overlay::Transcript(t)) = &mut self.overlay { - t.insert_cell(cell.clone()); - tui.frame_requester().schedule_frame(); - } - self.transcript_cells.push(cell.clone()); - let mut display = cell.display_lines(tui.terminal.last_known_screen_size.width); - if !display.is_empty() { - // Only insert a separating blank line for new cells that are not - // part of an ongoing stream. Streaming continuations should not - // accrue extra blank lines between chunks. - if !cell.is_stream_continuation() { - if self.has_emitted_history_lines { - display.insert(0, Line::from("")); - } else { - self.has_emitted_history_lines = true; - } - } - if self.overlay.is_some() { - self.deferred_history_lines.extend(display); - } else { - tui.insert_history_lines(display); - } - } - } - AppEvent::ApplyThreadRollback { num_turns } => { - if self.apply_non_pending_thread_rollback(num_turns) { - tui.frame_requester().schedule_frame(); - } - } - AppEvent::StartCommitAnimation => { - if self - .commit_anim_running - .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) - .is_ok() - { - let tx = self.app_event_tx.clone(); - let running = self.commit_anim_running.clone(); - thread::spawn(move || { - while running.load(Ordering::Relaxed) { - thread::sleep(COMMIT_ANIMATION_TICK); - tx.send(AppEvent::CommitTick); - } - }); - } - } - AppEvent::StopCommitAnimation => { - self.commit_anim_running.store(false, Ordering::Release); - } - AppEvent::CommitTick => { - self.chat_widget.on_commit_tick(); - } - AppEvent::Exit(mode) => { - return Ok(self.handle_exit_mode(app_server, mode).await); - } - AppEvent::Logout => match app_server.logout_account().await { - Ok(()) => { - return Ok(self - .handle_exit_mode(app_server, ExitMode::ShutdownFirst) - .await); - } - Err(err) => { - tracing::error!("failed to logout: {err}"); - self.chat_widget - .add_error_message(format!("Logout failed: {err}")); - } - }, - AppEvent::FatalExitRequest(message) => { - return Ok(AppRunControl::Exit(ExitReason::Fatal(message))); - } - AppEvent::CodexOp(op) => { - self.submit_active_thread_op(app_server, op.into()).await?; - } - AppEvent::SubmitThreadOp { thread_id, op } => { - self.submit_thread_op(app_server, thread_id, op.into()) - .await?; - } - AppEvent::ThreadHistoryEntryResponse { thread_id, event } => { - self.enqueue_thread_history_entry_response(thread_id, event) - .await?; - } - AppEvent::DiffResult(text) => { - // Clear the in-progress state in the bottom pane - self.chat_widget.on_diff_complete(); - // Enter alternate screen using TUI helper and build pager lines - let _ = tui.enter_alt_screen(); - let pager_lines: Vec> = if text.trim().is_empty() { - vec!["No changes detected.".italic().into()] - } else { - text.lines().map(ansi_escape_line).collect() - }; - self.overlay = Some(Overlay::new_static_with_lines( - pager_lines, - "D I F F".to_string(), - )); - tui.frame_requester().schedule_frame(); - } - AppEvent::OpenAppLink { - app_id, - title, - description, - instructions, - url, - is_installed, - is_enabled, - } => { - self.chat_widget - .open_app_link_view(crate::bottom_pane::AppLinkViewParams { - app_id, - title, - description, - instructions, - url, - is_installed, - is_enabled, - suggest_reason: None, - suggestion_type: None, - elicitation_target: None, - }); - } - AppEvent::OpenUrlInBrowser { url } => { - self.open_url_in_browser(url); - } - AppEvent::RefreshConnectors { force_refetch } => { - self.chat_widget.refresh_connectors(force_refetch); - } - AppEvent::PluginInstallAuthAdvance { refresh_connectors } => { - if refresh_connectors { - self.chat_widget.refresh_connectors(/*force_refetch*/ true); - } - self.chat_widget.advance_plugin_install_auth_flow(); - } - AppEvent::PluginInstallAuthAbandon => { - self.chat_widget.abandon_plugin_install_auth_flow(); - } - AppEvent::FetchPluginsList { cwd } => { - self.fetch_plugins_list(app_server, cwd); - } - AppEvent::OpenPluginDetailLoading { - plugin_display_name, - } => { - self.chat_widget - .open_plugin_detail_loading_popup(&plugin_display_name); - } - AppEvent::OpenPluginInstallLoading { - plugin_display_name, - } => { - self.chat_widget - .open_plugin_install_loading_popup(&plugin_display_name); - } - AppEvent::OpenPluginUninstallLoading { - plugin_display_name, - } => { - self.chat_widget - .open_plugin_uninstall_loading_popup(&plugin_display_name); - } - AppEvent::PluginsLoaded { cwd, result } => { - self.chat_widget.on_plugins_loaded(cwd, result); - } - AppEvent::FetchPluginDetail { cwd, params } => { - self.fetch_plugin_detail(app_server, cwd, params); - } - AppEvent::PluginDetailLoaded { cwd, result } => { - self.chat_widget.on_plugin_detail_loaded(cwd, result); - } - AppEvent::FetchPluginInstall { - cwd, - marketplace_path, - plugin_name, - plugin_display_name, - } => { - self.fetch_plugin_install( - app_server, - cwd, - marketplace_path, - plugin_name, - plugin_display_name, - ); - } - AppEvent::FetchPluginUninstall { - cwd, - plugin_id, - plugin_display_name, - } => { - self.fetch_plugin_uninstall(app_server, cwd, plugin_id, plugin_display_name); - } - AppEvent::SetPluginEnabled { - cwd, - plugin_id, - enabled, - } => { - self.set_plugin_enabled(app_server, cwd, plugin_id, enabled); - } - AppEvent::PluginInstallLoaded { - cwd, - marketplace_path, - plugin_name, - plugin_display_name, - result, - } => { - let install_succeeded = result.is_ok(); - if install_succeeded { - if let Err(err) = self.refresh_in_memory_config_from_disk().await { - tracing::warn!(error = %err, "failed to refresh config after plugin install"); - } - self.chat_widget.refresh_plugin_mentions(); - self.chat_widget.submit_op(AppCommand::reload_user_config()); - } - let should_refresh_plugin_detail = self.chat_widget.on_plugin_install_loaded( - cwd.clone(), - marketplace_path.clone(), - plugin_name.clone(), - plugin_display_name, - result, - ); - if install_succeeded && self.chat_widget.config_ref().cwd.as_path() == cwd.as_path() - { - self.fetch_plugins_list(app_server, cwd.clone()); - if should_refresh_plugin_detail { - self.fetch_plugin_detail( - app_server, - cwd, - PluginReadParams { - marketplace_path: Some(marketplace_path), - remote_marketplace_name: None, - plugin_name, - }, - ); - } - } - } - AppEvent::PluginEnabledSet { - cwd, - plugin_id, - enabled, - result, - } => { - let queued_enabled = self - .pending_plugin_enabled_writes - .get_mut(&plugin_id) - .and_then(Option::take); - let should_apply_result = if let Some(queued_enabled) = queued_enabled - && (result.is_err() || queued_enabled != enabled) - { - self.spawn_plugin_enabled_write( - app_server, - cwd.clone(), - plugin_id.clone(), - queued_enabled, - ); - false - } else { - true - }; - if should_apply_result { - self.pending_plugin_enabled_writes.remove(&plugin_id); - let update_succeeded = result.is_ok(); - if update_succeeded { - if let Err(err) = self.refresh_in_memory_config_from_disk().await { - tracing::warn!( - error = %err, - "failed to refresh config after plugin toggle" - ); - } - self.chat_widget.refresh_plugin_mentions(); - self.chat_widget.submit_op(AppCommand::reload_user_config()); - } - self.chat_widget - .on_plugin_enabled_set(cwd, plugin_id, enabled, result); - } - } - AppEvent::FetchMcpInventory { detail } => { - self.fetch_mcp_inventory(app_server, detail); - } - AppEvent::McpInventoryLoaded { result, detail } => { - self.handle_mcp_inventory_result(result, detail); - } - AppEvent::SkillsListLoaded { result } => { - self.handle_skills_list_result( - result.map_err(|err| color_eyre::eyre::eyre!(err)), - "failed to load skills on startup", - ); - } - AppEvent::StartFileSearch(query) => { - self.file_search.on_user_query(query); - } - AppEvent::FileSearchResult { query, matches } => { - self.chat_widget.apply_file_search_result(query, matches); - } - AppEvent::RefreshRateLimits { origin } => { - self.refresh_rate_limits(app_server, origin); - } - AppEvent::SendAddCreditsNudgeEmail { credit_type } => { - if self - .chat_widget - .start_add_credits_nudge_email_request(credit_type) - { - self.send_add_credits_nudge_email(app_server, credit_type); - } - } - AppEvent::AddCreditsNudgeEmailFinished { result } => { - self.chat_widget - .finish_add_credits_nudge_email_request(result); - } - AppEvent::RateLimitsLoaded { origin, result } => match result { - Ok(snapshots) => { - for snapshot in snapshots { - self.chat_widget.on_rate_limit_snapshot(Some(snapshot)); - } - match origin { - RateLimitRefreshOrigin::StartupPrefetch => { - tui.frame_requester().schedule_frame(); - } - RateLimitRefreshOrigin::StatusCommand { request_id } => { - self.chat_widget - .finish_status_rate_limit_refresh(request_id); - } - } - } - Err(err) => { - tracing::warn!("account/rateLimits/read failed during TUI refresh: {err}"); - if let RateLimitRefreshOrigin::StatusCommand { request_id } = origin { - self.chat_widget - .finish_status_rate_limit_refresh(request_id); - } - } - }, - AppEvent::ConnectorsLoaded { result, is_final } => { - self.chat_widget.on_connectors_loaded(result, is_final); - } - AppEvent::UpdateReasoningEffort(effort) => { - self.on_update_reasoning_effort(effort); - } - AppEvent::UpdateModel(model) => { - self.chat_widget.set_model(&model); - } - AppEvent::UpdateCollaborationMode(mask) => { - self.chat_widget.set_collaboration_mask(mask); - } - AppEvent::UpdatePersonality(personality) => { - self.on_update_personality(personality); - } - AppEvent::OpenRealtimeAudioDeviceSelection { kind } => { - self.chat_widget.open_realtime_audio_device_selection(kind); - } - AppEvent::RealtimeWebrtcOfferCreated { result } => { - self.chat_widget.on_realtime_webrtc_offer_created(result); - } - AppEvent::RealtimeWebrtcEvent(event) => { - self.chat_widget.on_realtime_webrtc_event(event); - } - AppEvent::RealtimeWebrtcLocalAudioLevel(peak) => { - self.chat_widget.on_realtime_webrtc_local_audio_level(peak); - } - AppEvent::OpenReasoningPopup { model } => { - self.chat_widget.open_reasoning_popup(model); - } - AppEvent::OpenPlanReasoningScopePrompt { model, effort } => { - self.chat_widget - .open_plan_reasoning_scope_prompt(model, effort); - } - AppEvent::OpenAllModelsPopup { models } => { - self.chat_widget.open_all_models_popup(models); - } - AppEvent::OpenFullAccessConfirmation { - preset, - return_to_permissions, - } => { - self.chat_widget - .open_full_access_confirmation(preset, return_to_permissions); - } - AppEvent::OpenWorldWritableWarningConfirmation { - preset, - sample_paths, - extra_count, - failed_scan, - } => { - self.chat_widget.open_world_writable_warning_confirmation( - preset, - sample_paths, - extra_count, - failed_scan, - ); - } - AppEvent::OpenFeedbackNote { - category, - include_logs, - } => { - self.chat_widget.open_feedback_note(category, include_logs); - } - AppEvent::OpenFeedbackConsent { category } => { - self.chat_widget.open_feedback_consent(category); - } - AppEvent::SubmitFeedback { - category, - reason, - turn_id, - include_logs, - } => { - self.submit_feedback(app_server, category, reason, turn_id, include_logs); - } - AppEvent::FeedbackSubmitted { - origin_thread_id, - category, - include_logs, - result, - } => { - self.handle_feedback_submitted(origin_thread_id, category, include_logs, result) - .await; - } - AppEvent::LaunchExternalEditor => { - if self.chat_widget.external_editor_state() == ExternalEditorState::Active { - self.launch_external_editor(tui).await; - } - } - AppEvent::OpenWindowsSandboxEnablePrompt { preset } => { - self.chat_widget.open_windows_sandbox_enable_prompt(preset); - } - AppEvent::OpenWindowsSandboxFallbackPrompt { preset } => { - self.session_telemetry.counter( - "codex.windows_sandbox.fallback_prompt_shown", - /*inc*/ 1, - &[], - ); - self.chat_widget.clear_windows_sandbox_setup_status(); - if let Some(started_at) = self.windows_sandbox.setup_started_at.take() { - self.session_telemetry.record_duration( - "codex.windows_sandbox.elevated_setup_duration_ms", - started_at.elapsed(), - &[("result", "failure")], - ); - } - self.chat_widget - .open_windows_sandbox_fallback_prompt(preset); - } - AppEvent::BeginWindowsSandboxElevatedSetup { preset } => { - #[cfg(target_os = "windows")] - { - let policy = preset.sandbox.clone(); - let policy_cwd = self.config.cwd.clone(); - let command_cwd = policy_cwd.clone(); - let env_map: std::collections::HashMap = - std::env::vars().collect(); - let codex_home = self.config.codex_home.clone(); - let tx = self.app_event_tx.clone(); - - // If the elevated setup already ran on this machine, don't prompt for - // elevation again - just flip the config to use the elevated path. - if crate::legacy_core::windows_sandbox::sandbox_setup_is_complete( - codex_home.as_path(), - ) { - tx.send(AppEvent::EnableWindowsSandboxForAgentMode { - preset, - mode: WindowsSandboxEnableMode::Elevated, - }); - return Ok(AppRunControl::Continue); - } - - self.chat_widget.show_windows_sandbox_setup_status(); - self.windows_sandbox.setup_started_at = Some(Instant::now()); - let session_telemetry = self.session_telemetry.clone(); - tokio::task::spawn_blocking(move || { - let result = crate::legacy_core::windows_sandbox::run_elevated_setup( - &policy, - policy_cwd.as_path(), - command_cwd.as_path(), - &env_map, - codex_home.as_path(), - ); - let event = match result { - Ok(()) => { - session_telemetry.counter( - "codex.windows_sandbox.elevated_setup_success", - /*inc*/ 1, - &[], - ); - AppEvent::EnableWindowsSandboxForAgentMode { - preset: preset.clone(), - mode: WindowsSandboxEnableMode::Elevated, - } - } - Err(err) => { - let mut code_tag: Option = None; - let mut message_tag: Option = None; - if let Some((code, message)) = - crate::legacy_core::windows_sandbox::elevated_setup_failure_details( - &err, - ) - { - code_tag = Some(code); - message_tag = Some(message); - } - let mut tags: Vec<(&str, &str)> = Vec::new(); - if let Some(code) = code_tag.as_deref() { - tags.push(("code", code)); - } - if let Some(message) = message_tag.as_deref() { - tags.push(("message", message)); - } - session_telemetry.counter( - crate::legacy_core::windows_sandbox::elevated_setup_failure_metric_name( - &err, - ), - /*inc*/ 1, - &tags, - ); - tracing::error!( - error = %err, - "failed to run elevated Windows sandbox setup" - ); - AppEvent::OpenWindowsSandboxFallbackPrompt { preset } - } - }; - tx.send(event); - }); - } - #[cfg(not(target_os = "windows"))] - { - let _ = preset; - } - } - AppEvent::BeginWindowsSandboxLegacySetup { preset } => { - #[cfg(target_os = "windows")] - { - let policy = preset.sandbox.clone(); - let policy_cwd = self.config.cwd.clone(); - let command_cwd = policy_cwd.clone(); - let env_map: std::collections::HashMap = - std::env::vars().collect(); - let codex_home = self.config.codex_home.clone(); - let tx = self.app_event_tx.clone(); - let session_telemetry = self.session_telemetry.clone(); - - self.chat_widget.show_windows_sandbox_setup_status(); - tokio::task::spawn_blocking(move || { - if let Err(err) = - crate::legacy_core::windows_sandbox::run_legacy_setup_preflight( - &policy, - policy_cwd.as_path(), - command_cwd.as_path(), - &env_map, - codex_home.as_path(), - ) - { - session_telemetry.counter( - "codex.windows_sandbox.legacy_setup_preflight_failed", - /*inc*/ 1, - &[], - ); - tracing::warn!( - error = %err, - "failed to preflight non-admin Windows sandbox setup" - ); - } - tx.send(AppEvent::EnableWindowsSandboxForAgentMode { - preset, - mode: WindowsSandboxEnableMode::Legacy, - }); - }); - } - #[cfg(not(target_os = "windows"))] - { - let _ = preset; - } - } - AppEvent::BeginWindowsSandboxGrantReadRoot { path } => { - #[cfg(target_os = "windows")] - { - self.chat_widget - .add_to_history(history_cell::new_info_event( - format!("Granting sandbox read access to {path} ..."), - /*hint*/ None, - )); - - let policy = self.config.permissions.sandbox_policy.get().clone(); - let policy_cwd = self.config.cwd.clone(); - let command_cwd = self.config.cwd.clone(); - let env_map: std::collections::HashMap = - std::env::vars().collect(); - let codex_home = self.config.codex_home.clone(); - let tx = self.app_event_tx.clone(); - - tokio::task::spawn_blocking(move || { - let requested_path = PathBuf::from(path); - let event = match crate::legacy_core::grant_read_root_non_elevated( - &policy, - policy_cwd.as_path(), - command_cwd.as_path(), - &env_map, - codex_home.as_path(), - requested_path.as_path(), - ) { - Ok(canonical_path) => AppEvent::WindowsSandboxGrantReadRootCompleted { - path: canonical_path, - error: None, - }, - Err(err) => AppEvent::WindowsSandboxGrantReadRootCompleted { - path: requested_path, - error: Some(err.to_string()), - }, - }; - tx.send(event); - }); - } - #[cfg(not(target_os = "windows"))] - { - let _ = path; - } - } - AppEvent::WindowsSandboxGrantReadRootCompleted { path, error } => match error { - Some(err) => { - self.chat_widget - .add_to_history(history_cell::new_error_event(format!("Error: {err}"))); - } - None => { - self.chat_widget - .add_to_history(history_cell::new_info_event( - format!("Sandbox read access granted for {}", path.display()), - /*hint*/ None, - )); - } - }, - AppEvent::EnableWindowsSandboxForAgentMode { preset, mode } => { - #[cfg(target_os = "windows")] - { - self.chat_widget.clear_windows_sandbox_setup_status(); - if let Some(started_at) = self.windows_sandbox.setup_started_at.take() { - self.session_telemetry.record_duration( - "codex.windows_sandbox.elevated_setup_duration_ms", - started_at.elapsed(), - &[("result", "success")], - ); - } - let profile = self.active_profile.as_deref(); - let elevated_enabled = matches!(mode, WindowsSandboxEnableMode::Elevated); - let builder = ConfigEditsBuilder::new(&self.config.codex_home) - .with_profile(profile) - .set_windows_sandbox_mode(if elevated_enabled { - "elevated" - } else { - "unelevated" - }) - .clear_legacy_windows_sandbox_keys(); - match builder.apply().await { - Ok(()) => { - if elevated_enabled { - self.config.set_windows_sandbox_enabled(/*value*/ false); - self.config - .set_windows_elevated_sandbox_enabled(/*value*/ true); - } else { - self.config.set_windows_sandbox_enabled(/*value*/ true); - self.config - .set_windows_elevated_sandbox_enabled(/*value*/ false); - } - self.chat_widget.set_windows_sandbox_mode( - self.config.permissions.windows_sandbox_mode, - ); - let windows_sandbox_level = - WindowsSandboxLevel::from_config(&self.config); - if let Some((sample_paths, extra_count, failed_scan)) = - self.chat_widget.world_writable_warning_details() - { - self.app_event_tx.send(AppEvent::CodexOp( - AppCommand::override_turn_context( - /*cwd*/ None, - /*approval_policy*/ None, - /*approvals_reviewer*/ None, - /*sandbox_policy*/ None, - #[cfg(target_os = "windows")] - Some(windows_sandbox_level), - /*model*/ None, - /*effort*/ None, - /*summary*/ None, - /*service_tier*/ None, - /*collaboration_mode*/ None, - /*personality*/ None, - ) - .into(), - )); - self.app_event_tx.send( - AppEvent::OpenWorldWritableWarningConfirmation { - preset: Some(preset.clone()), - sample_paths, - extra_count, - failed_scan, - }, - ); - } else { - self.app_event_tx.send(AppEvent::CodexOp( - AppCommand::override_turn_context( - /*cwd*/ None, - Some(preset.approval), - Some(self.config.approvals_reviewer), - Some(preset.sandbox.clone()), - #[cfg(target_os = "windows")] - Some(windows_sandbox_level), - /*model*/ None, - /*effort*/ None, - /*summary*/ None, - /*service_tier*/ None, - /*collaboration_mode*/ None, - /*personality*/ None, - ) - .into(), - )); - self.app_event_tx - .send(AppEvent::UpdateAskForApprovalPolicy(preset.approval)); - self.app_event_tx - .send(AppEvent::UpdateSandboxPolicy(preset.sandbox.clone())); - let _ = mode; - self.chat_widget.add_plain_history_lines(vec![ - Line::from(vec!["• ".dim(), "Sandbox ready".into()]), - Line::from(vec![ - " ".into(), - "Codex can now safely edit files and execute commands in your computer" - .dark_gray(), - ]), - ]); - } - } - Err(err) => { - tracing::error!( - error = %err, - "failed to enable Windows sandbox feature" - ); - self.chat_widget.add_error_message(format!( - "Failed to enable the Windows sandbox feature: {err}" - )); - } - } - } - #[cfg(not(target_os = "windows"))] - { - let _ = (preset, mode); - } - } - AppEvent::PersistModelSelection { model, effort } => { - let profile = self.active_profile.as_deref(); - match ConfigEditsBuilder::new(&self.config.codex_home) - .with_profile(profile) - .set_model(Some(model.as_str()), effort) - .apply() - .await - { - Ok(()) => { - let effort_label = effort - .map(|selected_effort| selected_effort.to_string()) - .unwrap_or_else(|| "default".to_string()); - tracing::info!("Selected model: {model}, Selected effort: {effort_label}"); - let mut message = format!("Model changed to {model}"); - if let Some(label) = Self::reasoning_label_for(&model, effort) { - message.push(' '); - message.push_str(label); - } - if let Some(profile) = profile { - message.push_str(" for "); - message.push_str(profile); - message.push_str(" profile"); - } - self.chat_widget.add_info_message(message, /*hint*/ None); - } - Err(err) => { - tracing::error!( - error = %err, - "failed to persist model selection" - ); - if let Some(profile) = profile { - self.chat_widget.add_error_message(format!( - "Failed to save model for profile `{profile}`: {err}" - )); - } else { - self.chat_widget - .add_error_message(format!("Failed to save default model: {err}")); - } - } - } - } - AppEvent::PluginUninstallLoaded { - cwd, - plugin_id: _plugin_id, - plugin_display_name, - result, - } => { - let uninstall_succeeded = result.is_ok(); - if uninstall_succeeded { - if let Err(err) = self.refresh_in_memory_config_from_disk().await { - tracing::warn!( - error = %err, - "failed to refresh config after plugin uninstall" - ); - } - self.chat_widget.refresh_plugin_mentions(); - self.chat_widget.submit_op(AppCommand::reload_user_config()); - } - self.chat_widget.on_plugin_uninstall_loaded( - cwd.clone(), - plugin_display_name, - result, - ); - if uninstall_succeeded - && self.chat_widget.config_ref().cwd.as_path() == cwd.as_path() - { - self.fetch_plugins_list(app_server, cwd); - } - } - AppEvent::RefreshPluginMentions => { - self.refresh_plugin_mentions(); - } - AppEvent::PluginMentionsLoaded { mut plugins } => { - if !self.config.features.enabled(Feature::Plugins) { - plugins = None; - } - self.chat_widget.on_plugin_mentions_loaded(plugins); - } - AppEvent::PersistPersonalitySelection { personality } => { - let profile = self.active_profile.as_deref(); - match ConfigEditsBuilder::new(&self.config.codex_home) - .with_profile(profile) - .set_personality(Some(personality)) - .apply() - .await - { - Ok(()) => { - let label = Self::personality_label(personality); - let mut message = format!("Personality set to {label}"); - if let Some(profile) = profile { - message.push_str(" for "); - message.push_str(profile); - message.push_str(" profile"); - } - self.chat_widget.add_info_message(message, /*hint*/ None); - } - Err(err) => { - tracing::error!( - error = %err, - "failed to persist personality selection" - ); - if let Some(profile) = profile { - self.chat_widget.add_error_message(format!( - "Failed to save personality for profile `{profile}`: {err}" - )); - } else { - self.chat_widget.add_error_message(format!( - "Failed to save default personality: {err}" - )); - } - } - } - } - AppEvent::PersistServiceTierSelection { service_tier } => { - self.refresh_status_line(); - let profile = self.active_profile.as_deref(); - match ConfigEditsBuilder::new(&self.config.codex_home) - .with_profile(profile) - .set_service_tier(service_tier) - .apply() - .await - { - Ok(()) => { - let status = if service_tier.is_some() { "on" } else { "off" }; - let mut message = format!("Fast mode set to {status}"); - if let Some(profile) = profile { - message.push_str(" for "); - message.push_str(profile); - message.push_str(" profile"); - } - self.chat_widget.add_info_message(message, /*hint*/ None); - } - Err(err) => { - tracing::error!(error = %err, "failed to persist fast mode selection"); - if let Some(profile) = profile { - self.chat_widget.add_error_message(format!( - "Failed to save Fast mode for profile `{profile}`: {err}" - )); - } else { - self.chat_widget.add_error_message(format!( - "Failed to save default Fast mode: {err}" - )); - } - } - } - } - AppEvent::PersistRealtimeAudioDeviceSelection { kind, name } => { - let builder = match kind { - RealtimeAudioDeviceKind::Microphone => { - ConfigEditsBuilder::new(&self.config.codex_home) - .set_realtime_microphone(name.as_deref()) - } - RealtimeAudioDeviceKind::Speaker => { - ConfigEditsBuilder::new(&self.config.codex_home) - .set_realtime_speaker(name.as_deref()) - } - }; - - match builder.apply().await { - Ok(()) => { - match kind { - RealtimeAudioDeviceKind::Microphone => { - self.config.realtime_audio.microphone = name.clone(); - } - RealtimeAudioDeviceKind::Speaker => { - self.config.realtime_audio.speaker = name.clone(); - } - } - self.chat_widget - .set_realtime_audio_device(kind, name.clone()); - - if self.chat_widget.realtime_conversation_is_live() { - self.chat_widget.open_realtime_audio_restart_prompt(kind); - } else { - let selection = name.unwrap_or_else(|| "System default".to_string()); - self.chat_widget.add_info_message( - format!("Realtime {} set to {selection}", kind.noun()), - /*hint*/ None, - ); - } - } - Err(err) => { - tracing::error!( - error = %err, - "failed to persist realtime audio selection" - ); - self.chat_widget.add_error_message(format!( - "Failed to save realtime {}: {err}", - kind.noun() - )); - } - } - } - AppEvent::RestartRealtimeAudioDevice { kind } => { - self.chat_widget.restart_realtime_audio_device(kind); - } - AppEvent::UpdateAskForApprovalPolicy(policy) => { - let mut config = self.config.clone(); - if !self.try_set_approval_policy_on_config( - &mut config, - policy, - "Failed to set approval policy", - "failed to set approval policy on app config", - ) { - return Ok(AppRunControl::Continue); - } - self.config = config; - self.runtime_approval_policy_override = - Some(self.config.permissions.approval_policy.value()); - self.chat_widget - .set_approval_policy(self.config.permissions.approval_policy.value()); - } - AppEvent::UpdateSandboxPolicy(policy) => { - #[cfg(target_os = "windows")] - let policy_is_workspace_write_or_ro = matches!( - &policy, - codex_protocol::protocol::SandboxPolicy::WorkspaceWrite { .. } - | codex_protocol::protocol::SandboxPolicy::ReadOnly { .. } - ); - let policy_for_chat = policy.clone(); - - let mut config = self.config.clone(); - if !self.try_set_sandbox_policy_on_config( - &mut config, - policy, - "Failed to set sandbox policy", - "failed to set sandbox policy on app config", - ) { - return Ok(AppRunControl::Continue); - } - self.config = config; - if let Err(err) = self.chat_widget.set_sandbox_policy(policy_for_chat) { - tracing::warn!(%err, "failed to set sandbox policy on chat config"); - self.chat_widget - .add_error_message(format!("Failed to set sandbox policy: {err}")); - return Ok(AppRunControl::Continue); - } - self.runtime_sandbox_policy_override = - Some(self.config.permissions.sandbox_policy.get().clone()); - - // If sandbox policy becomes workspace-write or read-only, run the Windows world-writable scan. - #[cfg(target_os = "windows")] - { - // One-shot suppression if the user just confirmed continue. - if self.windows_sandbox.skip_world_writable_scan_once { - self.windows_sandbox.skip_world_writable_scan_once = false; - return Ok(AppRunControl::Continue); - } - - let should_check = WindowsSandboxLevel::from_config(&self.config) - != WindowsSandboxLevel::Disabled - && policy_is_workspace_write_or_ro - && !self.chat_widget.world_writable_warning_hidden(); - if should_check { - let cwd = self.config.cwd.clone(); - let env_map: std::collections::HashMap = - std::env::vars().collect(); - let tx = self.app_event_tx.clone(); - let logs_base_dir = self.config.codex_home.clone(); - let sandbox_policy = self.config.permissions.sandbox_policy.get().clone(); - Self::spawn_world_writable_scan( - cwd, - env_map, - logs_base_dir, - sandbox_policy, - tx, - ); - } - } - } - AppEvent::UpdateApprovalsReviewer(policy) => { - self.config.approvals_reviewer = policy; - self.chat_widget.set_approvals_reviewer(policy); - let profile = self.active_profile.as_deref(); - let segments = if let Some(profile) = profile { - vec![ - "profiles".to_string(), - profile.to_string(), - "approvals_reviewer".to_string(), - ] - } else { - vec!["approvals_reviewer".to_string()] - }; - if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) - .with_profile(profile) - .with_edits([ConfigEdit::SetPath { - segments, - value: policy.to_string().into(), - }]) - .apply() - .await - { - tracing::error!( - error = %err, - "failed to persist approvals reviewer update" - ); - self.chat_widget - .add_error_message(format!("Failed to save approvals reviewer: {err}")); - } - } - AppEvent::UpdateFeatureFlags { updates } => { - self.update_feature_flags(updates).await; - } - AppEvent::UpdateMemorySettings { - use_memories, - generate_memories, - } => { - self.update_memory_settings_with_app_server( - app_server, - use_memories, - generate_memories, - ) - .await; - } - AppEvent::ResetMemories => { - self.reset_memories_with_app_server(app_server).await; - } - AppEvent::SkipNextWorldWritableScan => { - self.windows_sandbox.skip_world_writable_scan_once = true; - } - AppEvent::UpdateFullAccessWarningAcknowledged(ack) => { - self.chat_widget.set_full_access_warning_acknowledged(ack); - } - AppEvent::UpdateWorldWritableWarningAcknowledged(ack) => { - self.chat_widget - .set_world_writable_warning_acknowledged(ack); - } - AppEvent::UpdateRateLimitSwitchPromptHidden(hidden) => { - self.chat_widget.set_rate_limit_switch_prompt_hidden(hidden); - } - AppEvent::UpdatePlanModeReasoningEffort(effort) => { - self.config.plan_mode_reasoning_effort = effort; - self.chat_widget.set_plan_mode_reasoning_effort(effort); - } - AppEvent::PersistFullAccessWarningAcknowledged => { - if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) - .set_hide_full_access_warning(/*acknowledged*/ true) - .apply() - .await - { - tracing::error!( - error = %err, - "failed to persist full access warning acknowledgement" - ); - self.chat_widget.add_error_message(format!( - "Failed to save full access confirmation preference: {err}" - )); - } - } - AppEvent::PersistWorldWritableWarningAcknowledged => { - if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) - .set_hide_world_writable_warning(/*acknowledged*/ true) - .apply() - .await - { - tracing::error!( - error = %err, - "failed to persist world-writable warning acknowledgement" - ); - self.chat_widget.add_error_message(format!( - "Failed to save Agent mode warning preference: {err}" - )); - } - } - AppEvent::PersistRateLimitSwitchPromptHidden => { - if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) - .set_hide_rate_limit_model_nudge(/*acknowledged*/ true) - .apply() - .await - { - tracing::error!( - error = %err, - "failed to persist rate limit switch prompt preference" - ); - self.chat_widget.add_error_message(format!( - "Failed to save rate limit reminder preference: {err}" - )); - } - } - AppEvent::PersistPlanModeReasoningEffort(effort) => { - let profile = self.active_profile.as_deref(); - let segments = if let Some(profile) = profile { - vec![ - "profiles".to_string(), - profile.to_string(), - "plan_mode_reasoning_effort".to_string(), - ] - } else { - vec!["plan_mode_reasoning_effort".to_string()] - }; - let edit = if let Some(effort) = effort { - ConfigEdit::SetPath { - segments, - value: effort.to_string().into(), - } - } else { - ConfigEdit::ClearPath { segments } - }; - if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) - .with_edits([edit]) - .apply() - .await - { - tracing::error!( - error = %err, - "failed to persist plan mode reasoning effort" - ); - if let Some(profile) = profile { - self.chat_widget.add_error_message(format!( - "Failed to save Plan mode reasoning effort for profile `{profile}`: {err}" - )); - } else { - self.chat_widget.add_error_message(format!( - "Failed to save Plan mode reasoning effort: {err}" - )); - } - } - } - AppEvent::PersistModelMigrationPromptAcknowledged { - from_model, - to_model, - } => { - if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) - .record_model_migration_seen(from_model.as_str(), to_model.as_str()) - .apply() - .await - { - tracing::error!( - error = %err, - "failed to persist model migration prompt acknowledgement" - ); - self.chat_widget.add_error_message(format!( - "Failed to save model migration prompt preference: {err}" - )); - } - } - AppEvent::OpenApprovalsPopup => { - self.chat_widget.open_approvals_popup(); - } - AppEvent::OpenAgentPicker => { - self.open_agent_picker(app_server).await; - } - AppEvent::SelectAgentThread(thread_id) => { - self.select_agent_thread_and_discard_side(tui, app_server, thread_id) - .await?; - } - AppEvent::StartSide { - parent_thread_id, - user_message, - } => { - return self - .handle_start_side(tui, app_server, parent_thread_id, user_message) - .await; - } - AppEvent::OpenSkillsList => { - self.chat_widget.open_skills_list(); - } - AppEvent::OpenManageSkillsPopup => { - self.chat_widget.open_manage_skills_popup(); - } - AppEvent::SetSkillEnabled { path, enabled } => { - let edits = [ConfigEdit::SetSkillConfig { - path: path.to_path_buf(), - enabled, - }]; - match ConfigEditsBuilder::new(&self.config.codex_home) - .with_edits(edits) - .apply() - .await - { - Ok(()) => { - self.chat_widget.update_skill_enabled(path, enabled); - if let Err(err) = self.refresh_in_memory_config_from_disk().await { - tracing::warn!( - error = %err, - "failed to refresh config after skill toggle" - ); - } - } - Err(err) => { - let path_display = path.display(); - self.chat_widget.add_error_message(format!( - "Failed to update skill config for {path_display}: {err}" - )); - } - } - } - AppEvent::SetAppEnabled { id, enabled } => { - let edits = if enabled { - vec![ - ConfigEdit::ClearPath { - segments: vec!["apps".to_string(), id.clone(), "enabled".to_string()], - }, - ConfigEdit::ClearPath { - segments: vec![ - "apps".to_string(), - id.clone(), - "disabled_reason".to_string(), - ], - }, - ] - } else { - vec![ - ConfigEdit::SetPath { - segments: vec!["apps".to_string(), id.clone(), "enabled".to_string()], - value: false.into(), - }, - ConfigEdit::SetPath { - segments: vec![ - "apps".to_string(), - id.clone(), - "disabled_reason".to_string(), - ], - value: "user".into(), - }, - ] - }; - match ConfigEditsBuilder::new(&self.config.codex_home) - .with_edits(edits) - .apply() - .await - { - Ok(()) => { - self.chat_widget.update_connector_enabled(&id, enabled); - if let Err(err) = self.refresh_in_memory_config_from_disk().await { - tracing::warn!(error = %err, "failed to refresh config after app toggle"); - } - self.chat_widget.submit_op(AppCommand::reload_user_config()); - } - Err(err) => { - self.chat_widget.add_error_message(format!( - "Failed to update app config for {id}: {err}" - )); - } - } - } - AppEvent::OpenPermissionsPopup => { - self.chat_widget.open_permissions_popup(); - } - AppEvent::OpenReviewBranchPicker(cwd) => { - self.chat_widget.show_review_branch_picker(&cwd).await; - } - AppEvent::OpenReviewCommitPicker(cwd) => { - self.chat_widget.show_review_commit_picker(&cwd).await; - } - AppEvent::OpenReviewCustomPrompt => { - self.chat_widget.show_review_custom_prompt(); - } - AppEvent::SubmitUserMessageWithMode { - text, - collaboration_mode, - } => { - self.chat_widget - .submit_user_message_with_mode(text, collaboration_mode); - } - AppEvent::ManageSkillsClosed => { - self.chat_widget.handle_manage_skills_closed(); - } - AppEvent::FullScreenApprovalRequest(request) => match request { - ApprovalRequest::ApplyPatch { cwd, changes, .. } => { - let _ = tui.enter_alt_screen(); - let diff_summary = DiffSummary::new(changes, cwd); - self.overlay = Some(Overlay::new_static_with_renderables( - vec![diff_summary.into()], - "P A T C H".to_string(), - )); - } - ApprovalRequest::Exec { command, .. } => { - let _ = tui.enter_alt_screen(); - let full_cmd = strip_bash_lc_and_escape(&command); - let full_cmd_lines = highlight_bash_to_lines(&full_cmd); - self.overlay = Some(Overlay::new_static_with_lines( - full_cmd_lines, - "E X E C".to_string(), - )); - } - ApprovalRequest::Permissions { - permissions, - reason, - .. - } => { - let _ = tui.enter_alt_screen(); - let mut lines = Vec::new(); - if let Some(reason) = reason { - lines.push(Line::from(vec!["Reason: ".into(), reason.italic()])); - lines.push(Line::from("")); - } - if let Some(rule_line) = - crate::bottom_pane::format_requested_permissions_rule(&permissions) - { - lines.push(Line::from(vec![ - "Permission rule: ".into(), - rule_line.cyan(), - ])); - } - self.overlay = Some(Overlay::new_static_with_renderables( - vec![Box::new(Paragraph::new(lines).wrap(Wrap { trim: false }))], - "P E R M I S S I O N S".to_string(), - )); - } - ApprovalRequest::McpElicitation { - server_name, - message, - .. - } => { - let _ = tui.enter_alt_screen(); - let paragraph = Paragraph::new(vec![ - Line::from(vec!["Server: ".into(), server_name.bold()]), - Line::from(""), - Line::from(message), - ]) - .wrap(Wrap { trim: false }); - self.overlay = Some(Overlay::new_static_with_renderables( - vec![Box::new(paragraph)], - "E L I C I T A T I O N".to_string(), - )); - } - }, - #[cfg(not(target_os = "linux"))] - AppEvent::UpdateRecordingMeter { id, text } => { - // Update in place to preserve the element id for subsequent frames. - let updated = self.chat_widget.update_recording_meter_in_place(&id, &text); - if updated - || self - .chat_widget - .stop_realtime_conversation_for_deleted_meter(&id) - { - tui.frame_requester().schedule_frame(); - } - } - AppEvent::StatusLineSetup { items } => { - let ids = items.iter().map(ToString::to_string).collect::>(); - let edit = crate::legacy_core::config::edit::status_line_items_edit(&ids); - let apply_result = ConfigEditsBuilder::new(&self.config.codex_home) - .with_edits([edit]) - .apply() - .await; - match apply_result { - Ok(()) => { - self.config.tui_status_line = Some(ids.clone()); - self.chat_widget.setup_status_line(items); - } - Err(err) => { - tracing::error!(error = %err, "failed to persist status line items; keeping previous selection"); - self.chat_widget - .add_error_message(format!("Failed to save status line items: {err}")); - } - } - } - AppEvent::StatusLineBranchUpdated { cwd, branch } => { - self.chat_widget.set_status_line_branch(cwd, branch); - self.refresh_status_line(); - } - AppEvent::StatusLineSetupCancelled => { - self.chat_widget.cancel_status_line_setup(); - } - AppEvent::TerminalTitleSetup { items } => { - let ids = items.iter().map(ToString::to_string).collect::>(); - let edit = crate::legacy_core::config::edit::terminal_title_items_edit(&ids); - let apply_result = ConfigEditsBuilder::new(&self.config.codex_home) - .with_edits([edit]) - .apply() - .await; - match apply_result { - Ok(()) => { - self.config.tui_terminal_title = Some(ids.clone()); - self.chat_widget.setup_terminal_title(items); - } - Err(err) => { - tracing::error!(error = %err, "failed to persist terminal title items; keeping previous selection"); - self.chat_widget.revert_terminal_title_setup_preview(); - self.chat_widget.add_error_message(format!( - "Failed to save terminal title items: {err}" - )); - } - } - } - AppEvent::TerminalTitleSetupPreview { items } => { - self.chat_widget.preview_terminal_title(items); - } - AppEvent::TerminalTitleSetupCancelled => { - self.chat_widget.cancel_terminal_title_setup(); - } - AppEvent::SyntaxThemeSelected { name } => { - let edit = crate::legacy_core::config::edit::syntax_theme_edit(&name); - let apply_result = ConfigEditsBuilder::new(&self.config.codex_home) - .with_edits([edit]) - .apply() - .await; - match apply_result { - Ok(()) => { - // Ensure the selected theme is active in the current - // session. The preview callback covers arrow-key - // navigation, but if the user presses Enter without - // navigating, the runtime theme must still be applied. - if let Some(theme) = crate::render::highlight::resolve_theme_by_name( - &name, - Some(&self.config.codex_home), - ) { - crate::render::highlight::set_syntax_theme(theme); - } - self.sync_tui_theme_selection(name); - } - Err(err) => { - self.restore_runtime_theme_from_config(); - tracing::error!(error = %err, "failed to persist theme selection"); - self.chat_widget - .add_error_message(format!("Failed to save theme: {err}")); - } - } - } - } - Ok(AppRunControl::Continue) - } - - async fn handle_exit_mode( - &mut self, - app_server: &mut AppServerSession, - mode: ExitMode, - ) -> AppRunControl { - match mode { - ExitMode::ShutdownFirst => { - // Mark the thread we are explicitly shutting down for exit so - // its shutdown completion does not trigger agent failover. - self.pending_shutdown_exit_thread_id = - self.active_thread_id.or(self.chat_widget.thread_id()); - if self.pending_shutdown_exit_thread_id.is_some() { - self.shutdown_current_thread(app_server).await; - } - self.pending_shutdown_exit_thread_id = None; - AppRunControl::Exit(ExitReason::UserRequested) - } - ExitMode::Immediate => { - self.pending_shutdown_exit_thread_id = None; - AppRunControl::Exit(ExitReason::UserRequested) - } - } - } - - fn handle_skills_list_response(&mut self, response: SkillsListResponse) { - let response = list_skills_response_to_core(response); - let cwd = self.chat_widget.config_ref().cwd.clone(); - let errors = errors_for_cwd(&cwd, &response); - emit_skill_load_warnings(&self.app_event_tx, &errors); - self.chat_widget.handle_skills_list_response(response); - } - - async fn handle_thread_rollback_response( - &mut self, - thread_id: ThreadId, - num_turns: u32, - response: &ThreadRollbackResponse, - ) { - if let Some(channel) = self.thread_event_channels.get(&thread_id) { - let mut store = channel.store.lock().await; - store.apply_thread_rollback(response); - } - if self.active_thread_id == Some(thread_id) - && let Some(mut rx) = self.active_thread_rx.take() - { - let mut disconnected = false; - loop { - match rx.try_recv() { - Ok(_) => {} - Err(TryRecvError::Empty) => break, - Err(TryRecvError::Disconnected) => { - disconnected = true; - break; - } - } - } - - if !disconnected { - self.active_thread_rx = Some(rx); - } else { - self.clear_active_thread().await; - } - } - self.handle_backtrack_rollback_succeeded(num_turns); - } - - fn handle_thread_event_now(&mut self, event: ThreadBufferedEvent) { - let needs_refresh = matches!( - &event, - ThreadBufferedEvent::Notification(ServerNotification::TurnStarted(_)) - | ThreadBufferedEvent::Notification(ServerNotification::ThreadTokenUsageUpdated(_)) - ); - match event { - ThreadBufferedEvent::Notification(notification) => { - self.chat_widget - .handle_server_notification(notification, /*replay_kind*/ None); - } - ThreadBufferedEvent::Request(request) => { - if self - .pending_app_server_requests - .contains_server_request(&request) - { - self.chat_widget - .handle_server_request(request, /*replay_kind*/ None); - } - } - ThreadBufferedEvent::HistoryEntryResponse(event) => { - self.chat_widget.handle_history_entry_response(event); - } - ThreadBufferedEvent::FeedbackSubmission(event) => { - self.handle_feedback_thread_event(event); - } - } - if needs_refresh { - self.refresh_status_line(); - } - } - - fn handle_thread_event_replay(&mut self, event: ThreadBufferedEvent) { - match event { - ThreadBufferedEvent::Notification(notification) => self - .chat_widget - .handle_server_notification(notification, Some(ReplayKind::ThreadSnapshot)), - ThreadBufferedEvent::Request(request) => self - .chat_widget - .handle_server_request(request, Some(ReplayKind::ThreadSnapshot)), - ThreadBufferedEvent::HistoryEntryResponse(event) => { - self.chat_widget.handle_history_entry_response(event) - } - ThreadBufferedEvent::FeedbackSubmission(event) => { - self.handle_feedback_thread_event(event); - } - } - } - - /// Handles an event emitted by the currently active thread. - /// - /// This function enforces shutdown intent routing: unexpected non-primary - /// thread shutdowns fail over to the primary thread, while user-requested - /// app exits consume only the tracked shutdown completion and then proceed. - async fn handle_active_thread_event( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - event: ThreadBufferedEvent, - ) -> Result<()> { - // Capture this before any potential thread switch: we only want to clear - // the exit marker when the currently active thread acknowledges shutdown. - let pending_shutdown_exit_completed = matches!( - &event, - ThreadBufferedEvent::Notification(ServerNotification::ThreadClosed(_)) - ) && self.pending_shutdown_exit_thread_id - == self.active_thread_id; - - // Processing order matters: - // - // 1. handle unexpected non-primary shutdown failover first; - // 2. clear pending exit marker for matching shutdown; - // 3. forward the event through normal handling. - // - // This preserves the mental model that user-requested exits do not trigger - // failover, while true sub-agent deaths still do. - if let ThreadBufferedEvent::Notification(notification) = &event - && let Some((closed_thread_id, primary_thread_id)) = - self.active_non_primary_shutdown_target(notification) - { - self.mark_agent_picker_thread_closed(closed_thread_id); - if self.side_threads.contains_key(&closed_thread_id) { - self.discard_closed_side_thread(closed_thread_id).await; - self.select_agent_thread(tui, app_server, primary_thread_id) - .await?; - } else { - self.select_agent_thread_and_discard_side(tui, app_server, primary_thread_id) - .await?; - } - if self.active_thread_id == Some(primary_thread_id) { - self.chat_widget.add_info_message( - format!( - "Agent thread {closed_thread_id} closed. Switched back to main thread." - ), - /*hint*/ None, - ); - } else { - self.clear_active_thread().await; - self.chat_widget.add_error_message(format!( - "Agent thread {closed_thread_id} closed. Failed to switch back to main thread {primary_thread_id}.", - )); - } - return Ok(()); - } - - if pending_shutdown_exit_completed { - // Clear only after seeing the shutdown completion for the tracked - // thread, so unrelated shutdowns cannot consume this marker. - self.pending_shutdown_exit_thread_id = None; - } - if let ThreadBufferedEvent::Notification(notification) = &event { - self.hydrate_collab_agent_metadata_for_notification(app_server, notification) - .await; - } - - self.handle_thread_event_now(event); - if self.backtrack_render_pending { - tui.frame_requester().schedule_frame(); - } - Ok(()) - } - - fn reasoning_label(reasoning_effort: Option) -> &'static str { - match reasoning_effort { - Some(ReasoningEffortConfig::Minimal) => "minimal", - Some(ReasoningEffortConfig::Low) => "low", - Some(ReasoningEffortConfig::Medium) => "medium", - Some(ReasoningEffortConfig::High) => "high", - Some(ReasoningEffortConfig::XHigh) => "xhigh", - None | Some(ReasoningEffortConfig::None) => "default", - } - } - - fn reasoning_label_for( - model: &str, - reasoning_effort: Option, - ) -> Option<&'static str> { - (!model.starts_with("codex-auto-")).then(|| Self::reasoning_label(reasoning_effort)) - } - - pub(crate) fn token_usage(&self) -> codex_protocol::protocol::TokenUsage { - self.chat_widget.token_usage() - } - - fn on_update_reasoning_effort(&mut self, effort: Option) { - // TODO(aibrahim): Remove this and don't use config as a state object. - // Instead, explicitly pass the stored collaboration mode's effort into new sessions. - self.config.model_reasoning_effort = effort; - self.chat_widget.set_reasoning_effort(effort); - } - - fn on_update_personality(&mut self, personality: Personality) { - self.config.personality = Some(personality); - self.chat_widget.set_personality(personality); - } - - fn sync_tui_theme_selection(&mut self, name: String) { - self.config.tui_theme = Some(name.clone()); - self.chat_widget.set_tui_theme(Some(name)); - } - - fn restore_runtime_theme_from_config(&self) { - if let Some(name) = self.config.tui_theme.as_deref() - && let Some(theme) = - crate::render::highlight::resolve_theme_by_name(name, Some(&self.config.codex_home)) - { - crate::render::highlight::set_syntax_theme(theme); - return; - } - - let auto_theme_name = crate::render::highlight::adaptive_default_theme_name(); - if let Some(theme) = crate::render::highlight::resolve_theme_by_name( - auto_theme_name, - Some(&self.config.codex_home), - ) { - crate::render::highlight::set_syntax_theme(theme); - } - } - - fn personality_label(personality: Personality) -> &'static str { - match personality { - Personality::None => "None", - Personality::Friendly => "Friendly", - Personality::Pragmatic => "Pragmatic", - } - } - - async fn launch_external_editor(&mut self, tui: &mut tui::Tui) { - let editor_cmd = match external_editor::resolve_editor_command() { - Ok(cmd) => cmd, - Err(external_editor::EditorError::MissingEditor) => { - self.chat_widget - .add_to_history(history_cell::new_error_event( - "Cannot open external editor: set $VISUAL or $EDITOR before starting Codex." - .to_string(), - )); - self.reset_external_editor_state(tui); - return; - } - Err(err) => { - self.chat_widget - .add_to_history(history_cell::new_error_event(format!( - "Failed to open editor: {err}", - ))); - self.reset_external_editor_state(tui); - return; - } - }; - - let seed = self.chat_widget.composer_text_with_pending(); - let editor_result = tui - .with_restored(tui::RestoreMode::KeepRaw, || async { - external_editor::run_editor(&seed, &editor_cmd).await - }) - .await; - self.reset_external_editor_state(tui); - - match editor_result { - Ok(new_text) => { - // Trim trailing whitespace - let cleaned = new_text.trim_end().to_string(); - self.chat_widget.apply_external_edit(cleaned); - } - Err(err) => { - self.chat_widget - .add_to_history(history_cell::new_error_event(format!( - "Failed to open editor: {err}", - ))); - } - } - tui.frame_requester().schedule_frame(); - } - - fn request_external_editor_launch(&mut self, tui: &mut tui::Tui) { - self.chat_widget - .set_external_editor_state(ExternalEditorState::Requested); - self.chat_widget.set_footer_hint_override(Some(vec![( - EXTERNAL_EDITOR_HINT.to_string(), - String::new(), - )])); - tui.frame_requester().schedule_frame(); - } - - fn reset_external_editor_state(&mut self, tui: &mut tui::Tui) { - self.chat_widget - .set_external_editor_state(ExternalEditorState::Closed); - self.chat_widget.set_footer_hint_override(/*items*/ None); - tui.frame_requester().schedule_frame(); - } - - async fn handle_key_event( - &mut self, - tui: &mut tui::Tui, - app_server: &mut AppServerSession, - key_event: KeyEvent, - ) { - // Some terminals, especially on macOS, encode Option+Left/Right as Option+b/f unless - // enhanced keyboard reporting is available. We only treat those word-motion fallbacks as - // agent-switch shortcuts when the composer is empty so we never steal the expected - // editing behavior for moving across words inside a draft. - let allow_agent_word_motion_fallback = !self.enhanced_keys_supported - && self.chat_widget.composer_text_with_pending().is_empty(); - if self.overlay.is_none() - && self.chat_widget.no_modal_or_popup_active() - // Alt+Left/Right are also natural word-motion keys in the composer. Keep agent - // fast-switch available only once the draft is empty so editing behavior wins whenever - // there is text on screen. - && self.chat_widget.composer_text_with_pending().is_empty() - && previous_agent_shortcut_matches(key_event, allow_agent_word_motion_fallback) - { - if let Some(thread_id) = self - .adjacent_thread_id_with_backfill(app_server, AgentNavigationDirection::Previous) - .await - { - let _ = self - .select_agent_thread_and_discard_side(tui, app_server, thread_id) - .await; - } - return; - } - if self.overlay.is_none() - && self.chat_widget.no_modal_or_popup_active() - // Mirror the previous-agent rule above: empty drafts may use these keys for thread - // switching, but non-empty drafts keep them for expected word-wise cursor motion. - && self.chat_widget.composer_text_with_pending().is_empty() - && next_agent_shortcut_matches(key_event, allow_agent_word_motion_fallback) - { - if let Some(thread_id) = self - .adjacent_thread_id_with_backfill(app_server, AgentNavigationDirection::Next) - .await - { - let _ = self - .select_agent_thread_and_discard_side(tui, app_server, thread_id) - .await; - } - return; - } - if side_return_shortcut_matches(key_event) - && self.maybe_return_from_side(tui, app_server).await - { - return; - } - - match key_event { - KeyEvent { - code: KeyCode::Char('t'), - modifiers: KeyModifiers::CONTROL, - kind: KeyEventKind::Press, - .. - } => { - // Enter alternate screen and set viewport to full size. - let _ = tui.enter_alt_screen(); - self.overlay = Some(Overlay::new_transcript(self.transcript_cells.clone())); - tui.frame_requester().schedule_frame(); - } - KeyEvent { - code: KeyCode::Char('l'), - modifiers: KeyModifiers::CONTROL, - kind: KeyEventKind::Press, - .. - } => { - if !self.chat_widget.can_run_ctrl_l_clear_now() { - return; - } - if let Err(err) = self.clear_terminal_ui(tui, /*redraw_header*/ false) { - tracing::warn!(error = %err, "failed to clear terminal UI"); - self.chat_widget - .add_error_message(format!("Failed to clear terminal UI: {err}")); - } else { - self.reset_app_ui_state_after_clear(); - self.queue_clear_ui_header(tui); - tui.frame_requester().schedule_frame(); - } - } - KeyEvent { - code: KeyCode::Char('g'), - modifiers: KeyModifiers::CONTROL, - kind: KeyEventKind::Press, - .. - } => { - // Only launch the external editor if there is no overlay and the bottom pane is not in use. - // Note that it can be launched while a task is running to enable editing while the previous turn is ongoing. - if self.overlay.is_none() - && self.chat_widget.can_launch_external_editor() - && self.chat_widget.external_editor_state() == ExternalEditorState::Closed - { - self.request_external_editor_launch(tui); - } - } - // Esc primes/advances backtracking only in normal (not working) mode - // with the composer focused and empty. In any other state, forward - // Esc so the active UI (e.g. status indicator, modals, popups) - // handles it. - KeyEvent { - code: KeyCode::Esc, - kind: KeyEventKind::Press | KeyEventKind::Repeat, - .. - } => { - if self.chat_widget.is_normal_backtrack_mode() - && self.chat_widget.composer_is_empty() - { - self.handle_backtrack_esc_key(tui); - } else { - self.chat_widget.handle_key_event(key_event); - } - } - // Enter confirms backtrack when primed + count > 0. Otherwise pass to widget. - KeyEvent { - code: KeyCode::Enter, - kind: KeyEventKind::Press, - .. - } if self.backtrack.primed - && self.backtrack.nth_user_message != usize::MAX - && self.chat_widget.composer_is_empty() => - { - if let Some(selection) = self.confirm_backtrack_from_main() { - self.apply_backtrack_selection(tui, selection); - } - } - KeyEvent { - kind: KeyEventKind::Press | KeyEventKind::Repeat, - .. - } => { - // Any non-Esc key press should cancel a primed backtrack. - // This avoids stale "Esc-primed" state after the user starts typing - // (even if they later backspace to empty). - if key_event.code != KeyCode::Esc && self.backtrack.primed { - self.reset_backtrack_state(); - } - self.chat_widget.handle_key_event(key_event); - } - _ => { - self.chat_widget.handle_key_event(key_event); - } - }; - } - - fn refresh_status_line(&mut self) { - self.chat_widget.refresh_status_line(); - } - - #[cfg(target_os = "windows")] - fn spawn_world_writable_scan( - cwd: AbsolutePathBuf, - env_map: std::collections::HashMap, - logs_base_dir: AbsolutePathBuf, - sandbox_policy: codex_protocol::protocol::SandboxPolicy, - tx: AppEventSender, - ) { - tokio::task::spawn_blocking(move || { - let logs_base_dir_path = logs_base_dir.as_path(); - let result = codex_windows_sandbox::apply_world_writable_scan_and_denies( - logs_base_dir_path, - cwd.as_path(), - &env_map, - &sandbox_policy, - Some(logs_base_dir_path), - ); - if result.is_err() { - // Scan failed: warn without examples. - tx.send(AppEvent::OpenWorldWritableWarningConfirmation { - preset: None, - sample_paths: Vec::new(), - extra_count: 0usize, - failed_scan: true, - }); - } - }); - } -} - -fn side_return_shortcut_matches(key_event: KeyEvent) -> bool { - match key_event { - KeyEvent { - code: KeyCode::Esc, - kind: KeyEventKind::Press | KeyEventKind::Repeat, - .. - } => true, - KeyEvent { - code: KeyCode::Char(c), - modifiers, - kind: KeyEventKind::Press, - .. - } if modifiers.contains(KeyModifiers::CONTROL) && c.eq_ignore_ascii_case(&'c') => true, - _ => false, - } -} - -/// Collect every MCP server status needed for `/mcp` from the app-server by -/// walking the paginated `mcpServerStatus/list` RPC until no `next_cursor` is -/// returned. -/// -/// All pages are eagerly gathered into a single `Vec` so the caller can render -/// the inventory atomically. Each page requests up to 100 entries. -async fn fetch_all_mcp_server_statuses( - request_handle: AppServerRequestHandle, - detail: McpServerStatusDetail, -) -> Result> { - let mut cursor = None; - let mut statuses = Vec::new(); - - loop { - let request_id = RequestId::String(format!("mcp-inventory-{}", Uuid::new_v4())); - let response: ListMcpServerStatusResponse = request_handle - .request_typed(ClientRequest::McpServerStatusList { - request_id, - params: ListMcpServerStatusParams { - cursor: cursor.clone(), - limit: Some(100), - detail: Some(detail), - }, - }) - .await - .wrap_err("mcpServerStatus/list failed in TUI")?; - statuses.extend(response.data); - if let Some(next_cursor) = response.next_cursor { - cursor = Some(next_cursor); - } else { - break; - } - } - - Ok(statuses) -} - -async fn fetch_account_rate_limits( - request_handle: AppServerRequestHandle, -) -> Result> { - let request_id = RequestId::String(format!("account-rate-limits-{}", Uuid::new_v4())); - let response: GetAccountRateLimitsResponse = request_handle - .request_typed(ClientRequest::GetAccountRateLimits { - request_id, - params: None, - }) - .await - .wrap_err("account/rateLimits/read failed in TUI")?; - - Ok(app_server_rate_limit_snapshots_to_core(response)) -} - -async fn send_add_credits_nudge_email( - request_handle: AppServerRequestHandle, - credit_type: AddCreditsNudgeCreditType, -) -> Result { - let request_id = RequestId::String(format!("add-credits-nudge-{}", Uuid::new_v4())); - let response: codex_app_server_protocol::SendAddCreditsNudgeEmailResponse = request_handle - .request_typed(ClientRequest::SendAddCreditsNudgeEmail { - request_id, - params: SendAddCreditsNudgeEmailParams { credit_type }, - }) - .await - .wrap_err("account/sendAddCreditsNudgeEmail failed in TUI")?; - - Ok(response.status) -} - -async fn fetch_skills_list( - request_handle: AppServerRequestHandle, - cwd: PathBuf, -) -> Result { - let request_id = RequestId::String(format!("startup-skills-list-{}", Uuid::new_v4())); - // Use the cloneable request handle so startup can issue this RPC from a background task without - // extending a borrow of `AppServerSession` across the first frame render. - request_handle - .request_typed(ClientRequest::SkillsList { - request_id, - params: SkillsListParams { - cwds: vec![cwd], - force_reload: true, - per_cwd_extra_user_roots: None, - }, - }) - .await - .wrap_err("skills/list failed in TUI") -} - -async fn fetch_plugins_list( - request_handle: AppServerRequestHandle, - cwd: PathBuf, -) -> Result { - let cwd = AbsolutePathBuf::try_from(cwd).wrap_err("plugin list cwd must be absolute")?; - let request_id = RequestId::String(format!("plugin-list-{}", Uuid::new_v4())); - let mut response = request_handle - .request_typed(ClientRequest::PluginList { - request_id, - params: PluginListParams { - cwds: Some(vec![cwd]), - }, - }) - .await - .wrap_err("plugin/list failed in TUI")?; - hide_cli_only_plugin_marketplaces(&mut response); - Ok(response) -} - -const CLI_HIDDEN_PLUGIN_MARKETPLACES: &[&str] = &["openai-bundled"]; - -fn hide_cli_only_plugin_marketplaces(response: &mut PluginListResponse) { - response - .marketplaces - .retain(|marketplace| !CLI_HIDDEN_PLUGIN_MARKETPLACES.contains(&marketplace.name.as_str())); -} - -async fn fetch_plugin_detail( - request_handle: AppServerRequestHandle, - params: PluginReadParams, -) -> Result { - let request_id = RequestId::String(format!("plugin-read-{}", Uuid::new_v4())); - request_handle - .request_typed(ClientRequest::PluginRead { request_id, params }) - .await - .wrap_err("plugin/read failed in TUI") -} - -async fn fetch_plugin_install( - request_handle: AppServerRequestHandle, - marketplace_path: AbsolutePathBuf, - plugin_name: String, -) -> Result { - let request_id = RequestId::String(format!("plugin-install-{}", Uuid::new_v4())); - request_handle - .request_typed(ClientRequest::PluginInstall { - request_id, - params: PluginInstallParams { - marketplace_path: Some(marketplace_path), - remote_marketplace_name: None, - plugin_name, - }, - }) - .await - .wrap_err("plugin/install failed in TUI") -} - -async fn fetch_plugin_uninstall( - request_handle: AppServerRequestHandle, - plugin_id: String, -) -> Result { - let request_id = RequestId::String(format!("plugin-uninstall-{}", Uuid::new_v4())); - request_handle - .request_typed(ClientRequest::PluginUninstall { - request_id, - params: PluginUninstallParams { plugin_id }, - }) - .await - .wrap_err("plugin/uninstall failed in TUI") -} - -async fn write_plugin_enabled( - request_handle: AppServerRequestHandle, - plugin_id: String, - enabled: bool, -) -> Result { - let request_id = RequestId::String(format!("plugin-enable-{}", Uuid::new_v4())); - request_handle - .request_typed(ClientRequest::ConfigValueWrite { - request_id, - params: ConfigValueWriteParams { - key_path: format!("plugins.{plugin_id}"), - value: serde_json::json!({ "enabled": enabled }), - merge_strategy: MergeStrategy::Upsert, - file_path: None, - expected_version: None, - }, - }) - .await - .wrap_err("config/value/write failed while updating plugin enablement in TUI") -} - -fn build_feedback_upload_params( - origin_thread_id: Option, - rollout_path: Option, - category: FeedbackCategory, - reason: Option, - turn_id: Option, - include_logs: bool, -) -> FeedbackUploadParams { - let extra_log_files = if include_logs { - rollout_path.map(|rollout_path| vec![rollout_path]) - } else { - None - }; - let tags = turn_id.map(|turn_id| BTreeMap::from([(String::from("turn_id"), turn_id)])); - FeedbackUploadParams { - classification: crate::bottom_pane::feedback_classification(category).to_string(), - reason, - thread_id: origin_thread_id.map(|thread_id| thread_id.to_string()), - include_logs, - extra_log_files, - tags, - } -} - -async fn fetch_feedback_upload( - request_handle: AppServerRequestHandle, - params: FeedbackUploadParams, -) -> Result { - let request_id = RequestId::String(format!("feedback-upload-{}", Uuid::new_v4())); - request_handle - .request_typed(ClientRequest::FeedbackUpload { request_id, params }) - .await - .wrap_err("feedback/upload failed in TUI") -} - -/// Convert flat `McpServerStatus` responses into the per-server maps used by the -/// in-process MCP subsystem (tools keyed as `mcp__{server}__{tool}`, plus -/// per-server resource/template/auth maps). Test-only because the TUI -/// renders directly from `McpServerStatus` rather than these maps. -#[cfg(test)] -type McpInventoryMaps = ( - HashMap, - HashMap>, - HashMap>, - HashMap, -); - -#[cfg(test)] -fn mcp_inventory_maps_from_statuses(statuses: Vec) -> McpInventoryMaps { - let mut tools = HashMap::new(); - let mut resources = HashMap::new(); - let mut resource_templates = HashMap::new(); - let mut auth_statuses = HashMap::new(); - - for status in statuses { - let server_name = status.name; - auth_statuses.insert( - server_name.clone(), - match status.auth_status { - codex_app_server_protocol::McpAuthStatus::Unsupported => McpAuthStatus::Unsupported, - codex_app_server_protocol::McpAuthStatus::NotLoggedIn => McpAuthStatus::NotLoggedIn, - codex_app_server_protocol::McpAuthStatus::BearerToken => McpAuthStatus::BearerToken, - codex_app_server_protocol::McpAuthStatus::OAuth => McpAuthStatus::OAuth, - }, - ); - resources.insert(server_name.clone(), status.resources); - resource_templates.insert(server_name.clone(), status.resource_templates); - for (tool_name, tool) in status.tools { - tools.insert(format!("mcp__{server_name}__{tool_name}"), tool); - } - } - - (tools, resources, resource_templates, auth_statuses) } impl Drop for App { @@ -7049,5476 +1153,4 @@ impl Drop for App { } #[cfg(test)] -mod tests { - use super::*; - use crate::app_backtrack::BacktrackSelection; - use crate::app_backtrack::BacktrackState; - use crate::app_backtrack::user_count; - - use crate::chatwidget::ChatWidgetInit; - use crate::chatwidget::create_initial_user_message; - use crate::chatwidget::tests::make_chatwidget_manual_with_sender; - use crate::chatwidget::tests::set_chatgpt_auth; - use crate::chatwidget::tests::set_fast_mode_test_catalog; - use crate::file_search::FileSearchManager; - use crate::history_cell::AgentMessageCell; - use crate::history_cell::HistoryCell; - use crate::history_cell::UserHistoryCell; - use crate::history_cell::new_session_info; - use crate::multi_agents::AgentPickerThreadEntry; - use assert_matches::assert_matches; - - use crate::legacy_core::config::ConfigBuilder; - use crate::legacy_core::config::ConfigOverrides; - use codex_app_server_protocol::AdditionalFileSystemPermissions; - use codex_app_server_protocol::AdditionalNetworkPermissions; - use codex_app_server_protocol::AdditionalPermissionProfile; - use codex_app_server_protocol::AgentMessageDeltaNotification; - use codex_app_server_protocol::CommandExecutionRequestApprovalParams; - use codex_app_server_protocol::ConfigWarningNotification; - use codex_app_server_protocol::HookCompletedNotification; - use codex_app_server_protocol::HookEventName as AppServerHookEventName; - use codex_app_server_protocol::HookExecutionMode as AppServerHookExecutionMode; - use codex_app_server_protocol::HookHandlerType as AppServerHookHandlerType; - use codex_app_server_protocol::HookOutputEntry as AppServerHookOutputEntry; - use codex_app_server_protocol::HookOutputEntryKind as AppServerHookOutputEntryKind; - use codex_app_server_protocol::HookRunStatus as AppServerHookRunStatus; - use codex_app_server_protocol::HookRunSummary as AppServerHookRunSummary; - use codex_app_server_protocol::HookScope as AppServerHookScope; - use codex_app_server_protocol::HookStartedNotification; - use codex_app_server_protocol::JSONRPCErrorError; - use codex_app_server_protocol::McpServerStartupState; - use codex_app_server_protocol::McpServerStatusUpdatedNotification; - use codex_app_server_protocol::NetworkApprovalContext as AppServerNetworkApprovalContext; - use codex_app_server_protocol::NetworkApprovalProtocol as AppServerNetworkApprovalProtocol; - use codex_app_server_protocol::NetworkPolicyAmendment as AppServerNetworkPolicyAmendment; - use codex_app_server_protocol::NetworkPolicyRuleAction as AppServerNetworkPolicyRuleAction; - use codex_app_server_protocol::NonSteerableTurnKind as AppServerNonSteerableTurnKind; - use codex_app_server_protocol::PermissionsRequestApprovalParams; - use codex_app_server_protocol::PluginMarketplaceEntry; - use codex_app_server_protocol::RequestId as AppServerRequestId; - use codex_app_server_protocol::ServerNotification; - use codex_app_server_protocol::ServerRequest; - use codex_app_server_protocol::Thread; - use codex_app_server_protocol::ThreadClosedNotification; - use codex_app_server_protocol::ThreadItem; - use codex_app_server_protocol::ThreadStartedNotification; - use codex_app_server_protocol::ThreadTokenUsage; - use codex_app_server_protocol::ThreadTokenUsageUpdatedNotification; - use codex_app_server_protocol::TokenUsageBreakdown; - use codex_app_server_protocol::ToolRequestUserInputParams; - use codex_app_server_protocol::Turn; - use codex_app_server_protocol::TurnCompletedNotification; - use codex_app_server_protocol::TurnError as AppServerTurnError; - use codex_app_server_protocol::TurnStartedNotification; - use codex_app_server_protocol::TurnStatus; - use codex_app_server_protocol::UserInput as AppServerUserInput; - use codex_app_server_protocol::WarningNotification; - use codex_otel::SessionTelemetry; - use codex_protocol::ThreadId; - use codex_protocol::config_types::CollaborationMode; - use codex_protocol::config_types::CollaborationModeMask; - use codex_protocol::config_types::ModeKind; - use codex_protocol::config_types::Settings; - use codex_protocol::mcp::Tool; - use codex_protocol::models::FileSystemPermissions; - use codex_protocol::models::NetworkPermissions; - use codex_protocol::models::PermissionProfile; - use codex_protocol::protocol::AskForApproval; - use codex_protocol::protocol::Event; - use codex_protocol::protocol::EventMsg; - use codex_protocol::protocol::McpAuthStatus; - use codex_protocol::protocol::NetworkApprovalContext; - use codex_protocol::protocol::NetworkApprovalProtocol; - use codex_protocol::protocol::RolloutItem; - use codex_protocol::protocol::RolloutLine; - use codex_protocol::protocol::SandboxPolicy; - use codex_protocol::protocol::SessionConfiguredEvent; - use codex_protocol::protocol::SessionSource; - use codex_protocol::protocol::TurnContextItem; - use codex_protocol::request_permissions::RequestPermissionProfile; - use codex_protocol::user_input::TextElement; - use codex_protocol::user_input::UserInput; - use codex_utils_absolute_path::AbsolutePathBuf; - use crossterm::event::KeyModifiers; - use insta::assert_snapshot; - use pretty_assertions::assert_eq; - use ratatui::prelude::Line; - use std::path::PathBuf; - use std::sync::Arc; - use std::sync::atomic::AtomicBool; - use tempfile::tempdir; - use tokio::time; - - mod model_catalog; - - fn test_absolute_path(path: &str) -> AbsolutePathBuf { - AbsolutePathBuf::try_from(PathBuf::from(path)).expect("absolute test path") - } - - #[test] - fn hide_cli_only_plugin_marketplaces_removes_openai_bundled() { - let mut response = PluginListResponse { - marketplaces: vec![ - PluginMarketplaceEntry { - name: "openai-bundled".to_string(), - path: Some(test_absolute_path("/marketplaces/openai-bundled")), - interface: None, - plugins: Vec::new(), - }, - PluginMarketplaceEntry { - name: "openai-curated".to_string(), - path: Some(test_absolute_path("/marketplaces/openai-curated")), - interface: None, - plugins: Vec::new(), - }, - ], - marketplace_load_errors: Vec::new(), - featured_plugin_ids: Vec::new(), - }; - - hide_cli_only_plugin_marketplaces(&mut response); - - assert_eq!( - response.marketplaces, - vec![PluginMarketplaceEntry { - name: "openai-curated".to_string(), - path: Some(test_absolute_path("/marketplaces/openai-curated")), - interface: None, - plugins: Vec::new(), - }] - ); - } - - #[test] - fn normalize_harness_overrides_resolves_relative_add_dirs() -> Result<()> { - let temp_dir = tempdir()?; - let base_cwd = temp_dir.path().join("base").abs(); - std::fs::create_dir_all(base_cwd.as_path())?; - - let overrides = ConfigOverrides { - additional_writable_roots: vec![PathBuf::from("rel")], - ..Default::default() - }; - let normalized = normalize_harness_overrides_for_cwd(overrides, &base_cwd)?; - - assert_eq!( - normalized.additional_writable_roots, - vec![base_cwd.join("rel").into_path_buf()] - ); - Ok(()) - } - - #[test] - fn mcp_inventory_maps_prefix_tool_names_by_server() { - let statuses = vec![ - McpServerStatus { - name: "docs".to_string(), - tools: HashMap::from([( - "list".to_string(), - Tool { - description: None, - name: "list".to_string(), - title: None, - input_schema: serde_json::json!({"type": "object"}), - output_schema: None, - annotations: None, - icons: None, - meta: None, - }, - )]), - resources: Vec::new(), - resource_templates: Vec::new(), - auth_status: codex_app_server_protocol::McpAuthStatus::Unsupported, - }, - McpServerStatus { - name: "disabled".to_string(), - tools: HashMap::new(), - resources: Vec::new(), - resource_templates: Vec::new(), - auth_status: codex_app_server_protocol::McpAuthStatus::Unsupported, - }, - ]; - - let (tools, resources, resource_templates, auth_statuses) = - mcp_inventory_maps_from_statuses(statuses); - let mut resource_names = resources.keys().cloned().collect::>(); - resource_names.sort(); - let mut template_names = resource_templates.keys().cloned().collect::>(); - template_names.sort(); - - assert_eq!( - tools.keys().cloned().collect::>(), - vec!["mcp__docs__list".to_string()] - ); - assert_eq!(resource_names, vec!["disabled", "docs"]); - assert_eq!(template_names, vec!["disabled", "docs"]); - assert_eq!( - auth_statuses.get("disabled"), - Some(&McpAuthStatus::Unsupported) - ); - } - - #[tokio::test] - async fn handle_mcp_inventory_result_clears_committed_loading_cell() { - let mut app = make_test_app().await; - app.transcript_cells - .push(Arc::new(history_cell::new_mcp_inventory_loading( - /*animations_enabled*/ false, - ))); - - app.handle_mcp_inventory_result( - Ok(vec![McpServerStatus { - name: "docs".to_string(), - tools: HashMap::new(), - resources: Vec::new(), - resource_templates: Vec::new(), - auth_status: codex_app_server_protocol::McpAuthStatus::Unsupported, - }]), - McpServerStatusDetail::ToolsAndAuthOnly, - ); - - assert_eq!(app.transcript_cells.len(), 0); - } - - #[test] - fn startup_waiting_gate_is_only_for_fresh_or_exit_session_selection() { - assert_eq!( - App::should_wait_for_initial_session(&SessionSelection::StartFresh), - true - ); - assert_eq!( - App::should_wait_for_initial_session(&SessionSelection::Exit), - true - ); - assert_eq!( - App::should_wait_for_initial_session(&SessionSelection::Resume( - crate::resume_picker::SessionTarget { - path: Some(PathBuf::from("/tmp/restore")), - thread_id: ThreadId::new(), - } - )), - false - ); - assert_eq!( - App::should_wait_for_initial_session(&SessionSelection::Fork( - crate::resume_picker::SessionTarget { - path: Some(PathBuf::from("/tmp/fork")), - thread_id: ThreadId::new(), - } - )), - false - ); - } - - #[test] - fn startup_waiting_gate_holds_active_thread_events_until_primary_thread_configured() { - let mut wait_for_initial_session = - App::should_wait_for_initial_session(&SessionSelection::StartFresh); - assert_eq!(wait_for_initial_session, true); - assert_eq!( - App::should_handle_active_thread_events( - wait_for_initial_session, - /*has_active_thread_receiver*/ true - ), - false - ); - - assert_eq!( - App::should_stop_waiting_for_initial_session( - wait_for_initial_session, - /*primary_thread_id*/ None - ), - false - ); - if App::should_stop_waiting_for_initial_session( - wait_for_initial_session, - Some(ThreadId::new()), - ) { - wait_for_initial_session = false; - } - assert_eq!(wait_for_initial_session, false); - - assert_eq!( - App::should_handle_active_thread_events( - wait_for_initial_session, - /*has_active_thread_receiver*/ true - ), - true - ); - } - - #[test] - fn startup_waiting_gate_not_applied_for_resume_or_fork_session_selection() { - let wait_for_resume = App::should_wait_for_initial_session(&SessionSelection::Resume( - crate::resume_picker::SessionTarget { - path: Some(PathBuf::from("/tmp/restore")), - thread_id: ThreadId::new(), - }, - )); - assert_eq!( - App::should_handle_active_thread_events( - wait_for_resume, - /*has_active_thread_receiver*/ true - ), - true - ); - let wait_for_fork = App::should_wait_for_initial_session(&SessionSelection::Fork( - crate::resume_picker::SessionTarget { - path: Some(PathBuf::from("/tmp/fork")), - thread_id: ThreadId::new(), - }, - )); - assert_eq!( - App::should_handle_active_thread_events( - wait_for_fork, - /*has_active_thread_receiver*/ true - ), - true - ); - } - - #[tokio::test] - async fn ignore_same_thread_resume_reports_noop_for_current_thread() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.thread_event_channels.insert( - thread_id, - ThreadEventChannel::new_with_session( - THREAD_EVENT_CHANNEL_CAPACITY, - session, - Vec::new(), - ), - ); - app.activate_thread_channel(thread_id).await; - while app_event_rx.try_recv().is_ok() {} - - let ignored = app.ignore_same_thread_resume(&crate::resume_picker::SessionTarget { - path: Some(test_path_buf("/tmp/project")), - thread_id, - }); - - assert!(ignored); - let cell = match app_event_rx.try_recv() { - Ok(AppEvent::InsertHistoryCell(cell)) => cell, - other => panic!("expected info message after same-thread resume, saw {other:?}"), - }; - let rendered = lines_to_single_string(&cell.display_lines(/*width*/ 80)); - assert!(rendered.contains(&format!( - "Already viewing {}.", - test_path_display("/tmp/project") - ))); - } - - #[tokio::test] - async fn ignore_same_thread_resume_allows_reattaching_displayed_inactive_thread() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session); - - let ignored = app.ignore_same_thread_resume(&crate::resume_picker::SessionTarget { - path: Some(test_path_buf("/tmp/project")), - thread_id, - }); - - assert!(!ignored); - assert!(app.transcript_cells.is_empty()); - } - - #[tokio::test] - async fn enqueue_primary_thread_session_replays_buffered_approval_after_attach() -> Result<()> { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let approval_request = - exec_approval_request(thread_id, "turn-1", "call-1", /*approval_id*/ None); - - assert_eq!( - app.pending_app_server_requests - .note_server_request(&approval_request), - None - ); - app.enqueue_primary_thread_request(approval_request).await?; - app.enqueue_primary_thread_session( - test_thread_session(thread_id, test_path_buf("/tmp/project")), - Vec::new(), - ) - .await?; - - let rx = app - .active_thread_rx - .as_mut() - .expect("primary thread receiver should be active"); - let event = time::timeout(Duration::from_millis(50), rx.recv()) - .await - .expect("timed out waiting for buffered approval event") - .expect("channel closed unexpectedly"); - - assert!(matches!( - &event, - ThreadBufferedEvent::Request(ServerRequest::CommandExecutionRequestApproval { - params, - .. - }) if params.turn_id == "turn-1" - )); - - app.handle_thread_event_now(event); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE)); - - while let Ok(app_event) = app_event_rx.try_recv() { - if let AppEvent::SubmitThreadOp { - thread_id: op_thread_id, - .. - } = app_event - { - assert_eq!(op_thread_id, thread_id); - return Ok(()); - } - } - - panic!("expected approval action to submit a thread-scoped op"); - } - - #[tokio::test] - async fn resolved_buffered_approval_does_not_become_actionable_after_drain() -> Result<()> { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let approval_request = - exec_approval_request(thread_id, "turn-1", "call-1", /*approval_id*/ None); - - app.enqueue_primary_thread_session( - test_thread_session(thread_id, test_path_buf("/tmp/project")), - Vec::new(), - ) - .await?; - while app_event_rx.try_recv().is_ok() {} - - assert_eq!( - app.pending_app_server_requests - .note_server_request(&approval_request), - None - ); - app.enqueue_thread_request(thread_id, approval_request) - .await?; - - let resolved = app - .pending_app_server_requests - .resolve_notification(&AppServerRequestId::Integer(1)) - .expect("matching app-server request should resolve"); - app.chat_widget.dismiss_app_server_request(&resolved); - while app_event_rx.try_recv().is_ok() {} - - let rx = app - .active_thread_rx - .as_mut() - .expect("primary thread receiver should be active"); - let event = time::timeout(Duration::from_millis(50), rx.recv()) - .await - .expect("timed out waiting for buffered approval event") - .expect("channel closed unexpectedly"); - - assert!(matches!( - &event, - ThreadBufferedEvent::Request(ServerRequest::CommandExecutionRequestApproval { - params, - .. - }) if params.turn_id == "turn-1" - )); - - app.handle_thread_event_now(event); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE)); - - while let Ok(app_event) = app_event_rx.try_recv() { - assert!( - !matches!(app_event, AppEvent::SubmitThreadOp { .. }), - "resolved buffered approval should not become actionable" - ); - } - - Ok(()) - } - - #[tokio::test] - async fn enqueue_primary_thread_session_replays_turns_before_initial_prompt_submit() - -> Result<()> { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let initial_prompt = "follow-up after replay".to_string(); - let config = app.config.clone(); - let model = crate::legacy_core::test_support::get_model_offline(config.model.as_deref()); - app.chat_widget = ChatWidget::new_with_app_event(ChatWidgetInit { - config, - frame_requester: crate::tui::FrameRequester::test_dummy(), - app_event_tx: app.app_event_tx.clone(), - initial_user_message: create_initial_user_message( - Some(initial_prompt.clone()), - Vec::new(), - Vec::new(), - ), - enhanced_keys_supported: false, - has_chatgpt_account: false, - model_catalog: app.model_catalog.clone(), - feedback: codex_feedback::CodexFeedback::new(), - is_first_run: false, - status_account_display: None, - initial_plan_type: None, - model: Some(model), - startup_tooltip_override: None, - status_line_invalid_items_warned: app.status_line_invalid_items_warned.clone(), - terminal_title_invalid_items_warned: app.terminal_title_invalid_items_warned.clone(), - session_telemetry: app.session_telemetry.clone(), - }); - - app.enqueue_primary_thread_session( - test_thread_session(thread_id, test_path_buf("/tmp/project")), - vec![test_turn( - "turn-1", - TurnStatus::Completed, - vec![ThreadItem::UserMessage { - id: "user-1".to_string(), - content: vec![AppServerUserInput::Text { - text: "earlier prompt".to_string(), - text_elements: Vec::new(), - }], - }], - )], - ) - .await?; - - let mut saw_replayed_answer = false; - let mut submitted_items = None; - while let Ok(event) = app_event_rx.try_recv() { - match event { - AppEvent::InsertHistoryCell(cell) => { - let transcript = lines_to_single_string(&cell.transcript_lines(/*width*/ 80)); - saw_replayed_answer |= transcript.contains("earlier prompt"); - } - AppEvent::SubmitThreadOp { - thread_id: op_thread_id, - op: Op::UserTurn { items, .. }, - } => { - assert_eq!(op_thread_id, thread_id); - submitted_items = Some(items); - } - AppEvent::CodexOp(Op::UserTurn { items, .. }) => { - submitted_items = Some(items); - } - _ => {} - } - } - assert!( - saw_replayed_answer, - "expected replayed history before initial prompt submit" - ); - assert_eq!( - submitted_items, - Some(vec![UserInput::Text { - text: initial_prompt, - text_elements: Vec::new(), - }]) - ); - - Ok(()) - } - - #[tokio::test] - async fn reset_thread_event_state_aborts_listener_tasks() { - struct NotifyOnDrop(Option>); - - impl Drop for NotifyOnDrop { - fn drop(&mut self) { - if let Some(tx) = self.0.take() { - let _ = tx.send(()); - } - } - } - - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - let (started_tx, started_rx) = tokio::sync::oneshot::channel(); - let (dropped_tx, dropped_rx) = tokio::sync::oneshot::channel(); - let handle = tokio::spawn(async move { - let _notify_on_drop = NotifyOnDrop(Some(dropped_tx)); - let _ = started_tx.send(()); - std::future::pending::<()>().await; - }); - app.thread_event_listener_tasks.insert(thread_id, handle); - started_rx - .await - .expect("listener task should report it started"); - - app.reset_thread_event_state(); - - assert_eq!(app.thread_event_listener_tasks.is_empty(), true); - time::timeout(Duration::from_millis(50), dropped_rx) - .await - .expect("timed out waiting for listener task abort") - .expect("listener task drop notification should succeed"); - } - - #[tokio::test] - async fn history_lookup_response_is_routed_to_requesting_thread() -> Result<()> { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - - let handled = app - .try_handle_local_history_op( - thread_id, - &Op::GetHistoryEntryRequest { - offset: 0, - log_id: 1, - } - .into(), - ) - .await?; - - assert!(handled); - - let app_event = tokio::time::timeout(Duration::from_secs(1), app_event_rx.recv()) - .await - .expect("history lookup should emit an app event") - .expect("app event channel should stay open"); - - let AppEvent::ThreadHistoryEntryResponse { - thread_id: routed_thread_id, - event, - } = app_event - else { - panic!("expected thread-routed history response"); - }; - assert_eq!(routed_thread_id, thread_id); - assert_eq!(event.offset, 0); - assert_eq!(event.log_id, 1); - assert!(event.entry.is_none()); - - Ok(()) - } - - #[tokio::test] - async fn enqueue_thread_event_does_not_block_when_channel_full() -> Result<()> { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - app.thread_event_channels - .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - app.set_thread_active(thread_id, /*active*/ true).await; - - let event = thread_closed_notification(thread_id); - - app.enqueue_thread_notification(thread_id, event.clone()) - .await?; - time::timeout( - Duration::from_millis(50), - app.enqueue_thread_notification(thread_id, event), - ) - .await - .expect("enqueue_thread_notification blocked on a full channel")?; - - let mut rx = app - .thread_event_channels - .get_mut(&thread_id) - .expect("missing thread channel") - .receiver - .take() - .expect("missing receiver"); - - time::timeout(Duration::from_millis(50), rx.recv()) - .await - .expect("timed out waiting for first event") - .expect("channel closed unexpectedly"); - time::timeout(Duration::from_millis(50), rx.recv()) - .await - .expect("timed out waiting for second event") - .expect("channel closed unexpectedly"); - - Ok(()) - } - - #[tokio::test] - async fn replay_thread_snapshot_restores_draft_and_queued_input() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.thread_event_channels.insert( - thread_id, - ThreadEventChannel::new_with_session( - THREAD_EVENT_CHANNEL_CAPACITY, - session.clone(), - Vec::new(), - ), - ); - app.activate_thread_channel(thread_id).await; - app.chat_widget.handle_thread_session(session.clone()); - - app.chat_widget - .apply_external_edit("draft prompt".to_string()); - app.chat_widget.submit_user_message_with_mode( - "queued follow-up".to_string(), - CollaborationModeMask { - name: "Default".to_string(), - mode: None, - model: None, - reasoning_effort: None, - developer_instructions: None, - }, - ); - let expected_input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected thread input state"); - - app.store_active_thread_receiver().await; - - let snapshot = { - let channel = app - .thread_event_channels - .get(&thread_id) - .expect("thread channel should exist"); - let store = channel.store.lock().await; - assert_eq!(store.input_state, Some(expected_input_state)); - store.snapshot() - }; - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - - app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ true); - - assert_eq!(app.chat_widget.composer_text_with_pending(), "draft prompt"); - assert!(app.chat_widget.queued_user_message_texts().is_empty()); - while let Ok(op) = new_op_rx.try_recv() { - assert!( - !matches!(op, Op::UserTurn { .. }), - "draft-only replay should not auto-submit queued input" - ); - } - } - - #[tokio::test] - async fn active_turn_id_for_thread_uses_snapshot_turns() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.thread_event_channels.insert( - thread_id, - ThreadEventChannel::new_with_session( - THREAD_EVENT_CHANNEL_CAPACITY, - session, - vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())], - ), - ); - - assert_eq!( - app.active_turn_id_for_thread(thread_id).await, - Some("turn-1".to_string()) - ); - } - - #[tokio::test] - async fn replayed_turn_complete_submits_restored_queued_follow_up() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget.handle_server_notification( - turn_started_notification(thread_id, "turn-1"), - /*replay_kind*/ None, - ); - app.chat_widget.handle_server_notification( - agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), - /*replay_kind*/ None, - ); - app.chat_widget - .apply_external_edit("queued follow-up".to_string()); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected queued follow-up state"); - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - while new_op_rx.try_recv().is_ok() {} - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![ThreadBufferedEvent::Notification( - turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed), - )], - input_state: Some(input_state), - }, - /*resume_restored_queue*/ true, - ); - - match next_user_turn_op(&mut new_op_rx) { - Op::UserTurn { items, .. } => assert_eq!( - items, - vec![UserInput::Text { - text: "queued follow-up".to_string(), - text_elements: Vec::new(), - }] - ), - other => panic!("expected queued follow-up submission, got {other:?}"), - } - } - - #[tokio::test] - async fn replay_only_thread_keeps_restored_queue_visible() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget.handle_server_notification( - turn_started_notification(thread_id, "turn-1"), - /*replay_kind*/ None, - ); - app.chat_widget.handle_server_notification( - agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), - /*replay_kind*/ None, - ); - app.chat_widget - .apply_external_edit("queued follow-up".to_string()); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected queued follow-up state"); - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - while new_op_rx.try_recv().is_ok() {} - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![ThreadBufferedEvent::Notification( - turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed), - )], - input_state: Some(input_state), - }, - /*resume_restored_queue*/ false, - ); - - assert_eq!( - app.chat_widget.queued_user_message_texts(), - vec!["queued follow-up".to_string()] - ); - assert!( - new_op_rx.try_recv().is_err(), - "replay-only threads should not auto-submit restored queue" - ); - } - - #[tokio::test] - async fn replay_thread_snapshot_keeps_queue_when_running_state_only_comes_from_snapshot() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget.handle_server_notification( - turn_started_notification(thread_id, "turn-1"), - /*replay_kind*/ None, - ); - app.chat_widget.handle_server_notification( - agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), - /*replay_kind*/ None, - ); - app.chat_widget - .apply_external_edit("queued follow-up".to_string()); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected queued follow-up state"); - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - while new_op_rx.try_recv().is_ok() {} - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![], - input_state: Some(input_state), - }, - /*resume_restored_queue*/ true, - ); - - assert_eq!( - app.chat_widget.queued_user_message_texts(), - vec!["queued follow-up".to_string()] - ); - assert!( - new_op_rx.try_recv().is_err(), - "restored queue should stay queued when replay did not prove the turn finished" - ); - } - - #[tokio::test] - async fn replay_thread_snapshot_in_progress_turn_restores_running_queue_state() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget.handle_server_notification( - turn_started_notification(thread_id, "turn-1"), - /*replay_kind*/ None, - ); - app.chat_widget.handle_server_notification( - agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), - /*replay_kind*/ None, - ); - app.chat_widget - .apply_external_edit("queued follow-up".to_string()); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected queued follow-up state"); - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - while new_op_rx.try_recv().is_ok() {} - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())], - events: Vec::new(), - input_state: Some(input_state), - }, - /*resume_restored_queue*/ true, - ); - - assert_eq!( - app.chat_widget.queued_user_message_texts(), - vec!["queued follow-up".to_string()] - ); - assert!( - new_op_rx.try_recv().is_err(), - "restored queue should stay queued while replayed turn is still running" - ); - } - - #[tokio::test] - async fn replay_thread_snapshot_in_progress_turn_restores_running_state_without_input_state() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - let (chat_widget, _app_event_tx, _rx, _new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session); - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())], - events: Vec::new(), - input_state: None, - }, - /*resume_restored_queue*/ false, - ); - - assert!(app.chat_widget.is_task_running_for_test()); - } - - #[tokio::test] - async fn replay_thread_snapshot_does_not_submit_queue_before_replay_catches_up() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget.handle_server_notification( - turn_started_notification(thread_id, "turn-1"), - /*replay_kind*/ None, - ); - app.chat_widget.handle_server_notification( - agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), - /*replay_kind*/ None, - ); - app.chat_widget - .apply_external_edit("queued follow-up".to_string()); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected queued follow-up state"); - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - while new_op_rx.try_recv().is_ok() {} - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![ - ThreadBufferedEvent::Notification(turn_completed_notification( - thread_id, - "turn-0", - TurnStatus::Completed, - )), - ThreadBufferedEvent::Notification(turn_started_notification( - thread_id, "turn-1", - )), - ], - input_state: Some(input_state), - }, - /*resume_restored_queue*/ true, - ); - - assert!( - new_op_rx.try_recv().is_err(), - "queued follow-up should stay queued until the latest turn completes" - ); - assert_eq!( - app.chat_widget.queued_user_message_texts(), - vec!["queued follow-up".to_string()] - ); - - app.chat_widget.handle_server_notification( - turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed), - /*replay_kind*/ None, - ); - - match next_user_turn_op(&mut new_op_rx) { - Op::UserTurn { items, .. } => assert_eq!( - items, - vec![UserInput::Text { - text: "queued follow-up".to_string(), - text_elements: Vec::new(), - }] - ), - other => panic!("expected queued follow-up submission, got {other:?}"), - } - } - - #[tokio::test] - async fn replay_thread_snapshot_restores_pending_pastes_for_submit() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.thread_event_channels.insert( - thread_id, - ThreadEventChannel::new_with_session( - THREAD_EVENT_CHANNEL_CAPACITY, - session.clone(), - Vec::new(), - ), - ); - app.activate_thread_channel(thread_id).await; - app.chat_widget.handle_thread_session(session); - - let large = "x".repeat(1005); - app.chat_widget.handle_paste(large.clone()); - let expected_input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected thread input state"); - - app.store_active_thread_receiver().await; - - let snapshot = { - let channel = app - .thread_event_channels - .get(&thread_id) - .expect("thread channel should exist"); - let store = channel.store.lock().await; - assert_eq!(store.input_state, Some(expected_input_state)); - store.snapshot() - }; - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ true); - - assert_eq!(app.chat_widget.composer_text_with_pending(), large); - - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); - - match next_user_turn_op(&mut new_op_rx) { - Op::UserTurn { items, .. } => assert_eq!( - items, - vec![UserInput::Text { - text: large, - text_elements: Vec::new(), - }] - ), - other => panic!("expected restored paste submission, got {other:?}"), - } - } - - #[tokio::test] - async fn replay_thread_snapshot_restores_collaboration_mode_for_draft_submit() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget - .set_reasoning_effort(Some(ReasoningEffortConfig::High)); - app.chat_widget - .set_collaboration_mask(CollaborationModeMask { - name: "Plan".to_string(), - mode: Some(ModeKind::Plan), - model: Some("gpt-restored".to_string()), - reasoning_effort: Some(Some(ReasoningEffortConfig::High)), - developer_instructions: None, - }); - app.chat_widget - .apply_external_edit("draft prompt".to_string()); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected draft input state"); - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget - .set_reasoning_effort(Some(ReasoningEffortConfig::Low)); - app.chat_widget - .set_collaboration_mask(CollaborationModeMask { - name: "Default".to_string(), - mode: Some(ModeKind::Default), - model: Some("gpt-replacement".to_string()), - reasoning_effort: Some(Some(ReasoningEffortConfig::Low)), - developer_instructions: None, - }); - while new_op_rx.try_recv().is_ok() {} - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![], - input_state: Some(input_state), - }, - /*resume_restored_queue*/ true, - ); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); - - match next_user_turn_op(&mut new_op_rx) { - Op::UserTurn { - items, - model, - effort, - collaboration_mode, - .. - } => { - assert_eq!( - items, - vec![UserInput::Text { - text: "draft prompt".to_string(), - text_elements: Vec::new(), - }] - ); - assert_eq!(model, "gpt-restored".to_string()); - assert_eq!(effort, Some(ReasoningEffortConfig::High)); - assert_eq!( - collaboration_mode, - Some(CollaborationMode { - mode: ModeKind::Plan, - settings: Settings { - model: "gpt-restored".to_string(), - reasoning_effort: Some(ReasoningEffortConfig::High), - developer_instructions: None, - }, - }) - ); - } - other => panic!("expected restored draft submission, got {other:?}"), - } - } - - #[tokio::test] - async fn replay_thread_snapshot_restores_collaboration_mode_without_input() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget - .set_reasoning_effort(Some(ReasoningEffortConfig::High)); - app.chat_widget - .set_collaboration_mask(CollaborationModeMask { - name: "Plan".to_string(), - mode: Some(ModeKind::Plan), - model: Some("gpt-restored".to_string()), - reasoning_effort: Some(Some(ReasoningEffortConfig::High)), - developer_instructions: None, - }); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected collaboration-only input state"); - - let (chat_widget, _app_event_tx, _rx, _new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget - .set_reasoning_effort(Some(ReasoningEffortConfig::Low)); - app.chat_widget - .set_collaboration_mask(CollaborationModeMask { - name: "Default".to_string(), - mode: Some(ModeKind::Default), - model: Some("gpt-replacement".to_string()), - reasoning_effort: Some(Some(ReasoningEffortConfig::Low)), - developer_instructions: None, - }); - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![], - input_state: Some(input_state), - }, - /*resume_restored_queue*/ true, - ); - - assert_eq!( - app.chat_widget.active_collaboration_mode_kind(), - ModeKind::Plan - ); - assert_eq!(app.chat_widget.current_model(), "gpt-restored"); - assert_eq!( - app.chat_widget.current_reasoning_effort(), - Some(ReasoningEffortConfig::High) - ); - } - - #[tokio::test] - async fn replayed_interrupted_turn_restores_queued_input_to_composer() { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - app.chat_widget.handle_thread_session(session.clone()); - app.chat_widget.handle_server_notification( - turn_started_notification(thread_id, "turn-1"), - /*replay_kind*/ None, - ); - app.chat_widget.handle_server_notification( - agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), - /*replay_kind*/ None, - ); - app.chat_widget - .apply_external_edit("queued follow-up".to_string()); - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); - let input_state = app - .chat_widget - .capture_thread_input_state() - .expect("expected queued follow-up state"); - - let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = - make_chatwidget_manual_with_sender().await; - app.chat_widget = chat_widget; - app.chat_widget.handle_thread_session(session.clone()); - while new_op_rx.try_recv().is_ok() {} - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![ThreadBufferedEvent::Notification( - turn_completed_notification(thread_id, "turn-1", TurnStatus::Interrupted), - )], - input_state: Some(input_state), - }, - /*resume_restored_queue*/ true, - ); - - assert_eq!( - app.chat_widget.composer_text_with_pending(), - "queued follow-up" - ); - assert!(app.chat_widget.queued_user_message_texts().is_empty()); - assert!( - new_op_rx.try_recv().is_err(), - "replayed interrupted turns should restore queued input for editing, not submit it" - ); - } - - #[tokio::test] - async fn token_usage_update_refreshes_status_line_with_runtime_context_window() { - let mut app = make_test_app().await; - app.chat_widget - .setup_status_line(vec![crate::bottom_pane::StatusLineItem::ContextWindowSize]); - - assert_eq!(app.chat_widget.status_line_text(), None); - - app.handle_thread_event_now(ThreadBufferedEvent::Notification(token_usage_notification( - ThreadId::new(), - "turn-1", - Some(950_000), - ))); - - assert_eq!( - app.chat_widget.status_line_text(), - Some("950K window".into()) - ); - } - - #[tokio::test] - async fn open_agent_picker_keeps_missing_threads_for_replay() -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let thread_id = ThreadId::new(); - app.thread_event_channels - .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - - app.open_agent_picker(&mut app_server).await; - - assert_eq!(app.thread_event_channels.contains_key(&thread_id), true); - assert_eq!( - app.agent_navigation.get(&thread_id), - Some(&AgentPickerThreadEntry { - agent_nickname: None, - agent_role: None, - is_closed: true, - }) - ); - assert_eq!(app.agent_navigation.ordered_thread_ids(), vec![thread_id]); - Ok(()) - } - - #[tokio::test] - async fn open_agent_picker_preserves_cached_metadata_for_replay_threads() -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let thread_id = ThreadId::new(); - app.thread_event_channels - .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - app.agent_navigation.upsert( - thread_id, - Some("Robie".to_string()), - Some("explorer".to_string()), - /*is_closed*/ true, - ); - - app.open_agent_picker(&mut app_server).await; - - assert_eq!(app.thread_event_channels.contains_key(&thread_id), true); - assert_eq!( - app.agent_navigation.get(&thread_id), - Some(&AgentPickerThreadEntry { - agent_nickname: Some("Robie".to_string()), - agent_role: Some("explorer".to_string()), - is_closed: true, - }) - ); - Ok(()) - } - - #[tokio::test] - async fn open_agent_picker_prunes_terminal_metadata_only_threads() -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let thread_id = ThreadId::new(); - app.agent_navigation.upsert( - thread_id, - Some("Ghost".to_string()), - Some("worker".to_string()), - /*is_closed*/ false, - ); - - app.open_agent_picker(&mut app_server).await; - - assert_eq!(app.agent_navigation.get(&thread_id), None); - assert!(app.agent_navigation.is_empty()); - Ok(()) - } - - #[tokio::test] - async fn open_agent_picker_marks_terminal_read_errors_closed() -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let thread_id = ThreadId::new(); - app.thread_event_channels - .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - app.agent_navigation.upsert( - thread_id, - Some("Robie".to_string()), - Some("explorer".to_string()), - /*is_closed*/ false, - ); - - app.open_agent_picker(&mut app_server).await; - - assert_eq!( - app.agent_navigation.get(&thread_id), - Some(&AgentPickerThreadEntry { - agent_nickname: Some("Robie".to_string()), - agent_role: Some("explorer".to_string()), - is_closed: true, - }) - ); - Ok(()) - } - - #[test] - fn terminal_thread_read_error_detection_matches_not_loaded_errors() { - let err = color_eyre::eyre::eyre!( - "thread/read failed during TUI session lookup: thread/read failed: thread not loaded: thr_123" - ); - - assert!(App::is_terminal_thread_read_error(&err)); - } - - #[test] - fn terminal_thread_read_error_detection_ignores_transient_failures() { - let err = color_eyre::eyre::eyre!( - "thread/read failed during TUI session lookup: thread/read transport error: broken pipe" - ); - - assert!(!App::is_terminal_thread_read_error(&err)); - } - - #[test] - fn closed_state_for_thread_read_error_preserves_live_state_without_cache_on_transient_error() { - let err = color_eyre::eyre::eyre!( - "thread/read failed during TUI session lookup: thread/read transport error: broken pipe" - ); - - assert!(!App::closed_state_for_thread_read_error( - &err, /*existing_is_closed*/ None - )); - } - - #[test] - fn closed_state_for_thread_read_error_marks_terminal_uncached_threads_closed() { - let err = color_eyre::eyre::eyre!( - "thread/read failed during TUI session lookup: thread/read failed: thread not loaded: thr_123" - ); - - assert!(App::closed_state_for_thread_read_error( - &err, /*existing_is_closed*/ None - )); - } - - #[test] - fn include_turns_fallback_detection_handles_unmaterialized_and_ephemeral_threads() { - let unmaterialized = color_eyre::eyre::eyre!( - "thread/read failed during TUI session lookup: thread/read failed: thread thr_123 is not materialized yet; includeTurns is unavailable before first user message" - ); - let ephemeral = color_eyre::eyre::eyre!( - "thread/read failed during TUI session lookup: thread/read failed: ephemeral threads do not support includeTurns" - ); - - assert!(App::can_fallback_from_include_turns_error(&unmaterialized)); - assert!(App::can_fallback_from_include_turns_error(&ephemeral)); - } - - #[tokio::test] - async fn open_agent_picker_marks_loaded_threads_open() -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let started = app_server - .start_thread(app.chat_widget.config_ref()) - .await?; - let thread_id = started.session.thread_id; - app.thread_event_channels - .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - - app.open_agent_picker(&mut app_server).await; - - assert_eq!( - app.agent_navigation.get(&thread_id), - Some(&AgentPickerThreadEntry { - agent_nickname: None, - agent_role: None, - is_closed: false, - }) - ); - Ok(()) - } - - #[tokio::test] - async fn attach_live_thread_for_selection_rejects_empty_non_ephemeral_fallback_threads() - -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let started = app_server - .start_thread(app.chat_widget.config_ref()) - .await?; - let thread_id = started.session.thread_id; - app.agent_navigation.upsert( - thread_id, - Some("Scout".to_string()), - Some("worker".to_string()), - /*is_closed*/ false, - ); - - let err = app - .attach_live_thread_for_selection(&mut app_server, thread_id) - .await - .expect_err("empty fallback should not attach as a blank replay-only thread"); - - assert_eq!( - err.to_string(), - format!("Agent thread {thread_id} is not yet available for replay or live attach.") - ); - assert!(!app.thread_event_channels.contains_key(&thread_id)); - Ok(()) - } - - #[tokio::test] - async fn attach_live_thread_for_selection_rejects_unmaterialized_fallback_threads() -> Result<()> - { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let mut ephemeral_config = app.chat_widget.config_ref().clone(); - ephemeral_config.ephemeral = true; - let started = app_server.start_thread(&ephemeral_config).await?; - let thread_id = started.session.thread_id; - app.agent_navigation.upsert( - thread_id, - Some("Scout".to_string()), - Some("worker".to_string()), - /*is_closed*/ false, - ); - - let err = app - .attach_live_thread_for_selection(&mut app_server, thread_id) - .await - .expect_err("ephemeral fallback should not attach as a blank live thread"); - - assert_eq!( - err.to_string(), - format!("Agent thread {thread_id} is not yet available for replay or live attach.") - ); - assert!(!app.thread_event_channels.contains_key(&thread_id)); - Ok(()) - } - - #[tokio::test] - async fn should_attach_live_thread_for_selection_skips_closed_metadata_only_threads() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - app.agent_navigation.upsert( - thread_id, - Some("Ghost".to_string()), - Some("worker".to_string()), - /*is_closed*/ true, - ); - - assert!(!app.should_attach_live_thread_for_selection(thread_id)); - - app.agent_navigation.upsert( - thread_id, - Some("Ghost".to_string()), - Some("worker".to_string()), - /*is_closed*/ false, - ); - assert!(app.should_attach_live_thread_for_selection(thread_id)); - - app.thread_event_channels - .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - assert!(!app.should_attach_live_thread_for_selection(thread_id)); - } - - #[tokio::test] - async fn refresh_agent_picker_thread_liveness_prunes_closed_metadata_only_threads() -> Result<()> - { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let thread_id = ThreadId::new(); - app.agent_navigation.upsert( - thread_id, - Some("Ghost".to_string()), - Some("worker".to_string()), - /*is_closed*/ false, - ); - - let is_available = app - .refresh_agent_picker_thread_liveness(&mut app_server, thread_id) - .await; - - assert!(!is_available); - assert_eq!(app.agent_navigation.get(&thread_id), None); - assert!(!app.thread_event_channels.contains_key(&thread_id)); - Ok(()) - } - - #[tokio::test] - async fn open_agent_picker_prompts_to_enable_multi_agent_when_disabled() -> Result<()> { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let _ = app.config.features.disable(Feature::Collab); - - app.open_agent_picker(&mut app_server).await; - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); - - assert_matches!( - app_event_rx.try_recv(), - Ok(AppEvent::UpdateFeatureFlags { updates }) if updates == vec![(Feature::Collab, true)] - ); - let cell = match app_event_rx.try_recv() { - Ok(AppEvent::InsertHistoryCell(cell)) => cell, - other => panic!("expected InsertHistoryCell event, got {other:?}"), - }; - let rendered = cell - .display_lines(/*width*/ 120) - .into_iter() - .map(|line| line.to_string()) - .collect::>() - .join("\n"); - assert!(rendered.contains("Subagents will be enabled in the next session.")); - Ok(()) - } - - #[tokio::test] - async fn update_memory_settings_persists_and_updates_widget_config() -> Result<()> { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; - - app.update_memory_settings_with_app_server( - &mut app_server, - /*use_memories*/ false, - /*generate_memories*/ false, - ) - .await; - - assert!(!app.config.memories.use_memories); - assert!(!app.config.memories.generate_memories); - assert!(!app.chat_widget.config_ref().memories.use_memories); - assert!(!app.chat_widget.config_ref().memories.generate_memories); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - let config_value = toml::from_str::(&config)?; - let memories = config_value - .as_table() - .and_then(|table| table.get("memories")) - .and_then(TomlValue::as_table) - .expect("memories table should exist"); - assert_eq!( - memories.get("use_memories"), - Some(&TomlValue::Boolean(false)) - ); - assert_eq!( - memories.get("generate_memories"), - Some(&TomlValue::Boolean(false)) - ); - assert!( - !memories.contains_key("disable_on_external_context") - && !memories.contains_key("no_memories_if_mcp_or_web_search"), - "the TUI menu should not write the external-context memory setting" - ); - app_server.shutdown().await?; - Ok(()) - } - - #[tokio::test] - async fn update_memory_settings_updates_current_thread_memory_mode() -> Result<()> { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - // Seed the previous setting so this test exercises the thread-mode update path. - app.config.memories.generate_memories = true; - - let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; - let started = app_server.start_thread(&app.config).await?; - let thread_id = started.session.thread_id; - app.active_thread_id = Some(thread_id); - - app.update_memory_settings_with_app_server( - &mut app_server, - /*use_memories*/ true, - /*generate_memories*/ false, - ) - .await; - - let state_db = codex_state::StateRuntime::init( - codex_home.path().to_path_buf(), - app.config.model_provider_id.clone(), - ) - .await - .expect("state db should initialize"); - let memory_mode = state_db - .get_thread_memory_mode(thread_id) - .await - .expect("thread memory mode should be readable"); - assert_eq!(memory_mode.as_deref(), Some("disabled")); - - app_server.shutdown().await?; - Ok(()) - } - - #[tokio::test] - async fn reset_memories_clears_local_memory_directories() -> Result<()> { - let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - app.config.sqlite_home = codex_home.path().to_path_buf(); - - let memory_root = codex_home.path().join("memories"); - let extensions_root = codex_home.path().join("memories_extensions"); - std::fs::create_dir_all(memory_root.join("rollout_summaries"))?; - std::fs::create_dir_all(&extensions_root)?; - std::fs::write(memory_root.join("MEMORY.md"), "stale memory\n")?; - std::fs::write( - memory_root.join("rollout_summaries").join("stale.md"), - "stale summary\n", - )?; - std::fs::write(extensions_root.join("stale.txt"), "stale extension\n")?; - - let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; - - app.reset_memories_with_app_server(&mut app_server).await; - - assert_eq!(std::fs::read_dir(&memory_root)?.count(), 0); - assert_eq!(std::fs::read_dir(&extensions_root)?.count(), 0); - - app_server.shutdown().await?; - Ok(()) - } - - #[tokio::test] - async fn update_feature_flags_enabling_guardian_selects_guardian_approvals() -> Result<()> { - let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - let guardian_approvals = guardian_approvals_mode(); - - app.update_feature_flags(vec![(Feature::GuardianApproval, true)]) - .await; - - assert!(app.config.features.enabled(Feature::GuardianApproval)); - assert!( - app.chat_widget - .config_ref() - .features - .enabled(Feature::GuardianApproval) - ); - assert_eq!( - app.config.approvals_reviewer, - guardian_approvals.approvals_reviewer - ); - assert_eq!( - app.config.permissions.approval_policy.value(), - guardian_approvals.approval_policy - ); - assert_eq!( - app.chat_widget - .config_ref() - .permissions - .approval_policy - .value(), - guardian_approvals.approval_policy - ); - assert_eq!( - app.chat_widget - .config_ref() - .permissions - .sandbox_policy - .get(), - &guardian_approvals.sandbox_policy - ); - assert_eq!( - app.chat_widget.config_ref().approvals_reviewer, - guardian_approvals.approvals_reviewer - ); - assert_eq!(app.runtime_approval_policy_override, None); - assert_eq!(app.runtime_sandbox_policy_override, None); - assert_eq!( - op_rx.try_recv(), - Ok(Op::OverrideTurnContext { - cwd: None, - approval_policy: Some(guardian_approvals.approval_policy), - approvals_reviewer: Some(guardian_approvals.approvals_reviewer), - sandbox_policy: Some(guardian_approvals.sandbox_policy.clone()), - windows_sandbox_level: None, - model: None, - effort: None, - summary: None, - service_tier: None, - collaboration_mode: None, - personality: None, - }) - ); - let cell = match app_event_rx.try_recv() { - Ok(AppEvent::InsertHistoryCell(cell)) => cell, - other => panic!("expected InsertHistoryCell event, got {other:?}"), - }; - let rendered = cell - .display_lines(/*width*/ 120) - .into_iter() - .map(|line| line.to_string()) - .collect::>() - .join("\n"); - assert!(rendered.contains("Permissions updated to Auto-review")); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - assert!(config.contains("guardian_approval = true")); - assert!(config.contains("approvals_reviewer = \"guardian_subagent\"")); - assert!(config.contains("approval_policy = \"on-request\"")); - assert!(config.contains("sandbox_mode = \"workspace-write\"")); - Ok(()) - } - - #[tokio::test] - async fn update_feature_flags_disabling_guardian_clears_review_policy_and_restores_default() - -> Result<()> { - let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - let config_toml_path = codex_home.path().join("config.toml").abs(); - let config_toml = "approvals_reviewer = \"guardian_subagent\"\napproval_policy = \"on-request\"\nsandbox_mode = \"workspace-write\"\n\n[features]\nguardian_approval = true\n"; - std::fs::write(config_toml_path.as_path(), config_toml)?; - let user_config = toml::from_str::(config_toml)?; - app.config.config_layer_stack = app - .config - .config_layer_stack - .with_user_config(&config_toml_path, user_config); - app.config - .features - .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; - app.chat_widget - .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); - app.config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; - app.chat_widget - .set_approvals_reviewer(ApprovalsReviewer::GuardianSubagent); - app.config - .permissions - .approval_policy - .set(AskForApproval::OnRequest)?; - app.config - .permissions - .sandbox_policy - .set(SandboxPolicy::new_workspace_write_policy())?; - app.chat_widget - .set_approval_policy(AskForApproval::OnRequest); - app.chat_widget - .set_sandbox_policy(SandboxPolicy::new_workspace_write_policy())?; - - app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) - .await; - - assert!(!app.config.features.enabled(Feature::GuardianApproval)); - assert!( - !app.chat_widget - .config_ref() - .features - .enabled(Feature::GuardianApproval) - ); - assert_eq!(app.config.approvals_reviewer, ApprovalsReviewer::User); - assert_eq!( - app.config.permissions.approval_policy.value(), - AskForApproval::OnRequest - ); - assert_eq!( - app.chat_widget.config_ref().approvals_reviewer, - ApprovalsReviewer::User - ); - assert_eq!(app.runtime_approval_policy_override, None); - assert_eq!( - op_rx.try_recv(), - Ok(Op::OverrideTurnContext { - cwd: None, - approval_policy: None, - approvals_reviewer: Some(ApprovalsReviewer::User), - sandbox_policy: None, - windows_sandbox_level: None, - model: None, - effort: None, - summary: None, - service_tier: None, - collaboration_mode: None, - personality: None, - }) - ); - let cell = match app_event_rx.try_recv() { - Ok(AppEvent::InsertHistoryCell(cell)) => cell, - other => panic!("expected InsertHistoryCell event, got {other:?}"), - }; - let rendered = cell - .display_lines(/*width*/ 120) - .into_iter() - .map(|line| line.to_string()) - .collect::>() - .join("\n"); - assert!(rendered.contains("Permissions updated to Default")); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - assert!(!config.contains("guardian_approval = true")); - assert!(!config.contains("approvals_reviewer =")); - assert!(config.contains("approval_policy = \"on-request\"")); - assert!(config.contains("sandbox_mode = \"workspace-write\"")); - Ok(()) - } - - #[tokio::test] - async fn update_feature_flags_enabling_guardian_overrides_explicit_manual_review_policy() - -> Result<()> { - let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - let guardian_approvals = guardian_approvals_mode(); - let config_toml_path = codex_home.path().join("config.toml").abs(); - let config_toml = "approvals_reviewer = \"user\"\n"; - std::fs::write(config_toml_path.as_path(), config_toml)?; - let user_config = toml::from_str::(config_toml)?; - app.config.config_layer_stack = app - .config - .config_layer_stack - .with_user_config(&config_toml_path, user_config); - app.config.approvals_reviewer = ApprovalsReviewer::User; - app.chat_widget - .set_approvals_reviewer(ApprovalsReviewer::User); - - app.update_feature_flags(vec![(Feature::GuardianApproval, true)]) - .await; - - assert!(app.config.features.enabled(Feature::GuardianApproval)); - assert_eq!( - app.config.approvals_reviewer, - guardian_approvals.approvals_reviewer - ); - assert_eq!( - app.chat_widget.config_ref().approvals_reviewer, - guardian_approvals.approvals_reviewer - ); - assert_eq!( - app.config.permissions.approval_policy.value(), - guardian_approvals.approval_policy - ); - assert_eq!( - app.chat_widget - .config_ref() - .permissions - .sandbox_policy - .get(), - &guardian_approvals.sandbox_policy - ); - assert_eq!( - op_rx.try_recv(), - Ok(Op::OverrideTurnContext { - cwd: None, - approval_policy: Some(guardian_approvals.approval_policy), - approvals_reviewer: Some(guardian_approvals.approvals_reviewer), - sandbox_policy: Some(guardian_approvals.sandbox_policy.clone()), - windows_sandbox_level: None, - model: None, - effort: None, - summary: None, - service_tier: None, - collaboration_mode: None, - personality: None, - }) - ); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - assert!(config.contains("approvals_reviewer = \"guardian_subagent\"")); - assert!(config.contains("guardian_approval = true")); - assert!(config.contains("approval_policy = \"on-request\"")); - assert!(config.contains("sandbox_mode = \"workspace-write\"")); - Ok(()) - } - - #[tokio::test] - async fn update_feature_flags_disabling_guardian_clears_manual_review_policy_without_history() - -> Result<()> { - let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - let config_toml_path = codex_home.path().join("config.toml").abs(); - let config_toml = "approvals_reviewer = \"user\"\napproval_policy = \"on-request\"\nsandbox_mode = \"workspace-write\"\n\n[features]\nguardian_approval = true\n"; - std::fs::write(config_toml_path.as_path(), config_toml)?; - let user_config = toml::from_str::(config_toml)?; - app.config.config_layer_stack = app - .config - .config_layer_stack - .with_user_config(&config_toml_path, user_config); - app.config - .features - .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; - app.chat_widget - .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); - app.config.approvals_reviewer = ApprovalsReviewer::User; - app.chat_widget - .set_approvals_reviewer(ApprovalsReviewer::User); - - app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) - .await; - - assert!(!app.config.features.enabled(Feature::GuardianApproval)); - assert_eq!(app.config.approvals_reviewer, ApprovalsReviewer::User); - assert_eq!( - app.chat_widget.config_ref().approvals_reviewer, - ApprovalsReviewer::User - ); - assert_eq!( - op_rx.try_recv(), - Ok(Op::OverrideTurnContext { - cwd: None, - approval_policy: None, - approvals_reviewer: Some(ApprovalsReviewer::User), - sandbox_policy: None, - windows_sandbox_level: None, - model: None, - effort: None, - summary: None, - service_tier: None, - collaboration_mode: None, - personality: None, - }) - ); - assert!( - app_event_rx.try_recv().is_err(), - "manual review should not emit a permissions history update when the effective state stays default" - ); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - assert!(!config.contains("guardian_approval = true")); - assert!(!config.contains("approvals_reviewer =")); - Ok(()) - } - - #[tokio::test] - async fn update_feature_flags_enabling_guardian_in_profile_sets_profile_auto_review_policy() - -> Result<()> { - let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - let guardian_approvals = guardian_approvals_mode(); - app.active_profile = Some("guardian".to_string()); - let config_toml_path = codex_home.path().join("config.toml").abs(); - let config_toml = "profile = \"guardian\"\napprovals_reviewer = \"user\"\n"; - std::fs::write(config_toml_path.as_path(), config_toml)?; - let user_config = toml::from_str::(config_toml)?; - app.config.config_layer_stack = app - .config - .config_layer_stack - .with_user_config(&config_toml_path, user_config); - app.config.approvals_reviewer = ApprovalsReviewer::User; - app.chat_widget - .set_approvals_reviewer(ApprovalsReviewer::User); - - app.update_feature_flags(vec![(Feature::GuardianApproval, true)]) - .await; - - assert!(app.config.features.enabled(Feature::GuardianApproval)); - assert_eq!( - app.config.approvals_reviewer, - guardian_approvals.approvals_reviewer - ); - assert_eq!( - app.chat_widget.config_ref().approvals_reviewer, - guardian_approvals.approvals_reviewer - ); - assert_eq!( - op_rx.try_recv(), - Ok(Op::OverrideTurnContext { - cwd: None, - approval_policy: Some(guardian_approvals.approval_policy), - approvals_reviewer: Some(guardian_approvals.approvals_reviewer), - sandbox_policy: Some(guardian_approvals.sandbox_policy.clone()), - windows_sandbox_level: None, - model: None, - effort: None, - summary: None, - service_tier: None, - collaboration_mode: None, - personality: None, - }) - ); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - let config_value = toml::from_str::(&config)?; - let profile_config = config_value - .as_table() - .and_then(|table| table.get("profiles")) - .and_then(TomlValue::as_table) - .and_then(|profiles| profiles.get("guardian")) - .and_then(TomlValue::as_table) - .expect("guardian profile should exist"); - assert_eq!( - config_value - .as_table() - .and_then(|table| table.get("approvals_reviewer")), - Some(&TomlValue::String("user".to_string())) - ); - assert_eq!( - profile_config.get("approvals_reviewer"), - Some(&TomlValue::String("guardian_subagent".to_string())) - ); - Ok(()) - } - - #[tokio::test] - async fn update_feature_flags_disabling_guardian_in_profile_allows_inherited_user_reviewer() - -> Result<()> { - let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - app.active_profile = Some("guardian".to_string()); - let config_toml_path = codex_home.path().join("config.toml").abs(); - let config_toml = r#" -profile = "guardian" -approvals_reviewer = "user" - -[profiles.guardian] -approvals_reviewer = "guardian_subagent" - -[profiles.guardian.features] -guardian_approval = true -"#; - std::fs::write(config_toml_path.as_path(), config_toml)?; - let user_config = toml::from_str::(config_toml)?; - app.config.config_layer_stack = app - .config - .config_layer_stack - .with_user_config(&config_toml_path, user_config); - app.config - .features - .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; - app.chat_widget - .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); - app.config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; - app.chat_widget - .set_approvals_reviewer(ApprovalsReviewer::GuardianSubagent); - - app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) - .await; - - assert!(!app.config.features.enabled(Feature::GuardianApproval)); - assert!( - !app.chat_widget - .config_ref() - .features - .enabled(Feature::GuardianApproval) - ); - assert_eq!(app.config.approvals_reviewer, ApprovalsReviewer::User); - assert_eq!( - app.chat_widget.config_ref().approvals_reviewer, - ApprovalsReviewer::User - ); - assert_eq!( - op_rx.try_recv(), - Ok(Op::OverrideTurnContext { - cwd: None, - approval_policy: None, - approvals_reviewer: Some(ApprovalsReviewer::User), - sandbox_policy: None, - windows_sandbox_level: None, - model: None, - effort: None, - summary: None, - service_tier: None, - collaboration_mode: None, - personality: None, - }) - ); - let cell = match app_event_rx.try_recv() { - Ok(AppEvent::InsertHistoryCell(cell)) => cell, - other => panic!("expected InsertHistoryCell event, got {other:?}"), - }; - let rendered = cell - .display_lines(/*width*/ 120) - .into_iter() - .map(|line| line.to_string()) - .collect::>() - .join("\n"); - assert!(rendered.contains("Permissions updated to Default")); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - assert!(!config.contains("guardian_approval = true")); - assert!(!config.contains("guardian_subagent")); - assert_eq!( - toml::from_str::(&config)? - .as_table() - .and_then(|table| table.get("approvals_reviewer")), - Some(&TomlValue::String("user".to_string())) - ); - Ok(()) - } - - #[tokio::test] - async fn update_feature_flags_disabling_guardian_in_profile_keeps_inherited_non_user_reviewer_enabled() - -> Result<()> { - let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - app.active_profile = Some("guardian".to_string()); - let config_toml_path = codex_home.path().join("config.toml").abs(); - let config_toml = "profile = \"guardian\"\napprovals_reviewer = \"guardian_subagent\"\n\n[features]\nguardian_approval = true\n"; - std::fs::write(config_toml_path.as_path(), config_toml)?; - let user_config = toml::from_str::(config_toml)?; - app.config.config_layer_stack = app - .config - .config_layer_stack - .with_user_config(&config_toml_path, user_config); - app.config - .features - .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; - app.chat_widget - .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); - app.config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; - app.chat_widget - .set_approvals_reviewer(ApprovalsReviewer::GuardianSubagent); - - app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) - .await; - - assert!(app.config.features.enabled(Feature::GuardianApproval)); - assert!( - app.chat_widget - .config_ref() - .features - .enabled(Feature::GuardianApproval) - ); - assert_eq!( - app.config.approvals_reviewer, - ApprovalsReviewer::GuardianSubagent - ); - assert_eq!( - app.chat_widget.config_ref().approvals_reviewer, - ApprovalsReviewer::GuardianSubagent - ); - assert!( - op_rx.try_recv().is_err(), - "disabling an inherited non-user reviewer should not patch the active session" - ); - let app_events = std::iter::from_fn(|| app_event_rx.try_recv().ok()).collect::>(); - assert!( - !app_events.iter().any(|event| match event { - AppEvent::InsertHistoryCell(cell) => cell - .display_lines(/*width*/ 120) - .iter() - .any(|line| line.to_string().contains("Permissions updated to")), - _ => false, - }), - "blocking disable with inherited guardian review should not emit a permissions history update: {app_events:?}" - ); - - let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; - assert!(config.contains("guardian_approval = true")); - assert_eq!( - toml::from_str::(&config)? - .as_table() - .and_then(|table| table.get("approvals_reviewer")), - Some(&TomlValue::String("guardian_subagent".to_string())) - ); - Ok(()) - } - - #[tokio::test] - async fn open_agent_picker_allows_existing_agent_threads_when_feature_is_disabled() -> Result<()> - { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let thread_id = ThreadId::new(); - app.thread_event_channels - .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - - app.open_agent_picker(&mut app_server).await; - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); - - assert_matches!( - app_event_rx.try_recv(), - Ok(AppEvent::SelectAgentThread(selected_thread_id)) if selected_thread_id == thread_id - ); - Ok(()) - } - - #[tokio::test] - async fn refresh_pending_thread_approvals_only_lists_inactive_threads() { - let mut app = make_test_app().await; - let main_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000001").expect("valid thread"); - let agent_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000002").expect("valid thread"); - - app.primary_thread_id = Some(main_thread_id); - app.active_thread_id = Some(main_thread_id); - app.thread_event_channels - .insert(main_thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - - let agent_channel = ThreadEventChannel::new(/*capacity*/ 1); - { - let mut store = agent_channel.store.lock().await; - store.push_request(exec_approval_request( - agent_thread_id, - "turn-1", - "call-1", - /*approval_id*/ None, - )); - } - app.thread_event_channels - .insert(agent_thread_id, agent_channel); - app.agent_navigation.upsert( - agent_thread_id, - Some("Robie".to_string()), - Some("explorer".to_string()), - /*is_closed*/ false, - ); - - app.refresh_pending_thread_approvals().await; - assert_eq!( - app.chat_widget.pending_thread_approvals(), - &["Robie [explorer]".to_string()] - ); - - app.active_thread_id = Some(agent_thread_id); - app.refresh_pending_thread_approvals().await; - assert!(app.chat_widget.pending_thread_approvals().is_empty()); - } - - #[tokio::test] - async fn inactive_thread_approval_bubbles_into_active_view() -> Result<()> { - let mut app = make_test_app().await; - let main_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); - let agent_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000022").expect("valid thread"); - - app.primary_thread_id = Some(main_thread_id); - app.active_thread_id = Some(main_thread_id); - app.thread_event_channels - .insert(main_thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - app.thread_event_channels.insert( - agent_thread_id, - ThreadEventChannel::new_with_session( - /*capacity*/ 1, - ThreadSessionState { - approval_policy: AskForApproval::OnRequest, - sandbox_policy: SandboxPolicy::new_workspace_write_policy(), - rollout_path: Some(test_path_buf("/tmp/agent-rollout.jsonl")), - ..test_thread_session(agent_thread_id, test_path_buf("/tmp/agent")) - }, - Vec::new(), - ), - ); - app.agent_navigation.upsert( - agent_thread_id, - Some("Robie".to_string()), - Some("explorer".to_string()), - /*is_closed*/ false, - ); - - app.enqueue_thread_request( - agent_thread_id, - exec_approval_request( - agent_thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - ), - ) - .await?; - - assert_eq!(app.chat_widget.has_active_view(), true); - assert_eq!( - app.chat_widget.pending_thread_approvals(), - &["Robie [explorer]".to_string()] - ); - - Ok(()) - } - - #[tokio::test] - async fn side_defers_parent_approval_overlay_until_parent_replay() -> Result<()> { - let mut app = make_test_app().await; - let parent_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); - let side_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000022").expect("valid thread"); - - app.primary_thread_id = Some(parent_thread_id); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - app.thread_event_channels.insert( - parent_thread_id, - ThreadEventChannel::new_with_session( - /*capacity*/ 4, - test_thread_session(parent_thread_id, test_path_buf("/tmp/main")), - Vec::new(), - ), - ); - - app.enqueue_thread_request( - parent_thread_id, - exec_approval_request( - parent_thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - ), - ) - .await?; - - assert_eq!(app.chat_widget.has_active_view(), false); - assert!(app.chat_widget.pending_thread_approvals().is_empty()); - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - Some(SideParentStatus::NeedsApproval) - ); - - let snapshot = { - let channel = app - .thread_event_channels - .get(&parent_thread_id) - .expect("parent thread channel"); - let store = channel.store.lock().await; - store.snapshot() - }; - app.side_threads.remove(&side_thread_id); - app.active_thread_id = Some(parent_thread_id); - app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ false); - - assert_eq!(app.chat_widget.has_active_view(), true); - - Ok(()) - } - - #[tokio::test] - async fn replay_snapshot_with_pending_request_suppresses_replay_notices() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); - let stale_warning = "stale startup warning that should not cover the approval"; - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: Some(test_thread_session(thread_id, test_path_buf("/tmp/main"))), - turns: Vec::new(), - events: vec![ - ThreadBufferedEvent::Notification(ServerNotification::Warning( - WarningNotification { - thread_id: Some(thread_id.to_string()), - message: stale_warning.to_string(), - }, - )), - ThreadBufferedEvent::Request(exec_approval_request( - thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - )), - ], - input_state: None, - }, - /*resume_restored_queue*/ false, - ); - - assert_eq!(app.chat_widget.has_active_view(), true); - - let mut replayed_history = String::new(); - while let Ok(event) = app_event_rx.try_recv() { - if let AppEvent::InsertHistoryCell(cell) = event { - replayed_history.push_str(&lines_to_single_string( - &cell.transcript_lines(/*width*/ 80), - )); - } - } - - assert!( - replayed_history.is_empty(), - "expected pending approval replay to suppress session notices, got {replayed_history:?}" - ); - } - - #[tokio::test] - async fn side_defers_subagent_approval_overlay_until_side_exits() -> Result<()> { - let mut app = make_test_app().await; - let main_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); - let side_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000022").expect("valid thread"); - let agent_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000033").expect("valid thread"); - - app.primary_thread_id = Some(main_thread_id); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(main_thread_id)); - app.thread_event_channels.insert( - agent_thread_id, - ThreadEventChannel::new_with_session( - /*capacity*/ 4, - ThreadSessionState { - approval_policy: AskForApproval::OnRequest, - sandbox_policy: SandboxPolicy::new_workspace_write_policy(), - rollout_path: Some(test_path_buf("/tmp/agent-rollout.jsonl")), - ..test_thread_session(agent_thread_id, test_path_buf("/tmp/agent")) - }, - Vec::new(), - ), - ); - app.agent_navigation.upsert( - agent_thread_id, - Some("Robie".to_string()), - Some("explorer".to_string()), - /*is_closed*/ false, - ); - - app.enqueue_thread_request( - agent_thread_id, - exec_approval_request( - agent_thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - ), - ) - .await?; - - assert_eq!(app.chat_widget.has_active_view(), false); - assert_eq!( - app.chat_widget.pending_thread_approvals(), - &["Robie [explorer]".to_string()] - ); - - app.side_threads.remove(&side_thread_id); - app.active_thread_id = Some(main_thread_id); - app.surface_pending_inactive_thread_interactive_requests() - .await; - - assert_eq!(app.chat_widget.has_active_view(), true); - - Ok(()) - } - - #[tokio::test] - async fn inactive_thread_exec_approval_preserves_context() { - let app = make_test_app().await; - let thread_id = ThreadId::new(); - let mut request = exec_approval_request( - thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - ); - let ServerRequest::CommandExecutionRequestApproval { params, .. } = &mut request else { - panic!("expected exec approval request"); - }; - params.network_approval_context = Some(AppServerNetworkApprovalContext { - host: "example.com".to_string(), - protocol: AppServerNetworkApprovalProtocol::Socks5Tcp, - }); - params.additional_permissions = Some(AdditionalPermissionProfile { - network: Some(AdditionalNetworkPermissions { - enabled: Some(true), - }), - file_system: Some(AdditionalFileSystemPermissions { - read: Some(vec![test_absolute_path("/tmp/read-only")]), - write: Some(vec![test_absolute_path("/tmp/write")]), - entries: None, - }), - }); - params.proposed_network_policy_amendments = Some(vec![AppServerNetworkPolicyAmendment { - host: "example.com".to_string(), - action: AppServerNetworkPolicyRuleAction::Allow, - }]); - - let Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Exec { - available_decisions, - network_approval_context, - additional_permissions, - .. - })) = app - .interactive_request_for_thread_request(thread_id, &request) - .await - else { - panic!("expected exec approval request"); - }; - - assert_eq!( - network_approval_context, - Some(NetworkApprovalContext { - host: "example.com".to_string(), - protocol: NetworkApprovalProtocol::Socks5Tcp, - }) - ); - assert_eq!( - additional_permissions, - Some(PermissionProfile { - network: Some(NetworkPermissions { - enabled: Some(true), - }), - file_system: Some(FileSystemPermissions::from_read_write_roots( - Some(vec![test_absolute_path("/tmp/read-only")]), - Some(vec![test_absolute_path("/tmp/write")]), - )), - }) - ); - assert_eq!( - available_decisions, - vec![ - codex_protocol::protocol::ReviewDecision::Approved, - codex_protocol::protocol::ReviewDecision::ApprovedForSession, - codex_protocol::protocol::ReviewDecision::NetworkPolicyAmendment { - network_policy_amendment: codex_protocol::approvals::NetworkPolicyAmendment { - host: "example.com".to_string(), - action: codex_protocol::approvals::NetworkPolicyRuleAction::Allow, - }, - }, - codex_protocol::protocol::ReviewDecision::Abort, - ] - ); - } - - #[tokio::test] - async fn inactive_thread_exec_approval_splits_shell_wrapped_command() { - let app = make_test_app().await; - let thread_id = ThreadId::new(); - let script = r#"python3 -c 'print("Hello, world!")'"#; - let mut request = exec_approval_request( - thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - ); - let ServerRequest::CommandExecutionRequestApproval { params, .. } = &mut request else { - panic!("expected exec approval request"); - }; - params.command = Some( - shlex::try_join(["/bin/zsh", "-lc", script]).expect("round-trippable shell wrapper"), - ); - - let Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Exec { command, .. })) = app - .interactive_request_for_thread_request(thread_id, &request) - .await - else { - panic!("expected exec approval request"); - }; - - assert_eq!( - command, - vec![ - "/bin/zsh".to_string(), - "-lc".to_string(), - script.to_string(), - ] - ); - } - - #[tokio::test] - async fn inactive_thread_permissions_approval_preserves_file_system_permissions() { - let app = make_test_app().await; - let thread_id = ThreadId::new(); - let request = ServerRequest::PermissionsRequestApproval { - request_id: AppServerRequestId::Integer(7), - params: PermissionsRequestApprovalParams { - thread_id: thread_id.to_string(), - turn_id: "turn-approval".to_string(), - item_id: "call-approval".to_string(), - reason: Some("Need access to .git".to_string()), - permissions: codex_app_server_protocol::RequestPermissionProfile { - network: Some(AdditionalNetworkPermissions { - enabled: Some(true), - }), - file_system: Some(AdditionalFileSystemPermissions { - read: Some(vec![test_absolute_path("/tmp/read-only")]), - write: Some(vec![test_absolute_path("/tmp/write")]), - entries: None, - }), - }, - }, - }; - - let Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Permissions { - permissions, - .. - })) = app - .interactive_request_for_thread_request(thread_id, &request) - .await - else { - panic!("expected permissions approval request"); - }; - - assert_eq!( - permissions, - RequestPermissionProfile { - network: Some(NetworkPermissions { - enabled: Some(true), - }), - file_system: Some(FileSystemPermissions::from_read_write_roots( - Some(vec![test_absolute_path("/tmp/read-only")]), - Some(vec![test_absolute_path("/tmp/write")]), - )), - } - ); - } - - #[tokio::test] - async fn inactive_thread_approval_badge_clears_after_turn_completion_notification() -> Result<()> - { - let mut app = make_test_app().await; - let main_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000101").expect("valid thread"); - let agent_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000202").expect("valid thread"); - - app.primary_thread_id = Some(main_thread_id); - app.active_thread_id = Some(main_thread_id); - app.thread_event_channels - .insert(main_thread_id, ThreadEventChannel::new(/*capacity*/ 1)); - app.thread_event_channels.insert( - agent_thread_id, - ThreadEventChannel::new_with_session( - /*capacity*/ 4, - ThreadSessionState { - approval_policy: AskForApproval::OnRequest, - sandbox_policy: SandboxPolicy::new_workspace_write_policy(), - rollout_path: Some(test_path_buf("/tmp/agent-rollout.jsonl")), - ..test_thread_session(agent_thread_id, test_path_buf("/tmp/agent")) - }, - Vec::new(), - ), - ); - app.agent_navigation.upsert( - agent_thread_id, - Some("Robie".to_string()), - Some("explorer".to_string()), - /*is_closed*/ false, - ); - - app.enqueue_thread_request( - agent_thread_id, - exec_approval_request( - agent_thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - ), - ) - .await?; - assert_eq!( - app.chat_widget.pending_thread_approvals(), - &["Robie [explorer]".to_string()] - ); - - app.enqueue_thread_notification( - agent_thread_id, - turn_completed_notification(agent_thread_id, "turn-approval", TurnStatus::Completed), - ) - .await?; - - assert!( - app.chat_widget.pending_thread_approvals().is_empty(), - "turn completion should clear inactive-thread approval badge immediately" - ); - - Ok(()) - } - - #[tokio::test] - async fn inactive_thread_started_notification_initializes_replay_session() -> Result<()> { - let mut app = make_test_app().await; - let temp_dir = tempdir()?; - let main_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000101").expect("valid thread"); - let agent_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000202").expect("valid thread"); - let primary_session = ThreadSessionState { - approval_policy: AskForApproval::OnRequest, - sandbox_policy: SandboxPolicy::new_workspace_write_policy(), - ..test_thread_session(main_thread_id, test_path_buf("/tmp/main")) - }; - - app.primary_thread_id = Some(main_thread_id); - app.active_thread_id = Some(main_thread_id); - app.primary_session_configured = Some(primary_session.clone()); - app.thread_event_channels.insert( - main_thread_id, - ThreadEventChannel::new_with_session( - /*capacity*/ 4, - primary_session.clone(), - Vec::new(), - ), - ); - - let rollout_path = temp_dir.path().join("agent-rollout.jsonl"); - let turn_context = TurnContextItem { - turn_id: None, - trace_id: None, - cwd: test_path_buf("/tmp/agent"), - current_date: None, - timezone: None, - approval_policy: primary_session.approval_policy, - sandbox_policy: primary_session.sandbox_policy.clone(), - network: None, - file_system_sandbox_policy: None, - model: "gpt-agent".to_string(), - personality: None, - collaboration_mode: None, - realtime_active: Some(false), - effort: primary_session.reasoning_effort, - summary: app.config.model_reasoning_summary.unwrap_or_default(), - user_instructions: None, - developer_instructions: None, - final_output_json_schema: None, - truncation_policy: None, - }; - let rollout = RolloutLine { - timestamp: "t0".to_string(), - item: RolloutItem::TurnContext(turn_context), - }; - std::fs::write( - &rollout_path, - format!("{}\n", serde_json::to_string(&rollout)?), - )?; - app.enqueue_thread_notification( - agent_thread_id, - ServerNotification::ThreadStarted(ThreadStartedNotification { - thread: Thread { - id: agent_thread_id.to_string(), - forked_from_id: None, - preview: "agent thread".to_string(), - ephemeral: false, - model_provider: "agent-provider".to_string(), - created_at: 1, - updated_at: 2, - status: codex_app_server_protocol::ThreadStatus::Idle, - path: Some(rollout_path.clone()), - cwd: test_path_buf("/tmp/agent").abs(), - cli_version: "0.0.0".to_string(), - source: codex_app_server_protocol::SessionSource::Unknown, - agent_nickname: Some("Robie".to_string()), - agent_role: Some("explorer".to_string()), - git_info: None, - name: Some("agent thread".to_string()), - turns: Vec::new(), - }, - }), - ) - .await?; - - let store = app - .thread_event_channels - .get(&agent_thread_id) - .expect("agent thread channel") - .store - .lock() - .await; - let session = store.session.clone().expect("inferred session"); - drop(store); - - assert_eq!(session.thread_id, agent_thread_id); - assert_eq!(session.thread_name, Some("agent thread".to_string())); - assert_eq!(session.model, "gpt-agent"); - assert_eq!(session.model_provider_id, "agent-provider"); - assert_eq!(session.approval_policy, primary_session.approval_policy); - assert_eq!(session.cwd.as_path(), test_path_buf("/tmp/agent").as_path()); - assert_eq!(session.rollout_path, Some(rollout_path)); - assert_eq!( - app.agent_navigation.get(&agent_thread_id), - Some(&AgentPickerThreadEntry { - agent_nickname: Some("Robie".to_string()), - agent_role: Some("explorer".to_string()), - is_closed: false, - }) - ); - - Ok(()) - } - - #[tokio::test] - async fn inactive_thread_started_notification_preserves_primary_model_when_path_missing() - -> Result<()> { - let mut app = make_test_app().await; - let main_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000301").expect("valid thread"); - let agent_thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000302").expect("valid thread"); - let primary_session = ThreadSessionState { - approval_policy: AskForApproval::OnRequest, - sandbox_policy: SandboxPolicy::new_workspace_write_policy(), - ..test_thread_session(main_thread_id, test_path_buf("/tmp/main")) - }; - - app.primary_thread_id = Some(main_thread_id); - app.active_thread_id = Some(main_thread_id); - app.primary_session_configured = Some(primary_session.clone()); - app.thread_event_channels.insert( - main_thread_id, - ThreadEventChannel::new_with_session( - /*capacity*/ 4, - primary_session.clone(), - Vec::new(), - ), - ); - - app.enqueue_thread_notification( - agent_thread_id, - ServerNotification::ThreadStarted(ThreadStartedNotification { - thread: Thread { - id: agent_thread_id.to_string(), - forked_from_id: None, - preview: "agent thread".to_string(), - ephemeral: false, - model_provider: "agent-provider".to_string(), - created_at: 1, - updated_at: 2, - status: codex_app_server_protocol::ThreadStatus::Idle, - path: None, - cwd: test_path_buf("/tmp/agent").abs(), - cli_version: "0.0.0".to_string(), - source: codex_app_server_protocol::SessionSource::Unknown, - agent_nickname: Some("Robie".to_string()), - agent_role: Some("explorer".to_string()), - git_info: None, - name: Some("agent thread".to_string()), - turns: Vec::new(), - }, - }), - ) - .await?; - - let store = app - .thread_event_channels - .get(&agent_thread_id) - .expect("agent thread channel") - .store - .lock() - .await; - let session = store.session.clone().expect("inferred session"); - - assert_eq!(session.model, primary_session.model); - - Ok(()) - } - - #[test] - fn agent_picker_item_name_snapshot() { - let thread_id = - ThreadId::from_string("00000000-0000-0000-0000-000000000123").expect("valid thread id"); - let snapshot = [ - format!( - "{} | {}", - format_agent_picker_item_name( - Some("Robie"), - Some("explorer"), - /*is_primary*/ true - ), - thread_id - ), - format!( - "{} | {}", - format_agent_picker_item_name( - Some("Robie"), - Some("explorer"), - /*is_primary*/ false - ), - thread_id - ), - format!( - "{} | {}", - format_agent_picker_item_name( - Some("Robie"), - /*agent_role*/ None, - /*is_primary*/ false - ), - thread_id - ), - format!( - "{} | {}", - format_agent_picker_item_name( - /*agent_nickname*/ None, - Some("explorer"), - /*is_primary*/ false - ), - thread_id - ), - format!( - "{} | {}", - format_agent_picker_item_name( - /*agent_nickname*/ None, /*agent_role*/ None, - /*is_primary*/ false - ), - thread_id - ), - ] - .join("\n"); - assert_snapshot!("agent_picker_item_name", snapshot); - } - - #[tokio::test] - async fn side_fork_config_is_ephemeral_and_appends_developer_guardrails() { - let mut app = make_test_app().await; - app.config.developer_instructions = Some("Existing developer policy.".to_string()); - let original_approval_policy = app.config.permissions.approval_policy.value(); - let original_sandbox_policy = app.config.permissions.sandbox_policy.get().clone(); - - let fork_config = app.side_fork_config(); - - assert!(fork_config.ephemeral); - assert_eq!( - fork_config.permissions.approval_policy.value(), - original_approval_policy - ); - assert_eq!( - fork_config.permissions.sandbox_policy.get(), - &original_sandbox_policy - ); - let developer_instructions = fork_config - .developer_instructions - .as_deref() - .expect("side developer instructions"); - assert!(developer_instructions.contains("Existing developer policy.")); - assert!( - developer_instructions.contains("You are in a side conversation, not the main thread.") - ); - assert!( - developer_instructions - .contains("inherited fork history is provided only as reference context") - ); - assert!(developer_instructions.contains( - "Only instructions submitted after the side-conversation boundary are active" - )); - assert!(developer_instructions.contains("Do not continue, execute, or complete any task")); - assert!( - developer_instructions - .contains("External tools may be available according to this thread's current") - ); - assert!( - developer_instructions - .contains("Any MCP or external tool calls or outputs visible in the inherited") - ); - assert!(developer_instructions.contains("non-mutating inspection")); - assert!(developer_instructions.contains("Do not modify files")); - assert!(developer_instructions.contains("Do not request escalated permissions")); - assert!(app.transcript_cells.is_empty()); - } - - #[test] - fn side_boundary_prompt_marks_inherited_history_reference_only() { - let item = App::side_boundary_prompt_item(); - let codex_protocol::models::ResponseItem::Message { role, content, .. } = item else { - panic!("expected hidden side boundary prompt to be a user message"); - }; - assert_eq!(role, "user"); - let [codex_protocol::models::ContentItem::InputText { text }] = content.as_slice() else { - panic!("expected hidden side boundary prompt text"); - }; - assert!(text.contains("Side conversation boundary.")); - assert!(text.contains("Everything before this boundary is inherited history")); - assert!(text.contains("It is not your current task.")); - assert!(text.contains("Only messages submitted after this boundary are active")); - assert!(text.contains("Do not continue, execute, or complete")); - assert!(text.contains("separate from the main thread")); - assert!( - text.contains("External tools may be available according to this thread's current") - ); - assert!(text.contains("Any tool calls or outputs visible before this boundary happened")); - assert!(text.contains("Do not modify files")); - } - - #[test] - fn side_return_shortcuts_match_esc_and_ctrl_c() { - assert!(side_return_shortcut_matches(KeyEvent::new( - KeyCode::Esc, - KeyModifiers::NONE, - ))); - assert!(side_return_shortcut_matches(KeyEvent::new_with_kind( - KeyCode::Esc, - KeyModifiers::NONE, - KeyEventKind::Repeat, - ))); - assert!(side_return_shortcut_matches(KeyEvent::new( - KeyCode::Char('c'), - KeyModifiers::CONTROL, - ))); - assert!(side_return_shortcut_matches(KeyEvent::new( - KeyCode::Char('C'), - KeyModifiers::CONTROL, - ))); - assert!(!side_return_shortcut_matches(KeyEvent::new( - KeyCode::Char('d'), - KeyModifiers::CONTROL, - ))); - assert!(!side_return_shortcut_matches(KeyEvent::new_with_kind( - KeyCode::Esc, - KeyModifiers::NONE, - KeyEventKind::Release, - ))); - } - - #[tokio::test] - async fn side_start_block_message_tracks_open_side_conversation() { - let mut app = make_test_app().await; - assert_eq!( - app.side_start_block_message(), - Some("'/side' is unavailable until the main thread is ready.") - ); - - app.primary_thread_id = Some(ThreadId::new()); - assert_eq!(app.side_start_block_message(), None); - - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - - assert_eq!( - app.side_start_block_message(), - Some( - "A side conversation is already open. Press Esc to return before starting another." - ) - ); - - app.side_threads.remove(&side_thread_id); - assert_eq!(app.side_start_block_message(), None); - } - - #[tokio::test] - async fn side_parent_status_tracks_parent_turn_lifecycle() -> Result<()> { - let mut app = make_test_app().await; - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.primary_thread_id = Some(parent_thread_id); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - - app.enqueue_thread_notification( - parent_thread_id, - turn_completed_notification(parent_thread_id, "turn-1", TurnStatus::Completed), - ) - .await?; - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - Some(SideParentStatus::Finished) - ); - - app.enqueue_thread_notification( - parent_thread_id, - turn_started_notification(parent_thread_id, "turn-2"), - ) - .await?; - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - None - ); - - app.enqueue_thread_notification( - parent_thread_id, - turn_completed_notification(parent_thread_id, "turn-2", TurnStatus::Failed), - ) - .await?; - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - Some(SideParentStatus::Failed) - ); - - Ok(()) - } - - #[tokio::test] - async fn side_parent_status_prioritizes_input_over_approval() -> Result<()> { - let mut app = make_test_app().await; - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.primary_thread_id = Some(parent_thread_id); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - - app.enqueue_thread_request( - parent_thread_id, - exec_approval_request( - parent_thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - ), - ) - .await?; - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - Some(SideParentStatus::NeedsApproval) - ); - - app.enqueue_thread_request( - parent_thread_id, - request_user_input_request(parent_thread_id, "turn-input", "call-input"), - ) - .await?; - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - Some(SideParentStatus::NeedsInput) - ); - - app.enqueue_thread_notification( - parent_thread_id, - ServerNotification::ServerRequestResolved( - codex_app_server_protocol::ServerRequestResolvedNotification { - thread_id: parent_thread_id.to_string(), - request_id: AppServerRequestId::Integer(2), - }, - ), - ) - .await?; - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - Some(SideParentStatus::NeedsApproval) - ); - - app.enqueue_thread_notification( - parent_thread_id, - ServerNotification::ServerRequestResolved( - codex_app_server_protocol::ServerRequestResolvedNotification { - thread_id: parent_thread_id.to_string(), - request_id: AppServerRequestId::Integer(1), - }, - ), - ) - .await?; - assert_eq!( - app.side_threads - .get(&side_thread_id) - .and_then(|state| state.parent_status), - None - ); - - Ok(()) - } - - #[test] - fn side_start_error_message_explains_missing_first_prompt() { - let err = color_eyre::eyre::eyre!( - "thread/fork failed during TUI bootstrap: thread/fork failed: no rollout found for thread id 019da1a1-bed9-7a43-88a2-b49d43915021" - ); - - assert_eq!( - App::side_start_error_message(&err), - "'/side' is unavailable until the current conversation has started. Send a message first, then try /side again." - ); - } - - #[test] - fn side_start_error_message_uses_generic_start_wording() { - let err = color_eyre::eyre::eyre!("transport disconnected"); - - assert_eq!( - App::side_start_error_message(&err), - "Failed to start side conversation: transport disconnected" - ); - } - - #[tokio::test] - async fn side_thread_snapshot_hides_forked_parent_transcript() { - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - let mut store = ThreadEventStore::new(/*capacity*/ 4); - let session = ThreadSessionState { - forked_from_id: Some(parent_thread_id), - ..test_thread_session(side_thread_id, test_path_buf("/tmp/side")) - }; - let parent_turn = test_turn( - "parent-turn", - TurnStatus::Completed, - vec![ThreadItem::UserMessage { - id: "parent-user".to_string(), - content: vec![AppServerUserInput::Text { - text: "parent prompt should stay hidden".to_string(), - text_elements: Vec::new(), - }], - }], - ); - - App::install_side_thread_snapshot(&mut store, session, vec![parent_turn]); - - let stored_session = store.session.as_ref().expect("side session"); - assert_eq!(stored_session.thread_id, side_thread_id); - assert_eq!(stored_session.forked_from_id, None); - assert_eq!(store.turns, Vec::::new()); - assert_eq!(store.active_turn_id(), None); - } - - #[tokio::test] - async fn side_thread_snapshot_does_not_refresh_from_fork_history() { - let mut app = make_test_app().await; - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - - let snapshot = ThreadEventSnapshot { - session: Some(ThreadSessionState { - rollout_path: None, - ..test_thread_session(side_thread_id, test_path_buf("/tmp/side")) - }), - turns: Vec::new(), - events: Vec::new(), - input_state: None, - }; - - assert!(!app.should_refresh_snapshot_session( - side_thread_id, - /*is_replay_only*/ false, - &snapshot - )); - } - - #[tokio::test] - async fn side_thread_snapshot_skips_session_header_preamble() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - while app_event_rx.try_recv().is_ok() {} - - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.primary_thread_id = Some(parent_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - - let snapshot = ThreadEventSnapshot { - session: Some(ThreadSessionState { - forked_from_id: Some(parent_thread_id), - ..test_thread_session(side_thread_id, test_path_buf("/tmp/side")) - }), - turns: Vec::new(), - events: Vec::new(), - input_state: None, - }; - - app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ false); - - let mut rendered_cells = Vec::new(); - while let Ok(event) = app_event_rx.try_recv() { - if let AppEvent::InsertHistoryCell(cell) = event { - rendered_cells.push(lines_to_single_string(&cell.display_lines(/*width*/ 120))); - } - } - assert_eq!(app.chat_widget.thread_id(), Some(side_thread_id)); - assert_eq!(rendered_cells, Vec::::new()); - assert_eq!( - app.chat_widget.active_cell_transcript_lines(/*width*/ 120), - None - ); - } - - #[tokio::test] - async fn side_thread_ignores_global_mcp_startup_notifications() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - while app_event_rx.try_recv().is_ok() {} - let app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.primary_thread_id = Some(parent_thread_id); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - app.sync_side_thread_ui(); - - app.handle_app_server_event( - &app_server, - codex_app_server_client::AppServerEvent::ServerNotification( - ServerNotification::McpServerStatusUpdated(McpServerStatusUpdatedNotification { - name: "sentry".to_string(), - status: McpServerStartupState::Failed, - error: Some("sentry is not logged in".to_string()), - }), - ), - ) - .await; - - assert!(app_event_rx.try_recv().is_err()); - } - - #[tokio::test] - async fn side_restore_user_message_puts_inline_question_back_in_composer() { - let mut app = make_test_app().await; - let user_message = crate::chatwidget::UserMessage::from("side question"); - - app.restore_side_user_message(Some(user_message)); - - assert_eq!( - app.chat_widget.composer_text_with_pending(), - "side question" - ); - } - - #[tokio::test] - async fn side_discard_selection_keeps_current_side_thread() { - let mut app = make_test_app().await; - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - - assert_eq!( - app.side_thread_to_discard_after_switch(side_thread_id), - None - ); - assert_eq!( - app.side_thread_to_discard_after_switch(parent_thread_id), - Some(side_thread_id) - ); - } - - #[tokio::test] - async fn discard_side_thread_removes_agent_navigation_entry() -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?; - let mut side_config = app.chat_widget.config_ref().clone(); - side_config.ephemeral = true; - let started = app_server.start_thread(&side_config).await?; - let side_thread_id = started.session.thread_id; - app.side_threads - .insert(side_thread_id, SideThreadState::new(ThreadId::new())); - app.agent_navigation.upsert( - side_thread_id, - Some("Side".to_string()), - Some("side".to_string()), - /*is_closed*/ false, - ); - - assert!( - app.discard_side_thread(&mut app_server, side_thread_id) - .await - ); - - assert_eq!(app.agent_navigation.get(&side_thread_id), None); - assert!(!app.side_threads.contains_key(&side_thread_id)); - Ok(()) - } - - #[tokio::test] - async fn discard_side_thread_keeps_local_state_when_server_close_fails() -> Result<()> { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?; - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - app.agent_navigation.upsert( - side_thread_id, - Some("Side".to_string()), - Some("side".to_string()), - /*is_closed*/ false, - ); - - assert!( - !app.discard_side_thread(&mut app_server, side_thread_id) - .await - ); - - assert_eq!(app.active_thread_id, Some(side_thread_id)); - assert_eq!( - app.side_threads - .get(&side_thread_id) - .map(|state| state.parent_thread_id), - Some(parent_thread_id) - ); - assert!(app.agent_navigation.get(&side_thread_id).is_some()); - Ok(()) - } - - #[tokio::test] - async fn discard_closed_side_thread_removes_local_state_without_server_rpc() { - let mut app = make_test_app().await; - let parent_thread_id = ThreadId::new(); - let side_thread_id = ThreadId::new(); - app.active_thread_id = Some(side_thread_id); - app.side_threads - .insert(side_thread_id, SideThreadState::new(parent_thread_id)); - app.thread_event_channels - .insert(side_thread_id, ThreadEventChannel::new(/*capacity*/ 4)); - app.agent_navigation.upsert( - side_thread_id, - Some("Side".to_string()), - Some("side".to_string()), - /*is_closed*/ false, - ); - - app.discard_closed_side_thread(side_thread_id).await; - - assert_eq!(app.active_thread_id, None); - assert!(!app.side_threads.contains_key(&side_thread_id)); - assert!(!app.thread_event_channels.contains_key(&side_thread_id)); - assert_eq!(app.agent_navigation.get(&side_thread_id), None); - } - - #[tokio::test] - async fn active_non_primary_shutdown_target_returns_none_for_non_shutdown_event() -> Result<()> - { - let mut app = make_test_app().await; - app.active_thread_id = Some(ThreadId::new()); - app.primary_thread_id = Some(ThreadId::new()); - - assert_eq!( - app.active_non_primary_shutdown_target(&ServerNotification::SkillsChanged( - codex_app_server_protocol::SkillsChangedNotification {}, - )), - None - ); - Ok(()) - } - - #[tokio::test] - async fn active_non_primary_shutdown_target_returns_none_for_primary_thread_shutdown() - -> Result<()> { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - app.active_thread_id = Some(thread_id); - app.primary_thread_id = Some(thread_id); - - assert_eq!( - app.active_non_primary_shutdown_target(&thread_closed_notification(thread_id)), - None - ); - Ok(()) - } - - #[tokio::test] - async fn active_non_primary_shutdown_target_returns_ids_for_non_primary_shutdown() -> Result<()> - { - let mut app = make_test_app().await; - let active_thread_id = ThreadId::new(); - let primary_thread_id = ThreadId::new(); - app.active_thread_id = Some(active_thread_id); - app.primary_thread_id = Some(primary_thread_id); - - assert_eq!( - app.active_non_primary_shutdown_target(&thread_closed_notification(active_thread_id)), - Some((active_thread_id, primary_thread_id)) - ); - Ok(()) - } - - #[tokio::test] - async fn active_non_primary_shutdown_target_returns_none_when_shutdown_exit_is_pending() - -> Result<()> { - let mut app = make_test_app().await; - let active_thread_id = ThreadId::new(); - let primary_thread_id = ThreadId::new(); - app.active_thread_id = Some(active_thread_id); - app.primary_thread_id = Some(primary_thread_id); - app.pending_shutdown_exit_thread_id = Some(active_thread_id); - - assert_eq!( - app.active_non_primary_shutdown_target(&thread_closed_notification(active_thread_id)), - None - ); - Ok(()) - } - - #[tokio::test] - async fn active_non_primary_shutdown_target_still_switches_for_other_pending_exit_thread() - -> Result<()> { - let mut app = make_test_app().await; - let active_thread_id = ThreadId::new(); - let primary_thread_id = ThreadId::new(); - app.active_thread_id = Some(active_thread_id); - app.primary_thread_id = Some(primary_thread_id); - app.pending_shutdown_exit_thread_id = Some(ThreadId::new()); - - assert_eq!( - app.active_non_primary_shutdown_target(&thread_closed_notification(active_thread_id)), - Some((active_thread_id, primary_thread_id)) - ); - Ok(()) - } - - async fn render_clear_ui_header_after_long_transcript_for_snapshot() -> String { - let mut app = make_test_app().await; - app.config.cwd = test_path_buf("/tmp/project").abs(); - app.chat_widget.set_model("gpt-test"); - app.chat_widget - .set_reasoning_effort(Some(ReasoningEffortConfig::High)); - let story_part_one = "In the cliffside town of Bracken Ferry, the lighthouse had been dark for \ - nineteen years, and the children were told it was because the sea no longer wanted a \ - guide. Mara, who repaired clocks for a living, found that hard to believe. Every dawn she \ - heard the gulls circling the empty tower, and every dusk she watched ships hesitate at the \ - mouth of the bay as if listening for a signal that never came. When an old brass key fell \ - out of a cracked parcel in her workshop, tagged only with the words 'for the lamp room,' \ - she decided to climb the hill and see what the town had forgotten."; - let story_part_two = "Inside the lighthouse she found gears wrapped in oilcloth, logbooks filled \ - with weather notes, and a lens shrouded beneath salt-stiff canvas. The mechanism was not \ - broken, only unfinished. Someone had removed the governor spring and hidden it in a false \ - drawer, along with a letter from the last keeper admitting he had darkened the light on \ - purpose after smugglers threatened his family. Mara spent the night rebuilding the clockwork \ - from spare watch parts, her fingers blackened with soot and grease, while a storm gathered \ - over the water and the harbor bells began to ring."; - let story_part_three = "At midnight the first squall hit, and the fishing boats returned early, \ - blind in sheets of rain. Mara wound the mechanism, set the teeth by hand, and watched the \ - great lens begin to turn in slow, certain arcs. The beam swept across the bay, caught the \ - whitecaps, and reached the boats just as they were drifting toward the rocks below the \ - eastern cliffs. In the morning the town square was crowded with wet sailors, angry elders, \ - and wide-eyed children, but when the oldest captain placed the keeper's log on the fountain \ - and thanked Mara for relighting the coast, nobody argued. By sunset, Bracken Ferry had a \ - lighthouse again, and Mara had more clocks to mend than ever because everyone wanted \ - something in town to keep better time."; - - let user_cell = |text: &str| -> Arc { - Arc::new(UserHistoryCell { - message: text.to_string(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: Vec::new(), - }) as Arc - }; - let agent_cell = |text: &str| -> Arc { - Arc::new(AgentMessageCell::new( - vec![Line::from(text.to_string())], - /*is_first_line*/ true, - )) as Arc - }; - let make_header = |is_first| -> Arc { - let event = SessionConfiguredEvent { - session_id: ThreadId::new(), - forked_from_id: None, - thread_name: None, - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: test_path_buf("/tmp/project").abs(), - reasoning_effort: Some(ReasoningEffortConfig::High), - history_log_id: 0, - history_entry_count: 0, - initial_messages: None, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - }; - Arc::new(new_session_info( - app.chat_widget.config_ref(), - app.chat_widget.current_model(), - event, - is_first, - /*tooltip_override*/ None, - /*auth_plan*/ None, - /*show_fast_status*/ false, - )) as Arc - }; - - app.transcript_cells = vec![ - make_header(true), - Arc::new(crate::history_cell::new_info_event( - "startup tip that used to replay".to_string(), - /*hint*/ None, - )) as Arc, - user_cell("Tell me a long story about a town with a dark lighthouse."), - agent_cell(story_part_one), - user_cell("Continue the story and reveal why the light went out."), - agent_cell(story_part_two), - user_cell("Finish the story with a storm and a resolution."), - agent_cell(story_part_three), - ]; - app.has_emitted_history_lines = true; - - let rendered = app - .clear_ui_header_lines_with_version(/*width*/ 80, "") - .iter() - .map(|line| { - line.spans - .iter() - .map(|span| span.content.as_ref()) - .collect::() - }) - .collect::>() - .join("\n"); - - assert!( - !rendered.contains("startup tip that used to replay"), - "clear header should not replay startup notices" - ); - assert!( - !rendered.contains("Bracken Ferry"), - "clear header should not replay prior conversation turns" - ); - rendered - } - - #[tokio::test] - #[cfg_attr( - target_os = "windows", - ignore = "snapshot path rendering differs on Windows" - )] - async fn clear_ui_after_long_transcript_snapshots_fresh_header_only() { - let rendered = render_clear_ui_header_after_long_transcript_for_snapshot().await; - assert_snapshot!("clear_ui_after_long_transcript_fresh_header_only", rendered); - } - - #[tokio::test] - #[cfg_attr( - target_os = "windows", - ignore = "snapshot path rendering differs on Windows" - )] - async fn ctrl_l_clear_ui_after_long_transcript_reuses_clear_header_snapshot() { - let rendered = render_clear_ui_header_after_long_transcript_for_snapshot().await; - assert_snapshot!("clear_ui_after_long_transcript_fresh_header_only", rendered); - } - - #[tokio::test] - #[cfg_attr( - target_os = "windows", - ignore = "snapshot path rendering differs on Windows" - )] - async fn clear_ui_header_shows_fast_status_for_fast_capable_models() { - let mut app = make_test_app().await; - app.config.cwd = test_path_buf("/tmp/project").abs(); - app.chat_widget.set_model("gpt-5.4"); - set_fast_mode_test_catalog(&mut app.chat_widget); - app.chat_widget - .set_reasoning_effort(Some(ReasoningEffortConfig::XHigh)); - app.chat_widget - .set_service_tier(Some(codex_protocol::config_types::ServiceTier::Fast)); - set_chatgpt_auth(&mut app.chat_widget); - set_fast_mode_test_catalog(&mut app.chat_widget); - - let rendered = app - .clear_ui_header_lines_with_version(/*width*/ 80, "") - .iter() - .map(|line| { - line.spans - .iter() - .map(|span| span.content.as_ref()) - .collect::() - }) - .collect::>() - .join("\n"); - - assert_snapshot!("clear_ui_header_fast_status_fast_capable_models", rendered); - } - - async fn make_test_app() -> App { - let (chat_widget, app_event_tx, _rx, _op_rx) = make_chatwidget_manual_with_sender().await; - let config = chat_widget.config_ref().clone(); - let file_search = FileSearchManager::new(config.cwd.to_path_buf(), app_event_tx.clone()); - let model = crate::legacy_core::test_support::get_model_offline(config.model.as_deref()); - let session_telemetry = test_session_telemetry(&config, model.as_str()); - - App { - model_catalog: chat_widget.model_catalog(), - session_telemetry, - app_event_tx, - chat_widget, - config, - active_profile: None, - cli_kv_overrides: Vec::new(), - harness_overrides: ConfigOverrides::default(), - runtime_approval_policy_override: None, - runtime_sandbox_policy_override: None, - file_search, - transcript_cells: Vec::new(), - overlay: None, - deferred_history_lines: Vec::new(), - has_emitted_history_lines: false, - enhanced_keys_supported: false, - commit_anim_running: Arc::new(AtomicBool::new(false)), - status_line_invalid_items_warned: Arc::new(AtomicBool::new(false)), - terminal_title_invalid_items_warned: Arc::new(AtomicBool::new(false)), - backtrack: BacktrackState::default(), - backtrack_render_pending: false, - feedback: codex_feedback::CodexFeedback::new(), - feedback_audience: FeedbackAudience::External, - environment_manager: Arc::new(EnvironmentManager::new(/*exec_server_url*/ None)), - remote_app_server_url: None, - remote_app_server_auth_token: None, - pending_update_action: None, - pending_shutdown_exit_thread_id: None, - windows_sandbox: WindowsSandboxState::default(), - thread_event_channels: HashMap::new(), - thread_event_listener_tasks: HashMap::new(), - agent_navigation: AgentNavigationState::default(), - side_threads: HashMap::new(), - active_thread_id: None, - active_thread_rx: None, - primary_thread_id: None, - last_subagent_backfill_attempt: None, - primary_session_configured: None, - pending_primary_events: VecDeque::new(), - pending_app_server_requests: PendingAppServerRequests::default(), - pending_plugin_enabled_writes: HashMap::new(), - } - } - - async fn make_test_app_with_channels() -> ( - App, - tokio::sync::mpsc::UnboundedReceiver, - tokio::sync::mpsc::UnboundedReceiver, - ) { - let (chat_widget, app_event_tx, rx, op_rx) = make_chatwidget_manual_with_sender().await; - let config = chat_widget.config_ref().clone(); - let file_search = FileSearchManager::new(config.cwd.to_path_buf(), app_event_tx.clone()); - let model = crate::legacy_core::test_support::get_model_offline(config.model.as_deref()); - let session_telemetry = test_session_telemetry(&config, model.as_str()); - - ( - App { - model_catalog: chat_widget.model_catalog(), - session_telemetry, - app_event_tx, - chat_widget, - config, - active_profile: None, - cli_kv_overrides: Vec::new(), - harness_overrides: ConfigOverrides::default(), - runtime_approval_policy_override: None, - runtime_sandbox_policy_override: None, - file_search, - transcript_cells: Vec::new(), - overlay: None, - deferred_history_lines: Vec::new(), - has_emitted_history_lines: false, - enhanced_keys_supported: false, - commit_anim_running: Arc::new(AtomicBool::new(false)), - status_line_invalid_items_warned: Arc::new(AtomicBool::new(false)), - terminal_title_invalid_items_warned: Arc::new(AtomicBool::new(false)), - backtrack: BacktrackState::default(), - backtrack_render_pending: false, - feedback: codex_feedback::CodexFeedback::new(), - feedback_audience: FeedbackAudience::External, - environment_manager: Arc::new(EnvironmentManager::new( - /*exec_server_url*/ None, - )), - remote_app_server_url: None, - remote_app_server_auth_token: None, - pending_update_action: None, - pending_shutdown_exit_thread_id: None, - windows_sandbox: WindowsSandboxState::default(), - thread_event_channels: HashMap::new(), - thread_event_listener_tasks: HashMap::new(), - agent_navigation: AgentNavigationState::default(), - side_threads: HashMap::new(), - active_thread_id: None, - active_thread_rx: None, - primary_thread_id: None, - last_subagent_backfill_attempt: None, - primary_session_configured: None, - pending_primary_events: VecDeque::new(), - pending_app_server_requests: PendingAppServerRequests::default(), - pending_plugin_enabled_writes: HashMap::new(), - }, - rx, - op_rx, - ) - } - - fn test_thread_session(thread_id: ThreadId, cwd: PathBuf) -> ThreadSessionState { - ThreadSessionState { - thread_id, - forked_from_id: None, - thread_name: None, - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: cwd.abs(), - instruction_source_paths: Vec::new(), - reasoning_effort: None, - history_log_id: 0, - history_entry_count: 0, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - } - } - - fn test_turn(turn_id: &str, status: TurnStatus, items: Vec) -> Turn { - Turn { - id: turn_id.to_string(), - items, - status, - error: None, - started_at: None, - completed_at: None, - duration_ms: None, - } - } - - fn turn_started_notification(thread_id: ThreadId, turn_id: &str) -> ServerNotification { - ServerNotification::TurnStarted(TurnStartedNotification { - thread_id: thread_id.to_string(), - turn: Turn { - started_at: Some(0), - ..test_turn(turn_id, TurnStatus::InProgress, Vec::new()) - }, - }) - } - - fn turn_completed_notification( - thread_id: ThreadId, - turn_id: &str, - status: TurnStatus, - ) -> ServerNotification { - ServerNotification::TurnCompleted(TurnCompletedNotification { - thread_id: thread_id.to_string(), - turn: Turn { - completed_at: Some(0), - duration_ms: Some(1), - ..test_turn(turn_id, status, Vec::new()) - }, - }) - } - - fn thread_closed_notification(thread_id: ThreadId) -> ServerNotification { - ServerNotification::ThreadClosed(ThreadClosedNotification { - thread_id: thread_id.to_string(), - }) - } - - fn token_usage_notification( - thread_id: ThreadId, - turn_id: &str, - model_context_window: Option, - ) -> ServerNotification { - ServerNotification::ThreadTokenUsageUpdated(ThreadTokenUsageUpdatedNotification { - thread_id: thread_id.to_string(), - turn_id: turn_id.to_string(), - token_usage: ThreadTokenUsage { - total: TokenUsageBreakdown { - total_tokens: 10, - input_tokens: 4, - cached_input_tokens: 1, - output_tokens: 5, - reasoning_output_tokens: 0, - }, - last: TokenUsageBreakdown { - total_tokens: 10, - input_tokens: 4, - cached_input_tokens: 1, - output_tokens: 5, - reasoning_output_tokens: 0, - }, - model_context_window, - }, - }) - } - - fn hook_started_notification(thread_id: ThreadId, turn_id: &str) -> ServerNotification { - ServerNotification::HookStarted(HookStartedNotification { - thread_id: thread_id.to_string(), - turn_id: Some(turn_id.to_string()), - run: AppServerHookRunSummary { - id: "user-prompt-submit:0:/tmp/hooks.json".to_string(), - event_name: AppServerHookEventName::UserPromptSubmit, - handler_type: AppServerHookHandlerType::Command, - execution_mode: AppServerHookExecutionMode::Sync, - scope: AppServerHookScope::Turn, - source_path: test_path_buf("/tmp/hooks.json").abs(), - source: codex_app_server_protocol::HookSource::User, - display_order: 0, - status: AppServerHookRunStatus::Running, - status_message: Some("checking go-workflow input policy".to_string()), - started_at: 1, - completed_at: None, - duration_ms: None, - entries: Vec::new(), - }, - }) - } - - fn hook_completed_notification(thread_id: ThreadId, turn_id: &str) -> ServerNotification { - ServerNotification::HookCompleted(HookCompletedNotification { - thread_id: thread_id.to_string(), - turn_id: Some(turn_id.to_string()), - run: AppServerHookRunSummary { - id: "user-prompt-submit:0:/tmp/hooks.json".to_string(), - event_name: AppServerHookEventName::UserPromptSubmit, - handler_type: AppServerHookHandlerType::Command, - execution_mode: AppServerHookExecutionMode::Sync, - scope: AppServerHookScope::Turn, - source_path: test_path_buf("/tmp/hooks.json").abs(), - source: codex_app_server_protocol::HookSource::User, - display_order: 0, - status: AppServerHookRunStatus::Stopped, - status_message: Some("checking go-workflow input policy".to_string()), - started_at: 1, - completed_at: Some(11), - duration_ms: Some(10), - entries: vec![ - AppServerHookOutputEntry { - kind: AppServerHookOutputEntryKind::Warning, - text: "go-workflow must start from PlanMode".to_string(), - }, - AppServerHookOutputEntry { - kind: AppServerHookOutputEntryKind::Stop, - text: "prompt blocked".to_string(), - }, - ], - }, - }) - } - - fn agent_message_delta_notification( - thread_id: ThreadId, - turn_id: &str, - item_id: &str, - delta: &str, - ) -> ServerNotification { - ServerNotification::AgentMessageDelta(AgentMessageDeltaNotification { - thread_id: thread_id.to_string(), - turn_id: turn_id.to_string(), - item_id: item_id.to_string(), - delta: delta.to_string(), - }) - } - - fn exec_approval_request( - thread_id: ThreadId, - turn_id: &str, - item_id: &str, - approval_id: Option<&str>, - ) -> ServerRequest { - ServerRequest::CommandExecutionRequestApproval { - request_id: AppServerRequestId::Integer(1), - params: CommandExecutionRequestApprovalParams { - thread_id: thread_id.to_string(), - turn_id: turn_id.to_string(), - item_id: item_id.to_string(), - approval_id: approval_id.map(str::to_string), - reason: Some("needs approval".to_string()), - network_approval_context: None, - command: Some("echo hello".to_string()), - cwd: Some(test_path_buf("/tmp/project").abs()), - command_actions: None, - additional_permissions: None, - proposed_execpolicy_amendment: None, - proposed_network_policy_amendments: None, - available_decisions: None, - }, - } - } - - fn request_user_input_request( - thread_id: ThreadId, - turn_id: &str, - item_id: &str, - ) -> ServerRequest { - ServerRequest::ToolRequestUserInput { - request_id: AppServerRequestId::Integer(2), - params: ToolRequestUserInputParams { - thread_id: thread_id.to_string(), - turn_id: turn_id.to_string(), - item_id: item_id.to_string(), - questions: Vec::new(), - }, - } - } - - #[test] - fn thread_event_store_tracks_active_turn_lifecycle() { - let mut store = ThreadEventStore::new(/*capacity*/ 8); - assert_eq!(store.active_turn_id(), None); - - let thread_id = ThreadId::new(); - store.push_notification(turn_started_notification(thread_id, "turn-1")); - assert_eq!(store.active_turn_id(), Some("turn-1")); - - store.push_notification(turn_completed_notification( - thread_id, - "turn-2", - TurnStatus::Completed, - )); - assert_eq!(store.active_turn_id(), Some("turn-1")); - - store.push_notification(turn_completed_notification( - thread_id, - "turn-1", - TurnStatus::Interrupted, - )); - assert_eq!(store.active_turn_id(), None); - } - - #[test] - fn thread_event_store_restores_active_turn_from_snapshot_turns() { - let thread_id = ThreadId::new(); - let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); - let turns = vec![ - test_turn("turn-1", TurnStatus::Completed, Vec::new()), - test_turn("turn-2", TurnStatus::InProgress, Vec::new()), - ]; - - let store = - ThreadEventStore::new_with_session(/*capacity*/ 8, session.clone(), turns.clone()); - assert_eq!(store.active_turn_id(), Some("turn-2")); - - let mut refreshed_store = ThreadEventStore::new(/*capacity*/ 8); - refreshed_store.set_session(session, turns); - assert_eq!(refreshed_store.active_turn_id(), Some("turn-2")); - } - - #[test] - fn thread_event_store_clear_active_turn_id_resets_cached_turn() { - let mut store = ThreadEventStore::new(/*capacity*/ 8); - let thread_id = ThreadId::new(); - store.push_notification(turn_started_notification(thread_id, "turn-1")); - - store.clear_active_turn_id(); - - assert_eq!(store.active_turn_id(), None); - } - - #[test] - fn thread_event_store_rebase_preserves_resolved_request_state() { - let thread_id = ThreadId::new(); - let mut store = ThreadEventStore::new(/*capacity*/ 8); - store.push_request(exec_approval_request( - thread_id, - "turn-approval", - "call-approval", - /*approval_id*/ None, - )); - store.push_notification(ServerNotification::ServerRequestResolved( - codex_app_server_protocol::ServerRequestResolvedNotification { - request_id: AppServerRequestId::Integer(1), - thread_id: thread_id.to_string(), - }, - )); - - store.rebase_buffer_after_session_refresh(); - - let snapshot = store.snapshot(); - assert!(snapshot.events.is_empty()); - assert_eq!(store.has_pending_thread_approvals(), false); - } - - #[test] - fn thread_event_store_rebase_preserves_hook_notifications() { - let thread_id = ThreadId::new(); - let mut store = ThreadEventStore::new(/*capacity*/ 8); - store.push_notification(hook_started_notification(thread_id, "turn-hook")); - store.push_notification(hook_completed_notification(thread_id, "turn-hook")); - - store.rebase_buffer_after_session_refresh(); - - let snapshot = store.snapshot(); - let hook_notifications = snapshot - .events - .into_iter() - .map(|event| match event { - ThreadBufferedEvent::Notification(notification) => { - serde_json::to_value(notification).expect("hook notification should serialize") - } - other => panic!("expected buffered hook notification, saw: {other:?}"), - }) - .collect::>(); - assert_eq!( - hook_notifications, - vec![ - serde_json::to_value(hook_started_notification(thread_id, "turn-hook")) - .expect("hook notification should serialize"), - serde_json::to_value(hook_completed_notification(thread_id, "turn-hook")) - .expect("hook notification should serialize"), - ] - ); - } - - #[test] - fn build_feedback_upload_params_includes_thread_id_and_rollout_path() { - let thread_id = ThreadId::new(); - let rollout_path = PathBuf::from("/tmp/rollout.jsonl"); - - let params = build_feedback_upload_params( - Some(thread_id), - Some(rollout_path.clone()), - FeedbackCategory::SafetyCheck, - Some("needs follow-up".to_string()), - Some("turn-123".to_string()), - /*include_logs*/ true, - ); - - assert_eq!(params.classification, "safety_check"); - assert_eq!(params.reason, Some("needs follow-up".to_string())); - assert_eq!(params.thread_id, Some(thread_id.to_string())); - assert_eq!( - params - .tags - .as_ref() - .and_then(|tags| tags.get("turn_id")) - .map(String::as_str), - Some("turn-123") - ); - assert_eq!(params.include_logs, true); - assert_eq!(params.extra_log_files, Some(vec![rollout_path])); - } - - #[test] - fn build_feedback_upload_params_omits_rollout_path_without_logs() { - let params = build_feedback_upload_params( - /*origin_thread_id*/ None, - Some(PathBuf::from("/tmp/rollout.jsonl")), - FeedbackCategory::GoodResult, - /*reason*/ None, - /*turn_id*/ None, - /*include_logs*/ false, - ); - - assert_eq!(params.classification, "good_result"); - assert_eq!(params.reason, None); - assert_eq!(params.thread_id, None); - assert_eq!(params.tags, None); - assert_eq!(params.include_logs, false); - assert_eq!(params.extra_log_files, None); - } - - #[tokio::test] - async fn feedback_submission_without_thread_emits_error_history_cell() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - - app.handle_feedback_submitted( - /*origin_thread_id*/ None, - FeedbackCategory::Bug, - /*include_logs*/ true, - Err("boom".to_string()), - ) - .await; - - let cell = match app_event_rx.try_recv() { - Ok(AppEvent::InsertHistoryCell(cell)) => cell, - other => panic!("expected feedback error history cell, saw {other:?}"), - }; - assert_eq!( - lines_to_single_string(&cell.display_lines(/*width*/ 120)), - "■ Failed to upload feedback: boom" - ); - } - - #[tokio::test] - async fn feedback_submission_for_inactive_thread_replays_into_origin_thread() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let origin_thread_id = ThreadId::new(); - let active_thread_id = ThreadId::new(); - let origin_session = test_thread_session(origin_thread_id, test_path_buf("/tmp/origin")); - let active_session = test_thread_session(active_thread_id, test_path_buf("/tmp/active")); - app.thread_event_channels.insert( - origin_thread_id, - ThreadEventChannel::new_with_session( - THREAD_EVENT_CHANNEL_CAPACITY, - origin_session.clone(), - Vec::new(), - ), - ); - app.thread_event_channels.insert( - active_thread_id, - ThreadEventChannel::new_with_session( - THREAD_EVENT_CHANNEL_CAPACITY, - active_session.clone(), - Vec::new(), - ), - ); - app.activate_thread_channel(active_thread_id).await; - app.chat_widget.handle_thread_session(active_session); - while app_event_rx.try_recv().is_ok() {} - - app.handle_feedback_submitted( - Some(origin_thread_id), - FeedbackCategory::Bug, - /*include_logs*/ true, - Ok("uploaded-thread".to_string()), - ) - .await; - - assert_matches!( - app_event_rx.try_recv(), - Err(tokio::sync::mpsc::error::TryRecvError::Empty) - ); - - let snapshot = { - let channel = app - .thread_event_channels - .get(&origin_thread_id) - .expect("origin thread channel should exist"); - let store = channel.store.lock().await; - assert!(matches!( - store.buffer.back(), - Some(ThreadBufferedEvent::FeedbackSubmission(_)) - )); - store.snapshot() - }; - - app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ false); - - let mut rendered_cells = Vec::new(); - while let Ok(event) = app_event_rx.try_recv() { - if let AppEvent::InsertHistoryCell(cell) = event { - rendered_cells.push(lines_to_single_string(&cell.display_lines(/*width*/ 120))); - } - } - assert!(rendered_cells.iter().any(|cell| { - cell.contains("• Feedback uploaded. Please open an issue using the following URL:") - && cell.contains("uploaded-thread") - })); - } - - fn next_user_turn_op(op_rx: &mut tokio::sync::mpsc::UnboundedReceiver) -> Op { - let mut seen = Vec::new(); - while let Ok(op) = op_rx.try_recv() { - if matches!(op, Op::UserTurn { .. }) { - return op; - } - seen.push(format!("{op:?}")); - } - panic!("expected UserTurn op, saw: {seen:?}"); - } - - fn lines_to_single_string(lines: &[Line<'_>]) -> String { - lines - .iter() - .map(|line| { - line.spans - .iter() - .map(|span| span.content.as_ref()) - .collect::() - }) - .collect::>() - .join("\n") - } - - fn test_session_telemetry(config: &Config, model: &str) -> SessionTelemetry { - let model_info = - crate::legacy_core::test_support::construct_model_info_offline(model, config); - SessionTelemetry::new( - ThreadId::new(), - model, - model_info.slug.as_str(), - /*account_id*/ None, - /*account_email*/ None, - /*auth_mode*/ None, - "test_originator".to_string(), - /*log_user_prompts*/ false, - "test".to_string(), - SessionSource::Cli, - ) - } - - fn app_enabled_in_effective_config(config: &Config, app_id: &str) -> Option { - config - .config_layer_stack - .effective_config() - .as_table() - .and_then(|table| table.get("apps")) - .and_then(TomlValue::as_table) - .and_then(|apps| apps.get(app_id)) - .and_then(TomlValue::as_table) - .and_then(|app| app.get("enabled")) - .and_then(TomlValue::as_bool) - } - - #[test] - fn active_turn_not_steerable_turn_error_extracts_structured_server_error() { - let turn_error = AppServerTurnError { - message: "cannot steer a review turn".to_string(), - codex_error_info: Some(AppServerCodexErrorInfo::ActiveTurnNotSteerable { - turn_kind: AppServerNonSteerableTurnKind::Review, - }), - additional_details: None, - }; - let error = TypedRequestError::Server { - method: "turn/steer".to_string(), - source: JSONRPCErrorError { - code: -32602, - message: turn_error.message.clone(), - data: Some(serde_json::to_value(&turn_error).expect("turn error should serialize")), - }, - }; - - assert_eq!( - active_turn_not_steerable_turn_error(&error), - Some(turn_error) - ); - } - - #[test] - fn active_turn_steer_race_detects_missing_active_turn() { - let error = TypedRequestError::Server { - method: "turn/steer".to_string(), - source: JSONRPCErrorError { - code: -32602, - message: "no active turn to steer".to_string(), - data: None, - }, - }; - - assert_eq!( - active_turn_steer_race(&error), - Some(ActiveTurnSteerRace::Missing) - ); - assert_eq!(active_turn_not_steerable_turn_error(&error), None); - } - - #[test] - fn active_turn_steer_race_extracts_actual_turn_id_from_mismatch() { - let error = TypedRequestError::Server { - method: "turn/steer".to_string(), - source: JSONRPCErrorError { - code: -32602, - message: "expected active turn id `turn-expected` but found `turn-actual`" - .to_string(), - data: None, - }, - }; - - assert_eq!( - active_turn_steer_race(&error), - Some(ActiveTurnSteerRace::ExpectedTurnMismatch { - actual_turn_id: "turn-actual".to_string(), - }) - ); - } - - #[tokio::test] - async fn update_reasoning_effort_updates_collaboration_mode() { - let mut app = make_test_app().await; - app.chat_widget - .set_reasoning_effort(Some(ReasoningEffortConfig::Medium)); - - app.on_update_reasoning_effort(Some(ReasoningEffortConfig::High)); - - assert_eq!( - app.chat_widget.current_reasoning_effort(), - Some(ReasoningEffortConfig::High) - ); - assert_eq!( - app.config.model_reasoning_effort, - Some(ReasoningEffortConfig::High) - ); - } - - #[tokio::test] - async fn refresh_in_memory_config_from_disk_loads_latest_apps_state() -> Result<()> { - let mut app = make_test_app().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - let app_id = "unit_test_refresh_in_memory_config_connector".to_string(); - - assert_eq!(app_enabled_in_effective_config(&app.config, &app_id), None); - - ConfigEditsBuilder::new(&app.config.codex_home) - .with_edits([ - ConfigEdit::SetPath { - segments: vec!["apps".to_string(), app_id.clone(), "enabled".to_string()], - value: false.into(), - }, - ConfigEdit::SetPath { - segments: vec![ - "apps".to_string(), - app_id.clone(), - "disabled_reason".to_string(), - ], - value: "user".into(), - }, - ]) - .apply() - .await - .expect("persist app toggle"); - - assert_eq!(app_enabled_in_effective_config(&app.config, &app_id), None); - - app.refresh_in_memory_config_from_disk().await?; - - assert_eq!( - app_enabled_in_effective_config(&app.config, &app_id), - Some(false) - ); - Ok(()) - } - - #[tokio::test] - async fn refresh_in_memory_config_from_disk_best_effort_keeps_current_config_on_error() - -> Result<()> { - let mut app = make_test_app().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - std::fs::write(codex_home.path().join("config.toml"), "[broken")?; - let original_config = app.config.clone(); - - app.refresh_in_memory_config_from_disk_best_effort("starting a new thread") - .await; - - assert_eq!(app.config, original_config); - Ok(()) - } - - #[tokio::test] - async fn refresh_in_memory_config_from_disk_uses_active_chat_widget_cwd() -> Result<()> { - let mut app = make_test_app().await; - let original_cwd = app.config.cwd.clone(); - let next_cwd_tmp = tempdir()?; - let next_cwd = next_cwd_tmp.path().to_path_buf(); - - app.chat_widget.handle_codex_event(Event { - id: String::new(), - msg: EventMsg::SessionConfigured(SessionConfiguredEvent { - session_id: ThreadId::new(), - forked_from_id: None, - thread_name: None, - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: next_cwd.clone().abs(), - reasoning_effort: None, - history_log_id: 0, - history_entry_count: 0, - initial_messages: None, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - }), - }); - - assert_eq!(app.chat_widget.config_ref().cwd.to_path_buf(), next_cwd); - assert_eq!(app.config.cwd, original_cwd); - - app.refresh_in_memory_config_from_disk().await?; - - assert_eq!(app.config.cwd, app.chat_widget.config_ref().cwd); - Ok(()) - } - - #[tokio::test] - async fn rebuild_config_for_resume_or_fallback_uses_current_config_on_same_cwd_error() - -> Result<()> { - let mut app = make_test_app().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - std::fs::write(codex_home.path().join("config.toml"), "[broken")?; - let current_config = app.config.clone(); - let current_cwd = current_config.cwd.clone(); - - let resume_config = app - .rebuild_config_for_resume_or_fallback(¤t_cwd, current_cwd.to_path_buf()) - .await?; - - assert_eq!(resume_config, current_config); - Ok(()) - } - - #[tokio::test] - async fn rebuild_config_for_resume_or_fallback_errors_when_cwd_changes() -> Result<()> { - let mut app = make_test_app().await; - let codex_home = tempdir()?; - app.config.codex_home = codex_home.path().to_path_buf().abs(); - std::fs::write(codex_home.path().join("config.toml"), "[broken")?; - let current_cwd = app.config.cwd.clone(); - let next_cwd_tmp = tempdir()?; - let next_cwd = next_cwd_tmp.path().to_path_buf(); - - let result = app - .rebuild_config_for_resume_or_fallback(¤t_cwd, next_cwd) - .await; - - assert!(result.is_err()); - Ok(()) - } - - #[tokio::test] - async fn sync_tui_theme_selection_updates_chat_widget_config_copy() { - let mut app = make_test_app().await; - - app.sync_tui_theme_selection("dracula".to_string()); - - assert_eq!(app.config.tui_theme.as_deref(), Some("dracula")); - assert_eq!( - app.chat_widget.config_ref().tui_theme.as_deref(), - Some("dracula") - ); - } - - #[tokio::test] - async fn fresh_session_config_uses_current_service_tier() { - let mut app = make_test_app().await; - app.chat_widget - .set_service_tier(Some(codex_protocol::config_types::ServiceTier::Fast)); - - let config = app.fresh_session_config(); - - assert_eq!( - config.service_tier, - Some(codex_protocol::config_types::ServiceTier::Fast) - ); - } - - #[tokio::test] - async fn backtrack_selection_with_duplicate_history_targets_unique_turn() { - let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; - - let user_cell = |text: &str, - text_elements: Vec, - local_image_paths: Vec, - remote_image_urls: Vec| - -> Arc { - Arc::new(UserHistoryCell { - message: text.to_string(), - text_elements, - local_image_paths, - remote_image_urls, - }) as Arc - }; - let agent_cell = |text: &str| -> Arc { - Arc::new(AgentMessageCell::new( - vec![Line::from(text.to_string())], - /*is_first_line*/ true, - )) as Arc - }; - - let make_header = |is_first| { - let event = SessionConfiguredEvent { - session_id: ThreadId::new(), - forked_from_id: None, - thread_name: None, - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: test_path_buf("/home/user/project").abs(), - reasoning_effort: None, - history_log_id: 0, - history_entry_count: 0, - initial_messages: None, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - }; - Arc::new(new_session_info( - app.chat_widget.config_ref(), - app.chat_widget.current_model(), - event, - is_first, - /*tooltip_override*/ None, - /*auth_plan*/ None, - /*show_fast_status*/ false, - )) as Arc - }; - - let placeholder = "[Image #1]"; - let edited_text = format!("follow-up (edited) {placeholder}"); - let edited_range = edited_text.len().saturating_sub(placeholder.len())..edited_text.len(); - let edited_text_elements = vec![TextElement::new( - edited_range.into(), - /*placeholder*/ None, - )]; - let edited_local_image_paths = vec![PathBuf::from("/tmp/fake-image.png")]; - - // Simulate a transcript with duplicated history (e.g., from prior backtracks) - // and an edited turn appended after a session header boundary. - app.transcript_cells = vec![ - make_header(true), - user_cell("first question", Vec::new(), Vec::new(), Vec::new()), - agent_cell("answer first"), - user_cell("follow-up", Vec::new(), Vec::new(), Vec::new()), - agent_cell("answer follow-up"), - make_header(false), - user_cell("first question", Vec::new(), Vec::new(), Vec::new()), - agent_cell("answer first"), - user_cell( - &edited_text, - edited_text_elements.clone(), - edited_local_image_paths.clone(), - vec!["https://example.com/backtrack.png".to_string()], - ), - agent_cell("answer edited"), - ]; - - assert_eq!(user_count(&app.transcript_cells), 2); - - let base_id = ThreadId::new(); - app.chat_widget.handle_codex_event(Event { - id: String::new(), - msg: EventMsg::SessionConfigured(SessionConfiguredEvent { - session_id: base_id, - forked_from_id: None, - thread_name: None, - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: test_path_buf("/home/user/project").abs(), - reasoning_effort: None, - history_log_id: 0, - history_entry_count: 0, - initial_messages: None, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - }), - }); - - app.backtrack.base_id = Some(base_id); - app.backtrack.primed = true; - app.backtrack.nth_user_message = user_count(&app.transcript_cells).saturating_sub(1); - - let selection = app - .confirm_backtrack_from_main() - .expect("backtrack selection"); - assert_eq!(selection.nth_user_message, 1); - assert_eq!(selection.prefill, edited_text); - assert_eq!(selection.text_elements, edited_text_elements); - assert_eq!(selection.local_image_paths, edited_local_image_paths); - assert_eq!( - selection.remote_image_urls, - vec!["https://example.com/backtrack.png".to_string()] - ); - - app.apply_backtrack_rollback(selection); - assert_eq!( - app.chat_widget.remote_image_urls(), - vec!["https://example.com/backtrack.png".to_string()] - ); - - let mut rollback_turns = None; - while let Ok(op) = op_rx.try_recv() { - if let Op::ThreadRollback { num_turns } = op { - rollback_turns = Some(num_turns); - } - } - - assert_eq!(rollback_turns, Some(1)); - } - - #[tokio::test] - async fn backtrack_remote_image_only_selection_clears_existing_composer_draft() { - let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; - - app.transcript_cells = vec![Arc::new(UserHistoryCell { - message: "original".to_string(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: Vec::new(), - }) as Arc]; - app.chat_widget - .set_composer_text("stale draft".to_string(), Vec::new(), Vec::new()); - - let remote_image_url = "https://example.com/remote-only.png".to_string(); - app.apply_backtrack_rollback(BacktrackSelection { - nth_user_message: 0, - prefill: String::new(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: vec![remote_image_url.clone()], - }); - - assert_eq!(app.chat_widget.composer_text_with_pending(), ""); - assert_eq!(app.chat_widget.remote_image_urls(), vec![remote_image_url]); - - let mut rollback_turns = None; - while let Ok(op) = op_rx.try_recv() { - if let Op::ThreadRollback { num_turns } = op { - rollback_turns = Some(num_turns); - } - } - assert_eq!(rollback_turns, Some(1)); - } - - #[tokio::test] - async fn backtrack_resubmit_preserves_data_image_urls_in_user_turn() { - let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; - - let thread_id = ThreadId::new(); - app.chat_widget.handle_codex_event(Event { - id: String::new(), - msg: EventMsg::SessionConfigured(SessionConfiguredEvent { - session_id: thread_id, - forked_from_id: None, - thread_name: None, - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: test_path_buf("/home/user/project").abs(), - reasoning_effort: None, - history_log_id: 0, - history_entry_count: 0, - initial_messages: None, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - }), - }); - - let data_image_url = "data:image/png;base64,abc123".to_string(); - app.transcript_cells = vec![Arc::new(UserHistoryCell { - message: "please inspect this".to_string(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: vec![data_image_url.clone()], - }) as Arc]; - - app.apply_backtrack_rollback(BacktrackSelection { - nth_user_message: 0, - prefill: "please inspect this".to_string(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: vec![data_image_url.clone()], - }); - - app.chat_widget - .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); - - let mut saw_rollback = false; - let mut submitted_items: Option> = None; - while let Ok(op) = op_rx.try_recv() { - match op { - Op::ThreadRollback { .. } => saw_rollback = true, - Op::UserTurn { items, .. } => submitted_items = Some(items), - _ => {} - } - } - - assert!(saw_rollback); - let items = submitted_items.expect("expected user turn after backtrack resubmit"); - assert!(items.iter().any(|item| { - matches!( - item, - UserInput::Image { image_url } if image_url == &data_image_url - ) - })); - } - - #[tokio::test] - async fn replay_thread_snapshot_replays_turn_history_in_order() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: Some(test_thread_session( - thread_id, - test_path_buf("/home/user/project"), - )), - turns: vec![ - Turn { - id: "turn-1".to_string(), - items: vec![ThreadItem::UserMessage { - id: "user-1".to_string(), - content: vec![AppServerUserInput::Text { - text: "first prompt".to_string(), - text_elements: Vec::new(), - }], - }], - status: TurnStatus::Completed, - error: None, - started_at: None, - completed_at: None, - duration_ms: None, - }, - Turn { - id: "turn-2".to_string(), - items: vec![ - ThreadItem::UserMessage { - id: "user-2".to_string(), - content: vec![AppServerUserInput::Text { - text: "third prompt".to_string(), - text_elements: Vec::new(), - }], - }, - ThreadItem::AgentMessage { - id: "assistant-2".to_string(), - text: "done".to_string(), - phase: None, - memory_citation: None, - }, - ], - status: TurnStatus::Completed, - error: None, - started_at: None, - completed_at: None, - duration_ms: None, - }, - ], - events: Vec::new(), - input_state: None, - }, - /*resume_restored_queue*/ false, - ); - - while let Ok(event) = app_event_rx.try_recv() { - if let AppEvent::InsertHistoryCell(cell) = event { - let cell: Arc = cell.into(); - app.transcript_cells.push(cell); - } - } - - let user_messages: Vec = app - .transcript_cells - .iter() - .filter_map(|cell| { - cell.as_any() - .downcast_ref::() - .map(|cell| cell.message.clone()) - }) - .collect(); - assert_eq!( - user_messages, - vec!["first prompt".to_string(), "third prompt".to_string()] - ); - } - - #[tokio::test] - async fn replace_chat_widget_reseeds_collab_agent_metadata_for_replay() { - let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; - let receiver_thread_id = - ThreadId::from_string("019cff70-2599-75e2-af72-b958ce5dc1cc").expect("valid thread"); - app.agent_navigation.upsert( - receiver_thread_id, - Some("Robie".to_string()), - Some("explorer".to_string()), - /*is_closed*/ false, - ); - - let replacement = ChatWidget::new_with_app_event(ChatWidgetInit { - config: app.config.clone(), - frame_requester: crate::tui::FrameRequester::test_dummy(), - app_event_tx: app.app_event_tx.clone(), - initial_user_message: None, - enhanced_keys_supported: app.enhanced_keys_supported, - has_chatgpt_account: app.chat_widget.has_chatgpt_account(), - model_catalog: app.model_catalog.clone(), - feedback: app.feedback.clone(), - is_first_run: false, - status_account_display: app.chat_widget.status_account_display().cloned(), - initial_plan_type: app.chat_widget.current_plan_type(), - model: Some(app.chat_widget.current_model().to_string()), - startup_tooltip_override: None, - status_line_invalid_items_warned: app.status_line_invalid_items_warned.clone(), - terminal_title_invalid_items_warned: app.terminal_title_invalid_items_warned.clone(), - session_telemetry: app.session_telemetry.clone(), - }); - app.replace_chat_widget(replacement); - - app.replay_thread_snapshot( - ThreadEventSnapshot { - session: None, - turns: Vec::new(), - events: vec![ThreadBufferedEvent::Notification( - ServerNotification::ItemStarted(codex_app_server_protocol::ItemStartedNotification { - thread_id: "thread-1".to_string(), - turn_id: "turn-1".to_string(), - item: ThreadItem::CollabAgentToolCall { - id: "wait-1".to_string(), - tool: codex_app_server_protocol::CollabAgentTool::Wait, - status: codex_app_server_protocol::CollabAgentToolCallStatus::InProgress, - sender_thread_id: ThreadId::new().to_string(), - receiver_thread_ids: vec![receiver_thread_id.to_string()], - prompt: None, - model: None, - reasoning_effort: None, - agents_states: HashMap::new(), - }, - }), - )], - input_state: None, - }, - /*resume_restored_queue*/ false, - ); - - let mut saw_named_wait = false; - while let Ok(event) = app_event_rx.try_recv() { - if let AppEvent::InsertHistoryCell(cell) = event { - let transcript = lines_to_single_string(&cell.transcript_lines(/*width*/ 80)); - saw_named_wait |= transcript.contains("Robie [explorer]"); - } - } - - assert!( - saw_named_wait, - "expected replayed wait item to keep agent name" - ); - } - - #[tokio::test] - async fn refreshed_snapshot_session_persists_resumed_turns() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - let initial_session = test_thread_session(thread_id, test_path_buf("/tmp/original")); - app.thread_event_channels.insert( - thread_id, - ThreadEventChannel::new_with_session( - /*capacity*/ 4, - initial_session.clone(), - Vec::new(), - ), - ); - - let resumed_turns = vec![test_turn( - "turn-1", - TurnStatus::Completed, - vec![ThreadItem::UserMessage { - id: "user-1".to_string(), - content: vec![AppServerUserInput::Text { - text: "restored prompt".to_string(), - text_elements: Vec::new(), - }], - }], - )]; - let resumed_session = ThreadSessionState { - cwd: test_path_buf("/tmp/refreshed").abs(), - ..initial_session.clone() - }; - let mut snapshot = ThreadEventSnapshot { - session: Some(initial_session), - turns: Vec::new(), - events: Vec::new(), - input_state: None, - }; - - app.apply_refreshed_snapshot_thread( - thread_id, - AppServerStartedThread { - session: resumed_session.clone(), - turns: resumed_turns.clone(), - }, - &mut snapshot, - ) - .await; - - assert_eq!(snapshot.session, Some(resumed_session.clone())); - assert_eq!(snapshot.turns, resumed_turns); - - let store = app - .thread_event_channels - .get(&thread_id) - .expect("thread channel") - .store - .lock() - .await; - let store_snapshot = store.snapshot(); - assert_eq!(store_snapshot.session, Some(resumed_session)); - assert_eq!(store_snapshot.turns, snapshot.turns); - } - - #[tokio::test] - async fn queued_rollback_syncs_overlay_and_clears_deferred_history() { - let mut app = make_test_app().await; - app.transcript_cells = vec![ - Arc::new(UserHistoryCell { - message: "first".to_string(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: Vec::new(), - }) as Arc, - Arc::new(AgentMessageCell::new( - vec![Line::from("after first")], - /*is_first_line*/ false, - )) as Arc, - Arc::new(UserHistoryCell { - message: "second".to_string(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: Vec::new(), - }) as Arc, - Arc::new(AgentMessageCell::new( - vec![Line::from("after second")], - /*is_first_line*/ false, - )) as Arc, - ]; - app.overlay = Some(Overlay::new_transcript(app.transcript_cells.clone())); - app.deferred_history_lines = vec![Line::from("stale buffered line")]; - app.backtrack.overlay_preview_active = true; - app.backtrack.nth_user_message = 1; - - let changed = app.apply_non_pending_thread_rollback(/*num_turns*/ 1); - - assert!(changed); - assert!(app.backtrack_render_pending); - assert!(app.deferred_history_lines.is_empty()); - assert_eq!(app.backtrack.nth_user_message, 0); - let user_messages: Vec = app - .transcript_cells - .iter() - .filter_map(|cell| { - cell.as_any() - .downcast_ref::() - .map(|cell| cell.message.clone()) - }) - .collect(); - assert_eq!(user_messages, vec!["first".to_string()]); - let overlay_cell_count = match app.overlay.as_ref() { - Some(Overlay::Transcript(t)) => t.committed_cell_count(), - _ => panic!("expected transcript overlay"), - }; - assert_eq!(overlay_cell_count, app.transcript_cells.len()); - } - - #[tokio::test] - async fn thread_rollback_response_discards_queued_active_thread_events() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - let (tx, rx) = mpsc::channel(8); - app.active_thread_id = Some(thread_id); - app.active_thread_rx = Some(rx); - tx.send(ThreadBufferedEvent::Notification( - ServerNotification::ConfigWarning(ConfigWarningNotification { - summary: "stale warning".to_string(), - details: None, - path: None, - range: None, - }), - )) - .await - .expect("event should queue"); - - app.handle_thread_rollback_response( - thread_id, - /*num_turns*/ 1, - &ThreadRollbackResponse { - thread: Thread { - id: thread_id.to_string(), - forked_from_id: None, - preview: String::new(), - ephemeral: false, - model_provider: "openai".to_string(), - created_at: 0, - updated_at: 0, - status: codex_app_server_protocol::ThreadStatus::Idle, - path: None, - cwd: test_path_buf("/tmp/project").abs(), - cli_version: "0.0.0".to_string(), - source: SessionSource::Cli.into(), - agent_nickname: None, - agent_role: None, - git_info: None, - name: None, - turns: Vec::new(), - }, - }, - ) - .await; - - let rx = app - .active_thread_rx - .as_mut() - .expect("active receiver should remain attached"); - assert!(matches!(rx.try_recv(), Err(TryRecvError::Empty))); - } - - #[tokio::test] - async fn new_session_requests_shutdown_for_previous_conversation() { - let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; - - let thread_id = ThreadId::new(); - let event = SessionConfiguredEvent { - session_id: thread_id, - forked_from_id: None, - thread_name: None, - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: test_path_buf("/home/user/project").abs(), - reasoning_effort: None, - history_log_id: 0, - history_entry_count: 0, - initial_messages: None, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - }; - - app.chat_widget.handle_codex_event(Event { - id: String::new(), - msg: EventMsg::SessionConfigured(event), - }); - - while app_event_rx.try_recv().is_ok() {} - while op_rx.try_recv().is_ok() {} - - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - app.shutdown_current_thread(&mut app_server).await; - - assert!( - op_rx.try_recv().is_err(), - "shutdown should not submit Op::Shutdown" - ); - } - - #[tokio::test] - async fn shutdown_first_exit_returns_immediate_exit_when_shutdown_submit_fails() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - app.active_thread_id = Some(thread_id); - - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let control = app - .handle_exit_mode(&mut app_server, ExitMode::ShutdownFirst) - .await; - - assert_eq!(app.pending_shutdown_exit_thread_id, None); - assert!(matches!( - control, - AppRunControl::Exit(ExitReason::UserRequested) - )); - } - - #[tokio::test] - async fn shutdown_first_exit_uses_app_server_shutdown_without_submitting_op() { - let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; - let thread_id = ThreadId::new(); - app.active_thread_id = Some(thread_id); - - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let control = app - .handle_exit_mode(&mut app_server, ExitMode::ShutdownFirst) - .await; - - assert_eq!(app.pending_shutdown_exit_thread_id, None); - assert!(matches!( - control, - AppRunControl::Exit(ExitReason::UserRequested) - )); - assert!( - op_rx.try_recv().is_err(), - "shutdown should not submit Op::Shutdown" - ); - } - - #[tokio::test] - async fn interrupt_without_active_turn_is_treated_as_handled() { - let mut app = make_test_app().await; - let mut app_server = - crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) - .await - .expect("embedded app server"); - let started = app_server - .start_thread(app.chat_widget.config_ref()) - .await - .expect("thread/start should succeed"); - let thread_id = started.session.thread_id; - app.enqueue_primary_thread_session(started.session, started.turns) - .await - .expect("primary thread should be registered"); - let op = AppCommand::interrupt(); - - let handled = app - .try_submit_active_thread_op_via_app_server(&mut app_server, thread_id, &op) - .await - .expect("interrupt submission should not fail"); - - assert_eq!(handled, true); - } - - #[tokio::test] - async fn clear_only_ui_reset_preserves_chat_session_state() { - let mut app = make_test_app().await; - let thread_id = ThreadId::new(); - app.chat_widget.handle_codex_event(Event { - id: String::new(), - msg: EventMsg::SessionConfigured(SessionConfiguredEvent { - session_id: thread_id, - forked_from_id: None, - thread_name: Some("keep me".to_string()), - model: "gpt-test".to_string(), - model_provider_id: "test-provider".to_string(), - service_tier: None, - approval_policy: AskForApproval::Never, - approvals_reviewer: ApprovalsReviewer::User, - sandbox_policy: SandboxPolicy::new_read_only_policy(), - cwd: test_path_buf("/tmp/project").abs(), - reasoning_effort: None, - history_log_id: 0, - history_entry_count: 0, - initial_messages: None, - network_proxy: None, - rollout_path: Some(PathBuf::new()), - }), - }); - app.chat_widget - .apply_external_edit("draft prompt".to_string()); - app.transcript_cells = vec![Arc::new(UserHistoryCell { - message: "old message".to_string(), - text_elements: Vec::new(), - local_image_paths: Vec::new(), - remote_image_urls: Vec::new(), - }) as Arc]; - app.overlay = Some(Overlay::new_transcript(app.transcript_cells.clone())); - app.deferred_history_lines = vec![Line::from("stale buffered line")]; - app.has_emitted_history_lines = true; - app.backtrack.primed = true; - app.backtrack.overlay_preview_active = true; - app.backtrack.nth_user_message = 0; - app.backtrack_render_pending = true; - - app.reset_app_ui_state_after_clear(); - - assert!(app.overlay.is_none()); - assert!(app.transcript_cells.is_empty()); - assert!(app.deferred_history_lines.is_empty()); - assert!(!app.has_emitted_history_lines); - assert!(!app.backtrack.primed); - assert!(!app.backtrack.overlay_preview_active); - assert!(app.backtrack.pending_rollback.is_none()); - assert!(!app.backtrack_render_pending); - assert_eq!(app.chat_widget.thread_id(), Some(thread_id)); - assert_eq!(app.chat_widget.composer_text_with_pending(), "draft prompt"); - } - - #[tokio::test] - async fn session_summary_skips_when_no_usage_or_resume_hint() { - assert!( - session_summary( - TokenUsage::default(), - /*thread_id*/ None, - /*thread_name*/ None, - /*rollout_path*/ None, - ) - .is_none() - ); - } - - #[tokio::test] - async fn session_summary_skips_resume_hint_until_rollout_exists() { - let usage = TokenUsage::default(); - let conversation = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap(); - let temp_dir = tempdir().expect("temp dir"); - let rollout_path = temp_dir.path().join("rollout.jsonl"); - - assert!( - session_summary( - usage, - Some(conversation), - /*thread_name*/ None, - Some(&rollout_path), - ) - .is_none() - ); - } - - #[tokio::test] - async fn session_summary_includes_resume_hint_for_persisted_rollout() { - let usage = TokenUsage { - input_tokens: 10, - output_tokens: 2, - total_tokens: 12, - ..Default::default() - }; - let conversation = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap(); - let temp_dir = tempdir().expect("temp dir"); - let rollout_path = temp_dir.path().join("rollout.jsonl"); - std::fs::write(&rollout_path, "{}\n").expect("write rollout"); - - let summary = session_summary( - usage, - Some(conversation), - /*thread_name*/ None, - Some(&rollout_path), - ) - .expect("summary"); - assert_eq!( - summary.usage_line, - Some("Token usage: total=12 input=10 output=2".to_string()) - ); - assert_eq!( - summary.resume_command, - Some("codex resume 123e4567-e89b-12d3-a456-426614174000".to_string()) - ); - } - - #[tokio::test] - async fn session_summary_uses_id_even_when_thread_has_name() { - let usage = TokenUsage { - input_tokens: 10, - output_tokens: 2, - total_tokens: 12, - ..Default::default() - }; - let conversation = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap(); - let temp_dir = tempdir().expect("temp dir"); - let rollout_path = temp_dir.path().join("rollout.jsonl"); - std::fs::write(&rollout_path, "{}\n").expect("write rollout"); - - let summary = session_summary( - usage, - Some(conversation), - Some("my-session".to_string()), - Some(&rollout_path), - ) - .expect("summary"); - assert_eq!( - summary.resume_command, - Some("codex resume 123e4567-e89b-12d3-a456-426614174000".to_string()) - ); - } -} +mod tests; diff --git a/codex-rs/tui/src/app/app_server_requests.rs b/codex-rs/tui/src/app/app_server_requests.rs index c54aae826f..4e63567340 100644 --- a/codex-rs/tui/src/app/app_server_requests.rs +++ b/codex-rs/tui/src/app/app_server_requests.rs @@ -558,6 +558,7 @@ mod tests { file_system: Some(AdditionalFileSystemPermissions { read: Some(vec![absolute_path(read_path)]), write: Some(vec![absolute_path(write_path)]), + glob_scan_max_depth: None, entries: None, }), }, @@ -654,6 +655,7 @@ mod tests { thread_id: "thread-1".to_string(), turn_id: "turn-1".to_string(), call_id: "tool-1".to_string(), + namespace: None, tool: "tool".to_string(), arguments: json!({}), }, diff --git a/codex-rs/tui/src/app/background_requests.rs b/codex-rs/tui/src/app/background_requests.rs new file mode 100644 index 0000000000..9fc741ff5c --- /dev/null +++ b/codex-rs/tui/src/app/background_requests.rs @@ -0,0 +1,639 @@ +//! Background app-server requests launched by the TUI app. +//! +//! This module owns fire-and-forget fetch/write helpers for MCP inventory, skills, plugins, rate +//! limits, add-credit nudges, and feedback uploads. Results are routed back through `AppEvent` so +//! the main event loop remains single-threaded. + +use super::*; + +impl App { + pub(super) fn fetch_mcp_inventory( + &mut self, + app_server: &AppServerSession, + detail: McpServerStatusDetail, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let result = fetch_all_mcp_server_statuses(request_handle, detail) + .await + .map_err(|err| err.to_string()); + app_event_tx.send(AppEvent::McpInventoryLoaded { result, detail }); + }); + } + + /// Spawns a background task to fetch account rate limits and deliver the + /// result as a `RateLimitsLoaded` event. + /// + /// The `origin` is forwarded to the completion handler so it can distinguish + /// a startup prefetch (which only updates cached snapshots and schedules a + /// frame) from a `/status`-triggered refresh (which must finalize the + /// corresponding status card). + pub(super) fn refresh_rate_limits( + &mut self, + app_server: &AppServerSession, + origin: RateLimitRefreshOrigin, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let result = fetch_account_rate_limits(request_handle) + .await + .map_err(|err| err.to_string()); + app_event_tx.send(AppEvent::RateLimitsLoaded { origin, result }); + }); + } + + pub(super) fn send_add_credits_nudge_email( + &mut self, + app_server: &AppServerSession, + credit_type: AddCreditsNudgeCreditType, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let result = send_add_credits_nudge_email(request_handle, credit_type) + .await + .map_err(|err| err.to_string()); + app_event_tx.send(AppEvent::AddCreditsNudgeEmailFinished { result }); + }); + } + + /// Starts the initial skills refresh without delaying the first interactive frame. + /// + /// Startup only needs skill metadata to populate skill mentions and the skills UI; the prompt can be + /// rendered before that metadata arrives. The result is routed through the normal app event queue so + /// the same response handler updates the chat widget and emits invalid `SKILL.md` warnings once the + /// app-server RPC finishes. User-initiated skills refreshes still use the blocking app command path so + /// callers that explicitly asked for fresh skill state do not race ahead of their own refresh. + pub(super) fn refresh_startup_skills(&mut self, app_server: &AppServerSession) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + let cwd = self.config.cwd.to_path_buf(); + tokio::spawn(async move { + let result = fetch_skills_list(request_handle, cwd) + .await + .map_err(|err| format!("{err:#}")); + app_event_tx.send(AppEvent::SkillsListLoaded { result }); + }); + } + + pub(super) fn fetch_plugins_list(&mut self, app_server: &AppServerSession, cwd: PathBuf) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let result = fetch_plugins_list(request_handle, cwd.clone()) + .await + .map_err(|err| err.to_string()); + app_event_tx.send(AppEvent::PluginsLoaded { cwd, result }); + }); + } + + pub(super) fn fetch_plugin_detail( + &mut self, + app_server: &AppServerSession, + cwd: PathBuf, + params: PluginReadParams, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let result = fetch_plugin_detail(request_handle, params) + .await + .map_err(|err| err.to_string()); + app_event_tx.send(AppEvent::PluginDetailLoaded { cwd, result }); + }); + } + + pub(super) fn fetch_plugin_install( + &mut self, + app_server: &AppServerSession, + cwd: PathBuf, + marketplace_path: AbsolutePathBuf, + plugin_name: String, + plugin_display_name: String, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let cwd_for_event = cwd.clone(); + let marketplace_path_for_event = marketplace_path.clone(); + let plugin_name_for_event = plugin_name.clone(); + let result = fetch_plugin_install(request_handle, marketplace_path, plugin_name) + .await + .map_err(|err| format!("Failed to install plugin: {err}")); + app_event_tx.send(AppEvent::PluginInstallLoaded { + cwd: cwd_for_event, + marketplace_path: marketplace_path_for_event, + plugin_name: plugin_name_for_event, + plugin_display_name, + result, + }); + }); + } + + pub(super) fn fetch_plugin_uninstall( + &mut self, + app_server: &AppServerSession, + cwd: PathBuf, + plugin_id: String, + plugin_display_name: String, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let cwd_for_event = cwd.clone(); + let plugin_id_for_event = plugin_id.clone(); + let result = fetch_plugin_uninstall(request_handle, plugin_id) + .await + .map_err(|err| format!("Failed to uninstall plugin: {err}")); + app_event_tx.send(AppEvent::PluginUninstallLoaded { + cwd: cwd_for_event, + plugin_id: plugin_id_for_event, + plugin_display_name, + result, + }); + }); + } + + pub(super) fn set_plugin_enabled( + &mut self, + app_server: &AppServerSession, + cwd: PathBuf, + plugin_id: String, + enabled: bool, + ) { + if let Some(queued_enabled) = self.pending_plugin_enabled_writes.get_mut(&plugin_id) { + *queued_enabled = Some(enabled); + return; + } + + self.pending_plugin_enabled_writes + .insert(plugin_id.clone(), None); + self.spawn_plugin_enabled_write(app_server, cwd, plugin_id, enabled); + } + + pub(super) fn spawn_plugin_enabled_write( + &mut self, + app_server: &AppServerSession, + cwd: PathBuf, + plugin_id: String, + enabled: bool, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let cwd_for_event = cwd.clone(); + let plugin_id_for_event = plugin_id.clone(); + let result = write_plugin_enabled(request_handle, plugin_id, enabled) + .await + .map(|_| ()) + .map_err(|err| format!("Failed to update plugin config: {err}")); + app_event_tx.send(AppEvent::PluginEnabledSet { + cwd: cwd_for_event, + plugin_id: plugin_id_for_event, + enabled, + result, + }); + }); + } + + pub(super) fn refresh_plugin_mentions(&mut self) { + let config = self.config.clone(); + let app_event_tx = self.app_event_tx.clone(); + if !config.features.enabled(Feature::Plugins) { + app_event_tx.send(AppEvent::PluginMentionsLoaded { plugins: None }); + return; + } + + tokio::spawn(async move { + let plugins = PluginsManager::new(config.codex_home.to_path_buf()) + .plugins_for_config(&config) + .await + .capability_summaries() + .to_vec(); + app_event_tx.send(AppEvent::PluginMentionsLoaded { + plugins: Some(plugins), + }); + }); + } + + pub(super) fn submit_feedback( + &mut self, + app_server: &AppServerSession, + category: FeedbackCategory, + reason: Option, + turn_id: Option, + include_logs: bool, + ) { + let request_handle = app_server.request_handle(); + let app_event_tx = self.app_event_tx.clone(); + let origin_thread_id = self.chat_widget.thread_id(); + let rollout_path = if include_logs { + self.chat_widget.rollout_path() + } else { + None + }; + let params = build_feedback_upload_params( + origin_thread_id, + rollout_path, + category, + reason, + turn_id, + include_logs, + ); + tokio::spawn(async move { + let result = fetch_feedback_upload(request_handle, params) + .await + .map(|response| response.thread_id) + .map_err(|err| err.to_string()); + app_event_tx.send(AppEvent::FeedbackSubmitted { + origin_thread_id, + category, + include_logs, + result, + }); + }); + } + + pub(super) fn handle_feedback_thread_event(&mut self, event: FeedbackThreadEvent) { + match event.result { + Ok(thread_id) => { + self.chat_widget + .add_to_history(crate::bottom_pane::feedback_success_cell( + event.category, + event.include_logs, + &thread_id, + event.feedback_audience, + )) + } + Err(err) => self + .chat_widget + .add_to_history(history_cell::new_error_event(format!( + "Failed to upload feedback: {err}" + ))), + } + } + + pub(super) async fn enqueue_thread_feedback_event( + &mut self, + thread_id: ThreadId, + event: FeedbackThreadEvent, + ) { + let (sender, store) = { + let channel = self.ensure_thread_channel(thread_id); + (channel.sender.clone(), Arc::clone(&channel.store)) + }; + + let should_send = { + let mut guard = store.lock().await; + guard + .buffer + .push_back(ThreadBufferedEvent::FeedbackSubmission(event.clone())); + if guard.buffer.len() > guard.capacity + && let Some(removed) = guard.buffer.pop_front() + && let ThreadBufferedEvent::Request(request) = &removed + { + guard + .pending_interactive_replay + .note_evicted_server_request(request); + } + guard.active + }; + + if should_send { + match sender.try_send(ThreadBufferedEvent::FeedbackSubmission(event)) { + Ok(()) => {} + Err(TrySendError::Full(event)) => { + tokio::spawn(async move { + if let Err(err) = sender.send(event).await { + tracing::warn!("thread {thread_id} event channel closed: {err}"); + } + }); + } + Err(TrySendError::Closed(_)) => { + tracing::warn!("thread {thread_id} event channel closed"); + } + } + } + } + + pub(super) async fn handle_feedback_submitted( + &mut self, + origin_thread_id: Option, + category: FeedbackCategory, + include_logs: bool, + result: Result, + ) { + let event = FeedbackThreadEvent { + category, + include_logs, + feedback_audience: self.feedback_audience, + result, + }; + if let Some(thread_id) = origin_thread_id { + self.enqueue_thread_feedback_event(thread_id, event).await; + } else { + self.handle_feedback_thread_event(event); + } + } + + /// Process the completed MCP inventory fetch: clear the loading spinner, then + /// render either the full tool/resource listing or an error into chat history. + /// + /// When both the local config and the app-server report zero servers, a special + /// "empty" cell is shown instead of the full table. + pub(super) fn handle_mcp_inventory_result( + &mut self, + result: Result, String>, + detail: McpServerStatusDetail, + ) { + let config = self.chat_widget.config_ref().clone(); + self.chat_widget.clear_mcp_inventory_loading(); + self.clear_committed_mcp_inventory_loading(); + + let statuses = match result { + Ok(statuses) => statuses, + Err(err) => { + self.chat_widget + .add_error_message(format!("Failed to load MCP inventory: {err}")); + return; + } + }; + + if config.mcp_servers.get().is_empty() && statuses.is_empty() { + self.chat_widget + .add_to_history(history_cell::empty_mcp_output()); + return; + } + + self.chat_widget + .add_to_history(history_cell::new_mcp_tools_output_from_statuses( + &config, &statuses, detail, + )); + } + + pub(super) fn clear_committed_mcp_inventory_loading(&mut self) { + let Some(index) = self + .transcript_cells + .iter() + .rposition(|cell| cell.as_any().is::()) + else { + return; + }; + + self.transcript_cells.remove(index); + if let Some(Overlay::Transcript(overlay)) = &mut self.overlay { + overlay.replace_cells(self.transcript_cells.clone()); + } + } +} + +pub(super) async fn fetch_all_mcp_server_statuses( + request_handle: AppServerRequestHandle, + detail: McpServerStatusDetail, +) -> Result> { + let mut cursor = None; + let mut statuses = Vec::new(); + + loop { + let request_id = RequestId::String(format!("mcp-inventory-{}", Uuid::new_v4())); + let response: ListMcpServerStatusResponse = request_handle + .request_typed(ClientRequest::McpServerStatusList { + request_id, + params: ListMcpServerStatusParams { + cursor: cursor.clone(), + limit: Some(100), + detail: Some(detail), + }, + }) + .await + .wrap_err("mcpServerStatus/list failed in TUI")?; + statuses.extend(response.data); + if let Some(next_cursor) = response.next_cursor { + cursor = Some(next_cursor); + } else { + break; + } + } + + Ok(statuses) +} + +pub(super) async fn fetch_account_rate_limits( + request_handle: AppServerRequestHandle, +) -> Result> { + let request_id = RequestId::String(format!("account-rate-limits-{}", Uuid::new_v4())); + let response: GetAccountRateLimitsResponse = request_handle + .request_typed(ClientRequest::GetAccountRateLimits { + request_id, + params: None, + }) + .await + .wrap_err("account/rateLimits/read failed in TUI")?; + + Ok(app_server_rate_limit_snapshots_to_core(response)) +} + +pub(super) async fn send_add_credits_nudge_email( + request_handle: AppServerRequestHandle, + credit_type: AddCreditsNudgeCreditType, +) -> Result { + let request_id = RequestId::String(format!("add-credits-nudge-{}", Uuid::new_v4())); + let response: codex_app_server_protocol::SendAddCreditsNudgeEmailResponse = request_handle + .request_typed(ClientRequest::SendAddCreditsNudgeEmail { + request_id, + params: SendAddCreditsNudgeEmailParams { credit_type }, + }) + .await + .wrap_err("account/sendAddCreditsNudgeEmail failed in TUI")?; + + Ok(response.status) +} + +pub(super) async fn fetch_skills_list( + request_handle: AppServerRequestHandle, + cwd: PathBuf, +) -> Result { + let request_id = RequestId::String(format!("startup-skills-list-{}", Uuid::new_v4())); + // Use the cloneable request handle so startup can issue this RPC from a background task without + // extending a borrow of `AppServerSession` across the first frame render. + request_handle + .request_typed(ClientRequest::SkillsList { + request_id, + params: SkillsListParams { + cwds: vec![cwd], + force_reload: true, + per_cwd_extra_user_roots: None, + }, + }) + .await + .wrap_err("skills/list failed in TUI") +} + +pub(super) async fn fetch_plugins_list( + request_handle: AppServerRequestHandle, + cwd: PathBuf, +) -> Result { + let cwd = AbsolutePathBuf::try_from(cwd).wrap_err("plugin list cwd must be absolute")?; + let request_id = RequestId::String(format!("plugin-list-{}", Uuid::new_v4())); + let mut response = request_handle + .request_typed(ClientRequest::PluginList { + request_id, + params: PluginListParams { + cwds: Some(vec![cwd]), + }, + }) + .await + .wrap_err("plugin/list failed in TUI")?; + hide_cli_only_plugin_marketplaces(&mut response); + Ok(response) +} + +const CLI_HIDDEN_PLUGIN_MARKETPLACES: &[&str] = &["openai-bundled"]; + +pub(super) fn hide_cli_only_plugin_marketplaces(response: &mut PluginListResponse) { + response + .marketplaces + .retain(|marketplace| !CLI_HIDDEN_PLUGIN_MARKETPLACES.contains(&marketplace.name.as_str())); +} + +pub(super) async fn fetch_plugin_detail( + request_handle: AppServerRequestHandle, + params: PluginReadParams, +) -> Result { + let request_id = RequestId::String(format!("plugin-read-{}", Uuid::new_v4())); + request_handle + .request_typed(ClientRequest::PluginRead { request_id, params }) + .await + .wrap_err("plugin/read failed in TUI") +} + +pub(super) async fn fetch_plugin_install( + request_handle: AppServerRequestHandle, + marketplace_path: AbsolutePathBuf, + plugin_name: String, +) -> Result { + let request_id = RequestId::String(format!("plugin-install-{}", Uuid::new_v4())); + request_handle + .request_typed(ClientRequest::PluginInstall { + request_id, + params: PluginInstallParams { + marketplace_path: Some(marketplace_path), + remote_marketplace_name: None, + plugin_name, + }, + }) + .await + .wrap_err("plugin/install failed in TUI") +} + +pub(super) async fn fetch_plugin_uninstall( + request_handle: AppServerRequestHandle, + plugin_id: String, +) -> Result { + let request_id = RequestId::String(format!("plugin-uninstall-{}", Uuid::new_v4())); + request_handle + .request_typed(ClientRequest::PluginUninstall { + request_id, + params: PluginUninstallParams { plugin_id }, + }) + .await + .wrap_err("plugin/uninstall failed in TUI") +} + +pub(super) async fn write_plugin_enabled( + request_handle: AppServerRequestHandle, + plugin_id: String, + enabled: bool, +) -> Result { + let request_id = RequestId::String(format!("plugin-enable-{}", Uuid::new_v4())); + request_handle + .request_typed(ClientRequest::ConfigValueWrite { + request_id, + params: ConfigValueWriteParams { + key_path: format!("plugins.{plugin_id}"), + value: serde_json::json!({ "enabled": enabled }), + merge_strategy: MergeStrategy::Upsert, + file_path: None, + expected_version: None, + }, + }) + .await + .wrap_err("config/value/write failed while updating plugin enablement in TUI") +} + +pub(super) fn build_feedback_upload_params( + origin_thread_id: Option, + rollout_path: Option, + category: FeedbackCategory, + reason: Option, + turn_id: Option, + include_logs: bool, +) -> FeedbackUploadParams { + let extra_log_files = if include_logs { + rollout_path.map(|rollout_path| vec![rollout_path]) + } else { + None + }; + let tags = turn_id.map(|turn_id| BTreeMap::from([(String::from("turn_id"), turn_id)])); + FeedbackUploadParams { + classification: crate::bottom_pane::feedback_classification(category).to_string(), + reason, + thread_id: origin_thread_id.map(|thread_id| thread_id.to_string()), + include_logs, + extra_log_files, + tags, + } +} + +pub(super) async fn fetch_feedback_upload( + request_handle: AppServerRequestHandle, + params: FeedbackUploadParams, +) -> Result { + let request_id = RequestId::String(format!("feedback-upload-{}", Uuid::new_v4())); + request_handle + .request_typed(ClientRequest::FeedbackUpload { request_id, params }) + .await + .wrap_err("feedback/upload failed in TUI") +} + +/// Convert flat `McpServerStatus` responses into the per-server maps used by the +/// in-process MCP subsystem (tools keyed as `mcp__{server}__{tool}`, plus +/// per-server resource/template/auth maps). Test-only because the TUI +/// renders directly from `McpServerStatus` rather than these maps. +#[cfg(test)] +pub(super) type McpInventoryMaps = ( + HashMap, + HashMap>, + HashMap>, + HashMap, +); + +#[cfg(test)] +pub(super) fn mcp_inventory_maps_from_statuses(statuses: Vec) -> McpInventoryMaps { + let mut tools = HashMap::new(); + let mut resources = HashMap::new(); + let mut resource_templates = HashMap::new(); + let mut auth_statuses = HashMap::new(); + + for status in statuses { + let server_name = status.name; + auth_statuses.insert( + server_name.clone(), + match status.auth_status { + codex_app_server_protocol::McpAuthStatus::Unsupported => McpAuthStatus::Unsupported, + codex_app_server_protocol::McpAuthStatus::NotLoggedIn => McpAuthStatus::NotLoggedIn, + codex_app_server_protocol::McpAuthStatus::BearerToken => McpAuthStatus::BearerToken, + codex_app_server_protocol::McpAuthStatus::OAuth => McpAuthStatus::OAuth, + }, + ); + resources.insert(server_name.clone(), status.resources); + resource_templates.insert(server_name.clone(), status.resource_templates); + for (tool_name, tool) in status.tools { + tools.insert(format!("mcp__{server_name}__{tool_name}"), tool); + } + } + + (tools, resources, resource_templates, auth_statuses) +} diff --git a/codex-rs/tui/src/app/config_persistence.rs b/codex-rs/tui/src/app/config_persistence.rs new file mode 100644 index 0000000000..c909a37c1f --- /dev/null +++ b/codex-rs/tui/src/app/config_persistence.rs @@ -0,0 +1,539 @@ +//! Runtime configuration persistence helpers for the TUI app. +//! +//! This module owns the app-level glue between config.toml edits, in-memory `Config` refreshes, +//! and the ChatWidget copy of session settings, keeping persistence-heavy code out of the main app +//! loop. + +use super::*; + +impl App { + pub(super) async fn rebuild_config_for_cwd(&self, cwd: PathBuf) -> Result { + let mut overrides = self.harness_overrides.clone(); + overrides.cwd = Some(cwd.clone()); + let cwd_display = cwd.display().to_string(); + ConfigBuilder::default() + .codex_home(self.config.codex_home.to_path_buf()) + .cli_overrides(self.cli_kv_overrides.clone()) + .harness_overrides(overrides) + .build() + .await + .wrap_err_with(|| format!("Failed to rebuild config for cwd {cwd_display}")) + } + + pub(super) async fn refresh_in_memory_config_from_disk(&mut self) -> Result<()> { + let mut config = self + .rebuild_config_for_cwd(self.chat_widget.config_ref().cwd.to_path_buf()) + .await?; + self.apply_runtime_policy_overrides(&mut config); + self.config = config; + self.chat_widget.sync_plugin_mentions_config(&self.config); + Ok(()) + } + + pub(super) async fn refresh_in_memory_config_from_disk_best_effort(&mut self, action: &str) { + if let Err(err) = self.refresh_in_memory_config_from_disk().await { + tracing::warn!( + error = %err, + action, + "failed to refresh config before thread transition; continuing with current in-memory config" + ); + } + } + + pub(super) async fn rebuild_config_for_resume_or_fallback( + &mut self, + current_cwd: &Path, + resume_cwd: PathBuf, + ) -> Result { + match self.rebuild_config_for_cwd(resume_cwd.clone()).await { + Ok(config) => Ok(config), + Err(err) => { + if crate::cwds_differ(current_cwd, &resume_cwd) { + Err(err) + } else { + let resume_cwd_display = resume_cwd.display().to_string(); + tracing::warn!( + error = %err, + cwd = %resume_cwd_display, + "failed to rebuild config for same-cwd resume; using current in-memory config" + ); + Ok(self.config.clone()) + } + } + } + } + + pub(super) fn apply_runtime_policy_overrides(&mut self, config: &mut Config) { + if let Some(policy) = self.runtime_approval_policy_override.as_ref() + && let Err(err) = config.permissions.approval_policy.set(*policy) + { + tracing::warn!(%err, "failed to carry forward approval policy override"); + self.chat_widget.add_error_message(format!( + "Failed to carry forward approval policy override: {err}" + )); + } + if let Some(policy) = self.runtime_sandbox_policy_override.as_ref() + && let Err(err) = config.permissions.sandbox_policy.set(policy.clone()) + { + tracing::warn!(%err, "failed to carry forward sandbox policy override"); + self.chat_widget.add_error_message(format!( + "Failed to carry forward sandbox policy override: {err}" + )); + } + } + + pub(super) fn set_approvals_reviewer_in_app_and_widget(&mut self, reviewer: ApprovalsReviewer) { + self.config.approvals_reviewer = reviewer; + self.chat_widget.set_approvals_reviewer(reviewer); + } + + pub(super) fn try_set_approval_policy_on_config( + &mut self, + config: &mut Config, + policy: AskForApproval, + user_message_prefix: &str, + log_message: &str, + ) -> bool { + if let Err(err) = config.permissions.approval_policy.set(policy) { + tracing::warn!(error = %err, "{log_message}"); + self.chat_widget + .add_error_message(format!("{user_message_prefix}: {err}")); + return false; + } + + true + } + + pub(super) fn try_set_sandbox_policy_on_config( + &mut self, + config: &mut Config, + policy: SandboxPolicy, + user_message_prefix: &str, + log_message: &str, + ) -> bool { + if let Err(err) = config.permissions.sandbox_policy.set(policy) { + tracing::warn!(error = %err, "{log_message}"); + self.chat_widget + .add_error_message(format!("{user_message_prefix}: {err}")); + return false; + } + + true + } + + pub(super) async fn update_feature_flags(&mut self, updates: Vec<(Feature, bool)>) { + if updates.is_empty() { + return; + } + + let guardian_approvals_preset = guardian_approvals_mode(); + let mut next_config = self.config.clone(); + let active_profile = self.active_profile.clone(); + let scoped_segments = |key: &str| { + if let Some(profile) = active_profile.as_deref() { + vec!["profiles".to_string(), profile.to_string(), key.to_string()] + } else { + vec![key.to_string()] + } + }; + let windows_sandbox_changed = updates.iter().any(|(feature, _)| { + matches!( + feature, + Feature::WindowsSandbox | Feature::WindowsSandboxElevated + ) + }); + let mut approval_policy_override = None; + let mut approvals_reviewer_override = None; + let mut sandbox_policy_override = None; + let mut feature_updates_to_apply = Vec::with_capacity(updates.len()); + // Auto-Review owns `approvals_reviewer`, but disabling the feature + // from inside a profile should not silently clear a value configured at + // the root scope. + let (root_approvals_reviewer_blocks_profile_disable, profile_approvals_reviewer_configured) = { + let effective_config = next_config.config_layer_stack.effective_config(); + let root_blocks_disable = effective_config + .as_table() + .and_then(|table| table.get("approvals_reviewer")) + .is_some_and(|value| value != &TomlValue::String("user".to_string())); + let profile_configured = active_profile.as_deref().is_some_and(|profile| { + effective_config + .as_table() + .and_then(|table| table.get("profiles")) + .and_then(TomlValue::as_table) + .and_then(|profiles| profiles.get(profile)) + .and_then(TomlValue::as_table) + .is_some_and(|profile_config| profile_config.contains_key("approvals_reviewer")) + }); + (root_blocks_disable, profile_configured) + }; + let mut permissions_history_label: Option<&'static str> = None; + let mut builder = ConfigEditsBuilder::new(&self.config.codex_home) + .with_profile(self.active_profile.as_deref()); + + for (feature, enabled) in updates { + let feature_key = feature.key(); + let mut feature_edits = Vec::new(); + if feature == Feature::GuardianApproval + && !enabled + && self.active_profile.is_some() + && root_approvals_reviewer_blocks_profile_disable + { + self.chat_widget.add_error_message( + "Cannot disable Auto-review in this profile because `approvals_reviewer` is configured outside the active profile.".to_string(), + ); + continue; + } + let mut feature_config = next_config.clone(); + if let Err(err) = feature_config.features.set_enabled(feature, enabled) { + tracing::error!( + error = %err, + feature = feature_key, + "failed to update constrained feature flags" + ); + self.chat_widget.add_error_message(format!( + "Failed to update experimental feature `{feature_key}`: {err}" + )); + continue; + } + let effective_enabled = feature_config.features.enabled(feature); + if feature == Feature::GuardianApproval { + let previous_approvals_reviewer = feature_config.approvals_reviewer; + if effective_enabled { + // Persist the reviewer setting so future sessions keep the + // experiment's matching `/approvals` mode until the user + // changes it explicitly. + feature_config.approvals_reviewer = + guardian_approvals_preset.approvals_reviewer; + feature_edits.push(ConfigEdit::SetPath { + segments: scoped_segments("approvals_reviewer"), + value: guardian_approvals_preset + .approvals_reviewer + .to_string() + .into(), + }); + if previous_approvals_reviewer != guardian_approvals_preset.approvals_reviewer { + permissions_history_label = Some("Auto-review"); + } + } else if !effective_enabled { + if profile_approvals_reviewer_configured || self.active_profile.is_none() { + feature_edits.push(ConfigEdit::ClearPath { + segments: scoped_segments("approvals_reviewer"), + }); + } + feature_config.approvals_reviewer = ApprovalsReviewer::User; + if previous_approvals_reviewer != ApprovalsReviewer::User { + permissions_history_label = Some("Default"); + } + } + approvals_reviewer_override = Some(feature_config.approvals_reviewer); + } + if feature == Feature::GuardianApproval && effective_enabled { + // The feature flag alone is not enough for the live session. + // We also align approval policy + sandbox to the Auto-review + // preset so enabling the experiment immediately + // makes guardian review observable in the current thread. + if !self.try_set_approval_policy_on_config( + &mut feature_config, + guardian_approvals_preset.approval_policy, + "Failed to enable Auto-review", + "failed to set guardian approvals approval policy on staged config", + ) { + continue; + } + if !self.try_set_sandbox_policy_on_config( + &mut feature_config, + guardian_approvals_preset.sandbox_policy.clone(), + "Failed to enable Auto-review", + "failed to set guardian approvals sandbox policy on staged config", + ) { + continue; + } + feature_edits.extend([ + ConfigEdit::SetPath { + segments: scoped_segments("approval_policy"), + value: "on-request".into(), + }, + ConfigEdit::SetPath { + segments: scoped_segments("sandbox_mode"), + value: "workspace-write".into(), + }, + ]); + approval_policy_override = Some(guardian_approvals_preset.approval_policy); + sandbox_policy_override = Some(guardian_approvals_preset.sandbox_policy.clone()); + } + next_config = feature_config; + feature_updates_to_apply.push((feature, effective_enabled)); + builder = builder + .with_edits(feature_edits) + .set_feature_enabled(feature_key, effective_enabled); + } + + // Persist first so the live session does not diverge from disk if the + // config edit fails. Runtime/UI state is patched below only after the + // durable config update succeeds. + if let Err(err) = builder.apply().await { + tracing::error!(error = %err, "failed to persist feature flags"); + self.chat_widget + .add_error_message(format!("Failed to update experimental features: {err}")); + return; + } + + let memory_tool_was_enabled = self.config.features.enabled(Feature::MemoryTool); + self.config = next_config; + let show_memory_enable_notice = + feature_updates_to_apply.iter().any(|(feature, enabled)| { + *feature == Feature::MemoryTool && *enabled && !memory_tool_was_enabled + }); + for (feature, effective_enabled) in feature_updates_to_apply { + self.chat_widget + .set_feature_enabled(feature, effective_enabled); + } + if show_memory_enable_notice { + self.chat_widget.add_memories_enable_notice(); + } + if approvals_reviewer_override.is_some() { + self.set_approvals_reviewer_in_app_and_widget(self.config.approvals_reviewer); + } + if approval_policy_override.is_some() { + self.chat_widget + .set_approval_policy(self.config.permissions.approval_policy.value()); + } + if sandbox_policy_override.is_some() + && let Err(err) = self + .chat_widget + .set_sandbox_policy(self.config.permissions.sandbox_policy.get().clone()) + { + tracing::error!( + error = %err, + "failed to set guardian approvals sandbox policy on chat config" + ); + self.chat_widget + .add_error_message(format!("Failed to enable Auto-review: {err}")); + } + + if approval_policy_override.is_some() + || approvals_reviewer_override.is_some() + || sandbox_policy_override.is_some() + { + // This uses `OverrideTurnContext` intentionally: toggling the + // experiment should update the active thread's effective approval + // settings immediately, just like a `/approvals` selection. Without + // this runtime patch, the config edit would only affect future + // sessions or turns recreated from disk. + let op = AppCommand::override_turn_context( + /*cwd*/ None, + approval_policy_override, + approvals_reviewer_override, + sandbox_policy_override, + /*windows_sandbox_level*/ None, + /*model*/ None, + /*effort*/ None, + /*summary*/ None, + /*service_tier*/ None, + /*collaboration_mode*/ None, + /*personality*/ None, + ); + let replay_state_op = + ThreadEventStore::op_can_change_pending_replay_state(&op).then(|| op.clone()); + let submitted = self.chat_widget.submit_op(op); + if submitted && let Some(op) = replay_state_op.as_ref() { + self.note_active_thread_outbound_op(op).await; + self.refresh_pending_thread_approvals().await; + } + } + + if windows_sandbox_changed { + #[cfg(target_os = "windows")] + { + let windows_sandbox_level = WindowsSandboxLevel::from_config(&self.config); + self.app_event_tx.send(AppEvent::CodexOp( + AppCommand::override_turn_context( + /*cwd*/ None, + /*approval_policy*/ None, + /*approvals_reviewer*/ None, + /*sandbox_policy*/ None, + #[cfg(target_os = "windows")] + Some(windows_sandbox_level), + /*model*/ None, + /*effort*/ None, + /*summary*/ None, + /*service_tier*/ None, + /*collaboration_mode*/ None, + /*personality*/ None, + ) + .into_core(), + )); + } + } + + if let Some(label) = permissions_history_label { + self.chat_widget.add_info_message( + format!("Permissions updated to {label}"), + /*hint*/ None, + ); + } + } + + pub(super) async fn update_memory_settings( + &mut self, + use_memories: bool, + generate_memories: bool, + ) -> bool { + let active_profile = self.active_profile.clone(); + let scoped_memory_segments = |key: &str| { + if let Some(profile) = active_profile.as_deref() { + vec![ + "profiles".to_string(), + profile.to_string(), + "memories".to_string(), + key.to_string(), + ] + } else { + vec!["memories".to_string(), key.to_string()] + } + }; + let edits = [ + ConfigEdit::SetPath { + segments: scoped_memory_segments("use_memories"), + value: use_memories.into(), + }, + ConfigEdit::SetPath { + segments: scoped_memory_segments("generate_memories"), + value: generate_memories.into(), + }, + ]; + + if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) + .with_edits(edits) + .apply() + .await + { + tracing::error!(error = %err, "failed to persist memory settings"); + self.chat_widget + .add_error_message(format!("Failed to save memory settings: {err}")); + return false; + } + + self.config.memories.use_memories = use_memories; + self.config.memories.generate_memories = generate_memories; + self.chat_widget + .set_memory_settings(use_memories, generate_memories); + true + } + + pub(super) async fn update_memory_settings_with_app_server( + &mut self, + app_server: &mut AppServerSession, + use_memories: bool, + generate_memories: bool, + ) { + let previous_generate_memories = self.config.memories.generate_memories; + if !self + .update_memory_settings(use_memories, generate_memories) + .await + { + return; + } + + if previous_generate_memories == generate_memories { + return; + } + + let Some(thread_id) = self.current_displayed_thread_id() else { + return; + }; + + let mode = if generate_memories { + ThreadMemoryMode::Enabled + } else { + ThreadMemoryMode::Disabled + }; + + if let Err(err) = app_server.thread_memory_mode_set(thread_id, mode).await { + tracing::error!(error = %err, %thread_id, "failed to update thread memory mode"); + self.chat_widget.add_error_message(format!( + "Saved memory settings, but failed to update the current thread: {err}" + )); + } + } + + pub(super) async fn reset_memories_with_app_server( + &mut self, + app_server: &mut AppServerSession, + ) { + if let Err(err) = app_server.memory_reset().await { + tracing::error!(error = %err, "failed to reset memories"); + self.chat_widget + .add_error_message(format!("Failed to reset memories: {err}")); + return; + } + + self.chat_widget + .add_info_message("Reset local memories.".to_string(), /*hint*/ None); + } + + pub(super) fn reasoning_label(reasoning_effort: Option) -> &'static str { + match reasoning_effort { + Some(ReasoningEffortConfig::Minimal) => "minimal", + Some(ReasoningEffortConfig::Low) => "low", + Some(ReasoningEffortConfig::Medium) => "medium", + Some(ReasoningEffortConfig::High) => "high", + Some(ReasoningEffortConfig::XHigh) => "xhigh", + None | Some(ReasoningEffortConfig::None) => "default", + } + } + + pub(super) fn reasoning_label_for( + model: &str, + reasoning_effort: Option, + ) -> Option<&'static str> { + (!model.starts_with("codex-auto-")).then(|| Self::reasoning_label(reasoning_effort)) + } + + pub(crate) fn token_usage(&self) -> codex_protocol::protocol::TokenUsage { + self.chat_widget.token_usage() + } + + pub(super) fn on_update_reasoning_effort(&mut self, effort: Option) { + // TODO(aibrahim): Remove this and don't use config as a state object. + // Instead, explicitly pass the stored collaboration mode's effort into new sessions. + self.config.model_reasoning_effort = effort; + self.chat_widget.set_reasoning_effort(effort); + } + + pub(super) fn on_update_personality(&mut self, personality: Personality) { + self.config.personality = Some(personality); + self.chat_widget.set_personality(personality); + } + + pub(super) fn sync_tui_theme_selection(&mut self, name: String) { + self.config.tui_theme = Some(name.clone()); + self.chat_widget.set_tui_theme(Some(name)); + } + + pub(super) fn restore_runtime_theme_from_config(&self) { + if let Some(name) = self.config.tui_theme.as_deref() + && let Some(theme) = + crate::render::highlight::resolve_theme_by_name(name, Some(&self.config.codex_home)) + { + crate::render::highlight::set_syntax_theme(theme); + return; + } + + let auto_theme_name = crate::render::highlight::adaptive_default_theme_name(); + if let Some(theme) = crate::render::highlight::resolve_theme_by_name( + auto_theme_name, + Some(&self.config.codex_home), + ) { + crate::render::highlight::set_syntax_theme(theme); + } + } + + pub(super) fn personality_label(personality: Personality) -> &'static str { + match personality { + Personality::None => "None", + Personality::Friendly => "Friendly", + Personality::Pragmatic => "Pragmatic", + } + } +} diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs new file mode 100644 index 0000000000..d4bfa45e23 --- /dev/null +++ b/codex-rs/tui/src/app/event_dispatch.rs @@ -0,0 +1,1654 @@ +//! AppEvent dispatch for the TUI app. +//! +//! This module contains the exhaustive `AppEvent` dispatcher and exit-mode handling. Large domain +//! actions are delegated to focused app submodules so the central match remains the routing layer. + +use super::*; + +impl App { + pub(super) async fn handle_event( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + event: AppEvent, + ) -> Result { + match event { + AppEvent::NewSession => { + self.start_fresh_session_with_summary_hint( + tui, app_server, /*session_start_source*/ None, + /*initial_user_message*/ None, + ) + .await; + } + AppEvent::ClearUi => { + self.clear_terminal_ui(tui, /*redraw_header*/ false)?; + self.reset_app_ui_state_after_clear(); + + self.start_fresh_session_with_summary_hint( + tui, + app_server, + Some(ThreadStartSource::Clear), + /*initial_user_message*/ None, + ) + .await; + } + AppEvent::ClearUiAndSubmitUserMessage { text } => { + self.clear_terminal_ui(tui, /*redraw_header*/ false)?; + self.reset_app_ui_state_after_clear(); + + self.start_fresh_session_with_summary_hint( + tui, + app_server, + Some(ThreadStartSource::Clear), + crate::chatwidget::create_initial_user_message( + Some(text), + Vec::new(), + Vec::new(), + ), + ) + .await; + } + AppEvent::OpenResumePicker => { + let picker_app_server = match crate::start_app_server_for_picker( + &self.config, + &match self.remote_app_server_url.clone() { + Some(websocket_url) => crate::AppServerTarget::Remote { + websocket_url, + auth_token: self.remote_app_server_auth_token.clone(), + }, + None => crate::AppServerTarget::Embedded, + }, + self.environment_manager.clone(), + ) + .await + { + Ok(app_server) => app_server, + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to start TUI session picker: {err}" + )); + return Ok(AppRunControl::Continue); + } + }; + match crate::resume_picker::run_resume_picker_with_app_server( + tui, + &self.config, + /*show_all*/ false, + /*include_non_interactive*/ false, + picker_app_server, + ) + .await? + { + SessionSelection::Resume(target_session) => { + match self + .resume_target_session(tui, app_server, target_session) + .await? + { + AppRunControl::Continue => {} + AppRunControl::Exit(reason) => { + return Ok(AppRunControl::Exit(reason)); + } + } + } + SessionSelection::Exit + | SessionSelection::StartFresh + | SessionSelection::Fork(_) => {} + } + + // Leaving alt-screen may blank the inline viewport; force a redraw either way. + tui.frame_requester().schedule_frame(); + } + AppEvent::ResumeSessionByIdOrName(id_or_name) => { + match crate::lookup_session_target_with_app_server(app_server, &id_or_name).await? { + Some(target_session) => { + return self + .resume_target_session(tui, app_server, target_session) + .await; + } + None => { + self.chat_widget.add_error_message(format!( + "No saved chat found matching '{id_or_name}'." + )); + } + } + } + AppEvent::ForkCurrentSession => { + self.session_telemetry.counter( + "codex.thread.fork", + /*inc*/ 1, + &[("source", "slash_command")], + ); + let summary = session_summary( + self.chat_widget.token_usage(), + self.chat_widget.thread_id(), + self.chat_widget.thread_name(), + self.chat_widget.rollout_path().as_deref(), + ); + self.chat_widget + .add_plain_history_lines(vec!["/fork".magenta().into()]); + if let Some(thread_id) = self.chat_widget.thread_id() { + self.refresh_in_memory_config_from_disk_best_effort("forking the thread") + .await; + match app_server.fork_thread(self.config.clone(), thread_id).await { + Ok(forked) => { + self.shutdown_current_thread(app_server).await; + match self + .replace_chat_widget_with_app_server_thread( + tui, app_server, forked, /*initial_user_message*/ None, + ) + .await + { + Ok(()) => { + if let Some(summary) = summary { + let mut lines: Vec> = Vec::new(); + if let Some(usage_line) = summary.usage_line { + lines.push(usage_line.into()); + } + if let Some(command) = summary.resume_command { + let spans = vec![ + "To continue this session, run ".into(), + command.cyan(), + ]; + lines.push(spans.into()); + } + self.chat_widget.add_plain_history_lines(lines); + } + } + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to attach to forked app-server thread: {err}" + )); + } + } + } + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to fork current session through the app server: {err}" + )); + } + } + } else { + self.chat_widget.add_error_message( + "A thread must contain at least one turn before it can be forked." + .to_string(), + ); + } + + tui.frame_requester().schedule_frame(); + } + AppEvent::InsertHistoryCell(cell) => { + let cell: Arc = cell.into(); + if let Some(Overlay::Transcript(t)) = &mut self.overlay { + t.insert_cell(cell.clone()); + tui.frame_requester().schedule_frame(); + } + self.transcript_cells.push(cell.clone()); + let mut display = cell.display_lines(tui.terminal.last_known_screen_size.width); + if !display.is_empty() { + // Only insert a separating blank line for new cells that are not + // part of an ongoing stream. Streaming continuations should not + // accrue extra blank lines between chunks. + if !cell.is_stream_continuation() { + if self.has_emitted_history_lines { + display.insert(0, Line::from("")); + } else { + self.has_emitted_history_lines = true; + } + } + if self.overlay.is_some() { + self.deferred_history_lines.extend(display); + } else { + tui.insert_history_lines(display); + } + } + } + AppEvent::ApplyThreadRollback { num_turns } => { + if self.apply_non_pending_thread_rollback(num_turns) { + tui.frame_requester().schedule_frame(); + } + } + AppEvent::StartCommitAnimation => { + if self + .commit_anim_running + .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) + .is_ok() + { + let tx = self.app_event_tx.clone(); + let running = self.commit_anim_running.clone(); + thread::spawn(move || { + while running.load(Ordering::Relaxed) { + thread::sleep(COMMIT_ANIMATION_TICK); + tx.send(AppEvent::CommitTick); + } + }); + } + } + AppEvent::StopCommitAnimation => { + self.commit_anim_running.store(false, Ordering::Release); + } + AppEvent::CommitTick => { + self.chat_widget.on_commit_tick(); + } + AppEvent::Exit(mode) => { + return Ok(self.handle_exit_mode(app_server, mode).await); + } + AppEvent::Logout => match app_server.logout_account().await { + Ok(()) => { + return Ok(self + .handle_exit_mode(app_server, ExitMode::ShutdownFirst) + .await); + } + Err(err) => { + tracing::error!("failed to logout: {err}"); + self.chat_widget + .add_error_message(format!("Logout failed: {err}")); + } + }, + AppEvent::FatalExitRequest(message) => { + return Ok(AppRunControl::Exit(ExitReason::Fatal(message))); + } + AppEvent::CodexOp(op) => { + self.submit_active_thread_op(app_server, op.into()).await?; + } + AppEvent::SubmitThreadOp { thread_id, op } => { + self.submit_thread_op(app_server, thread_id, op.into()) + .await?; + } + AppEvent::ThreadHistoryEntryResponse { thread_id, event } => { + self.enqueue_thread_history_entry_response(thread_id, event) + .await?; + } + AppEvent::DiffResult(text) => { + // Clear the in-progress state in the bottom pane + self.chat_widget.on_diff_complete(); + // Enter alternate screen using TUI helper and build pager lines + let _ = tui.enter_alt_screen(); + let pager_lines: Vec> = if text.trim().is_empty() { + vec!["No changes detected.".italic().into()] + } else { + text.lines().map(ansi_escape_line).collect() + }; + self.overlay = Some(Overlay::new_static_with_lines( + pager_lines, + "D I F F".to_string(), + )); + tui.frame_requester().schedule_frame(); + } + AppEvent::OpenAppLink { + app_id, + title, + description, + instructions, + url, + is_installed, + is_enabled, + } => { + self.chat_widget + .open_app_link_view(crate::bottom_pane::AppLinkViewParams { + app_id, + title, + description, + instructions, + url, + is_installed, + is_enabled, + suggest_reason: None, + suggestion_type: None, + elicitation_target: None, + }); + } + AppEvent::OpenUrlInBrowser { url } => { + self.open_url_in_browser(url); + } + AppEvent::RefreshConnectors { force_refetch } => { + self.chat_widget.refresh_connectors(force_refetch); + } + AppEvent::PluginInstallAuthAdvance { refresh_connectors } => { + if refresh_connectors { + self.chat_widget.refresh_connectors(/*force_refetch*/ true); + } + self.chat_widget.advance_plugin_install_auth_flow(); + } + AppEvent::PluginInstallAuthAbandon => { + self.chat_widget.abandon_plugin_install_auth_flow(); + } + AppEvent::FetchPluginsList { cwd } => { + self.fetch_plugins_list(app_server, cwd); + } + AppEvent::OpenPluginDetailLoading { + plugin_display_name, + } => { + self.chat_widget + .open_plugin_detail_loading_popup(&plugin_display_name); + } + AppEvent::OpenPluginInstallLoading { + plugin_display_name, + } => { + self.chat_widget + .open_plugin_install_loading_popup(&plugin_display_name); + } + AppEvent::OpenPluginUninstallLoading { + plugin_display_name, + } => { + self.chat_widget + .open_plugin_uninstall_loading_popup(&plugin_display_name); + } + AppEvent::PluginsLoaded { cwd, result } => { + self.chat_widget.on_plugins_loaded(cwd, result); + } + AppEvent::FetchPluginDetail { cwd, params } => { + self.fetch_plugin_detail(app_server, cwd, params); + } + AppEvent::PluginDetailLoaded { cwd, result } => { + self.chat_widget.on_plugin_detail_loaded(cwd, result); + } + AppEvent::FetchPluginInstall { + cwd, + marketplace_path, + plugin_name, + plugin_display_name, + } => { + self.fetch_plugin_install( + app_server, + cwd, + marketplace_path, + plugin_name, + plugin_display_name, + ); + } + AppEvent::FetchPluginUninstall { + cwd, + plugin_id, + plugin_display_name, + } => { + self.fetch_plugin_uninstall(app_server, cwd, plugin_id, plugin_display_name); + } + AppEvent::SetPluginEnabled { + cwd, + plugin_id, + enabled, + } => { + self.set_plugin_enabled(app_server, cwd, plugin_id, enabled); + } + AppEvent::PluginInstallLoaded { + cwd, + marketplace_path, + plugin_name, + plugin_display_name, + result, + } => { + let install_succeeded = result.is_ok(); + if install_succeeded { + if let Err(err) = self.refresh_in_memory_config_from_disk().await { + tracing::warn!(error = %err, "failed to refresh config after plugin install"); + } + self.chat_widget.refresh_plugin_mentions(); + self.chat_widget.submit_op(AppCommand::reload_user_config()); + } + let should_refresh_plugin_detail = self.chat_widget.on_plugin_install_loaded( + cwd.clone(), + marketplace_path.clone(), + plugin_name.clone(), + plugin_display_name, + result, + ); + if install_succeeded && self.chat_widget.config_ref().cwd.as_path() == cwd.as_path() + { + self.fetch_plugins_list(app_server, cwd.clone()); + if should_refresh_plugin_detail { + self.fetch_plugin_detail( + app_server, + cwd, + PluginReadParams { + marketplace_path: Some(marketplace_path), + remote_marketplace_name: None, + plugin_name, + }, + ); + } + } + } + AppEvent::PluginEnabledSet { + cwd, + plugin_id, + enabled, + result, + } => { + let queued_enabled = self + .pending_plugin_enabled_writes + .get_mut(&plugin_id) + .and_then(Option::take); + let should_apply_result = if let Some(queued_enabled) = queued_enabled + && (result.is_err() || queued_enabled != enabled) + { + self.spawn_plugin_enabled_write( + app_server, + cwd.clone(), + plugin_id.clone(), + queued_enabled, + ); + false + } else { + true + }; + if should_apply_result { + self.pending_plugin_enabled_writes.remove(&plugin_id); + let update_succeeded = result.is_ok(); + if update_succeeded { + if let Err(err) = self.refresh_in_memory_config_from_disk().await { + tracing::warn!( + error = %err, + "failed to refresh config after plugin toggle" + ); + } + self.chat_widget.refresh_plugin_mentions(); + self.chat_widget.submit_op(AppCommand::reload_user_config()); + } + self.chat_widget + .on_plugin_enabled_set(cwd, plugin_id, enabled, result); + } + } + AppEvent::FetchMcpInventory { detail } => { + self.fetch_mcp_inventory(app_server, detail); + } + AppEvent::McpInventoryLoaded { result, detail } => { + self.handle_mcp_inventory_result(result, detail); + } + AppEvent::SkillsListLoaded { result } => { + self.handle_skills_list_result( + result.map_err(|err| color_eyre::eyre::eyre!(err)), + "failed to load skills on startup", + ); + } + AppEvent::StartFileSearch(query) => { + self.file_search.on_user_query(query); + } + AppEvent::FileSearchResult { query, matches } => { + self.chat_widget.apply_file_search_result(query, matches); + } + AppEvent::RefreshRateLimits { origin } => { + self.refresh_rate_limits(app_server, origin); + } + AppEvent::SendAddCreditsNudgeEmail { credit_type } => { + if self + .chat_widget + .start_add_credits_nudge_email_request(credit_type) + { + self.send_add_credits_nudge_email(app_server, credit_type); + } + } + AppEvent::AddCreditsNudgeEmailFinished { result } => { + self.chat_widget + .finish_add_credits_nudge_email_request(result); + } + AppEvent::RateLimitsLoaded { origin, result } => match result { + Ok(snapshots) => { + for snapshot in snapshots { + self.chat_widget.on_rate_limit_snapshot(Some(snapshot)); + } + match origin { + RateLimitRefreshOrigin::StartupPrefetch => { + tui.frame_requester().schedule_frame(); + } + RateLimitRefreshOrigin::StatusCommand { request_id } => { + self.chat_widget + .finish_status_rate_limit_refresh(request_id); + } + } + } + Err(err) => { + tracing::warn!("account/rateLimits/read failed during TUI refresh: {err}"); + if let RateLimitRefreshOrigin::StatusCommand { request_id } = origin { + self.chat_widget + .finish_status_rate_limit_refresh(request_id); + } + } + }, + AppEvent::ConnectorsLoaded { result, is_final } => { + self.chat_widget.on_connectors_loaded(result, is_final); + } + AppEvent::UpdateReasoningEffort(effort) => { + self.on_update_reasoning_effort(effort); + } + AppEvent::UpdateModel(model) => { + self.chat_widget.set_model(&model); + } + AppEvent::UpdateCollaborationMode(mask) => { + self.chat_widget.set_collaboration_mask(mask); + } + AppEvent::UpdatePersonality(personality) => { + self.on_update_personality(personality); + } + AppEvent::OpenRealtimeAudioDeviceSelection { kind } => { + self.chat_widget.open_realtime_audio_device_selection(kind); + } + AppEvent::RealtimeWebrtcOfferCreated { result } => { + self.chat_widget.on_realtime_webrtc_offer_created(result); + } + AppEvent::RealtimeWebrtcEvent(event) => { + self.chat_widget.on_realtime_webrtc_event(event); + } + AppEvent::RealtimeWebrtcLocalAudioLevel(peak) => { + self.chat_widget.on_realtime_webrtc_local_audio_level(peak); + } + AppEvent::OpenReasoningPopup { model } => { + self.chat_widget.open_reasoning_popup(model); + } + AppEvent::OpenPlanReasoningScopePrompt { model, effort } => { + self.chat_widget + .open_plan_reasoning_scope_prompt(model, effort); + } + AppEvent::OpenAllModelsPopup { models } => { + self.chat_widget.open_all_models_popup(models); + } + AppEvent::OpenFullAccessConfirmation { + preset, + return_to_permissions, + } => { + self.chat_widget + .open_full_access_confirmation(preset, return_to_permissions); + } + AppEvent::OpenWorldWritableWarningConfirmation { + preset, + sample_paths, + extra_count, + failed_scan, + } => { + self.chat_widget.open_world_writable_warning_confirmation( + preset, + sample_paths, + extra_count, + failed_scan, + ); + } + AppEvent::OpenFeedbackNote { + category, + include_logs, + } => { + self.chat_widget.open_feedback_note(category, include_logs); + } + AppEvent::OpenFeedbackConsent { category } => { + self.chat_widget.open_feedback_consent(category); + } + AppEvent::SubmitFeedback { + category, + reason, + turn_id, + include_logs, + } => { + self.submit_feedback(app_server, category, reason, turn_id, include_logs); + } + AppEvent::FeedbackSubmitted { + origin_thread_id, + category, + include_logs, + result, + } => { + self.handle_feedback_submitted(origin_thread_id, category, include_logs, result) + .await; + } + AppEvent::LaunchExternalEditor => { + if self.chat_widget.external_editor_state() == ExternalEditorState::Active { + self.launch_external_editor(tui).await; + } + } + AppEvent::OpenWindowsSandboxEnablePrompt { preset } => { + self.chat_widget.open_windows_sandbox_enable_prompt(preset); + } + AppEvent::OpenWindowsSandboxFallbackPrompt { preset } => { + self.session_telemetry.counter( + "codex.windows_sandbox.fallback_prompt_shown", + /*inc*/ 1, + &[], + ); + self.chat_widget.clear_windows_sandbox_setup_status(); + if let Some(started_at) = self.windows_sandbox.setup_started_at.take() { + self.session_telemetry.record_duration( + "codex.windows_sandbox.elevated_setup_duration_ms", + started_at.elapsed(), + &[("result", "failure")], + ); + } + self.chat_widget + .open_windows_sandbox_fallback_prompt(preset); + } + AppEvent::BeginWindowsSandboxElevatedSetup { preset } => { + #[cfg(target_os = "windows")] + { + let policy = preset.sandbox.clone(); + let policy_cwd = self.config.cwd.clone(); + let command_cwd = policy_cwd.clone(); + let env_map: std::collections::HashMap = + std::env::vars().collect(); + let codex_home = self.config.codex_home.clone(); + let tx = self.app_event_tx.clone(); + + // If the elevated setup already ran on this machine, don't prompt for + // elevation again - just flip the config to use the elevated path. + if crate::legacy_core::windows_sandbox::sandbox_setup_is_complete( + codex_home.as_path(), + ) { + tx.send(AppEvent::EnableWindowsSandboxForAgentMode { + preset, + mode: WindowsSandboxEnableMode::Elevated, + }); + return Ok(AppRunControl::Continue); + } + + self.chat_widget.show_windows_sandbox_setup_status(); + self.windows_sandbox.setup_started_at = Some(Instant::now()); + let session_telemetry = self.session_telemetry.clone(); + tokio::task::spawn_blocking(move || { + let result = crate::legacy_core::windows_sandbox::run_elevated_setup( + &policy, + policy_cwd.as_path(), + command_cwd.as_path(), + &env_map, + codex_home.as_path(), + ); + let event = match result { + Ok(()) => { + session_telemetry.counter( + "codex.windows_sandbox.elevated_setup_success", + /*inc*/ 1, + &[], + ); + AppEvent::EnableWindowsSandboxForAgentMode { + preset: preset.clone(), + mode: WindowsSandboxEnableMode::Elevated, + } + } + Err(err) => { + let mut code_tag: Option = None; + let mut message_tag: Option = None; + if let Some((code, message)) = + crate::legacy_core::windows_sandbox::elevated_setup_failure_details( + &err, + ) + { + code_tag = Some(code); + message_tag = Some(message); + } + let mut tags: Vec<(&str, &str)> = Vec::new(); + if let Some(code) = code_tag.as_deref() { + tags.push(("code", code)); + } + if let Some(message) = message_tag.as_deref() { + tags.push(("message", message)); + } + session_telemetry.counter( + crate::legacy_core::windows_sandbox::elevated_setup_failure_metric_name( + &err, + ), + /*inc*/ 1, + &tags, + ); + tracing::error!( + error = %err, + "failed to run elevated Windows sandbox setup" + ); + AppEvent::OpenWindowsSandboxFallbackPrompt { preset } + } + }; + tx.send(event); + }); + } + #[cfg(not(target_os = "windows"))] + { + let _ = preset; + } + } + AppEvent::BeginWindowsSandboxLegacySetup { preset } => { + #[cfg(target_os = "windows")] + { + let policy = preset.sandbox.clone(); + let policy_cwd = self.config.cwd.clone(); + let command_cwd = policy_cwd.clone(); + let env_map: std::collections::HashMap = + std::env::vars().collect(); + let codex_home = self.config.codex_home.clone(); + let tx = self.app_event_tx.clone(); + let session_telemetry = self.session_telemetry.clone(); + + self.chat_widget.show_windows_sandbox_setup_status(); + tokio::task::spawn_blocking(move || { + if let Err(err) = + crate::legacy_core::windows_sandbox::run_legacy_setup_preflight( + &policy, + policy_cwd.as_path(), + command_cwd.as_path(), + &env_map, + codex_home.as_path(), + ) + { + session_telemetry.counter( + "codex.windows_sandbox.legacy_setup_preflight_failed", + /*inc*/ 1, + &[], + ); + tracing::warn!( + error = %err, + "failed to preflight non-admin Windows sandbox setup" + ); + } + tx.send(AppEvent::EnableWindowsSandboxForAgentMode { + preset, + mode: WindowsSandboxEnableMode::Legacy, + }); + }); + } + #[cfg(not(target_os = "windows"))] + { + let _ = preset; + } + } + AppEvent::BeginWindowsSandboxGrantReadRoot { path } => { + #[cfg(target_os = "windows")] + { + self.chat_widget + .add_to_history(history_cell::new_info_event( + format!("Granting sandbox read access to {path} ..."), + /*hint*/ None, + )); + + let policy = self.config.permissions.sandbox_policy.get().clone(); + let policy_cwd = self.config.cwd.clone(); + let command_cwd = self.config.cwd.clone(); + let env_map: std::collections::HashMap = + std::env::vars().collect(); + let codex_home = self.config.codex_home.clone(); + let tx = self.app_event_tx.clone(); + + tokio::task::spawn_blocking(move || { + let requested_path = PathBuf::from(path); + let event = match crate::legacy_core::grant_read_root_non_elevated( + &policy, + policy_cwd.as_path(), + command_cwd.as_path(), + &env_map, + codex_home.as_path(), + requested_path.as_path(), + ) { + Ok(canonical_path) => AppEvent::WindowsSandboxGrantReadRootCompleted { + path: canonical_path, + error: None, + }, + Err(err) => AppEvent::WindowsSandboxGrantReadRootCompleted { + path: requested_path, + error: Some(err.to_string()), + }, + }; + tx.send(event); + }); + } + #[cfg(not(target_os = "windows"))] + { + let _ = path; + } + } + AppEvent::WindowsSandboxGrantReadRootCompleted { path, error } => match error { + Some(err) => { + self.chat_widget + .add_to_history(history_cell::new_error_event(format!("Error: {err}"))); + } + None => { + self.chat_widget + .add_to_history(history_cell::new_info_event( + format!("Sandbox read access granted for {}", path.display()), + /*hint*/ None, + )); + } + }, + AppEvent::EnableWindowsSandboxForAgentMode { preset, mode } => { + #[cfg(target_os = "windows")] + { + self.chat_widget.clear_windows_sandbox_setup_status(); + if let Some(started_at) = self.windows_sandbox.setup_started_at.take() { + self.session_telemetry.record_duration( + "codex.windows_sandbox.elevated_setup_duration_ms", + started_at.elapsed(), + &[("result", "success")], + ); + } + let profile = self.active_profile.as_deref(); + let elevated_enabled = matches!(mode, WindowsSandboxEnableMode::Elevated); + let builder = ConfigEditsBuilder::new(&self.config.codex_home) + .with_profile(profile) + .set_windows_sandbox_mode(if elevated_enabled { + "elevated" + } else { + "unelevated" + }) + .clear_legacy_windows_sandbox_keys(); + match builder.apply().await { + Ok(()) => { + if elevated_enabled { + self.config.set_windows_sandbox_enabled(/*value*/ false); + self.config + .set_windows_elevated_sandbox_enabled(/*value*/ true); + } else { + self.config.set_windows_sandbox_enabled(/*value*/ true); + self.config + .set_windows_elevated_sandbox_enabled(/*value*/ false); + } + self.chat_widget.set_windows_sandbox_mode( + self.config.permissions.windows_sandbox_mode, + ); + let windows_sandbox_level = + WindowsSandboxLevel::from_config(&self.config); + if let Some((sample_paths, extra_count, failed_scan)) = + self.chat_widget.world_writable_warning_details() + { + self.app_event_tx.send(AppEvent::CodexOp( + AppCommand::override_turn_context( + /*cwd*/ None, + /*approval_policy*/ None, + /*approvals_reviewer*/ None, + /*sandbox_policy*/ None, + #[cfg(target_os = "windows")] + Some(windows_sandbox_level), + /*model*/ None, + /*effort*/ None, + /*summary*/ None, + /*service_tier*/ None, + /*collaboration_mode*/ None, + /*personality*/ None, + ) + .into(), + )); + self.app_event_tx.send( + AppEvent::OpenWorldWritableWarningConfirmation { + preset: Some(preset.clone()), + sample_paths, + extra_count, + failed_scan, + }, + ); + } else { + self.app_event_tx.send(AppEvent::CodexOp( + AppCommand::override_turn_context( + /*cwd*/ None, + Some(preset.approval), + Some(self.config.approvals_reviewer), + Some(preset.sandbox.clone()), + #[cfg(target_os = "windows")] + Some(windows_sandbox_level), + /*model*/ None, + /*effort*/ None, + /*summary*/ None, + /*service_tier*/ None, + /*collaboration_mode*/ None, + /*personality*/ None, + ) + .into(), + )); + self.app_event_tx + .send(AppEvent::UpdateAskForApprovalPolicy(preset.approval)); + self.app_event_tx + .send(AppEvent::UpdateSandboxPolicy(preset.sandbox.clone())); + let _ = mode; + self.chat_widget.add_plain_history_lines(vec![ + Line::from(vec!["• ".dim(), "Sandbox ready".into()]), + Line::from(vec![ + " ".into(), + "Codex can now safely edit files and execute commands in your computer" + .dark_gray(), + ]), + ]); + } + } + Err(err) => { + tracing::error!( + error = %err, + "failed to enable Windows sandbox feature" + ); + self.chat_widget.add_error_message(format!( + "Failed to enable the Windows sandbox feature: {err}" + )); + } + } + } + #[cfg(not(target_os = "windows"))] + { + let _ = (preset, mode); + } + } + AppEvent::PersistModelSelection { model, effort } => { + let profile = self.active_profile.as_deref(); + match ConfigEditsBuilder::new(&self.config.codex_home) + .with_profile(profile) + .set_model(Some(model.as_str()), effort) + .apply() + .await + { + Ok(()) => { + let effort_label = effort + .map(|selected_effort| selected_effort.to_string()) + .unwrap_or_else(|| "default".to_string()); + tracing::info!("Selected model: {model}, Selected effort: {effort_label}"); + let mut message = format!("Model changed to {model}"); + if let Some(label) = Self::reasoning_label_for(&model, effort) { + message.push(' '); + message.push_str(label); + } + if let Some(profile) = profile { + message.push_str(" for "); + message.push_str(profile); + message.push_str(" profile"); + } + self.chat_widget.add_info_message(message, /*hint*/ None); + } + Err(err) => { + tracing::error!( + error = %err, + "failed to persist model selection" + ); + if let Some(profile) = profile { + self.chat_widget.add_error_message(format!( + "Failed to save model for profile `{profile}`: {err}" + )); + } else { + self.chat_widget + .add_error_message(format!("Failed to save default model: {err}")); + } + } + } + } + AppEvent::PluginUninstallLoaded { + cwd, + plugin_id: _plugin_id, + plugin_display_name, + result, + } => { + let uninstall_succeeded = result.is_ok(); + if uninstall_succeeded { + if let Err(err) = self.refresh_in_memory_config_from_disk().await { + tracing::warn!( + error = %err, + "failed to refresh config after plugin uninstall" + ); + } + self.chat_widget.refresh_plugin_mentions(); + self.chat_widget.submit_op(AppCommand::reload_user_config()); + } + self.chat_widget.on_plugin_uninstall_loaded( + cwd.clone(), + plugin_display_name, + result, + ); + if uninstall_succeeded + && self.chat_widget.config_ref().cwd.as_path() == cwd.as_path() + { + self.fetch_plugins_list(app_server, cwd); + } + } + AppEvent::RefreshPluginMentions => { + self.refresh_plugin_mentions(); + } + AppEvent::PluginMentionsLoaded { mut plugins } => { + if !self.config.features.enabled(Feature::Plugins) { + plugins = None; + } + self.chat_widget.on_plugin_mentions_loaded(plugins); + } + AppEvent::PersistPersonalitySelection { personality } => { + let profile = self.active_profile.as_deref(); + match ConfigEditsBuilder::new(&self.config.codex_home) + .with_profile(profile) + .set_personality(Some(personality)) + .apply() + .await + { + Ok(()) => { + let label = Self::personality_label(personality); + let mut message = format!("Personality set to {label}"); + if let Some(profile) = profile { + message.push_str(" for "); + message.push_str(profile); + message.push_str(" profile"); + } + self.chat_widget.add_info_message(message, /*hint*/ None); + } + Err(err) => { + tracing::error!( + error = %err, + "failed to persist personality selection" + ); + if let Some(profile) = profile { + self.chat_widget.add_error_message(format!( + "Failed to save personality for profile `{profile}`: {err}" + )); + } else { + self.chat_widget.add_error_message(format!( + "Failed to save default personality: {err}" + )); + } + } + } + } + AppEvent::PersistServiceTierSelection { service_tier } => { + self.refresh_status_line(); + let profile = self.active_profile.as_deref(); + match ConfigEditsBuilder::new(&self.config.codex_home) + .with_profile(profile) + .set_service_tier(service_tier) + .apply() + .await + { + Ok(()) => { + let status = if service_tier.is_some() { "on" } else { "off" }; + let mut message = format!("Fast mode set to {status}"); + if let Some(profile) = profile { + message.push_str(" for "); + message.push_str(profile); + message.push_str(" profile"); + } + self.chat_widget.add_info_message(message, /*hint*/ None); + } + Err(err) => { + tracing::error!(error = %err, "failed to persist fast mode selection"); + if let Some(profile) = profile { + self.chat_widget.add_error_message(format!( + "Failed to save Fast mode for profile `{profile}`: {err}" + )); + } else { + self.chat_widget.add_error_message(format!( + "Failed to save default Fast mode: {err}" + )); + } + } + } + } + AppEvent::PersistRealtimeAudioDeviceSelection { kind, name } => { + let builder = match kind { + RealtimeAudioDeviceKind::Microphone => { + ConfigEditsBuilder::new(&self.config.codex_home) + .set_realtime_microphone(name.as_deref()) + } + RealtimeAudioDeviceKind::Speaker => { + ConfigEditsBuilder::new(&self.config.codex_home) + .set_realtime_speaker(name.as_deref()) + } + }; + + match builder.apply().await { + Ok(()) => { + match kind { + RealtimeAudioDeviceKind::Microphone => { + self.config.realtime_audio.microphone = name.clone(); + } + RealtimeAudioDeviceKind::Speaker => { + self.config.realtime_audio.speaker = name.clone(); + } + } + self.chat_widget + .set_realtime_audio_device(kind, name.clone()); + + if self.chat_widget.realtime_conversation_is_live() { + self.chat_widget.open_realtime_audio_restart_prompt(kind); + } else { + let selection = name.unwrap_or_else(|| "System default".to_string()); + self.chat_widget.add_info_message( + format!("Realtime {} set to {selection}", kind.noun()), + /*hint*/ None, + ); + } + } + Err(err) => { + tracing::error!( + error = %err, + "failed to persist realtime audio selection" + ); + self.chat_widget.add_error_message(format!( + "Failed to save realtime {}: {err}", + kind.noun() + )); + } + } + } + AppEvent::RestartRealtimeAudioDevice { kind } => { + self.chat_widget.restart_realtime_audio_device(kind); + } + AppEvent::UpdateAskForApprovalPolicy(policy) => { + let mut config = self.config.clone(); + if !self.try_set_approval_policy_on_config( + &mut config, + policy, + "Failed to set approval policy", + "failed to set approval policy on app config", + ) { + return Ok(AppRunControl::Continue); + } + self.config = config; + self.runtime_approval_policy_override = + Some(self.config.permissions.approval_policy.value()); + self.chat_widget + .set_approval_policy(self.config.permissions.approval_policy.value()); + } + AppEvent::UpdateSandboxPolicy(policy) => { + #[cfg(target_os = "windows")] + let policy_is_workspace_write_or_ro = matches!( + &policy, + codex_protocol::protocol::SandboxPolicy::WorkspaceWrite { .. } + | codex_protocol::protocol::SandboxPolicy::ReadOnly { .. } + ); + let policy_for_chat = policy.clone(); + + let mut config = self.config.clone(); + if !self.try_set_sandbox_policy_on_config( + &mut config, + policy, + "Failed to set sandbox policy", + "failed to set sandbox policy on app config", + ) { + return Ok(AppRunControl::Continue); + } + self.config = config; + if let Err(err) = self.chat_widget.set_sandbox_policy(policy_for_chat) { + tracing::warn!(%err, "failed to set sandbox policy on chat config"); + self.chat_widget + .add_error_message(format!("Failed to set sandbox policy: {err}")); + return Ok(AppRunControl::Continue); + } + self.runtime_sandbox_policy_override = + Some(self.config.permissions.sandbox_policy.get().clone()); + + // If sandbox policy becomes workspace-write or read-only, run the Windows world-writable scan. + #[cfg(target_os = "windows")] + { + // One-shot suppression if the user just confirmed continue. + if self.windows_sandbox.skip_world_writable_scan_once { + self.windows_sandbox.skip_world_writable_scan_once = false; + return Ok(AppRunControl::Continue); + } + + let should_check = WindowsSandboxLevel::from_config(&self.config) + != WindowsSandboxLevel::Disabled + && policy_is_workspace_write_or_ro + && !self.chat_widget.world_writable_warning_hidden(); + if should_check { + let cwd = self.config.cwd.clone(); + let env_map: std::collections::HashMap = + std::env::vars().collect(); + let tx = self.app_event_tx.clone(); + let logs_base_dir = self.config.codex_home.clone(); + let sandbox_policy = self.config.permissions.sandbox_policy.get().clone(); + Self::spawn_world_writable_scan( + cwd, + env_map, + logs_base_dir, + sandbox_policy, + tx, + ); + } + } + } + AppEvent::UpdateApprovalsReviewer(policy) => { + self.config.approvals_reviewer = policy; + self.chat_widget.set_approvals_reviewer(policy); + let profile = self.active_profile.as_deref(); + let segments = if let Some(profile) = profile { + vec![ + "profiles".to_string(), + profile.to_string(), + "approvals_reviewer".to_string(), + ] + } else { + vec!["approvals_reviewer".to_string()] + }; + if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) + .with_profile(profile) + .with_edits([ConfigEdit::SetPath { + segments, + value: policy.to_string().into(), + }]) + .apply() + .await + { + tracing::error!( + error = %err, + "failed to persist approvals reviewer update" + ); + self.chat_widget + .add_error_message(format!("Failed to save approvals reviewer: {err}")); + } + } + AppEvent::UpdateFeatureFlags { updates } => { + self.update_feature_flags(updates).await; + } + AppEvent::UpdateMemorySettings { + use_memories, + generate_memories, + } => { + self.update_memory_settings_with_app_server( + app_server, + use_memories, + generate_memories, + ) + .await; + } + AppEvent::ResetMemories => { + self.reset_memories_with_app_server(app_server).await; + } + AppEvent::SkipNextWorldWritableScan => { + self.windows_sandbox.skip_world_writable_scan_once = true; + } + AppEvent::UpdateFullAccessWarningAcknowledged(ack) => { + self.chat_widget.set_full_access_warning_acknowledged(ack); + } + AppEvent::UpdateWorldWritableWarningAcknowledged(ack) => { + self.chat_widget + .set_world_writable_warning_acknowledged(ack); + } + AppEvent::UpdateRateLimitSwitchPromptHidden(hidden) => { + self.chat_widget.set_rate_limit_switch_prompt_hidden(hidden); + } + AppEvent::UpdatePlanModeReasoningEffort(effort) => { + self.config.plan_mode_reasoning_effort = effort; + self.chat_widget.set_plan_mode_reasoning_effort(effort); + } + AppEvent::PersistFullAccessWarningAcknowledged => { + if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) + .set_hide_full_access_warning(/*acknowledged*/ true) + .apply() + .await + { + tracing::error!( + error = %err, + "failed to persist full access warning acknowledgement" + ); + self.chat_widget.add_error_message(format!( + "Failed to save full access confirmation preference: {err}" + )); + } + } + AppEvent::PersistWorldWritableWarningAcknowledged => { + if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) + .set_hide_world_writable_warning(/*acknowledged*/ true) + .apply() + .await + { + tracing::error!( + error = %err, + "failed to persist world-writable warning acknowledgement" + ); + self.chat_widget.add_error_message(format!( + "Failed to save Agent mode warning preference: {err}" + )); + } + } + AppEvent::PersistRateLimitSwitchPromptHidden => { + if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) + .set_hide_rate_limit_model_nudge(/*acknowledged*/ true) + .apply() + .await + { + tracing::error!( + error = %err, + "failed to persist rate limit switch prompt preference" + ); + self.chat_widget.add_error_message(format!( + "Failed to save rate limit reminder preference: {err}" + )); + } + } + AppEvent::PersistPlanModeReasoningEffort(effort) => { + let profile = self.active_profile.as_deref(); + let segments = if let Some(profile) = profile { + vec![ + "profiles".to_string(), + profile.to_string(), + "plan_mode_reasoning_effort".to_string(), + ] + } else { + vec!["plan_mode_reasoning_effort".to_string()] + }; + let edit = if let Some(effort) = effort { + ConfigEdit::SetPath { + segments, + value: effort.to_string().into(), + } + } else { + ConfigEdit::ClearPath { segments } + }; + if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) + .with_edits([edit]) + .apply() + .await + { + tracing::error!( + error = %err, + "failed to persist plan mode reasoning effort" + ); + if let Some(profile) = profile { + self.chat_widget.add_error_message(format!( + "Failed to save Plan mode reasoning effort for profile `{profile}`: {err}" + )); + } else { + self.chat_widget.add_error_message(format!( + "Failed to save Plan mode reasoning effort: {err}" + )); + } + } + } + AppEvent::PersistModelMigrationPromptAcknowledged { + from_model, + to_model, + } => { + if let Err(err) = ConfigEditsBuilder::new(&self.config.codex_home) + .record_model_migration_seen(from_model.as_str(), to_model.as_str()) + .apply() + .await + { + tracing::error!( + error = %err, + "failed to persist model migration prompt acknowledgement" + ); + self.chat_widget.add_error_message(format!( + "Failed to save model migration prompt preference: {err}" + )); + } + } + AppEvent::OpenApprovalsPopup => { + self.chat_widget.open_approvals_popup(); + } + AppEvent::OpenAgentPicker => { + self.open_agent_picker(app_server).await; + } + AppEvent::SelectAgentThread(thread_id) => { + self.select_agent_thread_and_discard_side(tui, app_server, thread_id) + .await?; + } + AppEvent::StartSide { + parent_thread_id, + user_message, + } => { + return self + .handle_start_side(tui, app_server, parent_thread_id, user_message) + .await; + } + AppEvent::OpenSkillsList => { + self.chat_widget.open_skills_list(); + } + AppEvent::OpenManageSkillsPopup => { + self.chat_widget.open_manage_skills_popup(); + } + AppEvent::SetSkillEnabled { path, enabled } => { + let edits = [ConfigEdit::SetSkillConfig { + path: path.to_path_buf(), + enabled, + }]; + match ConfigEditsBuilder::new(&self.config.codex_home) + .with_edits(edits) + .apply() + .await + { + Ok(()) => { + self.chat_widget.update_skill_enabled(path, enabled); + if let Err(err) = self.refresh_in_memory_config_from_disk().await { + tracing::warn!( + error = %err, + "failed to refresh config after skill toggle" + ); + } + } + Err(err) => { + let path_display = path.display(); + self.chat_widget.add_error_message(format!( + "Failed to update skill config for {path_display}: {err}" + )); + } + } + } + AppEvent::SetAppEnabled { id, enabled } => { + let edits = if enabled { + vec![ + ConfigEdit::ClearPath { + segments: vec!["apps".to_string(), id.clone(), "enabled".to_string()], + }, + ConfigEdit::ClearPath { + segments: vec![ + "apps".to_string(), + id.clone(), + "disabled_reason".to_string(), + ], + }, + ] + } else { + vec![ + ConfigEdit::SetPath { + segments: vec!["apps".to_string(), id.clone(), "enabled".to_string()], + value: false.into(), + }, + ConfigEdit::SetPath { + segments: vec![ + "apps".to_string(), + id.clone(), + "disabled_reason".to_string(), + ], + value: "user".into(), + }, + ] + }; + match ConfigEditsBuilder::new(&self.config.codex_home) + .with_edits(edits) + .apply() + .await + { + Ok(()) => { + self.chat_widget.update_connector_enabled(&id, enabled); + if let Err(err) = self.refresh_in_memory_config_from_disk().await { + tracing::warn!(error = %err, "failed to refresh config after app toggle"); + } + self.chat_widget.submit_op(AppCommand::reload_user_config()); + } + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to update app config for {id}: {err}" + )); + } + } + } + AppEvent::OpenPermissionsPopup => { + self.chat_widget.open_permissions_popup(); + } + AppEvent::OpenReviewBranchPicker(cwd) => { + self.chat_widget.show_review_branch_picker(&cwd).await; + } + AppEvent::OpenReviewCommitPicker(cwd) => { + self.chat_widget.show_review_commit_picker(&cwd).await; + } + AppEvent::OpenReviewCustomPrompt => { + self.chat_widget.show_review_custom_prompt(); + } + AppEvent::SubmitUserMessageWithMode { + text, + collaboration_mode, + } => { + self.chat_widget + .submit_user_message_with_mode(text, collaboration_mode); + } + AppEvent::ManageSkillsClosed => { + self.chat_widget.handle_manage_skills_closed(); + } + AppEvent::FullScreenApprovalRequest(request) => match request { + ApprovalRequest::ApplyPatch { cwd, changes, .. } => { + let _ = tui.enter_alt_screen(); + let diff_summary = DiffSummary::new(changes, cwd); + self.overlay = Some(Overlay::new_static_with_renderables( + vec![diff_summary.into()], + "P A T C H".to_string(), + )); + } + ApprovalRequest::Exec { command, .. } => { + let _ = tui.enter_alt_screen(); + let full_cmd = strip_bash_lc_and_escape(&command); + let full_cmd_lines = highlight_bash_to_lines(&full_cmd); + self.overlay = Some(Overlay::new_static_with_lines( + full_cmd_lines, + "E X E C".to_string(), + )); + } + ApprovalRequest::Permissions { + permissions, + reason, + .. + } => { + let _ = tui.enter_alt_screen(); + let mut lines = Vec::new(); + if let Some(reason) = reason { + lines.push(Line::from(vec!["Reason: ".into(), reason.italic()])); + lines.push(Line::from("")); + } + if let Some(rule_line) = + crate::bottom_pane::format_requested_permissions_rule(&permissions) + { + lines.push(Line::from(vec![ + "Permission rule: ".into(), + rule_line.cyan(), + ])); + } + self.overlay = Some(Overlay::new_static_with_renderables( + vec![Box::new(Paragraph::new(lines).wrap(Wrap { trim: false }))], + "P E R M I S S I O N S".to_string(), + )); + } + ApprovalRequest::McpElicitation { + server_name, + message, + .. + } => { + let _ = tui.enter_alt_screen(); + let paragraph = Paragraph::new(vec![ + Line::from(vec!["Server: ".into(), server_name.bold()]), + Line::from(""), + Line::from(message), + ]) + .wrap(Wrap { trim: false }); + self.overlay = Some(Overlay::new_static_with_renderables( + vec![Box::new(paragraph)], + "E L I C I T A T I O N".to_string(), + )); + } + }, + #[cfg(not(target_os = "linux"))] + AppEvent::UpdateRecordingMeter { id, text } => { + // Update in place to preserve the element id for subsequent frames. + let updated = self.chat_widget.update_recording_meter_in_place(&id, &text); + if updated + || self + .chat_widget + .stop_realtime_conversation_for_deleted_meter(&id) + { + tui.frame_requester().schedule_frame(); + } + } + AppEvent::StatusLineSetup { items } => { + let ids = items.iter().map(ToString::to_string).collect::>(); + let edit = crate::legacy_core::config::edit::status_line_items_edit(&ids); + let apply_result = ConfigEditsBuilder::new(&self.config.codex_home) + .with_edits([edit]) + .apply() + .await; + match apply_result { + Ok(()) => { + self.config.tui_status_line = Some(ids.clone()); + self.chat_widget.setup_status_line(items); + } + Err(err) => { + tracing::error!(error = %err, "failed to persist status line items; keeping previous selection"); + self.chat_widget + .add_error_message(format!("Failed to save status line items: {err}")); + } + } + } + AppEvent::StatusLineBranchUpdated { cwd, branch } => { + self.chat_widget.set_status_line_branch(cwd, branch); + self.refresh_status_line(); + } + AppEvent::StatusLineSetupCancelled => { + self.chat_widget.cancel_status_line_setup(); + } + AppEvent::TerminalTitleSetup { items } => { + let ids = items.iter().map(ToString::to_string).collect::>(); + let edit = crate::legacy_core::config::edit::terminal_title_items_edit(&ids); + let apply_result = ConfigEditsBuilder::new(&self.config.codex_home) + .with_edits([edit]) + .apply() + .await; + match apply_result { + Ok(()) => { + self.config.tui_terminal_title = Some(ids.clone()); + self.chat_widget.setup_terminal_title(items); + } + Err(err) => { + tracing::error!(error = %err, "failed to persist terminal title items; keeping previous selection"); + self.chat_widget.revert_terminal_title_setup_preview(); + self.chat_widget.add_error_message(format!( + "Failed to save terminal title items: {err}" + )); + } + } + } + AppEvent::TerminalTitleSetupPreview { items } => { + self.chat_widget.preview_terminal_title(items); + } + AppEvent::TerminalTitleSetupCancelled => { + self.chat_widget.cancel_terminal_title_setup(); + } + AppEvent::SyntaxThemeSelected { name } => { + let edit = crate::legacy_core::config::edit::syntax_theme_edit(&name); + let apply_result = ConfigEditsBuilder::new(&self.config.codex_home) + .with_edits([edit]) + .apply() + .await; + match apply_result { + Ok(()) => { + // Ensure the selected theme is active in the current + // session. The preview callback covers arrow-key + // navigation, but if the user presses Enter without + // navigating, the runtime theme must still be applied. + if let Some(theme) = crate::render::highlight::resolve_theme_by_name( + &name, + Some(&self.config.codex_home), + ) { + crate::render::highlight::set_syntax_theme(theme); + } + self.sync_tui_theme_selection(name); + } + Err(err) => { + self.restore_runtime_theme_from_config(); + tracing::error!(error = %err, "failed to persist theme selection"); + self.chat_widget + .add_error_message(format!("Failed to save theme: {err}")); + } + } + } + } + Ok(AppRunControl::Continue) + } + + pub(super) async fn handle_exit_mode( + &mut self, + app_server: &mut AppServerSession, + mode: ExitMode, + ) -> AppRunControl { + match mode { + ExitMode::ShutdownFirst => { + // Mark the thread we are explicitly shutting down for exit so + // its shutdown completion does not trigger agent failover. + self.pending_shutdown_exit_thread_id = + self.active_thread_id.or(self.chat_widget.thread_id()); + if self.pending_shutdown_exit_thread_id.is_some() { + self.shutdown_current_thread(app_server).await; + } + self.pending_shutdown_exit_thread_id = None; + AppRunControl::Exit(ExitReason::UserRequested) + } + ExitMode::Immediate => { + self.pending_shutdown_exit_thread_id = None; + AppRunControl::Exit(ExitReason::UserRequested) + } + } + } +} diff --git a/codex-rs/tui/src/app/history_ui.rs b/codex-rs/tui/src/app/history_ui.rs new file mode 100644 index 0000000000..703cc38c3d --- /dev/null +++ b/codex-rs/tui/src/app/history_ui.rs @@ -0,0 +1,93 @@ +//! Terminal history and clear-screen UI helpers for the TUI app. +//! +//! This module owns rendering the fresh session header, clearing inline or alternate-screen UI +//! state, and resetting transcript-related app state after `/clear` or Ctrl-L. + +use super::*; + +impl App { + pub(super) fn open_url_in_browser(&mut self, url: String) { + if let Err(err) = webbrowser::open(&url) { + self.chat_widget + .add_error_message(format!("Failed to open browser for {url}: {err}")); + return; + } + + self.chat_widget + .add_info_message(format!("Opened {url} in your browser."), /*hint*/ None); + } + + pub(super) fn clear_ui_header_lines_with_version( + &self, + width: u16, + version: &'static str, + ) -> Vec> { + history_cell::SessionHeaderHistoryCell::new( + self.chat_widget.current_model().to_string(), + self.chat_widget.current_reasoning_effort(), + self.chat_widget.should_show_fast_status( + self.chat_widget.current_model(), + self.chat_widget.current_service_tier(), + ), + self.config.cwd.to_path_buf(), + version, + ) + .with_yolo_mode(history_cell::is_yolo_mode(&self.config)) + .display_lines(width) + } + + pub(super) fn clear_ui_header_lines(&self, width: u16) -> Vec> { + self.clear_ui_header_lines_with_version(width, CODEX_CLI_VERSION) + } + + pub(super) fn queue_clear_ui_header(&mut self, tui: &mut tui::Tui) { + let width = tui.terminal.last_known_screen_size.width; + let header_lines = self.clear_ui_header_lines(width); + if !header_lines.is_empty() { + tui.insert_history_lines(header_lines); + self.has_emitted_history_lines = true; + } + } + + pub(super) fn clear_terminal_ui( + &mut self, + tui: &mut tui::Tui, + redraw_header: bool, + ) -> Result<()> { + let is_alt_screen_active = tui.is_alt_screen_active(); + + // Drop queued history insertions so stale transcript lines cannot be flushed after /clear. + tui.clear_pending_history_lines(); + + if is_alt_screen_active { + tui.terminal.clear_visible_screen()?; + } else { + // Some terminals (Terminal.app, Warp) do not reliably drop scrollback when purge and + // clear are emitted as separate backend commands. Prefer a single ANSI sequence. + tui.terminal.clear_scrollback_and_visible_screen_ansi()?; + } + + let mut area = tui.terminal.viewport_area; + if area.y > 0 { + // After a full clear, anchor the inline viewport at the top and redraw a fresh header + // box. `insert_history_lines()` will shift the viewport down by the rendered height. + area.y = 0; + tui.terminal.set_viewport_area(area); + } + self.has_emitted_history_lines = false; + + if redraw_header { + self.queue_clear_ui_header(tui); + } + Ok(()) + } + + pub(super) fn reset_app_ui_state_after_clear(&mut self) { + self.overlay = None; + self.transcript_cells.clear(); + self.deferred_history_lines.clear(); + self.has_emitted_history_lines = false; + self.backtrack = BacktrackState::default(); + self.backtrack_render_pending = false; + } +} diff --git a/codex-rs/tui/src/app/input.rs b/codex-rs/tui/src/app/input.rs new file mode 100644 index 0000000000..36d4c5611b --- /dev/null +++ b/codex-rs/tui/src/app/input.rs @@ -0,0 +1,222 @@ +//! Keyboard input, external editor, and status-line dispatch for the TUI app. +//! +//! This module owns global key bindings that sit above ChatWidget, including transcript overlay +//! entry, Ctrl-L clear, external editor launch, and agent navigation shortcuts. + +use super::*; + +impl App { + pub(super) async fn launch_external_editor(&mut self, tui: &mut tui::Tui) { + let editor_cmd = match external_editor::resolve_editor_command() { + Ok(cmd) => cmd, + Err(external_editor::EditorError::MissingEditor) => { + self.chat_widget + .add_to_history(history_cell::new_error_event( + "Cannot open external editor: set $VISUAL or $EDITOR before starting Codex." + .to_string(), + )); + self.reset_external_editor_state(tui); + return; + } + Err(err) => { + self.chat_widget + .add_to_history(history_cell::new_error_event(format!( + "Failed to open editor: {err}", + ))); + self.reset_external_editor_state(tui); + return; + } + }; + + let seed = self.chat_widget.composer_text_with_pending(); + let editor_result = tui + .with_restored(tui::RestoreMode::KeepRaw, || async { + external_editor::run_editor(&seed, &editor_cmd).await + }) + .await; + self.reset_external_editor_state(tui); + + match editor_result { + Ok(new_text) => { + // Trim trailing whitespace + let cleaned = new_text.trim_end().to_string(); + self.chat_widget.apply_external_edit(cleaned); + } + Err(err) => { + self.chat_widget + .add_to_history(history_cell::new_error_event(format!( + "Failed to open editor: {err}", + ))); + } + } + tui.frame_requester().schedule_frame(); + } + + pub(super) fn request_external_editor_launch(&mut self, tui: &mut tui::Tui) { + self.chat_widget + .set_external_editor_state(ExternalEditorState::Requested); + self.chat_widget.set_footer_hint_override(Some(vec![( + EXTERNAL_EDITOR_HINT.to_string(), + String::new(), + )])); + tui.frame_requester().schedule_frame(); + } + + pub(super) fn reset_external_editor_state(&mut self, tui: &mut tui::Tui) { + self.chat_widget + .set_external_editor_state(ExternalEditorState::Closed); + self.chat_widget.set_footer_hint_override(/*items*/ None); + tui.frame_requester().schedule_frame(); + } + + pub(super) async fn handle_key_event( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + key_event: KeyEvent, + ) { + // Some terminals, especially on macOS, encode Option+Left/Right as Option+b/f unless + // enhanced keyboard reporting is available. We only treat those word-motion fallbacks as + // agent-switch shortcuts when the composer is empty so we never steal the expected + // editing behavior for moving across words inside a draft. + let allow_agent_word_motion_fallback = !self.enhanced_keys_supported + && self.chat_widget.composer_text_with_pending().is_empty(); + if self.overlay.is_none() + && self.chat_widget.no_modal_or_popup_active() + // Alt+Left/Right are also natural word-motion keys in the composer. Keep agent + // fast-switch available only once the draft is empty so editing behavior wins whenever + // there is text on screen. + && self.chat_widget.composer_text_with_pending().is_empty() + && previous_agent_shortcut_matches(key_event, allow_agent_word_motion_fallback) + { + if let Some(thread_id) = self + .adjacent_thread_id_with_backfill(app_server, AgentNavigationDirection::Previous) + .await + { + let _ = self + .select_agent_thread_and_discard_side(tui, app_server, thread_id) + .await; + } + return; + } + if self.overlay.is_none() + && self.chat_widget.no_modal_or_popup_active() + // Mirror the previous-agent rule above: empty drafts may use these keys for thread + // switching, but non-empty drafts keep them for expected word-wise cursor motion. + && self.chat_widget.composer_text_with_pending().is_empty() + && next_agent_shortcut_matches(key_event, allow_agent_word_motion_fallback) + { + if let Some(thread_id) = self + .adjacent_thread_id_with_backfill(app_server, AgentNavigationDirection::Next) + .await + { + let _ = self + .select_agent_thread_and_discard_side(tui, app_server, thread_id) + .await; + } + return; + } + if side_return_shortcut_matches(key_event) + && self.maybe_return_from_side(tui, app_server).await + { + return; + } + + match key_event { + KeyEvent { + code: KeyCode::Char('t'), + modifiers: KeyModifiers::CONTROL, + kind: KeyEventKind::Press, + .. + } => { + // Enter alternate screen and set viewport to full size. + let _ = tui.enter_alt_screen(); + self.overlay = Some(Overlay::new_transcript(self.transcript_cells.clone())); + tui.frame_requester().schedule_frame(); + } + KeyEvent { + code: KeyCode::Char('l'), + modifiers: KeyModifiers::CONTROL, + kind: KeyEventKind::Press, + .. + } => { + if !self.chat_widget.can_run_ctrl_l_clear_now() { + return; + } + if let Err(err) = self.clear_terminal_ui(tui, /*redraw_header*/ false) { + tracing::warn!(error = %err, "failed to clear terminal UI"); + self.chat_widget + .add_error_message(format!("Failed to clear terminal UI: {err}")); + } else { + self.reset_app_ui_state_after_clear(); + self.queue_clear_ui_header(tui); + tui.frame_requester().schedule_frame(); + } + } + KeyEvent { + code: KeyCode::Char('g'), + modifiers: KeyModifiers::CONTROL, + kind: KeyEventKind::Press, + .. + } => { + // Only launch the external editor if there is no overlay and the bottom pane is not in use. + // Note that it can be launched while a task is running to enable editing while the previous turn is ongoing. + if self.overlay.is_none() + && self.chat_widget.can_launch_external_editor() + && self.chat_widget.external_editor_state() == ExternalEditorState::Closed + { + self.request_external_editor_launch(tui); + } + } + // Esc primes/advances backtracking only in normal (not working) mode + // with the composer focused and empty. In any other state, forward + // Esc so the active UI (e.g. status indicator, modals, popups) + // handles it. + KeyEvent { + code: KeyCode::Esc, + kind: KeyEventKind::Press | KeyEventKind::Repeat, + .. + } => { + if self.chat_widget.is_normal_backtrack_mode() + && self.chat_widget.composer_is_empty() + { + self.handle_backtrack_esc_key(tui); + } else { + self.chat_widget.handle_key_event(key_event); + } + } + // Enter confirms backtrack when primed + count > 0. Otherwise pass to widget. + KeyEvent { + code: KeyCode::Enter, + kind: KeyEventKind::Press, + .. + } if self.backtrack.primed + && self.backtrack.nth_user_message != usize::MAX + && self.chat_widget.composer_is_empty() => + { + if let Some(selection) = self.confirm_backtrack_from_main() { + self.apply_backtrack_selection(tui, selection); + } + } + KeyEvent { + kind: KeyEventKind::Press | KeyEventKind::Repeat, + .. + } => { + // Any non-Esc key press should cancel a primed backtrack. + // This avoids stale "Esc-primed" state after the user starts typing + // (even if they later backspace to empty). + if key_event.code != KeyCode::Esc && self.backtrack.primed { + self.reset_backtrack_state(); + } + self.chat_widget.handle_key_event(key_event); + } + _ => { + self.chat_widget.handle_key_event(key_event); + } + }; + } + + pub(super) fn refresh_status_line(&mut self) { + self.chat_widget.refresh_status_line(); + } +} diff --git a/codex-rs/tui/src/app/platform_actions.rs b/codex-rs/tui/src/app/platform_actions.rs new file mode 100644 index 0000000000..36559feb94 --- /dev/null +++ b/codex-rs/tui/src/app/platform_actions.rs @@ -0,0 +1,61 @@ +//! Platform-specific app actions and small global shortcuts. +//! +//! This module owns platform state used by `App`, the side-conversation return shortcut predicate, +//! and Windows sandbox helper actions that are compiled only on Windows. + +use super::*; + +#[derive(Default)] +pub(super) struct WindowsSandboxState { + pub(super) setup_started_at: Option, + // One-shot suppression of the next world-writable scan after user confirmation. + pub(super) skip_world_writable_scan_once: bool, +} + +impl App { + #[cfg(target_os = "windows")] + pub(super) fn spawn_world_writable_scan( + cwd: AbsolutePathBuf, + env_map: std::collections::HashMap, + logs_base_dir: AbsolutePathBuf, + sandbox_policy: codex_protocol::protocol::SandboxPolicy, + tx: AppEventSender, + ) { + tokio::task::spawn_blocking(move || { + let logs_base_dir_path = logs_base_dir.as_path(); + let result = codex_windows_sandbox::apply_world_writable_scan_and_denies( + logs_base_dir_path, + cwd.as_path(), + &env_map, + &sandbox_policy, + Some(logs_base_dir_path), + ); + if result.is_err() { + // Scan failed: warn without examples. + tx.send(AppEvent::OpenWorldWritableWarningConfirmation { + preset: None, + sample_paths: Vec::new(), + extra_count: 0usize, + failed_scan: true, + }); + } + }); + } +} + +pub(super) fn side_return_shortcut_matches(key_event: KeyEvent) -> bool { + match key_event { + KeyEvent { + code: KeyCode::Esc, + kind: KeyEventKind::Press | KeyEventKind::Repeat, + .. + } => true, + KeyEvent { + code: KeyCode::Char(c), + modifiers, + kind: KeyEventKind::Press, + .. + } if modifiers.contains(KeyModifiers::CONTROL) && c.eq_ignore_ascii_case(&'c') => true, + _ => false, + } +} diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs new file mode 100644 index 0000000000..0551d32538 --- /dev/null +++ b/codex-rs/tui/src/app/session_lifecycle.rs @@ -0,0 +1,732 @@ +//! Session, resume, fork, and subagent selection lifecycle for the TUI app. +//! +//! This module owns the high-level transitions between app-server threads: starting fresh sessions, +//! resuming/forking saved sessions, replacing ChatWidget instances, and maintaining the agent picker +//! cache used for multi-agent navigation. + +use super::*; + +impl App { + pub(super) async fn open_agent_picker(&mut self, app_server: &mut AppServerSession) { + let mut thread_ids = self.agent_navigation.tracked_thread_ids(); + for thread_id in self.thread_event_channels.keys().copied() { + if !thread_ids.contains(&thread_id) { + thread_ids.push(thread_id); + } + } + for thread_id in thread_ids { + if self.side_threads.contains_key(&thread_id) { + continue; + } + if !self + .refresh_agent_picker_thread_liveness(app_server, thread_id) + .await + { + continue; + } + } + + let has_non_primary_agent_thread = self + .agent_navigation + .has_non_primary_thread(self.primary_thread_id); + if !self.config.features.enabled(Feature::Collab) && !has_non_primary_agent_thread { + self.chat_widget.open_multi_agent_enable_prompt(); + return; + } + + if self.agent_navigation.is_empty() { + self.chat_widget + .add_info_message("No agents available yet.".to_string(), /*hint*/ None); + return; + } + + let mut initial_selected_idx = None; + let items: Vec = self + .agent_navigation + .ordered_threads() + .iter() + .enumerate() + .map(|(idx, (thread_id, entry))| { + if self.active_thread_id == Some(*thread_id) { + initial_selected_idx = Some(idx); + } + let id = *thread_id; + let is_primary = self.primary_thread_id == Some(*thread_id); + let name = format_agent_picker_item_name( + entry.agent_nickname.as_deref(), + entry.agent_role.as_deref(), + is_primary, + ); + let uuid = thread_id.to_string(); + SelectionItem { + name: name.clone(), + name_prefix_spans: agent_picker_status_dot_spans(entry.is_closed), + description: Some(uuid.clone()), + is_current: self.active_thread_id == Some(*thread_id), + actions: vec![Box::new(move |tx| { + tx.send(AppEvent::SelectAgentThread(id)); + })], + dismiss_on_select: true, + search_value: Some(format!("{name} {uuid}")), + ..Default::default() + } + }) + .collect(); + + self.chat_widget.show_selection_view(SelectionViewParams { + title: Some("Subagents".to_string()), + subtitle: Some(AgentNavigationState::picker_subtitle()), + footer_hint: Some(standard_popup_hint_line()), + items, + initial_selected_idx, + ..Default::default() + }); + } + + pub(super) fn is_terminal_thread_read_error(err: &color_eyre::Report) -> bool { + err.chain() + .any(|cause| cause.to_string().contains("thread not loaded:")) + } + + pub(super) fn closed_state_for_thread_read_error( + err: &color_eyre::Report, + existing_is_closed: Option, + ) -> bool { + Self::is_terminal_thread_read_error(err) || existing_is_closed.unwrap_or(false) + } + + pub(super) fn can_fallback_from_include_turns_error(err: &color_eyre::Report) -> bool { + err.chain().any(|cause| { + let message = cause.to_string(); + message.contains("includeTurns is unavailable before first user message") + || message.contains("ephemeral threads do not support includeTurns") + }) + } + + /// Updates cached picker metadata and then mirrors any visible-label change into the footer. + /// + /// These two writes stay paired so the picker rows and contextual footer continue to describe + /// the same displayed thread after nickname or role updates. + pub(super) fn upsert_agent_picker_thread( + &mut self, + thread_id: ThreadId, + agent_nickname: Option, + agent_role: Option, + is_closed: bool, + ) { + self.chat_widget.set_collab_agent_metadata( + thread_id, + agent_nickname.clone(), + agent_role.clone(), + ); + self.agent_navigation + .upsert(thread_id, agent_nickname, agent_role, is_closed); + self.sync_active_agent_label(); + } + + /// Marks a cached picker thread closed and recomputes the contextual footer label. + /// + /// Closing a thread is not the same as removing it: users can still inspect finished agent + /// transcripts, and the stable next/previous traversal order should not collapse around them. + pub(super) fn mark_agent_picker_thread_closed(&mut self, thread_id: ThreadId) { + self.agent_navigation.mark_closed(thread_id); + self.sync_active_agent_label(); + } + + pub(super) async fn refresh_agent_picker_thread_liveness( + &mut self, + app_server: &mut AppServerSession, + thread_id: ThreadId, + ) -> bool { + let existing_entry = self.agent_navigation.get(&thread_id).cloned(); + let has_replay_channel = self.thread_event_channels.contains_key(&thread_id); + match app_server + .thread_read(thread_id, /*include_turns*/ false) + .await + { + Ok(thread) => { + self.upsert_agent_picker_thread( + thread_id, + thread.agent_nickname.or_else(|| { + existing_entry + .as_ref() + .and_then(|entry| entry.agent_nickname.clone()) + }), + thread.agent_role.or_else(|| { + existing_entry + .as_ref() + .and_then(|entry| entry.agent_role.clone()) + }), + matches!( + thread.status, + codex_app_server_protocol::ThreadStatus::NotLoaded + ), + ); + true + } + Err(err) => { + if Self::is_terminal_thread_read_error(&err) && !has_replay_channel { + self.agent_navigation.remove(thread_id); + return false; + } + let is_closed = Self::closed_state_for_thread_read_error( + &err, + existing_entry.as_ref().map(|entry| entry.is_closed), + ); + if let Some(entry) = existing_entry { + self.upsert_agent_picker_thread( + thread_id, + entry.agent_nickname, + entry.agent_role, + is_closed, + ); + } else { + self.upsert_agent_picker_thread( + thread_id, /*agent_nickname*/ None, /*agent_role*/ None, + is_closed, + ); + } + true + } + } + } + + /// Materializes a live thread into local replay state when the picker knows about it but the + /// TUI has not cached a local event channel yet. + /// + /// Resume-time backfill intentionally avoids creating empty placeholder channels, because those + /// placeholders make stale `/agent` entries open blank transcripts. When a user later selects a + /// still-live discovered thread, attach it on demand with a real resumed snapshot. + pub(super) async fn attach_live_thread_for_selection( + &mut self, + app_server: &mut AppServerSession, + thread_id: ThreadId, + ) -> Result { + if self.thread_event_channels.contains_key(&thread_id) { + return Ok(true); + } + + let (session, turns, live_attached) = match app_server + .resume_thread(self.config.clone(), thread_id) + .await + { + Ok(started) => (started.session, started.turns, true), + Err(resume_err) => { + tracing::warn!( + thread_id = %thread_id, + error = %resume_err, + "failed to resume live thread for selection; falling back to thread/read" + ); + let (thread, turns) = match app_server + .thread_read(thread_id, /*include_turns*/ true) + .await + { + Ok(thread) => { + let turns = thread.turns.clone(); + (thread, turns) + } + Err(err) if Self::can_fallback_from_include_turns_error(&err) => { + let thread = app_server + .thread_read(thread_id, /*include_turns*/ false) + .await?; + (thread, Vec::new()) + } + Err(err) => return Err(err), + }; + if turns.is_empty() { + // A `thread/read` fallback without turns would create a blank local replay + // channel with no live listener attached, which blocks later real re-attach. + return Err(color_eyre::eyre::eyre!( + "Agent thread {thread_id} is not yet available for replay or live attach." + )); + } + let mut session = self.session_state_for_thread_read(thread_id, &thread).await; + // `thread/read` can seed replay state, but it does not attach the app-server + // listener that `thread/resume` establishes, so treat this path as replay-only. + session.model.clear(); + (session, turns, false) + } + }; + let channel = self.ensure_thread_channel(thread_id); + let mut store = channel.store.lock().await; + store.set_session(session, turns); + Ok(live_attached) + } + + /// Replaces the chat widget and re-seeds the new widget's collab metadata from the navigation + /// cache. + /// + /// Thread switches reconstruct the `ChatWidget`, which loses the `collab_agent_metadata` map. + /// This helper copies every known nickname/role from `AgentNavigationState` into the + /// replacement widget so that replayed collab items render agent names immediately. + pub(super) fn replace_chat_widget(&mut self, mut chat_widget: ChatWidget) { + // Transfer the last-written terminal title to the replacement widget + // so it knows what OSC title is currently displayed. Without this, the + // new widget would redundantly clear and rewrite the same title, causing + // a visible flicker in some terminals. + let previous_terminal_title = self.chat_widget.last_terminal_title.take(); + if chat_widget.last_terminal_title.is_none() { + chat_widget.last_terminal_title = previous_terminal_title; + } + for (thread_id, entry) in self.agent_navigation.ordered_threads() { + chat_widget.set_collab_agent_metadata( + thread_id, + entry.agent_nickname.clone(), + entry.agent_role.clone(), + ); + } + self.chat_widget = chat_widget; + self.sync_active_agent_label(); + } + + pub(super) async fn select_agent_thread( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + thread_id: ThreadId, + ) -> Result<()> { + if self.active_thread_id == Some(thread_id) { + return Ok(()); + } + + if !self + .refresh_agent_picker_thread_liveness(app_server, thread_id) + .await + { + self.chat_widget + .add_error_message(format!("Agent thread {thread_id} is no longer available.")); + return Ok(()); + } + + let mut is_replay_only = self + .agent_navigation + .get(&thread_id) + .is_some_and(|entry| entry.is_closed); + let mut attached_replay_only = false; + if self.should_attach_live_thread_for_selection(thread_id) { + match self + .attach_live_thread_for_selection(app_server, thread_id) + .await + { + Ok(live_attached) => { + attached_replay_only = !live_attached; + if attached_replay_only { + is_replay_only = true; + } + } + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to attach to agent thread {thread_id}: {err}" + )); + return Ok(()); + } + } + } else if !self.thread_event_channels.contains_key(&thread_id) && is_replay_only { + self.chat_widget + .add_error_message(format!("Agent thread {thread_id} is no longer available.")); + return Ok(()); + } + + let previous_thread_id = self.active_thread_id; + self.store_active_thread_receiver().await; + self.active_thread_id = None; + let Some((receiver, mut snapshot)) = self.activate_thread_for_replay(thread_id).await + else { + self.chat_widget + .add_error_message(format!("Agent thread {thread_id} is already active.")); + if let Some(previous_thread_id) = previous_thread_id { + self.activate_thread_channel(previous_thread_id).await; + } + return Ok(()); + }; + + self.refresh_snapshot_session_if_needed( + app_server, + thread_id, + is_replay_only, + &mut snapshot, + ) + .await; + + self.active_thread_id = Some(thread_id); + self.active_thread_rx = Some(receiver); + + let init = self.chatwidget_init_for_forked_or_resumed_thread( + tui, + self.config.clone(), + /*initial_user_message*/ None, + ); + self.replace_chat_widget(ChatWidget::new_with_app_event(init)); + + self.reset_for_thread_switch(tui)?; + self.replay_thread_snapshot(snapshot, !is_replay_only); + if is_replay_only { + let message = if attached_replay_only { + format!( + "Agent thread {thread_id} could not be resumed live. Replaying saved transcript." + ) + } else { + format!("Agent thread {thread_id} is closed. Replaying saved transcript.") + }; + self.chat_widget.add_info_message(message, /*hint*/ None); + } + self.drain_active_thread_events(tui).await?; + self.refresh_pending_thread_approvals().await; + + Ok(()) + } + + pub(super) fn should_attach_live_thread_for_selection(&self, thread_id: ThreadId) -> bool { + !self.thread_event_channels.contains_key(&thread_id) + && self + .agent_navigation + .get(&thread_id) + .is_none_or(|entry| !entry.is_closed) + } + + pub(super) fn reset_for_thread_switch(&mut self, tui: &mut tui::Tui) -> Result<()> { + self.overlay = None; + self.transcript_cells.clear(); + self.deferred_history_lines.clear(); + tui.clear_pending_history_lines(); + self.has_emitted_history_lines = false; + self.backtrack = BacktrackState::default(); + self.backtrack_render_pending = false; + Self::clear_terminal_for_thread_switch(&mut tui.terminal)?; + Ok(()) + } + + pub(super) fn clear_terminal_for_thread_switch( + terminal: &mut crate::custom_terminal::Terminal, + ) -> Result<()> + where + B: Backend + Write, + { + terminal.clear_scrollback_and_visible_screen_ansi()?; + let mut area = terminal.viewport_area; + if area.y > 0 { + area.y = 0; + terminal.set_viewport_area(area); + } + Ok(()) + } + + pub(super) fn reset_thread_event_state(&mut self) { + self.abort_all_thread_event_listeners(); + self.thread_event_channels.clear(); + self.agent_navigation.clear(); + self.side_threads.clear(); + self.active_thread_id = None; + self.active_thread_rx = None; + self.primary_thread_id = None; + self.last_subagent_backfill_attempt = None; + self.primary_session_configured = None; + self.pending_primary_events.clear(); + self.pending_app_server_requests.clear(); + self.chat_widget.set_pending_thread_approvals(Vec::new()); + self.sync_active_agent_label(); + } + + pub(super) async fn start_fresh_session_with_summary_hint( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + session_start_source: Option, + initial_user_message: Option, + ) { + // Start a fresh in-memory session while preserving resumability via persisted rollout + // history. If an initial message is provided, `enqueue_primary_thread_session` suppresses it + // until the new session is configured and any replayed turns have been rendered. + self.refresh_in_memory_config_from_disk_best_effort("starting a new thread") + .await; + let model = self.chat_widget.current_model().to_string(); + let config = self.fresh_session_config(); + let summary = session_summary( + self.chat_widget.token_usage(), + self.chat_widget.thread_id(), + self.chat_widget.thread_name(), + self.chat_widget.rollout_path().as_deref(), + ); + self.shutdown_current_thread(app_server).await; + let tracked_thread_ids: Vec = + self.thread_event_channels.keys().copied().collect(); + for thread_id in tracked_thread_ids { + if let Err(err) = app_server.thread_unsubscribe(thread_id).await { + tracing::warn!("failed to unsubscribe tracked thread {thread_id}: {err}"); + } + } + self.config = config.clone(); + match app_server + .start_thread_with_session_start_source(&config, session_start_source) + .await + { + Ok(started) => { + if let Err(err) = self + .replace_chat_widget_with_app_server_thread( + tui, + app_server, + started, + initial_user_message, + ) + .await + { + self.chat_widget.add_error_message(format!( + "Failed to attach to fresh app-server thread: {err}" + )); + } else if let Some(summary) = summary { + let mut lines: Vec> = Vec::new(); + if let Some(usage_line) = summary.usage_line { + lines.push(usage_line.into()); + } + if let Some(command) = summary.resume_command { + let spans = vec!["To continue this session, run ".into(), command.cyan()]; + lines.push(spans.into()); + } + self.chat_widget.add_plain_history_lines(lines); + } + } + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to start a fresh session through the app server: {err}" + )); + self.config.model = Some(model); + } + } + tui.frame_requester().schedule_frame(); + } + + pub(super) async fn replace_chat_widget_with_app_server_thread( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + started: AppServerStartedThread, + initial_user_message: Option, + ) -> Result<()> { + // Initial messages are for freshly attached primary threads only. Thread switches and + // resume/fork flows pass `None` so they cannot replay old history and then auto-submit a new + // user turn by accident. + self.reset_thread_event_state(); + let init = self.chatwidget_init_for_forked_or_resumed_thread( + tui, + self.config.clone(), + initial_user_message, + ); + self.replace_chat_widget(ChatWidget::new_with_app_event(init)); + self.enqueue_primary_thread_session(started.session, started.turns) + .await?; + self.backfill_loaded_subagent_threads(app_server).await; + Ok(()) + } + + /// Fetches all loaded threads from the app server and registers descendants of the primary + /// thread in the navigation cache and chat widget metadata. + /// + /// Called after `replace_chat_widget_with_app_server_thread` during resume, fork, and new + /// thread creation so that the `/agent` picker and keyboard navigation are pre-populated even + /// if the TUI did not witness the original spawn events. + /// + /// The loaded-thread list is fetched in full (no pagination) and the spawn tree is walked + /// by `find_loaded_subagent_threads_for_primary`. Each discovered subagent is registered via + /// `upsert_agent_picker_thread`, which writes to both `AgentNavigationState` and the + /// `ChatWidget` metadata map. + pub(super) async fn backfill_loaded_subagent_threads( + &mut self, + app_server: &mut AppServerSession, + ) -> bool { + let Some(primary_thread_id) = self.primary_thread_id else { + return false; + }; + + let loaded_thread_ids = match app_server + .thread_loaded_list(ThreadLoadedListParams { + cursor: None, + limit: None, + }) + .await + { + Ok(response) => response.data, + Err(err) => { + tracing::warn!(%err, "failed to list loaded threads for subagent backfill"); + return false; + } + }; + + let mut threads = Vec::new(); + let mut had_read_error = false; + for thread_id in loaded_thread_ids { + let Ok(thread_id) = ThreadId::from_string(&thread_id) else { + tracing::warn!("ignoring loaded thread with invalid id during subagent backfill"); + continue; + }; + + if thread_id == primary_thread_id { + continue; + } + + match app_server + .thread_read(thread_id, /*include_turns*/ false) + .await + { + Ok(thread) => threads.push(thread), + Err(err) => { + had_read_error = true; + tracing::warn!(thread_id = %thread_id, %err, "failed to read loaded thread"); + } + } + } + + for thread in find_loaded_subagent_threads_for_primary(threads, primary_thread_id) { + self.upsert_agent_picker_thread( + thread.thread_id, + thread.agent_nickname, + thread.agent_role, + /*is_closed*/ false, + ); + } + + !had_read_error + } + + /// Returns the adjacent thread id for keyboard navigation, backfilling from the server if the + /// local cache has no neighbor. + /// + /// Tries the fast path first: ask `AgentNavigationState` directly. If it returns `None` (no + /// adjacent entry exists, typically because the cache was never populated with remote + /// subagents), performs a full `backfill_loaded_subagent_threads` and retries. This ensures the + /// first next/previous keypress in a resumed remote session discovers subagents on demand + /// without requiring the user to wait for a proactive fetch. + pub(super) async fn adjacent_thread_id_with_backfill( + &mut self, + app_server: &mut AppServerSession, + direction: AgentNavigationDirection, + ) -> Option { + let current_thread = self.current_displayed_thread_id(); + if let Some(thread_id) = self + .agent_navigation + .adjacent_thread_id(current_thread, direction) + { + return Some(thread_id); + } + + let primary_thread_id = self.primary_thread_id?; + if self.last_subagent_backfill_attempt == Some(primary_thread_id) { + return None; + } + + if self.backfill_loaded_subagent_threads(app_server).await { + self.last_subagent_backfill_attempt = Some(primary_thread_id); + } + self.agent_navigation + .adjacent_thread_id(self.current_displayed_thread_id(), direction) + } + + pub(super) fn fresh_session_config(&self) -> Config { + let mut config = self.config.clone(); + config.service_tier = self.chat_widget.current_service_tier(); + config + } + pub(super) async fn resume_target_session( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + target_session: SessionTarget, + ) -> Result { + if self.ignore_same_thread_resume(&target_session) { + tui.frame_requester().schedule_frame(); + return Ok(AppRunControl::Continue); + } + + let current_cwd = self.config.cwd.to_path_buf(); + let resume_cwd = if self.remote_app_server_url.is_some() { + current_cwd.clone() + } else { + match crate::resolve_cwd_for_resume_or_fork( + tui, + &self.config, + ¤t_cwd, + target_session.thread_id, + target_session.path.as_deref(), + CwdPromptAction::Resume, + /*allow_prompt*/ true, + ) + .await? + { + crate::ResolveCwdOutcome::Continue(Some(cwd)) => cwd, + crate::ResolveCwdOutcome::Continue(None) => current_cwd.clone(), + crate::ResolveCwdOutcome::Exit => { + return Ok(AppRunControl::Exit(ExitReason::UserRequested)); + } + } + }; + + let mut resume_config = match self + .rebuild_config_for_resume_or_fallback(¤t_cwd, resume_cwd) + .await + { + Ok(cfg) => cfg, + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to rebuild configuration for resume: {err}" + )); + return Ok(AppRunControl::Continue); + } + }; + self.apply_runtime_policy_overrides(&mut resume_config); + + let summary = session_summary( + self.chat_widget.token_usage(), + self.chat_widget.thread_id(), + self.chat_widget.thread_name(), + self.chat_widget.rollout_path().as_deref(), + ); + match app_server + .resume_thread(resume_config.clone(), target_session.thread_id) + .await + { + Ok(resumed) => { + self.shutdown_current_thread(app_server).await; + self.config = resume_config; + tui.set_notification_settings( + self.config.tui_notifications.method, + self.config.tui_notifications.condition, + ); + self.file_search + .update_search_dir(self.config.cwd.to_path_buf()); + match self + .replace_chat_widget_with_app_server_thread( + tui, app_server, resumed, /*initial_user_message*/ None, + ) + .await + { + Ok(()) => { + if let Some(summary) = summary { + let mut lines: Vec> = Vec::new(); + if let Some(usage_line) = summary.usage_line { + lines.push(usage_line.into()); + } + if let Some(command) = summary.resume_command { + let spans = + vec!["To continue this session, run ".into(), command.cyan()]; + lines.push(spans.into()); + } + self.chat_widget.add_plain_history_lines(lines); + } + } + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to attach to resumed app-server thread: {err}" + )); + } + } + } + Err(err) => { + let path_display = target_session.display_label(); + self.chat_widget.add_error_message(format!( + "Failed to resume session from {path_display}: {err}" + )); + } + } + + Ok(AppRunControl::Continue) + } +} diff --git a/codex-rs/tui/src/app/startup_prompts.rs b/codex-rs/tui/src/app/startup_prompts.rs new file mode 100644 index 0000000000..23c116ee5f --- /dev/null +++ b/codex-rs/tui/src/app/startup_prompts.rs @@ -0,0 +1,326 @@ +//! Startup warnings, model migration prompts, and bootstrap prompt helpers. +//! +//! These helpers run before or during `App::run` bootstrap. They translate configuration and model +//! catalog state into one-time TUI prompts or warning cells without owning the main event loop. + +use super::*; + +pub(super) fn emit_skill_load_warnings(app_event_tx: &AppEventSender, errors: &[SkillErrorInfo]) { + if errors.is_empty() { + return; + } + + let error_count = errors.len(); + app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( + crate::history_cell::new_warning_event(format!( + "Skipped loading {error_count} skill(s) due to invalid SKILL.md files." + )), + ))); + + for error in errors { + let path = error.path.display(); + let message = error.message.as_str(); + app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( + crate::history_cell::new_warning_event(format!("{path}: {message}")), + ))); + } +} + +pub(super) fn emit_project_config_warnings(app_event_tx: &AppEventSender, config: &Config) { + let mut disabled_folders = Vec::new(); + + for layer in config.config_layer_stack.get_layers( + ConfigLayerStackOrdering::LowestPrecedenceFirst, + /*include_disabled*/ true, + ) { + let ConfigLayerSource::Project { dot_codex_folder } = &layer.name else { + continue; + }; + let Some(disabled_reason) = &layer.disabled_reason else { + continue; + }; + disabled_folders.push(( + dot_codex_folder.as_path().display().to_string(), + disabled_reason.clone(), + )); + } + + if disabled_folders.is_empty() { + return; + } + + let mut message = concat!( + "Project-local config, hooks, and exec policies are disabled in the following folders ", + "until the project is trusted, but skills still load.\n", + ) + .to_string(); + for (index, (folder, reason)) in disabled_folders.iter().enumerate() { + let display_index = index + 1; + message.push_str(&format!(" {display_index}. {folder}\n")); + message.push_str(&format!(" {reason}\n")); + } + + app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( + history_cell::new_warning_event(message), + ))); +} + +pub(super) fn emit_system_bwrap_warning(app_event_tx: &AppEventSender, config: &Config) { + let Some(message) = + crate::legacy_core::config::system_bwrap_warning(config.permissions.sandbox_policy.get()) + else { + return; + }; + + app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( + history_cell::new_warning_event(message), + ))); +} + +pub(super) fn should_show_model_migration_prompt( + current_model: &str, + target_model: &str, + seen_migrations: &BTreeMap, + available_models: &[ModelPreset], +) -> bool { + if target_model == current_model { + return false; + } + + if let Some(seen_target) = seen_migrations.get(current_model) + && seen_target == target_model + { + return false; + } + + if !available_models + .iter() + .any(|preset| preset.model == target_model && preset.show_in_picker) + { + return false; + } + + if available_models + .iter() + .any(|preset| preset.model == current_model && preset.upgrade.is_some()) + { + return true; + } + + if available_models + .iter() + .any(|preset| preset.upgrade.as_ref().map(|u| u.id.as_str()) == Some(target_model)) + { + return true; + } + + false +} + +pub(super) fn migration_prompt_hidden(config: &Config, migration_config_key: &str) -> bool { + match migration_config_key { + HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG => config + .notices + .hide_gpt_5_1_codex_max_migration_prompt + .unwrap_or(false), + HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG => { + config.notices.hide_gpt5_1_migration_prompt.unwrap_or(false) + } + _ => false, + } +} + +pub(super) fn target_preset_for_upgrade<'a>( + available_models: &'a [ModelPreset], + target_model: &str, +) -> Option<&'a ModelPreset> { + available_models + .iter() + .find(|preset| preset.model == target_model && preset.show_in_picker) +} + +pub(super) const MODEL_AVAILABILITY_NUX_MAX_SHOW_COUNT: u32 = 4; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub(super) struct StartupTooltipOverride { + pub(super) model_slug: String, + pub(super) message: String, +} + +pub(super) fn select_model_availability_nux( + available_models: &[ModelPreset], + nux_config: &ModelAvailabilityNuxConfig, +) -> Option { + available_models.iter().find_map(|preset| { + let ModelAvailabilityNux { message } = preset.availability_nux.as_ref()?; + let shown_count = nux_config + .shown_count + .get(&preset.model) + .copied() + .unwrap_or_default(); + (shown_count < MODEL_AVAILABILITY_NUX_MAX_SHOW_COUNT).then(|| StartupTooltipOverride { + model_slug: preset.model.clone(), + message: message.clone(), + }) + }) +} + +pub(super) async fn prepare_startup_tooltip_override( + config: &mut Config, + available_models: &[ModelPreset], + is_first_run: bool, +) -> Option { + if is_first_run || !config.show_tooltips { + return None; + } + + let tooltip_override = + select_model_availability_nux(available_models, &config.model_availability_nux)?; + + let shown_count = config + .model_availability_nux + .shown_count + .get(&tooltip_override.model_slug) + .copied() + .unwrap_or_default(); + let next_count = shown_count.saturating_add(1); + let mut updated_shown_count = config.model_availability_nux.shown_count.clone(); + updated_shown_count.insert(tooltip_override.model_slug.clone(), next_count); + + if let Err(err) = ConfigEditsBuilder::new(&config.codex_home) + .set_model_availability_nux_count(&updated_shown_count) + .apply() + .await + { + tracing::error!( + error = %err, + model = %tooltip_override.model_slug, + "failed to persist model availability nux count" + ); + return Some(tooltip_override.message); + } + + config.model_availability_nux.shown_count = updated_shown_count; + Some(tooltip_override.message) +} + +pub(super) async fn handle_model_migration_prompt_if_needed( + tui: &mut tui::Tui, + config: &mut Config, + model: &str, + app_event_tx: &AppEventSender, + available_models: &[ModelPreset], +) -> Option { + let upgrade = available_models + .iter() + .find(|preset| preset.model == model) + .and_then(|preset| preset.upgrade.as_ref()); + + if let Some(ModelUpgrade { + id: target_model, + reasoning_effort_mapping, + migration_config_key, + model_link, + upgrade_copy, + migration_markdown, + }) = upgrade + { + if migration_prompt_hidden(config, migration_config_key.as_str()) { + return None; + } + + let target_model = target_model.to_string(); + if !should_show_model_migration_prompt( + model, + &target_model, + &config.notices.model_migrations, + available_models, + ) { + return None; + } + + let current_preset = available_models.iter().find(|preset| preset.model == model); + let target_preset = target_preset_for_upgrade(available_models, &target_model); + let target_preset = target_preset?; + let target_display_name = target_preset.display_name.clone(); + let heading_label = if target_display_name == model { + target_model.clone() + } else { + target_display_name.clone() + }; + let target_description = + (!target_preset.description.is_empty()).then(|| target_preset.description.clone()); + let can_opt_out = current_preset.is_some(); + let prompt_copy = migration_copy_for_models( + model, + &target_model, + model_link.clone(), + upgrade_copy.clone(), + migration_markdown.clone(), + heading_label, + target_description, + can_opt_out, + ); + match run_model_migration_prompt(tui, prompt_copy).await { + ModelMigrationOutcome::Accepted => { + app_event_tx.send(AppEvent::PersistModelMigrationPromptAcknowledged { + from_model: model.to_string(), + to_model: target_model.clone(), + }); + + let mapped_effort = if let Some(reasoning_effort_mapping) = reasoning_effort_mapping + && let Some(reasoning_effort) = config.model_reasoning_effort + { + reasoning_effort_mapping + .get(&reasoning_effort) + .cloned() + .or(config.model_reasoning_effort) + } else { + config.model_reasoning_effort + }; + + config.model = Some(target_model.clone()); + config.model_reasoning_effort = mapped_effort; + app_event_tx.send(AppEvent::UpdateModel(target_model.clone())); + app_event_tx.send(AppEvent::UpdateReasoningEffort(mapped_effort)); + app_event_tx.send(AppEvent::PersistModelSelection { + model: target_model.clone(), + effort: mapped_effort, + }); + } + ModelMigrationOutcome::Rejected => { + app_event_tx.send(AppEvent::PersistModelMigrationPromptAcknowledged { + from_model: model.to_string(), + to_model: target_model.clone(), + }); + } + ModelMigrationOutcome::Exit => { + return Some(AppExitInfo { + token_usage: TokenUsage::default(), + thread_id: None, + thread_name: None, + update_action: None, + exit_reason: ExitReason::UserRequested, + }); + } + } + } + + None +} +pub(super) fn normalize_harness_overrides_for_cwd( + mut overrides: ConfigOverrides, + base_cwd: &AbsolutePathBuf, +) -> Result { + if overrides.additional_writable_roots.is_empty() { + return Ok(overrides); + } + + let mut normalized = Vec::with_capacity(overrides.additional_writable_roots.len()); + for root in overrides.additional_writable_roots.drain(..) { + let absolute = base_cwd.join(root); + normalized.push(absolute.into_path_buf()); + } + overrides.additional_writable_roots = normalized; + Ok(overrides) +} diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs new file mode 100644 index 0000000000..5ed786ef05 --- /dev/null +++ b/codex-rs/tui/src/app/tests.rs @@ -0,0 +1,5443 @@ +//! App-level orchestration tests for the TUI. + +mod model_catalog; + +use super::*; +use crate::app_backtrack::BacktrackSelection; +use crate::app_backtrack::BacktrackState; +use crate::app_backtrack::user_count; + +use crate::chatwidget::ChatWidgetInit; +use crate::chatwidget::create_initial_user_message; +use crate::chatwidget::tests::make_chatwidget_manual_with_sender; +use crate::chatwidget::tests::set_chatgpt_auth; +use crate::chatwidget::tests::set_fast_mode_test_catalog; +use crate::file_search::FileSearchManager; +use crate::history_cell::AgentMessageCell; +use crate::history_cell::HistoryCell; +use crate::history_cell::UserHistoryCell; +use crate::history_cell::new_session_info; +use crate::multi_agents::AgentPickerThreadEntry; +use assert_matches::assert_matches; + +use crate::legacy_core::config::ConfigBuilder; +use crate::legacy_core::config::ConfigOverrides; +use codex_app_server_protocol::AdditionalFileSystemPermissions; +use codex_app_server_protocol::AdditionalNetworkPermissions; +use codex_app_server_protocol::AdditionalPermissionProfile; +use codex_app_server_protocol::AgentMessageDeltaNotification; +use codex_app_server_protocol::CommandExecutionRequestApprovalParams; +use codex_app_server_protocol::ConfigWarningNotification; +use codex_app_server_protocol::HookCompletedNotification; +use codex_app_server_protocol::HookEventName as AppServerHookEventName; +use codex_app_server_protocol::HookExecutionMode as AppServerHookExecutionMode; +use codex_app_server_protocol::HookHandlerType as AppServerHookHandlerType; +use codex_app_server_protocol::HookOutputEntry as AppServerHookOutputEntry; +use codex_app_server_protocol::HookOutputEntryKind as AppServerHookOutputEntryKind; +use codex_app_server_protocol::HookRunStatus as AppServerHookRunStatus; +use codex_app_server_protocol::HookRunSummary as AppServerHookRunSummary; +use codex_app_server_protocol::HookScope as AppServerHookScope; +use codex_app_server_protocol::HookStartedNotification; +use codex_app_server_protocol::JSONRPCErrorError; +use codex_app_server_protocol::McpServerStartupState; +use codex_app_server_protocol::McpServerStatusUpdatedNotification; +use codex_app_server_protocol::NetworkApprovalContext as AppServerNetworkApprovalContext; +use codex_app_server_protocol::NetworkApprovalProtocol as AppServerNetworkApprovalProtocol; +use codex_app_server_protocol::NetworkPolicyAmendment as AppServerNetworkPolicyAmendment; +use codex_app_server_protocol::NetworkPolicyRuleAction as AppServerNetworkPolicyRuleAction; +use codex_app_server_protocol::NonSteerableTurnKind as AppServerNonSteerableTurnKind; +use codex_app_server_protocol::PermissionsRequestApprovalParams; +use codex_app_server_protocol::PluginMarketplaceEntry; +use codex_app_server_protocol::RequestId as AppServerRequestId; +use codex_app_server_protocol::ServerNotification; +use codex_app_server_protocol::ServerRequest; +use codex_app_server_protocol::Thread; +use codex_app_server_protocol::ThreadClosedNotification; +use codex_app_server_protocol::ThreadItem; +use codex_app_server_protocol::ThreadStartedNotification; +use codex_app_server_protocol::ThreadTokenUsage; +use codex_app_server_protocol::ThreadTokenUsageUpdatedNotification; +use codex_app_server_protocol::TokenUsageBreakdown; +use codex_app_server_protocol::ToolRequestUserInputParams; +use codex_app_server_protocol::Turn; +use codex_app_server_protocol::TurnCompletedNotification; +use codex_app_server_protocol::TurnError as AppServerTurnError; +use codex_app_server_protocol::TurnStartedNotification; +use codex_app_server_protocol::TurnStatus; +use codex_app_server_protocol::UserInput as AppServerUserInput; +use codex_app_server_protocol::WarningNotification; +use codex_otel::SessionTelemetry; +use codex_protocol::ThreadId; +use codex_protocol::config_types::CollaborationMode; +use codex_protocol::config_types::CollaborationModeMask; +use codex_protocol::config_types::ModeKind; +use codex_protocol::config_types::Settings; +use codex_protocol::mcp::Tool; +use codex_protocol::models::FileSystemPermissions; +use codex_protocol::models::NetworkPermissions; +use codex_protocol::models::PermissionProfile; +use codex_protocol::protocol::AskForApproval; +use codex_protocol::protocol::Event; +use codex_protocol::protocol::EventMsg; +use codex_protocol::protocol::McpAuthStatus; +use codex_protocol::protocol::NetworkApprovalContext; +use codex_protocol::protocol::NetworkApprovalProtocol; +use codex_protocol::protocol::RolloutItem; +use codex_protocol::protocol::RolloutLine; +use codex_protocol::protocol::SandboxPolicy; +use codex_protocol::protocol::SessionConfiguredEvent; +use codex_protocol::protocol::SessionSource; +use codex_protocol::protocol::TurnContextItem; +use codex_protocol::request_permissions::RequestPermissionProfile; +use codex_protocol::user_input::TextElement; +use codex_protocol::user_input::UserInput; +use codex_utils_absolute_path::AbsolutePathBuf; +use crossterm::event::KeyModifiers; +use insta::assert_snapshot; +use pretty_assertions::assert_eq; +use ratatui::prelude::Line; +use std::path::PathBuf; +use std::sync::Arc; +use std::sync::atomic::AtomicBool; +use tempfile::tempdir; +use tokio::time; + +macro_rules! assert_app_snapshot { + ($name:expr, $value:expr $(,)?) => { + insta::with_settings!({snapshot_path => "../snapshots"}, { + assert_snapshot!($name, $value); + }); + }; +} + +fn test_absolute_path(path: &str) -> AbsolutePathBuf { + AbsolutePathBuf::try_from(PathBuf::from(path)).expect("absolute test path") +} + +#[test] +fn hide_cli_only_plugin_marketplaces_removes_openai_bundled() { + let mut response = PluginListResponse { + marketplaces: vec![ + PluginMarketplaceEntry { + name: "openai-bundled".to_string(), + path: Some(test_absolute_path("/marketplaces/openai-bundled")), + interface: None, + plugins: Vec::new(), + }, + PluginMarketplaceEntry { + name: "openai-curated".to_string(), + path: Some(test_absolute_path("/marketplaces/openai-curated")), + interface: None, + plugins: Vec::new(), + }, + ], + marketplace_load_errors: Vec::new(), + featured_plugin_ids: Vec::new(), + }; + + hide_cli_only_plugin_marketplaces(&mut response); + + assert_eq!( + response.marketplaces, + vec![PluginMarketplaceEntry { + name: "openai-curated".to_string(), + path: Some(test_absolute_path("/marketplaces/openai-curated")), + interface: None, + plugins: Vec::new(), + }] + ); +} + +#[test] +fn normalize_harness_overrides_resolves_relative_add_dirs() -> Result<()> { + let temp_dir = tempdir()?; + let base_cwd = temp_dir.path().join("base").abs(); + std::fs::create_dir_all(base_cwd.as_path())?; + + let overrides = ConfigOverrides { + additional_writable_roots: vec![PathBuf::from("rel")], + ..Default::default() + }; + let normalized = normalize_harness_overrides_for_cwd(overrides, &base_cwd)?; + + assert_eq!( + normalized.additional_writable_roots, + vec![base_cwd.join("rel").into_path_buf()] + ); + Ok(()) +} + +#[test] +fn mcp_inventory_maps_prefix_tool_names_by_server() { + let statuses = vec![ + McpServerStatus { + name: "docs".to_string(), + tools: HashMap::from([( + "list".to_string(), + Tool { + description: None, + name: "list".to_string(), + title: None, + input_schema: serde_json::json!({"type": "object"}), + output_schema: None, + annotations: None, + icons: None, + meta: None, + }, + )]), + resources: Vec::new(), + resource_templates: Vec::new(), + auth_status: codex_app_server_protocol::McpAuthStatus::Unsupported, + }, + McpServerStatus { + name: "disabled".to_string(), + tools: HashMap::new(), + resources: Vec::new(), + resource_templates: Vec::new(), + auth_status: codex_app_server_protocol::McpAuthStatus::Unsupported, + }, + ]; + + let (tools, resources, resource_templates, auth_statuses) = + mcp_inventory_maps_from_statuses(statuses); + let mut resource_names = resources.keys().cloned().collect::>(); + resource_names.sort(); + let mut template_names = resource_templates.keys().cloned().collect::>(); + template_names.sort(); + + assert_eq!( + tools.keys().cloned().collect::>(), + vec!["mcp__docs__list".to_string()] + ); + assert_eq!(resource_names, vec!["disabled", "docs"]); + assert_eq!(template_names, vec!["disabled", "docs"]); + assert_eq!( + auth_statuses.get("disabled"), + Some(&McpAuthStatus::Unsupported) + ); +} + +#[tokio::test] +async fn handle_mcp_inventory_result_clears_committed_loading_cell() { + let mut app = make_test_app().await; + app.transcript_cells + .push(Arc::new(history_cell::new_mcp_inventory_loading( + /*animations_enabled*/ false, + ))); + + app.handle_mcp_inventory_result( + Ok(vec![McpServerStatus { + name: "docs".to_string(), + tools: HashMap::new(), + resources: Vec::new(), + resource_templates: Vec::new(), + auth_status: codex_app_server_protocol::McpAuthStatus::Unsupported, + }]), + McpServerStatusDetail::ToolsAndAuthOnly, + ); + + assert_eq!(app.transcript_cells.len(), 0); +} + +#[test] +fn startup_waiting_gate_is_only_for_fresh_or_exit_session_selection() { + assert_eq!( + App::should_wait_for_initial_session(&SessionSelection::StartFresh), + true + ); + assert_eq!( + App::should_wait_for_initial_session(&SessionSelection::Exit), + true + ); + assert_eq!( + App::should_wait_for_initial_session(&SessionSelection::Resume( + crate::resume_picker::SessionTarget { + path: Some(PathBuf::from("/tmp/restore")), + thread_id: ThreadId::new(), + } + )), + false + ); + assert_eq!( + App::should_wait_for_initial_session(&SessionSelection::Fork( + crate::resume_picker::SessionTarget { + path: Some(PathBuf::from("/tmp/fork")), + thread_id: ThreadId::new(), + } + )), + false + ); +} + +#[test] +fn startup_waiting_gate_holds_active_thread_events_until_primary_thread_configured() { + let mut wait_for_initial_session = + App::should_wait_for_initial_session(&SessionSelection::StartFresh); + assert_eq!(wait_for_initial_session, true); + assert_eq!( + App::should_handle_active_thread_events( + wait_for_initial_session, + /*has_active_thread_receiver*/ true + ), + false + ); + + assert_eq!( + App::should_stop_waiting_for_initial_session( + wait_for_initial_session, + /*primary_thread_id*/ None + ), + false + ); + if App::should_stop_waiting_for_initial_session(wait_for_initial_session, Some(ThreadId::new())) + { + wait_for_initial_session = false; + } + assert_eq!(wait_for_initial_session, false); + + assert_eq!( + App::should_handle_active_thread_events( + wait_for_initial_session, + /*has_active_thread_receiver*/ true + ), + true + ); +} + +#[test] +fn startup_waiting_gate_not_applied_for_resume_or_fork_session_selection() { + let wait_for_resume = App::should_wait_for_initial_session(&SessionSelection::Resume( + crate::resume_picker::SessionTarget { + path: Some(PathBuf::from("/tmp/restore")), + thread_id: ThreadId::new(), + }, + )); + assert_eq!( + App::should_handle_active_thread_events( + wait_for_resume, + /*has_active_thread_receiver*/ true + ), + true + ); + let wait_for_fork = App::should_wait_for_initial_session(&SessionSelection::Fork( + crate::resume_picker::SessionTarget { + path: Some(PathBuf::from("/tmp/fork")), + thread_id: ThreadId::new(), + }, + )); + assert_eq!( + App::should_handle_active_thread_events( + wait_for_fork, + /*has_active_thread_receiver*/ true + ), + true + ); +} + +#[tokio::test] +async fn ignore_same_thread_resume_reports_noop_for_current_thread() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.thread_event_channels.insert( + thread_id, + ThreadEventChannel::new_with_session(THREAD_EVENT_CHANNEL_CAPACITY, session, Vec::new()), + ); + app.activate_thread_channel(thread_id).await; + while app_event_rx.try_recv().is_ok() {} + + let ignored = app.ignore_same_thread_resume(&crate::resume_picker::SessionTarget { + path: Some(test_path_buf("/tmp/project")), + thread_id, + }); + + assert!(ignored); + let cell = match app_event_rx.try_recv() { + Ok(AppEvent::InsertHistoryCell(cell)) => cell, + other => panic!("expected info message after same-thread resume, saw {other:?}"), + }; + let rendered = lines_to_single_string(&cell.display_lines(/*width*/ 80)); + assert!(rendered.contains(&format!( + "Already viewing {}.", + test_path_display("/tmp/project") + ))); +} + +#[tokio::test] +async fn ignore_same_thread_resume_allows_reattaching_displayed_inactive_thread() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session); + + let ignored = app.ignore_same_thread_resume(&crate::resume_picker::SessionTarget { + path: Some(test_path_buf("/tmp/project")), + thread_id, + }); + + assert!(!ignored); + assert!(app.transcript_cells.is_empty()); +} + +#[tokio::test] +async fn enqueue_primary_thread_session_replays_buffered_approval_after_attach() -> Result<()> { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let approval_request = + exec_approval_request(thread_id, "turn-1", "call-1", /*approval_id*/ None); + + assert_eq!( + app.pending_app_server_requests + .note_server_request(&approval_request), + None + ); + app.enqueue_primary_thread_request(approval_request).await?; + app.enqueue_primary_thread_session( + test_thread_session(thread_id, test_path_buf("/tmp/project")), + Vec::new(), + ) + .await?; + + let rx = app + .active_thread_rx + .as_mut() + .expect("primary thread receiver should be active"); + let event = time::timeout(Duration::from_millis(50), rx.recv()) + .await + .expect("timed out waiting for buffered approval event") + .expect("channel closed unexpectedly"); + + assert!(matches!( + &event, + ThreadBufferedEvent::Request(ServerRequest::CommandExecutionRequestApproval { + params, + .. + }) if params.turn_id == "turn-1" + )); + + app.handle_thread_event_now(event); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE)); + + while let Ok(app_event) = app_event_rx.try_recv() { + if let AppEvent::SubmitThreadOp { + thread_id: op_thread_id, + .. + } = app_event + { + assert_eq!(op_thread_id, thread_id); + return Ok(()); + } + } + + panic!("expected approval action to submit a thread-scoped op"); +} + +#[tokio::test] +async fn resolved_buffered_approval_does_not_become_actionable_after_drain() -> Result<()> { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let approval_request = + exec_approval_request(thread_id, "turn-1", "call-1", /*approval_id*/ None); + + app.enqueue_primary_thread_session( + test_thread_session(thread_id, test_path_buf("/tmp/project")), + Vec::new(), + ) + .await?; + while app_event_rx.try_recv().is_ok() {} + + assert_eq!( + app.pending_app_server_requests + .note_server_request(&approval_request), + None + ); + app.enqueue_thread_request(thread_id, approval_request) + .await?; + + let resolved = app + .pending_app_server_requests + .resolve_notification(&AppServerRequestId::Integer(1)) + .expect("matching app-server request should resolve"); + app.chat_widget.dismiss_app_server_request(&resolved); + while app_event_rx.try_recv().is_ok() {} + + let rx = app + .active_thread_rx + .as_mut() + .expect("primary thread receiver should be active"); + let event = time::timeout(Duration::from_millis(50), rx.recv()) + .await + .expect("timed out waiting for buffered approval event") + .expect("channel closed unexpectedly"); + + assert!(matches!( + &event, + ThreadBufferedEvent::Request(ServerRequest::CommandExecutionRequestApproval { + params, + .. + }) if params.turn_id == "turn-1" + )); + + app.handle_thread_event_now(event); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE)); + + while let Ok(app_event) = app_event_rx.try_recv() { + assert!( + !matches!(app_event, AppEvent::SubmitThreadOp { .. }), + "resolved buffered approval should not become actionable" + ); + } + + Ok(()) +} + +#[tokio::test] +async fn enqueue_primary_thread_session_replays_turns_before_initial_prompt_submit() -> Result<()> { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let initial_prompt = "follow-up after replay".to_string(); + let config = app.config.clone(); + let model = crate::legacy_core::test_support::get_model_offline(config.model.as_deref()); + app.chat_widget = ChatWidget::new_with_app_event(ChatWidgetInit { + config, + frame_requester: crate::tui::FrameRequester::test_dummy(), + app_event_tx: app.app_event_tx.clone(), + initial_user_message: create_initial_user_message( + Some(initial_prompt.clone()), + Vec::new(), + Vec::new(), + ), + enhanced_keys_supported: false, + has_chatgpt_account: false, + model_catalog: app.model_catalog.clone(), + feedback: codex_feedback::CodexFeedback::new(), + is_first_run: false, + status_account_display: None, + initial_plan_type: None, + model: Some(model), + startup_tooltip_override: None, + status_line_invalid_items_warned: app.status_line_invalid_items_warned.clone(), + terminal_title_invalid_items_warned: app.terminal_title_invalid_items_warned.clone(), + session_telemetry: app.session_telemetry.clone(), + }); + + app.enqueue_primary_thread_session( + test_thread_session(thread_id, test_path_buf("/tmp/project")), + vec![test_turn( + "turn-1", + TurnStatus::Completed, + vec![ThreadItem::UserMessage { + id: "user-1".to_string(), + content: vec![AppServerUserInput::Text { + text: "earlier prompt".to_string(), + text_elements: Vec::new(), + }], + }], + )], + ) + .await?; + + let mut saw_replayed_answer = false; + let mut submitted_items = None; + while let Ok(event) = app_event_rx.try_recv() { + match event { + AppEvent::InsertHistoryCell(cell) => { + let transcript = lines_to_single_string(&cell.transcript_lines(/*width*/ 80)); + saw_replayed_answer |= transcript.contains("earlier prompt"); + } + AppEvent::SubmitThreadOp { + thread_id: op_thread_id, + op: Op::UserTurn { items, .. }, + } => { + assert_eq!(op_thread_id, thread_id); + submitted_items = Some(items); + } + AppEvent::CodexOp(Op::UserTurn { items, .. }) => { + submitted_items = Some(items); + } + _ => {} + } + } + assert!( + saw_replayed_answer, + "expected replayed history before initial prompt submit" + ); + assert_eq!( + submitted_items, + Some(vec![UserInput::Text { + text: initial_prompt, + text_elements: Vec::new(), + }]) + ); + + Ok(()) +} + +#[tokio::test] +async fn reset_thread_event_state_aborts_listener_tasks() { + struct NotifyOnDrop(Option>); + + impl Drop for NotifyOnDrop { + fn drop(&mut self) { + if let Some(tx) = self.0.take() { + let _ = tx.send(()); + } + } + } + + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + let (started_tx, started_rx) = tokio::sync::oneshot::channel(); + let (dropped_tx, dropped_rx) = tokio::sync::oneshot::channel(); + let handle = tokio::spawn(async move { + let _notify_on_drop = NotifyOnDrop(Some(dropped_tx)); + let _ = started_tx.send(()); + std::future::pending::<()>().await; + }); + app.thread_event_listener_tasks.insert(thread_id, handle); + started_rx + .await + .expect("listener task should report it started"); + + app.reset_thread_event_state(); + + assert_eq!(app.thread_event_listener_tasks.is_empty(), true); + time::timeout(Duration::from_millis(50), dropped_rx) + .await + .expect("timed out waiting for listener task abort") + .expect("listener task drop notification should succeed"); +} + +#[tokio::test] +async fn history_lookup_response_is_routed_to_requesting_thread() -> Result<()> { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + + let handled = app + .try_handle_local_history_op( + thread_id, + &Op::GetHistoryEntryRequest { + offset: 0, + log_id: 1, + } + .into(), + ) + .await?; + + assert!(handled); + + let app_event = tokio::time::timeout(Duration::from_secs(1), app_event_rx.recv()) + .await + .expect("history lookup should emit an app event") + .expect("app event channel should stay open"); + + let AppEvent::ThreadHistoryEntryResponse { + thread_id: routed_thread_id, + event, + } = app_event + else { + panic!("expected thread-routed history response"); + }; + assert_eq!(routed_thread_id, thread_id); + assert_eq!(event.offset, 0); + assert_eq!(event.log_id, 1); + assert!(event.entry.is_none()); + + Ok(()) +} + +#[tokio::test] +async fn enqueue_thread_event_does_not_block_when_channel_full() -> Result<()> { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + app.thread_event_channels + .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + app.set_thread_active(thread_id, /*active*/ true).await; + + let event = thread_closed_notification(thread_id); + + app.enqueue_thread_notification(thread_id, event.clone()) + .await?; + time::timeout( + Duration::from_millis(50), + app.enqueue_thread_notification(thread_id, event), + ) + .await + .expect("enqueue_thread_notification blocked on a full channel")?; + + let mut rx = app + .thread_event_channels + .get_mut(&thread_id) + .expect("missing thread channel") + .receiver + .take() + .expect("missing receiver"); + + time::timeout(Duration::from_millis(50), rx.recv()) + .await + .expect("timed out waiting for first event") + .expect("channel closed unexpectedly"); + time::timeout(Duration::from_millis(50), rx.recv()) + .await + .expect("timed out waiting for second event") + .expect("channel closed unexpectedly"); + + Ok(()) +} + +#[tokio::test] +async fn replay_thread_snapshot_restores_draft_and_queued_input() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.thread_event_channels.insert( + thread_id, + ThreadEventChannel::new_with_session( + THREAD_EVENT_CHANNEL_CAPACITY, + session.clone(), + Vec::new(), + ), + ); + app.activate_thread_channel(thread_id).await; + app.chat_widget.handle_thread_session(session.clone()); + + app.chat_widget + .apply_external_edit("draft prompt".to_string()); + app.chat_widget.submit_user_message_with_mode( + "queued follow-up".to_string(), + CollaborationModeMask { + name: "Default".to_string(), + mode: None, + model: None, + reasoning_effort: None, + developer_instructions: None, + }, + ); + let expected_input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected thread input state"); + + app.store_active_thread_receiver().await; + + let snapshot = { + let channel = app + .thread_event_channels + .get(&thread_id) + .expect("thread channel should exist"); + let store = channel.store.lock().await; + assert_eq!(store.input_state, Some(expected_input_state)); + store.snapshot() + }; + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + + app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ true); + + assert_eq!(app.chat_widget.composer_text_with_pending(), "draft prompt"); + assert!(app.chat_widget.queued_user_message_texts().is_empty()); + while let Ok(op) = new_op_rx.try_recv() { + assert!( + !matches!(op, Op::UserTurn { .. }), + "draft-only replay should not auto-submit queued input" + ); + } +} + +#[tokio::test] +async fn active_turn_id_for_thread_uses_snapshot_turns() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.thread_event_channels.insert( + thread_id, + ThreadEventChannel::new_with_session( + THREAD_EVENT_CHANNEL_CAPACITY, + session, + vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())], + ), + ); + + assert_eq!( + app.active_turn_id_for_thread(thread_id).await, + Some("turn-1".to_string()) + ); +} + +#[tokio::test] +async fn replayed_turn_complete_submits_restored_queued_follow_up() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget.handle_server_notification( + turn_started_notification(thread_id, "turn-1"), + /*replay_kind*/ None, + ); + app.chat_widget.handle_server_notification( + agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), + /*replay_kind*/ None, + ); + app.chat_widget + .apply_external_edit("queued follow-up".to_string()); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected queued follow-up state"); + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + while new_op_rx.try_recv().is_ok() {} + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![ThreadBufferedEvent::Notification( + turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed), + )], + input_state: Some(input_state), + }, + /*resume_restored_queue*/ true, + ); + + match next_user_turn_op(&mut new_op_rx) { + Op::UserTurn { items, .. } => assert_eq!( + items, + vec![UserInput::Text { + text: "queued follow-up".to_string(), + text_elements: Vec::new(), + }] + ), + other => panic!("expected queued follow-up submission, got {other:?}"), + } +} + +#[tokio::test] +async fn replay_only_thread_keeps_restored_queue_visible() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget.handle_server_notification( + turn_started_notification(thread_id, "turn-1"), + /*replay_kind*/ None, + ); + app.chat_widget.handle_server_notification( + agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), + /*replay_kind*/ None, + ); + app.chat_widget + .apply_external_edit("queued follow-up".to_string()); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected queued follow-up state"); + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + while new_op_rx.try_recv().is_ok() {} + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![ThreadBufferedEvent::Notification( + turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed), + )], + input_state: Some(input_state), + }, + /*resume_restored_queue*/ false, + ); + + assert_eq!( + app.chat_widget.queued_user_message_texts(), + vec!["queued follow-up".to_string()] + ); + assert!( + new_op_rx.try_recv().is_err(), + "replay-only threads should not auto-submit restored queue" + ); +} + +#[tokio::test] +async fn replay_thread_snapshot_keeps_queue_when_running_state_only_comes_from_snapshot() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget.handle_server_notification( + turn_started_notification(thread_id, "turn-1"), + /*replay_kind*/ None, + ); + app.chat_widget.handle_server_notification( + agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), + /*replay_kind*/ None, + ); + app.chat_widget + .apply_external_edit("queued follow-up".to_string()); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected queued follow-up state"); + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + while new_op_rx.try_recv().is_ok() {} + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![], + input_state: Some(input_state), + }, + /*resume_restored_queue*/ true, + ); + + assert_eq!( + app.chat_widget.queued_user_message_texts(), + vec!["queued follow-up".to_string()] + ); + assert!( + new_op_rx.try_recv().is_err(), + "restored queue should stay queued when replay did not prove the turn finished" + ); +} + +#[tokio::test] +async fn replay_thread_snapshot_in_progress_turn_restores_running_queue_state() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget.handle_server_notification( + turn_started_notification(thread_id, "turn-1"), + /*replay_kind*/ None, + ); + app.chat_widget.handle_server_notification( + agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), + /*replay_kind*/ None, + ); + app.chat_widget + .apply_external_edit("queued follow-up".to_string()); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected queued follow-up state"); + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + while new_op_rx.try_recv().is_ok() {} + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())], + events: Vec::new(), + input_state: Some(input_state), + }, + /*resume_restored_queue*/ true, + ); + + assert_eq!( + app.chat_widget.queued_user_message_texts(), + vec!["queued follow-up".to_string()] + ); + assert!( + new_op_rx.try_recv().is_err(), + "restored queue should stay queued while replayed turn is still running" + ); +} + +#[tokio::test] +async fn replay_thread_snapshot_in_progress_turn_restores_running_state_without_input_state() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + let (chat_widget, _app_event_tx, _rx, _new_op_rx) = make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session); + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: vec![test_turn("turn-1", TurnStatus::InProgress, Vec::new())], + events: Vec::new(), + input_state: None, + }, + /*resume_restored_queue*/ false, + ); + + assert!(app.chat_widget.is_task_running_for_test()); +} + +#[tokio::test] +async fn replay_thread_snapshot_does_not_submit_queue_before_replay_catches_up() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget.handle_server_notification( + turn_started_notification(thread_id, "turn-1"), + /*replay_kind*/ None, + ); + app.chat_widget.handle_server_notification( + agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), + /*replay_kind*/ None, + ); + app.chat_widget + .apply_external_edit("queued follow-up".to_string()); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected queued follow-up state"); + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + while new_op_rx.try_recv().is_ok() {} + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![ + ThreadBufferedEvent::Notification(turn_completed_notification( + thread_id, + "turn-0", + TurnStatus::Completed, + )), + ThreadBufferedEvent::Notification(turn_started_notification(thread_id, "turn-1")), + ], + input_state: Some(input_state), + }, + /*resume_restored_queue*/ true, + ); + + assert!( + new_op_rx.try_recv().is_err(), + "queued follow-up should stay queued until the latest turn completes" + ); + assert_eq!( + app.chat_widget.queued_user_message_texts(), + vec!["queued follow-up".to_string()] + ); + + app.chat_widget.handle_server_notification( + turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed), + /*replay_kind*/ None, + ); + + match next_user_turn_op(&mut new_op_rx) { + Op::UserTurn { items, .. } => assert_eq!( + items, + vec![UserInput::Text { + text: "queued follow-up".to_string(), + text_elements: Vec::new(), + }] + ), + other => panic!("expected queued follow-up submission, got {other:?}"), + } +} + +#[tokio::test] +async fn replay_thread_snapshot_restores_pending_pastes_for_submit() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.thread_event_channels.insert( + thread_id, + ThreadEventChannel::new_with_session( + THREAD_EVENT_CHANNEL_CAPACITY, + session.clone(), + Vec::new(), + ), + ); + app.activate_thread_channel(thread_id).await; + app.chat_widget.handle_thread_session(session); + + let large = "x".repeat(1005); + app.chat_widget.handle_paste(large.clone()); + let expected_input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected thread input state"); + + app.store_active_thread_receiver().await; + + let snapshot = { + let channel = app + .thread_event_channels + .get(&thread_id) + .expect("thread channel should exist"); + let store = channel.store.lock().await; + assert_eq!(store.input_state, Some(expected_input_state)); + store.snapshot() + }; + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ true); + + assert_eq!(app.chat_widget.composer_text_with_pending(), large); + + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + + match next_user_turn_op(&mut new_op_rx) { + Op::UserTurn { items, .. } => assert_eq!( + items, + vec![UserInput::Text { + text: large, + text_elements: Vec::new(), + }] + ), + other => panic!("expected restored paste submission, got {other:?}"), + } +} + +#[tokio::test] +async fn replay_thread_snapshot_restores_collaboration_mode_for_draft_submit() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget + .set_reasoning_effort(Some(ReasoningEffortConfig::High)); + app.chat_widget + .set_collaboration_mask(CollaborationModeMask { + name: "Plan".to_string(), + mode: Some(ModeKind::Plan), + model: Some("gpt-restored".to_string()), + reasoning_effort: Some(Some(ReasoningEffortConfig::High)), + developer_instructions: None, + }); + app.chat_widget + .apply_external_edit("draft prompt".to_string()); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected draft input state"); + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget + .set_reasoning_effort(Some(ReasoningEffortConfig::Low)); + app.chat_widget + .set_collaboration_mask(CollaborationModeMask { + name: "Default".to_string(), + mode: Some(ModeKind::Default), + model: Some("gpt-replacement".to_string()), + reasoning_effort: Some(Some(ReasoningEffortConfig::Low)), + developer_instructions: None, + }); + while new_op_rx.try_recv().is_ok() {} + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![], + input_state: Some(input_state), + }, + /*resume_restored_queue*/ true, + ); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + + match next_user_turn_op(&mut new_op_rx) { + Op::UserTurn { + items, + model, + effort, + collaboration_mode, + .. + } => { + assert_eq!( + items, + vec![UserInput::Text { + text: "draft prompt".to_string(), + text_elements: Vec::new(), + }] + ); + assert_eq!(model, "gpt-restored".to_string()); + assert_eq!(effort, Some(ReasoningEffortConfig::High)); + assert_eq!( + collaboration_mode, + Some(CollaborationMode { + mode: ModeKind::Plan, + settings: Settings { + model: "gpt-restored".to_string(), + reasoning_effort: Some(ReasoningEffortConfig::High), + developer_instructions: None, + }, + }) + ); + } + other => panic!("expected restored draft submission, got {other:?}"), + } +} + +#[tokio::test] +async fn replay_thread_snapshot_restores_collaboration_mode_without_input() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget + .set_reasoning_effort(Some(ReasoningEffortConfig::High)); + app.chat_widget + .set_collaboration_mask(CollaborationModeMask { + name: "Plan".to_string(), + mode: Some(ModeKind::Plan), + model: Some("gpt-restored".to_string()), + reasoning_effort: Some(Some(ReasoningEffortConfig::High)), + developer_instructions: None, + }); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected collaboration-only input state"); + + let (chat_widget, _app_event_tx, _rx, _new_op_rx) = make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget + .set_reasoning_effort(Some(ReasoningEffortConfig::Low)); + app.chat_widget + .set_collaboration_mask(CollaborationModeMask { + name: "Default".to_string(), + mode: Some(ModeKind::Default), + model: Some("gpt-replacement".to_string()), + reasoning_effort: Some(Some(ReasoningEffortConfig::Low)), + developer_instructions: None, + }); + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![], + input_state: Some(input_state), + }, + /*resume_restored_queue*/ true, + ); + + assert_eq!( + app.chat_widget.active_collaboration_mode_kind(), + ModeKind::Plan + ); + assert_eq!(app.chat_widget.current_model(), "gpt-restored"); + assert_eq!( + app.chat_widget.current_reasoning_effort(), + Some(ReasoningEffortConfig::High) + ); +} + +#[tokio::test] +async fn replayed_interrupted_turn_restores_queued_input_to_composer() { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + app.chat_widget.handle_thread_session(session.clone()); + app.chat_widget.handle_server_notification( + turn_started_notification(thread_id, "turn-1"), + /*replay_kind*/ None, + ); + app.chat_widget.handle_server_notification( + agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"), + /*replay_kind*/ None, + ); + app.chat_widget + .apply_external_edit("queued follow-up".to_string()); + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + let input_state = app + .chat_widget + .capture_thread_input_state() + .expect("expected queued follow-up state"); + + let (chat_widget, _app_event_tx, _rx, mut new_op_rx) = + make_chatwidget_manual_with_sender().await; + app.chat_widget = chat_widget; + app.chat_widget.handle_thread_session(session.clone()); + while new_op_rx.try_recv().is_ok() {} + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![ThreadBufferedEvent::Notification( + turn_completed_notification(thread_id, "turn-1", TurnStatus::Interrupted), + )], + input_state: Some(input_state), + }, + /*resume_restored_queue*/ true, + ); + + assert_eq!( + app.chat_widget.composer_text_with_pending(), + "queued follow-up" + ); + assert!(app.chat_widget.queued_user_message_texts().is_empty()); + assert!( + new_op_rx.try_recv().is_err(), + "replayed interrupted turns should restore queued input for editing, not submit it" + ); +} + +#[tokio::test] +async fn token_usage_update_refreshes_status_line_with_runtime_context_window() { + let mut app = make_test_app().await; + app.chat_widget + .setup_status_line(vec![crate::bottom_pane::StatusLineItem::ContextWindowSize]); + + assert_eq!(app.chat_widget.status_line_text(), None); + + app.handle_thread_event_now(ThreadBufferedEvent::Notification(token_usage_notification( + ThreadId::new(), + "turn-1", + Some(950_000), + ))); + + assert_eq!( + app.chat_widget.status_line_text(), + Some("950K window".into()) + ); +} + +#[tokio::test] +async fn open_agent_picker_keeps_missing_threads_for_replay() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let thread_id = ThreadId::new(); + app.thread_event_channels + .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + + app.open_agent_picker(&mut app_server).await; + + assert_eq!(app.thread_event_channels.contains_key(&thread_id), true); + assert_eq!( + app.agent_navigation.get(&thread_id), + Some(&AgentPickerThreadEntry { + agent_nickname: None, + agent_role: None, + is_closed: true, + }) + ); + assert_eq!(app.agent_navigation.ordered_thread_ids(), vec![thread_id]); + Ok(()) +} + +#[tokio::test] +async fn open_agent_picker_preserves_cached_metadata_for_replay_threads() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let thread_id = ThreadId::new(); + app.thread_event_channels + .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + app.agent_navigation.upsert( + thread_id, + Some("Robie".to_string()), + Some("explorer".to_string()), + /*is_closed*/ true, + ); + + app.open_agent_picker(&mut app_server).await; + + assert_eq!(app.thread_event_channels.contains_key(&thread_id), true); + assert_eq!( + app.agent_navigation.get(&thread_id), + Some(&AgentPickerThreadEntry { + agent_nickname: Some("Robie".to_string()), + agent_role: Some("explorer".to_string()), + is_closed: true, + }) + ); + Ok(()) +} + +#[tokio::test] +async fn open_agent_picker_prunes_terminal_metadata_only_threads() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let thread_id = ThreadId::new(); + app.agent_navigation.upsert( + thread_id, + Some("Ghost".to_string()), + Some("worker".to_string()), + /*is_closed*/ false, + ); + + app.open_agent_picker(&mut app_server).await; + + assert_eq!(app.agent_navigation.get(&thread_id), None); + assert!(app.agent_navigation.is_empty()); + Ok(()) +} + +#[tokio::test] +async fn open_agent_picker_marks_terminal_read_errors_closed() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let thread_id = ThreadId::new(); + app.thread_event_channels + .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + app.agent_navigation.upsert( + thread_id, + Some("Robie".to_string()), + Some("explorer".to_string()), + /*is_closed*/ false, + ); + + app.open_agent_picker(&mut app_server).await; + + assert_eq!( + app.agent_navigation.get(&thread_id), + Some(&AgentPickerThreadEntry { + agent_nickname: Some("Robie".to_string()), + agent_role: Some("explorer".to_string()), + is_closed: true, + }) + ); + Ok(()) +} + +#[test] +fn terminal_thread_read_error_detection_matches_not_loaded_errors() { + let err = color_eyre::eyre::eyre!( + "thread/read failed during TUI session lookup: thread/read failed: thread not loaded: thr_123" + ); + + assert!(App::is_terminal_thread_read_error(&err)); +} + +#[test] +fn terminal_thread_read_error_detection_ignores_transient_failures() { + let err = color_eyre::eyre::eyre!( + "thread/read failed during TUI session lookup: thread/read transport error: broken pipe" + ); + + assert!(!App::is_terminal_thread_read_error(&err)); +} + +#[test] +fn closed_state_for_thread_read_error_preserves_live_state_without_cache_on_transient_error() { + let err = color_eyre::eyre::eyre!( + "thread/read failed during TUI session lookup: thread/read transport error: broken pipe" + ); + + assert!(!App::closed_state_for_thread_read_error( + &err, /*existing_is_closed*/ None + )); +} + +#[test] +fn closed_state_for_thread_read_error_marks_terminal_uncached_threads_closed() { + let err = color_eyre::eyre::eyre!( + "thread/read failed during TUI session lookup: thread/read failed: thread not loaded: thr_123" + ); + + assert!(App::closed_state_for_thread_read_error( + &err, /*existing_is_closed*/ None + )); +} + +#[test] +fn include_turns_fallback_detection_handles_unmaterialized_and_ephemeral_threads() { + let unmaterialized = color_eyre::eyre::eyre!( + "thread/read failed during TUI session lookup: thread/read failed: thread thr_123 is not materialized yet; includeTurns is unavailable before first user message" + ); + let ephemeral = color_eyre::eyre::eyre!( + "thread/read failed during TUI session lookup: thread/read failed: ephemeral threads do not support includeTurns" + ); + + assert!(App::can_fallback_from_include_turns_error(&unmaterialized)); + assert!(App::can_fallback_from_include_turns_error(&ephemeral)); +} + +#[tokio::test] +async fn open_agent_picker_marks_loaded_threads_open() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let started = app_server + .start_thread(app.chat_widget.config_ref()) + .await?; + let thread_id = started.session.thread_id; + app.thread_event_channels + .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + + app.open_agent_picker(&mut app_server).await; + + assert_eq!( + app.agent_navigation.get(&thread_id), + Some(&AgentPickerThreadEntry { + agent_nickname: None, + agent_role: None, + is_closed: false, + }) + ); + Ok(()) +} + +#[tokio::test] +async fn attach_live_thread_for_selection_rejects_empty_non_ephemeral_fallback_threads() +-> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let started = app_server + .start_thread(app.chat_widget.config_ref()) + .await?; + let thread_id = started.session.thread_id; + app.agent_navigation.upsert( + thread_id, + Some("Scout".to_string()), + Some("worker".to_string()), + /*is_closed*/ false, + ); + + let err = app + .attach_live_thread_for_selection(&mut app_server, thread_id) + .await + .expect_err("empty fallback should not attach as a blank replay-only thread"); + + assert_eq!( + err.to_string(), + format!("Agent thread {thread_id} is not yet available for replay or live attach.") + ); + assert!(!app.thread_event_channels.contains_key(&thread_id)); + Ok(()) +} + +#[tokio::test] +async fn attach_live_thread_for_selection_rejects_unmaterialized_fallback_threads() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let mut ephemeral_config = app.chat_widget.config_ref().clone(); + ephemeral_config.ephemeral = true; + let started = app_server.start_thread(&ephemeral_config).await?; + let thread_id = started.session.thread_id; + app.agent_navigation.upsert( + thread_id, + Some("Scout".to_string()), + Some("worker".to_string()), + /*is_closed*/ false, + ); + + let err = app + .attach_live_thread_for_selection(&mut app_server, thread_id) + .await + .expect_err("ephemeral fallback should not attach as a blank live thread"); + + assert_eq!( + err.to_string(), + format!("Agent thread {thread_id} is not yet available for replay or live attach.") + ); + assert!(!app.thread_event_channels.contains_key(&thread_id)); + Ok(()) +} + +#[tokio::test] +async fn should_attach_live_thread_for_selection_skips_closed_metadata_only_threads() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + app.agent_navigation.upsert( + thread_id, + Some("Ghost".to_string()), + Some("worker".to_string()), + /*is_closed*/ true, + ); + + assert!(!app.should_attach_live_thread_for_selection(thread_id)); + + app.agent_navigation.upsert( + thread_id, + Some("Ghost".to_string()), + Some("worker".to_string()), + /*is_closed*/ false, + ); + assert!(app.should_attach_live_thread_for_selection(thread_id)); + + app.thread_event_channels + .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + assert!(!app.should_attach_live_thread_for_selection(thread_id)); +} + +#[tokio::test] +async fn refresh_agent_picker_thread_liveness_prunes_closed_metadata_only_threads() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let thread_id = ThreadId::new(); + app.agent_navigation.upsert( + thread_id, + Some("Ghost".to_string()), + Some("worker".to_string()), + /*is_closed*/ false, + ); + + let is_available = app + .refresh_agent_picker_thread_liveness(&mut app_server, thread_id) + .await; + + assert!(!is_available); + assert_eq!(app.agent_navigation.get(&thread_id), None); + assert!(!app.thread_event_channels.contains_key(&thread_id)); + Ok(()) +} + +#[tokio::test] +async fn open_agent_picker_prompts_to_enable_multi_agent_when_disabled() -> Result<()> { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let _ = app.config.features.disable(Feature::Collab); + + app.open_agent_picker(&mut app_server).await; + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + + assert_matches!( + app_event_rx.try_recv(), + Ok(AppEvent::UpdateFeatureFlags { updates }) if updates == vec![(Feature::Collab, true)] + ); + let cell = match app_event_rx.try_recv() { + Ok(AppEvent::InsertHistoryCell(cell)) => cell, + other => panic!("expected InsertHistoryCell event, got {other:?}"), + }; + let rendered = cell + .display_lines(/*width*/ 120) + .into_iter() + .map(|line| line.to_string()) + .collect::>() + .join("\n"); + assert!(rendered.contains("Subagents will be enabled in the next session.")); + Ok(()) +} + +#[tokio::test] +async fn update_memory_settings_persists_and_updates_widget_config() -> Result<()> { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; + + app.update_memory_settings_with_app_server( + &mut app_server, + /*use_memories*/ false, + /*generate_memories*/ false, + ) + .await; + + assert!(!app.config.memories.use_memories); + assert!(!app.config.memories.generate_memories); + assert!(!app.chat_widget.config_ref().memories.use_memories); + assert!(!app.chat_widget.config_ref().memories.generate_memories); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + let config_value = toml::from_str::(&config)?; + let memories = config_value + .as_table() + .and_then(|table| table.get("memories")) + .and_then(TomlValue::as_table) + .expect("memories table should exist"); + assert_eq!( + memories.get("use_memories"), + Some(&TomlValue::Boolean(false)) + ); + assert_eq!( + memories.get("generate_memories"), + Some(&TomlValue::Boolean(false)) + ); + assert!( + !memories.contains_key("disable_on_external_context") + && !memories.contains_key("no_memories_if_mcp_or_web_search"), + "the TUI menu should not write the external-context memory setting" + ); + app_server.shutdown().await?; + Ok(()) +} + +#[tokio::test] +async fn update_memory_settings_updates_current_thread_memory_mode() -> Result<()> { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + // Seed the previous setting so this test exercises the thread-mode update path. + app.config.memories.generate_memories = true; + + let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; + let started = app_server.start_thread(&app.config).await?; + let thread_id = started.session.thread_id; + app.active_thread_id = Some(thread_id); + + app.update_memory_settings_with_app_server( + &mut app_server, + /*use_memories*/ true, + /*generate_memories*/ false, + ) + .await; + + let state_db = codex_state::StateRuntime::init( + codex_home.path().to_path_buf(), + app.config.model_provider_id.clone(), + ) + .await + .expect("state db should initialize"); + let memory_mode = state_db + .get_thread_memory_mode(thread_id) + .await + .expect("thread memory mode should be readable"); + assert_eq!(memory_mode.as_deref(), Some("disabled")); + + app_server.shutdown().await?; + Ok(()) +} + +#[tokio::test] +async fn reset_memories_clears_local_memory_directories() -> Result<()> { + let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + app.config.sqlite_home = codex_home.path().to_path_buf(); + + let memory_root = codex_home.path().join("memories"); + let extensions_root = codex_home.path().join("memories_extensions"); + std::fs::create_dir_all(memory_root.join("rollout_summaries"))?; + std::fs::create_dir_all(&extensions_root)?; + std::fs::write(memory_root.join("MEMORY.md"), "stale memory\n")?; + std::fs::write( + memory_root.join("rollout_summaries").join("stale.md"), + "stale summary\n", + )?; + std::fs::write(extensions_root.join("stale.txt"), "stale extension\n")?; + + let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?; + + app.reset_memories_with_app_server(&mut app_server).await; + + assert_eq!(std::fs::read_dir(&memory_root)?.count(), 0); + assert_eq!(std::fs::read_dir(&extensions_root)?.count(), 0); + + app_server.shutdown().await?; + Ok(()) +} + +#[tokio::test] +async fn update_feature_flags_enabling_guardian_selects_guardian_approvals() -> Result<()> { + let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + let guardian_approvals = guardian_approvals_mode(); + + app.update_feature_flags(vec![(Feature::GuardianApproval, true)]) + .await; + + assert!(app.config.features.enabled(Feature::GuardianApproval)); + assert!( + app.chat_widget + .config_ref() + .features + .enabled(Feature::GuardianApproval) + ); + assert_eq!( + app.config.approvals_reviewer, + guardian_approvals.approvals_reviewer + ); + assert_eq!( + app.config.permissions.approval_policy.value(), + guardian_approvals.approval_policy + ); + assert_eq!( + app.chat_widget + .config_ref() + .permissions + .approval_policy + .value(), + guardian_approvals.approval_policy + ); + assert_eq!( + app.chat_widget + .config_ref() + .permissions + .sandbox_policy + .get(), + &guardian_approvals.sandbox_policy + ); + assert_eq!( + app.chat_widget.config_ref().approvals_reviewer, + guardian_approvals.approvals_reviewer + ); + assert_eq!(app.runtime_approval_policy_override, None); + assert_eq!(app.runtime_sandbox_policy_override, None); + assert_eq!( + op_rx.try_recv(), + Ok(Op::OverrideTurnContext { + cwd: None, + approval_policy: Some(guardian_approvals.approval_policy), + approvals_reviewer: Some(guardian_approvals.approvals_reviewer), + sandbox_policy: Some(guardian_approvals.sandbox_policy.clone()), + windows_sandbox_level: None, + model: None, + effort: None, + summary: None, + service_tier: None, + collaboration_mode: None, + personality: None, + }) + ); + let cell = match app_event_rx.try_recv() { + Ok(AppEvent::InsertHistoryCell(cell)) => cell, + other => panic!("expected InsertHistoryCell event, got {other:?}"), + }; + let rendered = cell + .display_lines(/*width*/ 120) + .into_iter() + .map(|line| line.to_string()) + .collect::>() + .join("\n"); + assert!(rendered.contains("Permissions updated to Auto-review")); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + assert!(config.contains("guardian_approval = true")); + assert!(config.contains("approvals_reviewer = \"guardian_subagent\"")); + assert!(config.contains("approval_policy = \"on-request\"")); + assert!(config.contains("sandbox_mode = \"workspace-write\"")); + Ok(()) +} + +#[tokio::test] +async fn update_feature_flags_disabling_guardian_clears_review_policy_and_restores_default() +-> Result<()> { + let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + let config_toml_path = codex_home.path().join("config.toml").abs(); + let config_toml = "approvals_reviewer = \"guardian_subagent\"\napproval_policy = \"on-request\"\nsandbox_mode = \"workspace-write\"\n\n[features]\nguardian_approval = true\n"; + std::fs::write(config_toml_path.as_path(), config_toml)?; + let user_config = toml::from_str::(config_toml)?; + app.config.config_layer_stack = app + .config + .config_layer_stack + .with_user_config(&config_toml_path, user_config); + app.config + .features + .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; + app.chat_widget + .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); + app.config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; + app.chat_widget + .set_approvals_reviewer(ApprovalsReviewer::GuardianSubagent); + app.config + .permissions + .approval_policy + .set(AskForApproval::OnRequest)?; + app.config + .permissions + .sandbox_policy + .set(SandboxPolicy::new_workspace_write_policy())?; + app.chat_widget + .set_approval_policy(AskForApproval::OnRequest); + app.chat_widget + .set_sandbox_policy(SandboxPolicy::new_workspace_write_policy())?; + + app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) + .await; + + assert!(!app.config.features.enabled(Feature::GuardianApproval)); + assert!( + !app.chat_widget + .config_ref() + .features + .enabled(Feature::GuardianApproval) + ); + assert_eq!(app.config.approvals_reviewer, ApprovalsReviewer::User); + assert_eq!( + app.config.permissions.approval_policy.value(), + AskForApproval::OnRequest + ); + assert_eq!( + app.chat_widget.config_ref().approvals_reviewer, + ApprovalsReviewer::User + ); + assert_eq!(app.runtime_approval_policy_override, None); + assert_eq!( + op_rx.try_recv(), + Ok(Op::OverrideTurnContext { + cwd: None, + approval_policy: None, + approvals_reviewer: Some(ApprovalsReviewer::User), + sandbox_policy: None, + windows_sandbox_level: None, + model: None, + effort: None, + summary: None, + service_tier: None, + collaboration_mode: None, + personality: None, + }) + ); + let cell = match app_event_rx.try_recv() { + Ok(AppEvent::InsertHistoryCell(cell)) => cell, + other => panic!("expected InsertHistoryCell event, got {other:?}"), + }; + let rendered = cell + .display_lines(/*width*/ 120) + .into_iter() + .map(|line| line.to_string()) + .collect::>() + .join("\n"); + assert!(rendered.contains("Permissions updated to Default")); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + assert!(!config.contains("guardian_approval = true")); + assert!(!config.contains("approvals_reviewer =")); + assert!(config.contains("approval_policy = \"on-request\"")); + assert!(config.contains("sandbox_mode = \"workspace-write\"")); + Ok(()) +} + +#[tokio::test] +async fn update_feature_flags_enabling_guardian_overrides_explicit_manual_review_policy() +-> Result<()> { + let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + let guardian_approvals = guardian_approvals_mode(); + let config_toml_path = codex_home.path().join("config.toml").abs(); + let config_toml = "approvals_reviewer = \"user\"\n"; + std::fs::write(config_toml_path.as_path(), config_toml)?; + let user_config = toml::from_str::(config_toml)?; + app.config.config_layer_stack = app + .config + .config_layer_stack + .with_user_config(&config_toml_path, user_config); + app.config.approvals_reviewer = ApprovalsReviewer::User; + app.chat_widget + .set_approvals_reviewer(ApprovalsReviewer::User); + + app.update_feature_flags(vec![(Feature::GuardianApproval, true)]) + .await; + + assert!(app.config.features.enabled(Feature::GuardianApproval)); + assert_eq!( + app.config.approvals_reviewer, + guardian_approvals.approvals_reviewer + ); + assert_eq!( + app.chat_widget.config_ref().approvals_reviewer, + guardian_approvals.approvals_reviewer + ); + assert_eq!( + app.config.permissions.approval_policy.value(), + guardian_approvals.approval_policy + ); + assert_eq!( + app.chat_widget + .config_ref() + .permissions + .sandbox_policy + .get(), + &guardian_approvals.sandbox_policy + ); + assert_eq!( + op_rx.try_recv(), + Ok(Op::OverrideTurnContext { + cwd: None, + approval_policy: Some(guardian_approvals.approval_policy), + approvals_reviewer: Some(guardian_approvals.approvals_reviewer), + sandbox_policy: Some(guardian_approvals.sandbox_policy.clone()), + windows_sandbox_level: None, + model: None, + effort: None, + summary: None, + service_tier: None, + collaboration_mode: None, + personality: None, + }) + ); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + assert!(config.contains("approvals_reviewer = \"guardian_subagent\"")); + assert!(config.contains("guardian_approval = true")); + assert!(config.contains("approval_policy = \"on-request\"")); + assert!(config.contains("sandbox_mode = \"workspace-write\"")); + Ok(()) +} + +#[tokio::test] +async fn update_feature_flags_disabling_guardian_clears_manual_review_policy_without_history() +-> Result<()> { + let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + let config_toml_path = codex_home.path().join("config.toml").abs(); + let config_toml = "approvals_reviewer = \"user\"\napproval_policy = \"on-request\"\nsandbox_mode = \"workspace-write\"\n\n[features]\nguardian_approval = true\n"; + std::fs::write(config_toml_path.as_path(), config_toml)?; + let user_config = toml::from_str::(config_toml)?; + app.config.config_layer_stack = app + .config + .config_layer_stack + .with_user_config(&config_toml_path, user_config); + app.config + .features + .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; + app.chat_widget + .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); + app.config.approvals_reviewer = ApprovalsReviewer::User; + app.chat_widget + .set_approvals_reviewer(ApprovalsReviewer::User); + + app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) + .await; + + assert!(!app.config.features.enabled(Feature::GuardianApproval)); + assert_eq!(app.config.approvals_reviewer, ApprovalsReviewer::User); + assert_eq!( + app.chat_widget.config_ref().approvals_reviewer, + ApprovalsReviewer::User + ); + assert_eq!( + op_rx.try_recv(), + Ok(Op::OverrideTurnContext { + cwd: None, + approval_policy: None, + approvals_reviewer: Some(ApprovalsReviewer::User), + sandbox_policy: None, + windows_sandbox_level: None, + model: None, + effort: None, + summary: None, + service_tier: None, + collaboration_mode: None, + personality: None, + }) + ); + assert!( + app_event_rx.try_recv().is_err(), + "manual review should not emit a permissions history update when the effective state stays default" + ); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + assert!(!config.contains("guardian_approval = true")); + assert!(!config.contains("approvals_reviewer =")); + Ok(()) +} + +#[tokio::test] +async fn update_feature_flags_enabling_guardian_in_profile_sets_profile_auto_review_policy() +-> Result<()> { + let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + let guardian_approvals = guardian_approvals_mode(); + app.active_profile = Some("guardian".to_string()); + let config_toml_path = codex_home.path().join("config.toml").abs(); + let config_toml = "profile = \"guardian\"\napprovals_reviewer = \"user\"\n"; + std::fs::write(config_toml_path.as_path(), config_toml)?; + let user_config = toml::from_str::(config_toml)?; + app.config.config_layer_stack = app + .config + .config_layer_stack + .with_user_config(&config_toml_path, user_config); + app.config.approvals_reviewer = ApprovalsReviewer::User; + app.chat_widget + .set_approvals_reviewer(ApprovalsReviewer::User); + + app.update_feature_flags(vec![(Feature::GuardianApproval, true)]) + .await; + + assert!(app.config.features.enabled(Feature::GuardianApproval)); + assert_eq!( + app.config.approvals_reviewer, + guardian_approvals.approvals_reviewer + ); + assert_eq!( + app.chat_widget.config_ref().approvals_reviewer, + guardian_approvals.approvals_reviewer + ); + assert_eq!( + op_rx.try_recv(), + Ok(Op::OverrideTurnContext { + cwd: None, + approval_policy: Some(guardian_approvals.approval_policy), + approvals_reviewer: Some(guardian_approvals.approvals_reviewer), + sandbox_policy: Some(guardian_approvals.sandbox_policy.clone()), + windows_sandbox_level: None, + model: None, + effort: None, + summary: None, + service_tier: None, + collaboration_mode: None, + personality: None, + }) + ); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + let config_value = toml::from_str::(&config)?; + let profile_config = config_value + .as_table() + .and_then(|table| table.get("profiles")) + .and_then(TomlValue::as_table) + .and_then(|profiles| profiles.get("guardian")) + .and_then(TomlValue::as_table) + .expect("guardian profile should exist"); + assert_eq!( + config_value + .as_table() + .and_then(|table| table.get("approvals_reviewer")), + Some(&TomlValue::String("user".to_string())) + ); + assert_eq!( + profile_config.get("approvals_reviewer"), + Some(&TomlValue::String("guardian_subagent".to_string())) + ); + Ok(()) +} + +#[tokio::test] +async fn update_feature_flags_disabling_guardian_in_profile_allows_inherited_user_reviewer() +-> Result<()> { + let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + app.active_profile = Some("guardian".to_string()); + let config_toml_path = codex_home.path().join("config.toml").abs(); + let config_toml = r#" +profile = "guardian" +approvals_reviewer = "user" + +[profiles.guardian] +approvals_reviewer = "guardian_subagent" + +[profiles.guardian.features] +guardian_approval = true +"#; + std::fs::write(config_toml_path.as_path(), config_toml)?; + let user_config = toml::from_str::(config_toml)?; + app.config.config_layer_stack = app + .config + .config_layer_stack + .with_user_config(&config_toml_path, user_config); + app.config + .features + .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; + app.chat_widget + .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); + app.config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; + app.chat_widget + .set_approvals_reviewer(ApprovalsReviewer::GuardianSubagent); + + app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) + .await; + + assert!(!app.config.features.enabled(Feature::GuardianApproval)); + assert!( + !app.chat_widget + .config_ref() + .features + .enabled(Feature::GuardianApproval) + ); + assert_eq!(app.config.approvals_reviewer, ApprovalsReviewer::User); + assert_eq!( + app.chat_widget.config_ref().approvals_reviewer, + ApprovalsReviewer::User + ); + assert_eq!( + op_rx.try_recv(), + Ok(Op::OverrideTurnContext { + cwd: None, + approval_policy: None, + approvals_reviewer: Some(ApprovalsReviewer::User), + sandbox_policy: None, + windows_sandbox_level: None, + model: None, + effort: None, + summary: None, + service_tier: None, + collaboration_mode: None, + personality: None, + }) + ); + let cell = match app_event_rx.try_recv() { + Ok(AppEvent::InsertHistoryCell(cell)) => cell, + other => panic!("expected InsertHistoryCell event, got {other:?}"), + }; + let rendered = cell + .display_lines(/*width*/ 120) + .into_iter() + .map(|line| line.to_string()) + .collect::>() + .join("\n"); + assert!(rendered.contains("Permissions updated to Default")); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + assert!(!config.contains("guardian_approval = true")); + assert!(!config.contains("guardian_subagent")); + assert_eq!( + toml::from_str::(&config)? + .as_table() + .and_then(|table| table.get("approvals_reviewer")), + Some(&TomlValue::String("user".to_string())) + ); + Ok(()) +} + +#[tokio::test] +async fn update_feature_flags_disabling_guardian_in_profile_keeps_inherited_non_user_reviewer_enabled() +-> Result<()> { + let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + app.active_profile = Some("guardian".to_string()); + let config_toml_path = codex_home.path().join("config.toml").abs(); + let config_toml = "profile = \"guardian\"\napprovals_reviewer = \"guardian_subagent\"\n\n[features]\nguardian_approval = true\n"; + std::fs::write(config_toml_path.as_path(), config_toml)?; + let user_config = toml::from_str::(config_toml)?; + app.config.config_layer_stack = app + .config + .config_layer_stack + .with_user_config(&config_toml_path, user_config); + app.config + .features + .set_enabled(Feature::GuardianApproval, /*enabled*/ true)?; + app.chat_widget + .set_feature_enabled(Feature::GuardianApproval, /*enabled*/ true); + app.config.approvals_reviewer = ApprovalsReviewer::GuardianSubagent; + app.chat_widget + .set_approvals_reviewer(ApprovalsReviewer::GuardianSubagent); + + app.update_feature_flags(vec![(Feature::GuardianApproval, false)]) + .await; + + assert!(app.config.features.enabled(Feature::GuardianApproval)); + assert!( + app.chat_widget + .config_ref() + .features + .enabled(Feature::GuardianApproval) + ); + assert_eq!( + app.config.approvals_reviewer, + ApprovalsReviewer::GuardianSubagent + ); + assert_eq!( + app.chat_widget.config_ref().approvals_reviewer, + ApprovalsReviewer::GuardianSubagent + ); + assert!( + op_rx.try_recv().is_err(), + "disabling an inherited non-user reviewer should not patch the active session" + ); + let app_events = std::iter::from_fn(|| app_event_rx.try_recv().ok()).collect::>(); + assert!( + !app_events.iter().any(|event| match event { + AppEvent::InsertHistoryCell(cell) => cell + .display_lines(/*width*/ 120) + .iter() + .any(|line| line.to_string().contains("Permissions updated to")), + _ => false, + }), + "blocking disable with inherited guardian review should not emit a permissions history update: {app_events:?}" + ); + + let config = std::fs::read_to_string(codex_home.path().join("config.toml"))?; + assert!(config.contains("guardian_approval = true")); + assert_eq!( + toml::from_str::(&config)? + .as_table() + .and_then(|table| table.get("approvals_reviewer")), + Some(&TomlValue::String("guardian_subagent".to_string())) + ); + Ok(()) +} + +#[tokio::test] +async fn open_agent_picker_allows_existing_agent_threads_when_feature_is_disabled() -> Result<()> { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let thread_id = ThreadId::new(); + app.thread_event_channels + .insert(thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + + app.open_agent_picker(&mut app_server).await; + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + + assert_matches!( + app_event_rx.try_recv(), + Ok(AppEvent::SelectAgentThread(selected_thread_id)) if selected_thread_id == thread_id + ); + Ok(()) +} + +#[tokio::test] +async fn refresh_pending_thread_approvals_only_lists_inactive_threads() { + let mut app = make_test_app().await; + let main_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000001").expect("valid thread"); + let agent_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000002").expect("valid thread"); + + app.primary_thread_id = Some(main_thread_id); + app.active_thread_id = Some(main_thread_id); + app.thread_event_channels + .insert(main_thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + + let agent_channel = ThreadEventChannel::new(/*capacity*/ 1); + { + let mut store = agent_channel.store.lock().await; + store.push_request(exec_approval_request( + agent_thread_id, + "turn-1", + "call-1", + /*approval_id*/ None, + )); + } + app.thread_event_channels + .insert(agent_thread_id, agent_channel); + app.agent_navigation.upsert( + agent_thread_id, + Some("Robie".to_string()), + Some("explorer".to_string()), + /*is_closed*/ false, + ); + + app.refresh_pending_thread_approvals().await; + assert_eq!( + app.chat_widget.pending_thread_approvals(), + &["Robie [explorer]".to_string()] + ); + + app.active_thread_id = Some(agent_thread_id); + app.refresh_pending_thread_approvals().await; + assert!(app.chat_widget.pending_thread_approvals().is_empty()); +} + +#[tokio::test] +async fn inactive_thread_approval_bubbles_into_active_view() -> Result<()> { + let mut app = make_test_app().await; + let main_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); + let agent_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000022").expect("valid thread"); + + app.primary_thread_id = Some(main_thread_id); + app.active_thread_id = Some(main_thread_id); + app.thread_event_channels + .insert(main_thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + app.thread_event_channels.insert( + agent_thread_id, + ThreadEventChannel::new_with_session( + /*capacity*/ 1, + ThreadSessionState { + approval_policy: AskForApproval::OnRequest, + sandbox_policy: SandboxPolicy::new_workspace_write_policy(), + rollout_path: Some(test_path_buf("/tmp/agent-rollout.jsonl")), + ..test_thread_session(agent_thread_id, test_path_buf("/tmp/agent")) + }, + Vec::new(), + ), + ); + app.agent_navigation.upsert( + agent_thread_id, + Some("Robie".to_string()), + Some("explorer".to_string()), + /*is_closed*/ false, + ); + + app.enqueue_thread_request( + agent_thread_id, + exec_approval_request( + agent_thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + ), + ) + .await?; + + assert_eq!(app.chat_widget.has_active_view(), true); + assert_eq!( + app.chat_widget.pending_thread_approvals(), + &["Robie [explorer]".to_string()] + ); + + Ok(()) +} + +#[tokio::test] +async fn side_defers_parent_approval_overlay_until_parent_replay() -> Result<()> { + let mut app = make_test_app().await; + let parent_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); + let side_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000022").expect("valid thread"); + + app.primary_thread_id = Some(parent_thread_id); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + app.thread_event_channels.insert( + parent_thread_id, + ThreadEventChannel::new_with_session( + /*capacity*/ 4, + test_thread_session(parent_thread_id, test_path_buf("/tmp/main")), + Vec::new(), + ), + ); + + app.enqueue_thread_request( + parent_thread_id, + exec_approval_request( + parent_thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + ), + ) + .await?; + + assert_eq!(app.chat_widget.has_active_view(), false); + assert!(app.chat_widget.pending_thread_approvals().is_empty()); + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + Some(SideParentStatus::NeedsApproval) + ); + + let snapshot = { + let channel = app + .thread_event_channels + .get(&parent_thread_id) + .expect("parent thread channel"); + let store = channel.store.lock().await; + store.snapshot() + }; + app.side_threads.remove(&side_thread_id); + app.active_thread_id = Some(parent_thread_id); + app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ false); + + assert_eq!(app.chat_widget.has_active_view(), true); + + Ok(()) +} + +#[tokio::test] +async fn replay_snapshot_with_pending_request_suppresses_replay_notices() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); + let stale_warning = "stale startup warning that should not cover the approval"; + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: Some(test_thread_session(thread_id, test_path_buf("/tmp/main"))), + turns: Vec::new(), + events: vec![ + ThreadBufferedEvent::Notification(ServerNotification::Warning( + WarningNotification { + thread_id: Some(thread_id.to_string()), + message: stale_warning.to_string(), + }, + )), + ThreadBufferedEvent::Request(exec_approval_request( + thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + )), + ], + input_state: None, + }, + /*resume_restored_queue*/ false, + ); + + assert_eq!(app.chat_widget.has_active_view(), true); + + let mut replayed_history = String::new(); + while let Ok(event) = app_event_rx.try_recv() { + if let AppEvent::InsertHistoryCell(cell) = event { + replayed_history.push_str(&lines_to_single_string( + &cell.transcript_lines(/*width*/ 80), + )); + } + } + + assert!( + replayed_history.is_empty(), + "expected pending approval replay to suppress session notices, got {replayed_history:?}" + ); +} + +#[tokio::test] +async fn side_defers_subagent_approval_overlay_until_side_exits() -> Result<()> { + let mut app = make_test_app().await; + let main_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000011").expect("valid thread"); + let side_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000022").expect("valid thread"); + let agent_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000033").expect("valid thread"); + + app.primary_thread_id = Some(main_thread_id); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(main_thread_id)); + app.thread_event_channels.insert( + agent_thread_id, + ThreadEventChannel::new_with_session( + /*capacity*/ 4, + ThreadSessionState { + approval_policy: AskForApproval::OnRequest, + sandbox_policy: SandboxPolicy::new_workspace_write_policy(), + rollout_path: Some(test_path_buf("/tmp/agent-rollout.jsonl")), + ..test_thread_session(agent_thread_id, test_path_buf("/tmp/agent")) + }, + Vec::new(), + ), + ); + app.agent_navigation.upsert( + agent_thread_id, + Some("Robie".to_string()), + Some("explorer".to_string()), + /*is_closed*/ false, + ); + + app.enqueue_thread_request( + agent_thread_id, + exec_approval_request( + agent_thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + ), + ) + .await?; + + assert_eq!(app.chat_widget.has_active_view(), false); + assert_eq!( + app.chat_widget.pending_thread_approvals(), + &["Robie [explorer]".to_string()] + ); + + app.side_threads.remove(&side_thread_id); + app.active_thread_id = Some(main_thread_id); + app.surface_pending_inactive_thread_interactive_requests() + .await; + + assert_eq!(app.chat_widget.has_active_view(), true); + + Ok(()) +} + +#[tokio::test] +async fn inactive_thread_exec_approval_preserves_context() { + let app = make_test_app().await; + let thread_id = ThreadId::new(); + let mut request = exec_approval_request( + thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + ); + let ServerRequest::CommandExecutionRequestApproval { params, .. } = &mut request else { + panic!("expected exec approval request"); + }; + params.network_approval_context = Some(AppServerNetworkApprovalContext { + host: "example.com".to_string(), + protocol: AppServerNetworkApprovalProtocol::Socks5Tcp, + }); + params.additional_permissions = Some(AdditionalPermissionProfile { + network: Some(AdditionalNetworkPermissions { + enabled: Some(true), + }), + file_system: Some(AdditionalFileSystemPermissions { + read: Some(vec![test_absolute_path("/tmp/read-only")]), + write: Some(vec![test_absolute_path("/tmp/write")]), + glob_scan_max_depth: None, + entries: None, + }), + }); + params.proposed_network_policy_amendments = Some(vec![AppServerNetworkPolicyAmendment { + host: "example.com".to_string(), + action: AppServerNetworkPolicyRuleAction::Allow, + }]); + + let Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Exec { + available_decisions, + network_approval_context, + additional_permissions, + .. + })) = app + .interactive_request_for_thread_request(thread_id, &request) + .await + else { + panic!("expected exec approval request"); + }; + + assert_eq!( + network_approval_context, + Some(NetworkApprovalContext { + host: "example.com".to_string(), + protocol: NetworkApprovalProtocol::Socks5Tcp, + }) + ); + assert_eq!( + additional_permissions, + Some(PermissionProfile { + network: Some(NetworkPermissions { + enabled: Some(true), + }), + file_system: Some(FileSystemPermissions::from_read_write_roots( + Some(vec![test_absolute_path("/tmp/read-only")]), + Some(vec![test_absolute_path("/tmp/write")]), + )), + }) + ); + assert_eq!( + available_decisions, + vec![ + codex_protocol::protocol::ReviewDecision::Approved, + codex_protocol::protocol::ReviewDecision::ApprovedForSession, + codex_protocol::protocol::ReviewDecision::NetworkPolicyAmendment { + network_policy_amendment: codex_protocol::approvals::NetworkPolicyAmendment { + host: "example.com".to_string(), + action: codex_protocol::approvals::NetworkPolicyRuleAction::Allow, + }, + }, + codex_protocol::protocol::ReviewDecision::Abort, + ] + ); +} + +#[tokio::test] +async fn inactive_thread_exec_approval_splits_shell_wrapped_command() { + let app = make_test_app().await; + let thread_id = ThreadId::new(); + let script = r#"python3 -c 'print("Hello, world!")'"#; + let mut request = exec_approval_request( + thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + ); + let ServerRequest::CommandExecutionRequestApproval { params, .. } = &mut request else { + panic!("expected exec approval request"); + }; + params.command = + Some(shlex::try_join(["/bin/zsh", "-lc", script]).expect("round-trippable shell wrapper")); + + let Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Exec { command, .. })) = app + .interactive_request_for_thread_request(thread_id, &request) + .await + else { + panic!("expected exec approval request"); + }; + + assert_eq!( + command, + vec![ + "/bin/zsh".to_string(), + "-lc".to_string(), + script.to_string(), + ] + ); +} + +#[tokio::test] +async fn inactive_thread_permissions_approval_preserves_file_system_permissions() { + let app = make_test_app().await; + let thread_id = ThreadId::new(); + let request = ServerRequest::PermissionsRequestApproval { + request_id: AppServerRequestId::Integer(7), + params: PermissionsRequestApprovalParams { + thread_id: thread_id.to_string(), + turn_id: "turn-approval".to_string(), + item_id: "call-approval".to_string(), + reason: Some("Need access to .git".to_string()), + permissions: codex_app_server_protocol::RequestPermissionProfile { + network: Some(AdditionalNetworkPermissions { + enabled: Some(true), + }), + file_system: Some(AdditionalFileSystemPermissions { + read: Some(vec![test_absolute_path("/tmp/read-only")]), + write: Some(vec![test_absolute_path("/tmp/write")]), + glob_scan_max_depth: None, + entries: None, + }), + }, + }, + }; + + let Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Permissions { + permissions, .. + })) = app + .interactive_request_for_thread_request(thread_id, &request) + .await + else { + panic!("expected permissions approval request"); + }; + + assert_eq!( + permissions, + RequestPermissionProfile { + network: Some(NetworkPermissions { + enabled: Some(true), + }), + file_system: Some(FileSystemPermissions::from_read_write_roots( + Some(vec![test_absolute_path("/tmp/read-only")]), + Some(vec![test_absolute_path("/tmp/write")]), + )), + } + ); +} + +#[tokio::test] +async fn inactive_thread_approval_badge_clears_after_turn_completion_notification() -> Result<()> { + let mut app = make_test_app().await; + let main_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000101").expect("valid thread"); + let agent_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000202").expect("valid thread"); + + app.primary_thread_id = Some(main_thread_id); + app.active_thread_id = Some(main_thread_id); + app.thread_event_channels + .insert(main_thread_id, ThreadEventChannel::new(/*capacity*/ 1)); + app.thread_event_channels.insert( + agent_thread_id, + ThreadEventChannel::new_with_session( + /*capacity*/ 4, + ThreadSessionState { + approval_policy: AskForApproval::OnRequest, + sandbox_policy: SandboxPolicy::new_workspace_write_policy(), + rollout_path: Some(test_path_buf("/tmp/agent-rollout.jsonl")), + ..test_thread_session(agent_thread_id, test_path_buf("/tmp/agent")) + }, + Vec::new(), + ), + ); + app.agent_navigation.upsert( + agent_thread_id, + Some("Robie".to_string()), + Some("explorer".to_string()), + /*is_closed*/ false, + ); + + app.enqueue_thread_request( + agent_thread_id, + exec_approval_request( + agent_thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + ), + ) + .await?; + assert_eq!( + app.chat_widget.pending_thread_approvals(), + &["Robie [explorer]".to_string()] + ); + + app.enqueue_thread_notification( + agent_thread_id, + turn_completed_notification(agent_thread_id, "turn-approval", TurnStatus::Completed), + ) + .await?; + + assert!( + app.chat_widget.pending_thread_approvals().is_empty(), + "turn completion should clear inactive-thread approval badge immediately" + ); + + Ok(()) +} + +#[tokio::test] +async fn inactive_thread_started_notification_initializes_replay_session() -> Result<()> { + let mut app = make_test_app().await; + let temp_dir = tempdir()?; + let main_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000101").expect("valid thread"); + let agent_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000202").expect("valid thread"); + let primary_session = ThreadSessionState { + approval_policy: AskForApproval::OnRequest, + sandbox_policy: SandboxPolicy::new_workspace_write_policy(), + ..test_thread_session(main_thread_id, test_path_buf("/tmp/main")) + }; + + app.primary_thread_id = Some(main_thread_id); + app.active_thread_id = Some(main_thread_id); + app.primary_session_configured = Some(primary_session.clone()); + app.thread_event_channels.insert( + main_thread_id, + ThreadEventChannel::new_with_session( + /*capacity*/ 4, + primary_session.clone(), + Vec::new(), + ), + ); + + let rollout_path = temp_dir.path().join("agent-rollout.jsonl"); + let turn_context = TurnContextItem { + turn_id: None, + trace_id: None, + cwd: test_path_buf("/tmp/agent"), + current_date: None, + timezone: None, + approval_policy: primary_session.approval_policy, + sandbox_policy: primary_session.sandbox_policy.clone(), + network: None, + file_system_sandbox_policy: None, + model: "gpt-agent".to_string(), + personality: None, + collaboration_mode: None, + realtime_active: Some(false), + effort: primary_session.reasoning_effort, + summary: app.config.model_reasoning_summary.unwrap_or_default(), + user_instructions: None, + developer_instructions: None, + final_output_json_schema: None, + truncation_policy: None, + }; + let rollout = RolloutLine { + timestamp: "t0".to_string(), + item: RolloutItem::TurnContext(turn_context), + }; + std::fs::write( + &rollout_path, + format!("{}\n", serde_json::to_string(&rollout)?), + )?; + app.enqueue_thread_notification( + agent_thread_id, + ServerNotification::ThreadStarted(ThreadStartedNotification { + thread: Thread { + id: agent_thread_id.to_string(), + forked_from_id: None, + preview: "agent thread".to_string(), + ephemeral: false, + model_provider: "agent-provider".to_string(), + created_at: 1, + updated_at: 2, + status: codex_app_server_protocol::ThreadStatus::Idle, + path: Some(rollout_path.clone()), + cwd: test_path_buf("/tmp/agent").abs(), + cli_version: "0.0.0".to_string(), + source: codex_app_server_protocol::SessionSource::Unknown, + agent_nickname: Some("Robie".to_string()), + agent_role: Some("explorer".to_string()), + git_info: None, + name: Some("agent thread".to_string()), + turns: Vec::new(), + }, + }), + ) + .await?; + + let store = app + .thread_event_channels + .get(&agent_thread_id) + .expect("agent thread channel") + .store + .lock() + .await; + let session = store.session.clone().expect("inferred session"); + drop(store); + + assert_eq!(session.thread_id, agent_thread_id); + assert_eq!(session.thread_name, Some("agent thread".to_string())); + assert_eq!(session.model, "gpt-agent"); + assert_eq!(session.model_provider_id, "agent-provider"); + assert_eq!(session.approval_policy, primary_session.approval_policy); + assert_eq!(session.cwd.as_path(), test_path_buf("/tmp/agent").as_path()); + assert_eq!(session.rollout_path, Some(rollout_path)); + assert_eq!( + app.agent_navigation.get(&agent_thread_id), + Some(&AgentPickerThreadEntry { + agent_nickname: Some("Robie".to_string()), + agent_role: Some("explorer".to_string()), + is_closed: false, + }) + ); + + Ok(()) +} + +#[tokio::test] +async fn inactive_thread_started_notification_preserves_primary_model_when_path_missing() +-> Result<()> { + let mut app = make_test_app().await; + let main_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000301").expect("valid thread"); + let agent_thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000302").expect("valid thread"); + let primary_session = ThreadSessionState { + approval_policy: AskForApproval::OnRequest, + sandbox_policy: SandboxPolicy::new_workspace_write_policy(), + ..test_thread_session(main_thread_id, test_path_buf("/tmp/main")) + }; + + app.primary_thread_id = Some(main_thread_id); + app.active_thread_id = Some(main_thread_id); + app.primary_session_configured = Some(primary_session.clone()); + app.thread_event_channels.insert( + main_thread_id, + ThreadEventChannel::new_with_session( + /*capacity*/ 4, + primary_session.clone(), + Vec::new(), + ), + ); + + app.enqueue_thread_notification( + agent_thread_id, + ServerNotification::ThreadStarted(ThreadStartedNotification { + thread: Thread { + id: agent_thread_id.to_string(), + forked_from_id: None, + preview: "agent thread".to_string(), + ephemeral: false, + model_provider: "agent-provider".to_string(), + created_at: 1, + updated_at: 2, + status: codex_app_server_protocol::ThreadStatus::Idle, + path: None, + cwd: test_path_buf("/tmp/agent").abs(), + cli_version: "0.0.0".to_string(), + source: codex_app_server_protocol::SessionSource::Unknown, + agent_nickname: Some("Robie".to_string()), + agent_role: Some("explorer".to_string()), + git_info: None, + name: Some("agent thread".to_string()), + turns: Vec::new(), + }, + }), + ) + .await?; + + let store = app + .thread_event_channels + .get(&agent_thread_id) + .expect("agent thread channel") + .store + .lock() + .await; + let session = store.session.clone().expect("inferred session"); + + assert_eq!(session.model, primary_session.model); + + Ok(()) +} + +#[test] +fn agent_picker_item_name_snapshot() { + let thread_id = + ThreadId::from_string("00000000-0000-0000-0000-000000000123").expect("valid thread id"); + let snapshot = [ + format!( + "{} | {}", + format_agent_picker_item_name( + Some("Robie"), + Some("explorer"), + /*is_primary*/ true + ), + thread_id + ), + format!( + "{} | {}", + format_agent_picker_item_name( + Some("Robie"), + Some("explorer"), + /*is_primary*/ false + ), + thread_id + ), + format!( + "{} | {}", + format_agent_picker_item_name( + Some("Robie"), + /*agent_role*/ None, + /*is_primary*/ false + ), + thread_id + ), + format!( + "{} | {}", + format_agent_picker_item_name( + /*agent_nickname*/ None, + Some("explorer"), + /*is_primary*/ false + ), + thread_id + ), + format!( + "{} | {}", + format_agent_picker_item_name( + /*agent_nickname*/ None, /*agent_role*/ None, /*is_primary*/ false + ), + thread_id + ), + ] + .join("\n"); + assert_app_snapshot!("agent_picker_item_name", snapshot); +} + +#[tokio::test] +async fn side_fork_config_is_ephemeral_and_appends_developer_guardrails() { + let mut app = make_test_app().await; + app.config.developer_instructions = Some("Existing developer policy.".to_string()); + let original_approval_policy = app.config.permissions.approval_policy.value(); + let original_sandbox_policy = app.config.permissions.sandbox_policy.get().clone(); + + let fork_config = app.side_fork_config(); + + assert!(fork_config.ephemeral); + assert_eq!( + fork_config.permissions.approval_policy.value(), + original_approval_policy + ); + assert_eq!( + fork_config.permissions.sandbox_policy.get(), + &original_sandbox_policy + ); + let developer_instructions = fork_config + .developer_instructions + .as_deref() + .expect("side developer instructions"); + assert!(developer_instructions.contains("Existing developer policy.")); + assert!( + developer_instructions.contains("You are in a side conversation, not the main thread.") + ); + assert!( + developer_instructions + .contains("inherited fork history is provided only as reference context") + ); + assert!( + developer_instructions.contains( + "Only instructions submitted after the side-conversation boundary are active" + ) + ); + assert!(developer_instructions.contains("Do not continue, execute, or complete any task")); + assert!( + developer_instructions + .contains("External tools may be available according to this thread's current") + ); + assert!( + developer_instructions + .contains("Any MCP or external tool calls or outputs visible in the inherited") + ); + assert!(developer_instructions.contains("non-mutating inspection")); + assert!(developer_instructions.contains("Do not modify files")); + assert!(developer_instructions.contains("Do not request escalated permissions")); + assert!(app.transcript_cells.is_empty()); +} + +#[test] +fn side_boundary_prompt_marks_inherited_history_reference_only() { + let item = App::side_boundary_prompt_item(); + let codex_protocol::models::ResponseItem::Message { role, content, .. } = item else { + panic!("expected hidden side boundary prompt to be a user message"); + }; + assert_eq!(role, "user"); + let [codex_protocol::models::ContentItem::InputText { text }] = content.as_slice() else { + panic!("expected hidden side boundary prompt text"); + }; + assert!(text.contains("Side conversation boundary.")); + assert!(text.contains("Everything before this boundary is inherited history")); + assert!(text.contains("It is not your current task.")); + assert!(text.contains("Only messages submitted after this boundary are active")); + assert!(text.contains("Do not continue, execute, or complete")); + assert!(text.contains("separate from the main thread")); + assert!(text.contains("External tools may be available according to this thread's current")); + assert!(text.contains("Any tool calls or outputs visible before this boundary happened")); + assert!(text.contains("Do not modify files")); +} + +#[test] +fn side_return_shortcuts_match_esc_and_ctrl_c() { + assert!(side_return_shortcut_matches(KeyEvent::new( + KeyCode::Esc, + KeyModifiers::NONE, + ))); + assert!(side_return_shortcut_matches(KeyEvent::new_with_kind( + KeyCode::Esc, + KeyModifiers::NONE, + KeyEventKind::Repeat, + ))); + assert!(side_return_shortcut_matches(KeyEvent::new( + KeyCode::Char('c'), + KeyModifiers::CONTROL, + ))); + assert!(side_return_shortcut_matches(KeyEvent::new( + KeyCode::Char('C'), + KeyModifiers::CONTROL, + ))); + assert!(!side_return_shortcut_matches(KeyEvent::new( + KeyCode::Char('d'), + KeyModifiers::CONTROL, + ))); + assert!(!side_return_shortcut_matches(KeyEvent::new_with_kind( + KeyCode::Esc, + KeyModifiers::NONE, + KeyEventKind::Release, + ))); +} + +#[tokio::test] +async fn side_start_block_message_tracks_open_side_conversation() { + let mut app = make_test_app().await; + assert_eq!( + app.side_start_block_message(), + Some("'/side' is unavailable until the main thread is ready.") + ); + + app.primary_thread_id = Some(ThreadId::new()); + assert_eq!(app.side_start_block_message(), None); + + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + + assert_eq!( + app.side_start_block_message(), + Some("A side conversation is already open. Press Esc to return before starting another.") + ); + + app.side_threads.remove(&side_thread_id); + assert_eq!(app.side_start_block_message(), None); +} + +#[tokio::test] +async fn side_parent_status_tracks_parent_turn_lifecycle() -> Result<()> { + let mut app = make_test_app().await; + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.primary_thread_id = Some(parent_thread_id); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + + app.enqueue_thread_notification( + parent_thread_id, + turn_completed_notification(parent_thread_id, "turn-1", TurnStatus::Completed), + ) + .await?; + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + Some(SideParentStatus::Finished) + ); + + app.enqueue_thread_notification( + parent_thread_id, + turn_started_notification(parent_thread_id, "turn-2"), + ) + .await?; + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + None + ); + + app.enqueue_thread_notification( + parent_thread_id, + turn_completed_notification(parent_thread_id, "turn-2", TurnStatus::Failed), + ) + .await?; + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + Some(SideParentStatus::Failed) + ); + + Ok(()) +} + +#[tokio::test] +async fn side_parent_status_prioritizes_input_over_approval() -> Result<()> { + let mut app = make_test_app().await; + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.primary_thread_id = Some(parent_thread_id); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + + app.enqueue_thread_request( + parent_thread_id, + exec_approval_request( + parent_thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + ), + ) + .await?; + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + Some(SideParentStatus::NeedsApproval) + ); + + app.enqueue_thread_request( + parent_thread_id, + request_user_input_request(parent_thread_id, "turn-input", "call-input"), + ) + .await?; + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + Some(SideParentStatus::NeedsInput) + ); + + app.enqueue_thread_notification( + parent_thread_id, + ServerNotification::ServerRequestResolved( + codex_app_server_protocol::ServerRequestResolvedNotification { + thread_id: parent_thread_id.to_string(), + request_id: AppServerRequestId::Integer(2), + }, + ), + ) + .await?; + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + Some(SideParentStatus::NeedsApproval) + ); + + app.enqueue_thread_notification( + parent_thread_id, + ServerNotification::ServerRequestResolved( + codex_app_server_protocol::ServerRequestResolvedNotification { + thread_id: parent_thread_id.to_string(), + request_id: AppServerRequestId::Integer(1), + }, + ), + ) + .await?; + assert_eq!( + app.side_threads + .get(&side_thread_id) + .and_then(|state| state.parent_status), + None + ); + + Ok(()) +} + +#[test] +fn side_start_error_message_explains_missing_first_prompt() { + let err = color_eyre::eyre::eyre!( + "thread/fork failed during TUI bootstrap: thread/fork failed: no rollout found for thread id 019da1a1-bed9-7a43-88a2-b49d43915021" + ); + + assert_eq!( + App::side_start_error_message(&err), + "'/side' is unavailable until the current conversation has started. Send a message first, then try /side again." + ); +} + +#[test] +fn side_start_error_message_uses_generic_start_wording() { + let err = color_eyre::eyre::eyre!("transport disconnected"); + + assert_eq!( + App::side_start_error_message(&err), + "Failed to start side conversation: transport disconnected" + ); +} + +#[tokio::test] +async fn side_thread_snapshot_hides_forked_parent_transcript() { + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + let mut store = ThreadEventStore::new(/*capacity*/ 4); + let session = ThreadSessionState { + forked_from_id: Some(parent_thread_id), + ..test_thread_session(side_thread_id, test_path_buf("/tmp/side")) + }; + let parent_turn = test_turn( + "parent-turn", + TurnStatus::Completed, + vec![ThreadItem::UserMessage { + id: "parent-user".to_string(), + content: vec![AppServerUserInput::Text { + text: "parent prompt should stay hidden".to_string(), + text_elements: Vec::new(), + }], + }], + ); + + App::install_side_thread_snapshot(&mut store, session, vec![parent_turn]); + + let stored_session = store.session.as_ref().expect("side session"); + assert_eq!(stored_session.thread_id, side_thread_id); + assert_eq!(stored_session.forked_from_id, None); + assert_eq!(store.turns, Vec::::new()); + assert_eq!(store.active_turn_id(), None); +} + +#[tokio::test] +async fn side_thread_snapshot_does_not_refresh_from_fork_history() { + let mut app = make_test_app().await; + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + + let snapshot = ThreadEventSnapshot { + session: Some(ThreadSessionState { + rollout_path: None, + ..test_thread_session(side_thread_id, test_path_buf("/tmp/side")) + }), + turns: Vec::new(), + events: Vec::new(), + input_state: None, + }; + + assert!(!app.should_refresh_snapshot_session( + side_thread_id, + /*is_replay_only*/ false, + &snapshot + )); +} + +#[tokio::test] +async fn side_thread_snapshot_skips_session_header_preamble() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + while app_event_rx.try_recv().is_ok() {} + + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.primary_thread_id = Some(parent_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + + let snapshot = ThreadEventSnapshot { + session: Some(ThreadSessionState { + forked_from_id: Some(parent_thread_id), + ..test_thread_session(side_thread_id, test_path_buf("/tmp/side")) + }), + turns: Vec::new(), + events: Vec::new(), + input_state: None, + }; + + app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ false); + + let mut rendered_cells = Vec::new(); + while let Ok(event) = app_event_rx.try_recv() { + if let AppEvent::InsertHistoryCell(cell) = event { + rendered_cells.push(lines_to_single_string(&cell.display_lines(/*width*/ 120))); + } + } + assert_eq!(app.chat_widget.thread_id(), Some(side_thread_id)); + assert_eq!(rendered_cells, Vec::::new()); + assert_eq!( + app.chat_widget.active_cell_transcript_lines(/*width*/ 120), + None + ); +} + +#[tokio::test] +async fn side_thread_ignores_global_mcp_startup_notifications() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + while app_event_rx.try_recv().is_ok() {} + let app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.primary_thread_id = Some(parent_thread_id); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + app.sync_side_thread_ui(); + + app.handle_app_server_event( + &app_server, + codex_app_server_client::AppServerEvent::ServerNotification( + ServerNotification::McpServerStatusUpdated(McpServerStatusUpdatedNotification { + name: "sentry".to_string(), + status: McpServerStartupState::Failed, + error: Some("sentry is not logged in".to_string()), + }), + ), + ) + .await; + + assert!(app_event_rx.try_recv().is_err()); +} + +#[tokio::test] +async fn side_restore_user_message_puts_inline_question_back_in_composer() { + let mut app = make_test_app().await; + let user_message = crate::chatwidget::UserMessage::from("side question"); + + app.restore_side_user_message(Some(user_message)); + + assert_eq!( + app.chat_widget.composer_text_with_pending(), + "side question" + ); +} + +#[tokio::test] +async fn side_discard_selection_keeps_current_side_thread() { + let mut app = make_test_app().await; + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + + assert_eq!( + app.side_thread_to_discard_after_switch(side_thread_id), + None + ); + assert_eq!( + app.side_thread_to_discard_after_switch(parent_thread_id), + Some(side_thread_id) + ); +} + +#[tokio::test] +async fn discard_side_thread_removes_agent_navigation_entry() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = + crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?; + let mut side_config = app.chat_widget.config_ref().clone(); + side_config.ephemeral = true; + let started = app_server.start_thread(&side_config).await?; + let side_thread_id = started.session.thread_id; + app.side_threads + .insert(side_thread_id, SideThreadState::new(ThreadId::new())); + app.agent_navigation.upsert( + side_thread_id, + Some("Side".to_string()), + Some("side".to_string()), + /*is_closed*/ false, + ); + + assert!( + app.discard_side_thread(&mut app_server, side_thread_id) + .await + ); + + assert_eq!(app.agent_navigation.get(&side_thread_id), None); + assert!(!app.side_threads.contains_key(&side_thread_id)); + Ok(()) +} + +#[tokio::test] +async fn discard_side_thread_keeps_local_state_when_server_close_fails() -> Result<()> { + let mut app = make_test_app().await; + let mut app_server = + crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()).await?; + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + app.agent_navigation.upsert( + side_thread_id, + Some("Side".to_string()), + Some("side".to_string()), + /*is_closed*/ false, + ); + + assert!( + !app.discard_side_thread(&mut app_server, side_thread_id) + .await + ); + + assert_eq!(app.active_thread_id, Some(side_thread_id)); + assert_eq!( + app.side_threads + .get(&side_thread_id) + .map(|state| state.parent_thread_id), + Some(parent_thread_id) + ); + assert!(app.agent_navigation.get(&side_thread_id).is_some()); + Ok(()) +} + +#[tokio::test] +async fn discard_closed_side_thread_removes_local_state_without_server_rpc() { + let mut app = make_test_app().await; + let parent_thread_id = ThreadId::new(); + let side_thread_id = ThreadId::new(); + app.active_thread_id = Some(side_thread_id); + app.side_threads + .insert(side_thread_id, SideThreadState::new(parent_thread_id)); + app.thread_event_channels + .insert(side_thread_id, ThreadEventChannel::new(/*capacity*/ 4)); + app.agent_navigation.upsert( + side_thread_id, + Some("Side".to_string()), + Some("side".to_string()), + /*is_closed*/ false, + ); + + app.discard_closed_side_thread(side_thread_id).await; + + assert_eq!(app.active_thread_id, None); + assert!(!app.side_threads.contains_key(&side_thread_id)); + assert!(!app.thread_event_channels.contains_key(&side_thread_id)); + assert_eq!(app.agent_navigation.get(&side_thread_id), None); +} + +#[tokio::test] +async fn active_non_primary_shutdown_target_returns_none_for_non_shutdown_event() -> Result<()> { + let mut app = make_test_app().await; + app.active_thread_id = Some(ThreadId::new()); + app.primary_thread_id = Some(ThreadId::new()); + + assert_eq!( + app.active_non_primary_shutdown_target(&ServerNotification::SkillsChanged( + codex_app_server_protocol::SkillsChangedNotification {}, + )), + None + ); + Ok(()) +} + +#[tokio::test] +async fn active_non_primary_shutdown_target_returns_none_for_primary_thread_shutdown() -> Result<()> +{ + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + app.active_thread_id = Some(thread_id); + app.primary_thread_id = Some(thread_id); + + assert_eq!( + app.active_non_primary_shutdown_target(&thread_closed_notification(thread_id)), + None + ); + Ok(()) +} + +#[tokio::test] +async fn active_non_primary_shutdown_target_returns_ids_for_non_primary_shutdown() -> Result<()> { + let mut app = make_test_app().await; + let active_thread_id = ThreadId::new(); + let primary_thread_id = ThreadId::new(); + app.active_thread_id = Some(active_thread_id); + app.primary_thread_id = Some(primary_thread_id); + + assert_eq!( + app.active_non_primary_shutdown_target(&thread_closed_notification(active_thread_id)), + Some((active_thread_id, primary_thread_id)) + ); + Ok(()) +} + +#[tokio::test] +async fn active_non_primary_shutdown_target_returns_none_when_shutdown_exit_is_pending() +-> Result<()> { + let mut app = make_test_app().await; + let active_thread_id = ThreadId::new(); + let primary_thread_id = ThreadId::new(); + app.active_thread_id = Some(active_thread_id); + app.primary_thread_id = Some(primary_thread_id); + app.pending_shutdown_exit_thread_id = Some(active_thread_id); + + assert_eq!( + app.active_non_primary_shutdown_target(&thread_closed_notification(active_thread_id)), + None + ); + Ok(()) +} + +#[tokio::test] +async fn active_non_primary_shutdown_target_still_switches_for_other_pending_exit_thread() +-> Result<()> { + let mut app = make_test_app().await; + let active_thread_id = ThreadId::new(); + let primary_thread_id = ThreadId::new(); + app.active_thread_id = Some(active_thread_id); + app.primary_thread_id = Some(primary_thread_id); + app.pending_shutdown_exit_thread_id = Some(ThreadId::new()); + + assert_eq!( + app.active_non_primary_shutdown_target(&thread_closed_notification(active_thread_id)), + Some((active_thread_id, primary_thread_id)) + ); + Ok(()) +} + +async fn render_clear_ui_header_after_long_transcript_for_snapshot() -> String { + let mut app = make_test_app().await; + app.config.cwd = test_path_buf("/tmp/project").abs(); + app.chat_widget.set_model("gpt-test"); + app.chat_widget + .set_reasoning_effort(Some(ReasoningEffortConfig::High)); + let story_part_one = "In the cliffside town of Bracken Ferry, the lighthouse had been dark for \ + nineteen years, and the children were told it was because the sea no longer wanted a \ + guide. Mara, who repaired clocks for a living, found that hard to believe. Every dawn she \ + heard the gulls circling the empty tower, and every dusk she watched ships hesitate at the \ + mouth of the bay as if listening for a signal that never came. When an old brass key fell \ + out of a cracked parcel in her workshop, tagged only with the words 'for the lamp room,' \ + she decided to climb the hill and see what the town had forgotten."; + let story_part_two = "Inside the lighthouse she found gears wrapped in oilcloth, logbooks filled \ + with weather notes, and a lens shrouded beneath salt-stiff canvas. The mechanism was not \ + broken, only unfinished. Someone had removed the governor spring and hidden it in a false \ + drawer, along with a letter from the last keeper admitting he had darkened the light on \ + purpose after smugglers threatened his family. Mara spent the night rebuilding the clockwork \ + from spare watch parts, her fingers blackened with soot and grease, while a storm gathered \ + over the water and the harbor bells began to ring."; + let story_part_three = "At midnight the first squall hit, and the fishing boats returned early, \ + blind in sheets of rain. Mara wound the mechanism, set the teeth by hand, and watched the \ + great lens begin to turn in slow, certain arcs. The beam swept across the bay, caught the \ + whitecaps, and reached the boats just as they were drifting toward the rocks below the \ + eastern cliffs. In the morning the town square was crowded with wet sailors, angry elders, \ + and wide-eyed children, but when the oldest captain placed the keeper's log on the fountain \ + and thanked Mara for relighting the coast, nobody argued. By sunset, Bracken Ferry had a \ + lighthouse again, and Mara had more clocks to mend than ever because everyone wanted \ + something in town to keep better time."; + + let user_cell = |text: &str| -> Arc { + Arc::new(UserHistoryCell { + message: text.to_string(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: Vec::new(), + }) as Arc + }; + let agent_cell = |text: &str| -> Arc { + Arc::new(AgentMessageCell::new( + vec![Line::from(text.to_string())], + /*is_first_line*/ true, + )) as Arc + }; + let make_header = |is_first| -> Arc { + let event = SessionConfiguredEvent { + session_id: ThreadId::new(), + forked_from_id: None, + thread_name: None, + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: test_path_buf("/tmp/project").abs(), + reasoning_effort: Some(ReasoningEffortConfig::High), + history_log_id: 0, + history_entry_count: 0, + initial_messages: None, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + }; + Arc::new(new_session_info( + app.chat_widget.config_ref(), + app.chat_widget.current_model(), + event, + is_first, + /*tooltip_override*/ None, + /*auth_plan*/ None, + /*show_fast_status*/ false, + )) as Arc + }; + + app.transcript_cells = vec![ + make_header(true), + Arc::new(crate::history_cell::new_info_event( + "startup tip that used to replay".to_string(), + /*hint*/ None, + )) as Arc, + user_cell("Tell me a long story about a town with a dark lighthouse."), + agent_cell(story_part_one), + user_cell("Continue the story and reveal why the light went out."), + agent_cell(story_part_two), + user_cell("Finish the story with a storm and a resolution."), + agent_cell(story_part_three), + ]; + app.has_emitted_history_lines = true; + + let rendered = app + .clear_ui_header_lines_with_version(/*width*/ 80, "") + .iter() + .map(|line| { + line.spans + .iter() + .map(|span| span.content.as_ref()) + .collect::() + }) + .collect::>() + .join("\n"); + + assert!( + !rendered.contains("startup tip that used to replay"), + "clear header should not replay startup notices" + ); + assert!( + !rendered.contains("Bracken Ferry"), + "clear header should not replay prior conversation turns" + ); + rendered +} + +#[tokio::test] +#[cfg_attr( + target_os = "windows", + ignore = "snapshot path rendering differs on Windows" +)] +async fn clear_ui_after_long_transcript_snapshots_fresh_header_only() { + let rendered = render_clear_ui_header_after_long_transcript_for_snapshot().await; + assert_app_snapshot!("clear_ui_after_long_transcript_fresh_header_only", rendered); +} + +#[tokio::test] +#[cfg_attr( + target_os = "windows", + ignore = "snapshot path rendering differs on Windows" +)] +async fn ctrl_l_clear_ui_after_long_transcript_reuses_clear_header_snapshot() { + let rendered = render_clear_ui_header_after_long_transcript_for_snapshot().await; + assert_app_snapshot!("clear_ui_after_long_transcript_fresh_header_only", rendered); +} + +#[tokio::test] +#[cfg_attr( + target_os = "windows", + ignore = "snapshot path rendering differs on Windows" +)] +async fn clear_ui_header_shows_fast_status_for_fast_capable_models() { + let mut app = make_test_app().await; + app.config.cwd = test_path_buf("/tmp/project").abs(); + app.chat_widget.set_model("gpt-5.4"); + set_fast_mode_test_catalog(&mut app.chat_widget); + app.chat_widget + .set_reasoning_effort(Some(ReasoningEffortConfig::XHigh)); + app.chat_widget + .set_service_tier(Some(codex_protocol::config_types::ServiceTier::Fast)); + set_chatgpt_auth(&mut app.chat_widget); + set_fast_mode_test_catalog(&mut app.chat_widget); + + let rendered = app + .clear_ui_header_lines_with_version(/*width*/ 80, "") + .iter() + .map(|line| { + line.spans + .iter() + .map(|span| span.content.as_ref()) + .collect::() + }) + .collect::>() + .join("\n"); + + assert_app_snapshot!("clear_ui_header_fast_status_fast_capable_models", rendered); +} + +async fn make_test_app() -> App { + let (chat_widget, app_event_tx, _rx, _op_rx) = make_chatwidget_manual_with_sender().await; + let config = chat_widget.config_ref().clone(); + let file_search = FileSearchManager::new(config.cwd.to_path_buf(), app_event_tx.clone()); + let model = crate::legacy_core::test_support::get_model_offline(config.model.as_deref()); + let session_telemetry = test_session_telemetry(&config, model.as_str()); + + App { + model_catalog: chat_widget.model_catalog(), + session_telemetry, + app_event_tx, + chat_widget, + config, + active_profile: None, + cli_kv_overrides: Vec::new(), + harness_overrides: ConfigOverrides::default(), + runtime_approval_policy_override: None, + runtime_sandbox_policy_override: None, + file_search, + transcript_cells: Vec::new(), + overlay: None, + deferred_history_lines: Vec::new(), + has_emitted_history_lines: false, + enhanced_keys_supported: false, + commit_anim_running: Arc::new(AtomicBool::new(false)), + status_line_invalid_items_warned: Arc::new(AtomicBool::new(false)), + terminal_title_invalid_items_warned: Arc::new(AtomicBool::new(false)), + backtrack: BacktrackState::default(), + backtrack_render_pending: false, + feedback: codex_feedback::CodexFeedback::new(), + feedback_audience: FeedbackAudience::External, + environment_manager: Arc::new(EnvironmentManager::new(/*exec_server_url*/ None)), + remote_app_server_url: None, + remote_app_server_auth_token: None, + pending_update_action: None, + pending_shutdown_exit_thread_id: None, + windows_sandbox: WindowsSandboxState::default(), + thread_event_channels: HashMap::new(), + thread_event_listener_tasks: HashMap::new(), + agent_navigation: AgentNavigationState::default(), + side_threads: HashMap::new(), + active_thread_id: None, + active_thread_rx: None, + primary_thread_id: None, + last_subagent_backfill_attempt: None, + primary_session_configured: None, + pending_primary_events: VecDeque::new(), + pending_app_server_requests: PendingAppServerRequests::default(), + pending_plugin_enabled_writes: HashMap::new(), + } +} + +async fn make_test_app_with_channels() -> ( + App, + tokio::sync::mpsc::UnboundedReceiver, + tokio::sync::mpsc::UnboundedReceiver, +) { + let (chat_widget, app_event_tx, rx, op_rx) = make_chatwidget_manual_with_sender().await; + let config = chat_widget.config_ref().clone(); + let file_search = FileSearchManager::new(config.cwd.to_path_buf(), app_event_tx.clone()); + let model = crate::legacy_core::test_support::get_model_offline(config.model.as_deref()); + let session_telemetry = test_session_telemetry(&config, model.as_str()); + + ( + App { + model_catalog: chat_widget.model_catalog(), + session_telemetry, + app_event_tx, + chat_widget, + config, + active_profile: None, + cli_kv_overrides: Vec::new(), + harness_overrides: ConfigOverrides::default(), + runtime_approval_policy_override: None, + runtime_sandbox_policy_override: None, + file_search, + transcript_cells: Vec::new(), + overlay: None, + deferred_history_lines: Vec::new(), + has_emitted_history_lines: false, + enhanced_keys_supported: false, + commit_anim_running: Arc::new(AtomicBool::new(false)), + status_line_invalid_items_warned: Arc::new(AtomicBool::new(false)), + terminal_title_invalid_items_warned: Arc::new(AtomicBool::new(false)), + backtrack: BacktrackState::default(), + backtrack_render_pending: false, + feedback: codex_feedback::CodexFeedback::new(), + feedback_audience: FeedbackAudience::External, + environment_manager: Arc::new(EnvironmentManager::new(/*exec_server_url*/ None)), + remote_app_server_url: None, + remote_app_server_auth_token: None, + pending_update_action: None, + pending_shutdown_exit_thread_id: None, + windows_sandbox: WindowsSandboxState::default(), + thread_event_channels: HashMap::new(), + thread_event_listener_tasks: HashMap::new(), + agent_navigation: AgentNavigationState::default(), + side_threads: HashMap::new(), + active_thread_id: None, + active_thread_rx: None, + primary_thread_id: None, + last_subagent_backfill_attempt: None, + primary_session_configured: None, + pending_primary_events: VecDeque::new(), + pending_app_server_requests: PendingAppServerRequests::default(), + pending_plugin_enabled_writes: HashMap::new(), + }, + rx, + op_rx, + ) +} + +fn test_thread_session(thread_id: ThreadId, cwd: PathBuf) -> ThreadSessionState { + ThreadSessionState { + thread_id, + forked_from_id: None, + fork_parent_title: None, + thread_name: None, + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: cwd.abs(), + instruction_source_paths: Vec::new(), + reasoning_effort: None, + history_log_id: 0, + history_entry_count: 0, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + } +} + +fn test_turn(turn_id: &str, status: TurnStatus, items: Vec) -> Turn { + Turn { + id: turn_id.to_string(), + items, + status, + error: None, + started_at: None, + completed_at: None, + duration_ms: None, + } +} + +fn turn_started_notification(thread_id: ThreadId, turn_id: &str) -> ServerNotification { + ServerNotification::TurnStarted(TurnStartedNotification { + thread_id: thread_id.to_string(), + turn: Turn { + started_at: Some(0), + ..test_turn(turn_id, TurnStatus::InProgress, Vec::new()) + }, + }) +} + +fn turn_completed_notification( + thread_id: ThreadId, + turn_id: &str, + status: TurnStatus, +) -> ServerNotification { + ServerNotification::TurnCompleted(TurnCompletedNotification { + thread_id: thread_id.to_string(), + turn: Turn { + completed_at: Some(0), + duration_ms: Some(1), + ..test_turn(turn_id, status, Vec::new()) + }, + }) +} + +fn thread_closed_notification(thread_id: ThreadId) -> ServerNotification { + ServerNotification::ThreadClosed(ThreadClosedNotification { + thread_id: thread_id.to_string(), + }) +} + +fn token_usage_notification( + thread_id: ThreadId, + turn_id: &str, + model_context_window: Option, +) -> ServerNotification { + ServerNotification::ThreadTokenUsageUpdated(ThreadTokenUsageUpdatedNotification { + thread_id: thread_id.to_string(), + turn_id: turn_id.to_string(), + token_usage: ThreadTokenUsage { + total: TokenUsageBreakdown { + total_tokens: 10, + input_tokens: 4, + cached_input_tokens: 1, + output_tokens: 5, + reasoning_output_tokens: 0, + }, + last: TokenUsageBreakdown { + total_tokens: 10, + input_tokens: 4, + cached_input_tokens: 1, + output_tokens: 5, + reasoning_output_tokens: 0, + }, + model_context_window, + }, + }) +} + +fn hook_started_notification(thread_id: ThreadId, turn_id: &str) -> ServerNotification { + ServerNotification::HookStarted(HookStartedNotification { + thread_id: thread_id.to_string(), + turn_id: Some(turn_id.to_string()), + run: AppServerHookRunSummary { + id: "user-prompt-submit:0:/tmp/hooks.json".to_string(), + event_name: AppServerHookEventName::UserPromptSubmit, + handler_type: AppServerHookHandlerType::Command, + execution_mode: AppServerHookExecutionMode::Sync, + scope: AppServerHookScope::Turn, + source_path: test_path_buf("/tmp/hooks.json").abs(), + source: codex_app_server_protocol::HookSource::User, + display_order: 0, + status: AppServerHookRunStatus::Running, + status_message: Some("checking go-workflow input policy".to_string()), + started_at: 1, + completed_at: None, + duration_ms: None, + entries: Vec::new(), + }, + }) +} + +fn hook_completed_notification(thread_id: ThreadId, turn_id: &str) -> ServerNotification { + ServerNotification::HookCompleted(HookCompletedNotification { + thread_id: thread_id.to_string(), + turn_id: Some(turn_id.to_string()), + run: AppServerHookRunSummary { + id: "user-prompt-submit:0:/tmp/hooks.json".to_string(), + event_name: AppServerHookEventName::UserPromptSubmit, + handler_type: AppServerHookHandlerType::Command, + execution_mode: AppServerHookExecutionMode::Sync, + scope: AppServerHookScope::Turn, + source_path: test_path_buf("/tmp/hooks.json").abs(), + source: codex_app_server_protocol::HookSource::User, + display_order: 0, + status: AppServerHookRunStatus::Stopped, + status_message: Some("checking go-workflow input policy".to_string()), + started_at: 1, + completed_at: Some(11), + duration_ms: Some(10), + entries: vec![ + AppServerHookOutputEntry { + kind: AppServerHookOutputEntryKind::Warning, + text: "go-workflow must start from PlanMode".to_string(), + }, + AppServerHookOutputEntry { + kind: AppServerHookOutputEntryKind::Stop, + text: "prompt blocked".to_string(), + }, + ], + }, + }) +} + +fn agent_message_delta_notification( + thread_id: ThreadId, + turn_id: &str, + item_id: &str, + delta: &str, +) -> ServerNotification { + ServerNotification::AgentMessageDelta(AgentMessageDeltaNotification { + thread_id: thread_id.to_string(), + turn_id: turn_id.to_string(), + item_id: item_id.to_string(), + delta: delta.to_string(), + }) +} + +fn exec_approval_request( + thread_id: ThreadId, + turn_id: &str, + item_id: &str, + approval_id: Option<&str>, +) -> ServerRequest { + ServerRequest::CommandExecutionRequestApproval { + request_id: AppServerRequestId::Integer(1), + params: CommandExecutionRequestApprovalParams { + thread_id: thread_id.to_string(), + turn_id: turn_id.to_string(), + item_id: item_id.to_string(), + approval_id: approval_id.map(str::to_string), + reason: Some("needs approval".to_string()), + network_approval_context: None, + command: Some("echo hello".to_string()), + cwd: Some(test_path_buf("/tmp/project").abs()), + command_actions: None, + additional_permissions: None, + proposed_execpolicy_amendment: None, + proposed_network_policy_amendments: None, + available_decisions: None, + }, + } +} + +fn request_user_input_request(thread_id: ThreadId, turn_id: &str, item_id: &str) -> ServerRequest { + ServerRequest::ToolRequestUserInput { + request_id: AppServerRequestId::Integer(2), + params: ToolRequestUserInputParams { + thread_id: thread_id.to_string(), + turn_id: turn_id.to_string(), + item_id: item_id.to_string(), + questions: Vec::new(), + }, + } +} + +#[test] +fn thread_event_store_tracks_active_turn_lifecycle() { + let mut store = ThreadEventStore::new(/*capacity*/ 8); + assert_eq!(store.active_turn_id(), None); + + let thread_id = ThreadId::new(); + store.push_notification(turn_started_notification(thread_id, "turn-1")); + assert_eq!(store.active_turn_id(), Some("turn-1")); + + store.push_notification(turn_completed_notification( + thread_id, + "turn-2", + TurnStatus::Completed, + )); + assert_eq!(store.active_turn_id(), Some("turn-1")); + + store.push_notification(turn_completed_notification( + thread_id, + "turn-1", + TurnStatus::Interrupted, + )); + assert_eq!(store.active_turn_id(), None); +} + +#[test] +fn thread_event_store_restores_active_turn_from_snapshot_turns() { + let thread_id = ThreadId::new(); + let session = test_thread_session(thread_id, test_path_buf("/tmp/project")); + let turns = vec![ + test_turn("turn-1", TurnStatus::Completed, Vec::new()), + test_turn("turn-2", TurnStatus::InProgress, Vec::new()), + ]; + + let store = + ThreadEventStore::new_with_session(/*capacity*/ 8, session.clone(), turns.clone()); + assert_eq!(store.active_turn_id(), Some("turn-2")); + + let mut refreshed_store = ThreadEventStore::new(/*capacity*/ 8); + refreshed_store.set_session(session, turns); + assert_eq!(refreshed_store.active_turn_id(), Some("turn-2")); +} + +#[test] +fn thread_event_store_clear_active_turn_id_resets_cached_turn() { + let mut store = ThreadEventStore::new(/*capacity*/ 8); + let thread_id = ThreadId::new(); + store.push_notification(turn_started_notification(thread_id, "turn-1")); + + store.clear_active_turn_id(); + + assert_eq!(store.active_turn_id(), None); +} + +#[test] +fn thread_event_store_rebase_preserves_resolved_request_state() { + let thread_id = ThreadId::new(); + let mut store = ThreadEventStore::new(/*capacity*/ 8); + store.push_request(exec_approval_request( + thread_id, + "turn-approval", + "call-approval", + /*approval_id*/ None, + )); + store.push_notification(ServerNotification::ServerRequestResolved( + codex_app_server_protocol::ServerRequestResolvedNotification { + request_id: AppServerRequestId::Integer(1), + thread_id: thread_id.to_string(), + }, + )); + + store.rebase_buffer_after_session_refresh(); + + let snapshot = store.snapshot(); + assert!(snapshot.events.is_empty()); + assert_eq!(store.has_pending_thread_approvals(), false); +} + +#[test] +fn thread_event_store_rebase_preserves_hook_notifications() { + let thread_id = ThreadId::new(); + let mut store = ThreadEventStore::new(/*capacity*/ 8); + store.push_notification(hook_started_notification(thread_id, "turn-hook")); + store.push_notification(hook_completed_notification(thread_id, "turn-hook")); + + store.rebase_buffer_after_session_refresh(); + + let snapshot = store.snapshot(); + let hook_notifications = snapshot + .events + .into_iter() + .map(|event| match event { + ThreadBufferedEvent::Notification(notification) => { + serde_json::to_value(notification).expect("hook notification should serialize") + } + other => panic!("expected buffered hook notification, saw: {other:?}"), + }) + .collect::>(); + assert_eq!( + hook_notifications, + vec![ + serde_json::to_value(hook_started_notification(thread_id, "turn-hook")) + .expect("hook notification should serialize"), + serde_json::to_value(hook_completed_notification(thread_id, "turn-hook")) + .expect("hook notification should serialize"), + ] + ); +} + +#[test] +fn build_feedback_upload_params_includes_thread_id_and_rollout_path() { + let thread_id = ThreadId::new(); + let rollout_path = PathBuf::from("/tmp/rollout.jsonl"); + + let params = build_feedback_upload_params( + Some(thread_id), + Some(rollout_path.clone()), + FeedbackCategory::SafetyCheck, + Some("needs follow-up".to_string()), + Some("turn-123".to_string()), + /*include_logs*/ true, + ); + + assert_eq!(params.classification, "safety_check"); + assert_eq!(params.reason, Some("needs follow-up".to_string())); + assert_eq!(params.thread_id, Some(thread_id.to_string())); + assert_eq!( + params + .tags + .as_ref() + .and_then(|tags| tags.get("turn_id")) + .map(String::as_str), + Some("turn-123") + ); + assert_eq!(params.include_logs, true); + assert_eq!(params.extra_log_files, Some(vec![rollout_path])); +} + +#[test] +fn build_feedback_upload_params_omits_rollout_path_without_logs() { + let params = build_feedback_upload_params( + /*origin_thread_id*/ None, + Some(PathBuf::from("/tmp/rollout.jsonl")), + FeedbackCategory::GoodResult, + /*reason*/ None, + /*turn_id*/ None, + /*include_logs*/ false, + ); + + assert_eq!(params.classification, "good_result"); + assert_eq!(params.reason, None); + assert_eq!(params.thread_id, None); + assert_eq!(params.tags, None); + assert_eq!(params.include_logs, false); + assert_eq!(params.extra_log_files, None); +} + +#[tokio::test] +async fn feedback_submission_without_thread_emits_error_history_cell() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + + app.handle_feedback_submitted( + /*origin_thread_id*/ None, + FeedbackCategory::Bug, + /*include_logs*/ true, + Err("boom".to_string()), + ) + .await; + + let cell = match app_event_rx.try_recv() { + Ok(AppEvent::InsertHistoryCell(cell)) => cell, + other => panic!("expected feedback error history cell, saw {other:?}"), + }; + assert_eq!( + lines_to_single_string(&cell.display_lines(/*width*/ 120)), + "■ Failed to upload feedback: boom" + ); +} + +#[tokio::test] +async fn feedback_submission_for_inactive_thread_replays_into_origin_thread() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let origin_thread_id = ThreadId::new(); + let active_thread_id = ThreadId::new(); + let origin_session = test_thread_session(origin_thread_id, test_path_buf("/tmp/origin")); + let active_session = test_thread_session(active_thread_id, test_path_buf("/tmp/active")); + app.thread_event_channels.insert( + origin_thread_id, + ThreadEventChannel::new_with_session( + THREAD_EVENT_CHANNEL_CAPACITY, + origin_session.clone(), + Vec::new(), + ), + ); + app.thread_event_channels.insert( + active_thread_id, + ThreadEventChannel::new_with_session( + THREAD_EVENT_CHANNEL_CAPACITY, + active_session.clone(), + Vec::new(), + ), + ); + app.activate_thread_channel(active_thread_id).await; + app.chat_widget.handle_thread_session(active_session); + while app_event_rx.try_recv().is_ok() {} + + app.handle_feedback_submitted( + Some(origin_thread_id), + FeedbackCategory::Bug, + /*include_logs*/ true, + Ok("uploaded-thread".to_string()), + ) + .await; + + assert_matches!( + app_event_rx.try_recv(), + Err(tokio::sync::mpsc::error::TryRecvError::Empty) + ); + + let snapshot = { + let channel = app + .thread_event_channels + .get(&origin_thread_id) + .expect("origin thread channel should exist"); + let store = channel.store.lock().await; + assert!(matches!( + store.buffer.back(), + Some(ThreadBufferedEvent::FeedbackSubmission(_)) + )); + store.snapshot() + }; + + app.replay_thread_snapshot(snapshot, /*resume_restored_queue*/ false); + + let mut rendered_cells = Vec::new(); + while let Ok(event) = app_event_rx.try_recv() { + if let AppEvent::InsertHistoryCell(cell) = event { + rendered_cells.push(lines_to_single_string(&cell.display_lines(/*width*/ 120))); + } + } + assert!(rendered_cells.iter().any(|cell| { + cell.contains("• Feedback uploaded. Please open an issue using the following URL:") + && cell.contains("uploaded-thread") + })); +} + +fn next_user_turn_op(op_rx: &mut tokio::sync::mpsc::UnboundedReceiver) -> Op { + let mut seen = Vec::new(); + while let Ok(op) = op_rx.try_recv() { + if matches!(op, Op::UserTurn { .. }) { + return op; + } + seen.push(format!("{op:?}")); + } + panic!("expected UserTurn op, saw: {seen:?}"); +} + +fn lines_to_single_string(lines: &[Line<'_>]) -> String { + lines + .iter() + .map(|line| { + line.spans + .iter() + .map(|span| span.content.as_ref()) + .collect::() + }) + .collect::>() + .join("\n") +} + +fn test_session_telemetry(config: &Config, model: &str) -> SessionTelemetry { + let model_info = crate::legacy_core::test_support::construct_model_info_offline(model, config); + SessionTelemetry::new( + ThreadId::new(), + model, + model_info.slug.as_str(), + /*account_id*/ None, + /*account_email*/ None, + /*auth_mode*/ None, + "test_originator".to_string(), + /*log_user_prompts*/ false, + "test".to_string(), + SessionSource::Cli, + ) +} + +fn app_enabled_in_effective_config(config: &Config, app_id: &str) -> Option { + config + .config_layer_stack + .effective_config() + .as_table() + .and_then(|table| table.get("apps")) + .and_then(TomlValue::as_table) + .and_then(|apps| apps.get(app_id)) + .and_then(TomlValue::as_table) + .and_then(|app| app.get("enabled")) + .and_then(TomlValue::as_bool) +} + +#[test] +fn active_turn_not_steerable_turn_error_extracts_structured_server_error() { + let turn_error = AppServerTurnError { + message: "cannot steer a review turn".to_string(), + codex_error_info: Some(AppServerCodexErrorInfo::ActiveTurnNotSteerable { + turn_kind: AppServerNonSteerableTurnKind::Review, + }), + additional_details: None, + }; + let error = TypedRequestError::Server { + method: "turn/steer".to_string(), + source: JSONRPCErrorError { + code: -32602, + message: turn_error.message.clone(), + data: Some(serde_json::to_value(&turn_error).expect("turn error should serialize")), + }, + }; + + assert_eq!( + active_turn_not_steerable_turn_error(&error), + Some(turn_error) + ); +} + +#[test] +fn active_turn_steer_race_detects_missing_active_turn() { + let error = TypedRequestError::Server { + method: "turn/steer".to_string(), + source: JSONRPCErrorError { + code: -32602, + message: "no active turn to steer".to_string(), + data: None, + }, + }; + + assert_eq!( + active_turn_steer_race(&error), + Some(ActiveTurnSteerRace::Missing) + ); + assert_eq!(active_turn_not_steerable_turn_error(&error), None); +} + +#[test] +fn active_turn_steer_race_extracts_actual_turn_id_from_mismatch() { + let error = TypedRequestError::Server { + method: "turn/steer".to_string(), + source: JSONRPCErrorError { + code: -32602, + message: "expected active turn id `turn-expected` but found `turn-actual`".to_string(), + data: None, + }, + }; + + assert_eq!( + active_turn_steer_race(&error), + Some(ActiveTurnSteerRace::ExpectedTurnMismatch { + actual_turn_id: "turn-actual".to_string(), + }) + ); +} + +#[tokio::test] +async fn update_reasoning_effort_updates_collaboration_mode() { + let mut app = make_test_app().await; + app.chat_widget + .set_reasoning_effort(Some(ReasoningEffortConfig::Medium)); + + app.on_update_reasoning_effort(Some(ReasoningEffortConfig::High)); + + assert_eq!( + app.chat_widget.current_reasoning_effort(), + Some(ReasoningEffortConfig::High) + ); + assert_eq!( + app.config.model_reasoning_effort, + Some(ReasoningEffortConfig::High) + ); +} + +#[tokio::test] +async fn refresh_in_memory_config_from_disk_loads_latest_apps_state() -> Result<()> { + let mut app = make_test_app().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + let app_id = "unit_test_refresh_in_memory_config_connector".to_string(); + + assert_eq!(app_enabled_in_effective_config(&app.config, &app_id), None); + + ConfigEditsBuilder::new(&app.config.codex_home) + .with_edits([ + ConfigEdit::SetPath { + segments: vec!["apps".to_string(), app_id.clone(), "enabled".to_string()], + value: false.into(), + }, + ConfigEdit::SetPath { + segments: vec![ + "apps".to_string(), + app_id.clone(), + "disabled_reason".to_string(), + ], + value: "user".into(), + }, + ]) + .apply() + .await + .expect("persist app toggle"); + + assert_eq!(app_enabled_in_effective_config(&app.config, &app_id), None); + + app.refresh_in_memory_config_from_disk().await?; + + assert_eq!( + app_enabled_in_effective_config(&app.config, &app_id), + Some(false) + ); + Ok(()) +} + +#[tokio::test] +async fn refresh_in_memory_config_from_disk_best_effort_keeps_current_config_on_error() -> Result<()> +{ + let mut app = make_test_app().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + std::fs::write(codex_home.path().join("config.toml"), "[broken")?; + let original_config = app.config.clone(); + + app.refresh_in_memory_config_from_disk_best_effort("starting a new thread") + .await; + + assert_eq!(app.config, original_config); + Ok(()) +} + +#[tokio::test] +async fn refresh_in_memory_config_from_disk_uses_active_chat_widget_cwd() -> Result<()> { + let mut app = make_test_app().await; + let original_cwd = app.config.cwd.clone(); + let next_cwd_tmp = tempdir()?; + let next_cwd = next_cwd_tmp.path().to_path_buf(); + + app.chat_widget.handle_codex_event(Event { + id: String::new(), + msg: EventMsg::SessionConfigured(SessionConfiguredEvent { + session_id: ThreadId::new(), + forked_from_id: None, + thread_name: None, + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: next_cwd.clone().abs(), + reasoning_effort: None, + history_log_id: 0, + history_entry_count: 0, + initial_messages: None, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + }), + }); + + assert_eq!(app.chat_widget.config_ref().cwd.to_path_buf(), next_cwd); + assert_eq!(app.config.cwd, original_cwd); + + app.refresh_in_memory_config_from_disk().await?; + + assert_eq!(app.config.cwd, app.chat_widget.config_ref().cwd); + Ok(()) +} + +#[tokio::test] +async fn rebuild_config_for_resume_or_fallback_uses_current_config_on_same_cwd_error() -> Result<()> +{ + let mut app = make_test_app().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + std::fs::write(codex_home.path().join("config.toml"), "[broken")?; + let current_config = app.config.clone(); + let current_cwd = current_config.cwd.clone(); + + let resume_config = app + .rebuild_config_for_resume_or_fallback(¤t_cwd, current_cwd.to_path_buf()) + .await?; + + assert_eq!(resume_config, current_config); + Ok(()) +} + +#[tokio::test] +async fn rebuild_config_for_resume_or_fallback_errors_when_cwd_changes() -> Result<()> { + let mut app = make_test_app().await; + let codex_home = tempdir()?; + app.config.codex_home = codex_home.path().to_path_buf().abs(); + std::fs::write(codex_home.path().join("config.toml"), "[broken")?; + let current_cwd = app.config.cwd.clone(); + let next_cwd_tmp = tempdir()?; + let next_cwd = next_cwd_tmp.path().to_path_buf(); + + let result = app + .rebuild_config_for_resume_or_fallback(¤t_cwd, next_cwd) + .await; + + assert!(result.is_err()); + Ok(()) +} + +#[tokio::test] +async fn sync_tui_theme_selection_updates_chat_widget_config_copy() { + let mut app = make_test_app().await; + + app.sync_tui_theme_selection("dracula".to_string()); + + assert_eq!(app.config.tui_theme.as_deref(), Some("dracula")); + assert_eq!( + app.chat_widget.config_ref().tui_theme.as_deref(), + Some("dracula") + ); +} + +#[tokio::test] +async fn fresh_session_config_uses_current_service_tier() { + let mut app = make_test_app().await; + app.chat_widget + .set_service_tier(Some(codex_protocol::config_types::ServiceTier::Fast)); + + let config = app.fresh_session_config(); + + assert_eq!( + config.service_tier, + Some(codex_protocol::config_types::ServiceTier::Fast) + ); +} + +#[tokio::test] +async fn backtrack_selection_with_duplicate_history_targets_unique_turn() { + let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; + + let user_cell = |text: &str, + text_elements: Vec, + local_image_paths: Vec, + remote_image_urls: Vec| + -> Arc { + Arc::new(UserHistoryCell { + message: text.to_string(), + text_elements, + local_image_paths, + remote_image_urls, + }) as Arc + }; + let agent_cell = |text: &str| -> Arc { + Arc::new(AgentMessageCell::new( + vec![Line::from(text.to_string())], + /*is_first_line*/ true, + )) as Arc + }; + + let make_header = |is_first| { + let event = SessionConfiguredEvent { + session_id: ThreadId::new(), + forked_from_id: None, + thread_name: None, + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: test_path_buf("/home/user/project").abs(), + reasoning_effort: None, + history_log_id: 0, + history_entry_count: 0, + initial_messages: None, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + }; + Arc::new(new_session_info( + app.chat_widget.config_ref(), + app.chat_widget.current_model(), + event, + is_first, + /*tooltip_override*/ None, + /*auth_plan*/ None, + /*show_fast_status*/ false, + )) as Arc + }; + + let placeholder = "[Image #1]"; + let edited_text = format!("follow-up (edited) {placeholder}"); + let edited_range = edited_text.len().saturating_sub(placeholder.len())..edited_text.len(); + let edited_text_elements = vec![TextElement::new( + edited_range.into(), + /*placeholder*/ None, + )]; + let edited_local_image_paths = vec![PathBuf::from("/tmp/fake-image.png")]; + + // Simulate a transcript with duplicated history (e.g., from prior backtracks) + // and an edited turn appended after a session header boundary. + app.transcript_cells = vec![ + make_header(true), + user_cell("first question", Vec::new(), Vec::new(), Vec::new()), + agent_cell("answer first"), + user_cell("follow-up", Vec::new(), Vec::new(), Vec::new()), + agent_cell("answer follow-up"), + make_header(false), + user_cell("first question", Vec::new(), Vec::new(), Vec::new()), + agent_cell("answer first"), + user_cell( + &edited_text, + edited_text_elements.clone(), + edited_local_image_paths.clone(), + vec!["https://example.com/backtrack.png".to_string()], + ), + agent_cell("answer edited"), + ]; + + assert_eq!(user_count(&app.transcript_cells), 2); + + let base_id = ThreadId::new(); + app.chat_widget.handle_codex_event(Event { + id: String::new(), + msg: EventMsg::SessionConfigured(SessionConfiguredEvent { + session_id: base_id, + forked_from_id: None, + thread_name: None, + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: test_path_buf("/home/user/project").abs(), + reasoning_effort: None, + history_log_id: 0, + history_entry_count: 0, + initial_messages: None, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + }), + }); + + app.backtrack.base_id = Some(base_id); + app.backtrack.primed = true; + app.backtrack.nth_user_message = user_count(&app.transcript_cells).saturating_sub(1); + + let selection = app + .confirm_backtrack_from_main() + .expect("backtrack selection"); + assert_eq!(selection.nth_user_message, 1); + assert_eq!(selection.prefill, edited_text); + assert_eq!(selection.text_elements, edited_text_elements); + assert_eq!(selection.local_image_paths, edited_local_image_paths); + assert_eq!( + selection.remote_image_urls, + vec!["https://example.com/backtrack.png".to_string()] + ); + + app.apply_backtrack_rollback(selection); + assert_eq!( + app.chat_widget.remote_image_urls(), + vec!["https://example.com/backtrack.png".to_string()] + ); + + let mut rollback_turns = None; + while let Ok(op) = op_rx.try_recv() { + if let Op::ThreadRollback { num_turns } = op { + rollback_turns = Some(num_turns); + } + } + + assert_eq!(rollback_turns, Some(1)); +} + +#[tokio::test] +async fn backtrack_remote_image_only_selection_clears_existing_composer_draft() { + let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; + + app.transcript_cells = vec![Arc::new(UserHistoryCell { + message: "original".to_string(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: Vec::new(), + }) as Arc]; + app.chat_widget + .set_composer_text("stale draft".to_string(), Vec::new(), Vec::new()); + + let remote_image_url = "https://example.com/remote-only.png".to_string(); + app.apply_backtrack_rollback(BacktrackSelection { + nth_user_message: 0, + prefill: String::new(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: vec![remote_image_url.clone()], + }); + + assert_eq!(app.chat_widget.composer_text_with_pending(), ""); + assert_eq!(app.chat_widget.remote_image_urls(), vec![remote_image_url]); + + let mut rollback_turns = None; + while let Ok(op) = op_rx.try_recv() { + if let Op::ThreadRollback { num_turns } = op { + rollback_turns = Some(num_turns); + } + } + assert_eq!(rollback_turns, Some(1)); +} + +#[tokio::test] +async fn backtrack_resubmit_preserves_data_image_urls_in_user_turn() { + let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; + + let thread_id = ThreadId::new(); + app.chat_widget.handle_codex_event(Event { + id: String::new(), + msg: EventMsg::SessionConfigured(SessionConfiguredEvent { + session_id: thread_id, + forked_from_id: None, + thread_name: None, + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: test_path_buf("/home/user/project").abs(), + reasoning_effort: None, + history_log_id: 0, + history_entry_count: 0, + initial_messages: None, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + }), + }); + + let data_image_url = "data:image/png;base64,abc123".to_string(); + app.transcript_cells = vec![Arc::new(UserHistoryCell { + message: "please inspect this".to_string(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: vec![data_image_url.clone()], + }) as Arc]; + + app.apply_backtrack_rollback(BacktrackSelection { + nth_user_message: 0, + prefill: "please inspect this".to_string(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: vec![data_image_url.clone()], + }); + + app.chat_widget + .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + + let mut saw_rollback = false; + let mut submitted_items: Option> = None; + while let Ok(op) = op_rx.try_recv() { + match op { + Op::ThreadRollback { .. } => saw_rollback = true, + Op::UserTurn { items, .. } => submitted_items = Some(items), + _ => {} + } + } + + assert!(saw_rollback); + let items = submitted_items.expect("expected user turn after backtrack resubmit"); + assert!(items.iter().any(|item| { + matches!( + item, + UserInput::Image { image_url } if image_url == &data_image_url + ) + })); +} + +#[tokio::test] +async fn replay_thread_snapshot_replays_turn_history_in_order() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: Some(test_thread_session( + thread_id, + test_path_buf("/home/user/project"), + )), + turns: vec![ + Turn { + id: "turn-1".to_string(), + items: vec![ThreadItem::UserMessage { + id: "user-1".to_string(), + content: vec![AppServerUserInput::Text { + text: "first prompt".to_string(), + text_elements: Vec::new(), + }], + }], + status: TurnStatus::Completed, + error: None, + started_at: None, + completed_at: None, + duration_ms: None, + }, + Turn { + id: "turn-2".to_string(), + items: vec![ + ThreadItem::UserMessage { + id: "user-2".to_string(), + content: vec![AppServerUserInput::Text { + text: "third prompt".to_string(), + text_elements: Vec::new(), + }], + }, + ThreadItem::AgentMessage { + id: "assistant-2".to_string(), + text: "done".to_string(), + phase: None, + memory_citation: None, + }, + ], + status: TurnStatus::Completed, + error: None, + started_at: None, + completed_at: None, + duration_ms: None, + }, + ], + events: Vec::new(), + input_state: None, + }, + /*resume_restored_queue*/ false, + ); + + while let Ok(event) = app_event_rx.try_recv() { + if let AppEvent::InsertHistoryCell(cell) = event { + let cell: Arc = cell.into(); + app.transcript_cells.push(cell); + } + } + + let user_messages: Vec = app + .transcript_cells + .iter() + .filter_map(|cell| { + cell.as_any() + .downcast_ref::() + .map(|cell| cell.message.clone()) + }) + .collect(); + assert_eq!( + user_messages, + vec!["first prompt".to_string(), "third prompt".to_string()] + ); +} + +#[tokio::test] +async fn replace_chat_widget_reseeds_collab_agent_metadata_for_replay() { + let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await; + let receiver_thread_id = + ThreadId::from_string("019cff70-2599-75e2-af72-b958ce5dc1cc").expect("valid thread"); + app.agent_navigation.upsert( + receiver_thread_id, + Some("Robie".to_string()), + Some("explorer".to_string()), + /*is_closed*/ false, + ); + + let replacement = ChatWidget::new_with_app_event(ChatWidgetInit { + config: app.config.clone(), + frame_requester: crate::tui::FrameRequester::test_dummy(), + app_event_tx: app.app_event_tx.clone(), + initial_user_message: None, + enhanced_keys_supported: app.enhanced_keys_supported, + has_chatgpt_account: app.chat_widget.has_chatgpt_account(), + model_catalog: app.model_catalog.clone(), + feedback: app.feedback.clone(), + is_first_run: false, + status_account_display: app.chat_widget.status_account_display().cloned(), + initial_plan_type: app.chat_widget.current_plan_type(), + model: Some(app.chat_widget.current_model().to_string()), + startup_tooltip_override: None, + status_line_invalid_items_warned: app.status_line_invalid_items_warned.clone(), + terminal_title_invalid_items_warned: app.terminal_title_invalid_items_warned.clone(), + session_telemetry: app.session_telemetry.clone(), + }); + app.replace_chat_widget(replacement); + + app.replay_thread_snapshot( + ThreadEventSnapshot { + session: None, + turns: Vec::new(), + events: vec![ThreadBufferedEvent::Notification( + ServerNotification::ItemStarted( + codex_app_server_protocol::ItemStartedNotification { + thread_id: "thread-1".to_string(), + turn_id: "turn-1".to_string(), + item: ThreadItem::CollabAgentToolCall { + id: "wait-1".to_string(), + tool: codex_app_server_protocol::CollabAgentTool::Wait, + status: + codex_app_server_protocol::CollabAgentToolCallStatus::InProgress, + sender_thread_id: ThreadId::new().to_string(), + receiver_thread_ids: vec![receiver_thread_id.to_string()], + prompt: None, + model: None, + reasoning_effort: None, + agents_states: HashMap::new(), + }, + }, + ), + )], + input_state: None, + }, + /*resume_restored_queue*/ false, + ); + + let mut saw_named_wait = false; + while let Ok(event) = app_event_rx.try_recv() { + if let AppEvent::InsertHistoryCell(cell) = event { + let transcript = lines_to_single_string(&cell.transcript_lines(/*width*/ 80)); + saw_named_wait |= transcript.contains("Robie [explorer]"); + } + } + + assert!( + saw_named_wait, + "expected replayed wait item to keep agent name" + ); +} + +#[tokio::test] +async fn refreshed_snapshot_session_persists_resumed_turns() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + let initial_session = test_thread_session(thread_id, test_path_buf("/tmp/original")); + app.thread_event_channels.insert( + thread_id, + ThreadEventChannel::new_with_session( + /*capacity*/ 4, + initial_session.clone(), + Vec::new(), + ), + ); + + let resumed_turns = vec![test_turn( + "turn-1", + TurnStatus::Completed, + vec![ThreadItem::UserMessage { + id: "user-1".to_string(), + content: vec![AppServerUserInput::Text { + text: "restored prompt".to_string(), + text_elements: Vec::new(), + }], + }], + )]; + let resumed_session = ThreadSessionState { + cwd: test_path_buf("/tmp/refreshed").abs(), + ..initial_session.clone() + }; + let mut snapshot = ThreadEventSnapshot { + session: Some(initial_session), + turns: Vec::new(), + events: Vec::new(), + input_state: None, + }; + + app.apply_refreshed_snapshot_thread( + thread_id, + AppServerStartedThread { + session: resumed_session.clone(), + turns: resumed_turns.clone(), + }, + &mut snapshot, + ) + .await; + + assert_eq!(snapshot.session, Some(resumed_session.clone())); + assert_eq!(snapshot.turns, resumed_turns); + + let store = app + .thread_event_channels + .get(&thread_id) + .expect("thread channel") + .store + .lock() + .await; + let store_snapshot = store.snapshot(); + assert_eq!(store_snapshot.session, Some(resumed_session)); + assert_eq!(store_snapshot.turns, snapshot.turns); +} + +#[tokio::test] +async fn queued_rollback_syncs_overlay_and_clears_deferred_history() { + let mut app = make_test_app().await; + app.transcript_cells = vec![ + Arc::new(UserHistoryCell { + message: "first".to_string(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: Vec::new(), + }) as Arc, + Arc::new(AgentMessageCell::new( + vec![Line::from("after first")], + /*is_first_line*/ false, + )) as Arc, + Arc::new(UserHistoryCell { + message: "second".to_string(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: Vec::new(), + }) as Arc, + Arc::new(AgentMessageCell::new( + vec![Line::from("after second")], + /*is_first_line*/ false, + )) as Arc, + ]; + app.overlay = Some(Overlay::new_transcript(app.transcript_cells.clone())); + app.deferred_history_lines = vec![Line::from("stale buffered line")]; + app.backtrack.overlay_preview_active = true; + app.backtrack.nth_user_message = 1; + + let changed = app.apply_non_pending_thread_rollback(/*num_turns*/ 1); + + assert!(changed); + assert!(app.backtrack_render_pending); + assert!(app.deferred_history_lines.is_empty()); + assert_eq!(app.backtrack.nth_user_message, 0); + let user_messages: Vec = app + .transcript_cells + .iter() + .filter_map(|cell| { + cell.as_any() + .downcast_ref::() + .map(|cell| cell.message.clone()) + }) + .collect(); + assert_eq!(user_messages, vec!["first".to_string()]); + let overlay_cell_count = match app.overlay.as_ref() { + Some(Overlay::Transcript(t)) => t.committed_cell_count(), + _ => panic!("expected transcript overlay"), + }; + assert_eq!(overlay_cell_count, app.transcript_cells.len()); +} + +#[tokio::test] +async fn thread_rollback_response_discards_queued_active_thread_events() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + let (tx, rx) = mpsc::channel(8); + app.active_thread_id = Some(thread_id); + app.active_thread_rx = Some(rx); + tx.send(ThreadBufferedEvent::Notification( + ServerNotification::ConfigWarning(ConfigWarningNotification { + summary: "stale warning".to_string(), + details: None, + path: None, + range: None, + }), + )) + .await + .expect("event should queue"); + + app.handle_thread_rollback_response( + thread_id, + /*num_turns*/ 1, + &ThreadRollbackResponse { + thread: Thread { + id: thread_id.to_string(), + forked_from_id: None, + preview: String::new(), + ephemeral: false, + model_provider: "openai".to_string(), + created_at: 0, + updated_at: 0, + status: codex_app_server_protocol::ThreadStatus::Idle, + path: None, + cwd: test_path_buf("/tmp/project").abs(), + cli_version: "0.0.0".to_string(), + source: SessionSource::Cli.into(), + agent_nickname: None, + agent_role: None, + git_info: None, + name: None, + turns: Vec::new(), + }, + }, + ) + .await; + + let rx = app + .active_thread_rx + .as_mut() + .expect("active receiver should remain attached"); + assert!(matches!(rx.try_recv(), Err(TryRecvError::Empty))); +} + +#[tokio::test] +async fn new_session_requests_shutdown_for_previous_conversation() { + let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await; + + let thread_id = ThreadId::new(); + let event = SessionConfiguredEvent { + session_id: thread_id, + forked_from_id: None, + thread_name: None, + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: test_path_buf("/home/user/project").abs(), + reasoning_effort: None, + history_log_id: 0, + history_entry_count: 0, + initial_messages: None, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + }; + + app.chat_widget.handle_codex_event(Event { + id: String::new(), + msg: EventMsg::SessionConfigured(event), + }); + + while app_event_rx.try_recv().is_ok() {} + while op_rx.try_recv().is_ok() {} + + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + app.shutdown_current_thread(&mut app_server).await; + + assert!( + op_rx.try_recv().is_err(), + "shutdown should not submit Op::Shutdown" + ); +} + +#[tokio::test] +async fn shutdown_first_exit_returns_immediate_exit_when_shutdown_submit_fails() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + app.active_thread_id = Some(thread_id); + + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let control = app + .handle_exit_mode(&mut app_server, ExitMode::ShutdownFirst) + .await; + + assert_eq!(app.pending_shutdown_exit_thread_id, None); + assert!(matches!( + control, + AppRunControl::Exit(ExitReason::UserRequested) + )); +} + +#[tokio::test] +async fn shutdown_first_exit_uses_app_server_shutdown_without_submitting_op() { + let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await; + let thread_id = ThreadId::new(); + app.active_thread_id = Some(thread_id); + + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let control = app + .handle_exit_mode(&mut app_server, ExitMode::ShutdownFirst) + .await; + + assert_eq!(app.pending_shutdown_exit_thread_id, None); + assert!(matches!( + control, + AppRunControl::Exit(ExitReason::UserRequested) + )); + assert!( + op_rx.try_recv().is_err(), + "shutdown should not submit Op::Shutdown" + ); +} + +#[tokio::test] +async fn interrupt_without_active_turn_is_treated_as_handled() { + let mut app = make_test_app().await; + let mut app_server = crate::start_embedded_app_server_for_picker(app.chat_widget.config_ref()) + .await + .expect("embedded app server"); + let started = app_server + .start_thread(app.chat_widget.config_ref()) + .await + .expect("thread/start should succeed"); + let thread_id = started.session.thread_id; + app.enqueue_primary_thread_session(started.session, started.turns) + .await + .expect("primary thread should be registered"); + let op = AppCommand::interrupt(); + + let handled = app + .try_submit_active_thread_op_via_app_server(&mut app_server, thread_id, &op) + .await + .expect("interrupt submission should not fail"); + + assert_eq!(handled, true); +} + +#[tokio::test] +async fn clear_only_ui_reset_preserves_chat_session_state() { + let mut app = make_test_app().await; + let thread_id = ThreadId::new(); + app.chat_widget.handle_codex_event(Event { + id: String::new(), + msg: EventMsg::SessionConfigured(SessionConfiguredEvent { + session_id: thread_id, + forked_from_id: None, + thread_name: Some("keep me".to_string()), + model: "gpt-test".to_string(), + model_provider_id: "test-provider".to_string(), + service_tier: None, + approval_policy: AskForApproval::Never, + approvals_reviewer: ApprovalsReviewer::User, + sandbox_policy: SandboxPolicy::new_read_only_policy(), + cwd: test_path_buf("/tmp/project").abs(), + reasoning_effort: None, + history_log_id: 0, + history_entry_count: 0, + initial_messages: None, + network_proxy: None, + rollout_path: Some(PathBuf::new()), + }), + }); + app.chat_widget + .apply_external_edit("draft prompt".to_string()); + app.transcript_cells = vec![Arc::new(UserHistoryCell { + message: "old message".to_string(), + text_elements: Vec::new(), + local_image_paths: Vec::new(), + remote_image_urls: Vec::new(), + }) as Arc]; + app.overlay = Some(Overlay::new_transcript(app.transcript_cells.clone())); + app.deferred_history_lines = vec![Line::from("stale buffered line")]; + app.has_emitted_history_lines = true; + app.backtrack.primed = true; + app.backtrack.overlay_preview_active = true; + app.backtrack.nth_user_message = 0; + app.backtrack_render_pending = true; + + app.reset_app_ui_state_after_clear(); + + assert!(app.overlay.is_none()); + assert!(app.transcript_cells.is_empty()); + assert!(app.deferred_history_lines.is_empty()); + assert!(!app.has_emitted_history_lines); + assert!(!app.backtrack.primed); + assert!(!app.backtrack.overlay_preview_active); + assert!(app.backtrack.pending_rollback.is_none()); + assert!(!app.backtrack_render_pending); + assert_eq!(app.chat_widget.thread_id(), Some(thread_id)); + assert_eq!(app.chat_widget.composer_text_with_pending(), "draft prompt"); +} + +#[tokio::test] +async fn session_summary_skips_when_no_usage_or_resume_hint() { + assert!( + session_summary( + TokenUsage::default(), + /*thread_id*/ None, + /*thread_name*/ None, + /*rollout_path*/ None, + ) + .is_none() + ); +} + +#[tokio::test] +async fn session_summary_skips_resume_hint_until_rollout_exists() { + let usage = TokenUsage::default(); + let conversation = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap(); + let temp_dir = tempdir().expect("temp dir"); + let rollout_path = temp_dir.path().join("rollout.jsonl"); + + assert!( + session_summary( + usage, + Some(conversation), + /*thread_name*/ None, + Some(&rollout_path), + ) + .is_none() + ); +} + +#[tokio::test] +async fn session_summary_includes_resume_hint_for_persisted_rollout() { + let usage = TokenUsage { + input_tokens: 10, + output_tokens: 2, + total_tokens: 12, + ..Default::default() + }; + let conversation = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap(); + let temp_dir = tempdir().expect("temp dir"); + let rollout_path = temp_dir.path().join("rollout.jsonl"); + std::fs::write(&rollout_path, "{}\n").expect("write rollout"); + + let summary = session_summary( + usage, + Some(conversation), + /*thread_name*/ None, + Some(&rollout_path), + ) + .expect("summary"); + assert_eq!( + summary.usage_line, + Some("Token usage: total=12 input=10 output=2".to_string()) + ); + assert_eq!( + summary.resume_command, + Some("codex resume 123e4567-e89b-12d3-a456-426614174000".to_string()) + ); +} + +#[tokio::test] +async fn session_summary_uses_id_even_when_thread_has_name() { + let usage = TokenUsage { + input_tokens: 10, + output_tokens: 2, + total_tokens: 12, + ..Default::default() + }; + let conversation = ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").unwrap(); + let temp_dir = tempdir().expect("temp dir"); + let rollout_path = temp_dir.path().join("rollout.jsonl"); + std::fs::write(&rollout_path, "{}\n").expect("write rollout"); + + let summary = session_summary( + usage, + Some(conversation), + Some("my-session".to_string()), + Some(&rollout_path), + ) + .expect("summary"); + assert_eq!( + summary.resume_command, + Some("codex resume 123e4567-e89b-12d3-a456-426614174000".to_string()) + ); +} diff --git a/codex-rs/tui/src/app/thread_events.rs b/codex-rs/tui/src/app/thread_events.rs new file mode 100644 index 0000000000..6bbeca04e4 --- /dev/null +++ b/codex-rs/tui/src/app/thread_events.rs @@ -0,0 +1,266 @@ +//! Thread event buffering and replay state for the TUI app. +//! +//! This module owns the per-thread event store used when the TUI switches between the main +//! conversation, subagents, and side conversations. It keeps buffered app-server notifications, +//! pending interactive request replay state, active-turn tracking, and saved composer state close +//! together with the replay behavior that consumes them. + +use super::*; + +#[derive(Debug, Clone)] +pub(super) struct ThreadEventSnapshot { + pub(super) session: Option, + pub(super) turns: Vec, + pub(super) events: Vec, + pub(super) input_state: Option, +} + +#[derive(Debug, Clone)] +pub(super) enum ThreadBufferedEvent { + Notification(ServerNotification), + Request(ServerRequest), + HistoryEntryResponse(GetHistoryEntryResponseEvent), + FeedbackSubmission(FeedbackThreadEvent), +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub(super) struct FeedbackThreadEvent { + pub(super) category: FeedbackCategory, + pub(super) include_logs: bool, + pub(super) feedback_audience: FeedbackAudience, + pub(super) result: Result, +} + +#[derive(Debug)] +pub(super) struct ThreadEventStore { + pub(super) session: Option, + pub(super) turns: Vec, + pub(super) buffer: VecDeque, + pub(super) pending_interactive_replay: PendingInteractiveReplayState, + pub(super) active_turn_id: Option, + pub(super) input_state: Option, + pub(super) capacity: usize, + pub(super) active: bool, +} + +impl ThreadEventStore { + pub(super) fn event_survives_session_refresh(event: &ThreadBufferedEvent) -> bool { + matches!( + event, + ThreadBufferedEvent::Request(_) + | ThreadBufferedEvent::Notification(ServerNotification::HookStarted(_)) + | ThreadBufferedEvent::Notification(ServerNotification::HookCompleted(_)) + | ThreadBufferedEvent::FeedbackSubmission(_) + ) + } + + pub(super) fn new(capacity: usize) -> Self { + Self { + session: None, + turns: Vec::new(), + buffer: VecDeque::new(), + pending_interactive_replay: PendingInteractiveReplayState::default(), + active_turn_id: None, + input_state: None, + capacity, + active: false, + } + } + + #[cfg_attr(not(test), allow(dead_code))] + pub(super) fn new_with_session( + capacity: usize, + session: ThreadSessionState, + turns: Vec, + ) -> Self { + let mut store = Self::new(capacity); + store.session = Some(session); + store.set_turns(turns); + store + } + + pub(super) fn set_session(&mut self, session: ThreadSessionState, turns: Vec) { + self.session = Some(session); + self.set_turns(turns); + } + + pub(super) fn rebase_buffer_after_session_refresh(&mut self) { + self.buffer.retain(Self::event_survives_session_refresh); + } + + pub(super) fn set_turns(&mut self, turns: Vec) { + self.active_turn_id = turns + .iter() + .rev() + .find(|turn| matches!(turn.status, TurnStatus::InProgress)) + .map(|turn| turn.id.clone()); + self.turns = turns; + } + + pub(super) fn push_notification(&mut self, notification: ServerNotification) { + self.pending_interactive_replay + .note_server_notification(¬ification); + match ¬ification { + ServerNotification::TurnStarted(turn) => { + self.active_turn_id = Some(turn.turn.id.clone()); + } + ServerNotification::TurnCompleted(turn) => { + if self.active_turn_id.as_deref() == Some(turn.turn.id.as_str()) { + self.active_turn_id = None; + } + } + ServerNotification::ThreadClosed(_) => { + self.active_turn_id = None; + } + _ => {} + } + self.buffer + .push_back(ThreadBufferedEvent::Notification(notification)); + if self.buffer.len() > self.capacity + && let Some(removed) = self.buffer.pop_front() + && let ThreadBufferedEvent::Request(request) = &removed + { + self.pending_interactive_replay + .note_evicted_server_request(request); + } + } + + pub(super) fn push_request(&mut self, request: ServerRequest) { + self.pending_interactive_replay + .note_server_request(&request); + self.buffer.push_back(ThreadBufferedEvent::Request(request)); + if self.buffer.len() > self.capacity + && let Some(removed) = self.buffer.pop_front() + && let ThreadBufferedEvent::Request(request) = &removed + { + self.pending_interactive_replay + .note_evicted_server_request(request); + } + } + + pub(super) fn pending_replay_requests(&self) -> Vec { + self.buffer + .iter() + .filter_map(|event| match event { + ThreadBufferedEvent::Request(request) + if self + .pending_interactive_replay + .should_replay_snapshot_request(request) => + { + Some(request.clone()) + } + ThreadBufferedEvent::Request(_) + | ThreadBufferedEvent::Notification(_) + | ThreadBufferedEvent::HistoryEntryResponse(_) + | ThreadBufferedEvent::FeedbackSubmission(_) => None, + }) + .collect() + } + + pub(super) fn apply_thread_rollback(&mut self, response: &ThreadRollbackResponse) { + self.turns = response.thread.turns.clone(); + self.buffer.clear(); + self.pending_interactive_replay = PendingInteractiveReplayState::default(); + self.active_turn_id = None; + } + + pub(super) fn snapshot(&self) -> ThreadEventSnapshot { + ThreadEventSnapshot { + session: self.session.clone(), + turns: self.turns.clone(), + // Thread switches replay buffered events into a rebuilt ChatWidget. Only replay + // interactive prompts that are still pending, or answered approvals/input will reappear. + events: self + .buffer + .iter() + .filter(|event| match event { + ThreadBufferedEvent::Request(request) => self + .pending_interactive_replay + .should_replay_snapshot_request(request), + ThreadBufferedEvent::Notification(_) + | ThreadBufferedEvent::HistoryEntryResponse(_) + | ThreadBufferedEvent::FeedbackSubmission(_) => true, + }) + .cloned() + .collect(), + input_state: self.input_state.clone(), + } + } + + pub(super) fn note_outbound_op(&mut self, op: T) + where + T: Into, + { + self.pending_interactive_replay.note_outbound_op(op); + } + + pub(super) fn op_can_change_pending_replay_state(op: T) -> bool + where + T: Into, + { + PendingInteractiveReplayState::op_can_change_state(op) + } + + pub(super) fn has_pending_thread_approvals(&self) -> bool { + self.pending_interactive_replay + .has_pending_thread_approvals() + } + + pub(super) fn side_parent_pending_status(&self) -> Option { + if self + .pending_interactive_replay + .has_pending_thread_user_input() + { + Some(SideParentStatus::NeedsInput) + } else if self + .pending_interactive_replay + .has_pending_thread_approvals() + { + Some(SideParentStatus::NeedsApproval) + } else { + None + } + } + + pub(super) fn active_turn_id(&self) -> Option<&str> { + self.active_turn_id.as_deref() + } + + pub(super) fn clear_active_turn_id(&mut self) { + self.active_turn_id = None; + } +} + +#[derive(Debug)] +pub(super) struct ThreadEventChannel { + pub(super) sender: mpsc::Sender, + pub(super) receiver: Option>, + pub(super) store: Arc>, +} + +impl ThreadEventChannel { + pub(super) fn new(capacity: usize) -> Self { + let (sender, receiver) = mpsc::channel(capacity); + Self { + sender, + receiver: Some(receiver), + store: Arc::new(Mutex::new(ThreadEventStore::new(capacity))), + } + } + + #[cfg_attr(not(test), allow(dead_code))] + pub(super) fn new_with_session( + capacity: usize, + session: ThreadSessionState, + turns: Vec, + ) -> Self { + let (sender, receiver) = mpsc::channel(capacity); + Self { + sender, + receiver: Some(receiver), + store: Arc::new(Mutex::new(ThreadEventStore::new_with_session( + capacity, session, turns, + ))), + } + } +} diff --git a/codex-rs/tui/src/app/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rs new file mode 100644 index 0000000000..11f7638f9d --- /dev/null +++ b/codex-rs/tui/src/app/thread_routing.rs @@ -0,0 +1,1432 @@ +//! Thread routing, buffering, and app-server operation submission for the TUI app. +//! +//! This module manages active thread channels, routes server requests and notifications into those +//! channels, submits thread-scoped operations through the app server, and replays buffered events +//! when the visible thread changes. + +use super::*; + +impl App { + pub(super) async fn shutdown_current_thread(&mut self, app_server: &mut AppServerSession) { + if let Some(thread_id) = self.chat_widget.thread_id() { + // Clear any in-flight rollback guard when switching threads. + self.backtrack.pending_rollback = None; + if let Err(err) = app_server.thread_unsubscribe(thread_id).await { + tracing::warn!("failed to unsubscribe thread {thread_id}: {err}"); + } + self.abort_thread_event_listener(thread_id); + } + } + + pub(super) fn abort_thread_event_listener(&mut self, thread_id: ThreadId) { + if let Some(handle) = self.thread_event_listener_tasks.remove(&thread_id) { + handle.abort(); + } + } + + pub(super) fn abort_all_thread_event_listeners(&mut self) { + for handle in self + .thread_event_listener_tasks + .drain() + .map(|(_, handle)| handle) + { + handle.abort(); + } + } + + pub(super) fn ensure_thread_channel(&mut self, thread_id: ThreadId) -> &mut ThreadEventChannel { + self.thread_event_channels + .entry(thread_id) + .or_insert_with(|| ThreadEventChannel::new(THREAD_EVENT_CHANNEL_CAPACITY)) + } + + pub(super) async fn set_thread_active(&mut self, thread_id: ThreadId, active: bool) { + if let Some(channel) = self.thread_event_channels.get_mut(&thread_id) { + let mut store = channel.store.lock().await; + store.active = active; + } + } + + pub(super) async fn activate_thread_channel(&mut self, thread_id: ThreadId) { + if self.active_thread_id.is_some() { + return; + } + self.set_thread_active(thread_id, /*active*/ true).await; + let receiver = if let Some(channel) = self.thread_event_channels.get_mut(&thread_id) { + channel.receiver.take() + } else { + None + }; + self.active_thread_id = Some(thread_id); + self.active_thread_rx = receiver; + self.refresh_pending_thread_approvals().await; + } + + pub(super) async fn store_active_thread_receiver(&mut self) { + let Some(active_id) = self.active_thread_id else { + return; + }; + let input_state = self.chat_widget.capture_thread_input_state(); + if let Some(channel) = self.thread_event_channels.get_mut(&active_id) { + let receiver = self.active_thread_rx.take(); + let mut store = channel.store.lock().await; + store.active = false; + store.input_state = input_state; + if let Some(receiver) = receiver { + channel.receiver = Some(receiver); + } + } + } + + pub(super) async fn activate_thread_for_replay( + &mut self, + thread_id: ThreadId, + ) -> Option<(mpsc::Receiver, ThreadEventSnapshot)> { + let channel = self.thread_event_channels.get_mut(&thread_id)?; + let receiver = channel.receiver.take()?; + let mut store = channel.store.lock().await; + store.active = true; + let snapshot = store.snapshot(); + Some((receiver, snapshot)) + } + + pub(super) async fn clear_active_thread(&mut self) { + if let Some(active_id) = self.active_thread_id.take() { + self.set_thread_active(active_id, /*active*/ false).await; + } + self.active_thread_rx = None; + self.refresh_pending_thread_approvals().await; + } + + pub(super) async fn note_thread_outbound_op(&mut self, thread_id: ThreadId, op: &AppCommand) { + let Some(channel) = self.thread_event_channels.get(&thread_id) else { + return; + }; + let mut store = channel.store.lock().await; + store.note_outbound_op(op); + } + + pub(super) async fn note_active_thread_outbound_op(&mut self, op: &AppCommand) { + if !ThreadEventStore::op_can_change_pending_replay_state(op) { + return; + } + let Some(thread_id) = self.active_thread_id else { + return; + }; + self.note_thread_outbound_op(thread_id, op).await; + } + + pub(super) async fn active_turn_id_for_thread(&self, thread_id: ThreadId) -> Option { + let channel = self.thread_event_channels.get(&thread_id)?; + let store = channel.store.lock().await; + store.active_turn_id().map(ToOwned::to_owned) + } + + pub(super) fn thread_label(&self, thread_id: ThreadId) -> String { + let is_primary = self.primary_thread_id == Some(thread_id); + let fallback_label = if is_primary { + "Main [default]".to_string() + } else { + let thread_id = thread_id.to_string(); + let short_id: String = thread_id.chars().take(8).collect(); + format!("Agent ({short_id})") + }; + if let Some(entry) = self.agent_navigation.get(&thread_id) { + let label = format_agent_picker_item_name( + entry.agent_nickname.as_deref(), + entry.agent_role.as_deref(), + is_primary, + ); + if label == "Agent" { + let thread_id = thread_id.to_string(); + let short_id: String = thread_id.chars().take(8).collect(); + format!("{label} ({short_id})") + } else { + label + } + } else { + fallback_label + } + } + + /// Returns the thread whose transcript is currently on screen. + /// + /// `active_thread_id` is the source of truth during steady state, but the widget can briefly + /// lag behind thread bookkeeping during transitions. The footer label and adjacent-thread + /// navigation both follow what the user is actually looking at, not whichever thread most + /// recently began switching. + pub(super) fn current_displayed_thread_id(&self) -> Option { + self.active_thread_id.or(self.chat_widget.thread_id()) + } + + pub(super) fn ignore_same_thread_resume( + &mut self, + target_session: &crate::resume_picker::SessionTarget, + ) -> bool { + if self.active_thread_id != Some(target_session.thread_id) { + return false; + }; + + self.chat_widget.add_info_message( + format!("Already viewing {}.", target_session.display_label()), + /*hint*/ None, + ); + true + } + + /// Mirrors the visible thread into the contextual footer row. + /// + /// The footer sometimes shows ambient context instead of an instructional hint. In multi-agent + /// sessions, that contextual row includes the currently viewed agent label. The label is + /// intentionally hidden until there is more than one known thread so single-thread sessions do + /// not spend footer space restating that the user is already on the main conversation. + pub(super) fn sync_active_agent_label(&mut self) { + let label = self + .agent_navigation + .active_agent_label(self.current_displayed_thread_id(), self.primary_thread_id); + self.chat_widget.set_active_agent_label(label); + self.sync_side_thread_ui(); + } + + pub(super) async fn thread_cwd(&self, thread_id: ThreadId) -> Option { + let channel = self.thread_event_channels.get(&thread_id)?; + let store = channel.store.lock().await; + store.session.as_ref().map(|session| session.cwd.clone()) + } + + pub(super) async fn interactive_request_for_thread_request( + &self, + thread_id: ThreadId, + request: &ServerRequest, + ) -> Option { + let thread_label = Some(self.thread_label(thread_id)); + match request { + ServerRequest::CommandExecutionRequestApproval { params, .. } => { + let network_approval_context = params + .network_approval_context + .clone() + .map(network_approval_context_to_core); + let additional_permissions = params.additional_permissions.clone().map(Into::into); + let proposed_execpolicy_amendment = params + .proposed_execpolicy_amendment + .clone() + .map(codex_app_server_protocol::ExecPolicyAmendment::into_core); + let proposed_network_policy_amendments = params + .proposed_network_policy_amendments + .clone() + .map(|amendments| { + amendments + .into_iter() + .map(codex_app_server_protocol::NetworkPolicyAmendment::into_core) + .collect::>() + }); + Some(ThreadInteractiveRequest::Approval(ApprovalRequest::Exec { + thread_id, + thread_label, + id: params + .approval_id + .clone() + .unwrap_or_else(|| params.item_id.clone()), + command: params + .command + .as_deref() + .map(split_command_string) + .unwrap_or_default(), + reason: params.reason.clone(), + available_decisions: params + .available_decisions + .clone() + .map(|decisions| { + decisions + .into_iter() + .map(command_execution_decision_to_review_decision) + .collect() + }) + .unwrap_or_else(|| { + default_exec_approval_decisions( + network_approval_context.as_ref(), + proposed_execpolicy_amendment.as_ref(), + proposed_network_policy_amendments.as_deref(), + additional_permissions.as_ref(), + ) + }), + network_approval_context, + additional_permissions, + })) + } + ServerRequest::FileChangeRequestApproval { params, .. } => Some( + ThreadInteractiveRequest::Approval(ApprovalRequest::ApplyPatch { + thread_id, + thread_label, + id: params.item_id.clone(), + reason: params.reason.clone(), + cwd: self + .thread_cwd(thread_id) + .await + .unwrap_or_else(|| self.config.cwd.clone()), + changes: HashMap::new(), + }), + ), + ServerRequest::McpServerElicitationRequest { request_id, params } => { + if let Some(request) = McpServerElicitationFormRequest::from_app_server_request( + thread_id, + app_server_request_id_to_mcp_request_id(request_id), + params.clone(), + ) { + Some(ThreadInteractiveRequest::McpServerElicitation(request)) + } else { + Some(ThreadInteractiveRequest::Approval( + ApprovalRequest::McpElicitation { + thread_id, + thread_label, + server_name: params.server_name.clone(), + request_id: app_server_request_id_to_mcp_request_id(request_id), + message: match ¶ms.request { + codex_app_server_protocol::McpServerElicitationRequest::Form { + message, + .. + } + | codex_app_server_protocol::McpServerElicitationRequest::Url { + message, + .. + } => message.clone(), + }, + }, + )) + } + } + ServerRequest::PermissionsRequestApproval { params, .. } => Some( + ThreadInteractiveRequest::Approval(ApprovalRequest::Permissions { + thread_id, + thread_label, + call_id: params.item_id.clone(), + reason: params.reason.clone(), + permissions: params.permissions.clone().into(), + }), + ), + _ => None, + } + } + + pub(super) fn push_thread_interactive_request(&mut self, request: ThreadInteractiveRequest) { + match request { + ThreadInteractiveRequest::Approval(request) => { + self.chat_widget.push_approval_request(request); + } + ThreadInteractiveRequest::McpServerElicitation(request) => { + self.chat_widget + .push_mcp_server_elicitation_request(request); + } + } + } + + pub(super) async fn pending_inactive_thread_requests(&self) -> Vec<(ThreadId, ServerRequest)> { + let channels: Vec<(ThreadId, Arc>)> = self + .thread_event_channels + .iter() + .map(|(thread_id, channel)| (*thread_id, Arc::clone(&channel.store))) + .collect(); + + let mut requests = Vec::new(); + for (thread_id, store) in channels { + if Some(thread_id) == self.active_thread_id { + continue; + } + + let store = store.lock().await; + requests.extend( + store + .pending_replay_requests() + .into_iter() + .map(|request| (thread_id, request)), + ); + } + requests + } + + pub(super) async fn surface_pending_inactive_thread_interactive_requests(&mut self) { + if self.active_side_parent_thread_id().is_some() { + return; + } + + let requests = self.pending_inactive_thread_requests().await; + for (thread_id, request) in requests { + if let Some(request) = self + .interactive_request_for_thread_request(thread_id, &request) + .await + { + self.push_thread_interactive_request(request); + } + } + } + + pub(super) async fn submit_active_thread_op( + &mut self, + app_server: &mut AppServerSession, + op: AppCommand, + ) -> Result<()> { + let Some(thread_id) = self.active_thread_id else { + self.chat_widget + .add_error_message("No active thread is available.".to_string()); + return Ok(()); + }; + + self.submit_thread_op(app_server, thread_id, op).await + } + + pub(super) async fn submit_thread_op( + &mut self, + app_server: &mut AppServerSession, + thread_id: ThreadId, + op: AppCommand, + ) -> Result<()> { + crate::session_log::log_outbound_op(&op); + + if self.try_handle_local_history_op(thread_id, &op).await? { + return Ok(()); + } + + if self + .try_resolve_app_server_request(app_server, thread_id, &op) + .await? + { + return Ok(()); + } + + if self + .try_submit_active_thread_op_via_app_server(app_server, thread_id, &op) + .await? + { + if ThreadEventStore::op_can_change_pending_replay_state(&op) { + self.note_thread_outbound_op(thread_id, &op).await; + self.refresh_pending_thread_approvals().await; + self.refresh_side_parent_status_from_store(thread_id).await; + } + return Ok(()); + } + + self.chat_widget + .add_error_message(format!("Not available in TUI yet for thread {thread_id}.")); + Ok(()) + } + + /// Spawn a background task that fetches MCP server status from the app-server + /// via paginated RPCs, then delivers the result back through + /// `AppEvent::McpInventoryLoaded`. + /// + /// The spawned task is fire-and-forget: no `JoinHandle` is stored, so a stale + /// result may arrive after the user has moved on. We currently accept that + /// tradeoff because the effect is limited to stale inventory output in history, + /// while request-token invalidation would add cross-cutting async state for a + /// low-severity path. + pub(super) async fn try_handle_local_history_op( + &mut self, + thread_id: ThreadId, + op: &AppCommand, + ) -> Result { + match op.view() { + AppCommandView::Other(Op::AddToHistory { text }) => { + let text = text.clone(); + let config = self.chat_widget.config_ref().clone(); + tokio::spawn(async move { + if let Err(err) = append_message_history_entry(&text, &thread_id, &config).await + { + tracing::warn!( + thread_id = %thread_id, + error = %err, + "failed to append to message history" + ); + } + }); + Ok(true) + } + AppCommandView::Other(Op::GetHistoryEntryRequest { offset, log_id }) => { + let offset = *offset; + let log_id = *log_id; + let config = self.chat_widget.config_ref().clone(); + let app_event_tx = self.app_event_tx.clone(); + tokio::spawn(async move { + let entry_opt = tokio::task::spawn_blocking(move || { + lookup_message_history_entry(log_id, offset, &config) + }) + .await + .unwrap_or_else(|err| { + tracing::warn!(error = %err, "history lookup task failed"); + None + }); + + app_event_tx.send(AppEvent::ThreadHistoryEntryResponse { + thread_id, + event: GetHistoryEntryResponseEvent { + offset, + log_id, + entry: entry_opt.map(|entry| { + codex_protocol::message_history::HistoryEntry { + conversation_id: entry.session_id, + ts: entry.ts, + text: entry.text, + } + }), + }, + }); + }); + Ok(true) + } + _ => Ok(false), + } + } + + pub(super) async fn try_submit_active_thread_op_via_app_server( + &mut self, + app_server: &mut AppServerSession, + thread_id: ThreadId, + op: &AppCommand, + ) -> Result { + match op.view() { + AppCommandView::Interrupt => { + if let Some(turn_id) = self.active_turn_id_for_thread(thread_id).await { + app_server.turn_interrupt(thread_id, turn_id).await?; + } else { + app_server.startup_interrupt(thread_id).await?; + } + Ok(true) + } + AppCommandView::UserTurn { + items, + cwd, + approval_policy, + approvals_reviewer, + sandbox_policy, + model, + effort, + summary, + service_tier, + final_output_json_schema, + collaboration_mode, + personality, + } => { + let mut should_start_turn = true; + if let Some(turn_id) = self.active_turn_id_for_thread(thread_id).await { + let mut steer_turn_id = turn_id; + let mut retried_after_turn_mismatch = false; + loop { + match app_server + .turn_steer(thread_id, steer_turn_id.clone(), items.to_vec()) + .await + { + Ok(_) => return Ok(true), + Err(error) => { + if let Some(turn_error) = + active_turn_not_steerable_turn_error(&error) + { + if !self.chat_widget.enqueue_rejected_steer() { + self.chat_widget.add_error_message(turn_error.message); + } + return Ok(true); + } + match active_turn_steer_race(&error) { + Some(ActiveTurnSteerRace::Missing) => { + if let Some(channel) = + self.thread_event_channels.get(&thread_id) + { + let mut store = channel.store.lock().await; + store.clear_active_turn_id(); + } + should_start_turn = true; + break; + } + Some(ActiveTurnSteerRace::ExpectedTurnMismatch { + actual_turn_id, + }) if !retried_after_turn_mismatch + && actual_turn_id != steer_turn_id => + { + // Review flows can swap the active turn before the TUI + // processes the corresponding notification. Retry once with + // the server-reported turn id so non-steerable review turns + // still fall through to the existing queueing behavior. + if let Some(channel) = + self.thread_event_channels.get(&thread_id) + { + let mut store = channel.store.lock().await; + store.active_turn_id = Some(actual_turn_id.clone()); + } + steer_turn_id = actual_turn_id; + retried_after_turn_mismatch = true; + } + Some(ActiveTurnSteerRace::ExpectedTurnMismatch { + actual_turn_id, + }) => { + if let Some(channel) = + self.thread_event_channels.get(&thread_id) + { + let mut store = channel.store.lock().await; + store.active_turn_id = Some(actual_turn_id); + } + return Err(error.into()); + } + None => return Err(error.into()), + } + } + } + } + } + if should_start_turn { + app_server + .turn_start( + thread_id, + items.to_vec(), + cwd.clone(), + approval_policy, + approvals_reviewer + .unwrap_or(self.chat_widget.config_ref().approvals_reviewer), + sandbox_policy.clone(), + model.to_string(), + effort, + *summary, + *service_tier, + collaboration_mode.clone(), + *personality, + final_output_json_schema.clone(), + ) + .await?; + } + Ok(true) + } + AppCommandView::ListSkills { cwds, force_reload } => { + self.handle_skills_list_result( + app_server + .skills_list(codex_app_server_protocol::SkillsListParams { + cwds: cwds.to_vec(), + force_reload, + per_cwd_extra_user_roots: None, + }) + .await, + "failed to refresh skills", + ); + Ok(true) + } + AppCommandView::Compact => { + app_server.thread_compact_start(thread_id).await?; + Ok(true) + } + AppCommandView::SetThreadName { name } => { + app_server + .thread_set_name(thread_id, name.to_string()) + .await?; + Ok(true) + } + AppCommandView::ThreadRollback { num_turns } => { + let response = match app_server.thread_rollback(thread_id, num_turns).await { + Ok(response) => response, + Err(err) => { + self.handle_backtrack_rollback_failed(); + return Err(err); + } + }; + self.handle_thread_rollback_response(thread_id, num_turns, &response) + .await; + Ok(true) + } + AppCommandView::Review { review_request } => { + app_server + .review_start(thread_id, review_request.clone()) + .await?; + Ok(true) + } + AppCommandView::CleanBackgroundTerminals => { + app_server + .thread_background_terminals_clean(thread_id) + .await?; + Ok(true) + } + AppCommandView::RealtimeConversationStart(params) => { + app_server + .thread_realtime_start(thread_id, params.clone()) + .await?; + Ok(true) + } + AppCommandView::RealtimeConversationAudio(params) => { + app_server + .thread_realtime_audio(thread_id, params.clone()) + .await?; + Ok(true) + } + AppCommandView::RealtimeConversationText(params) => { + app_server + .thread_realtime_text(thread_id, params.clone()) + .await?; + Ok(true) + } + AppCommandView::RealtimeConversationClose => { + app_server.thread_realtime_stop(thread_id).await?; + Ok(true) + } + AppCommandView::RunUserShellCommand { command } => { + app_server + .thread_shell_command(thread_id, command.to_string()) + .await?; + Ok(true) + } + AppCommandView::ReloadUserConfig => { + app_server.reload_user_config().await?; + Ok(true) + } + AppCommandView::OverrideTurnContext { .. } => Ok(true), + _ => Ok(false), + } + } + + pub(super) fn handle_skills_list_result( + &mut self, + result: Result, + failure_message: &str, + ) { + match result { + Ok(response) => self.handle_skills_list_response(response), + Err(err) => { + tracing::warn!("{failure_message}: {err:#}"); + self.chat_widget + .add_error_message(format!("{failure_message}: {err:#}")); + } + } + } + + pub(super) async fn try_resolve_app_server_request( + &mut self, + app_server: &AppServerSession, + thread_id: ThreadId, + op: &AppCommand, + ) -> Result { + let Some(resolution) = self + .pending_app_server_requests + .take_resolution(op) + .map_err(|err| color_eyre::eyre::eyre!(err))? + else { + return Ok(false); + }; + + match app_server + .resolve_server_request(resolution.request_id, resolution.result) + .await + { + Ok(()) => { + if ThreadEventStore::op_can_change_pending_replay_state(op) { + self.note_thread_outbound_op(thread_id, op).await; + self.refresh_pending_thread_approvals().await; + self.refresh_side_parent_status_from_store(thread_id).await; + } + Ok(true) + } + Err(err) => { + self.chat_widget.add_error_message(format!( + "Failed to resolve app-server request for thread {thread_id}: {err}" + )); + Ok(false) + } + } + } + + pub(super) async fn refresh_pending_thread_approvals(&mut self) { + let side_parent_thread_id = self.active_side_parent_thread_id(); + let channels: Vec<(ThreadId, Arc>)> = self + .thread_event_channels + .iter() + .map(|(thread_id, channel)| (*thread_id, Arc::clone(&channel.store))) + .collect(); + + let mut pending_thread_ids = Vec::new(); + for (thread_id, store) in channels { + if Some(thread_id) == self.active_thread_id || Some(thread_id) == side_parent_thread_id + { + continue; + } + + let store = store.lock().await; + if store.has_pending_thread_approvals() { + pending_thread_ids.push(thread_id); + } + } + + pending_thread_ids.sort_by_key(ThreadId::to_string); + + let threads = pending_thread_ids + .into_iter() + .map(|thread_id| self.thread_label(thread_id)) + .collect(); + + self.chat_widget.set_pending_thread_approvals(threads); + } + + pub(super) async fn refresh_side_parent_status_from_store(&mut self, thread_id: ThreadId) { + let Some(channel) = self.thread_event_channels.get(&thread_id) else { + return; + }; + let status = { + let store = channel.store.lock().await; + store.side_parent_pending_status() + }; + if let Some(status) = status { + self.set_side_parent_status(thread_id, Some(status)); + } else { + self.clear_side_parent_action_status(thread_id); + } + } + + pub(super) async fn enqueue_thread_notification( + &mut self, + thread_id: ThreadId, + notification: ServerNotification, + ) -> Result<()> { + let inferred_session = self + .infer_session_for_thread_notification(thread_id, ¬ification) + .await; + let (sender, store) = { + let channel = self.ensure_thread_channel(thread_id); + (channel.sender.clone(), Arc::clone(&channel.store)) + }; + + let (should_send, pending_status) = { + let mut guard = store.lock().await; + if guard.session.is_none() + && let Some(session) = inferred_session + { + guard.session = Some(session); + } + guard.push_notification(notification.clone()); + (guard.active, guard.side_parent_pending_status()) + }; + let notification_status_change = SideParentStatusChange::for_notification(¬ification); + + if should_send { + match sender.try_send(ThreadBufferedEvent::Notification(notification)) { + Ok(()) => {} + Err(TrySendError::Full(event)) => { + tokio::spawn(async move { + if let Err(err) = sender.send(event).await { + tracing::warn!("thread {thread_id} event channel closed: {err}"); + } + }); + } + Err(TrySendError::Closed(_)) => { + tracing::warn!("thread {thread_id} event channel closed"); + } + } + } + if let Some(status) = pending_status { + self.set_side_parent_status(thread_id, Some(status)); + } else if let Some(change) = notification_status_change { + self.apply_side_parent_status_change(thread_id, change); + } + self.refresh_pending_thread_approvals().await; + Ok(()) + } + + /// Eagerly fetches nickname and role for receiver threads referenced by a collab notification. + /// + /// This runs on every buffered thread notification before it reaches rendering. For each + /// receiver thread id that the navigation cache does not yet have metadata for, it issues a + /// `thread/read` RPC and registers the result in both `AgentNavigationState` and the + /// `ChatWidget` metadata map. Threads that already have a nickname or role cached are skipped, + /// so the cost is at most one RPC per thread over the lifetime of a session. + /// + /// Failures are logged and silently ignored -- the worst outcome is that a rendered item shows + /// a thread id instead of a human-readable name, which is the same behavior the TUI had before + /// this change. + pub(super) async fn hydrate_collab_agent_metadata_for_notification( + &mut self, + app_server: &mut AppServerSession, + notification: &ServerNotification, + ) { + let Some(receiver_thread_ids) = collab_receiver_thread_ids(notification) else { + return; + }; + + for receiver_thread_id in receiver_thread_ids { + let Ok(thread_id) = ThreadId::from_string(receiver_thread_id) else { + tracing::warn!( + thread_id = receiver_thread_id, + "ignoring collab receiver with invalid thread id during metadata hydration" + ); + continue; + }; + + if self + .agent_navigation + .get(&thread_id) + .is_some_and(|entry| entry.agent_nickname.is_some() || entry.agent_role.is_some()) + { + continue; + } + + match app_server + .thread_read(thread_id, /*include_turns*/ false) + .await + { + Ok(thread) => { + self.upsert_agent_picker_thread( + thread_id, + thread.agent_nickname, + thread.agent_role, + /*is_closed*/ false, + ); + } + Err(err) => { + tracing::warn!( + thread_id = %thread_id, + error = %err, + "failed to hydrate collab receiver thread metadata" + ); + } + } + } + } + + pub(super) async fn infer_session_for_thread_notification( + &mut self, + thread_id: ThreadId, + notification: &ServerNotification, + ) -> Option { + let ServerNotification::ThreadStarted(notification) = notification else { + return None; + }; + let mut session = self.primary_session_configured.clone()?; + session.thread_id = thread_id; + session.thread_name = notification.thread.name.clone(); + session.model_provider_id = notification.thread.model_provider.clone(); + session.cwd = notification.thread.cwd.clone(); + let rollout_path = notification.thread.path.clone(); + if let Some(model) = + read_session_model(&self.config, thread_id, rollout_path.as_deref()).await + { + session.model = model; + } else if rollout_path.is_some() { + session.model.clear(); + } + session.history_log_id = 0; + session.history_entry_count = 0; + session.rollout_path = rollout_path; + self.upsert_agent_picker_thread( + thread_id, + notification.thread.agent_nickname.clone(), + notification.thread.agent_role.clone(), + /*is_closed*/ false, + ); + Some(session) + } + + pub(super) async fn enqueue_thread_request( + &mut self, + thread_id: ThreadId, + request: ServerRequest, + ) -> Result<()> { + let inactive_interactive_request = if self.active_thread_id != Some(thread_id) { + self.interactive_request_for_thread_request(thread_id, &request) + .await + } else { + None + }; + let (sender, store) = { + let channel = self.ensure_thread_channel(thread_id); + (channel.sender.clone(), Arc::clone(&channel.store)) + }; + + let (should_send, pending_status) = { + let mut guard = store.lock().await; + guard.push_request(request.clone()); + (guard.active, guard.side_parent_pending_status()) + }; + let request_status = SideParentStatus::for_request(&request); + + if should_send { + match sender.try_send(ThreadBufferedEvent::Request(request)) { + Ok(()) => {} + Err(TrySendError::Full(event)) => { + tokio::spawn(async move { + if let Err(err) = sender.send(event).await { + tracing::warn!("thread {thread_id} event channel closed: {err}"); + } + }); + } + Err(TrySendError::Closed(_)) => { + tracing::warn!("thread {thread_id} event channel closed"); + } + } + } else if self.active_side_parent_thread_id().is_none() + && let Some(request) = inactive_interactive_request + { + self.push_thread_interactive_request(request); + } + if let Some(status) = pending_status.or(request_status) { + self.set_side_parent_status(thread_id, Some(status)); + } + self.refresh_pending_thread_approvals().await; + Ok(()) + } + + pub(super) async fn enqueue_thread_history_entry_response( + &mut self, + thread_id: ThreadId, + event: GetHistoryEntryResponseEvent, + ) -> Result<()> { + let (sender, store) = { + let channel = self.ensure_thread_channel(thread_id); + (channel.sender.clone(), Arc::clone(&channel.store)) + }; + + let should_send = { + let mut guard = store.lock().await; + guard + .buffer + .push_back(ThreadBufferedEvent::HistoryEntryResponse(event.clone())); + if guard.buffer.len() > guard.capacity + && let Some(removed) = guard.buffer.pop_front() + && let ThreadBufferedEvent::Request(request) = &removed + { + guard + .pending_interactive_replay + .note_evicted_server_request(request); + } + guard.active + }; + + if should_send { + match sender.try_send(ThreadBufferedEvent::HistoryEntryResponse(event)) { + Ok(()) => {} + Err(TrySendError::Full(event)) => { + tokio::spawn(async move { + if let Err(err) = sender.send(event).await { + tracing::warn!("thread {thread_id} event channel closed: {err}"); + } + }); + } + Err(TrySendError::Closed(_)) => { + tracing::warn!("thread {thread_id} event channel closed"); + } + } + } + Ok(()) + } + + pub(super) async fn enqueue_primary_thread_session( + &mut self, + session: ThreadSessionState, + turns: Vec, + ) -> Result<()> { + let thread_id = session.thread_id; + self.primary_thread_id = Some(thread_id); + self.primary_session_configured = Some(session.clone()); + self.upsert_agent_picker_thread( + thread_id, /*agent_nickname*/ None, /*agent_role*/ None, + /*is_closed*/ false, + ); + let channel = self.ensure_thread_channel(thread_id); + { + let mut store = channel.store.lock().await; + store.set_session(session.clone(), turns.clone()); + } + self.activate_thread_channel(thread_id).await; + self.chat_widget + .set_initial_user_message_submit_suppressed(/*suppressed*/ true); + self.chat_widget.handle_thread_session(session); + self.chat_widget + .replay_thread_turns(turns, ReplayKind::ResumeInitialMessages); + let pending = std::mem::take(&mut self.pending_primary_events); + for pending_event in pending { + match pending_event { + ThreadBufferedEvent::Notification(notification) => { + self.enqueue_thread_notification(thread_id, notification) + .await?; + } + ThreadBufferedEvent::Request(request) => { + self.enqueue_thread_request(thread_id, request).await?; + } + ThreadBufferedEvent::HistoryEntryResponse(event) => { + self.enqueue_thread_history_entry_response(thread_id, event) + .await?; + } + ThreadBufferedEvent::FeedbackSubmission(event) => { + self.enqueue_thread_feedback_event(thread_id, event).await; + } + } + } + self.chat_widget + .set_initial_user_message_submit_suppressed(/*suppressed*/ false); + self.chat_widget.submit_initial_user_message_if_pending(); + Ok(()) + } + + pub(super) async fn enqueue_primary_thread_notification( + &mut self, + notification: ServerNotification, + ) -> Result<()> { + if let Some(thread_id) = self.primary_thread_id { + return self + .enqueue_thread_notification(thread_id, notification) + .await; + } + self.pending_primary_events + .push_back(ThreadBufferedEvent::Notification(notification)); + Ok(()) + } + + pub(super) async fn enqueue_primary_thread_request( + &mut self, + request: ServerRequest, + ) -> Result<()> { + if let Some(thread_id) = self.primary_thread_id { + return self.enqueue_thread_request(thread_id, request).await; + } + self.pending_primary_events + .push_back(ThreadBufferedEvent::Request(request)); + Ok(()) + } + + pub(super) async fn refresh_snapshot_session_if_needed( + &mut self, + app_server: &mut AppServerSession, + thread_id: ThreadId, + is_replay_only: bool, + snapshot: &mut ThreadEventSnapshot, + ) { + if !self.should_refresh_snapshot_session(thread_id, is_replay_only, snapshot) { + return; + } + + match app_server + .resume_thread(self.config.clone(), thread_id) + .await + { + Ok(started) => { + self.apply_refreshed_snapshot_thread(thread_id, started, snapshot) + .await + } + Err(err) => { + tracing::warn!( + thread_id = %thread_id, + error = %err, + "failed to refresh inferred thread session before replay" + ); + } + } + } + + pub(super) fn should_refresh_snapshot_session( + &self, + thread_id: ThreadId, + is_replay_only: bool, + snapshot: &ThreadEventSnapshot, + ) -> bool { + !is_replay_only + && !self.side_threads.contains_key(&thread_id) + && snapshot.session.as_ref().is_none_or(|session| { + session.model.trim().is_empty() || session.rollout_path.is_none() + }) + } + + pub(super) async fn apply_refreshed_snapshot_thread( + &mut self, + thread_id: ThreadId, + started: AppServerStartedThread, + snapshot: &mut ThreadEventSnapshot, + ) { + let AppServerStartedThread { session, turns } = started; + if let Some(channel) = self.thread_event_channels.get(&thread_id) { + let mut store = channel.store.lock().await; + store.set_session(session.clone(), turns.clone()); + store.rebase_buffer_after_session_refresh(); + } + snapshot.session = Some(session); + snapshot.turns = turns; + snapshot + .events + .retain(ThreadEventStore::event_survives_session_refresh); + } + + /// Opens the `/agent` picker after refreshing cached labels for known threads. + /// + /// The picker state is derived from long-lived thread channels plus best-effort metadata + /// refreshes from the backend. Refresh failures are treated as "thread is only inspectable by + /// historical id now" and converted into closed picker entries instead of deleting them, so + /// the stable traversal order remains intact for review and keyboard navigation. + pub(super) async fn drain_active_thread_events(&mut self, tui: &mut tui::Tui) -> Result<()> { + let Some(mut rx) = self.active_thread_rx.take() else { + return Ok(()); + }; + + let mut disconnected = false; + loop { + match rx.try_recv() { + Ok(event) => self.handle_thread_event_now(event), + Err(TryRecvError::Empty) => break, + Err(TryRecvError::Disconnected) => { + disconnected = true; + break; + } + } + } + + if !disconnected { + self.active_thread_rx = Some(rx); + } else { + self.clear_active_thread().await; + } + + if self.backtrack_render_pending { + tui.frame_requester().schedule_frame(); + } + Ok(()) + } + + /// Returns `(closed_thread_id, primary_thread_id)` when a non-primary active + /// thread has died and we should fail over to the primary thread. + /// + /// A user-requested shutdown (`ExitMode::ShutdownFirst`) sets + /// `pending_shutdown_exit_thread_id`; matching shutdown completions are ignored + /// here so Ctrl+C-like exits don't accidentally resurrect the main thread. + /// + /// Failover is only eligible when all of these are true: + /// 1. the event is `thread/closed`; + /// 2. the active thread differs from the primary thread; + /// 3. the active thread is not the pending shutdown-exit thread. + pub(super) fn active_non_primary_shutdown_target( + &self, + notification: &ServerNotification, + ) -> Option<(ThreadId, ThreadId)> { + if !matches!(notification, ServerNotification::ThreadClosed(_)) { + return None; + } + let active_thread_id = self.active_thread_id?; + let primary_thread_id = self.primary_thread_id?; + if self.pending_shutdown_exit_thread_id == Some(active_thread_id) { + return None; + } + (active_thread_id != primary_thread_id).then_some((active_thread_id, primary_thread_id)) + } + + pub(super) fn replay_thread_snapshot( + &mut self, + snapshot: ThreadEventSnapshot, + resume_restored_queue: bool, + ) { + let suppress_replay_notices = + replay_filter::snapshot_has_pending_interactive_request(&snapshot); + if let Some(session) = snapshot.session { + if self.side_threads.contains_key(&session.thread_id) { + self.chat_widget.handle_side_thread_session(session); + } else if suppress_replay_notices { + self.chat_widget.handle_thread_session_quiet(session); + } else { + self.chat_widget.handle_thread_session(session); + } + } + self.chat_widget + .set_queue_autosend_suppressed(/*suppressed*/ true); + self.chat_widget + .restore_thread_input_state(snapshot.input_state); + if !snapshot.turns.is_empty() { + self.chat_widget + .replay_thread_turns(snapshot.turns, ReplayKind::ThreadSnapshot); + } + for event in snapshot.events { + if suppress_replay_notices && replay_filter::event_is_notice(&event) { + continue; + } + self.handle_thread_event_replay(event); + } + self.chat_widget + .set_queue_autosend_suppressed(/*suppressed*/ false); + self.chat_widget + .set_initial_user_message_submit_suppressed(/*suppressed*/ false); + self.chat_widget.submit_initial_user_message_if_pending(); + if resume_restored_queue { + self.chat_widget.maybe_send_next_queued_input(); + } + self.refresh_status_line(); + } + + pub(super) fn should_wait_for_initial_session(session_selection: &SessionSelection) -> bool { + matches!( + session_selection, + SessionSelection::StartFresh | SessionSelection::Exit + ) + } + + pub(super) fn should_handle_active_thread_events( + waiting_for_initial_session_configured: bool, + has_active_thread_receiver: bool, + ) -> bool { + has_active_thread_receiver && !waiting_for_initial_session_configured + } + + pub(super) fn should_stop_waiting_for_initial_session( + waiting_for_initial_session_configured: bool, + primary_thread_id: Option, + ) -> bool { + waiting_for_initial_session_configured && primary_thread_id.is_some() + } + + #[allow(clippy::too_many_arguments)] + pub(super) fn handle_skills_list_response(&mut self, response: SkillsListResponse) { + let response = list_skills_response_to_core(response); + let cwd = self.chat_widget.config_ref().cwd.clone(); + let errors = errors_for_cwd(&cwd, &response); + emit_skill_load_warnings(&self.app_event_tx, &errors); + self.chat_widget.handle_skills_list_response(response); + } + + pub(super) async fn handle_thread_rollback_response( + &mut self, + thread_id: ThreadId, + num_turns: u32, + response: &ThreadRollbackResponse, + ) { + if let Some(channel) = self.thread_event_channels.get(&thread_id) { + let mut store = channel.store.lock().await; + store.apply_thread_rollback(response); + } + if self.active_thread_id == Some(thread_id) + && let Some(mut rx) = self.active_thread_rx.take() + { + let mut disconnected = false; + loop { + match rx.try_recv() { + Ok(_) => {} + Err(TryRecvError::Empty) => break, + Err(TryRecvError::Disconnected) => { + disconnected = true; + break; + } + } + } + + if !disconnected { + self.active_thread_rx = Some(rx); + } else { + self.clear_active_thread().await; + } + } + self.handle_backtrack_rollback_succeeded(num_turns); + } + + pub(super) fn handle_thread_event_now(&mut self, event: ThreadBufferedEvent) { + let needs_refresh = matches!( + &event, + ThreadBufferedEvent::Notification(ServerNotification::TurnStarted(_)) + | ThreadBufferedEvent::Notification(ServerNotification::ThreadTokenUsageUpdated(_)) + ); + match event { + ThreadBufferedEvent::Notification(notification) => { + self.chat_widget + .handle_server_notification(notification, /*replay_kind*/ None); + } + ThreadBufferedEvent::Request(request) => { + if self + .pending_app_server_requests + .contains_server_request(&request) + { + self.chat_widget + .handle_server_request(request, /*replay_kind*/ None); + } + } + ThreadBufferedEvent::HistoryEntryResponse(event) => { + self.chat_widget.handle_history_entry_response(event); + } + ThreadBufferedEvent::FeedbackSubmission(event) => { + self.handle_feedback_thread_event(event); + } + } + if needs_refresh { + self.refresh_status_line(); + } + } + + pub(super) fn handle_thread_event_replay(&mut self, event: ThreadBufferedEvent) { + match event { + ThreadBufferedEvent::Notification(notification) => self + .chat_widget + .handle_server_notification(notification, Some(ReplayKind::ThreadSnapshot)), + ThreadBufferedEvent::Request(request) => self + .chat_widget + .handle_server_request(request, Some(ReplayKind::ThreadSnapshot)), + ThreadBufferedEvent::HistoryEntryResponse(event) => { + self.chat_widget.handle_history_entry_response(event) + } + ThreadBufferedEvent::FeedbackSubmission(event) => { + self.handle_feedback_thread_event(event); + } + } + } + + /// Handles an event emitted by the currently active thread. + /// + /// This function enforces shutdown intent routing: unexpected non-primary + /// thread shutdowns fail over to the primary thread, while user-requested + /// app exits consume only the tracked shutdown completion and then proceed. + pub(super) async fn handle_active_thread_event( + &mut self, + tui: &mut tui::Tui, + app_server: &mut AppServerSession, + event: ThreadBufferedEvent, + ) -> Result<()> { + // Capture this before any potential thread switch: we only want to clear + // the exit marker when the currently active thread acknowledges shutdown. + let pending_shutdown_exit_completed = matches!( + &event, + ThreadBufferedEvent::Notification(ServerNotification::ThreadClosed(_)) + ) && self.pending_shutdown_exit_thread_id + == self.active_thread_id; + + // Processing order matters: + // + // 1. handle unexpected non-primary shutdown failover first; + // 2. clear pending exit marker for matching shutdown; + // 3. forward the event through normal handling. + // + // This preserves the mental model that user-requested exits do not trigger + // failover, while true sub-agent deaths still do. + if let ThreadBufferedEvent::Notification(notification) = &event + && let Some((closed_thread_id, primary_thread_id)) = + self.active_non_primary_shutdown_target(notification) + { + self.mark_agent_picker_thread_closed(closed_thread_id); + if self.side_threads.contains_key(&closed_thread_id) { + self.discard_closed_side_thread(closed_thread_id).await; + self.select_agent_thread(tui, app_server, primary_thread_id) + .await?; + } else { + self.select_agent_thread_and_discard_side(tui, app_server, primary_thread_id) + .await?; + } + if self.active_thread_id == Some(primary_thread_id) { + self.chat_widget.add_info_message( + format!( + "Agent thread {closed_thread_id} closed. Switched back to main thread." + ), + /*hint*/ None, + ); + } else { + self.clear_active_thread().await; + self.chat_widget.add_error_message(format!( + "Agent thread {closed_thread_id} closed. Failed to switch back to main thread {primary_thread_id}.", + )); + } + return Ok(()); + } + + if pending_shutdown_exit_completed { + // Clear only after seeing the shutdown completion for the tracked + // thread, so unrelated shutdowns cannot consume this marker. + self.pending_shutdown_exit_thread_id = None; + } + if let ThreadBufferedEvent::Notification(notification) = &event { + self.hydrate_collab_agent_metadata_for_notification(app_server, notification) + .await; + } + + self.handle_thread_event_now(event); + if self.backtrack_render_pending { + tui.frame_requester().schedule_frame(); + } + Ok(()) + } +} diff --git a/codex-rs/tui/src/app/thread_session_state.rs b/codex-rs/tui/src/app/thread_session_state.rs new file mode 100644 index 0000000000..a8fd34769e --- /dev/null +++ b/codex-rs/tui/src/app/thread_session_state.rs @@ -0,0 +1,52 @@ +use super::App; +use crate::app_server_session::ThreadSessionState; +use crate::read_session_model; +use codex_app_server_protocol::Thread; +use codex_protocol::ThreadId; + +impl App { + pub(super) async fn session_state_for_thread_read( + &self, + thread_id: ThreadId, + thread: &Thread, + ) -> ThreadSessionState { + let mut session = self + .primary_session_configured + .clone() + .unwrap_or(ThreadSessionState { + thread_id, + forked_from_id: None, + fork_parent_title: None, + thread_name: None, + model: self.chat_widget.current_model().to_string(), + model_provider_id: self.config.model_provider_id.clone(), + service_tier: self.chat_widget.current_service_tier(), + approval_policy: self.config.permissions.approval_policy.value(), + approvals_reviewer: self.config.approvals_reviewer, + sandbox_policy: self.config.permissions.sandbox_policy.get().clone(), + cwd: thread.cwd.clone(), + instruction_source_paths: Vec::new(), + reasoning_effort: self.chat_widget.current_reasoning_effort(), + history_log_id: 0, + history_entry_count: 0, + network_proxy: None, + rollout_path: thread.path.clone(), + }); + session.thread_id = thread_id; + session.thread_name = thread.name.clone(); + session.model_provider_id = thread.model_provider.clone(); + session.cwd = thread.cwd.clone(); + session.instruction_source_paths = Vec::new(); + session.rollout_path = thread.path.clone(); + if let Some(model) = + read_session_model(&self.config, thread_id, thread.path.as_deref()).await + { + session.model = model; + } else if thread.path.is_some() { + session.model.clear(); + } + session.history_log_id = 0; + session.history_entry_count = 0; + session + } +} diff --git a/codex-rs/tui/src/app_backtrack.rs b/codex-rs/tui/src/app_backtrack.rs index 2852fbc379..cc99a791df 100644 --- a/codex-rs/tui/src/app_backtrack.rs +++ b/codex-rs/tui/src/app_backtrack.rs @@ -482,6 +482,8 @@ impl App { if !trim_transcript_cells_drop_last_n_user_turns(&mut self.transcript_cells, num_turns) { return false; } + self.chat_widget + .truncate_agent_copy_history_to_user_turn_count(user_count(&self.transcript_cells)); self.sync_overlay_after_transcript_trim(); self.backtrack_render_pending = true; true @@ -503,6 +505,8 @@ impl App { &mut self.transcript_cells, pending.selection.nth_user_message, ) { + self.chat_widget + .truncate_agent_copy_history_to_user_turn_count(user_count(&self.transcript_cells)); self.sync_overlay_after_transcript_trim(); self.backtrack_render_pending = true; } diff --git a/codex-rs/tui/src/app_server_approval_conversions.rs b/codex-rs/tui/src/app_server_approval_conversions.rs index 7b8e777d5b..a26f9b2a90 100644 --- a/codex-rs/tui/src/app_server_approval_conversions.rs +++ b/codex-rs/tui/src/app_server_approval_conversions.rs @@ -92,6 +92,7 @@ mod tests { file_system: Some(codex_app_server_protocol::AdditionalFileSystemPermissions { read: Some(vec![absolute_path("/tmp/read-only")]), write: Some(vec![absolute_path("/tmp/write")]), + glob_scan_max_depth: None, entries: None, }), } @@ -109,6 +110,7 @@ mod tests { }, access: FileSystemAccessMode::Write, }], + glob_scan_max_depth: None, }), ..Default::default() }), @@ -117,6 +119,7 @@ mod tests { file_system: Some(codex_app_server_protocol::AdditionalFileSystemPermissions { read: None, write: None, + glob_scan_max_depth: None, entries: Some(vec![codex_app_server_protocol::FileSystemSandboxEntry { path: codex_app_server_protocol::FileSystemPath::Special { value: codex_app_server_protocol::FileSystemSpecialPath::Root, diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs index b223ab493b..4d8e213ef7 100644 --- a/codex-rs/tui/src/app_server_session.rs +++ b/codex-rs/tui/src/app_server_session.rs @@ -138,6 +138,7 @@ pub(crate) struct AppServerSession { pub(crate) struct ThreadSessionState { pub(crate) thread_id: ThreadId, pub(crate) forked_from_id: Option, + pub(crate) fork_parent_title: Option, pub(crate) thread_name: Option, pub(crate) model: String, pub(crate) model_provider_id: String, @@ -369,7 +370,12 @@ impl AppServerSession { }) .await .wrap_err("thread/resume failed during TUI bootstrap")?; - started_thread_from_resume_response(response, &config).await + let fork_parent_title = self + .fork_parent_title_from_app_server(response.thread.forked_from_id.as_deref()) + .await; + let mut started = started_thread_from_resume_response(response, &config).await?; + started.session.fork_parent_title = fork_parent_title; + Ok(started) } pub(crate) async fn fork_thread( @@ -391,7 +397,12 @@ impl AppServerSession { }) .await .wrap_err("thread/fork failed during TUI bootstrap")?; - started_thread_from_fork_response(response, &config).await + let fork_parent_title = self + .fork_parent_title_from_app_server(response.thread.forked_from_id.as_deref()) + .await; + let mut started = started_thread_from_fork_response(response, &config).await?; + started.session.fork_parent_title = fork_parent_title; + Ok(started) } fn thread_params_mode(&self) -> ThreadParamsMode { @@ -401,6 +412,31 @@ impl AppServerSession { } } + async fn fork_parent_title_from_app_server( + &mut self, + forked_from_id: Option<&str>, + ) -> Option { + let forked_from_id = forked_from_id?; + let forked_from_id = match ThreadId::from_string(forked_from_id) { + Ok(thread_id) => thread_id, + Err(err) => { + tracing::warn!("Failed to parse fork parent thread id from app server: {err}"); + return None; + } + }; + + match self + .thread_read(forked_from_id, /*include_turns*/ false) + .await + { + Ok(thread) => thread.name, + Err(err) => { + tracing::warn!("Failed to read fork parent metadata from app server: {err}"); + None + } + } + } + pub(crate) async fn thread_list( &mut self, params: ThreadListParams, @@ -1204,6 +1240,7 @@ async fn thread_session_state_from_thread_response( Ok(ThreadSessionState { thread_id, forked_from_id, + fork_parent_title: None, thread_name, model, model_provider_id, diff --git a/codex-rs/tui/src/bottom_pane/approval_overlay.rs b/codex-rs/tui/src/bottom_pane/approval_overlay.rs index 1c148cd02a..5212d81953 100644 --- a/codex-rs/tui/src/bottom_pane/approval_overlay.rs +++ b/codex-rs/tui/src/bottom_pane/approval_overlay.rs @@ -1372,6 +1372,7 @@ mod tests { access: FileSystemAccessMode::None, }, ], + glob_scan_max_depth: None, }), ..Default::default() }; diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rs index 470afbdab4..a529d169c4 100644 --- a/codex-rs/tui/src/bottom_pane/chat_composer.rs +++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs @@ -206,6 +206,7 @@ use crate::bottom_pane::textarea::TextAreaState; use crate::clipboard_paste::normalize_pasted_path; use crate::clipboard_paste::pasted_image_format; use crate::history_cell; +use crate::skills_helpers::skill_display_name; use crate::tui::FrameRequester; use crate::ui_consts::LIVE_PREFIX_COLS; use codex_app_server_protocol::AppInfo; @@ -224,6 +225,10 @@ use std::ops::Range; use std::path::PathBuf; use std::time::Duration; use std::time::Instant; + +#[cfg(test)] +use ratatui::style::Color; + /// If the pasted content exceeds this number of characters, replace it with a /// placeholder in the UI. const LARGE_PASTE_CHAR_THRESHOLD: usize = 1000; @@ -314,6 +319,7 @@ impl ChatComposerConfig { pub(crate) struct ChatComposer { textarea: TextArea, textarea_state: RefCell, + is_bash_mode: bool, active_popup: ActivePopup, app_event_tx: AppEventSender, history: ChatComposerHistory, @@ -470,6 +476,7 @@ impl ChatComposer { let mut this = Self { textarea: TextArea::new(), textarea_state: RefCell::new(TextAreaState::default()), + is_bash_mode: false, active_popup: ActivePopup::None, app_event_tx, history: ChatComposerHistory::new(), @@ -709,6 +716,7 @@ impl ChatComposer { /// Returns true if the composer currently contains no user-entered input. pub(crate) fn is_empty(&self) -> bool { self.textarea.is_empty() + && !self.is_bash_mode && self.attached_images.is_empty() && self.remote_image_urls.is_empty() } @@ -846,6 +854,7 @@ impl ChatComposer { /// remote images). Cursor is placed at the end after rebuilding elements. pub(crate) fn apply_external_edit(&mut self, text: String) { self.pending_pastes.clear(); + let (text, _) = self.imported_text_for_textarea(text, Vec::new()); // Count placeholder occurrences in the new text. let mut placeholder_counts: HashMap = HashMap::new(); @@ -913,7 +922,7 @@ impl ChatComposer { } pub(crate) fn current_text_with_pending(&self) -> String { - let mut text = self.textarea.text().to_string(); + let mut text = self.current_text(); for (placeholder, actual) in &self.pending_pastes { if text.contains(placeholder) { text = text.replace(placeholder, actual); @@ -927,7 +936,7 @@ impl ChatComposer { } pub(crate) fn set_pending_pastes(&mut self, pending_pastes: Vec<(String, String)>) { - let text = self.textarea.text().to_string(); + let text = self.current_text(); self.pending_pastes = pending_pastes .into_iter() .filter(|(placeholder, _)| text.contains(placeholder)) @@ -1014,10 +1023,12 @@ impl ChatComposer { ) { // Clear any existing content, placeholders, and attachments first. self.textarea.set_text_clearing_elements(""); + self.is_bash_mode = false; self.pending_pastes.clear(); self.attached_images.clear(); self.mention_bindings.clear(); + let (text, text_elements) = self.imported_text_for_textarea(text, text_elements); self.textarea.set_text_with_elements(&text, &text_elements); for (idx, path) in local_image_paths.into_iter().enumerate() { @@ -1033,10 +1044,51 @@ impl ChatComposer { self.sync_popups(); } + fn current_cursor(&self) -> usize { + self.textarea.cursor() + if self.is_bash_mode { 1 } else { 0 } + } + + fn history_navigation_cursor(&self) -> usize { + if self.is_bash_mode && self.textarea.cursor() == 0 { + 0 + } else { + self.current_cursor() + } + } + + fn set_current_cursor(&mut self, cursor: usize) { + let visible_cursor = if self.is_bash_mode { + cursor.saturating_sub(1) + } else { + cursor + }; + self.textarea + .set_cursor(visible_cursor.min(self.textarea.text().len())); + } + + fn current_text_elements(&self) -> Vec { + let shift = if self.is_bash_mode { 1 } else { 0 }; + self.textarea + .text_elements() + .into_iter() + .filter_map(|element| Self::shift_text_element(element, shift)) + .collect() + } + + fn shift_text_element(element: TextElement, shift: isize) -> Option { + let start = element.byte_range.start.checked_add_signed(shift)?; + let end = element.byte_range.end.checked_add_signed(shift)?; + if start >= end { + return None; + } + + Some(element.map_range(|_| (start..end).into())) + } + fn snapshot_draft(&self) -> ComposerDraft { ComposerDraft { - text: self.textarea.text().to_string(), - text_elements: self.textarea.text_elements(), + text: self.current_text(), + text_elements: self.current_text_elements(), local_image_paths: self .attached_images .iter() @@ -1045,7 +1097,7 @@ impl ChatComposer { remote_image_urls: self.remote_image_urls.clone(), mention_bindings: self.snapshot_mention_bindings(), pending_pastes: self.pending_pastes.clone(), - cursor: self.textarea.cursor(), + cursor: self.current_cursor(), } } @@ -1067,8 +1119,7 @@ impl ChatComposer { mention_bindings, ); self.set_pending_pastes(pending_pastes); - self.textarea - .set_cursor(cursor.min(self.textarea.text().len())); + self.set_current_cursor(cursor); self.sync_popups(); } @@ -1083,12 +1134,36 @@ impl ChatComposer { self.sync_popups(); } + /// Convert canonical composer text into the textarea's internal representation. + /// + /// Bash mode stores the leading `!` as prompt state instead of editable text, + /// so full-buffer imports must absorb that prefix before rebuilding the textarea. + fn imported_text_for_textarea( + &mut self, + text: String, + text_elements: Vec, + ) -> (String, Vec) { + if let Some(stripped) = text.strip_prefix('!') { + self.is_bash_mode = true; + ( + stripped.to_string(), + text_elements + .into_iter() + .filter_map(|element| Self::shift_text_element(element, /*shift*/ -1)) + .collect(), + ) + } else { + self.is_bash_mode = false; + (text, text_elements) + } + } + pub(crate) fn clear_for_ctrl_c(&mut self) -> Option { if self.is_empty() { return None; } let previous = self.current_text(); - let text_elements = self.textarea.text_elements(); + let text_elements = self.current_text_elements(); let local_image_paths = self .attached_images .iter() @@ -1114,7 +1189,11 @@ impl ChatComposer { /// Get the current composer text. pub(crate) fn current_text(&self) -> String { - self.textarea.text().to_string() + if self.is_bash_mode { + format!("!{}", self.textarea.text()) + } else { + self.textarea.text().to_string() + } } /// Rehydrate a history entry into the composer with shell-like cursor placement. @@ -1145,7 +1224,7 @@ impl ChatComposer { } pub(crate) fn text_elements(&self) -> Vec { - self.textarea.text_elements() + self.current_text_elements() } #[cfg(test)] @@ -1324,6 +1403,7 @@ impl ChatComposer { pub(crate) fn insert_str(&mut self, text: &str) { self.textarea.insert_str(text); + self.sync_bash_mode_from_text(); self.sync_popups(); } @@ -1425,6 +1505,7 @@ impl ChatComposer { if cmd == SlashCommand::Skills { self.stage_selected_slash_command_history(cmd); self.textarea.set_text_clearing_elements(""); + self.is_bash_mode = false; return (InputResult::Command(cmd), true); } @@ -1465,6 +1546,7 @@ impl ChatComposer { if !starts_with_cmd { self.textarea .set_text_clearing_elements(&format!("/{} ", cmd.command())); + self.is_bash_mode = false; } if !self.textarea.text().is_empty() { self.textarea.set_cursor(self.textarea.text().len()); @@ -1481,6 +1563,7 @@ impl ChatComposer { let CommandItem::Builtin(cmd) = sel; self.stage_selected_slash_command_history(cmd); self.textarea.set_text_clearing_elements(""); + self.is_bash_mode = false; return (InputResult::Command(cmd), true); } // Fallback to default newline handling if no command selected. @@ -2240,9 +2323,9 @@ impl ChatComposer { record_history: bool, slash_validation: SlashValidation, ) -> Option<(String, Vec)> { - let mut text = self.textarea.text().to_string(); + let mut text = self.current_text(); let original_input = text.clone(); - let original_text_elements = self.textarea.text_elements(); + let original_text_elements = self.current_text_elements(); let original_mention_bindings = self.snapshot_mention_bindings(); let original_local_image_paths = self .attached_images @@ -2254,6 +2337,7 @@ impl ChatComposer { let input_starts_with_space = original_input.starts_with(' '); self.recent_submission_mention_bindings.clear(); self.textarea.set_text_clearing_elements(""); + self.is_bash_mode = false; if !self.pending_pastes.is_empty() { // Expand placeholders so element byte ranges stay aligned. @@ -2393,6 +2477,7 @@ impl ChatComposer { // and accumulate it rather than submitting or inserting immediately. // Do not treat as paste inside a slash-command context. let in_slash_context = self.slash_commands_enabled() + && !self.is_bash_mode && (matches!(self.active_popup, ActivePopup::Command(_)) || self .textarea @@ -2421,8 +2506,8 @@ impl ChatComposer { return (InputResult::None, true); } - let original_input = self.textarea.text().to_string(); - let original_text_elements = self.textarea.text_elements(); + let original_input = self.current_text(); + let original_text_elements = self.current_text_elements(); let original_mention_bindings = self.snapshot_mention_bindings(); let original_local_image_paths = self .attached_images @@ -2472,7 +2557,7 @@ impl ChatComposer { /// Check if the first line is a bare slash command (no args) and dispatch it. /// Returns Some(InputResult) if a command was dispatched, None otherwise. fn try_dispatch_bare_slash_command(&mut self) -> Option { - if !self.slash_commands_enabled() { + if !self.slash_commands_enabled() || self.is_bash_mode { return None; } let first_line = self.textarea.text().lines().next().unwrap_or(""); @@ -2488,6 +2573,7 @@ impl ChatComposer { } self.stage_slash_command_history(); self.textarea.set_text_clearing_elements(""); + self.is_bash_mode = false; Some(InputResult::Command(cmd)) } else { None @@ -2497,7 +2583,7 @@ impl ChatComposer { /// Check if the input is a slash command with args (e.g., /review args) and dispatch it. /// Returns Some(InputResult) if a command was dispatched, None otherwise. fn try_dispatch_slash_command_with_args(&mut self) -> Option { - if !self.slash_commands_enabled() { + if !self.slash_commands_enabled() || self.is_bash_mode { return None; } let text = self.textarea.text().to_string(); @@ -2782,10 +2868,10 @@ impl ChatComposer { modifiers: KeyModifiers::CONTROL, .. } => { - if self - .history - .should_handle_navigation(self.textarea.text(), self.textarea.cursor()) - { + if self.history.should_handle_navigation( + &self.current_text(), + self.history_navigation_cursor(), + ) { let replace_entry = match key_event.code { KeyCode::Up => self.history.navigate_up(&self.app_event_tx), KeyCode::Down => self.history.navigate_down(&self.app_event_tx), @@ -2818,7 +2904,13 @@ impl ChatComposer { } fn is_bang_shell_command(&self) -> bool { - self.textarea.text().trim_start().starts_with('!') + self.current_text().trim_start().starts_with('!') + } + + fn shell_mode_footer_line(&self) -> Option> { + self.is_bang_shell_command() + .then_some(()) + .map(|_| Line::from(vec![Span::from("Bash mode").light_red()])) } /// Applies any due `PasteBurst` flush at time `now`. @@ -2836,8 +2928,7 @@ impl ChatComposer { true } FlushResult::Typed(ch) => { - self.textarea.insert_str(ch.to_string().as_str()); - self.sync_popups(); + self.insert_str(ch.to_string().as_str()); true } FlushResult::None => false, @@ -2971,7 +3062,16 @@ impl ChatComposer { Some(self.textarea.element_payloads()) }; + if self.is_bash_mode + && matches!(input.code, KeyCode::Backspace) + && self.textarea.cursor() == 0 + { + self.is_bash_mode = false; + return (InputResult::None, true); + } + self.textarea.input(input); + self.sync_bash_mode_from_text(); if let Some(elements_before) = elements_before { self.reconcile_deleted_elements(elements_before); @@ -3000,6 +3100,13 @@ impl ChatComposer { (InputResult::None, true) } + fn sync_bash_mode_from_text(&mut self) { + if !self.is_bash_mode && self.textarea.text().starts_with('!') { + self.textarea.replace_range(0..1, ""); + self.is_bash_mode = true; + } + } + fn reconcile_deleted_elements(&mut self, elements_before: Vec) { let elements_after: HashSet = self.textarea.element_payloads().into_iter().collect(); @@ -3155,7 +3262,7 @@ impl ChatComposer { let file_token = Self::current_at_token(&self.textarea); let browsing_history = self .history - .should_handle_navigation(self.textarea.text(), self.textarea.cursor()); + .should_handle_navigation(&self.current_text(), self.history_navigation_cursor()); // When browsing input history (shell-style Up/Down recall), skip all popup // synchronization so nothing steals focus from continued history navigation. if browsing_history { @@ -3169,8 +3276,10 @@ impl ChatComposer { } let mention_token = self.current_mention_token(); - let allow_command_popup = - self.slash_commands_enabled() && file_token.is_none() && mention_token.is_none(); + let allow_command_popup = self.slash_commands_enabled() + && !self.is_bash_mode + && file_token.is_none() + && mention_token.is_none(); self.sync_command_popup(allow_command_popup); if matches!(self.active_popup, ActivePopup::Command(_)) { @@ -3254,6 +3363,9 @@ impl ChatComposer { } fn slash_command_element_range(&self, first_line: &str) -> Option> { + if self.is_bash_mode { + return None; + } let (name, _rest, _rest_offset) = parse_slash_name(first_line)?; if name.contains('/') { return None; @@ -3455,7 +3567,7 @@ impl ChatComposer { let mut mentions = Vec::new(); if let Some(skills) = self.skills.as_ref() { for skill in skills { - let display_name = skill_display_name(skill).to_string(); + let display_name = skill_display_name(skill); let description = skill_description(skill); let skill_name = skill.name.clone(); let search_terms = if display_name == skill.name { @@ -3659,14 +3771,6 @@ impl ChatComposer { } } -fn skill_display_name(skill: &SkillMetadata) -> &str { - skill - .interface - .as_ref() - .and_then(|interface| interface.display_name.as_deref()) - .unwrap_or(&skill.name) -} - fn skill_description(skill: &SkillMetadata) -> Option { let description = skill .interface @@ -3863,6 +3967,8 @@ impl ChatComposer { self.side_conversation_context_label.as_ref() { Some(side_conversation_context_line(label)) + } else if let Some(line) = self.shell_mode_footer_line() { + Some(line) } else if status_line_active { let full = mode_indicator_line(self.collaboration_mode_indicator, show_cycle_hint); @@ -4034,7 +4140,13 @@ impl ChatComposer { } if !textarea_rect.is_empty() { let prompt = if self.input_enabled { - if is_zellij { + if self.is_bash_mode { + if is_zellij { + Span::from("!").light_red() + } else { + Span::from("!").light_red().bold() + } + } else if is_zellij { Span::styled("›", style.fg(ratatui::style::Color::Cyan)) } else { "›".bold() @@ -4053,7 +4165,7 @@ impl ChatComposer { } let mut state = self.textarea_state.borrow_mut(); - let textarea_is_empty = self.textarea.text().is_empty(); + let textarea_is_empty = self.textarea.text().is_empty() && !self.is_bash_mode; if let Some(mask_char) = mask_char { self.textarea.render_ref_masked( textarea_rect, @@ -4482,6 +4594,78 @@ mod tests { .handle_key_event(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)); }, ); + + snapshot_composer_state( + "footer_mode_shell_command_absorbs_bang", + /*enhanced_keys_supported*/ true, + |composer| { + composer.set_status_line_enabled(/*enabled*/ true); + composer.set_status_line(Some(Line::from( + "gpt-5.4 high fast · ~/code/codex-1 · Context 0% used", + ))); + composer.set_text_content("!git status".to_string(), Vec::new(), Vec::new()); + }, + ); + } + + #[test] + fn shell_command_cursor_uses_absorbed_prefix() { + let (tx, _rx) = unbounded_channel::(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new( + /*has_input_focus*/ true, + sender, + /*enhanced_keys_supported*/ true, + "Ask Codex to do anything".to_string(), + /*disable_paste_burst*/ false, + ); + let area = Rect::new(0, 0, 40, 5); + + composer.set_text_content("!git".to_string(), Vec::new(), Vec::new()); + composer.move_cursor_to_end(); + assert_eq!(composer.cursor_pos(area), Some((5, 1))); + + composer.set_text_content("! git".to_string(), Vec::new(), Vec::new()); + composer.move_cursor_to_end(); + assert_eq!(composer.cursor_pos(area), Some((6, 1))); + } + + #[test] + fn shell_command_uses_bash_accent_style() { + let (tx, _rx) = unbounded_channel::(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new( + /*has_input_focus*/ true, + sender, + /*enhanced_keys_supported*/ true, + "Ask Codex to do anything".to_string(), + /*disable_paste_burst*/ false, + ); + composer.set_status_line_enabled(/*enabled*/ true); + composer.set_status_line(Some(Line::from( + "gpt-5.4 high fast · ~/code/codex-1 · Context 0% used", + ))); + composer.set_text_content("!git status".to_string(), Vec::new(), Vec::new()); + + let area = Rect::new(0, 0, 100, 9); + let mut buf = Buffer::empty(area); + composer.render(area, &mut buf); + + let prompt_cell = &buf[(0, 1)]; + assert_eq!(prompt_cell.symbol(), "!"); + assert_eq!(prompt_cell.style().fg, Some(Color::LightRed)); + + let footer_y = area.height - 1; + let footer_text = (0..area.width) + .map(|x| buf[(x, footer_y)].symbol().chars().next().unwrap_or(' ')) + .collect::(); + let bash_label_x = footer_text + .find("Bash mode") + .expect("expected bash mode footer label"); + assert_eq!( + buf[(bash_label_x as u16, footer_y)].style().fg, + Some(Color::LightRed) + ); } #[test] @@ -7033,11 +7217,38 @@ mod tests { assert!(matches!(result, InputResult::None)); assert!( - composer.textarea.text().starts_with("!ls"), + composer.current_text().starts_with("!ls"), "expected Tab not to submit or clear a `!` command" ); } + #[test] + fn bang_prefixed_slash_text_submits_literal_shell_command() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let (tx, _rx) = unbounded_channel::(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new( + /*has_input_focus*/ true, + sender, + /*enhanced_keys_supported*/ false, + "Ask Codex to do anything".to_string(), + /*disable_paste_burst*/ false, + ); + + type_chars_humanlike(&mut composer, &['!', '/', 'd', 'i', 'f', 'f']); + + let (result, _needs_redraw) = + composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + + assert!(matches!( + result, + InputResult::Submitted { ref text, .. } if text == "!/diff" + )); + } + #[test] fn slash_mention_dispatches_command_and_inserts_at() { use crossterm::event::KeyCode; @@ -7639,6 +7850,42 @@ mod tests { assert_eq!(composer.textarea.cursor(), composer.textarea.text().len()); } + #[test] + fn history_navigation_from_start_of_bang_command_recalls_older_entry() { + use crossterm::event::KeyCode; + use crossterm::event::KeyEvent; + use crossterm::event::KeyModifiers; + + let (tx, _rx) = unbounded_channel::(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new( + /*has_input_focus*/ true, + sender, + /*enhanced_keys_supported*/ false, + "Ask Codex to do anything".to_string(), + /*disable_paste_burst*/ false, + ); + + type_chars_humanlike(&mut composer, &['f', 'i', 'r', 's', 't']); + let (result, _needs_redraw) = + composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + assert!(matches!(result, InputResult::Submitted { .. })); + + type_chars_humanlike(&mut composer, &['!', 'g', 'i', 't']); + let (result, _needs_redraw) = + composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)); + assert!(matches!(result, InputResult::Submitted { .. })); + + let (_result, _needs_redraw) = + composer.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)); + assert_eq!(composer.current_text(), "!git"); + + composer.textarea.set_cursor(/*pos*/ 0); + let (_result, _needs_redraw) = + composer.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE)); + assert_eq!(composer.current_text(), "first"); + } + #[test] fn set_text_content_reattaches_images_without_placeholder_metadata() { let (tx, _rx) = unbounded_channel::(); @@ -8559,6 +8806,66 @@ mod tests { assert_eq!(composer.textarea.cursor(), composer.current_text().len()); } + #[test] + fn apply_external_edit_absorbs_bash_prefix_without_duplication() { + let (tx, _rx) = unbounded_channel::(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new( + /*has_input_focus*/ true, + sender, + /*enhanced_keys_supported*/ false, + "Ask Codex to do anything".to_string(), + /*disable_paste_burst*/ false, + ); + composer.set_text_content("!git status".to_string(), Vec::new(), Vec::new()); + + composer.apply_external_edit("!git status".to_string()); + + assert!(composer.is_bash_mode); + assert_eq!(composer.textarea.text(), "git status"); + assert_eq!(composer.current_text(), "!git status"); + } + + #[test] + fn apply_external_edit_can_leave_bash_mode() { + let (tx, _rx) = unbounded_channel::(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new( + /*has_input_focus*/ true, + sender, + /*enhanced_keys_supported*/ false, + "Ask Codex to do anything".to_string(), + /*disable_paste_burst*/ false, + ); + composer.set_text_content("!git status".to_string(), Vec::new(), Vec::new()); + + composer.apply_external_edit("git status".to_string()); + + assert!(!composer.is_bash_mode); + assert_eq!(composer.textarea.text(), "git status"); + assert_eq!(composer.current_text(), "git status"); + } + + #[test] + fn apply_external_edit_can_enter_bash_mode() { + let (tx, _rx) = unbounded_channel::(); + let sender = AppEventSender::new(tx); + let mut composer = ChatComposer::new( + /*has_input_focus*/ true, + sender, + /*enhanced_keys_supported*/ false, + "Ask Codex to do anything".to_string(), + /*disable_paste_burst*/ false, + ); + composer.set_text_content("git status".to_string(), Vec::new(), Vec::new()); + + composer.apply_external_edit("!git status".to_string()); + + assert!(composer.is_bash_mode); + assert_eq!(composer.textarea.text(), "git status"); + assert_eq!(composer.current_text(), "!git status"); + } + #[test] fn apply_external_edit_drops_missing_attachments() { let (tx, _rx) = unbounded_channel::(); diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rs index b62ce7cc10..c9dc4db263 100644 --- a/codex-rs/tui/src/bottom_pane/mod.rs +++ b/codex-rs/tui/src/bottom_pane/mod.rs @@ -49,6 +49,7 @@ mod mcp_server_elicitation; mod multi_select_picker; mod request_user_input; mod status_line_setup; +mod status_surface_preview; mod title_setup; pub(crate) use app_link_view::AppLinkElicitationTarget; pub(crate) use app_link_view::AppLinkSuggestionType; @@ -107,10 +108,13 @@ pub(crate) use feedback_view::feedback_upload_consent_params; pub(crate) use skills_toggle_view::SkillsToggleItem; pub(crate) use skills_toggle_view::SkillsToggleView; pub(crate) use status_line_setup::StatusLineItem; -pub(crate) use status_line_setup::StatusLinePreviewData; pub(crate) use status_line_setup::StatusLineSetupView; +pub(crate) use status_surface_preview::StatusSurfacePreviewData; +pub(crate) use status_surface_preview::StatusSurfacePreviewItem; pub(crate) use title_setup::TerminalTitleItem; pub(crate) use title_setup::TerminalTitleSetupView; +#[cfg(test)] +pub(crate) use title_setup::preview_line_for_title_items; mod paste_burst; mod pending_input_preview; mod pending_thread_approvals; diff --git a/codex-rs/tui/src/bottom_pane/skill_popup.rs b/codex-rs/tui/src/bottom_pane/skill_popup.rs index 836bad636c..a0d4278396 100644 --- a/codex-rs/tui/src/bottom_pane/skill_popup.rs +++ b/codex-rs/tui/src/bottom_pane/skill_popup.rs @@ -28,7 +28,7 @@ pub(crate) struct MentionItem { pub(crate) sort_rank: u8, } -const MENTION_NAME_TRUNCATE_LEN: usize = 24; +const MENTION_NAME_TRUNCATE_LEN: usize = 28; pub(crate) struct SkillPopup { query: String, diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__footer_mode_shell_command_absorbs_bang.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__footer_mode_shell_command_absorbs_bang.snap new file mode 100644 index 0000000000..2b44670df0 --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__chat_composer__tests__footer_mode_shell_command_absorbs_bang.snap @@ -0,0 +1,13 @@ +--- +source: tui/src/bottom_pane/chat_composer.rs +expression: terminal.backend() +--- +" " +"! git status " +" " +" " +" " +" " +" " +" " +" gpt-5.4 high fast · ~/code/codex-1 · Context 0% used Bash mode " diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__status_line_setup__tests__setup_view_snapshot_uses_runtime_preview_values.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__status_line_setup__tests__setup_view_snapshot_uses_runtime_preview_values.snap deleted file mode 100644 index 20aca1e334..0000000000 --- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__status_line_setup__tests__setup_view_snapshot_uses_runtime_preview_values.snap +++ /dev/null @@ -1,21 +0,0 @@ ---- -source: tui/src/bottom_pane/status_line_setup.rs -expression: "render_lines(&view, 72)" ---- - - Configure Status Line - Select which items to display in the status line. - - Type to search - > -› [x] model-name Current model name - [x] current-dir Current working directory - [x] git-branch Current Git branch (omitted when unavaila… - [ ] model-with-reasoning Current model name with reasoning level - [ ] project-root Project root directory (omitted when unav… - [ ] context-remaining Percentage of context window remaining (o… - [ ] context-used Percentage of context window used (omitte… - [ ] five-hour-limit Remaining usage on 5-hour usage limit (om… - - gpt-5-codex · ~/codex-rs · jif/statusline-preview - Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__title_setup__tests__terminal_title_setup_basic.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__title_setup__tests__terminal_title_setup_basic.snap deleted file mode 100644 index 9a6d412874..0000000000 --- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__title_setup__tests__terminal_title_setup_basic.snap +++ /dev/null @@ -1,21 +0,0 @@ ---- -source: tui/src/bottom_pane/title_setup.rs -expression: "render_lines(&view, 84)" ---- - - Configure Terminal Title - Select which items to display in the terminal title. - - Type to search - > -› [x] project Project name (falls back to current directory name) - [x] spinner Animated task spinner (omitted while idle or when animations… - [x] status Compact session status text (Ready, Working, Thinking) - [x] thread Current thread title (omitted until available) - [ ] app-name Codex app name - [ ] git-branch Current Git branch (omitted when unavailable) - [ ] model Current model name - [ ] task-progress Latest task progress from update_plan (omitted until availab… - - my-project ⠋ Working | Investigate flaky test - Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc to cancel. diff --git a/codex-rs/tui/src/bottom_pane/status_line_setup.rs b/codex-rs/tui/src/bottom_pane/status_line_setup.rs index 4c7e29c053..0ae5ddd9c1 100644 --- a/codex-rs/tui/src/bottom_pane/status_line_setup.rs +++ b/codex-rs/tui/src/bottom_pane/status_line_setup.rs @@ -19,8 +19,6 @@ use ratatui::buffer::Buffer; use ratatui::layout::Rect; -use ratatui::text::Line; -use std::collections::BTreeMap; use std::collections::HashSet; use strum::IntoEnumIterator; use strum_macros::Display; @@ -33,6 +31,8 @@ use crate::bottom_pane::CancellationEvent; use crate::bottom_pane::bottom_pane_view::BottomPaneView; use crate::bottom_pane::multi_select_picker::MultiSelectItem; use crate::bottom_pane::multi_select_picker::MultiSelectPicker; +use crate::bottom_pane::status_surface_preview::StatusSurfacePreviewData; +use crate::bottom_pane::status_surface_preview::StatusSurfacePreviewItem; use crate::render::renderable::Renderable; /// Available items that can be displayed in the status line. @@ -138,36 +138,26 @@ impl StatusLineItem { StatusLineItem::ThreadTitle => "Current thread title (omitted unless changed by user)", } } -} -/// Runtime values used to preview the current status-line selection. -#[derive(Clone, Debug, Default, Eq, PartialEq)] -pub(crate) struct StatusLinePreviewData { - values: BTreeMap, -} - -impl StatusLinePreviewData { - pub(crate) fn from_iter(values: I) -> Self - where - I: IntoIterator, - { - Self { - values: values.into_iter().collect(), - } - } - - fn line_for_items(&self, items: &[MultiSelectItem]) -> Option> { - let preview = items - .iter() - .filter(|item| item.enabled) - .filter_map(|item| item.id.parse::().ok()) - .filter_map(|item| self.values.get(&item).cloned()) - .collect::>() - .join(" · "); - if preview.is_empty() { - None - } else { - Some(Line::from(preview)) + pub(crate) fn preview_item(self) -> StatusSurfacePreviewItem { + match self { + StatusLineItem::ModelName => StatusSurfacePreviewItem::Model, + StatusLineItem::ModelWithReasoning => StatusSurfacePreviewItem::ModelWithReasoning, + StatusLineItem::CurrentDir => StatusSurfacePreviewItem::CurrentDir, + StatusLineItem::ProjectRoot => StatusSurfacePreviewItem::ProjectRoot, + StatusLineItem::GitBranch => StatusSurfacePreviewItem::GitBranch, + StatusLineItem::ContextRemaining => StatusSurfacePreviewItem::ContextRemaining, + StatusLineItem::ContextUsed => StatusSurfacePreviewItem::ContextUsed, + StatusLineItem::FiveHourLimit => StatusSurfacePreviewItem::FiveHourLimit, + StatusLineItem::WeeklyLimit => StatusSurfacePreviewItem::WeeklyLimit, + StatusLineItem::CodexVersion => StatusSurfacePreviewItem::CodexVersion, + StatusLineItem::ContextWindowSize => StatusSurfacePreviewItem::ContextWindowSize, + StatusLineItem::UsedTokens => StatusSurfacePreviewItem::UsedTokens, + StatusLineItem::TotalInputTokens => StatusSurfacePreviewItem::TotalInputTokens, + StatusLineItem::TotalOutputTokens => StatusSurfacePreviewItem::TotalOutputTokens, + StatusLineItem::SessionId => StatusSurfacePreviewItem::SessionId, + StatusLineItem::FastMode => StatusSurfacePreviewItem::FastMode, + StatusLineItem::ThreadTitle => StatusSurfacePreviewItem::ThreadTitle, } } } @@ -197,7 +187,7 @@ impl StatusLineSetupView { /// enabled. Remaining items are appended and marked as disabled. pub(crate) fn new( status_line_items: Option<&[String]>, - preview_data: StatusLinePreviewData, + preview_data: StatusSurfacePreviewData, app_event_tx: AppEventSender, ) -> Self { let mut used_ids = HashSet::new(); @@ -236,7 +226,15 @@ impl StatusLineSetupView { ]) .items(items) .enable_ordering() - .on_preview(move |items| preview_data.line_for_items(items)) + .on_preview(move |items| { + preview_data.line_for_items( + items + .iter() + .filter(|item| item.enabled) + .filter_map(|item| item.id.parse::().ok()) + .map(StatusLineItem::preview_item), + ) + }) .on_confirm(|ids, app_event| { let items = ids .iter() @@ -291,14 +289,7 @@ impl Renderable for StatusLineSetupView { #[cfg(test)] mod tests { use super::*; - use crate::app_event_sender::AppEventSender; - use insta::assert_snapshot; use pretty_assertions::assert_eq; - use ratatui::buffer::Buffer; - use ratatui::layout::Rect; - use tokio::sync::mpsc::unbounded_channel; - - use crate::app_event::AppEvent; #[test] fn context_used_accepts_context_usage_legacy_id() { @@ -324,130 +315,4 @@ mod tests { "context-remaining" ); } - - #[test] - fn preview_uses_runtime_values() { - let preview_data = StatusLinePreviewData::from_iter([ - (StatusLineItem::ModelName, "gpt-5".to_string()), - (StatusLineItem::CurrentDir, "/repo".to_string()), - ]); - let items = vec![ - MultiSelectItem { - id: StatusLineItem::ModelName.to_string(), - name: String::new(), - description: None, - enabled: true, - }, - MultiSelectItem { - id: StatusLineItem::CurrentDir.to_string(), - name: String::new(), - description: None, - enabled: true, - }, - ]; - - assert_eq!( - preview_data.line_for_items(&items), - Some(Line::from("gpt-5 · /repo")) - ); - } - - #[test] - fn preview_omits_items_without_runtime_values() { - let preview_data = - StatusLinePreviewData::from_iter([(StatusLineItem::ModelName, "gpt-5".to_string())]); - let items = vec![ - MultiSelectItem { - id: StatusLineItem::ModelName.to_string(), - name: String::new(), - description: None, - enabled: true, - }, - MultiSelectItem { - id: StatusLineItem::GitBranch.to_string(), - name: String::new(), - description: None, - enabled: true, - }, - ]; - - assert_eq!( - preview_data.line_for_items(&items), - Some(Line::from("gpt-5")) - ); - } - - #[test] - fn preview_includes_thread_title() { - let preview_data = StatusLinePreviewData::from_iter([ - (StatusLineItem::ModelName, "gpt-5".to_string()), - (StatusLineItem::ThreadTitle, "Roadmap cleanup".to_string()), - ]); - let items = vec![ - MultiSelectItem { - id: StatusLineItem::ModelName.to_string(), - name: String::new(), - description: None, - enabled: true, - }, - MultiSelectItem { - id: StatusLineItem::ThreadTitle.to_string(), - name: String::new(), - description: None, - enabled: true, - }, - ]; - - assert_eq!( - preview_data.line_for_items(&items), - Some(Line::from("gpt-5 · Roadmap cleanup")) - ); - } - - #[test] - fn setup_view_snapshot_uses_runtime_preview_values() { - let (tx_raw, _rx) = unbounded_channel::(); - let view = StatusLineSetupView::new( - Some(&[ - StatusLineItem::ModelName.to_string(), - StatusLineItem::CurrentDir.to_string(), - StatusLineItem::GitBranch.to_string(), - ]), - StatusLinePreviewData::from_iter([ - (StatusLineItem::ModelName, "gpt-5-codex".to_string()), - (StatusLineItem::CurrentDir, "~/codex-rs".to_string()), - ( - StatusLineItem::GitBranch, - "jif/statusline-preview".to_string(), - ), - (StatusLineItem::WeeklyLimit, "weekly 82%".to_string()), - ]), - AppEventSender::new(tx_raw), - ); - - assert_snapshot!(render_lines(&view, /*width*/ 72)); - } - - fn render_lines(view: &StatusLineSetupView, width: u16) -> String { - let height = view.desired_height(width); - let area = Rect::new(0, 0, width, height); - let mut buf = Buffer::empty(area); - view.render(area, &mut buf); - - (0..area.height) - .map(|row| { - let mut line = String::new(); - for col in 0..area.width { - let symbol = buf[(area.x + col, area.y + row)].symbol(); - if symbol.is_empty() { - line.push(' '); - } else { - line.push_str(symbol); - } - } - line - }) - .collect::>() - .join("\n") - } } diff --git a/codex-rs/tui/src/bottom_pane/status_surface_preview.rs b/codex-rs/tui/src/bottom_pane/status_surface_preview.rs new file mode 100644 index 0000000000..93fca824ca --- /dev/null +++ b/codex-rs/tui/src/bottom_pane/status_surface_preview.rs @@ -0,0 +1,173 @@ +use std::collections::BTreeMap; + +use ratatui::text::Line; + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)] +pub(crate) enum StatusSurfacePreviewItem { + AppName, + ProjectName, + ProjectRoot, + CurrentDir, + Status, + ThreadTitle, + GitBranch, + ContextRemaining, + ContextUsed, + FiveHourLimit, + WeeklyLimit, + CodexVersion, + ContextWindowSize, + UsedTokens, + TotalInputTokens, + TotalOutputTokens, + SessionId, + FastMode, + Model, + ModelWithReasoning, + TaskProgress, +} + +impl StatusSurfacePreviewItem { + fn placeholder(self) -> &'static str { + match self { + StatusSurfacePreviewItem::AppName => "codex", + StatusSurfacePreviewItem::ProjectName => "my-project", + StatusSurfacePreviewItem::ProjectRoot => "my-project", + StatusSurfacePreviewItem::CurrentDir => "~/my-project/subdir", + StatusSurfacePreviewItem::Status => "Working", + StatusSurfacePreviewItem::ThreadTitle => "thread title", + StatusSurfacePreviewItem::GitBranch => "feat/awesome-feature", + StatusSurfacePreviewItem::ContextRemaining => "Context 0% left", + StatusSurfacePreviewItem::ContextUsed => "Context 0% used", + StatusSurfacePreviewItem::FiveHourLimit => "5h 0%", + StatusSurfacePreviewItem::WeeklyLimit => "weekly 0%", + StatusSurfacePreviewItem::CodexVersion => "0.0.0", + StatusSurfacePreviewItem::ContextWindowSize => "0 window", + StatusSurfacePreviewItem::UsedTokens => "0 used", + StatusSurfacePreviewItem::TotalInputTokens => "0 in", + StatusSurfacePreviewItem::TotalOutputTokens => "0 out", + StatusSurfacePreviewItem::SessionId => "550e8400-e29b-41d4", + StatusSurfacePreviewItem::FastMode => "Fast on", + StatusSurfacePreviewItem::Model => "gpt-5.2-codex", + StatusSurfacePreviewItem::ModelWithReasoning => "gpt-5.2-codex medium", + StatusSurfacePreviewItem::TaskProgress => "Tasks 0/0", + } + } + + pub(crate) fn iter() -> impl Iterator { + [ + Self::AppName, + Self::ProjectName, + Self::ProjectRoot, + Self::CurrentDir, + Self::Status, + Self::ThreadTitle, + Self::GitBranch, + Self::ContextRemaining, + Self::ContextUsed, + Self::FiveHourLimit, + Self::WeeklyLimit, + Self::CodexVersion, + Self::ContextWindowSize, + Self::UsedTokens, + Self::TotalInputTokens, + Self::TotalOutputTokens, + Self::SessionId, + Self::FastMode, + Self::Model, + Self::ModelWithReasoning, + Self::TaskProgress, + ] + .into_iter() + } +} + +#[derive(Clone, Debug, Eq, PartialEq)] +struct PreviewValue { + text: String, + is_placeholder: bool, +} + +#[derive(Clone, Debug, Eq, PartialEq)] +pub(crate) struct StatusSurfacePreviewData { + values: BTreeMap, +} + +impl Default for StatusSurfacePreviewData { + fn default() -> Self { + let mut data = Self { + values: BTreeMap::new(), + }; + for item in StatusSurfacePreviewItem::iter() { + data.set_placeholder(item, item.placeholder()); + } + data + } +} + +impl StatusSurfacePreviewData { + pub(crate) fn from_iter(values: I) -> Self + where + I: IntoIterator, + V: Into, + { + let mut data = Self::default(); + for (item, value) in values { + data.set_live(item, value); + } + data + } + + pub(crate) fn set_live(&mut self, item: StatusSurfacePreviewItem, value: V) + where + V: Into, + { + self.values.insert( + item, + PreviewValue { + text: value.into(), + is_placeholder: false, + }, + ); + } + + pub(crate) fn set_placeholder(&mut self, item: StatusSurfacePreviewItem, value: V) + where + V: Into, + { + if self + .values + .get(&item) + .is_some_and(|value| !value.is_placeholder) + { + return; + } + self.values.insert( + item, + PreviewValue { + text: value.into(), + is_placeholder: true, + }, + ); + } + + pub(crate) fn value_for(&self, item: StatusSurfacePreviewItem) -> Option<&str> { + self.values.get(&item).map(|value| value.text.as_str()) + } + + pub(crate) fn line_for_items(&self, items: I) -> Option> + where + I: IntoIterator, + { + let preview = items + .into_iter() + .filter_map(|item| self.value_for(item)) + .collect::>() + .join(" · "); + if preview.is_empty() { + None + } else { + Some(Line::from(preview)) + } + } +} diff --git a/codex-rs/tui/src/bottom_pane/title_setup.rs b/codex-rs/tui/src/bottom_pane/title_setup.rs index b9899e32d6..0595a17974 100644 --- a/codex-rs/tui/src/bottom_pane/title_setup.rs +++ b/codex-rs/tui/src/bottom_pane/title_setup.rs @@ -22,6 +22,8 @@ use crate::bottom_pane::CancellationEvent; use crate::bottom_pane::bottom_pane_view::BottomPaneView; use crate::bottom_pane::multi_select_picker::MultiSelectItem; use crate::bottom_pane::multi_select_picker::MultiSelectPicker; +use crate::bottom_pane::status_surface_preview::StatusSurfacePreviewData; +use crate::bottom_pane::status_surface_preview::StatusSurfacePreviewItem; use crate::render::renderable::Renderable; /// Available items that can be displayed in the terminal title. @@ -68,20 +70,16 @@ impl TerminalTitleItem { } } - /// Example text used when previewing the title picker. - /// - /// These are illustrative sample values, not live data from the current - /// session. - pub(crate) fn preview_example(self) -> &'static str { + pub(crate) fn preview_item(self) -> Option { match self { - TerminalTitleItem::AppName => "codex", - TerminalTitleItem::Project => "my-project", - TerminalTitleItem::Spinner => "⠋", - TerminalTitleItem::Status => "Working", - TerminalTitleItem::Thread => "Investigate flaky test", - TerminalTitleItem::GitBranch => "feat/awesome-feature", - TerminalTitleItem::Model => "gpt-5.2-codex", - TerminalTitleItem::TaskProgress => "Tasks 2/5", + TerminalTitleItem::AppName => Some(StatusSurfacePreviewItem::AppName), + TerminalTitleItem::Project => Some(StatusSurfacePreviewItem::ProjectName), + TerminalTitleItem::Spinner => None, + TerminalTitleItem::Status => Some(StatusSurfacePreviewItem::Status), + TerminalTitleItem::Thread => Some(StatusSurfacePreviewItem::ThreadTitle), + TerminalTitleItem::GitBranch => Some(StatusSurfacePreviewItem::GitBranch), + TerminalTitleItem::Model => Some(StatusSurfacePreviewItem::Model), + TerminalTitleItem::TaskProgress => Some(StatusSurfacePreviewItem::TaskProgress), } } @@ -103,6 +101,39 @@ impl TerminalTitleItem { } } +pub(crate) fn preview_line_for_title_items( + items: &[TerminalTitleItem], + preview_data: &StatusSurfacePreviewData, +) -> Option> { + let mut previous = None; + let preview = items + .iter() + .copied() + .fold(String::new(), |mut preview, item| { + if item == TerminalTitleItem::Spinner { + preview.push_str(item.separator_from_previous(previous)); + preview.push('⠋'); + previous = Some(item); + return preview; + } + let Some(value) = item + .preview_item() + .and_then(|preview_item| preview_data.value_for(preview_item)) + else { + return preview; + }; + preview.push_str(item.separator_from_previous(previous)); + preview.push_str(value); + previous = Some(item); + preview + }); + if preview.is_empty() { + None + } else { + Some(Line::from(preview)) + } +} + fn parse_terminal_title_items(ids: impl Iterator) -> Option> where T: AsRef, @@ -128,7 +159,11 @@ impl TerminalTitleSetupView { /// main TUI still warns about them when rendering the actual title, but the /// picker itself only exposes the selectable items it can meaningfully /// preview and persist. - pub(crate) fn new(title_items: Option<&[String]>, app_event_tx: AppEventSender) -> Self { + pub(crate) fn new( + title_items: Option<&[String]>, + preview_data: StatusSurfacePreviewData, + app_event_tx: AppEventSender, + ) -> Self { let selected_items = title_items .into_iter() .flatten() @@ -161,25 +196,14 @@ impl TerminalTitleSetupView { ]) .items(items) .enable_ordering() - .on_preview(|items| { + .on_preview(move |items| { let items = parse_terminal_title_items( items .iter() .filter(|item| item.enabled) .map(|item| item.id.as_str()), )?; - let mut preview = String::new(); - let mut previous = None; - for item in items.iter().copied() { - preview.push_str(item.separator_from_previous(previous)); - preview.push_str(item.preview_example()); - previous = Some(item); - } - if preview.is_empty() { - None - } else { - Some(Line::from(preview)) - } + preview_line_for_title_items(&items, &preview_data) }) .on_change(|items, app_event| { let Some(items) = parse_terminal_title_items( @@ -243,49 +267,7 @@ impl Renderable for TerminalTitleSetupView { #[cfg(test)] mod tests { use super::*; - use insta::assert_snapshot; use pretty_assertions::assert_eq; - use tokio::sync::mpsc::unbounded_channel; - - fn render_lines(view: &TerminalTitleSetupView, width: u16) -> String { - let height = view.desired_height(width); - let area = Rect::new(0, 0, width, height); - let mut buf = Buffer::empty(area); - view.render(area, &mut buf); - - let lines: Vec = (0..area.height) - .map(|row| { - let mut line = String::new(); - for col in 0..area.width { - let symbol = buf[(area.x + col, area.y + row)].symbol(); - if symbol.is_empty() { - line.push(' '); - } else { - line.push_str(symbol); - } - } - line - }) - .collect(); - lines.join("\n") - } - - #[test] - fn renders_title_setup_popup() { - let (tx_raw, _rx) = unbounded_channel::(); - let tx = AppEventSender::new(tx_raw); - let selected = [ - "project".to_string(), - "spinner".to_string(), - "status".to_string(), - "thread".to_string(), - ]; - let view = TerminalTitleSetupView::new(Some(&selected), tx); - assert_snapshot!( - "terminal_title_setup_basic", - render_lines(&view, /*width*/ 84) - ); - } #[test] fn parse_terminal_title_items_preserves_order() { diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index dbceecb6cb..860846f281 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -52,8 +52,9 @@ use crate::app_server_session::ThreadSessionState; #[cfg(not(target_os = "linux"))] use crate::audio_device::list_realtime_audio_device_names; use crate::bottom_pane::StatusLineItem; -use crate::bottom_pane::StatusLinePreviewData; use crate::bottom_pane::StatusLineSetupView; +use crate::bottom_pane::StatusSurfacePreviewData; +use crate::bottom_pane::StatusSurfacePreviewItem; use crate::bottom_pane::TerminalTitleItem; use crate::bottom_pane::TerminalTitleSetupView; use crate::legacy_core::DEFAULT_AGENTS_MD_FILENAME; @@ -473,6 +474,13 @@ fn is_standard_tool_call(parsed_cmd: &[ParsedCommand]) -> bool { const RATE_LIMIT_WARNING_THRESHOLDS: [f64; 3] = [75.0, 90.0, 95.0]; const NUDGE_MODEL_SLUG: &str = "gpt-5.4-mini"; const RATE_LIMIT_SWITCH_PROMPT_THRESHOLD: f64 = 90.0; +const MAX_AGENT_COPY_HISTORY: usize = 32; + +#[derive(Debug)] +struct AgentTurnMarkdown { + user_turn_count: usize, + markdown: String, +} #[derive(Default)] struct RateLimitWarningState { @@ -795,13 +803,17 @@ pub(crate) struct ChatWidget { plan_stream_controller: Option, /// Holds the platform clipboard lease so copied text remains available while supported. clipboard_lease: Option, - /// Raw markdown of the most recently completed agent response. - /// - /// This cache is intentionally best-effort: if the user rolls back the - /// thread and then copies before a replacement response arrives, `/copy` - /// may still return the response from before the rollback. Keeping this as - /// a single cache avoids coupling copy state to the backtrack transcript. + /// Raw markdown of the most recently completed agent response that + /// survived any local thread rollback. last_agent_markdown: Option, + /// Copyable agent responses keyed by the number of visible user turns at + /// the time the response completed. + agent_turn_markdowns: Vec, + /// Number of user turns currently reflected in the visible transcript. + visible_user_turn_count: usize, + /// True when rollback discarded the requested copy source because it was + /// older than the retained copy history. + copy_history_evicted_by_rollback: bool, /// Raw markdown of the most recently completed proposed plan. /// /// This is cached only for the approval popup. It is reset at the start of each new task so the @@ -2045,21 +2057,50 @@ impl ChatWidget { if message.is_empty() { return; } - self.last_agent_markdown = Some(message.to_string()); + let markdown = message.to_string(); + match self.agent_turn_markdowns.last_mut() { + Some(entry) if entry.user_turn_count == self.visible_user_turn_count => { + entry.markdown = markdown.clone(); + } + _ => { + self.agent_turn_markdowns.push(AgentTurnMarkdown { + user_turn_count: self.visible_user_turn_count, + markdown: markdown.clone(), + }); + if self.agent_turn_markdowns.len() > MAX_AGENT_COPY_HISTORY { + self.agent_turn_markdowns.remove(0); + } + } + } + self.last_agent_markdown = Some(markdown); + self.copy_history_evicted_by_rollback = false; self.saw_copy_source_this_turn = true; } - // --- Small event handlers --- - fn on_session_configured(&mut self, event: codex_protocol::protocol::SessionConfiguredEvent) { - self.on_session_configured_with_display(event, SessionConfiguredDisplay::Normal); + fn record_visible_user_turn_for_copy(&mut self) { + self.visible_user_turn_count = self.visible_user_turn_count.saturating_add(1); } - fn on_session_configured_with_display( + // --- Small event handlers --- + #[cfg(test)] + fn on_session_configured(&mut self, event: codex_protocol::protocol::SessionConfiguredEvent) { + self.on_session_configured_with_display_and_fork_parent_title( + event, + SessionConfiguredDisplay::Normal, + /*fork_parent_title*/ None, + ); + } + + fn on_session_configured_with_display_and_fork_parent_title( &mut self, event: codex_protocol::protocol::SessionConfiguredEvent, display: SessionConfiguredDisplay, + fork_parent_title: Option, ) { self.last_agent_markdown = None; + self.agent_turn_markdowns.clear(); + self.visible_user_turn_count = 0; + self.copy_history_evicted_by_rollback = false; self.saw_copy_source_this_turn = false; self.bottom_pane .set_history_metadata(event.history_log_id, event.history_entry_count); @@ -2156,7 +2197,7 @@ impl ChatWidget { if display == SessionConfiguredDisplay::Normal && let Some(forked_from_id) = forked_from_id { - self.emit_forked_thread_event(forked_from_id); + self.emit_forked_thread_event(forked_from_id, fork_parent_title); } if !self.suppress_session_configured_redraw { self.request_redraw(); @@ -2175,33 +2216,59 @@ impl ChatWidget { pub(crate) fn handle_thread_session(&mut self, session: ThreadSessionState) { self.instruction_source_paths = session.instruction_source_paths.clone(); - self.on_session_configured(thread_session_state_to_legacy_event(session)); + let fork_parent_title = session.fork_parent_title.clone(); + self.on_session_configured_with_display_and_fork_parent_title( + thread_session_state_to_legacy_event(session), + SessionConfiguredDisplay::Normal, + fork_parent_title, + ); } pub(crate) fn handle_thread_session_quiet(&mut self, session: ThreadSessionState) { self.instruction_source_paths = session.instruction_source_paths.clone(); - self.on_session_configured_with_display( + self.on_session_configured_with_display_and_fork_parent_title( thread_session_state_to_legacy_event(session), SessionConfiguredDisplay::Quiet, + /*fork_parent_title*/ None, ); } pub(crate) fn handle_side_thread_session(&mut self, session: ThreadSessionState) { self.instruction_source_paths = session.instruction_source_paths.clone(); - self.on_session_configured_with_display( + let fork_parent_title = session.fork_parent_title.clone(); + self.on_session_configured_with_display_and_fork_parent_title( thread_session_state_to_legacy_event(session), SessionConfiguredDisplay::SideConversation, + fork_parent_title, ); } - fn emit_forked_thread_event(&mut self, forked_from_id: ThreadId) { + fn emit_forked_thread_event( + &mut self, + forked_from_id: ThreadId, + fork_parent_title: Option, + ) { let forked_from_id_text = forked_from_id.to_string(); - let line: Line<'static> = vec![ - "• ".dim(), - "Thread forked from ".into(), - forked_from_id_text.cyan(), - ] - .into(); + let line: Line<'static> = if let Some(name) = fork_parent_title + && !name.trim().is_empty() + { + vec![ + "• ".dim(), + "Thread forked from ".into(), + name.cyan(), + " (".into(), + forked_from_id_text.cyan(), + ")".into(), + ] + .into() + } else { + vec![ + "• ".dim(), + "Thread forked from ".into(), + forked_from_id_text.cyan(), + ] + .into() + }; self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new( PlainHistoryCell::new(vec![line]), ))); @@ -3540,6 +3607,14 @@ impl ChatWidget { /// render the final approved/denied history cell when guardian returns a /// decision. fn on_guardian_assessment(&mut self, ev: GuardianAssessmentEvent) { + let permission_request_summary = |subject: &str, reason: &Option| { + reason + .as_deref() + .map(str::trim) + .filter(|reason| !reason.is_empty()) + .map(|reason| format!("{subject}: {reason}")) + .unwrap_or_else(|| subject.to_string()) + }; let guardian_action_summary = |action: &GuardianAssessmentAction| match action { GuardianAssessmentAction::Command { command, .. } => Some(command.clone()), GuardianAssessmentAction::Execve { program, argv, .. } => { @@ -3569,6 +3644,9 @@ impl ChatWidget { let label = connector_name.as_deref().unwrap_or(server.as_str()); Some(format!("MCP {tool_name} on {label}")) } + GuardianAssessmentAction::RequestPermissions { reason, .. } => { + Some(permission_request_summary("permission request", reason)) + } }; let guardian_command = |action: &GuardianAssessmentAction| match action { GuardianAssessmentAction::Command { command, .. } => shlex::split(command) @@ -3582,7 +3660,8 @@ impl ChatWidget { .filter(|command| !command.is_empty()), GuardianAssessmentAction::ApplyPatch { .. } | GuardianAssessmentAction::NetworkAccess { .. } - | GuardianAssessmentAction::McpToolCall { .. } => None, + | GuardianAssessmentAction::McpToolCall { .. } + | GuardianAssessmentAction::RequestPermissions { .. } => None, }; if ev.status == GuardianAssessmentStatus::InProgress @@ -3673,6 +3752,11 @@ impl ChatWidget { "codex could access {target}" )) } + GuardianAssessmentAction::RequestPermissions { reason, .. } => { + history_cell::new_guardian_timed_out_action_request( + permission_request_summary("codex could request permissions", reason), + ) + } GuardianAssessmentAction::Command { .. } => unreachable!(), GuardianAssessmentAction::Execve { .. } => unreachable!(), } @@ -3711,6 +3795,12 @@ impl ChatWidget { "codex to access {target}" )) } + GuardianAssessmentAction::RequestPermissions { reason, .. } => { + history_cell::new_guardian_denied_action_request(permission_request_summary( + "codex to request permissions", + reason, + )) + } GuardianAssessmentAction::Command { .. } => unreachable!(), GuardianAssessmentAction::Execve { .. } => unreachable!(), } @@ -5064,6 +5154,9 @@ impl ChatWidget { agent_turn_running: false, mcp_startup_status: None, last_agent_markdown: None, + agent_turn_markdowns: Vec::new(), + visible_user_turn_count: 0, + copy_history_evicted_by_rollback: false, latest_proposed_plan_markdown: None, saw_copy_source_this_turn: false, mcp_startup_expected_servers: None, @@ -5432,6 +5525,23 @@ impl ChatWidget { self.copy_last_agent_markdown_with(crate::clipboard_copy::copy_to_clipboard); } + pub(crate) fn truncate_agent_copy_history_to_user_turn_count( + &mut self, + user_turn_count: usize, + ) { + self.visible_user_turn_count = user_turn_count; + let had_copy_history = !self.agent_turn_markdowns.is_empty(); + self.agent_turn_markdowns + .retain(|entry| entry.user_turn_count <= user_turn_count); + self.last_agent_markdown = self + .agent_turn_markdowns + .last() + .map(|entry| entry.markdown.clone()); + self.copy_history_evicted_by_rollback = + had_copy_history && self.last_agent_markdown.is_none(); + self.saw_copy_source_this_turn = false; + } + /// Inner implementation with an injectable clipboard backend for testing. fn copy_last_agent_markdown_with( &mut self, @@ -5450,6 +5560,11 @@ impl ChatWidget { "Copy failed: {error}" ))), }, + _ if self.copy_history_evicted_by_rollback => { + self.add_to_history(history_cell::new_error_event(format!( + "Cannot copy that response after rewinding. Only the most recent {MAX_AGENT_COPY_HISTORY} responses are available to /copy." + ))); + } _ => self.add_to_history(history_cell::new_error_event( "No agent response to copy".into(), )), @@ -5865,6 +5980,7 @@ impl ChatWidget { local_image_paths.clone(), remote_image_urls.clone(), )); + self.record_visible_user_turn_for_copy(); self.add_to_history(history_cell::new_user_prompt( text, text_elements, @@ -5879,6 +5995,7 @@ impl ChatWidget { Vec::new(), remote_image_urls.clone(), )); + self.record_visible_user_turn_for_copy(); self.add_to_history(history_cell::new_user_prompt( String::new(), Vec::new(), @@ -7248,6 +7365,7 @@ impl ChatWidget { || !event.text_elements.is_empty() || !remote_image_urls.is_empty() { + self.record_visible_user_turn_for_copy(); self.add_to_history(history_cell::new_user_prompt( event.message, event.text_elements, @@ -7501,10 +7619,7 @@ impl ChatWidget { let configured_status_line_items = self.configured_status_line_items(); let view = StatusLineSetupView::new( Some(configured_status_line_items.as_slice()), - StatusLinePreviewData::from_iter(StatusLineItem::iter().filter_map(|item| { - self.status_line_value_for_item(&item) - .map(|value| (item, value)) - })), + self.status_surface_preview_data(), self.app_event_tx.clone(), ); self.bottom_pane.show_view(Box::new(view)); @@ -7515,11 +7630,40 @@ impl ChatWidget { self.terminal_title_setup_original_items = Some(self.config.tui_terminal_title.clone()); let view = TerminalTitleSetupView::new( Some(configured_terminal_title_items.as_slice()), + self.terminal_title_preview_data(), self.app_event_tx.clone(), ); self.bottom_pane.show_view(Box::new(view)); } + fn status_surface_preview_data(&mut self) -> StatusSurfacePreviewData { + StatusSurfacePreviewData::from_iter(StatusSurfacePreviewItem::iter().filter_map(|item| { + self.status_surface_preview_value_for_item(item) + .map(|value| (item, value)) + })) + } + + fn terminal_title_preview_data(&mut self) -> StatusSurfacePreviewData { + let mut preview_data = self.status_surface_preview_data(); + let now = Instant::now(); + for item in [ + TerminalTitleItem::Project, + TerminalTitleItem::Thread, + TerminalTitleItem::GitBranch, + TerminalTitleItem::Model, + TerminalTitleItem::TaskProgress, + ] { + let Some(preview_item) = item.preview_item() else { + continue; + }; + let Some(value) = self.terminal_title_value_for_item(item, now) else { + continue; + }; + preview_data.set_live(preview_item, value); + } + preview_data + } + fn open_theme_picker(&mut self) { let codex_home = crate::legacy_core::config::find_codex_home().ok(); let terminal_width = self diff --git a/codex-rs/tui/src/chatwidget/realtime.rs b/codex-rs/tui/src/chatwidget/realtime.rs index f09e3e9b37..bfeaff2eae 100644 --- a/codex-rs/tui/src/chatwidget/realtime.rs +++ b/codex-rs/tui/src/chatwidget/realtime.rs @@ -338,6 +338,7 @@ impl ChatWidget { RealtimeEvent::ConversationItemAdded(_item) => {} RealtimeEvent::ConversationItemDone { .. } => {} RealtimeEvent::HandoffRequested(_) => {} + RealtimeEvent::NoopRequested(_) => {} RealtimeEvent::Error(message) => { self.fail_realtime_conversation(format!("Realtime voice error: {message}")); } diff --git a/codex-rs/tui/src/chatwidget/skills.rs b/codex-rs/tui/src/chatwidget/skills.rs index 0f0261ffea..904678003a 100644 --- a/codex-rs/tui/src/chatwidget/skills.rs +++ b/codex-rs/tui/src/chatwidget/skills.rs @@ -75,7 +75,7 @@ impl ChatWidget { .iter() .map(|skill| { let core_skill = protocol_skill_to_core(skill); - let display_name = skill_display_name(&core_skill).to_string(); + let display_name = skill_display_name(&core_skill); let description = skill_description(&core_skill).to_string(); let name = core_skill.name.clone(); let path = core_skill.path_to_skills_md; diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__app_server_forked_thread_history_line.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__app_server_forked_thread_history_line.snap new file mode 100644 index 0000000000..2b4e8bc029 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__app_server_forked_thread_history_line.snap @@ -0,0 +1,5 @@ +--- +source: tui/src/chatwidget/tests/history_replay.rs +expression: combined +--- +• Thread forked from app-server-parent-thread (e9f18a88-8081-4e51-9d4e-8af5cde2d8dd) diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__app_server_forked_thread_history_line_without_app_server_name.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__app_server_forked_thread_history_line_without_app_server_name.snap new file mode 100644 index 0000000000..cd092d4760 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__app_server_forked_thread_history_line_without_app_server_name.snap @@ -0,0 +1,5 @@ +--- +source: tui/src/chatwidget/tests/history_replay.rs +expression: combined +--- +• Thread forked from 019c2d47-4935-7423-a190-05691f566092 diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__forked_thread_history_line.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__forked_thread_history_line.snap new file mode 100644 index 0000000000..de72926fd3 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__forked_thread_history_line.snap @@ -0,0 +1,5 @@ +--- +source: tui/src/chatwidget/tests/history_replay.rs +expression: combined +--- +• Thread forked from named-thread (e9f18a88-8081-4e51-9d4e-8af5cde2d8dd) diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__guardian_approved_request_permissions_renders_request_summary.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__guardian_approved_request_permissions_renders_request_summary.snap new file mode 100644 index 0000000000..4f0561af9e --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__guardian_approved_request_permissions_renders_request_summary.snap @@ -0,0 +1,16 @@ +--- +source: tui/src/chatwidget/tests/guardian.rs +expression: normalize_snapshot_paths(term.backend().vt100().screen().contents()) +--- + + + +✔ Request approved for permission request: Need write access for generated + report assets. + +• Working (0s • esc to interrupt) + + +› Ask Codex to do anything + + gpt-5.4 default · /tmp/project diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_hardcoded_only.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_hardcoded_only.snap new file mode 100644 index 0000000000..ccab3ca7d1 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_hardcoded_only.snap @@ -0,0 +1,20 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: status_line_popup_snapshot(&mut chat) +--- + Configure Status Line + Select which items to display in the status line. + + Type to search + > +› [x] project-root Project root directory (omitted when unavailable) + [x] git-branch Current Git branch (omitted when unavailable) + [x] thread-title Current thread title (omitted unless changed by user) + [ ] model-name Current model name + [ ] model-with-reasoning Current model name with reasoning level + [ ] current-dir Current working directory + [ ] context-remaining Percentage of context window remaining (omitted when unknown) + [ ] context-used Percentage of context window used (omitted when unknown) + + my-project · feat/awesome-feature · thread title + Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc to cancel. diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_live_only.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_live_only.snap new file mode 100644 index 0000000000..273e175114 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_live_only.snap @@ -0,0 +1,20 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: status_line_popup_snapshot(&mut chat) +--- + Configure Status Line + Select which items to display in the status line. + + Type to search + > +› [x] project-root Project root directory (omitted when unavailable) + [x] git-branch Current Git branch (omitted when unavailable) + [x] thread-title Current thread title (omitted unless changed by user) + [ ] model-name Current model name + [ ] model-with-reasoning Current model name with reasoning level + [ ] current-dir Current working directory + [ ] context-remaining Percentage of context window remaining (omitted when unknown) + [ ] context-used Percentage of context window used (omitted when unknown) + + preview-live-root · feature/live-preview-branch · Live preview thread + Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc to cancel. diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_mixed.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_mixed.snap new file mode 100644 index 0000000000..0f0bfdd24a --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_line_setup_popup_mixed.snap @@ -0,0 +1,20 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: status_line_popup_snapshot(&mut chat) +--- + Configure Status Line + Select which items to display in the status line. + + Type to search + > +› [x] project-root Project root directory (omitted when unavailable) + [x] git-branch Current Git branch (omitted when unavailable) + [x] thread-title Current thread title (omitted unless changed by user) + [ ] model-name Current model name + [ ] model-with-reasoning Current model name with reasoning level + [ ] current-dir Current working directory + [ ] context-remaining Percentage of context window remaining (omitted when unknown) + [ ] context-used Percentage of context window used (omitted when unknown) + + my-project · feature/mixed-preview · Mixed preview thread + Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc to cancel. diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_hardcoded_only.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_hardcoded_only.snap new file mode 100644 index 0000000000..abf3df3c26 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_hardcoded_only.snap @@ -0,0 +1,6 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: snapshot +--- +status line: my-project · feat/awesome-feature · thread title +terminal title: thread title | feat/awesome-feature | Tasks 0/0 diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_live_only.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_live_only.snap new file mode 100644 index 0000000000..4cf1871af6 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_live_only.snap @@ -0,0 +1,6 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: snapshot +--- +status line: preview-live-root · feature/live-preview-branch · Live preview thread +terminal title: preview-live-root | Live preview thread | feature/live-preview-branch | Tasks 2/5 diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_mixed.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_mixed.snap new file mode 100644 index 0000000000..ab50a69811 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_surface_previews_mixed.snap @@ -0,0 +1,6 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: snapshot +--- +status line: my-project · feature/mixed-preview · Mixed preview thread +terminal title: project | Mixed preview thread | Tasks 0/0 diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_hardcoded_only.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_hardcoded_only.snap new file mode 100644 index 0000000000..eb27cdd01b --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_hardcoded_only.snap @@ -0,0 +1,20 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: terminal_title_popup_snapshot(&mut chat) +--- + Configure Terminal Title + Select which items to display in the terminal title. + + Type to search + > +› [x] thread Current thread title (omitted until available) + [x] git-branch Current Git branch (omitted when unavailable) + [x] task-progress Latest task progress from update_plan (omitted until available) + [ ] app-name Codex app name + [ ] project Project name (falls back to current directory name) + [ ] spinner Animated task spinner (omitted while idle or when animations are off) + [ ] status Compact session status text (Ready, Working, Thinking) + [ ] model Current model name + + thread title | feat/awesome-feature | Tasks 0/0 + Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc to cancel. diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_live_only.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_live_only.snap new file mode 100644 index 0000000000..bc2bf2502a --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_live_only.snap @@ -0,0 +1,20 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: terminal_title_popup_snapshot(&mut chat) +--- + Configure Terminal Title + Select which items to display in the terminal title. + + Type to search + > +› [x] project Project name (falls back to current directory name) + [x] thread Current thread title (omitted until available) + [x] git-branch Current Git branch (omitted when unavailable) + [x] task-progress Latest task progress from update_plan (omitted until available) + [ ] app-name Codex app name + [ ] spinner Animated task spinner (omitted while idle or when animations are off) + [ ] status Compact session status text (Ready, Working, Thinking) + [ ] model Current model name + + preview-live-root | Live preview thread | feature/live-preview-branch | Tasks 2/5 + Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc to cancel. diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_mixed.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_mixed.snap new file mode 100644 index 0000000000..4d2f3128d5 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__terminal_title_setup_popup_mixed.snap @@ -0,0 +1,20 @@ +--- +source: tui/src/chatwidget/tests/status_surface_previews.rs +expression: terminal_title_popup_snapshot(&mut chat) +--- + Configure Terminal Title + Select which items to display in the terminal title. + + Type to search + > +› [x] project Project name (falls back to current directory name) + [x] thread Current thread title (omitted until available) + [x] task-progress Latest task progress from update_plan (omitted until available) + [ ] app-name Codex app name + [ ] spinner Animated task spinner (omitted while idle or when animations are off) + [ ] status Compact session status text (Ready, Working, Thinking) + [ ] git-branch Current Git branch (omitted when unavailable) + [ ] model Current model name + + project | Mixed preview thread | Tasks 0/0 + Use ↑↓ to navigate, ←→ to move, space to select, enter to confirm, esc to cancel. diff --git a/codex-rs/tui/src/chatwidget/status_surfaces.rs b/codex-rs/tui/src/chatwidget/status_surfaces.rs index a744711c2c..7045bbecfd 100644 --- a/codex-rs/tui/src/chatwidget/status_surfaces.rs +++ b/codex-rs/tui/src/chatwidget/status_surfaces.rs @@ -505,11 +505,41 @@ impl ChatWidget { } } + pub(super) fn status_surface_preview_value_for_item( + &mut self, + item: StatusSurfacePreviewItem, + ) -> Option { + let status_line_item = match item { + StatusSurfacePreviewItem::AppName => return Some("codex".to_string()), + StatusSurfacePreviewItem::ProjectName => return self.terminal_title_project_name(), + StatusSurfacePreviewItem::ProjectRoot => StatusLineItem::ProjectRoot, + StatusSurfacePreviewItem::Status => return Some(self.terminal_title_status_text()), + StatusSurfacePreviewItem::TaskProgress => return self.terminal_title_task_progress(), + StatusSurfacePreviewItem::CurrentDir => StatusLineItem::CurrentDir, + StatusSurfacePreviewItem::ThreadTitle => StatusLineItem::ThreadTitle, + StatusSurfacePreviewItem::GitBranch => StatusLineItem::GitBranch, + StatusSurfacePreviewItem::ContextRemaining => StatusLineItem::ContextRemaining, + StatusSurfacePreviewItem::ContextUsed => StatusLineItem::ContextUsed, + StatusSurfacePreviewItem::FiveHourLimit => StatusLineItem::FiveHourLimit, + StatusSurfacePreviewItem::WeeklyLimit => StatusLineItem::WeeklyLimit, + StatusSurfacePreviewItem::CodexVersion => StatusLineItem::CodexVersion, + StatusSurfacePreviewItem::ContextWindowSize => StatusLineItem::ContextWindowSize, + StatusSurfacePreviewItem::UsedTokens => StatusLineItem::UsedTokens, + StatusSurfacePreviewItem::TotalInputTokens => StatusLineItem::TotalInputTokens, + StatusSurfacePreviewItem::TotalOutputTokens => StatusLineItem::TotalOutputTokens, + StatusSurfacePreviewItem::SessionId => StatusLineItem::SessionId, + StatusSurfacePreviewItem::FastMode => StatusLineItem::FastMode, + StatusSurfacePreviewItem::Model => StatusLineItem::ModelName, + StatusSurfacePreviewItem::ModelWithReasoning => StatusLineItem::ModelWithReasoning, + }; + self.status_line_value_for_item(&status_line_item) + } + /// Resolves one configured terminal-title item into a displayable segment. /// /// Returning `None` means "omit this segment for now" so callers can keep /// the configured order while hiding values that are not yet available. - fn terminal_title_value_for_item( + pub(super) fn terminal_title_value_for_item( &mut self, item: TerminalTitleItem, now: Instant, diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rs index 4c4d74090c..d81544e4f7 100644 --- a/codex-rs/tui/src/chatwidget/tests.rs +++ b/codex-rs/tui/src/chatwidget/tests.rs @@ -276,6 +276,7 @@ mod side; mod slash_commands; mod status_and_layout; mod status_command_tests; +mod status_surface_previews; pub(crate) use helpers::make_chatwidget_manual_with_sender; pub(crate) use helpers::set_chatgpt_auth; diff --git a/codex-rs/tui/src/chatwidget/tests/approval_requests.rs b/codex-rs/tui/src/chatwidget/tests/approval_requests.rs index 472a13c118..4e5bc7556e 100644 --- a/codex-rs/tui/src/chatwidget/tests/approval_requests.rs +++ b/codex-rs/tui/src/chatwidget/tests/approval_requests.rs @@ -113,6 +113,7 @@ fn app_server_exec_approval_request_preserves_permissions_context() { file_system: Some(AppServerAdditionalFileSystemPermissions { read: Some(vec![read_path.clone()]), write: Some(vec![write_path.clone()]), + glob_scan_max_depth: None, entries: None, }), }), @@ -163,6 +164,7 @@ fn app_server_request_permissions_preserves_file_system_permissions() { file_system: Some(AppServerAdditionalFileSystemPermissions { read: Some(vec![read_path.clone()]), write: Some(vec![write_path.clone()]), + glob_scan_max_depth: None, entries: None, }), }, diff --git a/codex-rs/tui/src/chatwidget/tests/guardian.rs b/codex-rs/tui/src/chatwidget/tests/guardian.rs index 03e73ed883..ffdefa534b 100644 --- a/codex-rs/tui/src/chatwidget/tests/guardian.rs +++ b/codex-rs/tui/src/chatwidget/tests/guardian.rs @@ -121,6 +121,86 @@ async fn guardian_approved_exec_renders_approved_request() { ); } +#[tokio::test] +async fn guardian_approved_request_permissions_renders_request_summary() { + let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + chat.show_welcome_banner = false; + let action = GuardianAssessmentAction::RequestPermissions { + reason: Some("Need write access for generated report assets.".to_string()), + permissions: RequestPermissionProfile { + file_system: Some(FileSystemPermissions::from_read_write_roots( + /*read*/ None, + Some(vec![test_path_buf("/tmp/reports").abs()]), + )), + ..RequestPermissionProfile::default() + }, + }; + + chat.handle_codex_event(Event { + id: "guardian-in-progress".into(), + msg: EventMsg::GuardianAssessment(GuardianAssessmentEvent { + id: "guardian-request-permissions".into(), + target_item_id: None, + turn_id: "turn-1".into(), + status: GuardianAssessmentStatus::InProgress, + risk_level: None, + user_authorization: None, + rationale: None, + decision_source: None, + action: action.clone(), + }), + }); + + let status = chat + .bottom_pane + .status_widget() + .expect("status indicator should be visible"); + assert_eq!(status.header(), "Reviewing approval request"); + assert_eq!( + status.details(), + Some("permission request: Need write access for generated report assets.") + ); + + chat.handle_codex_event(Event { + id: "guardian-assessment".into(), + msg: EventMsg::GuardianAssessment(GuardianAssessmentEvent { + id: "guardian-request-permissions".into(), + target_item_id: None, + turn_id: "turn-1".into(), + status: GuardianAssessmentStatus::Approved, + risk_level: Some(GuardianRiskLevel::Low), + user_authorization: Some(GuardianUserAuthorization::High), + rationale: Some("Request is scoped to report output.".into()), + decision_source: Some(GuardianAssessmentDecisionSource::Agent), + action, + }), + }); + + let width: u16 = 110; + let ui_height: u16 = chat.desired_height(width); + let vt_height: u16 = 12; + let viewport = Rect::new(0, vt_height - ui_height - 1, width, ui_height); + + let backend = VT100Backend::new(width, vt_height); + let mut term = crate::custom_terminal::Terminal::with_options(backend).expect("terminal"); + term.set_viewport_area(viewport); + + for lines in drain_insert_history(&mut rx) { + crate::insert_history::insert_history_lines(&mut term, lines) + .expect("Failed to insert history lines in test"); + } + + term.draw(|f| { + chat.render(f.area(), f.buffer_mut()); + }) + .expect("draw guardian request permissions approval history"); + + assert_chatwidget_snapshot!( + "guardian_approved_request_permissions_renders_request_summary", + normalize_snapshot_paths(term.backend().vt100().screen().contents()) + ); +} + #[tokio::test] async fn guardian_timed_out_exec_renders_warning_and_timed_out_request() { let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; diff --git a/codex-rs/tui/src/chatwidget/tests/helpers.rs b/codex-rs/tui/src/chatwidget/tests/helpers.rs index a0b8882b6d..72ed31a30b 100644 --- a/codex-rs/tui/src/chatwidget/tests/helpers.rs +++ b/codex-rs/tui/src/chatwidget/tests/helpers.rs @@ -212,6 +212,9 @@ pub(super) async fn make_chatwidget_manual( pending_guardian_review_status: PendingGuardianReviewStatus::default(), terminal_title_status_kind: TerminalTitleStatusKind::Working, last_agent_markdown: None, + agent_turn_markdowns: Vec::new(), + visible_user_turn_count: 0, + copy_history_evicted_by_rollback: false, latest_proposed_plan_markdown: None, saw_copy_source_this_turn: false, running_commands: HashMap::new(), diff --git a/codex-rs/tui/src/chatwidget/tests/history_replay.rs b/codex-rs/tui/src/chatwidget/tests/history_replay.rs index 80fa79e1db..084743f98d 100644 --- a/codex-rs/tui/src/chatwidget/tests/history_replay.rs +++ b/codex-rs/tui/src/chatwidget/tests/history_replay.rs @@ -387,6 +387,36 @@ async fn replayed_user_message_with_only_local_images_does_not_render_history_ce assert!(!found_user_history_cell); } +#[tokio::test] +async fn forked_thread_history_line_includes_name_and_id_snapshot() { + let (chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let mut chat = chat; + + let forked_from_id = + ThreadId::from_string("e9f18a88-8081-4e51-9d4e-8af5cde2d8dd").expect("forked id"); + + chat.emit_forked_thread_event(forked_from_id, Some("named-thread".to_string())); + + let history_cell = tokio::time::timeout(std::time::Duration::from_secs(2), async { + loop { + match rx.recv().await { + Some(AppEvent::InsertHistoryCell(cell)) => break cell, + Some(_) => continue, + None => panic!("app event channel closed before forked thread history was emitted"), + } + } + }) + .await + .expect("timed out waiting for forked thread history"); + let combined = lines_to_single_string(&history_cell.display_lines(/*width*/ 80)); + + assert!( + combined.contains("Thread forked from"), + "expected forked thread message in history" + ); + assert_chatwidget_snapshot!("forked_thread_history_line", combined); +} + #[tokio::test] async fn forked_thread_history_line_without_name_shows_id_once_snapshot() { let (chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; @@ -398,7 +428,7 @@ async fn forked_thread_history_line_without_name_shows_id_once_snapshot() { let forked_from_id = ThreadId::from_string("019c2d47-4935-7423-a190-05691f566092").expect("forked id"); - chat.emit_forked_thread_event(forked_from_id); + chat.emit_forked_thread_event(forked_from_id, /*fork_parent_title*/ None); let history_cell = tokio::time::timeout(std::time::Duration::from_secs(2), async { loop { @@ -416,6 +446,88 @@ async fn forked_thread_history_line_without_name_shows_id_once_snapshot() { assert_chatwidget_snapshot!("forked_thread_history_line_without_name", combined); } +#[tokio::test] +async fn app_server_forked_thread_history_line_uses_app_server_title_snapshot() { + let (chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let mut chat = chat; + let temp = tempdir().expect("tempdir"); + chat.config.codex_home = + codex_utils_absolute_path::AbsolutePathBuf::from_absolute_path(temp.path()) + .expect("temp dir is absolute"); + + let forked_from_id = + ThreadId::from_string("e9f18a88-8081-4e51-9d4e-8af5cde2d8dd").expect("forked id"); + let session_index_entry = format!( + "{{\"id\":\"{forked_from_id}\",\"thread_name\":\"stale-local-thread\",\"updated_at\":\"2024-01-02T00:00:00Z\"}}\n" + ); + std::fs::write(temp.path().join("session_index.jsonl"), session_index_entry) + .expect("write session index"); + + chat.emit_forked_thread_event(forked_from_id, Some("app-server-parent-thread".to_string())); + + let history_cell = tokio::time::timeout(std::time::Duration::from_secs(2), async { + loop { + match rx.recv().await { + Some(AppEvent::InsertHistoryCell(cell)) => break cell, + Some(_) => continue, + None => panic!("app event channel closed before forked thread history was emitted"), + } + } + }) + .await + .expect("timed out waiting for forked thread history"); + let combined = lines_to_single_string(&history_cell.display_lines(/*width*/ 80)); + + assert!(combined.contains("app-server-parent-thread")); + assert!( + !combined.contains("stale-local-thread"), + "app-server fork title lookup should not read local CODEX_HOME" + ); + assert_chatwidget_snapshot!("app_server_forked_thread_history_line", combined); +} + +#[tokio::test] +async fn app_server_forked_thread_history_line_without_app_server_name_ignores_local_snapshot() { + let (chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let mut chat = chat; + let temp = tempdir().expect("tempdir"); + chat.config.codex_home = + codex_utils_absolute_path::AbsolutePathBuf::from_absolute_path(temp.path()) + .expect("temp dir is absolute"); + + let forked_from_id = + ThreadId::from_string("019c2d47-4935-7423-a190-05691f566092").expect("forked id"); + let session_index_entry = format!( + "{{\"id\":\"{forked_from_id}\",\"thread_name\":\"stale-local-thread\",\"updated_at\":\"2024-01-02T00:00:00Z\"}}\n" + ); + std::fs::write(temp.path().join("session_index.jsonl"), session_index_entry) + .expect("write session index"); + + chat.emit_forked_thread_event(forked_from_id, /*fork_parent_title*/ None); + + let history_cell = tokio::time::timeout(std::time::Duration::from_secs(2), async { + loop { + match rx.recv().await { + Some(AppEvent::InsertHistoryCell(cell)) => break cell, + Some(_) => continue, + None => panic!("app event channel closed before forked thread history was emitted"), + } + } + }) + .await + .expect("timed out waiting for forked thread history"); + let combined = lines_to_single_string(&history_cell.display_lines(/*width*/ 80)); + + assert!( + !combined.contains("stale-local-thread"), + "app-server fork title lookup should not read local CODEX_HOME" + ); + assert_chatwidget_snapshot!( + "app_server_forked_thread_history_line_without_app_server_name", + combined + ); +} + #[tokio::test] async fn thread_snapshot_replay_preserves_agent_message_during_review_mode() { let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await; diff --git a/codex-rs/tui/src/chatwidget/tests/side.rs b/codex-rs/tui/src/chatwidget/tests/side.rs index 84f8b027e1..8aaed6d366 100644 --- a/codex-rs/tui/src/chatwidget/tests/side.rs +++ b/codex-rs/tui/src/chatwidget/tests/side.rs @@ -9,7 +9,7 @@ async fn forked_thread_history_line_without_name_shows_id_once_snapshot() { let forked_from_id = ThreadId::from_string("019c2d47-4935-7423-a190-05691f566092").expect("forked id"); - chat.emit_forked_thread_event(forked_from_id); + chat.emit_forked_thread_event(forked_from_id, /*fork_parent_title*/ None); let history_cell = tokio::time::timeout(std::time::Duration::from_secs(2), async { loop { diff --git a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs index e91a11eca5..d255f3e00f 100644 --- a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs +++ b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs @@ -1029,6 +1029,92 @@ async fn agent_turn_complete_notification_does_not_reuse_stale_copy_source() { ); } +#[tokio::test] +async fn slash_copy_uses_latest_surviving_response_after_rollback() { + let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + + chat.handle_codex_event_replay(Event { + id: "user-1".into(), + msg: EventMsg::UserMessage(UserMessageEvent { + message: "foo".to_string(), + images: None, + local_images: Vec::new(), + text_elements: Vec::new(), + }), + }); + chat.handle_codex_event_replay(Event { + id: "agent-1".into(), + msg: EventMsg::AgentMessage(AgentMessageEvent { + message: "foo response".to_string(), + phase: None, + memory_citation: None, + }), + }); + chat.handle_codex_event_replay(Event { + id: "user-2".into(), + msg: EventMsg::UserMessage(UserMessageEvent { + message: "bar".to_string(), + images: None, + local_images: Vec::new(), + text_elements: Vec::new(), + }), + }); + chat.handle_codex_event_replay(Event { + id: "agent-2".into(), + msg: EventMsg::AgentMessage(AgentMessageEvent { + message: "bar response".to_string(), + phase: None, + memory_citation: None, + }), + }); + let _ = drain_insert_history(&mut rx); + assert_eq!(chat.last_agent_markdown_text(), Some("bar response")); + + chat.truncate_agent_copy_history_to_user_turn_count(/*user_turn_count*/ 1); + + assert_eq!(chat.last_agent_markdown_text(), Some("foo response")); + chat.copy_last_agent_markdown_with(|markdown| { + assert_eq!(markdown, "foo response"); + Ok(None) + }); +} + +#[tokio::test] +async fn slash_copy_reports_when_rewind_exceeds_retained_copy_history() { + let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + + chat.handle_codex_event_replay(Event { + id: "user-1".into(), + msg: EventMsg::UserMessage(UserMessageEvent { + message: "foo".to_string(), + images: None, + local_images: Vec::new(), + text_elements: Vec::new(), + }), + }); + chat.handle_codex_event_replay(Event { + id: "agent-1".into(), + msg: EventMsg::AgentMessage(AgentMessageEvent { + message: "foo response".to_string(), + phase: None, + memory_citation: None, + }), + }); + let _ = drain_insert_history(&mut rx); + + chat.truncate_agent_copy_history_to_user_turn_count(/*user_turn_count*/ 0); + chat.dispatch_command(SlashCommand::Copy); + + let cells = drain_insert_history(&mut rx); + let rendered = lines_to_single_string(&cells[0]); + assert!( + rendered.contains( + "Cannot copy that response after rewinding. Only the most recent 32 responses are available to /copy." + ), + "expected evicted-history message, got {rendered:?}" + ); +} + #[tokio::test] async fn slash_exit_requests_exit() { let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; diff --git a/codex-rs/tui/src/chatwidget/tests/status_surface_previews.rs b/codex-rs/tui/src/chatwidget/tests/status_surface_previews.rs new file mode 100644 index 0000000000..b5ef67dd60 --- /dev/null +++ b/codex-rs/tui/src/chatwidget/tests/status_surface_previews.rs @@ -0,0 +1,261 @@ +use super::*; +use crate::bottom_pane::preview_line_for_title_items; +use pretty_assertions::assert_eq; +use ratatui::text::Line; + +fn line_text(line: Line<'static>) -> String { + line.spans + .into_iter() + .map(|span| span.content.into_owned()) + .collect() +} + +fn status_preview_line(chat: &mut ChatWidget, items: &[StatusLineItem]) -> String { + let preview_data = chat.status_surface_preview_data(); + let preview = preview_data + .line_for_items(items.iter().cloned().map(StatusLineItem::preview_item)) + .expect("status preview line"); + line_text(preview) +} + +fn title_preview_line(chat: &mut ChatWidget, items: &[TerminalTitleItem]) -> String { + let preview_data = chat.terminal_title_preview_data(); + let preview = + preview_line_for_title_items(items, &preview_data).expect("terminal title preview line"); + line_text(preview) +} + +fn combined_preview_snapshot( + chat: &mut ChatWidget, + status_items: &[StatusLineItem], + title_items: &[TerminalTitleItem], +) -> String { + normalize_snapshot_paths(format!( + "status line: {}\nterminal title: {}", + status_preview_line(chat, status_items), + title_preview_line(chat, title_items), + )) +} + +fn status_line_popup_snapshot(chat: &mut ChatWidget) -> String { + chat.open_status_line_setup(); + normalize_snapshot_paths(strip_osc8_for_snapshot(&render_bottom_popup( + chat, /*width*/ 100, + ))) +} + +fn terminal_title_popup_snapshot(chat: &mut ChatWidget) -> String { + chat.open_terminal_title_setup(); + normalize_snapshot_paths(strip_osc8_for_snapshot(&render_bottom_popup( + chat, /*width*/ 100, + ))) +} + +fn cache_project_root(chat: &mut ChatWidget, root_name: &str) { + chat.status_line_project_root_name_cache = Some(CachedProjectRootName { + cwd: chat.config.cwd.to_path_buf(), + root_name: Some(root_name.to_string()), + }); +} + +#[tokio::test] +async fn status_surface_preview_lines_live_only_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + cache_project_root(&mut chat, "preview-live-root"); + chat.status_line_branch = Some("feature/live-preview-branch".to_string()); + chat.thread_name = Some("Live preview thread".to_string()); + chat.last_plan_progress = Some((2, 5)); + + let snapshot = combined_preview_snapshot( + &mut chat, + &[ + StatusLineItem::ProjectRoot, + StatusLineItem::GitBranch, + StatusLineItem::ThreadTitle, + ], + &[ + TerminalTitleItem::Project, + TerminalTitleItem::Thread, + TerminalTitleItem::GitBranch, + TerminalTitleItem::TaskProgress, + ], + ); + + assert_chatwidget_snapshot!("status_surface_previews_live_only", snapshot); +} + +#[tokio::test] +async fn status_line_setup_popup_live_only_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + cache_project_root(&mut chat, "preview-live-root"); + chat.status_line_branch = Some("feature/live-preview-branch".to_string()); + chat.thread_name = Some("Live preview thread".to_string()); + chat.config.tui_status_line = Some(vec![ + "project-root".to_string(), + "git-branch".to_string(), + "thread-title".to_string(), + ]); + + assert_chatwidget_snapshot!( + "status_line_setup_popup_live_only", + status_line_popup_snapshot(&mut chat) + ); +} + +#[tokio::test] +async fn status_surface_preview_lines_hardcoded_only_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + + let snapshot = combined_preview_snapshot( + &mut chat, + &[ + StatusLineItem::ProjectRoot, + StatusLineItem::GitBranch, + StatusLineItem::ThreadTitle, + ], + &[ + TerminalTitleItem::Thread, + TerminalTitleItem::GitBranch, + TerminalTitleItem::TaskProgress, + ], + ); + + assert_chatwidget_snapshot!("status_surface_previews_hardcoded_only", snapshot); +} + +#[tokio::test] +async fn status_line_setup_popup_hardcoded_only_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + chat.config.tui_status_line = Some(vec![ + "project-root".to_string(), + "git-branch".to_string(), + "thread-title".to_string(), + ]); + + assert_chatwidget_snapshot!( + "status_line_setup_popup_hardcoded_only", + status_line_popup_snapshot(&mut chat) + ); +} + +#[tokio::test] +async fn status_surface_preview_lines_mixed_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + chat.status_line_branch = Some("feature/mixed-preview".to_string()); + chat.thread_name = Some("Mixed preview thread".to_string()); + + let snapshot = combined_preview_snapshot( + &mut chat, + &[ + StatusLineItem::ProjectRoot, + StatusLineItem::GitBranch, + StatusLineItem::ThreadTitle, + ], + &[ + TerminalTitleItem::Project, + TerminalTitleItem::Thread, + TerminalTitleItem::TaskProgress, + ], + ); + + assert_chatwidget_snapshot!("status_surface_previews_mixed", snapshot); +} + +#[tokio::test] +async fn status_line_setup_popup_mixed_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + chat.status_line_branch = Some("feature/mixed-preview".to_string()); + chat.thread_name = Some("Mixed preview thread".to_string()); + chat.config.tui_status_line = Some(vec![ + "project-root".to_string(), + "git-branch".to_string(), + "thread-title".to_string(), + ]); + + assert_chatwidget_snapshot!( + "status_line_setup_popup_mixed", + status_line_popup_snapshot(&mut chat) + ); +} + +#[tokio::test] +async fn terminal_title_setup_popup_live_only_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + cache_project_root(&mut chat, "preview-live-root"); + chat.status_line_branch = Some("feature/live-preview-branch".to_string()); + chat.thread_name = Some("Live preview thread".to_string()); + chat.last_plan_progress = Some((2, 5)); + chat.config.tui_terminal_title = Some(vec![ + "project".to_string(), + "thread".to_string(), + "git-branch".to_string(), + "task-progress".to_string(), + ]); + + assert_chatwidget_snapshot!( + "terminal_title_setup_popup_live_only", + terminal_title_popup_snapshot(&mut chat) + ); +} + +#[tokio::test] +async fn terminal_title_setup_popup_hardcoded_only_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + chat.config.tui_terminal_title = Some(vec![ + "thread".to_string(), + "git-branch".to_string(), + "task-progress".to_string(), + ]); + + assert_chatwidget_snapshot!( + "terminal_title_setup_popup_hardcoded_only", + terminal_title_popup_snapshot(&mut chat) + ); +} + +#[tokio::test] +async fn terminal_title_setup_popup_mixed_snapshot() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + chat.thread_name = Some("Mixed preview thread".to_string()); + chat.config.tui_terminal_title = Some(vec![ + "project".to_string(), + "thread".to_string(), + "task-progress".to_string(), + ]); + + assert_chatwidget_snapshot!( + "terminal_title_setup_popup_mixed", + terminal_title_popup_snapshot(&mut chat) + ); +} + +#[tokio::test] +async fn missing_project_root_uses_different_status_and_title_preview_sources() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + + let status_preview = status_preview_line(&mut chat, &[StatusLineItem::ProjectRoot]); + let title_preview = title_preview_line(&mut chat, &[TerminalTitleItem::Project]); + + assert_eq!(status_preview, "my-project"); + assert_eq!(title_preview, "project"); +} + +#[tokio::test] +async fn terminal_title_preview_uses_title_truncation_for_live_values() { + let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + let long_thread = "This thread title is intentionally much longer than forty-eight characters"; + let long_branch = "feature/this-branch-name-is-intentionally-longer-than-thirty-two"; + chat.thread_name = Some(long_thread.to_string()); + chat.status_line_branch = Some(long_branch.to_string()); + + let preview = title_preview_line( + &mut chat, + &[TerminalTitleItem::Thread, TerminalTitleItem::GitBranch], + ); + let truncated_thread = + ChatWidget::truncate_terminal_title_part(long_thread.to_string(), /*max_chars*/ 48); + let truncated_branch = + ChatWidget::truncate_terminal_title_part(long_branch.to_string(), /*max_chars*/ 32); + + assert_eq!(preview, format!("{truncated_thread} | {truncated_branch}")); +} diff --git a/codex-rs/tui/src/cli.rs b/codex-rs/tui/src/cli.rs index d1cbabf37f..3d47442c90 100644 --- a/codex-rs/tui/src/cli.rs +++ b/codex-rs/tui/src/cli.rs @@ -1,8 +1,9 @@ +use clap::Args; +use clap::FromArgMatches; use clap::Parser; -use clap::ValueHint; use codex_utils_cli::ApprovalModeCliArg; use codex_utils_cli::CliConfigOverrides; -use std::path::PathBuf; +use codex_utils_cli::SharedCliOptions; #[derive(Parser, Debug)] #[command(version)] @@ -11,10 +12,6 @@ pub struct Cli { #[arg(value_name = "PROMPT", value_hint = clap::ValueHint::Other)] pub prompt: Option, - /// Optional image(s) to attach to the initial prompt. - #[arg(long = "image", short = 'i', value_name = "FILE", value_delimiter = ',', num_args = 1..)] - pub images: Vec, - // Internal controls set by the top-level `codex resume` subcommand. // These are not exposed as user flags on the base `codex` command. #[clap(skip)] @@ -53,60 +50,17 @@ pub struct Cli { #[clap(skip)] pub fork_show_all: bool, - /// Model the agent should use. - #[arg(long, short = 'm')] - pub model: Option, - - /// Convenience flag to select the local open source model provider. Equivalent to -c - /// model_provider=oss; verifies a local LM Studio or Ollama server is running. - #[arg(long = "oss", default_value_t = false)] - pub oss: bool, - - /// Specify which local provider to use (lmstudio or ollama). - /// If not specified with --oss, will use config default or show selection. - #[arg(long = "local-provider")] - pub oss_provider: Option, - - /// Configuration profile from config.toml to specify default options. - #[arg(long = "profile", short = 'p')] - pub config_profile: Option, - - /// Select the sandbox policy to use when executing model-generated shell - /// commands. - #[arg(long = "sandbox", short = 's')] - pub sandbox_mode: Option, + #[clap(flatten)] + pub shared: TuiSharedCliOptions, /// Configure when the model requires human approval before executing a command. #[arg(long = "ask-for-approval", short = 'a')] pub approval_policy: Option, - /// Convenience alias for low-friction sandboxed automatic execution (-a on-request, --sandbox workspace-write). - #[arg(long = "full-auto", default_value_t = false)] - pub full_auto: bool, - - /// Skip all confirmation prompts and execute commands without sandboxing. - /// EXTREMELY DANGEROUS. Intended solely for running in environments that are externally sandboxed. - #[arg( - long = "dangerously-bypass-approvals-and-sandbox", - alias = "yolo", - default_value_t = false, - conflicts_with_all = ["approval_policy", "full_auto"] - )] - pub dangerously_bypass_approvals_and_sandbox: bool, - - /// Tell the agent to use the specified directory as its working root. - /// In remote mode, the path is forwarded to the server and resolved there. - #[clap(long = "cd", short = 'C', value_name = "DIR")] - pub cwd: Option, - /// Enable live web search. When enabled, the native Responses `web_search` tool is available to the model (no per‑call approval). #[arg(long = "search", default_value_t = false)] pub web_search: bool, - /// Additional directories that should be writable alongside the primary workspace. - #[arg(long = "add-dir", value_name = "DIR", value_hint = ValueHint::DirPath)] - pub add_dir: Vec, - /// Disable alternate screen mode /// /// Runs the TUI in inline mode, preserving terminal scrollback history. This is useful @@ -118,3 +72,66 @@ pub struct Cli { #[clap(skip)] pub config_overrides: CliConfigOverrides, } + +impl std::ops::Deref for Cli { + type Target = SharedCliOptions; + + fn deref(&self) -> &Self::Target { + &self.shared.0 + } +} + +impl std::ops::DerefMut for Cli { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.shared.0 + } +} + +#[derive(Debug, Default)] +pub struct TuiSharedCliOptions(SharedCliOptions); + +impl TuiSharedCliOptions { + pub fn into_inner(self) -> SharedCliOptions { + self.0 + } +} + +impl std::ops::Deref for TuiSharedCliOptions { + type Target = SharedCliOptions; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl std::ops::DerefMut for TuiSharedCliOptions { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +impl Args for TuiSharedCliOptions { + fn augment_args(cmd: clap::Command) -> clap::Command { + mark_tui_args(SharedCliOptions::augment_args(cmd)) + } + + fn augment_args_for_update(cmd: clap::Command) -> clap::Command { + mark_tui_args(SharedCliOptions::augment_args_for_update(cmd)) + } +} + +impl FromArgMatches for TuiSharedCliOptions { + fn from_arg_matches(matches: &clap::ArgMatches) -> Result { + SharedCliOptions::from_arg_matches(matches).map(Self) + } + + fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> { + self.0.update_from_arg_matches(matches) + } +} + +fn mark_tui_args(cmd: clap::Command) -> clap::Command { + cmd.mut_arg("dangerously_bypass_approvals_and_sandbox", |arg| { + arg.conflicts_with("approval_policy") + }) +} diff --git a/codex-rs/tui/src/debug_config.rs b/codex-rs/tui/src/debug_config.rs index fbaf9f2a10..6cb71792ff 100644 --- a/codex-rs/tui/src/debug_config.rs +++ b/codex-rs/tui/src/debug_config.rs @@ -640,6 +640,7 @@ mod tests { allowed_approval_policies: Some(vec![AskForApproval::OnRequest]), allowed_approvals_reviewers: Some(vec![ApprovalsReviewer::GuardianSubagent]), allowed_sandbox_modes: Some(vec![SandboxModeRequirement::ReadOnly]), + remote_sandbox_config: None, allowed_web_search_modes: Some(vec![WebSearchModeRequirement::Cached]), guardian_policy_config: None, feature_requirements: Some(FeatureRequirementsToml { @@ -843,6 +844,7 @@ approval_policy = "never" allowed_approval_policies: None, allowed_approvals_reviewers: None, allowed_sandbox_modes: None, + remote_sandbox_config: None, allowed_web_search_modes: Some(Vec::new()), guardian_policy_config: None, feature_requirements: None, diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs index 84160e25f8..7c60b2e38a 100644 --- a/codex-rs/tui/src/lib.rs +++ b/codex-rs/tui/src/lib.rs @@ -1387,10 +1387,11 @@ async fn run_ratatui_app( let Cli { prompt, - images, + shared, no_alt_screen, .. } = cli; + let images = shared.into_inner().images; let use_alt_screen = determine_alt_screen_mode(no_alt_screen, config.tui_alternate_screen); tui.set_alt_screen_enabled(use_alt_screen); diff --git a/codex-rs/tui/src/onboarding/onboarding_screen.rs b/codex-rs/tui/src/onboarding/onboarding_screen.rs index c30ee500a8..0c7ebda080 100644 --- a/codex-rs/tui/src/onboarding/onboarding_screen.rs +++ b/codex-rs/tui/src/onboarding/onboarding_screen.rs @@ -139,7 +139,6 @@ impl OnboardingScreen { error: None, })) } - // TODO: add git warning. Self { request_frame: tui.frame_requester(), steps, diff --git a/codex-rs/tui/src/onboarding/trust_directory.rs b/codex-rs/tui/src/onboarding/trust_directory.rs index f04e9f9af9..5a1626fda4 100644 --- a/codex-rs/tui/src/onboarding/trust_directory.rs +++ b/codex-rs/tui/src/onboarding/trust_directory.rs @@ -51,6 +51,23 @@ impl WidgetRef for &TrustDirectoryWidget { ])); column.push(""); + if self.cwd != self.trust_target { + #[allow(clippy::disallowed_methods)] + let git_root_warning = Paragraph::new(format!( + "Note: You’re in a subdirectory of a Git project. Trusting will apply to the repository root: {}", + self.trust_target.display() + )) + .yellow(); + column.push( + git_root_warning + .wrap(Wrap { trim: true }) + .inset(Insets::tlbr( + /*top*/ 0, /*left*/ 2, /*bottom*/ 0, /*right*/ 0, + )), + ); + column.push(""); + } + column.push( Paragraph::new( "Do you trust the contents of this directory? Working with untrusted \ diff --git a/codex-rs/tui/src/skills_helpers.rs b/codex-rs/tui/src/skills_helpers.rs index e02e929d47..730acdcaaf 100644 --- a/codex-rs/tui/src/skills_helpers.rs +++ b/codex-rs/tui/src/skills_helpers.rs @@ -5,12 +5,23 @@ use crate::text_formatting::truncate_text; pub(crate) const SKILL_NAME_TRUNCATE_LEN: usize = 21; -pub(crate) fn skill_display_name(skill: &SkillMetadata) -> &str { - skill +pub(crate) fn skill_display_name(skill: &SkillMetadata) -> String { + if let Some(display_name) = skill .interface .as_ref() .and_then(|interface| interface.display_name.as_deref()) - .unwrap_or(&skill.name) + { + return display_name.to_string(); + } + + if let Some((plugin_name, skill_name)) = skill.name.split_once(':') + && !plugin_name.is_empty() + && !skill_name.is_empty() + { + return format!("{skill_name} ({plugin_name})"); + } + + skill.name.clone() } pub(crate) fn skill_description(skill: &SkillMetadata) -> &str { diff --git a/codex-rs/tui/src/tui.rs b/codex-rs/tui/src/tui.rs index 5cff8521ad..291a8ca63c 100644 --- a/codex-rs/tui/src/tui.rs +++ b/codex-rs/tui/src/tui.rs @@ -57,10 +57,114 @@ mod job_control; /// Target frame interval for UI redraw scheduling. pub(crate) const TARGET_FRAME_INTERVAL: Duration = frame_rate_limiter::MIN_FRAME_INTERVAL; +const DISABLE_KEYBOARD_ENHANCEMENT_ENV_VAR: &str = "CODEX_TUI_DISABLE_KEYBOARD_ENHANCEMENT"; /// A type alias for the terminal type used in this application pub type Terminal = CustomTerminal>; +fn keyboard_enhancement_disabled() -> bool { + let disable_env = std::env::var(DISABLE_KEYBOARD_ENHANCEMENT_ENV_VAR).ok(); + let is_wsl = running_in_wsl(); + let is_vscode_terminal = is_wsl && running_in_vscode_terminal(); + keyboard_enhancement_disabled_for(disable_env.as_deref(), is_wsl, is_vscode_terminal) +} + +fn keyboard_enhancement_disabled_for( + disable_env: Option<&str>, + is_wsl: bool, + is_vscode_terminal: bool, +) -> bool { + if let Some(disabled) = parse_bool_env(disable_env) { + return disabled; + } + + // VS Code running a WSL shell can hide TERM_PROGRAM from the Linux process + // environment, so `running_in_vscode_terminal` also probes the Windows-side + // environment through WSL interop. + is_wsl && is_vscode_terminal +} + +fn parse_bool_env(value: Option<&str>) -> Option { + match value.map(str::trim) { + Some("1") => Some(true), + Some(value) if value.eq_ignore_ascii_case("true") => Some(true), + Some(value) if value.eq_ignore_ascii_case("yes") => Some(true), + Some("0") => Some(false), + Some(value) if value.eq_ignore_ascii_case("false") => Some(false), + Some(value) if value.eq_ignore_ascii_case("no") => Some(false), + _ => None, + } +} + +fn running_in_wsl() -> bool { + #[cfg(target_os = "linux")] + { + crate::clipboard_paste::is_probably_wsl() + } + + #[cfg(not(target_os = "linux"))] + { + false + } +} + +fn running_in_vscode_terminal() -> bool { + vscode_terminal_detected( + std::env::var("TERM_PROGRAM").ok().as_deref(), + windows_term_program().as_deref(), + ) +} + +fn vscode_terminal_detected( + linux_term_program: Option<&str>, + windows_term_program: Option<&str>, +) -> bool { + term_program_is_vscode(linux_term_program) || term_program_is_vscode(windows_term_program) +} + +fn term_program_is_vscode(value: Option<&str>) -> bool { + value.is_some_and(|value| value.eq_ignore_ascii_case("vscode")) +} + +fn windows_term_program() -> Option { + #[cfg(target_os = "linux")] + { + static WINDOWS_TERM_PROGRAM: std::sync::OnceLock> = + std::sync::OnceLock::new(); + WINDOWS_TERM_PROGRAM + .get_or_init(read_windows_term_program) + .clone() + } + + #[cfg(not(target_os = "linux"))] + { + None + } +} + +#[cfg(target_os = "linux")] +fn read_windows_term_program() -> Option { + let output = std::process::Command::new("cmd.exe") + .args(["/d", "/s", "/c", "set TERM_PROGRAM"]) + .stdin(std::process::Stdio::null()) + .stderr(std::process::Stdio::null()) + .output() + .ok()?; + + if !output.status.success() { + return None; + } + + String::from_utf8_lossy(&output.stdout) + .lines() + .find_map(|line| { + line.trim_end_matches('\r') + .strip_prefix("TERM_PROGRAM=") + .map(str::to_string) + }) + .filter(|value| !value.trim().is_empty()) +} + fn should_emit_notification(condition: NotificationCondition, terminal_focused: bool) -> bool { match condition { NotificationCondition::Unfocused => !terminal_focused, @@ -70,7 +174,10 @@ fn should_emit_notification(condition: NotificationCondition, terminal_focused: #[cfg(test)] mod tests { + use super::keyboard_enhancement_disabled_for; + use super::parse_bool_env; use super::should_emit_notification; + use super::vscode_terminal_detected; use codex_config::types::NotificationCondition; #[test] @@ -96,6 +203,68 @@ mod tests { /*terminal_focused*/ false )); } + + #[test] + fn keyboard_enhancement_env_flag_parses_common_values() { + assert_eq!(parse_bool_env(Some("1")), Some(true)); + assert_eq!(parse_bool_env(Some("true")), Some(true)); + assert_eq!(parse_bool_env(Some("YES")), Some(true)); + assert_eq!(parse_bool_env(Some("0")), Some(false)); + assert_eq!(parse_bool_env(Some("false")), Some(false)); + assert_eq!(parse_bool_env(Some("NO")), Some(false)); + assert_eq!(parse_bool_env(Some("unexpected")), None); + assert_eq!(parse_bool_env(/*value*/ None), None); + } + + #[test] + fn keyboard_enhancement_auto_disables_for_vscode_in_wsl() { + assert!(keyboard_enhancement_disabled_for( + /*disable_env*/ None, /*is_wsl*/ true, /*is_vscode_terminal*/ true + )); + } + + #[test] + fn keyboard_enhancement_auto_disable_requires_wsl_and_vscode() { + assert!(!keyboard_enhancement_disabled_for( + /*disable_env*/ None, /*is_wsl*/ true, /*is_vscode_terminal*/ false + )); + assert!(!keyboard_enhancement_disabled_for( + /*disable_env*/ None, /*is_wsl*/ false, /*is_vscode_terminal*/ true + )); + } + + #[test] + fn keyboard_enhancement_env_flag_overrides_auto_detection() { + assert!(!keyboard_enhancement_disabled_for( + Some("0"), + /*is_wsl*/ true, + /*is_vscode_terminal*/ true + )); + assert!(keyboard_enhancement_disabled_for( + Some("1"), + /*is_wsl*/ false, + /*is_vscode_terminal*/ false + )); + } + + #[test] + fn vscode_terminal_detection_uses_linux_and_windows_term_program() { + assert!(vscode_terminal_detected( + Some("vscode"), + /*windows_term_program*/ None + )); + assert!(vscode_terminal_detected( + /*linux_term_program*/ None, + Some("vscode") + )); + assert!(!vscode_terminal_detected( + /*linux_term_program*/ None, + Some("WindowsTerminal") + )); + assert!(!vscode_terminal_detected( + /*linux_term_program*/ None, /*windows_term_program*/ None + )); + } } pub fn set_modes() -> Result<()> { @@ -108,14 +277,16 @@ pub fn set_modes() -> Result<()> { // Some terminals (notably legacy Windows consoles) do not support // keyboard enhancement flags. Attempt to enable them, but continue // gracefully if unsupported. - let _ = execute!( - stdout(), - PushKeyboardEnhancementFlags( - KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES - | KeyboardEnhancementFlags::REPORT_EVENT_TYPES - | KeyboardEnhancementFlags::REPORT_ALTERNATE_KEYS - ) - ); + if !keyboard_enhancement_disabled() { + let _ = execute!( + stdout(), + PushKeyboardEnhancementFlags( + KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES + | KeyboardEnhancementFlags::REPORT_EVENT_TYPES + | KeyboardEnhancementFlags::REPORT_ALTERNATE_KEYS + ) + ); + } let _ = execute!(stdout(), EnableFocusChange); Ok(()) @@ -305,7 +476,8 @@ impl Tui { // Detect keyboard enhancement support before any EventStream is created so the // crossterm poller can acquire its lock without contention. - let enhanced_keys_supported = supports_keyboard_enhancement().unwrap_or(false); + let enhanced_keys_supported = + !keyboard_enhancement_disabled() && supports_keyboard_enhancement().unwrap_or(false); // Cache this to avoid contention with the event reader. supports_color::on_cached(supports_color::Stream::Stdout); let _ = crate::terminal_palette::default_colors(); diff --git a/codex-rs/uds/BUILD.bazel b/codex-rs/uds/BUILD.bazel new file mode 100644 index 0000000000..a539147dd2 --- /dev/null +++ b/codex-rs/uds/BUILD.bazel @@ -0,0 +1,6 @@ +load("//:defs.bzl", "codex_rust_crate") + +codex_rust_crate( + name = "uds", + crate_name = "codex_uds", +) diff --git a/codex-rs/uds/Cargo.toml b/codex-rs/uds/Cargo.toml new file mode 100644 index 0000000000..bc36708919 --- /dev/null +++ b/codex-rs/uds/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "codex-uds" +version.workspace = true +edition.workspace = true +license.workspace = true + +[lib] +name = "codex_uds" +path = "src/lib.rs" + +[lints] +workspace = true + +[dependencies] +tokio = { workspace = true, features = ["fs", "net", "rt"] } + +[target.'cfg(windows)'.dependencies] +async-io = { workspace = true } +tokio-util = { workspace = true, features = ["compat"] } +uds_windows = { workspace = true } + +[dev-dependencies] +pretty_assertions = { workspace = true } +tempfile = { workspace = true } +tokio = { workspace = true, features = [ + "io-util", + "macros", + "rt-multi-thread", +] } diff --git a/codex-rs/uds/src/lib.rs b/codex-rs/uds/src/lib.rs new file mode 100644 index 0000000000..bb6dd31bfc --- /dev/null +++ b/codex-rs/uds/src/lib.rs @@ -0,0 +1,331 @@ +//! Cross-platform async Unix domain socket helpers. + +use std::io::Result as IoResult; +use std::path::Path; +use std::pin::Pin; +use std::task::Context; +use std::task::Poll; + +use tokio::io::AsyncRead; +use tokio::io::AsyncWrite; +use tokio::io::ReadBuf; + +/// Creates `socket_dir` if needed and restricts it to the current user where +/// the platform exposes Unix permissions. +pub async fn prepare_private_socket_directory(socket_dir: impl AsRef) -> IoResult<()> { + platform::prepare_private_socket_directory(socket_dir.as_ref()).await +} + +/// Returns whether `socket_path` points at a stale Unix socket rendezvous path. +/// +/// On Unix this checks the file type. On Windows, `uds_windows` represents the +/// rendezvous as a regular path, so existence is the only useful stale-path +/// signal available. +pub async fn is_stale_socket_path(socket_path: impl AsRef) -> IoResult { + platform::is_stale_socket_path(socket_path.as_ref()).await +} + +/// Async Unix domain socket listener. +pub struct UnixListener { + inner: platform::Listener, +} + +impl UnixListener { + /// Binds a new listener at `socket_path`. + pub async fn bind(socket_path: impl AsRef) -> IoResult { + platform::bind_listener(socket_path.as_ref()) + .await + .map(|inner| Self { inner }) + } + + /// Accepts the next incoming stream. + pub async fn accept(&mut self) -> IoResult { + self.inner.accept().await.map(|inner| UnixStream { inner }) + } +} + +/// Async Unix domain socket stream. +pub struct UnixStream { + inner: platform::Stream, +} + +impl UnixStream { + /// Connects to `socket_path`. + pub async fn connect(socket_path: impl AsRef) -> IoResult { + platform::connect_stream(socket_path.as_ref()) + .await + .map(|inner| Self { inner }) + } +} + +impl AsyncRead for UnixStream { + fn poll_read( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &mut ReadBuf<'_>, + ) -> Poll> { + Pin::new(&mut self.get_mut().inner).poll_read(cx, buf) + } +} + +impl AsyncWrite for UnixStream { + fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll> { + Pin::new(&mut self.get_mut().inner).poll_write(cx, buf) + } + + fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + Pin::new(&mut self.get_mut().inner).poll_flush(cx) + } + + fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + Pin::new(&mut self.get_mut().inner).poll_shutdown(cx) + } +} + +#[cfg(unix)] +mod platform { + use std::io; + use std::io::ErrorKind; + use std::io::Result as IoResult; + use std::os::unix::fs::FileTypeExt; + use std::os::unix::fs::PermissionsExt; + use std::path::Path; + + use tokio::fs; + use tokio::net::UnixListener; + use tokio::net::UnixStream; + + /// Owner-only access keeps the control socket directory private while + /// preserving owner traversal and socket path creation. + const SOCKET_DIR_MODE: u32 = 0o700; + const SOCKET_DIR_PERMISSION_BITS: u32 = 0o777; + + pub(super) type Stream = UnixStream; + + pub(super) struct Listener(UnixListener); + + pub(super) async fn prepare_private_socket_directory(socket_dir: &Path) -> IoResult<()> { + let mut dir_builder = fs::DirBuilder::new(); + dir_builder.mode(SOCKET_DIR_MODE); + match dir_builder.create(socket_dir).await { + Ok(()) => return Ok(()), + Err(err) if err.kind() == ErrorKind::AlreadyExists => {} + Err(err) => return Err(err), + } + + let metadata = fs::symlink_metadata(socket_dir).await?; + if !metadata.is_dir() { + return Err(io::Error::new( + ErrorKind::AlreadyExists, + format!( + "socket directory path exists and is not a directory: {}", + socket_dir.display() + ), + )); + } + + let permissions = metadata.permissions(); + // The SSH-over-UDS control socket is reachable by path, so the + // rendezvous directory must be owner-traversable while denying + // group/other access; exact 0700 fixes insecure modes and unusable + // owner-only modes like 0600. + if permissions.mode() & SOCKET_DIR_PERMISSION_BITS != SOCKET_DIR_MODE { + fs::set_permissions(socket_dir, std::fs::Permissions::from_mode(SOCKET_DIR_MODE)) + .await?; + } + + Ok(()) + } + + pub(super) async fn bind_listener(socket_path: &Path) -> IoResult { + UnixListener::bind(socket_path).map(Listener) + } + + impl Listener { + pub(super) async fn accept(&mut self) -> IoResult { + self.0.accept().await.map(|(stream, _addr)| stream) + } + } + + pub(super) async fn connect_stream(socket_path: &Path) -> IoResult { + UnixStream::connect(socket_path).await + } + + pub(super) async fn is_stale_socket_path(socket_path: &Path) -> IoResult { + Ok(fs::symlink_metadata(socket_path) + .await? + .file_type() + .is_socket()) + } +} + +#[cfg(windows)] +mod platform { + use std::io; + use std::io::Result as IoResult; + use std::net::Shutdown; + use std::ops::Deref; + use std::os::windows::io::AsRawSocket; + use std::os::windows::io::AsSocket; + use std::os::windows::io::BorrowedSocket; + use std::path::Path; + use std::pin::Pin; + use std::task::Context; + use std::task::Poll; + use std::task::ready; + + use async_io::Async; + use tokio::io::AsyncRead; + use tokio::io::AsyncWrite; + use tokio::io::ReadBuf; + use tokio::task; + use tokio_util::compat::Compat; + use tokio_util::compat::FuturesAsyncReadCompatExt; + + pub(super) struct Stream(Compat>); + + pub(super) async fn prepare_private_socket_directory(socket_dir: &Path) -> IoResult<()> { + tokio::fs::create_dir_all(socket_dir).await + } + + pub(super) struct Listener(Async); + + pub(super) async fn bind_listener(socket_path: &Path) -> IoResult { + let socket_path = socket_path.to_path_buf(); + let listener = + spawn_blocking_io(move || uds_windows::UnixListener::bind(socket_path)).await?; + Async::new(WindowsUnixListener::from(listener)).map(Listener) + } + + impl Listener { + pub(super) async fn accept(&mut self) -> IoResult { + let (stream, _addr) = self.0.read_with(|listener| listener.accept()).await?; + Async::new(WindowsUnixStream::from(stream)) + .map(FuturesAsyncReadCompatExt::compat) + .map(Stream) + } + } + + pub(super) async fn connect_stream(socket_path: &Path) -> IoResult { + let socket_path = socket_path.to_path_buf(); + let stream = + spawn_blocking_io(move || uds_windows::UnixStream::connect(socket_path)).await?; + Async::new(WindowsUnixStream::from(stream)) + .map(FuturesAsyncReadCompatExt::compat) + .map(Stream) + } + + pub(super) async fn is_stale_socket_path(socket_path: &Path) -> IoResult { + tokio::fs::try_exists(socket_path).await + } + + async fn spawn_blocking_io( + operation: impl FnOnce() -> IoResult + Send + 'static, + ) -> IoResult + where + T: Send + 'static, + { + task::spawn_blocking(operation) + .await + .map_err(|err| io::Error::other(format!("blocking socket task failed: {err}")))? + } + + pub(super) struct WindowsUnixListener(uds_windows::UnixListener); + + impl From for WindowsUnixListener { + fn from(listener: uds_windows::UnixListener) -> Self { + Self(listener) + } + } + + impl Deref for WindowsUnixListener { + type Target = uds_windows::UnixListener; + + fn deref(&self) -> &Self::Target { + &self.0 + } + } + + impl AsSocket for WindowsUnixListener { + fn as_socket(&self) -> BorrowedSocket<'_> { + unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) } + } + } + + pub(super) struct WindowsUnixStream(uds_windows::UnixStream); + + impl From for WindowsUnixStream { + fn from(stream: uds_windows::UnixStream) -> Self { + Self(stream) + } + } + + impl Deref for WindowsUnixStream { + type Target = uds_windows::UnixStream; + + fn deref(&self) -> &Self::Target { + &self.0 + } + } + + impl AsSocket for WindowsUnixStream { + fn as_socket(&self) -> BorrowedSocket<'_> { + unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) } + } + } + + impl io::Read for WindowsUnixStream { + fn read(&mut self, buf: &mut [u8]) -> IoResult { + io::Read::read(&mut self.0, buf) + } + } + + impl io::Write for WindowsUnixStream { + fn write(&mut self, buf: &[u8]) -> IoResult { + io::Write::write(&mut self.0, buf) + } + + fn flush(&mut self) -> IoResult<()> { + io::Write::flush(&mut self.0) + } + } + + impl AsyncRead for Stream { + fn poll_read( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &mut ReadBuf<'_>, + ) -> Poll> { + Pin::new(&mut self.get_mut().0).poll_read(cx, buf) + } + } + + impl AsyncWrite for Stream { + fn poll_write( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &[u8], + ) -> Poll> { + Pin::new(&mut self.get_mut().0).poll_write(cx, buf) + } + + fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + Pin::new(&mut self.get_mut().0).poll_flush(cx) + } + + fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + let stream = &mut self.get_mut().0; + ready!(Pin::new(&mut *stream).poll_flush(cx))?; + // `Compat>` maps shutdown to `poll_close()`, which only + // flushes for `async_io::Async`; call the socket shutdown directly. + stream.get_ref().get_ref().shutdown(Shutdown::Write)?; + Poll::Ready(Ok(())) + } + } + + unsafe impl async_io::IoSafe for WindowsUnixListener {} + unsafe impl async_io::IoSafe for WindowsUnixStream {} +} + +#[cfg(test)] +mod lib_tests; diff --git a/codex-rs/uds/src/lib_tests.rs b/codex-rs/uds/src/lib_tests.rs new file mode 100644 index 0000000000..1861cb5003 --- /dev/null +++ b/codex-rs/uds/src/lib_tests.rs @@ -0,0 +1,121 @@ +use std::io::ErrorKind; + +use pretty_assertions::assert_eq; +use tokio::io::AsyncReadExt; +use tokio::io::AsyncWriteExt; + +use super::*; + +#[tokio::test] +async fn prepare_private_socket_directory_creates_directory() { + let temp_dir = tempfile::TempDir::new().expect("temp dir"); + let socket_dir = temp_dir.path().join("app-server-control"); + + prepare_private_socket_directory(&socket_dir) + .await + .expect("socket dir should be created"); + + assert!(socket_dir.is_dir()); +} + +#[cfg(unix)] +#[tokio::test] +async fn prepare_private_socket_directory_sets_existing_permissions_to_owner_only() { + use std::os::unix::fs::PermissionsExt; + + let temp_dir = tempfile::TempDir::new().expect("temp dir"); + for mode in [0o755, 0o600] { + let socket_dir = temp_dir.path().join(format!("app-server-control-{mode:o}")); + std::fs::create_dir(&socket_dir).expect("socket dir should be created"); + std::fs::set_permissions(&socket_dir, std::fs::Permissions::from_mode(mode)) + .expect("socket dir permissions should be changed"); + + prepare_private_socket_directory(&socket_dir) + .await + .expect("socket dir permissions should be set exactly"); + + let mode = std::fs::metadata(&socket_dir) + .expect("socket dir metadata") + .permissions() + .mode(); + assert_eq!(mode & 0o777, 0o700); + } +} + +#[cfg(unix)] +#[tokio::test] +async fn regular_file_path_is_not_stale_socket_path() { + let temp_dir = tempfile::TempDir::new().expect("temp dir"); + let regular_file = temp_dir.path().join("not-a-socket"); + std::fs::write(®ular_file, b"not a socket").expect("regular file should be created"); + + assert!( + !is_stale_socket_path(®ular_file) + .await + .expect("stale socket check should succeed") + ); +} + +#[tokio::test] +async fn bound_listener_path_is_stale_socket_path() { + let temp_dir = tempfile::TempDir::new().expect("temp dir"); + let socket_path = temp_dir.path().join("socket"); + let _listener = match UnixListener::bind(&socket_path).await { + Ok(listener) => listener, + Err(err) if err.kind() == ErrorKind::PermissionDenied => { + eprintln!("skipping test: failed to bind unix socket: {err}"); + return; + } + Err(err) => panic!("failed to bind test socket: {err}"), + }; + + assert!( + is_stale_socket_path(&socket_path) + .await + .expect("stale socket check should succeed") + ); +} + +#[tokio::test] +async fn stream_round_trips_data_between_listener_and_client() { + let temp_dir = tempfile::TempDir::new().expect("temp dir"); + let socket_path = temp_dir.path().join("socket"); + let mut listener = match UnixListener::bind(&socket_path).await { + Ok(listener) => listener, + Err(err) if err.kind() == ErrorKind::PermissionDenied => { + eprintln!("skipping test: failed to bind unix socket: {err}"); + return; + } + Err(err) => panic!("failed to bind test socket: {err}"), + }; + + let server_task = tokio::spawn(async move { + let mut server_stream = listener.accept().await.expect("connection should accept"); + let mut request = [0; 7]; + server_stream + .read_exact(&mut request) + .await + .expect("server should read request"); + assert_eq!(&request, b"request"); + server_stream + .write_all(b"response") + .await + .expect("server should write response"); + }); + + let mut client_stream = UnixStream::connect(&socket_path) + .await + .expect("client should connect"); + client_stream + .write_all(b"request") + .await + .expect("client should write request"); + let mut response = [0; 8]; + client_stream + .read_exact(&mut response) + .await + .expect("client should read response"); + assert_eq!(&response, b"response"); + + server_task.await.expect("server task should join"); +} diff --git a/codex-rs/utils/cli/src/lib.rs b/codex-rs/utils/cli/src/lib.rs index ed00d683f9..35e4fd1daf 100644 --- a/codex-rs/utils/cli/src/lib.rs +++ b/codex-rs/utils/cli/src/lib.rs @@ -2,8 +2,10 @@ mod approval_mode_cli_arg; mod config_override; pub(crate) mod format_env_display; mod sandbox_mode_cli_arg; +mod shared_options; pub use approval_mode_cli_arg::ApprovalModeCliArg; pub use config_override::CliConfigOverrides; pub use format_env_display::format_env_display; pub use sandbox_mode_cli_arg::SandboxModeCliArg; +pub use shared_options::SharedCliOptions; diff --git a/codex-rs/utils/cli/src/shared_options.rs b/codex-rs/utils/cli/src/shared_options.rs new file mode 100644 index 0000000000..b9e47c8d84 --- /dev/null +++ b/codex-rs/utils/cli/src/shared_options.rs @@ -0,0 +1,174 @@ +//! Shared command-line flags used by both interactive and non-interactive Codex entry points. + +use crate::SandboxModeCliArg; +use clap::Args; +use std::path::PathBuf; + +#[derive(Args, Debug, Default)] +pub struct SharedCliOptions { + /// Optional image(s) to attach to the initial prompt. + #[arg( + long = "image", + short = 'i', + value_name = "FILE", + value_delimiter = ',', + num_args = 1.. + )] + pub images: Vec, + + /// Model the agent should use. + #[arg(long, short = 'm')] + pub model: Option, + + /// Use open-source provider. + #[arg(long = "oss", default_value_t = false)] + pub oss: bool, + + /// Specify which local provider to use (lmstudio or ollama). + /// If not specified with --oss, will use config default or show selection. + #[arg(long = "local-provider")] + pub oss_provider: Option, + + /// Configuration profile from config.toml to specify default options. + #[arg(long = "profile", short = 'p')] + pub config_profile: Option, + + /// Select the sandbox policy to use when executing model-generated shell + /// commands. + #[arg(long = "sandbox", short = 's')] + pub sandbox_mode: Option, + + /// Convenience alias for low-friction sandboxed automatic execution. + #[arg(long = "full-auto", default_value_t = false)] + pub full_auto: bool, + + /// Skip all confirmation prompts and execute commands without sandboxing. + /// EXTREMELY DANGEROUS. Intended solely for running in environments that are externally sandboxed. + #[arg( + long = "dangerously-bypass-approvals-and-sandbox", + alias = "yolo", + default_value_t = false, + conflicts_with = "full_auto" + )] + pub dangerously_bypass_approvals_and_sandbox: bool, + + /// Tell the agent to use the specified directory as its working root. + #[clap(long = "cd", short = 'C', value_name = "DIR")] + pub cwd: Option, + + /// Additional directories that should be writable alongside the primary workspace. + #[arg(long = "add-dir", value_name = "DIR", value_hint = clap::ValueHint::DirPath)] + pub add_dir: Vec, +} + +impl SharedCliOptions { + pub fn inherit_exec_root_options(&mut self, root: &Self) { + let self_selected_sandbox_mode = self.sandbox_mode.is_some() + || self.full_auto + || self.dangerously_bypass_approvals_and_sandbox; + let Self { + images, + model, + oss, + oss_provider, + config_profile, + sandbox_mode, + full_auto, + dangerously_bypass_approvals_and_sandbox, + cwd, + add_dir, + } = self; + let Self { + images: root_images, + model: root_model, + oss: root_oss, + oss_provider: root_oss_provider, + config_profile: root_config_profile, + sandbox_mode: root_sandbox_mode, + full_auto: root_full_auto, + dangerously_bypass_approvals_and_sandbox: root_dangerously_bypass_approvals_and_sandbox, + cwd: root_cwd, + add_dir: root_add_dir, + } = root; + + if model.is_none() { + model.clone_from(root_model); + } + if *root_oss { + *oss = true; + } + if oss_provider.is_none() { + oss_provider.clone_from(root_oss_provider); + } + if config_profile.is_none() { + config_profile.clone_from(root_config_profile); + } + if sandbox_mode.is_none() { + *sandbox_mode = *root_sandbox_mode; + } + if !self_selected_sandbox_mode { + *full_auto = *root_full_auto; + *dangerously_bypass_approvals_and_sandbox = + *root_dangerously_bypass_approvals_and_sandbox; + } + if cwd.is_none() { + cwd.clone_from(root_cwd); + } + if !root_images.is_empty() { + let mut merged_images = root_images.clone(); + merged_images.append(images); + *images = merged_images; + } + if !root_add_dir.is_empty() { + let mut merged_add_dir = root_add_dir.clone(); + merged_add_dir.append(add_dir); + *add_dir = merged_add_dir; + } + } + + pub fn apply_subcommand_overrides(&mut self, subcommand: Self) { + let subcommand_selected_sandbox_mode = subcommand.sandbox_mode.is_some() + || subcommand.full_auto + || subcommand.dangerously_bypass_approvals_and_sandbox; + let Self { + images, + model, + oss, + oss_provider, + config_profile, + sandbox_mode, + full_auto, + dangerously_bypass_approvals_and_sandbox, + cwd, + add_dir, + } = subcommand; + + if let Some(model) = model { + self.model = Some(model); + } + if oss { + self.oss = true; + } + if let Some(oss_provider) = oss_provider { + self.oss_provider = Some(oss_provider); + } + if let Some(config_profile) = config_profile { + self.config_profile = Some(config_profile); + } + if subcommand_selected_sandbox_mode { + self.sandbox_mode = sandbox_mode; + self.full_auto = full_auto; + self.dangerously_bypass_approvals_and_sandbox = + dangerously_bypass_approvals_and_sandbox; + } + if let Some(cwd) = cwd { + self.cwd = Some(cwd); + } + if !images.is_empty() { + self.images = images; + } + if !add_dir.is_empty() { + self.add_dir.extend(add_dir); + } + } +}