@intuned/runtime-dev 1.3.0-dev-52 → 1.3.0-responseLimits.1

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

@@ -0,0 +1,44 @@
+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;
+    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, ...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, }: {
+    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

@@ -0,0 +1,181 @@
+"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 _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; }
+async function executeRunApiCLI({
+  apiName,
+  inputData,
+  retries,
+  authSession,
+  outputFile,
+  ...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,
+          ...rest
+        });
+      }
+      try {
+        return await attemptApi({
+          apiName,
+          inputData,
+          auth,
+          ...rest
+        });
+      } catch (error) {
+        if (error instanceof _runApi.AutomationError) {
+          (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,
+  ...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,
+      ...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.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
+}) {
+  return await (0, _helpers.withTimeout)(async abortSignal => {
+    const runApiResult = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: `${_constants.API_FOLDER_NAME}/${apiName}`,
+        params: inputData
+      },
+      runOptions: {
+        headless,
+        environment: "standalone",
+        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
+      },
+      auth: auth ? {
+        session: {
+          type: "state",
+          state: auth
+        },
+        runCheck: false
+      } : undefined,
+      importFunction: _tsNodeImport.tsNodeImport,
+      abortSignal
+    });
+    if (runApiResult.isErr()) {
+      throw runApiResult.error;
+    }
+    const {
+      result,
+      extendedPayloads: payloadToAppend
+    } = runApiResult.value;
+    return {
+      result,
+      payloadToAppend
+    };
+  }, timeout);
+}
+const _attemptApi = exports._attemptApi = attemptApi;

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

