@intuned/runtime 1.1.5 → 1.2.0

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

@@ -0,0 +1 @@
+export declare const runBuild: () => Promise<boolean>;

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runBuild = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _child_process = require("child_process");
+var _util = require("util");
+var _terminal = require("../helpers/terminal");
+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; }
+const execPromise = (0, _util.promisify)(_child_process.exec);
+const runBuild = async () => {
+  const distPath = path.join(process.cwd(), "dist");
+  if (await fs.exists(distPath)) {
+    await fs.remove(distPath);
+  }
+  const buildCommand = "tsc";
+  try {
+    await execPromise(buildCommand);
+    (0, _terminal.terminal)(`^g^+✨ Build completed successfully!^:\n`);
+    return true;
+  } catch (error) {
+    (0, _terminal.terminal)(`^r^+An error occurred during the build process:^:\n`);
+    if ("stdout" in error) {
+      (0, _terminal.terminal)(`${error.stdout}\n`);
+    } else {
+      (0, _terminal.terminal)(`^${error.message}^:\n`);
+    }
+    (0, _terminal.terminal)(`^r^+Build failed^:\n`);
+    return false;
+  }
+};
+exports.runBuild = runBuild;

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import type { AuthCredentials, FileSystemTree } from "../types";
+export declare function convertProjectToCodeTree(projectPath: string): Promise<FileSystemTree>;
+export declare function runDeployProject(projectName: string, auth: AuthCredentials): Promise<void>;
+export declare const projectNameSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const validateProjectName: (projectName: string) => {
+    isValid: true;
+} | {
+    isValid: false;
+    errorMessage: string;
+};
+export declare const validateIntunedProject: () => Promise<{
+    isValid: boolean;
+    errorMessage?: string;
+}>;

package/dist/commands/{deploy/utils.js → intuned-cli/controller/deploy.js}

@@ -4,25 +4,25 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.convertProjectToCodeTree = convertProjectToCodeTree;
-exports.deployProject = deployProject;
-exports.validateProjectName = exports.validateIntunedProject = exports.runBuild = void 0;
+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 _chalk = _interopRequireDefault(require("chalk"));
 var _minimatch = require("minimatch");
 var _zod = require("zod");
-var _child_process = require("child_process");
-var _util = require("util");
-var _projectExclusions = _interopRequireDefault(require("../common/projectExclusions"));
-var _constants = require("../../common/cli/constants");
-var _utils = require("../../common/cli/utils");
-var _utils2 = require("../init/utils");
+var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
+var _constants = require("../constants");
+var _helpers = require("../helpers");
 var _lodash = require("lodash");
 var _uuid = require("uuid");
+var _terminal = require("../helpers/terminal");
+var _promises = require("timers/promises");
+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; }
-const execPromise = (0, _util.promisify)(_child_process.exec);
 function ignoreFilesByPattern(filePath, patterns, projectPath) {
   const relativePath = path.relative(projectPath, filePath);
   if (relativePath.startsWith("node_modules")) {
@@ -58,11 +58,11 @@ function listFilesNotIgnored(projectPath, ignorePatterns) {
             results.push(path.relative(projectPath, fullPath));
           }
         } catch (error) {
-          console.log(_chalk.default.yellow(`Warning: Could not access ${fullPath}`));
+          (0, _terminal.terminal)(`^yWarning: Could not access ${fullPath}^:\n`);
         }
       }
     } catch (error) {
-      console.log(_chalk.default.yellow(`Warning: Could not read directory ${dirPath}`));
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
     }
   }
   traverseDirectory(projectPath);
@@ -70,9 +70,9 @@ function listFilesNotIgnored(projectPath, ignorePatterns) {
 }
 async function convertProjectToCodeTree(projectPath) {
   const filesToDeploy = listFilesNotIgnored(projectPath, _projectExclusions.default);
-  console.log(_chalk.default.cyan("\nFiles to be deployed:"));
-  const filesToDeployText = "\n  " + filesToDeploy.join("\n  ");
-  console.log(filesToDeployText);
+  const filesToDeployText = "  " + filesToDeploy.join("\n  ");
+  (0, _terminal.terminal)("^CFiles to be deployed:^:\n");
+  (0, _terminal.terminal)(filesToDeployText + "\n");
   function readDirectory(dirPath) {
     const tree = {};
     try {
@@ -93,7 +93,7 @@ async function convertProjectToCodeTree(projectPath) {
                 }
               };
             } catch (error) {
-              console.log(_chalk.default.yellow(`Warning: Could not read file ${entryPath}`));
+              (0, _terminal.terminal)(`^yWarning: Could not read file ${entryPath}^:\n`);
             }
           } else if (stats.isDirectory()) {
             const subTree = readDirectory(entryPath);
@@ -104,25 +104,24 @@ async function convertProjectToCodeTree(projectPath) {
             }
           }
         } catch (error) {
-          console.log(_chalk.default.yellow(`Warning: Could not access ${entryPath}`));
+          (0, _terminal.terminal)(`^yWarning: Could not access ${entryPath}^:\n`);
         }
       }
     } catch (error) {
-      console.log(_chalk.default.yellow(`Warning: Could not read directory ${dirPath}`));
+      (0, _terminal.terminal)(`^YWarning: Could not read directory ${dirPath}^:\n`);
     }
     return tree;
   }
