@intuned/runtime-dev 1.3.9-deploy.0 → 1.3.9-dev10

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

@@ -0,0 +1,144 @@
+"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 _runApi = require("../../../common/runApi");
+var _formatZodError = require("../../../common/formatZodError");
+var _asyncLocalStorage = require("../../../common/asyncLocalStorage");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function isAuthEnabled() {
+  try {
+    const intunedJson = await (0, _intunedJson.loadIntunedJson)();
+    return Boolean(intunedJson?.authSessions?.enabled);
+  } catch (error) {
+    return false;
+  }
+}
+async function assertAuthEnabled() {
+  if (!(await isAuthEnabled())) {
+    throw new _errors.CLIAssertionError(`Auth session is not enabled, enable it in ${await (0, _intunedJson.getIntunedSettingsFileName)()} to use it`);
+  }
+}
+async function assertAuthConsistent(authSession) {
+  const _isAuthEnabled = await isAuthEnabled();
+  if (_isAuthEnabled && !authSession) {
+    throw new _errors.CLIAssertionError("Auth session is enabled, but no auth session is provided. Please provide an auth session ID.");
+  }
+  if (!_isAuthEnabled && authSession) {
+    throw new _errors.CLIAssertionError(`Auth session is not enabled, enable it in ${await (0, _intunedJson.getIntunedSettingsFileName)()} to use it`);
+  }
+}
+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(`Auth session instance with ID ${authSessionId} not found`);
+    }
+    const authSessionInstanceJson = await (0, _fsExtra.readJSON)(authSessionInstanceStoragePath);
+    const authSessionInstanceParseResult = _runApi.runApiStorageStateSchema.safeParse(authSessionInstanceJson);
+    if (!authSessionInstanceParseResult.success) {
+      throw new _errors.CLIError(`Auth session 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 retrieving auth session 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(`Auth sessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+    }
+    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 auth session instance: ${error.message}`);
+  }
+}
+function registerGetAuthSessionParameters(authSessionId) {
+  async function getAuthSessionParameters() {
+    if (!authSessionId) {
+      throw new Error("getAuthSessionParameters cannot be called without using an auth session");
+    }
+    const {
+      metadata
+    } = await loadAuthSessionInstance(authSessionId);
+    if (metadata?.authSessionType === "MANUAL") {
+      throw new Error("Auth session 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(`Auth sessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+  }
+  if (intunedJson.authSessions.type !== "MANUAL") {
+    throw new _errors.CLIError(`Auth session type is not recorder-based in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+  }
+  const {
+    startUrl,
+    finishUrl
+  } = intunedJson.authSessions;
+  if (startUrl === undefined || finishUrl === undefined) {
+    throw new _errors.CLIError(`Auth session type is recorder-based but start_url or finish_url is not set in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+  }
+  return {
+    startUrl,
+    finishUrl
+  };
+}

package/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/package/dist/commands/intuned-cli/helpers/backend.js

@@ -0,0 +1,27 @@
+"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");
+async function getAuthCredentials(options) {
+  const workspaceId = options.workspaceId || (await (0, _intunedJson.loadIntunedJson)()).workspaceId;
+  const apiKey = options.apiKey || process.env[_constants.API_KEY_ENV_VAR_KEY];
+  if (!workspaceId) {
+    throw new _errors.CLIError(`Workspace ID is required. Please provide it via command line options or ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+  }
+  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.`);
+  }
+  return {
+    workspaceId,
+    apiKey
+  };
+}
+function getBaseUrl() {
+  return process.env[_constants.API_BASE_URL_ENV_VAR_KEY] || process.env.INTUNED_API_DOMAIN || `https://app.intuned.io`;
+}

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

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

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

@@ -0,0 +1,57 @@
+"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");
+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
+}) {
+  if (context) {
+    await closeCliBrowser();
+  }
+  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) {}
+}

