@elench/testkit 0.1.57 → 0.1.59

package/lib/cli/commands/browser/serve.mjs

@@ -0,0 +1,112 @@
+import { Command, Flags } from "@oclif/core";
+import { startBrowserBridgeServer } from "@elench/testkit-bridge";
+import { loadConfigContext, resolveProductDir } from "../../../config/index.mjs";
+import { discoverTests } from "../../../discovery/index.mjs";
+import { loadCurrentRunArtifact } from "../../viewer.mjs";
+
+export default class BrowserServeCommand extends Command {
+  static summary = "Serve the local browser bridge for the current testkit product";
+
+  static enableJsonFlag = true;
+
+  static flags = {
+    dir: Flags.string({
+      description: "Product directory",
+    }),
+    host: Flags.string({
+      description: "Host to bind the browser bridge server",
+      default: "127.0.0.1",
+    }),
+    port: Flags.integer({
+      description: "Port to bind the browser bridge server",
+      default: 3847,
+    }),
+  };
+
+  async run() {
+    const { flags } = await this.parse(BrowserServeCommand);
+    const productDir = resolveProductDir(process.cwd(), flags.dir);
+
+    const adapter = {
+      loadProductContext: async () => {
+        const [configContext, discovery] = await Promise.all([
+          loadConfigContext({
+            dir: productDir,
+            discoveryOptions: { strict: false },
+          }),
+          discoverTests({
+            dir: productDir,
+            diagnostics: "report",
+          }),
+        ]);
+
+        return {
+          product: {
+            name: discovery.product.name,
+            directory: discovery.product.directory,
+          },
+          services: configContext.configs
+            .map((config) => {
+              const baseUrl = config.testkit.local?.baseUrl || null;
+              const browserOrigins = config.testkit.browser?.origins || [];
+              if (!baseUrl && browserOrigins.length === 0) return null;
+              const serviceEntries = [];
+              if (baseUrl && !baseUrl.includes("{port}")) {
+                try {
+                  const parsed = new URL(baseUrl);
+                  serviceEntries.push({
+                    name: config.name,
+                    baseUrl,
+                    origin: parsed.origin,
+                  });
+                } catch {
+                  // Ignore invalid local.baseUrl templates here; explicit browser origins still work.
+                }
+              }
+              for (const origin of browserOrigins) {
+                serviceEntries.push({
+                  name: config.name,
+                  baseUrl: origin,
+                  origin,
+                });
+              }
+              return serviceEntries;
+            })
+            .flat()
+            .filter(Boolean),
+          discovery,
+          runArtifact: loadRunArtifactIfPresent(productDir),
+        };
+      },
+    };
+
+    const serverRef = await startBrowserBridgeServer(adapter, {
+      host: flags.host,
+      port: flags.port,
+    });
+
+    const payload = {
+      ok: true,
+      productDir,
+      host: serverRef.host,
+      port: serverRef.port,
+      url: serverRef.url,
+    };
+
+    if (!this.jsonEnabled()) {
+      this.log(`testkit browser bridge serving ${productDir}`);
+      this.log(`Listening on ${serverRef.url}`);
+    }
+
+    await new Promise(() => {});
+    return payload;
+  }
+}
+
+function loadRunArtifactIfPresent(productDir) {
+  try {
+    return loadCurrentRunArtifact(productDir);
+  } catch {
+    return null;
+  }
+}

package/lib/cli/entrypoint.mjs

