@elench/testkit 0.1.57 → 0.1.58

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.test.mjs

@@ -204,10 +204,11 @@ describe("filesystem-discovery", () => {
       },
     ]);
   });
+
 });
 
-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

@@ -144,6 +144,7 @@ function normalizeServiceConfig({
     ...loadServiceEnv(productDir, envFiles),
     ...(explicitService.env || {}),
   };
+  const browser = normalizeBrowserServiceConfig(explicitService.browser, 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}.`
@@ -190,6 +191,7 @@ function normalizeServiceConfig({
       serviceEnv,
       skip,
       runtime,
+      browser,
       local,
     },
   };
@@ -702,6 +704,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) {