@qualflare/cypress 0.1.0 → 0.2.0

package/dist/plugin/index.js

@@ -1,6 +1,6 @@
 // src/plugin/attachment-reader.ts
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 
 // src/shared/logger.ts
 var PREFIX = "[qualflare-cypress]";
@@ -19,6 +19,46 @@ var logger = {
   }
 };
 
+// src/plugin/video-uploader.ts
+import * as fs from "fs";
+import * as path from "path";
+import { randomUUID } from "crypto";
+var VIDEO_MIME_TYPES_BY_EXTENSION = {
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime"
+};
+function copyVideoAttachment(filePath, outputDir, maxVideoBytes) {
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType = VIDEO_MIME_TYPES_BY_EXTENSION[ext];
+  if (!mimeType) {
+    logger.warn(`skipping video attachment "${filePath}": unsupported video format.`);
+    return void 0;
+  }
+  let fileSize;
+  try {
+    fileSize = fs.statSync(filePath).size;
+  } catch (err) {
+    logger.warn(`skipping video attachment "${filePath}": could not stat file: ${err.message}`);
+    return void 0;
+  }
+  if (fileSize > maxVideoBytes) {
+    logger.warn(
+      `skipping video attachment "${filePath}": ${fileSize} bytes exceeds the configured maxVideoBytes cap of ${maxVideoBytes} bytes.`
+    );
+    return void 0;
+  }
+  const localVideoPath = `${randomUUID()}${ext}`;
+  try {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.copyFileSync(filePath, path.join(outputDir, localVideoPath));
+  } catch (err) {
+    logger.warn(`skipping video attachment "${filePath}": could not copy file: ${err.message}`);
+    return void 0;
+  }
+  return { localVideoPath, fileSize, mimeType };
+}
+
 // src/plugin/attachment-reader.ts
 var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov", ".avi", ".mkv"]);
 var AttachmentBudget = class {
@@ -44,7 +84,7 @@ function isVideoLike(attachment) {
   if (attachment.mimeType?.toLowerCase().startsWith("video/")) {
     return true;
   }
-  if (attachment.path && VIDEO_EXTENSIONS.has(path.extname(attachment.path).toLowerCase())) {
+  if (attachment.path && VIDEO_EXTENSIONS.has(path2.extname(attachment.path).toLowerCase())) {
     return true;
   }
   return false;
@@ -52,7 +92,7 @@ function isVideoLike(attachment) {
 function readAttachmentFile(filePath, maxAttachmentBytes, budget) {
   let size;
   try {
-    size = fs.statSync(filePath).size;
+    size = fs2.statSync(filePath).size;
   } catch (err) {
     return { skipped: true, reason: `could not stat file: ${err.message}` };
   }
@@ -69,7 +109,7 @@ function readAttachmentFile(filePath, maxAttachmentBytes, budget) {
     };
   }
   try {
-    const content = fs.readFileSync(filePath).toString("base64");
+    const content = fs2.readFileSync(filePath).toString("base64");
     return { skipped: false, content };
   } catch (err) {
     return { skipped: true, reason: `could not read file: ${err.message}` };
@@ -85,9 +125,20 @@ function resolveAttachments(attachments, config, budget) {
   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"}).`
-      );
+      if (!attachment.path) {
+        logger.warn(`skipping video attachment "${attachment.name}": no local file path to copy.`);
+        continue;
+      }
+      const copied = copyVideoAttachment(attachment.path, config.outputDir, config.maxVideoBytes);
+      if (!copied) {
+        continue;
+      }
+      resolved.push({
+        ...attachment,
+        mimeType: copied.mimeType,
+        localVideoPath: copied.localVideoPath,
+        fileSize: copied.fileSize
+      });
       continue;
     }
     if (attachment.content !== void 0 || !attachment.path) {
@@ -104,228 +155,18 @@ function resolveAttachments(attachments, config, budget) {
   return resolved.length > 0 ? resolved : void 0;
 }
 
-// src/http/client.ts
-import { request } from "undici";
+// src/plugin/events.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // 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));
-}
+var MAX_ATTACHMENTS_PER_CASE = 50;
+var MAX_VIDEO_UPLOAD_BYTES = 50 * 1024 * 1024;
 
 // src/shared/duration.ts
 var NS_PER_MS = 1e6;
@@ -336,11 +177,13 @@ function msToNs(ms) {
   return Math.round(ms * NS_PER_MS);
 }
 
+// src/plugin/collect-builder.ts
+import * as os from "os";
+
 // src/plugin/version.ts
-var PACKAGE_VERSION = "0.1.0";
+var PACKAGE_VERSION = "0.2.0";
 
 // src/plugin/collect-builder.ts
-import * as os from "os";
 function resolveOs(config, info) {
   if (config.os) {
     return config.os;
@@ -432,6 +275,7 @@ var PendingAttachmentQueue = class {
 };
 
 // src/plugin/events.ts
+var FAILURE_STATUSES = /* @__PURE__ */ new Set(["failed", "error", "timeout"]);
 function registerEvents(on, config, buffer, pendingAttachments, testPhaseGate) {
   const accumulator = new LaunchAccumulator();
   let browserInfo;
@@ -447,7 +291,7 @@ function registerEvents(on, config, buffer, pendingAttachments, testPhaseGate) {
   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.`
+        `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 included in the report.`
       );
       return;
     }
@@ -462,59 +306,77 @@ function registerEvents(on, config, buffer, pendingAttachments, testPhaseGate) {
     testPhaseGate.reset();
     buffer.drain();
   });
-  on("after:spec", (spec, results) => {
+  on("after:spec", async (spec, results) => {
     const cases = buffer.drain();
+    if (results.video) {
+      const failedCase = cases.find((c) => FAILURE_STATUSES.has(c.status));
+      if (failedCase) {
+        const copied = copyVideoAttachment(results.video, config.outputDir, config.maxVideoBytes);
+        if (copied) {
+          attachVideo(failedCase, copied);
+        }
+      } else {
+        logger.info(`spec ${spec.relative} recorded a video but no test failed \u2014 not attached.`);
+      }
+    }
     const suite = {
       name: spec.relative,
-      category: "e2e",
+      category: "cypress",
       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.`
+        `spec ${spec.relative}: captured ${cases.length} case(s) but Cypress reported ${results.stats.tests} test(s) \u2014 some results may be missing from the 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).`
+        `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 included in the report.`
       );
     }
   });
   on("after:run", async () => {
     const suites = accumulator.getSuites();
     if (suites.length === 0) {
-      logger.info("no test results were captured this run \u2014 skipping upload.");
+      logger.info("no test results were captured this run \u2014 skipping file write.");
       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;
+    if (config.shardIndex !== void 0) {
+      for (const suite of collect.suites) {
+        for (const c of suite.cases) {
+          c.shardIndex = config.shardIndex;
+        }
       }
     }
+    fs3.mkdirSync(config.outputDir, { recursive: true });
+    const outputPath = path3.join(config.outputDir, `${randomUUID2()}.json`);
+    fs3.writeFileSync(outputPath, JSON.stringify(collect));
+    logger.info(`wrote Collect payload to ${outputPath} \u2014 run \`qualflare-cli collect ${config.outputDir}\` to upload it.`);
   });
 }
+function attachVideo(testCase, copied) {
+  const attachments = testCase.attachments ?? [];
+  if (attachments.length >= MAX_ATTACHMENTS_PER_CASE) {
+    logger.warn(
+      `not attaching video to "${testCase.name}": already at the server's ${MAX_ATTACHMENTS_PER_CASE}-attachment-per-case cap.`
+    );
+    return;
+  }
+  testCase.attachments = [
+    ...attachments,
+    {
+      name: "video",
+      mimeType: copied.mimeType,
+      localVideoPath: copied.localVideoPath,
+      fileSize: copied.fileSize
+    }
+  ];
+}
 
 // src/plugin/ci-detect.ts
 import * as ciInfo from "ci-info";
@@ -697,12 +559,8 @@ 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 outputDir = options.outputDir || firstEnv2("QUALFLARE_OUTPUT_DIR") || "./qualflare-results";
+  const shardIndex = options.shardIndex ?? envInt("QUALFLARE_SHARD_INDEX");
   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");
@@ -717,17 +575,14 @@ function resolveConfig(options, deps = {}) {
   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.
+    // and — since this process no longer attempts uploads — the error would
+    // be deferred until qualflare-cli tries to upload.
     environment: (options.environment || void 0) ?? firstEnv2("QUALFLARE_ENVIRONMENT", "QF_ENVIRONMENT") ?? "development",
     language: (options.language || void 0) ?? firstEnv2("QUALFLARE_LANGUAGE", "QF_LANGUAGE") ?? "en-US",
     milestone,
@@ -742,18 +597,13 @@ function resolveConfig(options, deps = {}) {
     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
+    maxVideoBytes: options.maxVideoBytes ?? envInt("QUALFLARE_MAX_VIDEO_BYTES") ?? MAX_VIDEO_UPLOAD_BYTES,
+    enabled,
+    outputDir,
+    shardIndex
   };
 }
 
@@ -785,9 +635,9 @@ var CaseBuffer = class {
 };
 function registerTasks(on, buffer, attachmentConfig, attachmentBudget, pendingAttachments, testPhaseGate) {
   on("task", {
-    [TASK_REPORT_CASE](testCase) {
+    async [TASK_REPORT_CASE](testCase) {
       const attachments = [...testCase.attachments ?? [], ...pendingAttachments.drain()];
-      const resolved = resolveAttachments(
+      const resolved = await resolveAttachments(
         attachments.length > 0 ? attachments : void 0,
         attachmentConfig,
         attachmentBudget
@@ -812,7 +662,8 @@ function qualflareCypress(on, config, options = {}) {
   const pendingAttachments = new PendingAttachmentQueue();
   const testPhaseGate = new TestPhaseGate();
   const attachmentBudget = new AttachmentBudget(resolved.maxTotalAttachmentBytes);
-  registerTasks(on, buffer, resolved, attachmentBudget, pendingAttachments, testPhaseGate);
+  const attachmentConfig = resolved;
+  registerTasks(on, buffer, attachmentConfig, attachmentBudget, pendingAttachments, testPhaseGate);
   if (resolved.enabled) {
     registerEvents(on, resolved, buffer, pendingAttachments, testPhaseGate);
   }