@intuned/runtime-dev 0.0.1-split.0

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/src/commands/common/getFirstLineNumber.test.ts

@@ -0,0 +1,274 @@
+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: string, content: string) => {
+    const filePath = path.join(testFilesDir, fileName);
+    fs.writeFileSync(filePath, content);
+    return filePath;
+  };
+
+  beforeAll(() => {
+    if (!fs.existsSync(testFilesDir)) {
+      fs.mkdirSync(testFilesDir);
+    }
+  });
+
+  afterAll(() => {
+    fs.readdirSync(testFilesDir).forEach((file) =>
+      fs.unlinkSync(path.join(testFilesDir, file))
+    );
+    fs.rmdirSync(testFilesDir);
+  });
+
+  it("correctly identifies first line in a default exported named function", async () => {
+    const filePath = createTestFile(
+      "defaultFunction.ts",
+      `import {
+        EnhancedPlaywrightPage,
+        EnhancedPlaywrightBrowserContext,
+        ExecutionHelpers,
+      } from "@intuned/runner";
+      interface Params {
+        name: string;
+        [key: string]: string | number | undefined;
+      }
+      export default async function runApi(
+        params: Params,
+        page: EnhancedPlaywrightPage,
+        context: EnhancedPlaywrightBrowserContext,
+        executionHelpers: ExecutionHelpers
+      ) {
+        await page.goto("https://www.wikipedia.org/");
+        await page.getByLabel("Search Wikipedia").click();
+        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 getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4); // 4 is the index after it's compiled to commonjs
+  });
+
+  it("correctly identifies first line in a default exported anonymous function", async () => {
+    const filePath = createTestFile(
+      "defaultFunction.ts",
+      `import {
+        EnhancedPlaywrightPage,
+        EnhancedPlaywrightBrowserContext,
+        ExecutionHelpers,
+      } from "@intuned/runner";
+      interface Params {
+        name: string;
+        [key: string]: string | number | undefined;
+      }
+      export default async function(
+        params: Params,
+        page: EnhancedPlaywrightPage,
+        context: EnhancedPlaywrightBrowserContext,
+        executionHelpers: ExecutionHelpers
+      ) {
+        await page.goto("https://www.wikipedia.org/");
+        await page.getByLabel("Search Wikipedia").click();
+        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 getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
+  });
+
+  it("correctly identifies first line in a default exported function identifier", async () => {
+    const filePath = createTestFile(
+      "defaultFunction.ts",
+      `import {
+        EnhancedPlaywrightPage,
+        EnhancedPlaywrightBrowserContext,
+        ExecutionHelpers,
+      } from "@intuned/runner";
+      interface Params {
+        name: string;
+        [key: string]: string | number | undefined;
+      }
+      async function runApi(
+        params: Params,
+        page: EnhancedPlaywrightPage,
+        context: EnhancedPlaywrightBrowserContext,
+        executionHelpers: ExecutionHelpers
+      ) {
+        await page.goto("https://www.wikipedia.org/");
+        await page.getByLabel("Search Wikipedia").click();
+        await page.getByLabel("Search Wikipedia").type(params.name);
+        await page.getByLabel("Search Wikipedia").press("Enter");
+        return { done: "true", name: "custom name from api1" };
+      }
+      export default runApi;
+      `
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
+  });
+
+  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,
+      } from "@intuned/runner";
+      interface Params {
+        name: string;
+        [key: string]: string | number | undefined;
+      }
+      export const foo = () => {};
+      async function runApi(
+        params: Params,
+        page: EnhancedPlaywrightPage,
+        context: EnhancedPlaywrightBrowserContext,
+        executionHelpers: ExecutionHelpers
+      ) {
+        await page.goto("https://www.wikipedia.org/");
+        await page.getByLabel("Search Wikipedia").click();
+        await page.getByLabel("Search Wikipedia").type(params.name);
+        await page.getByLabel("Search Wikipedia").press("Enter");
+        return { done: "true", name: "custom name from api1" };
+      }
+      export default runApi;`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(7);
+  });
+
+  it("correctly identifies first line in a default exported arrow function identifier", async () => {
+    const filePath = createTestFile(
+      "multipleExports.ts",
+      `import {
+        EnhancedPlaywrightPage,
+        EnhancedPlaywrightBrowserContext,
+        ExecutionHelpers,
+      } from "@intuned/runner";
+      interface Params {
+        name: string;
+        [key: string]: string | number | undefined;
+      }
+      const runApi = async (
+        params: Params,
+        page: EnhancedPlaywrightPage,
+        context: EnhancedPlaywrightBrowserContext,
+        executionHelpers: ExecutionHelpers
+      ) => {
+        await page.goto("https://www.wikipedia.org/");
+        await page.getByLabel("Search Wikipedia").click();
+        await page.getByLabel("Search Wikipedia").type(params.name);
+        await page.getByLabel("Search Wikipedia").press("Enter");
+        return { done: "true", name: "custom name from api1" };
+      }
+      export default runApi;`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
+  });
+
+  it("correctly identifies first line in a default exported anonymous arrow function", async () => {
+    const filePath = createTestFile(
+      "multipleExports.ts",
+      `import {
+        EnhancedPlaywrightPage,
+        EnhancedPlaywrightBrowserContext,
+        ExecutionHelpers,
+      } from "@intuned/runner";
+      interface Params {
+        name: string;
+        [key: string]: string | number | undefined;
+      }
+      export default async (
+        params: Params,
+        page: EnhancedPlaywrightPage,
+        context: EnhancedPlaywrightBrowserContext,
+        executionHelpers: ExecutionHelpers
+      ) => {
+        await page.goto("https://www.wikipedia.org/");
+        await page.getByLabel("Search Wikipedia").click();
+        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 getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
+  });
+
+  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 getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(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 getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(5);
+  });
+
+  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 getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(4);
+  });
+
+  it("returns -1 for a default exported class", async () => {
+    const filePath = createTestFile(
+      "defaultClass.ts",
+      `export default class MyClass {
+           constructor() {}
+         }`
+    );
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(-1);
+  });
+
+  it("returns -1 for a default exported variable", async () => {
+    const filePath = createTestFile("defaultVariable.ts", `export default 42;`);
+    const result = await getFirstLineNumber(filePath);
+    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);
+  });
+
+  it("returns -1 for an empty file", async () => {
+    const filePath = createTestFile("emptyFile.ts", ``);
+    const result = await getFirstLineNumber(filePath);
+    expect(result.lineNumber).toBe(-1);
+  });
+});

package/src/commands/common/getFirstLineNumber.ts

@@ -0,0 +1,146 @@
+import {
+  ts,
+  Project,
+  CompilerOptions,
+  ModuleKind,
+  ScriptTarget,
+  FunctionDeclaration,
+  SourceFile,
+  Node,
+} from "ts-morph";
+import { SourceMapConsumer } from "source-map";
+
+function compileTypeScript(apiFilePath: string) {
+  const compilerOptions: CompilerOptions = {
+    lib: ["dom", "es2020"],
+    sourceMap: true,
+    inlineSourceMap: true,
+    inlineSources: true,
+    declaration: false,
+    noEmit: false,
+    module: ModuleKind.CommonJS,
+    target: ScriptTarget.ES2020,
+  };
+  const project = new Project({
+    compilerOptions,
+  });
+  const sourceFile = project.addSourceFileAtPath(apiFilePath);
+  const outputJS = project.emitToMemory({ targetSourceFile: sourceFile });
+  const outputJSText = outputJS.getFiles()[0].text;
+  return { sourceFile, outputJSText };
+}
+
+export function findFirstExecutableLine(sourceFile: SourceFile) {
+  let functionBody: ReturnType<FunctionDeclaration["getBody"]>;
+
+  // Directly find the default exported function's body
+  const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
+  const defaultExportDeclaration = defaultExportSymbol?.getDeclarations()?.[0];
+  if (defaultExportDeclaration) {
+    // Check if the default export is a function
+    if (
+      defaultExportDeclaration.getKind() === ts.SyntaxKind.FunctionDeclaration
+    ) {
+      functionBody = (
+        defaultExportDeclaration as FunctionDeclaration
+      ).getBody();
+    } else {
+      // Handle ExportAssignment specifically for cases like `export default identifier;`
+      const exportAssignments = sourceFile.getExportAssignments();
+      for (const exportAssignment of exportAssignments) {
+        const expression = exportAssignment.getExpression();
+        if (!expression) continue;
+
+        if (
+          expression.getKind() === ts.SyntaxKind.Identifier ||
+          expression.getKind() === ts.SyntaxKind.FunctionExpression ||
+          expression.getKind() === ts.SyntaxKind.ArrowFunction
+        ) {
+          const identifier = expression.getText();
+          const possiblyExportedFunction =
+            sourceFile.getFunction(identifier) ||
+            (sourceFile
+              .getVariableStatement(identifier)
+              ?.getDescendants()
+              .find(
+                (node) =>
+                  node.getKind() === ts.SyntaxKind.FunctionExpression ||
+                  node.getKind() === ts.SyntaxKind.ArrowFunction
+              ) as FunctionDeclaration);
+          if (possiblyExportedFunction) {
+            functionBody = possiblyExportedFunction.getBody();
+            break;
+          }
+        }
+        if (
+          Node.hasBody(expression) &&
+          (expression.getKind() === ts.SyntaxKind.FunctionExpression ||
+            expression.getKind() === ts.SyntaxKind.ArrowFunction)
+        ) {
+          // As these are anonymous, we directly access their body
+          functionBody = expression.getBody() as ReturnType<
+            FunctionDeclaration["getBody"]
+          >;
+          break;
+        }
+      }
+    }
+  }
+  if (!functionBody || !Node.isStatemented(functionBody)) {
+    return -1;
+  }
+  if (functionBody.getStatements().length === 0) {
+    return -1;
+  }
+  const position = functionBody.getStatements()[0].getStart();
+  return sourceFile.getLineAndColumnAtPos(position);
+}
+
+async function getSourceMap(jsCode: string) {
+  const sourceMapBase64 = jsCode.substring(
+    jsCode.lastIndexOf("//# sourceMappingURL=data:application/json;base64,") +
+      "//# sourceMappingURL=data:application/json;base64,".length
+  );
+  const sourceMapText = Buffer.from(sourceMapBase64, "base64").toString(
+    "utf-8"
+  );
+  const sourceMap = JSON.parse(sourceMapText);
+  return new SourceMapConsumer(sourceMap);
+}
+
+async function mapFirstLineNumberBySourceMap(
+  sourceFileName: string,
+  jsCode: string,
+  line: number,
+  column: number
+) {
+  const sourceMap = await getSourceMap(jsCode);
+  const generatedLineNumber = sourceMap.generatedPositionFor({
+    source: sourceFileName,
+    line,
+    column,
+  }).line;
+  if (!generatedLineNumber) return -1;
+  return generatedLineNumber;
+}
+
+export default async function getFirstLineNumber(apiFilePath: string) {
+  const sourceFileName = apiFilePath.split("/").pop() ?? apiFilePath;
+
+  // Compile TypeScript to JavaScript and get the Typescript AST
+  const { sourceFile, outputJSText } = compileTypeScript(apiFilePath);
+
+  // Find the first line of code in the default export ts code
+  const result = findFirstExecutableLine(sourceFile);
+  if (result === -1) return { sourceFileName, lineNumber: -1 };
+
+  return {
+    sourceFileName,
+    lineNumber: await mapFirstLineNumberBySourceMap(
+      sourceFileName,
+      outputJSText,
+      result.line,
+      result.column
+    ),
+  };
+}

package/src/commands/common/sendMessageToClient.ts

@@ -0,0 +1,8 @@
+// Send information to the parent process where it should continue the debugger
+// This is handled by DebuggingProcessManager
+export const sendBreakPointOnToClient = (
+  sourceFileName: string,
+  lineNumber: number
+) => {
+  console.log(`breakpoint on ${sourceFileName}:${lineNumber}`);
+};

package/src/commands/common/utils/fileUtils.ts

@@ -0,0 +1,25 @@
+import * as path from "path";
+import * as fs from "fs-extra";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+// TODO: todo-identity handle identity instances
+export function getFullPathInProject(...paths: string[]) {
+  return path.resolve(process.cwd(), process.env.ROOT || "./", ...paths);
+}
+
+export async function listProjectFilesAndFolders() {
+  const projectPath = path.resolve(process.cwd(), process.env.ROOT || "./");
+  try {
+    const files = await fs.readdir(projectPath, { withFileTypes: true });
+    return files.map((file) => ({
+      type: file.isDirectory() ? ("Folder" as const) : ("File" as const),
+      fullPath: path.join(projectPath, file.name),
+      name: file.name,
+    }));
+  } catch (err) {
+    console.error("Error reading the directory:", err);
+    throw err;
+  }
+}

package/src/commands/common/utils/settings.ts

@@ -0,0 +1,23 @@
+import { getFullPathInProject } from "./fileUtils";
+import {
+  IntunedSettings,
+  settingsSchema,
+} from "../../../common/settingsSchema";
+
+export async function getSettings(): Promise<IntunedSettings> {
+  const settingsFilePath = getFullPathInProject("Intuned.json");
+  console.log("loading settings");
+
+  const settings = await import(settingsFilePath);
+  if (settings.default) {
+    const parsed = settingsSchema.safeParse(settings.default);
+    if (parsed.success) {
+      return parsed.data;
+    } else {
+      // ToDo: why does the type not work here?
+      throw new Error((parsed as any).error.message);
+    }
+  }
+
+  return { authSessions: { enabled: false } };
+}

package/src/commands/common/utils/webTemplate.ts

