@intuned/runtime 1.3.16 → 1.3.17

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

@@ -0,0 +1,300 @@
+"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 _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 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>;

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scaffoldAuthSessionFiles = scaffoldAuthSessionFiles;
+var _zod = require("zod");
+var _helpers = require("../helpers");
+var _types = require("../types");
+var _tsNodeImport = require("../../common/tsNodeImport");
+var _constants = require("../../../common/constants");
+var _fsExtra = require("fs-extra");
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const authSessionTemplateResponseSchema = _zod.z.object({
+  "auth-sessions": _types.fileSystemTreeSchema
+});
+async function scaffoldAuthSessionFiles() {
+  const [createResult, checkResult] = await Promise.all([(0, _tsNodeImport.tsNodeImport)(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`), (0, _tsNodeImport.tsNodeImport)(`${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`)]);
+  const createExists = createResult.isOk() || createResult.error.type !== "not_found";
+  const checkExists = checkResult.isOk() || checkResult.error.type !== "not_found";
+  if (createExists && checkExists) {
+    (0, _helpers.terminal)("^g^+AuthSession files already exist^:\n");
+    return;
+  }
+  (0, _helpers.terminal)("^g^+Scaffolding...^:\n");
+  const authSessionTemplateUrl = new URL("/api/v1/templates/authsession", (0, _helpers.getBaseUrl)());
+  authSessionTemplateUrl.searchParams.append("language", "typescript");
+  const response = await fetch(authSessionTemplateUrl.toString(), {
+    method: "GET"
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`Failed to fetch AuthSession template
+Got ${response.status} ${response.statusText}
+${text}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`Failed to parse AuthSession template response as JSON
+${text}`);
+  }
+  const parseResult = authSessionTemplateResponseSchema.safeParse(json);
+  if (!parseResult.success) {
+    throw new Error(`AuthSession template response has invalid shape: ${JSON.stringify(parseResult.error.errors, null, 2)}`);
+  }
+  const authSessionsContent = parseResult.data["auth-sessions"];
+  const cwd = process.cwd();
+  const exists = {
+    create: createExists,
+    check: checkExists
+  };
+  await (0, _fsExtra.ensureDir)(_path.default.join(cwd, _constants.AUTH_SESSIONS_FOLDER_NAME));
+  for (const api in exists) {
+    if (exists[api]) {
+      continue;
+    }
+    const [name, node] = Object.entries(authSessionsContent).find(entry => "file" in entry[1] && entry[0].replace(/\.[^/.]+$/, "") === api) ?? [undefined, undefined];
+    if (!name || !node) {
+      continue;
+    }
+    const {
+      file: {
+        contents
+      }
+    } = node;
+    if (typeof contents !== "string") {
+      continue;
+    }
+    await (0, _fsExtra.writeFile)(_path.default.join(cwd, _constants.AUTH_SESSIONS_FOLDER_NAME, name), contents, {
+      encoding: "utf-8"
+    });
+    (0, _helpers.terminal)(`^g^+Written ^_${_path.default.join(_constants.AUTH_SESSIONS_FOLDER_NAME, name)}^:\n`);
+  }
+}

package/dist/commands/intuned-cli/helpers/__test__/browser.test.js

@@ -10,6 +10,7 @@ function getTerminal() {
   });
 }
 _vitest.vi.mock("fs-extra", () => ({
+  ensureDir: _vitest.vi.fn(),
   exists: _vitest.vi.fn().mockResolvedValue(true)
 }));
 _vitest.vi.mock("portfinder", () => ({

package/dist/commands/intuned-cli/helpers/__test__/tracing.test.js

@@ -9,6 +9,7 @@ function getTerminal() {
   });
 }
 _vitest.vi.mock("fs-extra", () => ({
+  ensureDir: _vitest.vi.fn(),
   exists: _vitest.vi.fn().mockResolvedValue(true)
 }));
 _vitest.vi.mock("../../helpers/terminal", () => ({

package/dist/commands/intuned-cli/helpers/api.js

@@ -4,15 +4,12 @@ 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 }; }
+var _tsNodeImport = require("../../common/tsNodeImport");
 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.^:`, {
+  const result = await (0, _tsNodeImport.tsNodeImport)(`${dirname}/${api}`);
+  if (result.isErr() && result.error.type === "not_found") {
+    throw new _errors.CLIAssertionError(`^+^r API^ ^+${dirname}/${api}^ ^r^+does not exist. Make sure to use an existing API name.^:`, {
       autoColor: false
     });
   }

package/dist/commands/intuned-cli/helpers/auth.js

@@ -20,25 +20,21 @@ 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, _intunedJson.loadIntunedJson)();
-    return Boolean(intunedJson?.authSessions?.enabled);
-  } catch (error) {
-    return false;
-  }
+  const intunedJson = await (0, _intunedJson.loadIntunedJson)();
+  return Boolean(intunedJson?.authSessions?.enabled);
 }
 async function assertAuthEnabled() {
   if (!(await isAuthEnabled())) {
-    throw new _errors.CLIAssertionError(`Auth session is not enabled, enable it in ${await (0, _intunedJson.getIntunedSettingsFileName)()} to use it`);
+    throw new _errors.CLIAssertionError(await getAuthNotEnabledErrorMessage());
   }
 }
 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.");
+    throw new _errors.CLIAssertionError("AuthSession is enabled, but no AuthSession is provided. Please provide an AuthSession using '--auth-session <id>' option.");
   }
   if (!_isAuthEnabled && authSession) {
-    throw new _errors.CLIAssertionError(`Auth session is not enabled, enable it in ${await (0, _intunedJson.getIntunedSettingsFileName)()} to use it`);
+    throw new _errors.CLIAssertionError(await getAuthNotEnabledErrorMessage());
   }
 }
 async function loadAuthSessionInstance(authSessionId) {
@@ -47,12 +43,12 @@ async function loadAuthSessionInstance(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`);
+      throw new _errors.CLIError(`AuthSession instance with ID ${authSessionId} not found. Make sure the ID is correct.`);
     }
     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)}`);
+      throw new _errors.CLIError(`AuthSession instance with ID ${authSessionId} is not valid: ${(0, _formatZodError.formatZodError)(authSessionInstanceParseResult.error)}`);
     }
     const metadata = await (0, _fsExtra.readJSON)(authSessionInstanceMetadataPath);
     return {
@@ -60,7 +56,7 @@ async function loadAuthSessionInstance(authSessionId) {
       metadata
     };
   } catch (error) {
-    throw new _errors.CLIError(`Error retrieving auth session instance: ${error.message}`);
+    throw new _errors.CLIError(`Error loading AuthSession instance: ${error.message}`);
   }
 }
 async function storeAuthSessionInstance({
@@ -81,7 +77,7 @@ async function storeAuthSessionInstance({
     });
     const projectAuthConfig = (await (0, _intunedJson.loadIntunedJson)()).authSessions;
     if (!projectAuthConfig.enabled) {
-      throw new _errors.CLIError(`Auth sessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+      throw new _errors.CLIError(`AuthSessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}. Make sure they are enabled.`);
     }
     const authSessionInstanceMetadataPath = _path.default.join(authSessionInstancePath, `metadata.json`);
     const authSessionMetadata = {
@@ -104,19 +100,19 @@ async function storeAuthSessionInstance({
     });
     return authSessionInstancePath;
   } catch (error) {
-    throw new _errors.CLIError(`Error storing auth session instance: ${error.message}`);
+    throw new _errors.CLIError(`Error storing AuthSession instance: ${error.message}`);
   }
 }
 function registerGetAuthSessionParameters(authSessionId) {
   async function getAuthSessionParameters() {
     if (!authSessionId) {
-      throw new Error("getAuthSessionParameters cannot be called without using an auth session");
+      throw new Error("getAuthSessionParameters cannot be called without using an AuthSession");
     }
     const {
       metadata
     } = await loadAuthSessionInstance(authSessionId);
     if (metadata?.authSessionType === "MANUAL") {
-      throw new Error("Auth session is recorder-based, it does not have parameters.");
+      throw new Error("AuthSession is recorder-based, it does not have parameters.");
     }
     return metadata?.authSessionInput ?? {};
   }
@@ -125,20 +121,27 @@ function registerGetAuthSessionParameters(authSessionId) {
 async function getAuthSessionRecorderParameters() {
   const intunedJson = await (0, _intunedJson.loadIntunedJson)();
   if (!intunedJson.authSessions.enabled) {
-    throw new _errors.CLIError(`Auth sessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+    throw new _errors.CLIError(`AuthSessions are not enabled in ${await (0, _intunedJson.getIntunedSettingsFileName)()}. Make sure they are enabled.`);
   }
   if (intunedJson.authSessions.type !== "MANUAL") {
-    throw new _errors.CLIError(`Auth session type is not recorder-based in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+    throw new _errors.CLIError(`AuthSession type is not recorder-based in ${await (0, _intunedJson.getIntunedSettingsFileName)()}.
+Make sure the AuthSession type is set to 'MANUAL'
+For more details, check out https://docs.intunedhq.com/docs/05-references/intuned-json#configuration-properties.`);
   }
   const {
     startUrl,
     finishUrl
   } = intunedJson.authSessions;
   if (startUrl === undefined || finishUrl === undefined) {
-    throw new _errors.CLIError(`Auth session type is recorder-based but start_url or finish_url is not set in ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+    throw new _errors.CLIError(`AuthSession type is recorder-based but start_url or finish_url is not set in ${await (0, _intunedJson.getIntunedSettingsFileName)()}.
+Please set both values to use recorder-based AuthSessions.
+For more details, check out https://docs.intunedhq.com/docs/05-references/intuned-json#configuration-properties`);
   }
   return {
     startUrl,
     finishUrl
   };
+}
+async function getAuthNotEnabledErrorMessage() {
+  return "AuthSessions are not enabled.\n" + `Enable AuthSessions in ${await (0, _intunedJson.getIntunedSettingsFileName)()} to use this feature.\n` + "See https://docs.intunedhq.com/docs/02-features/auth-sessions#1-enable-authsessions-for-your-project for more information.";
 }

package/dist/commands/intuned-cli/helpers/backend.js

@@ -8,14 +8,22 @@ exports.getBaseUrl = getBaseUrl;
 var _constants = require("../../../common/constants");
 var _errors = require("./errors");
 var _intunedJson = require("./intunedJson");
+var _prompts = require("./prompts");
 async function getAuthCredentials(options) {
-  const workspaceId = options.workspaceId || (await (0, _intunedJson.loadIntunedJson)()).workspaceId;
-  const apiKey = options.apiKey || process.env[_constants.API_KEY_ENV_VAR_KEY];
+  const settings = await (0, _intunedJson.loadIntunedJson)();
+  let workspaceId = options.workspaceId || settings.workspaceId || process.env[_constants.WORKSPACE_ID_ENV_VAR_KEY];
+  let apiKey = options.apiKey || process.env[_constants.API_KEY_ENV_VAR_KEY];
   if (!workspaceId) {
-    throw new _errors.CLIError(`Workspace ID is required. Please provide it via command line options or ${await (0, _intunedJson.getIntunedSettingsFileName)()}`);
+    workspaceId = await (0, _prompts.promptForWorkspaceId)();
+  }
+  if (!workspaceId) {
+    throw new _errors.CLIError(`Workspace ID is required. Please provide it via command line options or ${await (0, _intunedJson.getIntunedSettingsFileName)()}.\n` + `Expected format: UUID (e.g., 123e4567-e89b-12d3-a456-426614174000)\n` + `Find your workspace ID at: https://app.intuned.io/settings/api-keys`);
+  }
+  if (!apiKey) {
+    apiKey = await (0, _prompts.promptForApiKey)();
   }
   if (!apiKey) {
-    throw new _errors.CLIError(`API key is required. Please provide it via command line options or ${_constants.API_KEY_ENV_VAR_KEY} environment variable.`);
+    throw new _errors.CLIError(`API key is required. Please provide it via command line options or ${_constants.API_KEY_ENV_VAR_KEY} environment variable.\n` + `Get your API key at: https://app.intuned.io/settings/api-keys`);
   }
   return {
     workspaceId,

package/dist/commands/intuned-cli/helpers/context.js

@@ -13,13 +13,13 @@ async function withCLIContext(fn, options) {
   async function getAuthSessionParameters() {
     const id = options?.authSessionId;
     if (!id) {
-      throw new Error("getAuthSessionParameters cannot be called without using an auth session");
+      throw new Error("getAuthSessionParameters cannot be called without using an AuthSession");
     }
     const {
       metadata
     } = await (0, _auth.loadAuthSessionInstance)(id);
     if (metadata?.authSessionType === "MANUAL") {
-      throw new Error("Auth session is recorder-based, it does not have parameters.");
+      throw new Error("AuthSession is recorder-based, it does not have parameters.");
     }
     return metadata?.authSessionInput ?? {};
   }

package/dist/commands/intuned-cli/helpers/prompts.d.ts

@@ -0,0 +1,3 @@
+export declare function promptForProjectName(validate: (name: string) => boolean | string): Promise<string | undefined>;
+export declare function promptForWorkspaceId(): Promise<string>;
+export declare function promptForApiKey(): Promise<string>;

package/dist/commands/intuned-cli/helpers/prompts.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.promptForApiKey = promptForApiKey;
+exports.promptForProjectName = promptForProjectName;
+exports.promptForWorkspaceId = promptForWorkspaceId;
+var _prompts = _interopRequireDefault(require("prompts"));
+var _zod = require("zod");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function promptForProjectName(validate) {
+  const {
+    projectName
+  } = await (0, _prompts.default)({
+    type: "text",
+    name: "projectName",
+    message: "Project name (required):",
+    validate
+  });
+  return projectName?.trim();
+}
+const workspaceIdSchema = _zod.z.string().uuid("Workspace ID must be a valid UUID");
+async function promptForWorkspaceId() {
+  const {
+    workspaceId
+  } = await (0, _prompts.default)({
+    type: "text",
+    name: "workspaceId",
+    message: "Workspace ID (required):",
+    validate: value => {
+      const parsed = workspaceIdSchema.safeParse(String(value).trim());
+      return parsed.success ? true : parsed.error.errors[0].message;
+    }
+  });
+  return workspaceId.trim();
+}
+const apiKeySchema = _zod.z.string().min(1, "API Key cannot be empty").superRefine((val, ctx) => {
+  if (val.includes(" ")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "API Key cannot contain spaces"
+    });
+  }
+  if (!val.startsWith("in1_")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "API Key must start with 'in1_'"
+    });
+  }
+  if (val.length !== 36) {
+    ctx.addIssue({
+      code: "custom",
+      message: "API Key must be 36 characters long"
+    });
+  }
+});
+async function promptForApiKey() {
+  const {
+    apiKey
+  } = await (0, _prompts.default)({
+    type: "text",
+    name: "apiKey",
+    message: "API Key (required, get it at: https://app.intuned.io/settings/api-keys):",
+    validate: value => {
+      const parsed = apiKeySchema.safeParse(String(value).trim());
+      return parsed.success ? true : parsed.error.errors.map(e => e.message).join(", ");
+    }
+  });
+  return apiKey.trim();
+}