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

package/dist/common/launchBrowser.js

@@ -0,0 +1,247 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBrowserExecutablePath = getBrowserExecutablePath;
+exports.getCdpWebSocketUrl = getCdpWebSocketUrl;
+exports.getHeadlessUserAgent = getHeadlessUserAgent;
+exports.getLocalCdpAddress = getLocalCdpAddress;
+exports.launchBrowser = launchBrowser;
+exports.launchChromium = launchChromium;
+var playwright = _interopRequireWildcard(require("playwright"));
+var _fsExtra = _interopRequireWildcard(require("fs-extra"));
+var fs = _fsExtra;
+var _path = require("path");
+var _waitOn = _interopRequireDefault(require("wait-on"));
+var _child_process = require("child_process");
+var _extensionsHelpers = require("./extension/extensionsHelpers");
+var _intunedExtensionServer = require("./extension/intunedExtensionServer");
+var _util = require("util");
+var _neverthrow = require("neverthrow");
+var _zod = require("zod");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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); }
+const execAsync = (0, _util.promisify)(_child_process.exec);
+async function createUserDirWithPreferences() {
+  const playwrightTempDir = await (0, _fsExtra.mkdtemp)("/tmp/pw-");
+  const userDir = (0, _path.join)(playwrightTempDir, "userdir");
+  const defaultDir = (0, _path.join)(userDir, "Default");
+  await (0, _fsExtra.mkdir)(defaultDir, {
+    recursive: true
+  });
+  const preferences = {
+    plugins: {
+      always_open_pdf_externally: true
+    }
+  };
+  await (0, _fsExtra.writeFile)((0, _path.join)(defaultDir, "Preferences"), JSON.stringify(preferences));
+  return userDir;
+}
+async function launchChromium(options) {
+  if ("cdpAddress" in options) {
+    if (await (0, _extensionsHelpers.isIntunedExtensionEnabled)()) {
+      await (0, _intunedExtensionServer.setupIntunedExtensionServer)();
+    }
+    const browser = await playwright.chromium.connectOverCDP(options.cdpAddress);
+    if (browser.contexts().length === 0) {
+      throw new Error("No browser contexts found in the connected browser");
+    }
+    const context = browser.contexts()[0];
+    let page = context.pages().at(0) ?? (await context.newPage());
+    const targetId = options.cdpTargetId;
+    if (targetId) {
+      for (const p of context.pages()) {
+        let cdp = null;
+        try {
+          cdp = await context.newCDPSession(p);
+          const result = await cdp.send("Target.getTargetInfo");
+          if (result.targetInfo.targetId === targetId) {
+            page = p;
+            break;
+          }
+        } catch (error) {} finally {
+          await cdp?.detach();
+        }
+      }
+    }
+    return {
+      page,
+      context
+    };
+  }
+  const {
+    headless,
+    appModeInitialUrl,
+    cdpPort,
+    proxy,
+    downloadsPath
+  } = options;
+  let {
+    executablePath
+  } = options;
+  const defaultArgsToIgnore = ["--disable-extensions", "--disable-component-extensions-with-background-pages", "--disable-background-networking", "--disable-backgrounding-occluded-windows", "--disable-background-timer-throttling"];
+  const extraArgs = [];
+  const userDataDir = await createUserDirWithPreferences();
+  if ((0, _extensionsHelpers.isIntunedExtensionLoaded)()) {
+    const extensionsList = (0, _extensionsHelpers.buildExtensionsList)();
+    const extensions = extensionsList.join(",");
+    extraArgs.push(`--disable-extensions-except=${extensions}`);
+    extraArgs.push(`--load-extension=${extensions}`);
+  }
+  if (await (0, _extensionsHelpers.isIntunedExtensionEnabled)()) {
+    await (0, _extensionsHelpers.setupIntunedExtension)();
+    if (proxy) {
+      extraArgs.push('--proxy-bypass-list="<-loopback>"');
+    }
+  }
+  if (cdpPort) {
+    extraArgs.push(`--remote-debugging-port=${cdpPort}`);
+  }
+  if (headless) {
+    defaultArgsToIgnore.push("--headless=old");
+    extraArgs.push("--headless=new");
+  }
+  if (appModeInitialUrl) {
+    extraArgs.push(`--app=${appModeInitialUrl}`);
+  }
+  if (executablePath) {
+    executablePath = await fs.realpath(executablePath);
+    if (!(await fs.exists(executablePath))) {
+      console.log(`Warning: Executable path ${executablePath} does not exist. Falling back to default.`);
+      executablePath = undefined;
+    }
+  }
+  const viewport = null;
+  const userAgent = process.env.__PLAYWRIGHT_USER_AGENT_OVERRIDE ?? (await getHeadlessUserAgent({
+    executablePath
+  }));
+  const context = await playwright.chromium.launchPersistentContext(userDataDir, {
+    userAgent,
+    executablePath,
+    headless,
+    viewport,
+    proxy,
+    downloadsPath,
+    args: extraArgs,
+    ignoreDefaultArgs: defaultArgsToIgnore
+  });
+  context.once("close", async () => {
+    try {
+      await (0, _fsExtra.rm)(userDataDir, {
+        recursive: true,
+        force: true,
+        retryDelay: 1000,
+        maxRetries: 5
+      });
+      if (await (0, _extensionsHelpers.isIntunedExtensionEnabled)()) {
+        await (0, _intunedExtensionServer.cleanIntunedExtensionServer)();
+      }
+    } catch (error) {
+      console.error("Failed to remove user data dir", error);
+    }
+  });
+  if (cdpPort) {
+    const createdCdpAddress = getLocalCdpAddress(cdpPort);
+    await waitOnCdpAddress(createdCdpAddress);
+  }
+  const page = context.pages().at(0) ?? (await context.newPage());
+  if (await (0, _extensionsHelpers.isIntunedExtensionEnabled)()) {
+    await (0, _extensionsHelpers.getIntunedExtensionWorker)(context);
+  }
+  return {
+    page,
+    context
+  };
+}
+async function getBrowserExecutablePath() {
+  const browserType = getBrowserType();
+  if (browserType === "brave") {
+    return await getBraveExecutablePath();
+  }
+}
+async function launchBrowser(options) {
+  if ("cdpAddress" in options) {
+    return launchChromium(options);
+  }
+  return launchChromium({
+    ...options,
+    executablePath: await getBrowserExecutablePath()
+  });
+}
+function getBrowserType() {
+  if (process.env.BROWSER_TYPE === "brave") {
+    return "brave";
+  }
+  return "chromium";
+}
+async function getBraveExecutablePath() {
+  const {
+    stdout
+  } = await execAsync("which brave-browser-stable");
+  const bravePath = stdout.trim();
+  if (bravePath.length === 0) {
+    throw new Error("Brave browser not found");
+  }
+  return bravePath;
+}
+function getLocalCdpAddress(port) {
+  return `http://localhost:${port}`;
+}
+async function getCdpWebSocketUrl(cdpAddress) {
+  let response;
+  try {
+    response = await fetch(`${cdpAddress}/json/version`);
+  } catch (error) {
+    return (0, _neverthrow.err)(`Failed to fetch CDP version from ${cdpAddress}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!response.ok) {
+    return (0, _neverthrow.err)(`Failed to get CDP WebSocket URL from ${cdpAddress}: ${response.status} ${response.statusText}`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (error) {
+    return (0, _neverthrow.err)(`Invalid CDP version response from ${cdpAddress}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const cdpJsonVersionResponseSchema = _zod.z.object({
+    webSocketDebuggerUrl: _zod.z.string().url()
+  });
+  const parseResult = cdpJsonVersionResponseSchema.safeParse(data);
+  if (!parseResult.success) {
+    return (0, _neverthrow.err)(`Invalid CDP version response from ${cdpAddress}: ${JSON.stringify(parseResult.error.format())}`);
+  }
+  return (0, _neverthrow.ok)(parseResult.data.webSocketDebuggerUrl);
+}
+async function waitOnCdpAddress(cdpAddress) {
+  const cdpAddressWithoutProtocol = cdpAddress.replace("http://", "").replace("https://", "").replace("localhost", "127.0.0.1");
+  await (0, _waitOn.default)({
+    resources: [`http-get://${cdpAddressWithoutProtocol}/json/version`],
+    delay: 100,
+    interval: 100,
+    timeout: 5000,
+    tcpTimeout: 1000,
+    window: 1000
+  });
+}
+async function getHeadlessUserAgent({
+  executablePath,
+  args,
+  ignoreDefaultArgs
+}) {
+  const browser = await playwright.chromium.launch({
+    headless: true,
+    executablePath,
+    args,
+    ignoreDefaultArgs
+  });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  let userAgent = await page.evaluate(() => navigator.userAgent);
+  await browser.close();
+  if (!userAgent || typeof userAgent !== "string") {
+    return undefined;
+  }
+  userAgent = userAgent.replace("HeadlessChrome", "Chrome");
+  return userAgent;
+}

package/dist/common/playwrightContext.d.ts

@@ -0,0 +1,29 @@
+import type * as playwright from "playwright";
+import { Err, Ok } from "neverthrow";
+import { type Proxy } from "./launchBrowser";
+import { ImportFunction, RunAutomationError, RunApiSession } from "@intuned/runtime-interface";
+type WithPlaywrightContextParameters = {
+    importFunction: ImportFunction;
+    apiName: string;
+    apiParameters: any;
+} | {
+    importFunction?: undefined;
+    apiName?: undefined;
+    apiParameters?: undefined;
+};
+type WithPlaywrightContextWrappedFunctionReturn<R> = Ok<R, any> | Err<any, RunAutomationError>;
+export type WithPlaywrightContextWrappedFunction<R> = (context: playwright.BrowserContext, page: playwright.Page) => Promise<WithPlaywrightContextWrappedFunctionReturn<R>>;
+export declare function withPlaywrightContext<R>(options: {
+    proxy?: Proxy;
+    headless: boolean;
+    downloadsPath: string;
+} & WithPlaywrightContextParameters, fn: WithPlaywrightContextWrappedFunction<R>): Promise<Ok<R, any> | Err<any, RunAutomationError>>;
+export declare function withPlaywrightContext<R>(options: {
+    cdpAddress: string;
+    cdpTargetId?: string;
+} & WithPlaywrightContextParameters, fn: WithPlaywrightContextWrappedFunction<R>): Promise<Ok<R, any> | Err<any, RunAutomationError>>;
+export declare function loadSessionToContext({ context, session, }: {
+    context: playwright.BrowserContext;
+    session: RunApiSession;
+}): Promise<void>;
+export {};

package/dist/common/playwrightContext.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadSessionToContext = loadSessionToContext;
+exports.withPlaywrightContext = withPlaywrightContext;
+var _contextStorageStateHelpers = require("./contextStorageStateHelpers");
+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("../vendor/runtime-interface");
+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); }
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.importUsingImportFunction = importUsingImportFunction;
+var _neverthrow = require("neverthrow");
+var _runtimeInterface = require("../../vendor/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/runApi/index.d.ts

@@ -0,0 +1,8 @@
+import { Result } from "neverthrow";
+import type { Page, BrowserContext } from "playwright";
+import { ExtendedRunApiParameters, RunApiResult, RunApiResultWithSessionOk, RunAutomationError } from "@intuned/runtime-interface";
+export declare function runApi<ResultType = any>(input: ExtendedRunApiParameters & {
+    retrieveSession: true;
+}): Promise<RunApiResult<ResultType, RunApiResultWithSessionOk<ResultType>>>;
+export declare function runApi<ResultType = any>(input: ExtendedRunApiParameters): Promise<RunApiResult<ResultType>>;
+export declare function checkAuthSessionWithRetries(page: Page, context: BrowserContext, checkFn: (..._: any) => Promise<boolean>, retries?: number): Promise<Result<boolean, RunAutomationError>>;

package/dist/common/runApi/index.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkAuthSessionWithRetries = checkAuthSessionWithRetries;
+exports.runApi = runApi;
+var _downloadDirectory = require("../../runtime/downloadDirectory");
+var _asyncLocalStorage = require("../asyncLocalStorage");
+var _fsExtra = _interopRequireWildcard(require("fs-extra"));
+var fs = _fsExtra;
+var _neverthrow = require("neverthrow");
+var _constants = require("../constants");
+var _playwrightContext = require("../playwrightContext");
+var _formatZodError = require("../formatZodError");
+var _cleanEnvironmentVariables = require("../cleanEnvironmentVariables");
+var _importUsingImportFunction = require("./importUsingImportFunction");
+var _runtimeInterface = require("../../vendor/runtime-interface");
+var _contextStorageStateHelpers = require("../contextStorageStateHelpers");
+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 getObjectSizeInBytes(obj) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(obj)).length;
+  } catch (error) {
+    return new TextEncoder().encode(String(obj)).length;
+  }
+}
+async function runApi({
+  abortSignal,
+  importFunction,
+  retrieveSession = false,
+  ...input
+}) {
+  let traceStarted = false;
+  const inputParseResult = _runtimeInterface.runApiParametersSchema.safeParse(input);
+  if (!inputParseResult.success) {
+    return (0, _neverthrow.err)(new _runtimeInterface.InternalInvalidInputError("Input validation failed", (0, _formatZodError.formatZodError)(inputParseResult.error)));
+  }
+  const {
+    automationFunction: {
+      name,
+      params
+    },
+    runOptions,
+    tracing,
+    auth
+  } = inputParseResult.data;
+  const abortSymbol = Symbol("abort");
+  const abortPromise = new Promise(resolve => {
+    if (!abortSignal) return;
+    abortSignal.addEventListener("abort", () => {
+      resolve(abortSymbol);
+    });
+  });
+  async function runAutomation() {
+    const validatedModuleResult = await (0, _importUsingImportFunction.importUsingImportFunction)({
+      path: name,
+      importFunction
+    });
+    if (validatedModuleResult.isErr()) {
+      return (0, _neverthrow.err)(validatedModuleResult.error);
+    }
+    const automationFunction = validatedModuleResult.value;
+    if (auth && auth.session.type === "state") {
+      const state = auth.session.state;
+      if (state === undefined || state === null) {
+        return (0, _neverthrow.err)(new _runtimeInterface.AuthRequiredError());
+      }
+    }
+    const playwrightContextParameters = {
+      apiName: name,
+      apiParameters: params,
+      importFunction
+    };
+    const intunedContext = (0, _asyncLocalStorage.getExecutionContext)();
+    const runAutomationWithContext = async (context, page) => {
+      async function saveTraceIfNeeded({
+        errorMessage
+      }) {
+        if (!tracing.enabled || !traceStarted) {
+          return;
+        }
+        try {
+          await context?.tracing.stop({
+            path: tracing.filePath
+          });
+        } catch (error) {
+          console.log(errorMessage, error?.message);
+          await (0, _fsExtra.remove)(tracing.filePath);
+        }
+      }
+      if (auth) {
+        await (0, _playwrightContext.loadSessionToContext)({
+          context,
+          session: auth.session
+        });
+        if (intunedContext && auth.parameters) {
+          intunedContext.getAuthSessionParameters = async () => auth.parameters;
+        }
+      }
+      if (tracing.enabled) {
+        await context.tracing.start({
+          screenshots: true,
+          snapshots: true,
+          sources: true
+        });
+        traceStarted = true;
+      }
+      (0, _cleanEnvironmentVariables.cleanEnvironmentVariables)();
+      const automationFunctionParameters = [...(params !== undefined ? [params] : []), page, context];
+      try {
+        const automationFunctionResult = await Promise.race([automationFunction(...automationFunctionParameters), abortPromise]);
+        if (automationFunctionResult === abortSymbol) {
+          return (0, _neverthrow.err)(new _runtimeInterface.AbortedError());
+        }
+        const MAX_RESULT_SIZE_BYTES = 2 * 1024 * 1024;
+        const resultSizeInBytes = getObjectSizeInBytes(automationFunctionResult);
+        if (resultSizeInBytes > MAX_RESULT_SIZE_BYTES) {
+          return (0, _neverthrow.err)(new _runtimeInterface.ResultTooBigError(resultSizeInBytes, MAX_RESULT_SIZE_BYTES));
+        }
+        if (retrieveSession) {
+          return (0, _neverthrow.ok)({
+            result: automationFunctionResult,
+            extendedPayloads: intunedContext?.extendedPayloads,
+            session: await (0, _contextStorageStateHelpers.getStorageState)(context)
+          });
+        }
+        return (0, _neverthrow.ok)({
+          result: automationFunctionResult,
+          extendedPayloads: intunedContext?.extendedPayloads
+        });
+      } catch (error) {
+        return (0, _neverthrow.err)(new _runtimeInterface.AutomationError(error));
+      } finally {
+        await saveTraceIfNeeded({
+          errorMessage: "failed to save trace"
+        });
+      }
+    };
+    if (intunedContext?.store) {
+      intunedContext.store = {};
+    }
+    if (runOptions.environment === "standalone") {
+      const downloadsPath = (0, _downloadDirectory.getDownloadDirectoryPath)();
+      try {
+        return await (0, _playwrightContext.withPlaywrightContext)({
+          headless: runOptions.headless,
+          proxy: runOptions.proxy,
+          downloadsPath,
+          ...playwrightContextParameters
+        }, runAutomationWithContext);
+      } finally {
+        await fs.remove(downloadsPath);
+      }
+    } else {
+      return await (0, _playwrightContext.withPlaywrightContext)({
+        cdpAddress: runOptions.cdpAddress,
+        cdpTargetId: runOptions.cdpTargetId,
+        ...playwrightContextParameters
+      }, runAutomationWithContext);
+    }
+  }
+  return await runAutomation();
+}
+async function checkAuthSessionWithRetries(page, context, checkFn, retries = 3) {
+  if (retries === 0) {
+    return (0, _neverthrow.ok)(false);
+  }
+  let tryNumber = 0;
+  console.log("Checking AuthSession with retries", `${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`);
+  while (retries > tryNumber) {
+    const result = await checkFn(page, context);
+    if (result) return (0, _neverthrow.ok)(true);
+    tryNumber++;
+  }
+  return (0, _neverthrow.ok)(false);
+}