@crvy/rprtr 0.1.3 → 0.2.2

package/CHANGELOG.md

@@ -5,6 +5,90 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.2] - 2026-07-03
+
+### Miscellaneous
+
+- Update repository URLs to creevey/rprtr
+## [0.2.1] - 2026-07-03
+## [0.2.0] - 2026-07-03
+
+### Added
+
+- **types:** Add run-status variant to ClientWebSocketMessage
+- **reporter:** Include configFile and cwd in register message
+- **server:** Add RunController for spawning playwright test
+- **server:** Persist register payload configFile and cwd as runContext
+- **server:** Instantiate RunController in createServerApp and dispose on close
+- **server:** Add POST /api/run and /api/stop, surface runEnabled in /api/report
+- **client:** Wire Start/Stop buttons to /api/run and /api/stop
+- **client:** Add per-test and per-suite run buttons to sidebar tree
+- **run-controller:** Resolve playwright via project package manager
+- **run-controller:** Descriptor-based filter with positional translation
+- **run-controller:** --test-list for suites with version fallback
+- **client:** Descriptor filters, no-location feedback, isRunning guard
+- **client:** Add captureTestStatuses/restoreTestStatuses helpers
+- **client:** Revert orphaned pending on no-event run
+
+### Changed
+
+- **schemas:** Extract HTTP request schemas to schemas/http.ts
+- **schemas:** Use discriminatedUnion for Run/Stop responses
+- **run-controller:** Document cwd param and test launch fallback
+- **reporter:** Make onBegin synchronous and defer screenshotDir creation
+- **client:** Reset runEventIds on rejected-start path
+
+### Documentation
+
+- **spec:** Run tests from UI design
+- **plan:** Run tests from UI implementation plan
+- **spec:** Run-from-UI robustness design
+- **plan:** Run-from-UI robustness implementation plan
+- **spec:** Stuck-pending run recovery design
+- **plan:** Stuck-pending run recovery implementation plan
+
+### Fixed
+
+- **run-controller:** Guard against duplicate exit/error cleanup
+- **reporter:** Honor CRVY_RPRTR_SERVER_URL env as fallback serverUrl
+- **run-controller:** Override reporters and strip CI env for UI-triggered runs
+- **run-from-ui:** Row height, re-run status, filtered-run scope, startup config
+- **run-from-ui:** Mark tests pending on start, use file:line:column for precise re-runs
+- **run-controller:** Resolve @crvy/rprtr from project cwd then server module
+- **run-controller:** Clean up test-list temp file on spawn throw
+- **knip:** Enable production-mode analysis in strict checks
+
+### Styling
+
+- **client:** Match semicolon convention and destructure location
+- **docs:** Reformat CLI options table
+
+### Testing
+
+- **client:** Cover undefined-restore and empty/bare-root edge cases
+## [0.1.4] - 2026-06-19
+
+### Added
+
+- **path-utils:** Add cross-platform absolute path helpers
+- **server:** Log diagnostic when /file URL cannot resolve on host OS
+
+### Documentation
+
+- **plans:** Cross-OS path handling and stale actual URL on passing rerun
+- Document cross-OS artifact loading limitations
+
+### Fixed
+
+- **report-utils:** Route Windows-style absolute paths to /file on any host
+- **server:** Check pre-resolve path for foreign-OS diagnostic
+- **report-state:** Drop stale comparison actual URL on passed reruns
+- **report-state:** Strip stale actual/diff when preserving baseline-only images
+
+### Testing
+
+- **path-utils:** Cover forward-slash UNC form
+- **server-routes:** Cover baseline enrichment after failed→passed progression
 ## [0.1.3] - 2026-06-18
 
 ### Fixed

package/README.md

@@ -74,13 +74,14 @@ If `artifact-dir` is provided, the CLI treats it as the directory containing:
 
 Explicit flags override the paths derived from `artifact-dir`.
 
