@intuned/runtime-dev 1.2.0-cli.0 → 1.2.0-cli.10

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

@@ -1,3 +1,5 @@
+import { Payload } from "../../../runtime/export";
+import { RunApiStorageState } from "../../../common/runApi";
 import type { BaseCommandOptions } from "../commands/types";
 export declare function executeRunApiCLI({ apiName, inputData, retries, authSession, outputFile, ...rest }: {
     apiName: string;
@@ -17,3 +19,26 @@ export declare function executeAttemptApiCLI({ apiName, inputData, authSessionId
     authSessionId?: string;
     outputFile?: string;
 } & BaseCommandOptions): Promise<void>;
+declare function handleApiResult({ apiResult, outputFile, }: {
+    apiResult: {
+        result: any;
+        payloadToAppend?: Payload[];
+    };
+    outputFile?: string;
+}): Promise<void>;
+export declare const _handleApiResult: typeof handleApiResult;
+declare function writeResultToFile(outputFile: string, result: any, payloadToAppend?: Payload[]): Promise<void>;
+export declare const _writeResultToFile: typeof writeResultToFile;
+declare function attemptApi({ apiName, inputData, auth, proxy, headless, timeout, }: {
+    apiName: string;
+    inputData: object | null | undefined;
+    auth?: RunApiStorageState;
+    proxy?: string | undefined;
+    headless: boolean;
+    timeout: number;
+}): Promise<{
+    result: any;
+    payloadToAppend: Payload[] | undefined;
+}>;
+export declare const _attemptApi: typeof attemptApi;
+export {};

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

@@ -3,15 +3,15 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports._writeResultToFile = exports._handleApiResult = exports._attemptApi = void 0;
 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 _helpers = require("../helpers");
+var _terminal = require("../helpers/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; }
@@ -24,15 +24,15 @@ async function executeRunApiCLI({
   ...rest
 }) {
   await (0, _helpers.assertApiFileExists)(_constants.API_FOLDER_NAME, apiName);
+  (0, _helpers.registerGetAuthSessionParameters)(authSession?.id);
   (0, _terminal.terminal)(`^+Running API ^c${apiName}^:\n`);
-  const apiResult = await (0, _helpers.withCLIContext)(async () => {
+  const apiResult = await (async () => {
     for (let i = 0; i < retries; i++) {
       (0, _terminal.terminal)(`\n^+Executing ^c${apiName} ^/(Attempt ${i + 1}) ^:...\n`);
-      let authSessionPathToUse;
+      let auth;
       if (authSession) {
-        authSessionPathToUse = await (0, _authSession.executeRunValidateAuthSessionCLI)({
+        auth = await (0, _authSession.executeRunValidateAuthSessionCLI)({
           ...authSession,
-          useExistingContext: true,
           ...rest
         });
       }
@@ -40,18 +40,16 @@ async function executeRunApiCLI({
         return await attemptApi({
           apiName,
           inputData,
-          auth: authSessionPathToUse ? {
-            session: {
-              type: "file",
-              path: authSessionPathToUse
-            },
-            runCheck: false
-          } : undefined,
+          auth,
           ...rest
         });
       } catch (error) {
-        (0, _terminal.terminal)(`^r^+Failed to run API ^:^+${apiName}^:: ^R${error.message}^:\n`);
-        continue;
+        if (error instanceof _runApi.AutomationError) {
+          (0, _helpers.logAutomationError)(error);
+          (0, _terminal.terminal)(`^r^+Attempt ${i + 1} failed^:\n`);
+          continue;
+        }
+        throw error;
       }
     }
   })();
@@ -74,30 +72,27 @@ async function executeAttemptApiCLI({
 }) {
   (0, _terminal.terminal)(`^+Execute API attempt for ^c${apiName}^:\n`);
   await (0, _helpers.assertApiFileExists)(_constants.API_FOLDER_NAME, apiName);
-  let authSessionInstance;
+  (0, _helpers.registerGetAuthSessionParameters)(authSessionId);
+  let storageState;
   if (authSessionId) {
     ({
-      authSessionInstance
-    } = await (0, _utils.retrieveAuthSessionInstance)(authSessionId));
+      storageState
+    } = await (0, _helpers.loadAuthSessionInstance)(authSessionId));
   }
   return await (0, _helpers.withCLIContext)(async () => {
     const apiResult = await attemptApi({
       apiName,
       inputData,
-      auth: authSessionInstance ? {
-        session: {
-          type: "state",
-          state: authSessionInstance
-        },
-        runCheck: false
-      } : undefined,
+      auth: storageState,
       ...rest
     });
     return await handleApiResult({
       apiResult,
       outputFile
     });
-  })();
+  }, {
+    authSessionId
+  });
 }
 async function handleApiResult({
   apiResult,
@@ -116,13 +111,14 @@ async function handleApiResult({
       (0, _terminal.terminal)(`${JSON.stringify(result, null, 2)}\n`);
     }
     if (payloadToAppend && payloadToAppend.length > 0) {
-      (0, _terminal.terminal)(`^+^gExtended payloads:^ ^/^G(This will only take effect if this API run was part of a job.)^:\n:\n`);
+      (0, _terminal.terminal)(`^+^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);
 }
+const _handleApiResult = exports._handleApiResult = handleApiResult;
 async function writeResultToFile(outputFile, result, payloadToAppend) {
   const resultToWrite = {
     result
@@ -139,6 +135,7 @@ async function writeResultToFile(outputFile, result, payloadToAppend) {
     throw new _helpers.CLIError(`Failed to write result to file: ${error.message}`);
   }
 }
+const _writeResultToFile = exports._writeResultToFile = writeResultToFile;
 async function attemptApi({
   apiName,
   inputData,
@@ -147,10 +144,10 @@ async function attemptApi({
   headless,
   timeout
 }) {
-  return await (0, _helpers.withTimeout)(async () => {
+  return await (0, _helpers.withTimeout)(async abortSignal => {
     const runApiResult = await (0, _runApi.runApi)({
       automationFunction: {
-        name: `api/${apiName}`,
+        name: `${_constants.API_FOLDER_NAME}/${apiName}`,
         params: inputData
       },
       runOptions: {
@@ -158,14 +155,18 @@ async function attemptApi({
         environment: "standalone",
         proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
       },
-      auth,
-      importFunction: _tsNodeImport.tsNodeImport
+      auth: auth ? {
+        session: {
+          type: "state",
+          state: auth
+        },
+        runCheck: false
+      } : undefined,
+      importFunction: _tsNodeImport.tsNodeImport,
+      abortSignal
     });
     if (runApiResult.isErr()) {
-      if (runApiResult.error instanceof _runApi.AutomationError) {
-        throw runApiResult.error.error;
-      }
-      throw new _helpers.CLIError(`An error occurred while running the API: ${runApiResult.error.message}`);
+      throw runApiResult.error;
     }
     const {
       result,
@@ -175,5 +176,6 @@ async function attemptApi({
       result,
       payloadToAppend
     };
-  }, timeout)();
-}
+  }, timeout);
+}
+const _attemptApi = exports._attemptApi = attemptApi;

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

@@ -1,32 +1,198 @@
 import type { BaseCommandOptions } from "../commands/types";
-import { StorageState } from "../../../common/contextStorageStateHelpers";
-export declare function executeRunValidateAuthSessionCLI({ id, autoRecreate, checkRetries, createRetries, useExistingContext, ...rest }: {
+import { RunApiStorageState } from "../../../common/runApi";
+export declare function executeRunValidateAuthSessionCLI({ id, autoRecreate, checkRetries, createRetries, ...rest }: {
     id: string;
     autoRecreate: boolean;
     checkRetries: number;
     createRetries: number;
-    useExistingContext?: boolean;
-} & BaseCommandOptions): Promise<string>;
+} & BaseCommandOptions): Promise<RunApiStorageState>;
 export declare function executeRunCreateAuthSessionCLI({ id, input, checkRetries, createRetries, log, ...rest }: {
     id?: string;
     input: any;
     checkRetries: number;
     createRetries: number;
     log?: boolean;
-} & BaseCommandOptions): Promise<string>;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        name: string;
+        path: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+        origin: string;
+    }[] | undefined;
+}>;
 export declare function executeRunUpdateAuthSessionCLI({ id, input, checkRetries, createRetries, ...rest }: {
     id: string;
     input?: any;
     checkRetries: number;
     createRetries: number;
-} & BaseCommandOptions): Promise<string>;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        name: string;
+        path: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+        origin: string;
+    }[] | undefined;
+}>;
 export declare function executeAttemptCreateAuthSessionCLI({ id, input, ...rest }: {
     id?: string;
     input: any;
-} & BaseCommandOptions): Promise<string>;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        name: string;
+        path: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+        origin: string;
+    }[] | undefined;
+}>;
 export declare function executeAttemptCheckAuthSessionCLI({ id, ...rest }: {
     id: string;
-} & BaseCommandOptions): Promise<string>;
-export declare function runCreate({ authSessionInput, proxy, headless, timeout, }: {
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        name: string;
+        path: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+        origin: string;
+    }[] | undefined;
+}>;
+declare function runCheck({ auth, proxy, headless, timeout, }: {
+    auth: RunApiStorageState;
+} & BaseCommandOptions): Promise<boolean>;
+export declare const _runCheck: typeof runCheck;
+declare function runCreate({ authSessionInput, proxy, headless, timeout, }: {
     authSessionInput: Record<string, any>;
-} & BaseCommandOptions): Promise<StorageState>;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        name: string;
+        path: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+        origin: string;
+    }[] | undefined;
+}>;
+export declare const _runCreate: typeof runCreate;
+declare function runCheckWithRetries({ auth, retries, ...rest }: {
+    auth: RunApiStorageState;
+    retries: number;
+} & BaseCommandOptions): Promise<boolean>;
+export declare const _runCheckWithRetries: typeof runCheckWithRetries;
+declare function runCreateWithRetries({ authSessionId, authSessionInput, retries, ...rest }: {
+    authSessionId: string;
+    authSessionInput: any;
+    retries: number;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        name: string;
+        path: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+        origin: string;
+    }[] | undefined;
+}>;
+export declare const _runCreateWithRetries: typeof runCreateWithRetries;
+export {};