monomind 1.10.40 → 1.10.41

package/packages/@monomind/cli/dist/src/browser/har.d.ts

@@ -14,6 +14,7 @@ interface HarRequest {
     encodedSize: number;
     fromCache: boolean;
     responseBody?: string;
+    bodyEncoding?: 'base64';
 }
 export declare function startHarRecording(client: CdpClient, sessionId: string): Promise<void>;
 export declare function stopHarRecording(client: CdpClient, sessionId: string, outputPath?: string, captureResponseBodies?: boolean): Promise<string>;

package/packages/@monomind/cli/dist/src/browser/har.js

@@ -60,22 +60,23 @@ export async function stopHarRecording(client, sessionId, outputPath, captureRes
     state.offReq();
     state.offResp();
     state.offFinished();
+    _sessions.delete(sessionId); // remove immediately after detaching listeners to prevent duplicate invocations
     // Optionally fetch response bodies
     if (captureResponseBodies) {
         for (const [reqId, entry] of state.requests.entries()) {
             try {
                 const body = await client.send('Network.getResponseBody', { requestId: reqId }, sessionId);
-                entry.responseBody = body.base64Encoded
-                    ? Buffer.from(body.body, 'base64').toString('utf8')
-                    : body.body;
-                entry.size = entry.responseBody?.length ?? 0;
+                entry.responseBody = body.body;
+                entry.bodyEncoding = body.base64Encoded ? 'base64' : undefined;
+                entry.size = body.base64Encoded
+                    ? Buffer.byteLength(body.body, 'base64')
+                    : Buffer.byteLength(body.body, 'utf8');
             }
             catch {
                 // body may not be available for cached/redirected responses
             }
         }
     }
-    _sessions.delete(sessionId); // always runs — response body loop errors are caught per-entry
     const har = buildHar(Array.from(state.requests.values()), state.startTime);
     const path = outputPath ?? join(tmpdir(), `monomind-har-${Date.now()}.har`);
     await writeFile(path, JSON.stringify(har, null, 2));
@@ -123,6 +124,7 @@ function buildHar(entries, startTime) {
                         size: e.size ?? -1,
                         mimeType: e.mimeType ?? 'application/octet-stream',
                         text: e.responseBody,
+                        encoding: e.bodyEncoding,
                     },
                     redirectURL: '',
                     headersSize: -1,

package/packages/@monomind/cli/dist/src/browser/network.d.ts

@@ -6,9 +6,7 @@ export declare function clearCookies(client: CdpClient, sessionId: string): Prom
 export declare function setExtraHeaders(client: CdpClient, sessionId: string, headers: Record<string, string>): Promise<void>;
 export declare function enableInterception(client: CdpClient, sessionId: string): Promise<void>;
 export declare function setupRoutes(client: CdpClient, sessionId: string, routes: NetworkRoute[]): Promise<void>;
-export declare function startRequestCapture(client: CdpClient, sessionId: string): void;
-export declare function stopRequestCapture(sessionId: string): void;
-export declare function getCapturedRequests(sessionId: string): {
+type CapturedRequest = {
     id: string;
     url: string;
     method: string;
@@ -19,11 +17,16 @@ export declare function getCapturedRequests(sessionId: string): {
     startTime: number;
     endTime?: number;
     encodedSize?: number;
-}[];
+};
+export declare function startRequestCapture(client: CdpClient, sessionId: string): void;
+export declare function stopRequestCapture(sessionId: string): void;
+export declare function getCapturedRequests(sessionId: string): CapturedRequest[];
 export declare function clearCapturedRequests(sessionId: string): void;
 export declare function disableInterception(client: CdpClient, sessionId: string): Promise<void>;
+export declare function teardownRouteInterception(sessionId: string): void;
 export declare function getLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
 export declare function setLocalStorage(client: CdpClient, sessionId: string, data: Record<string, string>): Promise<void>;
 export declare function getSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
 export declare function setSessionStorage(client: CdpClient, sessionId: string, data: Record<string, string>): Promise<void>;
+export {};
 //# sourceMappingURL=network.d.ts.map

package/packages/@monomind/cli/dist/src/browser/network.js

@@ -25,18 +25,19 @@ export async function setupRoutes(client, sessionId, routes) {
         _routeListeners.delete(sessionId);
     }
     if (routes.length === 0) {
-        await client.send('Fetch.disable', {}, sessionId);
+        await client.send('Fetch.disable', {}, sessionId).catch(() => { });
         return;
     }
-    await client.send('Fetch.enable', {
-        patterns: routes.map((r) => ({ urlPattern: globToFetchPattern(r.pattern), requestStage: 'Request' })),
-    }, sessionId);
+    // Pre-compile route regexes once — avoids creating new RegExp on every paused request
+    const compiledRoutes = routes.map((r) => ({ route: r, regex: globToRegex(r.pattern) }));
+    // Register listener BEFORE Fetch.enable to avoid race where Chrome emits
+    // Fetch.requestPaused before the handler is in place, leaving requests hung
     const off = client.on('Fetch.requestPaused', async (params, sid) => {
         if (sid !== sessionId)
             return;
         const { requestId, request } = params;
         try {
-            const matchedRoute = routes.find((r) => globToRegex(r.pattern).test(request.url));
+            const matchedRoute = compiledRoutes.find((e) => e.regex.test(request.url))?.route;
             if (!matchedRoute) {
                 await client.send('Fetch.continueRequest', { requestId }, sessionId);
                 return;
@@ -65,25 +66,29 @@ export async function setupRoutes(client, sessionId, routes) {
         }
     });
     _routeListeners.set(sessionId, off);
+    await client.send('Fetch.enable', {
+        patterns: routes.map((r) => ({ urlPattern: globToFetchPattern(r.pattern), requestStage: 'Request' })),
+    }, sessionId);
 }
 const _capturedRequests = new Map();
 const _captureListeners = new Map();
 export function startRequestCapture(client, sessionId) {
-    if (_captureListeners.has(sessionId))
-        return;
-    const list = [];
-    _capturedRequests.set(sessionId, list);
+    stopRequestCapture(sessionId);
+    _capturedRequests.set(sessionId, new Map());
+    client.send('Network.enable', {}, sessionId).catch(() => { });
+    // Use indirection so clearCapturedRequests (which replaces the Map) affects live listeners
+    const idx = () => _capturedRequests.get(sessionId);
     const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
         if (sid !== sessionId)
             return;
         const p = params;
-        list.push({ id: p.requestId, url: p.request.url, method: p.request.method, requestHeaders: p.request.headers, startTime: p.timestamp * 1000 });
+        idx().set(p.requestId, { id: p.requestId, url: p.request.url, method: p.request.method, requestHeaders: p.request.headers, startTime: p.timestamp * 1000 });
     });
     const offResp = client.on('Network.responseReceived', (params, sid) => {
         if (sid !== sessionId)
             return;
         const p = params;
-        const entry = list.find((r) => r.id === p.requestId);
+        const entry = idx().get(p.requestId);
         if (entry) {
             entry.status = p.response.status;
             entry.mimeType = p.response.mimeType;
@@ -95,13 +100,22 @@ export function startRequestCapture(client, sessionId) {
         if (sid !== sessionId)
             return;
         const p = params;
-        const entry = list.find((r) => r.id === p.requestId);
+        const entry = idx().get(p.requestId);
         if (entry) {
             entry.encodedSize = p.encodedDataLength;
             entry.endTime = p.timestamp * 1000;
         }
     });
-    _captureListeners.set(sessionId, [offReq, offResp, offFinished]);
+    const offFailed = client.on('Network.loadingFailed', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const p = params;
+        const entry = idx().get(p.requestId);
+        if (entry) {
+            entry.endTime = p.timestamp * 1000;
+        }
+    });
+    _captureListeners.set(sessionId, [offReq, offResp, offFinished, offFailed]);
 }
 export function stopRequestCapture(sessionId) {
     const offs = _captureListeners.get(sessionId);
@@ -113,10 +127,10 @@ export function stopRequestCapture(sessionId) {
     _capturedRequests.delete(sessionId);
 }
 export function getCapturedRequests(sessionId) {
-    return _capturedRequests.get(sessionId) ?? [];
+    return [...(_capturedRequests.get(sessionId)?.values() ?? [])];
 }
 export function clearCapturedRequests(sessionId) {
-    _capturedRequests.set(sessionId, []);
+    _capturedRequests.set(sessionId, new Map());
 }
 export async function disableInterception(client, sessionId) {
     const prevOff = _routeListeners.get(sessionId);
@@ -126,11 +140,20 @@ export async function disableInterception(client, sessionId) {
     }
     await client.send('Fetch.disable', {}, sessionId);
 }
+export function teardownRouteInterception(sessionId) {
+    const prevOff = _routeListeners.get(sessionId);
+    if (prevOff) {
+        prevOff();
+        _routeListeners.delete(sessionId);
+    }
+}
 export async function getLocalStorage(client, sessionId) {
     const result = await client.send('Runtime.evaluate', {
         expression: 'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',
         returnByValue: true,
     }, sessionId);
+    if (result.exceptionDetails)
+        return {};
     try {
         return JSON.parse(result.result?.value ?? '{}');
     }
@@ -142,14 +165,20 @@ export async function setLocalStorage(client, sessionId, data) {
     const script = Object.entries(data)
         .map(([k, v]) => `localStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
         .join('; ');
-    if (script)
-        await client.send('Runtime.evaluate', { expression: script }, sessionId);
+    if (script) {
+        const result = await client.send('Runtime.evaluate', { expression: script, returnByValue: true }, sessionId);
+        if (result.exceptionDetails) {
+            throw new Error(`setLocalStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
+        }
+    }
 }
 export async function getSessionStorage(client, sessionId) {
     const result = await client.send('Runtime.evaluate', {
         expression: 'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
         returnByValue: true,
     }, sessionId);
+    if (result.exceptionDetails)
+        return {};
     try {
         return JSON.parse(result.result?.value ?? '{}');
     }
@@ -161,14 +190,22 @@ export async function setSessionStorage(client, sessionId, data) {
     const script = Object.entries(data)
         .map(([k, v]) => `sessionStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
         .join('; ');
-    if (script)
-        await client.send('Runtime.evaluate', { expression: script }, sessionId);
+    if (script) {
+        const result = await client.send('Runtime.evaluate', { expression: script, returnByValue: true }, sessionId);
+        if (result.exceptionDetails) {
+            throw new Error(`setSessionStorage failed: ${result.exceptionDetails.exception?.description ?? result.exceptionDetails.text}`);
+        }
+    }
 }
 function globToRegex(pattern) {
+    // Chrome's Fetch urlPattern treats '*' as matching everything including '/'
+    // and '?' as any single character — match both behaviors here to avoid divergence
     const escaped = pattern
-        .replace(/[-[\]{}()+?.,\\^$|#\s]/g, '\\$&')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*');
+        .replace(/[-[\]{}()+.,\\^$|#\s]/g, '\\$&')
+        .replace(/\*\*/g, '\x00')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\x00/g, '.*')
+        .replace(/\?/g, '[^/]');
     return new RegExp(`^${escaped}$`);
 }
 function globToFetchPattern(pattern) {

package/packages/@monomind/cli/dist/src/browser/profiler.js

@@ -2,6 +2,7 @@ import { writeFile } from 'fs/promises';
 import { join } from 'path';
 import { tmpdir } from 'os';
 const _sessions = new Set();
+const _heapSessions = new Set();
 export async function startCpuProfile(client, sessionId, options = {}) {
     if (_sessions.has(sessionId)) {
         throw new Error('CPU profiler already running for this session');
@@ -34,6 +35,10 @@ export function isProfilingActive(sessionId) {
     return _sessions.has(sessionId);
 }
 export async function startHeapSnapshot(client, sessionId, outputPath) {
+    if (_heapSessions.has(sessionId)) {
+        throw new Error('Heap snapshot already in progress for this session');
+    }
+    _heapSessions.add(sessionId);
     await client.send('HeapProfiler.enable', {}, sessionId);
     const chunks = [];
     const off = client.on('HeapProfiler.addHeapSnapshotChunk', (params, sid) => {
@@ -43,22 +48,28 @@ export async function startHeapSnapshot(client, sessionId, outputPath) {
     });
     try {
         await new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                off2();
+                reject(new Error('Timeout waiting for heap snapshot (120s)'));
+            }, 120_000);
             const off2 = client.on('HeapProfiler.reportHeapSnapshotProgress', (params, sid) => {
                 if (sid !== sessionId)
                     return;
                 if (params.finished) {
+                    clearTimeout(timeoutHandle);
                     off2();
                     resolve();
                 }
             });
             client.send('HeapProfiler.takeHeapSnapshot', { reportProgress: true }, sessionId)
-                .catch((err) => { off2(); reject(err); });
+                .catch((err) => { clearTimeout(timeoutHandle); off2(); reject(err); });
         });
     }
     finally {
         off();
+        _heapSessions.delete(sessionId);
+        await client.send('HeapProfiler.disable', {}, sessionId).catch(() => { });
     }
-    await client.send('HeapProfiler.disable', {}, sessionId);
     const path = outputPath ?? join(tmpdir(), `monomind-heap-${Date.now()}.heapsnapshot`);
     await writeFile(path, chunks.join(''));
     return path;

package/packages/@monomind/cli/dist/src/browser/screenshot.js

@@ -1,5 +1,5 @@
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
+import { writeFile, mkdir } from 'fs/promises';
+import { join, dirname } from 'path';
 import { tmpdir } from 'os';
 export async function captureScreenshot(client, sessionId, options = {}) {
     const format = options.format ?? 'png';
@@ -20,6 +20,7 @@ export async function captureScreenshot(client, sessionId, options = {}) {
     const data = result.data;
     const dataUrl = `data:image/${format};base64,${data}`;
     const outputPath = options.path ?? join(tmpdir(), `monomind-screenshot-${Date.now()}.${format}`);
+    await mkdir(dirname(outputPath), { recursive: true });
     await writeFile(outputPath, Buffer.from(data, 'base64'));
     return { path: outputPath, dataUrl };
 }

package/packages/@monomind/cli/dist/src/browser/session.js

@@ -1,10 +1,23 @@
 import { readFile, writeFile, mkdir } from 'fs/promises';
-import { existsSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { getCookies, setCookies, getLocalStorage, setLocalStorage, getSessionStorage, setSessionStorage } from './network.js';
 const SESSION_DIR = join(homedir(), '.monomind', 'browser-sessions');
+function validateSessionName(name) {
+    if (!name || /[/\\\x00]/.test(name) || name === '..' || name === '.' || name.startsWith('..')) {
+        throw new Error(`Invalid session name: ${JSON.stringify(name)}`);
+    }
+}
+function validateFilePath(filePath) {
+    if (!filePath || filePath.includes('\x00')) {
+        throw new Error(`Invalid file path: ${JSON.stringify(filePath)}`);
+    }
+    if (filePath.includes('/../') || filePath.startsWith('../') || filePath.endsWith('/..') || filePath.includes('\\')) {
+        throw new Error(`Invalid file path (traversal not allowed): ${JSON.stringify(filePath)}`);
+    }
+}
 export async function saveSession(client, sessionId, targetId, name, url, title) {
+    validateSessionName(name);
     await mkdir(SESSION_DIR, { recursive: true });
     const cookies = await getCookies(client, sessionId);
     const localStorage = await getLocalStorage(client, sessionId);
@@ -15,19 +28,32 @@ export async function saveSession(client, sessionId, targetId, name, url, title)
     return filePath;
 }
 export async function loadSession(client, sessionId, name) {
+    validateSessionName(name);
     const filePath = join(SESSION_DIR, `${name}.json`);
-    if (!existsSync(filePath))
-        throw new Error(`Session not found: ${name}`);
-    const raw = await readFile(filePath, 'utf8');
+    const raw = await readFile(filePath, 'utf8').catch((err) => {
+        if (err.code === 'ENOENT')
+            throw new Error(`Session not found: ${name}`);
+        throw err;
+    });
     const state = JSON.parse(raw);
+    if (!Array.isArray(state.cookies))
+        throw new Error(`Invalid session file: cookies is not an array`);
     await setCookies(client, sessionId, state.cookies);
-    if (state.localStorage)
+    if (state.localStorage) {
+        if (typeof state.localStorage !== 'object' || Array.isArray(state.localStorage))
+            throw new Error('Invalid session file: localStorage is not a plain object');
         await setLocalStorage(client, sessionId, state.localStorage);
-    if (state.sessionStorage)
+    }
+    if (state.sessionStorage) {
+        if (typeof state.sessionStorage !== 'object' || Array.isArray(state.sessionStorage))
+            throw new Error('Invalid session file: sessionStorage is not a plain object');
         await setSessionStorage(client, sessionId, state.sessionStorage);
+    }
     return state;
 }
 export async function saveStateFile(client, sessionId, targetId, filePath, url, title) {
+    validateFilePath(filePath);
+    await mkdir(dirname(filePath), { recursive: true });
     const cookies = await getCookies(client, sessionId);
     const localStorage = await getLocalStorage(client, sessionId);
     const sessionStorage = await getSessionStorage(client, sessionId);
@@ -35,20 +61,31 @@ export async function saveStateFile(client, sessionId, targetId, filePath, url,
     await writeFile(filePath, JSON.stringify(state, null, 2));
 }
 export async function loadStateFile(client, sessionId, filePath) {
+    validateFilePath(filePath);
     const raw = await readFile(filePath, 'utf8');
     const state = JSON.parse(raw);
+    if (!Array.isArray(state.cookies))
+        throw new Error(`Invalid state file: cookies is not an array`);
     await setCookies(client, sessionId, state.cookies);
-    if (state.localStorage)
+    if (state.localStorage) {
+        if (typeof state.localStorage !== 'object' || Array.isArray(state.localStorage))
+            throw new Error('Invalid state file: localStorage is not a plain object');
         await setLocalStorage(client, sessionId, state.localStorage);
-    if (state.sessionStorage)
+    }
+    if (state.sessionStorage) {
+        if (typeof state.sessionStorage !== 'object' || Array.isArray(state.sessionStorage))
+            throw new Error('Invalid state file: sessionStorage is not a plain object');
         await setSessionStorage(client, sessionId, state.sessionStorage);
+    }
     return state;
 }
 export async function listSessions() {
-    if (!existsSync(SESSION_DIR))
-        return [];
     const { readdir } = await import('fs/promises');
-    const files = await readdir(SESSION_DIR);
+    const files = await readdir(SESSION_DIR).catch((err) => {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    });
     return files.filter((f) => f.endsWith('.json')).map((f) => f.replace(/\.json$/, ''));
 }
 //# sourceMappingURL=session.js.map

package/packages/@monomind/cli/dist/src/browser/snapshot.js

@@ -8,7 +8,7 @@ export async function captureSnapshot(client, sessionId, options = {}) {
         const doc = await client.send('DOM.getDocument', {}, sessionId);
         const found = await client.send('DOM.querySelector', { nodeId: doc.root.nodeId, selector }, sessionId).catch(() => ({ nodeId: 0 }));
         if (found.nodeId) {
-            const partial = await client.send('Accessibility.getPartialAXTree', { nodeId: found.nodeId, fetchRelatives: true }, sessionId).catch(async () => client.send('Accessibility.getFullAXTree', {}, sessionId));
+            const partial = await client.send('Accessibility.getPartialAXTree', { nodeId: found.nodeId, fetchRelatives: false }, sessionId).catch(async () => client.send('Accessibility.getFullAXTree', {}, sessionId));
             nodes = partial.nodes;
         }
         else {
@@ -29,14 +29,19 @@ export async function captureSnapshot(client, sessionId, options = {}) {
     let refCounter = 1;
     const lines = [];
     const processNode = (node, depth) => {
-        if (node.ignored)
-            return;
-        if (maxDepth !== undefined && depth > maxDepth)
+        // Transparent/structural nodes don't consume depth budget — check before maxDepth
+        if (node.ignored) {
+            if (node.childIds) {
+                for (const childId of node.childIds) {
+                    const child = nodeMap.get(childId);
+                    if (child)
+                        processNode(child, depth);
+                }
+            }
             return;
+        }
         const role = node.role?.value ?? 'generic';
-        const name = node.name?.value ?? '';
-        const description = node.description?.value;
-        if (role === 'none' || role === 'generic' || role === 'InlineTextBox') {
+        if (role === 'none' || role === 'generic' || role === 'inlineTextBox') {
             if (node.childIds) {
                 for (const childId of node.childIds) {
                     const child = nodeMap.get(childId);
@@ -46,6 +51,11 @@ export async function captureSnapshot(client, sessionId, options = {}) {
             }
             return;
         }
+        // Only enforce maxDepth for real rendered roles
+        if (maxDepth !== undefined && depth > maxDepth)
+            return;
+        const name = node.name?.value ?? '';
+        const description = node.description?.value;
         const isInteractive = INTERACTIVE_ROLES.has(role.toLowerCase());
         if (interactiveOnly && !isInteractive) {
             if (node.childIds) {
@@ -91,7 +101,7 @@ export async function captureSnapshot(client, sessionId, options = {}) {
         const descStr = description && !compact ? ` (${description})` : '';
         const attrsStr = ` [${attrParts.join(', ')}]`;
         lines.push(`${indent}${role}${nameStr}${descStr}${attrsStr}`);
-        if (!isInteractive && node.childIds) {
+        if (node.childIds) {
             for (const childId of node.childIds) {
                 const child = nodeMap.get(childId);
                 if (child)
@@ -99,9 +109,10 @@ export async function captureSnapshot(client, sessionId, options = {}) {
             }
         }
     };
-    // Find root node
-    const root = nodes.find((n) => !n.parentId);
-    if (root)
+    // Find root nodes — for partial trees parentId may point outside the set; use filter to handle forests
+    const ids = new Set(nodes.map((n) => n.nodeId));
+    const roots = nodes.filter((n) => n.parentId === undefined || !ids.has(n.parentId));
+    for (const root of roots)
         processNode(root, 0);
     return { text: lines.join('\n'), refs, url, title };
 }
@@ -112,7 +123,8 @@ function extractProperties(node) {
     for (const prop of node.properties) {
         switch (prop.name) {
             case 'value':
-                result.value = String(prop.value.value ?? '');
+                if (prop.value.value != null)
+                    result.value = String(prop.value.value);
                 break;
             case 'disabled':
                 result.disabled = Boolean(prop.value.value);
@@ -156,8 +168,8 @@ export async function getElementBox(client, sessionId, ref) {
         const content = result.model?.content;
         if (!content || content.length < 8)
             return null;
-        const x = (content[0] + content[2]) / 2;
-        const y = (content[1] + content[5]) / 2;
+        const x = (content[0] + content[2] + content[4] + content[6]) / 4;
+        const y = (content[1] + content[3] + content[5] + content[7]) / 4;
         return { x, y, width: result.model.width, height: result.model.height };
     }
     catch {

package/packages/@monomind/cli/dist/src/browser/storage.d.ts

@@ -6,6 +6,7 @@ export declare function clearLocalStorage(client: CdpClient, sessionId: string):
 export declare function getAllLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
 export declare function getSessionStorageKey(client: CdpClient, sessionId: string, key: string): Promise<string | null>;
 export declare function setSessionStorageKey(client: CdpClient, sessionId: string, key: string, value: string): Promise<void>;
+export declare function removeSessionStorageKey(client: CdpClient, sessionId: string, key: string): Promise<void>;
 export declare function clearSessionStorage(client: CdpClient, sessionId: string): Promise<void>;
 export declare function getAllSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
 //# sourceMappingURL=storage.d.ts.map

package/packages/@monomind/cli/dist/src/browser/storage.js

@@ -28,6 +28,9 @@ export async function getSessionStorageKey(client, sessionId, key) {
 export async function setSessionStorageKey(client, sessionId, key, value) {
     await evaluateJs(client, sessionId, `sessionStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`);
 }
+export async function removeSessionStorageKey(client, sessionId, key) {
+    await evaluateJs(client, sessionId, `sessionStorage.removeItem(${JSON.stringify(key)})`);
+}
 export async function clearSessionStorage(client, sessionId) {
     await evaluateJs(client, sessionId, 'sessionStorage.clear()');
 }

package/packages/@monomind/cli/dist/src/browser/tabs.d.ts

@@ -2,7 +2,7 @@ import type { CdpClient } from './cdp.js';
 import type { CdpTarget } from './types.js';
 export declare function listTabs(port: number): Promise<CdpTarget[]>;
 export declare function newTab(port: number, url?: string): Promise<CdpTarget>;
-export declare function closeTab(client: CdpClient, sessionId: string, targetId: string): Promise<void>;
-export declare function activateTab(client: CdpClient, sessionId: string, targetId: string): Promise<string>;
+export declare function closeTab(client: CdpClient, _sessionId: string, targetId: string): Promise<void>;
+export declare function activateTab(client: CdpClient, oldSessionId: string, targetId: string): Promise<string>;
 export declare function switchToFrame(_client: CdpClient, _sessionId: string, _frameSelector: string): Promise<string | null>;
 //# sourceMappingURL=tabs.d.ts.map

package/packages/@monomind/cli/dist/src/browser/tabs.js

@@ -6,12 +6,15 @@ export async function listTabs(port) {
 export async function newTab(port, url = 'about:blank') {
     return fetchNewTarget(port, url);
 }
-export async function closeTab(client, sessionId, targetId) {
-    await client.send('Target.closeTarget', { targetId }, sessionId);
+export async function closeTab(client, _sessionId, targetId) {
+    await client.send('Target.closeTarget', { targetId });
 }
-export async function activateTab(client, sessionId, targetId) {
-    await client.send('Target.activateTarget', { targetId }, sessionId);
-    const result = await client.send('Target.attachToTarget', { targetId, flatten: true }, sessionId);
+export async function activateTab(client, oldSessionId, targetId) {
+    if (oldSessionId) {
+        await client.send('Target.detachFromTarget', { sessionId: oldSessionId }).catch(() => { });
+    }
+    await client.send('Target.activateTarget', { targetId });
+    const result = await client.send('Target.attachToTarget', { targetId, flatten: true });
     return result.sessionId;
 }
 export async function switchToFrame(_client, _sessionId, _frameSelector) {

package/packages/@monomind/cli/dist/src/browser/wait.js

@@ -32,7 +32,10 @@ async function waitForLoad(client, sessionId, condition, timeout) {
     const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
     const [eventPromise, cancelOnce] = client.onceWithOff(event, sessionId);
     let timedOut = false;
-    const timeoutPromise = sleep(timeout).then(() => { timedOut = true; });
+    let timeoutHandle;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutHandle = setTimeout(() => { timedOut = true; resolve(); }, timeout);
+    });
     try {
         await Promise.race([eventPromise, timeoutPromise]);
         if (timedOut)
@@ -40,11 +43,13 @@ async function waitForLoad(client, sessionId, condition, timeout) {
     }
     finally {
         cancelOnce();
+        clearTimeout(timeoutHandle);
     }
 }
 async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
     return new Promise((resolve, reject) => {
         let pending = 0;
+        const inflight = new Set();
         let idleTimer = null;
         const cleanup = () => {
             if (idleTimer) {
@@ -55,6 +60,7 @@ async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
             offReq();
             offResp();
             offFail();
+            offCache();
         };
         const killTimer = setTimeout(() => {
             cleanup();
@@ -74,24 +80,28 @@ async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
                 }
             }
         };
-        const offReq = client.on('Network.requestWillBeSent', (_, sid) => {
-            if (sid === sessionId) {
+        const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
+            if (sid !== sessionId)
+                return;
+            const id = params.requestId;
+            if (!inflight.has(id)) {
+                inflight.add(id);
                 pending++;
                 check();
             }
         });
-        const offResp = client.on('Network.loadingFinished', (_, sid) => {
-            if (sid === sessionId) {
+        const decrement = (params, sid) => {
+            if (sid !== sessionId)
+                return;
+            const id = params.requestId;
+            if (inflight.delete(id)) {
                 pending = Math.max(0, pending - 1);
                 check();
             }
-        });
-        const offFail = client.on('Network.loadingFailed', (_, sid) => {
-            if (sid === sessionId) {
-                pending = Math.max(0, pending - 1);
-                check();
-            }
-        });
+        };
+        const offResp = client.on('Network.loadingFinished', decrement);
+        const offFail = client.on('Network.loadingFailed', decrement);
+        const offCache = client.on('Network.requestServedFromCache', decrement);
         check();
     });
 }
@@ -107,7 +117,7 @@ async function waitForUrl(client, sessionId, pattern, deadline) {
 }
 async function waitForText(client, sessionId, text, deadline) {
     while (Date.now() < deadline) {
-        const bodyText = await evaluateJs(client, sessionId, 'document.body.innerText');
+        const bodyText = await evaluateJs(client, sessionId, 'document.body?.innerText ?? ""');
         if (bodyText.includes(text))
             return;
         await sleep(POLL_INTERVAL);