@monoes/monobrowse 1.0.11 → 1.0.12

package/src/browser/screenshot.ts

@@ -1,9 +1,9 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import type { ElementRef } from './types.js';
 import { getObjectIdForRef } from './snapshot.js';
-import { writeFile, mkdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import { tmpdir } from 'os';
+import type { ElementRef } from './types.js';
 
 export interface ScreenshotOptions {
   path?: string;
@@ -17,16 +17,21 @@ export interface ScreenshotOptions {
 async function getViewportTopLeft(
   client: CdpClient,
   sessionId: string,
-  ref: ElementRef
+  ref: ElementRef,
 ): Promise<{ x: number; y: number } | null> {
   const objectId = await getObjectIdForRef(client, sessionId, ref).catch(() => null);
   if (!objectId) return null;
   try {
-    const r = await client.send<{ result: { value?: string } }>('Runtime.callFunctionOn', {
-      functionDeclaration: 'function() { var r=this.getBoundingClientRect(); if(r.width===0&&r.height===0)return null; return JSON.stringify({x:Math.round(r.left),y:Math.round(r.top)}); }',
-      objectId,
-      returnByValue: true,
-    }, sessionId);
+    const r = await client.send<{ result: { value?: string } }>(
+      'Runtime.callFunctionOn',
+      {
+        functionDeclaration:
+          'function() { var r=this.getBoundingClientRect(); if(r.width===0&&r.height===0)return null; return JSON.stringify({x:Math.round(r.left),y:Math.round(r.top)}); }',
+        objectId,
+        returnByValue: true,
+      },
+      sessionId,
+    );
     if (!r.result?.value) return null;
     return JSON.parse(r.result.value) as { x: number; y: number };
   } catch {
@@ -37,7 +42,7 @@ async function getViewportTopLeft(
 async function injectAnnotationOverlay(
   client: CdpClient,
   sessionId: string,
-  refs: Map<string, ElementRef>
+  refs: Map<string, ElementRef>,
 ): Promise<void> {
   const badges: Array<{ num: number; x: number; y: number }> = [];
   for (const [key, ref] of refs) {
@@ -49,8 +54,11 @@ async function injectAnnotationOverlay(
   if (badges.length === 0) return;
 
   const badgesJson = JSON.stringify(badges);
-  await client.send('Runtime.evaluate', {
-    expression: `(function(){
+  await client
+    .send(
+      'Runtime.evaluate',
+      {
+        expression: `(function(){
       var p=document.getElementById('__mm_ann__');if(p)p.remove();
       var c=document.createElement('div');
       c.id='__mm_ann__';
@@ -64,21 +72,30 @@ async function injectAnnotationOverlay(
       });
       document.body.appendChild(c);
     })()`,
-    returnByValue: false,
-  }, sessionId).catch(() => {});
+        returnByValue: false,
+      },
+      sessionId,
+    )
+    .catch(() => {});
 }
 
 async function removeAnnotationOverlay(client: CdpClient, sessionId: string): Promise<void> {
-  await client.send('Runtime.evaluate', {
-    expression: `(function(){var e=document.getElementById('__mm_ann__');if(e)e.remove();})()`,
-    returnByValue: false,
-  }, sessionId).catch(() => {});
+  await client
+    .send(
+      'Runtime.evaluate',
+      {
+        expression: `(function(){var e=document.getElementById('__mm_ann__');if(e)e.remove();})()`,
+        returnByValue: false,
+      },
+      sessionId,
+    )
+    .catch(() => {});
 }
 
 export async function captureScreenshot(
   client: CdpClient,
   sessionId: string,
-  options: ScreenshotOptions = {}
+  options: ScreenshotOptions = {},
 ): Promise<{ path: string; dataUrl: string }> {
   const format = options.format ?? 'png';
   const params: Record<string, unknown> = { format };
@@ -88,10 +105,15 @@ export async function captureScreenshot(
   }
 
   if (options.fullPage) {
-    const dims = await client.send<{ result: { value: string } }>('Runtime.evaluate', {
-      expression: 'JSON.stringify({w: document.documentElement.scrollWidth, h: document.documentElement.scrollHeight})',
-      returnByValue: true,
-    }, sessionId);
+    const dims = await client.send<{ result: { value: string } }>(
+      '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;
@@ -123,20 +145,24 @@ export async function setViewport(
   client: CdpClient,
   sessionId: string,
   width: number,
-  height: number
+  height: number,
 ): Promise<void> {
-  await client.send('Emulation.setDeviceMetricsOverride', {
-    width,
-    height,
-    deviceScaleFactor: 1,
-    mobile: false,
-  }, sessionId);
+  await client.send(
+    'Emulation.setDeviceMetricsOverride',
+    {
+      width,
+      height,
+      deviceScaleFactor: 1,
+      mobile: false,
+    },
+    sessionId,
+  );
 }
 
 export async function setUserAgent(
   client: CdpClient,
   sessionId: string,
-  userAgent: string
+  userAgent: string,
 ): Promise<void> {
   await client.send('Emulation.setUserAgentOverride', { userAgent }, sessionId);
 }

package/src/browser/session.ts

@@ -1,9 +1,16 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
-import type { SessionState, CdpCookie } from './types.js';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { getCookiesForUrls, setCookies, getLocalStorage, setLocalStorage, getSessionStorage, setSessionStorage } from './network.js';
+import {
+  getCookiesForUrls,
+  getLocalStorage,
+  getSessionStorage,
+  setCookies,
+  setLocalStorage,
+  setSessionStorage,
+} from './network.js';
+import type { SessionState } from './types.js';
 
 // Session state files contain cookies/localStorage — treat as secrets:
 // owner-only read/write on the file (0600) and owner-only access on the
@@ -23,7 +30,12 @@ function validateFilePath(filePath: string): void {
   if (!filePath || filePath.includes('\x00')) {
     throw new Error(`Invalid file path: ${JSON.stringify(filePath)}`);
   }
-  if (filePath.includes('/../') || filePath.startsWith('../') || filePath.endsWith('/..') || filePath.includes('\\')) {
+  if (
+    filePath.includes('/../') ||
+    filePath.startsWith('../') ||
+    filePath.endsWith('/..') ||
+    filePath.includes('\\')
+  ) {
     throw new Error(`Invalid file path (traversal not allowed): ${JSON.stringify(filePath)}`);
   }
 }
@@ -34,7 +46,7 @@ export async function saveSession(
   targetId: string,
   name: string,
   url: string,
-  title: string
+  title: string,
 ): Promise<string> {
   validateSessionName(name);
   await mkdir(SESSION_DIR, { recursive: true, mode: SESSION_DIR_MODE });
@@ -43,7 +55,15 @@ export async function saveSession(
   const localStorage = await getLocalStorage(client, sessionId);
   const sessionStorage = await getSessionStorage(client, sessionId);
 
-  const state: SessionState = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
+  const state: SessionState = {
+    targetId,
+    sessionId,
+    url,
+    title,
+    cookies,
+    localStorage,
+    sessionStorage,
+  };
   const filePath = join(SESSION_DIR, `${name}.json`);
   await writeFile(filePath, JSON.stringify(state, null, 2), { mode: SESSION_FILE_MODE });
   return filePath;
@@ -52,7 +72,7 @@ export async function saveSession(
 export async function loadSession(
   client: CdpClient,
   sessionId: string,
-  name: string
+  name: string,
 ): Promise<SessionState> {
   validateSessionName(name);
   const filePath = join(SESSION_DIR, `${name}.json`);
@@ -61,15 +81,18 @@ export async function loadSession(
     throw err;
   });
   const state: SessionState = JSON.parse(raw);
-  if (!Array.isArray(state.cookies)) throw new Error(`Invalid session file: cookies is not an array`);
+  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');
+    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');
+    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);
   }
 
@@ -82,21 +105,29 @@ export async function saveStateFile(
   targetId: string,
   filePath: string,
   url: string,
-  title: string
+  title: string,
 ): Promise<void> {
   validateFilePath(filePath);
   await mkdir(dirname(filePath), { recursive: true, mode: SESSION_DIR_MODE });
   const cookies = await getCookiesForUrls(client, sessionId, [url]);
   const localStorage = await getLocalStorage(client, sessionId);
   const sessionStorage = await getSessionStorage(client, sessionId);
-  const state: SessionState = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
+  const state: SessionState = {
+    targetId,
+    sessionId,
+    url,
+    title,
+    cookies,
+    localStorage,
+    sessionStorage,
+  };
   await writeFile(filePath, JSON.stringify(state, null, 2), { mode: SESSION_FILE_MODE });
 }
 
 export async function loadStateFile(
   client: CdpClient,
   sessionId: string,
-  filePath: string
+  filePath: string,
 ): Promise<SessionState> {
   validateFilePath(filePath);
   const raw = await readFile(filePath, 'utf8');
@@ -104,18 +135,20 @@ export async function loadStateFile(
   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');
+    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');
+    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(): Promise<string[]> {
-  const { readdir } = await import('fs/promises');
+  const { readdir } = await import('node:fs/promises');
   const files = await readdir(SESSION_DIR).catch((err: NodeJS.ErrnoException) => {
     if (err.code === 'ENOENT') return [] as string[];
     throw err;

package/src/browser/snapshot.ts

@@ -1,7 +1,7 @@
+import { getCurrentTitle, getCurrentUrl } from './browser.js';
 import type { CdpClient } from './cdp.js';
 import type { ElementRef, SnapshotOptions, SnapshotResult } from './types.js';
 import { INTERACTIVE_ROLES } from './types.js';
-import { getCurrentUrl, getCurrentTitle } from './browser.js';
 
 interface AXNode {
   nodeId: number;
@@ -20,7 +20,7 @@ interface AXNode {
 export async function captureSnapshot(
   client: CdpClient,
   sessionId: string,
-  options: SnapshotOptions = {}
+  options: SnapshotOptions = {},
 ): Promise<SnapshotResult> {
   const { interactiveOnly = false, compact = false, maxDepth, selector } = options;
 
@@ -28,25 +28,39 @@ export async function captureSnapshot(
   let nodes: AXNode[];
   if (selector) {
     const doc = await client.send<{ root: { nodeId: number } }>('DOM.getDocument', {}, sessionId);
-    const found = await client.send<{ nodeId: number }>(
-      'DOM.querySelector',
-      { nodeId: doc.root.nodeId, selector },
-      sessionId
-    ).catch(() => ({ nodeId: 0 }));
+    const found = await client
+      .send<{ nodeId: number }>(
+        'DOM.querySelector',
+        { nodeId: doc.root.nodeId, selector },
+        sessionId,
+      )
+      .catch(() => ({ nodeId: 0 }));
 
     if (found.nodeId) {
-      const partial = await client.send<{ nodes: AXNode[] }>(
-        'Accessibility.getPartialAXTree',
-        { nodeId: found.nodeId, fetchRelatives: false },
-        sessionId
-      ).catch(async () => client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId));
+      const partial = await client
+        .send<{ nodes: AXNode[] }>(
+          'Accessibility.getPartialAXTree',
+          { nodeId: found.nodeId, fetchRelatives: false },
+          sessionId,
+        )
+        .catch(async () =>
+          client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId),
+        );
       nodes = partial.nodes;
     } else {
-      const full = await client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId);
+      const full = await client.send<{ nodes: AXNode[] }>(
+        'Accessibility.getFullAXTree',
+        {},
+        sessionId,
+      );
       nodes = full.nodes;
     }
   } else {
-    const full = await client.send<{ nodes: AXNode[] }>('Accessibility.getFullAXTree', {}, sessionId);
+    const full = await client.send<{ nodes: AXNode[] }>(
+      'Accessibility.getFullAXTree',
+      {},
+      sessionId,
+    );
     nodes = full.nodes;
   }
 
@@ -192,10 +206,10 @@ function extractProperties(node: AXNode): {
 }
 
 export async function resolveRef(
-  client: CdpClient,
-  sessionId: string,
+  _client: CdpClient,
+  _sessionId: string,
   refs: Map<string, ElementRef>,
-  refKey: string
+  refKey: string,
 ): Promise<ElementRef> {
   const ref = refs.get(refKey);
   if (!ref) throw new Error(`Element ref @${refKey} not found. Run snapshot first.`);
@@ -205,14 +219,14 @@ export async function resolveRef(
 export async function getObjectIdForRef(
   client: CdpClient,
   sessionId: string,
-  ref: ElementRef
+  ref: ElementRef,
 ): Promise<string | null> {
   if (!ref.backendDOMNodeId) return null;
 
   const result = await client.send<{ object: { objectId?: string } }>(
     'DOM.resolveNode',
     { backendNodeId: ref.backendDOMNodeId },
-    sessionId
+    sessionId,
   );
   return result.object?.objectId ?? null;
 }
@@ -231,7 +245,7 @@ export async function getObjectIdForRef(
 export async function getElementBox(
   client: CdpClient,
   sessionId: string,
-  ref: ElementRef
+  ref: ElementRef,
 ): Promise<{ x: number; y: number; width: number; height: number } | null> {
   if (!ref.backendDOMNodeId) return null;
 

package/src/browser/storage.ts

@@ -1,16 +1,37 @@
-import type { CdpClient } from './cdp.js';
 import { evaluateJs } from './actions.js';
+import type { CdpClient } from './cdp.js';
 
-export async function getLocalStorageKey(client: CdpClient, sessionId: string, key: string): Promise<string | null> {
-  const result = await evaluateJs(client, sessionId, `localStorage.getItem(${JSON.stringify(key)})`);
+export async function getLocalStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<string | null> {
+  const result = await evaluateJs(
+    client,
+    sessionId,
+    `localStorage.getItem(${JSON.stringify(key)})`,
+  );
   return result as string | null;
 }
 
-export async function setLocalStorageKey(client: CdpClient, sessionId: string, key: string, value: string): Promise<void> {
-  await evaluateJs(client, sessionId, `localStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`);
+export async function setLocalStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+  value: string,
+): Promise<void> {
+  await evaluateJs(
+    client,
+    sessionId,
+    `localStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`,
+  );
 }
 
-export async function removeLocalStorageKey(client: CdpClient, sessionId: string, key: string): Promise<void> {
+export async function removeLocalStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<void> {
   await evaluateJs(client, sessionId, `localStorage.removeItem(${JSON.stringify(key)})`);
 }
 
@@ -18,25 +39,53 @@ export async function clearLocalStorage(client: CdpClient, sessionId: string): P
   await evaluateJs(client, sessionId, 'localStorage.clear()');
 }
 
-export async function getAllLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
+export async function getAllLocalStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
   const result = await evaluateJs(
     client,
     sessionId,
-    'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))'
+    'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',
   );
-  try { return JSON.parse(result as string); } catch { return {}; }
+  try {
+    return JSON.parse(result as string);
+  } catch {
+    return {};
+  }
 }
 
-export async function getSessionStorageKey(client: CdpClient, sessionId: string, key: string): Promise<string | null> {
-  const result = await evaluateJs(client, sessionId, `sessionStorage.getItem(${JSON.stringify(key)})`);
+export async function getSessionStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<string | null> {
+  const result = await evaluateJs(
+    client,
+    sessionId,
+    `sessionStorage.getItem(${JSON.stringify(key)})`,
+  );
   return result as string | null;
 }
 
-export async function setSessionStorageKey(client: CdpClient, sessionId: string, key: string, value: string): Promise<void> {
-  await evaluateJs(client, sessionId, `sessionStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`);
+export async function setSessionStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+  value: string,
+): Promise<void> {
+  await evaluateJs(
+    client,
+    sessionId,
+    `sessionStorage.setItem(${JSON.stringify(key)}, ${JSON.stringify(value)})`,
+  );
 }
 
-export async function removeSessionStorageKey(client: CdpClient, sessionId: string, key: string): Promise<void> {
+export async function removeSessionStorageKey(
+  client: CdpClient,
+  sessionId: string,
+  key: string,
+): Promise<void> {
   await evaluateJs(client, sessionId, `sessionStorage.removeItem(${JSON.stringify(key)})`);
 }
 
@@ -44,11 +93,18 @@ export async function clearSessionStorage(client: CdpClient, sessionId: string):
   await evaluateJs(client, sessionId, 'sessionStorage.clear()');
 }
 
-export async function getAllSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>> {
+export async function getAllSessionStorage(
+  client: CdpClient,
+  sessionId: string,
+): Promise<Record<string, string>> {
   const result = await evaluateJs(
     client,
     sessionId,
-    'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))'
+    'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
   );
-  try { return JSON.parse(result as string); } catch { return {}; }
+  try {
+    return JSON.parse(result as string);
+  } catch {
+    return {};
+  }
 }

package/src/browser/tabs.ts

@@ -1,6 +1,6 @@
 import type { CdpClient } from './cdp.js';
+import { fetchNewTarget, fetchTargets } from './cdp.js';
 import type { CdpTarget } from './types.js';
-import { fetchTargets, fetchNewTarget } from './cdp.js';
 
 export async function listTabs(port: number): Promise<CdpTarget[]> {
   const targets = await fetchTargets(port);
@@ -11,16 +11,27 @@ export async function newTab(port: number, url = 'about:blank'): Promise<CdpTarg
   return fetchNewTarget(port, url);
 }
 
-export async function closeTab(client: CdpClient, _sessionId: string, targetId: string): Promise<void> {
+export async function closeTab(
+  client: CdpClient,
+  _sessionId: string,
+  targetId: string,
+): Promise<void> {
   await client.send('Target.closeTarget', { targetId });
 }
 
-export async function activateTab(client: CdpClient, oldSessionId: string, targetId: string): Promise<string> {
+export async function activateTab(
+  client: CdpClient,
+  oldSessionId: string,
+  targetId: string,
+): Promise<string> {
   if (oldSessionId) {
     await client.send('Target.detachFromTarget', { sessionId: oldSessionId }).catch(() => {});
   }
   await client.send('Target.activateTarget', { targetId });
-  const result = await client.send<{ sessionId: string }>('Target.attachToTarget', { targetId, flatten: true });
+  const result = await client.send<{ sessionId: string }>('Target.attachToTarget', {
+    targetId,
+    flatten: true,
+  });
   return result.sessionId;
 }
 
@@ -32,7 +43,7 @@ export interface FrameSwitchResult {
 export async function switchToFrame(
   client: CdpClient,
   sessionId: string,
-  frameSelector: string
+  frameSelector: string,
 ): Promise<FrameSwitchResult> {
   const { result } = await client.send<{ result: { result: { value: string | null } } }>(
     'Runtime.evaluate',
@@ -44,29 +55,30 @@ export async function switchToFrame(
       })()`,
       returnByValue: true,
     },
-    sessionId
+    sessionId,
   );
   const frameSrc = result?.result?.value ?? null;
 
   const { frameTree } = await client.send<{
-    frameTree: { childFrames?: Array<{ frame: { id: string; url: string; securityOrigin: string } }> };
+    frameTree: {
+      childFrames?: Array<{ frame: { id: string; url: string; securityOrigin: string } }>;
+    };
   }>('Page.getFrameTree', {}, sessionId);
 
   const match = frameTree.childFrames?.find(
-    (cf) => cf.frame.url === frameSrc || cf.frame.id === frameSelector
+    (cf) => cf.frame.url === frameSrc || cf.frame.id === frameSelector,
   );
   if (!match) return { url: frameSrc, sessionId: null };
 
-  const targets = await client.send<{ targetInfos: Array<{ targetId: string; type: string; url: string }> }>(
-    'Target.getTargets', {}
-  );
-  const oopif = targets.targetInfos.find(
-    (t) => t.type === 'iframe' && t.url === match.frame.url
-  );
+  const targets = await client.send<{
+    targetInfos: Array<{ targetId: string; type: string; url: string }>;
+  }>('Target.getTargets', {});
+  const oopif = targets.targetInfos.find((t) => t.type === 'iframe' && t.url === match.frame.url);
   if (oopif) {
-    const attached = await client.send<{ sessionId: string }>(
-      'Target.attachToTarget', { targetId: oopif.targetId, flatten: true }
-    );
+    const attached = await client.send<{ sessionId: string }>('Target.attachToTarget', {
+      targetId: oopif.targetId,
+      flatten: true,
+    });
     return { url: frameSrc, sessionId: attached.sessionId };
   }
 

package/src/browser/trace.ts

@@ -1,7 +1,7 @@
+import { writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import type { CdpClient } from './cdp.js';
-import { writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
 
 export interface TraceOptions {
   path?: string;
@@ -27,7 +27,7 @@ const _sessions = new Map<string, { events: unknown[]; offData: () => void }>();
 export async function startTrace(
   client: CdpClient,
   sessionId: string,
-  options: TraceOptions = {}
+  options: TraceOptions = {},
 ): Promise<void> {
   if (_sessions.has(sessionId)) {
     throw new Error('Trace already in progress for this session');
@@ -47,12 +47,16 @@ export async function startTrace(
   if (options.screenshots) cats.push('disabled-by-default-devtools.screenshot');
 
   try {
-    await client.send('Tracing.start', {
-      traceConfig: {
-        includedCategories: cats.filter((c) => !c.startsWith('-')),
-        excludedCategories: cats.filter((c) => c.startsWith('-')).map((c) => c.slice(1)),
+    await client.send(
+      'Tracing.start',
+      {
+        traceConfig: {
+          includedCategories: cats.filter((c) => !c.startsWith('-')),
+          excludedCategories: cats.filter((c) => c.startsWith('-')).map((c) => c.slice(1)),
+        },
       },
-    }, sessionId);
+      sessionId,
+    );
   } catch (err) {
     offData();
     _sessions.delete(sessionId);
@@ -63,7 +67,7 @@ export async function startTrace(
 export async function stopTrace(
   client: CdpClient,
   sessionId: string,
-  outputPath?: string
+  outputPath?: string,
 ): Promise<string> {
   const state = _sessions.get(sessionId);
   if (!state) throw new Error('No active trace for this session');