@intuned/runtime-dev 1.3.18-interface.13 → 1.3.18-interface.16

package/dist/commands/interface/run.js

@@ -1,2061 +1,170 @@
-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;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAutomationCLI = runAutomationCLI;
+var _commander = require("commander");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _asyncLocalStorage = require("../../common/asyncLocalStorage");
+var _runApi = require("../../common/runApi");
+var _enums = require("../../runtime/enums");
+var _promises = require("timers/promises");
+var _jwtTokenManager = require("../../common/jwtTokenManager");
+var _formatZodError = require("../../common/formatZodError");
+var _neverthrow = require("neverthrow");
+var _getAuthSessionParameters = require("../../common/backendFunctions/getAuthSessionParameters");
+var _runtimeInterface = require("../../vendor/runtime-interface");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+_dotenv.default.config({
+  path: `.env`
+});
+function runAutomationCLI(importFunction) {
+  _commander.program.description("run user automation and communicate using unix socket").argument("<input>", "In unix socket mode: path to the unix socket. In jsonl mode: path to the jsonl file. In tcp socket mode: host:port").option("--mode [mode]", "Communication mode: unix, jsonl, or tcp").action(async (input, {
+    mode = "unix"
+  }) => {
+    let context;
+    const throttleTime = 60 * 1000;
+    let timeoutTimestamp = Date.now();
+    const client = createClient(mode, input);
+    const abortController = new AbortController();
+    const interruptSignalHandler = async () => {
+      abortController.abort();
+      await (0, _promises.setTimeout)(60_000);
+      await client.close();
+      process.exit(1);
+    };
+    process.on("SIGINT", interruptSignalHandler);
+    process.on("SIGTERM", interruptSignalHandler);
+    const messagesGenerator = client.receiveJSON();
+    async function receiveMessages() {
+      const data = await messagesGenerator.next();
+      if (data.done) {
+        return;
       }
-      get json() {
+      const inputParseResult = _runtimeInterface.runApiInputSchema.safeParse(data.value);
+      if (!inputParseResult.success) {
+        console.error("Validation error:", (0, _formatZodError.formatZodError)(inputParseResult.error));
         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
+          type: "error",
+          error: new _runtimeInterface.InternalInvalidInputError("Invalid input", (0, _formatZodError.formatZodError)(inputParseResult.error))
         };
       }
-    };
-    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 AutomationError4 = class extends RunAutomationError4 {
-      constructor(error) {
-        super(exports2.automationError, `[${error?.name ?? error}] ${error?.message}`);
-        this.details = {
-          ...error
-        };
-      }
-    };
-    exports2.AutomationError = AutomationError4;
-    var InternalInvalidInputError3 = class extends RunAutomationError4 {
-      constructor(message, details) {
-        super(exports2.internalInvalidInputErrorCode, message);
-        this.details = details;
-      }
-    };
-    exports2.InternalInvalidInputError = InternalInvalidInputError3;
-    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()
-      });
+      const input = inputParseResult.data;
+      return input;
     }
