@intuned/runtime-dev 1.3.18-interface.13 → 1.3.18-interface.16

package/dist/commands/interface/runApi.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/interface/runApi.js

@@ -0,0 +1,102 @@
+"use strict";
+
+var _asyncLocalStorage = require("../../common/asyncLocalStorage");
+var _v = _interopRequireDefault(require("zod/v3"));
+var _runApi = require("../../common/runApi");
+var _runtimeInterface = require("../../vendor/runtime-interface");
+var _enums = require("../../runtime/enums");
+var _jwtTokenManager = require("../../common/jwtTokenManager");
+var _formatZodError = require("../../common/formatZodError");
+var _getAuthSessionParameters = require("../../common/backendFunctions/getAuthSessionParameters");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const runApisValidMessagesSchema = _v.default.union([_runtimeInterface.abortRunApiSchema, _runtimeInterface.tokenUpdateSchema]);
+async function runApis(parameters, messagesGenerator, client, importFunction, abortController) {
+  const extendTimeoutThrottleTime = 60 * 1000;
+  let extendTimeoutTimestamp = Date.now();
+  const extendTimeoutCallback = async () => {
+    if (Date.now() - extendTimeoutTimestamp < extendTimeoutThrottleTime) return;
+    extendTimeoutTimestamp = Date.now();
+    client.sendJSON({
+      type: "extend"
+    });
+  };
+  const context = {
+    extendedPayloads: [],
+    runEnvironment: parameters.runOptions.environment === "standalone" ? _enums.RunEnvironment.DEPLOYED : _enums.RunEnvironment.IDE,
+    timeoutInfo: {
+      extendTimeoutCallback
+    },
+    getAuthSessionParameters: _getAuthSessionParameters.getAuthSessionParameters,
+    ...(parameters.context ?? {}),
+    proxy: getProxyUrlFromRunOptions(parameters.runOptions)
+  };
+  const resultPromise = (0, _asyncLocalStorage.runWithContext)(context, async () => {
+    return {
+      kind: "result",
+      result: await (0, _runApi.runApi)({
+        ...parameters,
+        importFunction
+      })
+    };
+  });
+  const receiveAndHandleMessages = async () => {
+    for await (const message of messagesGenerator) {
+      const parsedResult = runApisValidMessagesSchema.safeParse(message);
+      if (!parsedResult.success) {
+        return {
+          kind: "receive",
+          type: "error",
+          error: `Invalid message: ${(0, _formatZodError.formatZodError)(parsedResult.error)}`
+        };
+      }
+      const parsedMessage = parsedResult.data;
+      switch (parsedMessage.type) {
+        case "tokenUpdate":
+          {
+            _jwtTokenManager.backendFunctionsTokenManager.token = parsedMessage.parameters.functionsToken;
+            break;
+          }
+        case "abort":
+          {
+            return {
+              kind: "receive",
+              type: "aborted"
+            };
+          }
+      }
+    }
+    return {
+      kind: "receive",
+      type: "done"
+    };
+  };
+  const receiveAndHandleMessagesPromise = receiveAndHandleMessages();
+  const x = await Promise.race([resultPromise, receiveAndHandleMessagesPromise]);
+  if (x.kind === "receive") {
+    const h = x;
+    abortController.abort();
+    if (h.type === "error") {
+      client.sendJSON({
+        type: "error",
+        error: h.error
+      });
+    } else {
+      await resultPromise;
+    }
+    return;
+  }
+  const r = x;
+  client.sendJSON({
+    type: "result",
+    result: r.result
+  });
+}
+function getProxyUrlFromRunOptions(runOptions) {
+  if (runOptions?.environment !== "standalone") return undefined;
+  const proxy = runOptions.proxy;
+  if (!proxy) return undefined;
+  const url = new URL(proxy.server);
+  url.username = proxy.username;
+  url.password = proxy.password;
+  return url.toString();
+}

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,30 @@
+"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 argsSchema = _zod.z.tuple([_zod.z.string().min(1, "API name is required"), _zod.z.string().min(1, "Parameters are required")]);
+const optionsSchema = _types.baseCommandOptionsSchema.extend({
+  authSession: _zod.z.string().optional(),
+  outputFile: _zod.z.string().optional()
+});
+const attemptApiCommand = exports.attemptApiCommand = (0, _types.withBaseOptions)(_attempt.attemptCommand.command("api").description("Execute an Intuned API attempt with parameters").argument("<api-name>", "Name of the API to run").argument("<parameters>", "Path to the JSON file containing API parameters OR the parameters as a JSON string").option("-a, --auth-session <id>", "ID of the AuthSession to use for the API. This is expected to be in ./auth-sessions-instances/<id>.json").option("-o, --output-file <path>", "output file path")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([apiName, parameters], {
+  authSession,
+  ...rest
+}) => {
+  await (0, _helpers.assertAuthConsistent)(authSession);
+  const parametersData = await (0, _controller.loadParameters)(parameters);
+  await (0, _api.executeAttemptApiCLI)({
+    apiName,
+    inputData: parametersData,
+    authSessionId: authSession,
+    ...rest
+  });
+}));

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

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,19 @@
+"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 argsSchema = _zod.z.tuple([_zod.z.string().min(1, "ID of the AuthSession is required")]);
+const attemptAuthSessionCheckCommand = exports.attemptAuthSessionCheckCommand = (0, _types.withBaseOptions)(_attempt_authsession.attemptAuthSessionCommand.command("check").description("Check an existing AuthSession").argument("<id>", "ID of the AuthSession to check")).action((0, _helpers.cliCommandWrapper)(argsSchema, _types.baseCommandOptionsSchema, async ([id], options) => {
+  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,24 @@
+"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 argsSchema = _zod.z.tuple([_zod.z.string().min(1, "Parameters are required")]);
+const optionsSchema = _types.baseCommandOptionsSchema.extend({
+  id: _zod.z.string().optional()
+});
+const attemptAuthSessionCreateCommand = exports.attemptAuthSessionCreateCommand = (0, _types.withBaseOptions)(_attempt_authsession.attemptAuthSessionCommand.command("create").description("Create a new AuthSession").argument("<parameters>", "Parameters for the AuthSession command").option("--id <id>", "ID of the AuthSession to use for the command. Defaults to ./auth-sessions-instances/[current timestamp].json")).action((0, _helpers.cliCommandWrapper)(argsSchema, optionsSchema, async ([parameters], options) => {
+  await (0, _helpers.assertAuthEnabled)();
+  const authSessionInput = (await (0, _controller.loadParameters)(parameters)) ?? {};
+  await (0, _authSession.executeAttemptCreateAuthSessionCLI)({
+    input: authSessionInput,
+    ...options
+  });
+}));

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authSessionRecordCommand = void 0;
+var _zod = require("zod");
+var _authSession = require("../controller/authSession");
+var _helpers = require("../helpers");
+var _authsession = require("./authsession.command");
+var _run_authsession = require("./run_authsession.command");
+var _types = require("./types");
+const optionsSchema = _run_authsession.baseRunAuthSessionCommandOptionsSchema.extend({
+  id: _zod.z.string().optional()
+});
+const isAuthSessionRecorderEnabled = process.env.INTUNED_AUTH_SESSION_RECORDER_ENABLED === "true";
+const authSessionRecordCommand = exports.authSessionRecordCommand = isAuthSessionRecorderEnabled ? (0, _types.withBaseOptions)(_authsession.authSessionCommand.command("record").description("Record a new AuthSession").option("--id <id>", "ID of the AuthSession to use for the command. Defaults to auth-session-[current timestamp]").option("--check-attempts <number>", "Number of attempts to check the AuthSession validity", "1")).action((0, _helpers.cliCommandWrapper)(undefined, optionsSchema, async (_, {
+  checkAttempts,
+  ...rest
+}) => {
+  await (0, _helpers.assertAuthEnabled)();
+  const {
+    startUrl,
+    finishUrl
+  } = await (0, _helpers.getAuthSessionRecorderParameters)();
+  await (0, _authSession.executeRecordAuthSessionCLI)({
+    checkRetries: checkAttempts,
+    startUrl,
+    finishUrl,
+    ...rest
+  });
+})) : null;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.authSessionScaffoldCommand = void 0;
+var _zod = require("zod");
+var _helpers = require("../helpers");
+var _authsession = require("./authsession.command");
+var _types = require("./types");
+var _scaffold = require("../controller/scaffold");
+const optionsSchema = _zod.z.object({});
+const authSessionScaffoldCommand = exports.authSessionScaffoldCommand = (0, _types.withBaseOptions)(_authsession.authSessionCommand.command("scaffold").description("Scaffold AuthSession files")).action((0, _helpers.cliCommandWrapper)(undefined, optionsSchema, async _ => {
+  await (0, _helpers.assertAuthEnabled)();
+  await (0, _scaffold.scaffoldAuthSessionFiles)();
+}));

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.cliCommandWrapper)(undefined, undefined, 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,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deployCommand = void 0;
+var _command = require("./command");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _provision = require("../controller/provision");
+var _deploy = require("../controller/deploy");
+var _helpers = require("../helpers");
+var _provision2 = require("./provision.command");
+var _prompts = require("../helpers/prompts");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+_dotenv.default.config({
+  path: `.env`
+});
+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.cliCommandWrapper)(_provision2.saveOrDeployArgsSchema, _provision2.saveOrDeployOptionsSchema, async ([projectName], options) => {
+  const {
+    isValid,
+    errorMessage
+  } = await (0, _provision.validateIntunedProject)();
+  if (!isValid) {
+    const message = `^r^+Project to be deployed is not valid:^:^R ${errorMessage}:\n`;
+    throw new _helpers.CLIError(message, {
+      autoColor: false
+    });
+  }
+  const _projectName = projectName || (await (0, _helpers.loadIntunedJson)()).projectName || (await (0, _prompts.promptForProjectName)(name => {
+    const result = (0, _provision.validateProjectName)(name);
+    return result.isValid || result.errorMessage;
+  }));
+  if (!_projectName) {
+    throw new _helpers.CLIError(`Project name is required. Set it in ${await (0, _helpers.getIntunedSettingsFile)()} or provide it as an argument by running 'intuned deploy <project-name>'.`);
+  }
+  const projectNameValidation = (0, _provision.validateProjectName)(_projectName);
+  if (!projectNameValidation.isValid) {
+    throw new _helpers.CLIError(`Invalid project name: ${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,18 @@
+export * from "./command";
+export * from "./build.command";
+export * from "./deploy.command";
+export * from "./provision.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";
+export * from "./authsession.command";
+export * from "./authsession_record.command";
+export * from "./authsession_scaffold.command";

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 _provision = require("./provision.command");
+Object.keys(_provision).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _provision[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _provision[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];
+    }
+  });
+});
+var _authsession_scaffold = require("./authsession_scaffold.command");
+Object.keys(_authsession_scaffold).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _authsession_scaffold[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _authsession_scaffold[key];
+    }
+  });
+});

package/dist/commands/intuned-cli/commands/provision.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, {
+    apiKey?: string | undefined;
+    workspaceId?: string | undefined;
+}, {
+    apiKey?: string | undefined;
+    workspaceId?: string | undefined;
+}>;
+export declare const provisionCommand: import("commander").Command, saveCommand: import("commander").Command;

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

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.saveOrDeployOptionsSchema = exports.saveOrDeployArgsSchema = exports.saveCommand = exports.provisionCommand = void 0;
+var _command = require("./command");
+var _dotenv = _interopRequireDefault(require("dotenv"));
+var _provision = require("../controller/provision");
+var _helpers = require("../helpers");
+var _zod = require("zod");
+var _prompts = require("../helpers/prompts");
+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 description = "Provision an Intuned project to the platform";
+const commands = [_command.program.command("save").description(`${description}. (Deprecated, use 'provision' instead)`), _command.program.command("provision").description(description)];
+const [provisionCommand, saveCommand] = commands.map(command => command.argument("[project-name]", "Project name").option("-w, --workspace-id <id>", "Intuned Workspace ID").option("-k, --api-key <key>", "Intuned API key").action((0, _helpers.cliCommandWrapper)(saveOrDeployArgsSchema, saveOrDeployOptionsSchema, async ([projectName], options) => {
+  const {
+    isValid,
+    errorMessage
+  } = await (0, _provision.validateIntunedProject)();
+  if (!isValid) {
+    const message = `^r^+Project to be provisioned is not a valid Intuned project:^:^R ${errorMessage}:\n`;
+    throw new _helpers.CLIError(message, {
+      autoColor: false
+    });
+  }
+  const _projectName = projectName || (await (0, _helpers.loadIntunedJson)()).projectName || (await (0, _prompts.promptForProjectName)(name => {
+    const result = (0, _provision.validateProjectName)(name);
+    return result.isValid || result.errorMessage;
+  }));
+  if (!_projectName) {
+    throw new _helpers.CLIError(`Project name is required. Set it in ${await (0, _helpers.getIntunedSettingsFile)()} or provide it as an argument by running 'intuned provision <project-name>'.`);
+  }
+  const projectNameValidation = (0, _provision.validateProjectName)(_projectName);
+  if (!projectNameValidation.isValid) {
+    throw new _helpers.CLIError(`Invalid project name: ${projectNameValidation.errorMessage}`);
+  }
+  const auth = await (0, _helpers.getAuthCredentials)(options);
+  await (0, _provision.runProvisionProject)(_projectName, auth);
+})));
+exports.saveCommand = saveCommand;
+exports.provisionCommand = provisionCommand;

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

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