Add enable_bang_commands configuration option

- Add EnableBangCommands field to AgentConfig (v2)
- Add enableBangCommands field to Agent struct
- Add WithEnableBangCommands option function
- Wire configuration through teamloader to agents
- Add Runtime interface method CurrentAgentEnableBangCommands()
- Implement for both LocalRuntime and RemoteRuntime
- Update TUI chat page to check permission before executing ! commands
- Add tests for configuration parsing and agent options
- Add example configurations demonstrating the feature

Co-authored-by: dgageot <153495+dgageot@users.noreply.github.com>

Author: Copilot

examples/bang-commands-disabled.yaml

@@ -0,0 +1,23 @@
+#!/usr/bin/env cagent run
+version: "2"
+
+metadata:
+  readme: |
+    This is a demonstration of the enable_bang_commands configuration option.
+    
+    This agent has enable_bang_commands set to false (or omitted, which is the default).
+    When users try to use ! commands, they will see an error message explaining that
+    bang commands are not enabled.
+    
+    This is the recommended configuration for most agents, as it prevents users from
+    accidentally executing shell commands they didn't intend to run.
+
+agents:
+  root:
+    model: openai/gpt-4o
+    description: "Example agent with bang commands disabled (default)"
+    instruction: |
+      You are a helpful assistant focused on providing information and assistance.
+    enable_bang_commands: false
+    toolsets:
+      - type: think

examples/bang-commands-enabled.yaml

@@ -0,0 +1,25 @@
+#!/usr/bin/env cagent run
+version: "2"
+
+metadata:
+  readme: |
+    This is a demonstration of the enable_bang_commands configuration option.
+    Bang commands (!) allow users to execute shell commands directly from the TUI
+    without going through the agent.
+    
+    This agent has enable_bang_commands: true, so you can use commands like:
+    - !ls
+    - !pwd
+    - !echo "Hello World"
+
+agents:
+  root:
+    model: openai/gpt-4o
+    description: "Example agent with bang commands enabled"
+    instruction: |
+      You are a helpful assistant. Users can also execute shell commands directly 
+      using the ! prefix (e.g., !ls, !pwd). This is handled separately from your
+      agent capabilities.
+    enable_bang_commands: true
+    toolsets:
+      - type: think

pkg/agent/agent.go

@@ -26,6 +26,7 @@ type Agent struct {
 	addPromptFiles     []string
 	tools              []tools.Tool
 	commands           map[string]string
+	enableBangCommands bool
 	pendingWarnings    []string
 }
 
@@ -102,6 +103,11 @@ func (a *Agent) Commands() map[string]string {
 	return a.commands
 }
 
+// EnableBangCommands returns whether bang commands (!) are enabled for this agent
+func (a *Agent) EnableBangCommands() bool {
+	return a.enableBangCommands
+}
+
 // Tools returns the tools available to this agent
 func (a *Agent) Tools(ctx context.Context) ([]tools.Tool, error) {
 	a.ensureToolSetsAreStarted(ctx)

pkg/agent/bang_commands_test.go

@@ -0,0 +1,24 @@
+package agent
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEnableBangCommands(t *testing.T) {
+	t.Run("default is false", func(t *testing.T) {
+		a := New("test", "test prompt")
+		assert.False(t, a.EnableBangCommands())
+	})
+
+	t.Run("can enable bang commands", func(t *testing.T) {
+		a := New("test", "test prompt", WithEnableBangCommands(true))
+		assert.True(t, a.EnableBangCommands())
+	})
+
+	t.Run("can explicitly disable bang commands", func(t *testing.T) {
+		a := New("test", "test prompt", WithEnableBangCommands(false))
+		assert.False(t, a.EnableBangCommands())
+	})
+}

pkg/agent/opts.go

@@ -97,6 +97,12 @@ func WithCommands(commands map[string]string) Opt {
 	}
 }
 
