monomind 2.7.5 → 2.7.6

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

@@ -1,214 +0,0 @@
-export async function getCookies(client, sessionId) {
-    const result = await client.send('Network.getAllCookies', {}, sessionId);
-    return result.cookies ?? [];
-}
-export async function setCookies(client, sessionId, cookies) {
-    await client.send('Network.setCookies', { cookies }, sessionId);
-}
-export async function clearCookies(client, sessionId) {
-    await client.send('Network.clearBrowserCookies', {}, sessionId);
-}
-export async function setExtraHeaders(client, sessionId, headers) {
-    await client.send('Network.setExtraHTTPHeaders', { headers }, sessionId);
-}
-export async function enableInterception(client, sessionId) {
-    await client.send('Fetch.enable', {
-        patterns: [{ requestStage: 'Request' }],
-    }, sessionId);
-}
-const _routeListeners = new Map();
-export async function setupRoutes(client, sessionId, routes) {
-    // Remove previous route listener for this session before registering a new one
-    const prevOff = _routeListeners.get(sessionId);
-    if (prevOff) {
-        prevOff();
-        _routeListeners.delete(sessionId);
-    }
-    if (routes.length === 0) {
-        await client.send('Fetch.disable', {}, sessionId).catch(() => { });
-        return;
-    }
-    // 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 = compiledRoutes.find((e) => e.regex.test(request.url))?.route;
-            if (!matchedRoute) {
-                await client.send('Fetch.continueRequest', { requestId }, sessionId);
-                return;
-            }
-            switch (matchedRoute.action) {
-                case 'abort':
-                    await client.send('Fetch.failRequest', { requestId, errorReason: 'Failed' }, sessionId);
-                    break;
-                case 'fulfill':
-                    await client.send('Fetch.fulfillRequest', {
-                        requestId,
-                        responseCode: matchedRoute.response?.status ?? 200,
-                        responseHeaders: Object.entries(matchedRoute.response?.headers ?? {}).map(([name, value]) => ({ name, value })),
-                        body: matchedRoute.response?.body ? Buffer.from(matchedRoute.response.body).toString('base64') : '',
-                    }, sessionId);
-                    break;
-                case 'continue':
-                default:
-                    await client.send('Fetch.continueRequest', { requestId }, sessionId);
-                    break;
-            }
-        }
-        catch {
-            // Best-effort: resume the request so it doesn't hang in Chrome
-            await client.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
-        }
-    });
-    _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) {
-    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;
-        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 = idx().get(p.requestId);
-        if (entry) {
-            entry.status = p.response.status;
-            entry.mimeType = p.response.mimeType;
-            entry.responseHeaders = p.response.headers;
-            entry.endTime = p.timestamp * 1000;
-        }
-    });
-    const offFinished = client.on('Network.loadingFinished', (params, sid) => {
-        if (sid !== sessionId)
-            return;
-        const p = params;
-        const entry = idx().get(p.requestId);
-        if (entry) {
-            entry.encodedSize = p.encodedDataLength;
-            entry.endTime = p.timestamp * 1000;
-        }
-    });
-    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);
-    if (offs) {
-        for (const off of offs)
-            off();
-        _captureListeners.delete(sessionId);
-    }
-    _capturedRequests.delete(sessionId);
-}
-export function getCapturedRequests(sessionId) {
-    return [...(_capturedRequests.get(sessionId)?.values() ?? [])];
-}
-export function clearCapturedRequests(sessionId) {
-    _capturedRequests.set(sessionId, new Map());
-}
-export async function disableInterception(client, sessionId) {
-    const prevOff = _routeListeners.get(sessionId);
-    if (prevOff) {
-        prevOff();
-        _routeListeners.delete(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 ?? '{}');
-    }
-    catch {
-        return {};
-    }
-}
-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) {
-        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 ?? '{}');
-    }
-    catch {
-        return {};
-    }
-}
-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) {
-        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, '\x00')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\x00/g, '.*')
-        .replace(/\?/g, '[^/]');
-    return new RegExp(`^${escaped}$`);
-}
-function globToFetchPattern(pattern) {
-    return pattern.replace(/\*\*/g, '*');
-}
-//# sourceMappingURL=network.js.map

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

