@intuned/runtime-dev 1.2.1-hooks.4 → 1.2.1-hooks.5

package/dist/common/playwrightContext.js

@@ -0,0 +1,240 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.browserScriptsFile = void 0;
+exports.getRemotePlaywrightContext = getRemotePlaywrightContext;
+exports.launchChromium = launchChromium;
+exports.loadSessionToContext = loadSessionToContext;
+exports.withPlaywrightContext = withPlaywrightContext;
+var playwright = _interopRequireWildcard(require("playwright"));
+var _fsExtra = _interopRequireWildcard(require("fs-extra"));
+var fs = _fsExtra;
+var _contextStorageStateHelpers = require("./contextStorageStateHelpers");
+var _path = _interopRequireWildcard(require("path"));
+var _fileUtils = require("../commands/common/utils/fileUtils");
+var _waitOn = _interopRequireDefault(require("wait-on"));
+var _errors = require("./runApi/errors");
+var _neverthrow = require("neverthrow");
+var _initializeContextHook = require("./initializeContextHook");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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; }
+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({
+  proxy,
+  headless = true,
+  downloadsPath,
+  cdpAddress,
+  cdpPort
+}) {
+  if (cdpAddress) {
+    const browser = await playwright.chromium.connectOverCDP(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);
+    if (!page) {
+      page = await context.newPage();
+    }
+    return {
+      page,
+      context
+    };
+  }
+  const extraArgs = [];
+  const userDataDir = await createUserDirWithPreferences();
+  if (cdpPort) {
+    extraArgs.push(`--remote-debugging-port=${cdpPort}`);
+  }
+  const context = await playwright.chromium.launchPersistentContext(userDataDir, {
+    headless,
+    viewport: null,
+    proxy,
+    downloadsPath,
+    args: extraArgs
+  });
+  if (cdpPort) {
+    const createdCdpAddress = getCdpAddress(cdpPort);
+    await waitOnCdpAddress(createdCdpAddress);
+  }
+  context.once("close", async () => {
+    try {
+      await (0, _fsExtra.rm)(userDataDir, {
+        recursive: true,
+        force: true,
+        retryDelay: 1000,
+        maxRetries: 5
+      });
+    } catch (error) {
+      console.error("Failed to remove user data dir", error);
+    }
+  });
+  const page = context.pages().at(0) ?? (await context.newPage());
+  return {
+    page,
+    context
+  };
+}
+const browserScriptsFile = exports.browserScriptsFile = _path.default.join(__dirname, "./assets/browser_scripts.js");
+async function withPlaywrightContext({
+  cdpAddress,
+  proxy,
+  headless = true,
+  downloadsPath,
+  importFunction,
+  apiName,
+  apiParameters
+}, fn) {
+  let context;
+  let page;
+  try {
+    const initializeContextHookResult = await (0, _initializeContextHook.loadInitializeContextHook)({
+      importFunction
+    });
+    if (initializeContextHookResult.isErr()) {
+      return initializeContextHookResult;
+    }
+    const initializeContextHook = initializeContextHookResult.value;
+    if (initializeContextHook === null) {
+      if (cdpAddress !== undefined) {
+        ({
+          page,
+          context
+        } = await launchChromium({
+          cdpAddress
+        }));
+      } else {
+        ({
+          page,
+          context
+        } = await launchChromium({
+          proxy,
+          headless,
+          downloadsPath
+        }));
+      }
+      return await fn(context, page);
+    }
+    let hookCdpUrl = null;
+    if (cdpAddress) {
+      hookCdpUrl = cdpAddress;
+      ({
+        context,
+        page
+      } = await launchChromium({
+        cdpAddress
+      }));
+    } else {
+      const getPort = (await Promise.resolve().then(() => _interopRequireWildcard(require("get-port")))).default;
+      const port = await getPort({
+        port: 9222
+      });
+      hookCdpUrl = getCdpAddress(port);
+      ({
+        context,
+        page
+      } = await launchChromium({
+        proxy,
+        headless,
+        downloadsPath,
+        cdpPort: port
+      }));
+    }
+    let hookResult;
+    try {
+      hookResult = await initializeContextHook({
+        apiName,
+        apiParameters,
+        cdpUrl: hookCdpUrl
+      });
+    } catch (error) {
+      return (0, _neverthrow.err)(new _errors.AutomationError(error));
+    }
+    if (!hookResult) {
+      return await fn(context, page);
+    }
+    const {
+      page: newPage,
+      context: newContext
+    } = hookResult;
+    try {
+      return await fn(newContext, newPage ?? page);
+    } finally {
+      await newContext.close();
+    }
+  } 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);
+}
+function getCdpAddress(port) {
+  return `http://localhost:${port}`;
+}
+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 getRemotePlaywrightContext(cdpAddress) {
+  const playwright = await Promise.resolve().then(() => _interopRequireWildcard(require("playwright")));
+  let browser = null;
+  if (!cdpAddress) {
+    throw new Error("cdpAddress is required");
+  }
+  try {
+    await waitOnCdpAddress(cdpAddress);
+  } catch (error) {
+    console.error("Failed to connect to the browser");
+    process.exit(128 + 9);
+  }
+  try {
+    browser = await playwright.chromium.connectOverCDP(cdpAddress);
+  } catch (e) {
+    console.log(e);
+    throw new Error("failed to connect to the browser");
+  }
+  const context = browser.contexts()[0];
+  return {
+    browser,
+    context
+  };
+}

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

