@intuned/runtime-dev 1.1.7-dev-52 → 1.2.0-cli.0

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,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initCommand = void 0;
+var _init = require("../controller/init");
+var _command = require("./command");
+var _helpers = require("./helpers");
+const initCommand = exports.initCommand = _command.program.command("init").description("Initialize a new Intuned project from a template").argument("[template-name]", "Name of the template to use").action((0, _helpers.withErrorLogging)(async templateName => {
+  const template = await (0, _init.selectTemplate)(templateName);
+  const isTargetDirectoryEmpty = await (0, _init.checkEmptyDirectory)();
+  await (0, _init.scaffoldProject)(template, isTargetDirectoryEmpty);
+}));

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,21 @@
+/// <reference types="ms" />
+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;

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

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

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAuthSessionValidateCommand = 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({
+  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;
+  await (0, _helpers.assertAuthEnabled)();
+  await (0, _authSession.executeRunValidateAuthSessionCLI)({
+    id,
+    autoRecreate,
+    checkRetries: checkAttempts,
+    createRetries: createAttempts,
+    headless,
+    proxy,
+    timeout
+  });
+}));

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

@@ -0,0 +1,21 @@
+import ms from "ms";
+import { z } from "zod";
+export declare const authSessionCheckAttemptsSchema: z.ZodDefault<z.ZodNumber>;
+export declare const authSessionCreateAttemptsSchema: z.ZodDefault<z.ZodNumber>;
+export declare const proxySchema: z.ZodOptional<z.ZodString>;
+export declare const timeoutSchema: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, ms.StringValue, string | undefined>, number, string | undefined>;
+export declare const headlessSchema: z.ZodDefault<z.ZodBoolean>;
+export declare const baseCommandOptionsSchema: z.ZodObject<{
+    proxy: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, ms.StringValue, string | undefined>, number, string | undefined>;
+    headless: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    headless: boolean;
+    timeout: number;
+    proxy?: string | undefined;
+}, {
+    proxy?: string | undefined;
+    timeout?: string | undefined;
+    headless?: boolean | undefined;
+}>;
+export type BaseCommandOptions = z.infer<typeof baseCommandOptionsSchema>;

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

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.timeoutSchema = exports.proxySchema = exports.headlessSchema = exports.baseCommandOptionsSchema = exports.authSessionCreateAttemptsSchema = exports.authSessionCheckAttemptsSchema = void 0;
+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 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;
+}, "--timeout must be a valid integer or ms-formatted string").transform(val => (0, _ms.default)(val));
+const headlessSchema = exports.headlessSchema = _zod.z.boolean().default(false);
+const baseCommandOptionsSchema = exports.baseCommandOptionsSchema = _zod.z.object({
+  proxy: proxySchema,
+  timeout: timeoutSchema,
+  headless: headlessSchema
+});

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

@@ -0,0 +1,19 @@
+import type { BaseCommandOptions } from "../commands/types";
+export declare function executeRunApiCLI({ apiName, inputData, retries, authSession, outputFile, ...rest }: {
+    apiName: string;
+    inputData: object | null | undefined;
+    retries: number;
+    authSession?: {
+        id: string;
+        autoRecreate: boolean;
+        checkRetries: number;
+        createRetries: number;
+    };
+    outputFile?: string;
+} & BaseCommandOptions): Promise<void>;
+export declare function executeAttemptApiCLI({ apiName, inputData, authSessionId, outputFile, ...rest }: {
+    apiName: string;
+    inputData: object | null | undefined;
+    authSessionId?: string;
+    outputFile?: string;
+} & BaseCommandOptions): Promise<void>;

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

