sparkecoder 0.1.68 → 0.1.69

package/dist/{schema-XcP0dedO.d.ts → schema-Bq4tID-f.d.ts}

@@ -85,7 +85,7 @@ declare const sessions: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
             tableName: "sessions";
             dataType: "string";
             columnType: "SQLiteText";
-            data: "error" | "completed" | "active" | "waiting";
+            data: "active" | "waiting" | "completed" | "error";
             driverParam: string;
             notNull: true;
             hasDefault: true;
@@ -391,7 +391,7 @@ declare const toolExecutions: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
             tableName: "tool_executions";
             dataType: "string";
             columnType: "SQLiteText";
-            data: "error" | "completed" | "pending" | "approved" | "rejected";
+            data: "completed" | "error" | "pending" | "approved" | "rejected";
             driverParam: string;
             notNull: true;
             hasDefault: true;
@@ -967,7 +967,7 @@ declare const activeStreams: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
             tableName: "active_streams";
             dataType: "string";
             columnType: "SQLiteText";
-            data: "error" | "active" | "finished";
+            data: "active" | "error" | "finished";
             driverParam: string;
             notNull: true;
             hasDefault: true;

package/dist/{search-CCffrVJE.d.ts → search-BRnGaIl-.d.ts}

@@ -15,12 +15,12 @@ interface BashToolOptions {
 }
 declare function createBashTool(options: BashToolOptions): ai.Tool<{
     background: boolean;
-    input?: string | undefined;
     id?: string | undefined;
+    input?: string | undefined;
     command?: string | undefined;
     kill?: boolean | undefined;
     tail?: number | undefined;
-    key?: "y" | "Enter" | "Escape" | "Up" | "Down" | "Left" | "Right" | "Tab" | "C-c" | "C-d" | "n" | undefined;
+    key?: "Enter" | "Escape" | "Up" | "Down" | "Left" | "Right" | "Tab" | "C-c" | "C-d" | "y" | "n" | undefined;
 }, {
     success: boolean;
     id: string;
@@ -41,7 +41,7 @@ declare function createBashTool(options: BashToolOptions): ai.Tool<{
     success: boolean;
     id: string;
     output: string;
-    status: "unknown" | "running" | "stopped";
+    status: "running" | "stopped" | "unknown";
     message: string;
     error?: undefined;
     exitCode?: undefined;
@@ -49,7 +49,7 @@ declare function createBashTool(options: BashToolOptions): ai.Tool<{
     success: boolean;
     id: string;
     output: string;
-    status: "unknown" | "running" | "stopped";
+    status: "running" | "stopped" | "unknown";
     message?: undefined;
     error?: undefined;
     exitCode?: undefined;
@@ -66,7 +66,7 @@ declare function createBashTool(options: BashToolOptions): ai.Tool<{
     id: string;
     output: string;
     exitCode: number;
-    status: "error" | "completed" | "running" | "stopped";
+    status: "completed" | "error" | "running" | "stopped";
     message?: undefined;
     error?: undefined;
 } | {
@@ -116,8 +116,8 @@ interface WriteFileToolOptions {
     onProgress?: (progress: WriteFileProgress) => void;
 }
 declare function createWriteFileTool(options: WriteFileToolOptions): ai.Tool<{
-    path: string;
     mode: "full" | "str_replace";
+    path: string;
     content?: string | undefined;
     old_string?: string | undefined;
     new_string?: string | undefined;
@@ -218,8 +218,8 @@ interface SearchToolOptions {
  * Progress is streamed back to the UI so users can see exploration happening.
  */
 declare function createSearchTool(options: SearchToolOptions): ai.Tool<{
-    context: string;
     query: string;
+    context: string;
 }, {
     success: boolean;
     error: string;

package/dist/server/index.js

@@ -1785,10 +1785,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();
@@ -1800,8 +1805,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;
@@ -1832,18 +1840,22 @@ 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", {
@@ -1855,12 +1867,14 @@ var init_stream_proxy = __esm({
           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 });
           }
@@ -1868,14 +1882,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 ?? {
@@ -1891,21 +1917,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);
       }
       /**
@@ -1917,6 +1948,7 @@ var init_stream_proxy = __esm({
         }
       }
       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);
@@ -8063,11 +8095,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));
@@ -8106,9 +8146,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({
@@ -8294,19 +8337,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 {
@@ -8429,35 +8481,47 @@ ${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) {
+                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(() => {
+                  })).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);
+                  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(() => {
+                  })).catch((err) => {
+                    console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-status via SSE:`, err);
                   });
                 });
+              } else {
+                console.log(`[BROWSER-STREAM:${streamId}] Frame listeners already attached (count=${proxy.listenerCount("frame")}), skipping`);
               }
             }
           },
@@ -8647,14 +8711,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: {
@@ -8683,17 +8750,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: {
@@ -8855,19 +8925,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 {
@@ -8927,35 +9006,47 @@ 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) {
+                  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(() => {
+                    })).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);
+                    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(() => {
+                    })).catch((err) => {
+                      console.warn(`[BROWSER-STREAM:${streamId}] Failed to send browser-status via SSE:`, err);
                     });
                   });
+                } else {
+                  console.log(`[BROWSER-STREAM:${streamId}] Frame listeners already attached (count=${proxy.listenerCount("frame")}), skipping`);
                 }
               }
             },