@intuned/runtime 1.3.17 → 1.3.18-interface.7

package/dist/runtime/index.js

@@ -1,111 +1,802 @@
-"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  RunError: () => RunError,
+  attemptStore: () => attemptStore,
+  extendPayload: () => extendPayload,
+  extendTimeout: () => extendTimeout,
+  getAiGatewayConfig: () => getAiGatewayConfig,
+  getAuthSessionParameters: () => getAuthSessionParameters,
+  getDownloadDirectoryPath: () => getDownloadDirectoryPath,
+  onCaptchaEvent: () => onCaptchaEvent,
+  onceCaptchaEvent: () => onceCaptchaEvent,
+  pauseCaptchaSolver: () => pauseCaptchaSolver,
+  persistentStore: () => persistentStore,
+  removeCaptchaEventListener: () => removeCaptchaEventListener,
+  resumeCaptchaSolver: () => resumeCaptchaSolver,
+  runInfo: () => runInfo,
+  waitForCaptchaSolve: () => waitForCaptchaSolve,
+  withWaitForCaptchaSolve: () => withWaitForCaptchaSolve
 });
-Object.defineProperty(exports, "RunError", {
-  enumerable: true,
-  get: function () {
-    return _RunError.RunError;
+module.exports = __toCommonJS(runtime_exports);
+
+// src/common/asyncLocalStorage/index.ts
+var import_node_async_hooks = require("async_hooks");
+var asyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
+function getExecutionContext() {
+  const contextData = asyncLocalStorage.getStore();
+  return contextData;
+}
+
+// src/runtime/extendTimeout.ts
+function extendTimeout() {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error("extendTimeout failed due to an internal error.");
   }
-});
-Object.defineProperty(exports, "attemptStore", {
-  enumerable: true,
-  get: function () {
-    return _attemptStore.attemptStore;
+  const { timeoutInfo } = context;
+  if (!timeoutInfo) {
+    return;
   }
-});
-Object.defineProperty(exports, "extendPayload", {
-  enumerable: true,
-  get: function () {
-    return _extendPayload.extendPayload;
+  if (timeoutInfo.extendTimeoutCallback !== void 0) {
+    void timeoutInfo.extendTimeoutCallback().catch(() => void 0);
   }
-});
-Object.defineProperty(exports, "extendTimeout", {
-  enumerable: true,
-  get: function () {
-    return _extendTimeout.extendTimeout;
+}
+
+// src/runtime/extendPayload.ts
+function extendPayload(payload) {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error("extendPayload failed due to an internal error.");
   }
-});
-Object.defineProperty(exports, "getAiGatewayConfig", {
-  enumerable: true,
-  get: function () {
-    return _getAiGatewayConfig.getAiGatewayConfig;
+  const items = Array.isArray(payload) ? payload : [payload];
+  if (!context.extendedPayloads) {
+    context.extendedPayloads = [...items];
+    return;
   }
-});
-Object.defineProperty(exports, "getAuthSessionParameters", {
-  enumerable: true,
-  get: function () {
-    return _getAuthSessionParameters.getAuthSessionParameters;
+  context?.extendedPayloads.push(...items);
+  extendTimeout();
+}
+
+// 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;
   }
 });
-Object.defineProperty(exports, "getDownloadDirectoryPath", {
-  enumerable: true,
-  get: function () {
-    return _downloadDirectory.getDownloadDirectoryPath;
+
+// 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;
   }
-});
-Object.defineProperty(exports, "onCaptchaEvent", {
-  enumerable: true,
-  get: function () {
-    return _captcha.onCaptchaEvent;
+  get token() {
+    return this._token;
   }
-});
-Object.defineProperty(exports, "onceCaptchaEvent", {
-  enumerable: true,
-  get: function () {
-    return _captcha.onceCaptchaEvent;
+  // 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();
+    }
   }
-});
-Object.defineProperty(exports, "pauseCaptchaSolver", {
-  enumerable: true,
-  get: function () {
-    return _captcha.pauseCaptchaSolver;
+  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);
   }
-});
-Object.defineProperty(exports, "persistentStore", {
-  enumerable: true,
-  get: function () {
-    return _persistentStore.persistentStore;
+  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);
   }
-});
-Object.defineProperty(exports, "removeCaptchaEventListener", {
-  enumerable: true,
-  get: function () {
-    return _captcha.removeCaptchaEventListener;
+  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;
   }
-});
-Object.defineProperty(exports, "resumeCaptchaSolver", {
-  enumerable: true,
-  get: function () {
-    return _captcha.resumeCaptchaSolver;
+  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(path2, init) {
+  return backendFunctionsTokenManager.fetchWithToken(
+    `${backendFunctionsTokenManager.backendFunctionsBaseUrl}/${path2}`,
+    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);
+    }
   }
 });
-Object.defineProperty(exports, "runInfo", {
-  enumerable: true,
-  get: function () {
-    return _runInfo.runInfo;
+
+// src/runtime/getAuthSessionParameters.ts
+async function getAuthSessionParameters() {
+  const context = getExecutionContext();
+  if (!context) {
+    throw new Error(
+      "getAuthSessionParameters failed due to an internal error (context was not found)."
+    );
   }
+  const { getAuthSessionParameters: getAuthSessionParameters2 } = context;
+  if (!getAuthSessionParameters2) {
+    throw new Error(
+      "getAuthSessionParameters failed due to an internal error (helper was not found on context)."
+    );
+  }
+  return await getAuthSessionParameters2();
+}
+
+// src/runtime/runInfo.ts
+function runInfo() {
+  const context = getExecutionContext();
+  if (!context) {
+    return {
+      runEnvironment: "IDE" /* IDE */
+      // runType: RunType.SYNC,
+    };
+  }
+  const { extendedPayloads: _extendedPayloads, ...rest } = context;
+  return rest;
+}
+
+// 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()
 });
-Object.defineProperty(exports, "waitForCaptchaSolve", {
-  enumerable: true,
-  get: function () {
-    return _captcha.waitForCaptchaSolve;
+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
+]);
+var CaptchaSolveError = class extends Error {
+  constructor(message, error) {
+    super(message);
+    this.error = error;
+    this.name = "CaptchaSolveError";
+  }
+};
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
   }
+};
+
+// 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")
 });