@@ -9,6 +9,7 @@ export function normalizeCliArgs(argv) {
     "artifacts",
     "watch",
     "discover",
+    "browser",
     "known-failures",
     "db",
     "help",
@@ -77,6 +78,9 @@ function reorderCommandArgs(args, positionals) {
   if (positionals[0]?.value === "db" && positionals[1] && positionals[2]) {
     commandTokens.push(positionals[1], positionals[2]);
   }
+  if (positionals[0]?.value === "browser" && positionals[1]) {
+    commandTokens.push(positionals[1]);
+  }
   const commandIndexes = new Set(commandTokens.map((token) => token.index));
   return [
     ...commandTokens.map((token) => token.value),

package/lib/config/discovery.mjs

@@ -1,5 +1,12 @@
 import fs from "fs";
 import path from "path";
+import {
+  DEFAULT_DISCOVERY_EXCLUDES,
+  normalizeDiscoveryConfig,
+  normalizeDiscoveryPath,
+  resolveDiscoveryRoots,
+  shouldExcludeDiscoveryPath,
+} from "../discovery/path-policy.mjs";
 
 const TESTKIT_DIRNAME = "__testkit__";
 const DISCOVERY_RULES = [
@@ -11,27 +18,10 @@ const DISCOVERY_RULES = [
   { suffix: ".pw.testkit.ts", type: "e2e", framework: "playwright" },
 ];
 
-const IGNORED_DIRS = new Set([
-  ".cache",
-  ".git",
-  ".hg",
-  ".next",
-  ".nuxt",
-  ".playwright-browsers",
-  ".svn",
-  ".testkit",
-  ".turbo",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules",
-  "playwright-report",
-  "test-results",
-]);
-
 export function discoverProject(productDir, explicitServices = {}, options = {}) {
   const strict = options.strict !== false;
-  const { suiteFiles, legacyFiles } = discoverFiles(productDir);
+  const repoDiscovery = normalizeDiscoveryConfig(options.discovery, { allowRoots: true });
+  const { suiteFiles, legacyFiles } = discoverFiles(productDir, repoDiscovery);
   const groupedByService = {};
   const services = {};
   const diagnostics = buildLegacyFileDiagnostics(legacyFiles);
@@ -41,7 +31,8 @@ export function discoverProject(productDir, explicitServices = {}, options = {})
     const rule = inferRule(filePath);
     if (!rule) continue;
 
-    const owners = inferOwners(filePath, explicitServices);
+    const owners = inferOwners(filePath, explicitServices, repoDiscovery);
+    if (owners === null) continue;
     if (owners.length === 0) {
       diagnostics.push({
         code: "unowned_test",
@@ -185,10 +176,16 @@ export function buildDiscoveryErrorFromDiagnostics(diagnostics = []) {
   return new Error(lines.join("\n"));
 }
 
-function discoverFiles(productDir) {
+function discoverFiles(productDir, repoDiscovery = {}) {
   const suiteFiles = [];
   const legacyFiles = [];
-  const queue = [productDir];
+  const exclude = [
+    ...new Set([
+      ...DEFAULT_DISCOVERY_EXCLUDES,
+      ...((repoDiscovery.exclude || []).map(normalizePath)),
+    ]),
+  ];
+  const queue = resolveDiscoveryRoots(productDir, repoDiscovery.roots, ".");
 
   while (queue.length > 0) {
     const current = queue.pop();
@@ -198,7 +195,8 @@ function discoverFiles(productDir) {
       if (entry.isSymbolicLink()) continue;
 
       if (entry.isDirectory()) {
-        if (IGNORED_DIRS.has(entry.name)) continue;
+        const relativeDirPath = normalizeDiscoveryPath(path.relative(productDir, absolutePath));
+        if (shouldExcludeDiscoveryPath(relativeDirPath, exclude)) continue;
         queue.push(absolutePath);
         continue;
       }
@@ -221,9 +219,9 @@ function discoverFiles(productDir) {
   };
 }
 
-function inferOwners(filePath, explicitServices) {
+function inferOwners(filePath, explicitServices, repoDiscovery = {}) {
   const serviceRules = Object.entries(explicitServices).flatMap(([name, config]) =>
-    buildServiceRules(name, config)
+    buildServiceRules(name, config, repoDiscovery)
   );
   if (serviceRules.length === 0) {
     return [
@@ -235,8 +233,14 @@ function inferOwners(filePath, explicitServices) {
     ];
   }
 
-  const owningRules = serviceRules.filter((rule) => ownsFile(rule, filePath));
+  const relevantRules = serviceRules.filter(
+    (rule) => rule.depth === 0 || (rule.matchPrefix && hasPrefix(filePath, rule.matchPrefix))
+  );
+  const owningRules = relevantRules.filter((rule) => ownsFile(rule, filePath));
   if (owningRules.length === 0) {
+    if (relevantRules.length > 0 && relevantRules.every((rule) => isExcludedForServiceRule(rule, filePath))) {
+      return null;
+    }
     return [];
   }
 
@@ -291,37 +295,62 @@ function disambiguateSuiteNames(suites) {
   return resolved;
 }
 
-function buildServiceRules(serviceName, serviceConfig) {
+function buildServiceRules(serviceName, serviceConfig, repoDiscovery = {}) {
   const cwd = normalizePath(serviceConfig?.local?.cwd || ".");
-  const discoveryRoots = Array.isArray(serviceConfig?.discovery?.roots)
-    ? serviceConfig.discovery.roots
-    : [cwd];
+  const serviceDiscovery = normalizeDiscoveryConfig(serviceConfig?.discovery, { allowRoots: true });
+  const discoveryRoots =
+    Array.isArray(serviceDiscovery.roots) && serviceDiscovery.roots.length > 0 ? serviceDiscovery.roots : ["."];
+  const serviceRootRelativeExcludes = (serviceDiscovery.exclude || []).map((entry) =>
+    cwd === "." ? normalizePath(entry) : normalizePath(path.posix.join(cwd, entry))
+  );
+  const exclude = [
+    ...new Set([
+      ...DEFAULT_DISCOVERY_EXCLUDES,
+      ...((repoDiscovery.exclude || []).map(normalizePath)),
+      ...serviceRootRelativeExcludes,
+    ]),
+  ];
 
   return discoveryRoots.map((root) => {
     const normalizedRoot = normalizePath(root || ".");
+    const matchPrefix =
+      cwd === "."
+        ? normalizedRoot
+        : normalizedRoot === "."
+          ? cwd
+          : normalizePath(path.posix.join(cwd, normalizedRoot));
     return {
       name: serviceName,
       source: "cwd",
       cwdPrefix: cwd === "." ? null : cwd,
-      matchPrefix: normalizedRoot === "." ? null : normalizedRoot,
-      depth: normalizedRoot === "." ? 0 : normalizedRoot.split("/").filter(Boolean).length,
+      matchPrefix: matchPrefix === "." ? null : matchPrefix,
+      depth: matchPrefix === "." ? 0 : matchPrefix.split("/").filter(Boolean).length,
+      exclude,
     };
   });
 }
 
 function ownsFile(serviceRule, filePath) {
+  if (isExcludedForServiceRule(serviceRule, filePath)) return false;
   if (serviceRule.depth === 0) return true;
   if (serviceRule.matchPrefix && hasPrefix(filePath, serviceRule.matchPrefix)) return true;
   return false;
 }
 
 function relativeToServiceRoot(serviceRule, filePath) {
+  if (serviceRule.matchPrefix && hasPrefix(filePath, serviceRule.matchPrefix)) {
+    return path.posix.relative(serviceRule.matchPrefix, filePath);
+  }
   if (serviceRule.cwdPrefix && hasPrefix(filePath, serviceRule.cwdPrefix)) {
     return path.posix.relative(serviceRule.cwdPrefix, filePath);
   }
   return filePath;
 }
 
+function isExcludedForServiceRule(serviceRule, filePath) {
+  return shouldExcludeDiscoveryPath(normalizePath(filePath), serviceRule.exclude || []);
+}
+
 function deriveSuiteRef(relativePath, suffix) {
   const parts = relativePath.split("/").filter(Boolean);
   const testkitIndex = parts.indexOf(TESTKIT_DIRNAME);

package/lib/config/discovery.test.mjs

@@ -204,10 +204,73 @@ describe("filesystem-discovery", () => {
       },
     ]);
   });
+
+  it("does not treat nested coverage source directories as generated output", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+
+    writeFile(productDir, "app/coverage/__testkit__/coverage-map.pw.testkit.ts");
+
+    const project = discoverProject(productDir, {
+      web: {
+        local: {
+          cwd: ".",
+        },
+        discovery: {
+          roots: ["app"],
+        },
+      },
+    });
+
+    expect(project.files).toEqual([
+      {
+        serviceName: "web",
+        type: "e2e",
+        framework: "playwright",
+        suiteName: "coverage",
+        suitePath: ["coverage"],
+        filePath: "app/coverage/__testkit__/coverage-map.pw.testkit.ts",
+      },
+    ]);
+  });
+
+  it("supports repo-level and service-level discovery excludes", () => {
+    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
+    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
+
+    writeFile(productDir, "coverage/__testkit__/noise/noise.pw.testkit.ts");
+    writeFile(productDir, "app/generated/__testkit__/noise/noise.pw.testkit.ts");
+    writeFile(productDir, "app/coverage/__testkit__/coverage-map.pw.testkit.ts");
+
+    const project = discoverProject(
+      productDir,
+      {
+        web: {
+          local: {
+            cwd: ".",
+          },
+          discovery: {
+            roots: ["app"],
+            exclude: ["app/generated"],
+          },
+        },
+      },
+      {
+        discovery: {
+          exclude: ["coverage"],
+        },
+      }
+    );
+
+    expect(project.files.map((entry) => entry.filePath)).toEqual([
+      "app/coverage/__testkit__/coverage-map.pw.testkit.ts",
+    ]);
+  });
+
 });
 
-function writeFile(productDir, relativePath) {
+function writeFile(productDir, relativePath, content = "export {};\n") {
   const absolutePath = path.join(productDir, relativePath);
   fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
-  fs.writeFileSync(absolutePath, "export {};\n");
+  fs.writeFileSync(absolutePath, content);
 }

package/lib/config/index.mjs

@@ -20,6 +20,10 @@ import {
   normalizeRuntimeToolchain,
   normalizeToolchainRegistry,
 } from "../toolchains/index.mjs";
+import {
+  mergeDiscoveryConfigs,
+  normalizeDiscoveryConfig,
+} from "../discovery/path-policy.mjs";
 
 const TESTKIT_K6_BIN = "TESTKIT_K6_BIN";
 const DEFAULT_LOCAL_IMAGE = "pgvector/pgvector:pg16";
@@ -38,8 +42,12 @@ export async function loadConfigContext(opts = {}) {
   const execution = normalizeRepoExecution(setup.execution);
   const reporting = normalizeReportingConfig(setup.reporting);
   const toolchains = normalizeToolchainRegistry(setup.toolchains);
+  const discoveryConfig = normalizeRepoDiscoveryConfig(setup.discovery);
   const explicitServices = setup.services || {};
-  const discovery = discoverProject(productDir, explicitServices, opts.discoveryOptions || {});
+  const discovery = discoverProject(productDir, explicitServices, {
+    ...(opts.discoveryOptions || {}),
+    discovery: discoveryConfig,
+  });
   const serviceNames = new Set([
     ...Object.keys(explicitServices),
     ...Object.keys(discovery.suitesByService),
@@ -54,6 +62,7 @@ export async function loadConfigContext(opts = {}) {
         setup,
         setupFile,
         execution,
+        discovery: discoveryConfig,
         reporting,
         toolchains,
         explicitService: explicitServices[name] || {},
@@ -69,6 +78,7 @@ export async function loadConfigContext(opts = {}) {
     setup,
     setupFile,
     execution,
+    discovery: discoveryConfig,
     reporting,
     toolchains,
     explicitServices,
@@ -132,6 +142,7 @@ function normalizeServiceConfig({
   setup,
   setupFile,
   execution,
+  discovery,
   reporting,
   toolchains,
   explicitService,
@@ -144,6 +155,11 @@ function normalizeServiceConfig({
     ...loadServiceEnv(productDir, envFiles),
     ...(explicitService.env || {}),
   };
+  const browser = normalizeBrowserServiceConfig(explicitService.browser, name);
+  const normalizedDiscovery = mergeDiscoveryConfigs(
+    discovery,
+    normalizeServiceDiscoveryConfig(explicitService.discovery, name)
+  );
   if (explicitService.migrate || explicitService.seed) {
     throw new Error(
       `Service "${name}" uses removed migrate/seed hooks. Move template lifecycle to database.template.{migrate,seed,verify}.`
@@ -183,6 +199,7 @@ function normalizeServiceConfig({
       execution,
       reporting,
       dependsOn: explicitService.dependsOn || [],
+      discovery: normalizedDiscovery,
       database,
       databaseFrom: explicitService.databaseFrom,
       envFiles,
@@ -190,11 +207,24 @@ function normalizeServiceConfig({
       serviceEnv,
       skip,
       runtime,
+      browser,
       local,
     },
   };
 }
 
+function normalizeRepoDiscoveryConfig(value) {
+  return normalizeDiscoveryConfig(value, { allowRoots: true });
+}
+
+function normalizeServiceDiscoveryConfig(value, serviceName) {
+  try {
+    return normalizeDiscoveryConfig(value, { allowRoots: true });
+  } catch (error) {
+    throw new Error(`Service "${serviceName}" has invalid discovery config: ${error.message}`);
+  }
+}
+
 function normalizeReportingConfig(value) {
   if (!value) return null;
 
@@ -702,6 +732,33 @@ function normalizeSkipReason(reason, label) {
   return normalized;
 }
 
+function normalizeBrowserServiceConfig(value, serviceName) {
+  if (!value) return undefined;
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Service "${serviceName}" browser config must be an object`);
+  }
+
+  const origins = Array.isArray(value.origins)
+    ? value.origins
+        .map((origin) => normalizeOptionalString(origin))
+        .filter(Boolean)
+    : [];
+
+  for (const origin of origins) {
+    try {
+      const parsed = new URL(origin);
+      if (!parsed.origin) {
+        throw new Error("missing origin");
+      }
+    } catch {
+      throw new Error(`Service "${serviceName}" browser.origins contains an invalid URL: ${origin}`);
+    }
+  }
+
+  if (origins.length === 0) return undefined;
+  return { origins };
+}
+
 function loadServiceEnv(productDir, envFiles) {
   const env = {};
   for (const envFile of envFiles) {