-| Option             | Short | Default         | Description                                                                               |
-| ------------------ | ----- | --------------- | ----------------------------------------------------------------------------------------- |
-| `--port`           | `-p`  | `3000`          | Server port                                                                               |
-| `--screenshot-dir` | `-s`  | `./screenshots` | Screenshot directory path                                                                 |
-| `--report-path`    | `-r`  | `./report.json` | Report JSON file path or directory containing `report.json` and `crvy-rprtr-*.json` files |
+| Option             | Short | Default         | Description                                                                                                                                                                                        |
+| ------------------ | ----- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--port`           | `-p`  | `3000`          | Server port                                                                                                                                                                                        |
+| `--screenshot-dir` | `-s`  | `./screenshots` | Screenshot directory path                                                                                                                                                                          |
+| `--report-path`    | `-r`  | `./report.json` | Report JSON file path or directory containing `report.json` and `crvy-rprtr-*.json` files                                                                                                          |
+| `--config`         | `-c`  | auto-detect     | Playwright config path used to enable the run buttons at startup. When omitted, the server discovers `playwright.config.*` in the working directory. A registering reporter always overrides this. |
 
-The CLI currently exposes only these flags. Approval-routing resolver overrides are available through the programmatic server API, not additional CLI flags.
+When the server can resolve a Playwright config (via `--config` or auto-discovery, or once a reporter registers), the sidebar shows Start/Stop and per-test run buttons that trigger `playwright test` without leaving the browser. Approval-routing resolver overrides are available through the programmatic server API, not additional CLI flags.
 
 ## How It Works
 
@@ -113,6 +114,14 @@ Approval routing uses the same resolver, but it reads its resolver settings from
 
 When the server is running, Crvy Rprtr also refreshes the UI after report JSON or screenshot artifacts change on disk.
 
+## Cross-OS Artifact Loading
+
+Crvy Rprtr stores image URLs exactly as the reporter that produced them saw them. In live mode (server running during the test run), failure artifacts are referenced by absolute path under `/file/<encoded>`; in CI/offline mode, attachments are copied into `screenshots/` and referenced by relative path under `/screenshots/`.
+
+If you generate a report on one operating system and then open it on another (for example, downloading a Windows CI runner's `report.json` onto a macOS laptop), absolute-path `/file/...` URLs cannot resolve: the file is not on your filesystem. Crvy Rprtr logs a single diagnostic line per such request and returns 404. The `/screenshots/...` and `/baseline/...` URLs remain portable because they resolve through the server's `screenshotDir` or snapshot resolver.
+
+For fully portable artifact loading across operating systems, run the reporter in CI mode (`ci: true`) and ship the `screenshots/` directory alongside the report JSON.
+
 ## Programmatic API
 
 ```ts

package/dist/{chunk-X2TCDD54.js → chunk-HAFWYUNO.js}

@@ -170,169 +170,211 @@ function resolveBaselineTargets(input) {
 }
 
 // src/schemas.ts
+import { z as z2 } from "zod";
+
+// src/schemas/http.ts
 import { z } from "zod";
