@intuned/runtime 1.1.6 → 1.3.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/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/commands/intuned-cli/helpers/backend.d.ts

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