@@ -0,0 +1,179 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.executeAttemptApiCLI = executeAttemptApiCLI;
+exports.executeRunApiCLI = executeRunApiCLI;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var _runApi = require("../../../common/runApi");
+var _tsNodeImport = require("../../common/tsNodeImport");
+var _authSession = require("./authSession");
+var _utils = require("../../cli-auth-sessions/utils");
+var _helpers = require("../commands/helpers");
+var _terminal = require("../terminal");
+var _constants = require("../../../common/constants");
+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 executeRunApiCLI({
+  apiName,
+  inputData,
+  retries,
+  authSession,
+  outputFile,
+  ...rest
+}) {
+  await (0, _helpers.assertApiFileExists)(_constants.API_FOLDER_NAME, apiName);
+  (0, _terminal.terminal)(`^+Running API ^c${apiName}^:\n`);
+  const apiResult = await (0, _helpers.withCLIContext)(async () => {
+    for (let i = 0; i < retries; i++) {
+      (0, _terminal.terminal)(`\n^+Executing ^c${apiName} ^/(Attempt ${i + 1}) ^:...\n`);
+      let authSessionPathToUse;
+      if (authSession) {
+        authSessionPathToUse = await (0, _authSession.executeRunValidateAuthSessionCLI)({
+          ...authSession,
+          useExistingContext: true,
+          ...rest
+        });
+      }
+      try {
+        return await attemptApi({
+          apiName,
+          inputData,
+          auth: authSessionPathToUse ? {
+            session: {
+              type: "file",
+              path: authSessionPathToUse
+            },
+            runCheck: false
+          } : undefined,
+          ...rest
+        });
+      } catch (error) {
+        (0, _terminal.terminal)(`^r^+Failed to run API ^:^+${apiName}^:: ^R${error.message}^:\n`);
+        continue;
+      }
+    }
+  })();
+  if (apiResult === undefined) {
+    throw new _helpers.CLIError(`^r^+Failed to run API ^:^+${apiName}^:: ^RExceeded maximum retries of ^+${retries}^:\n`, {
+      autoColor: false
+    });
+  }
+  return handleApiResult({
+    apiResult,
+    outputFile
+  });
+}
+async function executeAttemptApiCLI({
+  apiName,
+  inputData,
+  authSessionId,
+  outputFile,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Execute API attempt for ^c${apiName}^:\n`);
+  await (0, _helpers.assertApiFileExists)(_constants.API_FOLDER_NAME, apiName);
+  let authSessionInstance;
+  if (authSessionId) {
+    ({
+      authSessionInstance
+    } = await (0, _utils.retrieveAuthSessionInstance)(authSessionId));
+  }
+  return await (0, _helpers.withCLIContext)(async () => {
+    const apiResult = await attemptApi({
+      apiName,
+      inputData,
+      auth: authSessionInstance ? {
+        session: {
+          type: "state",
+          state: authSessionInstance
+        },
+        runCheck: false
+      } : undefined,
+      ...rest
+    });
+    return await handleApiResult({
+      apiResult,
+      outputFile
+    });
+  })();
+}
+async function handleApiResult({
+  apiResult,
+  outputFile
+}) {
+  const {
+    result,
+    payloadToAppend
+  } = apiResult;
+  (0, _terminal.terminal)(`^+^gAPI executed successfully^:\n`);
+  if (!outputFile) {
+    if (!result) {
+      (0, _terminal.terminal)(`^+^yNo result returned from the API^:\n`);
+    } else {
+      (0, _terminal.terminal)(`^+^gResult:^:\n`);
+      (0, _terminal.terminal)(`${JSON.stringify(result, null, 2)}\n`);
+    }
+    if (payloadToAppend && payloadToAppend.length > 0) {
+      (0, _terminal.terminal)(`^+^gExtended payloads:^ ^/^G(This will only take effect if this API run was part of a job.)^:\n:\n`);
+      (0, _terminal.terminal)(`${JSON.stringify(payloadToAppend, null, 2)}\n`);
+    }
+    return;
+  }
+  await writeResultToFile(outputFile, result, payloadToAppend);
+}
+async function writeResultToFile(outputFile, result, payloadToAppend) {
+  const resultToWrite = {
+    result
+  };
+  if (payloadToAppend && payloadToAppend.length > 0) {
+    resultToWrite["extendedPayloads"] = payloadToAppend;
+  }
+  try {
+    await fs.writeJSON(outputFile, resultToWrite, {
+      spaces: 2
+    });
+    (0, _terminal.terminal)(`^+^gResults written to^ ^_${outputFile}^:\n`);
+  } catch (error) {
+    throw new _helpers.CLIError(`Failed to write result to file: ${error.message}`);
+  }
+}
+async function attemptApi({
+  apiName,
+  inputData,
+  auth,
+  proxy,
+  headless,
+  timeout
+}) {
+  return await (0, _helpers.withTimeout)(async () => {
+    const runApiResult = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: `api/${apiName}`,
+        params: inputData
+      },
+      runOptions: {
+        headless,
+        environment: "standalone",
+        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
+      },
+      auth,
+      importFunction: _tsNodeImport.tsNodeImport
+    });
+    if (runApiResult.isErr()) {
+      if (runApiResult.error instanceof _runApi.AutomationError) {
+        throw runApiResult.error.error;
+      }
+      throw new _helpers.CLIError(`An error occurred while running the API: ${runApiResult.error.message}`);
+    }
+    const {
+      result,
+      extendedPayloads: payloadToAppend
+    } = runApiResult.value;
+    return {
+      result,
+      payloadToAppend
+    };
+  }, timeout)();
+}