@intuned/runtime-dev 1.3.9-deploy.0 → 1.3.9-dev10

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

@@ -0,0 +1,203 @@
+"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 _save = require("./save.command");
+Object.keys(_save).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _save[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _save[key];
+    }
+  });
+});
+var _init = require("./init.command");
+Object.keys(_init).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _init[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _init[key];
+    }
+  });
+});
+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];
+    }
+  });
+});
+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/package/dist/commands/intuned-cli/commands/init.command.d.ts

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

package/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.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/package/dist/commands/intuned-cli/commands/run.command.d.ts

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

package/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/package/dist/commands/intuned-cli/commands/run_api.command.d.ts

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

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

@@ -0,0 +1,46 @@
+"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 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 = (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)({
+    apiName,
+    inputData: inputData,
+    authSession: authSession ? {
+      id: authSession,
+      autoRecreate: authSessionAutoRecreate,
+      checkRetries: authSessionCheckAttempts,
+      createRetries: authSessionCreateAttempts
+    } : undefined,
+    retries,
+    outputFile,
+    ...rest
+  });
+}));

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

@@ -0,0 +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>;
+    timeout: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodString>, import("ms").StringValue, string | undefined>, number, string | undefined>;
+    keepBrowserOpen: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    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;
+    timeout: number;
+    keepBrowserOpen: boolean;
+    trace: boolean;
+    checkAttempts: number;
+    createAttempts: number;
+    proxy?: string | undefined;
+}, {
+    proxy?: string | undefined;
+    headless?: boolean | undefined;
+    timeout?: string | undefined;
+    keepBrowserOpen?: boolean | undefined;
+    trace?: boolean | undefined;
+    checkAttempts?: number | undefined;
+    createAttempts?: number | undefined;
+}>;
+export declare const runAuthSessionCommand: Command;
+export declare function withAuthSessionBaseOptions(command: Command): Command;

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

@@ -0,0 +1,17 @@
+"use strict";
+
+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");
+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/package/dist/commands/intuned-cli/commands/run_authsession_create.command.d.ts

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

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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");
+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 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)({
+    id,
+    checkRetries: checkAttempts,
+    createRetries: createAttempts,
+    input: authSessionInput,
+    ...rest
+  });
+})));
+exports.authSessionCreateCommand = authSessionCreateCommand;
+exports.runAuthSessionCreateCommand = runAuthSessionCreateCommand;

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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");
+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 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)({
+    id,
+    input: authSessionInput,
+    checkRetries: checkAttempts,
+    createRetries: createAttempts,
+    ...rest
+  });
+})));
+exports.authSessionUpdateCommand = authSessionUpdateCommand;
+exports.runAuthSessionUpdateCommand = runAuthSessionUpdateCommand;

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

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

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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");
+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 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,
+    ...rest
+  });
+})));
+exports.authSessionValidateCommand = authSessionValidateCommand;
+exports.runAuthSessionValidateCommand = runAuthSessionValidateCommand;

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+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, {
+    workspaceId?: string | undefined;
+    apiKey?: string | undefined;
+}, {
+    workspaceId?: string | undefined;
+    apiKey?: string | undefined;
+}>;
+export declare const saveCommand: import("commander").Command;

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.saveOrDeployOptionsSchema = exports.saveOrDeployArgsSchema = exports.saveCommand = void 0;
+var _command = require("./command");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _save = require("../controller/save");
+var _helpers = require("../helpers");
+var _zod = require("zod");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+const saveOrDeployArgsSchema = exports.saveOrDeployArgsSchema = _zod.z.tuple([_zod.z.union([_zod.z.string(), _zod.z.undefined()])]);
+const saveOrDeployOptionsSchema = exports.saveOrDeployOptionsSchema = _zod.z.object({
+  workspaceId: _zod.z.string().optional(),
+  apiKey: _zod.z.string().optional()
+});
+const saveCommand = exports.saveCommand = _command.program.command("save").description("Save an Intuned project to the platform without deploying it").argument("[project-name]", "Name of the project to save").option("-w, --workspace-id <id>", "Your Intuned workspace ID").option("-k, --api-key <key>", "Your Intuned API key").action((0, _helpers.cliCommandWrapper)(saveOrDeployArgsSchema, saveOrDeployOptionsSchema, async ([projectName], options) => {
+  const {
+    isValid,
+    errorMessage
+  } = await (0, _save.validateIntunedProject)();
+  if (!isValid) {
+    const message = `^r^+Project to be saved is not a valid Intuned project:^:^R ${errorMessage}:\n`;
+    throw new _helpers.CLIError(message, {
+      autoColor: false
+    });
+  }
+  const _projectName = projectName || (await (0, _helpers.loadIntunedJson)()).projectName;
+  if (!_projectName) {
+    throw new _helpers.CLIError("Project name is required");
+  }
+  const projectNameValidation = (0, _save.validateProjectName)(_projectName);
+  if (!projectNameValidation.isValid) {
+    throw new _helpers.CLIError(projectNameValidation.errorMessage);
+  }
+  const auth = await (0, _helpers.getAuthCredentials)(options);
+  await (0, _save.runSaveProject)(_projectName, auth);
+}));

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

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+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 traceSchema: z.ZodDefault<z.ZodBoolean>;
+export declare const keepBrowserOpenSchema: 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>;
+    trace: z.ZodDefault<z.ZodBoolean>;
+    keepBrowserOpen: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    headless: boolean;
+    timeout: number;
+    keepBrowserOpen: boolean;
+    trace: boolean;
+    proxy?: string | undefined;
+}, {
+    proxy?: string | undefined;
+    timeout?: string | undefined;
+    headless?: boolean | undefined;
+    trace?: boolean | undefined;
+    keepBrowserOpen?: boolean | undefined;
+}>;
+export type BaseCommandOptions = z.infer<typeof baseCommandOptionsSchema>;
+export declare function withBaseOptions(command: Command): Command;

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.traceSchema = exports.timeoutSchema = exports.proxySchema = exports.keepBrowserOpenSchema = exports.headlessSchema = exports.baseCommandOptionsSchema = exports.authSessionCreateAttemptsSchema = exports.authSessionCheckAttemptsSchema = void 0;
+exports.withBaseOptions = withBaseOptions;
+var _ms = _interopRequireDefault(require("ms"));
+var _zod = require("zod");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const authSessionCheckAttemptsSchema = exports.authSessionCheckAttemptsSchema = _zod.z.coerce.number().int().min(1, "Auth session check attempts must be at least 1").default(1);
+const authSessionCreateAttemptsSchema = exports.authSessionCreateAttemptsSchema = _zod.z.coerce.number().int().min(1, "Auth session create attempts must be at least 1").default(1);
+const 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 traceSchema = exports.traceSchema = _zod.z.boolean().default(false);
+const keepBrowserOpenSchema = exports.keepBrowserOpenSchema = _zod.z.boolean().default(false);
+const baseCommandOptionsSchema = exports.baseCommandOptionsSchema = _zod.z.object({
+  proxy: proxySchema,
+  timeout: timeoutSchema,
+  headless: headlessSchema,
+  trace: traceSchema,
+  keepBrowserOpen: keepBrowserOpenSchema
+});
+function withBaseOptions(command) {
+  return command.option("--proxy <url>", "Proxy URL to use for browser").option("--timeout <time>", "Timeout for each attempt - milliseconds or ms-formatted string", "10 mins").option("--headless", "Run the attempts in a headless browser (default: false). This will not open a browser window.").option("--trace", "Capture a trace of each attempt, useful for debugging.").option("--keep-browser-open", "Keep the last browser open after the command completes, useful for debugging.");
+}

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

