@supatest/cypress-reporter 0.0.1

package/dist/index.js

@@ -0,0 +1,884 @@
+// src/index.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+// ../reporter-core/dist/index.js
+import { simpleGit } from "simple-git";
+import fs2 from "fs";
+import { createHash } from "crypto";
+import fs3 from "fs";
+var defaultRetryConfig = {
+  maxAttempts: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  retryOnStatusCodes: [408, 429, 500, 502, 503, 504]
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetry(error, config) {
+  if (error instanceof Error && "statusCode" in error) {
+    const statusCode = error.statusCode;
+    return config.retryOnStatusCodes.includes(statusCode);
+  }
+  if (error instanceof Error) {
+    const networkErrors = ["ECONNRESET", "ETIMEDOUT", "ECONNREFUSED", "ENOTFOUND"];
+    return networkErrors.some((e) => error.message.includes(e));
+  }
+  return false;
+}
+async function withRetry(fn, config = defaultRetryConfig) {
+  let lastError;
+  for (let attempt = 1; attempt <= config.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === config.maxAttempts) {
+        throw error;
+      }
+      if (!shouldRetry(error, config)) {
+        throw error;
+      }
+      const delay = Math.min(
+        config.baseDelayMs * Math.pow(2, attempt - 1),
+        config.maxDelayMs
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+var SupatestApiClient = class {
+  options;
+  retryConfig;
+  constructor(options) {
+    this.options = options;
+    this.retryConfig = {
+      ...defaultRetryConfig,
+      maxAttempts: options.retryAttempts
+    };
+  }
+  async createRun(data) {
+    if (this.options.dryRun) {
+      this.logPayload("POST /v1/runs", data);
+      return {
+        runId: `mock_run_${Date.now()}`,
+        status: "running"
+      };
+    }
+    return this.request("POST", "/v1/runs", data);
+  }
+  async submitTest(runId, data) {
+    if (this.options.dryRun) {
+      this.logPayload(`POST /v1/runs/${runId}/tests`, data);
+      return;
+    }
+    await this.request("POST", `/v1/runs/${runId}/tests`, data);
+  }
+  async signAttachments(runId, data) {
+    if (this.options.dryRun) {
+      this.logPayload(`POST /v1/runs/${runId}/attachments/sign`, data);
+      return {
+        uploads: data.attachments.map((att, i) => ({
+          attachmentId: `mock_att_${i}_${Date.now()}`,
+          signedUrl: `https://mock-s3.example.com/uploads/${att.filename}`,
+          expiresAt: new Date(Date.now() + 15 * 60 * 1e3).toISOString()
+        }))
+      };
+    }
+    return this.request(
+      "POST",
+      `/v1/runs/${runId}/attachments/sign`,
+      data
+    );
+  }
+  async completeRun(runId, data) {
+    if (this.options.dryRun) {
+      this.logPayload(`POST /v1/runs/${runId}/complete`, data);
+      return;
+    }
+    await this.request("POST", `/v1/runs/${runId}/complete`, data);
+  }
+  async request(method, path2, body) {
+    const url = `${this.options.apiUrl}${path2}`;
+    return withRetry(async () => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.options.timeoutMs
+      );
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.options.apiKey}`
+          },
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const error = new Error(
+            `API request failed: ${response.status} ${response.statusText}`
+          );
+          error.statusCode = response.status;
+          throw error;
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : {};
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }, this.retryConfig);
+  }
+  logPayload(endpoint, data) {
+    console.log(`
+[supatest][dry-run] ${endpoint}`);
+    console.log(JSON.stringify(data, null, 2));
+  }
+};
+var ErrorCollector = class {
+  errors = [];
+  recordError(category, message, context) {
+    const error = {
+      category,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      testId: context?.testId,
+      testTitle: context?.testTitle,
+      attachmentName: context?.attachmentName,
+      filePath: context?.filePath,
+      originalError: context?.error instanceof Error ? context.error.stack : void 0
+    };
+    this.errors.push(error);
+  }
+  getSummary() {
+    const byCategory = {
+      RUN_CREATE: 0,
+      TEST_SUBMISSION: 0,
+      ATTACHMENT_SIGN: 0,
+      ATTACHMENT_UPLOAD: 0,
+      FILE_READ: 0,
+      RUN_COMPLETE: 0
+    };
+    for (const error of this.errors) {
+      byCategory[error.category]++;
+    }
+    return {
+      totalErrors: this.errors.length,
+      byCategory,
+      errors: this.errors
+    };
+  }
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  formatSummary() {
+    if (this.errors.length === 0) {
+      return "";
+    }
+    const summary = this.getSummary();
+    const lines = [
+      "",
+      "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+      "\u26A0\uFE0F  Supatest Reporter - Error Summary",
+      "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+      `Total Errors: ${summary.totalErrors}`,
+      ""
+    ];
+    for (const [category, count] of Object.entries(summary.byCategory)) {
+      if (count === 0) continue;
+      const icon = this.getCategoryIcon(category);
+      const label = this.getCategoryLabel(category);
+      lines.push(`${icon} ${label}: ${count}`);
+      const categoryErrors = this.errors.filter((e) => e.category === category).slice(0, 3);
+      for (const error of categoryErrors) {
+        lines.push(`  \u2022 ${this.formatError(error)}`);
+      }
+      const remaining = count - categoryErrors.length;
+      if (remaining > 0) {
+        lines.push(`  ... and ${remaining} more`);
+      }
+      lines.push("");
+    }
+    lines.push(
+      "\u2139\uFE0F  Note: Test execution was not interrupted. Some results may not be visible in the dashboard."
+    );
+    lines.push(
+      "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"
+    );
+    return lines.join("\n");
+  }
+  getCategoryIcon(category) {
+    const icons = {
+      RUN_CREATE: "\u{1F680}",
+      TEST_SUBMISSION: "\u{1F4DD}",
+      ATTACHMENT_SIGN: "\u{1F510}",
+      ATTACHMENT_UPLOAD: "\u{1F4CE}",
+      FILE_READ: "\u{1F4C1}",
+      RUN_COMPLETE: "\u{1F3C1}"
+    };
+    return icons[category];
+  }
+  getCategoryLabel(category) {
+    const labels = {
+      RUN_CREATE: "Run Initialization",
+      TEST_SUBMISSION: "Test Result Submission",
+      ATTACHMENT_SIGN: "Attachment Signing",
+      ATTACHMENT_UPLOAD: "Attachment Upload",
+      FILE_READ: "File Access",
+      RUN_COMPLETE: "Run Completion"
+    };
+    return labels[category];
+  }
+  formatError(error) {
+    const parts = [];
+    if (error.testTitle) {
+      parts.push(`Test: "${error.testTitle}"`);
+    }
+    if (error.attachmentName) {
+      parts.push(`Attachment: "${error.attachmentName}"`);
+    }
+    if (error.filePath) {
+      parts.push(`File: ${error.filePath}`);
+    }
+    parts.push(error.message);
+    return parts.join(" - ");
+  }
+};
+async function getLocalGitInfo(rootDir) {
+  try {
+    const git = simpleGit(rootDir || process.cwd());
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      return {};
+    }
+    const [branchResult, commitResult, status, remotes] = await Promise.all([
+      git.revparse(["--abbrev-ref", "HEAD"]).catch(() => void 0),
+      git.revparse(["HEAD"]).catch(() => void 0),
+      git.status().catch(() => void 0),
+      git.getRemotes(true).catch(() => [])
+    ]);
+    const branch = typeof branchResult === "string" ? branchResult.trim() : void 0;
+    const commit = typeof commitResult === "string" ? commitResult.trim() : void 0;
+    let commitMessage;
+    try {
+      const logOutput = await git.raw(["log", "-1", "--format=%s"]);
+      commitMessage = typeof logOutput === "string" ? logOutput.trim() : void 0;
+    } catch {
+    }
+    let author;
+    let authorEmail;
+    try {
+      const authorConfig = await git.getConfig("user.name").catch(() => void 0);
+      const emailConfig = await git.getConfig("user.email").catch(() => void 0);
+      author = authorConfig && typeof authorConfig.value === "string" ? authorConfig.value.trim() : void 0;
+      authorEmail = emailConfig && typeof emailConfig.value === "string" ? emailConfig.value.trim() : void 0;
+    } catch {
+    }
+    let tag;
+    try {
+      const tagResult = await git.raw(["describe", "--tags", "--exact-match"]).catch(() => void 0);
+      tag = typeof tagResult === "string" ? tagResult.trim() : void 0;
+    } catch {
+    }
+    let repo;
+    const remote = remotes && remotes.length > 0 ? remotes[0] : null;
+    if (remote && remote.refs && remote.refs.fetch) {
+      repo = remote.refs.fetch;
+    }
+    const dirty = status ? status.modified.length > 0 || status.created.length > 0 || status.deleted.length > 0 : false;
+    return {
+      branch,
+      commit,
+      commitMessage,
+      repo,
+      author,
+      authorEmail,
+      tag,
+      dirty
+    };
+  } catch (error) {
+    return {};
+  }
+}
+var AttachmentUploader = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async upload(signedUrl, filePath, contentType) {
+    if (this.options.dryRun) {
+      try {
+        const stats = fs2.statSync(filePath);
+        console.log(
+          `[supatest][dry-run] Would upload ${filePath} (${stats.size} bytes) to S3`
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(
+          `[supatest][dry-run] Cannot access file ${filePath}: ${message}`
+        );
+      }
+      return;
+    }
+    let fileBuffer;
+    try {
+      fileBuffer = await fs2.promises.readFile(filePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to read file ${filePath}: ${message}`);
+    }
+    await withRetry(async () => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.options.timeoutMs
+      );
+      try {
+        const response = await fetch(signedUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": contentType,
+            "Content-Length": String(fileBuffer.length)
+          },
+          body: new Uint8Array(fileBuffer),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const error = new Error(
+            `S3 upload failed: ${response.status} ${response.statusText}`
+          );
+          error.statusCode = response.status;
+          throw error;
+        }
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }, defaultRetryConfig);
+  }
+  async uploadBatch(items, signedUploads) {
+    const pLimit = (await import("p-limit")).default;
+    const limit = pLimit(this.options.maxConcurrent);
+    const results = await Promise.allSettled(
+      items.map(
+        (item, index) => limit(async () => {
+          try {
+            await this.upload(item.signedUrl, item.filePath, item.contentType);
+            return {
+              success: true,
+              attachmentId: signedUploads[index]?.attachmentId
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              success: false,
+              attachmentId: signedUploads[index]?.attachmentId,
+              error: `${item.filePath}: ${message}`
+            };
+          }
+        })
+      )
+    );
+    return results.map((result, index) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      return {
+        success: false,
+        attachmentId: signedUploads[index]?.attachmentId,
+        error: message
+      };
+    });
+  }
+};
+function hashKey(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function getFileSize(filePath) {
+  try {
+    return fs3.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+function logInfo(message) {
+  console.log(`[supatest] ${message}`);
+}
+function logWarn(message) {
+  console.warn(`[supatest] ${message}`);
+}
+function getCIInfo() {
+  if (process.env.GITHUB_ACTIONS) {
+    return {
+      provider: "github-actions",
+      runId: process.env.GITHUB_RUN_ID,
+      jobId: process.env.GITHUB_JOB,
+      jobUrl: `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`,
+      buildNumber: process.env.GITHUB_RUN_NUMBER,
+      branch: process.env.GITHUB_REF_NAME,
+      pullRequest: process.env.GITHUB_EVENT_NAME === "pull_request" ? {
+        number: process.env.GITHUB_PR_NUMBER ?? "",
+        url: `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/pull/${process.env.GITHUB_PR_NUMBER}`
+      } : void 0
+    };
+  }
+  if (process.env.GITLAB_CI) {
+    return {
+      provider: "gitlab-ci",
+      runId: process.env.CI_PIPELINE_ID,
+      jobId: process.env.CI_JOB_ID,
+      jobUrl: process.env.CI_JOB_URL,
+      buildNumber: process.env.CI_PIPELINE_IID,
+      branch: process.env.CI_COMMIT_BRANCH,
+      pullRequest: process.env.CI_MERGE_REQUEST_IID ? {
+        number: process.env.CI_MERGE_REQUEST_IID,
+        url: process.env.CI_MERGE_REQUEST_PROJECT_URL + "/-/merge_requests/" + process.env.CI_MERGE_REQUEST_IID,
+        title: process.env.CI_MERGE_REQUEST_TITLE
+      } : void 0
+    };
+  }
+  if (process.env.JENKINS_URL) {
+    return {
+      provider: "jenkins",
+      runId: process.env.BUILD_ID,
+      jobUrl: process.env.BUILD_URL,
+      buildNumber: process.env.BUILD_NUMBER,
+      branch: process.env.GIT_BRANCH
+    };
+  }
+  if (process.env.CIRCLECI) {
+    return {
+      provider: "circleci",
+      runId: process.env.CIRCLE_WORKFLOW_ID,
+      jobId: process.env.CIRCLE_JOB,
+      jobUrl: process.env.CIRCLE_BUILD_URL,
+      buildNumber: process.env.CIRCLE_BUILD_NUM,
+      branch: process.env.CIRCLE_BRANCH,
+      pullRequest: process.env.CIRCLE_PULL_REQUEST ? {
+        number: process.env.CIRCLE_PR_NUMBER ?? "",
+        url: process.env.CIRCLE_PULL_REQUEST
+      } : void 0
+    };
+  }
+  if (process.env.TRAVIS) {
+    return {
+      provider: "travis",
+      runId: process.env.TRAVIS_BUILD_ID,
+      jobId: process.env.TRAVIS_JOB_ID,
+      jobUrl: process.env.TRAVIS_JOB_WEB_URL,
+      buildNumber: process.env.TRAVIS_BUILD_NUMBER,
+      branch: process.env.TRAVIS_BRANCH,
+      pullRequest: process.env.TRAVIS_PULL_REQUEST !== "false" ? {
+        number: process.env.TRAVIS_PULL_REQUEST ?? "",
+        url: `https://github.com/${process.env.TRAVIS_REPO_SLUG}/pull/${process.env.TRAVIS_PULL_REQUEST}`
+      } : void 0
+    };
+  }
+  if (process.env.BUILDKITE) {
+    return {
+      provider: "buildkite",
+      runId: process.env.BUILDKITE_BUILD_ID,
+      jobId: process.env.BUILDKITE_JOB_ID,
+      jobUrl: process.env.BUILDKITE_BUILD_URL,
+      buildNumber: process.env.BUILDKITE_BUILD_NUMBER,
+      branch: process.env.BUILDKITE_BRANCH
+    };
+  }
+  if (process.env.AZURE_PIPELINES || process.env.TF_BUILD) {
+    return {
+      provider: "azure-pipelines",
+      runId: process.env.BUILD_BUILDID,
+      jobUrl: `${process.env.SYSTEM_COLLECTIONURI}${process.env.SYSTEM_TEAMPROJECT}/_build/results?buildId=${process.env.BUILD_BUILDID}`,
+      buildNumber: process.env.BUILD_BUILDNUMBER,
+      branch: process.env.BUILD_SOURCEBRANCH
+    };
+  }
+  return void 0;
+}
+
+// src/index.ts
+var DEFAULT_API_URL = "https://code-api.supatest.ai";
+var SupatestCypressReporter = class {
+  options;
+  client;
+  uploader;
+  errorCollector = new ErrorCollector();
+  runId;
+  uploadQueue = [];
+  startedAt;
+  firstTestStartTime;
+  firstFailureTime;
+  testsProcessed = /* @__PURE__ */ new Map();
+  disabled = false;
+  rootDir;
+  stepIdCounter = 0;
+  cypressVersion;
+  browserName;
+  browserVersion;
+  constructor(options = {}) {
+    this.options = {
+      projectId: options.projectId || process.env.SUPATEST_PROJECT_ID || "",
+      apiKey: options.apiKey || process.env.SUPATEST_API_KEY || "",
+      apiUrl: options.apiUrl || process.env.SUPATEST_API_URL || DEFAULT_API_URL,
+      uploadAssets: options.uploadAssets ?? true,
+      maxConcurrentUploads: options.maxConcurrentUploads ?? 5,
+      retryAttempts: options.retryAttempts ?? 3,
+      timeoutMs: options.timeoutMs ?? 3e4,
+      dryRun: options.dryRun ?? process.env.SUPATEST_DRY_RUN === "true"
+    };
+  }
+  async onBeforeRun(details) {
+    this.rootDir = details.config.projectRoot;
+    this.cypressVersion = details.config.version;
+    this.browserName = details.browser.name;
+    this.browserVersion = details.browser.version;
+    if (!this.options.projectId || !this.options.apiKey) {
+      if (!this.options.dryRun) {
+        logWarn("Missing projectId or apiKey. Set SUPATEST_PROJECT_ID and SUPATEST_API_KEY.");
+        this.disabled = true;
+        return;
+      }
+    }
+    this.client = new SupatestApiClient({
+      apiKey: this.options.apiKey,
+      apiUrl: this.options.apiUrl,
+      timeoutMs: this.options.timeoutMs,
+      retryAttempts: this.options.retryAttempts,
+      dryRun: this.options.dryRun
+    });
+    this.uploader = new AttachmentUploader({
+      maxConcurrent: this.options.maxConcurrentUploads,
+      timeoutMs: this.options.timeoutMs,
+      dryRun: this.options.dryRun
+    });
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const runRequest = {
+        projectId: this.options.projectId,
+        startedAt: this.startedAt,
+        cypress: {
+          version: this.cypressVersion || "unknown",
+          browser: this.browserName || "electron"
+        },
+        projects: [{
+          name: this.browserName || "electron",
+          browserName: this.browserName
+        }],
+        testStats: {
+          totalFiles: details.specs.length,
+          totalTests: 0,
+          // Unknown at this point
+          totalProjects: 1
+        },
+        environment: this.getEnvironmentInfo(),
+        git: await this.getGitInfo(),
+        rootDir: this.rootDir
+      };
+      const response = await this.client.createRun(runRequest);
+      this.runId = response.runId;
+      logInfo(`Run ${this.runId} started (${details.specs.length} spec files)`);
+    } catch (error) {
+      this.errorCollector.recordError("RUN_CREATE", getErrorMessage(error), { error });
+      this.disabled = true;
+    }
+  }
+  async onAfterSpec(spec, results) {
+    if (this.disabled || !this.runId) return;
+    for (const test of results.tests) {
+      await this.processTestResult(spec, test, results);
+    }
+  }
+  async onAfterRun(results) {
+    if (this.disabled || !this.runId) {
+      if (this.errorCollector.hasErrors()) {
+        console.log(this.errorCollector.formatSummary());
+      }
+      return;
+    }
+    await Promise.allSettled(this.uploadQueue);
+    const summary = {
+      total: results.totalTests,
+      passed: results.totalPassed,
+      failed: results.totalFailed,
+      flaky: 0,
+      skipped: results.totalSkipped + results.totalPending,
+      timedOut: 0,
+      interrupted: 0,
+      durationMs: results.totalDuration
+    };
+    try {
+      await this.client.completeRun(this.runId, {
+        status: results.status === "finished" ? "complete" : "errored",
+        endedAt: results.endedTestsAt,
+        summary,
+        timing: {
+          totalDurationMs: results.totalDuration,
+          timeToFirstTest: this.firstTestStartTime ? this.firstTestStartTime - new Date(this.startedAt).getTime() : void 0,
+          timeToFirstFailure: this.firstFailureTime ? this.firstFailureTime - new Date(this.startedAt).getTime() : void 0
+        }
+      });
+      logInfo(`Run ${this.runId} completed`);
+    } catch (error) {
+      this.errorCollector.recordError("RUN_COMPLETE", getErrorMessage(error), { error });
+    }
+    if (this.errorCollector.hasErrors()) {
+      console.log(this.errorCollector.formatSummary());
+    }
+  }
+  async processTestResult(spec, test, specResults) {
+    const testId = this.getTestId(spec.relative, test.title);
+    const status = this.mapCypressStatus(test.state);
+    if (!this.firstTestStartTime && test.attempts[0]) {
+      this.firstTestStartTime = new Date(test.attempts[0].wallClockStartedAt).getTime();
+    }
+    if (!this.firstFailureTime && status === "failed") {
+      this.firstFailureTime = Date.now();
+    }
+    const lastAttempt = test.attempts[test.attempts.length - 1];
+    const resultEntry = {
+      resultId: hashKey(`${testId}:${test.attempts.length - 1}`),
+      retry: test.attempts.length - 1,
+      status,
+      startTime: lastAttempt?.wallClockStartedAt,
+      durationMs: lastAttempt?.wallClockDuration || 0,
+      errors: this.extractErrors(test),
+      steps: [],
+      // Cypress doesn't expose steps like Playwright
+      attachments: this.buildAttachmentMeta(test, specResults)
+    };
+    const tags = this.extractTags(test.title.join(" "));
+    const metadata = this.parseTestMetadata(tags);
+    const payload = {
+      testId,
+      cypressId: testId,
+      file: spec.relative,
+      location: { file: spec.relative, line: 0, column: 0 },
+      title: test.title[test.title.length - 1],
+      titlePath: test.title,
+      tags,
+      annotations: [],
+      expectedStatus: "passed",
+      outcome: this.getOutcome(test),
+      timeout: 0,
+      retries: test.attempts.length - 1,
+      status,
+      durationMs: test.attempts.reduce((sum, a) => sum + (a.wallClockDuration || 0), 0),
+      retryCount: test.attempts.length - 1,
+      results: [resultEntry],
+      projectName: this.browserName || "electron",
+      metadata
+    };
+    try {
+      await this.client.submitTest(this.runId, payload);
+      if (this.options.uploadAssets) {
+        await this.uploadAttachments(testId, resultEntry.resultId, specResults, test);
+      }
+    } catch (error) {
+      this.errorCollector.recordError("TEST_SUBMISSION", getErrorMessage(error), {
+        testId,
+        testTitle: test.title.join(" > "),
+        error
+      });
+    }
+  }
+  getTestId(file, titlePath) {
+    const fullTitle = titlePath.join(" ");
+    const idMatch = fullTitle.match(/@id:([^\s@]+)/);
+    if (idMatch) return idMatch[1];
+    return hashKey(`${file}::${titlePath.join("::")}`);
+  }
+  mapCypressStatus(state) {
+    switch (state) {
+      case "passed":
+        return "passed";
+      case "failed":
+        return "failed";
+      case "pending":
+      case "skipped":
+        return "skipped";
+      default:
+        return "failed";
+    }
+  }
+  getOutcome(test) {
+    if (test.state === "skipped" || test.state === "pending") return "skipped";
+    if (test.state === "passed") {
+      if (test.attempts.length > 1 && test.attempts.some((a) => a.state === "failed")) {
+        return "flaky";
+      }
+      return "expected";
+    }
+    return "unexpected";
+  }
+  extractErrors(test) {
+    const errors = [];
+    for (const attempt of test.attempts) {
+      if (attempt.error) {
+        errors.push({
+          message: attempt.error.message,
+          stack: attempt.error.stack
+        });
+      }
+    }
+    if (test.displayError) {
+      errors.push({ message: test.displayError });
+    }
+    return errors;
+  }
+  extractTags(title) {
+    const tagRegex = /@([a-zA-Z][a-zA-Z0-9_:-]*)/g;
+    const tags = [];
+    let match;
+    while ((match = tagRegex.exec(title)) !== null) {
+      tags.push(`@${match[1]}`);
+    }
+    return tags;
+  }
+  parseTestMetadata(tags) {
+    const metadata = {
+      isSlow: false,
+      isFlakyTagged: false,
+      customMetadata: {}
+    };
+    for (const tag of tags) {
+      const lower = tag.toLowerCase();
+      if (lower === "@slow") metadata.isSlow = true;
+      if (lower === "@flaky") metadata.isFlakyTagged = true;
+      const ownerMatch = tag.match(/@owner:([^\s@]+)/i);
+      if (ownerMatch) metadata.owner = ownerMatch[1];
+      const priorityMatch = tag.match(/@priority:(critical|high|medium|low)/i);
+      if (priorityMatch) metadata.priority = priorityMatch[1].toLowerCase();
+      const featureMatch = tag.match(/@feature:([^\s@]+)/i);
+      if (featureMatch) metadata.feature = featureMatch[1];
+      const typeMatch = tag.match(/@test_type:(smoke|e2e|regression|integration|unit)/i);
+      if (typeMatch) metadata.testType = typeMatch[1].toLowerCase();
+    }
+    return metadata;
+  }
+  buildAttachmentMeta(test, specResults) {
+    const attachments = [];
+    for (const screenshot of specResults.screenshots) {
+      if (screenshot.path) {
+        attachments.push({
+          name: screenshot.name || "screenshot",
+          filename: path.basename(screenshot.path),
+          contentType: "image/png",
+          sizeBytes: getFileSize(screenshot.path),
+          kind: "screenshot"
+        });
+      }
+    }
+    if (specResults.video) {
+      attachments.push({
+        name: "video",
+        filename: path.basename(specResults.video),
+        contentType: "video/mp4",
+        sizeBytes: getFileSize(specResults.video),
+        kind: "video"
+      });
+    }
+    return attachments;
+  }
+  async uploadAttachments(testId, testResultId, specResults, test) {
+    const attachments = [];
+    for (const screenshot of specResults.screenshots) {
+      if (screenshot.path && fs.existsSync(screenshot.path)) {
+        attachments.push({
+          path: screenshot.path,
+          meta: {
+            name: screenshot.name || "screenshot",
+            filename: path.basename(screenshot.path),
+            contentType: "image/png",
+            sizeBytes: getFileSize(screenshot.path),
+            kind: "screenshot"
+          }
+        });
+      }
+    }
+    if (specResults.video && fs.existsSync(specResults.video)) {
+      attachments.push({
+        path: specResults.video,
+        meta: {
+          name: "video",
+          filename: path.basename(specResults.video),
+          contentType: "video/mp4",
+          sizeBytes: getFileSize(specResults.video),
+          kind: "video"
+        }
+      });
+    }
+    if (attachments.length === 0) return;
+    try {
+      const { uploads } = await this.client.signAttachments(this.runId, {
+        testResultId,
+        attachments: attachments.map((a) => a.meta)
+      });
+      const uploadItems = uploads.map((u, i) => ({
+        signedUrl: u.signedUrl,
+        filePath: attachments[i].path,
+        contentType: attachments[i].meta.contentType
+      }));
+      await this.uploader.uploadBatch(uploadItems, uploads);
+    } catch (error) {
+      this.errorCollector.recordError("ATTACHMENT_SIGN", getErrorMessage(error), { error });
+    }
+  }
+  getEnvironmentInfo() {
+    return {
+      os: {
+        platform: os.platform(),
+        release: os.release(),
+        arch: os.arch()
+      },
+      node: {
+        version: process.version
+      },
+      machine: {
+        cpus: os.cpus().length,
+        memory: os.totalmem(),
+        hostname: os.hostname()
+      },
+      cypress: {
+        version: this.cypressVersion || "unknown"
+      },
+      ci: getCIInfo()
+    };
+  }
+  async getGitInfo() {
+    const ciGitInfo = {
+      branch: process.env.GITHUB_REF_NAME ?? process.env.CI_COMMIT_BRANCH ?? process.env.GIT_BRANCH,
+      commit: process.env.GITHUB_SHA ?? process.env.CI_COMMIT_SHA ?? process.env.GIT_COMMIT,
+      repo: process.env.GITHUB_REPOSITORY ?? process.env.CI_PROJECT_PATH,
+      author: process.env.GITHUB_ACTOR ?? process.env.GITLAB_USER_NAME
+    };
+    if (ciGitInfo.branch || ciGitInfo.commit) {
+      return ciGitInfo;
+    }
+    return await getLocalGitInfo(this.rootDir);
+  }
+};
+function supatestPlugin(on, config, options = {}) {
+  const reporter = new SupatestCypressReporter(options);
+  on("before:run", async (details) => {
+    await reporter.onBeforeRun(details);
+  });
+  on("after:spec", async (spec, results) => {
+    await reporter.onAfterSpec(spec, results);
+  });
+  on("after:run", async (results) => {
+    await reporter.onAfterRun(results);
+  });
+}
+export {
+  ErrorCollector,
+  supatestPlugin as default
+};
+//# sourceMappingURL=index.js.map