@elench/testkit 0.1.1 → 0.1.3

package/infra/fly-build.sh

@@ -29,6 +29,16 @@ if [ -f "$STATE_DIR/fly_image" ]; then
   fi
 fi
 
+# Skip if image already exists in registry (e.g. built by a previous run without state)
+if git -C "$API_DIR" diff --quiet 2>/dev/null; then
+  fly auth docker 2>/dev/null
+  if docker manifest inspect "$IMAGE" >/dev/null 2>&1; then
+    echo "Image $IMAGE already in registry — skipping build"
+    echo "$IMAGE" > "$STATE_DIR/fly_image"
+    exit 0
+  fi
+fi
+
 # Ensure the Fly app exists (registry requires it)
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 bash "$SCRIPT_DIR/fly-app-ensure.sh"

package/infra/fly-up.sh

@@ -1,7 +1,8 @@
 #!/usr/bin/env bash
 # Ensures a Fly machine is running with the correct env vars and image.
 # Reuses an existing stopped machine if available; creates a new one if not.
-# Requires: FLY_APP, FLY_REGION, FLY_IMAGE
+# Requires: FLY_APP, FLY_REGION
+# Image required only for --build or new machines (FLY_IMAGE / FLY_IMAGE_DEFAULT / .state/fly_image)
 # Optional: DB_URL_ENV_NAME (default: DATABASE_URL), FLY_PORT, FLY_ENV_FILE
 set -eo pipefail
 
@@ -15,12 +16,11 @@ FLY_REGION="${FLY_REGION:-lhr}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 bash "$SCRIPT_DIR/fly-app-ensure.sh"
 
-# Image resolution: explicit $FLY_IMAGE → .state/fly_image → $FLY_IMAGE_DEFAULT → error
+# Resolve image if available (not required yet — may not be needed for reuse)
 if [ -z "$FLY_IMAGE" ] && [ -f "$STATE_DIR/fly_image" ]; then
   FLY_IMAGE="$(cat "$STATE_DIR/fly_image")"
 fi
 FLY_IMAGE="${FLY_IMAGE:-$FLY_IMAGE_DEFAULT}"
-FLY_IMAGE="${FLY_IMAGE:?FLY_IMAGE required — run fly-build.sh first or set FLY_IMAGE}"
 
 if [ ! -f "$STATE_DIR/database_url" ]; then
   echo "ERROR: No database_url — run neon-up.sh first"
@@ -40,33 +40,56 @@ fi
 
 MACHINE_ID=""
 
-# ── Try to reuse existing machine ────────────────────────────────────────
+# ── 1. Try state file ────────────────────────────────────────────────────
 if [ -f "$STATE_DIR/fly_machine_id" ]; then
   EXISTING_ID=$(cat "$STATE_DIR/fly_machine_id")
   if fly machines status "$EXISTING_ID" --app "$FLY_APP" >/dev/null 2>&1; then
-    echo "Reusing machine $EXISTING_ID — updating config"
-
-    # Update env vars + image (handles DATABASE_URL change and code changes)
-    # shellcheck disable=SC2086
-    fly machines update "$EXISTING_ID" --app "$FLY_APP" \
-      --env "$DB_URL_ENV_NAME=$DATABASE_URL" \
-      $FLY_ENV_FLAGS \
-      --image "$FLY_IMAGE" \
-      --yes 2>&1
-
-    # Start if not already running (update may auto-restart)
-    fly machines start "$EXISTING_ID" --app "$FLY_APP" 2>/dev/null || true
-    fly machines wait "$EXISTING_ID" --app "$FLY_APP" --state started --wait-timeout 60s
-
     MACHINE_ID="$EXISTING_ID"
   else
-    echo "Stored machine $EXISTING_ID gone — creating new"
+    echo "Stored machine $EXISTING_ID gone — will discover or create"
     rm -f "$STATE_DIR/fly_machine_id"
   fi
 fi
 
