@rubytech/taskmaster 1.0.49 → 1.0.50

package/dist/browser/screencast.js

@@ -4,10 +4,15 @@ import { getHeadersWithAuth } from "./cdp.helpers.js";
 import { rawDataToString } from "../infra/ws.js";
 const log = createSubsystemLogger("browser").child("screencast-cdp");
 let sessionCounter = 0;
+/** Interval (ms) for the Page.captureScreenshot polling fallback. */
+const POLL_INTERVAL_MS = 500;
+/** How long to wait for Page.startScreencast frames before falling back. */
+const SCREENCAST_STALL_MS = 3000;
 /**
  * Start a persistent CDP screencast session.
- * Unlike `withCdpSocket` which opens/closes per call, this keeps
- * the WebSocket open for continuous frame delivery.
+ * Uses Page.startScreencast for compositor-driven frames, but falls back
+ * to Page.captureScreenshot polling when the compositor doesn't produce
+ * continuous frames (common on headless / software-rendered / Pi setups).
  */
 export async function startScreencast(opts) {
     const sessionId = ++sessionCounter;
@@ -31,29 +36,80 @@ export async function startScreencast(opts) {
             pending.set(msgId, { resolve, reject });
         });
     };
+    let frameCount = 0;
+    let pollInterval = null;
+    let stallTimeout = null;
+    let polling = false;
+    const cleanup = () => {
+        if (pollInterval) {
+            clearInterval(pollInterval);
+            pollInterval = null;
+        }
+        if (stallTimeout) {
+            clearTimeout(stallTimeout);
+            stallTimeout = null;
+        }
+    };
     const session = {
         id,
         ws,
         active: false,
         stop: () => {
             session.active = false;
+            cleanup();
+            // Don't send Page.stopScreencast — it's page-level and can race with
+            // a replacement session connecting to the same tab. Just close the socket.
             try {
-                send("Page.stopScreencast").catch(() => { });
+                ws.close();
             }
             catch {
-                // ignore
+                /* ignore */
             }
-            setTimeout(() => {
-                try {
-                    ws.close();
-                }
-                catch {
-                    /* ignore */
-                }
-            }, 100);
         },
     };
-    let frameCount = 0;
+    /** Synthetic metadata for polling-based frames. */
+    const syntheticMeta = {
+        offsetTop: 0,
+        pageScaleFactor: 1,
+        deviceWidth: maxWidth,
+        deviceHeight: maxHeight,
+        scrollOffsetX: 0,
+        scrollOffsetY: 0,
+    };
+    /** Take a single screenshot and deliver it as a frame. */
+    const pollOnce = async () => {
+        if (!session.active)
+            return;
+        try {
+            const result = (await send("Page.captureScreenshot", {
+                format,
+                quality,
+            }));
+            const data = result?.data;
+            if (data && session.active) {
+                frameCount++;
+                if (frameCount <= 3 || frameCount % 100 === 0) {
+                    log.info(`poll frame #${frameCount}: dataLen=${data.length}`);
+                }
+                opts.onFrame({ data, metadata: syntheticMeta, sessionId: 0 });
+            }
+        }
+        catch {
+            // ignore — socket may be closing
+        }
+    };
+    /** Switch from compositor-driven screencasting to polling. */
+    const startPollingFallback = () => {
+        if (polling || !session.active)
+            return;
+        polling = true;
+        log.warn(`screencast stalled (${frameCount} frames in ${SCREENCAST_STALL_MS}ms) — falling back to Page.captureScreenshot polling`);
+        // Stop the compositor screencast (best-effort)
+        send("Page.stopScreencast").catch(() => { });
+        pollInterval = setInterval(pollOnce, POLL_INTERVAL_MS);
+        // Fire one immediately so the UI gets a frame right away
+        pollOnce();
+    };
     ws.on("message", (raw) => {
         try {
             const msg = JSON.parse(rawDataToString(raw));
@@ -71,8 +127,8 @@ export async function startScreencast(opts) {
                 }
                 return;
             }
-            // Handle screencast frame events
-            if (msg.method === "Page.screencastFrame") {
+            // Handle screencast frame events (compositor-driven)
+            if (msg.method === "Page.screencastFrame" && !polling) {
                 frameCount++;
                 const params = msg.params;
                 if (frameCount <= 3 || frameCount % 100 === 0) {
@@ -90,12 +146,18 @@ export async function startScreencast(opts) {
                     });
                 }
             }
-            else if (msg.method) {
-                // Log other CDP events (first few only) for debugging
-                if (frameCount === 0) {
-                    log.debug(`CDP event: ${msg.method}`);
+            else if (msg.method === "Page.screencastVisibilityChanged") {
+                const visible = msg.params?.visible;
+                log.info(`Page.screencastVisibilityChanged visible=${visible}`);
+                // If the page becomes "not visible", the compositor won't produce
+                // frames. Switch to polling immediately.
+                if (visible === false && !polling && session.active) {
+                    startPollingFallback();
                 }
             }
+            else if (msg.method && frameCount === 0 && !polling) {
+                log.debug(`CDP event: ${msg.method}`);
+            }
         }
         catch {
             // ignore parse errors
@@ -104,6 +166,7 @@ export async function startScreencast(opts) {
     ws.on("close", (code, reason) => {
         log.info(`CDP socket closed: code=${code} reason=${reason?.toString() ?? ""}`);
         session.active = false;
+        cleanup();
         for (const [, p] of pending) {
             p.reject(new Error("CDP socket closed"));
         }
@@ -120,7 +183,6 @@ export async function startScreencast(opts) {
         ws.once("error", (err) => reject(err));
     });
     log.info("CDP socket connected, enabling Page domain");
-    // Enable Page domain and start screencast
     await send("Page.enable");
     log.info(`starting Page.startScreencast format=${format} quality=${quality}`);
     await send("Page.startScreencast", {
@@ -131,12 +193,13 @@ export async function startScreencast(opts) {
     });
     session.active = true;
     log.info(`screencast active: ${id}`);
-    // Warn if no frames arrive within 5 seconds — helps diagnose CDP/compositor issues
-    setTimeout(() => {
-        if (session.active && frameCount === 0) {
-            log.warn(`no frames received after 5s — CDP may not support screencast on this platform (headless? no display? software rendering?)`);
+    // If the compositor doesn't produce continuous frames within SCREENCAST_STALL_MS,
+    // fall back to polling. This handles headless, software-rendered, and Pi setups.
+    stallTimeout = setTimeout(() => {
+        if (session.active && !polling && frameCount <= 1) {
+            startPollingFallback();
         }
-    }, 5000);
+    }, SCREENCAST_STALL_MS);
     return session;
 }
 /**

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.49",
-  "commit": "599a958bd2f72fc80d487a91e1db7dc16306e99f",
-  "builtAt": "2026-02-17T16:28:06.596Z"
+  "version": "1.0.50",
+  "commit": "881e4b648e2a7bcb69968482fdd8da58891ea37f",
+  "builtAt": "2026-02-17T16:36:05.944Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.0.49",
+  "version": "1.0.50",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"