@supatest/cypress-reporter 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -916,7 +916,6 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_fs = __toESM(require("fs"), 1);
-var import_node_os = __toESM(require("os"), 1);
 var import_node_path = __toESM(require("path"), 1);
 
 // ../node_modules/.pnpm/simple-git@3.27.0/node_modules/simple-git/dist/esm/index.js
@@ -5471,8 +5470,9 @@ init_git_response_error();
 var simpleGit = gitInstanceFactory;
 
 // ../reporter-core/dist/index.js
-var import_fs = __toESM(require("fs"), 1);
 var import_crypto = require("crypto");
+var import_fs = __toESM(require("fs"), 1);
+var import_os = __toESM(require("os"), 1);
 var import_fs2 = __toESM(require("fs"), 1);
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -5584,12 +5584,16 @@ var SupatestApiClient = class {
         this.options.timeoutMs
       );
       try {
+        const headers = {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.options.apiKey}`
+        };
+        if (this.options.projectId) {
+          headers["X-Project-Id"] = this.options.projectId;
+        }
         const response = await _fetch(url, {
           method,
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.options.apiKey}`
-          },
+          headers,
           body: body ? JSON.stringify(body) : void 0,
           signal: controller.signal
         });
@@ -5613,6 +5617,10 @@ var SupatestApiClient = class {
     console.log(JSON.stringify(data, null, 2));
   }
 };
