@intuned/runtime-dev 1.3.8-fix.0 → 1.3.9-dev1

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

@@ -0,0 +1,420 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._runCreateWithRetries = exports._runCreate = exports._runCheckWithRetries = exports._runCheck = void 0;
+exports.executeAttemptCheckAuthSessionCLI = executeAttemptCheckAuthSessionCLI;
+exports.executeAttemptCreateAuthSessionCLI = executeAttemptCreateAuthSessionCLI;
+exports.executeRecordAuthSessionCLI = executeRecordAuthSessionCLI;
+exports.executeRunCreateAuthSessionCLI = executeRunCreateAuthSessionCLI;
+exports.executeRunUpdateAuthSessionCLI = executeRunUpdateAuthSessionCLI;
+exports.executeRunValidateAuthSessionCLI = executeRunValidateAuthSessionCLI;
+var _helpers = require("../helpers");
+var _runApi = require("../../../common/runApi");
+var _constants = require("../../../common/constants");
+var _tsNodeImport = require("../../common/tsNodeImport");
+var _terminal = require("../helpers/terminal");
+var _browser = require("../helpers/browser");
+var _launchBrowser = require("../../../common/launchBrowser");
+var _promises = require("timers/promises");
+var _contextStorageStateHelpers = require("../../../common/contextStorageStateHelpers");
+async function executeRunValidateAuthSessionCLI({
+  id,
+  autoRecreate,
+  checkRetries,
+  createRetries,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Validating auth session with id ^c${id}^:\n`);
+  const {
+    storageState
+  } = await (0, _helpers.loadAuthSessionInstance)(id);
+  await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check");
+  (0, _helpers.registerGetAuthSessionParameters)(id);
+  const checkResult = await runCheckWithRetries({
+    auth: storageState,
+    retries: checkRetries,
+    ...rest
+  });
+  if (!checkResult) {
+    if (!autoRecreate) {
+      throw new _helpers.CLIError("Auto recreate is disabled, please provide a new auth session or update it manually");
+    }
+    const {
+      metadata
+    } = await (0, _helpers.loadAuthSessionInstance)(id);
+    if (metadata?.authSessionType === "MANUAL") {
+      throw new _helpers.CLIError("Auth session is recorder-based, please provide a new one or update it manually");
+    }
+    (0, _terminal.terminal)("^+Auto recreate is enabled - trying to re-create it^:\n");
+    await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create");
+    const authSessionInput = metadata?.authSessionInput ?? {};
+    const storageState = await runCreateWithRetries({
+      authSessionId: id,
+      authSessionInput,
+      retries: createRetries,
+      metadata,
+      ...rest
+    });
+    const checkResult = await runCheckWithRetries({
+      auth: storageState,
+      retries: checkRetries,
+      ...rest
+    });
+    if (!checkResult) {
+      throw new _helpers.CLIError("Failed to re-create auth session");
+    }
+  }
+  (0, _terminal.terminal)(`^+^gAuth session validated successfully^:\n`);
+  return storageState;
+}
+async function executeRunCreateAuthSessionCLI({
+  id,
+  input,
+  checkRetries,
+  createRetries,
+  log = true,
+  ...rest
+}) {
+  id = id ?? generateAuthSessionId();
+  (0, _terminal.terminal)(`^+Creating auth session with id ^c${id}^:\n`);
+  await Promise.all([await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create"), await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check")]);
+  const createdStorageState = await runCreateWithRetries({
+    authSessionId: id,
+    authSessionInput: input,
+    retries: createRetries,
+    ...rest
+  });
+  const auth = createdStorageState;
+  const checkResult = await runCheckWithRetries({
+    auth,
+    retries: checkRetries,
+    ...rest
+  });
+  if (!checkResult) {
+    throw new _helpers.CLIError("Failed to create auth session");
+  }
+  if (log) {
+    (0, _terminal.terminal)(`^+^gAuth session created successfully^:\n`);
+  }
+  return auth;
+}
+async function executeRunUpdateAuthSessionCLI({
+  id,
+  input,
+  checkRetries,
+  createRetries,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Updating auth session with id ^c${id}^:\n`);
+  let metadata = undefined;
+  if (input === undefined) {
+    ({
+      metadata
+    } = await (0, _helpers.loadAuthSessionInstance)(id));
+    if (metadata?.authSessionType === "MANUAL") {
+      throw new _helpers.CLIError("Auth session is recorder-based, it cannot be updated.");
+    }
+    input = metadata?.authSessionInput ?? {};
+  }
+  await Promise.all([await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create"), await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check")]);
+  const authSession = await executeRunCreateAuthSessionCLI({
+    id,
+    input,
+    checkRetries,
+    createRetries,
+    log: false,
+    metadata,
+    ...rest
+  });
+  (0, _terminal.terminal)(`^+^gAuth session updated successfully^:\n`);
+  return authSession;
+}
+async function executeAttemptCreateAuthSessionCLI({
+  id,
+  input,
+  ...rest
+}) {
+  id = id ?? generateAuthSessionId(true);
+  (0, _terminal.terminal)(`^+Executing create auth session attempt with id ^c${id}^:\n`);
+  await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create");
+  return await runCreateWithRetries({
+    authSessionId: id,
+    authSessionInput: input,
+    ...rest
+  });
+}
+async function executeAttemptCheckAuthSessionCLI({
+  id,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Executing check auth session attempt with id ^c${id}^:\n`);
+  await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check");
+  (0, _helpers.registerGetAuthSessionParameters)(id);
+  const {
+    storageState
+  } = await (0, _helpers.loadAuthSessionInstance)(id);
+  const checkResult = await runCheckWithRetries({
+    auth: storageState,
+    ...rest
+  });
+  if (!checkResult) {
+    throw new _helpers.CLIError("Check failed");
+  }
+  (0, _terminal.terminal)(`^+^gAuth session check passed^:\n`);
+  return storageState;
+}
+async function runCheck({
+  auth,
+  proxy,
+  headless,
+  timeout,
+  traceId,
+  keepBrowserOpen
+}) {
+  return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
+    const runApiResult = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`
+      },
+      runOptions: await (0, _browser.getCLIRunOptions)({
+        headless,
+        proxy,
+        keepBrowserOpen
+      }),
+      auth: {
+        session: {
+          type: "state",
+          state: auth
+        }
+      },
+      tracing,
+      importFunction: _tsNodeImport.tsNodeImport,
+      abortSignal
+    });
+    if (runApiResult.isErr()) {
+      throw runApiResult.error;
+    }
+    const result = runApiResult.value.result;
+    if (!result) {
+      return false;
+    }
+    return result;
+  }, traceId), timeout);
+}
+const _runCheck = exports._runCheck = runCheck;
+async function runCreate({
+  authSessionInput,
+  proxy,
+  headless,
+  timeout,
+  traceId,
+  keepBrowserOpen
+}) {
+  return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
+    const result = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`,
+        params: authSessionInput
+      },
+      runOptions: await (0, _browser.getCLIRunOptions)({
+        headless,
+        proxy,
+        keepBrowserOpen
+      }),
+      retrieveSession: true,
+      tracing,
+      importFunction: _tsNodeImport.tsNodeImport,
+      abortSignal
+    });
+    if (result.isErr()) {
+      throw result.error;
+    }
+    return result.value.session;
+  }, traceId), timeout);
+}
+const _runCreate = exports._runCreate = runCreate;
+async function runCheckWithRetries({
+  auth,
+  retries,
+  ...rest
+}) {
+  for (let i = 0; i < (retries ?? 1); i++) {
+    (0, _terminal.terminal)(`\n^+Running ^cauth session check${i === 0 ? "" : ` ^/(Attempt ${i + 1})`}^:...\n`);
+    try {
+      let traceId = undefined;
+      if (rest.trace) {
+        traceId = "authsession-check-attempt";
+        if (retries) {
+          traceId += `-${i + 1}`;
+        }
+      }
+      const checkResult = await runCheck({
+        auth,
+        traceId,
+        ...rest
+      });
+      if (checkResult) {
+        (0, _terminal.terminal)(`^+^gAuth session check passed^:\n`);
+        return true;
+      }
+    } catch (error) {
+      if (error instanceof _runApi.RunAutomationError) {
+        (0, _helpers.logAutomationError)(error);
+      } else {
+        throw error;
+      }
+    }
+    (0, _terminal.terminal)(`^+^yAuth session check failed^:\n`);
+  }
+  (0, _terminal.terminal)(`^+^rAuth session check failed after ${retries} attempts^:\n`);
+  return false;
+}
+const _runCheckWithRetries = exports._runCheckWithRetries = runCheckWithRetries;
+async function runCreateWithRetries({
+  authSessionId,
+  authSessionInput,
+  retries,
+  trace,
+  metadata,
+  ...rest
+}) {
+  let newAuthSessionInstance = null;
+  for (let i = 0; i < (retries ?? 1); i++) {
+    (0, _terminal.terminal)(`\n^+Running ^cauth session create${i === 0 ? "" : ` ^/(Attempt ${i + 1})`}^:...\n`);
+    try {
+      let traceId = undefined;
+      if (trace) {
+        traceId = "authsession-create-attempt";
+        if (retries) {
+          traceId += `-${i + 1}`;
+        }
+      }
+      newAuthSessionInstance = await runCreate({
+        authSessionInput,
+        traceId,
+        ...rest
+      });
+      (0, _terminal.terminal)(`^+^gAuth session create succeeded^:\n`);
+      break;
+    } catch (error) {
+      if (error instanceof _runApi.RunAutomationError) {
+        (0, _helpers.logAutomationError)(error);
+      } else {
+        throw error;
+      }
+      (0, _terminal.terminal)(`^+^yAuth session create failed^:\n`);
+    }
+  }
+  if (!newAuthSessionInstance) {
+    throw new _helpers.CLIError(`Failed to create auth session after ${retries} retries`);
+  }
+  await (0, _helpers.storeAuthSessionInstance)({
+    state: newAuthSessionInstance,
+    id: authSessionId,
+    input: authSessionInput,
+    proxy: rest.proxy,
+    metadata
+  });
+  return newAuthSessionInstance;
+}
+const _runCreateWithRetries = exports._runCreateWithRetries = runCreateWithRetries;
+async function executeRecordAuthSessionCLI({
+  id,
+  checkRetries,
+  timeout,
+  headless,
+  proxy,
+  trace = false,
+  keepBrowserOpen,
+  startUrl,
+  finishUrl
+}) {
+  id = id ?? generateAuthSessionId();
+  (0, _terminal.terminal)(`^+Recording auth session with id ^c${id}^:\n`);
+  let authSession;
+  try {
+    authSession = await recordAuthSession({
+      startUrl,
+      finishUrl,
+      timeout,
+      proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
+    });
+  } catch (error) {
+    if (error instanceof _helpers.CLIError) {
+      throw new _helpers.CLIError(`Failed to record auth session: ${error.message}`);
+    }
+    throw error;
+  }
+  await (0, _helpers.storeAuthSessionInstance)({
+    state: authSession,
+    id,
+    proxy,
+    metadata: {
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      authSessionId: id,
+      authSessionType: "MANUAL",
+      recorderStartUrl: startUrl,
+      recorderEndUrl: finishUrl
+    }
+  });
+  await executeRunValidateAuthSessionCLI({
+    id,
+    headless,
+    timeout,
+    proxy,
+    autoRecreate: false,
+    checkRetries,
+    createRetries: 0,
+    trace,
+    keepBrowserOpen
+  });
+  (0, _terminal.terminal)(`^+^gAuth session ^c${id}^ ^+^grecorded successfully^:\n`);
+}
+async function recordAuthSession({
+  startUrl,
+  finishUrl,
+  timeout,
+  proxy
+}) {
+  const {
+    context,
+    page
+  } = await (0, _launchBrowser.launchChromium)({
+    headless: false,
+    proxy,
+    appModeInitialUrl: startUrl
+  });
+  try {
+    if (!page.url().startsWith(startUrl)) {
+      await page.goto(startUrl);
+    }
+    (0, _terminal.terminal)(`^+Navigated to^ ^_${startUrl}^:\n`);
+    (0, _terminal.terminal)(`^+Waiting for^ ^_${finishUrl}^:...\n`);
+    const timeoutTimestamp = Date.now() + timeout;
+    while (true) {
+      if (Date.now() > timeoutTimestamp) {
+        throw new _helpers.CLIError("Timeout waiting for finish URL");
+      }
+      if (context.pages().length === 0) {
+        throw new _helpers.CLIError("Browser was closed before reaching the finish URL");
+      }
+      if (context.pages()[0].url().startsWith(finishUrl)) {
+        break;
+      }
+      await (0, _promises.setTimeout)(1000);
+    }
+    (0, _terminal.terminal)(`^+Finish URL reached, capturing auth session...^:\n`);
+    await page.waitForLoadState("load");
+    const authSession = await (0, _contextStorageStateHelpers.getStorageState)(context);
+    return authSession;
+  } finally {
+    await context.close();
+  }
+}
+function generateAuthSessionId(isAttempt = false) {
+  if (isAttempt) return `auth-session-attempt-${Date.now()}`;
+  return `auth-session-${Date.now()}`;
+}

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

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

package/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/package/dist/commands/intuned-cli/controller/deploy.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+import type { AuthCredentials } from "../types";
+export declare function runDeployProject(projectName: string, auth: AuthCredentials): Promise<void>;
+export declare const projectNameSchema: z.ZodEffects<z.ZodString, string, string>;

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

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projectNameSchema = void 0;
+exports.runDeployProject = runDeployProject;
+var _zod = require("zod");
+var _constants = require("../constants");
+var _helpers = require("../helpers");
+var _terminal = require("../helpers/terminal");
+var _promises = require("timers/promises");
+var _ms = _interopRequireDefault(require("ms"));
+var _save = require("./save");
+var _constants2 = require("../../../common/constants");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function runDeployProject(projectName, auth) {
+  await (0, _save.runSaveProject)(projectName, auth);
+  const {
+    workspaceId,
+    apiKey
+  } = auth;
+  const baseUrl = (0, _helpers.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}/deploy`;
+  const headers = {
+    [_constants2.API_KEY_HEADER_NAME]: apiKey,
+    "Content-Type": "application/json"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "POST"
+  });
+  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();
+  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) {
+          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();
+      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(200, "Name must be 200 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 checkIntunedProjectDeployStatus = async (workspaceId, projectName, apiKey) => {
+  const baseUrl = (0, _helpers.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}/deploy/result`;
+  const headers = {
+    [_constants2.API_KEY_HEADER_NAME]: 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 _helpers.CLIError(`Error querying deployment status ${response.status}: ${await response.text()}`);
+  }
+  const data = await response.json();
+  if (data.status) {
+    return data;
+  }
+  return {
+    status: "failed",
+    message: `Deployment failed, please try again: ${data.message}`
+  };
+};

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

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

package/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/package/dist/commands/intuned-cli/controller/save.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { AuthCredentials } from "../types";
+export declare function runSaveProject(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;
+}>;