@crvy/rprtr 0.2.4 → 0.3.0

package/dist/{chunk-473CWZ4V.js → chunk-IFHYWPXG.js}

@@ -12,13 +12,14 @@ import {
   applyTestEndEvent,
   createMutableReportState,
   finalizeRunEvent,
+  isCI,
   isForeignAbsolutePath,
   resolveBaselineTargets,
   safeParse
-} from "./chunk-HAFWYUNO.js";
+} from "./chunk-4YJL655E.js";
 
 // src/server/app.ts
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname4, join as join6 } from "path";
 import { fileURLToPath } from "url";
 
 // src/offline-reports.ts
@@ -208,8 +209,544 @@ function mergeOfflineReportsIntoTests(existingTests, offlineReports, options = {
   };
 }
 
+// src/server/docker-support.ts
+import { spawn } from "child_process";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { isAbsolute, join as join2, relative, sep } from "node:path";
+import { detect } from "package-manager-detector/detect";
+function createDockerExec() {
+  return (args) => new Promise((resolve5, reject) => {
+    const child = spawn("docker", args, { stdio: ["ignore", "pipe", "pipe"] });
+    const stdout = [];
+    const stderr = [];
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve5({
+        exitCode: code ?? 1,
+        stdout: Buffer.concat(stdout).toString(),
+        stderr: Buffer.concat(stderr).toString()
+      });
+    });
+  });
+}
+async function probeDockerDaemon(exec) {
+  try {
+    const result = await exec(["info"]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function isDockerImagePresent(exec, image) {
+  try {
+    const result = await exec(["image", "inspect", image]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function pullDockerImage(exec, image) {
+  try {
+    const result = await exec(["pull", image]);
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function forceRemoveContainer(exec, name) {
+  try {
+    await exec(["rm", "-f", name]);
+  } catch {
+  }
+}
+function resolveDockerImage(options) {
+  if (options.image !== void 0 && options.image !== "") return options.image;
+  if (options.version === null) return null;
+  return `mcr.microsoft.com/playwright:v${options.version}-noble`;
+}
+var CONTAINER_INVOKERS = {
+  npm: ["npx"],
+  pnpm: ["pnpm", "exec"],
+  yarn: ["yarn"],
+  bun: ["bunx"]
+};
+var DEFAULT_CONTAINER_COMMAND = ["npx"];
+function resolveContainerCommand(input) {
+  if (input.command !== void 0 && input.command.length > 0) return input.command;
+  if (!input.hasCustomImage) return [...DEFAULT_CONTAINER_COMMAND];
+  if (input.detectedAgentName === void 0 || input.detectedAgentName === null) {
+    input.warn?.("Could not detect a package manager for the custom docker image; falling back to npx.");
+    return [...DEFAULT_CONTAINER_COMMAND];
+  }
+  const invoker = CONTAINER_INVOKERS[input.detectedAgentName];
+  if (invoker === void 0) {
+    input.warn?.(`Package manager "${input.detectedAgentName}" is not supported in docker mode; falling back to npx.`);
+    return [...DEFAULT_CONTAINER_COMMAND];
+  }
+  return [...invoker];
+}
+var detectProjectAgent = async (cwd) => {
+  try {
+    const result = await detect({ cwd, strategies: ["lockfile", "packageManager-field"] });
+    return result === null ? null : { name: result.name, agent: result.agent };
+  } catch {
+    return null;
+  }
+};
+function rewriteContainerPath(path, mapping) {
+  if (path === mapping.from) return mapping.to;
+  if (path.startsWith(`${mapping.from}/`)) return mapping.to + path.slice(mapping.from.length);
+  return path;
+}
+function resolvePlaywrightVersion(cwd) {
+  try {
+    const req = createRequire(join2(cwd, "package.json"));
+    const pkgPath = req.resolve("@playwright/test/package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return typeof pkg === "object" && pkg !== null && "version" in pkg && typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function rewriteContainerTestDescriptors(tests, mapping) {
+  if (tests === void 0 || mapping === void 0) return tests;
+  return tests.map((d) => ({ ...d, file: rewriteContainerPath(d.file, mapping) }));
+}
+function testListEntry(d, file) {
+  const loc = d.column === void 0 ? `${file}:${d.line}` : `${file}:${d.line}:${d.column}`;
+  const title = d.titlePath.join(" \u203A ");
+  const prefix = d.projectName !== void 0 && d.projectName !== "" ? `[${d.projectName}] \u203A ` : "";
+  return `${prefix}${loc} \u203A ${title}`;
+}
+function buildTestListEntries(tests, rootDir, cwd) {
+  if (rootDir !== void 0) {
+    return tests.map((d) => testListEntry(d, isAbsolute(d.file) ? relative(rootDir, d.file) || d.file : d.file));
+  }
+  return tests.flatMap((d) => {
+    if (!isAbsolute(d.file)) return [testListEntry(d, d.file)];
+    const rel = relative(cwd ?? process.cwd(), d.file);
+    const segments = rel.split(sep);
+    return segments.map((_, i) => testListEntry(d, segments.slice(i).join(sep)));
+  });
+}
+
+// src/server/run-controller.ts
+import { spawn as spawn2 } from "child_process";
+import { unlinkSync, writeFileSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/server/run-launcher.ts
+import { resolveCommand } from "package-manager-detector/commands";
+import { getUserAgent } from "package-manager-detector/detect";
+function resolvePlaywrightLaunch(cwd, playwrightArgs) {
+  const agent = getUserAgent();
+  const resolved = agent === null ? null : resolveCommand(agent, "execute-local", ["playwright", ...playwrightArgs]);
+  if (resolved !== null) return { cmd: resolved.command, args: resolved.args };
+  return { cmd: "npx", args: ["playwright", ...playwrightArgs] };
+}
+function buildSpawnEnv(port, baseEnv = process.env) {
+  const env = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (key === "CI") continue;
+    env[key] = value;
+  }
+  env.CRVY_RPRTR_SERVER_URL = `ws://localhost:${port}`;
+  env.PLAYWRIGHT_HTML_OPEN = "never";
+  return env;
+}
+function createLocalLauncher(options) {
+  return {
+    mode: "local",
+    launch({ ctx, playwrightArgs }) {
+      const resolve5 = options.resolveLaunch ?? resolvePlaywrightLaunch;
+      const { cmd, args } = resolve5(ctx.cwd, playwrightArgs);
+      return { cmd, args, env: buildSpawnEnv(options.port, options.env) };
+    }
+  };
+}
+
+// src/server/run-controller.ts
+var STOP_GRACE_MS = 5e3;
+var KNOWN_SIGNALS = {
+  SIGTERM: "SIGTERM",
+  SIGKILL: "SIGKILL"
+};
+function sharedProject(tests) {
+  const names = new Set(tests.map((t) => t.projectName ?? ""));
+  if (names.size === 1) {
+    const name = [...names][0];
+    return name === "" ? void 0 : name;
+  }
+  return void 0;
+}
+function gteMinor(version, major, minor) {
+  const match = /^(\d+)\.(\d+)/.exec(version.trim());
+  if (match === null) return false;
+  const maj = parseInt(match[1], 10);
+  const min = parseInt(match[2], 10);
+  if (maj !== major) return maj > major;
+  return min >= minor;
+}
+var defaultWriteTempFile = (content) => {
+  const path = join3(tmpdir(), `crvy-rprtr-test-list-${process.pid}-${Date.now()}.txt`);
+  writeFileSync(path, content, "utf8");
+  return path;
+};
+function defaultDeleteTempFile(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+function resolveReporterDefault(cwd) {
+  try {
+    return createRequire2(join3(cwd, "package.json")).resolve("@crvy/rprtr");
+  } catch {
+  }
+  try {
+    return createRequire2(import.meta.url).resolve("@crvy/rprtr");
+  } catch {
+    return null;
+  }
+}
+var RunController = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  child = null;
+  sigkillTimer = null;
+  testListPath = null;
+  get isRunning() {
+    return this.child !== null;
+  }
+  supportsTestList(cwd) {
+    const getVersion = this.deps.getPlaywrightVersion ?? resolvePlaywrightVersion;
+    const version = getVersion(cwd);
+    return version !== null && gteMinor(version, 1, 56);
+  }
+  cleanupTempFile() {
+    if (this.testListPath !== null) {
+      const del = this.deps.deleteTempFile ?? defaultDeleteTempFile;
+      del(this.testListPath);
+      this.testListPath = null;
+    }
+  }
+  buildPlaywrightArgs(ctx, filters, tests) {
+    const resolveReporter = this.deps.resolveReporter ?? resolveReporterDefault;
+    const reporterModule = resolveReporter(ctx.cwd);
+    const useTestList = tests !== void 0 && (tests.length > 1 || this.deps.containerPathMapping !== void 0) && this.supportsTestList(ctx.cwd);
+    const args = ["test", "--config", ctx.configFile];
+    if (reporterModule !== null) args.push("--reporter", reporterModule);
+    if (filters.update === true) args.push("--update-snapshots");
+    if (useTestList && tests !== void 0) {
+      const content = buildTestListEntries(tests, ctx.rootDir, ctx.cwd).join("\n");
+      const writeTemp = this.deps.writeTempFile ?? defaultWriteTempFile;
+      this.testListPath = writeTemp(content);
+      args.push("--test-list", this.testListPath);
+    } else if (tests !== void 0 && tests.length > 0) {
+      const project = sharedProject(tests);
+      if (project !== void 0) args.push(`--project=${project}`);
+      for (const d of tests) {
+        args.push(d.column === void 0 ? `${d.file}:${d.line}` : `${d.file}:${d.line}:${d.column}`);
+      }
+    }
+    return args;
+  }
+  start(filters) {
+    const ctx = this.deps.getRunContext();
+    if (ctx === null) return { ok: false, reason: "no-config" };
+    if (this.child !== null) return { ok: false, reason: "already-running" };
+    if (filters.tests !== void 0 && filters.tests.length === 0) return { ok: false, reason: "no-tests" };
+    if (this.deps.launcher.available === false) return { ok: false, reason: "docker-unavailable" };
+    const tests = rewriteContainerTestDescriptors(filters.tests, this.deps.containerPathMapping);
+    const args = this.buildPlaywrightArgs(ctx, filters, tests);
+    const spec = this.deps.launcher.launch({ ctx, playwrightArgs: args });
+    let child;
+    try {
+      child = this.deps.spawn(spec.cmd, spec.args, { cwd: ctx.cwd, env: spec.env, stdio: "inherit" });
+    } catch (err) {
+      this.cleanupTempFile();
+      throw err;
+    }
+    this.child = child;
+    child.on("exit", (code) => {
+      this.handleChildExit(code);
+    });
+    child.on("error", () => {
+      this.handleChildExit(null);
+    });
+    this.deps.setReportRunning(true);
+    this.deps.setRunFiltered?.(filters.tests !== void 0);
+    this.deps.broadcast({ type: "run-status", data: { running: true, mode: this.deps.launcher.mode } });
+    return { ok: true };
+  }
+  stop() {
+    if (this.child === null) return { ok: false, reason: "not-running" };
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.child.kill("SIGTERM");
+    this.sigkillTimer = this.deps.timers.setTimeout(() => {
+      if (this.child !== null) {
+        this.child.kill("SIGKILL");
+        this.deps.launcher.onForceKill?.();
+      }
+    }, STOP_GRACE_MS);
+    return { ok: true };
+  }
+  async prepareRun() {
+    const launcher = this.deps.launcher;
+    if (launcher.prepare === void 0) return { ok: true };
+    const ctx = this.deps.getRunContext();
+    if (ctx === null) return { ok: true };
+    try {
+      await launcher.prepare({
+        ctx,
+        onProgress: (phase) => {
+          this.deps.broadcast({ type: "run-status", data: { running: true, mode: launcher.mode, phase } });
+        }
+      });
+      return { ok: true };
+    } catch (error) {
+      this.deps.broadcast({ type: "run-status", data: { running: false, mode: launcher.mode } });
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[RunController] run preparation failed: ${message}`);
+      return { ok: false, reason: "docker-unavailable" };
+    }
+  }
+  dispose() {
+    if (this.child === null) return;
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.sigkillTimer = null;
+    this.child.kill("SIGKILL");
+    this.deps.launcher.onForceKill?.();
+    this.cleanupTempFile();
+  }
+  handleChildExit(code) {
+    if (this.child === null) return;
+    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
+    this.sigkillTimer = null;
+    this.child = null;
+    this.cleanupTempFile();
+    if (code !== null && code !== 0) console.warn(`[RunController] playwright test exited with code ${code}`);
+    this.deps.setReportRunning(false);
+    this.deps.broadcast({ type: "run-status", data: { running: false, mode: this.deps.launcher.mode } });
+    void this.deps.saveReport?.();
+  }
+};
+function createRealSpawn() {
+  return (cmd, args, opts) => {
+    const cp = spawn2(cmd, args, opts);
+    return {
+      on: (event, cb) => cp.on(event, cb),
+      kill: (signal) => {
+        const sig = KNOWN_SIGNALS[signal];
+        if (sig !== void 0) cp.kill(sig);
+      }
+    };
+  };
+}
+function createRealTimers() {
+  const pending = [];
+  return {
+    setTimeout: (fn, ms) => {
+      const id = setTimeout(fn, ms);
+      pending.push(id);
+      return id;
+    },
+    clearTimeout: () => {
+      for (const h of pending.splice(0)) clearTimeout(h);
+    }
+  };
+}
+
+// src/server/docker-launcher.ts
+var DOCKER_WORK_DIR = "/work";
+var DOCKER_HOST_GATEWAY = "host.docker.internal";
+var ENV_DENYLIST = /* @__PURE__ */ new Set([
+  "CI",
+  "PLAYWRIGHT_BROWSERS_PATH",
+  "CRVY_RPRTR_SERVER_URL",
+  "CRVY_RPRTR_PORTABLE_ARTIFACTS",
+  "TZ",
+  "LANG",
+  "LC_ALL",
+  "PLAYWRIGHT_HTML_OPEN"
+]);
+var DockerUnavailableError = class extends Error {
+  constructor() {
+    super("Docker daemon is not available");
+    this.name = "DockerUnavailableError";
+  }
+};
+function defaultWarn(message) {
+  console.warn(`[crvy-rprtr] ${message}`);
+}
+async function detectAgentName(detect2, cwd) {
+  const detected = await (detect2 ?? detectProjectAgent)(cwd);
+  return detected?.name ?? null;
+}
+async function prepareDocker(state, exec, ctx, deps, onProgress) {
+  if (!await probeDockerDaemon(exec)) {
+    state.available = false;
+    throw new DockerUnavailableError();
+  }
+  state.available = true;
+  const image = resolveDockerImage({ image: deps.docker?.image, version: deps.getPlaywrightVersion(ctx.cwd) });
+  if (image === null) {
+    throw new Error("Could not resolve the installed @playwright/test version; set docker.image explicitly.");
+  }
+  state.image = image;
+  state.command = resolveContainerCommand({
+    command: deps.docker?.command,
+    hasCustomImage: deps.docker?.image !== void 0,
+    detectedAgentName: deps.docker?.image === void 0 ? "npm" : await detectAgentName(deps.detectAgent, ctx.cwd),
+    warn: deps.warn
+  });
+  if (!await isDockerImagePresent(exec, image)) {
+    onProgress("pulling");
+    if (!await pullDockerImage(exec, image)) {
+      throw new Error(`Failed to pull docker image: ${image}`);
+    }
+  }
+}
+var REPORTER_BARE_SPECIFIER = "@crvy/rprtr";
+var PATH_FLAGS = /* @__PURE__ */ new Set(["--config", "--reporter", "--test-list"]);
+function rewritePlaywrightArgs(playwrightArgs, ctx, workDir, warn) {
+  const args = [];
+  const bindMounts = [];
+  for (let i = 0; i < playwrightArgs.length; i++) {
+    const flag = playwrightArgs[i];
+    if (!PATH_FLAGS.has(flag)) {
+      args.push(flag);
+      continue;
+    }
+    const value = playwrightArgs[i + 1];
+    if (value === void 0) break;
+    i += 1;
+    args.push(flag);
+    const rewritten = rewriteContainerPath(value, { from: ctx.cwd, to: workDir });
+    if (flag === "--reporter" && rewritten === value) {
+      args.push(REPORTER_BARE_SPECIFIER);
+    } else if (flag === "--test-list" && rewritten === value) {
+      args.push(value);
+      bindMounts.push(`${value}:${value}:ro`);
+    } else {
+      if (flag === "--config" && rewritten === value) {
+        warn(`--config "${value}" is outside the project directory and will not resolve inside the container.`);
+      }
+      args.push(rewritten);
+    }
+  }
+  return { args, bindMounts };
+}
+function buildDockerRunArgs(ctx, playwrightArgs, deps) {
+  const { args: rewrittenArgs, bindMounts } = rewritePlaywrightArgs(playwrightArgs, ctx, deps.workDir, deps.warn);
+  const args = [
+    "run",
+    "--rm",
+    "--init",
+    "--name",
+    deps.containerName,
+    "--add-host",
+    `${DOCKER_HOST_GATEWAY}:host-gateway`,
+    "--ipc=host"
+  ];
+  if (deps.docker?.platform !== void 0) {
+    args.push("--platform", deps.docker.platform);
+  }
+  args.push("-v", `${ctx.cwd}:${deps.workDir}:rw`, "-w", deps.workDir);
+  for (const mount of bindMounts) {
+    args.push("-v", mount);
+  }
+  args.push("-e", `CRVY_RPRTR_SERVER_URL=ws://${DOCKER_HOST_GATEWAY}:${deps.port}`);
+  args.push("-e", "CRVY_RPRTR_PORTABLE_ARTIFACTS=1", "-e", "TZ=UTC", "-e", "LANG=C.UTF-8", "-e", "LC_ALL=C.UTF-8");
+  args.push("-e", "PLAYWRIGHT_HTML_OPEN=never");
+  for (const [key, value] of Object.entries(deps.env)) {
+    if (ENV_DENYLIST.has(key) || value === void 0) continue;
+    args.push("-e", key);
+  }
+  if (deps.docker?.extraArgs !== void 0) args.push(...deps.docker.extraArgs);
+  args.push(deps.image, ...deps.command, "playwright", ...rewrittenArgs);
+  return args;
+}
+function stripCi(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (key === "CI") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function createState(docker) {
+  return { available: void 0, prepared: null, image: null, command: docker?.command ?? DEFAULT_CONTAINER_COMMAND };
+}
+function buildLauncher(state, deps) {
+  return {
+    mode: "docker",
+    get available() {
+      return state.available;
+    },
+    prepare({ ctx, onProgress }) {
+      state.prepared ??= prepareDocker(
+        state,
+        deps.exec,
+        ctx,
+        {
+          docker: deps.docker,
+          getPlaywrightVersion: deps.getVersion,
+          detectAgent: deps.detectAgent,
+          warn: deps.warn
+        },
+        onProgress
+      ).catch((error) => {
+        state.prepared = null;
+        throw error;
+      });
+      return state.prepared;
+    },
+    launch({ ctx, playwrightArgs }) {
+      const image = state.image ?? resolveDockerImage({ image: deps.docker?.image, version: deps.getVersion(ctx.cwd) });
+      if (image === null) {
+        throw new Error("Could not resolve the docker image; run prepare() first or set docker.image.");
+      }
+      const args = buildDockerRunArgs(ctx, playwrightArgs, {
+        docker: deps.docker,
+        workDir: deps.workDir,
+        containerName: deps.containerName,
+        port: deps.port,
+        env: deps.baseEnv,
+        image,
+        command: state.command,
+        warn: deps.warn
+      });
+      return { cmd: "docker", args, env: stripCi(deps.baseEnv) };
+    },
+    onForceKill() {
+      void forceRemoveContainer(deps.exec, deps.containerName);
+    }
+  };
+}
+function createDockerLauncher(options) {
+  return buildLauncher(createState(options.docker), {
+    exec: options.exec ?? createDockerExec(),
+    workDir: options.workDir ?? DOCKER_WORK_DIR,
+    containerName: options.containerName ?? `crvy-rprtr-run-${process.pid}`,
+    baseEnv: options.env ?? process.env,
+    getVersion: options.getPlaywrightVersion ?? resolvePlaywrightVersion,
+    detectAgent: options.detectAgent,
+    warn: options.warn ?? defaultWarn,
+    docker: options.docker,
+    port: options.port
+  });
+}
+
 // src/server/handlers.ts
 import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 
 // src/server/artifact-routes.ts
 import { existsSync } from "fs";
@@ -217,7 +754,7 @@ import { realpath } from "fs/promises";
 import { dirname as dirname2, resolve as resolve2 } from "path";
 
 // src/server/utils.ts
-import { isAbsolute, relative, resolve, sep } from "path";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve, sep as sep2 } from "path";
 var LIVE_UPDATES_WEBSOCKET_PATH = "/";
 function broadcastToBrowsers(wsClients, msg) {
   const payload = JSON.stringify(msg);
@@ -231,8 +768,8 @@ function isWebSocketUpgradeRequest(req) {
 function isPathWithinRoots(target, roots) {
   const resolvedTarget = resolve(target);
   return roots.some((root) => {
-    const rel = relative(resolve(root), resolvedTarget);
-    return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+    const rel = relative2(resolve(root), resolvedTarget);
+    return rel === "" || !rel.startsWith(`..${sep2}`) && rel !== ".." && !isAbsolute2(rel);
   });
 }
 
@@ -282,11 +819,14 @@ function reporterTitlePath(test) {
   return ["", projectName, testFile ?? "", ...test.titlePath, test.title];
 }
 function resolveBaselineSnapshotPath(routing, test, retry, imageName) {
-  const testFile = test.location?.file;
+  const mapping = routing?.containerPathMapping;
+  const rawTestFile = test.location?.file;
+  const testFile = rawTestFile === void 0 || mapping === void 0 ? rawTestFile : rewriteContainerPath(rawTestFile, mapping);
   const declaration = test.results?.[retry]?.visualDeclarations?.find((candidate) => candidate.visualName === imageName);
   if (routing === void 0 || testFile === void 0 || declaration === void 0) {
     return null;
   }
+  const isContainerPath = mapping !== void 0 && testFile !== rawTestFile;
   const targets = resolveBaselineTargets({
     testFile,
     reporterTitlePath: reporterTitlePath(test),
@@ -296,7 +836,7 @@ function resolveBaselineSnapshotPath(routing, test, retry, imageName) {
       testDir: routing.playwrightTestDir ?? dirname2(testFile),
       snapshotDir: routing.playwrightSnapshotDir ?? dirname2(testFile),
       projectName: test.projectName ?? test.browser,
-      snapshotSuffix: process.platform,
+      snapshotSuffix: isContainerPath ? "linux" : process.platform,
       snapshotPathTemplate: routing.playwrightSnapshotPathTemplate,
       toHaveScreenshotPathTemplate: routing.playwrightToHaveScreenshotPathTemplate
     },
@@ -419,7 +959,19 @@ function handleSync(ctx) {
   };
   broadcastToBrowsers(ctx.wsClients, message);
 }
-function handleRegister(ctx, data) {
+function applyContainerPathMapping(rawData, mapping) {
+  return {
+    ...rawData,
+    playwrightSnapshotDir: rawData.playwrightSnapshotDir === void 0 ? void 0 : rewriteContainerPath(rawData.playwrightSnapshotDir, mapping),
+    playwrightTestDir: rawData.playwrightTestDir === void 0 ? void 0 : rewriteContainerPath(rawData.playwrightTestDir, mapping),
+    playwrightRootDir: rawData.playwrightRootDir === void 0 ? void 0 : rewriteContainerPath(rawData.playwrightRootDir, mapping),
+    configFile: rawData.configFile === void 0 ? void 0 : rewriteContainerPath(rawData.configFile, mapping),
+    cwd: rawData.cwd === void 0 ? void 0 : rewriteContainerPath(rawData.cwd, mapping)
+  };
+}
+function handleRegister(ctx, rawData) {
+  const mapping = ctx.routesContext.containerPathMapping;
+  const data = mapping === void 0 ? rawData : applyContainerPathMapping(rawData, mapping);
   const roots = [];
   if (data.playwrightSnapshotDir !== void 0 && data.playwrightSnapshotDir !== "") {
     roots.push(data.playwrightSnapshotDir);
@@ -447,18 +999,61 @@ function handleRegister(ctx, data) {
     if (data.playwrightToHaveScreenshotPathTemplate !== void 0) {
       ctx.routesContext.approvalRouting.playwrightToHaveScreenshotPathTemplate = data.playwrightToHaveScreenshotPathTemplate;
     }
-  }
-  if (data.configFile !== void 0 && data.cwd !== void 0) {
-    ctx.routesContext.runContext = { configFile: data.configFile, cwd: data.cwd };
-  }
-  console.log("[Server] Reporter registered with config:", {
-    playwrightSnapshotDir: data.playwrightSnapshotDir,
-    playwrightTestDir: data.playwrightTestDir
+  }
+  if (data.configFile !== void 0 && data.cwd !== void 0) {
+    ctx.routesContext.runContext = buildRunContext(data.configFile, data);
+  }
+  console.log("[Server] Reporter registered with config:", {
+    playwrightSnapshotDir: data.playwrightSnapshotDir,
+    playwrightTestDir: data.playwrightTestDir,
+    configFile: data.configFile,
+    cwd: data.cwd
+  });
+}
+function buildRunContext(configFile, data) {
+  const configDir = dirname3(configFile);
+  return {
+    configFile,
+    cwd: configDir,
+    rootDir: data.playwrightRootDir ?? (data.playwrightTestDir === void 0 ? configDir : resolve3(configDir, data.playwrightTestDir))
+  };
+}
+
+// src/server/run-mode.ts
+async function resolveRunMode(options) {
+  if (options.runMode === "local") return "local";
+  if (options.runMode === "docker") return "docker";
+  if (options.isCI) return "local";
+  if (await options.probeDocker()) return "docker";
+  options.warn?.(
+    "Docker daemon unavailable \u2014 running tests locally; screenshots may differ from CI. Use --run-mode local to silence this warning."
+  );
+  return "local";
+}
+
+// src/server/launcher-resolver.ts
+async function resolveRunBackend(options) {
+  const dockerExec = createDockerExec();
+  const resolvedRunMode = await resolveRunMode({
+    runMode: options.runMode ?? "auto",
+    isCI: isCI(),
+    probeDocker: () => probeDockerDaemon(dockerExec),
+    warn: (message) => {
+      console.warn(`[crvy-rprtr] ${message}`);
+    }
   });
+  const launcher = resolvedRunMode === "docker" ? createDockerLauncher({ port: options.port, docker: options.docker, exec: dockerExec }) : createLocalLauncher({ port: options.port });
+  return {
+    launcher,
+    routesContextOptions: {
+      runInfo: { mode: resolvedRunMode },
+      containerPathMapping: resolvedRunMode === "docker" ? { from: DOCKER_WORK_DIR, to: process.cwd() } : void 0
+    }
+  };
 }
 
 // src/server/playwright-config.ts
-import { join as join2 } from "path";
+import { join as join4, resolve as resolve4 } from "path";
 var CONFIG_FILES = [
   "playwright.config.ts",
   "playwright.config.mts",
@@ -470,12 +1065,15 @@ var CONFIG_FILES = [
 async function resolvePlaywrightConfig(cwd) {
   const matches = await Promise.all(
     CONFIG_FILES.map(async (file) => {
-      const candidate = join2(cwd, file);
+      const candidate = join4(cwd, file);
       return await fileExists(candidate) ? candidate : null;
     })
   );
   return matches.find((path) => path !== null) ?? null;
 }
+function resolveSeedConfigFile(option, cwd) {
+  return option === void 0 ? resolvePlaywrightConfig(cwd) : Promise.resolve(resolve4(cwd, option));
+}
 
 // src/server/report-persistence.ts
 function createDebouncedSaver(save, delayMs, setTimeoutFn = (fn, ms) => setTimeout(fn, ms), clearTimeoutFn = (handle) => {
@@ -547,14 +1145,17 @@ function createRoutesContext(reportData, staticDir, saveReport, options) {
       playwrightTestDir: options.playwrightTestDir,
       playwrightSnapshotDir: options.playwrightSnapshotDir,
       playwrightSnapshotPathTemplate: options.playwrightSnapshotPathTemplate,
-      playwrightToHaveScreenshotPathTemplate: options.playwrightToHaveScreenshotPathTemplate
+      playwrightToHaveScreenshotPathTemplate: options.playwrightToHaveScreenshotPathTemplate,
+      containerPathMapping: options.containerPathMapping
     },
-    runContext: void 0
+    runContext: void 0,
+    runInfo: options.runInfo,
+    containerPathMapping: options.containerPathMapping
   };
 }
 
 // src/server/routes.ts
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 
 // src/server/run-routes.ts
 function handleRunRoutes(pathname, method, runController, req) {
@@ -576,6 +1177,10 @@ async function handleApiRun(runController, req) {
   if (parsed === null) {
     return Response.json({ ok: false, error: "Invalid request body" }, { status: 400 });
   }
+  const preparation = await runController.prepareRun();
+  if (!preparation.ok) {
+    return Response.json({ ok: false, reason: preparation.reason }, { status: 409 });
+  }
   const result = runController.start(parsed);
   if (result.ok) return Response.json(result);
   const status = result.reason === "no-tests" ? 400 : 409;
@@ -589,7 +1194,7 @@ function handleApiStop(runController) {
 
 // src/server/routes.ts
 async function handleRoot(ctx) {
-  const html = await respondWithFile(join3(ctx.staticDir, "index.html"), "text/html");
+  const html = await respondWithFile(join5(ctx.staticDir, "index.html"), "text/html");
   return html ?? new Response("Not Found", { status: 404 });
 }
 async function handleAppCss() {
@@ -606,13 +1211,14 @@ async function handleSrcFiles(req) {
 function handleApiReport(ctx) {
   return Response.json({
     ...ctx.reportData,
-    runEnabled: ctx.runContext !== void 0
+    runEnabled: ctx.runContext !== void 0,
+    runMode: ctx.runInfo?.mode
   });
 }
 var APPROVAL_TARGET_ERROR = "Could not resolve approval target";
 function actualPathFromUrl(ctx, actualUrl) {
   if (actualUrl.startsWith("/screenshots/")) {
-    return join3(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
+    return join5(ctx.reportData.screenshotDir, actualUrl.slice("/screenshots/".length));
   }
   if (actualUrl.startsWith("/file/")) {
     return decodeURIComponent(actualUrl.slice("/file/".length));
@@ -734,7 +1340,7 @@ async function handleScreenshots(ctx, req) {
 }
 async function handleDist(ctx, req) {
   const path = new URL(req.url).pathname.slice("/dist/".length);
-  const filePath = join3(ctx.staticDir, path);
+  const filePath = join5(ctx.staticDir, path);
   const contentType = filePath.endsWith(".css") ? "text/css" : filePath.endsWith(".js") ? "application/javascript" : filePath.endsWith(".svelte") ? "text/plain" : "application/octet-stream";
   const file = await respondWithFile(filePath, contentType);
   return file ?? new Response("Not Found", { status: 404 });
@@ -779,216 +1385,56 @@ function handleHttpRequest(ctx, req, runController) {
   return Promise.resolve(new Response("Not Found", { status: 404 }));
 }
 
-// src/server/run-controller.ts
-import { spawn } from "child_process";
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { tmpdir } from "node:os";
-import { join as join4 } from "node:path";
-import { resolveCommand } from "package-manager-detector/commands";
-import { getUserAgent } from "package-manager-detector/detect";
-var STOP_GRACE_MS = 5e3;
-var KNOWN_SIGNALS = {
-  SIGTERM: "SIGTERM",
-  SIGKILL: "SIGKILL"
-};
-function resolvePlaywrightLaunch(cwd, playwrightArgs) {
-  const agent = getUserAgent();
-  const resolved = agent === null ? null : resolveCommand(agent, "execute-local", ["playwright", ...playwrightArgs]);
-  if (resolved !== null) return { cmd: resolved.command, args: resolved.args };
-  return { cmd: "npx", args: ["playwright", ...playwrightArgs] };
-}
-function descriptorLocation(d) {
-  return d.column === void 0 ? `${d.file}:${d.line}` : `${d.file}:${d.line}:${d.column}`;
-}
-function sharedProject(tests) {
-  const names = new Set(tests.map((t) => t.projectName ?? ""));
-  if (names.size === 1) {
-    const name = [...names][0];
-    return name === "" ? void 0 : name;
-  }
-  return void 0;
-}
-function gteMinor(version, major, minor) {
-  const match = /^(\d+)\.(\d+)/.exec(version.trim());
-  if (match === null) return false;
-  const maj = parseInt(match[1], 10);
-  const min = parseInt(match[2], 10);
-  if (maj !== major) return maj > major;
-  return min >= minor;
-}
-function resolvePlaywrightVersion(cwd) {
-  try {
-    const req = createRequire(join4(cwd, "package.json"));
-    const pkgPath = req.resolve("@playwright/test/package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-    return typeof pkg === "object" && pkg !== null && "version" in pkg && typeof pkg.version === "string" ? pkg.version : null;
-  } catch {
-    return null;
-  }
-}
-function buildTestListEntries(tests) {
-  return tests.map((d) => {
-    const loc = descriptorLocation(d);
-    const title = d.titlePath.join(" \u203A ");
-    const prefix = d.projectName !== void 0 && d.projectName !== "" ? `[${d.projectName}] \u203A ` : "";
-    return `${prefix}${loc} \u203A ${title}`;
+// src/server/server-factories.ts
+function createServerRunController(routesContext, wsClients, reportData, port, setRunFiltered, saveReport, launcher) {
+  return new RunController({
+    getRunContext: () => routesContext.runContext ?? null,
+    port,
+    broadcast: (message) => {
+      broadcastToBrowsers(wsClients, message);
+    },
+    setReportRunning: (running) => {
+      reportData.isRunning = running;
+    },
+    setRunFiltered,
+    containerPathMapping: routesContext.containerPathMapping,
+    saveReport,
+    spawn: createRealSpawn(),
+    timers: createRealTimers(),
+    launcher
   });
 }
-function defaultWriteTempFile(content) {
-  const path = join4(tmpdir(), `crvy-rprtr-test-list-${process.pid}-${Date.now()}.txt`);
-  writeFileSync(path, content, "utf8");
-  return path;
-}
-function defaultDeleteTempFile(path) {
-  try {
-    unlinkSync(path);
-  } catch {
-  }
-}
-function resolveReporterDefault(cwd) {
-  try {
-    return createRequire(join4(cwd, "package.json")).resolve("@crvy/rprtr");
-  } catch {
-  }
-  try {
-    return createRequire(import.meta.url).resolve("@crvy/rprtr");
-  } catch {
-    return null;
-  }
-}
-function buildSpawnEnv(port) {
-  const env = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (key === "CI") continue;
-    env[key] = value;
-  }
-  env.CRVY_RPRTR_SERVER_URL = `ws://localhost:${port}`;
-  env.PLAYWRIGHT_HTML_OPEN = "never";
-  return env;
-}
-var RunController = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  child = null;
-  sigkillTimer = null;
-  testListPath = null;
-  get isRunning() {
-    return this.child !== null;
-  }
-  supportsTestList(cwd) {
-    const getVersion = this.deps.getPlaywrightVersion ?? resolvePlaywrightVersion;
-    const version = getVersion(cwd);
-    return version !== null && gteMinor(version, 1, 56);
-  }
-  cleanupTempFile() {
-    if (this.testListPath !== null) {
-      const del = this.deps.deleteTempFile ?? defaultDeleteTempFile;
-      del(this.testListPath);
-      this.testListPath = null;
-    }
-  }
-  start(filters) {
-    const ctx = this.deps.getRunContext();
-    if (ctx === null) return { ok: false, reason: "no-config" };
-    if (this.child !== null) return { ok: false, reason: "already-running" };
-    if (filters.tests !== void 0 && filters.tests.length === 0) {
-      return { ok: false, reason: "no-tests" };
-    }
-    const resolveReporter = this.deps.resolveReporter ?? resolveReporterDefault;
-    const reporterModule = resolveReporter(ctx.cwd);
-    const tests = filters.tests;
-    const useTestList = tests !== void 0 && tests.length > 1 && this.supportsTestList(ctx.cwd);
-    const args = ["test", "--config", ctx.configFile];
-    if (reporterModule !== null) args.push("--reporter", reporterModule);
-    if (useTestList && tests !== void 0) {
-      const content = buildTestListEntries(tests).join("\n");
-      const writeTemp = this.deps.writeTempFile ?? defaultWriteTempFile;
-      this.testListPath = writeTemp(content);
-      args.push("--test-list", this.testListPath);
-    } else if (tests !== void 0 && tests.length > 0) {
-      const project = sharedProject(tests);
-      if (project !== void 0) args.push("--project", project);
-      for (const d of tests) args.push(descriptorLocation(d));
-    }
-    const resolveLaunch = this.deps.resolveLaunch ?? resolvePlaywrightLaunch;
-    const { cmd, args: launchArgs } = resolveLaunch(ctx.cwd, args);
-    let child;
-    try {
-      child = this.deps.spawn(cmd, launchArgs, { cwd: ctx.cwd, env: buildSpawnEnv(this.deps.port), stdio: "inherit" });
-    } catch (err) {
-      this.cleanupTempFile();
-      throw err;
-    }
-    this.child = child;
-    child.on("exit", (code) => {
-      this.handleChildExit(code);
-    });
-    child.on("error", () => {
-      this.handleChildExit(null);
-    });
-    this.deps.setReportRunning(true);
-    this.deps.setRunFiltered?.(filters.tests !== void 0);
-    this.deps.broadcast({ type: "run-status", data: { running: true } });
-    return { ok: true };
-  }
-  stop() {
-    if (this.child === null) return { ok: false, reason: "not-running" };
-    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
-    this.child.kill("SIGTERM");
-    this.sigkillTimer = this.deps.timers.setTimeout(() => {
-      if (this.child !== null) this.child.kill("SIGKILL");
-    }, STOP_GRACE_MS);
-    return { ok: true };
-  }
-  dispose() {
-    if (this.child === null) return;
-    if (this.sigkillTimer !== null) this.deps.timers.clearTimeout(this.sigkillTimer);
-    this.sigkillTimer = null;
-    this.child.kill("SIGKILL");
-    this.cleanupTempFile();
-  }
-  handleChildExit(code) {
-    if (this.child === null) return;
-    if (this.sigkillTimer !== null) {
-      this.deps.timers.clearTimeout(this.sigkillTimer);
-      this.sigkillTimer = null;
-    }
-    this.child = null;
-    this.cleanupTempFile();
-    if (code !== null && code !== 0) {
-      console.warn(`[RunController] playwright test exited with code ${code}`);
-    }
-    this.deps.setReportRunning(false);
-    this.deps.broadcast({ type: "run-status", data: { running: false } });
-    void this.deps.saveReport?.();
-  }
-};
-function createRealSpawn() {
-  return (cmd, args, opts) => {
-    const cp = spawn(cmd, args, opts);
-    return {
-      on: (event, cb) => cp.on(event, cb),
-      kill: (signal) => {
-        const sig = KNOWN_SIGNALS[signal];
-        if (sig !== void 0) cp.kill(sig);
-      }
-    };
+function createCloseHandler(persistence, runController) {
+  return async () => {
+    await persistence.dispose();
+    runController.dispose();
   };
 }
-function createRealTimers() {
-  const pending = [];
-  return {
-    setTimeout: (fn, ms) => {
-      const id = setTimeout(fn, ms);
-      pending.push(id);
-      return id;
+function createRunControllerAndHandlers(routesContext, wsClients, reportData, currentRunIds, port, persistence, launcher) {
+  let isFilteredRun = false;
+  const runController = createServerRunController(
+    routesContext,
+    wsClients,
+    reportData,
+    port,
+    (filtered) => {
+      isFilteredRun = filtered;
     },
-    clearTimeout: () => {
-      for (const h of pending.splice(0)) clearTimeout(h);
-    }
-  };
+    persistence.saveReport,
+    launcher
+  );
+  const getHandlerContext = () => ({
+    reportData,
+    wsClients,
+    currentRunIds,
+    isFilteredRun,
+    saveReport: persistence.saveReport,
+    scheduleReportSave: persistence.scheduleReportSave,
+    approvalRouting: routesContext.approvalRouting,
+    routesContext,
+    runController
+  });
+  return { runController, getHandlerContext };
 }
 
 // src/server/app.ts
@@ -1080,19 +1526,19 @@ function createWebSocketMessageHandler(getHandlerContext) {
   };
 }
 async function resolveStaticDir(staticDir) {
-  const currentDir = dirname3(fileURLToPath(import.meta.url));
+  const currentDir = dirname4(fileURLToPath(import.meta.url));
   const candidates = staticDir === void 0 ? [
     currentDir,
-    join5(currentDir, "dist"),
-    join5(currentDir, "..", "dist"),
-    join5(currentDir, "..", "..", "dist"),
-    join5(currentDir, ".."),
-    join5(currentDir, "..", "..")
-  ] : [staticDir, join5(staticDir, "dist")];
+    join6(currentDir, "dist"),
+    join6(currentDir, "..", "dist"),
+    join6(currentDir, "..", "..", "dist"),
+    join6(currentDir, ".."),
+    join6(currentDir, "..", "..")
+  ] : [staticDir, join6(staticDir, "dist")];
   const resolvedCandidates = await Promise.all(
     candidates.map(async (candidate) => ({
       candidate,
-      exists: await fileExists(join5(candidate, "index.html"))
+      exists: await fileExists(join6(candidate, "index.html"))
     }))
   );
   const resolved = resolvedCandidates.find(({ exists }) => exists);
@@ -1103,34 +1549,31 @@ async function resolveStaticDir(staticDir) {
 }
 async function resolveReportPath(reportPath) {
   if (await isDirectory(reportPath)) {
-    return { reportFile: join5(reportPath, "report.json"), offlineReportDir: reportPath };
+    return { reportFile: join6(reportPath, "report.json"), offlineReportDir: reportPath };
   }
-  return { reportFile: reportPath, offlineReportDir: dirname3(reportPath) };
+  return { reportFile: reportPath, offlineReportDir: dirname4(reportPath) };
 }
 async function seedRunContext(routesContext, options) {
   if (routesContext.runContext !== void 0) {
     return;
   }
-  const configFile = options.playwrightConfig ?? await resolvePlaywrightConfig(process.cwd());
+  const configFile = await resolveSeedConfigFile(options.playwrightConfig, process.cwd());
   if (configFile !== null) {
     routesContext.runContext = { configFile, cwd: process.cwd() };
   }
 }
-function createServerRunController(routesContext, wsClients, reportData, port, setRunFiltered, saveReport) {
-  return new RunController({
-    getRunContext: () => routesContext.runContext ?? null,
-    port,
-    broadcast: (message) => {
-      broadcastToBrowsers(wsClients, message);
-    },
-    setReportRunning: (running) => {
-      reportData.isRunning = running;
-    },
-    setRunFiltered,
-    saveReport,
-    spawn: createRealSpawn(),
-    timers: createRealTimers()
+async function setupRoutesContext(options, reportData, staticDir, saveReport, port) {
+  const { launcher, routesContextOptions } = await resolveRunBackend({
+    runMode: options.runMode,
+    docker: options.docker,
+    port
+  });
+  const routesContext = createRoutesContext(reportData, staticDir, saveReport, {
+    ...options,
+    ...routesContextOptions
   });
+  await seedRunContext(routesContext, options);
+  return { routesContext, launcher };
 }
 async function createServerApp(options = {}) {
   const port = options.port ?? 3e3;
@@ -1141,30 +1584,22 @@ async function createServerApp(options = {}) {
   const wsClients = /* @__PURE__ */ new Set();
   const currentRunIds = /* @__PURE__ */ new Set();
   const persistence = createReportPersistence(reportFile, reportData);
-  const routesContext = createRoutesContext(reportData, staticDir, persistence.saveReport, options);
-  await seedRunContext(routesContext, options);
-  let isFilteredRun = false;
-  const runController = createServerRunController(
+  const { routesContext, launcher } = await setupRoutesContext(
+    options,
+    reportData,
+    staticDir,
+    persistence.saveReport,
+    port
+  );
+  const { runController, getHandlerContext } = createRunControllerAndHandlers(
     routesContext,
     wsClients,
     reportData,
+    currentRunIds,
     port,
-    (filtered) => {
-      isFilteredRun = filtered;
-    },
-    persistence.saveReport
+    persistence,
+    launcher
   );
-  const getHandlerContext = () => ({
-    reportData,
-    wsClients,
-    currentRunIds,
-    isFilteredRun,
-    saveReport: persistence.saveReport,
-    scheduleReportSave: persistence.scheduleReportSave,
-    approvalRouting: routesContext.approvalRouting,
-    routesContext,
-    runController
-  });
   const handleRequest = (req) => handleHttpRequest(routesContext, req, runController);
   const handleWebSocketMessage = createWebSocketMessageHandler(getHandlerContext);
   await loadReport(reportFile, reportData);
@@ -1177,12 +1612,6 @@ async function createServerApp(options = {}) {
     handleWebSocketMessage
   };
 }
-function createCloseHandler(persistence, runController) {
-  return async () => {
-    await persistence.dispose();
-    runController.dispose();
-  };
-}
 
 // src/server/bun-adapter.ts
 function logWebSocketError(prefix, error) {
@@ -1359,7 +1788,7 @@ function attachWebSocketServer(server, app) {
   });
 }
 async function listen(server, port) {
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve5, reject) => {
     const onError = (error) => {
       server.off("error", onError);
       reject(error);
@@ -1367,7 +1796,7 @@ async function listen(server, port) {
     server.on("error", onError);
     server.listen(port, () => {
       server.off("error", onError);
-      resolve3();
+      resolve5();
     });
   });
 }