kagami-playwright-reporter 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { Reporter, FullConfig, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
+
+interface PwInsightsOptions {
+    /** Base URL of the Insights API, e.g. https://kagami.shyim.de */
+    apiUrl: string;
+    /** OIDC audience configured on the server (must match OIDC_AUDIENCE). */
+    audience: string;
+    /** Optional: silence the reporter entirely. */
+    enabled?: boolean;
+}
+declare class PwInsightsReporter implements Reporter {
+    private readonly options;
+    private readonly specs;
+    private readonly uploads;
+    private clientIdSeq;
+    private active;
+    constructor(options: PwInsightsOptions);
+    onBegin(_config: FullConfig): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onEnd(result: FullResult): Promise<void>;
+}
+
+export { type PwInsightsOptions, PwInsightsReporter as default };

package/dist/index.js

@@ -0,0 +1,199 @@
+// src/index.ts
+import { readFile } from "fs/promises";
+
+// src/oidc.ts
+async function requestOidcToken(audience) {
+  const reqUrl = process.env.ACTIONS_ID_TOKEN_REQUEST_URL;
+  const reqToken = process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+  if (!reqUrl || !reqToken) return null;
+  const url = new URL(reqUrl);
+  url.searchParams.set("audience", audience);
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${reqToken}` }
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to fetch OIDC token: ${res.status} ${await res.text()}`
+    );
+  }
+  const json = await res.json();
+  return json.value ?? null;
+}
+
+// src/index.ts
+var PwInsightsReporter = class {
+  options;
+  specs = /* @__PURE__ */ new Map();
+  uploads = [];
+  clientIdSeq = 0;
+  active = false;
+  constructor(options) {
+    this.options = options;
+  }
+  onBegin(_config) {
+    this.active = this.options.enabled !== false && !!process.env.ACTIONS_ID_TOKEN_REQUEST_URL;
+    if (!this.active) {
+      console.log(
+        "[pw-insights] not in GitHub Actions with id-token permission; reporter is a no-op."
+      );
+    }
+  }
+  onTestEnd(test, result) {
+    if (!this.active) return;
+    const project = test.parent.project()?.name || void 0;
+    const file = test.location.file;
+    const key = `${file}::${project ?? ""}`;
+    let spec = this.specs.get(key);
+    if (!spec) {
+      spec = { file, project, tests: [] };
+      this.specs.set(key, spec);
+    }
+    let wireTest = spec.tests.find((t) => t.testId === test.id);
+    if (!wireTest) {
+      wireTest = {
+        testId: test.id,
+        title: test.titlePath().slice(3).join(" \u203A ") || test.title,
+        location: `${test.location.file}:${test.location.line}:${test.location.column}`,
+        tags: test.tags?.length ? test.tags : void 0,
+        expectedStatus: test.expectedStatus,
+        finalStatus: mapStatus(result.status),
+        attempts: []
+      };
+      spec.tests.push(wireTest);
+    }
+    wireTest.finalStatus = mapStatus(result.status);
+    const attachments = [];
+    for (const a of result.attachments) {
+      if (!a.path) continue;
+      const kind = classifyAttachment(a.name, a.contentType);
+      const clientId = `u${this.clientIdSeq++}`;
+      attachments.push({
+        clientId,
+        kind,
+        name: a.name,
+        contentType: a.contentType
+      });
+      this.uploads.push({ clientId, path: a.path, contentType: a.contentType });
+    }
+    wireTest.attempts.push({
+      attemptIndex: result.retry,
+      status: mapStatus(result.status),
+      durationMs: result.duration,
+      startedAt: Math.floor(result.startTime.getTime() / 1e3),
+      errorMessage: result.error?.message,
+      errorStack: result.error?.stack,
+      stdout: joinChunks(result.stdout),
+      stderr: joinChunks(result.stderr),
+      steps: flattenSteps(result.steps),
+      attachments
+    });
+  }
+  async onEnd(result) {
+    if (!this.active) return;
+    try {
+      const token = await requestOidcToken(this.options.audience);
+      if (!token) {
+        console.warn("[pw-insights] no OIDC token; skipping upload.");
+        return;
+      }
+      const base = this.options.apiUrl.replace(/\/$/, "");
+      const auth = { Authorization: `Bearer ${token}` };
+      const open = await postJson(`${base}/v1/runs`, auth, {});
+      console.log(
+        `[pw-insights] run ${open.runId} (${open.repo} @ ${open.branch})`
+      );
+      const payload = {
+        pwVersion: process.env.PLAYWRIGHT_VERSION,
+        specs: [...this.specs.values()]
+      };
+      const submit = await postJson(
+        `${base}/v1/runs/${open.runId}/specs`,
+        auth,
+        payload
+      );
+      const urlByClient = new Map(submit.uploads.map((u) => [u.clientId, u.url]));
+      let uploaded = 0;
+      for (const up of this.uploads) {
+        const url = urlByClient.get(up.clientId);
+        if (!url) continue;
+        try {
+          const body = await readFile(up.path);
+          const put = await fetch(url, {
+            method: "PUT",
+            headers: up.contentType ? { "Content-Type": up.contentType } : void 0,
+            body
+          });
+          if (put.ok) uploaded++;
+          else
+            console.warn(
+              `[pw-insights] upload failed (${put.status}) for ${up.path}`
+            );
+        } catch (err) {
+          console.warn(`[pw-insights] could not read ${up.path}: ${err}`);
+        }
+      }
+      await postJson(`${base}/v1/runs/${open.runId}/complete`, auth, {
+        status: result.status === "passed" ? "passed" : "failed"
+      });
+      console.log(
+        `[pw-insights] uploaded ${uploaded}/${this.uploads.length} artifacts; run finalized.`
+      );
+    } catch (err) {
+      console.error(`[pw-insights] upload error: ${err.message}`);
+    }
+  }
+};
+function mapStatus(s) {
+  switch (s) {
+    case "passed":
+    case "failed":
+    case "timedOut":
+    case "skipped":
+    case "interrupted":
+      return s;
+    default:
+      return "failed";
+  }
+}
+function classifyAttachment(name, contentType) {
+  if (name === "trace" || contentType === "application/zip") return "trace";
+  if (name === "video" || contentType?.startsWith("video/")) return "video";
+  if (name === "screenshot" || contentType?.startsWith("image/"))
+    return "screenshot";
+  if (name === "stdout" || name === "stderr") return "stdout";
+  return "attachment";
+}
+function flattenSteps(steps) {
+  const out = [];
+  const walk = (s) => {
+    if (s.category === "test.step" || s.category === "expect" || s.error) {
+      out.push({
+        title: s.title,
+        category: s.category,
+        duration: s.duration,
+        error: s.error?.message
+      });
+    }
+    s.steps?.forEach(walk);
+  };
+  steps.forEach(walk);
+  return out;
+}
+function joinChunks(chunks) {
+  if (!chunks.length) return void 0;
+  return chunks.map((c) => typeof c === "string" ? c : c.toString("utf8")).join("").slice(0, 2e4);
+}
+async function postJson(url, auth, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { ...auth, "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`${url} -> ${res.status} ${await res.text()}`);
+  }
+  return res.json();
+}
+export {
+  PwInsightsReporter as default
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "kagami-playwright-reporter",
+  "version": "0.0.1",
+  "description": "Playwright reporter that uploads test runs to Kagami via GitHub OIDC — no secrets required.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "keywords": [
+    "playwright",
+    "reporter",
+    "kagami",
+    "ci",
+    "test-reporting",
+    "github-oidc"
+  ],
+  "license": "MIT",
+  "homepage": "https://kagami.shyim.de",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.49.0",
+    "@kagami/shared": "workspace:*",
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5"
+  }
+}