+func WithEnableBangCommands(enable bool) Opt {
+	return func(a *Agent) {
+		a.enableBangCommands = enable
+	}
+}
+
 func WithLoadTimeWarnings(warnings []string) Opt {
 	return func(a *Agent) {
 		for _, w := range warnings {

pkg/app/app.go

@@ -46,6 +46,11 @@ func (a *App) ResolveCommand(ctx context.Context, userInput string) string {
 	return runtime.ResolveCommand(ctx, a.runtime, userInput)
 }
 
+// IsBangCommandsEnabled returns whether bang commands are enabled for the current agent
+func (a *App) IsBangCommandsEnabled() bool {
+	return a.runtime.CurrentAgentEnableBangCommands()
+}
+
 // Run one agent loop
 func (a *App) Run(ctx context.Context, cancel context.CancelFunc, message string) {
 	a.cancel = cancel

pkg/config/v2/bang_commands_test.go

@@ -0,0 +1,52 @@
+package v2
+
+import (
+	"testing"
+
+	"github.com/goccy/go-yaml"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEnableBangCommandsParsing(t *testing.T) {
+	t.Run("parse enable_bang_commands true", func(t *testing.T) {
+		yamlConfig := `
+version: "2"
+agents:
+  root:
+    model: openai/gpt-4o
+    enable_bang_commands: true
+`
+		var cfg Config
+		err := yaml.Unmarshal([]byte(yamlConfig), &cfg)
+		require.NoError(t, err)
+		assert.True(t, cfg.Agents["root"].EnableBangCommands)
+	})
+
+	t.Run("parse enable_bang_commands false", func(t *testing.T) {
+		yamlConfig := `
+version: "2"
+agents:
+  root:
+    model: openai/gpt-4o
+    enable_bang_commands: false
+`
+		var cfg Config
+		err := yaml.Unmarshal([]byte(yamlConfig), &cfg)
+		require.NoError(t, err)
+		assert.False(t, cfg.Agents["root"].EnableBangCommands)
+	})
+
+	t.Run("default is false when omitted", func(t *testing.T) {
+		yamlConfig := `
+version: "2"
+agents:
+  root:
+    model: openai/gpt-4o
+`
+		var cfg Config
+		err := yaml.Unmarshal([]byte(yamlConfig), &cfg)
+		require.NoError(t, err)
+		assert.False(t, cfg.Agents["root"].EnableBangCommands)
+	})
+}

pkg/config/v2/types.go

@@ -26,6 +26,7 @@ type AgentConfig struct {
 	NumHistoryItems    int               `json:"num_history_items,omitempty"`
 	AddPromptFiles     []string          `json:"add_prompt_files,omitempty" yaml:"add_prompt_files,omitempty"`
 	Commands           types.Commands    `json:"commands,omitempty"`
+	EnableBangCommands bool              `json:"enable_bang_commands,omitempty"`
 	StructuredOutput   *StructuredOutput `json:"structured_output,omitempty"`
 }
 

pkg/runtime/remote_runtime.go

@@ -77,6 +77,21 @@ func (r *RemoteRuntime) CurrentAgentCommands(ctx context.Context) map[string]str
 	return map[string]string{}
 }
 
+func (r *RemoteRuntime) CurrentAgentEnableBangCommands() bool {
+	cfg, err := r.client.GetAgent(context.Background(), r.agentFilename)
+	if err != nil {
+		return false
+	}
+
+	for agentName, agent := range cfg.Agents {
+		if agentName == r.currentAgent {
+			return agent.EnableBangCommands
+		}
+	}
+
+	return false
+}
+
 // RunStream starts the agent's interaction loop and returns a channel of events
 func (r *RemoteRuntime) RunStream(ctx context.Context, sess *session.Session) <-chan Event {
 	slog.Debug("Starting remote runtime stream", "agent", r.currentAgent, "session_id", r.sessionID)

pkg/runtime/runtime.go

@@ -68,6 +68,8 @@ type Runtime interface {
 	CurrentAgentName() string
 	// CurrentAgentCommands returns the commands for the active agent
 	CurrentAgentCommands(ctx context.Context) map[string]string
+	// CurrentAgentEnableBangCommands returns whether bang commands are enabled for the current agent
+	CurrentAgentEnableBangCommands() bool
 	// RunStream starts the agent's interaction loop and returns a channel of events
 	RunStream(ctx context.Context, sess *session.Session) <-chan Event
 	// Run starts the agent's interaction loop and returns the final messages
@@ -183,6 +185,11 @@ func (r *LocalRuntime) CurrentAgentCommands(context.Context) map[string]string {
 	return r.CurrentAgent().Commands()
 }
 
+// CurrentAgentEnableBangCommands returns whether bang commands are enabled for the current agent
+func (r *LocalRuntime) CurrentAgentEnableBangCommands() bool {
+	return r.CurrentAgent().EnableBangCommands()
+}
+
 // CurrentAgent returns the current agent
 func (r *LocalRuntime) CurrentAgent() *agent.Agent {
 	// We validated already that the agent exists