mirror of
https://github.com/openai/codex.git
synced 2026-04-28 02:11:08 +03:00
89591e4246
feature: Add "!cmd" user shell execution
This change lets users run local shell commands directly from the TUI by
prefixing their input with ! (e.g. !ls). Output is truncated to keep the
exec cell usable, and Ctrl-C cleanly
interrupts long-running commands (e.g. !sleep 10000).
**Summary of changes**
- Route Op::RunUserShellCommand through a dedicated UserShellCommandTask
(core/src/tasks/user_shell.rs), keeping the task logic out of codex.rs.
- Reuse the existing tool router: the task constructs a ToolCall for the
local_shell tool and relies on ShellHandler, so no manual MCP tool
lookup is required.
- Emit exec lifecycle events (ExecCommandBegin/ExecCommandEnd) so the
TUI can show command metadata, live output, and exit status.
**End-to-end flow**
**TUI handling**
1. ChatWidget::submit_user_message (TUI) intercepts messages starting
with !.
2. Non-empty commands dispatch Op::RunUserShellCommand { command };
empty commands surface a help hint.
3. No UserInput items are created, so nothing is enqueued for the model.
**Core submission loop**
4. The submission loop routes the op to handlers::run_user_shell_command
(core/src/codex.rs).
5. A fresh TurnContext is created and Session::spawn_user_shell_command
enqueues UserShellCommandTask.
**Task execution**
6. UserShellCommandTask::run emits TaskStartedEvent, formats the
command, and prepares a ToolCall targeting local_shell.
7. ToolCallRuntime::handle_tool_call dispatches to ShellHandler.
**Shell tool runtime**
8. ShellHandler::run_exec_like launches the process via the unified exec
runtime, honoring sandbox and shell policies, and emits
ExecCommandBegin/End.
9. Stdout/stderr are captured for the UI, but the task does not turn the
resulting ToolOutput into a model response.
**Completion**
10. After ExecCommandEnd, the task finishes without an assistant
message; the session marks it complete and the exec cell displays the
final output.
**Conversation context**
- The command and its output never enter the conversation history or the
model prompt; the flow is local-only.
- Only exec/task events are emitted for UI rendering.
**Demo video**
https://github.com/user-attachments/assets/fcd114b0-4304-4448-a367-a04c43e0b996
113 lines
3.5 KiB
Rust
113 lines
3.5 KiB
Rust
use std::sync::Arc;
|
|
|
|
use async_trait::async_trait;
|
|
use codex_protocol::models::ShellToolCallParams;
|
|
use codex_protocol::user_input::UserInput;
|
|
use tokio::sync::Mutex;
|
|
use tokio_util::sync::CancellationToken;
|
|
use tracing::error;
|
|
use uuid::Uuid;
|
|
|
|
use crate::codex::TurnContext;
|
|
use crate::protocol::EventMsg;
|
|
use crate::protocol::TaskStartedEvent;
|
|
use crate::state::TaskKind;
|
|
use crate::tools::context::ToolPayload;
|
|
use crate::tools::parallel::ToolCallRuntime;
|
|
use crate::tools::router::ToolCall;
|
|
use crate::tools::router::ToolRouter;
|
|
use crate::turn_diff_tracker::TurnDiffTracker;
|
|
|
|
use super::SessionTask;
|
|
use super::SessionTaskContext;
|
|
|
|
const USER_SHELL_TOOL_NAME: &str = "local_shell";
|
|
|
|
#[derive(Clone)]
|
|
pub(crate) struct UserShellCommandTask {
|
|
command: String,
|
|
}
|
|
|
|
impl UserShellCommandTask {
|
|
pub(crate) fn new(command: String) -> Self {
|
|
Self { command }
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl SessionTask for UserShellCommandTask {
|
|
fn kind(&self) -> TaskKind {
|
|
TaskKind::Regular
|
|
}
|
|
|
|
async fn run(
|
|
self: Arc<Self>,
|
|
session: Arc<SessionTaskContext>,
|
|
turn_context: Arc<TurnContext>,
|
|
_input: Vec<UserInput>,
|
|
cancellation_token: CancellationToken,
|
|
) -> Option<String> {
|
|
let event = EventMsg::TaskStarted(TaskStartedEvent {
|
|
model_context_window: turn_context.client.get_model_context_window(),
|
|
});
|
|
let session = session.clone_session();
|
|
session.send_event(turn_context.as_ref(), event).await;
|
|
|
|
// Execute the user's script under their default shell when known; this
|
|
// allows commands that use shell features (pipes, &&, redirects, etc.).
|
|
// We do not source rc files or otherwise reformat the script.
|
|
let shell_invocation = match session.user_shell() {
|
|
crate::shell::Shell::Zsh(zsh) => vec![
|
|
zsh.shell_path.clone(),
|
|
"-lc".to_string(),
|
|
self.command.clone(),
|
|
],
|
|
crate::shell::Shell::Bash(bash) => vec![
|
|
bash.shell_path.clone(),
|
|
"-lc".to_string(),
|
|
self.command.clone(),
|
|
],
|
|
crate::shell::Shell::PowerShell(ps) => vec![
|
|
ps.exe.clone(),
|
|
"-NoProfile".to_string(),
|
|
"-Command".to_string(),
|
|
self.command.clone(),
|
|
],
|
|
crate::shell::Shell::Unknown => {
|
|
shlex::split(&self.command).unwrap_or_else(|| vec![self.command.clone()])
|
|
}
|
|
};
|
|
|
|
let params = ShellToolCallParams {
|
|
command: shell_invocation,
|
|
workdir: None,
|
|
timeout_ms: None,
|
|
with_escalated_permissions: None,
|
|
justification: None,
|
|
};
|
|
|
|
let tool_call = ToolCall {
|
|
tool_name: USER_SHELL_TOOL_NAME.to_string(),
|
|
call_id: Uuid::new_v4().to_string(),
|
|
payload: ToolPayload::LocalShell { params },
|
|
};
|
|
|
|
let router = Arc::new(ToolRouter::from_config(&turn_context.tools_config, None));
|
|
let tracker = Arc::new(Mutex::new(TurnDiffTracker::new()));
|
|
let runtime = ToolCallRuntime::new(
|
|
Arc::clone(&router),
|
|
Arc::clone(&session),
|
|
Arc::clone(&turn_context),
|
|
Arc::clone(&tracker),
|
|
);
|
|
|
|
if let Err(err) = runtime
|
|
.handle_tool_call(tool_call, cancellation_token)
|
|
.await
|
|
{
|
|
error!("user shell command failed: {err:?}");
|
|
}
|
|
None
|
|
}
|
|
}
|