@yemi33/minions 0.1.253 → 0.1.255

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.255 (2026-04-03)
+
+### Features
+-  streaming CC responses — text appears as it arrives via SSE
+
+### Fixes
+-  CC messages no longer show as "queued" after page refresh
+
 ## 0.1.253 (2026-04-03)
 
 ### Fixes

package/dashboard/js/command-center.js

@@ -5,6 +5,8 @@ let _ccMessages = JSON.parse(localStorage.getItem('cc-messages') || '[]');
 let _ccOpen = false;
 let _ccSending = false;
 let _ccQueue = [];
+// Clear stale sending state on page load — SSE streams don't survive refresh
+try { localStorage.removeItem('cc-sending'); } catch {}
 
 function toggleCommandCenter() {
   _ccOpen = !_ccOpen;
@@ -40,7 +42,8 @@ function ccRestoreMessages() {
   // Restore "thinking" indicator if CC was mid-request when page refreshed
   try {
     const sendingState = JSON.parse(localStorage.getItem('cc-sending') || 'null');
-    if (sendingState?.sending && (Date.now() - sendingState.startedAt) < 300000) {
+    // Only restore sending state if very recent (< 10s) — page refresh kills the SSE stream
+    if (sendingState?.sending && (Date.now() - sendingState.startedAt) < 10000) {
       _ccSending = true;
       const elapsed = Date.now() - sendingState.startedAt;
       const thinking = document.createElement('div');
@@ -171,45 +174,67 @@ async function _ccDoSend(message, skipUserMsg) {
   }, 500);
 
   try {
-    const ccAbort = AbortSignal.timeout(960000);
-    const res = await fetch('/api/command-center', {
+    // Stream response via SSE — shows text as it arrives
+    const res = await fetch('/api/command-center/stream', {
       method: 'POST', headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ message, sessionId: _ccSessionId }),
-      signal: ccAbort
+      body: JSON.stringify({ message }),
+      signal: AbortSignal.timeout(960000)
     });
-    const data = await res.json();
 
-    clearInterval(ccTimer);
-    thinking.remove();
-
-    if (data.error) {
-      const isBusy = data.error.includes('busy');
-      ccAddMessage('assistant', '<span style="color:var(--red)">' + escHtml(data.error) + '</span>' +
-        (isBusy ? ' <button onclick="ccNewSession()" style="margin-top:4px;padding:3px 10px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--blue);cursor:pointer;font-size:10px">Reset CC</button>' : ''));
+    if (!res.ok) {
+      clearInterval(ccTimer);
+      thinking.remove();
+      const errText = await res.text();
+      ccAddMessage('assistant', '<span style="color:var(--red)">' + escHtml(errText || 'CC error') + '</span>' +
+        (errText.includes('busy') ? ' <button onclick="ccNewSession()" style="margin-top:4px;padding:3px 10px;background:var(--surface2);border:1px solid var(--border);border-radius:4px;color:var(--blue);cursor:pointer;font-size:10px">Reset CC</button>' : ''));
       return;
     }
 
-    // Track session — if server started a new session, clear stale frontend messages
-    if (data.sessionId) {
-      if (data.newSession && _ccSessionId && _ccSessionId !== data.sessionId) {
-        // Session was silently reset (expired/turn limit) — clear old messages except the current one
-        const el = document.getElementById('cc-messages');
-        // Keep only the user message we just added (last child)
-        const lastMsg = el.lastElementChild;
-        el.innerHTML = '';
-        if (lastMsg) el.appendChild(lastMsg);
-        _ccMessages = _ccMessages.slice(-1); // Keep only the message we just sent
+    // Create streaming message bubble
+    clearInterval(ccTimer);
+    thinking.remove();
+    const streamDiv = document.createElement('div');
+    streamDiv.className = 'cc-msg assistant';
+    streamDiv.innerHTML = '<span style="color:var(--muted);font-size:11px">Thinking...</span>';
+    document.getElementById('cc-messages').appendChild(streamDiv);
+    let streamedText = '';
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        try {
+          const evt = JSON.parse(line.slice(6));
+          if (evt.type === 'chunk') {
+            streamedText = evt.text; // each chunk is the full text so far for this turn
+            streamDiv.innerHTML = renderMd(streamedText);
+            const msgs = document.getElementById('cc-messages');
+            if (msgs.scrollHeight - msgs.scrollTop - msgs.clientHeight < 150) msgs.scrollTop = msgs.scrollHeight;
+          } else if (evt.type === 'done') {
+            // Final result — replace with rendered markdown + actions
+            const ccElapsed = Math.round((Date.now() - ccStartTime) / 1000);
+            streamDiv.innerHTML = renderMd(evt.text || streamedText || '') +
+              '<div style="font-size:9px;color:var(--muted);margin-top:6px;display:flex;justify-content:flex-end;padding-right:30px">' + ccElapsed + 's</div>';
+            _ccMessages.push({ role: 'assistant', html: streamDiv.innerHTML });
+            if (evt.sessionId) { _ccSessionId = evt.sessionId; ccSaveState(); ccUpdateSessionIndicator(); }
+            if (evt.actions && evt.actions.length > 0) {
+              for (const action of evt.actions) { await ccExecuteAction(action); }
+            }
+          } else if (evt.type === 'error') {
+            streamDiv.innerHTML = '<span style="color:var(--red)">' + escHtml(evt.error) + '</span>';
+          }
+        } catch { /* incomplete JSON */ }
       }
-      _ccSessionId = data.sessionId;
-      ccSaveState();
-      ccUpdateSessionIndicator();
     }
 
-    // Render markdown response
-    const ccElapsed = Math.round((Date.now() - ccStartTime) / 1000);
-    const rendered = renderMd(data.text || '');
-    ccAddMessage('assistant', rendered + '<div style="font-size:9px;color:var(--muted);margin-top:6px;display:flex;justify-content:flex-end;padding-right:30px">' + ccElapsed + 's</div>');
-
     // Execute actions
     if (data.actions && data.actions.length > 0) {
       for (const action of data.actions) {

package/dashboard.js

@@ -2980,6 +2980,55 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     } catch (e) { ccInFlight = false; return jsonReply(res, 500, { error: e.message }); }
   }
 
+  async function handleCommandCenterStream(req, res) {
+    if (checkRateLimit('command-center', 10)) { res.statusCode = 429; res.end('Rate limited'); return; }
+    try {
+      const body = await readBody(req);
+      if (!body.message) { res.statusCode = 400; res.end('message required'); return; }
+      if (ccInFlight && (Date.now() - ccInFlightSince) < CC_INFLIGHT_TIMEOUT_MS) {
+        res.statusCode = 429; res.end('CC busy'); return;
+      }
+      if (ccInFlight) console.log('[CC-stream] Auto-releasing stuck guard');
+      ccInFlight = true;
+      ccInFlightSince = Date.now();
+
+      res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' });
+
+      const sessionId = ccSessionValid() ? ccSession.sessionId : null;
+      const preamble = buildCCStatePreamble();
+      const prompt = preamble + '\n\n---\n\n' + body.message;
+
+      const { callLLMStreaming, trackEngineUsage: trackUsage } = require('./engine/llm');
+      const result = await callLLMStreaming(prompt, CC_STATIC_SYSTEM_PROMPT, {
+        timeout: 900000, label: 'command-center', model: 'sonnet', maxTurns: 50,
+        allowedTools: 'Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch',
+        sessionId,
+        onChunk: (text) => {
+          try { res.write('data: ' + JSON.stringify({ type: 'chunk', text }) + '\n\n'); } catch {}
+        }
+      });
+      trackUsage('command-center', result.usage);
+
+      // Update session
+      const now = Date.now();
+      if (result.sessionId) {
+        ccSession = { sessionId: result.sessionId, createdAt: ccSession.createdAt || now, lastActiveAt: now, turnCount: (ccSession.turnCount || 0) + 1 };
+        safeWrite(path.join(ENGINE_DIR, 'cc-session.json'), ccSession);
+      }
+
+      // Send final result with actions
+      const { text: displayText, actions } = parseCCActions(result.text);
+      res.write('data: ' + JSON.stringify({ type: 'done', text: displayText, actions, sessionId: ccSession.sessionId }) + '\n\n');
+      res.end();
+      ccInFlight = false;
+      ccInFlightSince = 0;
+    } catch (e) {
+      ccInFlight = false;
+      try { res.write('data: ' + JSON.stringify({ type: 'error', error: e.message }) + '\n\n'); } catch {}
+      try { res.end(); } catch {}
+    }
+  }
+
   async function handleSchedulesList(req, res) {
     reloadConfig();
     const schedules = CONFIG.schedules || [];
@@ -3473,6 +3522,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     // Command Center
     { method: 'POST', path: '/api/command-center/new-session', desc: 'Clear active CC session', handler: handleCommandCenterNewSession },
     { method: 'POST', path: '/api/command-center', desc: 'Conversational command center with full minions context', params: 'message, sessionId?', handler: handleCommandCenter },
+    { method: 'POST', path: '/api/command-center/stream', desc: 'Streaming CC — SSE with text chunks as they arrive', params: 'message', handler: handleCommandCenterStream },
 
     // Schedules
     { method: 'POST', path: '/api/schedules/parse-natural', desc: 'Parse natural language schedule text into cron expression', params: 'text', handler: handleSchedulesParseNatural },

package/engine/llm.js

@@ -108,8 +108,81 @@ function isResumeSessionStillValid(result) {
   return false;
 }
 
+/**
+ * Streaming variant of callLLM — emits text chunks via onChunk callback.
+ * Returns the same result object as callLLM when the process completes.
+ * onChunk(text) is called for each assistant text block as it arrives.
+ */
+function callLLMStreaming(promptText, sysPromptText, { timeout = 120000, label = 'llm', model = 'sonnet', maxTurns = 1, allowedTools = '', sessionId = null, onChunk = () => {} } = {}) {
+  return new Promise((resolve) => {
+    const id = uid();
+    const tmpDir = path.join(ENGINE_DIR, 'tmp');
+    if (!require('fs').existsSync(tmpDir)) require('fs').mkdirSync(tmpDir, { recursive: true });
+    const promptPath = path.join(tmpDir, `${label}-prompt-${id}.md`);
+    const sysPath = path.join(tmpDir, `${label}-sys-${id}.md`);
+    safeWrite(promptPath, promptText);
+    safeWrite(sysPath, sysPromptText || '');
+
+    const spawnScript = path.join(ENGINE_DIR, 'spawn-agent.js');
+    const args = [
+      spawnScript, promptPath, sysPath,
+      '--output-format', 'stream-json', '--max-turns', String(maxTurns), '--model', model,
+      '--verbose',
+    ];
+    if (allowedTools) args.push('--allowedTools', allowedTools);
+    args.push('--permission-mode', 'bypassPermissions');
+    if (sessionId) args.push('--resume', sessionId);
+
+    const proc = runFile(process.execPath, args, { cwd: MINIONS_DIR, stdio: ['pipe', 'pipe', 'pipe'], env: cleanChildEnv() });
+
+    let stdout = '';
+    let stderr = '';
+    let lineBuf = '';
+
+    proc.stdout.on('data', d => {
+      const chunk = d.toString();
+      stdout += chunk;
+      lineBuf += chunk;
+      // Parse complete lines for streaming text
+      const lines = lineBuf.split('\n');
+      lineBuf = lines.pop(); // keep incomplete line in buffer
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith('{')) continue;
+        try {
+          const obj = JSON.parse(trimmed);
+          if (obj.type === 'assistant' && obj.message?.content) {
+            for (const block of obj.message.content) {
+              if (block.type === 'text' && block.text) onChunk(block.text);
+            }
+          }
+        } catch { /* incomplete JSON or non-JSON line */ }
+      }
+    });
+    proc.stderr.on('data', d => { stderr += d.toString(); });
+
+    const timer = setTimeout(() => { try { proc.kill('SIGTERM'); } catch {} }, timeout);
+
+    proc.on('close', (code) => {
+      clearTimeout(timer);
+      safeUnlink(promptPath);
+      safeUnlink(sysPath);
+      const parsed = parseStreamJsonOutput(stdout);
+      resolve({ text: parsed.text || '', usage: parsed.usage, sessionId: parsed.sessionId || null, code, stderr, raw: stdout });
+    });
+
+    proc.on('error', (err) => {
+      clearTimeout(timer);
+      safeUnlink(promptPath);
+      safeUnlink(sysPath);
+      resolve({ text: '', usage: null, sessionId: null, code: 1, stderr: err.message, raw: '' });
+    });
+  });
+}
+
 module.exports = {
   callLLM,
+  callLLMStreaming,
   trackEngineUsage,
   isResumeSessionStillValid,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.253",
+  "version": "0.1.255",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"