+var DEFAULT_API_URL = "https://code-api.supatest.ai";
+var DEFAULT_MAX_CONCURRENT_UPLOADS = 5;
+var DEFAULT_RETRY_ATTEMPTS = 3;
+var DEFAULT_TIMEOUT_MS = 3e4;
 var ErrorCollector = class {
   errors = [];
   recordError(category, message, context) {
@@ -5778,105 +5786,37 @@ async function getLocalGitInfo(rootDir) {
     return {};
   }
 }
-var AttachmentUploader = class {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  async upload(signedUrl, filePath, contentType) {
-    if (this.options.dryRun) {
-      try {
-        const stats = import_fs.default.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 import_fs.default.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: 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 () => {
-          var _a2, _b;
-          try {
-            await this.upload(item.signedUrl, item.filePath, item.contentType);
-            return {
-              success: true,
-              attachmentId: (_a2 = signedUploads[index]) == null ? void 0 : _a2.attachmentId
-            };
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-              success: false,
-              attachmentId: (_b = signedUploads[index]) == null ? void 0 : _b.attachmentId,
-              error: `${item.filePath}: ${message}`
-            };
-          }
-        })
-      )
-    );
-    return results.map((result, index) => {
-      var _a2;
-      if (result.status === "fulfilled") {
-        return result.value;
-      }
-      const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
-      return {
-        success: false,
-        attachmentId: (_a2 = signedUploads[index]) == null ? void 0 : _a2.attachmentId,
-        error: message
-      };
-    });
+async function getGitInfoWithCI(rootDir) {
+  const ciGitInfo = {
+    branch: process.env.GITHUB_REF_NAME ?? process.env.GITHUB_HEAD_REF ?? process.env.CI_COMMIT_BRANCH ?? process.env.GITLAB_CI_COMMIT_BRANCH ?? process.env.GIT_BRANCH,
+    commit: process.env.GITHUB_SHA ?? process.env.CI_COMMIT_SHA ?? process.env.GITLAB_CI_COMMIT_SHA ?? process.env.GIT_COMMIT,
+    commitMessage: process.env.CI_COMMIT_MESSAGE ?? process.env.GITLAB_CI_COMMIT_MESSAGE,
+    repo: process.env.GITHUB_REPOSITORY ?? process.env.CI_PROJECT_PATH ?? process.env.GITLAB_CI_PROJECT_PATH ?? process.env.GIT_REPO,
+    author: process.env.GITHUB_ACTOR ?? process.env.GITLAB_USER_NAME,
+    authorEmail: process.env.GITLAB_USER_EMAIL,
+    tag: process.env.GITHUB_REF_TYPE === "tag" ? process.env.GITHUB_REF_NAME : void 0
+  };
+  if (ciGitInfo.branch || ciGitInfo.commit) {
+    return ciGitInfo;
   }
-};
+  const localGitInfo = await getLocalGitInfo(rootDir);
+  return {
+    branch: ciGitInfo.branch ?? localGitInfo.branch,
+    commit: ciGitInfo.commit ?? localGitInfo.commit,
+    commitMessage: ciGitInfo.commitMessage ?? localGitInfo.commitMessage,
+    repo: ciGitInfo.repo ?? localGitInfo.repo,
+    author: ciGitInfo.author ?? localGitInfo.author,
+    authorEmail: ciGitInfo.authorEmail ?? localGitInfo.authorEmail,
+    tag: ciGitInfo.tag ?? localGitInfo.tag,
+    dirty: localGitInfo.dirty
+  };
+}
 function hashKey(value) {
   return (0, import_crypto.createHash)("sha256").update(value).digest("hex").slice(0, 12);
 }
 function getFileSize(filePath) {
   try {
-    return import_fs2.default.statSync(filePath).size;
+    return import_fs.default.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -5979,9 +5919,197 @@ function getCIInfo() {
   }
   return void 0;
 }
+function getBaseEnvironmentInfo() {
+  return {
+    os: {
+      platform: import_os.default.platform(),
+      release: import_os.default.release(),
+      arch: import_os.default.arch()
+    },
+    node: {
+      version: process.version
+    },
+    machine: {
+      cpus: import_os.default.cpus().length,
+      memory: import_os.default.totalmem(),
+      hostname: import_os.default.hostname()
+    },
+    ci: getCIInfo()
+  };
+}
+function registerInterruptHandler(client, getRunId) {
+  let completed = false;
+  const handler = async (signal) => {
+    if (completed) {
+      return;
+    }
+    completed = true;
+    const runId = getRunId();
+    if (runId) {
+      logWarn(`Received ${signal}, marking run ${runId} as interrupted`);
+      try {
+        await client.completeRun(runId, {
+          status: "interrupted",
+          endedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    process.removeListener(signal, sigintHandler);
+    process.removeListener(signal, sigtermHandler);
+    process.kill(process.pid, signal);
+  };
+  const sigintHandler = () => handler("SIGINT");
+  const sigtermHandler = () => handler("SIGTERM");
+  process.once("SIGINT", sigintHandler);
+  process.once("SIGTERM", sigtermHandler);
+  return () => {
+    completed = true;
+    process.removeListener("SIGINT", sigintHandler);
+    process.removeListener("SIGTERM", sigtermHandler);
+  };
+}
+var TAG_PATTERNS = {
+  owner: /@owner:([^\s@]+)/,
+  priority: /@priority:(critical|high|medium|low)/i,
+  feature: /@feature:([^\s@]+)/,
+  ticketId: /@ticket:([^\s@]+)/,
+  testType: /@test_type:(smoke|e2e|regression|integration|unit)/i
+};
+var KNOWN_KEYS = ["owner", "priority", "feature", "ticket", "test_type", "id", "slow", "flaky"];
+function parseTestMetadata(tags) {
+  const metadata = {
+    isSlow: false,
+    isFlakyTagged: false,
+    customMetadata: {}
+  };
+  for (const tag of tags) {
+    const lowerTag = tag.toLowerCase();
+    if (lowerTag === "@slow") {
+      metadata.isSlow = true;
+    } else if (lowerTag === "@flaky") {
+      metadata.isFlakyTagged = true;
+    }
+  }
+  for (const tag of tags) {
+    for (const [key, pattern] of Object.entries(TAG_PATTERNS)) {
+      const match = tag.match(pattern);
+      if (match) {
+        const value = match[1];
+        if (key === "priority") {
+          metadata.priority = value.toLowerCase();
+        } else if (key === "testType") {
+          metadata.testType = value.toLowerCase();
+        } else {
+          metadata[key] = value;
+        }
+      }
+    }
+    const customMatch = tag.match(/@([a-zA-Z][a-zA-Z0-9_-]*):([^\s@]+)/);
+    if (customMatch) {
+      const [, key, value] = customMatch;
+      if (!KNOWN_KEYS.includes(key.toLowerCase())) {
+        metadata.customMetadata[key] = value;
+      }
+    }
+  }
+  return metadata;
+}
+var AttachmentUploader = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async upload(signedUrl, filePath, contentType) {
+    if (this.options.dryRun) {
+      try {
+        const stats = import_fs2.default.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 import_fs2.default.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: 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 () => {
+          var _a2, _b;
+          try {
+            await this.upload(item.signedUrl, item.filePath, item.contentType);
+            return {
+              success: true,
+              attachmentId: (_a2 = signedUploads[index]) == null ? void 0 : _a2.attachmentId
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              success: false,
+              attachmentId: (_b = signedUploads[index]) == null ? void 0 : _b.attachmentId,
+              error: `${item.filePath}: ${message}`
+            };
+          }
+        })
+      )
+    );
+    return results.map((result, index) => {
+      var _a2;
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      return {
+        success: false,
+        attachmentId: (_a2 = signedUploads[index]) == null ? void 0 : _a2.attachmentId,
+        error: message
+      };
+    });
+  }
+};
 
 // src/index.ts
-var DEFAULT_API_URL = "https://code-api.supatest.ai";
 var SupatestCypressReporter = class {
   options;
   client;
@@ -5999,15 +6127,16 @@ var SupatestCypressReporter = class {
   cypressVersion;
   browserName;
   browserVersion;
+  unregisterInterruptHandler;
   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,
+      maxConcurrentUploads: options.maxConcurrentUploads ?? DEFAULT_MAX_CONCURRENT_UPLOADS,
+      retryAttempts: options.retryAttempts ?? DEFAULT_RETRY_ATTEMPTS,
+      timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       dryRun: options.dryRun ?? process.env.SUPATEST_DRY_RUN === "true"
     };
   }
@@ -6026,6 +6155,7 @@ var SupatestCypressReporter = class {
     this.client = new SupatestApiClient({
       apiKey: this.options.apiKey,
       apiUrl: this.options.apiUrl,
+      projectId: this.options.projectId,
       timeoutMs: this.options.timeoutMs,
       retryAttempts: this.options.retryAttempts,
       dryRun: this.options.dryRun
@@ -6060,6 +6190,10 @@ var SupatestCypressReporter = class {
       };
       const response = await this.client.createRun(runRequest);
       this.runId = response.runId;
+      this.unregisterInterruptHandler = registerInterruptHandler(
+        this.client,
+        () => this.runId
+      );
       logInfo(`Run ${this.runId} started (${details.specs.length} spec files)`);
     } catch (error) {
       this.errorCollector.recordError("RUN_CREATE", getErrorMessage2(error), { error });
@@ -6068,11 +6202,16 @@ var SupatestCypressReporter = class {
   }
   async onAfterSpec(spec, results) {
     if (this.disabled || !this.runId) return;
+    if (!(results == null ? void 0 : results.tests)) {
+      logInfo(`Spec ${spec.relative} had no test results (browser may have crashed), skipping`);
+      return;
+    }
     for (const test of results.tests) {
       await this.processTestResult(spec, test, results);
     }
   }
   async onAfterRun(results) {
+    var _a2;
     if (this.disabled || !this.runId) {
       if (this.errorCollector.hasErrors()) {
         console.log(this.errorCollector.formatSummary());
@@ -6081,22 +6220,23 @@ var SupatestCypressReporter = class {
     }
     await Promise.allSettled(this.uploadQueue);
     const summary = {
-      total: results.totalTests,
-      passed: results.totalPassed,
-      failed: results.totalFailed,
+      total: (results == null ? void 0 : results.totalTests) ?? 0,
+      passed: (results == null ? void 0 : results.totalPassed) ?? 0,
+      failed: (results == null ? void 0 : results.totalFailed) ?? 0,
       flaky: 0,
-      skipped: results.totalSkipped + results.totalPending,
+      skipped: ((results == null ? void 0 : results.totalSkipped) ?? 0) + ((results == null ? void 0 : results.totalPending) ?? 0),
       timedOut: 0,
       interrupted: 0,
-      durationMs: results.totalDuration
+      durationMs: (results == null ? void 0 : results.totalDuration) ?? 0
     };
+    (_a2 = this.unregisterInterruptHandler) == null ? void 0 : _a2.call(this);
     try {
       await this.client.completeRun(this.runId, {
-        status: results.status === "finished" ? "complete" : "errored",
-        endedAt: results.endedTestsAt,
+        status: (results == null ? void 0 : results.status) === "finished" ? "complete" : "errored",
+        endedAt: (results == null ? void 0 : results.endedTestsAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
         summary,
         timing: {
-          totalDurationMs: results.totalDuration,
+          totalDurationMs: (results == null ? void 0 : results.totalDuration) ?? 0,
           timeToFirstTest: this.firstTestStartTime ? this.firstTestStartTime - new Date(this.startedAt).getTime() : void 0,
           timeToFirstFailure: this.firstFailureTime ? this.firstFailureTime - new Date(this.startedAt).getTime() : void 0
         }
@@ -6112,16 +6252,17 @@ var SupatestCypressReporter = class {
   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();
+    const attempts = test.attempts ?? [];
+    if (!this.firstTestStartTime && attempts[0]) {
+      this.firstTestStartTime = new Date(attempts[0].wallClockStartedAt).getTime();
     }
     if (!this.firstFailureTime && status === "failed") {
       this.firstFailureTime = Date.now();
     }
-    const lastAttempt = test.attempts[test.attempts.length - 1];
+    const lastAttempt = attempts[attempts.length - 1];
     const resultEntry = {
-      resultId: hashKey(`${testId}:${test.attempts.length - 1}`),
-      retry: test.attempts.length - 1,
+      resultId: hashKey(`${testId}:${attempts.length - 1}`),
+      retry: attempts.length - 1,
       status,
       startTime: (lastAttempt == null ? void 0 : lastAttempt.wallClockStartedAt) ?? void 0,
       durationMs: (lastAttempt == null ? void 0 : lastAttempt.wallClockDuration) || 0,
@@ -6146,8 +6287,8 @@ var SupatestCypressReporter = class {
       timeout: 0,
       retries: test.attempts.length - 1,
       status,
-      durationMs: test.attempts.reduce((sum, a) => sum + (a.wallClockDuration || 0), 0),
-      retryCount: test.attempts.length - 1,
+      durationMs: attempts.reduce((sum, a) => sum + (a.wallClockDuration || 0), 0),
+      retryCount: attempts.length - 1,
       results: [resultEntry],
       projectName: this.browserName || "electron",
       metadata
@@ -6185,9 +6326,10 @@ var SupatestCypressReporter = class {
     }
   }
   getOutcome(test) {
+    var _a2, _b;
     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")) {
+      if ((((_a2 = test.attempts) == null ? void 0 : _a2.length) ?? 0) > 1 && ((_b = test.attempts) == null ? void 0 : _b.some((a) => a.state === "failed"))) {
         return "flaky";
       }
       return "expected";
@@ -6196,7 +6338,7 @@ var SupatestCypressReporter = class {
   }
   extractErrors(test) {
     const errors = [];
-    for (const attempt of test.attempts) {
+    for (const attempt of test.attempts ?? []) {
       if (attempt.error) {
         errors.push({
           message: attempt.error.message,
@@ -6219,29 +6361,11 @@ var SupatestCypressReporter = class {
     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;
+    return parseTestMetadata(tags);
   }
   buildAttachmentMeta(test, specResults) {
     const attachments = [];
-    for (const screenshot of specResults.screenshots) {
+    for (const screenshot of specResults.screenshots ?? []) {
       if (screenshot.path) {
         attachments.push({
           name: screenshot.name || "screenshot",
@@ -6265,7 +6389,7 @@ var SupatestCypressReporter = class {
   }
   async uploadAttachments(testId, testResultId, specResults, test) {
     const attachments = [];
-    for (const screenshot of specResults.screenshots) {
+    for (const screenshot of specResults.screenshots ?? []) {
       if (screenshot.path && import_node_fs.default.existsSync(screenshot.path)) {
         attachments.push({
           path: screenshot.path,
@@ -6302,55 +6426,65 @@ var SupatestCypressReporter = class {
         filePath: attachments[i].path,
         contentType: attachments[i].meta.contentType
       }));
-      await this.uploader.uploadBatch(uploadItems, uploads);
+      const results = await this.uploader.uploadBatch(uploadItems, uploads);
+      const failures = results.filter((r) => !r.success);
+      if (failures.length > 0) {
+        failures.forEach((failure) => {
+          const attachment = attachments.find(
+            (_, i) => {
+              var _a2;
+              return ((_a2 = uploads[i]) == null ? void 0 : _a2.attachmentId) === failure.attachmentId;
+            }
+          );
+          this.errorCollector.recordError(
+            "ATTACHMENT_UPLOAD",
+            failure.error || "Upload failed",
+            {
+              attachmentName: attachment == null ? void 0 : attachment.meta.name,
+              filePath: attachment == null ? void 0 : attachment.path,
+              error: failure.error
+            }
+          );
+        });
+      }
     } catch (error) {
       this.errorCollector.recordError("ATTACHMENT_SIGN", getErrorMessage2(error), { error });
     }
   }
   getEnvironmentInfo() {
     return {
-      os: {
-        platform: import_node_os.default.platform(),
-        release: import_node_os.default.release(),
-        arch: import_node_os.default.arch()
-      },
-      node: {
-        version: process.version
-      },
-      machine: {
-        cpus: import_node_os.default.cpus().length,
-        memory: import_node_os.default.totalmem(),
-        hostname: import_node_os.default.hostname()
-      },
+      ...getBaseEnvironmentInfo(),
       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);
+    return getGitInfoWithCI(this.rootDir);
   }
 };
 function supatestPlugin(on, config, options = {}) {
   const reporter = new SupatestCypressReporter(options);
   on("before:run", async (details) => {
-    await reporter.onBeforeRun(details);
+    try {
+      await reporter.onBeforeRun(details);
+    } catch (error) {
+      logWarn(`Supatest reporter error in before:run: ${getErrorMessage2(error)}`);
+    }
   });
   on("after:spec", async (spec, results) => {
-    await reporter.onAfterSpec(spec, results);
+    try {
+      await reporter.onAfterSpec(spec, results);
+    } catch (error) {
+      logWarn(`Supatest reporter error in after:spec: ${getErrorMessage2(error)}`);
+    }
   });
   on("after:run", async (results) => {
-    await reporter.onAfterRun(results);
+    try {
+      await reporter.onAfterRun(results);
+    } catch (error) {
+      logWarn(`Supatest reporter error in after:run: ${getErrorMessage2(error)}`);
+    }
   });
 }
 // Annotate the CommonJS export names for ESM import in node: