agentgui 1.0.680 → 1.0.682

package/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(git add:*)"
+    ]
+  }
+}

package/CLAUDE.md

@@ -185,26 +185,20 @@ Server broadcasts:
 
 ## Steering
 
-Steering sends a follow-up prompt to a running agent via stdin JSON-RPC:
-```js
-// conv.steer handler sends to proc.stdin:
-{ jsonrpc: '2.0', id: Date.now(), method: 'session/prompt', params: { sessionId, prompt: [{ type: 'text', text }] } }
-```
-
-**Process lookup:** `entry.proc` (set by `onProcess` callback on `activeExecutions` entry) OR `activeProcessesByConvId.get(id)`. Check both — race condition between `activeExecutions` being set and `onProcess` firing.
-
-**Claude Code stdin:** `supportsStdin: true`, `closeStdin: false` in `lib/claude-runner.js`. Stdin must stay open for steering to work.
+Steering stops the running agent (SIGKILL) and immediately resumes with the new message:
 
-**Process lifetime:** After execution ends, process stays alive 30s (steeringTimeout) for follow-up steers. `conv.steer` resets timeout to another 30s on each steer.
+1. `conv.steer` RPC (`ws-handlers-conv.js`) — kills active process, marks session interrupted, creates new user message, calls `startExecution()` to resume
+2. Frontend inject button (`#injectBtn`) — when streaming: reads message input, fires `conv.steer`, clears input
+3. `conv.claudeSessionId` on the conversation row ensures the resumed execution picks up `--resume <sessionId>` automatically
 
 ## Execution State Management
 
 Three parallel state stores (must stay in sync):
-1. **In-memory maps:** `activeExecutions`, `activeProcessesByConvId`, `messageQueues`, `steeringTimeouts`
+1. **In-memory maps:** `activeExecutions`, `messageQueues`
 2. **Database:** `conversations.isStreaming`, `sessions.status`
 3. **WebSocket clients:** `streamingConversations` Set on each client
 
-**`cleanupExecution(conversationId)`** — atomic cleanup function in server.js. Always use this, never inline-delete from maps. Clears all maps, kills process, cancels timeout, sets DB isStreaming=0.
+**`cleanupExecution(conversationId)`** — atomic cleanup function in server.js. Always use this, never inline-delete from maps. Clears `activeExecutions`, sets DB isStreaming=0.
 
 **Queue drain:** If `processMessageWithStreaming` throws, catch block calls `cleanupExecution` and retries drain after 100ms. Queue never deadlocks.
 
@@ -282,7 +276,7 @@ Speech models (~470MB total) are downloaded automatically on server startup. No
 - **`all_conversations_deleted`** must be in `BROADCAST_TYPES` set in server.js or it won't fan-out to all clients.
 - **`streaming_start` and `message_created`** are high-priority in WSOptimizer — they flush immediately, not batched.
 - **Sidebar animation:** `transition: none !important` in index.html CSS — sidebar snaps instantly on toggle by design.
-- **gm plugin requires no `--dangerously-skip-permissions`** flag in claude-runner.js. That flag disables all plugins.
+- **Claude Code always runs with `--dangerously-skip-permissions`** (plugins disabled by design).
 - **Tool status race on startup:** `autoProvision()` broadcasts `tool_status_update` for already-installed tools so the UI shows correct state before the first manual fetch.
 - **Thinking blocks** are transient (not in DB), rendered only via `handleStreamingProgress()` in client.js. The `renderEvent` switch case for `thinking_block` is disabled to prevent double-render.
 - **Terminal output** is base64-encoded (`encoding: 'base64'` field on message). Client decodes with `decodeURIComponent(escape(atob(data)))` pattern for multibyte safety.

package/lib/claude-runner.js

