@intuned/runtime-dev 1.3.4-dev.3 → 1.3.4-enhancements.0

package/dist/commands/api/run.js

@@ -52,8 +52,7 @@ async function executeCLI(apiName, mode, inputData, options) {
     } : undefined,
     runOptions: {
       environment: "cdp",
-      cdpAddress: options.cdpAddress,
-      mode
+      cdpAddress: options.cdpAddress
     },
     importFunction: _tsNodeImport.tsNodeImport
   });

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

@@ -47,7 +47,6 @@ _commander.program.description("run auth session check").option("--cdpAddress <c
     },
     runOptions: {
       environment: "cdp",
-      mode,
       cdpAddress
     },
     auth: {

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

@@ -48,7 +48,6 @@ _commander.program.description("run auth session create").option("--cdpAddress <
       },
       runOptions: {
         environment: "cdp",
-        mode,
         cdpAddress
       },
       retrieveSession: true,

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"];
+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/**"];
 var _default = exports.default = exclusions;

package/dist/commands/common/tsNodeImport.js

@@ -20,7 +20,7 @@ const tsNodeImport = async apiName => {
     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") {
+    if ("code" in e && e.code.includes("MODULE_NOT_FOUND")) {
       return (0, _neverthrow.err)({
         type: "not_found"
       });

package/dist/commands/common/utils/settings.js

@@ -6,15 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.getSettings = getSettings;
 var _fileUtils = require("./fileUtils");
 var _settingsSchema = require("../../../common/settingsSchema");
-var _promises = require("fs/promises");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 async function getSettings() {
   const settingsFilePath = (0, _fileUtils.getFullPathInProject)("Intuned.json");
-  console.log("loading settings");
-  const settings = await (0, _promises.readFile)(settingsFilePath, {
-    encoding: "utf-8"
-  });
-  if (settings) {
-    const parsed = _settingsSchema.settingsSchema.safeParse(JSON.parse(settings));
+  const settings = await (specifier => new Promise(r => r(`${specifier}`)).then(s => _interopRequireWildcard(require(s))))(settingsFilePath);
+  if (settings.default) {
+    const parsed = _settingsSchema.settingsSchema.safeParse(settings.default);
     if (parsed.success) {
       return parsed.data;
     } else {

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

@@ -10,31 +10,21 @@ var _zod = require("zod");
 var _types = require("./types");
 var _helpers = require("../helpers");
 var _attempt = require("./attempt.command");
-const attemptApiCommandInputSchema = _zod.z.tuple([_zod.z.string().min(1, "API name is required"), _zod.z.string().min(1, "Parameters are required"), _types.baseCommandOptionsSchema.extend({
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "API name is required"), _zod.z.string().min(1, "Parameters are required")]);
+const optionsSchema = _types.baseCommandOptionsSchema.extend({
   authSession: _zod.z.string().optional(),
   outputFile: _zod.z.string().optional()
-})]);
-const attemptApiCommand = exports.attemptApiCommand = _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-session-instances/<id>.json").option("--proxy <url>", "proxy URL to use").option("--timeout <time>", "timeout - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the API in headless mode (default: false). This will not open a browser window.").option("-o, --output-file <path>", "output file path").action((0, _helpers.withErrorLogging)(async (inputApiName, inputParameters, inputOptions) => {
-  const parseResult = attemptApiCommandInputSchema.safeParse([inputApiName, inputParameters, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [apiName, parameters, {
-    headless,
-    authSession,
-    outputFile,
-    timeout,
-    proxy
-  }] = parseResult.data;
+});
+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-session-instances/<id>.json").option("-o, --output-file <path>", "output file path")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([apiName, parameters], {
+  authSession,
+  ...rest
+}) => {
   await (0, _helpers.assertAuthConsistent)(authSession);
-  const inputData = await (0, _controller.loadParameters)(parameters);
+  const parametersData = await (0, _controller.loadParameters)(parameters);
   await (0, _api.executeAttemptApiCLI)({
     apiName,
-    inputData: inputData,
+    inputData: parametersData,
     authSessionId: authSession,
-    proxy,
-    headless,
-    timeout,
-    outputFile
+    ...rest
   });
 }));

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

@@ -9,13 +9,8 @@ var _authSession = require("../controller/authSession");
 var _attempt_authsession = require("./attempt_authsession.command");
 var _helpers = require("../helpers");
 var _types = require("./types");
-const attemptAuthSessionCheckSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required"), _types.baseCommandOptionsSchema]);
-const attemptAuthSessionCheckCommand = exports.attemptAuthSessionCheckCommand = _attempt_authsession.attemptAuthSessionCommand.command("check").description("Check an existing auth session").argument("<id>", "ID of the auth session to check").option("--proxy <url>", "Proxy URL to use for the auth session command").option("--timeout <time>", "Timeout for the auth session command - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the API in headless mode (default: false). This will not open a browser window.").action((0, _helpers.withErrorLogging)(async (inputId, inputOptions) => {
-  const parseResult = attemptAuthSessionCheckSchema.safeParse([inputId, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [id, options] = parseResult.data;
+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) => {
   await (0, _helpers.assertAuthEnabled)();
   await (0, _authSession.executeAttemptCheckAuthSessionCLI)({
     id,

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

@@ -10,27 +10,15 @@ var _authSession = require("../controller/authSession");
 var _attempt_authsession = require("./attempt_authsession.command");
 var _helpers = require("../helpers");
 var _types = require("./types");
-const attemptAuthSessionCreateInputSchema = _zod.z.tuple([_zod.z.string().min(1, "Parameters are required"), _types.baseCommandOptionsSchema.extend({
+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 = _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-session-instances/[current timestamp].json").option("--proxy <url>", "Proxy URL to use for the auth session command").option("--timeout <time>", "Timeout for the auth session command - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the API in headless mode (default: false). This will not open a browser window.").action((0, _helpers.withErrorLogging)(async (inputParameters, inputOptions) => {
-  const parseResult = attemptAuthSessionCreateInputSchema.safeParse([inputParameters, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [parameters, {
-    headless,
-    id,
-    timeout,
-    proxy
-  }] = parseResult.data;
+});
+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-session-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)({
-    id,
     input: authSessionInput,
-    headless,
-    timeout,
-    proxy
+    ...options
   });
 }));

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authSessionCommand = void 0;
+var _command = require("./command");
+const authSessionCommand = exports.authSessionCommand = _command.program.command("authsession").description("Manage Auth Sessions");

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authSessionRecordCommand = void 0;
+var _zod = require("zod");
+var _authSession = require("../controller/authSession");
+var _helpers = require("../helpers");
+var _authsession = require("./authsession.command");
+var _run_authsession = require("./run_authsession.command");
+var _types = require("./types");
+const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
+  id: _zod.z.string().optional()
+});
+const authSessionRecordCommand = exports.authSessionRecordCommand = (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 (_, {
+  checkAttempts,
+  ...rest
+}) => {
+  await (0, _helpers.assertAuthEnabled)();
+  const {
+    startUrl,
+    finishUrl
+  } = await (0, _helpers.getAuthSessionRecorderParameters)();
+  await (0, _authSession.executeRecordAuthSessionCLI)({
+    checkRetries: checkAttempts,
+    startUrl,
+    finishUrl,
+    ...rest
+  });
+}));

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

@@ -7,6 +7,6 @@ exports.buildCommand = void 0;
 var _command = require("./command");
 var _build = require("../controller/build");
 var _helpers = require("../helpers");
-const buildCommand = exports.buildCommand = _command.program.command("build").description("Build Intuned project").action((0, _helpers.withErrorLogging)(async () => {
+const buildCommand = exports.buildCommand = _command.program.command("build").description("Build Intuned project").action((0, _helpers.cliCommandWrapper)(undefined, undefined, async () => {
   await (0, _build.runBuild)();
 }));

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

@@ -14,12 +14,7 @@ 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.withErrorLogging)(async (inputProjectName, inputOptions) => {
-  const parseResult = _save2.saveOrDeployCommandSchema.safeParse([inputProjectName, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [projectName, options] = parseResult.data;
+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 {
     isValid,
     errorMessage
@@ -30,7 +25,7 @@ const deployCommand = exports.deployCommand = _command.program.command("deploy")
       autoColor: false
     });
   }
-  const _projectName = projectName || (await (0, _helpers.getSettingIntunedJSON)("projectName"));
+  const _projectName = projectName || (await (0, _helpers.loadIntunedJson)()).projectName;
   if (!_projectName) {
     throw new _helpers.CLIError("Project name is required");
   }

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

@@ -14,3 +14,5 @@ export * from "./attempt_api.command";
 export * from "./attempt_authsession.command";
 export * from "./attempt_authsession_create.command";
 export * from "./attempt_authsession_check.command";
+export * from "./authsession.command";
+export * from "./authsession_record.command";

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

@@ -178,4 +178,26 @@ Object.keys(_attempt_authsession_check).forEach(function (key) {
       return _attempt_authsession_check[key];
     }
   });
+});
+var _authsession = require("./authsession.command");
+Object.keys(_authsession).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _authsession[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _authsession[key];
+    }
+  });
+});
+var _authsession_record = require("./authsession_record.command");
+Object.keys(_authsession_record).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _authsession_record[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _authsession_record[key];
+    }
+  });
 });

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

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.initCommand = void 0;
 var _command = require("./command");
 var _helpers = require("../helpers");
-const initCommand = exports.initCommand = _command.program.command("init").description("Deprecated: Initialize a new Intuned project").allowExcessArguments(true).allowUnknownOption(true).action((0, _helpers.withErrorLogging)(async () => {
+const initCommand = exports.initCommand = _command.program.command("init").description("Deprecated: Initialize a new Intuned project").allowExcessArguments(true).allowUnknownOption(true).action((0, _helpers.cliCommandWrapper)(undefined, undefined, async () => {
   throw new _helpers.CLIError("^r^+The init command has been deprecated. Please use^ ^c^/npx create-intuned-project^ ^r^+instead.^:", {
     autoColor: false
   });

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

@@ -10,30 +10,24 @@ var _controller = require("../controller");
 var _zod = require("zod");
 var _types = require("./types");
 var _helpers = require("../helpers");
-const runApiCommandInputSchema = _zod.z.tuple([_zod.z.string().min(1, "API name is required"), _zod.z.string().min(1, "Parameters are required"), _types.baseCommandOptionsSchema.extend({
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "API name is required"), _zod.z.string().min(1, "Parameters are required")]);
+const optionsSchema = _types.baseCommandOptionsSchema.extend({
   retries: _zod.z.coerce.number().default(1),
   authSession: _zod.z.string().optional(),
   authSessionAutoRecreate: _zod.z.boolean().default(true),
   outputFile: _zod.z.string().optional(),
   authSessionCheckAttempts: _types.authSessionCheckAttemptsSchema,
   authSessionCreateAttempts: _types.authSessionCreateAttemptsSchema
-})]);
-const runApiCommand = exports.runApiCommand = _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-session-instances/<id>").option("--retries <number>", "Number of retries for the API call", "1").option("--proxy <url>", "proxy URL to use").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("--timeout <time>", "timeout - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the API in headless mode (default: false). This will not open a browser window.").option("-o, --output-file <path>", "output file path").action((0, _helpers.withErrorLogging)(async (inputApiName, inputParameters, inputOptions) => {
-  const parseResult = runApiCommandInputSchema.safeParse([inputApiName, inputParameters, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [apiName, parameters, {
-    retries,
-    headless,
-    timeout,
-    outputFile,
-    proxy,
-    authSession,
-    authSessionAutoRecreate,
-    authSessionCreateAttempts,
-    authSessionCheckAttempts
-  }] = parseResult.data;
+});
+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-session-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], {
+  retries,
+  outputFile,
+  authSession,
+  authSessionAutoRecreate,
+  authSessionCreateAttempts,
+  authSessionCheckAttempts,
+  ...rest
+}) => {
   await (0, _helpers.assertAuthConsistent)(authSession);
   const inputData = await (0, _controller.loadParameters)(parameters);
   await (0, _api.executeRunApiCLI)({
@@ -47,8 +41,6 @@ const runApiCommand = exports.runApiCommand = _run.runCommand.command("api").des
     } : undefined,
     retries,
     outputFile,
-    proxy,
-    headless,
-    timeout
+    ...rest
   });
 }));

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

@@ -1,20 +1,28 @@
+import { Command } from "commander";
 export declare const baseRunAuthSessionCommandOptionsSchema: import("zod").ZodObject<{
     proxy: import("zod").ZodOptional<import("zod").ZodString>;
     headless: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    keepBrowserOpen: 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>;
     checkAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
     createAttempts: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, "strip", import("zod").ZodTypeAny, {
     headless: boolean;
+    keepBrowserOpen: boolean;
     timeout: number;
+    trace: boolean;
     checkAttempts: number;
     createAttempts: number;
     proxy?: string | undefined;
 }, {
     proxy?: string | undefined;
     headless?: boolean | undefined;
+    keepBrowserOpen?: boolean | undefined;
     timeout?: string | undefined;
+    trace?: boolean | undefined;
     checkAttempts?: number | undefined;
     createAttempts?: number | undefined;
 }>;
-export declare const runAuthSessionCommand: import("commander").Command;
+export declare const runAuthSessionCommand: Command;
+export declare function withAuthSessionBaseOptions(command: Command): Command;

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

@@ -4,10 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.runAuthSessionCommand = exports.baseRunAuthSessionCommandOptionsSchema = void 0;
+exports.withAuthSessionBaseOptions = withAuthSessionBaseOptions;
 var _types = require("./types");
 var _run = require("./run.command");
 const baseRunAuthSessionCommandOptionsSchema = exports.baseRunAuthSessionCommandOptionsSchema = _types.baseCommandOptionsSchema.extend({
   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("Manage authentication sessions");
+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"));
+}

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

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

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

@@ -3,28 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.runAuthSessionCreateCommand = void 0;
+exports.runAuthSessionCreateCommand = exports.authSessionCreateCommand = void 0;
 var _controller = require("../controller");
 var _zod = require("zod");
 var _authSession = require("../controller/authSession");
 var _run_authsession = require("./run_authsession.command");
 var _helpers = require("../helpers");
-const runAuthSessionCreateInputSchema = _zod.z.tuple([_zod.z.string().min(1, "Parameters are required"), _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
+var _authsession = require("./authsession.command");
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "Parameters are required")]);
+const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
   id: _zod.z.string().optional()
-})]);
-const runAuthSessionCreateCommand = exports.runAuthSessionCreateCommand = _run_authsession.runAuthSessionCommand.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-session-[current timestamp]").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").option("--proxy <url>", "Proxy URL to use for the auth session command").option("--timeout <time>", "Timeout for the auth session command - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the API in headless mode (default: false). This will not open a browser window.").action((0, _helpers.withErrorLogging)(async (inputParameters, inputOptions) => {
-  const parseResult = runAuthSessionCreateInputSchema.safeParse([inputParameters, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [parameters, {
-    checkAttempts,
-    createAttempts,
-    id,
-    proxy,
-    timeout,
-    headless
-  }] = parseResult.data;
+});
+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], {
+  checkAttempts,
+  createAttempts,
+  id,
+  ...rest
+}) => {
   await (0, _helpers.assertAuthEnabled)();
   const authSessionInput = (await (0, _controller.loadParameters)(parameters)) ?? {};
   await (0, _authSession.executeRunCreateAuthSessionCLI)({
@@ -32,8 +28,8 @@ const runAuthSessionCreateCommand = exports.runAuthSessionCreateCommand = _run_a
     checkRetries: checkAttempts,
     createRetries: createAttempts,
     input: authSessionInput,
-    headless,
-    proxy,
-    timeout
+    ...rest
   });
-}));
+})));
+exports.authSessionCreateCommand = authSessionCreateCommand;
+exports.runAuthSessionCreateCommand = runAuthSessionCreateCommand;

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

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

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

@@ -3,28 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.runAuthSessionUpdateCommand = void 0;
+exports.runAuthSessionUpdateCommand = exports.authSessionUpdateCommand = void 0;
 var _controller = require("../controller");
 var _zod = require("zod");
 var _authSession = require("../controller/authSession");
 var _run_authsession = require("./run_authsession.command");
 var _helpers = require("../helpers");
-const runAuthSessionUpdateSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required"), _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
+var _authsession = require("./authsession.command");
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required")]);
+const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
   parameters: _zod.z.string().optional()
-})]);
-const runAuthSessionUpdateCommand = exports.runAuthSessionUpdateCommand = _run_authsession.runAuthSessionCommand.command("update").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").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").option("--proxy <url>", "Proxy URL to use for the auth session command").option("--timeout <time>", "Timeout for the auth session command - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the API in headless mode (default: false). This will not open a browser window.").action((0, _helpers.withErrorLogging)(async (inputId, inputOptions) => {
-  const parseResult = runAuthSessionUpdateSchema.safeParse([inputId, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [id, {
-    checkAttempts,
-    createAttempts,
-    parameters,
-    proxy,
-    timeout,
-    headless
-  }] = parseResult.data;
+});
+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], {
+  checkAttempts,
+  createAttempts,
+  parameters,
+  ...rest
+}) => {
   await (0, _helpers.assertAuthEnabled)();
   const authSessionInput = parameters ? await (0, _controller.loadParameters)(parameters) : undefined;
   await (0, _authSession.executeRunUpdateAuthSessionCLI)({
@@ -32,8 +28,8 @@ const runAuthSessionUpdateCommand = exports.runAuthSessionUpdateCommand = _run_a
     input: authSessionInput,
     checkRetries: checkAttempts,
     createRetries: createAttempts,
-    headless,
-    proxy,
-    timeout
+    ...rest
   });
-}));
+})));
+exports.authSessionUpdateCommand = authSessionUpdateCommand;
+exports.runAuthSessionUpdateCommand = runAuthSessionUpdateCommand;

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

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

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

@@ -3,35 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.runAuthSessionValidateCommand = void 0;
+exports.runAuthSessionValidateCommand = exports.authSessionValidateCommand = void 0;
 var _zod = require("zod");
 var _authSession = require("../controller/authSession");
 var _run_authsession = require("./run_authsession.command");
 var _helpers = require("../helpers");
-const runAuthSessionValidateSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required"), _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
+var _authsession = require("./authsession.command");
+const argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the auth session is required")]);
+const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
   autoRecreate: _zod.z.boolean().default(true)
-})]);
-const runAuthSessionValidateCommand = exports.runAuthSessionValidateCommand = _run_authsession.runAuthSessionCommand.command("validate").description("Validate an existing auth session").argument("<id>", "ID of the auth session to validate").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").option("--proxy <url>", "Proxy URL to use for the auth session command").option("--timeout <time>", "Timeout for the auth session command - milliseconds or ms-formatted string", "10 mins").option("--no-auto-recreate", "Disable auto recreation of the auth session if it is invalid").option("--headless", "Run the API in headless mode (default: false). This will not open a browser window.").action((0, _helpers.withErrorLogging)(async (inputId, inputOptions) => {
-  const parseResult = runAuthSessionValidateSchema.safeParse([inputId, inputOptions]);
-  if (!parseResult.success) {
-    return (0, _helpers.logInvalidInput)(parseResult);
-  }
-  const [id, {
-    autoRecreate,
-    checkAttempts,
-    createAttempts,
-    headless,
-    proxy,
-    timeout
-  }] = parseResult.data;
+});
+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], {
+  autoRecreate,
+  checkAttempts,
+  createAttempts,
+  ...rest
+}) => {
   await (0, _helpers.assertAuthEnabled)();
   await (0, _authSession.executeRunValidateAuthSessionCLI)({
     id,
     autoRecreate,
     checkRetries: checkAttempts,
     createRetries: createAttempts,
-    headless,
-    proxy,
-    timeout
+    ...rest
   });
-}));
+})));
+exports.authSessionValidateCommand = authSessionValidateCommand;
+exports.runAuthSessionValidateCommand = runAuthSessionValidateCommand;

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
-export declare const saveOrDeployCommandSchema: z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodUndefined]>, z.ZodObject<{
+export declare const saveOrDeployArgsSchema: z.ZodTuple<[z.ZodUnion<[z.ZodString, z.ZodUndefined]>], null>;
+export declare const saveOrDeployOptionsSchema: z.ZodObject<{
     workspaceId: z.ZodOptional<z.ZodString>;
     apiKey: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -8,5 +9,5 @@ export declare const saveOrDeployCommandSchema: z.ZodTuple<[z.ZodUnion<[z.ZodStr
 }, {
     workspaceId?: string | undefined;
     apiKey?: string | undefined;
-}>], null>;
+}>;
 export declare const saveCommand: import("commander").Command;