@intuned/runtime 1.3.8 → 1.3.10

package/InterfaceTemplate/index.playwright.ts

@@ -1,3 +1,4 @@
+require("@intuned/runtime/dist/common/binStartupScript");
 import { runAutomationCLI } from "@intuned/runtime/dist/commands/interface/run";
 
 import { importModule } from "./utils";

package/bin/intuned

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+
+require("../dist/common/binStartupScript.js");
 require("../dist/commands/intuned-cli/main.js");

package/bin/intuned-api-run

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+
+require("../dist/common/binStartupScript.js");
 require("../dist/commands/api/run.js");

package/bin/intuned-auth-session-check

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+
+require("../dist/common/binStartupScript.js");
 require("../dist/commands/auth-sessions/run-check.js");

package/bin/intuned-auth-session-create

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+
+require("../dist/common/binStartupScript.js");
 require("../dist/commands/auth-sessions/run-create.js");

package/bin/intuned-auth-session-load

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
+
+require("../dist/common/binStartupScript.js");
 require("../dist/commands/auth-sessions/load.js");

package/dist/commands/common/utils/settings.js

@@ -23,6 +23,9 @@ async function getSettings() {
   return {
     authSessions: {
       enabled: false
+    },
+    stealthMode: {
+      enabled: false
     }
   };
 }

package/dist/commands/intuned-cli/commands/run_authsession.command.d.ts

@@ -4,6 +4,7 @@ export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodOb
     headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
     timeout: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodString>, import("ms").StringValue, string | undefined>, number, string | undefined>;
     keepBrowserOpen: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    cdpUrl: import("zod").ZodOptional<import("zod").ZodString>;
     trace: import("zod").ZodDefault<import("zod").ZodBoolean>;
     checkAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
     createAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
@@ -15,11 +16,13 @@ export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodOb
     checkAttempts: number;
     createAttempts: number;
     proxy?: string | undefined;