@@ -0,0 +1,9 @@
+import { Result } from "neverthrow";
+import { RunAutomationError } from "./errors";
+import { ExtendedRunApiParameters } from "./types";
+export type ImportFunction = ExtendedRunApiParameters["importFunction"];
+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 _errors = require("./errors");
+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 _errors.ApiNotFoundError(path));
+      }
+      return (0, _neverthrow.err)(new _errors.AutomationError(importedResult.error.error));
+    }
+    const imported = importedResult.value;
+    if (!imported || !imported.default || !imported.default.constructor) {
+      return (0, _neverthrow.err)(new _errors.InvalidApiError(`${path} does not have a default export`));
+    }
+    if (imported.default.constructor.name === "AsyncGeneratorFunction") {
+      if (!allowGenerators) {
+        return (0, _neverthrow.err)(new _errors.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 _errors.InvalidApiError(`${path} default export must be an async function`));
+  } catch (error) {
+    return (0, _neverthrow.err)(new _errors.AutomationError(error));
+  }
+}

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

@@ -4,13 +4,8 @@ import { Page, BrowserContext } from "playwright";
 import { ExtendedRunApiParameters, RunApiResult, RunApiResultWithSessionOk } from "./types";
 export * from "./types";
 export * from "./errors";
-export declare function runApiGenerator<ResultType = any, _YieldType = any, _NextType = any>(params: ExtendedRunApiParameters & {
-    retrieveSession: true;
-}): AsyncGenerator<_YieldType, RunApiResult<ResultType, RunApiResultWithSessionOk>, _NextType>;
-export declare function runApiGenerator<ResultType = any, _YieldType = any, _NextType = any>(params: ExtendedRunApiParameters): AsyncGenerator<_YieldType, RunApiResult<ResultType>, _NextType>;
-export declare function runApi<ResultType = any>(params: ExtendedRunApiParameters & {
+export declare function runApi<ResultType = any>(input: ExtendedRunApiParameters & {
     retrieveSession: true;
 }): Promise<RunApiResult<ResultType, RunApiResultWithSessionOk>>;
-export declare function runApi<ResultType = any>(params: ExtendedRunApiParameters): Promise<RunApiResult<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>>;
-export type ImportFunction = ExtendedRunApiParameters["importFunction"];

package/dist/common/runApi/index.js

@@ -4,13 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  runApiGenerator: true,
   runApi: true,
   checkAuthSessionWithRetries: true
 };
 exports.checkAuthSessionWithRetries = checkAuthSessionWithRetries;
 exports.runApi = runApi;
-exports.runApiGenerator = runApiGenerator;
 var _downloadDirectory = require("../../runtime/downloadDirectory");
 var _asyncLocalStorage = require("../asyncLocalStorage");
 var _fsExtra = _interopRequireWildcard(require("fs-extra"));
@@ -30,7 +28,7 @@ Object.keys(_errors).forEach(function (key) {
   });
 });
 var _constants = require("../constants");
-var _getPlaywrightConstructs = require("../getPlaywrightConstructs");
+var _playwrightContext = require("../playwrightContext");
 var _types = require("./types");
 Object.keys(_types).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -45,12 +43,13 @@ Object.keys(_types).forEach(function (key) {
 });
 var _formatZodError = require("../formatZodError");
 var _cleanEnvironmentVariables = require("../cleanEnvironmentVariables");
+var _importUsingImportFunction = require("./importUsingImportFunction");
 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; }
