dsh-builtin-browser 0.1.5 → 0.1.6

package/lib/browser/types.d.ts

@@ -64,6 +64,8 @@ export interface BrowserExecuteRequest {
     readonly script: string;
     /** Optional arguments injected into the script scope as `arguments[0..n]`. */
     readonly args?: readonly unknown[];
+    /** Evaluation budget in ms; a wedged page rejects with a timeout. Default 30000. */
+    readonly timeoutMs?: number;
 }
 /**
  * Result of an execute. Mirrors CDP `Runtime.evaluate` semantics: either a

package/lib/browser-electron/provider.js

@@ -177,11 +177,16 @@ export class ElectronBrowserProvider {
             const expression = hasArgs
                 ? `(function(){ const __dshArgs = ${JSON.stringify(request.args)}; return Function(${JSON.stringify(body)}).apply(null, __dshArgs) })()`
                 : `(function(){ return Function(${JSON.stringify(body)})() })()`;
-            const result = await handle.sendCommand(CDP_RUNTIME_EVALUATE, {
+            // CDP Runtime.evaluate can hang indefinitely on a not-yet-loaded page
+            // (navigate returned but the renderer has not committed). Bound it so a
+            // stuck call surfaces as BROWSER_EXECUTE_TIMEOUT instead of wedging the
+            // whole tool call. The caller's signal wins when it fires first.
+            const timeoutMs = request.timeoutMs ?? 30_000;
+            const result = await withTimeout(handle.sendCommand(CDP_RUNTIME_EVALUATE, {
                 expression,
                 returnByValue: true,
                 awaitPromise: true,
-            });
+            }), timeoutMs, signal, `browser: execute timed out after ${timeoutMs}ms`);
             if (result.exceptionDetails !== undefined) {
                 const detail = result.exceptionDetails;
                 return { ok: false, exception: detail.exception?.description ?? detail.text ?? 'unknown exception' };
@@ -226,7 +231,10 @@ export class ElectronBrowserProvider {
       }
       return { url, title, elements: out, truncated: out.length >= cap }
     })()`;
-        const result = await handleSendEvaluate(tab.handle, script);
+        // Same hang guard as execute: a renderer that has not committed after
+        // navigate would otherwise block snapshot forever.
+        const timeoutMs = 30_000;
+        const result = await withTimeout(handleSendEvaluate(tab.handle, script), timeoutMs, signal, `browser: snapshot timed out after ${timeoutMs}ms`);
         if (!result.ok)
             throw new BrowserError(`browser: snapshot evaluation failed: ${result.exception}`, 'BROWSER_SNAPSHOT_FAILED');
         const value = result.value;
@@ -357,6 +365,46 @@ export class ElectronBrowserProvider {
         return result.ok && typeof result.value === 'string' ? result.value : '';
     }
 }
+/**
+ * Bound a promise so a wedged CDP call surfaces as an error instead of
+ * hanging the tool call forever. The caller's signal, when provided, wins
+ * over the timeout if it fires first.
+ * @param promise - the operation to bound.
+ * @param ms - the timeout budget.
+ * @param signal - optional caller signal.
+ * @param message - the timeout error message.
+ * @returns the promise's value, or a rejected promise on timeout/abort.
+ */
+function withTimeout(promise, ms, signal, message) {
+    return new Promise((resolve, reject) => {
+        let done = false;
+        const timer = setTimeout(() => {
+            if (done)
+                return;
+            done = true;
+            reject(new Error(message));
+        }, ms);
+        const finish = (fn) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (signal !== undefined)
+                signal.removeEventListener('abort', onAbort);
+            fn();
+        };
+        const onAbort = () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            reject(signal?.reason instanceof Error ? signal.reason : new Error('aborted'));
+        };
+        if (signal !== undefined)
+            signal.addEventListener('abort', onAbort, { once: true });
+        promise.then(value => finish(() => resolve(value)), error => finish(() => reject(error)));
+    });
+}
 /**
  * Run a `Runtime.evaluate` through a view handle and normalize the result.
  * Shared by execute, snapshot, content, and internal URL reads.

package/lib/browser-electron/remote-host.js

@@ -358,12 +358,17 @@ export class RemoteElectronViewHost {
 class DeferredRemoteView {
     id;
     materialize;
+    materialized;
     constructor(id, materialize) {
         this.id = id;
         this.materialize = materialize;
     }
     async sendCommand(method, params) {
-        const view = await this.materialize();
+        // Materialize once and cache: every sendCommand on the same handle must
+        // target the SAME child view. Re-materializing would re-run createView
+        // (duplicate window) and drop the established view.
+        this.materialized ??= this.materialize();
+        const view = await this.materialized;
         return view.sendCommand(method, params);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-builtin-browser",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Shared real browser capability for DeepSeek Harness: a visible browser the human watches and can take over, driven by the agent over CDP (snapshot/execute/content/tab management); host-side seam, provider, and browser_* tools",
   "type": "module",
   "main": "lib/index.js",