@intuned/runtime-dev 1.3.18-interface.4 → 1.3.18-interface.9

package/dist/common/playwrightContext.js

@@ -1,153 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.browserScriptsFile = void 0;
-exports.loadSessionToContext = loadSessionToContext;
-exports.withPlaywrightContext = withPlaywrightContext;
-var _contextStorageStateHelpers = require("./contextStorageStateHelpers");
-var _path = _interopRequireDefault(require("path"));
-var fs = _interopRequireWildcard(require("fs-extra"));
-var _fileUtils = require("../commands/common/utils/fileUtils");
-var _neverthrow = require("neverthrow");
-var _setupContextHook = require("./setupContextHook");
-var _portfinder = require("portfinder");
-var _launchBrowser = require("./launchBrowser");
-var _runtimeInterface = require("@intuned/runtime-interface");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const browserScriptsFile = exports.browserScriptsFile = _path.default.join(__dirname, "./assets/browser_scripts.js");
-async function withPlaywrightContext({
-  cdpAddress,
-  cdpTargetId,
-  proxy,
-  headless = true,
-  downloadsPath,
-  importFunction,
-  apiName,
-  apiParameters
-}, fn) {
-  let context;
-  let page;
-  try {
-    const setupContextHookResult = importFunction ? await (0, _setupContextHook.loadSetupContextHook)({
-      importFunction
-    }) : (0, _neverthrow.ok)(null);
-    if (setupContextHookResult.isErr()) {
-      return setupContextHookResult;
-    }
-    const setupContextHook = setupContextHookResult.value;
-    if (setupContextHook === null) {
-      if (cdpAddress !== undefined) {
-        ({
-          page,
-          context
-        } = await (0, _launchBrowser.launchBrowser)({
-          cdpAddress,
-          cdpTargetId
-        }));
-      } else {
-        ({
-          page,
-          context
-        } = await (0, _launchBrowser.launchBrowser)({
-          proxy,
-          headless,
-          downloadsPath
-        }));
-      }
-      return await fn(context, page);
-    }
-    let hookCdpUrl = null;
-    if (cdpAddress) {
-      hookCdpUrl = cdpAddress;
-      ({
-        context,
-        page
-      } = await (0, _launchBrowser.launchBrowser)({
-        cdpAddress,
-        cdpTargetId
-      }));
-    } else {
-      const port = await (0, _portfinder.getPort)({
-        port: 9222
-      });
-      ({
-        context,
-        page
-      } = await (0, _launchBrowser.launchBrowser)({
-        proxy,
-        headless,
-        downloadsPath,
-        cdpPort: port
-      }));
-      hookCdpUrl = (0, _launchBrowser.getLocalCdpAddress)(port);
-    }
-    let hookResult;
-    try {
-      const wsUrlResult = await (0, _launchBrowser.getCdpWebSocketUrl)(hookCdpUrl);
-      if (wsUrlResult.isOk()) {
-        hookCdpUrl = wsUrlResult.value;
-      } else {
-        throw new Error(wsUrlResult.error);
-      }
-      hookResult = await setupContextHook({
-        apiName: apiName,
-        apiParameters: apiParameters,
-        cdpUrl: hookCdpUrl
-      });
-    } catch (error) {
-      return (0, _neverthrow.err)(new _runtimeInterface.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, _neverthrow.err)(new _runtimeInterface.AutomationError(e))
-      };
-    }
-    if ("throw" in result) {
-      throw result.throw;
-    }
-    return result.return;
-  } finally {
-    await context?.close();
-  }
-}
-async function loadSessionToContext({
-  context,
-  session
-}) {
-  let sessionToLoad;
-  if (session.type === "state") {
-    const state = session.state;
-    if (state === undefined || state === null) {
-      return;
-    }
-    sessionToLoad = state;
-  } else {
-    const fullPath = (0, _fileUtils.getFullPathInProject)(session.path);
-    sessionToLoad = await fs.readJson(fullPath);
-  }
-  await (0, _contextStorageStateHelpers.setStorageState)(context, sessionToLoad);
-}

package/dist/common/runApi/importUsingImportFunction.d.ts

@@ -1,7 +0,0 @@
-import { Result } from "neverthrow";
-import { ImportFunction, RunAutomationError } from "@intuned/runtime-interface";
-export declare function importUsingImportFunction<_ReturnType = any>({ path, allowGenerators, importFunction, }: {
-    path: string;
-    importFunction: ImportFunction;
-    allowGenerators?: boolean;
-}): Promise<Result<(..._: any) => Promise<_ReturnType>, RunAutomationError>>;

package/dist/common/runApi/importUsingImportFunction.js

@@ -1,46 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.importUsingImportFunction = importUsingImportFunction;
-var _neverthrow = require("neverthrow");
-var _runtimeInterface = require("@intuned/runtime-interface");
-async function importUsingImportFunction({
-  path,
-  allowGenerators = true,
-  importFunction
-}) {
-  try {
-    const importedResult = await importFunction(path);
-    if (importedResult.isErr()) {
-      if (importedResult.error.type === "not_found") {
-        return (0, _neverthrow.err)(new _runtimeInterface.ApiNotFoundError(path));
-      }
-      return (0, _neverthrow.err)(new _runtimeInterface.AutomationError(importedResult.error.error));
-    }
-    const imported = importedResult.value;
-    if (!imported || !imported.default || !imported.default.constructor) {
-      return (0, _neverthrow.err)(new _runtimeInterface.InvalidApiError(`${path} does not have a default export`));
-    }
-    if (imported.default.constructor.name === "AsyncGeneratorFunction") {
-      if (!allowGenerators) {
-        return (0, _neverthrow.err)(new _runtimeInterface.InvalidApiError(`${path} default export must be an async function`));
-      }
-      return (0, _neverthrow.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, _neverthrow.ok)(imported.default);
-    }
-    return (0, _neverthrow.err)(new _runtimeInterface.InvalidApiError(`${path} default export must be an async function`));
-  } catch (error) {
-    return (0, _neverthrow.err)(new _runtimeInterface.AutomationError(error));
-  }
-}

package/dist/common/setupContextHook.d.ts

@@ -1,16 +0,0 @@
-import type * as playwright from "playwright";
-import { type Err, type Ok } from "neverthrow";
-import { ImportFunction, type RunAutomationError } from "@intuned/runtime-interface";
-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 _neverthrow = require("neverthrow");
-var _importUsingImportFunction = require("./runApi/importUsingImportFunction");
-var _runtimeInterface = require("@intuned/runtime-interface");
-const setupContextHookPath = "hooks/setupContext";
-async function loadSetupContextHook({
-  importFunction
-}) {
-  const importedFunctionResult = await (0, _importUsingImportFunction.importUsingImportFunction)({
-    path: setupContextHookPath,
-    importFunction
-  });
-  if (importedFunctionResult.isErr() && importedFunctionResult.error instanceof _runtimeInterface.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);
-}