stably 4.12.1 → 4.12.2

package/dist/node_modules/playwright-core/lib/server/dispatchers/localUtilsDispatcher.js

@@ -0,0 +1,149 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var localUtilsDispatcher_exports = {};
+__export(localUtilsDispatcher_exports, {
+  LocalUtilsDispatcher: () => LocalUtilsDispatcher
+});
+module.exports = __toCommonJS(localUtilsDispatcher_exports);
+var import_dispatcher = require("./dispatcher");
+var import_instrumentation = require("../../server/instrumentation");
+var localUtils = __toESM(require("../localUtils"));
+var import_userAgent = require("../utils/userAgent");
+var import_deviceDescriptors = require("../deviceDescriptors");
+var import_jsonPipeDispatcher = require("../dispatchers/jsonPipeDispatcher");
+var import_socksInterceptor = require("../socksInterceptor");
+var import_transport = require("../transport");
+var import_network = require("../utils/network");
+var import_urlMatch = require("../../utils/isomorphic/urlMatch");
+class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, playwright) {
+    const localUtils2 = new import_instrumentation.SdkObject(playwright, "localUtils", "localUtils");
+    localUtils2.logName = "browser";
+    const deviceDescriptors = Object.entries(import_deviceDescriptors.deviceDescriptors).map(([name, descriptor]) => ({ name, descriptor }));
+    super(scope, localUtils2, "LocalUtils", {
+      deviceDescriptors
+    });
+    this._harBackends = /* @__PURE__ */ new Map();
+    this._stackSessions = /* @__PURE__ */ new Map();
+    this._type_LocalUtils = true;
+  }
+  async zip(params, progress) {
+    return await localUtils.zip(progress, this._stackSessions, params);
+  }
+  async harOpen(params, progress) {
+    return await localUtils.harOpen(progress, this._harBackends, params);
+  }
+  async harLookup(params, progress) {
+    return await localUtils.harLookup(progress, this._harBackends, params);
+  }
+  async harClose(params, progress) {
+    localUtils.harClose(this._harBackends, params);
+  }
+  async harUnzip(params, progress) {
+    return await localUtils.harUnzip(progress, params);
+  }
+  async tracingStarted(params, progress) {
+    return await localUtils.tracingStarted(progress, this._stackSessions, params);
+  }
+  async traceDiscarded(params, progress) {
+    return await localUtils.traceDiscarded(progress, this._stackSessions, params);
+  }
+  async addStackToTracingNoReply(params, progress) {
+    localUtils.addStackToTracingNoReply(this._stackSessions, params);
+  }
+  async connect(params, progress) {
+    const wsHeaders = {
+      "User-Agent": (0, import_userAgent.getUserAgent)(),
+      "x-playwright-proxy": params.exposeNetwork ?? "",
+      ...params.headers
+    };
+    const wsEndpoint = await urlToWSEndpoint(progress, params.wsEndpoint);
+    const transport = await import_transport.WebSocketTransport.connect(progress, wsEndpoint, { headers: wsHeaders, followRedirects: true, debugLogHeader: "x-playwright-debug-log" });
+    const socksInterceptor = new import_socksInterceptor.SocksInterceptor(transport, params.exposeNetwork, params.socksProxyRedirectPortForTest);
+    const pipe = new import_jsonPipeDispatcher.JsonPipeDispatcher(this);
+    transport.onmessage = (json) => {
+      if (socksInterceptor.interceptMessage(json))
+        return;
+      const cb = () => {
+        try {
+          pipe.dispatch(json);
+        } catch (e) {
+          transport.close();
+        }
+      };
+      if (params.slowMo)
+        setTimeout(cb, params.slowMo);
+      else
+        cb();
+    };
+    pipe.on("message", (message) => {
+      transport.send(message);
+    });
+    transport.onclose = (reason) => {
+      socksInterceptor?.cleanup();
+      pipe.wasClosed(reason);
+    };
+    pipe.on("close", () => transport.close());
+    return { pipe, headers: transport.headers };
+  }
+  async globToRegex(params, progress) {
+    const regex = (0, import_urlMatch.resolveGlobToRegexPattern)(params.baseURL, params.glob, params.webSocketUrl);
+    return { regex };
+  }
+}
+async function urlToWSEndpoint(progress, endpointURL) {
+  if (endpointURL.startsWith("ws"))
+    return endpointURL;
+  progress.log(`<ws preparing> retrieving websocket url from ${endpointURL}`);
+  const fetchUrl = new URL(endpointURL);
+  if (!fetchUrl.pathname.endsWith("/"))
+    fetchUrl.pathname += "/";
+  fetchUrl.pathname += "json";
+  const json = await (0, import_network.fetchData)(progress, {
+    url: fetchUrl.toString(),
+    method: "GET",
+    headers: { "User-Agent": (0, import_userAgent.getUserAgent)() }
+  }, async (params, response) => {
+    return new Error(`Unexpected status ${response.statusCode} when connecting to ${fetchUrl.toString()}.
+This does not look like a Playwright server, try connecting via ws://.`);
+  });
+  const wsUrl = new URL(endpointURL);
+  let wsEndpointPath = JSON.parse(json).wsEndpointPath;
+  if (wsEndpointPath.startsWith("/"))
+    wsEndpointPath = wsEndpointPath.substring(1);
+  if (!wsUrl.pathname.endsWith("/"))
+    wsUrl.pathname += "/";
+  wsUrl.pathname += wsEndpointPath;
+  wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+  return wsUrl.toString();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalUtilsDispatcher
+});