@@ -1,15 +0,0 @@
-import type { CdpClient } from './cdp.js';
-export interface PdfOptions {
-    path?: string;
-    landscape?: boolean;
-    paperWidth?: number;
-    paperHeight?: number;
-    marginTop?: number;
-    marginBottom?: number;
-    marginLeft?: number;
-    marginRight?: number;
-    printBackground?: boolean;
-    scale?: number;
-}
-export declare function capturePdf(client: CdpClient, sessionId: string, options?: PdfOptions): Promise<string>;
-//# sourceMappingURL=pdf.d.ts.map

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

@@ -1,27 +0,0 @@
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
-export async function capturePdf(client, sessionId, options = {}) {
-    const params = {
-        landscape: options.landscape ?? false,
-        printBackground: options.printBackground ?? true,
-        scale: options.scale ?? 1,
-    };
-    if (options.paperWidth)
-        params.paperWidth = options.paperWidth;
-    if (options.paperHeight)
-        params.paperHeight = options.paperHeight;
-    if (options.marginTop !== undefined)
-        params.marginTop = options.marginTop;
-    if (options.marginBottom !== undefined)
-        params.marginBottom = options.marginBottom;
-    if (options.marginLeft !== undefined)
-        params.marginLeft = options.marginLeft;
-    if (options.marginRight !== undefined)
-        params.marginRight = options.marginRight;
-    const result = await client.send('Page.printToPDF', params, sessionId);
-    const outputPath = options.path ?? join(tmpdir(), `monomind-pdf-${Date.now()}.pdf`);
-    await writeFile(outputPath, Buffer.from(result.data, 'base64'));
-    return outputPath;
-}
-//# sourceMappingURL=pdf.js.map

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

@@ -1,10 +0,0 @@
-import type { CdpClient } from './cdp.js';
-export interface ProfilerOptions {
-    path?: string;
-    samplingInterval?: number;
-}
-export declare function startCpuProfile(client: CdpClient, sessionId: string, options?: ProfilerOptions): Promise<void>;
-export declare function stopCpuProfile(client: CdpClient, sessionId: string, outputPath?: string): Promise<string>;
-export declare function isProfilingActive(sessionId: string): boolean;
-export declare function startHeapSnapshot(client: CdpClient, sessionId: string, outputPath?: string): Promise<string>;
-//# sourceMappingURL=profiler.d.ts.map

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

@@ -1,77 +0,0 @@
-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');
-    }
-    await client.send('Profiler.enable', {}, sessionId);
-    if (options.samplingInterval !== undefined) {
-        await client.send('Profiler.setSamplingInterval', { interval: options.samplingInterval }, sessionId);
-    }
-    await client.send('Profiler.start', {}, sessionId);
-    _sessions.add(sessionId);
-}
-export async function stopCpuProfile(client, sessionId, outputPath) {
-    if (!_sessions.has(sessionId)) {
-        throw new Error('No active CPU profiler for this session');
-    }
-    let result;
-    try {
-        result = await client.send('Profiler.stop', {}, sessionId);
-    }
-    finally {
-        _sessions.delete(sessionId);
-    }
-    // Disable after capturing the profile so a disable failure doesn't discard valid data
-    await client.send('Profiler.disable', {}, sessionId).catch(() => { });
-    const path = outputPath ?? join(tmpdir(), `monomind-profile-${Date.now()}.cpuprofile`);
-    await writeFile(path, JSON.stringify(result.profile));
-    return path;
-}
-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) => {
-        if (sid !== sessionId)
-            return;
-        chunks.push(params.chunk);
-    });
-    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) => { clearTimeout(timeoutHandle); off2(); reject(err); });
-        });
-    }
-    finally {
-        off();
-        _heapSessions.delete(sessionId);
-        await client.send('HeapProfiler.disable', {}, sessionId).catch(() => { });
-    }
-    const path = outputPath ?? join(tmpdir(), `monomind-heap-${Date.now()}.heapsnapshot`);
-    await writeFile(path, chunks.join(''));
-    return path;
-}
-//# sourceMappingURL=profiler.js.map

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

