@supatest/playwright-reporter 0.0.1

package/dist/index.js

@@ -0,0 +1,869 @@
+// src/index.ts
+import { createHash } from "crypto";
+import fs2 from "fs";
+import os from "os";
+import path from "path";
+
+// src/retry.ts
+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;
+}
+
+// src/api-client.ts
+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));
+  }
+};
+
+// src/git-utils.ts
+import { simpleGit } from "simple-git";
+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 {};
+  }
+}
+
+// src/uploader.ts
+import fs from "fs";
+var AttachmentUploader = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async upload(signedUrl, filePath, contentType) {
+    if (this.options.dryRun) {
+      const stats = fs.statSync(filePath);
+      console.log(
+        `[supatest][dry-run] Would upload ${filePath} (${stats.size} bytes) to S3`
+      );
+      return;
+    }
+    const fileBuffer = await fs.promises.readFile(filePath);
+    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 () => {
+          await this.upload(item.signedUrl, item.filePath, item.contentType);
+          return {
+            success: true,
+            attachmentId: signedUploads[index]?.attachmentId
+          };
+        })
+      )
+    );
+    return results.map((result, index) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      return {
+        success: false,
+        attachmentId: signedUploads[index]?.attachmentId,
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+      };
+    });
+  }
+};
+
+// src/index.ts
+var DEFAULT_API_URL = "https://api.supatest.dev";
+var DEFAULT_MAX_CONCURRENT_UPLOADS = 5;
+var DEFAULT_RETRY_ATTEMPTS = 3;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_STDOUT_LINES = 100;
+var MAX_STDERR_LINES = 100;
+var SupatestPlaywrightReporter = class {
+  options;
+  client;
+  uploader;
+  runId;
+  uploadQueue = [];
+  uploadLimit;
+  startedAt;
+  firstTestStartTime;
+  firstFailureTime;
+  testsProcessed = /* @__PURE__ */ new Map();
+  disabled = false;
+  config;
+  rootDir;
+  stepIdCounter = 0;
+  constructor(options = {}) {
+    this.options = {
+      apiUrl: DEFAULT_API_URL,
+      uploadAssets: true,
+      maxConcurrentUploads: DEFAULT_MAX_CONCURRENT_UPLOADS,
+      retryAttempts: DEFAULT_RETRY_ATTEMPTS,
+      timeoutMs: DEFAULT_TIMEOUT_MS,
+      dryRun: false,
+      ...options
+    };
+  }
+  async onBegin(config, suite) {
+    this.config = config;
+    this.rootDir = config.rootDir;
+    if (!this.options.projectId) {
+      this.options.projectId = process.env.SUPATEST_PROJECT_ID ?? "";
+    }
+    if (!this.options.apiKey) {
+      this.options.apiKey = process.env.SUPATEST_API_KEY ?? "";
+    }
+    if (process.env.SUPATEST_DRY_RUN === "true") {
+      this.options.dryRun = true;
+    }
+    if (!this.options.projectId || !this.options.apiKey) {
+      if (!this.options.dryRun) {
+        this.logWarn(
+          "Missing projectId or apiKey. Set SUPATEST_PROJECT_ID and SUPATEST_API_KEY env vars, or pass them as options."
+        );
+        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
+    });
+    const pLimit = (await import("p-limit")).default;
+    this.uploadLimit = pLimit(this.options.maxConcurrentUploads);
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const allTests = suite.allTests();
+    const projects = this.buildProjectConfigs(config);
+    const testFiles = new Set(allTests.map((t) => t.location.file));
+    try {
+      const runRequest = {
+        projectId: this.options.projectId,
+        startedAt: this.startedAt,
+        playwright: {
+          version: config.version,
+          workers: config.workers,
+          retries: config.projects?.[0]?.retries ?? 0,
+          fullyParallel: config.fullyParallel,
+          forbidOnly: config.forbidOnly,
+          globalTimeout: config.globalTimeout,
+          reportSlowTests: config.reportSlowTests ? {
+            max: config.reportSlowTests.max,
+            threshold: config.reportSlowTests.threshold
+          } : void 0
+        },
+        projects,
+        testStats: {
+          totalFiles: testFiles.size,
+          totalTests: allTests.length,
+          totalProjects: config.projects?.length ?? 0
+        },
+        shard: config.shard ? {
+          current: config.shard.current,
+          total: config.shard.total
+        } : void 0,
+        environment: this.getEnvironmentInfo(config),
+        git: await this.getGitInfo(),
+        configPath: config.configFile,
+        rootDir: config.rootDir,
+        testDir: config.projects?.[0]?.testDir,
+        outputDir: config.projects?.[0]?.outputDir
+      };
+      const response = await this.client.createRun(runRequest);
+      this.runId = response.runId;
+      this.logInfo(
+        `Run ${this.runId} started (${allTests.length} tests across ${testFiles.size} files, ${projects.length} projects)`
+      );
+    } catch (error) {
+      this.logWarn(`Failed to create run: ${this.getErrorMessage(error)}`);
+      this.disabled = true;
+    }
+  }
+  onTestEnd(test, result) {
+    if (this.disabled || !this.runId) return;
+    if (!this.firstTestStartTime && result.startTime) {
+      this.firstTestStartTime = result.startTime.getTime();
+    }
+    if (!this.firstFailureTime && (result.status === "failed" || result.status === "timedOut")) {
+      this.firstFailureTime = Date.now();
+    }
+    const promise = this.uploadLimit(
+      () => this.processTestResult(test, result)
+    );
+    this.uploadQueue.push(promise);
+  }
+  async onEnd(result) {
+    if (this.disabled || !this.runId) {
+      this.logInfo("Reporter disabled, skipping onEnd");
+      return;
+    }
+    this.logInfo(`Waiting for ${this.uploadQueue.length} pending uploads...`);
+    const results = await Promise.allSettled(this.uploadQueue);
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      this.logWarn(`${failures.length} uploads failed`);
+    }
+    const summary = this.computeSummary(result);
+    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = this.startedAt ? new Date(this.startedAt).getTime() : 0;
+    try {
+      await this.client.completeRun(this.runId, {
+        status: this.mapRunStatus(result.status),
+        endedAt,
+        summary,
+        timing: {
+          totalDurationMs: Math.round(result.duration),
+          timeToFirstTest: this.firstTestStartTime ? Math.round(this.firstTestStartTime - startTime) : void 0,
+          timeToFirstFailure: this.firstFailureTime ? Math.round(this.firstFailureTime - startTime) : void 0
+        }
+      });
+      this.logInfo(`Run ${this.runId} completed: ${result.status}`);
+    } catch (error) {
+      this.logWarn(`Failed to complete run: ${this.getErrorMessage(error)}`);
+    }
+  }
+  async processTestResult(test, result) {
+    const testId = this.getTestId(test);
+    const resultId = this.getResultId(testId, result.retry);
+    try {
+      const payload = this.buildTestPayload(test, result);
+      await this.client.submitTest(this.runId, payload);
+      if (this.options.uploadAssets) {
+        await this.uploadAttachments(result, resultId);
+      }
+      const outcome = this.getTestOutcome(test, result);
+      const existing = this.testsProcessed.get(testId);
+      this.testsProcessed.set(testId, {
+        status: result.status,
+        outcome,
+        retries: (existing?.retries ?? 0) + (result.retry > 0 ? 1 : 0)
+      });
+    } catch (error) {
+      this.logWarn(
+        `Failed to submit test ${test.title}: ${this.getErrorMessage(error)}`
+      );
+      throw error;
+    }
+  }
+  buildTestPayload(test, result) {
+    const testId = this.getTestId(test);
+    const tags = test.tags ?? [];
+    const annotations = this.serializeAnnotations(test.annotations ?? []);
+    const resultEntry = {
+      resultId: this.getResultId(testId, result.retry),
+      retry: result.retry,
+      status: result.status,
+      startTime: result.startTime?.toISOString?.() ?? void 0,
+      durationMs: result.duration,
+      workerIndex: result.workerIndex,
+      parallelIndex: result.parallelIndex,
+      errors: this.serializeErrors(result.errors ?? []),
+      steps: this.serializeSteps(result.steps ?? []),
+      annotations: this.serializeAnnotations(result.annotations ?? []),
+      attachments: this.serializeAttachmentMeta(result.attachments ?? []),
+      stdout: this.serializeOutput(result.stdout ?? [], MAX_STDOUT_LINES),
+      stderr: this.serializeOutput(result.stderr ?? [], MAX_STDERR_LINES)
+    };
+    const projectName = test.parent?.project()?.name ?? "unknown";
+    return {
+      testId,
+      playwrightId: test.id,
+      file: this.relativePath(test.location.file),
+      location: {
+        file: this.relativePath(test.location.file),
+        line: test.location.line,
+        column: test.location.column
+      },
+      title: test.title,
+      titlePath: test.titlePath(),
+      tags,
+      annotations,
+      expectedStatus: test.expectedStatus,
+      outcome: this.getTestOutcome(test, result),
+      timeout: test.timeout,
+      retries: test.retries,
+      repeatEachIndex: test.repeatEachIndex > 0 ? test.repeatEachIndex : void 0,
+      status: result.status,
+      durationMs: result.duration,
+      retryCount: result.retry,
+      results: [resultEntry],
+      projectName
+    };
+  }
+  serializeSteps(steps) {
+    return steps.map((step) => this.serializeStep(step));
+  }
+  serializeStep(step) {
+    const stepId = `step_${++this.stepIdCounter}`;
+    return {
+      stepId,
+      title: step.title,
+      category: step.category,
+      startTime: step.startTime?.toISOString?.() ?? void 0,
+      durationMs: step.duration,
+      location: step.location ? {
+        file: this.relativePath(step.location.file),
+        line: step.location.line,
+        column: step.location.column
+      } : void 0,
+      error: step.error ? this.serializeError(step.error) : void 0,
+      // Recursively serialize nested steps
+      steps: step.steps && step.steps.length > 0 ? this.serializeSteps(step.steps) : void 0,
+      // Step attachments (from step.attachments if available)
+      attachments: void 0
+      // Playwright doesn't expose step.attachments directly
+    };
+  }
+  serializeErrors(errors) {
+    return errors.map((e) => this.serializeError(e));
+  }
+  serializeError(error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      value: error.value !== void 0 ? String(error.value) : void 0,
+      location: error.location ? {
+        file: this.relativePath(error.location.file),
+        line: error.location.line,
+        column: error.location.column
+      } : void 0,
+      // Could extract code snippet from file here if needed
+      snippet: void 0
+    };
+  }
+  serializeAnnotations(annotations) {
+    return annotations.map((a) => ({
+      type: a.type,
+      description: a.description
+    }));
+  }
+  serializeAttachmentMeta(attachments) {
+    return attachments.filter((a) => a.path || a.body).map((a) => ({
+      name: a.name,
+      filename: a.path ? path.basename(a.path) : a.name,
+      contentType: a.contentType,
+      sizeBytes: this.getAttachmentSize(a),
+      kind: this.getAttachmentKind(a.name, a.contentType)
+    }));
+  }
+  serializeOutput(output, maxLines) {
+    const lines = [];
+    for (const chunk of output) {
+      const str = chunk.toString();
+      lines.push(...str.split("\n"));
+      if (lines.length >= maxLines) break;
+    }
+    return lines.slice(0, maxLines);
+  }
+  getTestOutcome(test, result) {
+    if (typeof test.outcome === "function") {
+      return test.outcome();
+    }
+    if (result.status === "skipped") return "skipped";
+    if (result.status === test.expectedStatus) return "expected";
+    if (result.status === "passed" && result.retry > 0) return "flaky";
+    return "unexpected";
+  }
+  async uploadAttachments(result, testResultId) {
+    const attachments = (result.attachments ?? []).filter((a) => a.path);
+    if (attachments.length === 0) return;
+    const meta = attachments.map((a) => ({
+      name: a.name,
+      filename: path.basename(a.path),
+      contentType: a.contentType,
+      sizeBytes: this.getFileSize(a.path),
+      kind: this.getAttachmentKind(a.name, a.contentType)
+    }));
+    try {
+      const { uploads } = await this.client.signAttachments(this.runId, {
+        testResultId,
+        attachments: meta
+      });
+      const uploadItems = uploads.map((u, i) => ({
+        signedUrl: u.signedUrl,
+        filePath: attachments[i].path,
+        contentType: attachments[i].contentType
+      }));
+      const results = await this.uploader.uploadBatch(uploadItems, uploads);
+      const failedCount = results.filter((r) => !r.success).length;
+      if (failedCount > 0) {
+        this.logWarn(`${failedCount} attachment uploads failed`);
+      }
+    } catch (error) {
+      this.logWarn(
+        `Failed to upload attachments: ${this.getErrorMessage(error)}`
+      );
+    }
+  }
+  buildProjectConfigs(config) {
+    return (config.projects ?? []).map((project) => {
+      const use = project.use ?? {};
+      return {
+        name: project.name,
+        browserName: use.browserName,
+        channel: use.channel,
+        deviceName: use.deviceName,
+        viewport: use.viewport ? { width: use.viewport.width, height: use.viewport.height } : void 0,
+        locale: use.locale,
+        timezone: use.timezoneId,
+        colorScheme: use.colorScheme,
+        isMobile: use.isMobile,
+        hasTouch: use.hasTouch,
+        testDir: project.testDir,
+        timeout: project.timeout
+      };
+    });
+  }
+  getEnvironmentInfo(config) {
+    const ciInfo = this.getCIInfo();
+    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()
+      },
+      playwright: {
+        version: config.version
+      },
+      ci: ciInfo
+    };
+  }
+  computeSummary(result) {
+    let passed = 0;
+    let failed = 0;
+    let flaky = 0;
+    let skipped = 0;
+    let timedOut = 0;
+    let interrupted = 0;
+    let expected = 0;
+    let unexpected = 0;
+    for (const [, testInfo] of this.testsProcessed) {
+      switch (testInfo.status) {
+        case "passed":
+          passed += 1;
+          if (testInfo.retries > 0) flaky += 1;
+          break;
+        case "failed":
+          failed += 1;
+          break;
+        case "skipped":
+          skipped += 1;
+          break;
+        case "timedOut":
+          timedOut += 1;
+          break;
+        case "interrupted":
+          interrupted += 1;
+          break;
+      }
+      if (testInfo.outcome === "expected") expected += 1;
+      else if (testInfo.outcome === "unexpected") unexpected += 1;
+    }
+    return {
+      total: this.testsProcessed.size,
+      passed,
+      failed,
+      flaky,
+      skipped,
+      timedOut,
+      interrupted,
+      durationMs: Math.round(result.duration),
+      expected,
+      unexpected
+    };
+  }
+  mapRunStatus(status) {
+    switch (status) {
+      case "passed":
+        return "complete";
+      case "failed":
+      case "timedout":
+        return "errored";
+      case "interrupted":
+        return "interrupted";
+      default:
+        return "complete";
+    }
+  }
+  getTestId(test) {
+    const key = `${test.location.file}:${test.location.line}:${test.title}`;
+    return this.hashKey(key);
+  }
+  getResultId(testId, retry) {
+    return this.hashKey(`${testId}:${retry}`);
+  }
+  hashKey(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+  }
+  relativePath(filePath) {
+    if (this.rootDir && filePath.startsWith(this.rootDir)) {
+      return filePath.slice(this.rootDir.length + 1);
+    }
+    return filePath;
+  }
+  getFileSize(filePath) {
+    try {
+      return fs2.statSync(filePath).size;
+    } catch {
+      return 0;
+    }
+  }
+  getAttachmentSize(attachment) {
+    if (attachment.path) {
+      return this.getFileSize(attachment.path);
+    }
+    if (attachment.body) {
+      return attachment.body.length;
+    }
+    return 0;
+  }
+  getAttachmentKind(name, contentType) {
+    if (name === "video" || contentType.startsWith("video/")) return "video";
+    if (name === "trace" || name.endsWith(".zip")) return "trace";
+    if (name.includes("screenshot") || contentType === "image/png")
+      return "screenshot";
+    if (name === "stdout") return "stdout";
+    if (name === "stderr") return "stderr";
+    return "other";
+  }
+  async getGitInfo() {
+    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(this.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
+    };
+  }
+  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;
+  }
+  getErrorMessage(error) {
+    if (error instanceof Error) return error.message;
+    return String(error);
+  }
+  logInfo(message) {
+    console.log(`[supatest] ${message}`);
+  }
+  logWarn(message) {
+    console.warn(`[supatest] ${message}`);
+  }
+};
+export {
+  SupatestPlaywrightReporter as default
+};
+//# sourceMappingURL=index.js.map