@intuned/runtime-dev 1.3.8-jsonl.0 → 1.3.9-dev1

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

@@ -0,0 +1,1059 @@
+"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"
+        })
+      }));
+    });
+  });
+});