@@ -0,0 +1,46 @@
+import * as fs from "fs-extra";
+import * as path from "path";
+
+import { getFullPathInProject, listProjectFilesAndFolders } from "./fileUtils";
+
+export const moveWebTemplateFiles = async () => {
+  await fs.remove("./intuned");
+  await fs.ensureDir("./intuned");
+
+  const currentFileLocation = path.resolve(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "..",
+    "WebTemplate"
+  );
+
+  // copy WebTemplate to ./intuned
+  await fs.copy(`${currentFileLocation}`, "./intuned/WebTemplate", {
+    filter: (src, dest) => {
+      if (src.includes(".d.ts")) {
+        return false;
+      }
+
+      return true;
+    },
+  });
+
+  const filesAndFolders = await listProjectFilesAndFolders();
+  const pathsIgnoreList = [
+    getFullPathInProject("intuned"),
+    getFullPathInProject("node_modules"),
+    getFullPathInProject("package.json"),
+    getFullPathInProject("yarn.lock"),
+    getFullPathInProject(".env"),
+  ];
+
+  const filesToCopy = filesAndFolders.filter(
+    (file) => !pathsIgnoreList.includes(file.fullPath)
+  );
+
+  for (const file of filesToCopy) {
+    await fs.copy(file.fullPath, `./intuned/WebTemplate/${file.name}`);
+  }
+};

package/src/commands/testing/saveVisibleHtml.ts

@@ -0,0 +1,29 @@
+import * as fs from "fs-extra";
+import dotenv from "dotenv";
+// import { getPageVisiblePageHtml } from "../../common/playwrightPageHelpers";
+import { getPlaywrightConstructsForMode } from "../../common/getPlaywrightConstructs";
+
+dotenv.config({
+  path: `.env`,
+});
+
+async function main() {
+  const { page } = await getPlaywrightConstructsForMode(
+    "playwright",
+    undefined
+  );
+
+  await page.goto(
+    "https://www.marriott.com/search/findHotels.mi?roomTypeCode=&recordsPerPage=20&autoSuggestItemType=&destinationAddress.types=locality,political&destinationAddress.latitude=47.6061389&propertyCode=&destinationAddress.stateProvinceShort=&isInternalSearch=true&destinationAddress.cityPopulation=&vsInitialRequest=false&searchType=InCity&destinationAddress.locality=&showAddressPin=&miniStoreFormSubmit=&destinationAddress.stateProvinceDisplayName=&destinationAddress.destinationPageDestinationAddress=&countryName=&destinationAddress.stateProvince=WA&searchRadius=50.0&singleSearchAutoSuggest=Unmatched&missingcheckInDateMsg=Please+enter+a+check-in+date.&destinationAddress.placeId=ChIJVTPokywQkFQRmtVEaUZlJRA&is-hotelsnearme-clicked=false&destinationAddress.addressline1=&airportName=&for-hotels-nearme=Near&missingcheckOutDateMsg=Please+enter+a+check-out+date.&suggestionsPropertyCode=&pageType=advanced&destinationAddress.country=US&destinationAddress.name=&poiCity=&destinationAddress.countryShort=&marriottBrands=&poiName=&destinationAddress.address=Seattle,+WA,+USA&search-countryRegion=&collapseAccordian=is-hidden&singleSearch=true&destinationAddress.cityPopulationDensity=&destinationAddress.secondaryText=WA,+USA&destinationAddress.postalCode=&destinationAddress.city=Seattle&destinationAddress.mainText=Seattle&airportCode=&isTransient=true&destinationAddress.longitude=-122.3328481&initialRequest=false&destinationAddress.website=https://maps.google.com/?q=Seattle,+WA,+USA&ftid=0x5490102c93e83355:0x102565466944d59a&search-locality=&dimensions=0&roomTypeCode=&propertyCode=&flexibleDateSearchRateDisplay=false&propertyName=&isSearch=true&marriottRewardsNumber=&isRateCalendar=false&incentiveType_Number=&incentiveType=&flexibleDateLowestRateMonth=&flexibleDateLowestRateDate=&marrOfferId=&isMultiRateSearch=&multiRateMaxCount=&multiRateCorpCodes=&useMultiRateRewardsPoints=&multiRateClusterCodes=&multiRateCorpCodesEntered=&lowestRegularRate=&js-location-nearme-values=&destinationAddress.destination=Seattle,+WA,+USA&fromToDate=10/07/2023&fromToDate_submit=10/08/2023&fromDate=10/07/2023&toDate=10/08/2023&toDateDefaultFormat=10/08/2023&fromDateDefaultFormat=10/07/2023&flexibleDateSearch=false&isHideFlexibleDateCalendar=false&t-start=2023-10-07&t-end=2023-10-08&lengthOfStay=1&roomCountBox=1+Room&roomCount=1&guestCountBox=1+Adult+Per+Room&numAdultsPerRoom=1&childrenCountBox=0+Children+Per+Room&childrenCount=0&childrenAges=&clusterCode=none&corporateCode=&useRewardsPoints=true&view=list#/0/",
+    { waitUntil: "load" }
+  );
+  await page.waitForTimeout(10000);
+
+  const html = ""; // await getPageVisiblePageHtml(page);
+
+  await fs.writeFile("./htmlFiles/marriott.html", html);
+
+  process.exit();
+}
+
+void main();