@intuned/runtime-dev 1.3.18-interface.2 → 1.3.18-interface.21

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scaffoldAuthSessionFiles = scaffoldAuthSessionFiles;
+var _zod = require("zod");
+var _helpers = require("../helpers");
+var _types = require("../types");
+var _tsNodeImport = require("../../common/tsNodeImport");
+var _constants = require("../../../common/constants");
+var _fsExtra = require("fs-extra");
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const authSessionTemplateResponseSchema = _zod.z.object({
+  "auth-sessions": _types.fileSystemTreeSchema
+});
+async function scaffoldAuthSessionFiles() {
+  const [createResult, checkResult] = await Promise.all([(0, _tsNodeImport.tsNodeImport)(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`), (0, _tsNodeImport.tsNodeImport)(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`)]);
+  const createExists = createResult.isOk() || createResult.error.type !== "not_found";
+  const checkExists = checkResult.isOk() || checkResult.error.type !== "not_found";
+  if (createExists && checkExists) {
+    (0, _helpers.terminal)("^g^+AuthSession files already exist^:\n");
+    return;
+  }
+  (0, _helpers.terminal)("^g^+Scaffolding...^:\n");
+  const authSessionTemplateUrl = new URL("/api/v1/templates/authsession", (0, _helpers.getBaseUrl)());
+  authSessionTemplateUrl.searchParams.append("language", "typescript");
+  const response = await fetch(authSessionTemplateUrl.toString(), {
+    method: "GET"
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`Failed to fetch AuthSession template
+Got ${response.status} ${response.statusText}
+${text}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`Failed to parse AuthSession template response as JSON
+${text}`);
+  }
+  const parseResult = authSessionTemplateResponseSchema.safeParse(json);
+  if (!parseResult.success) {
+    throw new Error(`AuthSession template response has invalid shape: ${JSON.stringify(parseResult.error.errors, null, 2)}`);
+  }
+  const authSessionsContent = parseResult.data["auth-sessions"];
+  const cwd = process.cwd();
+  const exists = {
+    create: createExists,
+    check: checkExists
+  };
+  await (0, _fsExtra.ensureDir)(_path.default.join(cwd, _constants.AUTH_SESSIONS_FOLDER_NAME));
+  for (const api in exists) {
+    if (exists[api]) {
+      continue;
+    }
+    const [name, node] = Object.entries(authSessionsContent).find(entry => "file" in entry[1] && entry[0].replace(/\.[^/.]+$/, "") === api) ?? [undefined, undefined];
+    if (!name || !node) {
+      continue;
+    }
+    const {
+      file: {
+        contents
+      }
+    } = node;
+    if (typeof contents !== "string") {
+      continue;
+    }
+    await (0, _fsExtra.writeFile)(_path.default.join(cwd, _constants.AUTH_SESSIONS_FOLDER_NAME, name), contents, {
+      encoding: "utf-8"
+    });
+    (0, _helpers.terminal)(`^g^+Written ^_${_path.default.join(_constants.AUTH_SESSIONS_FOLDER_NAME, name)}^:\n`);
+  }
+}

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

@@ -0,0 +1,152 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _browser = require("../browser");
+var _launchBrowser = require("../../../../common/launchBrowser");
+var _errors = require("../errors");
+function getTerminal() {
+  return new Proxy(() => ({}), {
+    get: () => getTerminal(),
+    apply: () => ({})
+  });
+}
+_vitest.vi.mock("fs-extra", () => ({
+  ensureDir: _vitest.vi.fn(),
+  exists: _vitest.vi.fn().mockResolvedValue(true)
+}));
+_vitest.vi.mock("portfinder", () => ({
+  getPort: _vitest.vi.fn().mockResolvedValue(1234)
+}));
+_vitest.vi.mock("../../../../common/launchBrowser", () => ({
+  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()
+  };
+});
+_vitest.vi.mock("../../../../common/browserTabs", () => {
+  return {
+    getCDPTabs: _vitest.vi.fn().mockResolvedValue([{
+      id: "tab1",
+      title: "Tab 1",
+      url: "http://example.com/1"
+    }, {
+      id: "tab2",
+      title: "Tab 2",
+      url: "http://example.com/2"
+    }])
+  };
+});
+(0, _vitest.describe)("Browser CLI options", () => {
+  (0, _vitest.it)("returns cdp options with first tab if cdpUrl is set and no cdpTabId is not provided", async () => {
+    const options = await (0, _browser.getCLIRunOptions)({
+      keepBrowserOpen: true,
+      headless: true,
+      cdpUrl: "cdp_url"
+    });
+    (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
+      environment: "cdp",
+      cdpAddress: "cdp_url",
+      cdpTargetId: "tab1"
+    }));
+  });
+  (0, _vitest.it)("returns cdp options with selected tab if cdpUrl and cdpTabId are provided", async () => {
+    const options = await (0, _browser.getCLIRunOptions)({
+      keepBrowserOpen: true,
+      headless: true,
+      cdpUrl: "cdp_url",
+      cdpTabId: "tab2"
+    });
+    (0, _vitest.expect)(options).toEqual(_vitest.expect.objectContaining({
+      environment: "cdp",
+      cdpAddress: "cdp_url",
+      cdpTargetId: "tab2"
+    }));
+  });
+  (0, _vitest.it)("fails in cdp options if cdp url is provided and invalid tab id is provided", async () => {
+    const optionsPromise = (0, _browser.getCLIRunOptions)({
+      keepBrowserOpen: true,
+      headless: true,
+      cdpUrl: "cdp_url",
+      cdpTabId: "tab3"
+    });
+    await (0, _vitest.expect)(optionsPromise).rejects.toThrowError(_errors.CLIError);
+  });
+  (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)(_launchBrowser.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)(_launchBrowser.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)(_launchBrowser.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,41 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _dist = require("../../../../../dist");
+function getTerminal() {
+  return new Proxy(() => ({}), {
+    get: () => getTerminal(),
+    apply: () => ({})
+  });
+}
+_vitest.vi.mock("fs-extra", () => ({
+  ensureDir: _vitest.vi.fn(),
+  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, _dist.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, _dist.withCLITrace)(fn, "trace-id");
+    (0, _vitest.expect)(fn).toHaveBeenCalledWith({
+      enabled: true,
+      filePath: _vitest.expect.stringContaining("trace-id")
+    });
+  });
+});

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

@@ -0,0 +1,3 @@
+import { API_FOLDER_NAME, AUTH_SESSIONS_FOLDER_NAME } from "../../../common/constants";
+export declare function assertApiFileExists(dirname: typeof AUTH_SESSIONS_FOLDER_NAME, api: "create" | "check"): Promise<void>;
+export declare function assertApiFileExists(dirname: typeof API_FOLDER_NAME, api: string): Promise<void>;

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertApiFileExists = assertApiFileExists;
+var _errors = require("./errors");
+var _tsNodeImport = require("../../common/tsNodeImport");
+async function assertApiFileExists(dirname, api) {
+  const result = await (0, _tsNodeImport.tsNodeImport)(`${dirname}/${api}`);
+  if (result.isErr() && result.error.type === "not_found") {
+    throw new _errors.CLIAssertionError(`^+^r API^ ^+${dirname}/${api}^ ^r^+does not exist. Make sure to use an existing API name.^:`, {
+      autoColor: false
+    });
+  }
+}

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

@@ -0,0 +1,46 @@
+import type { AuthSessionMetadata } from "../types";
+import { RunApiStorageState } from "@intuned/runtime-interface";
+export declare function isAuthEnabled(): Promise<boolean>;
+export declare function assertAuthEnabled(): Promise<void>;
+export declare function assertAuthConsistent(authSession: string | undefined): Promise<void>;
+export declare function loadAuthSessionInstance(authSessionId: string): Promise<{
+    storageState: {
+        cookies: {
+            value: string;
+            path: string;
+            name: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+            sameSite: "Strict" | "Lax" | "None";
+        }[];
+        origins: {
+            origin: string;
+            localStorage: {
+                value: string;
+                name: string;
+            }[];
+        }[];
+        sessionStorage?: {
+            origin: string;
+            sessionStorage: {
+                value: string;
+                name: string;
+            }[];
+        }[] | undefined;
+    };
+    metadata: AuthSessionMetadata;
+}>;
+export declare function storeAuthSessionInstance({ state, id, input, proxy, metadata, }: {
+    state: RunApiStorageState;
+    id: string;
+    input?: Record<string, any>;
+    proxy?: string;
+    metadata?: AuthSessionMetadata;
+}): Promise<string>;
+export declare function registerGetAuthSessionParameters(authSessionId?: string): void;
+export declare function getAuthSessionRecorderParameters(): Promise<{
+    startUrl: string;
+    finishUrl: string;
+}>;

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

@@ -0,0 +1,147 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertAuthConsistent = assertAuthConsistent;
+exports.assertAuthEnabled = assertAuthEnabled;
+exports.getAuthSessionRecorderParameters = getAuthSessionRecorderParameters;
+exports.isAuthEnabled = isAuthEnabled;
+exports.loadAuthSessionInstance = loadAuthSessionInstance;
+exports.registerGetAuthSessionParameters = registerGetAuthSessionParameters;
+exports.storeAuthSessionInstance = storeAuthSessionInstance;
+var _constants = require("../../../common/constants");
+var _path = _interopRequireDefault(require("path"));
+var _fsExtra = require("fs-extra");
+var _intunedJson = require("./intunedJson");
+var _errors = require("./errors");
+var _runtimeInterface = require("../../../vendor/runtime-interface");
+var _formatZodError = require("../../../common/formatZodError");
+var _asyncLocalStorage = require("../../../common/asyncLocalStorage");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function isAuthEnabled() {
+  const intunedJson = await (0, _intunedJson.loadIntunedJson)();
+  return Boolean(intunedJson?.authSessions?.enabled);
+}
+async function assertAuthEnabled() {
+  if (!(await isAuthEnabled())) {
+    throw new _errors.CLIAssertionError(await getAuthNotEnabledErrorMessage());
+  }
+}
+async function assertAuthConsistent(authSession) {
+  const _isAuthEnabled = await isAuthEnabled();
+  if (_isAuthEnabled && !authSession) {
+    throw new _errors.CLIAssertionError("AuthSession is enabled, but no AuthSession is provided. Please provide an AuthSession using '--auth-session <id>' option.");
+  }
+  if (!_isAuthEnabled && authSession) {
+    throw new _errors.CLIAssertionError(await getAuthNotEnabledErrorMessage());
+  }
+}
+async function loadAuthSessionInstance(authSessionId) {
+  try {
+    const authSessionInstancePath = _path.default.join(process.cwd(), _constants.AUTH_SESSIONS_INSTANCES_FOLDER_NAME, authSessionId);
+    const authSessionInstanceStoragePath = _path.default.join(authSessionInstancePath, `auth-session.json`);
+    const authSessionInstanceMetadataPath = _path.default.join(authSessionInstancePath, `metadata.json`);
+    if (!(await (0, _fsExtra.exists)(authSessionInstanceStoragePath))) {
+      throw new _errors.CLIError(`AuthSession instance with ID ${authSessionId} not found. Make sure the ID is correct.`);
+    }
+    const authSessionInstanceJson = await (0, _fsExtra.readJSON)(authSessionInstanceStoragePath);
+    const authSessionInstanceParseResult = _runtimeInterface.runApiStorageStateSchema.safeParse(authSessionInstanceJson);
+    if (!authSessionInstanceParseResult.success) {
+      throw new _errors.CLIError(`AuthSession instance with ID ${authSessionId} is not valid: ${(0, _formatZodError.formatZodError)(authSessionInstanceParseResult.error)}`);
+    }
+    const metadata = await (0, _fsExtra.readJSON)(authSessionInstanceMetadataPath);
+    return {
+      storageState: authSessionInstanceParseResult.data,
+      metadata
+    };
+  } catch (error) {
+    throw new _errors.CLIError(`Error loading AuthSession instance: ${error.message}`);
+  }
+}
+async function storeAuthSessionInstance({
+  state,
+  id,
+  input,
+  proxy,
+  metadata
+}) {
+  try {
+    const authSessionsDirectoryPath = _path.default.join(process.cwd(), _constants.AUTH_SESSIONS_INSTANCES_FOLDER_NAME);
+    await (0, _fsExtra.ensureDir)(authSessionsDirectoryPath);
+    const authSessionInstancePath = _path.default.join(authSessionsDirectoryPath, id);
+    await (0, _fsExtra.ensureDir)(authSessionInstancePath);
+    const authSessionInstanceStoragePath = _path.default.join(authSessionInstancePath, `auth-session.json`);
+    await (0, _fsExtra.writeJSON)(authSessionInstanceStoragePath, state, {
+      spaces: 2
+    });
+    const projectAuthConfig = (await (0, _intunedJson.loadIntunedJson)()).authSessions;
+    if (!projectAuthConfig.enabled) {
+      throw new _errors.CLIError(`AuthSessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}. Make sure they are enabled.`);
+    }
+    const authSessionInstanceMetadataPath = _path.default.join(authSessionInstancePath, `metadata.json`);
+    const authSessionMetadata = {
+      createdAt: metadata?.createdAt ?? new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      ...(projectAuthConfig.type === "API" && {
+        authSessionInput: input || metadata?.authSessionInput || {}
+      }),
+      authSessionId: id,
+      authSessionType: projectAuthConfig.type ?? metadata?.authSessionType ?? "API",
+      ...(projectAuthConfig.type === "MANUAL" && {
+        recorderStartUrl: projectAuthConfig.startUrl,
+        recorderEndUrl: projectAuthConfig.finishUrl
+      }),
+      authSessionInput: input || metadata?.authSessionInput || {},
+      authSessionProxy: proxy || metadata?.authSessionProxy
+    };
+    await (0, _fsExtra.writeJSON)(authSessionInstanceMetadataPath, authSessionMetadata, {
+      spaces: 2
+    });
+    return authSessionInstancePath;
+  } catch (error) {
+    throw new _errors.CLIError(`Error storing AuthSession instance: ${error.message}`);
+  }
+}
+function registerGetAuthSessionParameters(authSessionId) {
+  async function getAuthSessionParameters() {
+    if (!authSessionId) {
+      throw new Error("getAuthSessionParameters cannot be called without using an AuthSession");
+    }
+    const {
+      metadata
+    } = await loadAuthSessionInstance(authSessionId);
+    if (metadata?.authSessionType === "MANUAL") {
+      throw new Error("AuthSession is recorder-based, it does not have parameters.");
+    }
+    return metadata?.authSessionInput ?? {};
+  }
+  (0, _asyncLocalStorage.getExecutionContext)().getAuthSessionParameters = getAuthSessionParameters;
+}
+async function getAuthSessionRecorderParameters() {
+  const intunedJson = await (0, _intunedJson.loadIntunedJson)();
+  if (!intunedJson.authSessions.enabled) {
+    throw new _errors.CLIError(`AuthSessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}. Make sure they are enabled.`);
+  }
+  if (intunedJson.authSessions.type !== "MANUAL") {
+    throw new _errors.CLIError(`AuthSession type is not recorder-based in ${await (0, _intunedJson.getIntunedSettingsFileName)()}.
+Make sure the AuthSession type is set to 'MANUAL'
+For more details, check out https://docs.intunedhq.com/docs/05-references/intuned-json#configuration-properties.`);
+  }
+  const {
+    startUrl,
+    finishUrl
+  } = intunedJson.authSessions;
+  if (startUrl === undefined || finishUrl === undefined) {
+    throw new _errors.CLIError(`AuthSession type is recorder-based but start_url or finish_url is not set in ${await (0, _intunedJson.getIntunedSettingsFileName)()}.
+Please set both values to use recorder-based AuthSessions.
+For more details, check out https://docs.intunedhq.com/docs/05-references/intuned-json#configuration-properties`);
+  }
+  return {
+    startUrl,
+    finishUrl
+  };
+}
+async function getAuthNotEnabledErrorMessage() {
+  return "AuthSessions are not enabled.\n" + `Enable AuthSessions in ${await (0, _intunedJson.getIntunedSettingsFileName)()} to use this feature.\n` + "See https://docs.intunedhq.com/docs/02-features/auth-sessions#1-enable-authsessions-for-your-project for more information.";
+}

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

