@aion0/forge 0.5.36 → 0.5.38

package/RELEASE_NOTES.md

@@ -1,11 +1,8 @@
-# Forge v0.5.36
+# Forge v0.5.38
 
-Released: 2026-04-11
+Released: 2026-04-14
 
-## Changes since v0.5.35
+## Changes since v0.5.37
 
-### Bug Fixes
-- fix: workspace smith bell always sends to Telegram
 
-
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.35...v0.5.36
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.37...v0.5.38

package/components/WebTerminal.tsx

@@ -1446,6 +1446,8 @@ const MemoTerminalPane = memo(function TerminalPane({
     const MAX_CREATE_RETRIES = 2;
     let reconnectAttempts = 0;
     let isNewlyCreated = false;
+    let lastActivityTime = Date.now();
+    let staleCheckTimer = 0;
 
     function connect() {
       if (disposed) return;
@@ -1455,6 +1457,7 @@ const MemoTerminalPane = memo(function TerminalPane({
       socket.onopen = () => {
         if (disposed) { socket.close(); return; }
         if (socket.readyState !== WebSocket.OPEN) return;
+        lastActivityTime = Date.now();
         const cols = term.cols;
         const rows = term.rows;
 
@@ -1477,6 +1480,7 @@ const MemoTerminalPane = memo(function TerminalPane({
 
       ws.onmessage = (event) => {
         if (disposed || !initDone) return;
+        lastActivityTime = Date.now();
         try {
           const msg = JSON.parse(event.data);
           if (msg.type === 'output') {
@@ -1573,6 +1577,36 @@ const MemoTerminalPane = memo(function TerminalPane({
       };
     }
 
+    // Stale detection: WebSocket may appear "open" after Mac sleep but have no traffic.
+    // If no activity for 60s, force-close and reconnect.
+    staleCheckTimer = window.setInterval(() => {
+      if (disposed) return;
+      if (ws?.readyState === WebSocket.OPEN && Date.now() - lastActivityTime > 60000) {
+        console.warn('[ws] terminal stream stalled, forcing reconnect');
+        lastActivityTime = Date.now();
+        try { ws.close(); } catch {}
+      }
+    }, 20000);
+
+    // Detect tab wake from sleep — only triggers when tab was actually hidden.
+    // Conservative: needs > 60s of inactivity to force reconnect.
+    const onVisibilityChange = () => {
+      if (disposed) return;
+      if (document.visibilityState === 'visible' && Date.now() - lastActivityTime > 60000) {
+        console.log('[ws] terminal visible after long idle, forcing reconnect');
+        lastActivityTime = Date.now();
+        try { ws?.close(); } catch {}
+      }
+    };
+    const onOnline = () => {
+      if (disposed) return;
+      console.log('[ws] network online, reconnecting terminal');
+      lastActivityTime = Date.now();
+      try { ws?.close(); } catch {}
+    };
+    document.addEventListener('visibilitychange', onVisibilityChange);
+    window.addEventListener('online', onOnline);
+
     // NOTE: connect() is called inside initTerminal() — do NOT call it here.
     // Calling it both here and in initTerminal() causes duplicate WebSocket
     // connections to the same tmux session, resulting in doubled output.
@@ -1683,6 +1717,9 @@ const MemoTerminalPane = memo(function TerminalPane({
       visObserver.disconnect();
       clearTimeout(resizeTimer);
       clearTimeout(reconnectTimer);
+      if (staleCheckTimer) clearInterval(staleCheckTimer);
+      document.removeEventListener('visibilitychange', onVisibilityChange);
+      window.removeEventListener('online', onOnline);
       window.removeEventListener('terminal-drag-end', onDragEnd);
       resizeObserver.disconnect();
       // Strict Mode cleanup: if disposed within 2s of mount and we created a

package/components/WorkspaceView.tsx

@@ -280,9 +280,83 @@ function useWorkspaceStream(workspaceId: string | null, onEvent?: (event: any) =
   useEffect(() => {
     if (!workspaceId) return;
 
-    const es = new EventSource(`/api/workspace/${workspaceId}/stream`);
+    // Reconnection state — survives sleep/wake and network drops
+    let es: EventSource | null = null;
+    let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+    let staleCheckTimer: ReturnType<typeof setInterval> | null = null;
+    let reconnectAttempts = 0;
+    let lastEventTime = Date.now();
+    let disposed = false;
+
+    const scheduleReconnect = () => {
+      if (disposed) return;
+      if (reconnectTimer) return;
+      // Exponential backoff: 2s, 4s, 8s, max 30s
+      const delay = Math.min(30000, 2000 * Math.pow(2, reconnectAttempts));
+      reconnectAttempts++;
+      console.log(`[sse] reconnecting in ${delay / 1000}s (attempt ${reconnectAttempts})`);
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        connect();
+      }, delay);
+    };
+
+    const connect = () => {
+      if (disposed) return;
+      try { es?.close(); } catch {}
+      lastEventTime = Date.now();
+      es = new EventSource(`/api/workspace/${workspaceId}/stream`);
+
+      es.onopen = () => {
+        reconnectAttempts = 0;
+        lastEventTime = Date.now();
+      };
+
+      es.onerror = () => {
+        // Browser fires onerror when the connection drops
+        console.warn('[sse] EventSource error — will reconnect');
+        try { es?.close(); } catch {}
+        scheduleReconnect();
+      };
+
+      es.onmessage = (e) => {
+        lastEventTime = Date.now();
+        handleEvent(e);
+      };
+    };
+
+    // Stall detection: if we haven't received any event (including heartbeat ping from server)
+    // for 45s, the connection is stuck (common after Mac sleep). Force reconnect.
+    staleCheckTimer = setInterval(() => {
+      if (disposed) return;
+      if (Date.now() - lastEventTime > 45000) {
+        console.warn('[sse] stream stalled (no events for 45s), forcing reconnect');
+        try { es?.close(); } catch {}
+        lastEventTime = Date.now(); // prevent immediate re-trigger
+        connect();
+      }
+    }, 15000);
+
+    // Detect tab wake from sleep / network recovery — conservative to avoid churn
+    const onVisibilityChange = () => {
+      if (disposed) return;
+      if (document.visibilityState === 'visible' && Date.now() - lastEventTime > 60000) {
+        console.log('[sse] page visible after long idle, reconnecting');
+        try { es?.close(); } catch {}
+        connect();
+      }
+    };
+    const onOnline = () => {
+      if (disposed) return;
+      console.log('[sse] network online, reconnecting');
+      try { es?.close(); } catch {}
+      lastEventTime = Date.now();
+      connect();
+    };
+    document.addEventListener('visibilitychange', onVisibilityChange);
+    window.addEventListener('online', onOnline);
 
-    es.onmessage = (e) => {
+    const handleEvent = (e: MessageEvent) => {
       try {
         const event = JSON.parse(e.data);
 
@@ -408,7 +482,17 @@ function useWorkspaceStream(workspaceId: string | null, onEvent?: (event: any) =
       } catch {}
     };
 
-    return () => es.close();
+    // Start the initial connection
+    connect();
+
+    return () => {
+      disposed = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (staleCheckTimer) clearInterval(staleCheckTimer);
+      document.removeEventListener('visibilitychange', onVisibilityChange);
+      window.removeEventListener('online', onOnline);
+      try { es?.close(); } catch {}
+    };
   }, [workspaceId]);
 
   return { agents, states, logPreview, busLog, setAgents, daemonActive, setDaemonActive };

package/lib/workspace/agent-bus.ts

@@ -63,6 +63,7 @@ export class AgentBus extends EventEmitter {
     };
 
     this.log.push(msg);
+    this.pruneIfNeeded();
     this.emit('message', msg);
 
     // ACK messages don't need delivery tracking
@@ -350,6 +351,35 @@ export class AgentBus extends EventEmitter {
     if (count > 0) console.log(`[bus] Marked ${count} pending messages as failed (restart cleanup)`);
   }
 
+  // ─── Log maintenance ───────────────────────────────────
+
+  private static readonly MAX_LOG_SIZE = 500;
+  private static readonly PRUNE_KEEP = 200;
+
+  /** Prune completed messages to prevent unbounded log growth.
+   *  Keeps: all pending/running messages + last N completed ones.
+   *  Called automatically after each send(). */
+  private pruneIfNeeded(): void {
+    if (this.log.length <= AgentBus.MAX_LOG_SIZE) return;
+
+    // Separate active (must keep) from completed (can prune)
+    const active: BusMessage[] = [];
+    const completed: BusMessage[] = [];
+    for (const m of this.log) {
+      if (m.status === 'pending' || m.status === 'pending_approval' || m.status === 'running') {
+        active.push(m);
+      } else {
+        completed.push(m);
+      }
+    }
+
+    // Keep all active + most recent N completed
+    const keep = completed.slice(-AgentBus.PRUNE_KEEP);
+    this.log = [...active, ...keep].sort((a, b) => a.timestamp - b.timestamp);
+    const pruned = completed.length - keep.length;
+    if (pruned > 0) console.log(`[bus] Pruned ${pruned} completed messages (${this.log.length} remaining)`);
+  }
+
   // ─── Query ─────────────────────────────────────────────
 
   getMessagesFor(agentId: string): BusMessage[] {
@@ -374,6 +404,11 @@ export class AgentBus extends EventEmitter {
     return this.log;
   }
 
+  /** Get log for persistence — excludes _system messages (transient notifications) */
+  getLogForPersistence(): BusMessage[] {
+    return this.log.filter(m => m.to !== '_system');
+  }
+
   /** Get all outbox queues (for persistence) */
   getAllOutbox(): Record<string, BusMessage[]> {
     const result: Record<string, BusMessage[]> = {};
@@ -385,6 +420,7 @@ export class AgentBus extends EventEmitter {
 
   loadLog(messages: BusMessage[]): void {
     this.log = [...messages];
+    this.pruneIfNeeded();
   }
 
   /** Restore outbox from persisted state */

package/lib/workspace/orchestrator.ts

@@ -1870,7 +1870,7 @@ export class WorkspaceOrchestrator extends EventEmitter {
       agents: Array.from(this.agents.values()).map(e => e.config),
       agentStates: this.getAllAgentStates(),
       nodePositions: this.nodePositions,
-      busLog: [...this.bus.getLog()],
+      busLog: this.bus.getLogForPersistence(),
       busOutbox: this.bus.getAllOutbox(),
       createdAt: this.createdAt,
       updatedAt: Date.now(),

package/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.5.36",
+  "version": "0.5.38",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {