@intuned/runtime-dev 1.1.8-bot-detection → 1.2.0-cli.1

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

@@ -0,0 +1,182 @@
+"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) {
+        if (error instanceof _runApi.AutomationError) {
+          (0, _terminal.terminal)(`^r^+Attempt ${i + 1} failed ^:^+${apiName}^:: ^R${error.error.message}^:\n`);
+          continue;
+        }
+        throw error;
+      }
+    }
+  })();
+  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`);
+      (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;
+      }
+      throw new _helpers.CLIError(`An error occurred while running the API: ${runApiResult.error.message}`);
+    }
+    const {
+      result,
+      extendedPayloads: payloadToAppend
+    } = runApiResult.value;
+    return {
+      result,
+      payloadToAppend
+    };
+  }, timeout)();
+}

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

@@ -0,0 +1,32 @@
+import type { BaseCommandOptions } from "../commands/types";
+import { StorageState } from "../../../common/contextStorageStateHelpers";
+export declare function executeRunValidateAuthSessionCLI({ id, autoRecreate, checkRetries, createRetries, useExistingContext, ...rest }: {
+    id: string;
+    autoRecreate: boolean;
+    checkRetries: number;
+    createRetries: number;
+    useExistingContext?: boolean;
+} & BaseCommandOptions): Promise<string>;
+export declare function executeRunCreateAuthSessionCLI({ id, input, checkRetries, createRetries, log, ...rest }: {
+    id?: string;
+    input: any;
+    checkRetries: number;
+    createRetries: number;
+    log?: boolean;
+} & BaseCommandOptions): Promise<string>;
+export declare function executeRunUpdateAuthSessionCLI({ id, input, checkRetries, createRetries, ...rest }: {
+    id: string;
+    input?: any;
+    checkRetries: number;
+    createRetries: number;
+} & BaseCommandOptions): Promise<string>;
+export declare function executeAttemptCreateAuthSessionCLI({ id, input, ...rest }: {
+    id?: string;
+    input: any;
+} & BaseCommandOptions): Promise<string>;
+export declare function executeAttemptCheckAuthSessionCLI({ id, ...rest }: {
+    id: string;
+} & BaseCommandOptions): Promise<string>;
+export declare function runCreate({ authSessionInput, proxy, headless, timeout, }: {
+    authSessionInput: Record<string, any>;
+} & BaseCommandOptions): Promise<StorageState>;

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

@@ -0,0 +1,295 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.executeAttemptCheckAuthSessionCLI = executeAttemptCheckAuthSessionCLI;
+exports.executeAttemptCreateAuthSessionCLI = executeAttemptCreateAuthSessionCLI;
+exports.executeRunCreateAuthSessionCLI = executeRunCreateAuthSessionCLI;
+exports.executeRunUpdateAuthSessionCLI = executeRunUpdateAuthSessionCLI;
+exports.executeRunValidateAuthSessionCLI = executeRunValidateAuthSessionCLI;
+exports.runCreate = runCreate;
+var _utils = require("../../cli-auth-sessions/utils");
+var _path = _interopRequireDefault(require("path"));
+var _helpers = require("../commands/helpers");
+var _runApi = require("../../../common/runApi");
+var _constants = require("../../../common/constants");
+var _tsNodeImport = require("../../common/tsNodeImport");
+var _terminal = require("../terminal");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function executeRunValidateAuthSessionCLI({
+  id,
+  autoRecreate,
+  checkRetries,
+  createRetries,
+  useExistingContext = false,
+  ...rest
+}) {
+  const validate = async () => {
+    (0, _terminal.terminal)(`^+Validating auth session with id ^c${id}^:\n`);
+    const {
+      authSessionInstanceStoragePath
+    } = await (0, _utils.retrieveAuthSessionInstance)(id, true);
+    const authSessionPathToUse = authSessionInstanceStoragePath;
+    await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check");
+    const checkResult = await runCheckWithRetries({
+      authSessionPath: authSessionPathToUse,
+      retries: checkRetries,
+      ...rest
+    });
+    if (!checkResult) {
+      if (!autoRecreate) {
+        throw new _helpers.CLIError("Auto recreate is disabled, please provide a new auth session or update it manually");
+      }
+      const {
+        metadata
+      } = await (0, _utils.retrieveAuthSessionInstance)(id);
+      if (metadata?.authSessionType === "MANUAL") {
+        throw new _helpers.CLIError("Auth session is recorder-based, please provide a new one or update it manually");
+      }
+      (0, _terminal.terminal)("^+Auto recreate is enabled - trying to re-create it^:\n");
+      await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create");
+      const authSessionInput = metadata?.authSessionInput ?? {};
+      await runCreateWithRetries({
+        authSessionId: id,
+        authSessionInput,
+        retries: createRetries,
+        ...rest
+      });
+      const checkResult = await runCheckWithRetries({
+        authSessionPath: authSessionPathToUse,
+        retries: checkRetries,
+        ...rest
+      });
+      if (!checkResult) {
+        throw new _helpers.CLIError("Failed to re-create auth session");
+      }
+    }
+    (0, _terminal.terminal)(`^+^gAuth session validated successfully^:\n`);
+    return authSessionPathToUse;
+  };
+  if (useExistingContext) {
+    return await validate();
+  } else {
+    return await (0, _helpers.withCLIContext)(validate)();
+  }
+}
+async function executeRunCreateAuthSessionCLI({
+  id,
+  input,
+  checkRetries,
+  createRetries,
+  log = true,
+  ...rest
+}) {
+  return (0, _helpers.withCLIContext)(async () => {
+    id = id ?? `auth-session-${Date.now()}`;
+    (0, _terminal.terminal)(`^+Creating auth session with id ^c${id}^:\n`);
+    await Promise.all([await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create"), await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check")]);
+    const authSessionPath = await runCreateWithRetries({
+      authSessionId: id,
+      authSessionInput: input,
+      retries: createRetries,
+      ...rest
+    });
+    const checkResult = await runCheckWithRetries({
+      authSessionPath: _path.default.join(authSessionPath, "auth-session.json"),
+      retries: checkRetries,
+      ...rest
+    });
+    if (!checkResult) {
+      throw new _helpers.CLIError("Failed to create auth session");
+    }
+    if (log) {
+      (0, _terminal.terminal)(`^+^gAuth session created successfully^:\n`);
+    }
+    return authSessionPath;
+  })();
+}
+async function executeRunUpdateAuthSessionCLI({
+  id,
+  input,
+  checkRetries,
+  createRetries,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Updating auth session with id ^c${id}^:\n`);
+  return (0, _helpers.withCLIContext)(async () => {
+    if (input === undefined) {
+      const {
+        metadata
+      } = await (0, _utils.retrieveAuthSessionInstance)(id);
+      if (metadata?.authSessionType === "MANUAL") {
+        throw new Error("Auth session is recorder-based, it cannot be updated.");
+      }
+      input = metadata?.authSessionInput ?? {};
+    }
+    await Promise.all([await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create"), await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check")]);
+    const authSession = await executeRunCreateAuthSessionCLI({
+      id,
+      input,
+      checkRetries,
+      createRetries,
+      log: false,
+      ...rest
+    });
+    (0, _terminal.terminal)(`^+^gAuth session updated successfully^:\n`);
+    return authSession;
+  })();
+}
+async function executeAttemptCreateAuthSessionCLI({
+  id,
+  input,
+  ...rest
+}) {
+  id = id ?? `auth-session-attempt-${Date.now()}`;
+  (0, _terminal.terminal)(`^+Executing create auth session attempt with id ^c${id}^:\n`);
+  await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "create");
+  return await runCreateWithRetries({
+    authSessionId: id,
+    authSessionInput: input,
+    retries: 1,
+    ...rest
+  });
+}
+async function executeAttemptCheckAuthSessionCLI({
+  id,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Executing check auth session attempt with id ^c${id}^:\n`);
+  await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check");
+  const {
+    authSessionInstanceStoragePath
+  } = await (0, _utils.retrieveAuthSessionInstance)(id, true);
+  const authSessionPathToUse = authSessionInstanceStoragePath;
+  const checkResult = await runCheckWithRetries({
+    authSessionPath: authSessionPathToUse,
+    retries: 1,
+    ...rest
+  });
+  if (!checkResult) {
+    throw new Error("Check failed");
+  }
+  (0, _terminal.terminal)(`^+^gAuth session check passed^:\n`);
+  return authSessionPathToUse;
+}
+async function runCheck({
+  authSessionPath,
+  proxy,
+  headless,
+  timeout
+}) {
+  return await (0, _helpers.withTimeout)(async () => {
+    const runApiResult = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/check`
+      },
+      runOptions: {
+        headless,
+        environment: "standalone",
+        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
+      },
+      auth: {
+        session: {
+          type: "file",
+          path: authSessionPath
+        },
+        runCheck: false
+      },
+      importFunction: _tsNodeImport.tsNodeImport
+    });
+    if (runApiResult.isErr()) {
+      if (runApiResult.error instanceof _runApi.AutomationError) {
+        throw runApiResult.error;
+      }
+      return false;
+    }
+    const result = runApiResult.value.result;
+    if (!result) {
+      return false;
+    }
+    return result;
+  }, timeout)();
+}
+async function runCreate({
+  authSessionInput,
+  proxy,
+  headless,
+  timeout
+}) {
+  return await (0, _helpers.withTimeout)(async () => {
+    const createApiName = `${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`;
+    const result = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: createApiName,
+        params: authSessionInput
+      },
+      runOptions: {
+        headless,
+        environment: "standalone",
+        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
+      },
+      retrieveSession: true,
+      importFunction: _tsNodeImport.tsNodeImport
+    });
+    if (result.isErr()) {
+      if (result.error instanceof _runApi.AutomationError) {
+        throw result.error.error;
+      }
+      console.error(result.error);
+      throw new Error("Error while running create");
+    }
+    return result.value.session;
+  }, timeout)();
+}
+async function runCheckWithRetries({
+  authSessionPath,
+  retries,
+  ...rest
+}) {
+  for (let i = 0; i < retries; i++) {
+    (0, _terminal.terminal)(`\n^+Running ^cauth session check${i === 0 ? "" : ` ^/(Attempt ${i + 1})`}^:...\n`);
+    try {
+      const checkResult = await runCheck({
+        authSessionPath,
+        ...rest
+      });
+      if (checkResult) {
+        (0, _terminal.terminal)(`^+^gAuth session check passed^:\n`);
+        return true;
+      }
+    } catch (error) {
+      (0, _terminal.terminal)(`^+^yAuth session check failed with error ^:${error.message}^:\n`);
+      continue;
+    }
+    (0, _terminal.terminal)(`^+^yAuth session check failed^:\n`);
+  }
+  (0, _terminal.terminal)(`^+^rAuth session check failed after ${retries} attempts^:\n`);
+  return false;
+}
+async function runCreateWithRetries({
+  authSessionId,
+  authSessionInput,
+  retries,
+  ...rest
+}) {
+  let newAuthSessionInstance = null;
+  for (let i = 0; i < retries; i++) {
+    (0, _terminal.terminal)(`\n^+Running ^cauth session create${i === 0 ? "" : ` ^/(Attempt ${i + 1})`}^:...\n`);
+    try {
+      newAuthSessionInstance = await runCreate({
+        authSessionInput,
+        ...rest
+      });
+      (0, _terminal.terminal)(`^+^gAuth session create succeeded^:\n`);
+      break;
+    } catch (error) {
+      (0, _terminal.terminal)(`^+^yAuth session create failed with error ^:${error.message}^:\n`);
+      continue;
+    }
+  }
+  if (!newAuthSessionInstance) {
+    throw new _helpers.CLIError(`Failed to create auth session after ${retries} retries`);
+  }
+  return await (0, _utils.storeAuthSessionInstance)(newAuthSessionInstance, authSessionId, authSessionInput);
+}

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

