dsh-builtin-browser 0.1.9 → 0.1.10

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

@@ -18,6 +18,8 @@ import { createInterface } from 'node:readline';
 import { createConnection } from 'node:net';
 /** CDP protocol version attached to every view's debugger. */
 const CDP_VERSION = '1.3';
+/** Download cap: the body is shipped base64 as one JSON line; bound the memory. */
+const MAX_DOWNLOAD_BYTES = 256 * 1024 * 1024;
 /** Views by the id the parent assigned at createView time. */
 const views = new Map();
 /** The single browser window; created lazily on first createView. */
@@ -48,6 +50,9 @@ async function handle(op, msg) {
                     window.on('closed', () => { window = undefined; });
                 }
                 const view = new WebContentsView();
+                // Attach the debugger BEFORE the view can be seen: an attach failure
+                // then leaves nothing in the window (no visible ghost view).
+                view.webContents.debugger.attach(CDP_VERSION);
                 // New views start hidden: with several sessions/tabs only the shown
                 // one may be visible (they stack in contentView child order).
                 view.setVisible(false);
@@ -56,7 +61,6 @@ async function handle(op, msg) {
                 view.setBounds({ x: 0, y: 0, width: width ?? 0, height: height ?? 0 });
                 if (views.size === 0)
                     view.setVisible(true);
-                view.webContents.debugger.attach(CDP_VERSION);
                 views.set(viewId, { webContentsView: view });
                 reply(msg.id, { ok: true });
                 return;
@@ -137,6 +141,7 @@ async function handle(op, msg) {
             if (!r.ok) throw new Error('HTTP ' + r.status)
             const b = await r.arrayBuffer()
             const bytes = new Uint8Array(b)
+            if (bytes.length > ${String(MAX_DOWNLOAD_BYTES)}) throw new Error('download too large (limit ' + ${String(MAX_DOWNLOAD_BYTES)} + ' bytes, got ' + bytes.length + ')')
             let bin = ''
             for (let i = 0; i < bytes.length; i += 0x8000) bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000))
             return btoa(bin)
@@ -162,16 +167,21 @@ async function handle(op, msg) {
                 // Export the session's cookies so login state can be saved/restored
                 // across browser hosts (or shared with another machine).
                 const cookies = await entry.webContentsView.webContents.session.cookies.get({});
-                const exported = cookies.map(c => ({
-                    url: `http${c.secure ? 's' : ''}://${c.domain.startsWith('.') ? c.domain.slice(1) : c.domain}${c.path}`,
-                    name: c.name,
-                    value: c.value,
-                    domain: c.domain,
-                    path: c.path,
-                    secure: c.secure,
-                    httpOnly: c.httpOnly,
-                    expirationDate: c.expirationDate,
-                }));
+                const exported = cookies.map(c => {
+                    const host = c.domain.startsWith('.') ? c.domain.slice(1) : c.domain;
+                    // IPv6 literal domains need brackets in a URL (e.g. http://[::1]/).
+                    const hostPart = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+                    return {
+                        url: `http${c.secure ? 's' : ''}://${hostPart}${c.path}`,
+                        name: c.name,
+                        value: c.value,
+                        domain: c.domain,
+                        path: c.path,
+                        secure: c.secure,
+                        httpOnly: c.httpOnly,
+                        expirationDate: c.expirationDate,
+                    };
+                });
                 reply(msg.id, { ok: true, result: { cookies: exported } });
                 return;
             }
@@ -185,6 +195,7 @@ async function handle(op, msg) {
                     throw new Error(`restoreAuth: unknown view ${viewId}`);
                 if (!Array.isArray(cookies))
                     throw new Error('restoreAuth missing cookies array');
+                let restored = 0;
                 for (const c of cookies) {
                     if (typeof c.url !== 'string' || typeof c.name !== 'string' || typeof c.value !== 'string')
                         continue;
@@ -198,8 +209,9 @@ async function handle(op, msg) {
                         ...typeof c.httpOnly === 'boolean' ? { httpOnly: c.httpOnly } : {},
                         ...typeof c.expirationDate === 'number' ? { expirationDate: c.expirationDate } : {},
                     });
+                    restored++;
                 }
