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

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

@@ -0,0 +1,42 @@
+import { Payload } from "../../../runtime/export";
+import { RunApiStorageState } from "@intuned/runtime-interface";
+import type { BaseCommandOptions } from "../commands/types";
+export declare function executeRunApiCLI({ apiName, inputData, retries, authSession, outputFile, trace, ...rest }: {
+    apiName: string;
+    inputData: object | null | undefined;
+    retries: number;
+    authSession?: {
+        id: string;
+        autoRecreate: boolean;
+        checkRetries: number;
+        createRetries: number;
+    };
+    outputFile?: string;
+} & BaseCommandOptions): Promise<void>;
+export declare function executeAttemptApiCLI({ apiName, inputData, authSessionId, outputFile, trace, ...rest }: {
+    apiName: string;
+    inputData: object | null | undefined;
+    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, traceId, keepBrowserOpen, cdpUrl, }: {
+    apiName: string;
+    inputData: object | null | undefined;
+    auth?: RunApiStorageState;
+    traceId?: string;
+} & Omit<BaseCommandOptions, "trace">): Promise<{
+    result: any;
+    payloadToAppend: import("@intuned/runtime-interface").Payload[] | undefined;
+}>;
+export declare const _attemptApi: typeof attemptApi;
+export {};

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

@@ -0,0 +1,194 @@
+"use strict";
+
+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 _runtimeInterface = require("../../../vendor/runtime-interface");
+var _helpers = require("../helpers");
+var _terminal = require("../helpers/terminal");
+var _constants = require("../../../common/constants");
+var _browser = require("../helpers/browser");
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+async function executeRunApiCLI({
+  apiName,
+  inputData,
+  retries,
+  authSession,
+  outputFile,
+  trace,
+  ...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 (async () => {
+    for (let i = 0; i < retries; i++) {
+      (0, _terminal.terminal)(`\n^+Executing ^c${apiName} ^/(Attempt ${i + 1}) ^:...\n`);
+      let auth;
+      if (authSession) {
+        auth = await (0, _authSession.executeRunValidateAuthSessionCLI)({
+          ...authSession,
+          trace,
+          ...rest
+        });
+      }
+      try {
+        return await attemptApi({
+          apiName,
+          inputData,
+          auth,
+          traceId: trace ? `${apiName}-attempt-${i + 1}` : undefined,
+          ...rest
+        });
+      } catch (error) {
+        if (error instanceof _runtimeInterface.RunAutomationError) {
+          (0, _helpers.logAutomationError)(error);
+          (0, _terminal.terminal)(`^r^+Attempt ${i + 1} failed^:\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,
+  trace,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Execute API attempt for ^c${apiName}^:\n`);
+  await (0, _helpers.assertApiFileExists)(_constants.API_FOLDER_NAME, apiName);
+  (0, _helpers.registerGetAuthSessionParameters)(authSessionId);
+  let storageState;
+  if (authSessionId) {
+    ({
+      storageState
+    } = await (0, _helpers.loadAuthSessionInstance)(authSessionId));
+  }
+  return await (0, _helpers.withCLIContext)(async () => {
+    const apiResult = await attemptApi({
+      apiName,
+      inputData,
+      auth: storageState,
+      traceId: trace ? `${apiName}-attempt` : undefined,
+      ...rest
+    });
+    return await handleApiResult({
+      apiResult,
+      outputFile
+    });
+  }, {
+    authSessionId
+  });
+}
+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);
+}
+const _handleApiResult = exports._handleApiResult = handleApiResult;
+async function writeResultToFile(outputFile, result, payloadToAppend) {
+  const resultToWrite = {
+    result
+  };
+  if (payloadToAppend && payloadToAppend.length > 0) {
+    resultToWrite["extendedPayloads"] = payloadToAppend;
+  }
+  try {
+    await fs.ensureDir(_path.default.dirname(outputFile));
+    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}`);
+  }
+}
+const _writeResultToFile = exports._writeResultToFile = writeResultToFile;
+async function attemptApi({
+  apiName,
+  inputData,
+  auth,
+  proxy,
+  headless,
+  timeout,
+  traceId,
+  keepBrowserOpen,
+  cdpUrl
+}) {
+  return await (0, _helpers.withTimeout)(async abortSignal => (0, _helpers.withCLITrace)(async tracing => {
+    const runApiResult = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: `${_constants.API_FOLDER_NAME}/${apiName}`,
+        params: inputData
+      },
+      runOptions: await (0, _browser.getCLIRunOptions)({
+        headless,
+        proxy,
+        keepBrowserOpen,
+        cdpUrl
+      }),
+      auth: auth ? {
+        session: {
+          type: "state",
+          state: auth
+        }
+      } : undefined,
+      tracing,
+      importFunction: _tsNodeImport.tsNodeImport,
+      abortSignal
+    });
+    if (runApiResult.isErr()) {
+      throw runApiResult.error;
+    }
+    const {
+      result,
+      extendedPayloads: payloadToAppend
+    } = runApiResult.value;
+    return {
+      result,
+      payloadToAppend
+    };
+  }, traceId), timeout);
+}
+const _attemptApi = exports._attemptApi = attemptApi;

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

@@ -0,0 +1,209 @@
+import type { BaseCommandOptions } from "../commands/types";
+import { AuthSessionMetadata } from "../types";
+import { RunApiStorageState } from "@intuned/runtime-interface";
+export declare function executeRunValidateAuthSessionCLI({ id, autoRecreate, checkRetries, createRetries, ...rest }: {
+    id: string;
+    autoRecreate: boolean;
+    checkRetries: number;
+    createRetries: number;
+} & BaseCommandOptions): Promise<RunApiStorageState>;
+export declare function executeRunCreateAuthSessionCLI({ id, input, checkRetries, createRetries, log, ...rest }: {
+    id?: string;
+    input: any;
+    checkRetries: number;
+    createRetries: number;
+    log?: boolean;
+    metadata?: AuthSessionMetadata;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        path: string;
+        name: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        origin: string;
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[] | undefined;
+}>;
+export declare function executeRunUpdateAuthSessionCLI({ id, input, checkRetries, createRetries, ...rest }: {
+    id: string;
+    input?: any;
+    checkRetries: number;
+    createRetries: number;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        path: string;
+        name: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        origin: string;
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[] | undefined;
+}>;
+export declare function executeAttemptCreateAuthSessionCLI({ id, input, ...rest }: {
+    id?: string;
+    input: any;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        path: string;
+        name: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        origin: string;
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[] | undefined;
+}>;
+export declare function executeAttemptCheckAuthSessionCLI({ id, ...rest }: {
+    id: string;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        path: string;
+        name: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        origin: string;
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[] | undefined;
+}>;
+declare function runCheck({ auth, proxy, headless, timeout, traceId, keepBrowserOpen, cdpUrl, }: {
+    auth: RunApiStorageState;
+    traceId?: string;
+} & Omit<BaseCommandOptions, "trace">): Promise<boolean>;
+export declare const _runCheck: typeof runCheck;
+declare function runCreate({ authSessionInput, proxy, headless, timeout, traceId, keepBrowserOpen, cdpUrl, }: {
+    authSessionInput: Record<string, any>;
+    traceId?: string;
+} & Omit<BaseCommandOptions, "trace">): Promise<{
+    cookies: {
+        value: string;
+        path: string;
+        name: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        origin: string;
+        sessionStorage: {
+            value: string;
+            name: 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, trace, metadata, ...rest }: {
+    authSessionId: string;
+    authSessionInput: any;
+    retries?: number;
+    metadata?: AuthSessionMetadata;
+} & BaseCommandOptions): Promise<{
+    cookies: {
+        value: string;
+        path: string;
+        name: string;
+        domain: string;
+        expires: number;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "Strict" | "Lax" | "None";
+    }[];
+    origins: {
+        origin: string;
+        localStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[];
+    sessionStorage?: {
+        origin: string;
+        sessionStorage: {
+            value: string;
+            name: string;
+        }[];
+    }[] | undefined;
+}>;
+export declare const _runCreateWithRetries: typeof runCreateWithRetries;
+export declare function executeRecordAuthSessionCLI({ id, checkRetries, timeout, headless, proxy, trace, keepBrowserOpen, startUrl, finishUrl, }: {
+    id?: string;
+    checkRetries: number;
+    startUrl: string;
+    finishUrl: string;
+} & BaseCommandOptions): Promise<void>;
+export {};