@intuned/runtime-dev 1.3.18-interface.2 → 1.3.18-interface.21

package/dist/common/asyncLocalStorage/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Payload, RunInfo } from "../../runtime/export";
+export declare const asyncLocalStorage: AsyncLocalStorage<InternalRunInfo>;
+export declare function runWithContext<R, TArgs extends any[]>(contextData: InternalRunInfo, callback: (...args: TArgs) => R, ...args: TArgs): R;
+interface TimeoutInfo {
+    extendTimeoutCallback?: () => Promise<void>;
+}
+export interface InternalRunInfo extends RunInfo {
+    extendedPayloads: Payload[];
+    timeoutInfo?: TimeoutInfo;
+    store?: Record<string, any>;
+    getAuthSessionParameters?: () => Promise<any>;
+}
+export declare function getExecutionContext(): InternalRunInfo | undefined;
+export {};

package/dist/common/asyncLocalStorage/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asyncLocalStorage = void 0;
+exports.getExecutionContext = getExecutionContext;
+exports.runWithContext = runWithContext;
+var _nodeAsync_hooks = require("node:async_hooks");
+const asyncLocalStorage = exports.asyncLocalStorage = new _nodeAsync_hooks.AsyncLocalStorage();
+function runWithContext(contextData, callback, ...args) {
+  return asyncLocalStorage.run(contextData, callback, ...args);
+}
+function getExecutionContext() {
+  const contextData = asyncLocalStorage.getStore();
+  return contextData;
+}

package/dist/common/backendFunctions/getAuthSessionParameters.d.ts

@@ -0,0 +1 @@
+export declare function getAuthSessionParameters(): Promise<any>;

package/dist/common/backendFunctions/getAuthSessionParameters.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAuthSessionParameters = getAuthSessionParameters;
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+var _asyncLocalStorage = require("../asyncLocalStorage");
+var _zod = require("zod");
+var _jwtTokenManager = require("../jwtTokenManager");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const authSessionParametersResponseSchema = _zod.z.object({
+  parameters: _zod.z.any().refine(v => v !== undefined)
+});
+async function getAuthSessionParameters() {
+  const context = (0, _asyncLocalStorage.getExecutionContext)();
+  if (!context) {
+    throw new Error("getAuthSessionParameters failed due to an internal error (context was not found).");
+  }
+  const authSessionId = context.authSessionId;
+  if ((0, _isNil.default)(authSessionId)) {
+    throw new Error("AuthSessions are not enabled");
+  }
+  const response = await (0, _jwtTokenManager.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;
+}

package/dist/common/binStartupScript.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/common/binStartupScript.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var path = _interopRequireWildcard(require("path"));
+var _intunedJson = require("./intunedJson");
+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); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+function isStealthModeEnabled() {
+  try {
+    const settingsResult = (0, _intunedJson.loadIntunedJsonSync)();
+    if (settingsResult.isErr()) {
+      console.error(`Warning: Failed to load Intuned settings: ${settingsResult.error}
+Stealth mode will not be enabled.`);
+      return false;
+    }
+    return settingsResult.value.stealthMode?.enabled === true;
+  } catch (error) {
+    console.error("Error reading Intuned.json:", error.message);
+    return false;
+  }
+}
+try {
+  if (isStealthModeEnabled()) {
+    const currentNodeModules = path.resolve(process.cwd(), "node_modules");
+    process.env.NODE_PATH = process.env.NODE_PATH ? `${process.env.NODE_PATH}:${currentNodeModules}` : currentNodeModules;
+    require("module").Module._initPaths();
+    if (process.env.PLAYWRIGHT_PATCH_SCRIPT_PATH) {
+      require(process.env.PLAYWRIGHT_PATCH_SCRIPT_PATH);
+    }
+  }
+} catch (e) {
+  console.error("Failed to apply stealth mode");
+}

