@intuned/runtime-dev 1.3.9-dev8 → 1.3.11-deployment.0

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

@@ -1,1059 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _authSession = require("../authSession");
-var _helpers = require("../../helpers");
-var _neverthrow = require("neverthrow");
-var _runApi = require("../../../../common/runApi");
-var _browser = require("../../helpers/browser");
-var _launchBrowser = require("../../../../common/launchBrowser");
-var _promises = require("timers/promises");
-const _checkPassedResult = (0, _neverthrow.ok)({
-  result: true
-});
-const _checkFailedResult = (0, _neverthrow.ok)({
-  result: false
-});
-const _errorResult = (0, _neverthrow.err)(new _runApi.AutomationError("failed"));
-function _createSuccessResult(session) {
-  return (0, _neverthrow.ok)({
-    session
-  });
-}
-function getTerminal() {
-  return new Proxy(() => ({}), {
-    get: () => getTerminal(),
-    apply: () => ({})
-  });
-}
-function getMockTimeout() {
-  let resolveTimeout = () => undefined;
-  _vitest.vi.mocked(_promises.setTimeout).mockImplementation(() => new Promise(r => {
-    resolveTimeout = r;
-  }));
-  return {
-    async resolve() {
-      await Promise.resolve();
-      resolveTimeout();
-    }
-  };
-}
-_vitest.vi.mock("fs-extra", () => ({
-  writeJSON: _vitest.vi.fn(),
-  exists: _vitest.vi.fn().mockResolvedValue(true)
-}));
-_vitest.vi.mock("timers/promises", () => ({
-  setTimeout: _vitest.vi.fn().mockResolvedValue(undefined)
-}));
-_vitest.vi.mock("../../../../common/contextStorageStateHelpers", () => ({
-  getStorageState: _vitest.vi.fn()
-}));
-_vitest.vi.mock("../../../../common/launchBrowser", () => ({
-  launchChromium: _vitest.vi.fn()
-}));
-_vitest.vi.mock("../../../../common/runApi", async importOriginal => {
-  const original = await importOriginal();
-  return {
-    ...original,
-    runApi: _vitest.vi.fn().mockImplementation(() => (0, _neverthrow.ok)({}))
-  };
-});
-_vitest.vi.mock("../../helpers/terminal", () => ({
-  terminal: getTerminal()
-}));
-_vitest.vi.mock("../../helpers/proxy", () => {
-  return {
-    parseUrlProxy: _vitest.vi.fn(v => v)
-  };
-});
-_vitest.vi.mock("../../helpers/browser", async importOriginal => {
-  const original = await importOriginal();
-  return {
-    getCLIRunOptions: _vitest.vi.fn(({
-      keepBrowserOpen: _,
-      ...rest
-    }) => original.getCLIRunOptions({
-      keepBrowserOpen: false,
-      ...rest
-    }))
-  };
-});
-_vitest.vi.mock("../../helpers", async importOriginal => {
-  const original = await importOriginal();
-  return {
-    ...original,
-    terminal: getTerminal(),
-    assertApiFileExists: _vitest.vi.fn(),
-    withTimeout: _vitest.vi.fn(fn => fn()),
-    keepBrowserOpen: false,
-    withCLITrace: _vitest.vi.fn(original.withCLITrace),
-    loadAuthSessionInstance: _vitest.vi.fn(),
-    storeAuthSessionInstance: _vitest.vi.fn().mockResolvedValue("authSessionInstancePath"),
-    registerGetAuthSessionParameters: _vitest.vi.fn()
-  };
-});
-(0, _vitest.describe)("Auth session controller", () => {
-  (0, _vitest.beforeEach)(() => {
-    _vitest.vi.clearAllMocks();
-  });
-  (0, _vitest.describe)("runCheck", () => {
-    (0, _vitest.it)("calls timeout middleware with timeout", async () => {
-      await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.withTimeout).toHaveBeenCalledWith(_vitest.expect.any(Function), 6000);
-    });
-    (0, _vitest.it)("uses tracing wrapper and calls with correct parameters", async () => {
-      await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), undefined);
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false,
-        traceId: "trace-id"
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), "trace-id");
-    });
-    (0, _vitest.it)("uses cli browser helper", async () => {
-      await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_browser.getCLIRunOptions).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        headless: false,
-        keepBrowserOpen: false
-      }));
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: true,
-        timeout: 6000,
-        keepBrowserOpen: true
-      });
-      (0, _vitest.expect)(_browser.getCLIRunOptions).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        headless: true,
-        keepBrowserOpen: true
-      }));
-    });
-    (0, _vitest.it)("calls runApi with correct parameters and parses proxy", async () => {
-      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
-      await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        proxy: "proxy"
-      });
-      (0, _vitest.expect)(_helpers.parseUrlProxy).toHaveBeenCalledWith("proxy");
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        automationFunction: {
-          name: "auth-sessions/check"
-        },
-        runOptions: {
-          headless: "headless",
-          environment: "standalone",
-          proxy: "parsed-proxy"
-        },
-        auth: _vitest.expect.objectContaining({
-          session: {
-            type: "state",
-            state: "session"
-          }
-        })
-      }));
-    });
-    (0, _vitest.it)("returns if check returns", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
-      const resultTrue = await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(resultTrue).toEqual(true);
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult);
-      const resultFalse = await (0, _authSession._runCheck)({
-        auth: "session",
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(resultFalse).toEqual(false);
-    });
-    (0, _vitest.it)("throws the error check fails with an error", async () => {
-      const error = new Error("runApi failed");
-      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
-      await (0, _vitest.expect)((0, _authSession._runCheck)({
-        auth: "session",
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      })).rejects.toThrow(error);
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult);
-      await (0, _vitest.expect)((0, _authSession._runCheck)({
-        auth: "session",
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      })).rejects.toThrow("failed");
-    });
-  });
-  (0, _vitest.describe)("runCheckWithRetries", () => {
-    (0, _vitest.it)("enables tracing on runCheck if trace is true", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
-      await (0, _authSession._runCheckWithRetries)({
-        auth: "session",
-        retries: 1,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), undefined);
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
-      await (0, _authSession._runCheckWithRetries)({
-        auth: "session",
-        retries: 1,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: true
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), _vitest.expect.any(String));
-    });
-    (0, _vitest.it)("retries the check if it fails", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult).mockResolvedValueOnce(_checkPassedResult);
-      const result = await (0, _authSession._runCheckWithRetries)({
-        auth: "session",
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(result).toEqual(true);
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
-    });
-    (0, _vitest.it)("returns false if all retries fail", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.ok)({
-        result: false
-      }));
-      const result = await (0, _authSession._runCheckWithRetries)({
-        auth: "session",
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(result).toEqual(false);
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(10);
-    });
-    (0, _vitest.it)("continues retrying if check fails due to an automation error", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult).mockResolvedValueOnce(_checkPassedResult);
-      const result = await (0, _authSession._runCheckWithRetries)({
-        auth: "session",
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(result).toEqual(true);
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
-    });
-    (0, _vitest.it)("throws the error if check fails with a non-automation error", async () => {
-      const error = new Error("runCheck failed");
-      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
-      await (0, _vitest.expect)((0, _authSession._runCheckWithRetries)({
-        auth: "session",
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(error);
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
-    });
-  });
-  (0, _vitest.describe)("runCreate", () => {
-    (0, _vitest.it)("calls timeout middleware with timeout", async () => {
-      await (0, _authSession._runCreate)({
-        authSessionInput: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.withTimeout).toHaveBeenCalledWith(_vitest.expect.any(Function), 6000);
-    });
-    (0, _vitest.it)("uses tracing wrapper and calls with correct parameters", async () => {
-      await (0, _authSession._runCreate)({
-        authSessionInput: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), undefined);
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _authSession._runCreate)({
-        authSessionInput: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false,
-        traceId: "trace-id"
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), "trace-id");
-    });
-    (0, _vitest.it)("uses cli browser helper", async () => {
-      await (0, _authSession._runCreate)({
-        authSessionInput: {},
-        headless: false,
-        timeout: 6000,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_browser.getCLIRunOptions).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        headless: false,
-        keepBrowserOpen: false
-      }));
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_runApi.runApi).mockClear();
-      await (0, _authSession._runCreate)({
-        authSessionInput: {},
-        headless: true,
-        timeout: 6000,
-        keepBrowserOpen: true
-      });
-      (0, _vitest.expect)(_browser.getCLIRunOptions).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        headless: true,
-        keepBrowserOpen: true
-      }));
-    });
-    (0, _vitest.it)("calls runApi with correct parameters and parses proxy", async () => {
-      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
-      await (0, _authSession._runCreate)({
-        authSessionInput: "authSessionInput",
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        proxy: "proxy"
-      });
-      (0, _vitest.expect)(_helpers.parseUrlProxy).toHaveBeenCalledWith("proxy");
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        automationFunction: {
-          name: "auth-sessions/create",
-          params: "authSessionInput"
-        },
-        runOptions: {
-          headless: "headless",
-          environment: "standalone",
-          proxy: "parsed-proxy"
-        },
-        retrieveSession: true
-      }));
-    });
-    (0, _vitest.it)("returns if create returns", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
-      const storageState = await (0, _authSession._runCreate)({
-        authSessionInput: {},
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(storageState).toEqual("session");
-    });
-    (0, _vitest.it)("throws the error create fails with an error", async () => {
-      const error = new Error("runApi failed");
-      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
-      await (0, _vitest.expect)((0, _authSession._runCreate)({
-        authSessionInput: {},
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false
-      })).rejects.toThrow(error);
-    });
-  });
-  (0, _vitest.describe)("runCreateWithRetries", () => {
-    (0, _vitest.it)("enables tracing on runCreate if trace is true", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
-      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
-      await (0, _authSession._runCreateWithRetries)({
-        authSessionId: "authSessionId",
-        authSessionInput: "authSessionInput",
-        retries: 10,
-        headless: "headless",
-        proxy: "proxy",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), undefined);
-      _vitest.vi.mocked(_helpers.withCLITrace).mockClear();
-      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
-      await (0, _authSession._runCreateWithRetries)({
-        authSessionId: "authSessionId",
-        authSessionInput: "authSessionInput",
-        retries: 10,
-        headless: "headless",
-        proxy: "proxy",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: true
-      });
-      (0, _vitest.expect)(_helpers.withCLITrace).toHaveBeenCalledWith(_vitest.expect.any(Function), _vitest.expect.any(String));
-    });
-    (0, _vitest.it)("saves the auth session instance", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
-      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("parsed-proxy");
-      await (0, _authSession._runCreateWithRetries)({
-        authSessionId: "authSessionId",
-        authSessionInput: "authSessionInput",
-        retries: 10,
-        headless: "headless",
-        proxy: "proxy",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith({
-        state: "session",
-        id: "authSessionId",
-        input: "authSessionInput",
-        proxy: "proxy"
-      });
-    });
-    (0, _vitest.it)("retries the create if it fails with automation error", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult).mockResolvedValueOnce(_createSuccessResult("session"));
-      await (0, _authSession._runCreateWithRetries)({
-        authSessionId: "authSessionId",
-        authSessionInput: "authSessionInput",
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-    });
-    (0, _vitest.it)("throws if all retries fail", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValue(_errorResult);
-      await (0, _vitest.expect)((0, _authSession._runCreateWithRetries)({
-        authSessionId: "authSessionId",
-        authSessionInput: {},
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(_helpers.CLIError);
-    });
-    (0, _vitest.it)("continues retrying if create fails due to an automation error", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult).mockResolvedValueOnce(_createSuccessResult("session"));
-      const result = await (0, _authSession._runCreateWithRetries)({
-        authSessionId: "authSessionId",
-        authSessionInput: {},
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(result).toEqual("session");
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
-    });
-    (0, _vitest.it)("throws the error if create fails with a non-automation error", async () => {
-      const error = new Error("runCheck failed");
-      _vitest.vi.mocked(_runApi.runApi).mockRejectedValueOnce(error);
-      await (0, _vitest.expect)((0, _authSession._runCreateWithRetries)({
-        authSessionId: "authSessionId",
-        authSessionInput: {},
-        retries: 10,
-        headless: "headless",
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(error);
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(1);
-    });
-  });
-  (0, _vitest.describe)("executeRunValidateAuthSessionCLI", () => {
-    (0, _vitest.beforeEach)(() => {
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
-        storageState: {},
-        metadata: {
-          authSessionId: "authSessionId",
-          authSessionType: "API",
-          authSessionInput: {},
-          createdAt: "",
-          updatedAt: ""
-        }
-      });
-    });
-    (0, _vitest.it)("asserts check API file exists", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
-      await (0, _authSession.executeRunValidateAuthSessionCLI)({
-        id: "authSessionId",
-        checkRetries: 1,
-        createRetries: 1,
-        autoRecreate: false,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "check");
-    });
-    (0, _vitest.it)("succeeds if check succeeds", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
-      await (0, _authSession.executeRunValidateAuthSessionCLI)({
-        id: "authSessionId",
-        checkRetries: 1,
-        createRetries: 1,
-        autoRecreate: false,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-    });
-    (0, _vitest.it)("throws if check fails with auto recreate disabled", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult);
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
-        storageState: {},
-        metadata: {
-          authSessionId: "authSessionId",
-          authSessionType: "API",
-          authSessionInput: {},
-          createdAt: "1970-01-01T00:00:00Z",
-          updatedAt: "1970-01-01T00:00:00Z"
-        }
-      });
-      await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
-        id: "authSessionId",
-        checkRetries: 1,
-        createRetries: 1,
-        autoRecreate: false,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(_helpers.CLIError);
-    });
-    (0, _vitest.describe)("check failed with auto recreate enabled", () => {
-      (0, _vitest.beforeEach)(() => {
-        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkFailedResult);
-      });
-      afterEach(() => {
-        _vitest.vi.mocked(_runApi.runApi).mockReset();
-        _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockReset();
-      });
-      (0, _vitest.it)("asserts create API file exists", async () => {
-        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
-        await (0, _authSession.executeRunValidateAuthSessionCLI)({
-          id: "authSessionId",
-          checkRetries: 1,
-          createRetries: 1,
-          autoRecreate: true,
-          headless: false,
-          timeout: 999999999,
-          keepBrowserOpen: false,
-          trace: false
-        });
-        (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "create");
-      });
-      (0, _vitest.it)("throws if auth session is manual", async () => {
-        _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
-          storageState: {},
-          metadata: {
-            authSessionId: "authSessionId",
-            authSessionType: "MANUAL",
-            authSessionInput: {},
-            createdAt: "",
-            updatedAt: ""
-          }
-        });
-        await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
-          id: "authSessionId",
-          checkRetries: 1,
-          createRetries: 1,
-          autoRecreate: true,
-          headless: false,
-          timeout: 999999999,
-          keepBrowserOpen: false,
-          trace: false
-        })).rejects.toThrow(_helpers.CLIError);
-      });
-      (0, _vitest.it)("throws if create fails", async () => {
-        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_errorResult);
-        await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
-          id: "authSessionId",
-          checkRetries: 1,
-          createRetries: 1,
-          autoRecreate: true,
-          headless: false,
-          timeout: 999999999,
-          keepBrowserOpen: false,
-          trace: false
-        })).rejects.toThrow(_helpers.CLIError);
-      });
-      (0, _vitest.it)("throws if create succeeds then check fails", async () => {
-        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkFailedResult);
-        await (0, _vitest.expect)((0, _authSession.executeRunValidateAuthSessionCLI)({
-          id: "authSessionId",
-          checkRetries: 1,
-          createRetries: 1,
-          autoRecreate: true,
-          headless: false,
-          timeout: 999999999,
-          keepBrowserOpen: false,
-          trace: false
-        })).rejects.toThrow(_helpers.CLIError);
-      });
-      (0, _vitest.it)("succeeds if create succeeds then check succeeds", async () => {
-        _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
-        await (0, _authSession.executeRunValidateAuthSessionCLI)({
-          id: "authSessionId",
-          checkRetries: 1,
-          createRetries: 1,
-          autoRecreate: true,
-          headless: false,
-          timeout: 999999999,
-          keepBrowserOpen: false,
-          trace: false
-        });
-      });
-    });
-  });
-  (0, _vitest.describe)("executeRunCreateAuthSessionCLI", () => {
-    (0, _vitest.beforeEach)(() => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
-    });
-    (0, _vitest.it)("asserts create check API file exists", async () => {
-      await (0, _authSession.executeRunCreateAuthSessionCLI)({
-        input: {},
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "check");
-      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "create");
-    });
-    (0, _vitest.it)("throws if create fails", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_errorResult);
-      await (0, _vitest.expect)((0, _authSession.executeRunCreateAuthSessionCLI)({
-        input: {},
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(_helpers.CLIError);
-    });
-    (0, _vitest.it)("throws if check fails after create succeeds", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkFailedResult);
-      await (0, _vitest.expect)((0, _authSession.executeRunCreateAuthSessionCLI)({
-        input: {},
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(_helpers.CLIError);
-    });
-    (0, _vitest.it)("saves to auth session instance path if create and check succeed", async () => {
-      await (0, _authSession.executeRunCreateAuthSessionCLI)({
-        input: "authSessionInput",
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: _vitest.expect.any(String)
-      }));
-    });
-    (0, _vitest.it)("uses auth session id to save if provided", async () => {
-      const result = await (0, _authSession.executeRunCreateAuthSessionCLI)({
-        id: "authSessionId",
-        input: "authSessionInput",
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: "authSessionId"
-      }));
-    });
-  });
-  (0, _vitest.describe)("executeRunUpdateAuthSessionCLI", () => {
-    (0, _vitest.beforeEach)(() => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session")).mockResolvedValueOnce(_checkPassedResult);
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
-        storageState: {},
-        metadata: {
-          authSessionId: "authSessionId",
-          authSessionType: "API",
-          authSessionInput: {},
-          createdAt: "",
-          updatedAt: ""
-        }
-      });
-    });
-    afterEach(() => {
-      _vitest.vi.mocked(_runApi.runApi).mockReset();
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockReset();
-    });
-    (0, _vitest.it)("throws if auth session is manual", async () => {
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
-        storageState: {},
-        metadata: {
-          authSessionId: "authSessionId",
-          authSessionType: "MANUAL",
-          authSessionInput: {},
-          createdAt: "",
-          updatedAt: ""
-        }
-      });
-      await (0, _vitest.expect)((0, _authSession.executeRunUpdateAuthSessionCLI)({
-        id: "authSessionId",
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(_helpers.CLIError);
-    });
-    (0, _vitest.it)("calls create with existing input if no input provided", async () => {
-      await (0, _authSession.executeRunUpdateAuthSessionCLI)({
-        id: "authSessionId",
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        automationFunction: {
-          name: "auth-sessions/create",
-          params: {}
-        },
-        runOptions: {
-          headless: false,
-          environment: "standalone",
-          proxy: undefined
-        },
-        retrieveSession: true
-      }));
-    });
-    (0, _vitest.it)("calls create with new input if provided", async () => {
-      _vitest.vi.mocked(_helpers.parseUrlProxy).mockReturnValueOnce("newProxy");
-      await (0, _authSession.executeRunUpdateAuthSessionCLI)({
-        id: "authSessionId",
-        input: "newAuthSessionInput",
-        proxy: "newProxyUrl",
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        automationFunction: {
-          name: "auth-sessions/create",
-          params: "newAuthSessionInput"
-        },
-        runOptions: {
-          headless: false,
-          environment: "standalone",
-          proxy: "newProxy"
-        },
-        retrieveSession: true
-      }));
-    });
-    (0, _vitest.it)("saves the auth session with existing input if create and check succeed without providing input", async () => {
-      const result = await (0, _authSession.executeRunUpdateAuthSessionCLI)({
-        id: "authSessionId",
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: "authSessionId",
-        input: {},
-        proxy: undefined
-      }));
-    });
-    (0, _vitest.it)("saves the auth session with new input if create and check succeed with new input", async () => {
-      const result = await (0, _authSession.executeRunUpdateAuthSessionCLI)({
-        id: "authSessionId",
-        input: "newAuthSessionInput",
-        proxy: "newProxyUrl",
-        checkRetries: 1,
-        createRetries: 1,
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: "authSessionId",
-        input: "newAuthSessionInput",
-        proxy: "newProxyUrl"
-      }));
-    });
-  });
-  (0, _vitest.describe)("executeAttemptCheckAuthSessionCLI", () => {
-    (0, _vitest.beforeEach)(() => {
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
-        storageState: {},
-        metadata: {
-          authSessionId: "authSessionId",
-          authSessionType: "API",
-          authSessionInput: {},
-          createdAt: "",
-          updatedAt: ""
-        }
-      });
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
-    });
-    afterEach(() => {
-      _vitest.vi.mocked(_runApi.runApi).mockReset();
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockReset();
-    });
-    (0, _vitest.it)("asserts check API file exists", async () => {
-      await (0, _authSession.executeAttemptCheckAuthSessionCLI)({
-        id: "authSessionId",
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "check");
-    });
-    (0, _vitest.it)("succeeds if check succeeds", async () => {
-      await (0, _authSession.executeAttemptCheckAuthSessionCLI)({
-        id: "authSessionId",
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-    });
-    (0, _vitest.it)("throws if check fails", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_checkFailedResult);
-      await (0, _vitest.expect)((0, _authSession.executeAttemptCheckAuthSessionCLI)({
-        id: "authSessionId",
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(_helpers.CLIError);
-    });
-  });
-  (0, _vitest.describe)("executeAttemptCreateAuthSessionCLI", () => {
-    (0, _vitest.beforeEach)(() => {
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_createSuccessResult("session"));
-    });
-    (0, _vitest.it)("asserts create API file exists", async () => {
-      await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
-        input: {},
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.assertApiFileExists).toHaveBeenCalledWith("auth-sessions", "create");
-    });
-    (0, _vitest.it)("throws if create fails", async () => {
-      _vitest.vi.mocked(_runApi.runApi).mockReset().mockResolvedValueOnce(_errorResult);
-      await (0, _vitest.expect)((0, _authSession.executeAttemptCreateAuthSessionCLI)({
-        input: {},
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      })).rejects.toThrow(_helpers.CLIError);
-    });
-    (0, _vitest.it)("saves to auth session instance path if create and check succeed", async () => {
-      await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
-        input: "authSessionInput",
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: _vitest.expect.any(String)
-      }));
-    });
-    (0, _vitest.it)("uses auth session id to save if provided", async () => {
-      await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
-        id: "authSessionId",
-        input: "authSessionInput",
-        headless: false,
-        timeout: 999999999,
-        keepBrowserOpen: false,
-        trace: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: "authSessionId"
-      }));
-    });
-  });
-  (0, _vitest.describe)("executeRecordAuthSessionCLI", () => {
-    let mockPage;
-    let mockContext;
-    (0, _vitest.beforeEach)(() => {
-      _vitest.vi.useFakeTimers();
-      _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce(_checkPassedResult);
-      mockPage = {
-        url: _vitest.vi.fn().mockReturnValue(""),
-        close: _vitest.vi.fn(),
-        goto: _vitest.vi.fn(),
-        waitForLoadState: _vitest.vi.fn()
-      };
-      mockContext = {
-        pages: _vitest.vi.fn().mockReturnValue([mockPage]),
-        close: _vitest.vi.fn()
-      };
-      _vitest.vi.mocked(_launchBrowser.launchChromium).mockResolvedValue({
-        context: mockContext,
-        page: mockPage
-      });
-      _vitest.vi.mocked(_helpers.loadAuthSessionInstance).mockResolvedValue({
-        storageState: {},
-        metadata: {
-          authSessionId: "authSessionId",
-          authSessionType: "MANUAL",
-          authSessionInput: {},
-          createdAt: "",
-          updatedAt: ""
-        }
-      });
-    });
-    afterEach(() => {
-      _vitest.vi.mocked(_runApi.runApi).mockReset();
-      _vitest.vi.mocked(_launchBrowser.launchChromium).mockReset();
-      _vitest.vi.useRealTimers();
-    });
-    (0, _vitest.it)("launches browser with app mode", async () => {
-      mockPage.url.mockReturnValue("finishUrl");
-      await (0, _authSession.executeRecordAuthSessionCLI)({
-        checkRetries: 1,
-        startUrl: "startUrl",
-        finishUrl: "finishUrl",
-        headless: false,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_launchBrowser.launchChromium).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        appModeInitialUrl: "startUrl"
-      }));
-    });
-    (0, _vitest.it)("navigates to the start url if the page doesn't load with it", async () => {
-      mockPage.url.mockReturnValue("finishUrl");
-      await (0, _authSession.executeRecordAuthSessionCLI)({
-        checkRetries: 1,
-        startUrl: "startUrl",
-        finishUrl: "finishUrl",
-        headless: false,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(mockPage.goto).toHaveBeenCalledWith("startUrl");
-    });
-    (0, _vitest.it)("waits for the finish url", async () => {
-      mockPage.url.mockReturnValueOnce("startUrl");
-      const mockTimeout = getMockTimeout();
-      let pending = true;
-      const p = (0, _authSession.executeRecordAuthSessionCLI)({
-        checkRetries: 1,
-        startUrl: "startUrl",
-        finishUrl: "finishUrl",
-        headless: false,
-        keepBrowserOpen: false
-      }).finally(() => pending = false);
-      await mockTimeout.resolve();
-      await mockTimeout.resolve();
-      await mockTimeout.resolve();
-      (0, _vitest.expect)(pending).toEqual(true);
-      mockPage.url.mockClear();
-      mockPage.url.mockReturnValueOnce("finishUrl");
-      await mockTimeout.resolve();
-      await p;
-    });
-    (0, _vitest.it)("throws if timeout is reached", async () => {
-      mockPage.url.mockReturnValueOnce("startUrl");
-      const mockTimeout = getMockTimeout();
-      _vitest.vi.setSystemTime(new Date(0));
-      let pending = true;
-      const p = (0, _authSession.executeRecordAuthSessionCLI)({
-        checkRetries: 1,
-        startUrl: "startUrl",
-        finishUrl: "finishUrl",
-        headless: false,
-        keepBrowserOpen: false,
-        timeout: 1000
-      }).finally(() => pending = false);
-      await mockTimeout.resolve();
-      await mockTimeout.resolve();
-      await mockTimeout.resolve();
-      (0, _vitest.expect)(pending).toEqual(true);
-      _vitest.vi.setSystemTime(new Date(2000));
-      await mockTimeout.resolve();
-      await (0, _vitest.expect)(p).rejects.toThrow(_helpers.CLIError);
-    });
-    (0, _vitest.it)("stores auth session and validates it if successful", async () => {
-      mockPage.url.mockReturnValue("finishUrl");
-      await (0, _authSession.executeRecordAuthSessionCLI)({
-        checkRetries: 1,
-        startUrl: "startUrl",
-        finishUrl: "finishUrl",
-        headless: false,
-        keepBrowserOpen: false
-      });
-      (0, _vitest.expect)(_helpers.storeAuthSessionInstance).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        id: _vitest.expect.any(String),
-        metadata: _vitest.expect.objectContaining({
-          authSessionType: "MANUAL",
-          recorderStartUrl: "startUrl",
-          recorderEndUrl: "finishUrl"
-        })
-      }));
-      (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledWith(_vitest.expect.objectContaining({
-        automationFunction: _vitest.expect.objectContaining({
-          name: "auth-sessions/check"
-        })
-      }));
-    });
-  });
-});