@crvy/rprtr 0.1.4 → 0.2.2

package/CHANGELOG.md

@@ -5,6 +5,67 @@ 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

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 |
-
-The CLI currently exposes only these flags. Approval-routing resolver overrides are available through the programmatic server API, not additional CLI flags.
+| 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. |
+
+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
 

package/dist/{chunk-WRMHUY5A.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")
+  })
+]);
+
+// 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 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 = z.object({
-  name: z.string(),
-  path: z.string(),
-  contentType: z.string()
+var AttachmentSchema = z2.object({
+  name: z2.string(),
+  path: z2.string(),
+  contentType: z2.string()
 });
-var TestStatusSchema = z.enum(["unknown", "pending", "running", "failed", "approved", "success", "retrying"]);
-var TestResultStatusSchema = z.enum(["failed", "success", "pending"]);
-var TestResultSchema = z.object({
+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 OfflineReportSchema = z2.object({
+  version: z2.number(),
+  generatedAt: z2.string(),
+  workers: z2.number(),
+  events: z2.array(OfflineEventSchema)
 });
-var ApproveRequestBodySchema = z.object({
-  id: z.string(),
-  retry: z.number(),
-  image: z.string()
+var ReportApiResponseSchema = z2.object({
+  tests: z2.record(z2.string(), TestDataSchema),
+  isUpdateMode: z2.boolean().optional(),
+  isRunning: z2.boolean().optional(),
+  runEnabled: z2.boolean().optional()
 });
-var ReportApiResponseSchema = z.object({
-  tests: z.record(z.string(), TestDataSchema),
-  isUpdateMode: z.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) {
@@ -484,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 ?? "",
@@ -496,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];
@@ -534,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 {
@@ -554,6 +604,8 @@ export {
   applyTestBeginEvent,
   applyTestEndEvent,
   finalizeRunEvent,
+  ApproveRequestBodySchema,
+  RunRequestBodySchema,
   IncomingWebSocketMessageSchema,
   TestBeginDataSchema,
   TestEndDataSchema,
@@ -561,7 +613,6 @@ export {
   RegisterDataSchema,
   LoadedReportDataSchema,
   OfflineReportSchema,
-  ApproveRequestBodySchema,
   ClientBootstrapDataSchema,
   safeParse,
   withResolvedVisualNames,