agentgui 1.0.796 → 1.0.798

package/lib/model-download-machine.js

@@ -0,0 +1,107 @@
+import { createMachine, createActor, assign } from 'xstate';
+
+const machine = createMachine({
+  id: 'model-download',
+  initial: 'idle',
+  context: {
+    progress: null,
+    error: null,
+    startTime: null,
+    waiters: [],
+  },
+  states: {
+    idle: {
+      on: {
+        START: {
+          target: 'downloading',
+          actions: assign({ startTime: () => Date.now(), error: null }),
+        },
+        WAIT: {
+          actions: assign(({ context, event }) => ({
+            waiters: [...context.waiters, event.resolve],
+          })),
+        },
+      },
+    },
+    downloading: {
+      on: {
+        PROGRESS: {
+          actions: assign(({ event }) => ({ progress: event.progress })),
+        },
+        COMPLETE: { target: 'complete' },
+        ERROR: {
+          target: 'error',
+          actions: assign(({ event }) => ({ error: event.error })),
+        },
+        WAIT: {
+          actions: assign(({ context, event }) => ({
+            waiters: [...context.waiters, event.resolve],
+          })),
+        },
+      },
+    },
+    complete: {
+      entry: assign(({ context }) => {
+        for (const resolve of context.waiters) resolve(true);
+        return { waiters: [] };
+      }),
+      on: {
+        RESET: { target: 'idle' },
+      },
+    },
+    error: {
+      entry: assign(({ context }) => {
+        for (const resolve of context.waiters) resolve(false);
+        return { waiters: [] };
+      }),
+      on: {
+        RESET: { target: 'idle' },
+        START: {
+          target: 'downloading',
+          actions: assign({ startTime: () => Date.now(), error: null }),
+        },
+      },
+    },
+  },
+});
+
+let actor = null;
+
+export function getActor() {
+  if (!actor) {
+    actor = createActor(machine);
+    actor.start();
+  }
+  return actor;
+}
+
+export function send(event) {
+  return getActor().send(event);
+}
+
+export function snapshot() {
+  return getActor().getSnapshot();
+}
+
+export function isDownloading() {
+  const s = snapshot();
+  return s.value === 'downloading';
+}
+
+export function isComplete() {
+  const s = snapshot();
+  return s.value === 'complete';
+}
+
+export function isError() {
+  const s = snapshot();
+  return s.value === 'error';
+}
+
+export function getState() {
+  return snapshot().value;
+}
+
+export function getContext() {
+  return snapshot().context;
+}

package/lib/rate-limit-machine.js

@@ -0,0 +1,99 @@
+import { createMachine, createActor, assign } from 'xstate';
+
+const machine = createMachine({
+  id: 'rate-limit',
+  initial: 'normal',
+  context: {
+    retryCount: 0,
+    retryAt: null,
+    cooldownMs: null,
+    isStreamDetected: false,
+  },
+  states: {
+    normal: {
+      entry: assign({ retryCount: 0, retryAt: null, cooldownMs: null, isStreamDetected: false }),
+      on: {
+        HIT: {
+          target: 'limited',
+          actions: assign(({ context, event }) => ({
+            retryCount: context.retryCount + 1,
+            retryAt: event.retryAt,
+            cooldownMs: event.cooldownMs,
+            isStreamDetected: event.isStreamDetected || false,
+          })),
+        },
+      },
+    },
+    limited: {
+      on: {
+        CLEAR: [
+          { guard: ({ context }) => context.retryCount >= 3, target: 'exceeded' },
+          { target: 'normal' },
+        ],
+        HIT: {
+          actions: assign(({ context, event }) => ({
+            retryCount: context.retryCount + 1,
+            retryAt: event.retryAt,
+            cooldownMs: event.cooldownMs,
+            isStreamDetected: event.isStreamDetected || false,
+          })),
+        },
+      },
+    },
+    exceeded: {
+      on: {
+        RESET: { target: 'normal' },
+      },
+    },
+  },
+});
+
+const actors = new Map();
+
+export function getOrCreate(convId) {
+  if (actors.has(convId)) return actors.get(convId);
+  const actor = createActor(machine);
+  actor.start();
+  actors.set(convId, actor);
+  return actor;
+}
+
+export function get(convId) {
+  return actors.get(convId) || null;
+}
+
+export function remove(convId) {
+  const actor = actors.get(convId);
+  if (actor) { actor.stop(); actors.delete(convId); }
+}
+
+export function snapshot(convId) {
+  const actor = actors.get(convId);
+  return actor ? actor.getSnapshot() : null;
+}
+
+export function send(convId, event) {
+  const actor = getOrCreate(convId);
+  actor.send(event);
+  return actor.getSnapshot();
+}
+
+export function isLimited(convId) {
+  const s = snapshot(convId);
+  return s ? s.value === 'limited' : false;
+}
+
+export function isExceeded(convId) {
+  const s = snapshot(convId);
+  return s ? s.value === 'exceeded' : false;
+}
+
+export function getContext(convId) {
+  const s = snapshot(convId);
+  return s ? s.context : null;
+}
+
+export function has(convId) {
+  const s = snapshot(convId);
+  return s ? s.value !== 'normal' : false;
+}