+    cdpUrl?: string | undefined;
 }, {
     proxy?: string | undefined;
     headless?: boolean | undefined;
     timeout?: string | undefined;
     keepBrowserOpen?: boolean | undefined;
+    cdpUrl?: string | undefined;
     trace?: boolean | undefined;
     checkAttempts?: number | undefined;
     createAttempts?: number | undefined;

package/dist/commands/intuned-cli/commands/types.d.ts

@@ -8,24 +8,28 @@ export declare const timeoutSchema: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.Zod
 export declare const headlessSchema: z.ZodDefault<z.ZodBoolean>;
 export declare const traceSchema: z.ZodDefault<z.ZodBoolean>;
 export declare const keepBrowserOpenSchema: z.ZodDefault<z.ZodBoolean>;
+export declare const cdpUrlSchema: z.ZodOptional<z.ZodString>;
 export declare const baseCommandOptionsSchema: z.ZodObject<{
     proxy: z.ZodOptional<z.ZodString>;
     timeout: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, ms.StringValue, string | undefined>, number, string | undefined>;
     headless: z.ZodDefault<z.ZodBoolean>;
     trace: z.ZodDefault<z.ZodBoolean>;
     keepBrowserOpen: z.ZodDefault<z.ZodBoolean>;
+    cdpUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     headless: boolean;
     timeout: number;
     keepBrowserOpen: boolean;
     trace: boolean;
     proxy?: string | undefined;
+    cdpUrl?: string | undefined;
 }, {
     proxy?: string | undefined;
     timeout?: string | undefined;
     headless?: boolean | undefined;
     trace?: boolean | undefined;
     keepBrowserOpen?: boolean | undefined;
+    cdpUrl?: string | undefined;
 }>;
 export type BaseCommandOptions = z.infer<typeof baseCommandOptionsSchema>;
 export declare function withBaseOptions(command: Command): Command;

package/dist/commands/intuned-cli/commands/types.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.traceSchema = exports.timeoutSchema = exports.proxySchema = exports.keepBrowserOpenSchema = exports.headlessSchema = exports.baseCommandOptionsSchema = exports.authSessionCreateAttemptsSchema = exports.authSessionCheckAttemptsSchema = void 0;
+exports.traceSchema = exports.timeoutSchema = exports.proxySchema = exports.keepBrowserOpenSchema = exports.headlessSchema = exports.cdpUrlSchema = exports.baseCommandOptionsSchema = exports.authSessionCreateAttemptsSchema = exports.authSessionCheckAttemptsSchema = void 0;
 exports.withBaseOptions = withBaseOptions;
 var _ms = _interopRequireDefault(require("ms"));
 var _zod = require("zod");
@@ -17,13 +17,15 @@ const timeoutSchema = exports.timeoutSchema = _zod.z.string().default("10 mins")
 const headlessSchema = exports.headlessSchema = _zod.z.boolean().default(false);
 const traceSchema = exports.traceSchema = _zod.z.boolean().default(false);
 const keepBrowserOpenSchema = exports.keepBrowserOpenSchema = _zod.z.boolean().default(false);
+const cdpUrlSchema = exports.cdpUrlSchema = _zod.z.string().url().optional();
 const baseCommandOptionsSchema = exports.baseCommandOptionsSchema = _zod.z.object({
   proxy: proxySchema,
   timeout: timeoutSchema,
   headless: headlessSchema,
   trace: traceSchema,
-  keepBrowserOpen: keepBrowserOpenSchema
+  keepBrowserOpen: keepBrowserOpenSchema,
+  cdpUrl: cdpUrlSchema
 });
 function withBaseOptions(command) {
-  return command.option("--proxy <url>", "Proxy URL to use for browser").option("--timeout <time>", "Timeout for each attempt - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the attempts in a headless browser (default: false). This will not open a browser window.").option("--trace", "Capture a trace of each attempt, useful for debugging.").option("--keep-browser-open", "Keep the last browser open after the command completes, useful for debugging.");
+  return command.option("--proxy <url>", "Proxy URL to use for browser").option("--timeout <time>", "Timeout for each attempt - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the attempts in a headless browser (default: false). This will not open a browser window.").option("--trace", "Capture a trace of each attempt, useful for debugging.").option("--keep-browser-open", "Keep the last browser open after the command completes, useful for debugging.").option("--cdp-url <url>", "[Experimental] Chrome DevTools Protocol URL to connect to an existing browser instance. Disables proxy, headless, keep_browser_open options.");
 }

package/dist/commands/intuned-cli/controller/api.d.ts

@@ -29,7 +29,7 @@ declare function handleApiResult({ apiResult, outputFile, }: {
 export declare const _handleApiResult: typeof handleApiResult;
 declare function writeResultToFile(outputFile: string, result: any, payloadToAppend?: Payload[]): Promise<void>;
 export declare const _writeResultToFile: typeof writeResultToFile;
-declare function attemptApi({ apiName, inputData, auth, proxy, headless, timeout, traceId, keepBrowserOpen, }: {
+declare function attemptApi({ apiName, inputData, auth, proxy, headless, timeout, traceId, keepBrowserOpen, cdpUrl, }: {
     apiName: string;
     inputData: object | null | undefined;
     auth?: RunApiStorageState;

package/dist/commands/intuned-cli/controller/api.js

@@ -150,7 +150,8 @@ async function attemptApi({
   headless,
   timeout,
   traceId,
-  keepBrowserOpen
+  keepBrowserOpen,
+  cdpUrl
 }) {
   return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
     const runApiResult = await (0, _runApi.runApi)({
@@ -161,7 +162,8 @@ async function attemptApi({
       runOptions: await (0, _browser.getCLIRunOptions)({
         headless,
         proxy,
-        keepBrowserOpen
+        keepBrowserOpen,
+        cdpUrl
       }),
       auth: auth ? {
         session: {

package/dist/commands/intuned-cli/controller/authSession.d.ts

@@ -128,12 +128,12 @@ export declare function executeAttemptCheckAuthSessionCLI({ id, ...rest }: {
         origin: string;
     }[] | undefined;
 }>;
-declare function runCheck({ auth, proxy, headless, timeout, traceId, keepBrowserOpen, }: {
+declare function runCheck({ auth, proxy, headless, timeout, traceId, keepBrowserOpen, cdpUrl, }: {
     auth: RunApiStorageState;
     traceId?: string;
 } & Omit<BaseCommandOptions, "trace">): Promise<boolean>;
 export declare const _runCheck: typeof runCheck;
-declare function runCreate({ authSessionInput, proxy, headless, timeout, traceId, keepBrowserOpen, }: {
+declare function runCreate({ authSessionInput, proxy, headless, timeout, traceId, keepBrowserOpen, cdpUrl, }: {
     authSessionInput: Record<string, any>;
     traceId?: string;
 } & Omit<BaseCommandOptions, "trace">): Promise<{

package/dist/commands/intuned-cli/controller/authSession.js

@@ -171,7 +171,8 @@ async function runCheck({
   headless,
   timeout,
   traceId,
-  keepBrowserOpen
+  keepBrowserOpen,
+  cdpUrl
 }) {
   return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
     const runApiResult = await (0, _runApi.runApi)({
@@ -181,7 +182,8 @@ async function runCheck({
       runOptions: await (0, _browser.getCLIRunOptions)({
         headless,
         proxy,
-        keepBrowserOpen
+        keepBrowserOpen,
+        cdpUrl
       }),
       auth: {
         session: {
@@ -210,7 +212,8 @@ async function runCreate({
   headless,
   timeout,
   traceId,
-  keepBrowserOpen
+  keepBrowserOpen,
+  cdpUrl
 }) {
   return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
     const result = await (0, _runApi.runApi)({
@@ -221,7 +224,8 @@ async function runCreate({
       runOptions: await (0, _browser.getCLIRunOptions)({
         headless,
         proxy,
-        keepBrowserOpen
+        keepBrowserOpen,
+        cdpUrl
       }),
       retrieveSession: true,
       tracing,

package/dist/commands/intuned-cli/helpers/__test__/browser.test.js

@@ -39,6 +39,17 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
   };
 });
 (0, _vitest.describe)("Browser CLI options", () => {
+  (0, _vitest.it)("returns cdp options if cdpUrl is set", async () => {
+    const options = await (0, _browser.getCLIRunOptions)({
+      keepBrowserOpen: true,
+      headless: true,
+      cdpUrl: "cdp_url"
+    });
+    (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
+      environment: "cdp",
+      cdpAddress: "cdp_url"
+    }));
+  });
   (0, _vitest.it)("returns standalone options if keepBrowserOpen is not set", async () => {
     const options = await (0, _browser.getCLIRunOptions)({
       keepBrowserOpen: false,

package/dist/commands/intuned-cli/helpers/browser.d.ts

@@ -4,10 +4,11 @@ import { z } from "zod";
 declare let context: BrowserContext | null;
 export declare function _getContextForTest(): typeof context;
 type RunApiRunOptions = z.infer<typeof runApiParametersSchema>["runOptions"];
-export declare function getCLIRunOptions({ headless, proxy, keepBrowserOpen, }: {
+export declare function getCLIRunOptions({ headless, proxy, keepBrowserOpen, cdpUrl, }: {
     headless: boolean;
     proxy?: string;
     keepBrowserOpen: boolean;
+    cdpUrl?: string;
 }): Promise<RunApiRunOptions>;
 export declare function isCliBrowserLaunched(): boolean;
 export declare function closeCliBrowser(): Promise<void>;

package/dist/commands/intuned-cli/helpers/browser.js

@@ -20,11 +20,18 @@ function _getContextForTest() {
 async function getCLIRunOptions({
   headless,
   proxy,
-  keepBrowserOpen
+  keepBrowserOpen,
+  cdpUrl
 }) {
   if (context) {
     await closeCliBrowser();
   }
+  if (cdpUrl) {
+    return {
+      environment: "cdp",
+      cdpAddress: cdpUrl
+    };
+  }
   if (!keepBrowserOpen) {
     return {
       environment: "standalone",

package/dist/commands/intuned-cli/helpers/wrapper.js

@@ -22,7 +22,8 @@ function cliCommandWrapper(argsSchema, optionsSchema, fn) {
         return (0, _validation.logInvalidInput)(parseResult);
       }
       const [_, parsedOptions] = parseResult.data;
-      keepBrowserOpen = "keepBrowserOpen" in parsedOptions && parsedOptions.keepBrowserOpen === true;
+      const cdpUrl = "cdpUrl" in parsedOptions ? parsedOptions.cdpUrl : undefined;
+      keepBrowserOpen = !cdpUrl && "keepBrowserOpen" in parsedOptions && parsedOptions.keepBrowserOpen === true;
       if (keepBrowserOpen) {
         (0, _terminal.terminal)(`^+--keep-open is set, the CLI will not close the last browser after the command completes^:\n`);
       }

package/dist/commands/intuned-cli/main.js

@@ -6,6 +6,7 @@ var _backend = require("./helpers/backend");
 var _commands = require("./commands");
 var _helpers = require("./helpers");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+require("../../common/binStartupScript");
 _dotenv.default.config({
   path: `.env`
 });

package/dist/common/binStartupScript.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/common/binStartupScript.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _dotenv = _interopRequireDefault(require("dotenv"));
+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 && {}.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(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+function isStealthModeEnabled() {
+  try {
+    const intunedConfigPath = path.resolve(process.cwd(), process.env.ROOT || "./", "Intuned.json");
+    const configContent = fs.readFileSync(intunedConfigPath, "utf8");
+    const config = JSON.parse(configContent);
+    return config.stealthMode?.enabled === true;
+  } catch (error) {
+    console.error("Error reading Intuned.json:", error.message);
+    return false;
+  }
+}
+try {
+  if (isStealthModeEnabled()) {
+    const currentNodeModules = path.resolve(process.cwd(), "node_modules");
+    process.env.NODE_PATH = process.env.NODE_PATH ? `${process.env.NODE_PATH}:${currentNodeModules}` : currentNodeModules;
+    require("module").Module._initPaths();
+    if (process.env.PLAYWRIGHT_PATCH_SCRIPT_PATH) {
+      require(process.env.PLAYWRIGHT_PATCH_SCRIPT_PATH);
+    }
+  }
+} catch (e) {
+  console.error("Failed to apply stealth mode");
+}

package/dist/common/settingsSchema.d.ts

@@ -208,6 +208,13 @@ export declare const settingsSchema: z.ZodObject<{
     }, {
         enabled: boolean;
     }>>>;
+    stealthMode: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
     captchaSolver: z.ZodOptional<z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         cloudflare: z.ZodOptional<z.ZodObject<{
@@ -407,6 +414,9 @@ export declare const settingsSchema: z.ZodObject<{
     authSessions: {
         enabled: boolean;
     };
+    stealthMode: {
+        enabled: boolean;
+    };
     captchaSolver?: {
         enabled: boolean;
         settings: {
@@ -456,6 +466,9 @@ export declare const settingsSchema: z.ZodObject<{
     authSessions?: {
         enabled: boolean;
     } | undefined;
+    stealthMode?: {
+        enabled: boolean;
+    } | undefined;
     captchaSolver?: {
         enabled?: boolean | undefined;
         cloudflare?: {

package/dist/common/settingsSchema.js

@@ -45,7 +45,13 @@ const authSessionsSchema = z.object({
 }).optional().default({
   enabled: false
 });
+const stealthModeSchema = z.object({
+  enabled: z.boolean()
+}).optional().default({
+  enabled: false
+});
 const settingsSchema = exports.settingsSchema = z.object({
   authSessions: authSessionsSchema,
+  stealthMode: stealthModeSchema,
   captchaSolver: captchaSolverSettingsSchema.optional()
 });

package/package/dist/commands/api/run.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export declare function executeCLI(apiName: string, mode: "vanilla" | "playwright" | "playwright-standalone" | "playwright-headless", inputData: object | null | undefined, options: {
+    cdpAddress: string;
+    authSessionPath: undefined | string;
+    outputFileId: string | undefined;
+}): Promise<void>;

package/package/dist/commands/api/run.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.executeCLI = executeCLI;
+var _commander = require("commander");
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _settings = require("../common/utils/settings");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _asyncLocalStorage = require("../../common/asyncLocalStorage");
+var _enums = require("../../runtime/enums");
+var _cleanEnvironmentVariables = require("../../common/cleanEnvironmentVariables");
+var _Logger = require("../../common/Logger");
+var _nanoid = require("nanoid");
+var _chalk = _interopRequireDefault(require("chalk"));
+var _runApi = require("../../common/runApi");
+var _tsNodeImport = require("../common/tsNodeImport");
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+var _constants = require("../../common/constants");
+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; }
+_dotenv.default.config({
+  path: `.env`
+});
+async function executeCLI(apiName, mode, inputData, options) {
+  (0, _cleanEnvironmentVariables.cleanEnvironmentVariables)();
+  let authSessionPathToUse = null;
+  const settings = await (0, _settings.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 (0, _runApi.runApi)({
+    automationFunction: {
+      name: `${_constants.API_FOLDER_NAME}/${apiName}`,
+      params: inputData
+    },
+    auth: authSessionPathToUse ? {
+      session: {
+        type: "file",
+        path: authSessionPathToUse
+      }
+    } : undefined,
+    runOptions: {
+      environment: "cdp",
+      cdpAddress: options.cdpAddress
+    },
+    importFunction: _tsNodeImport.tsNodeImport
+  });
+  if (runApiResult.isErr()) {
+    if (runApiResult.error instanceof _runApi.AutomationError) {
+      throw runApiResult.error.error;
+    }
+    console.error(runApiResult.error);
+    throw new Error("An error occurred while running the API");
+  }
+  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.logger.info(_chalk.default.underline.bgBlue.white(`Click to Open: Results saved (Run: ${options.outputFileId})`));
+    fs.ensureDirSync(resultsDir);
+    const path = `${resultsDir}/${options.outputFileId}.json`;
+    await fs.writeJson(path, {
+      input: inputData,
+      output: result
+    }, {
+      spaces: 2
+    });
+  } else {
+    console.log("result:", result);
+  }
+  const hasPayloadToAppend = payloadToAppend && payloadToAppend.length > 0;
+  if (hasPayloadToAppend && options.outputFileId) {
+    _Logger.logger.info(_chalk.default.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.logger.info("payload to append:", payloadToAppend);
+    _Logger.logger.info("This will only take an effect if this API run was part of a job.");
+  }
+}
+_commander.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").option("--authSessionParameters <authSessionParameters>", "parameters used to create the used auth session").argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(new _commander.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 = {};
+  }
+  let authSessionParametersJson = undefined;
+  if (!(0, _isNil.default)(options?.authSessionParameters)) {
+    authSessionParametersJson = JSON.parse(options.authSessionParameters);
+  }
+  await (0, _asyncLocalStorage.runWithContext)({
+    runEnvironment: _enums.RunEnvironment.IDE,
+    extendedPayloads: [],
+    runId: (0, _nanoid.nanoid)(),
+    proxy: options.proxy,
+    getAuthSessionParameters: authSessionParametersJson !== undefined ? async () => authSessionParametersJson : undefined
+  }, () => executeCLI(apiName, mode, inputData, options));
+  process.exit(0);
+});
+_commander.program.parse(process.argv);

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+"use strict";
+
+var _commander = require("commander");
+var _playwrightContext = require("../../common/playwrightContext");
+var _settings = require("../common/utils/settings");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _neverthrow = require("neverthrow");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+_commander.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 (0, _settings.getSettings)();
+  if (!setting.authSessions.enabled) {
+    throw new Error("Auth session is not enabled");
+  }
+  await (0, _playwrightContext.withPlaywrightContext)({
+    cdpAddress
+  }, async context => {
+    await (0, _playwrightContext.loadSessionToContext)({
+      context,
+      session: {
+        type: "file",
+        path: authSessionPath
+      }
+    });
+    return (0, _neverthrow.ok)({});
+  });
+  process.exit(0);
+});
+_commander.program.parse(process.argv);

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+
+var _commander = require("commander");
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _fileUtils = require("../common/utils/fileUtils");
+var _settings = require("../common/utils/settings");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _constants = require("../../common/constants");
+var _runApi = require("../../common/runApi");
+var _tsNodeImport = require("../common/tsNodeImport");
+var _enums = require("../../runtime/enums");
+var _nanoid = require("nanoid");
+var _asyncLocalStorage = require("../../common/asyncLocalStorage");
+var _isNil = _interopRequireDefault(require("lodash/isNil"));
+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; }
+_dotenv.default.config({
+  path: `.env`
+});
+_commander.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").option("--authSessionParameters <authSessionParameters>", "parameters used to create the used auth session").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
+  cdpAddress,
+  authSessionPath,
+  authSessionParameters
+}) => {
+  const setting = await (0, _settings.getSettings)();
+  if (!setting.authSessions.enabled) {
+    throw new Error("auth session is not enabled");
+  }
+  const checkFilePath = (0, _fileUtils.getFullPathInProject)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check");
+  if (!fs.exists(checkFilePath)) {
+    throw new Error("auth session check file not found");
+  }
+  let authSessionParametersJson = undefined;
+  if (!(0, _isNil.default)(authSessionParameters)) {
+    authSessionParametersJson = JSON.parse(authSessionParameters);
+  }
+  const runApiResult = await (0, _asyncLocalStorage.runWithContext)({
+    runEnvironment: _enums.RunEnvironment.IDE,
+    extendedPayloads: [],
+    runId: (0, _nanoid.nanoid)(),
+    getAuthSessionParameters: authSessionParametersJson !== undefined ? async () => authSessionParametersJson : undefined
+  }, async () => await (0, _runApi.runApi)({
+    automationFunction: {
+      name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`
+    },
+    runOptions: {
+      environment: "cdp",
+      cdpAddress
+    },
+    auth: {
+      session: {
+        type: "file",
+        path: authSessionPath
+      }
+    },
+    importFunction: _tsNodeImport.tsNodeImport
+  }));
+  if (runApiResult.isErr()) {
+    if (runApiResult.error instanceof _runApi.AutomationError) {
+      throw runApiResult.error.error;
+    }
+    console.error(runApiResult.error);
+    throw new Error("Error running auth session check");
+  }
+  const result = runApiResult.value.result;
+  console.log("check result", result);
+  if (!result) {
+    throw new Error("auth session check failed");
+  }
+  process.exit(0);
+});
+_commander.program.parse(process.argv);

package/package/dist/commands/auth-sessions/run-create.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};