@intuned/runtime 1.1.6 → 1.3.0

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # UNRELEASED
 
--
+# 1.3.0
+- Limit Automation response size to 2MB at MAX.
+
+# 1.2.0
+
+- Release CLI v1
 
 # 1.0.3
 

package/bin/intuned

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../dist/commands/intuned-cli/main.js");

package/dist/commands/api/run.js

@@ -18,6 +18,7 @@ var _chalk = _interopRequireDefault(require("chalk"));
 var _runApi = require("../../common/runApi");
 var _tsNodeImport = require("../common/tsNodeImport");
 var _isNil = _interopRequireDefault(require("lodash/isNil"));
+var _constants = require("../../common/constants");
 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; }
@@ -40,7 +41,7 @@ async function executeCLI(apiName, mode, inputData, options) {
   }
   const runApiResult = await (0, _runApi.runApi)({
     automationFunction: {
-      name: `api/${apiName}`,
+      name: `${_constants.API_FOLDER_NAME}/${apiName}`,
       params: inputData
     },
     auth: authSessionPathToUse ? {

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attemptCommand = void 0;
+var _command = require("./command");
+const attemptCommand = exports.attemptCommand = _command.program.command("attempt").description("Execute an Intuned attempt");

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attemptApiCommand = void 0;
+var _api = require("../controller/api");
+var _controller = require("../controller");
+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({
+  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;
+  await (0, _helpers.assertAuthConsistent)(authSession);
+  const inputData = await (0, _controller.loadParameters)(parameters);
+  await (0, _api.executeAttemptApiCLI)({
+    apiName,
+    inputData: inputData,
+    authSessionId: authSession,
+    proxy,
+    headless,
+    timeout,
+    outputFile
+  });
+}));

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

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

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

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attemptAuthSessionCommand = void 0;
+var _attempt = require("./attempt.command");
+const attemptAuthSessionCommand = exports.attemptAuthSessionCommand = _attempt.attemptCommand.command("authsession").description("Manage authentication sessions");

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attemptAuthSessionCheckCommand = void 0;
+var _zod = require("zod");
+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;
+  await (0, _helpers.assertAuthEnabled)();
+  await (0, _authSession.executeAttemptCheckAuthSessionCLI)({
+    id,
+    ...options
+  });
+}));

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

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

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.attemptAuthSessionCreateCommand = void 0;
+var _controller = require("../controller");
+var _zod = require("zod");
+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({
+  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;
+  await (0, _helpers.assertAuthEnabled)();
+  const authSessionInput = (await (0, _controller.loadParameters)(parameters)) ?? {};
+  await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
+    id,
+    input: authSessionInput,
+    headless,
+    timeout,
+    proxy
+  });
+}));

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 () => {
+  await (0, _build.runBuild)();
+}));

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

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const program: Command;

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

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.program = void 0;
+var _commander = require("commander");
+const program = exports.program = new _commander.Command();
+program.name("intuned").description("Intuned CLI for creating, developing and deploying Intuned projects").version("1.0.0").enablePositionalOptions(true);

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

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

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

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deployCommand = void 0;
+var _command = require("./command");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _deploy = require("../controller/deploy");
+var _helpers = require("../helpers");
+var _zod = require("zod");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+const deployCommandSchema = _zod.z.tuple([_zod.z.union([_zod.z.string(), _zod.z.undefined()]), _zod.z.object({
+  workspaceId: _zod.z.string().optional(),
+  apiKey: _zod.z.string().optional()
+})]);
+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.withErrorLogging)(async (inputProjectName, inputOptions) => {
+  const parseResult = deployCommandSchema.safeParse([inputProjectName, inputOptions]);
+  if (!parseResult.success) {
+    return (0, _helpers.logInvalidInput)(parseResult);
+  }
+  const [projectName, options] = parseResult.data;
+  const {
+    isValid,
+    errorMessage
+  } = await (0, _deploy.validateIntunedProject)();
+  if (!isValid) {
+    const message = `^r^+Project to be deployed is not a valid Intuned project:^:^R ${errorMessage}:\n`;
+    throw new _helpers.CLIError(message, {
+      autoColor: false
+    });
+  }
+  const _projectName = projectName || (await (0, _helpers.getSettingIntunedJSON)("projectName"));
+  if (!_projectName) {
+    throw new _helpers.CLIError("Project name is required");
+  }
+  const projectNameValidation = (0, _deploy.validateProjectName)(_projectName);
+  if (!projectNameValidation.isValid) {
+    throw new _helpers.CLIError(projectNameValidation.errorMessage);
+  }
+  const auth = await (0, _helpers.getAuthCredentials)(options);
+  await (0, _deploy.runDeployProject)(_projectName, auth);
+}));

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

