@intuned/runtime-dev 0.0.1-testing.0 → 0.0.1

package/src/commands/auth-sessions/run-create.ts

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { Argument, program } from "commander";
+import { getDefaultExportFromFile } from "../common/getDefaultExportFromFile";
+import * as fs from "fs-extra";
+import { saveSession } from "../common/browserUtils";
+import { prompt } from "promptly";
+import { getFullPathInProject } from "../common/utils/fileUtils";
+import { getSettings } from "../common/utils/settings";
+import dotenv from "dotenv";
+import { AUTH_SESSIONS_FOLDER_NAME } from "../../common/constants";
+import { getPlaywrightConstructsForMode } from "../../common/getPlaywrightConstructs";
+
+dotenv.config({
+  path: `.env`,
+});
+
+program
+  .description("run auth session create")
+  .option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222")
+  .option("-i, --input [file]", "input json file")
+  .option("-j, --json [json]", "input json string")
+  .option(
+    "--authSessionPath <authSession>",
+    "auth session to use when executing the api"
+  )
+  .option(
+    "--pathToSave <pathToSave>",
+    "path to save the auth session, if not provided, will discard the auth session"
+  )
+  .allowUnknownOption()
+  .addArgument(
+    new Argument("<mode>", "mode of execution")
+      .choices(["vanilla", "playwright", "playwright-standalone"])
+      .default("playwright-standalone")
+      .argOptional()
+  )
+  .action(
+    async (
+      mode: "vanilla" | "playwright" | "playwright-standalone",
+      {
+        cdpAddress,
+        pathToSave,
+        input,
+        json,
+      }: {
+        cdpAddress: string;
+        pathToSave: string | undefined;
+        input: string;
+        json: string;
+      }
+    ) => {
+      let inputData: null | object = null;
+      if (input) {
+        inputData = await fs.readJSON(input);
+      } else if (json) {
+        inputData = JSON.parse(json);
+      } else {
+        inputData = {};
+      }
+
+      const setting = await getSettings();
+
+      if (!setting.authSessions.enabled) {
+        throw new Error("auth sessions feature is not enabled");
+      }
+
+      const createFilePath = getFullPathInProject(
+        AUTH_SESSIONS_FOLDER_NAME,
+        "create.ts"
+      );
+
+      if (!fs.exists(createFilePath)) {
+        throw new Error("auth session create file not found");
+      }
+
+      // Dynamically import the TypeScript file
+      const defaultExport = await getDefaultExportFromFile(createFilePath);
+      const { page, context } = await getPlaywrightConstructsForMode(
+        mode,
+        cdpAddress
+      );
+
+      const generator = await defaultExport(inputData, page, context, false);
+      let nextGeneratorParam: string | undefined = undefined;
+
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        const { value, done } = await generator.next(nextGeneratorParam);
+
+        if (done) {
+          if (pathToSave) {
+            await saveSession(pathToSave, context);
+          }
+          break;
+        }
+
+        if (
+          value.action === "request_more_info" &&
+          value.requestType == "multiple_choice"
+        ) {
+          nextGeneratorParam = await prompt(
+            value.messageToUser + `, choices: ${value.choices}`,
+            {
+              validator: (input) => {
+                if (!value.choices.includes(input)) {
+                  throw new Error("Please type on of the allowed choices");
+                }
+                return input;
+              },
+            }
+          );
+        } else if (
+          value.action === "request_more_info" &&
+          value.requestType == "otp"
+        ) {
+          nextGeneratorParam = await prompt(value.messageToUser, {});
+        }
+      }
+
+      process.exit(0);
+    }
+  );
+
+program.parse(process.argv);

package/src/commands/browser/save-state.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { saveSessionFromOpenedBrowser } from "../common/browserUtils";
+import dotenv from "dotenv";
+
+dotenv.config({
+  path: `.env`,
+});
+
+program
+  .description("save browser state to file storage.json")
+  .option("-p, --path [file]", "path for file", "./localSessions/default.json")
+  .allowUnknownOption()
+  .action(async ({ path }) => {
+    await saveSessionFromOpenedBrowser(path);
+    // playwright keeps an open handle to the connected browser and it stops the process from exiting
+    // there is no way to close the connection gracefully without destroying the context/browser
+    // https://github.com/microsoft/playwright/issues/4956
+    process.exit(0);
+  });
+
+program.parse(process.argv);

package/src/commands/browser/start-browser.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { startOrRestartBrowser } from "../common/browserUtils";
+import dotenv from "dotenv";
+
+dotenv.config({
+  path: `.env`,
+});
+
+program
+  .description("start browser testing purposes")
+  .allowUnknownOption()
+  .action(async () => {
+    await startOrRestartBrowser();
+  });
+
+program.parse(process.argv);

package/src/commands/build.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { program, Argument } from "commander";
+import { RollupBuild, RollupLog, rollup } from "rollup";
+import typescript from "@rollup/plugin-typescript";
+import commonjs from "@rollup/plugin-commonjs";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import dynamicImportVars from "@rollup/plugin-dynamic-import-vars";
+import json from "@rollup/plugin-json";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { moveWebTemplateFiles } from "./common/utils/webTemplate";
+
+function isThirdPartyWarning(warning: RollupLog) {
+  if (warning.id && /node_modules/.test(warning.id)) return true;
+  if (warning.ids && warning.ids.every((id) => /node_modules/.test(id)))
+    return true;
+
+  return false;
+}
+
+import dotenv from "dotenv";
+dotenv.config();
+
+program
+  .description("build the intuned server")
+  .addArgument(
+    new Argument("<mode>", "mode of execution")
+      .choices(["vanilla", "playwright"])
+      .default("playwright")
+      .argOptional()
+  )
+  .argument("[outfile]", "output bundle", "./output/bundle_v2.js")
+  .allowUnknownOption()
+  .action(async (mode, outfile) => {
+    await moveWebTemplateFiles();
+
+    const currentTemplateTsConfig = path.resolve(
+      __dirname,
+      "..",
+      "..",
+      "template.tsconfig.json"
+    );
+    await fs.copy(
+      currentTemplateTsConfig,
+      "./intuned/WebTemplate/tsconfig.json"
+    );
+
+    await build(outfile, mode);
+  });
+
+async function build(outfile: string, mode: "playwright" | "vanilla") {
+  let bundle: RollupBuild | null = null;
+  let buildFailed = false;
+
+  try {
+    // create a bundle
+    bundle = await rollup({
+      input: `./intuned/WebTemplate/index.${mode}.ts`,
+      output: {
+        globals: { crypto: "crypto" },
+      },
+      plugins: [
+        json(),
+        nodeResolve({ exportConditions: ["node"], preferBuiltins: true }),
+        typescript({ tsconfig: "./intuned/WebTemplate/tsconfig.json" }),
+        commonjs({
+          include: [
+            "node_modules/**",
+            "intuned/WebTemplate/**",
+            "dist",
+            "../runner/**",
+          ],
+          extensions: [".js"],
+          ignoreGlobal: false,
+          sourceMap: false,
+        }),
+        dynamicImportVars({
+          include: ["**/*.js", "**/*.ts"],
+          exclude: ["**/*.d.ts", "**/*.js.map"],
+        }),
+      ],
+      onwarn: (warning, warn) => {
+        if (isThirdPartyWarning(warning)) return;
+        warn(warning);
+      },
+      external: [
+        "@intuned/playwright",
+        "@intuned/playwright-core",
+        "jsdom",
+        "canvas",
+        "pdfjs-dist",
+        "pdf-to-png-converter",
+        "crypto",
+        "applicationinsights",
+        "fingerprint-generator",
+        "fingerprint-injector",
+      ],
+    });
+
+    console.log(`📦 Building ${outfile}`);
+    const outfileFolder = path.dirname(outfile);
+
+    // copy assets to outfile folder
+    const assetsDir = path.resolve(__dirname, "..", "common", "assets");
+    await fs.copy(assetsDir, `${outfileFolder}/assets`);
+
+    await bundle.write({
+      format: "cjs",
+      file: outfile,
+      inlineDynamicImports: true,
+    });
+
+    console.log(`✨ Build succeeded: ${outfile}`);
+  } catch (error) {
+    buildFailed = true;
+    console.error("error", error);
+  }
+
+  if (buildFailed) {
+    console.error("build failed");
+    process.exit(1);
+  }
+}
+
+program.parse(process.argv);