package/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/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 auth session");
+    }
+    const {
+      metadata
+    } = await (0, _auth.loadAuthSessionInstance)(id);
+    if (metadata?.authSessionType === "MANUAL") {
+      throw new Error("Auth session 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);
+}

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

@@ -0,0 +1,13 @@
+import { RunAutomationError } from "../../../common/runApi";
+export declare class CLIError extends Error {
+    autoColor: boolean;
+    constructor(message: string, options?: {
+        autoColor?: boolean;
+    });
+}
+export declare class CLIAssertionError extends CLIError {
+    constructor(message: string, options?: {
+        autoColor?: boolean;
+    });
+}
+export declare function logAutomationError(error: RunAutomationError): void;

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

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLIError = exports.CLIAssertionError = void 0;
+exports.logAutomationError = logAutomationError;
+var _runApi = require("../../../common/runApi");
+var _terminal = require("./terminal");
+class CLIError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "CLIError";
+    this.autoColor = options?.autoColor ?? true;
+  }
+}
+exports.CLIError = CLIError;
+class CLIAssertionError extends CLIError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CLIAssertionError";
+  }
+}
+exports.CLIAssertionError = CLIAssertionError;
+function logAutomationError(error) {
+  (0, _terminal.terminal)(`^r^+An error occurred while running the API:^:\n`);
+  if (error instanceof _runApi.AutomationError) {
+    if (error.error.stack) {
+      const stackLines = error.error.stack.split("\n").filter(line => !line.includes("@intuned/runtime") && !line.includes("node:"));
+      (0, _terminal.terminal)(`^r${stackLines.join("\n")}^:\n`);
+    } else {
+      (0, _terminal.terminal)(`^r${error.error.message}^:\n`);
+    }
+  } else {
+    (0, _terminal.terminal)(`^r${error.message}^:\n`);
+  }
+}

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

