@intuned/runtime-dev 1.3.18-interface.15 → 1.3.18-interface.16

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

@@ -0,0 +1,317 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projectNameSchema = exports.START_RUN_INPUT_QUERY_PARAM_KEY = 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 _provision = require("./provision");
+var _constants2 = require("../../../common/constants");
+var _path = _interopRequireDefault(require("path"));
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _prompts = _interopRequireDefault(require("prompts"));
+var _terminalLink = _interopRequireDefault(require("terminal-link"));
+var _pressAnyKey = _interopRequireDefault(require("press-any-key"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const START_RUN_INPUT_QUERY_PARAM_KEY = exports.START_RUN_INPUT_QUERY_PARAM_KEY = "startRunInput";
+async function runDeployProject(projectName, auth) {
+  let enableFirstRunExperience = false;
+  let firstRunExperienceInput = undefined;
+  const settings = await (0, _helpers.loadIntunedJson)();
+  const provisionResult = await (0, _provision.runProvisionProject)(projectName, auth, true);
+  if (provisionResult) {
+    enableFirstRunExperience = provisionResult?.enableFirstRunExperience ?? false;
+    if (enableFirstRunExperience) {
+      firstRunExperienceInput = await promptFirstRunExperience(settings);
+    }
+    const {
+      projectId,
+      dotenvContent,
+      environmentVariablesKeys
+    } = provisionResult;
+    if (dotenvContent) {
+      const dotenvKeys = Object.keys(dotenvContent);
+      const missingKeys = dotenvKeys.filter(key => dotenvContent[key] && !environmentVariablesKeys.includes(key));
+      if (missingKeys.length > 0) {
+        (0, _terminal.terminal)(`^yWarning: The following environment variables are defined in your .env file but are not defined on Intuned platform^:\n`);
+        for (const key of missingKeys) {
+          (0, _terminal.terminal)(`^y  • ${key}^:\n`);
+        }
+        (0, _terminal.terminal)(`^yPlease add them to your project or workspace on Intuned platform to ensure proper functionality.^:\n`);
+        const projectEnvVarsUrl = `${(0, _helpers.getBaseUrl)()}/projects/${projectId}/env-vars`;
+        const workspaceEnvVarsUrl = `${(0, _helpers.getBaseUrl)()}/settings/env-vars`;
+        if (_terminalLink.default.isSupported) {
+          const projectEnvVarsTerminalLink = (0, _terminalLink.default)(`[ Project Env Vars ]`, projectEnvVarsUrl).replaceAll("%", "%%");
+          const workspaceEnvVarsTerminalLink = (0, _terminalLink.default)(`[ Workspace Env Vars ]`, workspaceEnvVarsUrl).replaceAll("%", "%%");
+          (0, _terminal.terminal)(`^Y${projectEnvVarsTerminalLink} ${workspaceEnvVarsTerminalLink}^:\n`);
+        } else {
+          (0, _terminal.terminal)(`^yProject Env Vars: ^_${projectEnvVarsUrl}^:\n`);
+          (0, _terminal.terminal)(`^yWorkspace Env Vars: ^_${workspaceEnvVarsUrl}^:\n`);
+        }
+        try {
+          (0, _terminal.terminal)("Press any key to continue...");
+          await (0, _pressAnyKey.default)("", {
+            ctrlC: "reject",
+            hideMessage: true
+          });
+          (0, _terminal.terminal)("\n");
+        } catch {
+          throw new _helpers.AbortedCLIError();
+        }
+      }
+    }
+  }
+  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",
+    body: JSON.stringify({
+      firstRunExperienceInput
+    })
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new _helpers.CLIError(`Invalid API key. The provided API key is not authorized to access this workspace.\n` + `Please verify your API key at: https://app.intuned.io/settings/api-keys`);
+    }
+    throw new _helpers.CLIError(`^r^+Invalid response from server\n^:^R${response.status} ${await response.text()}^:\n^r^+Deployment failed. Report this issue to the Intuned team.^:\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 failed - 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\n`);
+        const projectUrl = `${url}/projects/${projectId}`;
+        const runsUrl = `${projectUrl}/runs`;
+        const jobsUrl = `${projectUrl}/jobs`;
+        const runsPlaygroundUrl = `${runsUrl}?${buildRunsPlaygroundQueryParams({
+          enableFirstRunExperience,
+          settings,
+          testAuthSessionId: rest.testAuthSessionId
+        })}`;
+        const defaultJobTriggerUrl = rest.defaultJobId ? `${jobsUrl}/${rest.defaultJobId}?action=trigger` : undefined;
+        const actions = [{
+          label: "View Project",
+          url: runsUrl
+        }, ...(settings.apiAccess.enabled ? [{
+          label: "Run Playground",
+          url: runsPlaygroundUrl
+        }] : []), {
+          label: "Manage Jobs",
+          url: jobsUrl
+        }, ...(defaultJobTriggerUrl !== undefined ? [{
+          label: "Trigger Default Job",
+          url: defaultJobTriggerUrl
+        }] : [])];
+        if (_terminalLink.default.isSupported) {
+          for (const action of actions) {
+            const link = (0, _terminalLink.default)(`[ ${action.label} ]`, action.url);
+            (0, _terminal.terminal)(`^+${link.replaceAll("%", "%%")}^ `);
+          }
+          (0, _terminal.terminal)("\n");
+        } else {
+          for (const action of actions) {
+            (0, _terminal.terminal)(`^+${action.label}:^ ^c^_${action.url}^:\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`;
+      } else {
+        errorMessage += `^r^+Unknown error occurred, please report this issue to the Intuned team.^:\n`;
+      }
+      errorMessage += `^r^+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}`
+  };
+};
+async function promptFirstRunExperience(settings) {
+  let testAuthSessionInput = undefined;
+  const shouldPromptForTestAuthSession = settings.authSessions.enabled && settings.authSessions.type === "API";
+  const defaultJobInput = settings.metadata?.defaultJobInput;
+  const shouldPromptForDefaultJob = defaultJobInput !== undefined;
+  if (shouldPromptForTestAuthSession) {
+    testAuthSessionInput = await promptFirstRunExperienceTestAuthSessionParameters({
+      shouldPromptForDefaultJob
+    });
+    if (!testAuthSessionInput) {
+      return {};
+    }
+  }
+  return {
+    testAuthSessionInput,
+    defaultJobInput: shouldPromptForDefaultJob ? await promptFirstRunExperienceDefaultJobParameters({
+      defaultJobInput
+    }) : undefined
+  };
+}
+async function promptFirstRunExperienceTestAuthSessionParameters({
+  shouldPromptForDefaultJob
+}) {
+  const authSessionInstancesDirectory = _path.default.join(process.cwd(), _constants2.AUTH_SESSIONS_INSTANCES_FOLDER_NAME);
+  if (!(await fs.exists(authSessionInstancesDirectory))) {
+    return;
+  }
+  const authSessionId = (await fs.readdir(authSessionInstancesDirectory)).shift();
+  if (!authSessionId) {
+    return;
+  }
+  const {
+    metadata
+  } = await (0, _helpers.loadAuthSessionInstance)(authSessionId);
+  if (!metadata.authSessionId) {
+    return;
+  }
+  const message = shouldPromptForDefaultJob ? `^:^+Create a test AuthSession using^ ^c${authSessionId}^:^+ parameters?^ ^/(required for creating default job)^:` : `^:^+Create a test AuthSession using^ ^c${authSessionId}^:^+ parameters?^:`;
+  const {
+    value
+  } = await (0, _prompts.default)({
+    type: "confirm",
+    name: "value",
+    message: _terminal.terminal.str(message).toString(),
+    initial: true
+  });
+  if (value === undefined) {
+    throw new _helpers.AbortedCLIError();
+  }
+  if (value) {
+    return metadata.authSessionInput;
+  }
+}
+async function promptFirstRunExperienceDefaultJobParameters({
+  defaultJobInput
+}) {
+  const {
+    value
+  } = await (0, _prompts.default)({
+    type: "confirm",
+    name: "value",
+    message: _terminal.terminal.str(`^:^+Create a default job with sample parameters?^:`).toString(),
+    initial: true
+  });
+  if (value === undefined) {
+    throw new _helpers.AbortedCLIError();
+  }
+  if (value) {
+    return defaultJobInput;
+  }
+}
+function buildRunsPlaygroundQueryParams({
+  enableFirstRunExperience,
+  settings,
+  testAuthSessionId
+}) {
+  const params = new URLSearchParams();
+  if (!enableFirstRunExperience) return params.toString();
+  params.set(START_RUN_INPUT_QUERY_PARAM_KEY, JSON.stringify({}));
+  const input = settings.metadata?.defaultRunPlaygroundInput;
+  if (!input) return params.toString();
+  if (testAuthSessionId) {
+    input.authSessionId = testAuthSessionId;
+  }
+  params.set(START_RUN_INPUT_QUERY_PARAM_KEY, JSON.stringify({
+    ...input
+  }));
+  return params.toString();
+}

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"));
+var _helpers = require("../helpers");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+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("Invalid 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/provision.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { AuthCredentials } from "../types";
+export declare function runProvisionProject(projectName: string, auth: AuthCredentials, silent?: boolean): Promise<{
+    projectId: string;
+    enableFirstRunExperience: boolean | undefined;
+    environmentVariablesKeys: string[];
+    dotenvContent: {
+        [x: string]: string;
+    };
+} | undefined>;
+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/intuned-cli/controller/provision.js

@@ -0,0 +1,299 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.projectNameSchema = void 0;
+exports.runProvisionProject = runProvisionProject;
+exports.validateProjectName = exports.validateIntunedProject = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _zod = require("zod");
+var _projectExclusions = _interopRequireDefault(require("../../common/projectExclusions"));
+var _constants = require("../constants");
+var _helpers = require("../helpers");
+var _terminal = require("../helpers/terminal");
+var _build = require("./build");
+var dotenv = _interopRequireWildcard(require("dotenv"));
+var _constants2 = require("../../../common/constants");
+var _ignore = _interopRequireDefault(require("ignore"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+const provisionProjectApiResponseSchema = _zod.z.string().transform((val, ctx) => {
+  try {
+    return JSON.parse(val);
+  } catch (e) {
+    ctx.addIssue({
+      code: _zod.z.ZodIssueCode.custom,
+      message: "Response is not valid JSON"
+    });
+    return _zod.z.NEVER;
+  }
+}).pipe(_zod.z.object({
+  id: _zod.z.string().uuid(),
+  enableFirstRunExperience: _zod.z.boolean().optional(),
+  environmentVariablesKeys: _zod.z.array(_zod.z.string()).default([]).catch(() => [])
+}));
+async function runProvisionProject(projectName, auth, silent = false) {
+  const {
+    workspaceId,
+    apiKey
+  } = auth;
+  const baseUrl = (0, _helpers.getBaseUrl)();
+  const url = `${baseUrl}/api/v1/workspace/${workspaceId}/projects/${projectName}`;
+  const headers = {
+    [_constants2.API_KEY_HEADER_NAME]: apiKey,
+    "Content-Type": "application/json"
+  };
+  const projectPath = process.cwd();
+  const codeTree = await convertProjectToCodeTree(projectPath);
+  const intunedSettingsFile = await (0, _helpers.getIntunedSettingsFile)();
+  codeTree["Intuned.json"] = {
+    file: {
+      contents: JSON.stringify(intunedSettingsFile.parse(await fs.readFile(intunedSettingsFile.path, "utf-8")))
+    }
+  };
+  codeTree["tsconfig.json"] = {
+    file: {
+      contents: JSON.stringify(_constants.tsConfigCli, null, 2)
+    }
+  };
+  const upsertProjectPayload = {
+    codeTree,
+    platformType: "CLI",
+    language: "typescript"
+  };
+  const response = await fetch(url, {
+    headers,
+    method: "PUT",
+    body: JSON.stringify(upsertProjectPayload)
+  });
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new _helpers.CLIError(`Invalid API key. The provided API key is not authorized to access this workspace.\n` + `Please verify your API key at: https://app.intuned.io/settings/api-keys`);
+    }
+    throw new _helpers.CLIError(`^r^+Project provisioning failed:^:\n` + `^RServer returned status ${response.status}^:\n` + `^RResponse: ${await response.text()}^:\n\n` + `^yCommon causes:^:\n` + `  • Invalid workspace ID or project name\n` + `  • Insufficient permissions\n` + `  • Network connectivity issues\n` + `  • Project structure validation errors\n`, {
+      autoColor: false
+    });
+  }
+  if (!silent) {
+    (0, _terminal.terminal)("^g^+Project provisioned successfully!^:\n");
+  }
+  const body = await response.text();
+  const parseResult = provisionProjectApiResponseSchema.safeParse(body);
+  if (!parseResult.success) {
+    (0, _terminal.terminal)(`^yWarning: Could not parse provision project response:^:\n`);
+    (0, _terminal.terminal)(body + "\n");
+    return;
+  }
+  const {
+    id: projectId,
+    enableFirstRunExperience,
+    environmentVariablesKeys
+  } = parseResult.data;
+  const dotEnvPath = path.join(projectPath, ".env");
+  if (!(await fs.exists(dotEnvPath))) {
+    await fs.writeFile(dotEnvPath, `${_constants2.PROJECT_ID_ENV_VAR_KEY}=${projectId}
+${_constants2.WORKSPACE_ID_ENV_VAR_KEY}=${workspaceId}
+${_constants2.API_KEY_ENV_VAR_KEY}=${apiKey}`);
+    (0, _terminal.terminal)(`^g^+Created .env file with project credentials.^:\n`);
+    return {
+      projectId,
+      enableFirstRunExperience,
+      environmentVariablesKeys,
+      dotenvContent: {}
+    };
+  }
+  const envContent = await fs.readFile(dotEnvPath, "utf-8");
+  const dotenvContent = dotenv.parse(envContent);
+  let contentToAppend = "";
+  const projectCredentialsEnvVars = {
+    [_constants2.PROJECT_ID_ENV_VAR_KEY]: projectId,
+    [_constants2.WORKSPACE_ID_ENV_VAR_KEY]: workspaceId,
+    [_constants2.API_KEY_ENV_VAR_KEY]: apiKey
+  };
+  for (const key in projectCredentialsEnvVars) {
+    if (dotenvContent[key] === projectCredentialsEnvVars[key]) {
+      continue;
+    }
+    if (dotenvContent[key]) {
+      (0, _terminal.terminal)(`^yWarning: Existing ${key} in .env has invalid value. Appending correct value.^:\n`);
+    }
+    contentToAppend += `${key}=${projectCredentialsEnvVars[key]}\n`;
+  }
+  if (contentToAppend) {
+    await fs.appendFile(dotEnvPath, contentToAppend + "\n");
+    (0, _terminal.terminal)(`^g^+Updated .env file with project credentials.^:\n`);
+  }
+  const dotenvContentToReturn = {
+    ...dotenvContent
+  };
+  for (const key of [_constants2.PROJECT_ID_ENV_VAR_KEY, _constants2.WORKSPACE_ID_ENV_VAR_KEY, _constants2.API_KEY_ENV_VAR_KEY]) {
+    if (key in dotenvContentToReturn) {
+      delete dotenvContentToReturn[key];
+    }
+  }
+  return {
+    projectId,
+    enableFirstRunExperience,
+    environmentVariablesKeys,
+    dotenvContent: dotenvContentToReturn
+  };
+}
+const projectNameSchema = exports.projectNameSchema = _zod.z.string().min(1, "Name is required").max(200, "Must be 200 characters or less").regex(/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/, "Can only contain lowercase letters, numbers, hyphens, and underscores in between").refine(value => !_zod.z.string().uuid().safeParse(value).success, {
+  message: "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 currentDirectoryToProvision = process.cwd();
+  const intunedSettingsFile = await (0, _helpers.getIntunedSettingsFile)();
+  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: intunedSettingsFile.name,
+    check: async () => {
+      try {
+        const intunedJsonPath = path.join(currentDirectoryToProvision, intunedSettingsFile.name);
+        await fs.exists(intunedJsonPath);
+        return {
+          isValid: true
+        };
+      } catch (error) {
+        return {
+          isValid: false,
+          errorMessage: `${intunedSettingsFile.name} file not found`
+        };
+      }
+    }
+  }, {
+    name: "api folder",
+    check: async () => {
+      try {
+        const apiFolderPath = path.join(currentDirectoryToProvision, "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;
+async function convertProjectToCodeTree(projectPath) {
+  const ig = (0, _ignore.default)();
+  const gitIgnorePath = await findGitIgnoreFile(projectPath);
+  if (gitIgnorePath) {
+    const gitIgnoreContent = await fs.readFile(gitIgnorePath, "utf-8");
+    ig.add(gitIgnoreContent);
+  }
+  ig.add(_projectExclusions.default);
+  async function traverse(dirPath) {
+    const tree = {};
+    const fileNames = [];
+    const entries = await fs.readdir(dirPath, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry.name);
+      if (ig.ignores(path.relative(projectPath, entryPath))) {
+        continue;
+      }
+      if (entry.isFile()) {
+        try {
+          const content = await fs.readFile(entryPath, "utf-8");
+          tree[entry.name] = {
+            file: {
+              contents: content
+            }
+          };
+          fileNames.push(path.relative(projectPath, entryPath));
+        } catch (error) {
+          (0, _terminal.terminal)(`^yWarning: Could not read file ${entryPath}^:\n`);
+        }
+      } else if (entry.isDirectory()) {
+        const {
+          tree: subTree,
+          fileNames: subFileNames
+        } = await traverse(entryPath);
+        fileNames.push(...subFileNames);
+        if (Object.keys(subTree).length > 0) {
+          tree[entry.name] = {
+            directory: subTree
+          };
+        }
+      }
+    }
+    return {
+      tree,
+      fileNames
+    };
+  }
+  const {
+    tree,
+    fileNames
+  } = await traverse(projectPath);
+  const filesToProvisionText = "  " + fileNames.join("\n  ");
+  (0, _terminal.terminal)("^CFiles to be provisioned:^:\n");
+  (0, _terminal.terminal)(filesToProvisionText + "\n");
+  return tree;
+}
+async function findGitIgnoreFile(projectPath) {
+  let currentDirectory = projectPath;
+  while (true) {
+    const gitIgnorePath = path.join(currentDirectory, ".gitignore");
+    if (await fs.exists(gitIgnorePath)) {
+      return gitIgnorePath;
+    }
+    const parentDirectory = path.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      break;
+    }
+    currentDirectory = parentDirectory;
+  }
+  return null;
+}

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

@@ -0,0 +1 @@
+export declare function scaffoldAuthSessionFiles(): Promise<void>;