@@ -1,21 +0,0 @@
-import type { CdpClient } from './cdp.js';
-export interface RecordOptions {
-    path?: string;
-    format?: 'jpeg' | 'png' | 'webp';
-    quality?: number;
-    everyNthFrame?: number;
-    maxWidth?: number;
-    maxHeight?: number;
-}
-export interface RecordingState {
-    frames: string[];
-    offScreencast: (() => void) | null;
-}
-export declare function startRecording(client: CdpClient, sessionId: string, options?: RecordOptions): Promise<void>;
-export declare function stopRecording(client: CdpClient, sessionId: string, outputPath?: string): Promise<string>;
-export declare function getRecordingStatus(sessionId: string): {
-    recording: boolean;
-    frames: number;
-};
-export declare function saveFrameAsPng(client: CdpClient, sessionId: string, frameIndex: number, outputPath: string): Promise<void>;
-//# sourceMappingURL=record.d.ts.map

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

@@ -1,59 +0,0 @@
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
-const _sessions = new Map();
-export async function startRecording(client, sessionId, options = {}) {
-    if (_sessions.has(sessionId)) {
-        throw new Error('Recording already in progress for this session');
-    }
-    const state = { frames: [], offScreencast: null };
-    _sessions.set(sessionId, state);
-    state.offScreencast = client.on('Page.screencastFrame', async (params, sid) => {
-        if (sid !== sessionId)
-            return;
-        const { data, sessionId: frameSessionId } = params;
-        state.frames.push(data);
-        await client.send('Page.screencastFrameAck', { sessionId: frameSessionId }, sessionId).catch(() => { });
-    });
-    try {
-        await client.send('Page.startScreencast', {
-            format: options.format ?? 'jpeg',
-            quality: options.quality ?? 80,
-            everyNthFrame: options.everyNthFrame ?? 1,
-            ...(options.maxWidth ? { maxWidth: options.maxWidth } : {}),
-            ...(options.maxHeight ? { maxHeight: options.maxHeight } : {}),
-        }, sessionId);
-    }
-    catch (err) {
-        state.offScreencast?.();
-        _sessions.delete(sessionId);
-        throw err;
-    }
-}
-export async function stopRecording(client, sessionId, outputPath) {
-    const state = _sessions.get(sessionId);
-    if (!state)
-        throw new Error('No active recording for this session');
-    try {
-        await client.send('Page.stopScreencast', {}, sessionId);
-    }
-    finally {
-        state.offScreencast?.();
-        _sessions.delete(sessionId);
-    }
-    const path = outputPath ?? join(tmpdir(), `monomind-screencast-${Date.now()}.frames.json`);
-    await writeFile(path, JSON.stringify({ frameCount: state.frames.length, frames: state.frames }));
-    return path;
-}
-export function getRecordingStatus(sessionId) {
-    const state = _sessions.get(sessionId);
-    return { recording: !!state, frames: state?.frames.length ?? 0 };
-}
-export async function saveFrameAsPng(client, sessionId, frameIndex, outputPath) {
-    const state = _sessions.get(sessionId);
-    if (!state || frameIndex >= state.frames.length) {
-        throw new Error(`Frame ${frameIndex} not available`);
-    }
-    await writeFile(outputPath, Buffer.from(state.frames[frameIndex], 'base64'));
-}
-//# sourceMappingURL=record.js.map

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

