fix: agent stop works, command approval UI, session cleanup on window close

- Emit session_id from backend so frontend stop button actually works
- Add kill_all_agent_sessions() called on window close (belt+suspenders)
- Add agent_approve_command Tauri command for run_command approval flow
- Add COMMAND_APPROVALS static map for per-session approval oneshots
- Frontend: listen for agent_session_id event and store it
- Frontend: listen for agent_command_approval event, show modal overlay
- Modal shows the exact command with Allow/Block buttons
- Approval waits with cancel-race so Stop also unblocks pending approvals
- Add agentApproveCommand IPC wrapper in tauri.ts

Made-with: Cursor

Author: DLhugly

clif-pad-ide/src-tauri/Cargo.lock

@@ -7,6 +7,32 @@ use uuid::Uuid;
 static AGENT_SESSIONS: std::sync::LazyLock<Arc<Mutex<HashMap<String, tokio::sync::oneshot::Sender<()>>>>> =
     std::sync::LazyLock::new(|| Arc::new(Mutex::new(HashMap::new())));
 
+// Pending command approvals: session_id -> oneshot sender with bool (true=approved)
+static COMMAND_APPROVALS: std::sync::LazyLock<Arc<Mutex<HashMap<String, tokio::sync::oneshot::Sender<bool>>>>> =
+    std::sync::LazyLock::new(|| Arc::new(Mutex::new(HashMap::new())));
+
+/// Frontend calls this to approve or deny a pending run_command
+#[tauri::command]
+pub async fn agent_approve_command(session_id: String, approved: bool) -> Result<(), String> {
+    let tx = {
+        let mut map = COMMAND_APPROVALS.lock().map_err(|e| e.to_string())?;
+        map.remove(&session_id)
+    };
+    if let Some(tx) = tx {
+        let _ = tx.send(approved);
+    }
+    Ok(())
+}
+
+/// Kill all active agent sessions (called on window close)
+pub fn kill_all_agent_sessions() {
+    if let Ok(mut sessions) = AGENT_SESSIONS.lock() {
+        for (_, tx) in sessions.drain() {
+            let _ = tx.send(());
+        }
+    }
+}
+
 /// Tool definitions for OpenAI function-calling format
 fn tool_definitions() -> Vec<serde_json::Value> {
     vec![
@@ -537,6 +563,9 @@ pub async fn agent_chat(
         sessions.insert(session_id.clone(), cancel_tx);
     }
 
+    // Emit session ID to frontend so it can call agent_stop
+    let _ = window.emit("agent_session_id", &session_id);
+
     let sid = session_id.clone();
 
     tokio::spawn(async move {
@@ -571,7 +600,7 @@ pub async fn agent_chat(
 async fn run_agent_loop(
     app: tauri::AppHandle,
     label: &str,
-    _session_id: &str,
+    session_id: &str,
     initial_messages: Vec<super::ai::ChatMessage>,
     model: String,
     api_key: Option<String>,
@@ -889,13 +918,27 @@ async fn run_agent_loop(
                 json!({ "id": id, "name": name, "arguments": args_str }),
             );
 
-            // Execute the tool — for run_command, race against cancel so Stop
-            // works even while a subprocess is still running.
+            // For run_command: request user approval before executing.
+            // Emit approval request, wait for frontend response (or cancel).
             let result = if name == "run_command" {
-                tokio::select! {
-                    res = execute_tool(name, &args, &workspace_dir) => res,
+                let command_preview = args.get("command").and_then(|v| v.as_str()).unwrap_or("").to_string();
+
+                let (approval_tx, approval_rx) = tokio::sync::oneshot::channel::<bool>();
+                {
+                    let mut approvals = COMMAND_APPROVALS.lock().unwrap_or_else(|e| e.into_inner());
+                    approvals.insert(session_id.to_string(), approval_tx);
+                }
+
+                let _ = app.emit_to(label, "agent_command_approval", json!({
+                    "session_id": session_id,
+                    "command": command_preview,
+                    "tool_call_id": id,
+                }));
+
+                // Wait for approval or cancel
+                let approved = tokio::select! {
+                    result = approval_rx => result.unwrap_or(false),
                     _ = async {
-                        // Poll cancel channel every 250ms while command runs
                         loop {
                             tokio::time::sleep(std::time::Duration::from_millis(250)).await;
                             if cancel_rx.try_recv().is_ok() { break; }
@@ -905,6 +948,25 @@ async fn run_agent_loop(
                         let _ = app.emit_to(label, "agent_stream", "[DONE]");
                         return Ok(());
                     }
+                };
+
+                if !approved {
+                    "Command blocked by user.".to_string()
+                } else {
+                    // Execute with cancel-race
+                    tokio::select! {
+                        res = execute_tool(name, &args, &workspace_dir) => res,
+                        _ = async {
+                            loop {
+                                tokio::time::sleep(std::time::Duration::from_millis(250)).await;
+                                if cancel_rx.try_recv().is_ok() { break; }
+                            }
+                        } => {
+                            let _ = app.emit_to(label, "agent_stream", "\n*[Stopped by user]*\n");
+                            let _ = app.emit_to(label, "agent_stream", "[DONE]");
+                            return Ok(());
+                        }
+                    }
                 }
             } else {
                 execute_tool(name, &args, &workspace_dir).await

clif-pad-ide/src-tauri/src/commands/agent.rs

@@ -92,6 +92,8 @@ pub fn run() {
                 if let Some(pty_state) = app.try_state::<PtyState>() {
                     pty_state.kill_all_for_window(&label);
                 }
+                // Kill all active agent sessions
+                commands::agent::kill_all_agent_sessions();
 
                 // Clean up file watchers for this window
                 if let Some(watcher_state) = app.try_state::<WatcherState>() {
@@ -145,6 +147,7 @@ pub fn run() {
             commands::window::create_window,
             commands::agent::agent_chat,
             commands::agent::agent_stop,
+            commands::agent::agent_approve_command,
             commands::security::scan_files_security,
             commands::security::scan_repo_security,
         ])

clif-pad-ide/src-tauri/src/lib.rs

@@ -1,4 +1,4 @@
-import { Component, For, Show, createSignal, createEffect, onMount, onCleanup } from "solid-js";
+import { Component, For, Show, createSignal, createEffect, onMount, onCleanup, type Accessor } from "solid-js";
 import {
   agentMessages,
   agentStreaming,
@@ -16,7 +16,7 @@ import { activeFile, projectRoot } from "../../stores/fileStore";
 import { currentBranch } from "../../stores/gitStore";
 import { settings, updateSettings } from "../../stores/settingsStore";
 import { fontSize } from "../../stores/uiStore";
-import { getApiKey, setApiKey as saveApiKey } from "../../lib/tauri";
+import { getApiKey, setApiKey as saveApiKey, agentApproveCommand } from "../../lib/tauri";
 import ChatMessage from "./ChatMessage";
 import ContextChip from "./ContextChip";
 import type { AgentContext } from "../../types/agent";
@@ -122,6 +122,7 @@ const AgentChatPanel: Component = () => {
   const [modelSort, setModelSort] = createSignal<"name" | "price-asc" | "price-desc" | "ctx">("name");
   const [modelProviderFilter, setModelProviderFilter] = createSignal("all");
   const [hoveredModel, setHoveredModel] = createSignal<string | null>(null);
+  const [pendingCommand, setPendingCommand] = createSignal<{ sessionId: string; command: string; toolCallId: string } | null>(null);
 
   async function fetchOpenRouterModels() {
     if (openRouterModels().length > 0) return;
@@ -168,6 +169,20 @@ const AgentChatPanel: Component = () => {
     await initAgentListeners();
     setInitialized(true);
     await checkApiKey();
+
+    // Listen for run_command approval requests from the agent
+    const { listen } = await import("@tauri-apps/api/event");
+    const unlisten = await listen<{ session_id: string; command: string; tool_call_id: string }>(
+      "agent_command_approval",
+      (event) => {
+        setPendingCommand({
+          sessionId: event.payload.session_id,
+          command: event.payload.command,
+          toolCallId: event.payload.tool_call_id,
+        });
+      }
+    );
+    onCleanup(() => unlisten());
   });
 
   async function checkApiKey() {
@@ -1057,6 +1072,89 @@ const AgentChatPanel: Component = () => {
         </div>
       </Show>
 
+      {/* Command approval prompt */}
+      <Show when={pendingCommand()}>
+        {(cmd) => (
+          <div
+            style={{
+              position: "absolute", inset: "0", "z-index": "60",
+              background: "rgba(0,0,0,0.7)", "backdrop-filter": "blur(4px)",
+              display: "flex", "align-items": "center", "justify-content": "center",
+              padding: "16px",
+            }}
+          >
+            <div
+              style={{
+                background: "var(--bg-surface)", "border-radius": "12px",
+                border: "1px solid var(--border-default)",
+                "box-shadow": "0 16px 48px rgba(0,0,0,0.5)",
+                padding: "20px", width: "100%",
+              }}
+            >
+              <div class="flex items-center gap-2 mb-3">
+                <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="var(--accent-yellow)" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+                  <path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"/>
+                  <line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/>
+                </svg>
+                <span style={{ "font-size": "13px", "font-weight": "700", color: "var(--text-primary)" }}>
+                  Agent wants to run a command
+                </span>
+              </div>
+
+              <div
+                style={{
+                  background: "var(--bg-base)", "border-radius": "8px",
+                  padding: "10px 12px", "margin-bottom": "14px",
+                  "font-family": "var(--font-mono, monospace)", "font-size": "12px",
+                  color: "var(--accent-yellow)", "word-break": "break-all",
+                  border: "1px solid var(--border-muted)",
+                }}
+              >
+                {cmd().command}
+              </div>
+
+              <div class="flex gap-2">
+                <button
+                  class="flex-1 rounded-lg py-2 text-sm font-semibold transition-colors"
+                  style={{
+                    background: "var(--accent-primary)", color: "#fff", border: "none", cursor: "pointer",
+                    "font-size": "13px", "font-weight": "700",
+                  }}
+                  onClick={async () => {
+                    const c = pendingCommand();
+                    if (!c) return;
+                    setPendingCommand(null);
+                    await agentApproveCommand(c.sessionId, true);
+                  }}
+                >
+                  Allow
+                </button>
+                <button
+                  class="flex-1 rounded-lg py-2 text-sm font-semibold transition-colors"
+                  style={{
+                    background: "color-mix(in srgb, var(--accent-red) 12%, transparent)",
+                    color: "var(--accent-red)",
+                    border: "1px solid color-mix(in srgb, var(--accent-red) 25%, transparent)",
+                    cursor: "pointer", "font-size": "13px", "font-weight": "700",
+                  }}
+                  onClick={async () => {
+                    const c = pendingCommand();
+                    if (!c) return;
+                    setPendingCommand(null);
+                    await agentApproveCommand(c.sessionId, false);
+                  }}
+                >
+                  Block
+                </button>
+              </div>
+              <p style={{ "font-size": "10px", color: "var(--text-muted)", "margin-top": "8px", "text-align": "center" }}>
+                The agent will continue with the result either way
+              </p>
+            </div>
+          </div>
+        )}
+      </Show>
+
       {/* Agent status bar — visible when agent loop is active */}
       <Show when={agentStreaming()}>
         <div

clif-pad-ide/src/components/agent/AgentChatPanel.tsx

@@ -247,6 +247,10 @@ export async function agentStop(sessionId: string): Promise<void> {
   return invoke("agent_stop", { sessionId });
 }
 
+export async function agentApproveCommand(sessionId: string, approved: boolean): Promise<void> {
+  return invoke("agent_approve_command", { sessionId, approved });
+}
+
 // Agent event listeners
 export function onAgentStream(callback: (chunk: string) => void): Promise<UnlistenFn> {
   return listen<string>("agent_stream", (event) => callback(event.payload));

clif-pad-ide/src/lib/tauri.ts

@@ -156,6 +156,12 @@ async function initAgentListeners() {
     })
   );
 
+  unlisteners.push(
+    await listen<string>("agent_session_id", (event) => {
+      setAgentSessionId(event.payload);
+    })
+  );
+
   unlisteners.push(
     await listen<void>("agent_done", () => {
       setAgentStreaming(false);