@@ -0,0 +1,8 @@
+export declare function getAuthCredentials(options: {
+    workspaceId?: string;
+    apiKey?: string;
+}): Promise<{
+    workspaceId: string;
+    apiKey: string;
+}>;
+export declare function getBaseUrl(): string;

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAuthCredentials = getAuthCredentials;
+exports.getBaseUrl = getBaseUrl;
+var _constants = require("../../../common/constants");
+var _errors = require("./errors");
+var _intunedJson = require("./intunedJson");
+var _prompts = require("./prompts");
+async function getAuthCredentials(options) {
+  const settings = await (0, _intunedJson.loadIntunedJson)();
+  let workspaceId = options.workspaceId || settings.workspaceId || process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY];
+  let apiKey = options.apiKey || process.env[_constants.API_KEY_ENV_VAR_KEY];
+  if (!workspaceId) {
+    workspaceId = await (0, _prompts.promptForWorkspaceId)();
+  }
+  if (!workspaceId) {
+    throw new _errors.CLIError(`Workspace ID is required. Please provide it via command line options or ${await (0, _intunedJson.getIntunedSettingsFileName)()}.\n` + `Expected format: UUID (e.g., 123e4567-e89b-12d3-a456-426614174000)\n` + `Find your workspace ID at: https://app.intuned.io/settings/api-keys`);
+  }
+  if (!apiKey) {
+    apiKey = await (0, _prompts.promptForApiKey)();
+  }
+  if (!apiKey) {
+    throw new _errors.CLIError(`API key is required. Please provide it via command line options or ${_constants.API_KEY_ENV_VAR_KEY} environment variable.\n` + `Get your API key at: https://app.intuned.io/settings/api-keys`);
+  }
+  return {
+    workspaceId,
+    apiKey
+  };
+}
+function getBaseUrl() {
+  return new URL(process.env[_constants.API_BASE_URL_ENV_VAR_KEY] || process.env.INTUNED_API_DOMAIN || `https://app.intuned.io`).origin;
+}

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