@@ -1,15 +0,0 @@
-import type { CdpClient } from './cdp.js';
-export interface ScreenshotOptions {
-    path?: string;
-    fullPage?: boolean;
-    quality?: number;
-    format?: 'jpeg' | 'png' | 'webp';
-    annotate?: boolean;
-}
-export declare function captureScreenshot(client: CdpClient, sessionId: string, options?: ScreenshotOptions): Promise<{
-    path: string;
-    dataUrl: string;
-}>;
-export declare function setViewport(client: CdpClient, sessionId: string, width: number, height: number): Promise<void>;
-export declare function setUserAgent(client: CdpClient, sessionId: string, userAgent: string): Promise<void>;
-//# sourceMappingURL=screenshot.d.ts.map

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

@@ -1,38 +0,0 @@
-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';
-    const params = { format };
-    if (format === 'jpeg' || format === 'webp') {
-        params.quality = options.quality ?? 80;
-    }
-    if (options.fullPage) {
-        const dims = await client.send('Runtime.evaluate', {
-            expression: 'JSON.stringify({w: document.documentElement.scrollWidth, h: document.documentElement.scrollHeight})',
-            returnByValue: true,
-        }, sessionId);
-        const { w, h } = JSON.parse(dims.result?.value ?? '{"w":1280,"h":720}');
-        params.clip = { x: 0, y: 0, width: w, height: h, scale: 1 };
-        params.captureBeyondViewport = true;
-    }
-    const result = await client.send('Page.captureScreenshot', params, sessionId);
-    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 };
-}
-export async function setViewport(client, sessionId, width, height) {
-    await client.send('Emulation.setDeviceMetricsOverride', {
-        width,
-        height,
-        deviceScaleFactor: 1,
-        mobile: false,
-    }, sessionId);
-}
-export async function setUserAgent(client, sessionId, userAgent) {
-    await client.send('Emulation.setUserAgentOverride', { userAgent }, sessionId);
-}
-//# sourceMappingURL=screenshot.js.map

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

@@ -1,8 +0,0 @@
-import type { SessionState } from './types.js';
-import type { CdpClient } from './cdp.js';
-export declare function saveSession(client: CdpClient, sessionId: string, targetId: string, name: string, url: string, title: string): Promise<string>;
-export declare function loadSession(client: CdpClient, sessionId: string, name: string): Promise<SessionState>;
-export declare function saveStateFile(client: CdpClient, sessionId: string, targetId: string, filePath: string, url: string, title: string): Promise<void>;
-export declare function loadStateFile(client: CdpClient, sessionId: string, filePath: string): Promise<SessionState>;
-export declare function listSessions(): Promise<string[]>;
-//# sourceMappingURL=session.d.ts.map

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

@@ -1,91 +0,0 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
-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);
-    const sessionStorage = await getSessionStorage(client, sessionId);
-    const state = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
-    const filePath = join(SESSION_DIR, `${name}.json`);
-    await writeFile(filePath, JSON.stringify(state, null, 2));
-    return filePath;
-}
-export async function loadSession(client, sessionId, name) {
-    validateSessionName(name);
-    const filePath = join(SESSION_DIR, `${name}.json`);
-    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 (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 (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);
-    const state = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
-    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 (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 (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() {
-    const { readdir } = await import('fs/promises');
-    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.d.ts

@@ -1,12 +0,0 @@
-import type { CdpClient } from './cdp.js';
-import type { ElementRef, SnapshotOptions, SnapshotResult } from './types.js';
-export declare function captureSnapshot(client: CdpClient, sessionId: string, options?: SnapshotOptions): Promise<SnapshotResult>;
-export declare function resolveRef(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, refKey: string): Promise<ElementRef>;
-export declare function getObjectIdForRef(client: CdpClient, sessionId: string, ref: ElementRef): Promise<string | null>;
-export declare function getElementBox(client: CdpClient, sessionId: string, ref: ElementRef): Promise<{
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-} | null>;
-//# sourceMappingURL=snapshot.d.ts.map