@@ -0,0 +1,12 @@
+export * from "./api";
+export * from "./auth";
+export * from "./context";
+export * from "./errors";
+export * from "./proxy";
+export * from "./terminal";
+export * from "./timeout";
+export * from "./validation";
+export * from "./intunedJson";
+export * from "./backend";
+export * from "./traces";
+export * from "./wrapper";

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

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _api = require("./api");
+Object.keys(_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _api[key];
+    }
+  });
+});
+var _auth = require("./auth");
+Object.keys(_auth).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _auth[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _auth[key];
+    }
+  });
+});
+var _context = require("./context");
+Object.keys(_context).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _context[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _context[key];
+    }
+  });
+});
+var _errors = require("./errors");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errors[key];
+    }
+  });
+});
+var _proxy = require("./proxy");
+Object.keys(_proxy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _proxy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _proxy[key];
+    }
+  });
+});
+var _terminal = require("./terminal");
+Object.keys(_terminal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _terminal[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _terminal[key];
+    }
+  });
+});
+var _timeout = require("./timeout");
+Object.keys(_timeout).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _timeout[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _timeout[key];
+    }
+  });
+});
+var _validation = require("./validation");
+Object.keys(_validation).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validation[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validation[key];
+    }
+  });
+});
+var _intunedJson = require("./intunedJson");
+Object.keys(_intunedJson).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _intunedJson[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _intunedJson[key];
+    }
+  });
+});
+var _backend = require("./backend");
+Object.keys(_backend).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _backend[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _backend[key];
+    }
+  });
+});
+var _traces = require("./traces");
+Object.keys(_traces).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _traces[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _traces[key];
+    }
+  });
+});
+var _wrapper = require("./wrapper");
+Object.keys(_wrapper).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _wrapper[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _wrapper[key];
+    }
+  });
+});

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export declare const intunedJsonSchema: z.ZodObject<{
+    authSessions: z.ZodUnion<[z.ZodObject<{
+        enabled: z.ZodLiteral<false>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: false;
+    }, {
+        enabled: false;
+    }>, z.ZodObject<{
+        enabled: z.ZodLiteral<true>;
+        type: z.ZodEnum<["MANUAL", "API"]>;
+        startUrl: z.ZodOptional<z.ZodString>;
+        finishUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    }, {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    }>]>;
+    projectName: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    authSessions: {
+        enabled: false;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    projectName?: string | undefined;
+    workspaceId?: string | undefined;
+}, {
+    authSessions: {
+        enabled: false;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    projectName?: string | undefined;
+    workspaceId?: string | undefined;
+}>;
+export type IntunedJson = z.infer<typeof intunedJsonSchema>;
+export declare const intunedSettingsFileNames: readonly ["Intuned.json", "Intuned.jsonc", "Intuned.yaml", "Intuned.yml", "Intuned.toml"];
+export declare function loadIntunedJson(): Promise<{
+    authSessions: {
+        enabled: false;
+    } | {
+        type: "API" | "MANUAL";
+        enabled: true;
+        startUrl?: string | undefined;
+        finishUrl?: string | undefined;
+    };
+    projectName?: string | undefined;
+    workspaceId?: string | undefined;
+}>;
+export declare function getIntunedSettingsFile(): Promise<{
+    name: typeof intunedSettingsFileNames[number];
+    path: string;
+    parse: (content: string) => any;
+}>;
+export declare function getIntunedSettingsFileName(): Promise<string>;

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

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIntunedSettingsFile = getIntunedSettingsFile;
+exports.getIntunedSettingsFileName = getIntunedSettingsFileName;
+exports.intunedSettingsFileNames = exports.intunedJsonSchema = void 0;
+exports.loadIntunedJson = loadIntunedJson;
+var _path = _interopRequireDefault(require("path"));
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _zod = require("zod");
+var _errors = require("./errors");
+var JSONC = _interopRequireWildcard(require("jsonc-parser"));
+var YAML = _interopRequireWildcard(require("yaml"));
+var TOML = _interopRequireWildcard(require("smol-toml"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const intunedJsonSchema = exports.intunedJsonSchema = _zod.z.object({
+  authSessions: _zod.z.union([_zod.z.object({
+    enabled: _zod.z.literal(false)
+  }), _zod.z.object({
+    enabled: _zod.z.literal(true),
+    type: _zod.z.enum(["MANUAL", "API"]),
+    startUrl: _zod.z.string().optional(),
+    finishUrl: _zod.z.string().optional()
+  })]),
+  projectName: _zod.z.string().optional(),
+  workspaceId: _zod.z.string().optional()
+});
+const intunedSettingsFileNames = exports.intunedSettingsFileNames = ["Intuned.json", "Intuned.jsonc", "Intuned.yaml", "Intuned.yml", "Intuned.toml"];
+async function loadIntunedJson() {
+  const settingsFile = await getIntunedSettingsFile();
+  const intunedJsonContent = await fs.readFile(settingsFile.path, "utf-8");
+  let intunedJson;
+  try {
+    intunedJson = settingsFile.parse(intunedJsonContent);
+  } catch (e) {
+    throw new _errors.CLIError(`Failed to parse ${settingsFile.name}: ${e.message}`);
+  }
+  const parseResult = intunedJsonSchema.safeParse(intunedJson);
+  if (!parseResult.success) {
+    const formattedError = parseResult.error.errors.map(e => `- ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new _errors.CLIError(`${settingsFile.name} is not valid:\n${formattedError}\nPlease fix the errors and try again.`);
+  }
+  return parseResult.data;
+}
+const intunedSettingsParsers = {
+  "Intuned.json": JSON.parse,
+  "Intuned.jsonc": JSONC.parse,
+  "Intuned.yaml": YAML.parse,
+  "Intuned.yml": YAML.parse,
+  "Intuned.toml": TOML.parse
+};
+async function getIntunedSettingsFile() {
+  for (const fileName of intunedSettingsFileNames) {
+    const filePath = _path.default.join(process.cwd(), fileName);
+    if (await fs.exists(filePath)) {
+      return {
+        name: fileName,
+        path: filePath,
+        parse: intunedSettingsParsers[fileName]
+      };
+    }
+  }
+  throw new _errors.CLIError(`No Intuned settings file found.`);
+}
+async function getIntunedSettingsFileName() {
+  return (await getIntunedSettingsFile()).name;
+}

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

@@ -0,0 +1,5 @@
+export declare function parseUrlProxy(proxyUrl: string): {
+    password: string;
+    username: string;
+    server: string;
+} | undefined;

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUrlProxy = parseUrlProxy;
+function parseUrlProxy(proxyUrl) {
+  try {
+    const url = new URL(proxyUrl);
+    const username = url.username;
+    const password = url.password;
+    const proxy = url.hostname;
+    const port = url.port ? `:${url.port}` : "";
+    const domain = `${url.protocol}//${proxy}${port}`;
+    return {
+      password,
+      username,
+      server: domain
+    };
+  } catch (error) {
+    return;
+  }
+}

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export declare const terminalStdout: NodeJS.WriteStream & {
+    fd: 2;
+};
+export declare const terminal: import("terminal-kit/Terminal");