@@ -0,0 +1 @@
+export declare const runBuild: () => Promise<boolean>;

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runBuild = void 0;
+var fs = _interopRequireWildcard(require("fs-extra"));
+var path = _interopRequireWildcard(require("path"));
+var _child_process = require("child_process");
+var _util = require("util");
+var _terminal = require("../terminal");
+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; }
+const execPromise = (0, _util.promisify)(_child_process.exec);
+const runBuild = async () => {
+  const distPath = path.join(process.cwd(), "dist");
+  if (await fs.exists(distPath)) {
+    await fs.remove(distPath);
+  }
+  const buildCommand = "tsc";
+  try {
+    await execPromise(buildCommand);
+    (0, _terminal.terminal)(`^g^+✨ Build completed successfully!^:\n`);
+    return true;
+  } catch (error) {
+    (0, _terminal.terminal)(`^r^+An error occurred during the build process:^:\n`);
+    if ("stdout" in error) {
+      (0, _terminal.terminal)(`${error.stdout}\n`);
+    } else {
+      (0, _terminal.terminal)(`^${error.message}^:\n`);
+    }
+    (0, _terminal.terminal)(`^r^+Build failed^:\n`);
+    return false;
+  }
+};
+exports.runBuild = runBuild;

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

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { AuthCredentials, FileSystemTree } from "../../../common/cli/types";
+export declare function convertProjectToCodeTree(projectPath: string): Promise<FileSystemTree>;
+export declare function runDeployProject(projectName: string, auth: AuthCredentials): Promise<void>;
+export declare const projectNameSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const validateProjectName: (projectName: string) => {
+    isValid: true;
+} | {
+    isValid: false;
+    errorMessage: string;
+};
+export declare const validateIntunedProject: () => Promise<{
+    isValid: boolean;
+    errorMessage?: string;
+}>;