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

package/.babelrc

@@ -4,8 +4,8 @@
       "@babel/preset-env",
       {
         "targets": {
-          "chrome": 115,
-          "node": "16"
+          "chrome": 130,
+          "node": "20"
         },
         "modules": "commonjs"
       }

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 # UNRELEASED
 
--
+- 
+
+# 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

@@ -96,7 +96,7 @@ async function executeCLI(apiName, mode, inputData, options) {
     _Logger.logger.info("This will only take an effect if this API run was part of a job.");
   }
 }
-_commander.program.description("run the user function in the cli for testing purposes").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").option("--outputFileId <outputFileId>", "the output file id to save the result in").option("--proxy <proxy>", "proxy to use").option("--authSessionPath <authSessionParameters>", "parameters used to create the used auth session").argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone", "playwright-headless"]).default("playwright-standalone").argOptional()).action(async (apiName, mode, options) => {
+_commander.program.description("run the user function in the cli for testing purposes").option("-i, --input [file]", "input json file").option("-j, --json [json]", "input json string").option("--cdpAddress <cdpAddress>", "CDP address", "http://localhost:9222").option("--authSessionPath <authSession>", "auth session to use when executing the api").option("--outputFileId <outputFileId>", "the output file id to save the result in").option("--proxy <proxy>", "proxy to use").option("--authSessionParameters <authSessionParameters>", "parameters used to create the used auth session").argument("[apiName]", "name of the api", "default").allowUnknownOption().addArgument(new _commander.Argument("<mode>", "mode of execution").choices(["vanilla", "playwright", "playwright-standalone", "playwright-headless"]).default("playwright-standalone").argOptional()).action(async (apiName, mode, options) => {
   let inputData = null;
   if (options.input) {
     inputData = await fs.readJSON(options.input);
@@ -106,7 +106,7 @@ _commander.program.description("run the user function in the cli for testing pur
     inputData = {};
   }
   let authSessionParametersJson = undefined;
-  if (!(0, _isNil.default)(options === null || options === void 0 ? void 0 : options.authSessionParameters)) {
+  if (!(0, _isNil.default)(options?.authSessionParameters)) {
     authSessionParametersJson = JSON.parse(options.authSessionParameters);
   }
   await (0, _asyncLocalStorage.runWithContext)({

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

@@ -32,7 +32,7 @@ _commander.program.description("Create an auth session").argument("[auth-session
       if (!createApiExists) {
         throw new Error("Auth session create API not implemented, please create it in the auth sessions specified directory");
       }
-      const authSessionInput = (await (0, _utils2.loadParameters)(options === null || options === void 0 ? void 0 : options.input)) ?? {};
+      const authSessionInput = (await (0, _utils2.loadParameters)(options?.input)) ?? {};
       const session = await (0, _utils.runCreateApi)(authSessionInput);
       if (!session) {
         console.error(_chalk.default.red("Failed to create auth session."));

package/dist/commands/cli-auth-sessions/utils.d.ts

@@ -1,6 +1,6 @@
 import { StorageState } from "../../common/contextStorageStateHelpers";
 import { AuthSessionMetadata, AuthSessionType } from "../../common/cli/types";
-import * as playwright from "playwright";
+import * as playwright from "playwright-core";
 export declare function isAuthEnabled(): Promise<boolean>;
 export declare function getAuthType(): Promise<AuthSessionType>;
 export declare function ensureRecorderURLs(): Promise<{

package/dist/commands/cli-auth-sessions/utils.js

@@ -26,15 +26,14 @@ var _tsNodeImport = require("../common/tsNodeImport");
 var _promptly = require("promptly");
 var _utils = require("../../common/cli/utils");
 var _types = require("../../common/cli/types");
-var playwright = _interopRequireWildcard(require("playwright"));
+var playwright = _interopRequireWildcard(require("playwright-core"));
 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; }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 async function isAuthEnabled() {
   try {
-    var _intunedJson$authSess;
     const intunedJson = await fs.readJSON(_path.default.join(process.cwd(), "Intuned.json"));
-    return Boolean(intunedJson === null || intunedJson === void 0 || (_intunedJson$authSess = intunedJson.authSessions) === null || _intunedJson$authSess === void 0 ? void 0 : _intunedJson$authSess.enabled);
+    return Boolean(intunedJson?.authSessions?.enabled);
   } catch (error) {
     return false;
   }

package/dist/commands/common/getFirstLineNumber.js

@@ -32,10 +32,9 @@ function compileTypeScript(apiFilePath) {
   };
 }
 function findFirstExecutableLine(sourceFile) {
-  var _defaultExportSymbol$;
   let functionBody;
   const defaultExportSymbol = sourceFile.getDefaultExportSymbol();
-  const defaultExportDeclaration = defaultExportSymbol === null || defaultExportSymbol === void 0 || (_defaultExportSymbol$ = defaultExportSymbol.getDeclarations()) === null || _defaultExportSymbol$ === void 0 ? void 0 : _defaultExportSymbol$[0];
+  const defaultExportDeclaration = defaultExportSymbol?.getDeclarations()?.[0];
   if (defaultExportDeclaration) {
     if (defaultExportDeclaration.getKind() === _tsMorph.ts.SyntaxKind.FunctionDeclaration) {
       functionBody = defaultExportDeclaration.getBody();
@@ -45,9 +44,8 @@ function findFirstExecutableLine(sourceFile) {
         const expression = exportAssignment.getExpression();
         if (!expression) continue;
         if (expression.getKind() === _tsMorph.ts.SyntaxKind.Identifier || expression.getKind() === _tsMorph.ts.SyntaxKind.FunctionExpression || expression.getKind() === _tsMorph.ts.SyntaxKind.ArrowFunction) {
-          var _sourceFile$getVariab;
           const identifier = expression.getText();
-          const possiblyExportedFunction = sourceFile.getFunction(identifier) || ((_sourceFile$getVariab = sourceFile.getVariableStatement(identifier)) === null || _sourceFile$getVariab === void 0 ? void 0 : _sourceFile$getVariab.getDescendants().find(node => node.getKind() === _tsMorph.ts.SyntaxKind.FunctionExpression || node.getKind() === _tsMorph.ts.SyntaxKind.ArrowFunction));
+          const possiblyExportedFunction = sourceFile.getFunction(identifier) || sourceFile.getVariableStatement(identifier)?.getDescendants().find(node => node.getKind() === _tsMorph.ts.SyntaxKind.FunctionExpression || node.getKind() === _tsMorph.ts.SyntaxKind.ArrowFunction);
           if (possiblyExportedFunction) {
             functionBody = possiblyExportedFunction.getBody();
             break;

package/dist/commands/deploy/utils.js

@@ -228,13 +228,12 @@ const validateIntunedProject = async () => {
     name: "package.json",
     check: async () => {
       try {
-        var _packageJson$dependen;
         const packageJsonPath = path.join(currentDirectoryToDeploy, "package.json");
         await fs.exists(packageJsonPath);
         const packageJson = JSON.parse(await fs.readFile(packageJsonPath, {
           encoding: "utf-8"
         }));
-        const userCodePlaywrightVersion = (_packageJson$dependen = packageJson.dependencies) === null || _packageJson$dependen === void 0 ? void 0 : _packageJson$dependen.playwright;
+        const userCodePlaywrightVersion = packageJson.dependencies?.playwright;
         if (userCodePlaywrightVersion !== _constants.CURRENT_PLAYWRIGHT_VERSION) {
           return {
             isValid: false,

package/dist/commands/init/utils.js

@@ -15,7 +15,6 @@ var _types = require("../../common/cli/types");
 var _chalk = _interopRequireDefault(require("chalk"));
 var _inquirer = _interopRequireDefault(require("inquirer"));
 var _path = _interopRequireDefault(require("path"));
-var _boxen = _interopRequireDefault(require("boxen"));
 var _projectExclusions = _interopRequireDefault(require("../common/projectExclusions"));
 var _constants = require("../../common/cli/constants");
 var _cliReadme = require("../../common/cli/cliReadme");
@@ -139,12 +138,7 @@ async function scaffoldProject(templateId, isTargetDirectoryEmpty) {
   await prepareCLITemplate(codeTree);
   await mountFiles(cwd, codeTree);
   console.log(_chalk.default.green("✓ Project files created"));
-  console.log((0, _boxen.default)(_chalk.default.green(`✅ Project initialized successfully`) + `\n\n${_chalk.default.cyan("Project details:")}` + `\n• Template: ${_chalk.default.bold(templateId)}` + `\n• Directory: ${_chalk.default.bold(process.cwd())}` + `\n\n${_chalk.default.cyan("Next steps:")}` + `\n1. ${_chalk.default.bold("cd")} into your project directory (if not already there)` + `\n2. Run ${_chalk.default.bold("npm/yarn install")} to install dependencies` + `\n3. Develop, test and run your automation APIs`, {
-    padding: 1,
-    margin: 1,
-    borderStyle: "round",
-    borderColor: "green"
-  }));
+  console.log(_chalk.default.cyan(`\n🎉 Project initialized successfully!`), _chalk.default.yellow(`\n\nRun ${_chalk.default.bold("yarn")} to install dependencies and start coding!`));
 }
 async function fetchProjectTemplate(templateId) {
   const baseUrl = (0, _utils.getBaseUrl)();

package/dist/commands/interface/run.js

@@ -29,7 +29,8 @@ const startRunApiSchema = _zod.default.object({
       jobId: _zod.default.string().optional(),
       jobRunId: _zod.default.string().optional(),
       runId: _zod.default.string().optional(),
-      queueId: _zod.default.string().optional()
+      queueId: _zod.default.string().optional(),
+      authSessionId: _zod.default.string().optional()
     }).optional()
   })
 });
@@ -66,14 +67,12 @@ function runAutomationCLI(importFunction) {
     let generator = null;
     const abortController = new AbortController();
     client.on("error", err => {
-      var _generator;
-      void ((_generator = generator) === null || _generator === void 0 ? void 0 : _generator.throw(err).catch(() => undefined));
+      void generator?.throw(err).catch(() => undefined);
     });
     const interruptSignalHandler = async () => {
-      var _generator2;
       abortController.abort();
       await (0, _promises.setTimeout)(60_000);
-      void ((_generator2 = generator) === null || _generator2 === void 0 ? void 0 : _generator2.throw(new Error("Interrupted")).catch(() => undefined));
+      void generator?.throw(new Error("Interrupted")).catch(() => undefined);
       client.end();
       process.exit(1);
     };
@@ -214,7 +213,7 @@ function runAutomationCLI(importFunction) {
   _commander.program.parse(process.argv);
 }
 function getProxyUrlFromRunOptions(runOptions) {
-  if ((runOptions === null || runOptions === void 0 ? void 0 : runOptions.environment) !== "standalone") return undefined;
+  if (runOptions?.environment !== "standalone") return undefined;
   const proxy = runOptions.proxy;
   if (!proxy) return undefined;
   const url = new URL(proxy.server);

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,47 @@
+"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 _utils = require("../../../common/cli/utils");
+var _zod = require("zod");
+var _helpers = require("./helpers");
+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, _utils.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, _utils.getAuthCredentials)(options);
+  await (0, _deploy.runDeployProject)(_projectName, auth);
+}));

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { API_FOLDER_NAME, AUTH_SESSIONS_FOLDER_NAME } from "../../../common/constants";
+export declare class CLIError extends Error {
+    autoColor: boolean;
+    constructor(message: string, options?: {
+        autoColor?: boolean;
+    });
+}
+export declare class CLIAssertionError extends CLIError {
+    constructor(message: string, options?: {
+        autoColor?: boolean;
+    });
+}
+export declare function logInvalidInput(result: z.SafeParseError<unknown>): void;
+export declare function assertAuthEnabled(): Promise<void>;
+export declare function assertAuthConsistent(authSession: string | undefined): Promise<void>;
+export declare function withErrorLogging<T extends any[]>(fn: (...args: T) => Promise<unknown>): (...args: T) => Promise<never>;
+export declare function parseUrlProxy(proxyUrl: string): {
+    password: string;
+    username: string;
+    server: string;
+} | undefined;
+export declare function withTimeout<R, P extends any[]>(fn: (...args: P) => Promise<R>, timeout: number): (...args: P) => Promise<R>;
+export declare function withCLIContext<R, P extends any[]>(fn: (...args: P) => Promise<R>): (...args: P) => Promise<R>;
+export declare function assertApiFileExists(dirname: typeof AUTH_SESSIONS_FOLDER_NAME, api: "create" | "check"): Promise<void>;
+export declare function assertApiFileExists(dirname: typeof API_FOLDER_NAME, api: string): Promise<void>;

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

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CLIError = exports.CLIAssertionError = void 0;
+exports.assertApiFileExists = assertApiFileExists;
+exports.assertAuthConsistent = assertAuthConsistent;
+exports.assertAuthEnabled = assertAuthEnabled;
+exports.logInvalidInput = logInvalidInput;
+exports.parseUrlProxy = parseUrlProxy;
+exports.withCLIContext = withCLIContext;
+exports.withErrorLogging = withErrorLogging;
+exports.withTimeout = withTimeout;
+var _utils = require("../../cli-auth-sessions/utils");
+var _nanoid = require("nanoid");
+var _asyncLocalStorage = require("../../../common/asyncLocalStorage");
+var _enums = require("../../../runtime/enums");
+var _terminal = require("../terminal");
+var _path = _interopRequireDefault(require("path"));
+var _fsExtra = require("fs-extra");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class CLIError extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "CLIError";
+    this.autoColor = options?.autoColor ?? true;
+  }
+}
+exports.CLIError = CLIError;
+class CLIAssertionError extends CLIError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CLIAssertionError";
+  }
+}
+exports.CLIAssertionError = CLIAssertionError;
+function logInvalidInput(result) {
+  (0, _terminal.terminal)("^r^+Invalid input parameters:^: ^R" + result.error.errors.map(({
+    message
+  }) => `^R${message}^:`).join(", ") + "\n");
+}
+async function assertAuthEnabled() {
+  if (!(await (0, _utils.isAuthEnabled)())) {
+    throw new CLIAssertionError("Auth session is not enabled, enable it in Intuned.json to use it");
+  }
+}
+async function assertAuthConsistent(authSession) {
+  const _isAuthEnabled = await (0, _utils.isAuthEnabled)();
+  if (_isAuthEnabled && !authSession) {
+    throw new CLIAssertionError("Auth session is enabled, but no auth session is provided. Please provide an auth session ID.");
+  }
+  if (!_isAuthEnabled && authSession) {
+    throw new CLIAssertionError("Auth session is not enabled, enable it in Intuned.json to use it");
+  }
+}
+function withErrorLogging(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+      process.exit(0);
+    } catch (error) {
+      if (error instanceof CLIError) {
+        if (error.autoColor) {
+          (0, _terminal.terminal)(`^r^+${error.message}^:\n`);
+        } else {
+          (0, _terminal.terminal)(`${error.message}\n`);
+        }
+      } else {
+        (0, _terminal.terminal)(`^r^+An error occurred:^: ^R${error.message}^:\n^r^+Please report this issue to the Intuned team.^:\n`);
+      }
+      process.exit(1);
+    }
+  };
+}
+function parseUrlProxy(proxyUrl) {
+  try {
+    const url = new URL(proxyUrl);
+    const username = url.username;
+    const password = url.password;
+    const proxy = url.hostname;
+    const port = url.port ? `:${url.port}` : "";
+    const domain = `${url.protocol}//${proxy}${port}`;
+    return {
+      password,
+      username,
+      server: domain
+    };
+  } catch (error) {
+    return;
+  }
+}
+function withTimeout(fn, timeout) {
+  let reject;
+  const timeoutPromise = new Promise((_, _reject) => {
+    reject = _reject;
+  });
+  const timeoutId = setTimeout(() => {
+    reject(new CLIError("Timed out"));
+  }, timeout);
+  const fnWithWrapper = async (...args) => {
+    return Promise.race([fn(...args), timeoutPromise]);
+  };
+  (0, _asyncLocalStorage.getExecutionContext)().timeoutInfo.extendTimeoutCallback = async () => {
+    timeoutId.refresh();
+  };
+  return fnWithWrapper;
+}
+function withCLIContext(fn) {
+  const runId = (0, _nanoid.nanoid)();
+  return async (...args) => (0, _asyncLocalStorage.runWithContext)({
+    runEnvironment: _enums.RunEnvironment.IDE,
+    runId,
+    extendedPayloads: [],
+    timeoutInfo: {}
+  }, fn, ...args);
+}
+async function assertApiFileExists(dirname, api) {
+  const file = `${dirname}/${api}.ts`;
+  const filePath = _path.default.join(process.cwd(), file);
+  if (!(await (0, _fsExtra.exists)(filePath))) {
+    throw new CLIAssertionError(`^+^r API^ ^+${dirname}/${api}^ ^r^+is not implemented.^:`, {
+      autoColor: false
+    });
+  }
+}

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";