@kinora/reporter 0.1.3 → 0.3.0

package/README.md

@@ -1,8 +1,8 @@
 # @kinora/reporter
 
-Playwright reporter that uploads your test results to a [kinora](https://github.com/joris-gallot/kinora) server: pass rates, trends, flaky tests, and the full Playwright trace for failures, across projects and over time.
+Playwright reporter that uploads your test results to a [kinora](https://github.com/Kinora-dev/kinora) server: pass rates, trends, flaky tests, and the full Playwright trace for failures, across projects and over time.
 
-It runs on `onEnd`, posts the normalized run, then uploads the trace.zip for each failed/flaky test that has one. Upload never fails your test run.
+It runs on `onEnd`, posts the normalized run, then uploads the trace.zip for each test that produced one (videos and screenshots too, see below). Upload never fails your test run.
 
 ## Install
 
@@ -33,42 +33,28 @@ The token comes from the environment (keep it out of the config file); the serve
 KINORA_TOKEN=<token> npx playwright test
 ```
 
-Create an API token in the kinora dashboard (Settings → Workspace). Self-hosting? Point at your server with `KINORA_URL` - see [selfhost/README.md](https://github.com/joris-gallot/kinora/blob/main/selfhost/README.md).
+Create an API token in the kinora dashboard (Settings → Workspace). Self-hosting? Point at your server with `KINORA_URL`.
 
-## Options
+## Videos and screenshots without tracing
+
+Traces are uploaded by default, and Playwright already embeds a test's screenshots and video
+inside its trace.zip. If you run without tracing, upload them on their own:
 
 ```ts
-[
-  '@kinora/reporter',
-  {
-    project: { slug: 'web-app', name: 'Web App' },
-  },
-]
+reporter: [['@kinora/reporter', {
+  project: { slug: 'web-app' },
+  uploadAttachments: ['trace', 'video', 'screenshot'],
+}]]
 ```
 
-| Option    | Type                                 | Default                      | Description                                |
-| --------- | ------------------------------------ | ---------------------------- | ------------------------------------------ |
-| `project` | `{ slug: string, name?: string }`    | required                     | Target project. `name` defaults to `slug`. |
-| `url`     | `string`                             | env `KINORA_URL`, then cloud | kinora server base URL. Set for self-host. |
-| `token`   | `string`                             | env `KINORA_TOKEN`           | Project API token. Prefer the env var.     |
-| `git`     | `{ sha?, branch?, repoUrl? }`        | auto on GitHub Actions       | Git metadata. `repoUrl` links a sha to its commit. |
-| `ci`      | `{ provider?, runUrl?, runNumber? }` | auto on GitHub Actions       | CI metadata for the run.                   |
-
-On GitHub Actions, `git` and `ci` are filled from the standard `GITHUB_*` env vars (including the repo URL, so shas link to their commit in the dashboard). Pass them explicitly on other CI providers.
+Kinora uploads whatever Playwright attached, so `screenshot: 'only-on-failure'` and
+`video: 'retain-on-failure'` keep deciding what exists in the first place.
 
-## CI example (GitHub Actions)
-
-```yaml
-- run: npx playwright test
-  env:
-    KINORA_TOKEN: ${{ secrets.KINORA_TOKEN }}
-```
+## Documentation
 
-## Notes
+Full reporter options, GitHub PR comments, CI examples, and self-hosting are in the docs:
 
-- If `KINORA_TOKEN` is missing, the reporter logs a warning and skips the upload, so local runs aren't affected. `KINORA_URL` is optional (defaults to the hosted cloud).
-- Traces are uploaded only for tests that produced one, so enable `trace` in your Playwright config (`on-first-retry`, `retain-on-failure`, etc.).
-- Cross-run test identity is the file + title path + Playwright project name, so history stays stable as long as those don't change.
+**https://docs.kinora.dev/guides/reporter/**
 
 ## License
 

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { CiMeta, GitMeta } from "@kinora/core";
+import { AttachmentKind, CiMeta, GitMeta } from "@kinora/core";
 import { FullConfig, FullResult, Reporter, Suite } from "@playwright/test/reporter";
 
 //#region src/index.d.ts
@@ -14,6 +14,20 @@ interface KinoraReporterOptions {
   };
   git?: GitMeta;
   ci?: CiMeta;
+  /**
+   * Post/update a summary comment on the GitHub PR (uses the job's GITHUB_TOKEN; needs
+   * `permissions: pull-requests: write`). `label` distinguishes matrix legs sharing one PR.
+   */
+  prComment?: boolean | {
+    label?: string;
+    policy?: 'always' | 'on-failure';
+  };
+  /**
+   * Which attachment kinds to upload. Defaults to `['trace']`. Add `'video'` / `'screenshot'`
+   * to host them on their own, which is what you want when `trace` is off (with tracing on,
+   * Playwright already embeds them in the trace.zip).
+   */
+  uploadAttachments?: AttachmentKind[];
 }
 declare class KinoraReporter implements Reporter {
   private readonly options;
@@ -22,6 +36,7 @@ declare class KinoraReporter implements Reporter {
   constructor(options: KinoraReporterOptions);
   onBegin(config: FullConfig, suite: Suite): void;
   onEnd(result: FullResult): Promise<void>;
+  private maybePostPrComment;
 }
 //#endregion
 export { KinoraReporterOptions, KinoraReporter as default };

package/dist/index.mjs

@@ -1,6 +1,7 @@
+import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import process from "node:process";
-import { DEFAULT_KINORA_URL, IngestError, createIngestClient, effectiveAttachments, isTraceAttachment, makeTestKey } from "@kinora/core";
+import { DEFAULT_KINORA_URL, DEFAULT_UPLOAD_ATTACHMENTS, IngestError, createIngestClient, effectiveAttachments, isUploadableAttachment, makeTestKey, postPrComment, resolvePrContext } from "@kinora/core";
 //#region src/index.ts
 function identity(test) {
 	let file = "";
@@ -70,12 +71,14 @@ function countsOf(tests) {
 function detectGit() {
 	const sha = process.env.GITHUB_SHA;
 	const branch = process.env.GITHUB_REF_NAME;
+	const baseBranch = process.env.GITHUB_BASE_REF || void 0;
 	const { GITHUB_SERVER_URL, GITHUB_REPOSITORY } = process.env;
 	const repoUrl = GITHUB_SERVER_URL && GITHUB_REPOSITORY ? `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}` : void 0;
 	if (!sha && !branch && !repoUrl) return void 0;
 	return {
 		sha,
 		branch,
+		baseBranch,
 		repoUrl
 	};
 }
@@ -125,12 +128,14 @@ var KinoraReporter = class {
 		try {
 			const client = createIngestClient({
 				baseUrl: url,
-				token
+				token,
+				regression: !!this.options.prComment
 			});
 			const res = await client.uploadRun(payload);
-			let traces = 0;
+			const kinds = this.options.uploadAttachments ?? DEFAULT_UPLOAD_ATTACHMENTS;
+			let artifacts = 0;
 			for (const t of tests) for (const a of t.attachments) {
-				if (!a.path || !isTraceAttachment(a)) continue;
+				if (!a.path || !isUploadableAttachment(a, kinds)) continue;
 				try {
 					await client.uploadArtifact({
 						runId: res.runId,
@@ -139,17 +144,49 @@ var KinoraReporter = class {
 						contentType: a.contentType,
 						body: await readFile(a.path)
 					});
-					traces++;
+					artifacts++;
 				} catch (err) {
-					console.warn(`[kinora] trace upload failed for ${t.testKey}:`, err instanceof Error ? err.message : err);
+					console.warn(`[kinora] ${a.name} upload failed for ${t.testKey}:`, err instanceof Error ? err.message : err);
 				}
 			}
-			console.log(`[kinora] uploaded ${res.tests} tests + ${traces} traces (run ${res.runId})`);
+			console.log(`[kinora] uploaded ${res.tests} tests + ${artifacts} artifacts (run ${res.runId})`);
+			await this.maybePostPrComment(payload, res);
 		} catch (err) {
 			if (err instanceof IngestError && err.status === 402) console.warn(`[kinora] ${err.message}`);
 			else console.error(`[kinora] upload failed:`, err instanceof Error ? err.message : err);
 		}
 	}
+	async maybePostPrComment(payload, res) {
+		if (!this.options.prComment) return;
+		const opt = this.options.prComment;
+		const label = typeof opt === "object" ? opt.label : void 0;
+		const policy = typeof opt === "object" ? opt.policy : void 0;
+		try {
+			const ctx = resolvePrContext(this.config?.shard ? {
+				...process.env,
+				__KINORA_IS_SHARD: "1"
+			} : process.env, (p) => {
+				try {
+					return readFileSync(p, "utf8");
+				} catch {
+					return;
+				}
+			});
+			if (!ctx) return;
+			const outcome = await postPrComment(ctx, {
+				projectSlug: payload.project.slug,
+				projectName: payload.project.name,
+				label,
+				runUrl: res.runUrl,
+				ciRunUrl: payload.run.ci?.runUrl,
+				counts: payload.run.counts,
+				regression: res.regression
+			}, policy ?? "always");
+			if (outcome !== "skipped") console.warn(`[kinora] PR comment ${outcome}`);
+		} catch (err) {
+			console.warn("[kinora] PR comment failed:", err instanceof Error ? err.message : err);
+		}
+	}
 };
 //#endregion
 export { KinoraReporter as default };

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@kinora/reporter",
   "type": "module",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "Playwright reporter that uploads test results to a kinora server",
   "author": "Joris Gallot",
   "license": "MIT",
-  "homepage": "https://github.com/joris-gallot/kinora#readme",
+  "homepage": "https://github.com/Kinora-dev/kinora#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/joris-gallot/kinora.git",
+    "url": "git+https://github.com/Kinora-dev/kinora.git",
     "directory": "packages/reporter"
   },
-  "bugs": "https://github.com/joris-gallot/kinora/issues",
+  "bugs": "https://github.com/Kinora-dev/kinora/issues",
   "keywords": [
     "playwright",
     "reporter",
@@ -36,16 +36,19 @@
     "@playwright/test": ">=1.40.0"
   },
   "dependencies": {
-    "@kinora/core": "0.1.3"
+    "@kinora/core": "0.3.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.61.0",
     "@types/node": "^26.0.0",
+    "@vitest/coverage-v8": "^4.1.9",
     "tsdown": "^0.22.3",
-    "typescript": "~6.0.3"
+    "typescript": "~6.0.3",
+    "vitest": "^4.1.9"
   },
   "scripts": {
     "build": "tsdown",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --coverage"
   }
 }