package/src/commands/common/browserUtils.ts

@@ -0,0 +1,80 @@
+// this file is to make testing easier only.
+
+import { spawn } from "child_process";
+import * as playwright from "@intuned/playwright-core";
+import * as fs from "fs-extra";
+import { BrowserContext } from "@intuned/playwright-core";
+import { getFullPathInProject } from "./utils/fileUtils";
+import { getContextStorageState } from "../../common/contextStorageStateHelpers";
+
+export const REMOTE_DEBUGGING_PORT = 9222;
+
+export const getChromiumLaunchArgs = () => [
+  "--no-sandbox",
+  `--remote-debugging-port=${REMOTE_DEBUGGING_PORT}`,
+  `--user-data-dir=/tmp/${Date.now()}`,
+  "--new-window",
+  "--start-maximized",
+  "--disable-popup-blocking",
+];
+
+// this is needed cause we need to keep the same browser instance alive between start recording and stop recording calls.
+async function getBrowser() {
+  let playwrightBrowser: playwright.Browser | null = null;
+
+  try {
+    playwrightBrowser = await playwright.chromium.connectOverCDP(
+      `http://localhost:${REMOTE_DEBUGGING_PORT}`
+    );
+  } catch (e) {
+    throw new Error("Browser is not running");
+  }
+
+  return playwrightBrowser;
+}
+
+export async function startOrRestartBrowser() {
+  const chromiumPath = await playwright.chromium.executablePath();
+
+  const chromeInstanceProcess = spawn(chromiumPath, getChromiumLaunchArgs());
+
+  chromeInstanceProcess.stdout.on("data", (data) => {
+    console.log(`Chrome stdout: ${data}`);
+  });
+
+  chromeInstanceProcess.stderr.on("data", (data) => {
+    console.error(`Chrome stderr: ${data}`);
+  });
+}
+
+export interface SessionState {
+  cookies: any[];
+  storage: Record<string, { localStorage: any; sessionStorage: any }>;
+}
+
+export async function saveSessionFromOpenedBrowser(path: string) {
+  const browser = await getBrowser();
+  const context = await browser.contexts()[0];
+
+  return saveSession(path, context);
+}
+
+export async function loadState(path: string, context: BrowserContext) {
+  const fullPath = getFullPathInProject(path);
+  if (!(await fs.pathExists(fullPath))) {
+    throw new Error("session file does not exist");
+  }
+
+  const data: SessionState = await fs.readJson(fullPath);
+
+  await context.addCookies(data.cookies);
+
+  // ToDo: logic to load storage without using the page.
+}
+
+export async function saveSession(path: string, context: BrowserContext) {
+  const fullState = await getContextStorageState(context);
+  const fullPath = getFullPathInProject(path);
+  fs.ensureFileSync(fullPath);
+  await fs.writeJSON(fullPath, fullState);
+}

package/src/commands/common/getDefaultExportFromFile.ts

@@ -0,0 +1,13 @@
+export async function getDefaultExportFromFile(apiFilePath: string) {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  require("ts-node").register({
+    transpileOnly: true,
+    compilerOptions: {
+      lib: ["dom", "es2020"],
+    },
+  });
+
+  const imported = await import(apiFilePath);
+  const defaultExport = imported.default;
+  return defaultExport;
+}

package/{dist/commands/common/getFirstLineNumber.test.js → src/commands/common/getFirstLineNumber.test.ts}

