@intuned/runtime 1.3.16 → 1.3.18-interface.6

package/dist/chunk-XC75QGFG.mjs

@@ -0,0 +1,1106 @@
+import {
+  buildExtensionsList,
+  cleanIntunedExtensionServer,
+  getDownloadDirectoryPath,
+  getFullPathInProject,
+  getIntunedExtensionWorker,
+  isIntunedExtensionEnabled,
+  isIntunedExtensionLoaded,
+  setupIntunedExtension,
+  setupIntunedExtensionServer
+} from "./chunk-B3T6RXPC.mjs";
+import {
+  getExecutionContext
+} from "./chunk-W4UX6G4X.mjs";
+import {
+  formatZodError
+} from "./chunk-NDMVGENG.mjs";
+import {
+  cleanEnvironmentVariables
+} from "./chunk-6ZRJOUQS.mjs";
+import {
+  getStorageState,
+  setStorageState
+} from "./chunk-G4PO5RIV.mjs";
+import {
+  AUTH_SESSIONS_FOLDER_NAME
+} from "./chunk-FGV5T6SI.mjs";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-LZOMFHX3.mjs";
+
+// ../packages/runtime-interface/dist/errors.js
+var require_errors = __commonJS({
+  "../packages/runtime-interface/dist/errors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ResultTooBigError = exports.InternalInvalidInputError = exports.AutomationError = exports.MaxLevelsExceededError = exports.AuthCheckFailedError = exports.AuthCheckNotFoundError = exports.AuthRequiredError = exports.AbortedError = exports.InvalidCheckError = exports.InvalidApiError = exports.ApiNotFoundError = exports.RunAutomationError = exports.runAutomationErrorCodes = exports.resultTooBigErrorCode = exports.internalInvalidInputErrorCode = exports.automationError = exports.maxLevelsExceededErrorCode = exports.authCheckFailedErrorCode = exports.authCheckNotFoundErrorCode = exports.authRequiredErrorCode = exports.abortedErrorCode = exports.invalidCheckErrorCode = exports.invalidApiErrorCode = exports.apiNotFoundErrorCode = void 0;
+    exports.apiNotFoundErrorCode = "APINotFoundError";
+    exports.invalidApiErrorCode = "InvalidAPIError";
+    exports.invalidCheckErrorCode = "InvalidCheckError";
+    exports.abortedErrorCode = "AbortedError";
+    exports.authRequiredErrorCode = "AuthRequiredError";
+    exports.authCheckNotFoundErrorCode = "AuthCheckNotFoundError";
+    exports.authCheckFailedErrorCode = "AuthCheckFailedError";
+    exports.maxLevelsExceededErrorCode = "MaxLevelsExceededError";
+    exports.automationError = "AutomationError";
+    exports.internalInvalidInputErrorCode = "InternalInvalidInputError";
+    exports.resultTooBigErrorCode = "ResultTooBigError";
+    exports.runAutomationErrorCodes = [
+      exports.apiNotFoundErrorCode,
+      exports.invalidApiErrorCode,
+      exports.invalidCheckErrorCode,
+      exports.abortedErrorCode,
+      exports.authRequiredErrorCode,
+      exports.authCheckNotFoundErrorCode,
+      exports.authCheckFailedErrorCode,
+      exports.maxLevelsExceededErrorCode,
+      exports.automationError,
+      exports.internalInvalidInputErrorCode,
+      exports.resultTooBigErrorCode
+    ];
+    var RunAutomationError4 = class {
+      constructor(code, message) {
+        this.code = code;
+        this.message = message;
+      }
+      get json() {
+        return {
+          code: this.code,
+          details: this.details,
+          cause: this.cause?.json
+        };
+      }
+    };
+    exports.RunAutomationError = RunAutomationError4;
+    var ApiNotFoundError3 = class extends RunAutomationError4 {
+      constructor(apiName) {
+        super(exports.apiNotFoundErrorCode, `API ${apiName} not found`);
+      }
+    };
+    exports.ApiNotFoundError = ApiNotFoundError3;
+    var InvalidApiError2 = class extends RunAutomationError4 {
+      constructor(message) {
+        super(exports.invalidApiErrorCode, `API is invalid: ${message}`);
+        this.details = {
+          message
+        };
+      }
+    };
+    exports.InvalidApiError = InvalidApiError2;
+    var InvalidCheckError = class extends RunAutomationError4 {
+      constructor(message, cause) {
+        super(exports.invalidCheckErrorCode, message);
+        this.cause = cause;
+      }
+    };
+    exports.InvalidCheckError = InvalidCheckError;
+    var AbortedError2 = class extends RunAutomationError4 {
+      constructor() {
+        super(exports.abortedErrorCode, "Operation was aborted");
+      }
+    };
+    exports.AbortedError = AbortedError2;
+    var AuthRequiredError2 = class extends RunAutomationError4 {
+      constructor() {
+        super(exports.authRequiredErrorCode, "AuthSessions are required");
+      }
+    };
+    exports.AuthRequiredError = AuthRequiredError2;
+    var AuthCheckNotFoundError = class extends RunAutomationError4 {
+      constructor() {
+        super(exports.authCheckNotFoundErrorCode, "AuthSession check not found");
+      }
+    };
+    exports.AuthCheckNotFoundError = AuthCheckNotFoundError;
+    var AuthCheckFailedError = class extends RunAutomationError4 {
+      constructor() {
+        super(exports.authCheckFailedErrorCode, "AuthSession check failed");
+      }
+    };
+    exports.AuthCheckFailedError = AuthCheckFailedError;
+    var MaxLevelsExceededError = class extends RunAutomationError4 {
+      constructor(levels) {
+        super(exports.maxLevelsExceededErrorCode, `Max levels exceeded. Only ${levels} levels are supported`);
+        this.details = { levels };
+      }
+    };
+    exports.MaxLevelsExceededError = MaxLevelsExceededError;
+    var AutomationError4 = class extends RunAutomationError4 {
+      constructor(error) {
+        super(exports.automationError, `[${error?.name ?? error}] ${error?.message}`);
+        this.details = {
+          ...error
+        };
+      }
+    };
+    exports.AutomationError = AutomationError4;
+    var InternalInvalidInputError2 = class extends RunAutomationError4 {
+      constructor(message, details) {
+        super(exports.internalInvalidInputErrorCode, message);
+        this.details = details;
+      }
+    };
+    exports.InternalInvalidInputError = InternalInvalidInputError2;
+    var ResultTooBigError2 = class extends RunAutomationError4 {
+      constructor(sizeInBytes, maxSizeInBytes) {
+        super(exports.resultTooBigErrorCode, `Automation result is too big. Size: ${Math.round(sizeInBytes / 1024 / 1024 * 100) / 100}MB, Max allowed: ${Math.round(maxSizeInBytes / 1024 / 1024 * 100) / 100}MB`);
+        this.details = { sizeInBytes, maxSizeInBytes };
+      }
+    };
+    exports.ResultTooBigError = ResultTooBigError2;
+  }
+});
+
+// ../packages/runtime-interface/dist/types.js
+var require_types = __commonJS({
+  "../packages/runtime-interface/dist/types.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.outputRunApiSchema = exports.pongMessageSchema = exports.doneMessageSchema = exports.extendMessageSchema = exports.runApiInputSchema = exports.pingSchema = exports.tokenUpdateSchema = exports.abortRunApiSchema = exports.startRunApiSchema = exports.startRunApiParametersSchema = exports.runApiParametersSchema = exports.runApiRunOptionsSchema = exports.runApiCdpRunOptionsSchema = exports.runApiStandaloneRunOptionsSchema = exports.runApiAuthSchema = exports.runApiTracingSchema = exports.runApiAutomationFunctionSchema = exports.runApiSessionSchema = exports.runApiStorageStateSchema = void 0;
+    exports.runApiResultOkSchema = runApiResultOkSchema;
+    exports.runApiResultWithSessionOkSchema = runApiResultWithSessionOkSchema;
+    var zod_1 = __importDefault(__require("zod"));
+    exports.runApiStorageStateSchema = zod_1.default.object({
+      cookies: zod_1.default.array(zod_1.default.object({
+        name: zod_1.default.string(),
+        value: zod_1.default.string(),
+        domain: zod_1.default.string(),
+        path: zod_1.default.string(),
+        expires: zod_1.default.number(),
+        httpOnly: zod_1.default.boolean(),
+        secure: zod_1.default.boolean(),
+        sameSite: zod_1.default.enum(["Strict", "Lax", "None"])
+      })),
+      origins: zod_1.default.array(zod_1.default.object({
+        origin: zod_1.default.string(),
+        localStorage: zod_1.default.array(zod_1.default.object({
+          name: zod_1.default.string(),
+          value: zod_1.default.string()
+        }))
+      })),
+      sessionStorage: zod_1.default.array(zod_1.default.object({
+        origin: zod_1.default.string(),
+        sessionStorage: zod_1.default.array(zod_1.default.object({
+          name: zod_1.default.string(),
+          value: zod_1.default.string()
+        }))
+      })).optional()
+    });
+    exports.runApiSessionSchema = zod_1.default.discriminatedUnion("type", [
+      zod_1.default.object({
+        type: zod_1.default.literal("file"),
+        path: zod_1.default.string()
+      }),
+      zod_1.default.object({
+        type: zod_1.default.literal("state"),
+        state: exports.runApiStorageStateSchema.nullable().optional()
+      })
+    ]);
+    exports.runApiAutomationFunctionSchema = zod_1.default.object({
+      name: zod_1.default.string(),
+      params: zod_1.default.any().optional()
+    });
+    exports.runApiTracingSchema = zod_1.default.discriminatedUnion("enabled", [
+      zod_1.default.object({ enabled: zod_1.default.literal(false) }),
+      zod_1.default.object({ enabled: zod_1.default.literal(true), filePath: zod_1.default.string() })
+    ]).optional().default({ enabled: false });
+    exports.runApiAuthSchema = zod_1.default.object({
+      session: exports.runApiSessionSchema,
+      parameters: zod_1.default.record(zod_1.default.any()).optional()
+    }).optional();
+    exports.runApiStandaloneRunOptionsSchema = zod_1.default.object({
+      environment: zod_1.default.literal("standalone"),
+      headless: zod_1.default.boolean().default(true),
+      proxy: zod_1.default.object({
+        server: zod_1.default.string(),
+        username: zod_1.default.string(),
+        password: zod_1.default.string()
+      }).optional()
+    });
+    exports.runApiCdpRunOptionsSchema = zod_1.default.object({
+      environment: zod_1.default.literal("cdp"),
+      cdpAddress: zod_1.default.string(),
+      cdpTargetId: zod_1.default.string().optional()
+    });
+    exports.runApiRunOptionsSchema = zod_1.default.discriminatedUnion("environment", [
+      exports.runApiStandaloneRunOptionsSchema,
+      exports.runApiCdpRunOptionsSchema
+    ]).default({ environment: "standalone", headless: true });
+    exports.runApiParametersSchema = zod_1.default.object({
+      automationFunction: exports.runApiAutomationFunctionSchema,
+      tracing: exports.runApiTracingSchema,
+      auth: exports.runApiAuthSchema,
+      runOptions: exports.runApiRunOptionsSchema,
+      retrieveSession: zod_1.default.boolean().default(false)
+    });
+    function runApiResultOkSchema(resultSchema) {
+      return zod_1.default.object({
+        result: resultSchema,
+        extendedPayloads: zod_1.default.array(zod_1.default.object({
+          api: zod_1.default.string(),
+          parameters: zod_1.default.record(zod_1.default.any())
+        })).optional()
+      });
+    }
+    function runApiResultWithSessionOkSchema(resultSchema) {
+      return runApiResultOkSchema(resultSchema).extend({
+        session: exports.runApiStorageStateSchema
+      });
+    }
+    exports.startRunApiParametersSchema = exports.runApiParametersSchema.extend({
+      retrieveSession: zod_1.default.boolean(),
+      functionsToken: zod_1.default.string().optional(),
+      context: zod_1.default.object({
+        jobId: zod_1.default.string().optional(),
+        jobRunId: zod_1.default.string().optional(),
+        runId: zod_1.default.string().optional(),
+        queueId: zod_1.default.string().optional(),
+        authSessionId: zod_1.default.string().optional()
+      }).optional()
+    });
+    exports.startRunApiSchema = zod_1.default.object({
+      type: zod_1.default.literal("start"),
+      parameters: exports.startRunApiParametersSchema
+    });
+    exports.abortRunApiSchema = zod_1.default.object({
+      type: zod_1.default.literal("abort"),
+      parameters: zod_1.default.object({}).optional()
+    });
+    exports.tokenUpdateSchema = zod_1.default.object({
+      type: zod_1.default.literal("tokenUpdate"),
+      parameters: zod_1.default.object({
+        functionsToken: zod_1.default.string()
+      })
+    });
+    exports.pingSchema = zod_1.default.object({
+      type: zod_1.default.literal("ping"),
+      parameters: zod_1.default.object({}).optional()
+    });
+    exports.runApiInputSchema = zod_1.default.union([
+      exports.startRunApiSchema,
+      exports.abortRunApiSchema,
+      exports.tokenUpdateSchema,
+      exports.pingSchema
+    ]);
+    exports.extendMessageSchema = zod_1.default.object({ type: zod_1.default.literal("extend") });
+    exports.doneMessageSchema = zod_1.default.object({
+      type: zod_1.default.literal("done"),
+      result: zod_1.default.any(),
+      success: zod_1.default.boolean()
+    });
+    exports.pongMessageSchema = zod_1.default.object({
+      type: zod_1.default.literal("pong")
+    });
+    exports.outputRunApiSchema = zod_1.default.union([
+      exports.extendMessageSchema,
+      exports.doneMessageSchema,
+      exports.pongMessageSchema
+    ]);
+  }
+});
+
+// ../packages/runtime-interface/dist/interfaceClient.js
+var require_interfaceClient = __commonJS({
+  "../packages/runtime-interface/dist/interfaceClient.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONLFileClient = exports.TCPSocketClient = exports.UnixSocketClient = exports.SocketClient = void 0;
+    var net = __importStar(__require("net"));
+    var fs4 = __importStar(__require("fs-extra"));
+    var readline_1 = __require("readline");
+    var promises_1 = __require("timers/promises");
+    var SocketClient = class _SocketClient {
+      constructor(socket) {
+        this.socket = socket;
+      }
+      sendJSON(data) {
+        const dataToSend = JSON.stringify(data);
+        const length = Buffer.byteLength(dataToSend);
+        const buffer = Buffer.alloc(_SocketClient.LENGTH_HEADER_LENGTH + length);
+        buffer.writeUInt32BE(length, 0);
+        buffer.write(dataToSend, _SocketClient.LENGTH_HEADER_LENGTH);
+        this.socket.write(buffer);
+      }
+      async *receiveJSON() {
+        let buffer = Buffer.alloc(0);
+        const endPromise = new Promise((resolve, reject) => {
+          this.socket.once("end", () => {
+            resolve();
+          });
+          this.socket.once("error", reject);
+        });
+        while (true) {
+          const chunk = await Promise.race([
+            new Promise((resolve) => this.socket.once("data", (data2) => {
+              if (typeof data2 === "string") {
+                return resolve(Buffer.from(data2));
+              }
+              resolve(data2);
+            })),
+            endPromise
+          ]);
+          if (!(chunk instanceof Buffer)) {
+            break;
+          }
+          buffer = Buffer.concat([buffer, chunk]);
+          const length = buffer.readUInt32BE(0);
+          if (buffer.length < length + _SocketClient.LENGTH_HEADER_LENGTH) {
+            continue;
+          }
+          const data = buffer.subarray(_SocketClient.LENGTH_HEADER_LENGTH, length + _SocketClient.LENGTH_HEADER_LENGTH);
+          buffer = buffer.subarray(length + _SocketClient.LENGTH_HEADER_LENGTH);
+          yield JSON.parse(data.toString());
+        }
+      }
+      async close() {
+        this.socket.end();
+        await Promise.race([
+          new Promise((resolve) => this.socket.once("close", resolve)),
+          new Promise((resolve) => this.socket.once("error", resolve)),
+          (0, promises_1.setTimeout)(3e3)
+        ]);
+      }
+      get closed() {
+        return this.socket.closed;
+      }
+    };
+    exports.SocketClient = SocketClient;
+    SocketClient.LENGTH_HEADER_LENGTH = 4;
+    var UnixSocketClient = class extends SocketClient {
+      constructor(path2) {
+        super(net.createConnection(path2));
+      }
+    };
+    exports.UnixSocketClient = UnixSocketClient;
+    var TCPSocketClient = class extends SocketClient {
+      constructor(host, port) {
+        super(net.createConnection(port, host));
+      }
+    };
+    exports.TCPSocketClient = TCPSocketClient;
+    var JSONLFileClient = class {
+      constructor(filePath) {
+        this.fileStream = fs4.createReadStream(filePath, { encoding: "utf-8" });
+      }
+      sendJSON(data) {
+        console.log("Sending message", data);
+      }
+      async *receiveJSON() {
+        const rl = (0, readline_1.createInterface)({
+          input: this.fileStream,
+          crlfDelay: Infinity
+        });
+        for await (const line of rl) {
+          if (line.trim() === "") {
+            continue;
+          }
+          yield JSON.parse(line);
+        }
+      }
+      async close() {
+        this.fileStream.close();
+        await Promise.race([
+          new Promise((resolve) => this.fileStream.once("close", resolve)),
+          new Promise((resolve) => this.fileStream.once("error", resolve)),
+          (0, promises_1.setTimeout)(3e3)
+        ]);
+      }
+      get closed() {
+        return this.fileStream.closed;
+      }
+    };
+    exports.JSONLFileClient = JSONLFileClient;
+  }
+});
+
+// ../packages/runtime-interface/dist/index.js
+var require_dist = __commonJS({
+  "../packages/runtime-interface/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_errors(), exports);
+    __exportStar(require_types(), exports);
+    __exportStar(require_interfaceClient(), exports);
+  }
+});
+
+// src/common/runApi/index.ts
+import * as fs3 from "fs-extra";
+import { remove as remove2 } from "fs-extra";
+import { ok as ok5, err as err4 } from "neverthrow";
+
+// src/common/playwrightContext.ts
+import path from "path";
+import * as fs2 from "fs-extra";
+import { err as err3, ok as ok4 } from "neverthrow";
+
+// src/common/setupContextHook.ts
+import { ok as ok2 } from "neverthrow";
+
+// src/common/runApi/importUsingImportFunction.ts
+var import_runtime_interface = __toESM(require_dist());
+import { ok, err } from "neverthrow";
+async function importUsingImportFunction({
+  path: path2,
+  allowGenerators = true,
+  importFunction
+}) {
+  try {
+    const importedResult = await importFunction(path2);
+    if (importedResult.isErr()) {
+      if (importedResult.error.type === "not_found") {
+        return err(new import_runtime_interface.ApiNotFoundError(path2));
+      }
+      return err(new import_runtime_interface.AutomationError(importedResult.error.error));
+    }
+    const imported = importedResult.value;
+    if (!imported || !imported.default || !imported.default.constructor) {
+      return err(new import_runtime_interface.InvalidApiError(`${path2} does not have a default export`));
+    }
+    if (imported.default.constructor.name === "AsyncGeneratorFunction") {
+      if (!allowGenerators) {
+        return err(
+          new import_runtime_interface.InvalidApiError(
+            `${path2} default export must be an async function`
+          )
+        );
+      }
+      return ok(async (...args) => {
+        const generator = imported.default(
+          ...args
+        );
+        const result = await generator.next();
+        if (!result.done) {
+          throw new Error("Yield is not supported");
+        }
+        return result.value;
+      });
+    }
+    if (imported.default.constructor.name === "AsyncFunction") {
+      return ok(imported.default);
+    }
+    return err(
+      new import_runtime_interface.InvalidApiError(`${path2} default export must be an async function`)
+    );
+  } catch (error) {
+    return err(new import_runtime_interface.AutomationError(error));
+  }
+}
+
+// src/common/setupContextHook.ts
+var import_runtime_interface2 = __toESM(require_dist());
+var setupContextHookPath = "hooks/setupContext";
+async function loadSetupContextHook({
+  importFunction
+}) {
+  const importedFunctionResult = await importUsingImportFunction({
+    path: setupContextHookPath,
+    importFunction
+  });
+  if (importedFunctionResult.isErr() && importedFunctionResult.error instanceof import_runtime_interface2.ApiNotFoundError) {
+    return ok2(null);
+  }
+  return importedFunctionResult;
+}
+
+// src/common/playwrightContext.ts
+import { getPort } from "portfinder";
+
+// src/common/launchBrowser.ts
+import * as playwright from "playwright";
+import { mkdir, mkdtemp, rm, writeFile } from "fs-extra";
+import { join } from "path";
+import * as fs from "fs-extra";
+import waitOn from "wait-on";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { err as err2, ok as ok3 } from "neverthrow";
+import { z } from "zod";
+var execAsync = promisify(exec);
+async function createUserDirWithPreferences() {
+  const playwrightTempDir = await mkdtemp("/tmp/pw-");
+  const userDir = join(playwrightTempDir, "userdir");
+  const defaultDir = join(userDir, "Default");
+  await mkdir(defaultDir, {
+    recursive: true
+  });
+  const preferences = {
+    plugins: {
+      always_open_pdf_externally: true
+    }
+  };
+  await writeFile(join(defaultDir, "Preferences"), JSON.stringify(preferences));
+  return userDir;
+}
+async function launchChromium(options) {
+  if ("cdpAddress" in options) {
+    if (await isIntunedExtensionEnabled()) {
+      await setupIntunedExtensionServer();
+    }
+    const browser = await playwright.chromium.connectOverCDP(
+      options.cdpAddress
+    );
+    if (browser.contexts().length === 0) {
+      throw new Error("No browser contexts found in the connected browser");
+    }
+    const context2 = browser.contexts()[0];
+    let page2 = context2.pages().at(0) ?? await context2.newPage();
+    const targetId = options.cdpTargetId;
+    if (targetId) {
+      for (const p of context2.pages()) {
+        let cdp = null;
+        try {
+          cdp = await context2.newCDPSession(p);
+          const result = await cdp.send("Target.getTargetInfo");
+          if (result.targetInfo.targetId === targetId) {
+            page2 = p;
+            break;
+          }
+        } catch (error) {
+        } finally {
+          await cdp?.detach();
+        }
+      }
+    }
+    return { page: page2, context: context2 };
+  }
+  const { headless, appModeInitialUrl, cdpPort, proxy, downloadsPath } = options;
+  let { executablePath } = options;
+  const defaultArgsToIgnore = [
+    "--disable-extensions",
+    "--disable-component-extensions-with-background-pages",
+    "--disable-background-networking",
+    "--disable-backgrounding-occluded-windows",
+    "--disable-background-timer-throttling"
+  ];
+  const extraArgs = [];
+  const userDataDir = await createUserDirWithPreferences();
+  if (isIntunedExtensionLoaded()) {
+    const extensionsList = buildExtensionsList();
+    const extensions = extensionsList.join(",");
+    extraArgs.push(`--disable-extensions-except=${extensions}`);
+    extraArgs.push(`--load-extension=${extensions}`);
+  }
+  if (await isIntunedExtensionEnabled()) {
+    await setupIntunedExtension();
+    if (proxy) {
+      extraArgs.push('--proxy-bypass-list="<-loopback>"');
+    }
+  }
+  if (cdpPort) {
+    extraArgs.push(`--remote-debugging-port=${cdpPort}`);
+  }
+  if (headless) {
+    defaultArgsToIgnore.push("--headless=old");
+    extraArgs.push("--headless=new");
+  }
+  if (appModeInitialUrl) {
+    extraArgs.push(`--app=${appModeInitialUrl}`);
+  }
+  if (executablePath) {
+    executablePath = await fs.realpath(executablePath);
+    if (!await fs.exists(executablePath)) {
+      console.log(
+        `Warning: Executable path ${executablePath} does not exist. Falling back to default.`
+      );
+      executablePath = void 0;
+    }
+  }
+  const viewport = null;
+  const userAgent = process.env.__PLAYWRIGHT_USER_AGENT_OVERRIDE ?? await getHeadlessUserAgent({
+    executablePath
+  });
+  const context = await playwright.chromium.launchPersistentContext(
+    userDataDir,
+    {
+      userAgent,
+      executablePath,
+      headless,
+      viewport,
+      proxy,
+      downloadsPath,
+      args: extraArgs,
+      ignoreDefaultArgs: defaultArgsToIgnore
+    }
+  );
+  context.once("close", async () => {
+    try {
+      await rm(userDataDir, {
+        recursive: true,
+        force: true,
+        retryDelay: 1e3,
+        maxRetries: 5
+      });
+      if (await isIntunedExtensionEnabled()) {
+        await cleanIntunedExtensionServer();
+      }
+    } catch (error) {
+      console.error("Failed to remove user data dir", error);
+    }
+  });
+  if (cdpPort) {
+    const createdCdpAddress = getLocalCdpAddress(cdpPort);
+    await waitOnCdpAddress(createdCdpAddress);
+  }
+  const page = context.pages().at(0) ?? await context.newPage();
+  if (await isIntunedExtensionEnabled()) {
+    await getIntunedExtensionWorker(context);
+  }
+  return {
+    page,
+    context
+  };
+}
+async function getBrowserExecutablePath() {
+  const browserType = getBrowserType();
+  if (browserType === "brave") {
+    return await getBraveExecutablePath();
+  }
+}
+async function launchBrowser(options) {
+  if ("cdpAddress" in options) {
+    return launchChromium(options);
+  }
+  return launchChromium({
+    ...options,
+    executablePath: await getBrowserExecutablePath()
+  });
+}
+function getBrowserType() {
+  if (process.env.BROWSER_TYPE === "brave") {
+    return "brave";
+  }
+  return "chromium";
+}
+async function getBraveExecutablePath() {
+  const { stdout } = await execAsync("which brave-browser-stable");
+  const bravePath = stdout.trim();
+  if (bravePath.length === 0) {
+    throw new Error("Brave browser not found");
+  }
+  return bravePath;
+}
+function getLocalCdpAddress(port) {
+  return `http://localhost:${port}`;
+}
+async function getCdpWebSocketUrl(cdpAddress) {
+  let response;
+  try {
+    response = await fetch(`${cdpAddress}/json/version`);
+  } catch (error) {
+    return err2(
+      `Failed to fetch CDP version from ${cdpAddress}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!response.ok) {
+    return err2(
+      `Failed to get CDP WebSocket URL from ${cdpAddress}: ${response.status} ${response.statusText}`
+    );
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (error) {
+    return err2(
+      `Invalid CDP version response from ${cdpAddress}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const cdpJsonVersionResponseSchema = z.object({
+    webSocketDebuggerUrl: z.string().url()
+  });
+  const parseResult = cdpJsonVersionResponseSchema.safeParse(data);
+  if (!parseResult.success) {
+    return err2(
+      `Invalid CDP version response from ${cdpAddress}: ${JSON.stringify(
+        parseResult.error.format()
+      )}`
+    );
+  }
+  return ok3(parseResult.data.webSocketDebuggerUrl);
+}
+async function waitOnCdpAddress(cdpAddress) {
+  const cdpAddressWithoutProtocol = cdpAddress.replace("http://", "").replace("https://", "").replace("localhost", "127.0.0.1");
+  await waitOn({
+    resources: [`http-get://${cdpAddressWithoutProtocol}/json/version`],
+    delay: 100,
+    interval: 100,
+    timeout: 5e3,
+    tcpTimeout: 1e3,
+    window: 1e3
+  });
+}
+async function getHeadlessUserAgent({
+  executablePath,
+  args,
+  ignoreDefaultArgs
+}) {
+  const browser = await playwright.chromium.launch({
+    headless: true,
+    executablePath,
+    args,
+    ignoreDefaultArgs
+  });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  let userAgent = await page.evaluate(() => navigator.userAgent);
+  await browser.close();
+  if (!userAgent || typeof userAgent !== "string") {
+    return void 0;
+  }
+  userAgent = userAgent.replace("HeadlessChrome", "Chrome");
+  return userAgent;
+}
+
+// src/common/playwrightContext.ts
+var import_runtime_interface3 = __toESM(require_dist());
+var browserScriptsFile = path.join(
+  __dirname,
+  "./assets/browser_scripts.js"
+);
+async function withPlaywrightContext({
+  cdpAddress,
+  cdpTargetId,
+  proxy,
+  headless = true,
+  downloadsPath,
+  importFunction,
+  apiName,
+  apiParameters
+}, fn) {
+  let context;
+  let page;
+  try {
+    const setupContextHookResult = importFunction ? await loadSetupContextHook({
+      importFunction
+    }) : ok4(null);
+    if (setupContextHookResult.isErr()) {
+      return setupContextHookResult;
+    }
+    const setupContextHook = setupContextHookResult.value;
+    if (setupContextHook === null) {
+      if (cdpAddress !== void 0) {
+        ({ page, context } = await launchBrowser({ cdpAddress, cdpTargetId }));
+      } else {
+        ({ page, context } = await launchBrowser({
+          proxy,
+          headless,
+          downloadsPath
+        }));
+      }
+      return await fn(context, page);
+    }
+    let hookCdpUrl = null;
+    if (cdpAddress) {
+      hookCdpUrl = cdpAddress;
+      ({ context, page } = await launchBrowser({ cdpAddress, cdpTargetId }));
+    } else {
+      const port = await getPort({
+        port: 9222
+      });
+      ({ context, page } = await launchBrowser({
+        proxy,
+        headless,
+        downloadsPath,
+        cdpPort: port
+      }));
+      hookCdpUrl = getLocalCdpAddress(port);
+    }
+    let hookResult;
+    try {
+      const wsUrlResult = await getCdpWebSocketUrl(hookCdpUrl);
+      if (wsUrlResult.isOk()) {
+        hookCdpUrl = wsUrlResult.value;
+      } else {
+        throw new Error(wsUrlResult.error);
+      }
+      hookResult = await setupContextHook({
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        apiName,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        apiParameters,
+        cdpUrl: hookCdpUrl
+      });
+    } catch (error) {
+      return err3(new import_runtime_interface3.AutomationError(error));
+    }
+    if (!hookResult) {
+      return await fn(context, page);
+    }
+    const { page: newPage, context: newContext, cleanup } = hookResult;
+    let result;
+    try {
+      result = { return: await fn(newContext, newPage ?? page) };
+    } catch (e) {
+      result = { throw: e };
+    }
+    try {
+      await cleanup?.();
+    } catch (e) {
+      result = { return: err3(new import_runtime_interface3.AutomationError(e)) };
+    }
+    if ("throw" in result) {
+      throw result.throw;
+    }
+    return result.return;
+  } finally {
+    await context?.close();
+  }
+}
+async function loadSessionToContext({
+  context,
+  session
+}) {
+  let sessionToLoad;
+  if (session.type === "state") {
+    const state = session.state;
+    if (state === void 0 || state === null) {
+      return;
+    }
+    sessionToLoad = state;
+  } else {
+    const fullPath = getFullPathInProject(session.path);
+    sessionToLoad = await fs2.readJson(fullPath);
+  }
+  await setStorageState(context, sessionToLoad);
+}
+
+// src/common/runApi/index.ts
+var import_runtime_interface4 = __toESM(require_dist());
+function getObjectSizeInBytes(obj) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(obj)).length;
+  } catch (error) {
+    return new TextEncoder().encode(String(obj)).length;
+  }
+}
+async function runApi({
+  abortSignal,
+  importFunction,
+  retrieveSession = false,
+  ...input
+}) {
+  let traceStarted = false;
+  const inputParseResult = import_runtime_interface4.runApiParametersSchema.safeParse(input);
+  if (!inputParseResult.success) {
+    return err4(
+      new import_runtime_interface4.InternalInvalidInputError(
+        "Input validation failed",
+        formatZodError(inputParseResult.error)
+      )
+    );
+  }
+  const {
+    automationFunction: { name, params },
+    runOptions,
+    tracing,
+    auth
+  } = inputParseResult.data;
+  const abortSymbol = /* @__PURE__ */ Symbol("abort");
+  const abortPromise = new Promise((resolve) => {
+    if (!abortSignal) return;
+    abortSignal.addEventListener("abort", () => {
+      resolve(abortSymbol);
+    });
+  });
+  async function runAutomation() {
+    const validatedModuleResult = await importUsingImportFunction({
+      path: name,
+      importFunction
+    });
+    if (validatedModuleResult.isErr()) {
+      return err4(validatedModuleResult.error);
+    }
+    const automationFunction = validatedModuleResult.value;
+    if (auth && auth.session.type === "state") {
+      const state = auth.session.state;
+      if (state === void 0 || state === null) {
+        return err4(new import_runtime_interface4.AuthRequiredError());
+      }
+    }
+    const playwrightContextParameters = {
+      apiName: name,
+      apiParameters: params,
+      importFunction
+    };
+    const intunedContext = getExecutionContext();
+    const runAutomationWithContext = async (context, page) => {
+      async function saveTraceIfNeeded({
+        errorMessage
+      }) {
+        if (!tracing.enabled || !traceStarted) {
+          return;
+        }
+        try {
+          await context?.tracing.stop({ path: tracing.filePath });
+        } catch (error) {
+          console.log(errorMessage, error?.message);
+          await remove2(tracing.filePath);
+        }
+      }
+      if (auth) {
+        await loadSessionToContext({
+          context,
+          session: auth.session
+        });
+        if (intunedContext && auth.parameters) {
+          intunedContext.getAuthSessionParameters = async () => auth.parameters;
+        }
+      }
+      const scriptContent = await fs3.readFile(browserScriptsFile, "utf-8");
+      await context.addInitScript({
+        content: scriptContent
+      });
+      for (const page2 of context.pages()) {
+        await page2.evaluate(scriptContent);
+      }
+      if (tracing.enabled) {
+        await context.tracing.start({
+          screenshots: true,
+          snapshots: true,
+          sources: true
+        });
+        traceStarted = true;
+      }
+      cleanEnvironmentVariables();
+      const automationFunctionParameters = [
+        ...params !== void 0 ? [params] : [],
+        page,
+        context
+      ];
+      try {
+        const [automationFunctionResult] = await Promise.all([
+          automationFunction(...automationFunctionParameters)
+        ]);
+        const MAX_RESULT_SIZE_BYTES = 2 * 1024 * 1024;
+        const resultSizeInBytes = getObjectSizeInBytes(
+          automationFunctionResult
+        );
+        if (resultSizeInBytes > MAX_RESULT_SIZE_BYTES) {
+          return err4(
+            new import_runtime_interface4.ResultTooBigError(resultSizeInBytes, MAX_RESULT_SIZE_BYTES)
+          );
+        }
+        if (retrieveSession) {
+          return ok5({
+            result: automationFunctionResult,
+            extendedPayloads: intunedContext?.extendedPayloads,
+            session: await getStorageState(context)
+          });
+        }
+        return ok5({
+          result: automationFunctionResult,
+          extendedPayloads: intunedContext?.extendedPayloads
+        });
+      } catch (error) {
+        return err4(new import_runtime_interface4.AutomationError(error));
+      } finally {
+        await saveTraceIfNeeded({ errorMessage: "failed to save trace" });
+      }
+    };
+    if (intunedContext?.store) {
+      intunedContext.store = {};
+    }
+    if (runOptions.environment === "standalone") {
+      const downloadsPath = getDownloadDirectoryPath();
+      try {
+        return await withPlaywrightContext(
+          {
+            headless: runOptions.headless,
+            proxy: runOptions.proxy,
+            downloadsPath,
+            ...playwrightContextParameters
+          },
+          runAutomationWithContext
+        );
+      } finally {
+        await fs3.remove(downloadsPath);
+      }
+    } else {
+      return await withPlaywrightContext(
+        {
+          cdpAddress: runOptions.cdpAddress,
+          cdpTargetId: runOptions.cdpTargetId,
+          ...playwrightContextParameters
+        },
+        runAutomationWithContext
+      );
+    }
+  }
+  const result = await Promise.race([await runAutomation(), abortPromise]);
+  if (result === abortSymbol) {
+    return err4(new import_runtime_interface4.AbortedError());
+  }
+  return result;
+}
+async function checkAuthSessionWithRetries(page, context, checkFn, retries = 3) {
+  if (retries === 0) {
+    return ok5(false);
+  }
+  let tryNumber = 0;
+  console.log(
+    "Checking AuthSession with retries",
+    `${AUTH_SESSIONS_FOLDER_NAME}/check`
+  );
+  while (retries > tryNumber) {
+    const result = await checkFn(page, context);
+    if (result) return ok5(true);
+    tryNumber++;
+  }
+  return ok5(false);
+}
+
+export {
+  require_dist,
+  runApi,
+  checkAuthSessionWithRetries
+};
+//# sourceMappingURL=chunk-XC75QGFG.mjs.map