@intuned/runtime-dev 1.3.18-interface.10 → 1.3.18-interface.12

package/dist/commands/api/run.js

@@ -0,0 +1,2094 @@
+#!/usr/bin/env node
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+// ../packages/runtime-interface/dist/errors.js
+var require_errors = __commonJS({
+  "../packages/runtime-interface/dist/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ResultTooBigError = exports2.InternalInvalidInputError = exports2.AutomationError = exports2.MaxLevelsExceededError = exports2.AuthCheckFailedError = exports2.AuthCheckNotFoundError = exports2.AuthRequiredError = exports2.AbortedError = exports2.InvalidCheckError = exports2.InvalidApiError = exports2.ApiNotFoundError = exports2.RunAutomationError = exports2.runAutomationErrorCodes = exports2.resultTooBigErrorCode = exports2.internalInvalidInputErrorCode = exports2.automationError = exports2.maxLevelsExceededErrorCode = exports2.authCheckFailedErrorCode = exports2.authCheckNotFoundErrorCode = exports2.authRequiredErrorCode = exports2.abortedErrorCode = exports2.invalidCheckErrorCode = exports2.invalidApiErrorCode = exports2.apiNotFoundErrorCode = void 0;
+    exports2.apiNotFoundErrorCode = "APINotFoundError";
+    exports2.invalidApiErrorCode = "InvalidAPIError";
+    exports2.invalidCheckErrorCode = "InvalidCheckError";
+    exports2.abortedErrorCode = "AbortedError";
+    exports2.authRequiredErrorCode = "AuthRequiredError";
+    exports2.authCheckNotFoundErrorCode = "AuthCheckNotFoundError";
+    exports2.authCheckFailedErrorCode = "AuthCheckFailedError";
+    exports2.maxLevelsExceededErrorCode = "MaxLevelsExceededError";
+    exports2.automationError = "AutomationError";
+    exports2.internalInvalidInputErrorCode = "InternalInvalidInputError";
+    exports2.resultTooBigErrorCode = "ResultTooBigError";
+    exports2.runAutomationErrorCodes = [
+      exports2.apiNotFoundErrorCode,
+      exports2.invalidApiErrorCode,
+      exports2.invalidCheckErrorCode,
+      exports2.abortedErrorCode,
+      exports2.authRequiredErrorCode,
+      exports2.authCheckNotFoundErrorCode,
+      exports2.authCheckFailedErrorCode,
+      exports2.maxLevelsExceededErrorCode,
+      exports2.automationError,
+      exports2.internalInvalidInputErrorCode,
+      exports2.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
+        };
+      }
+    };
+    exports2.RunAutomationError = RunAutomationError4;
+    var ApiNotFoundError3 = class extends RunAutomationError4 {
+      constructor(apiName) {
+        super(exports2.apiNotFoundErrorCode, `API ${apiName} not found`);
+      }
+    };
+    exports2.ApiNotFoundError = ApiNotFoundError3;
+    var InvalidApiError2 = class extends RunAutomationError4 {
+      constructor(message) {
+        super(exports2.invalidApiErrorCode, `API is invalid: ${message}`);
+        this.details = {
+          message
+        };
+      }
+    };
+    exports2.InvalidApiError = InvalidApiError2;
+    var InvalidCheckError = class extends RunAutomationError4 {
+      constructor(message, cause) {
+        super(exports2.invalidCheckErrorCode, message);
+        this.cause = cause;
+      }
+    };
+    exports2.InvalidCheckError = InvalidCheckError;
+    var AbortedError2 = class extends RunAutomationError4 {
+      constructor() {
+        super(exports2.abortedErrorCode, "Operation was aborted");
+      }
+    };
+    exports2.AbortedError = AbortedError2;
+    var AuthRequiredError2 = class extends RunAutomationError4 {
+      constructor() {
+        super(exports2.authRequiredErrorCode, "AuthSessions are required");
+      }
+    };
+    exports2.AuthRequiredError = AuthRequiredError2;
+    var AuthCheckNotFoundError = class extends RunAutomationError4 {
+      constructor() {
+        super(exports2.authCheckNotFoundErrorCode, "AuthSession check not found");
+      }
+    };
+    exports2.AuthCheckNotFoundError = AuthCheckNotFoundError;
+    var AuthCheckFailedError = class extends RunAutomationError4 {
+      constructor() {
+        super(exports2.authCheckFailedErrorCode, "AuthSession check failed");
+      }
+    };
+    exports2.AuthCheckFailedError = AuthCheckFailedError;
+    var MaxLevelsExceededError = class extends RunAutomationError4 {
+      constructor(levels) {
+        super(exports2.maxLevelsExceededErrorCode, `Max levels exceeded. Only ${levels} levels are supported`);
+        this.details = { levels };
+      }
+    };
+    exports2.MaxLevelsExceededError = MaxLevelsExceededError;
+    var AutomationError5 = class extends RunAutomationError4 {
+      constructor(error) {
+        super(exports2.automationError, `[${error?.name ?? error}] ${error?.message}`);
+        this.details = {
+          ...error
+        };
+      }
+    };
+    exports2.AutomationError = AutomationError5;
+    var InternalInvalidInputError2 = class extends RunAutomationError4 {
+      constructor(message, details) {
+        super(exports2.internalInvalidInputErrorCode, message);
+        this.details = details;
+      }
+    };
+    exports2.InternalInvalidInputError = InternalInvalidInputError2;
+    var ResultTooBigError2 = class extends RunAutomationError4 {
+      constructor(sizeInBytes, maxSizeInBytes) {
+        super(exports2.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 };
+      }
+    };
+    exports2.ResultTooBigError = ResultTooBigError2;
+  }
+});
+
+// ../packages/runtime-interface/dist/types.js
+var require_types = __commonJS({
+  "../packages/runtime-interface/dist/types.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.outputRunApiSchema = exports2.pongMessageSchema = exports2.doneMessageSchema = exports2.extendMessageSchema = exports2.runApiInputSchema = exports2.pingSchema = exports2.tokenUpdateSchema = exports2.abortRunApiSchema = exports2.startRunApiSchema = exports2.startRunApiParametersSchema = exports2.runApiParametersSchema = exports2.runApiRunOptionsSchema = exports2.runApiCdpRunOptionsSchema = exports2.runApiStandaloneRunOptionsSchema = exports2.runApiAuthSchema = exports2.runApiTracingSchema = exports2.runApiAutomationFunctionSchema = exports2.runApiSessionSchema = exports2.runApiStorageStateSchema = void 0;
+    exports2.runApiResultOkSchema = runApiResultOkSchema;
+    exports2.runApiResultWithSessionOkSchema = runApiResultWithSessionOkSchema;
+    var zod_1 = __importDefault(require("zod"));
+    exports2.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()
+    });
+    exports2.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: exports2.runApiStorageStateSchema.nullable().optional()
+      })
+    ]);
+    exports2.runApiAutomationFunctionSchema = zod_1.default.object({
+      name: zod_1.default.string(),
+      params: zod_1.default.any().optional()
+    });
+    exports2.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 });
+    exports2.runApiAuthSchema = zod_1.default.object({
+      session: exports2.runApiSessionSchema,
+      parameters: zod_1.default.record(zod_1.default.any()).optional()
+    }).optional();
+    exports2.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()
+    });
+    exports2.runApiCdpRunOptionsSchema = zod_1.default.object({
+      environment: zod_1.default.literal("cdp"),
+      cdpAddress: zod_1.default.string(),
+      cdpTargetId: zod_1.default.string().optional()
+    });
+    exports2.runApiRunOptionsSchema = zod_1.default.discriminatedUnion("environment", [
+      exports2.runApiStandaloneRunOptionsSchema,
+      exports2.runApiCdpRunOptionsSchema
+    ]).default({ environment: "standalone", headless: true });
+    exports2.runApiParametersSchema = zod_1.default.object({
+      automationFunction: exports2.runApiAutomationFunctionSchema,
+      tracing: exports2.runApiTracingSchema,
+      auth: exports2.runApiAuthSchema,
+      runOptions: exports2.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: exports2.runApiStorageStateSchema
+      });
+    }
+    exports2.startRunApiParametersSchema = exports2.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()
+    });
+    exports2.startRunApiSchema = zod_1.default.object({
+      type: zod_1.default.literal("start"),
+      parameters: exports2.startRunApiParametersSchema
+    });
+    exports2.abortRunApiSchema = zod_1.default.object({
+      type: zod_1.default.literal("abort"),
+      parameters: zod_1.default.object({}).optional()
+    });
+    exports2.tokenUpdateSchema = zod_1.default.object({
+      type: zod_1.default.literal("tokenUpdate"),
+      parameters: zod_1.default.object({
+        functionsToken: zod_1.default.string()
+      })
+    });
+    exports2.pingSchema = zod_1.default.object({
+      type: zod_1.default.literal("ping"),
+      parameters: zod_1.default.object({}).optional()
+    });
+    exports2.runApiInputSchema = zod_1.default.union([
+      exports2.startRunApiSchema,
+      exports2.abortRunApiSchema,
+      exports2.tokenUpdateSchema,
+      exports2.pingSchema
+    ]);
+    exports2.extendMessageSchema = zod_1.default.object({ type: zod_1.default.literal("extend") });
+    exports2.doneMessageSchema = zod_1.default.object({
+      type: zod_1.default.literal("done"),
+      result: zod_1.default.any(),
+      success: zod_1.default.boolean()
+    });
+    exports2.pongMessageSchema = zod_1.default.object({
+      type: zod_1.default.literal("pong")
+    });
+    exports2.outputRunApiSchema = zod_1.default.union([
+      exports2.extendMessageSchema,
+      exports2.doneMessageSchema,
+      exports2.pongMessageSchema
+    ]);
+  }
+});
+
+// ../packages/runtime-interface/dist/interfaceClient.js
+var require_interfaceClient = __commonJS({
+  "../packages/runtime-interface/dist/interfaceClient.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__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(exports2, "__esModule", { value: true });
+    exports2.JSONLFileClient = exports2.TCPSocketClient = exports2.UnixSocketClient = exports2.SocketClient = void 0;
+    var net = __importStar(require("net"));
+    var fs6 = __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((resolve2, reject) => {
+          this.socket.once("end", () => {
+            resolve2();
+          });
+          this.socket.once("error", reject);
+        });
+        while (true) {
+          const chunk = await Promise.race([
+            new Promise((resolve2) => this.socket.once("data", (data2) => {
+              if (typeof data2 === "string") {
+                return resolve2(Buffer.from(data2));
+              }
+              resolve2(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((resolve2) => this.socket.once("close", resolve2)),
+          new Promise((resolve2) => this.socket.once("error", resolve2)),
+          (0, promises_1.setTimeout)(3e3)
+        ]);
+      }
+      get closed() {
+        return this.socket.closed;
+      }
+    };
+    exports2.SocketClient = SocketClient;
+    SocketClient.LENGTH_HEADER_LENGTH = 4;
+    var UnixSocketClient = class extends SocketClient {
+      constructor(path3) {
+        super(net.createConnection(path3));
+      }
+    };
+    exports2.UnixSocketClient = UnixSocketClient;
+    var TCPSocketClient = class extends SocketClient {
+      constructor(host, port) {
+        super(net.createConnection(port, host));
+      }
+    };
+    exports2.TCPSocketClient = TCPSocketClient;
+    var JSONLFileClient = class {
+      constructor(filePath) {
+        this.fileStream = fs6.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((resolve2) => this.fileStream.once("close", resolve2)),
+          new Promise((resolve2) => this.fileStream.once("error", resolve2)),
+          (0, promises_1.setTimeout)(3e3)
+        ]);
+      }
+      get closed() {
+        return this.fileStream.closed;
+      }
+    };
+    exports2.JSONLFileClient = JSONLFileClient;
+  }
+});
+
+// ../packages/runtime-interface/dist/index.js
+var require_dist = __commonJS({
+  "../packages/runtime-interface/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__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 = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_errors(), exports2);
+    __exportStar(require_types(), exports2);
+    __exportStar(require_interfaceClient(), exports2);
+  }
+});
+
+// src/commands/api/run.ts
+var run_exports = {};
+__export(run_exports, {
+  executeCLI: () => executeCLI
+});
+module.exports = __toCommonJS(run_exports);
+var import_commander = require("commander");
+var fs5 = __toESM(require("fs-extra"));
+
+// src/commands/common/utils/fileUtils.ts
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs-extra"));
+var import_dotenv = __toESM(require("dotenv"));
+import_dotenv.default.config();
+function getFullPathInProject(...paths) {
+  return path.resolve(process.cwd(), process.env.ROOT || "./", ...paths);
+}
+
+// src/common/settingsSchema.ts
+var z = __toESM(require("zod"));
+var baseCaptchaSchema = z.object({
+  enabled: z.boolean()
+});
+var customCaptchaSchema = baseCaptchaSchema.extend({
+  imageLocators: z.array(z.string()).min(1, "At least one image locator is required"),
+  submitLocators: z.array(z.string()).min(1, "At least one submit locator is required"),
+  inputLocators: z.array(z.string()).min(1, "At least one input locator is required")
+});
+var textCaptchaSchema = baseCaptchaSchema.extend({
+  labelLocators: z.array(z.string()).min(1, "At least one image locator is required"),
+  submitLocators: z.array(z.string()).min(1, "At least one submit locator is required"),
+  inputLocators: z.array(z.string()).min(1, "At least one input locator is required")
+});
+var captchaSolverSolveSettingsSchema = z.object({
+  autoSolve: z.boolean().default(true),
+  solveDelay: z.number().min(0).default(2e3),
+  maxRetries: z.number().min(0).default(3),
+  timeout: z.number().min(0).default(3e4)
+});
+var captchaSolverSettingsSchema = z.object({
+  enabled: z.boolean().default(false),
+  port: z.number().int().min(1).max(65535).optional(),
+  cloudflare: baseCaptchaSchema.optional(),
+  googleRecaptchaV2: baseCaptchaSchema.optional(),
+  googleRecaptchaV3: baseCaptchaSchema.optional(),
+  awscaptcha: baseCaptchaSchema.optional(),
+  hcaptcha: baseCaptchaSchema.optional(),
+  funcaptcha: baseCaptchaSchema.optional(),
+  geetest: baseCaptchaSchema.optional(),
+  lemin: baseCaptchaSchema.optional(),
+  customCaptcha: customCaptchaSchema.optional(),
+  text: textCaptchaSchema.optional(),
+  settings: captchaSolverSolveSettingsSchema.default(
+    captchaSolverSolveSettingsSchema.parse({})
+  )
+}).default({});
+var authSessionsSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+var stealthModeSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
+var settingsSchema = z.object({
+  authSessions: authSessionsSchema,
+  stealthMode: stealthModeSchema,
+  captchaSolver: captchaSolverSettingsSchema.optional()
+});
+
+// src/commands/common/utils/settings.ts
+var import_promises = require("fs/promises");
+async function getSettings() {
+  const settingsFilePath = getFullPathInProject("Intuned.json");
+  const settings = await (0, import_promises.readFile)(settingsFilePath, { encoding: "utf-8" });
+  if (settings) {
+    const parsed = settingsSchema.safeParse(JSON.parse(settings));
+    if (parsed.success) {
+      return parsed.data;
+    } else {
+      throw new Error(parsed.error.message);
+    }
+  }
+  return {
+    authSessions: { enabled: false },
+    stealthMode: { enabled: false }
+  };
+}
+
+// src/commands/api/run.ts
+var import_dotenv2 = __toESM(require("dotenv"));
+
+// src/common/asyncLocalStorage/index.ts
+var import_node_async_hooks = require("async_hooks");
+var asyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+function runWithContext(contextData, callback, ...args) {
+  return asyncLocalStorage.run(contextData, callback, ...args);
+}
+function getExecutionContext() {
+  const contextData = asyncLocalStorage.getStore();
+  return contextData;
+}
+
+// src/common/cleanEnvironmentVariables.ts
+function cleanEnvironmentVariables() {
+  Object.keys(process.env).filter((i) => {
+    if (i.toLocaleLowerCase().startsWith("npm")) {
+      return true;
+    }
+    if (i.toLocaleLowerCase().startsWith("fly") && i !== "FLY_ALLOC_ID") {
+      return true;
+    }
+  }).forEach((i) => delete process.env[i]);
+}
+
+// src/common/Logger/index.ts
+var import_node_util = require("util");
+var import_chalk = __toESM(require("chalk"));
+var format = import_node_util.formatWithOptions.bind(void 0, { colors: true });
+var LOG_LEVEL_COLORS = {
+  TRACE: import_chalk.default.gray,
+  DEBUG: import_chalk.default.blue,
+  INFO: import_chalk.default.green,
+  WARN: import_chalk.default.yellow,
+  ERROR: import_chalk.default.red
+};
+var Logger = class {
+  logFunction(entry) {
+    const { level, timestamp, message, meta } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+    if (meta === void 0) {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}
+`
+      );
+    } else {
+      process.stderr.write(
+        `${format(date)} [@intuned/sdk][${levelColor(
+          level
+        )}] ${message} ${format(meta)}
+`
+      );
+    }
+  }
+  log(level, message, meta) {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? void 0 : meta,
+      timestamp: Date.now()
+    });
+  }
+  trace(message, meta) {
+    this.log("TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this.log("DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this.log("INFO", message, meta);
+  }
+  warn(message, meta) {
+    this.log("WARN", message, meta);
+  }
+  error(message, meta) {
+    this.log("ERROR", message, meta);
+  }
+};
+var logger = new Logger();
+
+// src/commands/api/run.ts
+var import_nanoid = require("nanoid");
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/runtime/attemptStore.ts
+var attemptStore = Object.freeze({
+  get: (key) => {
+    const context = getExecutionContext();
+    return context?.store ? context.store[key] : void 0;
+  },
+  set: (key, value) => {
+    const context = getExecutionContext();
+    if (!context) {
+      throw new Error("store.set failed due to an internal error.");
+    }
+    if (!context.store) {
+      context.store = {};
+    }
+    context.store[key] = value;
+  }
+});
+
+// src/runtime/persistentStore.ts
+var import_zod = require("zod");
+
+// src/common/jwtTokenManager.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+var jwt = __toESM(require("jsonwebtoken"));
+var import_neverthrow = require("neverthrow");
+
+// src/common/constants.ts
+var API_FOLDER_NAME = "api";
+var WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+var PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+var API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";
+var AUTH_TOKEN_ENV_VAR_KEY = "INTUNED_AUTH_TOKEN";
+var API_KEY_HEADER_NAME = "x-api-key";
+var CLI_ENV_VAR_KEY = "INTUNED_CLI";
+
+// src/common/jwtTokenManager.ts
+var JwtTokenManager = class {
+  constructor(refreshTokenPath) {
+    this.refreshTokenPath = refreshTokenPath;
+    this._token = void 0;
+  }
+  get token() {
+    return this._token;
+  }
+  // When the token is set, the schedule for renewal is issued automatically
+  // This is currently being set it two places:
+  // 1. Whenever the runner starts, initializes it from the environment variable (set whenever the api is run from the authoring IDE)
+  // 2. Whenever a published api is called to run (/api/run/*), it is set to the token received in the run request.
+  set token(newToken) {
+    if (this._token != newToken) {
+      this._token = newToken;
+      void this.scheduleTokenRefresh();
+    }
+  }
+  get timeToRefresh() {
+    if (!this._token) return;
+    const payload = jwt.decode(this._token);
+    if (!payload || typeof payload == "string") return;
+    const expiry = payload.expiry;
+    if (!expiry || typeof expiry !== "number") return;
+    const timeWindow = 60 * 1e3;
+    const timeToRefresh = expiry - Date.now() - timeWindow;
+    return Math.max(timeToRefresh, timeWindow);
+  }
+  async scheduleTokenRefresh() {
+    if (process.env.RUN_ENVIRONMENT?.toLowerCase() !== "authoring") return;
+    const timeToRefresh = this.timeToRefresh;
+    if (timeToRefresh === void 0) return;
+    if (this.tokenRefreshTimeout) clearTimeout(this.tokenRefreshTimeout);
+    this.tokenRefreshTimeout = setTimeout(async () => {
+      const result = await this.refreshToken();
+      if (result && result.isErr()) {
+        console.error(`[Internal Error] ${result.error}`);
+        return;
+      }
+      await this.scheduleTokenRefresh();
+    }, timeToRefresh);
+  }
+  async refreshToken() {
+    if (process.env.RUN_ENVIRONMENT?.toLowerCase() !== "authoring") return;
+    const res = await this.fetchWithToken(
+      `${this.backendFunctionsBaseUrl}/${this.refreshTokenPath}`,
+      {
+        method: "GET"
+      }
+    );
+    if (res.status === 401) {
+      return (0, import_neverthrow.err)("Unauthorized");
+    }
+    const jsonResult = await import_neverthrow.ResultAsync.fromPromise(
+      res.json(),
+      () => "not json"
+    );
+    if (jsonResult.isErr()) return;
+    const newToken = jsonResult.value.token;
+    if (newToken) this._token = newToken;
+  }
+  async fetchWithToken(...[input, init]) {
+    const headers = new Headers(init?.headers);
+    const apiKey = process.env[API_KEY_ENV_VAR_KEY];
+    if (apiKey) {
+      headers.set(API_KEY_HEADER_NAME, apiKey);
+    }
+    const token = process.env[AUTH_TOKEN_ENV_VAR_KEY];
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    if (this.token !== void 0) {
+      headers.set("Authorization", `Bearer ${this.token}`);
+    }
+    const result = await (0, import_cross_fetch.default)(input, {
+      ...init,
+      headers
+    });
+    if (result.status === 401 && process.env[CLI_ENV_VAR_KEY] === "true") {
+      console.warn(
+        "Unauthorized backend function call - make sure to provision your project to Intuned to set up the correct API credentials.\nRun 'intuned provision' or see https://docs.intunedhq.com/docs/05-references/cli#provision-project for more information."
+      );
+    }
+    return result;
+  }
+  get backendFunctionsBaseUrl() {
+    try {
+      if (!process.env.FUNCTIONS_DOMAIN) {
+        throw new Error(
+          `Cannot call backend function - FUNCTIONS_DOMAIN not set`
+        );
+      }
+      const domain = process.env.FUNCTIONS_DOMAIN;
+      if (!process.env[WORKSPACE_ID_ENV_VAR_KEY]) {
+        throw new Error(
+          `Cannot call backend function - ${WORKSPACE_ID_ENV_VAR_KEY} not set`
+        );
+      }
+      const workspaceId = process.env[WORKSPACE_ID_ENV_VAR_KEY];
+      if (!process.env[PROJECT_ID_ENV_VAR_KEY] && !process.env.INTUNED_INTEGRATION_ID) {
+        throw new Error(
+          `Cannot call backend function - ${PROJECT_ID_ENV_VAR_KEY} or INTUNED_INTEGRATION_ID not set`
+        );
+      }
+      const projectId = process.env.INTUNED_INTEGRATION_ID ?? process.env[PROJECT_ID_ENV_VAR_KEY];
+      return `${domain}/api/${workspaceId}/functions/${projectId}`;
+    } catch (e) {
+      if (process.env[CLI_ENV_VAR_KEY] === "true") {
+        throw new Error(
+          `API credentials not set - make sure to provision your project to Intuned to set up the correct API credentials.
+Run 'intuned provision' or see https://docs.intunedhq.com/docs/05-references/cli#provision-project for more information.
+Original error: ${e.message}`
+        );
+      }
+    }
+  }
+};
+var backendFunctionsTokenManager = new JwtTokenManager(
+  `refreshBackendFunctionsToken`
+);
+backendFunctionsTokenManager.token = process.env.INTUNED_AUTHORING_SESSION_BACKEND_FUNCTIONS_TOKEN;
+function callBackendFunctionWithToken(path3, init) {
+  return backendFunctionsTokenManager.fetchWithToken(
+    `${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path3}`,
+    init
+  );
+}
+
+// src/runtime/persistentStore.ts
+var forbiddenCharacters = /[:#]/g;
+var keySchema = import_zod.z.string().min(1, "Key must be at least 1 character long").refine(
+  (key) => (key.match(forbiddenCharacters)?.length ?? 0) === 0,
+  'Key cannot contain the following characters: ":" or "#"'
+);
+var persistentStore = Object.freeze({
+  get: async (key) => {
+    const parsedKey = keySchema.parse(key);
+    const response = await callBackendFunctionWithToken(
+      `kv-store/${parsedKey}`,
+      {
+        method: "GET"
+      }
+    );
+    const json = await response.json();
+    if (!response.ok) {
+      throw new Error(json.message);
+    }
+    return json.value;
+  },
+  set: async (key, value) => {
+    const keyResult = keySchema.parse(key);
+    const response = await callBackendFunctionWithToken(
+      `kv-store/${keyResult}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(value),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    const json = await response.json();
+    if (!response.ok) {
+      throw new Error(json.message);
+    }
+  }
+});
+
+// src/runtime/RunError.ts
+var RunError = class _RunError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.message = message;
+    this.name = "USER_GENERATED_ERROR";
+    this.options = options ?? {
+      retryable: false
+    };
+    Object.setPrototypeOf(this, _RunError.prototype);
+  }
+};
+new RunError("", {});
+
+// src/common/extension/intunedExtensionServer.ts
+var import_fastify = __toESM(require("fastify"));
+
+// src/common/extension/types.ts
+var import_zod2 = require("zod");
+var captchaTypeSchema = import_zod2.z.enum([
+  "aws",
+  "cloudflare",
+  "customcaptcha",
+  "funcaptcha",
+  "geetest",
+  "hcaptcha",
+  "lemincaptcha",
+  "recaptcha",
+  "textcaptcha"
+]);
+var captchaStatusSchema = import_zod2.z.enum([
+  "attached",
+  "solving",
+  "solved",
+  "error",
+  "detached"
+]);
+var captchaErrorCodeSchema = import_zod2.z.enum([
+  "HIT_LIMIT",
+  "MAX_RETRIES",
+  "UNEXPECTED_SERVER_RESPONSE",
+  "UNEXPECTED_ERROR"
+]);
+var captchaErrorSchema = import_zod2.z.object({
+  code: captchaErrorCodeSchema,
+  error: import_zod2.z.unknown().optional()
+});
+var captchaBaseSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  tabId: import_zod2.z.number().int().positive(),
+  type: captchaTypeSchema,
+  retryCount: import_zod2.z.number().int().nonnegative().optional()
+});
+var captchaNonErrorSchema = captchaBaseSchema.extend({
+  status: captchaStatusSchema.exclude(["error"])
+});
+var captchaErrorStatusSchema = captchaBaseSchema.extend({
+  status: import_zod2.z.literal("error"),
+  error: captchaErrorSchema
+});
+var captchaSchema = import_zod2.z.discriminatedUnion("status", [
+  captchaBaseSchema.extend({
+    status: import_zod2.z.literal("attached")
+  }),
+  captchaBaseSchema.extend({
+    status: import_zod2.z.literal("solving")
+  }),
+  captchaBaseSchema.extend({
+    status: import_zod2.z.literal("solved")
+  }),
+  captchaBaseSchema.extend({
+    status: import_zod2.z.literal("detached")
+  }),
+  captchaErrorStatusSchema
+]);
+
+// src/common/extension/extensionsHelpers.ts
+var import_path = __toESM(require("path"));
+var import_promises2 = require("fs/promises");
+var import_portfinder = require("portfinder");
+var INTUNED_WORKER = "intunedWorker.js";
+var INTUNED_EXTENSION_SETTINGS_FILE_NAME = "intunedSettings.json";
+var captchaSolverSettings = null;
+async function getIntunedCaptchaExtensionPort() {
+  if (process.env.INTUNED_CAPTCHA_EXTENSION_PORT) {
+    return parseInt(process.env.INTUNED_CAPTCHA_EXTENSION_PORT, 10);
+  }
+  return await (0, import_portfinder.getPort)({});
+}
+async function resolveCaptchaSolverSettings(input) {
+  const parsed = captchaSolverSettingsSchema.parse(input || {});
+  if (!parsed.port) {
+    parsed.port = await getIntunedCaptchaExtensionPort();
+  }
+  return parsed;
+}
+function isIntunedExtensionLoaded() {
+  return !!getIntunedExtensionPath();
+}
+function buildExtensionsList() {
+  const extensionsList = [];
+  if (isIntunedExtensionLoaded()) {
+    const intunedExtensionPath = getIntunedExtensionPath();
+    extensionsList.push(intunedExtensionPath);
+  }
+  return extensionsList;
+}
+function getIntunedExtensionPath() {
+  return process.env.INTUNED_EXTENSION_PATH;
+}
+async function isIntunedExtensionEnabled() {
+  const path3 = getIntunedExtensionPath();
+  if (!path3) {
+    return false;
+  }
+  const captchaSolverSettings2 = await getIntunedCaptchaSolverSettings();
+  return captchaSolverSettings2.enabled;
+}
+async function getIntunedExtensionWorker(context) {
+  if (!await isIntunedExtensionEnabled()) {
+    return null;
+  }
+  let attemptCount = 0;
+  while (attemptCount < 4) {
+    const intunedServiceWorker = context.serviceWorkers().find((serviceWorker) => serviceWorker.url().includes(INTUNED_WORKER));
+    if (intunedServiceWorker) {
+      return intunedServiceWorker;
+    }
+    try {
+      await context.waitForEvent("serviceworker", { timeout: 3e3 });
+    } catch (err7) {
+      console.log(`Error accessing service workers (attempt ${attemptCount})`);
+    }
+    attemptCount++;
+  }
+  console.error("Failed to get intuned worker after 5 attmepts");
+  return null;
+}
+async function getIntunedExtensionSettings(captchaSolverSettings2) {
+  const [domain, workspaceId, projectId] = [
+    process.env.FUNCTIONS_DOMAIN,
+    process.env[WORKSPACE_ID_ENV_VAR_KEY],
+    process.env.INTUNED_INTEGRATION_ID ?? process.env[PROJECT_ID_ENV_VAR_KEY]
+  ];
+  if (!domain || !workspaceId || !projectId) {
+    const missingEnvVars = [
+      domain && "FUNCTIONS_DOMAIN",
+      workspaceId && WORKSPACE_ID_ENV_VAR_KEY,
+      projectId && `INTUNED_INTEGRATION_ID OR ${PROJECT_ID_ENV_VAR_KEY}`
+    ];
+    throw new Error(
+      `Missing required environment variables: ${missingEnvVars}`
+    );
+  }
+  const authentication = (() => {
+    if (process.env.INTUNED_API_KEY) {
+      return { type: "apiKey", apiKey: process.env.INTUNED_API_KEY };
+    }
+    if (process.env.INTUNED_BASIC_AUTH_USERNAME && process.env.INTUNED_BASIC_AUTH_PASSWORD) {
+      const credentials = `${process.env.INTUNED_BASIC_AUTH_USERNAME}:${process.env.INTUNED_BASIC_AUTH_PASSWORD}`;
+      const token = Buffer.from(credentials, "utf-8").toString("base64");
+      return { type: "basic", token };
+    }
+    return {
+      type: "bearer",
+      token: backendFunctionsTokenManager.token
+    };
+  })();
+  const baseUrl = process.env.INTUNED_API_BASE_URL ?? domain;
+  return {
+    ...captchaSolverSettings2,
+    workspaceId,
+    projectId,
+    baseUrl,
+    authentication
+  };
+}
+async function getIntunedCaptchaSolverSettings() {
+  if (captchaSolverSettings) {
+    return captchaSolverSettings;
+  }
+  const settings = await getSettings();
+  captchaSolverSettings = await resolveCaptchaSolverSettings(
+    settings.captchaSolver
+  );
+  return captchaSolverSettings;
+}
+async function setupIntunedExtension() {
+  if (!await isIntunedExtensionEnabled()) {
+    return;
+  }
+  const intunedExtensionPath = getIntunedExtensionPath();
+  const intunedExtensionSettingsPath = import_path.default.join(
+    intunedExtensionPath,
+    INTUNED_EXTENSION_SETTINGS_FILE_NAME
+  );
+  const captchaSolverSettings2 = await getIntunedCaptchaSolverSettings();
+  await setupIntunedExtensionServer(captchaSolverSettings2);
+  const captchaSolverSettingsWithRunContext = await getIntunedExtensionSettings(
+    captchaSolverSettings2
+  );
+  await (0, import_promises2.writeFile)(
+    intunedExtensionSettingsPath,
+    JSON.stringify(captchaSolverSettingsWithRunContext)
+  );
+}
+
+// src/common/extension/intunedExtensionServer.ts
+var TabCaptchaState = class {
+  constructor(tabId) {
+    this.tabId = tabId;
+    this.captchasById = /* @__PURE__ */ new Map();
+    this.subscribers = new Array();
+  }
+  subscribe(handler) {
+    this.subscribers.push(handler);
+  }
+  unsubscribe(handler, status) {
+    const index = this.subscribers.findIndex(
+      (subscriber) => subscriber.handler === handler && (subscriber.status === status || !status)
+    );
+    if (index !== -1) {
+      this.subscribers.splice(index, 1);
+    }
+  }
+  getCaptchas() {
+    return [...this.captchasById.values()];
+  }
+  async upsertCaptcha(captcha) {
+    this.captchasById.set(captcha.id, captcha);
+    for (const subscriber of this.subscribers) {
+      if (!subscriber.status || subscriber.status === captcha.status) {
+        await subscriber.handler(captcha);
+      }
+    }
+  }
+};
+var ExtensionServer = class {
+  constructor() {
+    this.app = null;
+    this.tabs = /* @__PURE__ */ new Map();
+  }
+  getOrCreateTab(tabId) {
+    const existing = this.tabs.get(tabId);
+    if (existing) return existing;
+    const created = new TabCaptchaState(tabId);
+    this.tabs.set(tabId, created);
+    return created;
+  }
+  async handleUpsertCaptcha(captcha) {
+    const tab = this.getOrCreateTab(captcha.tabId);
+    await tab.upsertCaptcha(captcha);
+  }
+  async start({
+    port,
+    host = "0.0.0.0"
+  }) {
+    if (this.app) {
+      return;
+    }
+    this.app = (0, import_fastify.default)({
+      logger: false,
+      bodyLimit: 1e6
+    });
+    this.app.post("/state", async (request, reply) => {
+      try {
+        const result = captchaSchema.safeParse(request.body);
+        if (!result.success) {
+          return reply.code(400).send({
+            error: "Invalid captcha payload",
+            details: result.error.flatten().fieldErrors
+          });
+        }
+        await this.handleUpsertCaptcha(result.data);
+        return reply.code(200).send({});
+      } catch (error) {
+        console.error("Error processing captcha state update:", error);
+        return reply.code(500).send({
+          error: "Internal server error",
+          message: error?.message ?? String(error)
+        });
+      }
+    });
+    this.app.setNotFoundHandler((_request, reply) => {
+      return reply.code(404).send({ error: "Not found" });
+    });
+    await this.app.listen({
+      port,
+      host
+    });
+  }
+  async stop() {
+    if (!this.app) return;
+    const toClose = this.app;
+    this.app = null;
+    await toClose.close();
+  }
+  async getCaptchas(page, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return [];
+    const captchas = tab.getCaptchas();
+    if (!status) return captchas;
+    return captchas.filter((c) => c.status === status && c.tabId === tabId);
+  }
+  async subscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.getOrCreateTab(tabId);
+    tab.subscribe({ handler, status });
+  }
+  async unsubscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return;
+    tab.unsubscribe(handler, status);
+  }
+  removeTab(tabId) {
+    this.tabs.delete(tabId);
+  }
+  async getTabId(page) {
+    return await getTabId(page);
+  }
+};
+var extensionServerSingleton = null;
+async function setupIntunedExtensionServer(captchaSolverSettings2) {
+  if (!captchaSolverSettings2) {
+    captchaSolverSettings2 = await resolveCaptchaSolverSettings();
+  }
+  if (!extensionServerSingleton) {
+    extensionServerSingleton = new ExtensionServer();
+  }
+  await extensionServerSingleton.start({
+    port: captchaSolverSettings2.port ?? 9e3
+  });
+}
+async function cleanIntunedExtensionServer() {
+  if (extensionServerSingleton) {
+    await extensionServerSingleton.stop();
+    extensionServerSingleton = null;
+  }
+}
+var TAB_ID_CACHE_KEY = "__INTUNED_CACHED_TAB_ID__";
+async function getTabId(page) {
+  const cached = page[TAB_ID_CACHE_KEY];
+  if (cached !== void 0 && typeof cached === "number") {
+    return cached;
+  }
+  let tabId;
+  try {
+    tabId = await page.evaluate("window.__INTUNED_TAB_ID__", { timeout: 100 });
+  } catch {
+    await page.waitForFunction("window.__INTUNED_TAB_ID__ !== undefined", {
+      timeout: 15e3
+    });
+    tabId = await page.evaluate("window.__INTUNED_TAB_ID__");
+  }
+  const numericTabId = Number(tabId);
+  page[TAB_ID_CACHE_KEY] = numericTabId;
+  return numericTabId;
+}
+
+// src/runtime/downloadDirectory.ts
+var import_fs_extra = require("fs-extra");
+function getDownloadDirectoryPath() {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error("ExecutionContext not found");
+  }
+  const path3 = `/tmp/downloads/${context.runId}`;
+  (0, import_fs_extra.ensureDirSync)(path3, {
+    mode: 1533
+  });
+  return path3;
+}
+
+// src/common/runApi/index.ts
+var fs4 = __toESM(require("fs-extra"));
+var import_fs_extra3 = require("fs-extra");
+var import_neverthrow6 = require("neverthrow");
+
+// src/common/contextStorageStateHelpers.ts
+async function setStorageState(context, state) {
+  if ("cookies" in state && state.cookies) {
+    await context.addCookies(state.cookies);
+  }
+  const page = await context.newPage();
+  if ("origins" in state && state.origins) {
+    for (const originData of state.origins || []) {
+      const origin = originData.origin;
+      await page.route(
+        `${origin}/*`,
+        (route) => route.fulfill({
+          body: "<html><head><title>Set Storage</title></head><body><h1>Set Storage</h1></body></html>",
+          contentType: "text/html",
+          status: 200
+        })
+      );
+      try {
+        await page.goto(origin);
+        for (const item of originData.localStorage) {
+          await page.evaluate(
+            ([key, value]) => {
+              window.localStorage.setItem(key, value);
+            },
+            [item.name, item.value]
+          );
+        }
+      } finally {
+        await page.unroute(`${origin}/*`);
+      }
+    }
+  }
+  if ("sessionStorage" in state && state.sessionStorage) {
+    await context.addInitScript((storage) => {
+      for (const { origin, sessionStorage } of storage) {
+        if (window.location.origin === origin) {
+          for (const item of sessionStorage) {
+            const value = window.sessionStorage.getItem(item.name);
+            if (!value) {
+              window.sessionStorage.setItem(item.name, item.value);
+            }
+          }
+        }
+      }
+    }, state.sessionStorage);
+  }
+  await page.close();
+}
+async function getStorageState(context) {
+  const result = {
+    cookies: [],
+    origins: []
+  };
+  const storageState = await context.storageState();
+  result.cookies = storageState.cookies;
+  result.origins = storageState.origins;
+  const sessionDataList = [];
+  const pages = await context.pages();
+  for (const page of pages) {
+    if (page.isClosed()) continue;
+    try {
+      const sessionData = await page.evaluate(() => {
+        const items = { ...window.sessionStorage };
+        return {
+          origin: window.location.origin,
+          sessionStorage: Object.entries(items).map(([name, value]) => ({
+            name,
+            value
+          }))
+        };
+      });
+      sessionDataList.push(sessionData);
+    } catch (error) {
+      console.error("Error getting sessionStorage:", error);
+    }
+  }
+  result["sessionStorage"] = sessionDataList;
+  return result;
+}
+
+// src/common/playwrightContext.ts
+var fs3 = __toESM(require("fs-extra"));
+var import_neverthrow5 = require("neverthrow");
+
+// src/common/setupContextHook.ts
+var import_neverthrow3 = require("neverthrow");
+
+// src/common/runApi/importUsingImportFunction.ts
+var import_neverthrow2 = require("neverthrow");
+var import_runtime_interface = __toESM(require_dist());
+async function importUsingImportFunction({
+  path: path3,
+  allowGenerators = true,
+  importFunction
+}) {
+  try {
+    const importedResult = await importFunction(path3);
+    if (importedResult.isErr()) {
+      if (importedResult.error.type === "not_found") {
+        return (0, import_neverthrow2.err)(new import_runtime_interface.ApiNotFoundError(path3));
+      }
+      return (0, import_neverthrow2.err)(new import_runtime_interface.AutomationError(importedResult.error.error));
+    }
+    const imported = importedResult.value;
+    if (!imported || !imported.default || !imported.default.constructor) {
+      return (0, import_neverthrow2.err)(new import_runtime_interface.InvalidApiError(`${path3} does not have a default export`));
+    }
+    if (imported.default.constructor.name === "AsyncGeneratorFunction") {
+      if (!allowGenerators) {
+        return (0, import_neverthrow2.err)(
+          new import_runtime_interface.InvalidApiError(
+            `${path3} default export must be an async function`
+          )
+        );
+      }
+      return (0, import_neverthrow2.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 (0, import_neverthrow2.ok)(imported.default);
+    }
+    return (0, import_neverthrow2.err)(
+      new import_runtime_interface.InvalidApiError(`${path3} default export must be an async function`)
+    );
+  } catch (error) {
+    return (0, import_neverthrow2.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 (0, import_neverthrow3.ok)(null);
+  }
+  return importedFunctionResult;
+}
+
+// src/common/playwrightContext.ts
+var import_portfinder2 = require("portfinder");
+
+// src/common/launchBrowser.ts
+var playwright = __toESM(require("playwright"));
+var import_fs_extra2 = require("fs-extra");
+var import_path2 = require("path");
+var fs2 = __toESM(require("fs-extra"));
+var import_wait_on = __toESM(require("wait-on"));
+var import_child_process = require("child_process");
+var import_util = require("util");
+var import_neverthrow4 = require("neverthrow");
+var import_zod3 = require("zod");
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+async function createUserDirWithPreferences() {
+  const playwrightTempDir = await (0, import_fs_extra2.mkdtemp)("/tmp/pw-");
+  const userDir = (0, import_path2.join)(playwrightTempDir, "userdir");
+  const defaultDir = (0, import_path2.join)(userDir, "Default");
+  await (0, import_fs_extra2.mkdir)(defaultDir, {
+    recursive: true
+  });
+  const preferences = {
+    plugins: {
+      always_open_pdf_externally: true
+    }
+  };
+  await (0, import_fs_extra2.writeFile)((0, import_path2.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 fs2.realpath(executablePath);
+    if (!await fs2.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 (0, import_fs_extra2.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 (0, import_neverthrow4.err)(
+      `Failed to fetch CDP version from ${cdpAddress}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!response.ok) {
+    return (0, import_neverthrow4.err)(
+      `Failed to get CDP WebSocket URL from ${cdpAddress}: ${response.status} ${response.statusText}`
+    );
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (error) {
+    return (0, import_neverthrow4.err)(
+      `Invalid CDP version response from ${cdpAddress}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const cdpJsonVersionResponseSchema = import_zod3.z.object({
+    webSocketDebuggerUrl: import_zod3.z.string().url()
+  });
+  const parseResult = cdpJsonVersionResponseSchema.safeParse(data);
+  if (!parseResult.success) {
+    return (0, import_neverthrow4.err)(
+      `Invalid CDP version response from ${cdpAddress}: ${JSON.stringify(
+        parseResult.error.format()
+      )}`
+    );
+  }
+  return (0, import_neverthrow4.ok)(parseResult.data.webSocketDebuggerUrl);
+}
+async function waitOnCdpAddress(cdpAddress) {
+  const cdpAddressWithoutProtocol = cdpAddress.replace("http://", "").replace("https://", "").replace("localhost", "127.0.0.1");
+  await (0, import_wait_on.default)({
+    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());
+async function withPlaywrightContext({
+  cdpAddress,
+  cdpTargetId,
+  proxy,
+  headless = true,
+  downloadsPath,
+  importFunction,
+  apiName,
+  apiParameters
+}, fn) {
+  let context;
+  let page;
+  try {
+    const setupContextHookResult = importFunction ? await loadSetupContextHook({
+      importFunction
+    }) : (0, import_neverthrow5.ok)(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 (0, import_portfinder2.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 (0, import_neverthrow5.err)(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: (0, import_neverthrow5.err)(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 fs3.readJson(fullPath);
+  }
+  await setStorageState(context, sessionToLoad);
+}
+
+// src/common/formatZodError.ts
+function formatZodError(zodError) {
+  const formattedErrors = zodError.errors.map((error) => {
+    const path3 = error.path.map((segment) => {
+      return typeof segment === "number" ? `[${segment}]` : segment;
+    }).join(".");
+    if (path3) {
+      return `${path3} is invalid - ${error.message}`;
+    }
+    return error.message;
+  });
+  return formattedErrors;
+}
+
+// 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 (0, import_neverthrow6.err)(
+      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((resolve2) => {
+    if (!abortSignal) return;
+    abortSignal.addEventListener("abort", () => {
+      resolve2(abortSymbol);
+    });
+  });
+  async function runAutomation() {
+    const validatedModuleResult = await importUsingImportFunction({
+      path: name,
+      importFunction
+    });
+    if (validatedModuleResult.isErr()) {
+      return (0, import_neverthrow6.err)(validatedModuleResult.error);
+    }
+    const automationFunction = validatedModuleResult.value;
+    if (auth && auth.session.type === "state") {
+      const state = auth.session.state;
+      if (state === void 0 || state === null) {
+        return (0, import_neverthrow6.err)(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 (0, import_fs_extra3.remove)(tracing.filePath);
+        }
+      }
+      if (auth) {
+        await loadSessionToContext({
+          context,
+          session: auth.session
+        });
+        if (intunedContext && auth.parameters) {
+          intunedContext.getAuthSessionParameters = async () => auth.parameters;
+        }
+      }
+      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 (0, import_neverthrow6.err)(
+            new import_runtime_interface4.ResultTooBigError(resultSizeInBytes, MAX_RESULT_SIZE_BYTES)
+          );
+        }
+        if (retrieveSession) {
+          return (0, import_neverthrow6.ok)({
+            result: automationFunctionResult,
+            extendedPayloads: intunedContext?.extendedPayloads,
+            session: await getStorageState(context)
+          });
+        }
+        return (0, import_neverthrow6.ok)({
+          result: automationFunctionResult,
+          extendedPayloads: intunedContext?.extendedPayloads
+        });
+      } catch (error) {
+        return (0, import_neverthrow6.err)(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 fs4.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 (0, import_neverthrow6.err)(new import_runtime_interface4.AbortedError());
+  }
+  return result;
+}
+
+// src/commands/api/run.ts
+var import_runtime_interface5 = __toESM(require_dist());
+
+// src/commands/common/tsNodeImport.ts
+var import_neverthrow7 = require("neverthrow");
+var tsNodeImport = async (apiName) => {
+  require("ts-node").register({
+    transpileOnly: true,
+    compilerOptions: {
+      lib: ["dom", "es2020"]
+    }
+  });
+  const path3 = getFullPathInProject(...apiName.split("/"));
+  try {
+    const imported = await Promise.resolve().then(() => require(path3));
+    return (0, import_neverthrow7.ok)(imported);
+  } catch (e) {
+    if ("code" in e && e.code.includes("MODULE_NOT_FOUND")) {
+      if ("requireStack" in e && Array.isArray(e.requireStack)) {
+        const isStackTopThisFile = e.requireStack[0] === __filename;
+        if (!isStackTopThisFile) {
+          return (0, import_neverthrow7.err)({
+            type: "other",
+            error: e
+          });
+        }
+      }
+      return (0, import_neverthrow7.err)({
+        type: "not_found"
+      });
+    }
+    return (0, import_neverthrow7.err)({
+      type: "other",
+      error: e
+    });
+  }
+};
+
+// src/commands/api/run.ts
+var import_isNil = __toESM(require("lodash/isNil"));
+import_dotenv2.default.config({
+  path: `.env`
+});
+async function executeCLI(apiName, mode, inputData, options) {
+  cleanEnvironmentVariables();
+  let authSessionPathToUse = null;
+  const settings = await getSettings();
+  if (settings.authSessions.enabled) {
+    if (!options.authSessionPath) {
+      throw new Error(
+        "AuthSessions are enabled but no AuthSession provided.\nPlease provide --auth-session-path option.\nSee https://docs.intunedhq.com/docs/cli/auth-sessions for more information."
+      );
+    }
+    authSessionPathToUse = options.authSessionPath;
+  } else {
+    if (options.authSessionPath) {
+      throw new Error(
+        "Authentication is not enabled but AuthSession was provided.\nEnable AuthSessions in Intuned.json to use this feature.\nSee https://docs.intunedhq.com/docs/cli/auth-sessions for more information."
+      );
+    }
+  }
+  const runApiResult = await runApi({
+    automationFunction: {
+      name: `${API_FOLDER_NAME}/${apiName}`,
+      params: inputData
+    },
+    auth: authSessionPathToUse ? {
+      session: {
+        type: "file",
+        path: authSessionPathToUse
+      }
+    } : void 0,
+    runOptions: {
+      environment: "cdp",
+      cdpAddress: options.cdpAddress
+    },
+    importFunction: tsNodeImport
+  });
+  if (runApiResult.isErr()) {
+    if (runApiResult.error instanceof import_runtime_interface5.AutomationError) {
+      throw runApiResult.error.error;
+    }
+    console.error(runApiResult.error);
+    throw new Error("An error occurred while running the API");
+  }
+  const { result, extendedPayloads: payloadToAppend } = runApiResult.value;
+  const resultsDir = "/tmp/run-results";
+  if (options.outputFileId) {
+    logger.info(
+      import_chalk2.default.underline.bgBlue.white(
+        `Click to Open: Results saved (Run: ${options.outputFileId})`
+      )
+    );
+    fs5.ensureDirSync(resultsDir);
+    const path3 = `${resultsDir}/${options.outputFileId}.json`;
+    await fs5.writeJson(
+      path3,
+      {
+        input: inputData,
+        output: result
+      },
+      {
+        spaces: 2
+      }
+    );
+  } else {
+    console.log("result:", result);
+  }
+  const hasPayloadToAppend = payloadToAppend && payloadToAppend.length > 0;
+  if (hasPayloadToAppend && options.outputFileId) {
+    logger.info(
+      import_chalk2.default.underline.bgBlue.white(
+        `Click to Open: payloads to append (Run: ${options.outputFileId})`
+      )
+    );
+    fs5.ensureDirSync(resultsDir);
+    const path3 = `${resultsDir}/${options.outputFileId}-payloads-to-append.json`;
+    await fs5.writeJson(path3, payloadToAppend, {
+      spaces: 2
+    });
+  } else if (hasPayloadToAppend) {
+    logger.info("payload to append:", payloadToAppend);
+    logger.info(
+      "This will only take an effect if this API run was part of a job."
+    );
+  }
+}
+import_commander.program.description("run the user function in the cli for testing purposes").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option(
+  "--authSessionPath <authSession>",
+  "AuthSession to use when executing the api"
+).option(
+  "--outputFileId <outputFileId>",
+  "the output file id to save the result in"
+).option("--proxy <proxy>", "proxy to use").option(
+  "--authSessionParameters <authSessionParameters>",
+  "parameters used to create the used AuthSession"
+).argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(
+  new import_commander.Argument("<mode>", "mode of execution").choices([
+    "vanilla",
+    "playwright",
+    "playwright-standalone",
+    "playwright-headless"
+  ]).default("playwright-standalone").argOptional()
+).action(async (apiName, mode, options) => {
+  let inputData = null;
+  if (options.input) {
+    inputData = await fs5.readJSON(options.input);
+  } else if (options.json) {
+    inputData = JSON.parse(options.json);
+  } else {
+    inputData = {};
+  }
+  let authSessionParametersJson = void 0;
+  if (!(0, import_isNil.default)(options?.authSessionParameters)) {
+    authSessionParametersJson = JSON.parse(options.authSessionParameters);
+  }
+  await runWithContext(
+    {
+      runEnvironment: "IDE" /* IDE */,
+      extendedPayloads: [],
+      runId: (0, import_nanoid.nanoid)(),
+      proxy: options.proxy,
+      getAuthSessionParameters: authSessionParametersJson !== void 0 ? async () => authSessionParametersJson : void 0
+    },
+    () => executeCLI(apiName, mode, inputData, options)
+  );
+  process.exit(0);
+});
+import_commander.program.parse(process.argv);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeCLI
+});