@intuned/runtime-dev 1.1.8-bot-detection → 1.2.0-cli.0

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

@@ -0,0 +1,397 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertProjectToCodeTree = convertProjectToCodeTree;
+exports.projectNameSchema = void 0;
+exports.runDeployProject = runDeployProject;
+exports.validateProjectName = exports.validateIntunedProject = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _minimatch = require("minimatch");
+var _zod = require("zod");
+var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
+var _constants = require("../../../common/cli/constants");
+var _utils = require("../../../common/cli/utils");
+var _utils2 = require("../../init/utils");
+var _lodash = require("lodash");
+var _uuid = require("uuid");
+var _terminal = require("../terminal");
+var _promises = require("timers/promises");
+var _helpers = require("../commands/helpers");
+var _ms = _interopRequireDefault(require("ms"));
+var _build = require("./build");
+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; }
+function ignoreFilesByPattern(filePath, patterns, projectPath) {
+  const relativePath = path.relative(projectPath, filePath);
+  if (relativePath.startsWith("node_modules")) {
+    return true;
+  }
+  for (const pattern of patterns) {
+    if (!pattern || pattern.startsWith("#")) continue;
+    if (pattern.startsWith("!")) {
+      if ((0, _minimatch.minimatch)(relativePath, pattern.substring(1))) {
+        return false;
+      }
+    } else if ((0, _minimatch.minimatch)(relativePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function listFilesNotIgnored(projectPath, ignorePatterns) {
+  const results = [];
+  function traverseDirectory(dirPath) {
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(fullPath, ignorePatterns, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(fullPath);
+          if (stats.isDirectory()) {
+            traverseDirectory(fullPath);
+          } else if (stats.isFile()) {
+            results.push(path.relative(projectPath, fullPath));
+          }
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not access ${fullPath}^:\n`);
+        }
+      }
+    } catch (error) {
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
+    }
+  }
+  traverseDirectory(projectPath);
+  return results;
+}
+async function convertProjectToCodeTree(projectPath) {
+  const filesToDeploy = listFilesNotIgnored(projectPath, _projectExclusions.default);
+  const filesToDeployText = "  " + filesToDeploy.join("\n  ");
+  (0, _terminal.terminal)("^CFiles to be deployed:^:\n");
+  (0, _terminal.terminal)(filesToDeployText + "\n");
+  function readDirectory(dirPath) {
+    const tree = {};
+    try {
+      const entries = fs.readdirSync(dirPath);
+      for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry);
+        if (ignoreFilesByPattern(entryPath, _projectExclusions.default, projectPath)) {
+          continue;
+        }
+        try {
+          const stats = fs.statSync(entryPath);
+          if (stats.isFile()) {
+            try {
+              const content = fs.readFileSync(entryPath, "utf-8");
+              tree[entry] = {
+                file: {
+                  contents: content
+                }
+              };
+            } catch (error) {
+              (0, _terminal.terminal)(`^yWarning: Could not read file ${entryPath}^:\n`);
+            }
+          } else if (stats.isDirectory()) {
+            const subTree = readDirectory(entryPath);
+            if (Object.keys(subTree).length > 0) {
+              tree[entry] = {
+                directory: subTree
+              };
+            }
+          }
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not access ${entryPath}^:\n`);
+        }
+      }
+    } catch (error) {
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
+    }
+    return tree;
+  }
+  const tree = readDirectory(projectPath);
+  await mapToIDEParams(tree);
+  return tree;
+}
+async function runDeployProject(projectName, auth) {
+  const {
+    workspaceId,
+    apiKey
+  } = auth;
+  const baseUrl = (0, _utils.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create`;
+  const headers = {
+    "x-api-key": apiKey,
+    "Content-Type": "application/json"
+  };
+  const projectPath = process.cwd();
+  const codeTree = await convertProjectToCodeTree(projectPath);
+  codeTree["tsconfig.json"] = {
+    file: {
+      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
+    }
+  };
+  const deployProjectPayload = {
+    name: projectName,
+    codeTree,
+    isCli: true,
+    language: "typescript"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "POST",
+    body: JSON.stringify(deployProjectPayload)
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new _helpers.CLIError(`Invalid API key. Please check your API key and try again.`);
+    }
+    throw new _helpers.CLIError(`^r^+Invalid response from server\n^:^R${response.status} ${await response.text()}^:\n^r^+Project deployment failed^:\n`, {
+      autoColor: false
+    });
+  }
+  (0, _terminal.terminal)("\n");
+  const startTime = Date.now();
+  let lastCheckTime = startTime;
+  const spinner = await _terminal.terminal.spinner("dotSpinner");
+  (0, _terminal.terminal)("\n");
+  try {
+    while (true) {
+      await (0, _promises.setTimeout)(50);
+      _terminal.terminal.previousLine(1);
+      _terminal.terminal.column(3);
+      _terminal.terminal.eraseLineAfter();
+      const timeElapsedText = ((Date.now() - startTime) / (0, _ms.default)("1 second")).toFixed(1);
+      (0, _terminal.terminal)(`^cDeploying ^:^K(${timeElapsedText}s)^ \n`);
+      if (Date.now() - lastCheckTime < _constants.PROJECT_DEPLOY_CHECK_PERIOD) {
+        continue;
+      }
+      lastCheckTime = Date.now();
+      const {
+        status,
+        message,
+        projectId
+      } = await checkIntunedProjectDeployStatus(workspaceId, projectName, apiKey);
+      if (status === "pending") {
+        const elapsedTime = Date.now() - startTime;
+        if (elapsedTime > _constants.PROJECT_DEPLOY_TIMEOUT) {
+          throw new _helpers.CLIError(`Deployment timed out after ${Math.floor(_constants.PROJECT_DEPLOY_TIMEOUT / (0, _ms.default)("1 minute"))} minutes`);
+        }
+        continue;
+      }
+      _terminal.terminal.previousLine(1);
+      _terminal.terminal.eraseLine();
+      spinner.animate(false);
+      if (status === "completed") {
+        const url = (0, _utils.getBaseUrl)();
+        (0, _terminal.terminal)(`\n^g^+Project deployed successfully!^:\n`);
+        (0, _terminal.terminal)(`^+You can check your project on the platform:^s ^c^_${url}/projects/${projectId}/details^:\n`);
+        return;
+      }
+      throw new _helpers.CLIError(`^r^+An error occurred while deploying project:^:\n^R${message}^:\n^r^+Project deployment failed^:\n`);
+    }
+  } catch (e) {
+    spinner.animate(false);
+  }
+}
+const projectNameSchema = exports.projectNameSchema = _zod.z.string().min(1, "Project Name is required").max(50, "Name must be 50 characters or less").regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/, "Name can only contain lowercase letters, numbers, hyphens, and underscores in between").refine(value => !_zod.z.string().uuid().safeParse(value).success, {
+  message: "Name cannot be a UUID"
+});
+const validateProjectName = projectName => {
+  const validation = projectNameSchema.safeParse(projectName);
+  if (!validation.success) {
+    return {
+      isValid: false,
+      errorMessage: validation.error.errors[0].message
+    };
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateProjectName = validateProjectName;
+const validateIntunedProject = async () => {
+  const currentDirectoryToDeploy = process.cwd();
+  const validationSteps = [{
+    name: "build",
+    check: async () => {
+      try {
+        const buildResult = await (0, _build.runBuild)();
+        if (!buildResult) {
+          return {
+            isValid: false,
+            errorMessage: "Build failed"
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Build failed"
+        };
+      }
+    }
+  }, {
+    name: "package.json",
+    check: async () => {
+      try {
+        const packageJsonPath = path.join(currentDirectoryToDeploy, "package.json");
+        await fs.exists(packageJsonPath);
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, {
+          encoding: "utf-8"
+        }));
+        const userCodePlaywrightVersion = packageJson.dependencies?.playwright;
+        if (userCodePlaywrightVersion !== _constants.CURRENT_PLAYWRIGHT_VERSION) {
+          return {
+            isValid: false,
+            errorMessage: `Playwright version mismatch: expected ${_constants.CURRENT_PLAYWRIGHT_VERSION}, found ${userCodePlaywrightVersion || "none"}`
+          };
+        }
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Package.json file not found or cannot be read"
+        };
+      }
+    }
+  }, {
+    name: "Intuned.json",
+    check: async () => {
+      try {
+        const intunedJsonPath = path.join(currentDirectoryToDeploy, "Intuned.json");
+        await fs.exists(intunedJsonPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "Intuned.json file not found"
+        };
+      }
+    }
+  }, {
+    name: "api folder",
+    check: async () => {
+      try {
+        const apiFolderPath = path.join(currentDirectoryToDeploy, "api");
+        await fs.access(apiFolderPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: "API folder not found"
+        };
+      }
+    }
+  }];
+  for (const step of validationSteps) {
+    const result = await step.check();
+    if (!result.isValid) {
+      return result;
+    }
+  }
+  return {
+    isValid: true
+  };
+};
+exports.validateIntunedProject = validateIntunedProject;
+const checkIntunedProjectDeployStatus = async (workspaceId, projectName, apiKey) => {
+  const baseUrl = (0, _utils.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create/${projectName}/result`;
+  const headers = {
+    "x-api-key": apiKey,
+    "Content-Type": "application/json"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "GET"
+  });
+  if (response.status === 404) {
+    return {
+      status: "not_found",
+      message: "Project not found"
+    };
+  }
+  if (!response.ok) {
+    throw new Error(`Error querying deployment status ${response.status}: ${await response.text()}`);
+  }
+  const data = await response.json();
+  if (data.status) {
+    return {
+      status: data.status,
+      message: data.message,
+      projectId: data.projectId
+    };
+  }
+  return {
+    status: "failed",
+    message: `Deployment failed, please try again: ${data.message}`
+  };
+};
+async function mapToIDEParams(tree) {
+  if (!tree) {
+    return;
+  }
+  if (!tree["parameters"] || (0, _utils2._isFileNode)(tree["parameters"])) {
+    return;
+  }
+  const apiParametersMap = {};
+  const cliParameters = Object.keys(tree["parameters"].directory);
+  const ____testParameters = {
+    directory: {}
+  };
+  for (const parameterKey of cliParameters) {
+    const parameter = tree["parameters"].directory[parameterKey];
+    if ((0, _utils2._isDirectoryNode)(parameter)) {
+      continue;
+    }
+    if ((0, _lodash.isEmpty)(parameter.file.contents)) {
+      continue;
+    }
+    const parameterPayload = JSON.parse(parameter.file.contents);
+    if (!parameterPayload["__api-name"]) {
+      continue;
+    }
+    const api = parameterPayload["__api-name"];
+    const {
+      "__api-name": _,
+      ...parameterValue
+    } = parameterPayload;
+    const testParameter = {
+      name: parameterKey.replace(".json", ""),
+      lastUsed: false,
+      id: (0, _uuid.v4)(),
+      value: JSON.stringify(parameterValue)
+    };
+    if (!apiParametersMap[api]) {
+      apiParametersMap[api] = [];
+    }
+    apiParametersMap[api].push(testParameter);
+  }
+  for (const api in apiParametersMap) {
+    if (apiParametersMap[api].length > 0) {
+      apiParametersMap[api][apiParametersMap[api].length - 1].lastUsed = true;
+    }
+    ____testParameters.directory[`${api}.json`] = {
+      file: {
+        contents: JSON.stringify(apiParametersMap[api], null, 2)
+      }
+    };
+  }
+  delete tree["parameters"];
+  tree["____testParameters"] = ____testParameters;
+  return;
+}

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

@@ -0,0 +1 @@
+export declare function loadParameters(parameters: string): Promise<object | null>;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadParameters = loadParameters;
+var fs = _interopRequireWildcard(require("fs-extra"));
+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; }
+async function loadParameters(parameters) {
+  let inputData;
+  if (await fs.exists(parameters)) {
+    inputData = await loadParametersFromFile(parameters);
+  } else {
+    try {
+      inputData = JSON.parse(parameters);
+    } catch (err) {
+      throw new Error("Parameters must be a valid JSON string or a path to a JSON file");
+    }
+  }
+  return inputData;
+}
+async function loadParametersFromFile(parametersFile) {
+  if (!parametersFile) {
+    return {};
+  }
+  try {
+    const filePath = parametersFile;
+    await fs.access(filePath);
+    let inputData = null;
+    if (parametersFile) {
+      inputData = await fs.readJSON(filePath);
+    } else {
+      inputData = {};
+    }
+    return inputData;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Parameters file not found: ${parametersFile}`);
+    } else if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in parameters file: ${error.message}`);
+    }
+    throw new Error(`Error reading parameters file: ${error.message}`);
+  }
+}

package/dist/commands/intuned-cli/controller/init.d.ts

@@ -0,0 +1,5 @@
+import { FileSystemTree, TemplateId } from "../../../common/cli/types";
+export declare function mountFiles(cwd: string, tree: FileSystemTree): Promise<void>;
+export declare function checkEmptyDirectory(): Promise<boolean>;
+export declare function selectTemplate(templateName: string): Promise<TemplateId>;
+export declare function scaffoldProject(templateId: string, isTargetDirectoryEmpty: boolean): Promise<void>;

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

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkEmptyDirectory = checkEmptyDirectory;
+exports.mountFiles = mountFiles;
+exports.scaffoldProject = scaffoldProject;
+exports.selectTemplate = selectTemplate;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _types = require("../../../common/cli/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");
+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; }
+function isDirectoryNode(node) {
+  return node.directory !== undefined;
+}
+function isFileNode(node) {
+  return node.file !== undefined;
+}
+async function mountFiles(cwd, tree) {
+  for (const name in tree) {
+    const fullPath = _path.default.join(cwd, name);
+    const node = tree[name];
+    if (isDirectoryNode(node)) {
+      await fs.ensureDir(fullPath);
+      await mountFiles(fullPath, node.directory);
+    } else if (isFileNode(node)) {
+      await fs.writeFile(fullPath, node.file.contents);
+    }
+  }
+}
+async function checkEmptyDirectory() {
+  const currentDir = process.cwd();
+  try {
+    const stats = await fs.stat(currentDir);
+    if (!stats.isDirectory()) {
+      throw new _helpers.CLIError("The current path is not a directory.");
+    }
+    const files = await fs.readdir(currentDir);
+    const significantFiles = files.filter(file => !_projectExclusions.default.includes(file));
+    return significantFiles.length === 0;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new _helpers.CLIError("The specified directory does not exist.");
+    }
+    throw error;
+  }
+}
+async function selectTemplate(templateName) {
+  if (templateName) {
+    if (!_types.templateIds.includes(templateName)) {
+      throw new _helpers.CLIError(`Template "${templateName}" not found.`);
+    }
+    return templateName;
+  }
+  (0, _terminal.terminal)("^+Select a template (ESC to cancel):^:\n");
+  const {
+    promise: selectedCommandPromise
+  } = _terminal.terminal.singleColumnMenu(_types.templateIds, {
+    cancelable: true
+  });
+  const selectedTemplateIndex = (await selectedCommandPromise).selectedIndex;
+  if (selectedTemplateIndex === undefined) {
+    throw new _helpers.CLIError("^y^+Project initialization cancelled.^:\n", {
+      autoColor: false
+    });
+  }
+  return _types.templateIds[selectedTemplateIndex];
+}
+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)");
+    const {
+      promise
+    } = _terminal.terminal.yesOrNo({
+      no: ["n", "ENTER", "ESCAPE"],
+      yes: ["y"],
+      echoNo: " no\n",
+      echoYes: " yes\n"
+    });
+    const confirm = await promise;
+    if (!confirm) {
+      throw new _helpers.CLIError("^y^+Project initialization cancelled^:\n", {
+        autoColor: false
+      });
+    }
+  }
+  const cwd = process.cwd();
+  (0, _terminal.terminal)(`^c🚀 Initializing ^:^+${templateId}^:^c project...\n`);
+  const template = await fetchProjectTemplate(templateId);
+  (0, _terminal.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`);
+}
+async function fetchProjectTemplate(templateId) {
+  const baseUrl = (0, _utils.getBaseUrl)();
+  const url = `${baseUrl}/api/templates/${templateId}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new _helpers.CLIError(`^r^+Error fetching template:\n^:^R${response.statusText} ${response.status}\n^r^+Failed to initialize project^:\n`, {
+      autoColor: false
+    });
+  }
+  const data = await response.json();
+  if (!data) {
+    throw new _helpers.CLIError("Error fetching template: Template not found");
+  }
+  return data.template;
+}
+async function prepareCLITemplate(codeTree) {
+  codeTree["parameters"] = {
+    directory: {}
+  };
+  codeTree["tsconfig.json"] = {
+    file: {
+      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
+    }
+  };
+  if (isFileNode(codeTree["package.json"]) && codeTree["package.json"].file) {
+    const packageJson = JSON.parse(codeTree["package.json"].file.contents);
+    packageJson.scripts = _constants.userCLIScripts;
+    codeTree["package.json"].file.contents = JSON.stringify(packageJson, null, 2);
+  }
+  codeTree["README.md"] = {
+    file: {
+      contents: _cliReadme.cliReadme
+    }
+  };
+}

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

