@ricsam/isolate 0.1.10 → 0.1.12

package/dist/cjs/internal/playwright/client.cjs

@@ -39,11 +39,13 @@ var __export = (target, all) => {
 // src/internal/playwright/client.ts
 var exports_client = {};
 __export(exports_client, {
+  getPlaywrightHandlerMetadata: () => import_handler.getPlaywrightHandlerMetadata,
   getDefaultPlaywrightHandlerMetadata: () => import_handler.getDefaultPlaywrightHandlerMetadata,
   defaultPlaywrightHandler: () => import_handler.defaultPlaywrightHandler,
-  createPlaywrightHandler: () => import_handler.createPlaywrightHandler
+  createPlaywrightHandler: () => import_handler.createPlaywrightHandler,
+  createPlaywrightFactoryHandler: () => import_handler.createPlaywrightFactoryHandler
 });
 module.exports = __toCommonJS(exports_client);
 var import_handler = require("./handler.cjs");
 
-//# debugId=074A4B0BA48AFF2564756E2164756E21
+//# debugId=BD3C24F38A9EF75364756E2164756E21

package/dist/cjs/internal/playwright/client.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/internal/playwright/client.ts"],
   "sourcesContent": [
-    "/**\n * Client-safe exports for ./index.ts\n * This module can be imported without loading isolated-vm\n */\n\n// Re-export types from types.ts\nexport type {\n  NetworkRequestInfo,\n  NetworkResponseInfo,\n  BrowserConsoleLogEntry,\n  PageErrorInfo,\n  RequestFailureInfo,\n  DefaultPlaywrightHandler,\n  DefaultPlaywrightHandlerMetadata,\n  DefaultPlaywrightHandlerOptions,\n  PlaywrightSetupOptions,\n  PlaywrightHandle,\n  PlaywrightCallback,\n} from \"./types.cjs\";\n\nexport type { PlaywrightOperation, PlaywrightResult, PlaywrightEvent, PlaywrightFileData } from \"../protocol/index.cjs\";\n\n// Re-export handler functions\nexport {\n  createPlaywrightHandler,\n  defaultPlaywrightHandler,\n  getDefaultPlaywrightHandlerMetadata,\n} from \"./handler.cjs\";\n"
+    "/**\n * Client-safe exports for ./index.ts\n * This module can be imported without loading isolated-vm\n */\n\n// Re-export types from types.ts\nexport type {\n  NetworkRequestInfo,\n  NetworkResponseInfo,\n  BrowserConsoleLogEntry,\n  PageErrorInfo,\n  RequestFailureInfo,\n  DefaultPlaywrightHandler,\n  DefaultPlaywrightHandlerMetadata,\n  DefaultPlaywrightHandlerOptions,\n  PlaywrightCollector,\n  PlaywrightHandlerMetadata,\n  PlaywrightSetupOptions,\n  PlaywrightHandle,\n  PlaywrightCallback,\n} from \"./types.cjs\";\n\nexport type { PlaywrightOperation, PlaywrightResult, PlaywrightEvent, PlaywrightFileData } from \"../protocol/index.cjs\";\n\n// Re-export handler functions\nexport {\n  createPlaywrightHandler,\n  createPlaywrightFactoryHandler,\n  defaultPlaywrightHandler,\n  getDefaultPlaywrightHandlerMetadata,\n  getPlaywrightHandlerMetadata,\n} from \"./handler.cjs\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BO,IAJP;",
-  "debugId": "074A4B0BA48AFF2564756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO,IANP;",
+  "debugId": "BD3C24F38A9EF75364756E2164756E21",
   "names": []
 }

package/dist/cjs/internal/playwright/handler.cjs

@@ -39,18 +39,259 @@ var __export = (target, all) => {
 // src/internal/playwright/handler.ts
 var exports_handler = {};
 __export(exports_handler, {
+  getPlaywrightHandlerMetadata: () => getPlaywrightHandlerMetadata,
   getLocator: () => getLocator,
   getDefaultPlaywrightHandlerMetadata: () => getDefaultPlaywrightHandlerMetadata,
   executePageExpectAssertion: () => executePageExpectAssertion,
   executeLocatorAction: () => executeLocatorAction,
   executeExpectAssertion: () => executeExpectAssertion,
   defaultPlaywrightHandler: () => defaultPlaywrightHandler,
-  createPlaywrightHandler: () => createPlaywrightHandler
+  createPlaywrightHandler: () => createPlaywrightHandler,
+  createPlaywrightFactoryHandler: () => createPlaywrightFactoryHandler
 });
 module.exports = __toCommonJS(exports_handler);
 var import_types = require("./types.cjs");
 var INPUT_FILES_VALIDATION_ERROR = "setInputFiles() expects a file path string, an array of file path strings, " + "a single inline file object ({ name, mimeType, buffer }), or an array of inline file objects.";
 var MIXED_INPUT_FILES_ERROR = "setInputFiles() does not support mixing file paths and inline file objects in the same array.";
+function cloneCollectedData(collectedData) {
+  return {
+    browserConsoleLogs: [...collectedData.browserConsoleLogs],
+    pageErrors: [...collectedData.pageErrors],
+    networkRequests: [...collectedData.networkRequests],
+    networkResponses: [...collectedData.networkResponses],
+    requestFailures: [...collectedData.requestFailures]
+  };
+}
+function createPlaywrightCollector(registry) {
+  const emitEvent = (event) => {
+    for (const callback of registry.eventSubscribers) {
+      try {
+        callback(event);
+      } catch {}
+    }
+  };
+  const getRequestId = (request) => {
+    let requestId = registry.requestIds.get(request);
+    if (!requestId) {
+      requestId = `req_${registry.nextRequestId++}`;
+      registry.requestIds.set(request, requestId);
+    }
+    return requestId;
+  };
+  const toLocation = (location) => {
+    if (!location || !location.url && location.lineNumber == null && location.columnNumber == null) {
+      return;
+    }
+    return {
+      url: location.url || undefined,
+      lineNumber: location.lineNumber != null ? location.lineNumber + 1 : undefined,
+      columnNumber: location.columnNumber != null ? location.columnNumber + 1 : undefined
+    };
+  };
+  const registerContext = (context, preferredId, includeExistingPages = true) => {
+    const existingId = registry.contextIdsByObject.get(context);
+    if (existingId) {
+      return existingId;
+    }
+    const contextId = preferredId ?? `ctx_${registry.nextContextId++}`;
+    registry.contexts.set(contextId, {
+      context,
+      pageIds: new Set
+    });
+    registry.contextIdsByObject.set(context, contextId);
+    const onPage = (page) => {
+      registerPage(page, contextId);
+    };
+    const onClose = () => {
+      unregisterContext(contextId);
+    };
+    context.on("page", onPage);
+    context.on("close", onClose);
+    registry.contextListenerCleanups.set(contextId, () => {
+      context.removeListener("page", onPage);
+      context.removeListener("close", onClose);
+    });
+    if (includeExistingPages) {
+      for (const page of context.pages()) {
+        registerPage(page, contextId);
+      }
+    }
+    return contextId;
+  };
+  const unregisterPage = (pageId) => {
+    const record = registry.pages.get(pageId);
+    if (!record) {
+      return;
+    }
+    registry.pageListenerCleanups.get(pageId)?.();
+    registry.pageListenerCleanups.delete(pageId);
+    registry.pageIdsByObject.delete(record.page);
+    registry.pages.delete(pageId);
+    registry.contexts.get(record.contextId)?.pageIds.delete(pageId);
+  };
+  const unregisterContext = (contextId) => {
+    const record = registry.contexts.get(contextId);
+    if (!record) {
+      return;
+    }
+    for (const pageId of [...record.pageIds]) {
+      unregisterPage(pageId);
+    }
+    registry.contextListenerCleanups.get(contextId)?.();
+    registry.contextListenerCleanups.delete(contextId);
+    registry.contextIdsByObject.delete(record.context);
+    registry.contexts.delete(contextId);
+  };
+  const registerPage = (page, preferredContextId, preferredPageId) => {
+    const existingId = registry.pageIdsByObject.get(page);
+    if (existingId) {
+      const existingRecord = registry.pages.get(existingId);
+      if (existingRecord && preferredContextId) {
+        registry.contexts.get(preferredContextId)?.pageIds.add(existingId);
+      }
+      return existingId;
+    }
+    const contextId = preferredContextId ?? registry.contextIdsByObject.get(page.context()) ?? registerContext(page.context());
+    const pageId = preferredPageId ?? `page_${registry.nextPageId++}`;
+    registry.pages.set(pageId, {
+      page,
+      contextId
+    });
+    registry.pageIdsByObject.set(page, pageId);
+    registry.contexts.get(contextId)?.pageIds.add(pageId);
+    const requestHandler = (request) => {
+      const info = {
+        contextId,
+        pageId,
+        requestId: getRequestId(request),
+        url: request.url(),
+        method: request.method(),
+        headers: request.headers(),
+        postData: request.postData() ?? undefined,
+        resourceType: request.resourceType(),
+        timestamp: Date.now()
+      };
+      registry.collectedData.networkRequests.push(info);
+      emitEvent({
+        type: "networkRequest",
+        ...info
+      });
+    };
+    const responseHandler = (response) => {
+      const request = response.request();
+      const info = {
+        contextId,
+        pageId,
+        requestId: getRequestId(request),
+        url: response.url(),
+        status: response.status(),
+        statusText: response.statusText(),
+        headers: response.headers(),
+        resourceType: request.resourceType(),
+        timestamp: Date.now()
+      };
+      registry.collectedData.networkResponses.push(info);
+      emitEvent({
+        type: "networkResponse",
+        ...info
+      });
+    };
+    const requestFailedHandler = (request) => {
+      const info = {
+        contextId,
+        pageId,
+        requestId: getRequestId(request),
+        url: request.url(),
+        method: request.method(),
+        failureText: request.failure()?.errorText || "request failed",
+        resourceType: request.resourceType(),
+        timestamp: Date.now()
+      };
+      registry.collectedData.requestFailures.push(info);
+      emitEvent({
+        type: "requestFailure",
+        ...info
+      });
+    };
+    const consoleHandler = (msg) => {
+      const args = msg.args().map((arg) => String(arg));
+      const entry = {
+        contextId,
+        pageId,
+        level: msg.type(),
+        stdout: args.join(" "),
+        location: toLocation(msg.location()),
+        timestamp: Date.now()
+      };
+      registry.collectedData.browserConsoleLogs.push(entry);
+      emitEvent({
+        type: "browserConsoleLog",
+        ...entry
+      });
+    };
+    const pageErrorHandler = (error) => {
+      const entry = {
+        contextId,
+        pageId,
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        timestamp: Date.now()
+      };
+      registry.collectedData.pageErrors.push(entry);
+      emitEvent({
+        type: "pageError",
+        ...entry
+      });
+    };
+    const closeHandler = () => {
+      unregisterPage(pageId);
+    };
+    page.on("request", requestHandler);
+    page.on("response", responseHandler);
+    page.on("requestfailed", requestFailedHandler);
+    page.on("console", consoleHandler);
+    page.on("pageerror", pageErrorHandler);
+    page.on("close", closeHandler);
+    registry.pageListenerCleanups.set(pageId, () => {
+      page.removeListener("request", requestHandler);
+      page.removeListener("response", responseHandler);
+      page.removeListener("requestfailed", requestFailedHandler);
+      page.removeListener("console", consoleHandler);
+      page.removeListener("pageerror", pageErrorHandler);
+      page.removeListener("close", closeHandler);
+    });
+    return pageId;
+  };
+  return {
+    registerContext,
+    registerPage,
+    unregisterContext,
+    unregisterPage,
+    getCollectedData() {
+      return cloneCollectedData(registry.collectedData);
+    },
+    getTrackedResources() {
+      return {
+        contexts: [...registry.contexts.keys()],
+        pages: [...registry.pages.keys()]
+      };
+    },
+    clearCollectedData() {
+      registry.collectedData.browserConsoleLogs.length = 0;
+      registry.collectedData.pageErrors.length = 0;
+      registry.collectedData.networkRequests.length = 0;
+      registry.collectedData.networkResponses.length = 0;
+      registry.collectedData.requestFailures.length = 0;
+    },
+    onEvent(callback) {
+      registry.eventSubscribers.add(callback);
+      return () => {
+        registry.eventSubscribers.delete(callback);
+      };
+    }
+  };
+}
 function isSerializedInputFilePayload(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -406,11 +647,11 @@ async function executeLocatorAction(locator, action, actionArg, timeout, fileIO)
       });
       if (opts?.path) {
         if (!fileIO?.writeFile) {
-          throw new Error("screenshot() with path option requires a writeFile callback to be provided. " + "Either provide a writeFile callback in defaultPlaywrightHandler options, or omit the path option " + "and handle the returned base64 data yourself.");
+          throw new Error("screenshot() with path option requires a writeFile callback to be provided. " + "Either provide a writeFile callback in defaultPlaywrightHandler options, or remove the path option.");
         }
         await fileIO.writeFile(opts.path, buffer);
       }
-      return buffer.toString("base64");
+      return;
     }
     case "dragTo": {
       const targetInfo = actionArg;
@@ -848,25 +1089,53 @@ function createPlaywrightHandler(page, options) {
     writeFile: options?.writeFile
   };
   const registry = {
-    pages: new Map([["page_0", page]]),
-    contexts: new Map([["ctx_0", page.context()]]),
+    pages: new Map,
+    contexts: new Map,
+    pageIdsByObject: new WeakMap,
+    contextIdsByObject: new WeakMap,
     nextPageId: 1,
     nextContextId: 1,
+    nextRequestId: 1,
     pendingResponses: new Map,
     pendingRequests: new Map,
-    nextListenerId: 0
+    nextListenerId: 0,
+    requestIds: new WeakMap,
+    pageListenerCleanups: new Map,
+    contextListenerCleanups: new Map,
+    eventSubscribers: new Set,
+    collectedData: {
+      browserConsoleLogs: [],
+      pageErrors: [],
+      networkRequests: [],
+      networkResponses: [],
+      requestFailures: []
+    }
   };
-  return async (op) => {
+  const collector = createPlaywrightCollector(registry);
+  if (page) {
+    collector.registerContext(page.context(), "ctx_0", false);
+    collector.registerPage(page, "ctx_0", "page_0");
+  }
+  const handler = async (op) => {
     try {
       switch (op.type) {
+        case "contexts":
+          return { ok: true, value: [...registry.contexts.keys()] };
+        case "pages": {
+          const contextId2 = op.contextId ?? "ctx_0";
+          const context = registry.contexts.get(contextId2);
+          if (!context) {
+            return { ok: false, error: { name: "Error", message: `Context ${contextId2} not found` } };
+          }
+          return { ok: true, value: [...context.pageIds] };
+        }
         case "newContext": {
           if (!options?.createContext) {
             return { ok: false, error: { name: "Error", message: "createContext callback not provided. Configure createContext in playwright options to enable browser.newContext()." } };
           }
           const [contextOptions] = op.args;
           const newContext = await options.createContext(contextOptions);
-          const contextId2 = `ctx_${registry.nextContextId++}`;
-          registry.contexts.set(contextId2, newContext);
+          const contextId2 = collector.registerContext(newContext);
           return { ok: true, value: { contextId: contextId2 } };
         }
         case "newPage": {
@@ -878,9 +1147,8 @@ function createPlaywrightHandler(page, options) {
           if (!targetContext2) {
             return { ok: false, error: { name: "Error", message: `Context ${contextId2} not found` } };
           }
-          const newPage = await options.createPage(targetContext2);
-          const pageId2 = `page_${registry.nextPageId++}`;
-          registry.pages.set(pageId2, newPage);
+          const newPage = await options.createPage(targetContext2.context);
+          const pageId2 = collector.registerPage(newPage, contextId2);
           return { ok: true, value: { pageId: pageId2 } };
         }
         case "closeContext": {
@@ -889,23 +1157,18 @@ function createPlaywrightHandler(page, options) {
           if (!context) {
             return { ok: false, error: { name: "Error", message: `Context ${contextId2} not found` } };
           }
-          await context.close();
-          registry.contexts.delete(contextId2);
-          for (const [pid, p] of registry.pages) {
-            if (p.context() === context) {
-              registry.pages.delete(pid);
-            }
-          }
+          await context.context.close();
+          collector.unregisterContext(contextId2);
           return { ok: true };
         }
       }
       const pageId = op.pageId ?? "page_0";
-      const targetPage = registry.pages.get(pageId);
+      const targetPage = registry.pages.get(pageId)?.page;
       if (!targetPage) {
         return { ok: false, error: { name: "Error", message: `Page ${pageId} not found` } };
       }
       const contextId = op.contextId ?? "ctx_0";
-      const targetContext = registry.contexts.get(contextId);
+      const targetContext = registry.contexts.get(contextId)?.context;
       switch (op.type) {
         case "goto": {
           const [url, waitUntil] = op.args;
@@ -1265,11 +1528,11 @@ function createPlaywrightHandler(page, options) {
           });
           if (screenshotOptions?.path) {
             if (!fileIO.writeFile) {
-              throw new Error("screenshot() with path option requires a writeFile callback to be provided. " + "Either provide a writeFile callback in defaultPlaywrightHandler options, or omit the path option " + "and handle the returned base64 data yourself.");
+              throw new Error("screenshot() with path option requires a writeFile callback to be provided. " + "Either provide a writeFile callback in defaultPlaywrightHandler options, or remove the path option.");
             }
             await fileIO.writeFile(screenshotOptions.path, buffer);
           }
-          return { ok: true, value: buffer.toString("base64") };
+          return { ok: true };
         }
         case "setViewportSize": {
           const [size] = op.args;
@@ -1351,7 +1614,7 @@ function createPlaywrightHandler(page, options) {
         }
         case "close": {
           await targetPage.close();
-          registry.pages.delete(pageId);
+          collector.unregisterPage(pageId);
           return { ok: true };
         }
         case "isClosed": {
@@ -1403,14 +1666,24 @@ function createPlaywrightHandler(page, options) {
       return { ok: false, error: { name: error.name, message: error.message } };
     }
   };
+  handler[import_types.PLAYWRIGHT_HANDLER_META] = {
+    collector
+  };
+  return handler;
 }
 function defaultPlaywrightHandler(page, options) {
   const handler = createPlaywrightHandler(page, options);
   handler[import_types.DEFAULT_PLAYWRIGHT_HANDLER_META] = { page, options };
   return handler;
 }
+function createPlaywrightFactoryHandler(options) {
+  return createPlaywrightHandler(undefined, options);
+}
+function getPlaywrightHandlerMetadata(handler) {
+  return handler[import_types.PLAYWRIGHT_HANDLER_META];
+}
 function getDefaultPlaywrightHandlerMetadata(handler) {
   return handler[import_types.DEFAULT_PLAYWRIGHT_HANDLER_META];
 }
 
-//# debugId=1EA18A56C336D40464756E2164756E21
+//# debugId=1E1ED47A7B37F25964756E2164756E21