@qualflare/cypress 0.1.0

package/dist/plugin/index.js

@@ -0,0 +1,825 @@
+// src/plugin/attachment-reader.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/shared/logger.ts
+var PREFIX = "[qualflare-cypress]";
+var logger = {
+  debug(...args) {
+    console.debug(PREFIX, ...args);
+  },
+  info(...args) {
+    console.log(PREFIX, ...args);
+  },
+  warn(...args) {
+    console.warn(PREFIX, ...args);
+  },
+  error(...args) {
+    console.error(PREFIX, ...args);
+  }
+};
+
+// src/plugin/attachment-reader.ts
+var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov", ".avi", ".mkv"]);
+var AttachmentBudget = class {
+  constructor(maxTotalBytes) {
+    this.maxTotalBytes = maxTotalBytes;
+  }
+  maxTotalBytes;
+  used = 0;
+  /** Atomically checks-and-reserves `bytes` against the remaining budget.
+   * Returns false (reserving nothing) if it would exceed the total. */
+  tryReserve(bytes) {
+    if (this.used + bytes > this.maxTotalBytes) {
+      return false;
+    }
+    this.used += bytes;
+    return true;
+  }
+  get usedBytes() {
+    return this.used;
+  }
+};
+function isVideoLike(attachment) {
+  if (attachment.mimeType?.toLowerCase().startsWith("video/")) {
+    return true;
+  }
+  if (attachment.path && VIDEO_EXTENSIONS.has(path.extname(attachment.path).toLowerCase())) {
+    return true;
+  }
+  return false;
+}
+function readAttachmentFile(filePath, maxAttachmentBytes, budget) {
+  let size;
+  try {
+    size = fs.statSync(filePath).size;
+  } catch (err) {
+    return { skipped: true, reason: `could not stat file: ${err.message}` };
+  }
+  if (size > maxAttachmentBytes) {
+    return {
+      skipped: true,
+      reason: `${size} bytes exceeds the configured per-attachment cap of ${maxAttachmentBytes} bytes`
+    };
+  }
+  if (!budget.tryReserve(size)) {
+    return {
+      skipped: true,
+      reason: `would exceed this run's total attachment budget (${budget.usedBytes} bytes already used)`
+    };
+  }
+  try {
+    const content = fs.readFileSync(filePath).toString("base64");
+    return { skipped: false, content };
+  } catch (err) {
+    return { skipped: true, reason: `could not read file: ${err.message}` };
+  }
+}
+function resolveAttachments(attachments, config, budget) {
+  if (!attachments || attachments.length === 0) {
+    return void 0;
+  }
+  if (!config.attachScreenshots) {
+    return void 0;
+  }
+  const resolved = [];
+  for (const attachment of attachments) {
+    if (isVideoLike(attachment)) {
+      logger.warn(
+        `refusing to attach "${attachment.name}": video attachments are not supported yet (${attachment.path ?? attachment.mimeType ?? "unknown"}).`
+      );
+      continue;
+    }
+    if (attachment.content !== void 0 || !attachment.path) {
+      resolved.push(attachment);
+      continue;
+    }
+    const result = readAttachmentFile(attachment.path, config.maxAttachmentBytes, budget);
+    if (result.skipped) {
+      logger.warn(`skipping attachment "${attachment.name}" (${attachment.path}): ${result.reason}`);
+      continue;
+    }
+    resolved.push({ ...attachment, content: result.content });
+  }
+  return resolved.length > 0 ? resolved : void 0;
+}
+
+// src/http/client.ts
+import { request } from "undici";
+
+// src/shared/constants.ts
+var TASK_REPORT_CASE = "qualflareReportCase";
+var TASK_MARK_TEST_PHASE_STARTED = "qualflareMarkTestPhaseStarted";
+var HEADER_TOKEN = "QF_TOKEN";
+var HEADER_IDEMPOTENCY_KEY = "Idempotency-Key";
+var HEADER_CONTENT_TYPE = "Content-Type";
+var HEADER_ACCEPT = "Accept";
+var HEADER_USER_AGENT = "User-Agent";
+var MAX_SUITES_PER_LAUNCH = 2e3;
+var MAX_CASES_PER_SUITE = 5e3;
+var MAX_IDEMPOTENCY_KEY_CHARS = 255;
+
+// src/http/backoff.ts
+function computeDelay(attempt, baseDelayMs, maxDelayMs, retryAfterMs) {
+  const exponential = baseDelayMs * 2 ** Math.max(0, attempt - 1);
+  const jittered = Math.random() * Math.min(exponential, maxDelayMs);
+  const floor = retryAfterMs !== void 0 ? retryAfterMs : 0;
+  return Math.min(Math.max(jittered, floor), maxDelayMs);
+}
+
+// src/http/errors.ts
+function friendlyHint(code) {
+  switch (code) {
+    case "environment.not_found":
+      return "Environment not found. Check the `environment` option or create it in Qualflare.";
+    case "milestone.not_found":
+      return "Milestone not found. Check the `milestone` option or its sequence number in Qualflare.";
+    case "common.validation_failed":
+      return "Validation failed. Check the request data below.";
+    default:
+      return void 0;
+  }
+}
+function actionHint(statusCode) {
+  switch (statusCode) {
+    case 401:
+      return "the configured token is missing or invalid \u2014 check `token`/QUALFLARE_TOKEN";
+    case 403:
+      return "the token lacks access to this project";
+    case 402:
+      return "a plan limit was reached \u2014 check your Qualflare subscription";
+    default:
+      return void 0;
+  }
+}
+function renderFields(fields) {
+  if (!fields || fields.length === 0) {
+    return void 0;
+  }
+  return fields.map((f) => {
+    const rule = f.rule ? ` (${f.rule})` : "";
+    const msg = f.message ? `: ${f.message}` : "";
+    return `${f.field}${rule}${msg}`;
+  }).join("; ");
+}
+var QualflareApiError = class extends Error {
+  code;
+  statusCode;
+  requestId;
+  fields;
+  constructor(init) {
+    const parts = [init.message];
+    const fieldsRendered = renderFields(init.fields);
+    if (fieldsRendered) {
+      parts.push(`fields: ${fieldsRendered}`);
+    }
+    const hint = actionHint(init.statusCode);
+    if (hint) {
+      parts.push(`(${hint})`);
+    }
+    if (init.requestId) {
+      parts.push(`[request_id: ${init.requestId}]`);
+    }
+    super(parts.join(" \u2014 "), init.cause !== void 0 ? { cause: init.cause } : void 0);
+    this.name = "QualflareApiError";
+    this.code = init.code;
+    this.statusCode = init.statusCode;
+    this.requestId = init.requestId;
+    this.fields = init.fields;
+  }
+};
+function buildApiError(statusCode, body) {
+  const code = body?.code;
+  const message = body?.message || friendlyHint(code) || body?.error || `request failed with status ${statusCode}`;
+  return new QualflareApiError({
+    message,
+    code,
+    statusCode,
+    requestId: body?.request_id,
+    fields: body?.fields
+  });
+}
+
+// src/http/idempotency.ts
+import { randomUUID } from "crypto";
+function newIdempotencyKey() {
+  const key = randomUUID();
+  if (key.length > MAX_IDEMPOTENCY_KEY_CHARS) {
+    return key.slice(0, MAX_IDEMPOTENCY_KEY_CHARS);
+  }
+  return key;
+}
+
+// src/http/client.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function redactToken(token) {
+  return token.length > 0 ? "***REDACTED***" : "(none)";
+}
+var QualflareHttpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  async send(collect) {
+    const url = `${this.opts.endpoint.replace(/\/+$/, "")}/api/v1/collect`;
+    const idempotencyKey = newIdempotencyKey();
+    const body = JSON.stringify(collect);
+    const maxAttempts = Math.max(1, this.opts.retry.max + 1);
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (this.opts.debug) {
+        logger.debug(
+          `POST ${url} (attempt ${attempt}/${maxAttempts}, QF_TOKEN: ${redactToken(this.opts.token)})`
+        );
+      }
+      let statusCode;
+      let responseBody;
+      let responseHeaders;
+      try {
+        const res = await request(url, {
+          method: "POST",
+          headers: {
+            [HEADER_TOKEN]: this.opts.token,
+            [HEADER_CONTENT_TYPE]: "application/json",
+            [HEADER_ACCEPT]: "application/json",
+            [HEADER_USER_AGENT]: this.opts.userAgent,
+            [HEADER_IDEMPOTENCY_KEY]: idempotencyKey
+          },
+          body,
+          maxRedirections: 0,
+          signal: AbortSignal.timeout(this.opts.timeoutMs)
+        });
+        statusCode = res.statusCode;
+        responseHeaders = res.headers;
+        responseBody = await res.body.text();
+      } catch (err) {
+        lastError = err;
+        if (this.opts.debug) {
+          logger.debug(`attempt ${attempt} transport error: ${err?.message ?? err}`);
+        }
+        if (attempt < maxAttempts) {
+          await sleep(computeDelay(attempt, this.opts.retry.baseDelayMs, this.opts.retry.maxDelayMs));
+          continue;
+        }
+        throw new QualflareApiError({
+          message: `failed to send request to ${url}`,
+          cause: err
+        });
+      }
+      if (this.opts.debug) {
+        logger.debug(`attempt ${attempt} response: ${statusCode}`);
+      }
+      if (statusCode >= 200 && statusCode < 300) {
+        return parseSuccess(responseBody);
+      }
+      const parsedError = parseErrorBody(responseBody);
+      if (!RETRYABLE_STATUS_CODES.has(statusCode) || attempt === maxAttempts) {
+        throw buildApiError(statusCode, parsedError);
+      }
+      const retryAfterMs = parseRetryAfter(responseHeaders["retry-after"]);
+      const delay = computeDelay(
+        attempt,
+        this.opts.retry.baseDelayMs,
+        this.opts.retry.maxDelayMs,
+        retryAfterMs
+      );
+      if (this.opts.debug) {
+        logger.debug(`retrying after ${Math.round(delay)}ms (status ${statusCode})`);
+      }
+      await sleep(delay);
+    }
+    throw lastError instanceof Error ? lastError : new QualflareApiError({ message: "request failed for an unknown reason" });
+  }
+};
+function parseSuccess(responseBody) {
+  try {
+    const parsed = JSON.parse(responseBody);
+    if (typeof parsed.seq !== "number") {
+      throw new Error('response body missing numeric "seq"');
+    }
+    return parsed;
+  } catch (err) {
+    throw new QualflareApiError({
+      message: "server returned a success status but an unparseable body",
+      cause: err
+    });
+  }
+}
+function parseErrorBody(responseBody) {
+  if (!responseBody) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(responseBody);
+  } catch {
+    return void 0;
+  }
+}
+function parseRetryAfter(value) {
+  const raw = Array.isArray(value) ? value[0] : value;
+  if (!raw) {
+    return void 0;
+  }
+  const seconds = Number(raw);
+  return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/shared/duration.ts
+var NS_PER_MS = 1e6;
+function msToNs(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return 0;
+  }
+  return Math.round(ms * NS_PER_MS);
+}
+
+// src/plugin/version.ts
+var PACKAGE_VERSION = "0.1.0";
+
+// src/plugin/collect-builder.ts
+import * as os from "os";
+function resolveOs(config, info) {
+  if (config.os) {
+    return config.os;
+  }
+  if (info?.osName) {
+    return info.osVersion ? `${info.osName} ${info.osVersion}` : info.osName;
+  }
+  return `${os.type()} ${os.release()}`;
+}
+function resolveBrowser(config, info) {
+  if (config.browser) {
+    return config.browser;
+  }
+  if (info?.browserName) {
+    return info.browserVersion ? `${info.browserName} ${info.browserVersion}` : info.browserName;
+  }
+  return "";
+}
+function buildCollectPayload(accumulator, config, browserInfo) {
+  return {
+    framework: config.framework,
+    platform: config.platform,
+    os: resolveOs(config, browserInfo),
+    browser: resolveBrowser(config, browserInfo),
+    branch: config.branch,
+    commit: config.commit,
+    environment: config.environment,
+    language: config.language,
+    milestone: config.milestone,
+    metadata: {
+      version: PACKAGE_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cliName: "qualflare-cypress"
+    },
+    properties: config.properties,
+    suites: accumulator.getSuites(),
+    ciProvider: config.ciProvider,
+    ciBuildNumber: config.ciBuildNumber,
+    ciRunUrl: config.ciRunUrl,
+    ciPrNumber: config.ciPrNumber
+  };
+}
+
+// src/plugin/state.ts
+var LaunchAccumulator = class {
+  suites = [];
+  truncated = false;
+  addSuite(suite) {
+    if (this.suites.length >= MAX_SUITES_PER_LAUNCH) {
+      if (!this.truncated) {
+        this.truncated = true;
+        logger.warn(
+          `reached the server's ${MAX_SUITES_PER_LAUNCH}-suite-per-launch cap \u2014 further spec files' results will not be uploaded this run.`
+        );
+      }
+      return;
+    }
+    this.suites.push(suite);
+  }
+  getSuites() {
+    return this.suites;
+  }
+};
+var TestPhaseGate = class {
+  started = false;
+  markStarted() {
+    this.started = true;
+  }
+  hasStarted() {
+    return this.started;
+  }
+  /** Called at `before:spec`, so each spec file gets its own fresh
+   * before()-hook-vs-real-test boundary. */
+  reset() {
+    this.started = false;
+  }
+};
+var PendingAttachmentQueue = class {
+  pending = [];
+  enqueue(attachment) {
+    this.pending.push(attachment);
+  }
+  /** Returns the buffered attachments and clears the queue. */
+  drain() {
+    const drained = this.pending;
+    this.pending = [];
+    return drained;
+  }
+};
+
+// src/plugin/events.ts
+function registerEvents(on, config, buffer, pendingAttachments, testPhaseGate) {
+  const accumulator = new LaunchAccumulator();
+  let browserInfo;
+  let currentSpecStart = 0;
+  on("before:run", (details) => {
+    browserInfo = {
+      browserName: details.browser?.displayName,
+      browserVersion: details.browser?.version,
+      osName: details.system?.osName,
+      osVersion: details.system?.osVersion
+    };
+  });
+  on("after:screenshot", (details) => {
+    if (!testPhaseGate.hasStarted()) {
+      logger.warn(
+        `a screenshot ("${details.name || "unnamed"}") was captured before any test in this spec had started (likely in a root \`before()\` hook) and cannot be attributed to a specific test \u2014 it was not uploaded.`
+      );
+      return;
+    }
+    pendingAttachments.enqueue({
+      name: details.name || (details.testFailure ? "failure-screenshot" : "screenshot"),
+      path: details.path,
+      mimeType: "image/png"
+    });
+  });
+  on("before:spec", () => {
+    currentSpecStart = Date.now();
+    testPhaseGate.reset();
+    buffer.drain();
+  });
+  on("after:spec", (spec, results) => {
+    const cases = buffer.drain();
+    const suite = {
+      name: spec.relative,
+      category: "e2e",
+      duration: msToNs(results.stats.duration ?? Date.now() - currentSpecStart),
+      timestamp: new Date(results.stats.startedAt ?? Date.now()).toISOString(),
+      cases
+    };
+    if (cases.length !== results.stats.tests) {
+      logger.warn(
+        `spec ${spec.relative}: captured ${cases.length} case(s) but Cypress reported ${results.stats.tests} test(s) \u2014 some results may be missing from the uploaded report.`
+      );
+    }
+    accumulator.addSuite(suite);
+    const orphaned = pendingAttachments.drain();
+    if (orphaned.length > 0) {
+      logger.warn(
+        `spec ${spec.relative}: ${orphaned.length} screenshot(s) could not be attributed to a specific test (likely taken outside a test body, e.g. in an \`after\` hook) and were not uploaded.`
+      );
+    }
+    if (results.video) {
+      logger.info(
+        `spec ${spec.relative} recorded a video at ${results.video} \u2014 not uploaded (qualflare-cypress does not support video attachments yet).`
+      );
+    }
+  });
+  on("after:run", async () => {
+    const suites = accumulator.getSuites();
+    if (suites.length === 0) {
+      logger.info("no test results were captured this run \u2014 skipping upload.");
+      return;
+    }
+    const collect = buildCollectPayload(accumulator, config, browserInfo);
+    const client = new QualflareHttpClient({
+      endpoint: config.apiEndpoint,
+      token: config.token,
+      timeoutMs: config.timeoutMs,
+      retry: config.retry,
+      userAgent: `qualflare-cypress/${PACKAGE_VERSION}`,
+      debug: config.debug
+    });
+    try {
+      const result = await client.send(collect);
+      logger.info(`uploaded launch #${result.seq} to Qualflare.`);
+    } catch (err) {
+      logger.error(`failed to upload results to Qualflare: ${err.message}`);
+      if (config.failOnUploadError) {
+        throw err;
+      }
+    }
+  });
+}
+
+// src/plugin/ci-detect.ts
+import * as ciInfo from "ci-info";
+function parsePositiveInt(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 1 ? n : void 0;
+}
+function nonEmpty(raw) {
+  return raw && raw.length > 0 ? raw : void 0;
+}
+var PROVIDERS = [
+  {
+    detect: (env) => env.GITHUB_ACTIONS === "true",
+    providerName: "GitHub Actions",
+    buildNumber: (env) => nonEmpty(env.GITHUB_RUN_NUMBER),
+    runUrl: (env) => env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY && env.GITHUB_RUN_ID ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}` : void 0,
+    prNumber: (env) => {
+      const match = /^refs\/pull\/(\d+)\/merge$/.exec(env.GITHUB_REF ?? "");
+      return match ? parsePositiveInt(match[1]) : void 0;
+    }
+  },
+  {
+    detect: (env) => env.GITLAB_CI === "true",
+    providerName: "GitLab CI",
+    buildNumber: (env) => nonEmpty(env.CI_PIPELINE_IID),
+    runUrl: (env) => nonEmpty(env.CI_PIPELINE_URL),
+    prNumber: (env) => parsePositiveInt(env.CI_MERGE_REQUEST_IID)
+  },
+  {
+    detect: (env) => env.CIRCLECI === "true",
+    providerName: "CircleCI",
+    buildNumber: (env) => nonEmpty(env.CIRCLE_BUILD_NUM),
+    runUrl: (env) => nonEmpty(env.CIRCLE_BUILD_URL),
+    prNumber: (env) => parsePositiveInt(env.CIRCLE_PR_NUMBER)
+  },
+  {
+    detect: (env) => env.BUILDKITE === "true",
+    providerName: "Buildkite",
+    buildNumber: (env) => nonEmpty(env.BUILDKITE_BUILD_NUMBER),
+    runUrl: (env) => nonEmpty(env.BUILDKITE_BUILD_URL),
+    prNumber: (env) => {
+      const raw = env.BUILDKITE_PULL_REQUEST;
+      if (!raw || raw === "false") {
+        return void 0;
+      }
+      return parsePositiveInt(raw);
+    }
+  },
+  {
+    // Jenkins has no simple `JENKINS=true`-style flag; JENKINS_URL is always
+    // set by the Jenkins agent and is the conventional detection signal.
+    detect: (env) => Boolean(env.JENKINS_URL),
+    providerName: "Jenkins",
+    buildNumber: (env) => nonEmpty(env.BUILD_NUMBER),
+    runUrl: (env) => nonEmpty(env.BUILD_URL)
+    // Jenkins has no standardized PR-number env var across its many PR
+    // plugins (Multibranch, GitHub Branch Source, etc.) — deliberately
+    // omitted rather than guessing at a plugin-specific variable.
+  },
+  {
+    detect: (env) => env.TF_BUILD === "True" || env.TF_BUILD === "true",
+    providerName: "Azure Pipelines",
+    buildNumber: (env) => nonEmpty(env.BUILD_BUILDID),
+    runUrl: (env) => {
+      const collectionUri = env.SYSTEM_TEAMFOUNDATIONCOLLECTIONURI;
+      const project = env.SYSTEM_TEAMPROJECT;
+      const buildId = env.BUILD_BUILDID;
+      if (!collectionUri || !project || !buildId) {
+        return void 0;
+      }
+      return `${collectionUri.replace(/\/+$/, "")}/${encodeURIComponent(project)}/_build/results?buildId=${buildId}`;
+    },
+    prNumber: (env) => parsePositiveInt(env.SYSTEM_PULLREQUEST_PULLREQUESTNUMBER)
+  },
+  {
+    detect: (env) => Boolean(env.BITBUCKET_BUILD_NUMBER),
+    providerName: "Bitbucket Pipelines",
+    buildNumber: (env) => nonEmpty(env.BITBUCKET_BUILD_NUMBER),
+    runUrl: (env) => {
+      const origin = env.BITBUCKET_GIT_HTTP_ORIGIN;
+      if (!origin) {
+        return void 0;
+      }
+      const resultsId = env.BITBUCKET_PIPELINE_UUID ?? env.BITBUCKET_BUILD_NUMBER;
+      return resultsId ? `${origin}/addon/pipelines/home#!/results/${resultsId}` : void 0;
+    },
+    prNumber: (env) => parsePositiveInt(env.BITBUCKET_PR_ID)
+  }
+];
+function detectCi(env = process.env) {
+  const provider = PROVIDERS.find((p) => p.detect(env));
+  if (provider) {
+    const result = { ciProvider: provider.providerName };
+    const buildNumber = provider.buildNumber?.(env);
+    if (buildNumber !== void 0) result.ciBuildNumber = buildNumber;
+    const runUrl = provider.runUrl?.(env);
+    if (runUrl !== void 0) result.ciRunUrl = runUrl;
+    const prNumber = provider.prNumber?.(env);
+    if (prNumber !== void 0) result.ciPrNumber = prNumber;
+    return result;
+  }
+  if (ciInfo.name) {
+    return { ciProvider: ciInfo.name };
+  }
+  return {};
+}
+
+// src/plugin/git-detect.ts
+import { execFileSync } from "child_process";
+var defaultExecGit = (args, cwd) => execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+function firstEnv(env, ...names) {
+  for (const name2 of names) {
+    const value = env[name2];
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function detectBranchFromGit(exec, cwd) {
+  try {
+    const out = exec(["symbolic-ref", "--short", "-q", "HEAD"], cwd).trim();
+    return out || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectCommitFromGit(exec, cwd) {
+  try {
+    const out = exec(["rev-parse", "HEAD"], cwd).trim();
+    return out || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectGit(env = process.env, cwd = process.cwd(), exec = defaultExecGit) {
+  const branch = firstEnv(env, "GIT_BRANCH", "GITHUB_REF_NAME", "CI_COMMIT_REF_NAME", "BITBUCKET_BRANCH") ?? detectBranchFromGit(exec, cwd);
+  const commit = firstEnv(env, "GIT_COMMIT", "GITHUB_SHA", "CI_COMMIT_SHA", "BITBUCKET_COMMIT") ?? detectCommitFromGit(exec, cwd);
+  const result = {};
+  if (branch !== void 0) result.branch = branch;
+  if (commit !== void 0) result.commit = commit;
+  return result;
+}
+
+// src/plugin/resolve-config.ts
+function firstEnv2(...names) {
+  for (const name2 of names) {
+    const value = process.env[name2];
+    if (value !== void 0 && value !== "") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function envBool(...names) {
+  const raw = firstEnv2(...names);
+  if (raw === void 0) {
+    return void 0;
+  }
+  return raw === "true" || raw === "1";
+}
+function envInt(...names) {
+  const raw = firstEnv2(...names);
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+var QualflareConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QualflareConfigError";
+  }
+};
+function resolveConfig(options, deps = {}) {
+  const doDetectGit = deps.detectGit ?? detectGit;
+  const doDetectCi = deps.detectCi ?? detectCi;
+  const enabled = options.enabled ?? envBool("QUALFLARE_ENABLED") ?? true;
+  const token = options.token ?? firstEnv2("QUALFLARE_TOKEN", "QF_TOKEN") ?? "";
+  if (enabled && token === "") {
+    throw new QualflareConfigError(
+      "qualflare-cypress: no token configured. Set the `token` option or the QUALFLARE_TOKEN (or QF_TOKEN) environment variable, or pass `enabled: false` to disable this plugin."
+    );
+  }
+  const milestoneRaw = options.milestone !== void 0 ? options.milestone : envInt("QUALFLARE_MILESTONE", "QF_MILESTONE");
+  const milestone = milestoneRaw !== void 0 && milestoneRaw !== null && milestoneRaw >= 1 ? milestoneRaw : null;
+  const envBranch = firstEnv2("QUALFLARE_BRANCH", "QF_BRANCH");
+  const envCommit = firstEnv2("QUALFLARE_COMMIT", "QF_COMMIT");
+  const needsGitDetection = options.branch === void 0 && envBranch === void 0 || options.commit === void 0 && envCommit === void 0;
+  const detectedGit = needsGitDetection ? doDetectGit() : {};
+  const branch = options.branch !== void 0 ? options.branch : envBranch ?? detectedGit.branch ?? null;
+  const commit = options.commit !== void 0 ? options.commit : envCommit ?? detectedGit.commit ?? null;
+  const detectedCi = doDetectCi();
+  const ciProvider = options.ciProvider ?? detectedCi.ciProvider;
+  const ciBuildNumber = options.ciBuildNumber ?? detectedCi.ciBuildNumber;
+  const ciRunUrl = options.ciRunUrl ?? detectedCi.ciRunUrl;
+  const ciPrNumber = options.ciPrNumber ?? detectedCi.ciPrNumber;
+  return {
+    token,
+    apiEndpoint: options.apiEndpoint ?? firstEnv2("QUALFLARE_API_ENDPOINT") ?? "https://api.qualflare.com",
+    // `||` (truthy check), not `??`, for these three REQUIRED-non-empty wire
+    // fields — matching `collect-builder.ts`'s `resolveOs`/`resolveBrowser`,
+    // which already correctly treat an explicit `''` option as "not set."
+    // `??` only falls back on `null`/`undefined`, so `environment: ''` would
+    // previously win outright over the `'development'` default, silently
+    // 400ing the whole launch (the server rejects an empty `environment`)
+    // and — since `failOnUploadError` defaults `false` — failing the entire
+    // upload with no visible error by default. Found via deep adversarial
+    // self-review.
+    environment: (options.environment || void 0) ?? firstEnv2("QUALFLARE_ENVIRONMENT", "QF_ENVIRONMENT") ?? "development",
+    language: (options.language || void 0) ?? firstEnv2("QUALFLARE_LANGUAGE", "QF_LANGUAGE") ?? "en-US",
+    milestone,
+    branch,
+    commit,
+    platform: options.platform ?? "web",
+    framework: options.framework || "cypress",
+    os: options.os,
+    browser: options.browser,
+    properties: options.properties,
+    ciProvider,
+    ciBuildNumber,
+    ciRunUrl,
+    ciPrNumber,
+    timeoutMs: options.timeoutMs ?? envInt("QUALFLARE_TIMEOUT_MS") ?? 12e4,
+    retry: {
+      max: options.retry?.max ?? envInt("QUALFLARE_RETRY_MAX", "QF_RETRY_MAX") ?? 3,
+      baseDelayMs: options.retry?.baseDelayMs ?? envInt("QUALFLARE_RETRY_BASE_DELAY_MS") ?? 1e3,
+      maxDelayMs: options.retry?.maxDelayMs ?? envInt("QUALFLARE_RETRY_MAX_DELAY_MS") ?? 3e4
+    },
+    failOnUploadError: options.failOnUploadError ?? envBool("QUALFLARE_FAIL_ON_UPLOAD_ERROR") ?? false,
+    attachScreenshots: options.attachScreenshots ?? envBool("QUALFLARE_ATTACH_SCREENSHOTS") ?? true,
+    maxAttachmentBytes: options.maxAttachmentBytes ?? envInt("QUALFLARE_MAX_ATTACHMENT_BYTES") ?? 15e5,
+    maxTotalAttachmentBytes: options.maxTotalAttachmentBytes ?? envInt("QUALFLARE_MAX_TOTAL_ATTACHMENT_BYTES") ?? 75e4,
+    debug: options.debug ?? envBool("QUALFLARE_DEBUG", "QF_DEBUG") ?? false,
+    enabled
+  };
+}
+
+// src/plugin/tasks.ts
+var CaseBuffer = class {
+  cases = [];
+  truncated = false;
+  add(testCase) {
+    if (this.cases.length >= MAX_CASES_PER_SUITE) {
+      if (!this.truncated) {
+        this.truncated = true;
+        logger.warn(
+          `reached the server's ${MAX_CASES_PER_SUITE}-case-per-suite cap \u2014 further test results in this spec file will not be uploaded.`
+        );
+      }
+      return;
+    }
+    this.cases.push(testCase);
+  }
+  /** Returns the buffered cases and clears the buffer (including the
+   * truncation-warned flag, so a later spec that also hits the cap warns
+   * again rather than staying silent for the rest of the run). */
+  drain() {
+    const drained = this.cases;
+    this.cases = [];
+    this.truncated = false;
+    return drained;
+  }
+};
+function registerTasks(on, buffer, attachmentConfig, attachmentBudget, pendingAttachments, testPhaseGate) {
+  on("task", {
+    [TASK_REPORT_CASE](testCase) {
+      const attachments = [...testCase.attachments ?? [], ...pendingAttachments.drain()];
+      const resolved = resolveAttachments(
+        attachments.length > 0 ? attachments : void 0,
+        attachmentConfig,
+        attachmentBudget
+      );
+      buffer.add({ ...testCase, attachments: resolved });
+      return null;
+    },
+    // One-shot signal from the browser side (see TestPhaseGate's doc
+    // comment in state.ts) — fired from a root-level beforeEach right
+    // before the first test's body runs.
+    [TASK_MARK_TEST_PHASE_STARTED]() {
+      testPhaseGate.markStarted();
+      return null;
+    }
+  });
+}
+
+// src/plugin/index.ts
+function qualflareCypress(on, config, options = {}) {
+  const resolved = resolveConfig(options);
+  const buffer = new CaseBuffer();
+  const pendingAttachments = new PendingAttachmentQueue();
+  const testPhaseGate = new TestPhaseGate();
+  const attachmentBudget = new AttachmentBudget(resolved.maxTotalAttachmentBytes);
+  registerTasks(on, buffer, resolved, attachmentBudget, pendingAttachments, testPhaseGate);
+  if (resolved.enabled) {
+    registerEvents(on, resolved, buffer, pendingAttachments, testPhaseGate);
+  }
+  return config;
+}
+export {
+  QualflareConfigError,
+  qualflareCypress
+};
+//# sourceMappingURL=index.js.map