-                reply(msg.id, { ok: true, result: { restored: cookies.length } });
+                reply(msg.id, { ok: true, result: { restored } });
                 return;
             }
             default:

package/lib/browser-electron/provider.js

@@ -531,7 +531,10 @@ export class ElectronBrowserProvider {
         if (typeof downloadable.download !== 'function') {
             throw new BrowserError('browser: download is only available on the self-hosted browser', 'BROWSER_DOWNLOAD_UNSUPPORTED');
         }
-        await downloadable.download(request.url, request.savePath);
+        // The child fetches in-page with awaitPromise; a slow/hung network can
+        // block it well past the tool budget, so bound it like every other call.
+        const timeoutMs = 60_000;
+        await withTimeout(downloadable.download(request.url, request.savePath), timeoutMs, signal, `browser: download timed out after ${timeoutMs}ms`);
         this.record(s, 'download', { url: request.url, savePath: request.savePath }, true, { result: request.savePath });
         return { path: request.savePath };
     }
@@ -546,7 +549,8 @@ export class ElectronBrowserProvider {
         if (typeof host.flushAuth !== 'function') {
             throw new BrowserError('browser: auth export is only available on the self-hosted browser', 'BROWSER_AUTH_UNSUPPORTED');
         }
-        const cookies = await host.flushAuth();
+        const timeoutMs = 30_000;
+        const cookies = await withTimeout(host.flushAuth(), timeoutMs, undefined, `browser: auth export timed out after ${timeoutMs}ms`);
         this.record(s, 'flushAuth', {}, true, { result: `${cookies.length} cookies` });
         return cookies;
     }
@@ -558,7 +562,8 @@ export class ElectronBrowserProvider {
         if (typeof host.restoreAuth !== 'function') {
             throw new BrowserError('browser: auth restore is only available on the self-hosted browser', 'BROWSER_AUTH_UNSUPPORTED');
         }
-        const restored = await host.restoreAuth(cookies);
+        const timeoutMs = 30_000;
+        const restored = await withTimeout(host.restoreAuth(cookies), timeoutMs, undefined, `browser: auth restore timed out after ${timeoutMs}ms`);
         this.record(s, 'restoreAuth', { count: cookies.length }, true, { result: `${restored} cookies` });
         return restored;
     }
@@ -706,7 +711,9 @@ export class ElectronBrowserProvider {
     }
     /** Read the current URL of a view through CDP. */
     async currentUrl(handle) {
-        const result = await handleSendEvaluate(handle, 'location.href');
+        // Bound the read: a wedged renderer would otherwise hang listTabs.
+        const timeoutMs = 10_000;
+        const result = await withTimeout(handleSendEvaluate(handle, 'location.href'), timeoutMs, undefined, `browser: url read timed out after ${timeoutMs}ms`);
         return result.ok && typeof result.value === 'string' ? result.value : '';
     }
 }

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

@@ -23,6 +23,8 @@ import { createServer } from 'node:net';
 import { fileURLToPath } from 'node:url';
 /** How long to wait for the child to signal readiness before failing. */
 const READY_TIMEOUT_MS = 20_000;