-Object.defineProperty(exports, "withWaitForCaptchaSolve", {
-  enumerable: true,
-  get: function () {
-    return _captcha.withWaitForCaptchaSolve;
+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_portfinder = require("portfinder");
+var INTUNED_WORKER = "intunedWorker.js";
+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 getIntunedExtensionPath() {
+  return process.env.INTUNED_EXTENSION_PATH;
+}
+async function isIntunedExtensionEnabled() {
+  const path2 = getIntunedExtensionPath();
+  if (!path2) {
+    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 (err2) {
+      console.log(`Error accessing service workers (attempt ${attemptCount})`);
+    }
+    attemptCount++;
+  }
+  console.error("Failed to get intuned worker after 5 attmepts");
+  return null;
+}
+async function getIntunedCaptchaSolverSettings() {
+  if (captchaSolverSettings) {
+    return captchaSolverSettings;
+  }
+  const settings = await getSettings();
+  captchaSolverSettings = await resolveCaptchaSolverSettings(
+    settings.captchaSolver
+  );
+  return captchaSolverSettings;
+}
+
+// src/common/extension/intunedExtensionServer.ts
+var extensionServerSingleton = null;
+function getIntunedExtensionServer() {
+  if (!extensionServerSingleton) {
+    throw new Error("Intuned Extension Server is not initialized.");
+  }
+  return extensionServerSingleton;
+}
+
+// src/runtime/captcha.ts
+async function withWaitForCaptchaSolve(callback, options) {
+  const {
+    page,
+    timeoutInMs = 1e4,
+    settleDurationMs = 5e3,
+    waitForNetworkSettled = true
+  } = options;
+  console.error(
+    `Starting captcha solve wait (timeout=${timeoutInMs}ms, settleDuration=${settleDurationMs}ms, waitForNetworkSettled=${waitForNetworkSettled})`
+  );
+  const extensionServer = getIntunedExtensionServer();
+  let settledResolve = null;
+  let settledPromise = new Promise((resolve2) => {
+    settledResolve = resolve2;
+  });
+  let isTimeout = false;
+  let captchasAppeared = false;
+  let error = void 0;
+  let actionDone = false;
+  const getPendingCaptchas = async () => await extensionServer.getCaptchas(page, "solving");
+  const hasNoPendingCaptchas = async () => !captchasAppeared || (await getPendingCaptchas()).length === 0;
+  const maybeSettle = async () => {
+    if (await hasNoPendingCaptchas()) {
+      settledResolve?.();
+    }
+  };
+  const onCaptchaUpdate = async (_captcha) => {
+    const solvingCaptchas = await extensionServer.getCaptchas(page, "solving");
+    const errorCaptchas = await extensionServer.getCaptchas(page, "error");
+    console.error(
+      `Captcha update received: solving=${solvingCaptchas.length}, errors=${errorCaptchas.length}`
+    );
+    if (solvingCaptchas.length > 0) {
+      captchasAppeared = true;
+      console.error(
+        `Captchas detected: ${solvingCaptchas.map((c) => c.id).join(", ")}`
+      );
+    }
+    if (errorCaptchas.length > 0) {
+      error = errorCaptchas[0].error;
+      console.error(`Captcha error detected: ${error?.code}`);
+      await maybeSettle();
+      return;
+    }
+    if (solvingCaptchas.length === 0) {
+      console.error("No pending captchas, settling");
+      await maybeSettle();
+    }
+  };
+  const result = await callback(page);
+  actionDone = true;
+  if (waitForNetworkSettled) {
+    try {
+      await page.waitForLoadState("networkidle");
+    } catch (err2) {
+      console.error(`Failed to wait for networkidle. Error: ${err2}`);
+    }
+  }
+  const timeoutPromise = new Promise((resolve2) => {
+    setTimeout(() => {
+      isTimeout = true;
+      console.error("Captcha solve timeout reached");
+      settledResolve?.();
+      resolve2();
+    }, timeoutInMs);
+  });
+  await extensionServer.subscribe(page, onCaptchaUpdate);
+  try {
+    const initialPending = await getPendingCaptchas();
+    console.error(`Found ${initialPending.length} ongoing captchas`);
+    if (initialPending.length > 0) {
+      captchasAppeared = true;
+    }
+    await maybeSettle();
+    let shouldContinue = true;
+    while (shouldContinue) {
+      await Promise.race([settledPromise, timeoutPromise]);
+      console.error(
+        `Settled event received, waiting ${settleDurationMs}ms before checking`
+      );
+      await new Promise((r) => setTimeout(r, settleDurationMs));
+      if (error) {
+        console.error(`Raising captcha error: ${error.code}`);
+        throw new CaptchaSolveError(
+          `CAPTCHA Solve Error: ${error.code}`,
+          error
+        );
+      }
+      const noPendingCaptchas = await hasNoPendingCaptchas();
+      const pending = await getPendingCaptchas();
+      console.error(
+        `Check point: actionDone=${actionDone}, noPendingCaptchas=${noPendingCaptchas}, isTimeout=${isTimeout}, pendingCount=${pending.length}`
+      );
+      if (actionDone && noPendingCaptchas || isTimeout) {
+        if (isTimeout && !noPendingCaptchas) {
+          console.error(`Timeout with ${pending.length} pending captchas`);
+          throw new TimeoutError(
+            "CAPTCHA Solve timed out with pending captchas."
+          );
+        }
+        console.error("Captcha solve completed successfully");
+        shouldContinue = false;
+      } else {
+        console.error(
+          `Still have ${pending.length} pending captchas, waiting for more updates`
+        );
+        settledPromise = new Promise((resolve2) => {
+          settledResolve = resolve2;
+        });
+      }
+    }
+    return result;
+  } finally {
+    await extensionServer.unsubscribe(page, onCaptchaUpdate);
+  }
+}
+async function waitForCaptchaSolve(page, {
+  timeoutInMs = 1e4,
+  settleDurationMs = 5e3
+} = {}) {
+  await withWaitForCaptchaSolve(async () => void 0, {
+    page,
+    timeoutInMs,
+    settleDurationMs,
+    waitForNetworkSettled: false
+  });
+}
+async function removeCaptchaEventListener(page, status, f) {
+  const extensionServer = getIntunedExtensionServer();
+  await extensionServer.unsubscribe(page, f, status);
+}
+async function onCaptchaEvent(page, status, f) {
+  const extensionServer = getIntunedExtensionServer();
+  await extensionServer.subscribe(page, f, status);
+}
+async function onceCaptchaEvent(page, status, f) {
+  const extensionServer = getIntunedExtensionServer();
+  const oneTimeHandler = async (captcha) => {
+    await extensionServer.unsubscribe(page, oneTimeHandler, status);
+    await f(captcha);
+  };
+  await extensionServer.subscribe(page, oneTimeHandler, status);
+}
+async function setAutoSolve(context, enabled) {
+  const worker = await getIntunedExtensionWorker(context);
+  if (!worker) {
+    if (!enabled) {
+      return;
+    }
+    throw new Error("Intuned service worker not found");
+  }
+  await worker.evaluate(
+    `
+    (enabled) => new Promise((resolve, reject) => {
+      const updateSettings = () => {
+        if (chrome?.storage?.local) {
+          chrome.storage.local.get('settings', (result) => {
+            if (chrome.runtime.lastError) {
+              reject(new Error(chrome.runtime.lastError.message));
+              return;
+            }
+            const settings = result.settings || {};
+            if (!settings.settings) {
+              settings.settings = {};
+            }
+            settings.settings.autoSolve = enabled;
+            chrome.storage.local.set({ settings }, () => {
+              if (chrome.runtime.lastError) {
+                reject(new Error(chrome.runtime.lastError.message));
+              } else {
+                resolve(true);
+              }
+            });
+          });
+        } else {
+          setTimeout(updateSettings, 50);
+        }
+      };
+      updateSettings();
+    })
+  `,
+    enabled
+  );
+}
+async function pauseCaptchaSolver(context) {
+  if (!await isIntunedExtensionEnabled()) {
+    throw new Error(
+      "Intuned extension is not enabled. Cannot pause captcha solver."
+    );
+  }
+  await setAutoSolve(context, false);
+}
+async function resumeCaptchaSolver(context) {
+  if (!await isIntunedExtensionEnabled()) {
+    throw new Error(
+      "Intuned extension is not enabled. Cannot resume captcha solver."
+    );
+  }
+  await setAutoSolve(context, true);
+}
+
+// src/runtime/getAiGatewayConfig.ts
+function getAiGatewayConfig() {
+  const baseUrl = `${backendFunctionsTokenManager.backendFunctionsBaseUrl}/intuned-ai-gateway`;
+  const apiKey = backendFunctionsTokenManager.token ?? process.env[API_KEY_ENV_VAR_KEY] ?? "";
+  return { baseUrl, apiKey };
+}
+
+// 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 path2 = `/tmp/downloads/${context.runId}`;
+  (0, import_fs_extra.ensureDirSync)(path2, {
+    mode: 1533
+  });
+  return path2;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RunError,
+  attemptStore,
+  extendPayload,
+  extendTimeout,
+  getAiGatewayConfig,
+  getAuthSessionParameters,
+  getDownloadDirectoryPath,
+  onCaptchaEvent,
+  onceCaptchaEvent,
+  pauseCaptchaSolver,
+  persistentStore,
+  removeCaptchaEventListener,
+  resumeCaptchaSolver,
+  runInfo,
+  waitForCaptchaSolve,
+  withWaitForCaptchaSolve
 });
-var _extendPayload = require("./extendPayload");
-var _extendTimeout = require("./extendTimeout");
-var _attemptStore = require("./attemptStore");
-var _persistentStore = require("./persistentStore");
-var _getAuthSessionParameters = require("./getAuthSessionParameters");
-var _runInfo = require("./runInfo");
-var _RunError = require("./RunError");
-var _captcha = require("./captcha");
-var _getAiGatewayConfig = require("./getAiGatewayConfig");
-var _downloadDirectory = require("./downloadDirectory");
+//# sourceMappingURL=index.js.map