@intuned/runtime-dev 0.1.0-test.11 → 0.1.0-test.13

package/.babelrc

@@ -13,7 +13,6 @@
     "@babel/preset-typescript"
   ],
   "plugins": [
-    // ["./preserve-dynamic-imports.js"],
     "babel-plugin-macros",
     "@babel/plugin-syntax-dynamic-import",
     "@babel/plugin-transform-export-namespace-from"

package/dist/commands/api/run.js

@@ -12,94 +12,167 @@ import chalk from "chalk";
 import { runApi } from "../../common/runApi";
 import { AutomationError } from "../../common/runApi";
 dotenv.config({
-  path: `.env`
+    path: `.env`,
 });
 export async function executeCLI(apiName, mode, inputData, options) {
-  cleanEnvironmentVariables();
-  let authSessionPathToUse = null;
-  const settings = await getSettings();
-  if (settings.authSessions.enabled) {
-    if (!options.authSessionPath) {
-      throw new Error("Auth session is enabled but no auth session provided");
+    // cleanup environment variables before running the user code
+    cleanEnvironmentVariables();
+    let authSessionPathToUse = null;
+    // check auth session
+    const settings = await getSettings();
+    if (settings.authSessions.enabled) {
+        // if auth session enabled, check if the auth session is provided
+        if (!options.authSessionPath) {
+            throw new Error("Auth session is enabled but no auth session provided");
+        }
+        authSessionPathToUse = options.authSessionPath;
     }
-    authSessionPathToUse = options.authSessionPath;
-  } else {
-    if (options.authSessionPath) {
-      throw new Error("Auth session is not enabled but auth session provided. To use auth session please enable it in Intuned.json");
+    else {
+        // if auth session is not enabled, check if the auth session is provided
+        if (options.authSessionPath) {
+            throw new Error("Auth session is not enabled but auth session provided. To use auth session please enable it in Intuned.json");
+        }
     }
-  }
-  const runApiResult = await runApi({
-    automationFunction: {
-      name: `api/${apiName}`,
-      params: inputData ?? {}
-    },
-    auth: authSessionPathToUse ? {
-      session: {
-        type: "file",
-        path: authSessionPathToUse
-      },
-      runCheck: false
-    } : undefined,
-    runOptions: {
-      environment: "ide",
-      cdpAddress: options.cdpAddress,
-      mode
+    // Dynamically import the TypeScript file
+    // const defaultExport = await getDefaultExportFromFile(apiFilePath);
+    // const isDebug = process.execArgv.some((arg) => arg.includes("--inspect"));
+    // if (isDebug) {
+    //   const { sourceFileName, lineNumber } = await getFirstLineNumber(
+    //     apiFilePath
+    //   );
+    //   sendBreakPointOnToClient(sourceFileName, lineNumber);
+    // }
+    // if (mode === "vanilla") {
+    // Execute the function with the input data
+    //   const result = await defaultExport(inputData);
+    //   return result;
+    // }
+    // const { page, context } = await getPlaywrightConstructsForMode(
+    //   mode,
+    //   options.cdpAddress,
+    //   authSessionPathToUse ? authSessionPathToUse : undefined
+    // );
+    // // wait for the page to get stable, this is a workaround for a bug in playwright when you try to do something
+    // // on a page after connecting to it immediately, the page needs some time to get stable.
+    // let isPageStable = false;
+    // let retry = 0;
+    // // will wait maximum 2 seconds before failing.
+    // while (!isPageStable && retry < 10) {
+    //   try {
+    //     await page.locator("html").all();
+    //     isPageStable = true;
+    //     break;
+    //   } catch (error) {
+    //     if (error?.message?.includes("Execution context was destroyed")) {
+    //       await new Promise((resolve) => setTimeout(resolve, 200));
+    //     } else {
+    //       // throwing to make sure we do not hide any other unexpected issues.
+    //       throw error;
+    //     }
+    //   }
+    //   retry++;
+    // }
+    // if (!isPageStable) {
+    //   throw new Error("The page is not stable, try to run again.");
+    // }
+    const runApiResult = await runApi({
+        automationFunction: {
+            name: `api/${apiName}`,
+            params: inputData ?? {},
+        },
+        auth: authSessionPathToUse
+            ? {
+                session: {
+                    type: "file",
+                    path: authSessionPathToUse,
+                },
+                runCheck: false,
+            }
+            : undefined,
+        runOptions: {
+            environment: "ide",
+            cdpAddress: options.cdpAddress,
+            mode,
+        },
+    });
+    if (runApiResult.isErr()) {
+        if (runApiResult.error instanceof AutomationError) {
+            throw runApiResult.error.error;
+        }
+        console.error("An error occurred while running the API", runApiResult.error);
+        return;
     }
-  });
-  if (runApiResult.isErr()) {
-    if (runApiResult.error instanceof AutomationError) {
-      throw runApiResult.error.error;
+    const { result, extendedPayloads: payloadToAppend } = runApiResult.value;
+    const isResponseObject = typeof result === "object" && result !== null;
+    const hasMoreThank5Keys = isResponseObject && Object.keys(result).length > 5;
+    const hasNestedObjects = isResponseObject &&
+        Object.values(result).some((value) => typeof value === "object");
+    const shouldWriteToFile = isResponseObject && (hasMoreThank5Keys || hasNestedObjects);
+    const resultsDir = "/tmp/run-results";
+    if (options.outputFileId && shouldWriteToFile) {
+        logger.info(chalk.underline.bgBlue.white(`Click to Open: Results saved (Run: ${options.outputFileId})`));
+        fs.ensureDirSync(resultsDir);
+        const path = `${resultsDir}/${options.outputFileId}.json`;
+        await fs.writeJson(path, result, {
+            spaces: 2,
+        });
+    }
+    else {
+        console.log("result:", result);
+    }
+    const hasPayloadToAppend = payloadToAppend && payloadToAppend.length > 0;
+    if (hasPayloadToAppend && options.outputFileId) {
+        logger.info(chalk.underline.bgBlue.white(`Click to Open: payloads to append (Run: ${options.outputFileId})`));
+        fs.ensureDirSync(resultsDir);
+        const path = `${resultsDir}/${options.outputFileId}-payloads-to-append.json`;
+        await fs.writeJson(path, payloadToAppend, {
+            spaces: 2,
+        });
+    }
+    else if (hasPayloadToAppend) {
+        logger.info("payload to append:", payloadToAppend);
+        logger.info("This will only take an effect if this API run was part of a job.");
     }
-    console.error("An error occurred while running the API", runApiResult.error);
-    return;
-  }
-  const {
-    result,
-    extendedPayloads: payloadToAppend
-  } = runApiResult.value;
-  const isResponseObject = typeof result === "object" && result !== null;
-  const hasMoreThank5Keys = isResponseObject && Object.keys(result).length > 5;
-  const hasNestedObjects = isResponseObject && Object.values(result).some(value => typeof value === "object");
-  const shouldWriteToFile = isResponseObject && (hasMoreThank5Keys || hasNestedObjects);
-  const resultsDir = "/tmp/run-results";
-  if (options.outputFileId && shouldWriteToFile) {
-    logger.info(chalk.underline.bgBlue.white(`Click to Open: Results saved (Run: ${options.outputFileId})`));
-    fs.ensureDirSync(resultsDir);
-    const path = `${resultsDir}/${options.outputFileId}.json`;
-    await fs.writeJson(path, result, {
-      spaces: 2
-    });
-  } else {
-    console.log("result:", result);
-  }
-  const hasPayloadToAppend = payloadToAppend && payloadToAppend.length > 0;
-  if (hasPayloadToAppend && options.outputFileId) {
-    logger.info(chalk.underline.bgBlue.white(`Click to Open: payloads to append (Run: ${options.outputFileId})`));
-    fs.ensureDirSync(resultsDir);
-    const path = `${resultsDir}/${options.outputFileId}-payloads-to-append.json`;
-    await fs.writeJson(path, payloadToAppend, {
-      spaces: 2
-    });
-  } else if (hasPayloadToAppend) {
-    logger.info("payload to append:", payloadToAppend);
-    logger.info("This will only take an effect if this API run was part of a job.");
-  }
 }
-program.description("run the user function in the cli for testing purposes").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").option("--outputFileId <outputFileId>", "the output file id to save the result in").option("--proxy <proxy>", "proxy to use").argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(new Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone", "playwright-headless"]).default("playwright-standalone").argOptional()).action(async (apiName, mode, options) => {
-  let inputData = null;
-  if (options.input) {
-    inputData = await fs.readJSON(options.input);
-  } else if (options.json) {
-    inputData = JSON.parse(options.json);
-  } else {
-    inputData = {};
-  }
-  await runWithContext({
-    runEnvironment: RunEnvironment.IDE,
-    extendedPayloads: [],
-    runId: nanoid(),
-    proxy: options.proxy
-  }, () => executeCLI(apiName, mode, inputData, options));
-  process.exit(0);
+program
+    .description("run the user function in the cli for testing purposes")
+    .option("-i, --input [file]", "input json file")
+    .option("-j, --json [json]", "input json string")
+    .option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222")
+    .option("--authSessionPath <authSession>", "auth session to use when executing the api")
+    .option("--outputFileId <outputFileId>", "the output file id to save the result in")
+    .option("--proxy <proxy>", "proxy to use")
+    .argument("[apiName]", "name of the api", "default")
+    .allowUnknownOption()
+    .addArgument(new Argument("<mode>", "mode of execution")
+    .choices([
+    "vanilla",
+    "playwright",
+    "playwright-standalone",
+    "playwright-headless",
+])
+    .default("playwright-standalone")
+    .argOptional())
+    .action(async (apiName, mode, options) => {
+    let inputData = null;
+    if (options.input) {
+        inputData = await fs.readJSON(options.input);
+    }
+    else if (options.json) {
+        inputData = JSON.parse(options.json);
+    }
+    else {
+        inputData = {};
+    }
+    await runWithContext({
+        runEnvironment: RunEnvironment.IDE,
+        extendedPayloads: [],
+        runId: nanoid(),
+        proxy: options.proxy,
+    }, () => executeCLI(apiName, mode, inputData, options));
+    // 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);
+program.parse(process.argv);

package/dist/commands/api/run.ts

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { program, Argument } from "commander";
+import * as fs from "fs-extra";
+import { getSettings } from "../common/utils/settings";
+import dotenv from "dotenv";
+import { runWithContext } from "../../common/asyncLocalStorage";
+import { RunEnvironment } from "../../runtime/enums";
+import { cleanEnvironmentVariables } from "../../common/cleanEnvironmentVariables";
+import { logger } from "../../common/Logger";
+import { nanoid } from "nanoid";
+import chalk from "chalk";
+import { runApi } from "../../common/runApi";
+import { AutomationError } from "../../common/runApi";
+dotenv.config({
+  path: `.env`
+});
+export async function executeCLI(apiName, mode, inputData, options) {
+  cleanEnvironmentVariables();
+  let authSessionPathToUse = null;
+  const settings = await getSettings();
+  if (settings.authSessions.enabled) {
+    if (!options.authSessionPath) {
+      throw new Error("Auth session is enabled but no auth session provided");
+    }
+    authSessionPathToUse = options.authSessionPath;
+  } else {
+    if (options.authSessionPath) {
+      throw new Error("Auth session is not enabled but auth session provided. To use auth session please enable it in Intuned.json");
+    }
+  }
+  const runApiResult = await runApi({
+    automationFunction: {
+      name: `api/${apiName}`,
+      params: inputData ?? {}
+    },
+    auth: authSessionPathToUse ? {
+      session: {
+        type: "file",
+        path: authSessionPathToUse
+      },
+      runCheck: false
+    } : undefined,
+    runOptions: {
+      environment: "ide",
+      cdpAddress: options.cdpAddress,
+      mode
+    }
+  });
+  if (runApiResult.isErr()) {
+    if (runApiResult.error instanceof AutomationError) {
+      throw runApiResult.error.error;
+    }
+    console.error("An error occurred while running the API", runApiResult.error);
+    return;
+  }
+  const {
+    result,
+    extendedPayloads: payloadToAppend
+  } = runApiResult.value;
+  const isResponseObject = typeof result === "object" && result !== null;
+  const hasMoreThank5Keys = isResponseObject && Object.keys(result).length > 5;
+  const hasNestedObjects = isResponseObject && Object.values(result).some(value => typeof value === "object");
+  const shouldWriteToFile = isResponseObject && (hasMoreThank5Keys || hasNestedObjects);
+  const resultsDir = "/tmp/run-results";
+  if (options.outputFileId && shouldWriteToFile) {
+    logger.info(chalk.underline.bgBlue.white(`Click to Open: Results saved (Run: ${options.outputFileId})`));
+    fs.ensureDirSync(resultsDir);
+    const path = `${resultsDir}/${options.outputFileId}.json`;
+    await fs.writeJson(path, result, {
+      spaces: 2
+    });
+  } else {
+    console.log("result:", result);
+  }
+  const hasPayloadToAppend = payloadToAppend && payloadToAppend.length > 0;
+  if (hasPayloadToAppend && options.outputFileId) {
+    logger.info(chalk.underline.bgBlue.white(`Click to Open: payloads to append (Run: ${options.outputFileId})`));
+    fs.ensureDirSync(resultsDir);
+    const path = `${resultsDir}/${options.outputFileId}-payloads-to-append.json`;
+    await fs.writeJson(path, payloadToAppend, {
+      spaces: 2
+    });
+  } else if (hasPayloadToAppend) {
+    logger.info("payload to append:", payloadToAppend);
+    logger.info("This will only take an effect if this API run was part of a job.");
+  }
+}
+program.description("run the user function in the cli for testing purposes").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").option("--outputFileId <outputFileId>", "the output file id to save the result in").option("--proxy <proxy>", "proxy to use").argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(new Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone", "playwright-headless"]).default("playwright-standalone").argOptional()).action(async (apiName, mode, options) => {
+  let inputData = null;
+  if (options.input) {
+    inputData = await fs.readJSON(options.input);
+  } else if (options.json) {
+    inputData = JSON.parse(options.json);
+  } else {
+    inputData = {};
+  }
+  await runWithContext({
+    runEnvironment: RunEnvironment.IDE,
+    extendedPayloads: [],
+    runId: nanoid(),
+    proxy: options.proxy
+  }, () => executeCLI(apiName, mode, inputData, options));
+  process.exit(0);
+});
+program.parse(process.argv);

package/dist/commands/auth-sessions/load.js

@@ -5,26 +5,26 @@ import { getSettings } from "../common/utils/settings";
 import dotenv from "dotenv";
 import { loadSessionToContext } from "../../common/getPlaywrightConstructs";
 dotenv.config({
-  path: `.env`
+    path: `.env`,
 });
-program.description("load auth session to browser").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").allowUnknownOption().action(async ({
-  cdpAddress,
-  authSessionPath
-}) => {
-  const setting = await getSettings();
-  if (!setting.authSessions.enabled) {
-    throw new Error("Auth session is not enabled");
-  }
-  const {
-    context
-  } = await getRemotePlaywrightContext(cdpAddress);
-  await loadSessionToContext({
-    context,
-    session: {
-      type: "file",
-      path: authSessionPath
+program
+    .description("load auth session to browser")
+    .option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222")
+    .option("--authSessionPath <authSession>", "auth session to use when executing the api")
+    .allowUnknownOption()
+    .action(async ({ cdpAddress, authSessionPath, }) => {
+    const setting = await getSettings();
+    if (!setting.authSessions.enabled) {
+        throw new Error("Auth session is not enabled");
     }
-  });
-  process.exit(0);
+    const { context } = await getRemotePlaywrightContext(cdpAddress);
+    await loadSessionToContext({
+        context,
+        session: {
+            type: "file",
+            path: authSessionPath,
+        },
+    });
+    process.exit(0);
 });
-program.parse(process.argv);
+program.parse(process.argv);

package/dist/commands/auth-sessions/load.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { getRemotePlaywrightContext } from "../../common/getPlaywrightConstructs";
+import { getSettings } from "../common/utils/settings";
+import dotenv from "dotenv";
+import { loadSessionToContext } from "../../common/getPlaywrightConstructs";
+dotenv.config({
+  path: `.env`
+});
+program.description("load auth session to browser").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").allowUnknownOption().action(async ({
+  cdpAddress,
+  authSessionPath
+}) => {
+  const setting = await getSettings();
+  if (!setting.authSessions.enabled) {
+    throw new Error("Auth session is not enabled");
+  }
+  const {
+    context
+  } = await getRemotePlaywrightContext(cdpAddress);
+  await loadSessionToContext({
+    context,
+    session: {
+      type: "file",
+      path: authSessionPath
+    }
+  });
+  process.exit(0);
+});
+program.parse(process.argv);