@@ -0,0 +1,17 @@
+export declare const CURRENT_PLAYWRIGHT_VERSION = "1.44.1";
+export declare const ProjectDeploymentStatus: readonly ["completed", "failed", "pending", "not_found"];
+export declare const PROJECT_DEPLOY_TIMEOUT: number;
+export declare const PROJECT_DEPLOY_CHECK_PERIOD: number;
+export declare const tsConfigCli: {
+    compilerOptions: {
+        moduleResolution: string;
+        module: string;
+        target: string;
+        outDir: string;
+        sourceMap: boolean;
+        declaration: boolean;
+        esModuleInterop: boolean;
+    };
+    include: string[];
+    exclude: string[];
+};

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tsConfigCli = exports.ProjectDeploymentStatus = exports.PROJECT_DEPLOY_TIMEOUT = exports.PROJECT_DEPLOY_CHECK_PERIOD = exports.CURRENT_PLAYWRIGHT_VERSION = void 0;
+var _ms = _interopRequireDefault(require("ms"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const CURRENT_PLAYWRIGHT_VERSION = exports.CURRENT_PLAYWRIGHT_VERSION = "1.44.1";
+const ProjectDeploymentStatus = exports.ProjectDeploymentStatus = ["completed", "failed", "pending", "not_found"];
+const PROJECT_DEPLOY_TIMEOUT = exports.PROJECT_DEPLOY_TIMEOUT = (0, _ms.default)("10 minutes");
+const PROJECT_DEPLOY_CHECK_PERIOD = exports.PROJECT_DEPLOY_CHECK_PERIOD = (0, _ms.default)("5 seconds");
+const tsConfigCli = exports.tsConfigCli = {
+  compilerOptions: {
+    moduleResolution: "NodeNext",
+    module: "NodeNext",
+    target: "ES2021",
+    outDir: "./dist",
+    sourceMap: false,
+    declaration: true,
+    esModuleInterop: true
+  },
+  include: ["**/*.ts"],
+  exclude: ["node_modules", "dist"]
+};