@@ -0,0 +1,15 @@
+export * from "./command";
+export * from "./build.command";
+export * from "./deploy.command";
+export * from "./init.command";
+export * from "./run.command";
+export * from "./run_api.command";
+export * from "./run_authsession.command";
+export * from "./run_authsession_create.command";
+export * from "./run_authsession_update.command";
+export * from "./run_authsession_validate.command";
+export * from "./attempt.command";
+export * from "./attempt_api.command";
+export * from "./attempt_authsession.command";
+export * from "./attempt_authsession_create.command";
+export * from "./attempt_authsession_check.command";

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

@@ -0,0 +1,170 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _command = require("./command");
+Object.keys(_command).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _command[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _command[key];
+    }
+  });
+});
+var _build = require("./build.command");
+Object.keys(_build).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _build[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _build[key];
+    }
+  });
+});
+var _deploy = require("./deploy.command");
+Object.keys(_deploy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _deploy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _deploy[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];
+    }
+  });
+});
+var _run = require("./run.command");
+Object.keys(_run).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _run[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _run[key];
+    }
+  });
+});
+var _run_api = require("./run_api.command");
+Object.keys(_run_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _run_api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _run_api[key];
+    }
+  });
+});
+var _run_authsession = require("./run_authsession.command");
+Object.keys(_run_authsession).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _run_authsession[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _run_authsession[key];
+    }
+  });
+});
+var _run_authsession_create = require("./run_authsession_create.command");
+Object.keys(_run_authsession_create).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _run_authsession_create[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _run_authsession_create[key];
+    }
+  });
+});
+var _run_authsession_update = require("./run_authsession_update.command");
+Object.keys(_run_authsession_update).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _run_authsession_update[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _run_authsession_update[key];
+    }
+  });
+});
+var _run_authsession_validate = require("./run_authsession_validate.command");
+Object.keys(_run_authsession_validate).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _run_authsession_validate[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _run_authsession_validate[key];
+    }
+  });
+});
+var _attempt = require("./attempt.command");
+Object.keys(_attempt).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _attempt[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _attempt[key];
+    }
+  });
+});
+var _attempt_api = require("./attempt_api.command");
+Object.keys(_attempt_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _attempt_api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _attempt_api[key];
+    }
+  });
+});
+var _attempt_authsession = require("./attempt_authsession.command");
+Object.keys(_attempt_authsession).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _attempt_authsession[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _attempt_authsession[key];
+    }
+  });
+});
+var _attempt_authsession_create = require("./attempt_authsession_create.command");
+Object.keys(_attempt_authsession_create).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _attempt_authsession_create[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _attempt_authsession_create[key];
+    }
+  });
+});
+var _attempt_authsession_check = require("./attempt_authsession_check.command");
+Object.keys(_attempt_authsession_check).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _attempt_authsession_check[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _attempt_authsession_check[key];
+    }
+  });
+});

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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 () => {
+  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.command.d.ts

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

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

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runCommand = void 0;
+var _command = require("./command");
+const runCommand = exports.runCommand = _command.program.command("run").description("Execute an Intuned run");

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

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

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

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runApiCommand = void 0;
+var _run = require("./run.command");
+var _api = require("../controller/api");
+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({
+  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;
+  await (0, _helpers.assertAuthConsistent)(authSession);
+  const inputData = await (0, _controller.loadParameters)(parameters);
+  await (0, _api.executeRunApiCLI)({
+    apiName,
+    inputData: inputData,
+    authSession: authSession ? {
+      id: authSession,
+      autoRecreate: authSessionAutoRecreate,
+      checkRetries: authSessionCheckAttempts,
+      createRetries: authSessionCreateAttempts
+    } : undefined,
+    retries,
+    outputFile,
+    proxy,
+    headless,
+    timeout
+  });
+}));

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAuthSessionCommand = exports.baseRunAuthSessionCommandOptionsSchema = void 0;
+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");

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAuthSessionCreateCommand = 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({
+  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;
+  await (0, _helpers.assertAuthEnabled)();
+  const authSessionInput = (await (0, _controller.loadParameters)(parameters)) ?? {};
+  await (0, _authSession.executeRunCreateAuthSessionCLI)({
+    id,
+    checkRetries: checkAttempts,
+    createRetries: createAttempts,
+    input: authSessionInput,
+    headless,
+    proxy,
+    timeout
+  });
+}));

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

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