package/dist/common/browserTabs.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Tab management utilities using CDP HTTP API.
+ *
+ * Provides functions to interact with browser tabs via Chrome DevTools Protocol HTTP endpoints.
+ * Refer to https://chromedevtools.github.io/devtools-protocol/ for the endpoints documentation.
+ * This approach is simpler than using the playwright API because it doesn't require us to create a playwright context.
+ */
+export interface CDPTabInfo {
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+    webSocketDebuggerUrl?: string;
+    devtoolsFrontendUrl?: string;
+    faviconUrl?: string;
+    description?: string;
+}
+/**
+ * Fetch current tabs from CDP /json endpoint.
+ *
+ * @param cdpAddress - CDP address (e.g., "http://localhost:9222")
+ * @returns List of tab info dictionaries from CDP (filtered to only "page" type)
+ *
+ * @example
+ * const tabs = await getCDPTabs("http://localhost:9222");
+ * // Returns:
+ * // [
+ * //   {
+ * //     "id": "1234",
+ * //     "type": "page",
+ * //     "title": "Google",
+ * //     "url": "https://google.com",
+ * //     ...
+ * //   }
+ * // ]
+ */
+export declare function getCDPTabs(cdpAddress: string): Promise<CDPTabInfo[]>;
+/**
+ * Create new tab via CDP /json/new endpoint with optional URL.
+ *
+ * @param cdpAddress - CDP address (e.g., "http://localhost:9222")
+ * @param url - Initial URL for the tab (default: "about:blank")
+ * @returns Tab info dictionary from CDP
+ *
+ * @example
+ * const tab = await createCDPTab("http://localhost:9222", "https://google.com");
+ * // Returns:
+ * // {
+ * //   "id": "1234",
+ * //   "type": "page",
+ * //   "title": "New Tab",
+ * //   "url": "about:blank",
+ * //   ...
+ * // }
+ */
+export declare function createCDPTab(cdpAddress: string, url?: string): Promise<CDPTabInfo>;
+/**
+ * Close tab via CDP /json/close/{id} endpoint.
+ *
+ * @param cdpAddress - CDP address (e.g., "http://localhost:9222")
+ * @param cdpTargetId - Full CDP target ID to close
+ * @returns True if successful, False otherwise
+ */
+export declare function closeCDPTab(cdpAddress: string, cdpTargetId: string): Promise<boolean>;
+/**
+ * Activate/bring to front a tab via CDP /json/activate/{id} endpoint.
+ *
+ * @param cdpAddress - CDP address (e.g., "http://localhost:9222")
+ * @param cdpTargetId - Full CDP target ID to activate
+ * @returns True if successful, False otherwise
+ */
+export declare function activateCDPTab(cdpAddress: string, cdpTargetId: string): Promise<boolean>;