package/lib/script-machine.js

@@ -0,0 +1,81 @@
+import { createMachine, createActor, assign } from 'xstate';
+
+const machine = createMachine({
+  id: 'script',
+  initial: 'idle',
+  context: {
+    process: null,
+    script: null,
+    startTime: null,
+    pid: null,
+  },
+  states: {
+    idle: {
+      entry: assign({ process: null, script: null, startTime: null, pid: null }),
+      on: {
+        START: {
+          target: 'running',
+          actions: assign(({ event }) => ({
+            process: event.process,
+            script: event.script,
+            startTime: Date.now(),
+            pid: event.pid || null,
+          })),
+        },
+      },
+    },
+    running: {
+      on: {
+        STOP: { target: 'stopping' },
+        CLOSE: { target: 'idle' },
+        ERROR: { target: 'idle' },
+      },
+    },
+    stopping: {
+      on: {
+        CLOSE: { target: 'idle' },
+        ERROR: { target: 'idle' },
+      },
+    },
+  },
+});
+
+const actors = new Map();
+
+export function getOrCreate(convId) {
+  if (actors.has(convId)) return actors.get(convId);
+  const actor = createActor(machine);
+  actor.start();
+  actors.set(convId, actor);
+  return actor;
+}
+
+export function get(convId) {
+  return actors.get(convId) || null;
+}
+
+export function remove(convId) {
+  const actor = actors.get(convId);
+  if (actor) { actor.stop(); actors.delete(convId); }
+}
+
+export function snapshot(convId) {
+  const actor = actors.get(convId);
+  return actor ? actor.getSnapshot() : null;
+}
+
+export function send(convId, event) {
+  const actor = getOrCreate(convId);
+  actor.send(event);
+  return actor.getSnapshot();
+}
+
+export function isRunning(convId) {
+  const s = snapshot(convId);
+  return s ? s.value === 'running' || s.value === 'stopping' : false;
+}
+
+export function getContext(convId) {
+  const s = snapshot(convId);
+  return s ? s.context : null;
+}

package/lib/ws-handlers-scripts.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { spawn } from 'child_process';
+import * as scriptMachine from './script-machine.js';
 
 function err(code, message) { const e = new Error(message); e.code = code; throw e; }
 
@@ -19,15 +20,16 @@ export function register(router, deps) {
       hasStart = !!scripts.start;
       hasDev = !!scripts.dev;
     } catch {}