-var LocationSchema = z.object({
+var ApproveRequestBodySchema = z.object({
+  id: z.string(),
+  retry: z.number(),
+  image: z.string()
+});
+var RunTestDescriptorSchema = z.object({
   file: z.string(),
-  line: z.number()
+  line: z.number(),
+  column: z.number().optional(),
+  projectName: z.string().optional(),
+  titlePath: z.array(z.string())
 });
-var VisualSourceSchema = z.enum(["comparison", "baseline-only", "declared-only"]);
-var ImagesSchema = z.object({
-  actual: z.string().optional(),
-  expect: z.string().optional(),
-  diff: z.string().optional(),
-  error: z.string().optional(),
-  source: VisualSourceSchema.optional()
+var RunRequestBodySchema = z.object({
+  tests: z.array(RunTestDescriptorSchema).optional()
 });
-var ScreenshotDeclarationSchema = z.discriminatedUnion("kind", [
+var RunResponseSchema = z.discriminatedUnion("ok", [
+  z.object({ ok: z.literal(true) }),
   z.object({
-    visualName: z.string(),
-    kind: z.literal("named"),
-    declaredName: z.string(),
-    snapshotBaseName: z.string(),
-    occurrenceIndex: z.number()
-  }),
+    ok: z.literal(false),
+    reason: z.enum(["no-config", "already-running", "no-tests"])
+  })
+]);
+var StopResponseSchema = z.discriminatedUnion("ok", [
+  z.object({ ok: z.literal(true) }),
   z.object({
-    visualName: z.string(),
-    kind: z.literal("unnamed"),
-    occurrenceIndex: z.number()
+    ok: z.literal(false),
+    reason: z.literal("not-running")
   })
 ]);
-var AttachmentSchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  contentType: z.string()
+
+// src/schemas.ts
+var LocationSchema = z2.object({
+  file: z2.string(),
+  line: z2.number(),
+  column: z2.number().optional()
+});
+var VisualSourceSchema = z2.enum(["comparison", "baseline-only", "declared-only"]);
+var ImagesSchema = z2.object({
+  actual: z2.string().optional(),
+  expect: z2.string().optional(),
+  diff: z2.string().optional(),
+  error: z2.string().optional(),
+  source: VisualSourceSchema.optional()
 });
-var TestStatusSchema = z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
-var TestResultStatusSchema = z.enum(["failed", "success", "pending"]);
-var TestResultSchema = z.object({
+var ScreenshotDeclarationSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    visualName: z2.string(),
+    kind: z2.literal("named"),
+    declaredName: z2.string(),
+    snapshotBaseName: z2.string(),
+    occurrenceIndex: z2.number()
+  }),
+  z2.object({
+    visualName: z2.string(),
+    kind: z2.literal("unnamed"),
+    occurrenceIndex: z2.number()
+  })
+]);
+var AttachmentSchema = z2.object({
+  name: z2.string(),
+  path: z2.string(),
+  contentType: z2.string()
+});
+var TestStatusSchema = z2.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
+var TestResultStatusSchema = z2.enum(["failed", "success", "pending"]);
+var TestResultSchema = z2.object({
   status: TestResultStatusSchema,
-  retries: z.number(),
-  images: z.record(z.string(), ImagesSchema).optional(),
-  visualDeclarations: z.array(ScreenshotDeclarationSchema).optional(),
-  error: z.string().optional(),
-  duration: z.number().optional()
+  retries: z2.number(),
+  images: z2.record(z2.string(), ImagesSchema).optional(),
+  visualDeclarations: z2.array(ScreenshotDeclarationSchema).optional(),
+  error: z2.string().optional(),
+  duration: z2.number().optional()
 });
-var TestDataSchema = z.object({
-  id: z.string(),
-  titlePath: z.array(z.string()),
-  browser: z.string(),
-  projectName: z.string().optional(),
-  title: z.string(),
-  skip: z.union([z.boolean(), z.string()]).optional(),
-  retries: z.number().optional(),
+var TestDataSchema = z2.object({
+  id: z2.string(),
+  titlePath: z2.array(z2.string()),
+  browser: z2.string(),
+  projectName: z2.string().optional(),
+  title: z2.string(),
+  skip: z2.union([z2.boolean(), z2.string()]).optional(),
+  retries: z2.number().optional(),
   status: TestStatusSchema.optional(),
-  results: z.array(TestResultSchema).optional(),
-  approved: z.record(z.string(), z.number()).nullable().optional(),
-  attachments: z.array(AttachmentSchema).optional(),
+  results: z2.array(TestResultSchema).optional(),
+  approved: z2.record(z2.string(), z2.number()).nullable().optional(),
+  attachments: z2.array(AttachmentSchema).optional(),
   location: LocationSchema.optional()
 });
 var CrvyRprtrTestSchema = TestDataSchema.extend({
-  checked: z.boolean()
+  checked: z2.boolean()
 });
-var CrvyRprtrSuiteSchema = z.lazy(
-  () => z.object({
-    path: z.array(z.string()),
-    skip: z.boolean(),
+var CrvyRprtrSuiteSchema = z2.lazy(
+  () => z2.object({
+    path: z2.array(z2.string()),
+    skip: z2.boolean(),
     status: TestStatusSchema.optional(),
-    opened: z.boolean(),
-    checked: z.boolean(),
-    indeterminate: z.boolean(),
-    children: z.record(z.string(), z.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
+    opened: z2.boolean(),
+    checked: z2.boolean(),
+    indeterminate: z2.boolean(),
+    children: z2.record(z2.string(), z2.union([CrvyRprtrSuiteSchema, CrvyRprtrTestSchema])).optional()
   })
 );
-var IncomingWebSocketMessageSchema = z.object({
-  type: z.enum(["test-begin", "test-end", "run-end", "approve", "sync", "register"]),
-  data: z.unknown()
+var IncomingWebSocketMessageSchema = z2.object({
+  type: z2.enum(["test-begin", "test-end", "run-end", "approve", "sync", "register"]),
+  data: z2.unknown()
 });
-var WebSocketMessageSchema = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("test-begin"), data: TestDataSchema }),
-  z.object({ type: z.literal("test-update"), data: TestDataSchema }),
-  z.object({
-    type: z.literal("run-end"),
-    data: z.object({
-      status: z.enum(["passed", "failed", "skipped"]),
-      removedTestIds: z.array(z.string())
+var WebSocketMessageSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("test-begin"), data: TestDataSchema }),
+  z2.object({ type: z2.literal("test-update"), data: TestDataSchema }),
+  z2.object({
+    type: z2.literal("run-end"),
+    data: z2.object({
+      status: z2.enum(["passed", "failed", "skipped"]),
+      removedTestIds: z2.array(z2.string())
     })
   }),
-  z.object({
-    type: z.literal("sync"),
-    data: z.object({
-      tests: z.record(z.string(), TestDataSchema),
-      isUpdateMode: z.boolean().optional()
+  z2.object({
+    type: z2.literal("sync"),
+    data: z2.object({
+      tests: z2.record(z2.string(), TestDataSchema),
+      isUpdateMode: z2.boolean().optional()
     })
   }),
-  z.object({ type: z.literal("approve"), data: z.unknown() })
+  z2.object({ type: z2.literal("approve"), data: z2.unknown() }),
+  z2.object({
+    type: z2.literal("run-status"),
+    data: z2.object({
+      running: z2.boolean()
+    })
+  })
 ]);
-var TestBeginDataSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  titlePath: z.array(z.string()),
-  browser: z.string(),
-  projectName: z.string().optional(),
+var TestBeginDataSchema = z2.object({
+  id: z2.string(),
+  title: z2.string(),
+  titlePath: z2.array(z2.string()),
+  browser: z2.string(),
+  projectName: z2.string().optional(),
   location: LocationSchema
 });
-var TestEndDataSchema = z.object({
-  id: z.string(),
-  status: z.enum(["passed", "failed", "skipped"]),
-  attachments: z.array(AttachmentSchema),
-  visualNames: z.array(z.string()).default([]),
-  visualDeclarations: z.preprocess(
+var TestEndDataSchema = z2.object({
+  id: z2.string(),
+  status: z2.enum(["passed", "failed", "skipped"]),
+  attachments: z2.array(AttachmentSchema),
+  visualNames: z2.array(z2.string()).default([]),
+  visualDeclarations: z2.preprocess(
     (value) => value === null ? void 0 : value,
-    z.array(ScreenshotDeclarationSchema).optional()
+    z2.array(ScreenshotDeclarationSchema).optional()
   ),
-  error: z.string().optional(),
-  duration: z.number().optional()
+  error: z2.string().optional(),
+  duration: z2.number().optional()
 });
-var RunEndDataSchema = z.object({
-  status: z.enum(["passed", "failed", "skipped"])
+var RunEndDataSchema = z2.object({
+  status: z2.enum(["passed", "failed", "skipped"])
 });
-var RegisterDataSchema = z.object({
-  playwrightSnapshotDir: z.string().optional(),
-  playwrightTestDir: z.string().optional(),
-  playwrightSnapshotPathTemplate: z.string().optional(),
-  playwrightToHaveScreenshotPathTemplate: z.string().optional()
+var RegisterDataSchema = z2.object({
+  playwrightSnapshotDir: z2.string().optional(),
+  playwrightTestDir: z2.string().optional(),
+  playwrightSnapshotPathTemplate: z2.string().optional(),
+  playwrightToHaveScreenshotPathTemplate: z2.string().optional(),
+  configFile: z2.string().optional(),
+  cwd: z2.string().optional()
 });
-var ReportDataSchema = z.object({
-  isRunning: z.boolean(),
-  tests: z.record(z.string(), TestDataSchema),
-  browsers: z.array(z.string()),
-  isUpdateMode: z.boolean(),
-  screenshotDir: z.string()
+var ReportDataSchema = z2.object({
+  isRunning: z2.boolean(),
+  tests: z2.record(z2.string(), TestDataSchema),
+  browsers: z2.array(z2.string()),
+  isUpdateMode: z2.boolean(),
+  screenshotDir: z2.string()
 });
-var LoadedReportDataSchema = z.object({
-  tests: z.record(z.string(), TestDataSchema).optional(),
-  isUpdateMode: z.boolean().optional()
+var LoadedReportDataSchema = z2.object({
+  tests: z2.record(z2.string(), TestDataSchema).optional(),
+  isUpdateMode: z2.boolean().optional()
 });
-var OfflineEventSchema = z.object({
-  type: z.enum(["test-begin", "test-end", "run-end"]),
-  data: z.unknown(),
-  timestamp: z.number(),
-  workerIndex: z.number()
+var OfflineEventSchema = z2.object({
+  type: z2.enum(["test-begin", "test-end", "run-end"]),
+  data: z2.unknown(),
+  timestamp: z2.number(),
+  workerIndex: z2.number()
 });
-var OfflineReportSchema = z.object({
-  version: z.number(),
-  generatedAt: z.string(),
-  workers: z.number(),
-  events: z.array(OfflineEventSchema)
-});
-var ApproveRequestBodySchema = z.object({
-  id: z.string(),
-  retry: z.number(),
-  image: z.string()
+var OfflineReportSchema = z2.object({
+  version: z2.number(),
+  generatedAt: z2.string(),
+  workers: z2.number(),
+  events: z2.array(OfflineEventSchema)
 });
-var ReportApiResponseSchema = z.object({
-  tests: z.record(z.string(), TestDataSchema),
-  isUpdateMode: z.boolean().optional()
+var ReportApiResponseSchema = z2.object({
+  tests: z2.record(z2.string(), TestDataSchema),
+  isUpdateMode: z2.boolean().optional(),
+  isRunning: z2.boolean().optional(),
+  runEnabled: z2.boolean().optional()
 });
-var ClientBootstrapDataSchema = z.object({
+var ClientBootstrapDataSchema = z2.object({
   report: ReportApiResponseSchema.extend({
-    isUpdateMode: z.boolean()
+    isUpdateMode: z2.boolean()
   }),
-  liveUpdates: z.boolean(),
-  approvalEnabled: z.boolean(),
-  approvalMessage: z.string().optional()
+  liveUpdates: z2.boolean(),
+  approvalEnabled: z2.boolean(),
+  approvalMessage: z2.string().optional(),
+  runEnabled: z2.boolean().optional(),
+  isRunning: z2.boolean().optional()
 });
-var ImagesViewModeSchema = z.enum(["side-by-side", "swap", "slide", "blend"]);
+var ImagesViewModeSchema = z2.enum(["side-by-side", "swap", "slide", "blend"]);
 function safeParse(schema, data) {
   const result = schema.safeParse(data);
   if (result.success) {
@@ -341,8 +383,26 @@ function safeParse(schema, data) {
   return null;
 }
 
+// src/path-utils.ts
+var posixAbsolutePattern = /^\//u;
+var windowsDrivePattern = /^[A-Za-z]:[\\/]/u;
+var windowsUncPattern = /^[\\/][\\/]/u;
+function isPosixAbsolutePath(p) {
+  return posixAbsolutePattern.test(p);
+}
+function isWindowsAbsolutePath(p) {
+  return windowsDrivePattern.test(p) || windowsUncPattern.test(p);
+}
+function isAnyAbsolutePath(p) {
+  return isPosixAbsolutePath(p) || isWindowsAbsolutePath(p);
+}
+function isForeignAbsolutePath(p, hostPlatform) {
+  if (!isAnyAbsolutePath(p)) return false;
+  if (hostPlatform === "win32") return !isWindowsAbsolutePath(p);
+  return !isPosixAbsolutePath(p);
+}
+
 // src/report-utils.ts
-import { isAbsolute } from "path";
 function normalizeScreenshotsBaseUrl(baseUrl) {
   return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 }
@@ -387,7 +447,7 @@ function attachmentsToImages(attachments, screenshotsBaseUrl = "/screenshots/")
     const role = match[2];
     if (baseName === null || baseName === void 0 || role === null || role === void 0) continue;
     images[baseName] ??= {};
-    const url = isAbsolute(attachment.path) ? `/file/${encodeURIComponent(attachment.path)}` : `${baseUrl}${attachment.path}`;
+    const url = isAnyAbsolutePath(attachment.path) ? `/file/${encodeURIComponent(attachment.path)}` : `${baseUrl}${attachment.path}`;
     const img = images[baseName];
     if (img !== null && img !== void 0) {
       if (role === "actual") img.actual = url;
@@ -422,9 +482,6 @@ function isCurrentArtifact(image) {
 }
 function isReusablePassingImage(image) {
   const source = image.source ?? classifyImage(image);
-  if (source === "comparison") {
-    return image.actual !== void 0 && image.diff === void 0;
-  }
   return source === "baseline-only";
 }
 function hasReusablePassingImages(images) {
@@ -445,8 +502,8 @@ function preservePreviousPassingImages(test, status, images) {
     return {
       ...currentImages,
       [name]: {
-        ...previousImage,
-        source: previousImage.source ?? classifyImage(previousImage)
+        expect: previousImage.expect,
+        source: "baseline-only"
       }
     };
   }, images);
@@ -469,7 +526,12 @@ function createMutableReportState(screenshotDir = "./screenshots") {
 function applyTestBeginEvent(state, data) {
   const { id, title, titlePath, browser, projectName, location } = data;
   state.currentRunIds.add(id);
-  state.reportData.tests[id] ??= {
+  const existing = state.reportData.tests[id];
+  if (existing !== void 0) {
+    existing.status = "running";
+    return existing;
+  }
+  const created = {
     id,
     titlePath: titlePath ?? [],
     browser: browser ?? "",
@@ -481,7 +543,8 @@ function applyTestBeginEvent(state, data) {
     location,
     status: "running"
   };
-  return state.reportData.tests[id];
+  state.reportData.tests[id] = created;
+  return created;
 }
 function applyTestEndEvent(state, data, options = {}) {
   const test = state.reportData.tests[data.id];
@@ -519,11 +582,13 @@ function applyTestEndEvent(state, data, options = {}) {
     diffCount
   };
 }
-function finalizeRunEvent(state) {
+function finalizeRunEvent(state, options = {}) {
   state.reportData.isRunning = false;
-  state.reportData.tests = Object.fromEntries(
-    Object.entries(state.reportData.tests).filter(([id]) => state.currentRunIds.has(id))
-  );
+  if (options.preserveNonCurrent !== true) {
+    state.reportData.tests = Object.fromEntries(
+      Object.entries(state.reportData.tests).filter(([id]) => state.currentRunIds.has(id))
+    );
+  }
   state.currentRunIds.clear();
   const runTests = Object.values(state.reportData.tests).filter((test) => test !== void 0);
   return {
@@ -534,10 +599,13 @@ function finalizeRunEvent(state) {
 }
 
 export {
+  isForeignAbsolutePath,
   createMutableReportState,
   applyTestBeginEvent,
   applyTestEndEvent,
   finalizeRunEvent,
+  ApproveRequestBodySchema,
+  RunRequestBodySchema,
   IncomingWebSocketMessageSchema,
   TestBeginDataSchema,
   TestEndDataSchema,
@@ -545,7 +613,6 @@ export {
   RegisterDataSchema,
   LoadedReportDataSchema,
   OfflineReportSchema,
-  ApproveRequestBodySchema,
   ClientBootstrapDataSchema,
   safeParse,
   withResolvedVisualNames,