@intuned/runtime-dev 1.2.0-cli.0 → 1.2.0-cli.10

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

@@ -8,14 +8,11 @@ exports.mountFiles = mountFiles;
 exports.scaffoldProject = scaffoldProject;
 exports.selectTemplate = selectTemplate;
 var fs = _interopRequireWildcard(require("fs-extra"));
-var _types = require("../../../common/cli/types");
+var _types = require("../types");
 var _path = _interopRequireDefault(require("path"));
 var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
-var _constants = require("../../../common/cli/constants");
-var _cliReadme = require("../../../common/cli/cliReadme");
-var _utils = require("../../../common/cli/utils");
-var _helpers = require("../commands/helpers");
-var _terminal = require("../terminal");
+var _constants = require("../constants");
+var _helpers = require("../helpers");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 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; }
@@ -61,10 +58,10 @@ async function selectTemplate(templateName) {
     }
     return templateName;
   }
-  (0, _terminal.terminal)("^+Select a template (ESC to cancel):^:\n");
+  (0, _helpers.terminal)("^+Select a template (ESC to cancel):^:\n");
   const {
     promise: selectedCommandPromise
-  } = _terminal.terminal.singleColumnMenu(_types.templateIds, {
+  } = _helpers.terminal.singleColumnMenu(_types.templateIds, {
     cancelable: true
   });
   const selectedTemplateIndex = (await selectedCommandPromise).selectedIndex;
@@ -77,10 +74,10 @@ async function selectTemplate(templateName) {
 }
 async function scaffoldProject(templateId, isTargetDirectoryEmpty) {
   if (!isTargetDirectoryEmpty) {
-    (0, _terminal.terminal)("^+The current directory is not empty. Do you want to proceed and override files?^: (y/N)");
+    (0, _helpers.terminal)("^+The current directory is not empty. Do you want to proceed and override files?^: (y/N)");
     const {
       promise
-    } = _terminal.terminal.yesOrNo({
+    } = _helpers.terminal.yesOrNo({
       no: ["n", "ENTER", "ESCAPE"],
       yes: ["y"],
       echoNo: " no\n",
@@ -94,16 +91,16 @@ async function scaffoldProject(templateId, isTargetDirectoryEmpty) {
     }
   }
   const cwd = process.cwd();
-  (0, _terminal.terminal)(`^c🚀 Initializing ^:^+${templateId}^:^c project...\n`);
+  (0, _helpers.terminal)(`^c🚀 Initializing ^:^+${templateId}^:^c project...\n`);
   const template = await fetchProjectTemplate(templateId);
-  (0, _terminal.terminal)(`^c🔨 Creating project files...^:\n`);
+  (0, _helpers.terminal)(`^c🔨 Creating project files...^:\n`);
   const codeTree = template;
   await prepareCLITemplate(codeTree);
   await mountFiles(cwd, codeTree);
-  (0, _terminal.terminal)(`^g^+🎉 Project initialized successfully!^ ^GRun ^:^+yarn^:^G to install dependencies and start coding!\n`);
+  (0, _helpers.terminal)(`^g^+🎉 Project initialized successfully!^ ^GRun ^:^+yarn^:^G to install dependencies and start coding!\n`);
 }
 async function fetchProjectTemplate(templateId) {
-  const baseUrl = (0, _utils.getBaseUrl)();
+  const baseUrl = (0, _helpers.getBaseUrl)();
   const url = `${baseUrl}/api/templates/${templateId}`;
   const response = await fetch(url);
   if (!response.ok) {
@@ -133,7 +130,7 @@ async function prepareCLITemplate(codeTree) {
   }
   codeTree["README.md"] = {
     file: {
-      contents: _cliReadme.cliReadme
+      contents: _constants.readme
     }
   };
 }

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,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertApiFileExists = assertApiFileExists;
+var _path = _interopRequireDefault(require("path"));
+var _fsExtra = require("fs-extra");
+var _errors = require("./errors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function assertApiFileExists(dirname, api) {
+  const file = `${dirname}/${api}.ts`;
+  const filePath = _path.default.join(process.cwd(), file);
+  if (!(await (0, _fsExtra.exists)(filePath))) {
+    throw new _errors.CLIAssertionError(`^+^r API^ ^+${dirname}/${api}^ ^r^+is not implemented.^:`, {
+      autoColor: false
+    });
+  }
+}

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

@@ -0,0 +1,41 @@
+import type { AuthSessionMetadata } from "../types";
+import { RunApiStorageState as StorageState } from "../../../common/runApi";
+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;
+            name: string;
+            path: string;
+            domain: string;
+            expires: number;
+            httpOnly: boolean;
+            secure: boolean;
+            sameSite: "Strict" | "Lax" | "None";
+        }[];
+        origins: {
+            origin: string;
+            localStorage: {
+                value: string;
+                name: string;
+            }[];
+        }[];
+        sessionStorage?: {
+            sessionStorage: {
+                value: string;
+                name: string;
+            }[];
+            origin: string;
+        }[] | undefined;
+    };
+    metadata: AuthSessionMetadata;
+}>;
+export declare function storeAuthSessionInstance({ state, id, input, proxy, }: {
+    state: StorageState;
+    id?: string;
+    input?: Record<string, any>;
+    proxy?: string;
+}): Promise<string>;
+export declare function registerGetAuthSessionParameters(authSessionId?: string): void;

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertAuthConsistent = assertAuthConsistent;
+exports.assertAuthEnabled = assertAuthEnabled;
+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, _fsExtra.readJSON)(_path.default.join(process.cwd(), "Intuned.json"));
+    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 Intuned.json 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 Intuned.json 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
+}) {
+  try {
+    const authSessionsDirectoryPath = _path.default.join(process.cwd(), _constants.AUTH_SESSIONS_INSTANCES_FOLDER_NAME);
+    await (0, _fsExtra.ensureDir)(authSessionsDirectoryPath);
+    const authSessionInstanceId = id ?? `auth-session-${Date.now()}`;
+    const authSessionInstancePath = _path.default.join(authSessionsDirectoryPath, authSessionInstanceId);
+    const authSessionExists = await (0, _fsExtra.pathExists)(authSessionInstancePath);
+    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.getSettingIntunedJSON)("authSessions");
+    let existingMetadata = {};
+    const authSessionInstanceMetadataPath = _path.default.join(authSessionInstancePath, `metadata.json`);
+    if (authSessionExists) {
+      try {
+        existingMetadata = await (0, _fsExtra.readJSON)(authSessionInstanceMetadataPath);
+      } catch (readError) {
+        existingMetadata = {};
+      }
+    }
+    const authSessionMetadata = {
+      createdAt: existingMetadata.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      ...(projectAuthConfig.type === "API" && {
+        authSessionInput: input || existingMetadata.authSessionInput || {}
+      }),
+      authSessionId: authSessionInstanceId,
+      authSessionType: projectAuthConfig.type ?? existingMetadata.authSessionType ?? "API",
+      ...(projectAuthConfig.type === "MANUAL" && {
+        recorderStartUrl: projectAuthConfig.startUrl,
+        recorderEndUrl: projectAuthConfig.endUrl
+      }),
+      authSessionInput: input || existingMetadata.authSessionInput || {},
+      authSessionProxy: proxy || existingMetadata.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;
+}

package/dist/{common/cli/utils.d.ts → commands/intuned-cli/helpers/backend.d.ts}

@@ -6,4 +6,3 @@ export declare function getAuthCredentials(options: {
     apiKey: string;
 }>;
 export declare function getBaseUrl(): string;
-export declare function getSettingIntunedJSON(key: string): Promise<any>;

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAuthCredentials = getAuthCredentials;
+exports.getBaseUrl = getBaseUrl;
+var _errors = require("./errors");
+var _intunedJson = require("./intunedJson");
+async function getAuthCredentials(options) {
+  const workspaceId = options.workspaceId || (await (0, _intunedJson.getSettingIntunedJSON)("workspaceId"));
+  const apiKey = options.apiKey || process.env.INTUNED_API_KEY;
+  if (!workspaceId) {
+    throw new _errors.CLIError("Workspace ID is required. Please provide it via command line options or Intuned.json");
+  }
+  if (!apiKey) {
+    throw new _errors.CLIError("API key is required. Please provide it via command line options or INTUNED_API_KEY environment variable.");
+  }
+  return {
+    workspaceId,
+    apiKey
+  };
+}
+function getBaseUrl() {
+  return process.env.INTUNED_API_DOMAIN || `https://app.intuned.io`;
+}

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 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/dist/commands/intuned-cli/helpers/errors.d.ts

@@ -0,0 +1,14 @@
+import { AutomationError } 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: AutomationError): void;
+export declare function withErrorLogging<T extends any[]>(fn: (...args: T) => Promise<unknown>): (...args: T) => Promise<never>;

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

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLIError = exports.CLIAssertionError = void 0;
+exports.logAutomationError = logAutomationError;
+exports.withErrorLogging = withErrorLogging;
+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.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`);
+  }
+}
+function withErrorLogging(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+      process.exit(0);
+    } catch (error) {
+      if (error instanceof CLIError) {
+        if (error.autoColor) {
+          (0, _terminal.terminal)(`^r^+${error.message}^:\n`);
+        } else {
+          (0, _terminal.terminal)(`${error.message}\n`);
+        }
+      } else if (error instanceof _runApi.AutomationError) {
+        logAutomationError(error);
+      } else {
+        (0, _terminal.terminal)(`^r^+An error occurred:^: ^R${error.message}^:\n^r^+Please report this issue to the Intuned team.^:\n`);
+      }
+      process.exit(1);
+    }
+  };
+}

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

@@ -0,0 +1,10 @@
+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";

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

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

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

@@ -0,0 +1 @@
+export declare function getSettingIntunedJSON(key: string): Promise<any>;

package/dist/{common/cli/utils.js → commands/intuned-cli/helpers/intunedJson.js}

@@ -3,32 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getAuthCredentials = getAuthCredentials;
-exports.getBaseUrl = getBaseUrl;
 exports.getSettingIntunedJSON = getSettingIntunedJSON;
 var _path = _interopRequireDefault(require("path"));
 var fs = _interopRequireWildcard(require("fs-extra"));
-var _helpers = require("../../commands/intuned-cli/commands/helpers");
 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 }; }
-async function getAuthCredentials(options) {
-  const workspaceId = options.workspaceId || (await getSettingIntunedJSON("workspaceId"));
-  const apiKey = options.apiKey || process.env.INTUNED_API_KEY;
-  if (!workspaceId) {
-    throw new _helpers.CLIError("Workspace ID is required. Please provide it via command line options or Intuned.json");
-  }
-  if (!apiKey) {
-    throw new _helpers.CLIError("API key is required. Please provide it via command line options or INTUNED_API_KEY environment variable.");
-  }
-  return {
-    workspaceId,
-    apiKey
-  };
-}
-function getBaseUrl() {
-  return process.env.INTUNED_API_DOMAIN || `https://app.intuned.io`;
-}
 async function getSettingIntunedJSON(key) {
   const intunedJsonPath = _path.default.join(process.cwd(), "Intuned.json");
   const intunedJson = await fs.readJSON(intunedJsonPath);

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/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/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");

package/dist/commands/intuned-cli/{terminal.js → helpers/terminal.js}

@@ -3,10 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.terminal = void 0;
+exports.terminalStdout = exports.terminal = void 0;
 var _terminalKit = require("terminal-kit");
+const terminalStdout = exports.terminalStdout = process.stderr;
 const terminal = exports.terminal = (0, _terminalKit.createTerminal)({
   appId: "Intuned CLI",
   appName: "Intuned CLI",
-  stdout: process.stderr
+  stdout: terminalStdout
 });

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

@@ -0,0 +1 @@
+export declare function withTimeout<R>(fn: (abortSignal: AbortSignal) => Promise<R>, timeout: number): Promise<Awaited<R>>;

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

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withTimeout = withTimeout;
+var _asyncLocalStorage = require("../../../common/asyncLocalStorage");
+var _runApi = require("../../../common/runApi");
+function withTimeout(fn, timeout) {
+  let reject;
+  const abortController = new AbortController();
+  const timeoutPromise = new Promise((_, _reject) => {
+    reject = _reject;
+  });
+  const timeoutId = setTimeout(() => {
+    abortController.abort();
+    reject(new _runApi.AutomationError(new Error("Timed out")));
+  }, timeout);
+  (0, _asyncLocalStorage.getExecutionContext)().timeoutInfo.extendTimeoutCallback = async () => {
+    timeoutId.refresh();
+  };
+  return Promise.race([fn(abortController.signal), timeoutPromise]);
+}

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

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function logInvalidInput(result: z.SafeParseError<unknown>): void;