@intuned/runtime 1.3.17 → 1.3.18-interface.7

package/dist/common/runApi/types.js

@@ -1,73 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.runApiStorageStateSchema = exports.runApiSessionSchema = exports.runApiParametersSchema = void 0;
-var _zod = _interopRequireDefault(require("zod"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const runApiStorageStateSchema = exports.runApiStorageStateSchema = _zod.default.object({
-  cookies: _zod.default.array(_zod.default.object({
-    name: _zod.default.string(),
-    value: _zod.default.string(),
-    domain: _zod.default.string(),
-    path: _zod.default.string(),
-    expires: _zod.default.number(),
-    httpOnly: _zod.default.boolean(),
-    secure: _zod.default.boolean(),
-    sameSite: _zod.default.enum(["Strict", "Lax", "None"])
-  })),
-  origins: _zod.default.array(_zod.default.object({
-    origin: _zod.default.string(),
-    localStorage: _zod.default.array(_zod.default.object({
-      name: _zod.default.string(),
-      value: _zod.default.string()
-    }))
-  })),
-  sessionStorage: _zod.default.array(_zod.default.object({
-    origin: _zod.default.string(),
-    sessionStorage: _zod.default.array(_zod.default.object({
-      name: _zod.default.string(),
-      value: _zod.default.string()
-    }))
-  })).optional()
-});
-const runApiSessionSchema = exports.runApiSessionSchema = _zod.default.discriminatedUnion("type", [_zod.default.object({
-  type: _zod.default.literal("file"),
-  path: _zod.default.string()
-}), _zod.default.object({
-  type: _zod.default.literal("state"),
-  state: runApiStorageStateSchema.nullable().optional()
-})]);
-const runApiParametersSchema = exports.runApiParametersSchema = _zod.default.object({
-  automationFunction: _zod.default.object({
-    name: _zod.default.string(),
-    params: _zod.default.any().optional()
-  }),
-  tracing: _zod.default.discriminatedUnion("enabled", [_zod.default.object({
-    enabled: _zod.default.literal(false)
-  }), _zod.default.object({
-    enabled: _zod.default.literal(true),
-    filePath: _zod.default.string()
-  })]).optional().default({
-    enabled: false
-  }),
-  auth: _zod.default.object({
-    session: runApiSessionSchema
-  }).optional(),
-  runOptions: _zod.default.discriminatedUnion("environment", [_zod.default.object({
-    environment: _zod.default.literal("standalone"),
-    headless: _zod.default.boolean().default(true),
-    proxy: _zod.default.object({
-      server: _zod.default.string(),
-      username: _zod.default.string(),
-      password: _zod.default.string()
-    }).optional()
-  }), _zod.default.object({
-    environment: _zod.default.literal("cdp"),
-    cdpAddress: _zod.default.string()
-  })]).default({
-    environment: "standalone"
-  }),
-  retrieveSession: _zod.default.boolean().default(false)
-});

package/dist/common/setupContextHook.d.ts

@@ -1,17 +0,0 @@
-import type * as playwright from "playwright";
-import { type RunAutomationError } from "./runApi/errors";
-import { type Err, type Ok } from "neverthrow";
-import { type ImportFunction } from "./runApi/importUsingImportFunction";
-export type InitializeContextHookOptions = {
-    apiName: string;
-    apiParameters: any;
-    cdpUrl: string;
-};
-export type SetupContextHook = (options: InitializeContextHookOptions) => Promise<{
-    page: playwright.Page | null;
-    context: playwright.BrowserContext;
-    cleanup?: () => Promise<void>;
-} | null>;
-export declare function loadSetupContextHook({ importFunction, }: {
-    importFunction: ImportFunction;
-}): Promise<Ok<SetupContextHook | null, any> | Err<any, RunAutomationError>>;

package/dist/common/setupContextHook.js

@@ -1,22 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.loadSetupContextHook = loadSetupContextHook;
-var _errors = require("./runApi/errors");
-var _neverthrow = require("neverthrow");
-var _importUsingImportFunction = require("./runApi/importUsingImportFunction");
-const setupContextHookPath = "hooks/setupContext";
-async function loadSetupContextHook({
-  importFunction
-}) {
-  const importedFunctionResult = await (0, _importUsingImportFunction.importUsingImportFunction)({
-    path: setupContextHookPath,
-    importFunction
-  });
-  if (importedFunctionResult.isErr() && importedFunctionResult.error instanceof _errors.ApiNotFoundError) {
-    return (0, _neverthrow.ok)(null);
-  }
-  return importedFunctionResult;
-}

package/dist/runtime/RunError.d.ts

@@ -1,5 +0,0 @@
-import { RunErrorOptions } from "./export";
-export declare class RunError extends Error {
-    options: RunErrorOptions;
-    constructor(message: string, options?: RunErrorOptions);
-}

package/dist/runtime/RunError.js

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

package/dist/runtime/attemptStore.d.ts

@@ -1,2 +0,0 @@
-import { AttemptStore } from "./export";
-export declare const attemptStore: AttemptStore;

package/dist/runtime/attemptStore.js

@@ -1,23 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.attemptStore = void 0;
-var _asyncLocalStorage = require("../common/asyncLocalStorage");
-const attemptStore = exports.attemptStore = Object.freeze({
-  get: key => {
-    const context = (0, _asyncLocalStorage.getExecutionContext)();
-    return context?.store ? context.store[key] : undefined;
-  },
-  set: (key, value) => {
-    const context = (0, _asyncLocalStorage.getExecutionContext)();
-    if (!context) {
-      throw new Error("store.set failed due to an internal error.");
-    }
-    if (!context.store) {
-      context.store = {};
-    }
-    context.store[key] = value;
-  }
-});

package/dist/runtime/captcha.d.ts

@@ -1,15 +0,0 @@
-import type { Page, BrowserContext } from "playwright";
-import { CaptchaStatus, CaptchaCallback } from "../common/extension/types";
-export type WithWaitForCaptchaSolveOptions = {
-    page: Page;
-    timeoutInMs?: number;
-    settleDurationMs?: number;
-    waitForNetworkSettled?: boolean;
-};
-export declare function withWaitForCaptchaSolve<T>(callback: (page: Page) => Promise<T>, options: WithWaitForCaptchaSolveOptions): Promise<T>;
-export declare function waitForCaptchaSolve(page: Page, { timeoutInMs, settleDurationMs, }?: Pick<WithWaitForCaptchaSolveOptions, "timeoutInMs" | "settleDurationMs">): Promise<void>;
-export declare function removeCaptchaEventListener(page: Page, status: CaptchaStatus, f: CaptchaCallback): Promise<void>;
-export declare function onCaptchaEvent(page: Page, status: CaptchaStatus, f: CaptchaCallback): Promise<void>;
-export declare function onceCaptchaEvent(page: Page, status: CaptchaStatus, f: CaptchaCallback): Promise<void>;
-export declare function pauseCaptchaSolver(context: BrowserContext): Promise<void>;
-export declare function resumeCaptchaSolver(context: BrowserContext): Promise<void>;

package/dist/runtime/captcha.js

@@ -1,191 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.onCaptchaEvent = onCaptchaEvent;
-exports.onceCaptchaEvent = onceCaptchaEvent;
-exports.pauseCaptchaSolver = pauseCaptchaSolver;
-exports.removeCaptchaEventListener = removeCaptchaEventListener;
-exports.resumeCaptchaSolver = resumeCaptchaSolver;
-exports.waitForCaptchaSolve = waitForCaptchaSolve;
-exports.withWaitForCaptchaSolve = withWaitForCaptchaSolve;
-var _intunedExtensionServer = require("../common/extension/intunedExtensionServer");
-var _extensionsHelpers = require("../common/extension/extensionsHelpers");
-var _types = require("../common/extension/types");
-async function withWaitForCaptchaSolve(callback, options) {
-  const {
-    page,
-    timeoutInMs = 10_000,
-    settleDurationMs = 5_000,
-    waitForNetworkSettled = true
-  } = options;
-  console.error(`Starting captcha solve wait (timeout=${timeoutInMs}ms, settleDuration=${settleDurationMs}ms, waitForNetworkSettled=${waitForNetworkSettled})`);
-  const extensionServer = (0, _intunedExtensionServer.getIntunedExtensionServer)();
-  let settledResolve = null;
-  let settledPromise = new Promise(resolve => {
-    settledResolve = resolve;
-  });
-  let isTimeout = false;
-  let captchasAppeared = false;
-  let error = undefined;
-  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 (err) {
-      console.error(`Failed to wait for networkidle. Error: ${err}`);
-    }
-  }
-  const timeoutPromise = new Promise(resolve => {
-    setTimeout(() => {
-      isTimeout = true;
-      console.error("Captcha solve timeout reached");
-      settledResolve?.();
-      resolve();
-    }, 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 _types.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 _types.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(resolve => {
-          settledResolve = resolve;
-        });
-      }
-    }
-    return result;
-  } finally {
-    await extensionServer.unsubscribe(page, onCaptchaUpdate);
-  }
-}
-async function waitForCaptchaSolve(page, {
-  timeoutInMs = 10_000,
-  settleDurationMs = 5_000
-} = {}) {
-  await withWaitForCaptchaSolve(async () => undefined, {
-    page,
-    timeoutInMs,
-    settleDurationMs,
-    waitForNetworkSettled: false
-  });
-}
-async function removeCaptchaEventListener(page, status, f) {
-  const extensionServer = (0, _intunedExtensionServer.getIntunedExtensionServer)();
-  await extensionServer.unsubscribe(page, f, status);
-}
-async function onCaptchaEvent(page, status, f) {
-  const extensionServer = (0, _intunedExtensionServer.getIntunedExtensionServer)();
-  await extensionServer.subscribe(page, f, status);
-}
-async function onceCaptchaEvent(page, status, f) {
-  const extensionServer = (0, _intunedExtensionServer.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 (0, _extensionsHelpers.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 (0, _extensionsHelpers.isIntunedExtensionEnabled)())) {
-    throw new Error("Intuned extension is not enabled. Cannot pause captcha solver.");
-  }
-  await setAutoSolve(context, false);
-}
-async function resumeCaptchaSolver(context) {
-  if (!(await (0, _extensionsHelpers.isIntunedExtensionEnabled)())) {
-    throw new Error("Intuned extension is not enabled. Cannot resume captcha solver.");
-  }
-  await setAutoSolve(context, true);
-}