+/** Safety cap on a single RPC reply line (base64 downloads are the big ones). */
+const MAX_RPC_BUFFER_BYTES = 512 * 1024 * 1024;
 /**
  * Locate the Electron binary, trying, in order:
  *   1. require('electron') from this module (optional peer dependency),
@@ -227,6 +229,14 @@ class ElectronChildClient {
     }
     onData(chunk) {
         this.buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        // Safety net: a pathological child (or a reply larger than expected)
+        // must not grow the parent's memory without bound. The child caps
+        // downloads at 256 MiB, so a healthy stream never approaches this.
+        if (this.buffer.length > MAX_RPC_BUFFER_BYTES) {
+            this.buffer = '';
+            this.fail(new Error(`dsh-builtin-browser: RPC reply exceeded ${MAX_RPC_BUFFER_BYTES} bytes`));
+            return;
+        }
         let nl;
         while ((nl = this.buffer.indexOf('\n')) >= 0) {
             const line = this.buffer.slice(0, nl).trim();
@@ -329,8 +339,22 @@ export class RemoteElectronViewHost {
     ready() {
         if (this.readyPromise !== undefined)
             return this.readyPromise;
-        this.readyPromise = this.start();
-        return this.readyPromise;
+        const started = this.start();
+        const wrapped = started.catch(error => {
+            // A failed startup must not poison the host forever: tear down whatever
+            // was half-created and let the next call retry from scratch.
+            if (this.readyPromise === wrapped) {
+                this.readyPromise = undefined;
+                this.client?.kill();
+                this.client = undefined;
+                this.server?.close();
+                this.server = undefined;
+                this.pendingSocket = undefined;
+            }
+            throw error;
+        });
+        this.readyPromise = wrapped;
+        return wrapped;
     }
     async start() {
         // Listen on an ephemeral loopback port; the child connects back.
@@ -386,6 +410,11 @@ export class RemoteElectronViewHost {
         if (client === undefined)
             throw new Error('browser host unavailable');
         await client.call('createView', { viewId: id });
+        // If the view was destroyed while the createView RPC was in flight, do
+        // not re-insert a stale entry that would resurrect a dead child view.
+        if (this.views.get(id) === undefined) {
+            throw new Error('browser: view destroyed while starting');
+        }
         const view = new RemoteView(id, client);
         this.views.set(id, view);
         return view;
@@ -426,27 +455,37 @@ class DeferredRemoteView {
         this.id = id;
         this.materialize = materialize;
     }
+    /**
+     * Materialize once and cache: every sendCommand on the same handle must
+     * target the SAME child view (re-materializing would re-run createView and
+     * duplicate the window). A FAILED materialization is reset so a later call
+     * (e.g. after the host restarted) can retry instead of being poisoned.
+     */
+    materializeOnce() {
+        if (this.materialized === undefined) {
+            const pending = this.materialize();
+            this.materialized = pending.catch(error => {
+                if (this.materialized === pending)
+                    this.materialized = undefined;
+                throw error;
+            });
+        }
+        return this.materialized;
+    }
     async sendCommand(method, params) {
-        // 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;
+        const view = await this.materializeOnce();
         return view.sendCommand(method, params);
     }
     async download(url, savePath) {
-        this.materialized ??= this.materialize();
-        const view = await this.materialized;
+        const view = await this.materializeOnce();
         return view.download(url, savePath);
     }
     async flushAuth() {
-        this.materialized ??= this.materialize();
-        const view = await this.materialized;
+        const view = await this.materializeOnce();
         return view.flushAuth();
     }
     async restoreAuth(cookies) {
-        this.materialized ??= this.materialize();
-        const view = await this.materialized;
+        const view = await this.materializeOnce();
         return view.restoreAuth(cookies);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-builtin-browser",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Shared real browser plugin for DeepSeek Harness: install-and-use — a visible native browser the human can take over, driven by the agent over CDP. DOM-level interaction (React/Vue safe), per-task session isolation, cookie persistence (browser_auth), CAPTCHA detection, batch form fill (browser_fill), authenticated download, history/replay, action restriction",
   "type": "module",
   "main": "lib/index.js",

package/src/browser-electron/host-main.ts

@@ -21,6 +21,9 @@ import { createConnection } from 'node:net'
 /** CDP protocol version attached to every view's debugger. */
 const CDP_VERSION = '1.3'
 
+/** Download cap: the body is shipped base64 as one JSON line; bound the memory. */
+const MAX_DOWNLOAD_BYTES = 256 * 1024 * 1024
+
 /** One view: the Electron object plus its CDP-backed surface. */
 interface HostView {
   readonly webContentsView: WebContentsView
@@ -59,6 +62,9 @@ async function handle(op: string, msg: { id: number; viewId?: string; method?: s
           window.on('closed', () => { window = undefined })
         }
         const view = new WebContentsView()
+        // Attach the debugger BEFORE the view can be seen: an attach failure
+        // then leaves nothing in the window (no visible ghost view).
+        view.webContents.debugger.attach(CDP_VERSION)
         // New views start hidden: with several sessions/tabs only the shown
         // one may be visible (they stack in contentView child order).
         view.setVisible(false)
@@ -66,7 +72,6 @@ async function handle(op: string, msg: { id: number; viewId?: string; method?: s
         const [width, height] = window.getContentSize()
         view.setBounds({ x: 0, y: 0, width: width ?? 0, height: height ?? 0 })
         if (views.size === 0) view.setVisible(true)
-        view.webContents.debugger.attach(CDP_VERSION)
         views.set(viewId, { webContentsView: view })
         reply(msg.id, { ok: true })
         return
@@ -134,6 +139,7 @@ async function handle(op: string, msg: { id: number; viewId?: string; method?: s
             if (!r.ok) throw new Error('HTTP ' + r.status)
             const b = await r.arrayBuffer()
             const bytes = new Uint8Array(b)
+            if (bytes.length > ${String(MAX_DOWNLOAD_BYTES)}) throw new Error('download too large (limit ' + ${String(MAX_DOWNLOAD_BYTES)} + ' bytes, got ' + bytes.length + ')')
             let bin = ''
             for (let i = 0; i < bytes.length; i += 0x8000) bin += String.fromCharCode.apply(null, bytes.subarray(i, i + 0x8000))
             return btoa(bin)
@@ -157,16 +163,21 @@ async function handle(op: string, msg: { id: number; viewId?: string; method?: s
         // Export the session's cookies so login state can be saved/restored
         // across browser hosts (or shared with another machine).
         const cookies = await entry.webContentsView.webContents.session.cookies.get({})
-        const exported = cookies.map(c => ({
-          url: `http${c.secure ? 's' : ''}://${c.domain.startsWith('.') ? c.domain.slice(1) : c.domain}${c.path}`,
-          name: c.name,
-          value: c.value,
-          domain: c.domain,
-          path: c.path,
-          secure: c.secure,
-          httpOnly: c.httpOnly,
-          expirationDate: c.expirationDate,
-        }))
+        const exported = cookies.map(c => {
+          const host = c.domain.startsWith('.') ? c.domain.slice(1) : c.domain
+          // IPv6 literal domains need brackets in a URL (e.g. http://[::1]/).
+          const hostPart = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host
+          return {
+            url: `http${c.secure ? 's' : ''}://${hostPart}${c.path}`,
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: c.path,
+            secure: c.secure,
+            httpOnly: c.httpOnly,
+            expirationDate: c.expirationDate,
+          }
+        })
         reply(msg.id, { ok: true, result: { cookies: exported } })
         return
       }
@@ -177,6 +188,7 @@ async function handle(op: string, msg: { id: number; viewId?: string; method?: s
         const entry = views.get(viewId)
         if (entry === undefined) throw new Error(`restoreAuth: unknown view ${viewId}`)
         if (!Array.isArray(cookies)) throw new Error('restoreAuth missing cookies array')
+        let restored = 0
         for (const c of cookies as Array<{ url?: string; name?: string; value?: string; domain?: string; path?: string; secure?: boolean; httpOnly?: boolean; expirationDate?: number }>) {
           if (typeof c.url !== 'string' || typeof c.name !== 'string' || typeof c.value !== 'string') continue
           await entry.webContentsView.webContents.session.cookies.set({
@@ -189,8 +201,9 @@ async function handle(op: string, msg: { id: number; viewId?: string; method?: s
             ...typeof c.httpOnly === 'boolean' ? { httpOnly: c.httpOnly } : {},
             ...typeof c.expirationDate === 'number' ? { expirationDate: c.expirationDate } : {},
           })
+          restored++
         }
-        reply(msg.id, { ok: true, result: { restored: (cookies as unknown[]).length } })
+        reply(msg.id, { ok: true, result: { restored } })
         return
       }
       default:

package/src/browser-electron/provider.ts

@@ -693,7 +693,15 @@ export class ElectronBrowserProvider implements BrowserProvider {
     if (typeof downloadable.download !== 'function') {
       throw new BrowserError('browser: download is only available on the self-hosted browser', 'BROWSER_DOWNLOAD_UNSUPPORTED')
     }
-    await downloadable.download(request.url, request.savePath)
+    // The child fetches in-page with awaitPromise; a slow/hung network can
+    // block it well past the tool budget, so bound it like every other call.
+    const timeoutMs = 60_000
+    await withTimeout(
+      downloadable.download(request.url, request.savePath),
+      timeoutMs,
+      signal,
+      `browser: download timed out after ${timeoutMs}ms`,
+    )
     this.record(s, 'download', { url: request.url, savePath: request.savePath }, true, { result: request.savePath })
     return { path: request.savePath }
   }
@@ -709,7 +717,8 @@ export class ElectronBrowserProvider implements BrowserProvider {
     if (typeof host.flushAuth !== 'function') {
       throw new BrowserError('browser: auth export is only available on the self-hosted browser', 'BROWSER_AUTH_UNSUPPORTED')
     }
-    const cookies = await host.flushAuth()
+    const timeoutMs = 30_000
+    const cookies = await withTimeout(host.flushAuth(), timeoutMs, undefined, `browser: auth export timed out after ${timeoutMs}ms`)
     this.record(s, 'flushAuth', {}, true, { result: `${cookies.length} cookies` })
     return cookies
   }
@@ -722,7 +731,8 @@ export class ElectronBrowserProvider implements BrowserProvider {
     if (typeof host.restoreAuth !== 'function') {
       throw new BrowserError('browser: auth restore is only available on the self-hosted browser', 'BROWSER_AUTH_UNSUPPORTED')
     }
-    const restored = await host.restoreAuth(cookies)
+    const timeoutMs = 30_000
+    const restored = await withTimeout(host.restoreAuth(cookies), timeoutMs, undefined, `browser: auth restore timed out after ${timeoutMs}ms`)
     this.record(s, 'restoreAuth', { count: cookies.length }, true, { result: `${restored} cookies` })
     return restored
   }
@@ -887,7 +897,14 @@ export class ElectronBrowserProvider implements BrowserProvider {
 
   /** Read the current URL of a view through CDP. */
   private async currentUrl(handle: ElectronViewHandle): Promise<string> {
-    const result = await handleSendEvaluate(handle, 'location.href')
+    // Bound the read: a wedged renderer would otherwise hang listTabs.
+    const timeoutMs = 10_000
+    const result = await withTimeout(
+      handleSendEvaluate(handle, 'location.href'),
+      timeoutMs,
+      undefined,
+      `browser: url read timed out after ${timeoutMs}ms`,
+    )
     return result.ok && typeof result.value === 'string' ? result.value : ''
   }
 }

package/src/browser-electron/remote-host.ts

@@ -28,6 +28,9 @@ import type { ExportedCookie } from '../browser/types.ts'
 /** How long to wait for the child to signal readiness before failing. */
 const READY_TIMEOUT_MS = 20_000
 
+/** Safety cap on a single RPC reply line (base64 downloads are the big ones). */
+const MAX_RPC_BUFFER_BYTES = 512 * 1024 * 1024
+
 /**
  * Locate the Electron binary, trying, in order:
  *   1. require('electron') from this module (optional peer dependency),
@@ -233,6 +236,14 @@ class ElectronChildClient {
 
   private onData(chunk: string | Buffer): void {
     this.buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8')
+    // Safety net: a pathological child (or a reply larger than expected)
+    // must not grow the parent's memory without bound. The child caps
+    // downloads at 256 MiB, so a healthy stream never approaches this.
+    if (this.buffer.length > MAX_RPC_BUFFER_BYTES) {
+      this.buffer = ''
+      this.fail(new Error(`dsh-builtin-browser: RPC reply exceeded ${MAX_RPC_BUFFER_BYTES} bytes`))
+      return
+    }
     let nl: number
     while ((nl = this.buffer.indexOf('\n')) >= 0) {
       const line = this.buffer.slice(0, nl).trim()
@@ -326,8 +337,22 @@ export class RemoteElectronViewHost implements ElectronBrowserViewHost {
   /** Ensure the child is up and ready (lazy on first use; restarts after a crash). */
   private ready(): Promise<void> {
     if (this.readyPromise !== undefined) return this.readyPromise
-    this.readyPromise = this.start()
-    return this.readyPromise
+    const started = this.start()
+    const wrapped = started.catch(error => {
+      // A failed startup must not poison the host forever: tear down whatever
+      // was half-created and let the next call retry from scratch.
+      if (this.readyPromise === wrapped) {
+        this.readyPromise = undefined
+        this.client?.kill()
+        this.client = undefined
+        this.server?.close()
+        this.server = undefined
+        this.pendingSocket = undefined
+      }
+      throw error
+    })
+    this.readyPromise = wrapped
+    return wrapped
   }
 
   private async start(): Promise<void> {
@@ -383,6 +408,11 @@ export class RemoteElectronViewHost implements ElectronBrowserViewHost {
     const client = this.client
     if (client === undefined) throw new Error('browser host unavailable')
     await client.call('createView', { viewId: id })
+    // If the view was destroyed while the createView RPC was in flight, do
+    // not re-insert a stale entry that would resurrect a dead child view.
+    if (this.views.get(id) === undefined) {
+      throw new Error('browser: view destroyed while starting')
+    }
     const view = new RemoteView(id, client)
     this.views.set(id, view)
     return view
@@ -426,30 +456,40 @@ class DeferredRemoteView implements ElectronViewHandle {
     private readonly materialize: () => Promise<RemoteView>,
   ) {}
 
+  /**
+   * Materialize once and cache: every sendCommand on the same handle must
+   * target the SAME child view (re-materializing would re-run createView and
+   * duplicate the window). A FAILED materialization is reset so a later call
+   * (e.g. after the host restarted) can retry instead of being poisoned.
+   */
+  private materializeOnce(): Promise<RemoteView> {
+    if (this.materialized === undefined) {
+      const pending = this.materialize()
+      this.materialized = pending.catch(error => {
+        if (this.materialized === pending) this.materialized = undefined
+        throw error
+      })
+    }
+    return this.materialized
+  }
+
   async sendCommand(method: string, params?: Record<string, unknown>): Promise<Record<string, unknown>> {
-    // 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
+    const view = await this.materializeOnce()
     return view.sendCommand(method, params)
   }
 
   async download(url: string, savePath: string): Promise<void> {
-    this.materialized ??= this.materialize()
-    const view = await this.materialized
+    const view = await this.materializeOnce()
     return view.download(url, savePath)
   }
 
   async flushAuth(): Promise<ExportedCookie[]> {
-    this.materialized ??= this.materialize()
-    const view = await this.materialized
+    const view = await this.materializeOnce()
     return view.flushAuth()
   }
 
   async restoreAuth(cookies: ExportedCookie[]): Promise<number> {
-    this.materialized ??= this.materialize()
-    const view = await this.materialized
+    const view = await this.materializeOnce()
     return view.restoreAuth(cookies)
   }
 }