sparkecoder 0.1.68 → 0.1.70

package/dist/cli.js

@@ -2556,10 +2556,15 @@ import WebSocket from "ws";
 import { EventEmitter } from "events";
 function getOrCreateProxy(sessionId, port) {
   const existing = activeProxies.get(sessionId);
-  if (existing) return existing;
+  if (existing) {
+    console.log(`[BROWSER-WS] Reusing existing proxy for session ${sessionId} (connected=${existing.connected})`);
+    return existing;
+  }
+  console.log(`[BROWSER-WS] Creating new proxy for session ${sessionId} on port ${port} (active proxies: ${activeProxies.size})`);
   const proxy = new BrowserStreamProxy(port);
   activeProxies.set(sessionId, proxy);
   proxy.on("close", () => {
+    console.log(`[BROWSER-WS] Proxy closed for session ${sessionId}, removing from registry`);
     activeProxies.delete(sessionId);
   });
   proxy.connect();
@@ -2571,8 +2576,11 @@ function getProxy(sessionId) {
 function destroyProxy(sessionId) {
   const proxy = activeProxies.get(sessionId);
   if (proxy) {
+    console.log(`[BROWSER-WS] destroyProxy() called for session ${sessionId}`);
     proxy.destroy();
     activeProxies.delete(sessionId);
+  } else {
+    console.log(`[BROWSER-WS] destroyProxy() called but no proxy exists for session ${sessionId}`);
   }
 }
 var RECONNECT_DELAY_MS, MAX_RECONNECT_ATTEMPTS, FRAME_THROTTLE_MS, BrowserStreamProxy, activeProxies;
@@ -2603,35 +2611,37 @@ var init_stream_proxy = __esm({
       }
       connect() {
         if (this.destroyed) return;
+        console.log(`[BROWSER-WS] connect() called for port ${this.port}`);
         this.doConnect();
       }
       doConnect() {
         if (this.destroyed) return;
         const url = `ws://localhost:${this.port}`;
+        console.log(`[BROWSER-WS] Attempting WebSocket connection to ${url} (attempt ${this.reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})`);
         try {
           this.ws = new WebSocket(url);
-        } catch {
+        } catch (err) {
+          console.warn(`[BROWSER-WS] WebSocket constructor threw for ${url}:`, err);
           this.scheduleReconnect();
           return;
         }
         this.ws.on("open", () => {
+          console.log(`[BROWSER-WS] Connected to ${url} (after ${this.reconnectAttempts} retries)`);
           this.reconnectAttempts = 0;
           this._connected = true;
-          this.emit("status", {
-            connected: true,
-            screencasting: true
-          });
         });
         this.ws.on("message", (raw) => {
           try {
             const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
             this.handleMessage(msg);
-          } catch {
+          } catch (err) {
+            console.warn(`[BROWSER-WS] Malformed message from ${url}:`, err);
           }
         });
-        this.ws.on("close", () => {
+        this.ws.on("close", (code, reason) => {
           const wasConnected = this._connected;
           this._connected = false;
+          console.log(`[BROWSER-WS] Connection closed: code=${code} reason="${reason?.toString() || ""}" wasConnected=${wasConnected} destroyed=${this.destroyed}`);
           if (wasConnected) {
             this.emit("status", { connected: false, screencasting: false });
           }
@@ -2639,14 +2649,26 @@ var init_stream_proxy = __esm({
             this.scheduleReconnect();
           }
         });
-        this.ws.on("error", () => {
+        this.ws.on("error", (err) => {
+          console.warn(`[BROWSER-WS] WebSocket error on port ${this.port}:`, err.message);
         });
       }
+      frameCount = 0;
+      throttledCount = 0;
+      lastFrameLogTime = 0;
       handleMessage(msg) {
         if (msg.type === "frame") {
           const now = Date.now();
-          if (now - this.lastFrameTime < FRAME_THROTTLE_MS) return;
+          if (now - this.lastFrameTime < FRAME_THROTTLE_MS) {
+            this.throttledCount++;
+            return;
+          }
           this.lastFrameTime = now;
+          this.frameCount++;
+          if (now - this.lastFrameLogTime > 5e3) {
+            console.log(`[BROWSER-WS] Frame stats: emitted=${this.frameCount} throttled=${this.throttledCount} listeners=${this.listenerCount("frame")} dataSize=${msg.data?.length ?? 0}`);
+            this.lastFrameLogTime = now;
+          }
           const frame = {
             data: msg.data,
             metadata: msg.metadata ?? {
@@ -2662,21 +2684,26 @@ var init_stream_proxy = __esm({
           this._latestFrame = frame;
           this.emit("frame", frame);
         } else if (msg.type === "status") {
+          console.log(`[BROWSER-WS] Status message received:`, JSON.stringify(msg));
           this.emit("status", {
             connected: msg.connected ?? true,
             screencasting: msg.screencasting ?? true,
             viewportWidth: msg.viewportWidth,
             viewportHeight: msg.viewportHeight
           });
+        } else {
+          console.log(`[BROWSER-WS] Unknown message type: ${msg.type}`);
         }
       }
       scheduleReconnect() {
         if (this.destroyed || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+          console.log(`[BROWSER-WS] Giving up reconnection: destroyed=${this.destroyed} attempts=${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`);
           this.emit("close");
           return;
         }
         this.reconnectAttempts++;
         const delay = this.reconnectAttempts <= 5 ? RECONNECT_DELAY_MS : RECONNECT_DELAY_MS * (this.reconnectAttempts - 4);
+        console.log(`[BROWSER-WS] Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
         this.reconnectTimer = setTimeout(() => this.doConnect(), delay);
       }
       /**
@@ -2687,7 +2714,19 @@ var init_stream_proxy = __esm({
           this.ws.send(JSON.stringify(event));
         }
       }
+      /**
+       * Ask the StreamServer to send its current status (triggers sendStatus and
+       * re-evaluates screencasting). Useful when listeners are replaced on a new
+       * stream and we want a fresh status event.
+       */
+      requestStatus() {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          console.log(`[BROWSER-WS] Requesting fresh status from StreamServer`);
+          this.ws.send(JSON.stringify({ type: "status" }));
+        }
+      }
       destroy() {
+        console.log(`[BROWSER-WS] Destroying proxy for port ${this.port} (emitted ${this.frameCount} frames, throttled ${this.throttledCount})`);
         this.destroyed = true;
         if (this.reconnectTimer) {
           clearTimeout(this.reconnectTimer);
@@ -8841,11 +8880,19 @@ var cleanupInterval = setInterval(() => {
   }
 }, 6e4);
 cleanupInterval.unref();
+var publishCount = 0;
+var lastPublishLog = 0;
 var publisher = {
   connect: async () => {
   },
   publish: async (channel, message) => {
     const subscribers = channels.get(channel);
+    publishCount++;
+    const now = Date.now();
+    if (now - lastPublishLog > 1e4) {
+      console.log(`[ResumableStream] Publish stats: total=${publishCount}, channels=${channels.size}, store=${store.size}`);
+      lastPublishLog = now;
+    }
     if (subscribers) {
       for (const callback of subscribers) {
         setImmediate(() => callback(message));
@@ -8884,9 +8931,12 @@ var subscriber = {
       channels.set(channel, /* @__PURE__ */ new Set());
     }
     channels.get(channel).add(callback);
+    console.log(`[ResumableStream] Subscribe to channel "${channel}" (total subscribers: ${channels.get(channel).size})`);
   },
   unsubscribe: async (channel) => {
+    const count = channels.get(channel)?.size ?? 0;
     channels.delete(channel);
+    console.log(`[ResumableStream] Unsubscribe from channel "${channel}" (removed ${count} subscribers)`);
   }
 };
 var streamContext = createResumableStreamContext({
@@ -9072,19 +9122,28 @@ function createAgentStreamProducer(sessionId, prompt, streamId, attachments) {
     const toolCallStarts = /* @__PURE__ */ new Set();
     const abortController = new AbortController();
     streamAbortControllers.set(streamId, abortController);
+    let sseEventCount = 0;
+    let sseBrowserFrameCount = 0;
+    let sseWriteErrors = 0;
     const writeSSE = async (data) => {
       if (writerClosed) return;
       try {
+        sseEventCount++;
         await writer.write(`data: ${data}
 
 `);
       } catch (err) {
+        sseWriteErrors++;
+        if (sseWriteErrors === 1) {
+          console.log(`[SSE:${streamId}] Writer closed (client disconnected). Total events sent: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}`);
+        }
         writerClosed = true;
       }
     };
     const safeClose = async () => {
       if (writerClosed) return;
       try {
+        console.log(`[SSE:${streamId}] Stream closing. Total events: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}, write errors: ${sseWriteErrors}`);
         writerClosed = true;
         await writer.close();
       } catch {
@@ -9207,36 +9266,51 @@ ${prompt}` });
             const browserPort = progress.data?.browserStreamPort;
             const browserClosed = progress.data?.browserClosed;
             if (progress.toolName === "bash" && browserClosed) {
-              console.log(`[BROWSER-STREAM] agent-browser close detected, destroying proxy`);
+              console.log(`[BROWSER-STREAM:${streamId}] agent-browser close detected, destroying proxy for session ${sessionId}`);
               destroyProxy(sessionId);
             } else if (progress.toolName === "bash" && browserPort) {
-              console.log(`[BROWSER-STREAM] agent-browser command detected, ensuring proxy on port ${browserPort}`);
+              console.log(`[BROWSER-STREAM:${streamId}] agent-browser command detected, ensuring proxy on port ${browserPort} for session ${sessionId}`);
               const proxy = getOrCreateProxy(sessionId, browserPort);
+              console.log(`[BROWSER-STREAM:${streamId}] Proxy state: connected=${proxy.connected}, frameListeners=${proxy.listenerCount("frame")}, statusListeners=${proxy.listenerCount("status")}`);
               if (!sessionRecorders.has(sessionId)) {
                 const recorder = new FrameRecorder(sessionId);
                 recorder.start();
                 sessionRecorders.set(sessionId, recorder);
               }
-              if (proxy.listenerCount("frame") === 0) {
-                proxy.on("frame", (frame) => {
-                  const rec = sessionRecorders.get(sessionId);
-                  rec?.addFrame(frame);
-                  writeSSE(JSON.stringify({
-                    type: "browser-frame",
-                    data: frame.data,
-                    metadata: frame.metadata
-                  })).catch(() => {
-                  });
+              const oldFrameListeners = proxy.listenerCount("frame");
+              if (oldFrameListeners > 0) {
+                console.log(`[BROWSER-STREAM:${streamId}] Replacing ${oldFrameListeners} stale frame listener(s) from previous stream`);
+                proxy.removeAllListeners("frame");
+                proxy.removeAllListeners("status");
+              }
+              console.log(`[BROWSER-STREAM:${streamId}] Attaching frame+status listeners to proxy`);
+              proxy.on("frame", (frame) => {
+                sseBrowserFrameCount++;
+                if (sseBrowserFrameCount === 1) {
+                  console.log(`[BROWSER-STREAM:${streamId}] First browser frame received! dataSize=${frame.data?.length ?? 0} writerClosed=${writerClosed}`);
+                } else if (sseBrowserFrameCount % 50 === 0) {
+                  console.log(`[BROWSER-STREAM:${streamId}] Browser frame #${sseBrowserFrameCount} (writerClosed=${writerClosed})`);
+                }
+                const rec = sessionRecorders.get(sessionId);
+                rec?.addFrame(frame);
+                writeSSE(JSON.stringify({
+                  type: "browser-frame",
+                  data: frame.data,
+                  metadata: frame.metadata
+                })).catch((err) => {
+                  console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-frame via SSE:`, err);
                 });
-                proxy.on("status", (s) => {
-                  console.log(`[BROWSER-STREAM] Status:`, s);
-                  writeSSE(JSON.stringify({
-                    type: "browser-status",
-                    ...s
-                  })).catch(() => {
-                  });
+              });
+              proxy.on("status", (s) => {
+                console.log(`[BROWSER-STREAM:${streamId}] Browser status event: connected=${s.connected} screencasting=${s.screencasting} viewport=${s.viewportWidth}x${s.viewportHeight}`);
+                writeSSE(JSON.stringify({
+                  type: "browser-status",
+                  ...s
+                })).catch((err) => {
+                  console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-status via SSE:`, err);
                 });
-              }
+              });
+              proxy.requestStatus();
             }
           },
           onStepFinish: async () => {
@@ -9425,14 +9499,17 @@ ${prompt}` });
     }
     await messageQueries.create(id, { role: "user", content: userMessageContent });
     const streamId = `stream_${id}_${nanoid6(10)}`;
+    console.log(`[STREAM] Creating stream ${streamId} for session ${id}`);
     await activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
       streamId,
       createAgentStreamProducer(id, prompt, streamId, streamAttachments)
     );
     if (!stream) {
+      console.error(`[STREAM] Failed to create resumable stream ${streamId}`);
       return c.json({ error: "Failed to create stream" }, 500);
     }
+    console.log(`[STREAM] Stream ${streamId} created successfully`);
     const encodedStream = stream.pipeThrough(new TextEncoderStream());
     return new Response(encodedStream, {
       headers: {
@@ -9461,17 +9538,20 @@ agents.get("/:id/watch", async (c) => {
     }
     streamId = activeStream.streamId;
   }
+  console.log(`[STREAM] Watch request for session ${sessionId}, streamId=${streamId}, resumeAt=${resumeAt || "none"}`);
   const stream = await streamContext.resumeExistingStream(
     streamId,
     resumeAt ? parseInt(resumeAt, 10) : void 0
   );
   if (!stream) {
+    console.log(`[STREAM] Watch failed \u2014 stream ${streamId} is no longer active`);
     return c.json({
       error: "Stream is no longer active",
       streamId,
       hint: "The stream may have finished. Check /agents/:id/approvals or start a new run."
     }, 422);
   }
+  console.log(`[STREAM] Client watching stream ${streamId}`);
   const encodedStream = stream.pipeThrough(new TextEncoderStream());
   return new Response(encodedStream, {
     headers: {
@@ -9633,19 +9713,28 @@ agents.post(
       const toolCallStarts = /* @__PURE__ */ new Set();
       const abortController = new AbortController();
       streamAbortControllers.set(streamId, abortController);
+      let sseEventCount = 0;
+      let sseBrowserFrameCount = 0;
+      let sseWriteErrors = 0;
       const writeSSE = async (data) => {
         if (writerClosed) return;
         try {
+          sseEventCount++;
           await writer.write(`data: ${data}
 
 `);
         } catch (err) {
+          sseWriteErrors++;
+          if (sseWriteErrors === 1) {
+            console.log(`[SSE:${streamId}] Writer closed (client disconnected). Total events sent: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}`);
+          }
           writerClosed = true;
         }
       };
       const safeClose = async () => {
         if (writerClosed) return;
         try {
+          console.log(`[SSE:${streamId}] Stream closing. Total events: ${sseEventCount}, browser frames: ${sseBrowserFrameCount}, write errors: ${sseWriteErrors}`);
           writerClosed = true;
           await writer.close();
         } catch {
@@ -9705,36 +9794,51 @@ agents.post(
               const browserPort = progress.data?.browserStreamPort;
               const browserClosed = progress.data?.browserClosed;
               if (progress.toolName === "bash" && browserClosed) {
-                console.log(`[BROWSER-STREAM] agent-browser close detected`);
+                console.log(`[BROWSER-STREAM:${streamId}] agent-browser close detected, destroying proxy for session ${session.id}`);
                 destroyProxy(session.id);
               } else if (progress.toolName === "bash" && browserPort) {
-                console.log(`[BROWSER-STREAM] agent-browser command detected, port ${browserPort}`);
+                console.log(`[BROWSER-STREAM:${streamId}] agent-browser command detected, port ${browserPort} for session ${session.id}`);
                 const proxy = getOrCreateProxy(session.id, browserPort);
+                console.log(`[BROWSER-STREAM:${streamId}] Proxy state: connected=${proxy.connected}, frameListeners=${proxy.listenerCount("frame")}, statusListeners=${proxy.listenerCount("status")}`);
                 if (!sessionRecorders.has(session.id)) {
                   const recorder = new FrameRecorder(session.id);
                   recorder.start();
                   sessionRecorders.set(session.id, recorder);
                 }
-                if (proxy.listenerCount("frame") === 0) {
-                  proxy.on("frame", (frame) => {
-                    const rec = sessionRecorders.get(session.id);
-                    rec?.addFrame(frame);
-                    writeSSE(JSON.stringify({
-                      type: "browser-frame",
-                      data: frame.data,
-                      metadata: frame.metadata
-                    })).catch(() => {
-                    });
+                const oldFrameListeners = proxy.listenerCount("frame");
+                if (oldFrameListeners > 0) {
+                  console.log(`[BROWSER-STREAM:${streamId}] Replacing ${oldFrameListeners} stale frame listener(s) from previous stream`);
+                  proxy.removeAllListeners("frame");
+                  proxy.removeAllListeners("status");
+                }
+                console.log(`[BROWSER-STREAM:${streamId}] Attaching frame+status listeners to proxy`);
+                proxy.on("frame", (frame) => {
+                  sseBrowserFrameCount++;
+                  if (sseBrowserFrameCount === 1) {
+                    console.log(`[BROWSER-STREAM:${streamId}] First browser frame received! dataSize=${frame.data?.length ?? 0} writerClosed=${writerClosed}`);
+                  } else if (sseBrowserFrameCount % 50 === 0) {
+                    console.log(`[BROWSER-STREAM:${streamId}] Browser frame #${sseBrowserFrameCount} (writerClosed=${writerClosed})`);
+                  }
+                  const rec = sessionRecorders.get(session.id);
+                  rec?.addFrame(frame);
+                  writeSSE(JSON.stringify({
+                    type: "browser-frame",
+                    data: frame.data,
+                    metadata: frame.metadata
+                  })).catch((err) => {
+                    console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-frame via SSE:`, err);
                   });
-                  proxy.on("status", (s) => {
-                    console.log(`[BROWSER-STREAM] Status:`, s);
-                    writeSSE(JSON.stringify({
-                      type: "browser-status",
-                      ...s
-                    })).catch(() => {
-                    });
+                });
+                proxy.on("status", (s) => {
+                  console.log(`[BROWSER-STREAM:${streamId}] Browser status event: connected=${s.connected} screencasting=${s.screencasting} viewport=${s.viewportWidth}x${s.viewportHeight}`);
+                  writeSSE(JSON.stringify({
+                    type: "browser-status",
+                    ...s
+                  })).catch((err) => {
+                    console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-status via SSE:`, err);
                   });
-                }
+                });
+                proxy.requestStatus();
               }
             },
             onStepFinish: async () => {