package/dist/node_modules/playwright-core/lib/server/dispatchers/networkDispatchers.js

@@ -0,0 +1,211 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var networkDispatchers_exports = {};
+__export(networkDispatchers_exports, {
+  APIRequestContextDispatcher: () => APIRequestContextDispatcher,
+  RequestDispatcher: () => RequestDispatcher,
+  ResponseDispatcher: () => ResponseDispatcher,
+  RouteDispatcher: () => RouteDispatcher,
+  WebSocketDispatcher: () => WebSocketDispatcher
+});
+module.exports = __toCommonJS(networkDispatchers_exports);
+var import_network = require("../network");
+var import_dispatcher = require("./dispatcher");
+var import_frameDispatcher = require("./frameDispatcher");
+var import_pageDispatcher = require("./pageDispatcher");
+var import_tracingDispatcher = require("./tracingDispatcher");
+class RequestDispatcher extends import_dispatcher.Dispatcher {
+  static from(scope, request) {
+    const result = scope.connection.existingDispatcher(request);
+    return result || new RequestDispatcher(scope, request);
+  }
+  static fromNullable(scope, request) {
+    return request ? RequestDispatcher.from(scope, request) : void 0;
+  }
+  constructor(scope, request) {
+    const postData = request.postDataBuffer();
+    const frame = request.frame();
+    const page = request.frame()?._page;
+    const pageDispatcher = page ? scope.connection.existingDispatcher(page) : null;
+    const frameDispatcher = import_frameDispatcher.FrameDispatcher.fromNullable(scope, frame);
+    super(pageDispatcher || frameDispatcher || scope, request, "Request", {
+      frame: frameDispatcher,
+      serviceWorker: import_pageDispatcher.WorkerDispatcher.fromNullable(scope, request.serviceWorker()),
+      url: request.url(),
+      resourceType: request.resourceType(),
+      method: request.method(),
+      postData: postData === null ? void 0 : postData,
+      headers: request.headers(),
+      isNavigationRequest: request.isNavigationRequest(),
+      redirectedFrom: RequestDispatcher.fromNullable(scope, request.redirectedFrom())
+    });
+    this._type_Request = true;
+    this._browserContextDispatcher = scope;
+    ResponseDispatcher.fromNullable(scope, request._existingResponse());
+  }
+  async rawRequestHeaders(params, progress) {
+    return { headers: await progress.race(this._object.rawRequestHeaders()) };
+  }
+  async response(params, progress) {
+    return { response: ResponseDispatcher.fromNullable(this._browserContextDispatcher, await progress.race(this._object.response())) };
+  }
+}
+class ResponseDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, response) {
+    super(scope, response, "Response", {
+      // TODO: responses in popups can point to non-reported requests.
+      request: scope,
+      url: response.url(),
+      status: response.status(),
+      statusText: response.statusText(),
+      headers: response.headers(),
+      timing: response.timing(),
+      fromServiceWorker: response.fromServiceWorker()
+    });
+    this._type_Response = true;
+  }
+  static from(scope, response) {
+    const requestDispatcher = RequestDispatcher.from(scope, response.request());
+    const result = scope.connection.existingDispatcher(response);
+    return result || new ResponseDispatcher(requestDispatcher, response);
+  }
+  static fromNullable(scope, response) {
+    return response ? ResponseDispatcher.from(scope, response) : void 0;
+  }
+  async body(params, progress) {
+    return { binary: await progress.race(this._object.body()) };
+  }
+  async securityDetails(params, progress) {
+    return { value: await progress.race(this._object.securityDetails()) || void 0 };
+  }
+  async serverAddr(params, progress) {
+    return { value: await progress.race(this._object.serverAddr()) || void 0 };
+  }
+  async rawResponseHeaders(params, progress) {
+    return { headers: await progress.race(this._object.rawResponseHeaders()) };
+  }
+  async sizes(params, progress) {
+    return { sizes: await progress.race(this._object.sizes()) };
+  }
+}
+class RouteDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, route) {
+    super(scope, route, "Route", {
+      // Context route can point to a non-reported request, so we send the request in the initializer.
+      request: scope
+    });
+    this._type_Route = true;
+    this._handled = false;
+  }
+  _checkNotHandled() {
+    if (this._handled)
+      throw new Error("Route is already handled!");
+    this._handled = true;
+  }
+  async continue(params, progress) {
+    this._checkNotHandled();
+    await this._object.continue({
+      url: params.url,
+      method: params.method,
+      headers: params.headers,
+      postData: params.postData,
+      isFallback: params.isFallback
+    });
+  }
+  async fulfill(params, progress) {
+    this._checkNotHandled();
+    await this._object.fulfill(params);
+  }
+  async abort(params, progress) {
+    this._checkNotHandled();
+    await this._object.abort(params.errorCode || "failed");
+  }
+  async redirectNavigationRequest(params, progress) {
+    this._checkNotHandled();
+    this._object.redirectNavigationRequest(params.url);
+  }
+}
+class WebSocketDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, webSocket) {
+    super(scope, webSocket, "WebSocket", {
+      url: webSocket.url()
+    });
+    this._type_EventTarget = true;
+    this._type_WebSocket = true;
+    this.addObjectListener(import_network.WebSocket.Events.FrameSent, (event) => this._dispatchEvent("frameSent", event));
+    this.addObjectListener(import_network.WebSocket.Events.FrameReceived, (event) => this._dispatchEvent("frameReceived", event));
+    this.addObjectListener(import_network.WebSocket.Events.SocketError, (error) => this._dispatchEvent("socketError", { error }));
+    this.addObjectListener(import_network.WebSocket.Events.Close, () => this._dispatchEvent("close", {}));
+  }
+}
+class APIRequestContextDispatcher extends import_dispatcher.Dispatcher {
+  constructor(parentScope, request) {
+    const tracing = import_tracingDispatcher.TracingDispatcher.from(parentScope, request.tracing());
+    super(parentScope, request, "APIRequestContext", {
+      tracing
+    });
+    this._type_APIRequestContext = true;
+    this.adopt(tracing);
+  }
+  static from(scope, request) {
+    const result = scope.connection.existingDispatcher(request);
+    return result || new APIRequestContextDispatcher(scope, request);
+  }
+  static fromNullable(scope, request) {
+    return request ? APIRequestContextDispatcher.from(scope, request) : void 0;
+  }
+  async storageState(params, progress) {
+    return await this._object.storageState(progress, params.indexedDB);
+  }
+  async dispose(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    await this._object.dispose(params);
+    this._dispose();
+  }
+  async fetch(params, progress) {
+    const fetchResponse = await this._object.fetch(progress, params);
+    return {
+      response: {
+        url: fetchResponse.url,
+        status: fetchResponse.status,
+        statusText: fetchResponse.statusText,
+        headers: fetchResponse.headers,
+        fetchUid: fetchResponse.fetchUid
+      }
+    };
+  }
+  async fetchResponseBody(params, progress) {
+    return { binary: this._object.fetchResponses.get(params.fetchUid) };
+  }
+  async fetchLog(params, progress) {
+    const log = this._object.fetchLog.get(params.fetchUid) || [];
+    return { log };
+  }
+  async disposeAPIResponse(params, progress) {
+    this._object.disposeResponse(params.fetchUid);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIRequestContextDispatcher,
+  RequestDispatcher,
+  ResponseDispatcher,
+  RouteDispatcher,
+  WebSocketDispatcher
+});