@@ -645,6 +645,7 @@ registry.register({
     if (model) flags.push('--model', model);
     if (resumeSessionId) flags.push('--resume', resumeSessionId);
     if (systemPrompt) flags.push('--append-system-prompt', systemPrompt);
+    flags.push('--dangerously-skip-permissions');
     flags.push(prompt); // positional arg - stdin stays open separately for steering
 
     return flags;

package/lib/ws-handlers-conv.js

@@ -7,7 +7,7 @@ function expandTilde(p) { return p && p.startsWith('~') ? path.join(os.homedir()
 
 export function register(router, deps) {
   const { queries, activeExecutions, messageQueues, rateLimitState,
-    broadcastSync, processMessageWithStreaming, cleanupExecution, activeProcessesByConvId, steeringTimeouts } = deps;
+    broadcastSync, processMessageWithStreaming, cleanupExecution } = deps;
 
   // Per-conversation queue seq counter for event ordering
   const queueSeqByConv = new Map();
@@ -135,33 +135,29 @@ export function register(router, deps) {
     if (!p.content) fail(400, 'Missing content');
 
     const entry = activeExecutions.get(p.id);
-    const proc = (entry && entry.proc) || activeProcessesByConvId.get(p.id);
+    if (!entry) fail(409, 'No active execution to steer');
 
-    if (proc && proc.stdin && !proc.stdin.destroyed) {
-      // Agent is running and stdin is alive — inject prompt directly
-      const message = queries.createMessage(p.id, 'user', p.content);
-      queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
-      broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
+    const { pid, sessionId } = entry;
 
-      const sessionId = entry?.sessionId;
-      const promptRequest = {
-        jsonrpc: '2.0',
-        id: Date.now(),
-        method: 'session/prompt',
-        params: { sessionId, prompt: [{ type: 'text', text: p.content }] }
-      };
-      proc.stdin.write(JSON.stringify(promptRequest) + '\n');
-
-      // Reset steering timeout
-      const existing = steeringTimeouts.get(p.id);
-      if (existing) clearTimeout(existing);
-      const t = setTimeout(() => { activeProcessesByConvId.delete(p.id); steeringTimeouts.delete(p.id); }, 30000);
-      steeringTimeouts.set(p.id, t);
-
-      return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
+    if (pid) {
+      try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch (e) {} }
     }
 
-    fail(409, 'Process not available for steering');
+    if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
+    queries.setIsStreaming(p.id, false);
+    activeExecutions.delete(p.id);
+
+    broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
+
+    const agentId = conv.agentType || conv.agentId || 'claude-code';
+    const model = conv.model || null;
+    const subAgent = conv.subAgent || null;
+    const message = queries.createMessage(p.id, 'user', p.content);
+    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
+    broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
+    startExecution(p.id, message, agentId, model, p.content, subAgent);
+
+    return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
   });
 
   router.handle('msg.ls', (p) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.680",
+  "version": "1.0.682",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -299,8 +299,6 @@ const activeScripts = new Map();
 const messageQueues = new Map();
 const rateLimitState = new Map();
 const activeProcessesByRunId = new Map();
-const activeProcessesByConvId = new Map(); // Store process handles by conversationId for steering
-const steeringTimeouts = new Map(); // Track timeout handles for process cleanup
 const checkpointManager = new CheckpointManager(queries);
 const STUCK_AGENT_THRESHOLD_MS = 1800000;
 const NO_PID_GRACE_PERIOD_MS = 60000;
@@ -315,26 +313,7 @@ const debugLog = (msg) => {
 function cleanupExecution(conversationId, broadcastCompletion = false) {
   debugLog(`[cleanup] Starting cleanup for ${conversationId}`);
 
-  // Clean in-memory maps in atomic block
   activeExecutions.delete(conversationId);
-  const proc = activeProcessesByConvId.get(conversationId);
-  activeProcessesByConvId.delete(conversationId);
-
-  // Cancel steering timeout if present
-  const steeringTimeout = steeringTimeouts.get(conversationId);
-  if (steeringTimeout) {
-    clearTimeout(steeringTimeout);
-    steeringTimeouts.delete(conversationId);
-  }
-
-  // Try to kill process if still alive
-  if (proc) {
-    try {
-      if (proc.kill) proc.kill('SIGTERM');
-    } catch (e) {
-      debugLog(`[cleanup] Error killing process: ${e.message}`);
-    }
-  }
 
   // Clean database state
   queries.setIsStreaming(conversationId, false);
@@ -3724,8 +3703,6 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
         if (entry) entry.pid = pid;
       },
       onProcess: (proc) => {
-        // Store process handle for steering - both maps so steer handler always finds it
-        activeProcessesByConvId.set(conversationId, proc);
         const entry = activeExecutions.get(conversationId);
         if (entry) entry.proc = proc;
       }
@@ -3736,17 +3713,10 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
     // Check if rate limit was already handled in stream detection
     if (rateLimitState.get(conversationId)?.isStreamDetected) {
       debugLog(`[rate-limit] Rate limit already handled in stream for conv ${conversationId}, skipping success handler`);
-      activeProcessesByConvId.delete(conversationId);
       return;
     }
 
     activeExecutions.delete(conversationId);
-    // Keep process alive for steering for up to 30 seconds after execution completes
-    const steeringTimeout = setTimeout(() => {
-      activeProcessesByConvId.delete(conversationId);
-      steeringTimeouts.delete(conversationId);
-    }, 30000);
-    steeringTimeouts.set(conversationId, steeringTimeout);
     batcher.drain();
     debugLog(`[stream] Claude returned ${outputs.length} outputs, sessionId=${claudeSessionId}`);
 
@@ -3909,14 +3879,6 @@ async function processMessageWithStreaming(conversationId, messageId, sessionId,
     if (!rateLimitState.has(conversationId)) {
       cleanupExecution(conversationId);
       drainMessageQueue(conversationId);
-    } else {
-      // Rate limit in flight - keep execution entry for now, but clean process handle
-      activeProcessesByConvId.delete(conversationId);
-      const steeringTimeout = steeringTimeouts.get(conversationId);
-      if (steeringTimeout) {
-        clearTimeout(steeringTimeout);
-        steeringTimeouts.delete(conversationId);
-      }
     }
   }
 }
@@ -4138,8 +4100,7 @@ const wsRouter = new WsRouter();
 
 registerConvHandlers(wsRouter, {
   queries, activeExecutions, messageQueues, rateLimitState,
-  broadcastSync, processMessageWithStreaming, activeProcessesByConvId, steeringTimeouts,
-  cleanupExecution
+  broadcastSync, processMessageWithStreaming, cleanupExecution
 });
 
 console.log('[INIT] About to call registerSessionHandlers, discoveredAgents.length:', discoveredAgents.length);

package/static/js/client.js

@@ -520,16 +520,14 @@ class AgentGUIClient {
             return;
           }
 
-          // Capture message and clear UI immediately (no await)
           const steerMsg = message;
           if (this.ui.messageInput) {
             this.ui.messageInput.value = '';
             this.ui.messageInput.style.height = 'auto';
           }
 
-          // Fire RPC in background, don't await
+          // Stop agent and resume with new message
           window.wsClient.rpc('conv.steer', { id: this.state.currentConversation.id, content: steerMsg })
-            .then(data => console.log('Steer response:', data))
             .catch(err => {
               console.error('Failed to steer:', err);
               this.showError('Failed to steer: ' + err.message);
@@ -537,12 +535,8 @@ class AgentGUIClient {
         } else {
           const instructions = await window.UIDialog.prompt('Enter instructions to inject into the running agent:', '', 'Inject Instructions');
           if (!instructions) return;
-          try {
-            const data = await window.wsClient.rpc('conv.inject', { id: this.state.currentConversation.id, content: instructions });
-            console.log('Inject response:', data);
-          } catch (err) {
-            console.error('Failed to inject:', err);
-          }
+          window.wsClient.rpc('conv.inject', { id: this.state.currentConversation.id, content: instructions })
+            .catch(err => console.error('Failed to inject:', err));
         }
       });
     }
@@ -1409,11 +1403,9 @@ class AgentGUIClient {
         outputEl.appendChild(queueEl);
       }
 
-      const isStreaming = this.state.streamingConversations.has(conversationId);
       queueEl.innerHTML = queue.map((q, i) => `
         <div class="queue-item" data-message-id="${q.messageId}" style="padding:0.5rem 1rem;margin:0.5rem 0;border-radius:0.375rem;background:var(--color-warning);color:#000;font-size:0.875rem;display:flex;align-items:center;gap:0.5rem;">
           <span style="flex:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;">${i + 1}. ${this.escapeHtml(q.content)}</span>
-          ${isStreaming ? `<button class="queue-steer-btn" data-index="${i}" style="padding:0.25rem 0.5rem;background:#06b6d4;border:1px solid #0891b2;border-radius:0.25rem;cursor:pointer;font-size:0.75rem;color:#fff;">Steer</button>` : ''}
           <button class="queue-edit-btn" data-index="${i}" style="padding:0.25rem 0.5rem;background:transparent;border:1px solid #000;border-radius:0.25rem;cursor:pointer;font-size:0.75rem;">Edit</button>
           <button class="queue-delete-btn" data-index="${i}" style="padding:0.25rem 0.5rem;background:transparent;border:1px solid #000;border-radius:0.25rem;cursor:pointer;font-size:0.75rem;">Delete</button>
         </div>
@@ -1422,21 +1414,7 @@ class AgentGUIClient {
       if (!queueEl._listenersAttached) {
         queueEl._listenersAttached = true;
         queueEl.addEventListener('click', async (e) => {
-          if (e.target.classList.contains('queue-steer-btn')) {
-            const index = parseInt(e.target.dataset.index);
-            const q = queue[index];
-            try {
-              const data = await window.wsClient.rpc('conv.steer', { id: conversationId, content: q.content });
-              console.log('Steer response:', data);
-              if (data.ok && data.steered) {
-                // Remove from queue after successful steer
-                await window.wsClient.rpc('q.del', { id: conversationId, messageId: q.messageId });
-              }
-            } catch (err) {
-              console.error('Failed to steer:', err);
-              this.showError('Failed to steer: ' + err.message);
-            }
-          } else if (e.target.classList.contains('queue-delete-btn')) {
+          if (e.target.classList.contains('queue-delete-btn')) {
             const index = parseInt(e.target.dataset.index);
             const msgId = queue[index].messageId;
             if (await window.UIDialog.confirm('Delete this queued message?', 'Delete Message')) {