@@ -0,0 +1,198 @@
+import type { BaseCommandOptions } from "../commands/types";
+import { RunApiStorageState } from "../../../common/runApi";
+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;
+} & 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<{
+    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<{
+    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<{
+    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<{
+    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 {};

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

@@ -0,0 +1,292 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._runCreateWithRetries = exports._runCreate = exports._runCheckWithRetries = exports._runCheck = void 0;
+exports.executeAttemptCheckAuthSessionCLI = executeAttemptCheckAuthSessionCLI;
+exports.executeAttemptCreateAuthSessionCLI = executeAttemptCreateAuthSessionCLI;
+exports.executeRunCreateAuthSessionCLI = executeRunCreateAuthSessionCLI;
+exports.executeRunUpdateAuthSessionCLI = executeRunUpdateAuthSessionCLI;
+exports.executeRunValidateAuthSessionCLI = executeRunValidateAuthSessionCLI;
+var _helpers = require("../helpers");
+var _runApi = require("../../../common/runApi");
+var _constants = require("../../../common/constants");
+var _tsNodeImport = require("../../common/tsNodeImport");
+var _terminal = require("../helpers/terminal");
+async function executeRunValidateAuthSessionCLI({
+  id,
+  autoRecreate,
+  checkRetries,
+  createRetries,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Validating auth session with id ^c${id}^:\n`);
+  const {
+    storageState
+  } = await (0, _helpers.loadAuthSessionInstance)(id);
+  await (0, _helpers.assertApiFileExists)(_constants.AUTH_SESSIONS_FOLDER_NAME, "check");
+  (0, _helpers.registerGetAuthSessionParameters)(id);
+  const checkResult = await runCheckWithRetries({
+    auth: storageState,
+    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, _helpers.loadAuthSessionInstance)(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 ?? {};
+    const storageState = await runCreateWithRetries({
+      authSessionId: id,
+      authSessionInput,
+      retries: createRetries,
+      ...rest
+    });
+    const checkResult = await runCheckWithRetries({
+      auth: storageState,
+      retries: checkRetries,
+      ...rest
+    });
+    if (!checkResult) {
+      throw new _helpers.CLIError("Failed to re-create auth session");
+    }
+  }
+  (0, _terminal.terminal)(`^+^gAuth session validated successfully^:\n`);
+  return storageState;
+}
+async function executeRunCreateAuthSessionCLI({
+  id,
+  input,
+  checkRetries,
+  createRetries,
+  log = true,
+  ...rest
+}) {
+  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 createdStorageState = await runCreateWithRetries({
+    authSessionId: id,
+    authSessionInput: input,
+    retries: createRetries,
+    ...rest
+  });
+  const auth = createdStorageState;
+  const checkResult = await runCheckWithRetries({
+    auth,
+    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 auth;
+}
+async function executeRunUpdateAuthSessionCLI({
+  id,
+  input,
+  checkRetries,
+  createRetries,
+  ...rest
+}) {
+  (0, _terminal.terminal)(`^+Updating auth session with id ^c${id}^:\n`);
+  if (input === undefined) {
+    const {
+      metadata
+    } = await (0, _helpers.loadAuthSessionInstance)(id);
+    if (metadata?.authSessionType === "MANUAL") {
+      throw new _helpers.CLIError("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");
+  (0, _helpers.registerGetAuthSessionParameters)(id);
+  const {
+    storageState
+  } = await (0, _helpers.loadAuthSessionInstance)(id);
+  const checkResult = await runCheckWithRetries({
+    auth: storageState,
+    retries: 1,
+    ...rest
+  });
+  if (!checkResult) {
+    throw new _helpers.CLIError("Check failed");
+  }
+  (0, _terminal.terminal)(`^+^gAuth session check passed^:\n`);
+  return storageState;
+}
+async function runCheck({
+  auth,
+  proxy,
+  headless,
+  timeout
+}) {
+  return await (0, _helpers.withTimeout)(async abortSignal => {
+    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: "state",
+          state: auth
+        },
+        runCheck: false
+      },
+      importFunction: _tsNodeImport.tsNodeImport,
+      abortSignal
+    });
+    if (runApiResult.isErr()) {
+      throw runApiResult.error;
+    }
+    const result = runApiResult.value.result;
+    if (!result) {
+      return false;
+    }
+    return result;
+  }, timeout);
+}
+const _runCheck = exports._runCheck = runCheck;
+async function runCreate({
+  authSessionInput,
+  proxy,
+  headless,
+  timeout
+}) {
+  return await (0, _helpers.withTimeout)(async abortSignal => {
+    const result = await (0, _runApi.runApi)({
+      automationFunction: {
+        name: `${_constants.AUTH_SESSIONS_FOLDER_NAME}/create`,
+        params: authSessionInput
+      },
+      runOptions: {
+        headless,
+        environment: "standalone",
+        proxy: proxy ? (0, _helpers.parseUrlProxy)(proxy) : undefined
+      },
+      retrieveSession: true,
+      importFunction: _tsNodeImport.tsNodeImport,
+      abortSignal
+    });
+    if (result.isErr()) {
+      throw result.error;
+    }
+    return result.value.session;
+  }, timeout);
+}
+const _runCreate = exports._runCreate = runCreate;
+async function runCheckWithRetries({
+  auth,
+  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({
+        auth,
+        ...rest
+      });
+      if (checkResult) {
+        (0, _terminal.terminal)(`^+^gAuth session check passed^:\n`);
+        return true;
+      }
+    } catch (error) {
+      if (error instanceof _runApi.AutomationError) {
+        (0, _helpers.logAutomationError)(error);
+      } else {
+        throw error;
+      }
+    }
+    (0, _terminal.terminal)(`^+^yAuth session check failed^:\n`);
+  }
+  (0, _terminal.terminal)(`^+^rAuth session check failed after ${retries} attempts^:\n`);
+  return false;
+}
+const _runCheckWithRetries = exports._runCheckWithRetries = runCheckWithRetries;
+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) {
+      if (error instanceof _runApi.AutomationError) {
+        (0, _helpers.logAutomationError)(error);
+      } else {
+        throw error;
+      }
+      (0, _terminal.terminal)(`^+^yAuth session create failed^:\n`);
+    }
+  }
+  if (!newAuthSessionInstance) {
+    throw new _helpers.CLIError(`Failed to create auth session after ${retries} retries`);
+  }
+  await (0, _helpers.storeAuthSessionInstance)({
+    state: newAuthSessionInstance,
+    id: authSessionId,
+    input: authSessionInput,
+    proxy: rest.proxy
+  });
+  return newAuthSessionInstance;
+}
+const _runCreateWithRetries = exports._runCreateWithRetries = runCreateWithRetries;