package/dist/node_modules/playwright-core/lib/server/dispatchers/pageAgentDispatcher.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pageAgentDispatcher_exports = {};
+__export(pageAgentDispatcher_exports, {
+  PageAgentDispatcher: () => PageAgentDispatcher
+});
+module.exports = __toCommonJS(pageAgentDispatcher_exports);
+var import_dispatcher = require("./dispatcher");
+var import_pageAgent = require("../agent/pageAgent");
+var import_instrumentation = require("../instrumentation");
+var import_context = require("../agent/context");
+class PageAgentDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, options) {
+    super(scope, new import_instrumentation.SdkObject(scope._object, "pageAgent"), "PageAgent", { page: scope });
+    this._type_PageAgent = true;
+    this._type_EventTarget = true;
+    this._usage = { turns: 0, inputTokens: 0, outputTokens: 0 };
+    this._page = scope._object;
+    this._context = new import_context.Context(this._page, options, this._eventSupport());
+  }
+  async perform(params, progress) {
+    try {
+      await (0, import_pageAgent.pageAgentPerform)(progress, this._context, params.task, params);
+    } finally {
+      this._context.pushHistory({ type: "perform", description: params.task });
+    }
+    return { usage: this._usage };
+  }
+  async expect(params, progress) {
+    try {
+      await (0, import_pageAgent.pageAgentExpect)(progress, this._context, params.expectation, params);
+    } finally {
+      this._context.pushHistory({ type: "expect", description: params.expectation });
+    }
+    return { usage: this._usage };
+  }
+  async extract(params, progress) {
+    const result = await (0, import_pageAgent.pageAgentExtract)(progress, this._context, params.query, params.schema, params);
+    return { result, usage: this._usage };
+  }
+  async usage(params, progress) {
+    return { usage: this._usage };
+  }
+  async dispose(params, progress) {
+    progress.metadata.potentiallyClosesScope = true;
+    void this.stopPendingOperations(new Error("The agent is disposed"));
+    this._dispose();
+  }
+  _eventSupport() {
+    const self = this;
+    return {
+      onBeforeTurn(params) {
+        if (self._disposed)
+          return;
+        const userMessage = params.conversation.messages.find((m) => m.role === "user");
+        self._dispatchEvent("turn", { role: "user", message: userMessage?.content ?? "" });
+      },
+      onAfterTurn(params) {
+        if (self._disposed)
+          return;
+        const usage = { inputTokens: params.totalUsage.input, outputTokens: params.totalUsage.output };
+        const intent = params.assistantMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+        self._dispatchEvent("turn", { role: "assistant", message: intent, usage });
+        if (!params.assistantMessage.content.filter((c) => c.type === "tool_call").length)
+          self._dispatchEvent("turn", { role: "assistant", message: `no tool calls`, usage });
+        self._usage = { turns: self._usage.turns + 1, inputTokens: self._usage.inputTokens + usage.inputTokens, outputTokens: self._usage.outputTokens + usage.outputTokens };
+      },
+      onBeforeToolCall(params) {
+        if (self._disposed)
+          return;
+        self._dispatchEvent("turn", { role: "assistant", message: `call tool "${params.toolCall.name}"` });
+      },
+      onAfterToolCall(params) {
+        if (self._disposed)
+          return;
+        const suffix = params.toolCall.result?.isError ? "failed" : "succeeded";
+        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" ${suffix}` });
+      },
+      onToolCallError(params) {
+        if (self._disposed)
+          return;
+        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" failed: ${params.error.message}` });
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PageAgentDispatcher
+});