-  console.log(_chalk.default.cyan("\n📦 Building project..."));
   const tree = readDirectory(projectPath);
   await mapToIDEParams(tree);
   return tree;
 }
-async function deployProject(projectName, auth) {
+async function runDeployProject(projectName, auth) {
   const {
     workspaceId,
     apiKey
   } = auth;
-  const baseUrl = (0, _utils.getBaseUrl)();
+  const baseUrl = (0, _helpers.getBaseUrl)();
   const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/create`;
   const headers = {
     "x-api-key": apiKey,
@@ -148,48 +147,84 @@ async function deployProject(projectName, auth) {
   });
   if (!response.ok) {
     if (response.status === 401) {
-      throw new Error(`Invalid API key. Please check your API key and try again.`);
+      throw new _helpers.CLIError(`Invalid API key. Please check your API key and try again.`);
     }
-    throw new Error(`Error deploying project`);
+    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();
-  console.log(_chalk.default.greenBright(`\n🚀 Deploying project...`));
-  return new Promise((resolve, reject) => {
-    const checkInterval = setInterval(async () => {
-      try {
-        const {
-          status,
-          message,
-          projectId
-        } = await checkIntunedProjectDeployStatus(workspaceId, projectName, apiKey);
-        if (status === "completed" || status === "failed" || status === "not_found") {
-          clearInterval(checkInterval);
-          resolve(status === "completed" ? {
-            deployDone: true,
-            projectId
-          } : {
-            deployDone: false,
-            projectId: "",
-            deployErrorMessage: message
-          });
-        }
+  const timeElapsedText = () => ((Date.now() - startTime) / (0, _ms.default)("1 second")).toFixed(1);
+  function* getSpinnerGenerator() {
+    while (true) {
+      yield* "⠙⠹⠸⠼⠴⠦⠧⠇";
+    }
+  }
+  const spinnerGen = getSpinnerGenerator();
+  let updateSpinnerInterval = null;
+  if (_terminal.terminalStdout.isTTY) {
+    updateSpinnerInterval = setInterval(() => {
+      _terminal.terminal.previousLine(1);
+      _terminal.terminal.column(0);
+      _terminal.terminal.eraseLineAfter();
+      (0, _terminal.terminal)(`${spinnerGen.next().value} ^cDeploying ^:^K(${timeElapsedText()}s)^ \n`);
+    }, 50);
+    (0, _terminal.terminal)("\n");
+  } else {
+    (0, _terminal.terminal)(`^cDeploying ^:\n`);
+  }
+  try {
+    while (true) {
+      await (0, _promises.setTimeout)(_constants.PROJECT_DEPLOY_CHECK_PERIOD);
+      if (!_terminal.terminalStdout.isTTY) {
+        (0, _terminal.terminal)(`^cDeploying ^:^K(${timeElapsedText()}s)^ \n`);
+      }
+      const {
+        status,
+        message,
+        projectId,
+        ...rest
+      } = await checkIntunedProjectDeployStatus(workspaceId, projectName, apiKey);
+      if (status === "pending") {
         const elapsedTime = Date.now() - startTime;
         if (elapsedTime > _constants.PROJECT_DEPLOY_TIMEOUT) {
-          clearInterval(checkInterval);
-          reject(new Error(`Deployment timed out after ${Math.floor(_constants.PROJECT_DEPLOY_TIMEOUT / 1000 / 60)} minutes`));
+          throw new _helpers.CLIError(`Deployment timed out after ${Math.floor(_constants.PROJECT_DEPLOY_TIMEOUT / (0, _ms.default)("1 minute"))} minutes`);
         }
-      } catch (error) {
-        clearInterval(checkInterval);
-        reject(error);
+        continue;
       }
-    }, 5000);
-  });
+      _terminal.terminal.previousLine(1);
+      _terminal.terminal.eraseLine();
+      if (updateSpinnerInterval) {
+        clearTimeout(updateSpinnerInterval);
+      }
+      if (status === "completed") {
+        const url = (0, _helpers.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;
+      }
+      let errorMessage = `^r^+An error occurred while deploying project:^:\n^R${message}^:\n`;
+      if (rest.reason) {
+        errorMessage += `^r^+Reason:^:\n^R${rest.reason}^:\n`;
+      }
+      errorMessage += `^r^+Project deployment failed^:\n`;
+      throw new _helpers.CLIError(errorMessage, {
+        autoColor: false
+      });
+    }
+  } catch (e) {
+    if (updateSpinnerInterval) {
+      clearTimeout(updateSpinnerInterval);
+    }
+    throw e;
+  }
 }
+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 nameSchema = _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 validation = nameSchema.safeParse(projectName);
+  const validation = projectNameSchema.safeParse(projectName);
   if (!validation.success) {
     return {
       isValid: false,
@@ -207,7 +242,7 @@ const validateIntunedProject = async () => {
     name: "build",
     check: async () => {
       try {
-        const buildResult = await runBuild();
+        const buildResult = await (0, _build.runBuild)();
         if (!buildResult) {
           return {
             isValid: false,
@@ -295,67 +330,39 @@ const validateIntunedProject = async () => {
 };
 exports.validateIntunedProject = validateIntunedProject;
 const checkIntunedProjectDeployStatus = async (workspaceId, projectName, apiKey) => {
-  try {
-    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");
-    }
-    const data = await response.json();
-    if (data.status) {
-      return {
-        status: data.status,
-        message: data.message,
-        projectId: data.projectId
-      };
-    }
+  const baseUrl = (0, _helpers.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: "failed",
-      message: `Deployment failed, please try again: ${data.message}`
+      status: "not_found",
+      message: "Project not found"
     };
-  } catch (e) {
-    throw new Error(`Error during deployment`);
   }
-};
-const runBuild = async () => {
-  const currentProjectDirectory = process.cwd();
-  console.log(_chalk.default.yellow("Running build..."));
-  const distPath = path.join(currentProjectDirectory, "dist");
-  if (await fs.exists(distPath)) {
-    await fs.remove(distPath);
+  if (!response.ok) {
+    throw new _helpers.CLIError(`Error querying deployment status ${response.status}: ${await response.text()}`);
   }
-  const buildCommand = "tsc";
-  try {
-    await execPromise(buildCommand, {
-      cwd: currentProjectDirectory
-    });
-    console.log(_chalk.default.green("🏗️ Build completed successfully"));
-    return true;
-  } catch (error) {
-    console.error(_chalk.default.red(`Build failed: ${error.message}`));
-    return false;
+  const data = await response.json();
+  if (data.status) {
+    return data;
   }
+  return {
+    status: "failed",
+    message: `Deployment failed, please try again: ${data.message}`
+  };
 };
-exports.runBuild = runBuild;
 async function mapToIDEParams(tree) {
   if (!tree) {
     return;
   }
-  if (!tree["parameters"] || (0, _utils2._isFileNode)(tree["parameters"])) {
+  if (!tree["parameters"] || "file" in tree["parameters"]) {
     return;
   }
   const apiParametersMap = {};
@@ -365,7 +372,7 @@ async function mapToIDEParams(tree) {
   };
   for (const parameterKey of cliParameters) {
     const parameter = tree["parameters"].directory[parameterKey];
-    if ((0, _utils2._isDirectoryNode)(parameter)) {
+    if ("directory" in parameter) {
       continue;
     }
     if ((0, _lodash.isEmpty)(parameter.file.contents)) {

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,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadParameters = loadParameters;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _helpers = require("../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; }
+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 _helpers.CLIError("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 _helpers.CLIError(`Parameters file not found: ${parametersFile}`);
+    } else if (error instanceof SyntaxError) {
+      throw new _helpers.CLIError(`Invalid JSON in parameters file: ${error.message}`);
+    }
+    throw new _helpers.CLIError(`Error reading parameters file: ${error.message}`);
+  }
+}

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

@@ -0,0 +1,5 @@
+import { FileSystemTree, TemplateId } from "../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,136 @@
+"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("../types");
+var _path = _interopRequireDefault(require("path"));
+var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
+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; }
+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, _helpers.terminal)("^+Select a template (ESC to cancel):^:\n");
+  const {
+    promise: selectedCommandPromise
+  } = _helpers.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, _helpers.terminal)("^+The current directory is not empty. Do you want to proceed and override files?^: (y/N)");
+    const {
+      promise
+    } = _helpers.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, _helpers.terminal)(`^c🚀 Initializing ^:^+${templateId}^:^c project...\n`);
+  const template = await fetchProjectTemplate(templateId);
+  (0, _helpers.terminal)(`^c🔨 Creating project files...^:\n`);
+  const codeTree = template;
+  await prepareCLITemplate(codeTree);
+  await mountFiles(cwd, codeTree);
+  (0, _helpers.terminal)(`^g^+🎉 Project initialized successfully!^ ^GRun ^:^+yarn^:^G to install dependencies and start coding!\n`);
+}
+async function fetchProjectTemplate(templateId) {
+  const baseUrl = (0, _helpers.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: _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;