-    const running = activeScripts.has(p.id);
-    const runningScript = running ? activeScripts.get(p.id).script : null;
+    const running = scriptMachine.isRunning(p.id);
+    const ctx = scriptMachine.getContext(p.id);
+    const runningScript = running ? ctx?.script : null;
     return { hasStart, hasDev, running, runningScript };
   });
 
   router.handle('conv.run-script', (p) => {
     const conv = queries.getConversation(p.id);
     if (!conv) err(404, 'Not found');
-    if (activeScripts.has(p.id)) err(409, 'Script already running');
+    if (scriptMachine.isRunning(p.id)) err(409, 'Script already running');
     const script = p.script;
     if (script !== 'start' && script !== 'dev') err(400, 'Invalid script');
     const wd = conv.workingDirectory || STARTUP_CWD;
@@ -39,21 +41,26 @@ export function register(router, deps) {
     delete childEnv.PORT; delete childEnv.BASE_URL; delete childEnv.HOT_RELOAD;
     const isWindows = os.platform() === 'win32';
     const child = spawn('npm', ['run', script], { cwd: wd, stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: childEnv, shell: isWindows });
+    scriptMachine.send(p.id, { type: 'START', process: child, script, pid: child.pid });
     activeScripts.set(p.id, { process: child, script, startTime: Date.now() });
     broadcastSync({ type: 'script_started', conversationId: p.id, script, timestamp: Date.now() });
     const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId: p.id, data: chunk.toString(), stream, timestamp: Date.now() });
     child.stdout.on('data', onData('stdout'));
     child.stderr.on('data', onData('stderr'));
-    child.on('error', (e) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: 1, error: e.message, timestamp: Date.now() }); });
-    child.on('close', (code) => { activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: code || 0, timestamp: Date.now() }); });
+    child.on('error', (e) => { scriptMachine.send(p.id, { type: 'ERROR' }); activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: 1, error: e.message, timestamp: Date.now() }); });
+    child.on('close', (code) => { scriptMachine.send(p.id, { type: 'CLOSE' }); activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: code || 0, timestamp: Date.now() }); });
     return { ok: true, script, pid: child.pid };
   });
 
   router.handle('conv.stop-script', (p) => {
-    const entry = activeScripts.get(p.id);
-    if (!entry) err(404, 'No running script');
-    try { process.kill(-entry.process.pid, 'SIGTERM'); } catch { try { entry.process.kill('SIGTERM'); } catch {} }
-    setTimeout(() => { try { process.kill(-entry.process.pid, 'SIGKILL'); } catch { try { entry.process.kill('SIGKILL'); } catch {} } }, 5000);
+    if (!scriptMachine.isRunning(p.id)) err(404, 'No running script');
+    const ctx = scriptMachine.getContext(p.id);
+    const proc = ctx?.process;
+    scriptMachine.send(p.id, { type: 'STOP' });
+    if (proc) {
+      try { process.kill(-proc.pid, 'SIGTERM'); } catch { try { proc.kill('SIGTERM'); } catch {} }
+      setTimeout(() => { try { process.kill(-proc.pid, 'SIGKILL'); } catch { try { proc.kill('SIGKILL'); } catch {} } }, 5000);
+    }
     return { ok: true };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.796",
+  "version": "1.0.798",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",

package/static/index.html

@@ -290,6 +290,8 @@
   <script defer src="/gm/js/voice-machine.js"></script>
   <script defer src="/gm/js/conv-list-machine.js"></script>
   <script defer src="/gm/js/prompt-machine.js"></script>
+  <script defer src="/gm/js/recording-machine.js"></script>
+  <script defer src="/gm/js/terminal-machine.js"></script>
   <script defer src="/gm/js/conversations.js"></script>
   <script defer src="/gm/lib/msgpackr.min.js"></script>
   <script defer src="/gm/js/websocket-manager.js"></script>

package/static/js/recording-machine.js

@@ -0,0 +1,49 @@
+(function() {
+  const { createMachine, createActor, assign } = XState;
+
+  const recordingMachine = createMachine({
+    id: 'recording',
+    initial: 'idle',
+    context: {
+      error: null,
+    },
+    states: {
+      idle: {
+        entry: assign({ error: null }),
+        on: {
+          START: { target: 'recording' },
+        },
+      },
+      recording: {
+        on: {
+          STOP: { target: 'processing' },
+          ERROR: {
+            target: 'idle',
+            actions: assign(({ event }) => ({ error: event.error || 'Recording failed' })),
+          },
+        },
+      },
+      processing: {
+        on: {
+          COMPLETE: { target: 'idle' },
+          ERROR: {
+            target: 'idle',
+            actions: assign(({ event }) => ({ error: event.error || 'Processing failed' })),
+          },
+        },
+      },
+    },
+  });
+
+  const actor = createActor(recordingMachine);
+  actor.start();
+
+  window.recordingMachineAPI = {
+    send: function(event) { actor.send(event); },
+    getState: function() { return actor.getSnapshot().value; },
+    isRecording: function() { return actor.getSnapshot().value === 'recording'; },
+    isProcessing: function() { return actor.getSnapshot().value === 'processing'; },
+    subscribe: function(fn) { return actor.subscribe(fn); },
+  };
+  window.__recordingMachine = actor;
+})();

package/static/js/stt-handler.js

@@ -7,11 +7,13 @@
   var recordedChunks = [];
   var TARGET_SAMPLE_RATE = 16000;
 
+  function rmApi() { return window.recordingMachineAPI; }
+
   window.STTHandler = {
-    isRecording: function() { return isRecording; },
+    isRecording: function() { return rmApi()?.isRecording() || isRecording; },
 
     startRecording: async function() {
-      if (isRecording) return;
+      if (isRecording || rmApi()?.isRecording()) return;
       try {
         mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
         audioContext = new (window.AudioContext || window.webkitAudioContext)();
@@ -24,16 +26,19 @@
         };
         source.connect(workletNode);
         isRecording = true;
+        if (rmApi()) rmApi().send({ type: 'START' });
         return { success: true };
       } catch (e) {
         isRecording = false;
+        if (rmApi()) rmApi().send({ type: 'ERROR', error: e.message });
         return { success: false, error: e.message };
       }
     },
 
     stopRecording: async function() {
-      if (!isRecording) return { success: false, error: 'Not recording' };
+      if (!isRecording && !rmApi()?.isRecording()) return { success: false, error: 'Not recording' };
       isRecording = false;
+      if (rmApi()) rmApi().send({ type: 'STOP' });
 
       if (workletNode) {
         workletNode.port.postMessage('stop');
@@ -77,13 +82,17 @@
         });
         var data = await resp.json();
         if (data.text) {
+          if (rmApi()) rmApi().send({ type: 'COMPLETE' });
           return { success: true, text: data.text };
         } else if (data.error) {
+          if (rmApi()) rmApi().send({ type: 'ERROR', error: data.error });
           return { success: false, error: data.error };
         } else {
+          if (rmApi()) rmApi().send({ type: 'ERROR', error: 'No transcription returned' });
           return { success: false, error: 'No transcription returned' };
         }
       } catch (e) {
+        if (rmApi()) rmApi().send({ type: 'ERROR', error: e.message });
         return { success: false, error: 'Transcription failed: ' + e.message };
       }
     }