-# ── Create new machine if needed ─────────────────────────────────────────
+# ── 2. Discover existing machine on the app ──────────────────────────────
+if [ -z "$MACHINE_ID" ]; then
+  DISCOVERED_ID=$(fly machines list --app "$FLY_APP" --json 2>/dev/null \
+    | jq -r '.[0].id // empty')
+  if [ -n "$DISCOVERED_ID" ]; then
+    MACHINE_ID="$DISCOVERED_ID"
+    echo "Discovered existing machine: $MACHINE_ID"
+  fi
+fi
+
+# ── 3. Update and start existing machine ─────────────────────────────────
+if [ -n "$MACHINE_ID" ]; then
+  echo "Reusing machine $MACHINE_ID — updating config"
+
+  # Build update flags: always update DATABASE_URL + target env
+  UPDATE_FLAGS="--env $DB_URL_ENV_NAME=$DATABASE_URL $FLY_ENV_FLAGS"
+
+  # Only update image if one was provided (--build was used)
+  if [ -n "$FLY_IMAGE" ]; then
+    UPDATE_FLAGS="$UPDATE_FLAGS --image $FLY_IMAGE"
+  fi
+
+  # shellcheck disable=SC2086
+  fly machines update "$MACHINE_ID" --app "$FLY_APP" \
+    $UPDATE_FLAGS \
+    --yes 2>&1
+
+  # Start if not already running (update may auto-restart)
+  fly machines start "$MACHINE_ID" --app "$FLY_APP" 2>/dev/null || true
+  fly machines wait "$MACHINE_ID" --app "$FLY_APP" --state started --wait-timeout 60s
+
+  echo "$MACHINE_ID" > "$STATE_DIR/fly_machine_id"
+fi
+
+# ── 4. Create new machine if needed ──────────────────────────────────────
 if [ -z "$MACHINE_ID" ]; then
+  # Image is required for new machines
+  FLY_IMAGE="${FLY_IMAGE:?FLY_IMAGE required — run with --build or set FLY_IMAGE}"
+
   echo "Creating Fly machine (app: $FLY_APP, region: $FLY_REGION)"
 
   # shellcheck disable=SC2086

package/infra/neon-up.sh

@@ -11,7 +11,7 @@ NEON_API="https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID"
 
 mkdir -p "$STATE_DIR"
 
-# ── Check for existing branch ────────────────────────────────────────────
+# ── 1. Check state file ──────────────────────────────────────────────────
 BRANCH_ID=""
 if [ -f "$STATE_DIR/neon_branch_id" ]; then
   STORED_ID=$(cat "$STATE_DIR/neon_branch_id")
@@ -20,12 +20,25 @@ if [ -f "$STATE_DIR/neon_branch_id" ]; then
     BRANCH_ID="$STORED_ID"
     echo "Neon branch exists: $BRANCH_ID"
   else
-    echo "Stored branch $STORED_ID gone — creating new"
+    echo "Stored branch $STORED_ID gone — will discover or create"
     rm -f "$STATE_DIR/neon_branch_id"
   fi
 fi
 