@@ -1,30 +1,33 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _getFirstLineNumber = _interopRequireDefault(require("./getFirstLineNumber"));
-var fs = _interopRequireWildcard(require("fs"));
-var path = _interopRequireWildcard(require("path"));
-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 && Object.prototype.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(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-(0, _vitest.describe)("getFirstLineNumber", () => {
+import { expect, describe, it, beforeAll, afterAll } from "vitest";
+import getFirstLineNumber from "./getFirstLineNumber";
+import * as fs from "fs";
+import * as path from "path";
+
+describe("getFirstLineNumber", () => {
   const testFilesDir = path.join(__dirname, "testFiles");
-  const createTestFile = (fileName, content) => {
+  const createTestFile = (fileName: string, content: string) => {
     const filePath = path.join(testFilesDir, fileName);
     fs.writeFileSync(filePath, content);
     return filePath;
   };
-  (0, _vitest.beforeAll)(() => {
+
+  beforeAll(() => {
     if (!fs.existsSync(testFilesDir)) {
       fs.mkdirSync(testFilesDir);
     }
   });
-  (0, _vitest.afterAll)(() => {
-    fs.readdirSync(testFilesDir).forEach(file => fs.unlinkSync(path.join(testFilesDir, file)));
+
+  afterAll(() => {
+    fs.readdirSync(testFilesDir).forEach((file) =>
+      fs.unlinkSync(path.join(testFilesDir, file))
+    );
     fs.rmdirSync(testFilesDir);
   });
-  (0, _vitest.it)("correctly identifies first line in a default exported named function", async () => {
-    const filePath = createTestFile("defaultFunction.ts", `import {
+
+  it("correctly identifies first line in a default exported named function", async () => {
+    const filePath = createTestFile(
+      "defaultFunction.ts",
+      `import {
         EnhancedPlaywrightPage,
         EnhancedPlaywrightBrowserContext,
         ExecutionHelpers,
@@ -45,12 +48,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
         await page.getByLabel("Search Wikipedia").press("Enter");
         return { done: "true", name: "custom name from api1" };
       }
-      `);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(4);
+      `
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4); // 4 is the index after it's compiled to commonjs
   });
-  (0, _vitest.it)("correctly identifies first line in a default exported anonymous function", async () => {
-    const filePath = createTestFile("defaultFunction.ts", `import {
+
+  it("correctly identifies first line in a default exported anonymous function", async () => {
+    const filePath = createTestFile(
+      "defaultFunction.ts",
+      `import {
         EnhancedPlaywrightPage,
         EnhancedPlaywrightBrowserContext,
         ExecutionHelpers,
@@ -71,12 +78,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
         await page.getByLabel("Search Wikipedia").press("Enter");
         return { done: "true", name: "custom name from api1" };
       }
-      `);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(4);
+      `
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
   });
-  (0, _vitest.it)("correctly identifies first line in a default exported function identifier", async () => {
-    const filePath = createTestFile("defaultFunction.ts", `import {
+
+  it("correctly identifies first line in a default exported function identifier", async () => {
+    const filePath = createTestFile(
+      "defaultFunction.ts",
+      `import {
         EnhancedPlaywrightPage,
         EnhancedPlaywrightBrowserContext,
         ExecutionHelpers,
@@ -98,12 +109,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
         return { done: "true", name: "custom name from api1" };
       }
       export default runApi;
-      `);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(4);
+      `
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
   });
-  (0, _vitest.it)("correctly identifies first line in a file with multiple exports including a default function", async () => {
-    const filePath = createTestFile("multipleExports.ts", `import {
+
+  it("correctly identifies first line in a file with multiple exports including a default function", async () => {
+    const filePath = createTestFile(
+      "multipleExports.ts",
+      `import {
         EnhancedPlaywrightPage,
         EnhancedPlaywrightBrowserContext,
         ExecutionHelpers,
@@ -125,12 +140,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
         await page.getByLabel("Search Wikipedia").press("Enter");
         return { done: "true", name: "custom name from api1" };
       }
-      export default runApi;`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(7);
+      export default runApi;`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(7);
   });
-  (0, _vitest.it)("correctly identifies first line in a default exported arrow function identifier", async () => {
-    const filePath = createTestFile("multipleExports.ts", `import {
+
+  it("correctly identifies first line in a default exported arrow function identifier", async () => {
+    const filePath = createTestFile(
+      "multipleExports.ts",
+      `import {
         EnhancedPlaywrightPage,
         EnhancedPlaywrightBrowserContext,
         ExecutionHelpers,
@@ -151,12 +170,16 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
         await page.getByLabel("Search Wikipedia").press("Enter");
         return { done: "true", name: "custom name from api1" };
       }
-      export default runApi;`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(4);
+      export default runApi;`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
   });
-  (0, _vitest.it)("correctly identifies first line in a default exported anonymous arrow function", async () => {
-    const filePath = createTestFile("multipleExports.ts", `import {
+
+  it("correctly identifies first line in a default exported anonymous arrow function", async () => {
+    const filePath = createTestFile(
+      "multipleExports.ts",
+      `import {
         EnhancedPlaywrightPage,
         EnhancedPlaywrightBrowserContext,
         ExecutionHelpers,
@@ -176,53 +199,76 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
         await page.getByLabel("Search Wikipedia").type(params.name);
         await page.getByLabel("Search Wikipedia").press("Enter");
         return { done: "true", name: "custom name from api1" };
-      };`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(4);
+      };`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
   });
-  (0, _vitest.it)("identifies first executable line in a default exported arrow function", async () => {
-    const filePath = createTestFile("defaultArrowFunction.ts", `export default () => {
+
+  it("identifies first executable line in a default exported arrow function", async () => {
+    const filePath = createTestFile(
+      "defaultArrowFunction.ts",
+      `export default () => {
            console.log("Hello, Arrow World!");
-         };`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(4);
+         };`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
   });
-  (0, _vitest.it)("identifies first executable line within nested functions of a default export", async () => {
-    const filePath = createTestFile("nestedFunctions.ts", `const x = 4;
+
+  it("identifies first executable line within nested functions of a default export", async () => {
+    const filePath = createTestFile(
+      "nestedFunctions.ts",
+      `const x = 4;
       export default function() {
            const nested = (x) => console.log("Nested function call");
            nested(x);
-         }`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(5);
+         }`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(5);
   });
-  (0, _vitest.it)("handles async default exported function correctly", async () => {
-    const filePath = createTestFile("asyncDefaultFunction.ts", `export default async function() {
+
+  it("handles async default exported function correctly", async () => {
+    const filePath = createTestFile(
+      "asyncDefaultFunction.ts",
+      `export default async function() {
            await Promise.resolve(console.log("Async Hello, World!"));
-       }`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(4);
+       }`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
   });
-  (0, _vitest.it)("returns -1 for a default exported class", async () => {
-    const filePath = createTestFile("defaultClass.ts", `export default class MyClass {
+
+  it("returns -1 for a default exported class", async () => {
+    const filePath = createTestFile(
+      "defaultClass.ts",
+      `export default class MyClass {
            constructor() {}
-         }`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(-1);
+         }`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(-1);
   });
-  (0, _vitest.it)("returns -1 for a default exported variable", async () => {
+
+  it("returns -1 for a default exported variable", async () => {
     const filePath = createTestFile("defaultVariable.ts", `export default 42;`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(-1);
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(-1);
   });
-  (0, _vitest.it)("returns -1 when there is no default export", async () => {
-    const filePath = createTestFile("noDefaultExport.ts", `export const foo = () => console.log("bar");`);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(-1);
+
+  it("returns -1 when there is no default export", async () => {
+    const filePath = createTestFile(
+      "noDefaultExport.ts",
+      `export const foo = () => console.log("bar");`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(-1);
   });
-  (0, _vitest.it)("returns -1 for an empty file", async () => {
+
+  it("returns -1 for an empty file", async () => {
     const filePath = createTestFile("emptyFile.ts", ``);
-    const result = await (0, _getFirstLineNumber.default)(filePath);
-    (0, _vitest.expect)(result.lineNumber).toBe(-1);
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(-1);
   });
-});
+});