The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
refactor(shell): remove unused shell exec port adapters
Steven Enamakel35845c733fd1
diff --git a/crates/openhuman-core/src/tools/impl/system/shell.rs b/crates/openhuman-core/src/tools/impl/system/shell.rsindex 02bda9dc85..db497646ed 100644--- a/crates/openhuman-core/src/tools/impl/system/shell.rs+++ b/crates/openhuman-core/src/tools/impl/system/shell.rs@@ -594,283 +594,6 @@ impl ShellHost {}}-#[derive(Debug, Clone, Copy)]-struct HostShellCapability;--/// The host supplies the authorization and execution ports consumed by the-/// generic TinyAgents exec tool. Runtime routing stays in `ShellHost`, where-/// OpenHuman applies its sandbox, SaaS, and command policy.-struct ShellPorts {- host: Arc<ShellHost>,-}--#[async_trait]-impl ExecGate for ShellPorts {- async fn prepare_authorization(&self, args: &Value) -> anyhow::Result<Option<Value>> {- self.host.prepare_authorization(args).await- }-- fn external_effect_with_args(&self, args: &Value) -> bool {- self.host.external_effect_with_args(args)- }-- async fn authorize(- &self,- request: &ExecAuthorizationRequest,- context: Option<&dyn ToolRunContext>,- ) -> Result<ExecPermit, ExecDenied> {- let ExecOperation::Shell { command, category } = &request.operation else {- return Err(ExecDenied(- "shell gate received a non-shell operation".into(),- ));- };-- // Check policy here before issuing a permit. The execution path repeats- // the module analysis immediately before launch to close the approval- // to execution race and to protect workflow-driven direct calls too.- #[cfg(feature = "modules")]- {- let Some(config) = self.host.analysis_config.as_deref() else {- #[cfg(test)]- self.host- .security- .check_gated_command(command)- .map_err(ExecDenied)?;- #[cfg(not(test))]- return Err(ExecDenied("Command analysis is unavailable.".into()));- #[cfg(test)]- return self.permit(context);- };- let analysis = crate::modules::tinybox::analyze_command(config, command.clone())- .await- .map_err(|_| ExecDenied("Command analysis is unavailable.".into()))?;- self.host- .security- .check_gated_command_analysis(&analysis)- .map_err(ExecDenied)?;- }- #[cfg(not(feature = "modules"))]- {- #[cfg(test)]- self.host- .security- .check_gated_command(command)- .map_err(ExecDenied)?;- #[cfg(not(test))]- return Err(ExecDenied("Command analysis is unavailable.".into()));- }-- let _ = category;- self.permit(context)- }-- fn record(&self, event: ExecAuditEvent) {- let (command, risk_level) = match &event.operation {- ExecOperation::Shell { command, category } => {- (command.as_str(), category.as_deref().unwrap_or("unknown"))- }- ExecOperation::Install { .. } => ("<invalid shell operation>", "unknown"),- };- let success = matches!(- event.outcome,- ExecAuditOutcome::Completed { success: true, .. }- );- if let Err(error) = self.host.audit.log_command_event(CommandExecutionLog {- channel: "tool:shell",- command,- risk_level,- approved: event.approval_required,- allowed: event.allowed,- success,- duration_ms: u64::try_from(event.duration.as_millis()).unwrap_or(u64::MAX),- }) {- tracing::warn!(error = %error, channel = "tool:shell", "failed to persist shell audit event");- }- }-}--impl ShellPorts {- fn permit(&self, context: Option<&dyn ToolRunContext>) -> Result<ExecPermit, ExecDenied> {- let action_dir = self.host.effective_action_dir_for_context(context);- let environment = command_environment_for_tool(context)- .as_deref()- .into_iter()- .flat_map(|environment| environment.iter())- .map(|(name, value)| (name.into(), value.into()))- .collect();- Ok(ExecPermit {- action_dir,- environment,- backend_selection: "openhuman-runtime".into(),- backend_capability: ExecBackendCapability::new(HostShellCapability),- })- }-}--#[async_trait]-impl ExecBackend for ShellPorts {- fn shell_flavor(&self) -> ShellFlavor {- match self.host.runtime.shell_flavor() {- crate::modules::tinybox::host_runtime::ShellFlavor::Cmd => ShellFlavor::Cmd,- _ => ShellFlavor::Posix,- }- }-- async fn execute(- &self,- request: ExecRequest,- context: Option<&dyn ToolRunContext>,- _progress: Option<tinyagents_harness_tools::exec::ExecProgress>,- ) -> ExecBackendOutcome {- if request.backend_selection != "openhuman-runtime"- || request- .backend_capability- .downcast_ref::<HostShellCapability>()- .is_none()- {- return ExecBackendOutcome::Refused {- kind: ExecRefusalKind::Preflight,- reason: "OpenHuman runtime was not selected or authorized".into(),- };- }- let Some(command) = request.shell_command else {- return ExecBackendOutcome::Refused {- kind: ExecRefusalKind::Preflight,- reason: "shell command is missing".into(),- };- };- let timeout_secs = request.timeout.map(|timeout| timeout.as_secs());- let (allowed, result) = crate::sandbox::shell_progress::with_shell_progress(- context,- crate::sandbox::shell_progress::HEARTBEAT_INTERVAL,- |meter| async {- self.host- .run_with_security_in_context(- &dispatch_ctx_for_tool(context),- &command,- timeout_secs,- context,- meter,- )- .await- },- )- .await;- if !allowed {- return ExecBackendOutcome::Refused {- kind: ExecRefusalKind::Preflight,- reason: result.output(),- };- }- ExecBackendOutcome::Completed(ExecOutput {- stdout: result.output().into_bytes(),- stderr: Vec::new(),- exit_code: Some(if result.is_error { 1 } else { 0 }),- timed_out: false,- })- }-}--/// Public OpenHuman adapter that presents the upstream generic exec tool.-pub struct ShellTool {- inner: ExecTool,- host: Arc<ShellHost>,-}--impl ShellTool {- pub fn new(- security: Arc<SecurityPolicy>,- runtime: Arc<dyn RuntimeAdapter>,- audit: Arc<AuditLogger>,- ) -> Self {- Self::from_host(Arc::new(ShellHost::new(security, runtime, audit)))- }-- pub fn with_config(- security: Arc<SecurityPolicy>,- runtime: Arc<dyn RuntimeAdapter>,- audit: Arc<AuditLogger>,- config: Arc<Config>,- ) -> Self {- Self::from_host(Arc::new(ShellHost::with_config(- security, runtime, audit, config,- )))- }-- fn from_host(host: Arc<ShellHost>) -> Self {- let ports = Arc::new(ShellPorts {- host: Arc::clone(&host),- });- let gate: Arc<dyn ExecGate> = ports.clone();- let backend: Arc<dyn ExecBackend> = ports;- Self {- inner: ExecTool::new(gate, backend),- host,- }- }-- fn explicit_timeout(&self, requested: Option<u64>) -> Option<Duration> {- self.host.explicit_timeout(requested)- }-- /// Retains the workflow command entry point while the registered agent- /// tool uses TinyAgents' generic ExecTool and the same host policy path.- pub(crate) async fn run_with_security(- &self,- ctx: &DispatchCtx,- command: &str,- requested_timeout: Option<u64>,- ) -> (bool, ToolResult) {- self.host- .run_with_security(ctx, command, requested_timeout)- .await- }-}--#[async_trait]-impl Tool for ShellTool {- fn name(&self) -> &str {- // Preserve OpenHuman's established model-facing tool contract while- // delegating its schema and call behavior to TinyAgents ExecTool.- "shell"- }- fn description(&self) -> &str {- self.inner.description()- }- fn parameters_schema(&self) -> Value {- self.inner.parameters_schema()- }- fn max_result_size_chars(&self) -> Option<usize> {- self.inner.max_result_size_chars()- }- fn timeout_policy(&self, args: &Value) -> ToolTimeout {- self.inner.timeout_policy(args)- }- fn permission_level(&self) -> PermissionLevel {- self.inner.permission_level()- }- fn external_effect_with_args(&self, args: &Value) -> bool {- self.inner.external_effect_with_args(args)- }- async fn prepare_authorization(&self, args: &Value) -> anyhow::Result<Option<Value>> {- self.inner.prepare_authorization(args).await- }- async fn execute(&self, args: Value) -> anyhow::Result<ToolResult> {- self.inner.execute(args).await- }- async fn execute_with_context(- &self,- args: Value,- options: ToolCallOptions,- context: Option<&dyn ToolRunContext>,- ) -> anyhow::Result<ToolResult> {- let _ = &self.host;- self.inner- .execute_with_context(args, options, context)- .await- }-}-#[cfg(test)]#[path = "shell_tests.rs"]mod tests;