@@ -0,0 +1 @@
+export * from "./commands";

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _commands = require("./commands");
+Object.keys(_commands).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _commands[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _commands[key];
+    }
+  });
+});

package/dist/commands/intuned-cli/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/intuned-cli/main.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _commands = require("./commands");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+_commands.program.configureHelp({
+  sortSubcommands: true
+});
+_commands.program.parse(process.argv);

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

@@ -0,0 +1 @@
+export declare const terminal: import("terminal-kit/Terminal");

package/dist/commands/intuned-cli/terminal.js

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

package/dist/commands/run-api-cli/utils.js

@@ -62,10 +62,10 @@ async function writeResultToFile(runId, result, payloadToAppend) {
 }
 async function runApiViaCLI(apiName, inputData, options) {
   let authSessionPathToUse = null;
-  if (options !== null && options !== void 0 && options.authSession) {
+  if (options?.authSession) {
     const {
       authSessionInstanceStoragePath
-    } = await (0, _utils.retrieveAuthSessionInstance)(options === null || options === void 0 ? void 0 : options.authSession, true);
+    } = await (0, _utils.retrieveAuthSessionInstance)(options?.authSession, true);
     authSessionPathToUse = authSessionInstanceStoragePath;
   }
   if (authSessionPathToUse) {
@@ -82,17 +82,17 @@ async function runApiViaCLI(apiName, inputData, options) {
       }
       const {
         metadata
-      } = await (0, _utils.retrieveAuthSessionInstance)(options === null || options === void 0 ? void 0 : options.authSession);
-      if ((metadata === null || metadata === void 0 ? void 0 : metadata.authSessionType) === "MANUAL") {
+      } = await (0, _utils.retrieveAuthSessionInstance)(options?.authSession);
+      if (metadata?.authSessionType === "MANUAL") {
         throw new Error("Expired Auth session is recorder-based, please provide a new one or refresh it manually");
       }
-      const authSessionInput = (metadata === null || metadata === void 0 ? void 0 : metadata.authSessionInput) ?? {};
+      const authSessionInput = metadata?.authSessionInput ?? {};
       try {
         const refresehAuthSessionInstance = await (0, _utils.runCreateApiViaCLI)(authSessionInput);
         if (!refresehAuthSessionInstance) {
           throw new Error("Failed to refresh auth session");
         }
-        await (0, _utils.storeAuthSessionInstance)(refresehAuthSessionInstance, options === null || options === void 0 ? void 0 : options.authSession, authSessionInput);
+        await (0, _utils.storeAuthSessionInstance)(refresehAuthSessionInstance, options?.authSession, authSessionInput);
         const checkResult = await (0, _utils.runCheckApiViaCLI)(authSessionPathToUse);
         if (!checkResult) {
           throw new Error("Failed to refresh auth session");