@intuned/runtime 1.3.14 → 1.3.16

package/dist/commands/intuned-cli/commands/run_authsession.command.d.ts

@@ -1,29 +1,29 @@
 import { Command } from "commander";
 export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodObject<{
     proxy: import("zod").ZodOptional<import("zod").ZodString>;
-    headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
     timeout: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodString>, import("ms").StringValue, string | undefined>, number, string | undefined>;
+    trace: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
     keepBrowserOpen: import("zod").ZodDefault<import("zod").ZodBoolean>;
     cdpUrl: import("zod").ZodOptional<import("zod").ZodString>;
-    trace: import("zod").ZodDefault<import("zod").ZodBoolean>;
     checkAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
     createAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, "strip", import("zod").ZodTypeAny, {
-    headless: boolean;
     timeout: number;
-    keepBrowserOpen: boolean;
     trace: boolean;
+    headless: boolean;
+    keepBrowserOpen: boolean;
     checkAttempts: number;
     createAttempts: number;
     proxy?: string | undefined;
     cdpUrl?: string | undefined;
 }, {
     proxy?: string | undefined;
-    headless?: boolean | undefined;
     timeout?: string | undefined;
+    trace?: boolean | undefined;
+    headless?: boolean | undefined;
     keepBrowserOpen?: boolean | undefined;
     cdpUrl?: string | undefined;
-    trace?: boolean | undefined;
     checkAttempts?: number | undefined;
     createAttempts?: number | undefined;
 }>;

package/dist/commands/intuned-cli/commands/types.d.ts

@@ -17,10 +17,10 @@ export declare const baseCommandOptionsSchema: z.ZodObject<{
     keepBrowserOpen: z.ZodDefault<z.ZodBoolean>;
     cdpUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    headless: boolean;
     timeout: number;
-    keepBrowserOpen: boolean;
     trace: boolean;
+    headless: boolean;
+    keepBrowserOpen: boolean;
     proxy?: string | undefined;
     cdpUrl?: string | undefined;
 }, {

package/dist/commands/intuned-cli/controller/authSession.d.ts

@@ -18,8 +18,8 @@ export declare function executeRunCreateAuthSessionCLI({ id, input, checkRetries
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -49,8 +49,8 @@ export declare function executeRunUpdateAuthSessionCLI({ id, input, checkRetries
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -78,8 +78,8 @@ export declare function executeAttemptCreateAuthSessionCLI({ id, input, ...rest
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -106,8 +106,8 @@ export declare function executeAttemptCheckAuthSessionCLI({ id, ...rest }: {
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -140,8 +140,8 @@ declare function runCreate({ authSessionInput, proxy, headless, timeout, traceId
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;
@@ -177,8 +177,8 @@ declare function runCreateWithRetries({ authSessionId, authSessionInput, retries
     cookies: {
         path: string;
         value: string;
-        name: string;
         domain: string;
+        name: string;
         expires: number;
         httpOnly: boolean;
         secure: boolean;

package/dist/commands/intuned-cli/helpers/auth.d.ts

@@ -8,8 +8,8 @@ export declare function loadAuthSessionInstance(authSessionId: string): Promise<
         cookies: {
             path: string;
             value: string;
-            name: string;
             domain: string;
+            name: string;
             expires: number;
             httpOnly: boolean;
             secure: boolean;

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

@@ -0,0 +1,11 @@
+import * 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>;

package/dist/common/extension/intunedExtensionServer.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExtensionServer = void 0;
+exports.cleanIntunedExtensionServer = cleanIntunedExtensionServer;
+exports.getIntunedExtensionServer = getIntunedExtensionServer;
+exports.getTabId = getTabId;
+exports.setupIntunedExtensionServer = setupIntunedExtensionServer;
+var _fastify = _interopRequireDefault(require("fastify"));
+var _types = require("./types");
+var _extensionsHelpers = require("./extensionsHelpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class TabCaptchaState {
+  constructor(tabId) {
+    this.tabId = tabId;
+    this.captchasById = 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);
+      }
+    }
+  }
+}
+class ExtensionServer {
+  app = null;
+  constructor() {
+    this.tabs = 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, _fastify.default)({
+      logger: false,
+      bodyLimit: 1_000_000
+    });
+    this.app.post("/state", async (request, reply) => {
+      try {
+        const result = _types.captchaSchema.safeParse(request.body);
+        if (!result.success) {
+          return reply.code(400).send({
+            error: "Invalid captcha payload",
+            details: result.error.flatten().fieldErrors
+          });
+        }
+        await this.handleUpsertCaptcha(result.data);
+        return reply.code(200).send({});
+      } catch (error) {
+        console.error("Error processing captcha state update:", error);
+        return reply.code(500).send({
+          error: "Internal server error",
+          message: error?.message ?? String(error)
+        });
+      }
+    });
+    this.app.setNotFoundHandler((_request, reply) => {
+      return reply.code(404).send({
+        error: "Not found"
+      });
+    });
+    await this.app.listen({
+      port,
+      host
+    });
+  }
+  async stop() {
+    if (!this.app) return;
+    const toClose = this.app;
+    this.app = null;
+    await toClose.close();
+  }
+  async getCaptchas(page, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return [];
+    const captchas = tab.getCaptchas();
+    if (!status) return captchas;
+    return captchas.filter(c => c.status === status && c.tabId === tabId);
+  }
+  async subscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.getOrCreateTab(tabId);
+    tab.subscribe({
+      handler,
+      status
+    });
+  }
+  async unsubscribe(page, handler, status) {
+    const tabId = await getTabId(page);
+    const tab = this.tabs.get(tabId);
+    if (!tab) return;
+    tab.unsubscribe(handler, status);
+  }
+  removeTab(tabId) {
+    this.tabs.delete(tabId);
+  }
+  async getTabId(page) {
+    return await getTabId(page);
+  }
+}
+exports.ExtensionServer = ExtensionServer;
+let extensionServerSingleton = null;
+function getIntunedExtensionServer() {
+  if (!extensionServerSingleton) {
+    throw new Error("Intuned Extension Server is not initialized.");
+  }
+  return extensionServerSingleton;
+}
+async function setupIntunedExtensionServer(captchaSolverSettings) {
+  if (!captchaSolverSettings) {
+    captchaSolverSettings = await (0, _extensionsHelpers.resolveCaptchaSolverSettings)();
+  }
+  if (!extensionServerSingleton) {
+    extensionServerSingleton = new ExtensionServer();
+  }
+  await extensionServerSingleton.start({
+    port: captchaSolverSettings.port ?? 9000
+  });
+}
+async function cleanIntunedExtensionServer() {
+  if (extensionServerSingleton) {
+    await extensionServerSingleton.stop();
+    extensionServerSingleton = null;
+  }
+}
+const TAB_ID_CACHE_KEY = "__INTUNED_CACHED_TAB_ID__";
+async function getTabId(page) {
+  const cached = page[TAB_ID_CACHE_KEY];
+  if (cached !== undefined && 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: 15_000
+    });
+    tabId = await page.evaluate("window.__INTUNED_TAB_ID__");
+  }
+  const numericTabId = Number(tabId);
+  page[TAB_ID_CACHE_KEY] = numericTabId;
+  return numericTabId;
+}