-    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 fs5 = __importStar(require("fs-extra"));
-    var readline_1 = require("readline");
-    var promises_1 = require("timers/promises");
-    var SocketClient = class _SocketClient {
-      constructor(socket) {
-        this.socket = socket;
+    let resultPromise = null;
+    async function handleMessage(message) {
+      if (message.type === "abort") {
+        abortController.abort();
+        return;
       }
-      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);
+      if (message.type === "tokenUpdate") {
+        _jwtTokenManager.backendFunctionsTokenManager.token = message.parameters.functionsToken;
+        return;
       }
-      async *receiveJSON() {
-        let buffer = Buffer.alloc(0);
-        const endPromise = new Promise((resolve2, reject) => {
-          this.socket.once("end", () => {
-            resolve2();
+      if (message.type === "start") {
+        context = {
+          extendedPayloads: [],
+          runEnvironment: message.parameters.runOptions.environment === "standalone" ? _enums.RunEnvironment.DEPLOYED : _enums.RunEnvironment.IDE,
+          timeoutInfo: {
+            extendTimeoutCallback: async () => {
+              if (Date.now() - timeoutTimestamp < throttleTime) return;
+              timeoutTimestamp = Date.now();
+              client.sendJSON({
+                type: "extend"
+              });
+            }
+          },
+          getAuthSessionParameters: _getAuthSessionParameters.getAuthSessionParameters,
+          ...(message.parameters.context ?? {}),
+          proxy: getProxyUrlFromRunOptions(message.parameters.runOptions)
+        };
+        _jwtTokenManager.backendFunctionsTokenManager.token = message.parameters.functionsToken;
+        resultPromise = (0, _asyncLocalStorage.runWithContext)(context, async () => {
+          return await (0, _runApi.runApi)({
+            ...message.parameters,
+            abortSignal: abortController.signal,
+            importFunction: importFunction ?? _defaultImport
           });
-          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 UnixSocketClient2 = class extends SocketClient {
-      constructor(path3) {
-        super(net.createConnection(path3));
-      }
-    };
-    exports2.UnixSocketClient = UnixSocketClient2;
-    var TCPSocketClient2 = class extends SocketClient {
-      constructor(host, port) {
-        super(net.createConnection(port, host));
-      }
-    };
-    exports2.TCPSocketClient = TCPSocketClient2;
-    var JSONLFileClient2 = class {
-      constructor(filePath) {
-        this.fileStream = fs5.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 = JSONLFileClient2;
-  }
-});
-
-// ../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/interface/run.ts
-var run_exports = {};
-__export(run_exports, {
-  runAutomationCLI: () => runAutomationCLI
-});
-module.exports = __toCommonJS(run_exports);
-var import_commander = require("commander");
-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/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 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/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 z3 = __toESM(require("zod"));
-var baseCaptchaSchema = z3.object({
-  enabled: z3.boolean()
-});
-var customCaptchaSchema = baseCaptchaSchema.extend({
-  imageLocators: z3.array(z3.string()).min(1, "At least one image locator is required"),
-  submitLocators: z3.array(z3.string()).min(1, "At least one submit locator is required"),
-  inputLocators: z3.array(z3.string()).min(1, "At least one input locator is required")
-});
-var textCaptchaSchema = baseCaptchaSchema.extend({
-  labelLocators: z3.array(z3.string()).min(1, "At least one image locator is required"),
-  submitLocators: z3.array(z3.string()).min(1, "At least one submit locator is required"),
-  inputLocators: z3.array(z3.string()).min(1, "At least one input locator is required")
-});
-var captchaSolverSolveSettingsSchema = z3.object({
-  autoSolve: z3.boolean().default(true),
-  solveDelay: z3.number().min(0).default(2e3),
-  maxRetries: z3.number().min(0).default(3),
-  timeout: z3.number().min(0).default(3e4)
-});
-var captchaSolverSettingsSchema = z3.object({
-  enabled: z3.boolean().default(false),
-  port: z3.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 = z3.object({
-  enabled: z3.boolean()
-}).optional().default({
-  enabled: false
-});
-var stealthModeSchema = z3.object({
-  enabled: z3.boolean()
-}).optional().default({
-  enabled: false
-});
-var settingsSchema = z3.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/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
+    let receiveMessagesPromise = receiveMessages();
+    while (true) {
+      const messageOrResult = await Promise.race([receiveMessagesPromise.then(message => ({
+        type: "message",
+        message
+      })), ...(resultPromise ? [resultPromise.then(result => ({
+        type: "result",
+        result
+      }))] : [])]);
+      if (messageOrResult.type === "message") {
+        const {
+          message
+        } = messageOrResult;
+        if (message === undefined) {
+          break;
+        }
+        if (message.type === "error") {
+          client.sendJSON({
+            type: "done",
+            result: message.error.json,
+            success: false
           });
+          break;
         }
-        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
+        if (message.type === "ping") {
+          client.sendJSON({
+            type: "pong"
+          });
+          break;
+        }
+        await handleMessage(message);
+        receiveMessagesPromise = receiveMessages();
+        continue;
+      }
+      const {
+        result
+      } = messageOrResult;
+      const success = result.isOk();
+      const resultToSend = success ? result.value : result.error.json;
+      client.sendJSON({
+        type: "done",
+        result: resultToSend,
+        success
       });
-    } 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;
+      break;
     }
-    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;
+    if (!client.closed) {
+      await client.close();
     }
-    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;
+    process.exit(0);
   });
-  return formattedErrors;
-}
-
-// 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/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/interface/run.ts
-var import_promises3 = require("timers/promises");
-var import_neverthrow7 = require("neverthrow");
-
-// src/common/backendFunctions/getAuthSessionParameters.ts
-var import_isNil = __toESM(require("lodash/isNil"));
-var import_zod4 = require("zod");
-var authSessionParametersResponseSchema = import_zod4.z.object({
-  parameters: import_zod4.z.any().refine((v) => v !== void 0)
-});
-async function getAuthSessionParameters2() {
-  const context = getExecutionContext();
-  if (!context) {
-    throw new Error(
-      "getAuthSessionParameters failed due to an internal error (context was not found)."
-    );
-  }
-  const authSessionId = context.authSessionId;
-  if ((0, import_isNil.default)(authSessionId)) {
-    throw new Error("AuthSessions are not enabled");
-  }
-  const response = await callBackendFunctionWithToken(
-    `auth-session/${authSessionId}/parameters`,
-    {
-      method: "GET"
-    }
-  );
-  const body = await response.text();
-  if (!response.ok) {
-    throw new Error(
-      `getAuthSessionParameters failed with status ${response.status}: ${body}`
-    );
-  }
-  let json;
-  try {
-    json = JSON.parse(body);
-  } catch (e) {
-    throw new Error(`Expected JSON response, but got ${body}`);
-  }
-  return authSessionParametersResponseSchema.parse(json).parameters;
-}
-
-// src/commands/interface/run.ts
-var import_runtime_interface5 = __toESM(require_dist());
-import_dotenv2.default.config({
-  path: `.env`
-});
-function runAutomationCLI(importFunction) {
-  import_commander.program.description("run user automation and communicate using unix socket").argument(
-    "<input>",
-    "In unix socket mode: path to the unix socket. In jsonl mode: path to the jsonl file. In tcp socket mode: host:port"
-  ).option("--mode [mode]", "Communication mode: unix, jsonl, or tcp").action(
-    async (input, {
-      mode = "unix"
-    }) => {
-      let context;
-      const throttleTime = 60 * 1e3;
-      let timeoutTimestamp = Date.now();
-      const client = createClient(mode, input);
-      const abortController = new AbortController();
-      const interruptSignalHandler = async () => {
-        abortController.abort();
-        await (0, import_promises3.setTimeout)(6e4);
-        await client.close();
-        process.exit(1);
-      };
-      process.on("SIGINT", interruptSignalHandler);
-      process.on("SIGTERM", interruptSignalHandler);
-      const messagesGenerator = client.receiveJSON();
-      async function receiveMessages() {
-        const data = await messagesGenerator.next();
-        if (data.done) {
-          return;
-        }
-        const inputParseResult = import_runtime_interface5.runApiInputSchema.safeParse(data.value);
-        if (!inputParseResult.success) {
-          console.error(
-            "Validation error:",
-            formatZodError(inputParseResult.error)
-          );
-          return {
-            type: "error",
-            error: new import_runtime_interface5.InternalInvalidInputError(
-              "Invalid input",
-              formatZodError(inputParseResult.error)
-            )
-          };
-        }
-        const input2 = inputParseResult.data;
-        return input2;
-      }
-      let resultPromise = null;
-      async function handleMessage(message) {
-        if (message.type === "abort") {
-          abortController.abort();
-          return;
-        }
-        if (message.type === "tokenUpdate") {
-          backendFunctionsTokenManager.token = message.parameters.functionsToken;
-          return;
-        }
-        if (message.type === "start") {
-          context = {
-            extendedPayloads: [],
-            runEnvironment: message.parameters.runOptions.environment === "standalone" ? "DEPLOYED" /* DEPLOYED */ : "IDE" /* IDE */,
-            timeoutInfo: {
-              extendTimeoutCallback: async () => {
-                if (Date.now() - timeoutTimestamp < throttleTime) return;
-                timeoutTimestamp = Date.now();
-                client.sendJSON({ type: "extend" });
-              }
-            },
-            getAuthSessionParameters: getAuthSessionParameters2,
-            ...message.parameters.context ?? {},
-            proxy: getProxyUrlFromRunOptions(message.parameters.runOptions)
-          };
-          backendFunctionsTokenManager.token = message.parameters.functionsToken;
-          resultPromise = runWithContext(context, async () => {
-            return await runApi({
-              ...message.parameters,
-              abortSignal: abortController.signal,
-              importFunction: importFunction ?? _defaultImport
-            });
-          });
-          return;
-        }
-      }
-      let receiveMessagesPromise = receiveMessages();
-      while (true) {
-        const messageOrResult = await Promise.race([
-          receiveMessagesPromise.then((message) => ({
-            type: "message",
-            message
-          })),
-          ...resultPromise ? [
-            resultPromise.then((result2) => ({
-              type: "result",
-              result: result2
-            }))
-          ] : []
-        ]);
-        if (messageOrResult.type === "message") {
-          const { message } = messageOrResult;
-          if (message === void 0) {
-            break;
-          }
-          if (message.type === "error") {
-            client.sendJSON({
-              type: "done",
-              result: message.error.json,
-              success: false
-            });
-            break;
-          }
-          if (message.type === "ping") {
-            client.sendJSON({
-              type: "pong"
-            });
-            break;
-          }
-          await handleMessage(message);
-          receiveMessagesPromise = receiveMessages();
-          continue;
-        }
-        const { result } = messageOrResult;
-        const success = result.isOk();
-        const resultToSend = success ? result.value : result.error.json;
-        client.sendJSON({
-          type: "done",
-          result: resultToSend,
-          success
-        });
-        break;
-      }
-      if (!client.closed) {
-        await client.close();
-      }
-      process.exit(0);
-    }
-  );
-  import_commander.program.parse(process.argv);
+  _commander.program.parse(process.argv);
 }
 function getProxyUrlFromRunOptions(runOptions) {
-  if (runOptions?.environment !== "standalone") return void 0;
+  if (runOptions?.environment !== "standalone") return undefined;
   const proxy = runOptions.proxy;
-  if (!proxy) return void 0;
+  if (!proxy) return undefined;
   const url = new URL(proxy.server);
   url.username = proxy.username;
   url.password = proxy.password;
   return url.toString();
 }
-var _defaultImport = async (path3) => {
+const _defaultImport = async path => {
   try {
-    const imported = await Promise.resolve().then(() => require(`${process.cwd()}/${path3}`));
-    return (0, import_neverthrow7.ok)(imported);
+    const imported = await (specifier => new Promise(r => r(specifier)).then(s => _interopRequireWildcard(require(s))))(`${process.cwd()}/${path}`);
+    return (0, _neverthrow.ok)(imported);
   } catch (e) {
     if ("code" in e && e.code === "MODULE_NOT_FOUND" || e.code === "ERR_MODULE_NOT_FOUND") {
-      return (0, import_neverthrow7.err)({
+      return (0, _neverthrow.err)({
         type: "not_found"
       });
     }
-    return (0, import_neverthrow7.err)({
+    return (0, _neverthrow.err)({
       type: "other",
       error: e
     });
@@ -2063,7 +172,7 @@ var _defaultImport = async (path3) => {
 };
 function createClient(mode, input) {
   if (mode === "jsonl") {
-    return new import_runtime_interface5.JSONLFileClient(input);
+    return new _runtimeInterface.JSONLFileClient(input);
   }
   if (mode === "tcp") {
     const [host, portString] = input.split(":");
@@ -2071,14 +180,10 @@ function createClient(mode, input) {
     if (!host || isNaN(port)) {
       throw new Error("Invalid tcp input, expected format host:port");
     }
-    return new import_runtime_interface5.TCPSocketClient(host, port);
+    return new _runtimeInterface.TCPSocketClient(host, port);
   }
-  return new import_runtime_interface5.UnixSocketClient(input);
+  return new _runtimeInterface.UnixSocketClient(input);
 }
 if (require.main === module) {
   runAutomationCLI();
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  runAutomationCLI
-});
+}