@intuned/runtime-dev 1.3.4-dev.4 → 1.3.4-enhancements.1

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

@@ -1,7 +1,7 @@
 import { Payload } from "../../../runtime/export";
 import { RunApiStorageState } from "../../../common/runApi";
 import type { BaseCommandOptions } from "../commands/types";
-export declare function executeRunApiCLI({ apiName, inputData, retries, authSession, outputFile, ...rest }: {
+export declare function executeRunApiCLI({ apiName, inputData, retries, authSession, outputFile, trace, ...rest }: {
     apiName: string;
     inputData: object | null | undefined;
     retries: number;
@@ -13,7 +13,7 @@ export declare function executeRunApiCLI({ apiName, inputData, retries, authSess
     };
     outputFile?: string;
 } & BaseCommandOptions): Promise<void>;
-export declare function executeAttemptApiCLI({ apiName, inputData, authSessionId, outputFile, ...rest }: {
+export declare function executeAttemptApiCLI({ apiName, inputData, authSessionId, outputFile, trace, ...rest }: {
     apiName: string;
     inputData: object | null | undefined;
     authSessionId?: string;
@@ -29,14 +29,12 @@ 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, }: {
+declare function attemptApi({ apiName, inputData, auth, proxy, headless, timeout, traceId, keepBrowserOpen, }: {
     apiName: string;
     inputData: object | null | undefined;
     auth?: RunApiStorageState;
-    proxy?: string | undefined;
-    headless: boolean;
-    timeout: number;
-}): Promise<{
+    traceId?: string;
+} & Omit<BaseCommandOptions, "trace">): Promise<{
     result: any;
     payloadToAppend: Payload[] | undefined;
 }>;

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

@@ -13,6 +13,7 @@ var _authSession = require("./authSession");
 var _helpers = require("../helpers");
 var _terminal = require("../helpers/terminal");
 var _constants = require("../../../common/constants");
+var _browser = require("../helpers/browser");
 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; }
 async function executeRunApiCLI({
@@ -21,6 +22,7 @@ async function executeRunApiCLI({
   retries,
   authSession,
   outputFile,
+  trace,
   ...rest
 }) {
   await (0, _helpers.assertApiFileExists)(_constants.API_FOLDER_NAME, apiName);
@@ -33,6 +35,7 @@ async function executeRunApiCLI({
       if (authSession) {
         auth = await (0, _authSession.executeRunValidateAuthSessionCLI)({
           ...authSession,
+          trace,
           ...rest
         });
       }
@@ -41,6 +44,7 @@ async function executeRunApiCLI({
           apiName,
           inputData,
           auth,
+          traceId: trace ? `${apiName}-attempt-${i + 1}` : undefined,
           ...rest
         });
       } catch (error) {
@@ -68,6 +72,7 @@ async function executeAttemptApiCLI({
   inputData,
   authSessionId,
   outputFile,
+  trace,
   ...rest
 }) {
   (0, _terminal.terminal)(`^+Execute API attempt for ^c${apiName}^:\n`);
@@ -84,6 +89,7 @@ async function executeAttemptApiCLI({
       apiName,
       inputData,
       auth: storageState,
+      traceId: trace ? `${apiName}-attempt` : undefined,
       ...rest
     });
     return await handleApiResult({
@@ -142,25 +148,28 @@ async function attemptApi({
   auth,
   proxy,
   headless,
-  timeout
+  timeout,
+  traceId,
+  keepBrowserOpen
 }) {
-  return await (0, _helpers.withTimeout)(async abortSignal => {
+  return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
     const runApiResult = await (0, _runApi.runApi)({
       automationFunction: {
         name: `${_constants.API_FOLDER_NAME}/${apiName}`,
         params: inputData
       },
-      runOptions: {
+      runOptions: await (0, _browser.getCLIRunOptions)({
         headless,
-        environment: "standalone",
-        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
-      },
+        proxy,
+        keepBrowserOpen
+      }),
       auth: auth ? {
         session: {
           type: "state",
           state: auth
         }
       } : undefined,
+      tracing,
       importFunction: _tsNodeImport.tsNodeImport,
       abortSignal
     });
@@ -175,6 +184,6 @@ async function attemptApi({
       result,
       payloadToAppend
     };
-  }, timeout);
+  }, traceId), timeout);
 }
 const _attemptApi = exports._attemptApi = attemptApi;

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

@@ -1,5 +1,6 @@
 import type { BaseCommandOptions } from "../commands/types";
 import { RunApiStorageState } from "../../../common/runApi";
+import { AuthSessionMetadata } from "../types";
 export declare function executeRunValidateAuthSessionCLI({ id, autoRecreate, checkRetries, createRetries, ...rest }: {
     id: string;
     autoRecreate: boolean;
@@ -12,6 +13,7 @@ export declare function executeRunCreateAuthSessionCLI({ id, input, checkRetries
     checkRetries: number;
     createRetries: number;
     log?: boolean;
+    metadata?: AuthSessionMetadata;
 } & BaseCommandOptions): Promise<{
     cookies: {
         value: string;
@@ -126,13 +128,15 @@ export declare function executeAttemptCheckAuthSessionCLI({ id, ...rest }: {
         origin: string;
     }[] | undefined;
 }>;
-declare function runCheck({ auth, proxy, headless, timeout, }: {
+declare function runCheck({ auth, proxy, headless, timeout, traceId, keepBrowserOpen, }: {
     auth: RunApiStorageState;
-} & BaseCommandOptions): Promise<boolean>;
+    traceId?: string;
+} & Omit<BaseCommandOptions, "trace">): Promise<boolean>;
 export declare const _runCheck: typeof runCheck;
-declare function runCreate({ authSessionInput, proxy, headless, timeout, }: {
+declare function runCreate({ authSessionInput, proxy, headless, timeout, traceId, keepBrowserOpen, }: {
     authSessionInput: Record<string, any>;
-} & BaseCommandOptions): Promise<{
+    traceId?: string;
+} & Omit<BaseCommandOptions, "trace">): Promise<{
     cookies: {
         value: string;
         name: string;
@@ -161,13 +165,14 @@ declare function runCreate({ authSessionInput, proxy, headless, timeout, }: {
 export declare const _runCreate: typeof runCreate;
 declare function runCheckWithRetries({ auth, retries, ...rest }: {
     auth: RunApiStorageState;
-    retries: number;
+    retries?: number;
 } & BaseCommandOptions): Promise<boolean>;
 export declare const _runCheckWithRetries: typeof runCheckWithRetries;
-declare function runCreateWithRetries({ authSessionId, authSessionInput, retries, ...rest }: {
+declare function runCreateWithRetries({ authSessionId, authSessionInput, retries, trace, metadata, ...rest }: {
     authSessionId: string;
     authSessionInput: any;
-    retries: number;
+    retries?: number;
+    metadata?: AuthSessionMetadata;
 } & BaseCommandOptions): Promise<{
     cookies: {
         value: string;
@@ -195,4 +200,10 @@ declare function runCreateWithRetries({ authSessionId, authSessionInput, retries
     }[] | undefined;
 }>;
 export declare const _runCreateWithRetries: typeof runCreateWithRetries;
+export declare function executeRecordAuthSessionCLI({ id, checkRetries, timeout, headless, proxy, trace, keepBrowserOpen, startUrl, finishUrl, }: {
+    id?: string;
+    checkRetries: number;
+    startUrl: string;
+    finishUrl: string;
+} & BaseCommandOptions): Promise<void>;
 export {};

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports._runCreateWithRetries = exports._runCreate = exports._runCheckWithRetries = exports._runCheck = void 0;
 exports.executeAttemptCheckAuthSessionCLI = executeAttemptCheckAuthSessionCLI;
 exports.executeAttemptCreateAuthSessionCLI = executeAttemptCreateAuthSessionCLI;
+exports.executeRecordAuthSessionCLI = executeRecordAuthSessionCLI;
 exports.executeRunCreateAuthSessionCLI = executeRunCreateAuthSessionCLI;
 exports.executeRunUpdateAuthSessionCLI = executeRunUpdateAuthSessionCLI;
 exports.executeRunValidateAuthSessionCLI = executeRunValidateAuthSessionCLI;
@@ -14,6 +15,10 @@ var _runApi = require("../../../common/runApi");
 var _constants = require("../../../common/constants");
 var _tsNodeImport = require("../../common/tsNodeImport");
 var _terminal = require("../helpers/terminal");
+var _browser = require("../helpers/browser");
+var _playwrightContext = require("../../../common/playwrightContext");
+var _promises = require("timers/promises");
+var _contextStorageStateHelpers = require("../../../common/contextStorageStateHelpers");
 async function executeRunValidateAuthSessionCLI({
   id,
   autoRecreate,
@@ -49,6 +54,7 @@ async function executeRunValidateAuthSessionCLI({
       authSessionId: id,
       authSessionInput,
       retries: createRetries,
+      metadata,
       ...rest
     });
     const checkResult = await runCheckWithRetries({
@@ -71,7 +77,7 @@ async function executeRunCreateAuthSessionCLI({
   log = true,
   ...rest
 }) {
-  id = id ?? `auth-session-${Date.now()}`;
+  id = id ?? generateAuthSessionId();
   (0, _terminal.terminal)(`^+Creating auth session with id ^c${id}^:\n`);
   await Promise.all([await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create"), await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check")]);
   const createdStorageState = await runCreateWithRetries({
@@ -102,10 +108,11 @@ async function executeRunUpdateAuthSessionCLI({
   ...rest
 }) {
   (0, _terminal.terminal)(`^+Updating auth session with id ^c${id}^:\n`);
+  let metadata = undefined;
   if (input === undefined) {
-    const {
+    ({
       metadata
-    } = await (0, _helpers.loadAuthSessionInstance)(id);
+    } = await (0, _helpers.loadAuthSessionInstance)(id));
     if (metadata?.authSessionType === "MANUAL") {
       throw new _helpers.CLIError("Auth session is recorder-based, it cannot be updated.");
     }
@@ -118,6 +125,7 @@ async function executeRunUpdateAuthSessionCLI({
     checkRetries,
     createRetries,
     log: false,
+    metadata,
     ...rest
   });
   (0, _terminal.terminal)(`^+^gAuth session updated successfully^:\n`);
@@ -128,13 +136,12 @@ async function executeAttemptCreateAuthSessionCLI({
   input,
   ...rest
 }) {
-  id = id ?? `auth-session-attempt-${Date.now()}`;
+  id = id ?? generateAuthSessionId(true);
   (0, _terminal.terminal)(`^+Executing create auth session attempt with id ^c${id}^:\n`);
   await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create");
   return await runCreateWithRetries({
     authSessionId: id,
     authSessionInput: input,
-    retries: 1,
     ...rest
   });
 }
@@ -150,7 +157,6 @@ async function executeAttemptCheckAuthSessionCLI({
   } = await (0, _helpers.loadAuthSessionInstance)(id);
   const checkResult = await runCheckWithRetries({
     auth: storageState,
-    retries: 1,
     ...rest
   });
   if (!checkResult) {
@@ -163,24 +169,27 @@ async function runCheck({
   auth,
   proxy,
   headless,
-  timeout
+  timeout,
+  traceId,
+  keepBrowserOpen
 }) {
-  return await (0, _helpers.withTimeout)(async abortSignal => {
+  return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
     const runApiResult = await (0, _runApi.runApi)({
       automationFunction: {
         name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`
       },
-      runOptions: {
+      runOptions: await (0, _browser.getCLIRunOptions)({
         headless,
-        environment: "standalone",
-        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
-      },
+        proxy,
+        keepBrowserOpen
+      }),
       auth: {
         session: {
           type: "state",
           state: auth
         }
       },
+      tracing,
       importFunction: _tsNodeImport.tsNodeImport,
       abortSignal
     });
@@ -192,27 +201,30 @@ async function runCheck({
       return false;
     }
     return result;
-  }, timeout);
+  }, traceId), timeout);
 }
 const _runCheck = exports._runCheck = runCheck;
 async function runCreate({
   authSessionInput,
   proxy,
   headless,
-  timeout
+  timeout,
+  traceId,
+  keepBrowserOpen
 }) {
-  return await (0, _helpers.withTimeout)(async abortSignal => {
+  return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
     const result = await (0, _runApi.runApi)({
       automationFunction: {
         name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`,
         params: authSessionInput
       },
-      runOptions: {
+      runOptions: await (0, _browser.getCLIRunOptions)({
         headless,
-        environment: "standalone",
-        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
-      },
+        proxy,
+        keepBrowserOpen
+      }),
       retrieveSession: true,
+      tracing,
       importFunction: _tsNodeImport.tsNodeImport,
       abortSignal
     });
@@ -220,7 +232,7 @@ async function runCreate({
       throw result.error;
     }
     return result.value.session;
-  }, timeout);
+  }, traceId), timeout);
 }
 const _runCreate = exports._runCreate = runCreate;
 async function runCheckWithRetries({
@@ -228,11 +240,19 @@ async function runCheckWithRetries({
   retries,
   ...rest
 }) {
-  for (let i = 0; i < retries; i++) {
+  for (let i = 0; i < (retries ?? 1); i++) {
     (0, _terminal.terminal)(`\n^+Running ^cauth session check${i === 0 ? "" : ` ^/(Attempt ${i + 1})`}^:...\n`);
     try {
+      let traceId = undefined;
+      if (rest.trace) {
+        traceId = "authsession-check-attempt";
+        if (retries) {
+          traceId += `-${i + 1}`;
+        }
+      }
       const checkResult = await runCheck({
         auth,
+        traceId,
         ...rest
       });
       if (checkResult) {
@@ -256,14 +276,24 @@ async function runCreateWithRetries({
   authSessionId,
   authSessionInput,
   retries,
+  trace,
+  metadata,
   ...rest
 }) {
   let newAuthSessionInstance = null;
-  for (let i = 0; i < retries; i++) {
+  for (let i = 0; i < (retries ?? 1); i++) {
     (0, _terminal.terminal)(`\n^+Running ^cauth session create${i === 0 ? "" : ` ^/(Attempt ${i + 1})`}^:...\n`);
     try {
+      let traceId = undefined;
+      if (trace) {
+        traceId = "authsession-create-attempt";
+        if (retries) {
+          traceId += `-${i + 1}`;
+        }
+      }
       newAuthSessionInstance = await runCreate({
         authSessionInput,
+        traceId,
         ...rest
       });
       (0, _terminal.terminal)(`^+^gAuth session create succeeded^:\n`);
@@ -284,8 +314,107 @@ async function runCreateWithRetries({
     state: newAuthSessionInstance,
     id: authSessionId,
     input: authSessionInput,
-    proxy: rest.proxy
+    proxy: rest.proxy,
+    metadata
   });
   return newAuthSessionInstance;
 }
-const _runCreateWithRetries = exports._runCreateWithRetries = runCreateWithRetries;
+const _runCreateWithRetries = exports._runCreateWithRetries = runCreateWithRetries;
+async function executeRecordAuthSessionCLI({
+  id,
+  checkRetries,
+  timeout,
+  headless,
+  proxy,
+  trace = false,
+  keepBrowserOpen,
+  startUrl,
+  finishUrl
+}) {
+  id = id ?? generateAuthSessionId();
+  (0, _terminal.terminal)(`^+Recording auth session with id ^c${id}^:\n`);
+  let authSession;
+  try {
+    authSession = await recordAuthSession({
+      startUrl,
+      finishUrl,
+      timeout,
+      proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
+    });
+  } catch (error) {
+    if (error instanceof _helpers.CLIError) {
+      throw new _helpers.CLIError(`Failed to record auth session: ${error.message}`);
+    }
+    throw error;
+  }
+  await (0, _helpers.storeAuthSessionInstance)({
+    state: authSession,
+    id,
+    proxy,
+    metadata: {
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      authSessionId: id,
+      authSessionType: "MANUAL",
+      recorderStartUrl: startUrl,
+      recorderEndUrl: finishUrl
+    }
+  });
+  await executeRunValidateAuthSessionCLI({
+    id,
+    headless,
+    timeout,
+    proxy,
+    autoRecreate: false,
+    checkRetries,
+    createRetries: 0,
+    trace,
+    keepBrowserOpen
+  });
+  (0, _terminal.terminal)(`^+^gAuth session ^c${id}^ ^+^grecorded successfully^:\n`);
+}
+async function recordAuthSession({
+  startUrl,
+  finishUrl,
+  timeout,
+  proxy
+}) {
+  const {
+    context,
+    page
+  } = await (0, _playwrightContext.launchChromium)({
+    headless: false,
+    proxy,
+    appModeInitialUrl: startUrl
+  });
+  try {
+    if (!page.url().startsWith(startUrl)) {
+      await page.goto(startUrl);
+    }
+    (0, _terminal.terminal)(`^+Navigated to^ ^_${startUrl}^:\n`);
+    (0, _terminal.terminal)(`^+Waiting for^ ^_${finishUrl}^:...\n`);
+    const timeoutTimestamp = Date.now() + timeout;
+    while (true) {
+      if (Date.now() > timeoutTimestamp) {
+        throw new _helpers.CLIError("Timeout waiting for finish URL");
+      }
+      if (context.pages().length === 0) {
+        throw new _helpers.CLIError("Browser was closed before reaching the finish URL");
+      }
+      if (context.pages()[0].url().startsWith(finishUrl)) {
+        break;
+      }
+      await (0, _promises.setTimeout)(1000);
+    }
+    (0, _terminal.terminal)(`^+Finish URL reached, capturing auth session...^:\n`);
+    await page.waitForLoadState("load");
+    const authSession = await (0, _contextStorageStateHelpers.getStorageState)(context);
+    return authSession;
+  } finally {
+    await context.close();
+  }
+}
+function generateAuthSessionId(isAttempt = false) {
+  if (isAttempt) return `auth-session-attempt-${Date.now()}`;
+  return `auth-session-${Date.now()}`;
+}

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

@@ -48,6 +48,12 @@ async function runSaveProject(projectName, auth) {
   };
   const projectPath = process.cwd();
   const codeTree = await convertProjectToCodeTree(projectPath);
+  const intunedSettingsFile = await (0, _helpers.getIntunedSettingsFile)();
+  codeTree["Intuned.json"] = {
+    file: {
+      contents: JSON.stringify(intunedSettingsFile.parse(await fs.readFile(intunedSettingsFile.path, "utf-8")))
+    }
+  };
   codeTree["tsconfig.json"] = {
     file: {
       contents: JSON.stringify(_constants.tsConfigCli, null, 2)
@@ -124,6 +130,7 @@ const validateProjectName = projectName => {
 exports.validateProjectName = validateProjectName;
 const validateIntunedProject = async () => {
   const currentDirectoryToSave = process.cwd();
+  const intunedSettingsFile = await (0, _helpers.getIntunedSettingsFile)();
   const validationSteps = [{
     name: "build",
     check: async () => {
@@ -172,10 +179,10 @@ const validateIntunedProject = async () => {
       }
     }
   }, {
-    name: "Intuned.json",
+    name: intunedSettingsFile.name,
     check: async () => {
       try {
-        const intunedJsonPath = path.join(currentDirectoryToSave, "Intuned.json");
+        const intunedJsonPath = path.join(currentDirectoryToSave, intunedSettingsFile.name);
         await fs.exists(intunedJsonPath);
         return {
           isValid: true
@@ -183,7 +190,7 @@ const validateIntunedProject = async () => {
       } catch (error) {
         return {
           isValid: false,
-          errorMessage: "Intuned.json file not found"
+          errorMessage: `${intunedSettingsFile.name} file not found`
         };
       }
     }

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

@@ -0,0 +1,103 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _browser = require("../browser");
+var _playwrightContext = require("../../../../common/playwrightContext");
+function getTerminal() {
+  return new Proxy(() => ({}), {
+    get: () => getTerminal(),
+    apply: () => ({})
+  });
+}
+_vitest.vi.mock("fs-extra", () => ({
+  exists: _vitest.vi.fn().mockResolvedValue(true)
+}));
+_vitest.vi.mock("portfinder", () => ({
+  getPort: _vitest.vi.fn().mockResolvedValue(1234)
+}));
+_vitest.vi.mock("../../../../common/playwrightContext", () => ({
+  launchChromium: _vitest.vi.fn().mockImplementation(async () => ({
+    context: {
+      close: _vitest.vi.fn().mockResolvedValue(undefined)
+    },
+    page: {}
+  }))
+}));
+_vitest.vi.mock("../../helpers/terminal", () => ({
+  terminal: getTerminal()
+}));
+_vitest.vi.mock("../../helpers/proxy", () => {
+  return {
+    parseUrlProxy: _vitest.vi.fn(v => v)
+  };
+});
+_vitest.vi.mock("../../helpers", async importOriginal => {
+  const original = await importOriginal();
+  return {
+    ...original,
+    terminal: getTerminal()
+  };
+});
+(0, _vitest.describe)("Browser CLI options", () => {
+  (0, _vitest.it)("returns standalone options if keepBrowserOpen is not set", async () => {
+    const options = await (0, _browser.getCLIRunOptions)({
+      keepBrowserOpen: false,
+      headless: false
+    });
+    (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
+      environment: "standalone",
+      headless: false
+    }));
+  });
+  (0, _vitest.describe)("when keepBrowserOpen is set", () => {
+    beforeEach(async () => {
+      _vitest.vi.clearAllMocks();
+      await (0, _browser.closeCliBrowser)();
+    });
+    (0, _vitest.it)("launches a browser with correct parameters and returns cdp options", async () => {
+      const options = await (0, _browser.getCLIRunOptions)({
+        keepBrowserOpen: true,
+        headless: false,
+        proxy: "proxy"
+      });
+      (0, _vitest.expect)(_playwrightContext.launchChromium).toHaveBeenCalledWith({
+        headless: false,
+        cdpPort: 1234,
+        proxy: "proxy"
+      });
+      (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
+        environment: "cdp",
+        cdpAddress: "http://localhost:1234"
+      }));
+    });
+    (0, _vitest.it)("keeps context open until new context", async () => {
+      await (0, _browser.getCLIRunOptions)({
+        keepBrowserOpen: true,
+        headless: false,
+        proxy: "proxy"
+      });
+      const firstContext = (0, _browser._getContextForTest)();
+      (0, _vitest.expect)(firstContext).not.toBeNull();
+      (0, _vitest.expect)(_playwrightContext.launchChromium).toHaveBeenCalledTimes(1);
+      await (0, _browser.getCLIRunOptions)({
+        keepBrowserOpen: true,
+        headless: false,
+        proxy: "proxy"
+      });
+      const secondContext = (0, _browser._getContextForTest)();
+      (0, _vitest.expect)(secondContext).not.toBeNull();
+      (0, _vitest.expect)(firstContext).not.toBe(secondContext);
+      (0, _vitest.expect)(_playwrightContext.launchChromium).toHaveBeenCalledTimes(2);
+    });
+    (0, _vitest.it)("keeps context open until explicitly closed", async () => {
+      await (0, _browser.getCLIRunOptions)({
+        keepBrowserOpen: true,
+        headless: false,
+        proxy: "proxy"
+      });
+      (0, _vitest.expect)((0, _browser._getContextForTest)()).not.toBeNull();
+      await (0, _browser.closeCliBrowser)();
+      (0, _vitest.expect)((0, _browser._getContextForTest)()).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _ = require("..");
+function getTerminal() {
+  return new Proxy(() => ({}), {
+    get: () => getTerminal(),
+    apply: () => ({})
+  });
+}
+_vitest.vi.mock("fs-extra", () => ({
+  exists: _vitest.vi.fn().mockResolvedValue(true)
+}));
+_vitest.vi.mock("../../helpers/terminal", () => ({
+  terminal: getTerminal()
+}));
+_vitest.vi.mock("../../helpers", async importOriginal => {
+  const original = await importOriginal();
+  return {
+    ...original,
+    terminal: getTerminal()
+  };
+});
+(0, _vitest.describe)("Tracing wrapper", () => {
+  (0, _vitest.it)("calls wrapped function with disabled tracing when id is undefined", async () => {
+    const fn = _vitest.vi.fn();
+    await (0, _.withCLITrace)(fn, undefined);
+    (0, _vitest.expect)(fn).toHaveBeenCalledWith({
+      enabled: false
+    });
+  });
+  (0, _vitest.it)("calls wrapped function with enabled tracing when id is defined", async () => {
+    const fn = _vitest.vi.fn();
+    await (0, _.withCLITrace)(fn, "trace-id");
+    (0, _vitest.expect)(fn).toHaveBeenCalledWith({
+      enabled: true,
+      filePath: _vitest.expect.stringContaining("trace-id")
+    });
+  });
+});