-async function* runApiGenerator({
-  retrieveSession = false,
+async function runApi({
   abortSignal,
   importFunction,
+  retrieveSession = false,
   ...input
 }) {
   let traceStarted = false;
@@ -59,7 +58,10 @@ async function* runApiGenerator({
     return (0, _neverthrow.err)(new _errors.InternalInvalidInputError("Input validation failed", (0, _formatZodError.formatZodError)(inputParseResult.error)));
   }
   const {
-    automationFunction,
+    automationFunction: {
+      name,
+      params
+    },
     runOptions,
     tracing,
     auth
@@ -71,170 +73,103 @@ async function* runApiGenerator({
       resolve(abortSymbol);
     });
   });
-  let context;
-  let downloadsPath;
-  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);
-    }
-  }
-  async function* runAutomation() {
-    let page;
-    const validatedModuleResult = await importUsingImportFunction(automationFunction.name, importFunction);
+  async function runAutomation() {
+    const validatedModuleResult = await (0, _importUsingImportFunction.importUsingImportFunction)({
+      path: name,
+      importFunction
+    });
     if (validatedModuleResult.isErr()) {
       return (0, _neverthrow.err)(validatedModuleResult.error);
     }
-    const importedModule = validatedModuleResult.value;
-    let checkFn;
-    if (auth?.runCheck) {
-      if (!auth.session) {
-        return (0, _neverthrow.err)(new _errors.AuthRequiredError());
-      }
-      const checkImportResult = await importUsingImportFunction(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`, importFunction);
-      if (checkImportResult.isErr()) {
-        return (0, _neverthrow.err)(checkImportResult.error);
-      }
-      if (checkImportResult.value.type !== "async") {
-        return (0, _neverthrow.err)(new _errors.InvalidCheckError("Check function is not an async function"));
-      }
-      checkFn = checkImportResult.value.func;
-    }
+    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 _errors.AuthRequiredError());
       }
     }
-    if (runOptions.environment === "standalone") {
-      downloadsPath = (0, _downloadDirectory.getDownloadDirectoryPath)();
-      const {
-        headless,
-        proxy
-      } = runOptions;
-      ({
-        page,
-        context
-      } = await (0, _getPlaywrightConstructs.getProductionPlaywrightConstructs)({
-        headless,
-        proxy,
-        downloadsPath,
-        storageState: auth?.session,
-        hookOptions: {
-          apiName: automationFunction.name,
-          parameters: automationFunction.params,
-          importFunction
+    const playwrightContextParameters = {
+      apiName: name,
+      apiParameters: params,
+      importFunction
+    };
+    const runAutomationWithContext = async (context, page) => {
+      async function saveTraceIfNeeded({
+        errorMessage
+      }) {
+        if (!tracing.enabled || !traceStarted) {
+          return;
         }
-      }));
-    } else {
-      const {
-        mode,
-        cdpAddress
-      } = runOptions;
-      ({
-        page,
-        context
-      } = await (0, _getPlaywrightConstructs.getPlaywrightConstructsForMode)(mode, cdpAddress, auth?.session, {
-        apiName: automationFunction.name,
-        parameters: automationFunction.params,
-        importFunction
-      }));
-    }
-    if (tracing.enabled) {
-      await context.tracing.start({
-        screenshots: true,
-        snapshots: true,
-        sources: true
+        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
+        });
+      }
+      const scriptContent = await fs.readFile(_playwrightContext.browserScriptsFile, "utf-8");
+      await context.addInitScript({
+        content: scriptContent
       });
-      traceStarted = true;
-    }
-    (0, _cleanEnvironmentVariables.cleanEnvironmentVariables)();
-    if (checkFn !== undefined) {
+      for (const page of context.pages()) {
+        await page.evaluate(scriptContent);
+      }
+      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 {
-        console.log("Running auth check");
-        const authCheckResult = await checkAuthSessionWithRetries(page, context, checkFn, 2);
-        if (authCheckResult.isErr()) {
-          const error = authCheckResult.error;
-          if (["APINotFoundError", "InvalidAPIError"].includes(error.code)) {
-            return (0, _neverthrow.err)(new _errors.InvalidCheckError(`Auth session check function failed`, error));
-          }
-          return authCheckResult;
-        }
-        if (!authCheckResult.value) {
-          return (0, _neverthrow.err)(new _errors.AuthCheckFailedError());
-        }
+        return (0, _neverthrow.ok)({
+          result: await automationFunction(...automationFunctionParameters),
+          extendedPayloads: (0, _asyncLocalStorage.getExecutionContext)()?.extendedPayloads,
+          session: retrieveSession ? await (0, _contextStorageStateHelpers.getStorageState)(context) : undefined
+        });
       } catch (error) {
-        return (0, _neverthrow.err)(new _errors.AuthCheckFailedError());
+        return (0, _neverthrow.err)(new _errors.AutomationError(error));
+      } finally {
+        await saveTraceIfNeeded({
+          errorMessage: "failed to save trace"
+        });
       }
-    }
-    const automationFunctionParameters = [...(automationFunction.params !== undefined ? [automationFunction.params] : []), page, context];
-    let result;
-    if (importedModule.type === "async-generator") {
-      const generator = importedModule.generator(...automationFunctionParameters);
-      let next = undefined;
-      while (true) {
-        const generatorResult = await generator.next(...(next ? [next] : []));
-        if (!generatorResult.done) {
-          next = yield generatorResult.value;
-          continue;
-        }
-        result = generatorResult.value;
-        break;
+    };
+    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 {
-      result = await importedModule.func(...automationFunctionParameters);
-    }
-    return (0, _neverthrow.ok)({
-      result,
-      extendedPayloads: (0, _asyncLocalStorage.getExecutionContext)()?.extendedPayloads,
-      session: retrieveSession ? await (0, _contextStorageStateHelpers.getStorageState)(context) : undefined
-    });
-  }
-  try {
-    const generator = runAutomation();
-    let next = undefined;
-    while (true) {
-      const result = await Promise.race([generator.next(await next), abortPromise]);
-      if (result === abortSymbol) {
-        return (0, _neverthrow.err)(new _errors.AbortedError());
-      }
-      if (!result.done) {
-        next = yield result.value;
-        continue;
-      }
-      return result.value;
-    }
-  } catch (error) {
-    return (0, _neverthrow.err)(new _errors.AutomationError(error));
-  } finally {
-    await saveTraceIfNeeded({
-      errorMessage: "failed to save trace"
-    });
-    await context?.close();
-    if (downloadsPath !== undefined) {
-      await fs.remove(downloadsPath);
+      return await (0, _playwrightContext.withPlaywrightContext)({
+        cdpAddress: runOptions.cdpAddress,
+        ...playwrightContextParameters
+      }, runAutomationWithContext);
     }
   }
-}
-async function runApi(params) {
-  const generator = runApiGenerator(params);
-  const {
-    value,
-    done
-  } = await generator.next();
-  if (done) {
-    return value;
+  const result = await Promise.race([await runAutomation(), abortPromise]);
+  if (result === abortSymbol) {
+    return (0, _neverthrow.err)(new _errors.AbortedError());
   }
-  return (0, _neverthrow.err)(new _errors.InvalidApiError("Expected API to be async function, got async generator"));
+  return result;
 }
 async function checkAuthSessionWithRetries(page, context, checkFn, retries = 3) {
   if (retries === 0) {
@@ -248,34 +183,4 @@ async function checkAuthSessionWithRetries(page, context, checkFn, retries = 3)
     tryNumber++;
   }
   return (0, _neverthrow.ok)(false);
-}
-async function importUsingImportFunction(path, importFunction) {
-  try {
-    const importedResult = await importFunction(path);
-    if (importedResult.isErr()) {
-      if (importedResult.error.type === "not_found") {
-        return (0, _neverthrow.err)(new _errors.ApiNotFoundError(path));
-      }
-      return (0, _neverthrow.err)(new _errors.AutomationError(importedResult.error.error));
-    }
-    const imported = importedResult.value;
-    if (!imported || !imported.default || !imported.default.constructor) {
-      return (0, _neverthrow.err)(new _errors.InvalidApiError("API file path does not have a default export"));
-    }
-    if (imported.default.constructor.name === "AsyncGeneratorFunction") {
-      return (0, _neverthrow.ok)({
-        type: "async-generator",
-        generator: imported.default
-      });
-    }
-    if (imported.default.constructor.name === "AsyncFunction") {
-      return (0, _neverthrow.ok)({
-        type: "async",
-        func: imported.default
-      });
-    }
-    return (0, _neverthrow.err)(new _errors.InvalidApiError("API file path does not have a default async function/generator export"));
-  } catch (error) {
-    return (0, _neverthrow.err)(new _errors.AutomationError(error));
-  }
 }