package/dist/commands/auth-sessions/run-check.js

@@ -7,45 +7,51 @@ import dotenv from "dotenv";
 import { AUTH_SESSIONS_FOLDER_NAME } from "../../common/constants";
 import { runApi } from "../../common/runApi";
 dotenv.config({
-  path: `.env`
+    path: `.env`,
 });
-program.description("run auth session check").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the check").allowUnknownOption().addArgument(new Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
-  cdpAddress,
-  authSessionPath
-}) => {
-  const setting = await getSettings();
-  if (!setting.authSessions.enabled) {
-    throw new Error("auth session is not enabled");
-  }
-  const checkFilePath = getFullPathInProject(AUTH_SESSIONS_FOLDER_NAME, "check");
-  if (!fs.exists(checkFilePath)) {
-    throw new Error("auth session check file not found");
-  }
-  const runApiResult = await runApi({
-    automationFunction: {
-      name: `${AUTH_SESSIONS_FOLDER_NAME}/check`
-    },
-    runOptions: {
-      environment: "ide",
-      mode,
-      cdpAddress
-    },
-    auth: {
-      session: {
-        type: "file",
-        path: authSessionPath
-      },
-      runCheck: false
+program
+    .description("run auth session check")
+    .option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222")
+    .option("--authSessionPath <authSession>", "auth session to use when executing the check")
+    .allowUnknownOption()
+    .addArgument(new Argument("<mode>", "mode of execution")
+    .choices(["vanilla", "playwright", "playwright-standalone"])
+    .default("playwright-standalone")
+    .argOptional())
+    .action(async (mode, { cdpAddress, authSessionPath, }) => {
+    const setting = await getSettings();
+    if (!setting.authSessions.enabled) {
+        throw new Error("auth session is not enabled");
     }
-  });
-  if (runApiResult.isErr()) {
-    throw new Error(runApiResult.error);
-  }
-  const result = runApiResult.value.result;
-  console.log("check result", result);
-  if (!result) {
-    throw new Error("auth session check failed");
-  }
-  process.exit(0);
+    const checkFilePath = getFullPathInProject(AUTH_SESSIONS_FOLDER_NAME, "check");
+    if (!fs.exists(checkFilePath)) {
+        throw new Error("auth session check file not found");
+    }
+    const runApiResult = await runApi({
+        automationFunction: {
+            name: `${AUTH_SESSIONS_FOLDER_NAME}/check`,
+        },
+        runOptions: {
+            environment: "ide",
+            mode,
+            cdpAddress,
+        },
+        auth: {
+            session: {
+                type: "file",
+                path: authSessionPath,
+            },
+            runCheck: false,
+        },
+    });
+    if (runApiResult.isErr()) {
+        throw new Error(runApiResult.error);
+    }
+    const result = runApiResult.value.result;
+    console.log("check result", result);
+    if (!result) {
+        throw new Error("auth session check failed");
+    }
+    process.exit(0);
 });
-program.parse(process.argv);
+program.parse(process.argv);

package/dist/commands/auth-sessions/run-check.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { Argument, program } from "commander";
+import * as fs from "fs-extra";
+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 { runApi } from "../../common/runApi";
+dotenv.config({
+  path: `.env`
+});
+program.description("run auth session check").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the check").allowUnknownOption().addArgument(new Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
+  cdpAddress,
+  authSessionPath
+}) => {
+  const setting = await getSettings();
+  if (!setting.authSessions.enabled) {
+    throw new Error("auth session is not enabled");
+  }
+  const checkFilePath = getFullPathInProject(AUTH_SESSIONS_FOLDER_NAME, "check");
+  if (!fs.exists(checkFilePath)) {
+    throw new Error("auth session check file not found");
+  }
+  const runApiResult = await runApi({
+    automationFunction: {
+      name: `${AUTH_SESSIONS_FOLDER_NAME}/check`
+    },
+    runOptions: {
+      environment: "ide",
+      mode,
+      cdpAddress
+    },
+    auth: {
+      session: {
+        type: "file",
+        path: authSessionPath
+      },
+      runCheck: false
+    }
+  });
+  if (runApiResult.isErr()) {
+    throw new Error(runApiResult.error);
+  }
+  const result = runApiResult.value.result;
+  console.log("check result", result);
+  if (!result) {
+    throw new Error("auth session check failed");
+  }
+  process.exit(0);
+});
+program.parse(process.argv);