-# ── Create branch if needed ──────────────────────────────────────────────
+# ── 2. Discover existing branch by name ──────────────────────────────────
+if [ -z "$BRANCH_ID" ]; then
+  EXISTING_ID=$(curl -sf "$NEON_API/branches" \
+    -H "Authorization: Bearer $NEON_API_KEY" \
+    | jq -r --arg name "$BRANCH_NAME" '.branches[] | select(.name == $name) | .id' | head -1)
+
+  if [ -n "$EXISTING_ID" ] && [ "$EXISTING_ID" != "null" ]; then
+    BRANCH_ID="$EXISTING_ID"
+    echo "$BRANCH_ID" > "$STATE_DIR/neon_branch_id"
+    echo "Discovered existing Neon branch '$BRANCH_NAME': $BRANCH_ID"
+  fi
+fi
+
+# ── 3. Create branch if needed ───────────────────────────────────────────
 if [ -z "$BRANCH_ID" ]; then
   echo "Creating Neon branch: $BRANCH_NAME"
   RESPONSE=$(curl -sf -X POST "$NEON_API/branches" \
@@ -38,9 +51,17 @@ if [ -z "$BRANCH_ID" ]; then
 
   BRANCH_ID=$(echo "$RESPONSE" | jq -r '.branch.id')
   if [ -z "$BRANCH_ID" ] || [ "$BRANCH_ID" = "null" ]; then
-    echo "ERROR: Failed to create branch"
-    echo "$RESPONSE" | jq .
-    exit 1
+    # Create failed — may be a 409 race (another parallel service created it).
+    # Re-discover by name before giving up.
+    BRANCH_ID=$(curl -sf "$NEON_API/branches" \
+      -H "Authorization: Bearer $NEON_API_KEY" \
+      | jq -r --arg name "$BRANCH_NAME" '.branches[] | select(.name == $name) | .id' | head -1)
+
+    if [ -z "$BRANCH_ID" ] || [ "$BRANCH_ID" = "null" ]; then
+      echo "ERROR: Failed to create or discover branch '$BRANCH_NAME'"
+      exit 1
+    fi
+    echo "Branch created by another process — discovered: $BRANCH_ID"
   fi
   echo "$BRANCH_ID" > "$STATE_DIR/neon_branch_id"
 

package/lib/cli.mjs

@@ -1,30 +1,77 @@
 import { cac } from "cac";
-import { loadConfig } from "./config.mjs";
+import { loadConfigs, getServiceNames, isSiblingProduct } from "./config.mjs";
 import * as runner from "./runner.mjs";
 
+const SUITE_TYPES = new Set(["int", "integration", "e2e", "dal", "load", "all"]);
+const LIFECYCLE = new Set(["status", "destroy"]);
+const RESERVED = new Set([...SUITE_TYPES, ...LIFECYCLE]);
+
 export function run() {
   const cli = cac("testkit");
 
   cli
-    .command("<product> [type]", "Run test suites")
+    .command("[first] [second] [third]", "Run test suites (int, e2e, dal, all)")
     .option("-s, --suite <name>", "Run specific suite(s)", { default: [] })
     .option("--build", "Build image from source first", { default: false })
     .option("--dir <path>", "Explicit product directory")
-    .action(async (product, type, options) => {
-      // Handle lifecycle subcommands
-      if (type === "status") {
-        const config = loadConfig(product, options);
-        return runner.showStatus(config);
+    .action(async (first, second, third, options) => {
+      // Resolve: service filter, suite type, and --dir.
+      //
+      // From product dir:
+      //   testkit                          → all services, all types
+      //   testkit int -s health            → all services, int, health
+      //   testkit avocado_api int          → one service, int
+      //   testkit avocado_api              → one service, all types
+      //
+      // From workspace root:
+      //   testkit --dir outreach int       → all services, int
+      //   testkit --dir avocado avocado_api int  → one service, int
+      //
+      // Legacy (sibling dir as first arg):
+      //   testkit outreach int             → --dir outreach, int
+
+      let service = null;
+      let type = null;
+
+      // If first arg is a sibling dir with a manifest, treat it as --dir
+      if (first && !RESERVED.has(first) && !options.dir && isSiblingProduct(first)) {
+        options.dir = first;
+        first = second;
+        second = third;
+        third = undefined;
+      }
+
+      // Now resolve service vs type from remaining args
+      const serviceNames = new Set(getServiceNames(options.dir));
+
+      if (first && serviceNames.has(first)) {
+        service = first;
+        type = second || null;
+      } else if (first && RESERVED.has(first)) {
+        type = first;
+      } else if (first) {
+        // Unknown arg — might be a service name that doesn't exist
+        throw new Error(
+          `Unknown argument "${first}". Expected a service name (${[...serviceNames].join(", ") || "none found"}) ` +
+          `or suite type (int, e2e, dal, all).`
+        );
       }
-      if (type === "destroy") {
-        const config = loadConfig(product, options);
-        return runner.destroy(config);
+
+      const configs = loadConfigs({ dir: options.dir, service });
+
+      // Lifecycle commands
+      if (type === "status" || type === "destroy") {
+        for (const config of configs) {
+          if (configs.length > 1) console.log(`\n── ${config.name} ──`);
+          if (type === "status") runner.showStatus(config);
+          else await runner.destroy(config);
+        }
+        return;
       }
 
-      const config = loadConfig(product, options);
       const suiteType = type || "all";
       const suiteNames = Array.isArray(options.suite) ? options.suite : [options.suite].filter(Boolean);
-      await runner.run(config, suiteType, suiteNames, options);
+      await runner.runAll(configs, suiteType, suiteNames, options);
     });
 
   cli.help();

package/lib/config.mjs

@@ -25,63 +25,223 @@ export function parseDotenv(filePath) {
 }
 
 /**
- * Find the product directory and load the manifest + env.
- * Returns { productDir, manifest, stateDir }.
+ * Read the manifest and return the service names.
+ * Used by the CLI to resolve ambiguous positional args.
  */
-export function loadConfig(product, opts = {}) {
-  const cwd = opts.cwd || process.cwd();
-  const productDir = resolveProductDir(product, cwd, opts.dir);
+export function getServiceNames(cwd) {
+  const dir = cwd || process.cwd();
+  const manifestPath = path.join(dir, "runner.manifest.json");
+  if (!fs.existsSync(manifestPath)) return [];
+  const m = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  if (!isObject(m.services)) return [];
+  return Object.keys(m.services);
+}
+
+/**
+ * Load configs for all (or one) service from the manifest.
+ * Returns an array of { name, productDir, stateDir, manifest } objects.
+ *
+ * opts.service — filter to a single service name
+ * opts.dir     — explicit product directory
+ */
+export function loadConfigs(opts = {}) {
+  const cwd = process.cwd();
+  const productDir = resolveProductDir(cwd, opts.dir);
   const manifestPath = path.join(productDir, "runner.manifest.json");
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const raw = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
 
-  if (!manifest.testkit) {
-    throw new Error(`No "testkit" section in ${manifestPath}`);
+  if (!isObject(raw.services)) {
+    throw new Error(`Manifest must have a "services" object (${manifestPath})`);
   }
 
   // Load product .env into process.env (product wins on conflict)
   const dotenv = parseDotenv(path.join(productDir, ".env"));
   Object.assign(process.env, dotenv);
 
-  // Validate required infra keys
-  for (const key of ["NEON_API_KEY", "FLY_API_TOKEN"]) {
-    if (!process.env[key]) {
-      throw new Error(
-        `${key} not found. Set it in your shell environment, .envrc, or ${product}/.env`
-      );
-    }
+  if (!process.env.NEON_API_KEY) {
+    throw new Error(
+      `NEON_API_KEY not found. Set it in your shell environment, .envrc, or .env`
+    );
   }
 
-  // Validate manifest secrets are available
-  const tk = manifest.testkit;
-  for (const key of [...(tk.fly?.secrets || []), ...(tk.k6?.secrets || [])]) {
-    if (!process.env[key]) {
-      throw new Error(`Secret "${key}" (from manifest) not found in env or ${product}/.env`);
+  const entries = Object.entries(raw.services);
+
+  // Filter by service name if requested
+  const filtered = opts.service
+    ? entries.filter(([name]) => name === opts.service)
+    : entries;
+
+  if (opts.service && filtered.length === 0) {
+    const available = entries.map(([n]) => n).join(", ");
+    throw new Error(`Service "${opts.service}" not found. Available: ${available}`);
+  }
+
+  return filtered.map(([name, svc]) => {
+    validateService(name, svc, manifestPath);
+
+    // Check service secrets are available
+    const tk = svc.testkit;
+    for (const key of [...(tk.fly?.secrets || []), ...(tk.k6?.secrets || []), ...(tk.dal?.secrets || [])]) {
+      if (!process.env[key]) {
+        throw new Error(`Secret "${key}" (service "${name}") not found in env or .env`);
+      }
     }
+
+    // Each service gets its own state dir: .testkit/<service>/
+    const stateDir = entries.length === 1
+      ? path.join(productDir, ".testkit")
+      : path.join(productDir, ".testkit", name);
+
+    return {
+      name,
+      productDir,
+      stateDir,
+      manifest: { testkit: tk, suites: svc.suites },
+    };
+  });
+}
+
+/**
+ * Require FLY_API_TOKEN. Call this only when HTTP tests need Fly infrastructure.
+ */
+export function requireFlyToken(serviceName) {
+  if (!process.env.FLY_API_TOKEN) {
+    throw new Error(
+      `FLY_API_TOKEN not found. Set it in your shell environment, .envrc, or .env`
+    );
   }
+}
 
-  return { productDir, manifest, stateDir: path.join(productDir, ".testkit") };
+/**
+ * Resolve the custom k6 binary for DAL tests. Returns the absolute path.
+ */
+export function resolveDalBinary(config) {
+  const { productDir, manifest } = config;
+  const rel = manifest.testkit.dal?.k6Binary;
+  if (!rel) {
+    throw new Error("testkit.dal.k6Binary is required for DAL tests");
+  }
+  const abs = path.resolve(productDir, rel);
+  if (!fs.existsSync(abs)) {
+    throw new Error(`DAL k6 binary not found: ${abs}`);
+  }
+  return abs;
 }
 
-function resolveProductDir(product, cwd, explicitDir) {
+// ── Directory resolution ────────────────────────────────────────────────
+
+function resolveProductDir(cwd, explicitDir) {
   if (explicitDir) {
     const p = path.resolve(cwd, explicitDir);
     if (fs.existsSync(path.join(p, "runner.manifest.json"))) return p;
     throw new Error(`No runner.manifest.json in ${p}`);
   }
 
-  // Try ./bourne/runner.manifest.json (workspace root)
-  const sibling = path.join(cwd, product);
-  if (fs.existsSync(path.join(sibling, "runner.manifest.json"))) return sibling;
-
-  // Try ./runner.manifest.json (already in product dir)
-  const here = path.join(cwd, "runner.manifest.json");
-  if (fs.existsSync(here)) {
-    const m = JSON.parse(fs.readFileSync(here, "utf8"));
-    if (m.product === product) return cwd;
-  }
+  // Check cwd
+  if (fs.existsSync(path.join(cwd, "runner.manifest.json"))) return cwd;
 
   throw new Error(
-    `Could not find runner.manifest.json for "${product}". ` +
-    `Run from the workspace root or use --dir.`
+    `No runner.manifest.json in current directory. ` +
+    `Either cd into a product directory or use --dir.`
   );
 }
+
+/**
+ * Check if the given name (relative to cwd) is a sibling directory with a manifest.
+ * Used by the CLI to distinguish dir args from service/type args.
+ */
+export function isSiblingProduct(name) {
+  const candidate = path.join(process.cwd(), name);
+  return fs.existsSync(path.join(candidate, "runner.manifest.json"));
+}
+
+// ── Per-service validation ──────────────────────────────────────────────
+
+function validateService(name, svc, manifestPath) {
+  const errors = [];
+  const ctx = `service "${name}" in ${manifestPath}`;
+
+  if (!isObject(svc.testkit)) {
+    errors.push(`${ctx}: testkit is required and must be an object`);
+  } else {
+    const tk = svc.testkit;
+
+    if (!isObject(tk.neon)) {
+      errors.push(`${ctx}: testkit.neon is required`);
+    } else {
+      requireString(errors, tk.neon, `${ctx}: testkit.neon.projectId`, "projectId");
+      requireString(errors, tk.neon, `${ctx}: testkit.neon.dbName`, "dbName");
+    }
+
+    if (!isObject(tk.fly)) {
+      errors.push(`${ctx}: testkit.fly is required`);
+    } else {
+      requireString(errors, tk.fly, `${ctx}: testkit.fly.app`, "app");
+      requireString(errors, tk.fly, `${ctx}: testkit.fly.org`, "org");
+      optionalStringArray(errors, tk.fly, `${ctx}: testkit.fly.secrets`, "secrets");
+    }
+
+    if (tk.k6 !== undefined && !isObject(tk.k6)) {
+      errors.push(`${ctx}: testkit.k6 must be an object`);
+    }
+
+    if (tk.dal !== undefined) {
+      if (!isObject(tk.dal)) {
+        errors.push(`${ctx}: testkit.dal must be an object`);
+      } else if (svc.suites?.dal) {
+        requireString(errors, tk.dal, `${ctx}: testkit.dal.k6Binary`, "k6Binary");
+      }
+    }
+
+    if (svc.suites?.dal && !tk.dal) {
+      errors.push(`${ctx}: testkit.dal is required when suites.dal exists`);
+    }
+  }
+
+  if (!isObject(svc.suites)) {
+    errors.push(`${ctx}: suites is required and must be an object`);
+  } else {
+    for (const type of Object.keys(svc.suites)) {
+      const arr = svc.suites[type];
+      if (!Array.isArray(arr)) {
+        errors.push(`${ctx}: suites.${type} must be an array`);
+        continue;
+      }
+      for (let i = 0; i < arr.length; i++) {
+        const suite = arr[i];
+        const prefix = `${ctx}: suites.${type}[${i}]`;
+        requireString(errors, suite, `${prefix}.name`, "name");
+        requireNonEmptyStringArray(errors, suite, `${prefix}.files`, "files");
+      }
+    }
+  }
+
+  if (errors.length) throw new Error(errors.join("\n"));
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+function isObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+
+function requireString(errors, obj, msg, key) {
+  if (typeof obj[key] !== "string" || obj[key].length === 0) {
+    errors.push(`${msg} is required`);
+  }
+}
+
+function optionalStringArray(errors, obj, msg, key) {
+  const val = obj[key];
+  if (val === undefined) return;
+  if (!Array.isArray(val) || !val.every(v => typeof v === "string")) {
+    errors.push(`${msg} must be a string[]`);
+  }
+}
+
+function requireNonEmptyStringArray(errors, obj, msg, key) {
+  const val = obj[key];
+  if (!Array.isArray(val) || val.length === 0 || !val.every(v => typeof v === "string")) {
+    errors.push(`${msg} is required and must be a non-empty string[]`);
+  }
+}

package/lib/runner.mjs

@@ -2,6 +2,42 @@ import fs from "fs";
 import path from "path";
 import { runScript } from "./exec.mjs";
 import { execaCommand } from "execa";
+import { requireFlyToken, resolveDalBinary } from "./config.mjs";
+
+const HTTP_SUITE_TYPES = new Set(["integration", "e2e", "load"]);
+
+/**
+ * Run multiple service configs in parallel.
+ * Single service: runs directly. Multiple: Promise.allSettled.
+ */
+export async function runAll(configs, suiteType, suiteNames, opts) {
+  if (configs.length === 1) {
+    const failed = await runService(configs[0], suiteType, suiteNames, opts);
+    if (failed) process.exit(1);
+    return;
+  }
+
+  // Multiple services — run in parallel
+  const results = await Promise.allSettled(
+    configs.map(async (config) => {
+      console.log(`\n══ ${config.name} ══`);
+      return runService(config, suiteType, suiteNames, opts);
+    })
+  );
+
+  // Summarize
+  const summary = configs.map((c, i) => {
+    const r = results[i];
+    const ok = r.status === "fulfilled" && !r.value;
+    return `  ${ok ? "✓" : "✗"} ${c.name}`;
+  });
+  console.log(`\n── Summary ──\n${summary.join("\n")}`);
+
+  const anyFailed = results.some(
+    (r) => r.status === "rejected" || r.value === true
+  );
+  if (anyFailed) process.exit(1);
+}
 
 /**
  * Build the Docker image and push to Fly registry.
@@ -84,7 +120,7 @@ export async function destroy(config) {
 }
 
 /**
- * Run k6 test files with the correct env flags.
+ * Run k6 test files against the Fly machine (HTTP tests).
  */
 export async function runTests(config, files) {
   const { productDir, stateDir, manifest } = config;
@@ -108,7 +144,36 @@ export async function runTests(config, files) {
       await execaCommand(`k6 run ${envStr} ${absFile}`, { stdio: "inherit" });
     } catch (err) {
       failed = true;
-      // Continue running remaining files — report all failures, don't stop at first
+    }
+  }
+  return { failed };
+}
+
+/**
+ * Run k6 DAL test files directly against Neon (no Fly machine).
+ */
+export async function runDalTests(config, files) {
+  const { productDir, stateDir, manifest } = config;
+  const tk = manifest.testkit;
+  const k6Binary = resolveDalBinary(config);
+
+  // Read DATABASE_URL from neon state
+  const databaseUrl = fs.readFileSync(path.join(stateDir, "database_url"), "utf8").trim();
+
+  // Build -e flags
+  const envFlags = [`-e DATABASE_URL=${databaseUrl}`];
+  for (const key of tk.dal?.secrets || []) {
+    envFlags.push(`-e ${key}=${process.env[key]}`);
+  }
+  const envStr = envFlags.join(" ");
+
+  let failed = false;
+  for (const file of files) {
+    const absFile = path.join(productDir, file);
+    try {
+      await execaCommand(`${k6Binary} run ${envStr} ${absFile}`, { stdio: "inherit" });
+    } catch (err) {
+      failed = true;
     }
   }
   return { failed };
@@ -125,47 +190,70 @@ export function showStatus(config) {
   }
   for (const file of fs.readdirSync(stateDir)) {
     if (file === "fly-env.sh") continue;
-    const val = fs.readFileSync(path.join(stateDir, file), "utf8").trim();
+    const filePath = path.join(stateDir, file);
+    if (fs.statSync(filePath).isDirectory()) continue;
+    const val = fs.readFileSync(filePath, "utf8").trim();
     console.log(`  ${file}: ${val}`);
   }
 }
 
 /**
- * Main entry: build → neon → fly → k6 → stop.
+ * Run a single service: orchestrate HTTP and/or DAL test flows.
+ * Returns true if any tests failed.
  */
-export async function run(config, suiteType, suiteNames, opts) {
+async function runService(config, suiteType, suiteNames, opts) {
   const { manifest, stateDir } = config;
 
-  // Collect test files from manifest
+  // Collect test files from manifest, partitioned by flow
   const types = suiteType === "all"
     ? Object.keys(manifest.suites)
     : [suiteType === "int" ? "integration" : suiteType];
 
-  let files = [];
+  let httpFiles = [];
+  let dalFiles = [];
   for (const type of types) {
     const suites = manifest.suites[type] || [];
     for (const suite of suites) {
       if (suiteNames.length && !suiteNames.includes(suite.name)) continue;
-      files.push(...suite.files);
+      if (type === "dal") {
+        dalFiles.push(...suite.files);
+      } else {
+        httpFiles.push(...suite.files);
+      }
     }
   }
 
-  if (!files.length) {
-    throw new Error(`No test files found for type="${suiteType}" suites=${suiteNames.join(",") || "all"}`);
+  if (!httpFiles.length && !dalFiles.length) {
+    console.log(`No test files for ${config.name} type="${suiteType}" suites=${suiteNames.join(",") || "all"} — skipping`);
+    return false;
   }
 
   fs.mkdirSync(stateDir, { recursive: true });
 
-  if (opts.build) await build(config);
-  await neonUp(config);
-  await flyUp(config);
+  let failed = false;
+  let neonReady = false;
+
+  // HTTP flow: build → neon → fly → run → fly down
+  if (httpFiles.length) {
+    requireFlyToken(config.name);
+    if (opts.build) await build(config);
+    await neonUp(config);
+    neonReady = true;
+    await flyUp(config);
+    try {
+      const result = await runTests(config, httpFiles);
+      if (result?.failed) failed = true;
+    } finally {
+      await flyDown(config);
+    }
+  }
 
-  let result;
-  try {
-    result = await runTests(config, files);
-  } finally {
-    await flyDown(config);
+  // DAL flow: neon (idempotent) → run DAL tests
+  if (dalFiles.length) {
+    if (!neonReady) await neonUp(config);
+    const result = await runDalTests(config, dalFiles);
+    if (result?.failed) failed = true;
   }
 
-  if (result?.failed) process.exit(1);
+  return failed;
 }

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.1",
+  "version": "0.1.3",
+  "description": "CLI for running k6 tests against real, ephemeral infrastructure",
   "type": "module",
   "bin": {
     "testkit": "bin/testkit.mjs"