rubycrawl 0.1.1 → 0.1.3

data/node/node_modules/playwright-core/lib/server/dispatchers/localUtilsDispatcher.js

@@ -1,149 +0,0 @@
-"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
-});

data/node/node_modules/playwright-core/lib/server/dispatchers/networkDispatchers.js

@@ -1,213 +0,0 @@
-"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");
-var import_network2 = require("../network");
-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()),
-      hasResponse: !!request._existingResponse()
-    });
-    this._type_Request = true;
-    this._browserContextDispatcher = scope;
-    this.addObjectListener(import_network2.Request.Events.Response, () => this._dispatchEvent("response", {}));
-  }
-  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 result = scope.connection.existingDispatcher(response);
-    const requestDispatcher = RequestDispatcher.from(scope, response.request());
-    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
-});

data/node/node_modules/playwright-core/lib/server/dispatchers/pageAgentDispatcher.js

@@ -1,96 +0,0 @@
-"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) {
-        const userMessage = params.conversation.messages.find((m) => m.role === "user");
-        self._dispatchEvent("turn", { role: "user", message: userMessage?.content ?? "" });
-      },
-      onAfterTurn(params) {
-        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) {
-        self._dispatchEvent("turn", { role: "assistant", message: `call tool "${params.toolCall.name}"` });
-      },
-      onAfterToolCall(params) {
-        const suffix = params.toolCall.result?.isError ? "failed" : "succeeded";
-        self._dispatchEvent("turn", { role: "user", message: `tool "${params.toolCall.name}" ${suffix}` });
-      },
-      onToolCallError(params) {
-        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
-});