package/dist/common/browserTabs.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.activateCDPTab = activateCDPTab;
+exports.closeCDPTab = closeCDPTab;
+exports.createCDPTab = createCDPTab;
+exports.getCDPTabs = getCDPTabs;
+const DEFAULT_TIMEOUT = 5000;
+async function getCDPTabs(cdpAddress) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+  try {
+    const response = await fetch(`${cdpAddress}/json`, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const tabs = await response.json();
+    return tabs.filter(tab => tab.type === "page");
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function createCDPTab(cdpAddress, url = "about:blank") {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+  try {
+    let endpoint = `${cdpAddress}/json/new`;
+    if (url && url !== "about:blank") {
+      endpoint = `${endpoint}?${url}`;
+    }
+    const response = await fetch(endpoint, {
+      method: "PUT",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    return await response.json();
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function closeCDPTab(cdpAddress, cdpTargetId) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+  try {
+    const response = await fetch(`${cdpAddress}/json/close/${cdpTargetId}`, {
+      signal: controller.signal
+    });
+    return response.status === 200;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function activateCDPTab(cdpAddress, cdpTargetId) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
+  try {
+    const response = await fetch(`${cdpAddress}/json/activate/${cdpTargetId}`, {
+      signal: controller.signal
+    });
+    return response.status === 200;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

package/dist/common/cleanEnvironmentVariables.d.ts

@@ -0,0 +1 @@
+export declare function cleanEnvironmentVariables(): void;

package/dist/common/cleanEnvironmentVariables.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanEnvironmentVariables = cleanEnvironmentVariables;
+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]);
+}

package/dist/common/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const API_FOLDER_NAME = "api";
+export declare const AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
+export declare const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+export declare const WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+export declare const EXTENSION_PATH_ENV_VAR_KEY = "INTUNED_EXTENSION_PATH";
+export declare const PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+export declare const API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";
+export declare const AUTH_TOKEN_ENV_VAR_KEY = "INTUNED_AUTH_TOKEN";
+export declare const API_KEY_HEADER_NAME = "x-api-key";
+export declare const API_BASE_URL_ENV_VAR_KEY = "INTUNED_API_BASE_URL";
+export declare const CLI_ENV_VAR_KEY = "INTUNED_CLI";

package/dist/common/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WORKSPACE_ID_ENV_VAR_KEY = exports.PROJECT_ID_ENV_VAR_KEY = exports.EXTENSION_PATH_ENV_VAR_KEY = exports.CLI_ENV_VAR_KEY = exports.AUTH_TOKEN_ENV_VAR_KEY = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = exports.API_KEY_HEADER_NAME = exports.API_KEY_ENV_VAR_KEY = exports.API_FOLDER_NAME = exports.API_BASE_URL_ENV_VAR_KEY = void 0;
+const API_FOLDER_NAME = exports.API_FOLDER_NAME = "api";
+const AUTH_SESSIONS_FOLDER_NAME = exports.AUTH_SESSIONS_FOLDER_NAME = "auth-sessions";
+const AUTH_SESSIONS_INSTANCES_FOLDER_NAME = exports.AUTH_SESSIONS_INSTANCES_FOLDER_NAME = "auth-sessions-instances";
+const WORKSPACE_ID_ENV_VAR_KEY = exports.WORKSPACE_ID_ENV_VAR_KEY = "INTUNED_WORKSPACE_ID";
+const EXTENSION_PATH_ENV_VAR_KEY = exports.EXTENSION_PATH_ENV_VAR_KEY = "INTUNED_EXTENSION_PATH";
+const PROJECT_ID_ENV_VAR_KEY = exports.PROJECT_ID_ENV_VAR_KEY = "INTUNED_PROJECT_ID";
+const API_KEY_ENV_VAR_KEY = exports.API_KEY_ENV_VAR_KEY = "INTUNED_API_KEY";
+const AUTH_TOKEN_ENV_VAR_KEY = exports.AUTH_TOKEN_ENV_VAR_KEY = "INTUNED_AUTH_TOKEN";
+const API_KEY_HEADER_NAME = exports.API_KEY_HEADER_NAME = "x-api-key";
+const API_BASE_URL_ENV_VAR_KEY = exports.API_BASE_URL_ENV_VAR_KEY = "INTUNED_API_BASE_URL";
+const CLI_ENV_VAR_KEY = exports.CLI_ENV_VAR_KEY = "INTUNED_CLI";

package/dist/common/contextStorageStateHelpers.d.ts

@@ -0,0 +1,22 @@
+import type * as playwright from "playwright";
+import type { RunApiStorageState } from "@intuned/runtime-interface";
+interface StorageEntry {
+    name: string;
+    value: string;
+}
+interface LocalStorageState {
+    origin: string;
+    localStorage: StorageEntry[];
+}
+interface SessionStorageState {
+    origin: string;
+    sessionStorage: StorageEntry[];
+}
+export interface StorageState {
+    cookies?: playwright.Cookie[] | null;
+    origins?: LocalStorageState[] | null;
+    sessionStorage?: SessionStorageState[] | null;
+}
+export declare function setStorageState(context: playwright.BrowserContext, state: RunApiStorageState): Promise<void>;
+export declare function getStorageState(context: playwright.BrowserContext): Promise<RunApiStorageState>;
+export {};

package/dist/common/contextStorageStateHelpers.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStorageState = getStorageState;
+exports.setStorageState = setStorageState;
+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;
+}

package/dist/common/extension/extensionsHelpers.d.ts

@@ -0,0 +1,11 @@
+import type * as playwright from "playwright";
+import { CaptchaSolverSettings, CaptchaSolverSettingsWithRunContext } from "../settingsSchema";
+export declare function resolveCaptchaSolverSettings(input?: unknown): Promise<CaptchaSolverSettings>;
+export declare function isIntunedExtensionLoaded(): boolean;
+export declare function buildExtensionsList(): string[];
+export declare function getIntunedExtensionPath(): string;
+export declare function isIntunedExtensionEnabled(): Promise<boolean>;
+export declare function getIntunedExtensionWorker(context: playwright.BrowserContext): Promise<playwright.Worker | null>;
+export declare function getIntunedExtensionSettings(captchaSolverSettings: CaptchaSolverSettings): Promise<CaptchaSolverSettingsWithRunContext>;
+export declare function getIntunedCaptchaSolverSettings(): Promise<CaptchaSolverSettings>;
+export declare function setupIntunedExtension(): Promise<void>;

package/dist/common/extension/extensionsHelpers.js

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildExtensionsList = buildExtensionsList;
+exports.getIntunedCaptchaSolverSettings = getIntunedCaptchaSolverSettings;
+exports.getIntunedExtensionPath = getIntunedExtensionPath;
+exports.getIntunedExtensionSettings = getIntunedExtensionSettings;
+exports.getIntunedExtensionWorker = getIntunedExtensionWorker;
+exports.isIntunedExtensionEnabled = isIntunedExtensionEnabled;
+exports.isIntunedExtensionLoaded = isIntunedExtensionLoaded;
+exports.resolveCaptchaSolverSettings = resolveCaptchaSolverSettings;
+exports.setupIntunedExtension = setupIntunedExtension;
+var _settings = require("../../commands/common/utils/settings");
+var _settingsSchema = require("../settingsSchema");
+var _constants = require("../constants");
+var _jwtTokenManager = require("../jwtTokenManager");
+var _path = _interopRequireDefault(require("path"));
+var _promises = require("fs/promises");
+var _intunedExtensionServer = require("./intunedExtensionServer");
+var _portfinder = require("portfinder");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const INTUNED_WORKER = "intunedWorker.js";
+const INTUNED_EXTENSION_SETTINGS_FILE_NAME = "intunedSettings.json";
+const INTUNED_CAPTCHA_EXTENSION_PORT_ENV_VAR = "INTUNED_CAPTCHA_EXTENSION_PORT";
+let captchaSolverSettings = null;
+async function getIntunedCaptchaExtensionPort() {
+  if (process.env.INTUNED_CAPTCHA_EXTENSION_PORT) {
+    return parseInt(process.env.INTUNED_CAPTCHA_EXTENSION_PORT, 10);
+  }
+  return await (0, _portfinder.getPort)({});
+}
+async function resolveCaptchaSolverSettings(input) {
+  const parsed = _settingsSchema.captchaSolverSettingsSchema.parse(input || {});
+  if (!parsed.port) {
+    parsed.port = await getIntunedCaptchaExtensionPort();
+  }
+  return parsed;
+}
+function getIntunedCaptchaExtensionPortFromEnv() {
+  const raw = process.env[INTUNED_CAPTCHA_EXTENSION_PORT_ENV_VAR];
+  if (!raw) return null;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`Invalid ${INTUNED_CAPTCHA_EXTENSION_PORT_ENV_VAR}: ${raw}`);
+  }
+  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 path = getIntunedExtensionPath();
+  if (!path) {
+    return false;
+  }
+  const captchaSolverSettings = await getIntunedCaptchaSolverSettings();
+  return captchaSolverSettings.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: 3000
+      });
+    } catch (err) {
+      console.log(`Error accessing service workers (attempt ${attemptCount})`);
+    }
+    attemptCount++;
+  }
+  console.error("Failed to get intuned worker after 5 attmepts");
+  return null;
+}
+async function getIntunedExtensionSettings(captchaSolverSettings) {
+  const [domain, workspaceId, projectId] = [process.env.FUNCTIONS_DOMAIN, process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY], process.env.INTUNED_INTEGRATION_ID ?? process.env[_constants.PROJECT_ID_ENV_VAR_KEY]];
+  if (!domain || !workspaceId || !projectId) {
+    const missingEnvVars = [domain && "FUNCTIONS_DOMAIN", workspaceId && _constants.WORKSPACE_ID_ENV_VAR_KEY, projectId && `INTUNED_INTEGRATION_ID OR ${_constants.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: _jwtTokenManager.backendFunctionsTokenManager.token
+    };
+  })();
+  const baseUrl = process.env.INTUNED_API_BASE_URL ?? domain;
+  return {
+    ...captchaSolverSettings,
+    workspaceId,
+    projectId,
+    baseUrl,
+    authentication
+  };
+}
+async function getIntunedCaptchaSolverSettings() {
+  if (captchaSolverSettings) {
+    return captchaSolverSettings;
+  }
+  const settings = await (0, _settings.getSettings)();
+  captchaSolverSettings = await resolveCaptchaSolverSettings(settings.captchaSolver);
+  return captchaSolverSettings;
+}
+async function setupIntunedExtension() {
+  if (!(await isIntunedExtensionEnabled())) {
+    return;
+  }
+  const intunedExtensionPath = getIntunedExtensionPath();
+  const intunedExtensionSettingsPath = _path.default.join(intunedExtensionPath, INTUNED_EXTENSION_SETTINGS_FILE_NAME);
+  const captchaSolverSettings = await getIntunedCaptchaSolverSettings();
+  await (0, _intunedExtensionServer.setupIntunedExtensionServer)(captchaSolverSettings);
+  const captchaSolverSettingsWithRunContext = await getIntunedExtensionSettings(captchaSolverSettings);
+  await (0, _promises.writeFile)(intunedExtensionSettingsPath, JSON.stringify(captchaSolverSettingsWithRunContext));
+}

package/dist/common/extension/intunedExtensionServer.d.ts

@@ -0,0 +1,24 @@
+import type * as playwright from "playwright";
+import { Captcha, CaptchaCallback, CaptchaStatus } from "./types";
+import { CaptchaSolverSettings } from "../settingsSchema";
+export declare class ExtensionServer {
+    private tabs;
+    private app;
+    constructor();
+    private getOrCreateTab;
+    handleUpsertCaptcha(captcha: Captcha): Promise<void>;
+    start({ port, host, }: {
+        port: number;
+        host?: string;
+    }): Promise<void>;
+    stop(): Promise<void>;
+    getCaptchas(page: playwright.Page, status?: CaptchaStatus): Promise<Captcha[]>;
+    subscribe(page: playwright.Page, handler: CaptchaCallback, status?: CaptchaStatus): Promise<void>;
+    unsubscribe(page: playwright.Page, handler: CaptchaCallback, status?: CaptchaStatus): Promise<void>;
+    removeTab(tabId: number): void;
+    getTabId(page: playwright.Page): Promise<number>;
+}
+export declare function getIntunedExtensionServer(): ExtensionServer;
+export declare function setupIntunedExtensionServer(captchaSolverSettings?: CaptchaSolverSettings): Promise<void>;
+export declare function cleanIntunedExtensionServer(): Promise<void>;
+export declare function getTabId(page: playwright.Page): Promise<number>;