@intuned/runtime 1.3.15 → 1.3.17

package/InterfaceTemplate/index.playwright.ts

@@ -1,6 +1,6 @@
 require("@intuned/runtime/dist/common/binStartupScript");
 import { runAutomationCLI } from "@intuned/runtime/dist/commands/interface/run";
 
-import { importModule } from "./utils";
+import { importModule } from "./__utils";
 
 runAutomationCLI(importModule);

package/dist/commands/api/run.js

@@ -31,12 +31,12 @@ async function executeCLI(apiName, mode, inputData, options) {
   const settings = await (0, _settings.getSettings)();
   if (settings.authSessions.enabled) {
     if (!options.authSessionPath) {
-      throw new Error("Auth session is enabled but no auth session provided");
+      throw new Error("AuthSessions are enabled but no AuthSession provided.\n" + "Please provide --auth-session-path option.\n" + "See https://docs.intunedhq.com/docs/cli/auth-sessions for more information.");
     }
     authSessionPathToUse = options.authSessionPath;
   } else {
     if (options.authSessionPath) {
-      throw new Error("Auth session is not enabled but auth session provided. To use auth session please enable it in Intuned.json");
+      throw new Error("Authentication is not enabled but AuthSession was provided.\n" + "Enable AuthSessions in Intuned.json to use this feature.\n" + "See https://docs.intunedhq.com/docs/cli/auth-sessions for more information.");
     }
   }
   const runApiResult = await (0, _runApi.runApi)({
@@ -67,12 +67,8 @@ async function executeCLI(apiName, mode, inputData, options) {
     result,
     extendedPayloads: payloadToAppend
   } = runApiResult.value;
-  const isResponseObject = typeof result === "object" && result !== null;
-  const hasMoreThank5Keys = isResponseObject && Object.keys(result).length > 5;
-  const hasNestedObjects = isResponseObject && Object.values(result).some(value => typeof value === "object");
-  const shouldWriteToFile = isResponseObject && (hasMoreThank5Keys || hasNestedObjects);
   const resultsDir = "/tmp/run-results";
-  if (options.outputFileId && shouldWriteToFile) {
+  if (options.outputFileId) {
     _Logger.logger.info(_chalk.default.underline.bgBlue.white(`Click to Open: Results saved (Run: ${options.outputFileId})`));
     fs.ensureDirSync(resultsDir);
     const path = `${resultsDir}/${options.outputFileId}.json`;
@@ -98,7 +94,7 @@ async function executeCLI(apiName, mode, inputData, options) {
     _Logger.logger.info("This will only take an effect if this API run was part of a job.");
   }
 }
-_commander.program.description("run the user function in the cli for testing purposes").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").option("--outputFileId <outputFileId>", "the output file id to save the result in").option("--proxy <proxy>", "proxy to use").option("--authSessionParameters <authSessionParameters>", "parameters used to create the used auth session").argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone", "playwright-headless"]).default("playwright-standalone").argOptional()).action(async (apiName, mode, options) => {
+_commander.program.description("run the user function in the cli for testing purposes").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "AuthSession to use when executing the api").option("--outputFileId <outputFileId>", "the output file id to save the result in").option("--proxy <proxy>", "proxy to use").option("--authSessionParameters <authSessionParameters>", "parameters used to create the used AuthSession").argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone", "playwright-headless"]).default("playwright-standalone").argOptional()).action(async (apiName, mode, options) => {
   let inputData = null;
   if (options.input) {
     inputData = await fs.readJSON(options.input);

package/dist/commands/auth-sessions/load.js

@@ -10,13 +10,13 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 _dotenv.default.config({
   path: `.env`
 });
-_commander.program.description("load auth session to browser").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").allowUnknownOption().action(async ({
+_commander.program.description("load AuthSession to browser").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "AuthSession to use when executing the api").allowUnknownOption().action(async ({
   cdpAddress,
   authSessionPath
 }) => {
   const setting = await (0, _settings.getSettings)();
   if (!setting.authSessions.enabled) {
-    throw new Error("Auth session is not enabled");
+    throw new Error("Authentication required but not configured.\n" + "Enable AuthSessions in Intuned.json to use this feature.\n" + "See https://docs.intunedhq.com/docs/cli/auth-sessions for more information.");
   }
   await (0, _playwrightContext.withPlaywrightContext)({
     cdpAddress

package/dist/commands/auth-sessions/run-check.js

@@ -19,18 +19,18 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 _dotenv.default.config({
   path: `.env`
 });
-_commander.program.description("run auth session check").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the check").option("--authSessionParameters <authSessionParameters>", "parameters used to create the used auth session").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
+_commander.program.description("run AuthSession check").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "AuthSession to use when executing the check").option("--authSessionParameters <authSessionParameters>", "parameters used to create the used AuthSession").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
   cdpAddress,
   authSessionPath,
   authSessionParameters
 }) => {
   const setting = await (0, _settings.getSettings)();
   if (!setting.authSessions.enabled) {
-    throw new Error("auth session is not enabled");
+    throw new Error("Authentication required but not configured.\n" + "Enable AuthSessions in Intuned.json to use this feature.\n" + "See https://docs.intunedhq.com/docs/cli/auth-sessions for more information.");
   }
   const checkFilePath = (0, _fileUtils.getFullPathInProject)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check");
   if (!fs.exists(checkFilePath)) {
-    throw new Error("auth session check file not found");
+    throw new Error("AuthSession check file not found");
   }
   let authSessionParametersJson = undefined;
   if (!(0, _isNil.default)(authSessionParameters)) {
@@ -62,12 +62,12 @@ _commander.program.description("run auth session check").option("--cdpAddress <c
       throw runApiResult.error.error;
     }
     console.error(runApiResult.error);
-    throw new Error("Error running auth session check");
+    throw new Error("Error running AuthSession check");
   }
   const result = runApiResult.value.result;
   console.log("check result", result);
   if (!result) {
-    throw new Error("auth session check failed");
+    throw new Error("AuthSession check failed");
   }
   process.exit(0);
 });

package/dist/commands/auth-sessions/run-create.js

@@ -18,7 +18,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 _dotenv.default.config({
   path: `.env`
 });
-_commander.program.description("run auth session create").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--authSessionPath <authSession>", "auth session to use when executing the api").option("--pathToSave <pathToSave>", "path to save the auth session, if not provided, will discard the auth session").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
+_commander.program.description("run AuthSession create").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--authSessionPath <authSession>", "AuthSession to use when executing the api").option("--pathToSave <pathToSave>", "path to save the AuthSession, if not provided, will discard the AuthSession").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone"]).default("playwright-standalone").argOptional()).action(async (mode, {
   cdpAddress,
   pathToSave,
   input,
@@ -34,11 +34,11 @@ _commander.program.description("run auth session create").option("--cdpAddress <
   }
   const setting = await (0, _settings.getSettings)();
   if (!setting.authSessions.enabled) {
-    throw new Error("auth sessions feature is not enabled");
+    throw new Error("Authentication required but not configured.\n" + "Enable AuthSessions in Intuned.json to use this feature.\n" + "See https://docs.intunedhq.com/docs/cli/auth-sessions for more information.");
   }
   const createFilePath = (0, _fileUtils.getFullPathInProject)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create.ts");
   if (!fs.exists(createFilePath)) {
-    throw new Error("auth session create file not found");
+    throw new Error("AuthSession create file not found");
   }
   async function runCreate() {
     const result = await (0, _runApi.runApi)({

package/dist/commands/build.js

@@ -45,7 +45,7 @@ async function build(outfile, mode, template) {
       }), (0, _pluginTypescript.default)({
         tsconfig: `./intuned/${template}/tsconfig.json`
       }), (0, _pluginCommonjs.default)({
-        include: ["node_modules/**", `intuned/${template}/**`, "dist", "../typescript-sdk/**", "../typescript-runtime/**"],
+        include: ["node_modules/**", `intuned/${template}/**`, "dist", "../typescript-runtime/**"],
         extensions: [".js"],
         ignoreGlobal: false,
         sourceMap: false,

package/dist/commands/common/projectExclusions.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-const exclusions = ["node_modules/**", ".git/**", "dist/**", "build/**", "coverage/**", ".next/**", ".cache/**", "out/**", "tmp/**", ".DS_Store", "npm-debug.log*", "yarn-debug.log*", "yarn-error.log*", ".env", ".env.*", "**/*.map", "**/*.tsbuildinfo", "tsconfig.json", "output/**", "auth-sessions-instances/**", "README.md", "traces/**"];
+const exclusions = ["node_modules/**", ".vscode/**", ".idea/**", ".git/**", "dist/**", "build/**", "coverage/**", ".next/**", ".cache/**", "out/**", "tmp/**", ".DS_Store", "npm-debug.log*", "yarn-debug.log*", "yarn-error.log*", ".env", ".env.*", "**/*.map", "**/*.tsbuildinfo", "tsconfig.json", "output/**", "auth-sessions-instances/**", "README.md", "traces/**"];
 var _default = exports.default = exclusions;

package/dist/commands/common/tsNodeImport.js

@@ -21,6 +21,15 @@ const tsNodeImport = async apiName => {
     return (0, _neverthrow.ok)(imported);
   } catch (e) {
     if ("code" in e && e.code.includes("MODULE_NOT_FOUND")) {
+      if ("requireStack" in e && Array.isArray(e.requireStack)) {
+        const isStackTopThisFile = e.requireStack[0] === __filename;
+        if (!isStackTopThisFile) {
+          return (0, _neverthrow.err)({
+            type: "other",
+            error: e
+          });
+        }
+      }
       return (0, _neverthrow.err)({
         type: "not_found"
       });

package/dist/commands/interface/run.js

@@ -196,7 +196,7 @@ function getProxyUrlFromRunOptions(runOptions) {
 }
 const _defaultImport = async path => {
   try {
-    const imported = await (specifier => new Promise(r => r(specifier)).then(s => _interopRequireWildcard(require(s))))(`../../../${path}.ts`);
+    const imported = await (specifier => new Promise(r => r(specifier)).then(s => _interopRequireWildcard(require(s))))(`../../../${path}`);
     return (0, _neverthrow.ok)(imported);
   } catch (e) {
     if ("code" in e && e.code === "MODULE_NOT_FOUND") {

package/dist/commands/intuned-cli/commands/attempt_api.command.js

@@ -15,7 +15,7 @@ const optionsSchema = _types.baseCommandOptionsSchema.extend({
   authSession: _zod.z.string().optional(),
   outputFile: _zod.z.string().optional()
 });
-const attemptApiCommand = exports.attemptApiCommand = (0, _types.withBaseOptions)(_attempt.attemptCommand.command("api").description("Execute an Intuned API attempt with parameters").argument("<api-name>", "Name of the API to run").argument("<parameters>", "Path to the JSON file containing API parameters OR the parameters as a JSON string").option("-a, --auth-session <id>", "ID of the auth session to use for the API. This is expected to be in ./auth-sessions-instances/<id>.json").option("-o, --output-file <path>", "output file path")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([apiName, parameters], {
+const attemptApiCommand = exports.attemptApiCommand = (0, _types.withBaseOptions)(_attempt.attemptCommand.command("api").description("Execute an Intuned API attempt with parameters").argument("<api-name>", "Name of the API to run").argument("<parameters>", "Path to the JSON file containing API parameters OR the parameters as a JSON string").option("-a, --auth-session <id>", "ID of the AuthSession to use for the API. This is expected to be in ./auth-sessions-instances/<id>.json").option("-o, --output-file <path>", "output file path")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([apiName, parameters], {
   authSession,
   ...rest
 }) => {

package/dist/commands/intuned-cli/commands/attempt_authsession.command.js

@@ -5,4 +5,4 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.attemptAuthSessionCommand = void 0;
 var _attempt = require("./attempt.command");
-const attemptAuthSessionCommand = exports.attemptAuthSessionCommand = _attempt.attemptCommand.command("authsession").description("Manage authentication sessions");
+const attemptAuthSessionCommand = exports.attemptAuthSessionCommand = _attempt.attemptCommand.command("authsession").description("Manage AuthSessions");

package/dist/commands/intuned-cli/commands/attempt_authsession_check.command.js

@@ -9,8 +9,8 @@ var _authSession = require("../controller/authSession");
 var _attempt_authsession = require("./attempt_authsession.command");
 var _helpers = require("../helpers");
 var _types = require("./types");
-const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required")]);
-const attemptAuthSessionCheckCommand = exports.attemptAuthSessionCheckCommand = (0, _types.withBaseOptions)(_attempt_authsession.attemptAuthSessionCommand.command("check").description("Check an existing auth session").argument("<id>", "ID of the auth session to check")).action((0, _helpers.cliCommandWrapper)(argsSchema, _types.baseCommandOptionsSchema, async ([id], options) => {
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the AuthSession is required")]);
+const attemptAuthSessionCheckCommand = exports.attemptAuthSessionCheckCommand = (0, _types.withBaseOptions)(_attempt_authsession.attemptAuthSessionCommand.command("check").description("Check an existing AuthSession").argument("<id>", "ID of the AuthSession to check")).action((0, _helpers.cliCommandWrapper)(argsSchema, _types.baseCommandOptionsSchema, async ([id], options) => {
   await (0, _helpers.assertAuthEnabled)();
   await (0, _authSession.executeAttemptCheckAuthSessionCLI)({
     id,

package/dist/commands/intuned-cli/commands/attempt_authsession_create.command.js

@@ -14,7 +14,7 @@ const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "Parameters are required
 const optionsSchema = _types.baseCommandOptionsSchema.extend({
   id: _zod.z.string().optional()
 });
-const attemptAuthSessionCreateCommand = exports.attemptAuthSessionCreateCommand = (0, _types.withBaseOptions)(_attempt_authsession.attemptAuthSessionCommand.command("create").description("Create a new auth session").argument("<parameters>", "Parameters for the auth session command").option("--id <id>", "ID of the auth session to use for the command. Defaults to ./auth-sessions-instances/[current timestamp].json")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([parameters], options) => {
+const attemptAuthSessionCreateCommand = exports.attemptAuthSessionCreateCommand = (0, _types.withBaseOptions)(_attempt_authsession.attemptAuthSessionCommand.command("create").description("Create a new AuthSession").argument("<parameters>", "Parameters for the AuthSession command").option("--id <id>", "ID of the AuthSession to use for the command. Defaults to ./auth-sessions-instances/[current timestamp].json")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([parameters], options) => {
   await (0, _helpers.assertAuthEnabled)();
   const authSessionInput = (await (0, _controller.loadParameters)(parameters)) ?? {};
   await (0, _authSession.executeAttemptCreateAuthSessionCLI)({

package/dist/commands/intuned-cli/commands/authsession.command.js

@@ -5,4 +5,4 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.authSessionCommand = void 0;
 var _command = require("./command");
-const authSessionCommand = exports.authSessionCommand = _command.program.command("authsession").description("Manage Auth Sessions");
+const authSessionCommand = exports.authSessionCommand = _command.program.command("authsession").description("Manage AuthSessions");

package/dist/commands/intuned-cli/commands/authsession_record.command.js

@@ -14,7 +14,7 @@ const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.ex
   id: _zod.z.string().optional()
 });
 const isAuthSessionRecorderEnabled = process.env.INTUNED_AUTH_SESSION_RECORDER_ENABLED === "true";
-const authSessionRecordCommand = exports.authSessionRecordCommand = isAuthSessionRecorderEnabled ? (0, _types.withBaseOptions)(_authsession.authSessionCommand.command("record").description("Record a new auth session").option("--id <id>", "ID of the auth session to use for the command. Defaults to auth-session-[current timestamp]").option("--check-attempts <number>", "Number of attempts to check the auth session validity", "1")).action((0, _helpers.cliCommandWrapper)(undefined, optionsSchema, async (_, {
+const authSessionRecordCommand = exports.authSessionRecordCommand = isAuthSessionRecorderEnabled ? (0, _types.withBaseOptions)(_authsession.authSessionCommand.command("record").description("Record a new AuthSession").option("--id <id>", "ID of the AuthSession to use for the command. Defaults to auth-session-[current timestamp]").option("--check-attempts <number>", "Number of attempts to check the AuthSession validity", "1")).action((0, _helpers.cliCommandWrapper)(undefined, optionsSchema, async (_, {
   checkAttempts,
   ...rest
 }) => {

package/dist/commands/intuned-cli/commands/authsession_scaffold.command.d.ts

@@ -0,0 +1 @@
+export declare const authSessionScaffoldCommand: import("commander").Command;

package/dist/commands/intuned-cli/commands/authsession_scaffold.command.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authSessionScaffoldCommand = void 0;
+var _zod = require("zod");
+var _helpers = require("../helpers");
+var _authsession = require("./authsession.command");
+var _types = require("./types");
+var _scaffold = require("../controller/scaffold");
+const optionsSchema = _zod.z.object({});
+const authSessionScaffoldCommand = exports.authSessionScaffoldCommand = (0, _types.withBaseOptions)(_authsession.authSessionCommand.command("scaffold").description("Scaffold AuthSession files")).action((0, _helpers.cliCommandWrapper)(undefined, optionsSchema, async _ => {
+  await (0, _helpers.assertAuthEnabled)();
+  await (0, _scaffold.scaffoldAuthSessionFiles)();
+}));

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

@@ -6,32 +6,36 @@ Object.defineProperty(exports, "__esModule", {
 exports.deployCommand = void 0;
 var _command = require("./command");
 var _dotenv = _interopRequireDefault(require("dotenv"));
-var _save = require("../controller/save");
+var _provision = require("../controller/provision");
 var _deploy = require("../controller/deploy");
 var _helpers = require("../helpers");
-var _save2 = require("./save.command");
+var _provision2 = require("./provision.command");
+var _prompts = require("../helpers/prompts");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 _dotenv.default.config({
   path: `.env`
 });
-const deployCommand = exports.deployCommand = _command.program.command("deploy").description("Save and deploy an Intuned project to the platform").argument("[project-name]", "Name of the project to deploy").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action((0, _helpers.cliCommandWrapper)(_save2.saveOrDeployArgsSchema, _save2.saveOrDeployOptionsSchema, async ([projectName], options) => {
+const deployCommand = exports.deployCommand = _command.program.command("deploy").description("Deploy an Intuned project to the platform").argument("[project-name]", "Name of the project to deploy").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action((0, _helpers.cliCommandWrapper)(_provision2.saveOrDeployArgsSchema, _provision2.saveOrDeployOptionsSchema, async ([projectName], options) => {
   const {
     isValid,
     errorMessage
-  } = await (0, _save.validateIntunedProject)();
+  } = await (0, _provision.validateIntunedProject)();
   if (!isValid) {
-    const message = `^r^+Project to be deployed is not a valid Intuned project:^:^R ${errorMessage}:\n`;
+    const message = `^r^+Project to be deployed is not valid:^:^R ${errorMessage}:\n`;
     throw new _helpers.CLIError(message, {
       autoColor: false
     });
   }
-  const _projectName = projectName || (await (0, _helpers.loadIntunedJson)()).projectName;
+  const _projectName = projectName || (await (0, _helpers.loadIntunedJson)()).projectName || (await (0, _prompts.promptForProjectName)(name => {
+    const result = (0, _provision.validateProjectName)(name);
+    return result.isValid || result.errorMessage;
+  }));
   if (!_projectName) {
-    throw new _helpers.CLIError("Project name is required");
+    throw new _helpers.CLIError(`Project name is required. Set it in ${await (0, _helpers.getIntunedSettingsFile)()} or provide it as an argument by running 'intuned deploy <project-name>'.`);
   }
-  const projectNameValidation = (0, _save.validateProjectName)(_projectName);
+  const projectNameValidation = (0, _provision.validateProjectName)(_projectName);
   if (!projectNameValidation.isValid) {
-    throw new _helpers.CLIError(projectNameValidation.errorMessage);
+    throw new _helpers.CLIError(`Invalid project name: ${projectNameValidation.errorMessage}`);
   }
   const auth = await (0, _helpers.getAuthCredentials)(options);
   await (0, _deploy.runDeployProject)(_projectName, auth);

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

@@ -1,8 +1,7 @@
 export * from "./command";
 export * from "./build.command";
 export * from "./deploy.command";
-export * from "./save.command";
-export * from "./init.command";
+export * from "./provision.command";
 export * from "./run.command";
 export * from "./run_api.command";
 export * from "./run_authsession.command";
@@ -16,3 +15,4 @@ export * from "./attempt_authsession_create.command";
 export * from "./attempt_authsession_check.command";
 export * from "./authsession.command";
 export * from "./authsession_record.command";
+export * from "./authsession_scaffold.command";

package/dist/commands/intuned-cli/commands/index.js

@@ -36,25 +36,14 @@ Object.keys(_deploy).forEach(function (key) {
     }
   });
 });
-var _save = require("./save.command");
-Object.keys(_save).forEach(function (key) {
+var _provision = require("./provision.command");
+Object.keys(_provision).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _save[key]) return;
+  if (key in exports && exports[key] === _provision[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _save[key];
-    }
-  });
-});
-var _init = require("./init.command");
-Object.keys(_init).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _init[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _init[key];
+      return _provision[key];
     }
   });
 });
@@ -200,4 +189,15 @@ Object.keys(_authsession_record).forEach(function (key) {
       return _authsession_record[key];
     }
   });
+});
+var _authsession_scaffold = require("./authsession_scaffold.command");
+Object.keys(_authsession_scaffold).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _authsession_scaffold[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _authsession_scaffold[key];
+    }
+  });
 });

package/dist/commands/intuned-cli/commands/{save.command.d.ts → provision.command.d.ts}

@@ -10,4 +10,4 @@ export declare const saveOrDeployOptionsSchema: z.ZodObject<{
     workspaceId?: string | undefined;
     apiKey?: string | undefined;
 }>;
-export declare const saveCommand: import("commander").Command;
+export declare const provisionCommand: import("commander").Command, saveCommand: import("commander").Command;

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

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.saveOrDeployOptionsSchema = exports.saveOrDeployArgsSchema = exports.saveCommand = exports.provisionCommand = void 0;
+var _command = require("./command");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _provision = require("../controller/provision");
+var _helpers = require("../helpers");
+var _zod = require("zod");
+var _prompts = require("../helpers/prompts");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+const saveOrDeployArgsSchema = exports.saveOrDeployArgsSchema = _zod.z.tuple([_zod.z.union([_zod.z.string(), _zod.z.undefined()])]);
+const saveOrDeployOptionsSchema = exports.saveOrDeployOptionsSchema = _zod.z.object({
+  workspaceId: _zod.z.string().optional(),
+  apiKey: _zod.z.string().optional()
+});
+const description = "Provision an Intuned project to the platform";
+const commands = [_command.program.command("save").description(`${description}. (Deprecated, use 'provision' instead)`), _command.program.command("provision").description(description)];
+const [provisionCommand, saveCommand] = commands.map(command => command.argument("[project-name]", "Project name").option("-w, --workspace-id <id>", "Intuned Workspace ID").option("-k, --api-key <key>", "Intuned API key").action((0, _helpers.cliCommandWrapper)(saveOrDeployArgsSchema, saveOrDeployOptionsSchema, async ([projectName], options) => {
+  const {
+    isValid,
+    errorMessage
+  } = await (0, _provision.validateIntunedProject)();
+  if (!isValid) {
+    const message = `^r^+Project to be provisioned is not a valid Intuned project:^:^R ${errorMessage}:\n`;
+    throw new _helpers.CLIError(message, {
+      autoColor: false
+    });
+  }
+  const _projectName = projectName || (await (0, _helpers.loadIntunedJson)()).projectName || (await (0, _prompts.promptForProjectName)(name => {
+    const result = (0, _provision.validateProjectName)(name);
+    return result.isValid || result.errorMessage;
+  }));
+  if (!_projectName) {
+    throw new _helpers.CLIError(`Project name is required. Set it in ${await (0, _helpers.getIntunedSettingsFile)()} or provide it as an argument by running 'intuned provision <project-name>'.`);
+  }
+  const projectNameValidation = (0, _provision.validateProjectName)(_projectName);
+  if (!projectNameValidation.isValid) {
+    throw new _helpers.CLIError(`Invalid project name: ${projectNameValidation.errorMessage}`);
+  }
+  const auth = await (0, _helpers.getAuthCredentials)(options);
+  await (0, _provision.runProvisionProject)(_projectName, auth);
+})));
+exports.saveCommand = saveCommand;
+exports.provisionCommand = provisionCommand;

package/dist/commands/intuned-cli/commands/run_api.command.js

@@ -19,7 +19,7 @@ const optionsSchema = _types.baseCommandOptionsSchema.extend({
   authSessionCheckAttempts: _types.authSessionCheckAttemptsSchema,
   authSessionCreateAttempts: _types.authSessionCreateAttemptsSchema
 });
-const runApiCommand = exports.runApiCommand = (0, _types.withBaseOptions)(_run.runCommand.command("api").description("Execute an Intuned API run with parameters").argument("<api-name>", "Name of the API to run").argument("<parameters>", "Path to the JSON file containing API parameters OR the parameters as a JSON string").option("-a, --auth-session <id>", "ID of the auth session to use for the API. This is expected to be in ./auth-sessions-instances/<id>").option("--retries <number>", "Number of retries for the API call", "1").option("--no-auth-session-auto-recreate", "disable auto recreate for auth session").option("--auth-session-check-attempts <number>", "auth session check attempts", "1").option("--auth-session-create-attempts <number>", "auth session create attempts", "1").option("-o, --output-file <path>", "output file path")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([apiName, parameters], {
+const runApiCommand = exports.runApiCommand = (0, _types.withBaseOptions)(_run.runCommand.command("api").description("Execute an Intuned API run with parameters").argument("<api-name>", "Name of the API to run").argument("<parameters>", "Path to the JSON file containing API parameters OR the parameters as a JSON string").option("-a, --auth-session <id>", "ID of the AuthSession to use for the API. This is expected to be in ./auth-sessions-instances/<id>").option("--retries <number>", "Number of retries for the API call", "1").option("--no-auth-session-auto-recreate", "disable auto recreate for AuthSession").option("--auth-session-check-attempts <number>", "AuthSession check attempts", "1").option("--auth-session-create-attempts <number>", "AuthSession create attempts", "1").option("-o, --output-file <path>", "output file path")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([apiName, parameters], {
   retries,
   outputFile,
   authSession,

package/dist/commands/intuned-cli/commands/run_authsession.command.d.ts

@@ -1,16 +1,16 @@
 import { Command } from "commander";
 export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodObject<{
     proxy: import("zod").ZodOptional<import("zod").ZodString>;
-    trace: import("zod").ZodDefault<import("zod").ZodBoolean>;
     timeout: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodString>, import("ms").StringValue, string | undefined>, number, string | undefined>;
+    trace: import("zod").ZodDefault<import("zod").ZodBoolean>;
     headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
     keepBrowserOpen: import("zod").ZodDefault<import("zod").ZodBoolean>;
     cdpUrl: import("zod").ZodOptional<import("zod").ZodString>;
     checkAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
     createAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, "strip", import("zod").ZodTypeAny, {
-    trace: boolean;
     timeout: number;
+    trace: boolean;
     headless: boolean;
     keepBrowserOpen: boolean;
     checkAttempts: number;
@@ -19,8 +19,8 @@ export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodOb
     cdpUrl?: string | undefined;
 }, {
     proxy?: string | undefined;
-    trace?: boolean | undefined;
     timeout?: string | undefined;
+    trace?: boolean | undefined;
     headless?: boolean | undefined;
     keepBrowserOpen?: boolean | undefined;
     cdpUrl?: string | undefined;

package/dist/commands/intuned-cli/commands/run_authsession.command.js

@@ -11,7 +11,7 @@ const baseRunAuthSessionCommandOptionsSchema = exports.baseRunAuthSessionCommand
   checkAttempts: _types.authSessionCheckAttemptsSchema,
   createAttempts: _types.authSessionCreateAttemptsSchema
 });
-const runAuthSessionCommand = exports.runAuthSessionCommand = _run.runCommand.command("authsession").description("Manage authentication sessions");
+const runAuthSessionCommand = exports.runAuthSessionCommand = _run.runCommand.command("authsession").description("Execute AuthSession Runs");
 function withAuthSessionBaseOptions(command) {
-  return (0, _types.withBaseOptions)(command.option("--check-attempts <number>", "Number of attempts to check the auth session validity", "1").option("--create-attempts <number>", "Number of attempts to create a new auth session if it is invalid", "1"));
+  return (0, _types.withBaseOptions)(command.option("--check-attempts <number>", "Number of attempts to check the AuthSession validity", "1").option("--create-attempts <number>", "Number of attempts to create a new AuthSession if it is invalid", "1"));
 }

package/dist/commands/intuned-cli/commands/run_authsession_create.command.js

@@ -15,7 +15,7 @@ const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.ex
   id: _zod.z.string().optional()
 });
 const commands = [_run_authsession.runAuthSessionCommand.command("create"), _authsession.authSessionCommand.command("create")];
-const [runAuthSessionCreateCommand, authSessionCreateCommand] = commands.map(command => (0, _run_authsession.withAuthSessionBaseOptions)(command.description("Create a new auth session").argument("<parameters>", "Parameters for the auth session command").option("--id <id>", "ID of the auth session to use for the command. Defaults to auth-session-[current timestamp]")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([parameters], {
+const [runAuthSessionCreateCommand, authSessionCreateCommand] = commands.map(command => (0, _run_authsession.withAuthSessionBaseOptions)(command.description("Create a new AuthSession").argument("<parameters>", "Parameters for the AuthSession command").option("--id <id>", "ID of the AuthSession to use for the command. Defaults to auth-session-[current timestamp]")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([parameters], {
   checkAttempts,
   createAttempts,
   id,

package/dist/commands/intuned-cli/commands/run_authsession_update.command.js

@@ -10,12 +10,12 @@ var _authSession = require("../controller/authSession");
 var _run_authsession = require("./run_authsession.command");
 var _helpers = require("../helpers");
 var _authsession = require("./authsession.command");
-const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required")]);
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the AuthSession is required")]);
 const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
   parameters: _zod.z.string().optional()
 });
 const commands = [_run_authsession.runAuthSessionCommand.command("update"), _authsession.authSessionCommand.command("update")];
-const [runAuthSessionUpdateCommand, authSessionUpdateCommand] = commands.map(command => (0, _run_authsession.withAuthSessionBaseOptions)(command.description("Update an existing auth session").argument("<id>", "ID of the auth session to update").option("--parameters <parameters>", "Parameters for the auth session command. If not provided, it will use the existing parameters")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([id], {
+const [runAuthSessionUpdateCommand, authSessionUpdateCommand] = commands.map(command => (0, _run_authsession.withAuthSessionBaseOptions)(command.description("Update an existing AuthSession").argument("<id>", "ID of the AuthSession to update").option("--parameters <parameters>", "Parameters for the AuthSession command. If not provided, it will use the existing parameters")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([id], {
   checkAttempts,
   createAttempts,
   parameters,

package/dist/commands/intuned-cli/commands/run_authsession_validate.command.js

@@ -9,12 +9,12 @@ var _authSession = require("../controller/authSession");
 var _run_authsession = require("./run_authsession.command");
 var _helpers = require("../helpers");
 var _authsession = require("./authsession.command");
-const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required")]);
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the AuthSession is required")]);
 const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
   autoRecreate: _zod.z.boolean().default(true)
 });
 const commands = [_run_authsession.runAuthSessionCommand.command("validate"), _authsession.authSessionCommand.command("validate")];
-const [runAuthSessionValidateCommand, authSessionValidateCommand] = commands.map(command => (0, _run_authsession.withAuthSessionBaseOptions)(command.description("Validate an existing auth session").argument("<id>", "ID of the auth session to validate").option("--no-auto-recreate", "Disable auto recreation of the auth session if it is invalid")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([id], {
+const [runAuthSessionValidateCommand, authSessionValidateCommand] = commands.map(command => (0, _run_authsession.withAuthSessionBaseOptions)(command.description("Validate an existing AuthSession").argument("<id>", "ID of the AuthSession to validate").option("--no-auto-recreate", "Disable auto recreation of the AuthSession if it is invalid")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([id], {
   autoRecreate,
   checkAttempts,
   createAttempts,

package/dist/commands/intuned-cli/commands/types.d.ts

@@ -17,8 +17,8 @@ export declare const baseCommandOptionsSchema: z.ZodObject<{
     keepBrowserOpen: z.ZodDefault<z.ZodBoolean>;
     cdpUrl: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    trace: boolean;
     timeout: number;
+    trace: boolean;
     headless: boolean;
     keepBrowserOpen: boolean;
     proxy?: string | undefined;

package/dist/commands/intuned-cli/commands/types.js

@@ -8,8 +8,8 @@ exports.withBaseOptions = withBaseOptions;
 var _ms = _interopRequireDefault(require("ms"));
 var _zod = require("zod");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const authSessionCheckAttemptsSchema = exports.authSessionCheckAttemptsSchema = _zod.z.coerce.number().int().min(1, "Auth session check attempts must be at least 1").default(1);
-const authSessionCreateAttemptsSchema = exports.authSessionCreateAttemptsSchema = _zod.z.coerce.number().int().min(1, "Auth session create attempts must be at least 1").default(1);
+const authSessionCheckAttemptsSchema = exports.authSessionCheckAttemptsSchema = _zod.z.coerce.number().int().min(1, "AuthSession check attempts must be at least 1").default(1);
+const authSessionCreateAttemptsSchema = exports.authSessionCreateAttemptsSchema = _zod.z.coerce.number().int().min(1, "AuthSession create attempts must be at least 1").default(1);
 const proxySchema = exports.proxySchema = _zod.z.string().url("--proxy must be a valid URL").optional();
 const timeoutSchema = exports.timeoutSchema = _zod.z.string().default("10 mins").refine(val => {
   return (0, _ms.default)(val) !== undefined;

package/dist/commands/intuned-cli/controller/__test__/api.test.js

@@ -15,6 +15,7 @@ function getTerminal() {
   });
 }
 _vitest.vi.mock("fs-extra", () => ({
+  ensureDir: _vitest.vi.fn(),
   writeJSON: _vitest.vi.fn(),
   exists: _vitest.vi.fn().mockResolvedValue(true)
 }));
@@ -251,7 +252,7 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
       });
       (0, _vitest.expect)(_runApi.runApi).toHaveBeenCalledTimes(2);
     });
-    (0, _vitest.it)("validates auth session before each attempt if provided", async () => {
+    (0, _vitest.it)("validates AuthSession before each attempt if provided", async () => {
       _vitest.vi.mocked(_runApi.runApi).mockResolvedValueOnce((0, _neverthrow.err)(new _runApi.AutomationError("runApi failed"))).mockResolvedValue((0, _neverthrow.ok)({
         result: "success"
       }));
@@ -274,7 +275,7 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
         createRetries: 2
       }));
     });
-    (0, _vitest.it)("doesn't validate auth session if not provided", async () => {
+    (0, _vitest.it)("doesn't validate AuthSession if not provided", async () => {
       _vitest.vi.mocked(_runApi.runApi).mockResolvedValue((0, _neverthrow.ok)({
         result: "success"
       }));
@@ -285,8 +286,8 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
       });
       (0, _vitest.expect)(_authSession.executeRunValidateAuthSessionCLI).not.toHaveBeenCalled();
     });
-    (0, _vitest.it)("fails if auth session is provided but not valid", async () => {
-      _vitest.vi.mocked(_authSession.executeRunValidateAuthSessionCLI).mockRejectedValue(new _helpers.CLIError("Auth session validation failed"));
+    (0, _vitest.it)("fails if AuthSession is provided but not valid", async () => {
+      _vitest.vi.mocked(_authSession.executeRunValidateAuthSessionCLI).mockRejectedValue(new _helpers.CLIError("AuthSession validation failed"));
       await (0, _vitest.expect)((0, _api.executeRunApiCLI)({
         apiName: "testApi",
         inputData: {},
@@ -297,7 +298,7 @@ _vitest.vi.mock("../../helpers", async importOriginal => {
           createRetries: 2
         },
         retries: 10
-      })).rejects.toThrow("Auth session validation failed");
+      })).rejects.toThrow("AuthSession validation failed");
       (0, _vitest.expect)(_authSession.executeRunValidateAuthSessionCLI).toHaveBeenCalledWith(_vitest.expect.objectContaining({
         id: "authSessionId",
         autoRecreate: false,