@@ -0,0 +1,14 @@
+import type { BrowserContext } from "playwright";
+import type { RunApiRunOptions } from "@intuned/runtime-interface";
+declare let context: BrowserContext | null;
+export declare function _getContextForTest(): typeof context;
+export declare function getCLIRunOptions({ headless, proxy, keepBrowserOpen, cdpUrl, cdpTabId, }: {
+    headless: boolean;
+    proxy?: string;
+    keepBrowserOpen: boolean;
+    cdpUrl?: string;
+    cdpTabId?: string;
+}): Promise<RunApiRunOptions>;
+export declare function isCliBrowserLaunched(): boolean;
+export declare function closeCliBrowser(): Promise<void>;
+export {};

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

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._getContextForTest = _getContextForTest;
+exports.closeCliBrowser = closeCliBrowser;
+exports.getCLIRunOptions = getCLIRunOptions;
+exports.isCliBrowserLaunched = isCliBrowserLaunched;
+var _launchBrowser = require("../../../common/launchBrowser");
+var _portfinder = require("portfinder");
+var _proxy = require("./proxy");
+var _browserTabs = require("../../../common/browserTabs");
+var _errors = require("./errors");
+let context = null;
+function _getContextForTest() {
+  if (process.env.NODE_ENV !== "test") {
+    throw new Error("_getContextForTest should only be used in tests");
+  }
+  return context;
+}
+async function getCLIRunOptions({
+  headless,
+  proxy,
+  keepBrowserOpen,
+  cdpUrl,
+  cdpTabId
+}) {
+  if (context) {
+    await closeCliBrowser();
+  }
+  if (cdpUrl) {
+    return {
+      environment: "cdp",
+      cdpAddress: cdpUrl,
+      cdpTargetId: await resolveCdpTargetId({
+        cdpAddress: cdpUrl,
+        cdpTabId
+      })
+    };
+  }
+  if (!keepBrowserOpen) {
+    return {
+      environment: "standalone",
+      headless,
+      proxy: proxy ? (0, _proxy.parseUrlProxy)(proxy) : undefined
+    };
+  }
+  const port = await (0, _portfinder.getPort)({});
+  ({
+    context
+  } = await (0, _launchBrowser.launchChromium)({
+    headless,
+    proxy: proxy ? (0, _proxy.parseUrlProxy)(proxy) : undefined,
+    cdpPort: port
+  }));
+  return {
+    environment: "cdp",
+    cdpAddress: `http://localhost:${port}`
+  };
+}
+function isCliBrowserLaunched() {
+  return context !== null;
+}
+async function closeCliBrowser() {
+  if (!context) return;
+  try {
+    await context.close();
+    context = null;
+  } catch (e) {}
+}
+async function resolveCdpTargetId({
+  cdpAddress,
+  cdpTabId
+}) {
+  let tabs = [];
+  try {
+    tabs = await (0, _browserTabs.getCDPTabs)(cdpAddress);
+  } catch (e) {
+    if (cdpTabId) {
+      throw new _errors.CLIError(`Failed to fetch tabs from browser: ${e}`);
+    }
+  }
+  if (!cdpTabId) {
+    return tabs[0]?.id;
+  }
+  for (const tab of tabs) {
+    if (tab.id.startsWith(cdpTabId)) {
+      return tab.id;
+    }
+  }
+  throw new _errors.CLIError(`Tab ${cdpTabId} not found at ${cdpAddress}`);
+}

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

@@ -0,0 +1,3 @@
+export declare function withCLIContext<R>(fn: () => Promise<R>, options?: {
+    authSessionId?: string;
+}): Promise<R>;

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withCLIContext = withCLIContext;
+var _nanoid = require("nanoid");
+var _asyncLocalStorage = require("../../../common/asyncLocalStorage");
+var _enums = require("../../../runtime/enums");
+var _auth = require("./auth");
+async function withCLIContext(fn, options) {
+  const runId = (0, _nanoid.nanoid)();
+  async function getAuthSessionParameters() {
+    const id = options?.authSessionId;
+    if (!id) {
+      throw new Error("getAuthSessionParameters cannot be called without using an AuthSession");
+    }
+    const {
+      metadata
+    } = await (0, _auth.loadAuthSessionInstance)(id);
+    if (metadata?.authSessionType === "MANUAL") {
+      throw new Error("AuthSession is recorder-based, it does not have parameters.");
+    }
+    return metadata?.authSessionInput ?? {};
+  }
+  return await (0, _asyncLocalStorage.runWithContext)({
+    runEnvironment: _enums.RunEnvironment.IDE,
+    runId,
+    extendedPayloads: [],
+    timeoutInfo: {},
+    getAuthSessionParameters
+  }, fn);
+}