@qawolf/ci-sdk 0.22.0 → 0.23.1

package/dist/index.mjs

@@ -0,0 +1,1610 @@
+import slugify from 'slugify';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/lib/other.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+function pluralize(count) {
+  return count === 1 ? "" : "s";
+}
+__name(pluralize, "pluralize");
+function getBackoffMs(attemptNumber, minWaitMs = 1e3, maxWaitMs = 1e4) {
+  return Math.min(maxWaitMs, minWaitMs * 1.2 ** attemptNumber);
+}
+__name(getBackoffMs, "getBackoffMs");
+var buildFetchWithTimeout = /* @__PURE__ */ __name((fetch, timeout) => async (...args) => fetch(args[0], {
+  ...args[1],
+  signal: AbortSignal.timeout(timeout)
+}), "buildFetchWithTimeout");
+
+// src/lib/sdk/defaults/fetch.ts
+var defaultFetch = globalThis.fetch;
+
+// src/lib/sdk/defaults/log.ts
+var defaultLogDriver = {
+  error(message, error) {
+    console.error(message, error);
+  },
+  info(message) {
+    console.log(message);
+  },
+  warn(message) {
+    console.warn(message);
+  }
+};
+
+// src/lib/sdk/defaults/serviceBase.ts
+var defaultServiceBase = "https://app.qawolf.com/";
+
+// package.json
+var version = "0.23.1";
+
+// src/lib/sdk/defaults/userAgent.ts
+var defaultUserAgent = `ci-sdk/${version}`;
+
+// src/lib/api/log.ts
+async function logFetchError({ log, methodName, response }) {
+  if (response.ok) return;
+  const { eventId, failureMessage } = await (async () => {
+    try {
+      const body = await response.json().catch(() => response.text());
+      if (typeof body === "object" && body !== null) {
+        return {
+          eventId: body.eventId,
+          failureMessage: body.failureMessage
+        };
+      }
+      return {
+        eventId: void 0,
+        failureMessage: body
+      };
+    } catch {
+      return {
+        eventId: undefined,
+        failureMessage: undefined
+      };
+    }
+  })();
+  const eventIdSuffix = eventId ? ` (Event ID: ${eventId})` : "";
+  const messageSuffix = failureMessage ? `: ${failureMessage}` : "";
+  const statusText = response.status >= 500 ? "Server Error" : response.statusText || "Unknown Error";
+  log.error(`\u274C [${methodName}] ${response.status} ${statusText}${eventIdSuffix}${messageSuffix}`);
+}
+__name(logFetchError, "logFetchError");
+
+// src/lib/sdk/domain/attemptDeploy/index.ts
+async function attemptNotifyDeploy(deps, apiConfig, config) {
+  const { fetch: localFetch, log } = deps;
+  try {
+    const response = await localFetch(new URL("/api/webhooks/deploy_success", apiConfig.serviceBase), {
+      body: JSON.stringify({
+        branch: config.branch,
+        commit_url: config.commitUrl,
+        deduplication_key: config.deduplicationKey,
+        deployment_type: config.deploymentType,
+        deployment_url: config.deploymentUrl,
+        hosting_service: config.hostingService,
+        merge_request_number: config.hostingService === "GitLab" ? config.mergeRequestNumber : void 0,
+        pull_request_number: config.hostingService === "GitHub" ? config.pullRequestNumber : void 0,
+        repository: config.repository,
+        sha: config.sha,
+        variables: config.variables
+      }),
+      headers: {
+        Authorization: `Bearer ${apiConfig.apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": apiConfig.userAgent
+      },
+      method: "POST"
+    });
+    if (!response.ok) return handleErrorResponse(response, log);
+    const data = await response.json();
+    return handleSuccessResponse(data, log);
+  } catch (error) {
+    log.error(`\u{1F6AB} Network error from deploy_success, aborting.`);
+    return {
+      abortReason: "network-error",
+      httpStatus: undefined,
+      outcome: "aborted"
+    };
+  }
+}
+__name(attemptNotifyDeploy, "attemptNotifyDeploy");
+async function handleErrorResponse(response, log) {
+  const status = response.status;
+  let abortReason;
+  if (status === undefined) abortReason = "network-error";
+  else if (status === 401) abortReason = "401-unauthorized";
+  else if (status === 403) abortReason = "403-forbidden";
+  else if (status >= 500) abortReason = "5XX-server-error";
+  else abortReason = "4XX-client-error";
+  await logFetchError({
+    log,
+    methodName: "attemptNotifyDeploy",
+    response
+  });
+  return {
+    abortReason,
+    httpStatus: status,
+    outcome: "aborted"
+  };
+}
+__name(handleErrorResponse, "handleErrorResponse");
+async function handleSuccessResponse(data, log) {
+  const { environment, results } = data;
+  const isPreviewDeployment = environment && !environment.isStatic;
+  if (environment) {
+    const logPrefix = environment.isStatic ? "Static environment" : "Preview environment";
+    log.info(`${logPrefix}: ${environment.alias} (id: ${environment.id})`);
+  }
+  if (results.length === 0) {
+    if (isPreviewDeployment) {
+      log.info(`\u2705 Deployment notification was successful. No run was created for this deployment.`);
+      return {
+        environmentId: environment.id,
+        outcome: "success",
+        runId: undefined
+      };
+    }
+    log.error(`\u{1F6AB} No trigger matched the request. Please contact support.`);
+    return {
+      failReason: "no-matched-trigger",
+      outcome: "failed"
+    };
+  }
+  if (!environment) {
+    log.error(`\u{1F6AB} No environment matched the request. Please contact support.`);
+    return {
+      failReason: "no-environment",
+      outcome: "failed"
+    };
+  }
+  const failedTrigger = results.find((t) => "failure_reason" in t);
+  if (failedTrigger) {
+    log.error(`\u{1F6AB} Run could not be created. Reason: "${failedTrigger.failure_reason}". Please contact support.`);
+    return {
+      failReason: "run-could-not-be-created",
+      outcome: "failed"
+    };
+  }
+  const duplicateSuite = results.find((t) => "duplicate_suite_id" in t);
+  if (duplicateSuite) {
+    log.info(`\u2705 Deployment notification was successful. Previous run ID: ${duplicateSuite.duplicate_suite_id} already exists for this deployment.`);
+    return {
+      environmentId: environment.id,
+      outcome: "success",
+      runId: duplicateSuite.duplicate_suite_id
+    };
+  }
+  const successfulTrigger = results.find((t) => "created_suite_id" in t);
+  if (!successfulTrigger) {
+    log.error(`\u{1F6AB} No trigger matched the request. Please contact support.`);
+    return {
+      failReason: "no-matched-trigger",
+      outcome: "failed"
+    };
+  }
+  log.info(`\u2705 Deployment notification was successful. Run created with ID: ${successfulTrigger.created_suite_id}`);
+  return {
+    environmentId: environment.id,
+    outcome: "success",
+    runId: successfulTrigger.created_suite_id
+  };
+}
+__name(handleSuccessResponse, "handleSuccessResponse");
+
+// src/lib/api/generate-signed-url-for-run-inputs-executables.ts
+async function callGenerateSignedUrlForRunInputsExecutablesStorage({ apiKey, serviceBase, userAgent }, { destinationFilePath }, { fetch: localFetch, log }) {
+  try {
+    const response = await localFetch(new URL(`${serviceBase}/api/v0/run-inputs-executables-signed-urls?file=${encodeURIComponent(destinationFilePath)}`), {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": userAgent
+      },
+      method: "GET"
+    });
+    if (response.status === 200) {
+      const json = await response.json();
+      return {
+        fileLocation: json.fileLocation,
+        httpStatus: response.status,
+        playgroundFileLocation: json.playgroundFileLocation,
+        signedUrl: json.signedUrl,
+        success: true
+      };
+    }
+    await logFetchError({
+      log,
+      methodName: "callGenerateSignedUrlForRunInputsExecutablesStorage",
+      response
+    });
+    return {
+      errorMessage: await response.text(),
+      httpStatus: response.status,
+      success: false
+    };
+  } catch (e) {
+    return {
+      errorMessage: "Network error, aborting request to generate signed URL",
+      httpStatus: 0,
+      success: false
+    };
+  }
+}
+__name(callGenerateSignedUrlForRunInputsExecutablesStorage, "callGenerateSignedUrlForRunInputsExecutablesStorage");
+
+// src/lib/sdk/domain/generateSignedUrls/generate-signed-url-for-run-inputs-executables.ts
+async function generateSignedUrlForRunInputsExecutablesStorage(deps, apiConfig, config) {
+  const { log } = deps;
+  if (!config.destinationFilePath) {
+    log.error(`\u{1F6AB} destinationFilePath is a required config parameter`);
+    return {
+      abortReason: "sdk-argument-validation-failed",
+      success: false
+    };
+  }
+  const responseState = await callGenerateSignedUrlForRunInputsExecutablesStorage(apiConfig, config, deps);
+  if (!responseState.success) {
+    let abortReason = "XXX-other-http-code";
+    if (responseState.httpStatus >= 500) {
+      abortReason = "5XX-server-error";
+      log.error(`\u{1F6AB} Unrecoverable error (status ${responseState.httpStatus}) when generating signed upload url: aborting.`);
+    } else {
+      if (responseState.httpStatus === 400) abortReason = "400-invalid-request";
+      else if (responseState.httpStatus === 401) abortReason = "401-invalid-credentials";
+      else if (responseState.httpStatus === 403) abortReason = "403-forbidden";
+      else if (responseState.httpStatus === 0) abortReason = "client-network-error";
+      log.error(`\u{1F6AB} Unrecoverable error (status ${responseState.httpStatus}) when generating signed upload url: ${responseState.errorMessage ? `${responseState.errorMessage}.` : ""} aborting.`);
+    }
+    return {
+      abortReason,
+      httpStatus: responseState.httpStatus,
+      success: false
+    };
+  }
+  log.info(`\u2705 Generated Signed Upload URL: ${responseState.signedUrl}.`);
+  return {
+    fileLocation: responseState.fileLocation,
+    playgroundFileLocation: responseState.playgroundFileLocation,
+    success: true,
+    uploadUrl: responseState.signedUrl
+  };
+}
+__name(generateSignedUrlForRunInputsExecutablesStorage, "generateSignedUrlForRunInputsExecutablesStorage");
+
+// src/lib/api/generate-signed-url-for-team-storage.ts
+async function callGenerateSignedUrlForTempTeamStorage({ apiKey, serviceBase, userAgent }, { destinationFilePath }, { fetch: localFetch, log }) {
+  try {
+    const response = await localFetch(new URL(`${serviceBase}/api/v0/team-storage-signed-url?file=${destinationFilePath}`), {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": userAgent
+      },
+      method: "GET"
+    });
+    if (response.status === 200) {
+      const json = await response.json();
+      return {
+        fileLocation: json.fileLocation,
+        httpStatus: response.status,
+        playgroundFileLocation: json.playgroundFileLocation,
+        signedUrl: json.signedUrl,
+        success: true
+      };
+    }
+    await logFetchError({
+      log,
+      methodName: "callGenerateSignedUrlForTempTeamStorage",
+      response
+    });
+    return {
+      errorMessage: await response.text(),
+      httpStatus: response.status,
+      success: false
+    };
+  } catch (e) {
+    return {
+      errorMessage: "Network error, aborting request to generate signed URL",
+      httpStatus: 0,
+      success: false
+    };
+  }
+}
+__name(callGenerateSignedUrlForTempTeamStorage, "callGenerateSignedUrlForTempTeamStorage");
+
+// src/lib/sdk/domain/generateSignedUrls/generate-signed-url-for-team-storage.ts
+async function generateSignedUrlForTempTeamStorage(deps, apiConfig, config) {
+  const { log } = deps;
+  if (!config.destinationFilePath) {
+    log.error(`\u{1F6AB} destinationFilePath is a required config parameter`);
+    return {
+      abortReason: "sdk-argument-validation-failed",
+      success: false
+    };
+  }
+  const responseState = await callGenerateSignedUrlForTempTeamStorage(apiConfig, config, deps);
+  if (!responseState.success) {
+    let abortReason = "XXX-other-http-code";
+    if (responseState.httpStatus >= 500) {
+      abortReason = "5XX-server-error";
+      log.error(`\u{1F6AB} Unrecoverable error (status ${responseState.httpStatus}) when generating signed upload url: aborting.`);
+    } else {
+      if (responseState.httpStatus === 400) abortReason = "400-invalid-request";
+      else if (responseState.httpStatus === 401) abortReason = "401-invalid-credentials";
+      else if (responseState.httpStatus === 403) abortReason = "403-forbidden";
+      else if (responseState.httpStatus === 0) abortReason = "client-network-error";
+      log.error(`\u{1F6AB} Unrecoverable error (status ${responseState.httpStatus}) when generating signed upload url: ${responseState.errorMessage ? `${responseState.errorMessage}.` : ""} aborting.`);
+    }
+    return {
+      abortReason,
+      httpStatus: responseState.httpStatus,
+      success: false
+    };
+  }
+  log.info(`\u2705 Generated Signed Upload URL: ${responseState.signedUrl}.`);
+  return {
+    fileLocation: responseState.fileLocation,
+    playgroundFileLocation: responseState.playgroundFileLocation,
+    success: true,
+    uploadUrl: responseState.signedUrl
+  };
+}
+__name(generateSignedUrlForTempTeamStorage, "generateSignedUrlForTempTeamStorage");
+
+// src/lib/sdk/domain/legacy_previewTesting/constants.ts
+var qawolfBaseUrl = "https://app.qawolf.com";
+var qawolfGraphQLEndpoint = `${qawolfBaseUrl}/api/graphql`;
+var previewDeploymentType = "qawolf-preview";
+
+// src/lib/sdk/domain/legacy_previewTesting/createEnvironmentVariables.ts
+async function createEnvironmentVariables(deps, apiConfig, { environmentId, variables }) {
+  const environmentVariableRequests = Object.keys(variables).map(async (key) => {
+    const value = variables[key];
+    return deps.fetch(qawolfGraphQLEndpoint, {
+      body: JSON.stringify({
+        query: `
+            mutation UpsertEnvironmentVariable($environmentId: ID!, $value: String!, $name: String) {
+              upsertEnvironmentVariable(environmentId: $environmentId, value: $value, name: $name) {
+                id
+              }
+            }
+          `,
+        variables: {
+          environmentId,
+          name: key,
+          value
+        }
+      }),
+      headers: {
+        Authorization: `Bearer ${apiConfig.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      method: "post"
+    });
+  });
+  await Promise.all(environmentVariableRequests);
+}
+__name(createEnvironmentVariables, "createEnvironmentVariables");
+
+// src/lib/sdk/domain/legacy_previewTesting/findOrCreateEnvironment.ts
+async function findOrCreateEnvironment(deps, apiConfig, { baseEnvironmentId, branch, pr, qaWolfTeamId }) {
+  const retrievalResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+      query Environments($where: EnvironmentWhereInput) {
+        environments(where: $where) {
+          id
+        }
+      }
+      `,
+      variables: {
+        where: {
+          deletedAt: {
+            equals: null
+          },
+          name: {
+            equals: pr ? `[PR] #${pr.number} - ${pr.title}` : `[Preview] ${branch}`
+          }
+        }
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const jsonResponse = await retrievalResponse.json();
+  if (jsonResponse.data.environments[0]) {
+    const environmentId = jsonResponse.data.environments[0].id;
+    deps.log.info(`Environment already exists with ID: ${environmentId}`);
+    return environmentId;
+  }
+  const creationResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      operationName: "createEnvironment",
+      query: `
+        mutation createEnvironment($name: String!, $teamId: String!) {
+          createEnvironment(name: $name, teamId: $teamId) {
+            id
+            branchId
+          }
+        }
+      `,
+      variables: {
+        name: pr ? `[PR] #${pr.number} - ${pr.title}` : `[Preview] ${branch}`,
+        teamId: qaWolfTeamId
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const createionResponseJson = await creationResponse.json();
+  deps.log.info(`Environment response: ${JSON.stringify(createionResponseJson)}`);
+  if (!createionResponseJson.data.createEnvironment.id) throw Error("Environment ID not found in response");
+  const multiBranchResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        query teamBranches($teamId: String!) {
+          teamBranches: activeTeamBranches(teamId: $teamId) {
+            id
+            environments{
+              id
+            }
+          }
+        }
+      `,
+      variables: {
+        teamId: qaWolfTeamId
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const multiBranchResponseJson = await multiBranchResponse.json();
+  const hasMultipleBranches = multiBranchResponseJson.data.teamBranches.length > 1;
+  if (!hasMultipleBranches) return createionResponseJson.data.createEnvironment.id;
+  const sourceEnvironmentResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        query EnvironmentWithBranch($where: EnvironmentWhereUniqueInput!) {
+          environment(where: $where) {
+            id
+            branchId
+          }
+        }
+      `,
+      variables: {
+        where: {
+          id: baseEnvironmentId
+        }
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const sourceEnvironmentJson = await sourceEnvironmentResponse.json();
+  const baseBranchId = sourceEnvironmentJson.data.environment.branchId;
+  const targetBranchId = createionResponseJson.data.createEnvironment.branchId;
+  if (!baseBranchId) throw Error("Base branch ID not found in response");
+  deps.log.info(`Promoting workflows from branch ${baseBranchId} to ${targetBranchId}`);
+  const promotionResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        mutation PromoteWorkflowsToBranch(
+          $sourceTeamBranchId: String!
+          $targetTeamBranchId: String!
+        ) {
+          promoteWorkflowsToBranch(
+            mergeStrategy: overwrite
+            sourceTeamBranchId: $sourceTeamBranchId
+            targetTeamBranchId: $targetTeamBranchId
+          )
+        }
+      `,
+      variables: {
+        sourceTeamBranchId: baseBranchId,
+        targetTeamBranchId: targetBranchId
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const promotionResponseJson = await promotionResponse.json();
+  if (!promotionResponseJson) throw Error("Promotion failed");
+  return createionResponseJson.data.createEnvironment.id;
+}
+__name(findOrCreateEnvironment, "findOrCreateEnvironment");
+
+// src/lib/sdk/domain/legacy_previewTesting/findOrCreateTrigger.ts
+async function findOrCreateTrigger(deps, apiConfig, args) {
+  const { branch, environmentId, pr, qaWolfTeamId, repositoryId, tags } = args;
+  const triggerName = `Deployments of ${pr ? `PR #${pr.number} - ${pr.title}` : `branch ${branch}`}`;
+  const retrievalResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `query getTriggersForBranch($where: TriggerWhereInput) {
+        triggers(where: $where) {
+          environment_id
+          id
+        }
+      }
+      `,
+      variables: {
+        where: {
+          environment_id: {
+            equals: environmentId
+          },
+          name: {
+            equals: triggerName
+          }
+        }
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const retrievalResponseJson = await retrievalResponse.json();
+  if (retrievalResponseJson.data.triggers[0]) {
+    const triggerId2 = retrievalResponseJson.data.triggers[0].id;
+    const environmentId2 = retrievalResponseJson.data.triggers[0].environment_id;
+    deps.log.info(`Trigger with name ${triggerName} already exists with id ${triggerId2} in environment ${environmentId2}`);
+    return triggerId2;
+  }
+  const creationResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      operationName: "createTrigger",
+      query: `
+        mutation createTrigger(
+          $codeHostingServiceRepositoryId: ID!,
+          $deploymentBranches: String!,
+          $deploymentEnvironment: String!,
+          $deploymentProvider: String!,
+          $environmentId: ID!,
+          $name: String!,
+          $teamId: ID!,
+          $tag_ids: [ID!]
+        ) {
+          createTrigger(
+            codeHostingServiceRepositoryId: $codeHostingServiceRepositoryId,
+            deployment_branches: $deploymentBranches,
+            deployment_environment: $deploymentEnvironment,
+            deployment_provider: $deploymentProvider,
+            environment_id: $environmentId,
+            name: $name,
+            team_id: $teamId,
+            tag_ids: $tag_ids
+          ) {
+            id
+            __typename
+          }
+        }
+      `,
+      variables: {
+        codeHostingServiceRepositoryId: repositoryId,
+        deploymentBranches: branch,
+        deploymentEnvironment: previewDeploymentType,
+        deploymentProvider: "generic",
+        environmentId,
+        name: triggerName,
+        tag_ids: tags?.map((tag) => tag.id),
+        teamId: qaWolfTeamId
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const creationResponseJson = await creationResponse.json();
+  deps.log.info(`Trigger response: ${JSON.stringify(creationResponseJson)}`);
+  const triggerId = creationResponseJson.data?.createTrigger?.id;
+  if (!triggerId) throw Error("Trigger ID not found in response");
+  deps.log.info(`Trigger created with ID: ${triggerId}`);
+  return triggerId;
+}
+__name(findOrCreateTrigger, "findOrCreateTrigger");
+
+// src/lib/sdk/domain/legacy_previewTesting/findRepositoryIdByName.ts
+async function findRepositoryIdByName(deps, apiConfig, { headRepoFullName }) {
+  const response = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        query codeHostingServiceRepositories($where: CodeHostingServiceRepositoryWhereInput) {
+          codeHostingServiceRepositories(where: $where) {
+            id
+          }
+        }
+      `,
+      variables: {
+        where: {
+          externalFullName: {
+            equals: headRepoFullName
+          }
+        }
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const responseJson = await response.json();
+  deps.log.info(`Repository response: ${JSON.stringify(responseJson)}`);
+  const repositories = responseJson.data.codeHostingServiceRepositories;
+  if (!repositories[0]) return;
+  return repositories[0].id;
+}
+__name(findRepositoryIdByName, "findRepositoryIdByName");
+
+// src/lib/sdk/domain/legacy_previewTesting/getEnvironmentVariablesFromEnvironment.ts
+async function getEnvironmentVariablesFromEnvironment(deps, apiConfig, { environmentId }) {
+  const retrievalResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        query EnvironmentVariables($where: EnvironmentWhereUniqueInput!) {
+          environment(where: $where) {
+            id
+            variablesJSON
+          }
+        }
+      `,
+      variables: {
+        where: {
+          id: environmentId
+        }
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const retrievalResponseJson = await retrievalResponse.json();
+  if (!retrievalResponseJson.data.environment) {
+    throw Error(`Environment not found with ID: ${environmentId}. Please check the environment ID is correct.`);
+  }
+  return JSON.parse(retrievalResponseJson.data.environment.variablesJSON);
+}
+__name(getEnvironmentVariablesFromEnvironment, "getEnvironmentVariablesFromEnvironment");
+
+// src/lib/sdk/domain/legacy_previewTesting/getTagsFromEnvironment.ts
+async function getTagsFromGenericTriggerInEnvironment(deps, apiConfig, { environmentId }) {
+  const retrievalResponse = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        query GenericTriggerTagsFromEnvironment($where: EnvironmentWhereUniqueInput!) {
+          environment(where: $where) {
+            id
+            triggers(where: {deployment_provider: {equals: "generic"}}) {
+              id
+              tags {
+                id
+                name
+              }
+            }
+          }
+        }
+      `,
+      variables: {
+        where: {
+          id: environmentId
+        }
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const retrievalResponseJson = await retrievalResponse.json();
+  if (!retrievalResponseJson.data.environment) {
+    throw Error(`Environment not found with ID: ${environmentId}. Please check the environment ID is correct.`);
+  }
+  return retrievalResponseJson.data.environment.triggers[0]?.tags?.map((tag) => tag);
+}
+__name(getTagsFromGenericTriggerInEnvironment, "getTagsFromGenericTriggerInEnvironment");
+
+// src/lib/sdk/domain/legacy_previewTesting/createEnvironmentAction.ts
+var createEnvironmentAction = /* @__PURE__ */ __name(async (deps, apiConfig, { baseEnvironmentId, branch, deploymentUrl, headRepoFullName, pr, qaWolfTeamId, variables }) => {
+  deps.log.info("Creating environment for pull request...");
+  const environmentId = await findOrCreateEnvironment(deps, apiConfig, {
+    baseEnvironmentId,
+    branch,
+    pr,
+    qaWolfTeamId
+  });
+  deps.log.info(`Environment created with ID: ${environmentId}`);
+  const baseEnvironmentVariablesJSON = baseEnvironmentId ? await getEnvironmentVariablesFromEnvironment(deps, apiConfig, {
+    environmentId: baseEnvironmentId
+  }) : {};
+  if (typeof baseEnvironmentVariablesJSON !== "object") {
+    deps.log.error("baseEnvironmentVariablesJSON is not an object");
+    throw Error("baseEnvironmentVariablesJSON is not an object");
+  }
+  const combinedEnvironmentVariables = {
+    ...baseEnvironmentVariablesJSON,
+    ...variables,
+    ...deploymentUrl ? {
+      URL: deploymentUrl
+    } : {}
+  };
+  deps.log.info("Creating environment variables...");
+  await createEnvironmentVariables(deps, apiConfig, {
+    environmentId,
+    variables: combinedEnvironmentVariables
+  });
+  deps.log.info(`Environment variables created for environment ID: ${environmentId}`);
+  deps.log.info("Retrieving repository ID...");
+  const repositoryId = await findRepositoryIdByName(deps, apiConfig, {
+    headRepoFullName
+  });
+  deps.log.info(repositoryId ? `Repository ID retrieved: ${repositoryId}` : "Repository not integrated with QA Wolf, enable it in the settings page to get PR comments and checks.");
+  const tags = baseEnvironmentId ? await getTagsFromGenericTriggerInEnvironment(deps, apiConfig, {
+    environmentId: baseEnvironmentId
+  }) : undefined;
+  deps.log.info(`Tags retrieved: ${tags?.map((tag) => tag.name).join(", ")}`);
+  deps.log.info("Creating trigger for deployment...");
+  await findOrCreateTrigger(deps, apiConfig, {
+    branch,
+    environmentId,
+    pr,
+    qaWolfTeamId,
+    repositoryId,
+    tags
+  });
+}, "createEnvironmentAction");
+
+// src/lib/sdk/domain/legacy_previewTesting/deleteEnvironment.ts
+async function deleteEnvironment(deps, apiConfig, { environmentId }) {
+  await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        mutation deleteEnvironment($environmentId: ID!) {
+          deleteEnvironment(environment_id: $environmentId) {
+            id
+          }
+        }
+      `,
+      variables: {
+        environmentId
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  deps.log.info(`Environment deleted with ID: ${environmentId}`);
+}
+__name(deleteEnvironment, "deleteEnvironment");
+
+// src/lib/sdk/domain/legacy_previewTesting/getEnvironmentIdForBranch.ts
+async function getEnvironmentIdForBranch(deps, apiConfig, branch) {
+  const response = await deps.fetch(qawolfGraphQLEndpoint, {
+    body: JSON.stringify({
+      query: `
+        query getTriggersForBranch($where: TriggerWhereInput) {
+          triggers(where: $where) {
+            id
+            environment_id
+          }
+        }
+      `,
+      variables: {
+        where: {
+          deployment_branches: {
+            contains: branch
+          }
+        }
+      }
+    }),
+    headers: {
+      Authorization: `Bearer ${apiConfig.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    method: "post"
+  });
+  const responseJson = await response.json();
+  deps.log.info(`Trigger response: ${JSON.stringify(responseJson)}`);
+  const triggers = responseJson.data.triggers;
+  if (!triggers || !triggers[0]) throw Error(`No environment found for branch: ${branch}`);
+  return triggers[0].environment_id;
+}
+__name(getEnvironmentIdForBranch, "getEnvironmentIdForBranch");
+
+// src/lib/sdk/domain/legacy_previewTesting/deleteEnvironmentAction.ts
+var deleteEnvironmentAction = /* @__PURE__ */ __name(async (deps, apiConfig, { branch }) => {
+  deps.log.info("Retrieving environment ID for deletion...");
+  const environmentId = await getEnvironmentIdForBranch(deps, apiConfig, branch);
+  deps.log.info(`Deleting environment with ID: ${environmentId}`);
+  await deleteEnvironment(deps, apiConfig, {
+    environmentId
+  });
+}, "deleteEnvironmentAction");
+
+// src/lib/sdk/domain/legacy_previewTesting/index.ts
+async function testPreview(deps, apiConfig, config) {
+  await createEnvironmentAction(deps, apiConfig, {
+    baseEnvironmentId: config.baseEnvironmentId,
+    branch: config.branch,
+    deploymentUrl: config.deploymentUrl,
+    headRepoFullName: config.repoFullName,
+    pr: config.pr,
+    qaWolfTeamId: config.qaWolfTeamId,
+    variables: config.variables
+  });
+  return attemptNotifyDeploy(deps, apiConfig, {
+    branch: config.branch,
+    commitUrl: config.commitUrl,
+    deploymentType: previewDeploymentType,
+    deploymentUrl: config.deploymentUrl,
+    sha: config.sha,
+    variables: config.variables
+  });
+}
+__name(testPreview, "testPreview");
+async function removeEnvironment(deps, apiConfig, config) {
+  await deleteEnvironmentAction(deps, apiConfig, config);
+}
+__name(removeEnvironment, "removeEnvironment");
+
+// src/lib/api/ci-greenlight.ts
+async function fetchCiGreenlightStatus({ apiKey, serviceBase, userAgent }, { runId }, { fetch: localFetch, log }) {
+  try {
+    const resp = await localFetch(new URL(`/api/v0/ci-greenlight/${encodeURIComponent(runId)}`, serviceBase), {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "User-Agent": userAgent
+      }
+    });
+    if (resp.ok) {
+      const greenlightStatus = await resp.json();
+      return {
+        greenlightStatus,
+        httpStatus: resp.status,
+        ok: true
+      };
+    }
+    await logFetchError({
+      log,
+      methodName: "fetchCiGreenlightStatus",
+      response: resp
+    });
+    if (resp.status === 404) {
+      return {
+        canRetry: true,
+        errorType: "not-found",
+        httpStatus: resp.status,
+        ok: false
+      };
+    }
+    if (resp.status >= 500) {
+      return {
+        canRetry: true,
+        errorType: "server",
+        httpStatus: resp.status,
+        ok: false
+      };
+    }
+    return {
+      canRetry: false,
+      errorType: "client",
+      httpStatus: resp.status,
+      ok: false
+    };
+  } catch (e) {
+    return {
+      canRetry: true,
+      errorType: "network",
+      httpStatus: 0,
+      ok: false
+    };
+  }
+}
+__name(fetchCiGreenlightStatus, "fetchCiGreenlightStatus");
+
+// src/lib/sdk/domain/poll-ci-greenlight.ts
+var safeDefaults = {
+  abortOnSuperseded: false,
+  maxRetries: 10,
+  pollTimeout: 120 * 60 * 1e3,
+  retryInterval: 10 * 1e3,
+  runInProgressInterval: 30 * 1e3,
+  runUnderReviewInterval: 60 * 1e3
+};
+async function pollCiGreenlightStatus(deps, apiConfig, { onRunStageChanged = /* @__PURE__ */ __name(() => undefined, "onRunStageChanged"), runId, ...pollConfig }) {
+  let retries = 0;
+  const { log } = deps;
+  const { abortOnSuperseded = safeDefaults.abortOnSuperseded, maxRetries = safeDefaults.maxRetries, pollTimeout = safeDefaults.pollTimeout, retryInterval = safeDefaults.retryInterval, runInProgressInterval = safeDefaults.runInProgressInterval, runUnderReviewInterval = safeDefaults.runUnderReviewInterval } = pollConfig;
+  let currentStatus = undefined;
+  const startedAt = Date.now();
+  let hasTimedOut = false;
+  while (!(hasTimedOut = Date.now() - startedAt > pollTimeout)) {
+    const responseState = await fetchCiGreenlightStatus(apiConfig, {
+      runId
+    }, deps);
+    if (!responseState.ok && !responseState.canRetry) {
+      log.error(`\u{1F6AB} Unrecoverable error (status ${responseState.httpStatus}) from CI greenlight, aborting.`);
+      return {
+        abortReason: "4XX-client-error",
+        httpStatus: responseState.httpStatus,
+        outcome: "aborted"
+      };
+    }
+    if (!responseState.ok) {
+      retries += 1;
+      if (retries > maxRetries) {
+        log.error(`\u{1F6AB} Unrecoverable error${responseState.httpStatus ? ` (status ${responseState.httpStatus})` : ""} from CI greenlight, aborting after ${maxRetries} attempts.`);
+        if (responseState.errorType === "network") {
+          return {
+            abortReason: "network-error",
+            httpStatus: undefined,
+            outcome: "aborted"
+          };
+        }
+        let abortReason = "XXX-other-http-code";
+        if (responseState.errorType === "not-found") abortReason = "404-run-not-found";
+        else if (responseState.errorType === "server") abortReason = "5XX-server-error";
+        else ;
+        return {
+          abortReason,
+          httpStatus: responseState.httpStatus,
+          outcome: "aborted"
+        };
+      }
+      const { errorType, httpStatus } = responseState;
+      const retryLabel = `${httpStatus ? ` (status ${httpStatus})` : ""}, will try again... (${retries}/${maxRetries})`;
+      if (errorType === "network") log.warn(`\u274C Network error${retryLabel}`);
+      else if (errorType === "not-found") log.info(`\u23F3 Run not found${retryLabel}`);
+      else if (errorType === "server") log.warn(`\u274C Server error${retryLabel}`);
+      await sleep(retryInterval);
+      continue;
+    }
+    retries = 0;
+    const { greenlightStatus } = responseState;
+    const previousStatus = currentStatus;
+    currentStatus = greenlightStatus;
+    if (!previousStatus || previousStatus.runStage !== greenlightStatus.runStage) {
+      try {
+        await onRunStageChanged(greenlightStatus, previousStatus);
+      } catch (e) {
+        log.error(`Error in onRunStageChanged callback`, e);
+      }
+    }
+    const urlInfo = `See ${greenlightStatus.relevantRunUrl}`;
+    const { greenlight, relevantRunId, relevantRunUrl, relevantRunWithBugsUrl, rootRunId, rootRunUrl, runStage } = greenlightStatus;
+    if (rootRunId !== relevantRunId) {
+      const supersedingDetails = `
+  - Root: ${rootRunUrl}
+  - Superseding: ${relevantRunUrl}`;
+      if (abortOnSuperseded) {
+        log.warn(`\u274C Aborting due to superseded run (option 'abortOnSuperseded' is enabled).${supersedingDetails}`);
+        return {
+          abortReason: "superseded-run",
+          httpStatus: undefined,
+          outcome: "aborted"
+        };
+      }
+      log.info(`Root run was superseded:${supersedingDetails}`);
+    }
+    if (runStage === "completed") {
+      const { blockingBugsCount, blockingBugUrls = [], nonBlockingBugsCount, nonBlockingBugUrls = [] } = greenlightStatus;
+      const blockingBugList = blockingBugUrls.map((url) => `
+\u2022 ${url}`).join("");
+      const nonBlockingBugList = nonBlockingBugUrls.map((url) => `
+\u2022 ${url}`).join("");
+      const bugsListInText = `${blockingBugUrls.length > 0 ? `
+BLOCKING BUGS:${blockingBugList}` : ""}${nonBlockingBugUrls.length > 0 ? `
+NON BLOCKING BUGS:${nonBlockingBugList}` : ""}`;
+      if (greenlight) {
+        log.info(`\u2705 Run passed and no blocking bugs found${nonBlockingBugsCount > 0 ? ` and ${nonBlockingBugsCount} non-blocking bug${pluralize(nonBlockingBugsCount)} found` : ""}.
+${urlInfo}`);
+        return {
+          greenlightStatus,
+          outcome: "success"
+        };
+      } else {
+        log.warn(`\u274C Run failed and ${blockingBugsCount} blocking bug${pluralize(blockingBugsCount)} found${nonBlockingBugsCount ? ` and ${nonBlockingBugsCount} non-blocking bug${pluralize(nonBlockingBugsCount)}` : ""}.
+See ${relevantRunWithBugsUrl}
+You may review the priority of certain bugs to mark these non-blocking and retry the job.
+` + bugsListInText);
+        return {
+          greenlightStatus,
+          outcome: "failed"
+        };
+      }
+    }
+    if (runStage === "canceled") {
+      log.info(`\u{1F6AB} Run was canceled. Aborting... Please contact support.
+${urlInfo}`);
+      return {
+        abortReason: "run-canceled",
+        httpStatus: undefined,
+        outcome: "aborted"
+      };
+    }
+    if (hasTimedOut) {
+      log.warn(`\u274C Poll timed out after ${pollTimeout / 1e3}s. Aborting...`);
+      return {
+        abortReason: "poll-timed-out",
+        httpStatus: undefined,
+        outcome: "aborted"
+      };
+    }
+    if (runStage === "initializing") {
+      log.info(`\u23F3 Run is in progress... ${urlInfo}`);
+      await sleep(runInProgressInterval);
+    } else if (runStage === "underReview") {
+      log.info(`\u{1F575}\uFE0F  Run is under review... ${urlInfo}`);
+      await sleep(runUnderReviewInterval);
+    } else throw Error(`Unexpected run stage: ${runStage}`);
+  }
+  log.warn(`\u274C Poll timed out after ${pollTimeout / 1e3}s. Aborting...`);
+  return {
+    abortReason: "poll-timed-out",
+    httpStatus: undefined,
+    outcome: "aborted"
+  };
+}
+__name(pollCiGreenlightStatus, "pollCiGreenlightStatus");
+
+// src/lib/api/graphql.ts
+var GraphQLBadResponseError = class GraphQLBadResponseError2 extends Error {
+  static {
+    __name(this, "GraphQLBadResponseError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "GraphQLBadResponseError";
+  }
+};
+function mapErrorCodeToAbortReason({ errorCode, log }) {
+  switch (errorCode) {
+    case "BAD_USER_INPUT":
+      return "invalid-input";
+    case "FORBIDDEN":
+      return "forbidden";
+    case "INTERNAL":
+      return "server-error";
+    case "UNAUTHENTICATED":
+      return "unauthenticated";
+    default:
+      log.error(`Unknown error code. ${errorCode}`);
+      return "server-error";
+  }
+}
+__name(mapErrorCodeToAbortReason, "mapErrorCodeToAbortReason");
+async function qawolfGraphql({ apiConfig: { apiKey, serviceBase, userAgent }, deps: { fetch: localFetch, log }, name, query: queryGql, variables }) {
+  try {
+    const response = await localFetch(new URL(`/api/graphql`, serviceBase), {
+      body: JSON.stringify({
+        query: queryGql,
+        variables
+      }),
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": userAgent
+      },
+      method: "post"
+    });
+    let rawBody;
+    try {
+      rawBody = await response.json();
+    } catch (e) {
+      throw new GraphQLBadResponseError(`[GraphQL] Unexpected response schema. Not valid JSON body.`);
+    }
+    if ("errors" in rawBody) {
+      for (const error of rawBody.errors) log.warn(`\u274C [GraphQL] error: ${error.message}`);
+      const firstError = rawBody.errors[0];
+      const eventId = firstError?.extensions?.eventId;
+      const errorCode = firstError?.extensions?.code;
+      return {
+        abortReason: mapErrorCodeToAbortReason({
+          errorCode,
+          log
+        }),
+        eventId,
+        isGqlError: true
+      };
+    }
+    if (!("data" in rawBody)) {
+      throw new GraphQLBadResponseError(`[GraphQL] Unexpected response schema. Missing 'data' in response body. This is a bug.`);
+    }
+    if (!(name in rawBody.data)) {
+      throw new GraphQLBadResponseError(`[GraphQL] Unexpected response schema. Missing 'data.${name}' in response body. This is a bug.`);
+    }
+    return {
+      isGqlError: false,
+      responseBody: rawBody.data[name]
+    };
+  } catch (e) {
+    if (e instanceof GraphQLBadResponseError) throw e;
+    log.error(`\u274C [GraphQL] network error: ${e instanceof Error ? e.message : e}`);
+    return {
+      abortReason: "network-error",
+      isGqlError: true
+    };
+  }
+}
+__name(qawolfGraphql, "qawolfGraphql");
+function logGraphQLError({ log, methodName, payload }) {
+  const eventIdSuffix = payload.eventId ? ` (Event ID: ${payload.eventId})` : "";
+  switch (payload.abortReason) {
+    case "forbidden":
+      log.error(`\u274C [${methodName}] Forbidden. Aborting${eventIdSuffix}`);
+      break;
+    case "invalid-input":
+      log.error(`\u274C [${methodName}] Bad GraphQL input. This is a bug. Aborting${eventIdSuffix}`);
+      break;
+    case "network-error":
+      log.error(`\u274C [${methodName}] Network error. Aborting${eventIdSuffix}`);
+      break;
+    case "server-error":
+      log.error(`\u274C [${methodName}] Server error. Aborting${eventIdSuffix}`);
+      break;
+    case "unauthenticated":
+      log.error(`\u274C [${methodName}] Unauthenticated. Aborting${eventIdSuffix}`);
+      break;
+    default:
+      payload.abortReason;
+      log.error(`\u274C [${methodName}] Unknown error. ${payload.abortReason} This is a bug${eventIdSuffix}`);
+  }
+}
+__name(logGraphQLError, "logGraphQLError");
+
+// src/lib/api/notify-vcs-branch-merge-canceled-mutation.ts
+var mutationName = "notifyVCSBranchMergeCanceled";
+var mutationGql = `
+mutation NotifyVCSBranchMergeCanceled($headEnvironmentAlias: String!) {
+  ${mutationName}(headEnvironmentAlias: $headEnvironmentAlias) {
+    outcome
+    failureCode
+    failureDetails
+  }
+}`;
+async function callNotifyVCSBranchMergeCanceledMutation(deps, apiConfig, { headEnvironmentAlias }) {
+  return qawolfGraphql({
+    apiConfig,
+    deps,
+    name: mutationName,
+    query: mutationGql,
+    variables: {
+      headEnvironmentAlias
+    }
+  });
+}
+__name(callNotifyVCSBranchMergeCanceledMutation, "callNotifyVCSBranchMergeCanceledMutation");
+
+// src/lib/sdk/domain/vcsBranchTesting/lib/domain-failure.ts
+function domainFailureToAbortResult({ log, methodName, result }) {
+  switch (result.failureCode) {
+    case "base-environment-not-found":
+      log.error(`\u274C [${methodName}] Base environment not found. Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    case "base-trigger-not-found":
+      log.error(`\u274C [${methodName}] Base trigger not found. A QA Wolf representative should set this up for you. Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    case "head-environment-not-found":
+      log.error(`\u274C [${methodName}] Head environment not found. Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    case "head-trigger-not-found":
+      log.error(`\u274C [${methodName}] Head trigger not found. Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    case "invalid-input":
+      log.error(`\u274C [${methodName}] Invalid input: ${result.failureDetails} Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    case "non-ephemeral-head-environment-violation":
+      log.error(`\u274C [${methodName}] Non-ephemeral head environment violation. Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    case "repository-not-found":
+      log.error(`\u274C [${methodName}] Repository not found: ${result.failureDetails} Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    case "run-creation-failed":
+      log.error(`\u274C [${methodName}] Run creation failed: ${result.failureDetails}. Aborting.`);
+      return {
+        abortReason: result.failureCode,
+        outcome: "aborted"
+      };
+    default:
+      result.failureCode;
+      throw Error(`[${methodName}] Unreachable code detected. This is a bug. ${result.failureCode}`);
+  }
+}
+__name(domainFailureToAbortResult, "domainFailureToAbortResult");
+
+// src/lib/sdk/domain/vcsBranchTesting/lib/retry.ts
+async function retryWithExponentialBackoff({ log, maxRetries, methodName, retriableAbortReasons, runOnce }) {
+  let attemptNumber = 0;
+  let result;
+  do {
+    attemptNumber++;
+    log.info(`\u{1F501} [${methodName}] Attempt ${attemptNumber}/${maxRetries + 1}.`);
+    result = await runOnce();
+    if (result.outcome === "success" || !retriableAbortReasons.includes(result.abortReason)) return result;
+    if (attemptNumber >= maxRetries + 1) return result;
+    const backoffMs = getBackoffMs(attemptNumber);
+    const secondsApproximation = (backoffMs / 1e3).toFixed(1);
+    log.warn(`\u23F3 [${methodName}] Retrying in ${secondsApproximation} seconds.`);
+    await sleep(backoffMs);
+  } while (true);
+}
+__name(retryWithExponentialBackoff, "retryWithExponentialBackoff");
+
+// src/lib/sdk/domain/vcsBranchTesting/notify-vcs-branch-merge-canceled.ts
+async function runNotifyVCSMergeCanceledOnce(deps, apiConfig, input) {
+  const log = deps.log;
+  const { headEnvironmentAlias } = input;
+  const resp = await callNotifyVCSBranchMergeCanceledMutation(deps, apiConfig, {
+    headEnvironmentAlias
+  });
+  if (resp.isGqlError) {
+    logGraphQLError({
+      log,
+      methodName: "notifyVCSBranchMergeCanceled",
+      payload: resp
+    });
+    return {
+      abortReason: resp.abortReason,
+      eventId: resp.eventId,
+      outcome: "aborted"
+    };
+  }
+  const result = resp.responseBody;
+  if (result.outcome === "success") {
+    log.info(`\u2705 [notifyVCSBranchMergeCanceled] Successfully notified the CI system that the merge was canceled.`);
+    return {
+      outcome: "success"
+    };
+  }
+  result.outcome;
+  return domainFailureToAbortResult({
+    log,
+    methodName: "notifyVCSBranchMergeCanceled",
+    result
+  });
+}
+__name(runNotifyVCSMergeCanceledOnce, "runNotifyVCSMergeCanceledOnce");
+async function notifyVCSBranchMergeCanceled(deps, apiConfig, input) {
+  const { maxRetries = 10 } = input;
+  return retryWithExponentialBackoff({
+    log: deps.log,
+    maxRetries,
+    methodName: "notifyVCSBranchMergeCanceled",
+    retriableAbortReasons: [
+      "network-error",
+      "server-error"
+    ],
+    runOnce: /* @__PURE__ */ __name(() => runNotifyVCSMergeCanceledOnce(deps, apiConfig, input), "runOnce")
+  });
+}
+__name(notifyVCSBranchMergeCanceled, "notifyVCSBranchMergeCanceled");
+
+// src/lib/api/notify-vcs-branch-merge-completed-mutation.ts
+var mutationName2 = "notifyVCSBranchMergeCompleted";
+var mutationGql2 = `
+mutation NotifyVCSBranchMergeCompleted($baseEnvironmentAlias: String, $headEnvironmentAlias: String!) {
+${mutationName2}(baseEnvironmentAlias: $baseEnvironmentAlias, headEnvironmentAlias: $headEnvironmentAlias) {
+    outcome
+    failureCode
+    failureDetails
+  }
+}`;
+async function callNotifyVCSBranchMergeCompletedMutation(deps, apiConfig, { baseEnvironmentAlias, headEnvironmentAlias }) {
+  return qawolfGraphql({
+    apiConfig,
+    deps,
+    name: mutationName2,
+    query: mutationGql2,
+    variables: {
+      baseEnvironmentAlias: baseEnvironmentAlias ?? null,
+      headEnvironmentAlias
+    }
+  });
+}
+__name(callNotifyVCSBranchMergeCompletedMutation, "callNotifyVCSBranchMergeCompletedMutation");
+
+// src/lib/sdk/domain/vcsBranchTesting/notify-vcs-branch-merge-completed.ts
+async function runNotifyVCSBranchMergeCompletedOnce(deps, apiConfig, input) {
+  const log = deps.log;
+  const { baseEnvironmentsMapping, baseVcsBranch: vcsBaseBranch } = input;
+  const baseEnvironmentAlias = baseEnvironmentsMapping?.find((mapping) => mapping.vcsBranch === vcsBaseBranch)?.environmentAlias;
+  if (baseEnvironmentAlias === undefined) {
+    log.info(`\u2139\uFE0F [notifyVCSBranchMergeCompleted] Could not find a base environment for VCS branch '${vcsBaseBranch}'. Fall back to use the default base environment`);
+  }
+  const resp = await callNotifyVCSBranchMergeCompletedMutation(deps, apiConfig, {
+    baseEnvironmentAlias,
+    headEnvironmentAlias: input.headEnvironmentAlias
+  });
+  if (resp.isGqlError) {
+    logGraphQLError({
+      log,
+      methodName: "notifyVCSBranchMergeCompleted",
+      payload: resp
+    });
+    return {
+      abortReason: resp.abortReason,
+      eventId: resp.eventId,
+      outcome: "aborted"
+    };
+  }
+  const result = resp.responseBody;
+  if (result.outcome === "success") {
+    log.info(`\u2705 [notifyVCSBranchMergeCompleted] Successfully notified the CI system that the merge was completed.`);
+    return {
+      outcome: "success"
+    };
+  }
+  result.outcome;
+  return domainFailureToAbortResult({
+    log,
+    methodName: "notifyVCSBranchMergeCompleted",
+    result
+  });
+}
+__name(runNotifyVCSBranchMergeCompletedOnce, "runNotifyVCSBranchMergeCompletedOnce");
+async function notifyVCSBranchMergeCompleted(deps, apiConfig, input) {
+  const { maxRetries = 10 } = input;
+  return retryWithExponentialBackoff({
+    log: deps.log,
+    maxRetries,
+    methodName: "notifyVCSBranchMergeCompleted",
+    retriableAbortReasons: [
+      "network-error",
+      "server-error"
+    ],
+    runOnce: /* @__PURE__ */ __name(() => runNotifyVCSBranchMergeCompletedOnce(deps, apiConfig, input), "runOnce")
+  });
+}
+__name(notifyVCSBranchMergeCompleted, "notifyVCSBranchMergeCompleted");
+
+// src/lib/api/notify-vcs-branch-build-deployed-mutation.ts
+var mutationName3 = "notifyVCSBranchBuildDeployed";
+var mutationGql3 = `
+mutation NotifyVCSBranchBuildDeployed(
+  $headVcsCommitId: String!,
+  $baseVcsBranch: String,
+  $headEnvironmentVariablesJson: String!,
+  $baseEnvironmentAlias: String,
+  $headEnvironmentAlias: String!,
+  $concurrencyLimit: Int,
+  $headEnvironmentName: String,
+  $headVcsBranch: String,
+  $headVcsCommitUrl: String,
+  $pullOrMergeRequestNumber: Int
+) {
+    ${mutationName3}(
+      headVcsCommitId: $headVcsCommitId,
+      baseVcsBranch: $baseVcsBranch,
+      headEnvironmentVariablesJson: $headEnvironmentVariablesJson,
+      baseEnvironmentAlias: $baseEnvironmentAlias,
+      headEnvironmentAlias: $headEnvironmentAlias,
+      concurrencyLimit: $concurrencyLimit,
+      headEnvironmentName: $headEnvironmentName,
+      headVcsBranch: $headVcsBranch,
+      headVcsCommitUrl: $headVcsCommitUrl,
+      pullOrMergeRequestNumber: $pullOrMergeRequestNumber
+    ) {
+    outcome
+    codeHostingServiceInstallationPlatform
+    failureCode
+    failureDetails
+    runId
+  }
+}`;
+async function callNotifyVCSBranchBuildDeployedMutation(deps, apiConfig, { baseEnvironmentAlias, baseVcsBranch, concurrencyLimit, headEnvironmentAlias, headEnvironmentName, headEnvironmentVariables, headVcsBranch, headVcsCommitId, headVcsCommitUrl, pullOrMergeRequestNumber }) {
+  return qawolfGraphql({
+    apiConfig,
+    deps,
+    name: mutationName3,
+    query: mutationGql3,
+    variables: {
+      baseEnvironmentAlias: baseEnvironmentAlias ?? null,
+      baseVcsBranch: baseVcsBranch ?? null,
+      concurrencyLimit: concurrencyLimit ?? null,
+      headEnvironmentAlias,
+      headEnvironmentName,
+      headEnvironmentVariablesJson: JSON.stringify(headEnvironmentVariables),
+      headVcsBranch: headVcsBranch ?? null,
+      headVcsCommitId,
+      headVcsCommitUrl: headVcsCommitUrl ?? null,
+      pullOrMergeRequestNumber: pullOrMergeRequestNumber ?? null
+    }
+  });
+}
+__name(callNotifyVCSBranchBuildDeployedMutation, "callNotifyVCSBranchBuildDeployedMutation");
+
+// src/lib/sdk/domain/vcsBranchTesting/notifyVCSBranchBuildDeployed/index.ts
+async function runNotifyVCSBranchBuildDeployedOnce(deps, apiConfig, input) {
+  const { baseEnvironmentsMapping, baseVcsBranch, concurrencyLimit, headEnvironmentAlias, headEnvironmentName, headEnvironmentVariables, headVcsBranch, headVcsCommitId, headVcsCommitUrl, pullOrMergeRequestNumber } = input;
+  const log = deps.log;
+  const baseEnvironmentAlias = baseEnvironmentsMapping?.find((mapping) => mapping.vcsBranch === baseVcsBranch)?.environmentAlias;
+  let finalConcurrencyLimit = concurrencyLimit;
+  if (typeof concurrencyLimit === "number") {
+    if (concurrencyLimit === Infinity) finalConcurrencyLimit = 0;
+    else if (Number.isNaN(concurrencyLimit) || !Number.isInteger(concurrencyLimit)) {
+      log.error(`\u274C [notifyVCSBranchBuildDeployed] Invalid concurrency limit '${concurrencyLimit}'. Must be a positive integer.`);
+      return {
+        abortReason: "invalid-input",
+        outcome: "aborted"
+      };
+    }
+    if (concurrencyLimit < 0) {
+      log.error(`\u274C [notifyVCSBranchBuildDeployed] Invalid concurrency limit '${concurrencyLimit}'. Must be a positive integer.`);
+      return {
+        abortReason: "invalid-input",
+        outcome: "aborted"
+      };
+    }
+  }
+  const resp = await callNotifyVCSBranchBuildDeployedMutation(deps, apiConfig, {
+    baseEnvironmentAlias,
+    baseVcsBranch,
+    concurrencyLimit: finalConcurrencyLimit,
+    headEnvironmentAlias,
+    headEnvironmentName,
+    headEnvironmentVariables,
+    headVcsBranch,
+    headVcsCommitId,
+    headVcsCommitUrl,
+    pullOrMergeRequestNumber
+  });
+  if (resp.isGqlError) {
+    logGraphQLError({
+      log,
+      methodName: "notifyVCSBranchBuildDeployed",
+      payload: resp
+    });
+    return {
+      abortReason: resp.abortReason,
+      eventId: resp.eventId,
+      outcome: "aborted"
+    };
+  }
+  const result = resp.responseBody;
+  if (result.outcome === "success") {
+    const codeHostingInfo = result.codeHostingServiceInstallationPlatform == null ? "" : `, and code hosting service integration '${result.codeHostingServiceInstallationPlatform}'.`;
+    log.info(`\u2705 [notifyVCSBranchBuildDeployed] Success. Run was deployed with ID: '${result.runId}'${codeHostingInfo}`);
+    return {
+      codeHostingServiceInstallationType: result.codeHostingServiceInstallationPlatform ?? undefined,
+      outcome: "success",
+      runId: result.runId
+    };
+  }
+  result.outcome;
+  return domainFailureToAbortResult({
+    log,
+    methodName: "notifyVCSBranchBuildDeployed",
+    result
+  });
+}
+__name(runNotifyVCSBranchBuildDeployedOnce, "runNotifyVCSBranchBuildDeployedOnce");
+async function notifyVCSBranchBuildDeployed(deps, apiConfig, input) {
+  const { maxRetries = 10 } = input;
+  return retryWithExponentialBackoff({
+    log: deps.log,
+    maxRetries,
+    methodName: "notifyVCSBranchBuildDeployed",
+    retriableAbortReasons: [
+      "network-error",
+      "server-error",
+      "run-creation-failed"
+    ],
+    runOnce: /* @__PURE__ */ __name(() => runNotifyVCSBranchBuildDeployedOnce(deps, apiConfig, input), "runOnce")
+  });
+}
+__name(notifyVCSBranchBuildDeployed, "notifyVCSBranchBuildDeployed");
+function pullRequestDetailsToEnvironmentAlias({ codeHostingServiceOrganization, codeHostingServiceRepositoryName, pullRequestIdentifier }) {
+  return arbitraryStringToEnvironmentAlias(`${codeHostingServiceOrganization}-${codeHostingServiceRepositoryName}-pr-${pullRequestIdentifier}`);
+}
+__name(pullRequestDetailsToEnvironmentAlias, "pullRequestDetailsToEnvironmentAlias");
+function arbitraryStringToEnvironmentAlias(arbitraryString) {
+  return slugify(arbitraryString, {
+    lower: true
+  });
+}
+__name(arbitraryStringToEnvironmentAlias, "arbitraryStringToEnvironmentAlias");
+
+// src/lib/sdk/domain/vcsBranchTesting/index.ts
+function makeVCSBranchTestingSDK({ apiKey, serviceBase = defaultServiceBase, userAgent = defaultUserAgent }, { fetch = defaultFetch, log = defaultLogDriver } = {}) {
+  const deps = {
+    fetch,
+    log
+  };
+  const apiConfig = {
+    apiKey,
+    serviceBase,
+    userAgent
+  };
+  return {
+    notifyVCSBranchBuildDeployed: notifyVCSBranchBuildDeployed.bind(null, deps, apiConfig),
+    notifyVCSBranchMergeCanceled: notifyVCSBranchMergeCanceled.bind(null, deps, apiConfig),
+    notifyVCSBranchMergeCompleted: notifyVCSBranchMergeCompleted.bind(null, deps, apiConfig)
+  };
+}
+__name(makeVCSBranchTestingSDK, "makeVCSBranchTestingSDK");
+
+// src/lib/sdk/index.ts
+function makeQaWolfSdk({ apiKey, serviceBase = defaultServiceBase, userAgent = defaultUserAgent }, { fetch = defaultFetch, log = defaultLogDriver } = {}) {
+  if (typeof fetch !== "function") {
+    throw Error(`QA Wolf CI-SDK requires fetch to be defined. Make sure you are using NodeJS 18+, OR pass a fetch polyfill to the makeQaWolfSdk function.
+We recommend 'undici' package for that purpose. See the Requirement section of our README for more guidance.`);
+  }
+  const deps = {
+    // Versions of fetch may have different default timeouts. For consistency, we explicitly set it to 60 seconds here.
+    fetch: buildFetchWithTimeout(fetch, 6e4),
+    log
+  };
+  const apiConfig = {
+    apiKey,
+    serviceBase,
+    userAgent
+  };
+  return {
+    attemptNotifyDeploy: attemptNotifyDeploy.bind(null, deps, apiConfig),
+    /**
+    * @deprecated Use `experimental_vcsBranchTesting` instead.
+    */
+    experimental_removeEnvironment: removeEnvironment.bind(null, deps, apiConfig),
+    /**
+    * @deprecated Use `experimental_vcsBranchTesting` instead.
+    */
+    experimental_testPreview: testPreview.bind(null, deps, apiConfig),
+    experimental_vcsBranchTesting: makeVCSBranchTestingSDK(apiConfig, deps),
+    generateSignedUrlForRunInputsExecutablesStorage: generateSignedUrlForRunInputsExecutablesStorage.bind(null, deps, apiConfig),
+    generateSignedUrlForTempTeamStorage: generateSignedUrlForTempTeamStorage.bind(null, deps, apiConfig),
+    pollCiGreenlightStatus: pollCiGreenlightStatus.bind(null, deps, apiConfig)
+  };
+}
+__name(makeQaWolfSdk, "makeQaWolfSdk");
+
+export { arbitraryStringToEnvironmentAlias, makeQaWolfSdk, makeVCSBranchTestingSDK, pullRequestDetailsToEnvironmentAlias };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map