package/static/js/terminal-machine.js

@@ -0,0 +1,51 @@
+(function() {
+  const { createMachine, createActor, assign } = XState;
+
+  const terminalMachine = createMachine({
+    id: 'terminal',
+    initial: 'inactive',
+    context: {
+      cwd: null,
+    },
+    states: {
+      inactive: {
+        on: {
+          START: { target: 'initializing' },
+        },
+      },
+      initializing: {
+        on: {
+          READY: { target: 'active' },
+          ERROR: { target: 'inactive' },
+        },
+      },
+      active: {
+        on: {
+          STOP: { target: 'inactive' },
+          SESSION_EXIT: { target: 'restarting' },
+          SET_CWD: {
+            actions: assign(({ event }) => ({ cwd: event.cwd })),
+          },
+        },
+      },
+      restarting: {
+        on: {
+          READY: { target: 'active' },
+          ERROR: { target: 'inactive' },
+          STOP: { target: 'inactive' },
+        },
+      },
+    },
+  });
+
+  const actor = createActor(terminalMachine);
+  actor.start();
+
+  window.terminalMachineAPI = {
+    send: function(event) { actor.send(event); },
+    getState: function() { return actor.getSnapshot().value; },
+    isActive: function() { var s = actor.getSnapshot().value; return s === 'active' || s === 'restarting'; },
+    subscribe: function(fn) { return actor.subscribe(fn); },
+  };
+  window.__terminalMachine = actor;
+})();

package/static/js/terminal.js

@@ -101,10 +101,14 @@
     var cwd = getCwd();
     var dims = term ? { cols: term.cols, rows: term.rows } : { cols: 80, rows: 24 };
     wsSend({ type: 'terminal_start', cwd: cwd, cols: dims.cols, rows: dims.rows });
+    if (tmApi()) tmApi().send({ type: 'READY' });
     setTimeout(function() { if (term && term.focus) term.focus(); }, 100);
   }
 
+  function tmApi() { return window.terminalMachineAPI; }
+
   function startTerminal() {
+    if (tmApi()) tmApi().send({ type: 'START' });
     if (!ensureTerm()) {
       setTimeout(startTerminal, 200);
       return;
@@ -124,6 +128,7 @@
 
   function stopTerminal() {
     termActive = false;
+    if (tmApi()) tmApi().send({ type: 'STOP' });
     if (_wsListener && window.wsManager) { window.wsManager.off('message', _wsListener); _wsListener = null; }
     wsSend({ type: 'terminal_stop' });
   }