@intuned/runtime-dev 1.3.1-api-token.5 → 1.3.3-fix.0

package/dist/common/{getPlaywrightConstructs.js → playwrightContext.js}

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getPlaywrightConstructsForMode = getPlaywrightConstructsForMode;
-exports.getProductionPlaywrightConstructs = getProductionPlaywrightConstructs;
+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;
@@ -14,7 +15,10 @@ var _contextStorageStateHelpers = require("./contextStorageStateHelpers");
 var _path = _interopRequireWildcard(require("path"));
 var _fileUtils = require("../commands/common/utils/fileUtils");
 var _waitOn = _interopRequireDefault(require("wait-on"));
-var _runtime = require("../runtime");
+var _errors = require("./runApi/errors");
+var _neverthrow = require("neverthrow");
+var _setupContextHook = require("./setupContextHook");
+var _portfinder = require("portfinder");
 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; }
@@ -33,22 +37,39 @@ async function createUserDirWithPreferences() {
   await (0, _fsExtra.writeFile)((0, _path.join)(defaultDir, "Preferences"), JSON.stringify(preferences));
   return userDir;
 }
-async function getProductionPlaywrightConstructs({
+async function launchChromium({
   proxy,
   headless = true,
-  storageState,
-  downloadsPath
+  downloadsPath,
+  cdpAddress,
+  cdpPort
 }) {
-  const extraArgs = ["--no-first-run", "--disable-sync", "--disable-translate", "--disable-features=TranslateUI", "--disable-features=NetworkService", "--lang=en"];
-  if (headless) {
-    extraArgs.push("--headless=new");
+  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
+    downloadsPath,
+    args: extraArgs
   });
   context.once("close", async () => {
     try {
@@ -62,80 +83,122 @@ async function getProductionPlaywrightConstructs({
       console.error("Failed to remove user data dir", error);
     }
   });
-  if (storageState) {
-    await loadSessionToContext({
-      context,
-      session: storageState
-    });
-  }
-  const assetsFile = _path.default.join(__dirname, "./assets/browser_scripts.js");
-  await context.addInitScript({
-    path: assetsFile
-  });
-  let page = context.pages().at(0);
-  if (page) {
-    const scriptString = await (0, _fsExtra.readFile)(assetsFile, "utf8");
-    await page.evaluate(scriptString);
-  } else {
-    page = await context.newPage();
+  if (cdpPort) {
+    const createdCdpAddress = getLocalCdpAddress(cdpPort);
+    await waitOnCdpAddress(createdCdpAddress);
   }
+  const page = context.pages().at(0) ?? (await context.newPage());
   return {
     page,
     context
   };
 }
-async function getPlaywrightConstructsForMode(mode, cdpAddress, authSession) {
-  if (mode == "playwright-standalone") {
-    if (!cdpAddress) {
-      throw new Error("cdpAddress is required");
-    }
-    const {
-      context
-    } = await getRemotePlaywrightContext(cdpAddress);
-    if (!context) {
-      throw new Error("no context found");
+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 setupContextHookResult = importFunction ? await (0, _setupContextHook.loadSetupContextHook)({
+      importFunction
+    }) : (0, _neverthrow.ok)(null);
+    if (setupContextHookResult.isErr()) {
+      return setupContextHookResult;
     }
-    const assetsFile = _path.default.join(__dirname, "./assets/browser_scripts.js");
-    await context.addInitScript({
-      path: assetsFile
-    });
-    const pages = await context.pages();
-    let page = null;
-    if (pages.length > 0) {
-      page = pages[0];
-      const scriptString = await fs.readFile(assetsFile, "utf8");
-      await page.evaluate(scriptString);
-    } else {
-      page = await context.newPage();
+    const setupContextHook = setupContextHookResult.value;
+    if (setupContextHook === null) {
+      if (cdpAddress !== undefined) {
+        ({
+          page,
+          context
+        } = await launchChromium({
+          cdpAddress
+        }));
+      } else {
+        ({
+          page,
+          context
+        } = await launchChromium({
+          proxy,
+          headless,
+          downloadsPath
+        }));
+      }
+      return await fn(context, page);
     }
-    if (authSession) {
-      await loadSessionToContext({
+    let hookCdpUrl = null;
+    if (cdpAddress) {
+      hookCdpUrl = cdpAddress;
+      ({
         context,
-        session: authSession
+        page
+      } = await launchChromium({
+        cdpAddress
+      }));
+    } else {
+      const port = await (0, _portfinder.getPort)({
+        port: 9222
       });
+      hookCdpUrl = getLocalCdpAddress(port);
+      ({
+        context,
+        page
+      } = await launchChromium({
+        proxy,
+        headless,
+        downloadsPath,
+        cdpPort: port
+      }));
     }
-    return {
-      page,
-      context
-    };
-  }
-  const downloadsPath = (0, _runtime.getDownloadDirectoryPath)();
-  if (mode === "playwright" || mode === "playwright-headless") {
-    const productionConstructs = await getProductionPlaywrightConstructs({
-      headless: mode === "playwright-headless",
-      downloadsPath
-    });
-    if (authSession) {
-      await loadSessionToContext({
-        context: productionConstructs.context,
-        session: authSession
+    let hookResult;
+    try {
+      hookResult = await setupContextHook({
+        apiName: apiName,
+        apiParameters: apiParameters,
+        cdpUrl: hookCdpUrl
       });
+    } catch (error) {
+      return (0, _neverthrow.err)(new _errors.AutomationError(error));
     }
-    return {
-      ...productionConstructs
-    };
+    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 _errors.AutomationError(e))
+      };
+    }
+    if ("throw" in result) {
+      throw result.throw;
+    }
+    return result.return;
+  } finally {
+    await context?.close();
   }
-  throw "invalid mode";
 }
 async function loadSessionToContext({
   context,
@@ -154,22 +217,28 @@ async function loadSessionToContext({
   }
   await (0, _contextStorageStateHelpers.setStorageState)(context, sessionToLoad);
 }
+function getLocalCdpAddress(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");
   }
-  const cdpAddressWithoutProtocol = cdpAddress.replace("http://", "").replace("https://", "").replace("localhost", "127.0.0.1");
   try {
-    await (0, _waitOn.default)({
-      resources: [`http-get://${cdpAddressWithoutProtocol}/json/version`],
-      delay: 100,
-      interval: 100,
-      timeout: 5000,
-      tcpTimeout: 1000,
-      window: 1000
-    });
+    await waitOnCdpAddress(cdpAddress);
   } catch (error) {
     console.error("Failed to connect to the browser");
     process.exit(128 + 9);

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"];