@lenne.tech/cli 1.26.0 → 1.27.0

package/build/lib/dev-patches.js

@@ -165,6 +165,16 @@ function patchNuxtConfig(file) {
  *      bracketed by `// >>> lt-dev:bridge >>>` markers.
  *   2. Hardcoded baseURL/host/url for `http://localhost:3001` →
  *      `process.env.NUXT_PUBLIC_SITE_URL || 'http://localhost:3001'`.
+ *   3. `webServer` wrapped in an `LT_DEV_ACTIVE` guard so Playwright reuses
+ *      the App already served by `lt dev` / `lt dev test` instead of spawning
+ *      its own (which would bind the wrong port and miss the isolated stack).
+ *   4. `ignoreHTTPSErrors: true` so Playwright's Chromium accepts the lt dev
+ *      Caddy self-signed cert (required for `lt dev test` over HTTPS).
+ *   5. Shard-aware timeouts gated on `LT_DEV_TEST_SHARDS` — a `SHARDED` const
+ *      plus relaxed `timeout` / `expect` / `navigationTimeout` / `actionTimeout`
+ *      under sharded load only, so serial + CI keep their tight, fast-failing
+ *      defaults. Each sub-patch is a graceful no-op on a non-standard config.
+ *   6. `slowMo: 10` → `0` (pointless per-action delay, multiplied across shards).
  */
 function patchPlaywrightConfig(file) {
     if (!(0, fs_1.existsSync)(file))
@@ -225,6 +235,67 @@ function patchPlaywrightConfig(file) {
             count++;
         }
     }
+    // 3. Wrap `webServer` in an `LT_DEV_ACTIVE` guard so Playwright does NOT
+    //    start/manage its own server when the App is already served by
+    //    `lt dev` / `lt dev test` (both export LT_DEV_ACTIVE + the App URL).
+    //    The original array/object's closing `]`/`}` becomes the ternary's
+    //    false branch, so no bracket-matching is needed. Idempotent.
+    if (!/webServer:\s*process\.env\.LT_DEV_ACTIVE/.test(after)) {
+        after = after.replace(/webServer:\s*([[{])/, (_match, open) => {
+            count++;
+            return `webServer: process.env.LT_DEV_ACTIVE ? undefined : ${open}`;
+        });
+    }
+    // 4. ignoreHTTPSErrors — accept the `lt dev` Caddy self-signed cert on
+    //    `https://*.localhost` (Playwright's bundled Chromium uses its own trust
+    //    store, so NODE_EXTRA_CA_CERTS alone is not enough). No-op in CI (http).
+    //    Without this, `lt dev test` fails with ERR_CERT_AUTHORITY_INVALID.
+    if (!/ignoreHTTPSErrors/.test(after)) {
+        after = after.replace(/(\n(\s*)use:\s*\{)/, (_m, whole, indent) => {
+            count++;
+            return `${whole}\n${indent}  ignoreHTTPSErrors: true,`;
+        });
+    }
+    // 5. Shard-aware timeouts — `lt dev test --shard N` runs N built stacks +
+    //    N Chromium concurrently; the CPU saturates and SSR slows 2-3x. Relax
+    //    timeouts ONLY under that load (the CLI exports LT_DEV_TEST_SHARDS), so
+    //    serial + CI keep their tight values and fast-failure feedback. Each
+    //    sub-patch is idempotent + a graceful no-op on non-standard configs.
+    if (!/const SHARDED\b/.test(after) && /export default defineConfig/.test(after)) {
+        const shardConst = '// `lt dev test --shard N` saturates the CPU (N built SSR servers + N Chromium),\n' +
+            '// slowing every navigation. Relax timeouts ONLY under that load — the CLI sets\n' +
+            "// LT_DEV_TEST_SHARDS — so serial + CI keep their tight, fast-failing defaults.\n" +
+            "const SHARDED = Number(process.env.LT_DEV_TEST_SHARDS || '0') > 1;\n\n";
+        after = after.replace(/(export default defineConfig)/, `${shardConst}$1`);
+        count++;
+    }
+    // 5a. per-test timeout (`isWindows ? A : B` form) → add the sharded branch.
+    if (/timeout:\s*isWindows\s*\?/.test(after) && !/timeout:\s*isWindows\s*\?[^,\n]*SHARDED/.test(after)) {
+        after = after.replace(/timeout:\s*isWindows\s*\?\s*([0-9_]+)\s*:\s*([0-9_]+|undefined)/, (_m, a, b) => {
+            count++;
+            return `timeout: isWindows ? ${a} : SHARDED ? 180_000 : ${b}`;
+        });
+    }
+    // 5b. expect.timeout (only when an `expect: { timeout: N }` already exists).
+    if (/expect:\s*\{\s*timeout:\s*[0-9_]+\s*\}/.test(after) && !/expect:\s*\{\s*timeout:\s*SHARDED/.test(after)) {
+        after = after.replace(/expect:\s*\{\s*timeout:\s*([0-9_]+)\s*\}/, (_m, t) => {
+            count++;
+            return `expect: { timeout: SHARDED ? 30_000 : ${t} }`;
+        });
+    }
+    // 5c. navigation/action ceilings under shard (inject into `use` if absent).
+    if (!/navigationTimeout/.test(after)) {
+        after = after.replace(/(\n(\s*)use:\s*\{)/, (_m, whole, indent) => {
+            count++;
+            return `${whole}\n${indent}  actionTimeout: SHARDED ? 30_000 : undefined,\n${indent}  navigationTimeout: SHARDED ? 60_000 : undefined,`;
+        });
+    }
+    // 6. slowMo: 10 → 0 — an artificial per-action delay, pointless and multiplied
+    //    across N concurrent sharded browsers.
+    after = after.replace(/slowMo:\s*10\b/, () => {
+        count++;
+        return 'slowMo: 0';
+    });
     if (count === 0)
         return { file, patched: false, replacements: 0 };
     (0, fs_1.writeFileSync)(file, after, 'utf8');

package/build/lib/dev-process.js

@@ -13,7 +13,11 @@ exports.checkPortInUse = checkPortInUse;
 exports.killProcessGroup = killProcessGroup;
 exports.listenSnapshot = listenSnapshot;
 exports.rotateLogFile = rotateLogFile;
+exports.runChildInherit = runChildInherit;
+exports.runChildToFile = runChildToFile;
 exports.spawnDetached = spawnDetached;
+exports.terminateProcessGroup = terminateProcessGroup;
+exports.waitForHttp = waitForHttp;
 /**
  * Process + port helpers for `lt dev`.
  *
@@ -145,6 +149,60 @@ function rotateLogFile(logFile) {
     }
     return { archivePath, previousSize, rotated: true };
 }
+/**
+ * Run a child to completion with inherited stdio. Resolves with the exit code.
+ *
+ * Counterpart of `spawnDetached`: foreground, synchronous-feeling, used for
+ * commands the user must see live output from (build, test runners).
+ * Errors during spawn resolve as exit code `1` so callers can branch on a
+ * single integer instead of try/catch.
+ */
+function runChildInherit(cmd, args, opts) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: 'inherit' });
+        child.on('error', () => resolve(1));
+        child.on('close', (code) => resolve(code));
+    });
+}
+/**
+ * Run a child to completion with stdout+stderr redirected to a log file.
+ * Resolves with the exit code (`1` on spawn error). Like `runChildInherit` but
+ * non-interleaving — used to run several children CONCURRENTLY (e.g. parallel
+ * Playwright shards) without their console output clobbering each other.
+ */
+function runChildToFile(cmd, args, opts) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(opts.logFile), { recursive: true });
+    // Rotate so each run starts with a fresh log (one prior generation kept as
+    // `<logFile>.1`) instead of appending run-on-run.
+    rotateLogFile(opts.logFile);
+    const out = (0, fs_1.openSync)(opts.logFile, 'a');
+    const close = () => {
+        try {
+            (0, fs_1.closeSync)(out);
+        }
+        catch (_a) {
+            /* already closed */
+        }
+    };
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: ['ignore', out, out] });
+        }
+        catch (_a) {
+            close();
+            return resolve(1);
+        }
+        child.on('error', () => {
+            close();
+            resolve(1);
+        });
+        child.on('close', (code) => {
+            close();
+            resolve(code);
+        });
+    });
+}
 /**
  * Spawn a detached child whose stdio is redirected to a log file.
  *
@@ -188,3 +246,99 @@ function spawnDetached(cmd, args, opts) {
         }
     }
 }
+/**
+ * Terminate a detached process group RELIABLY: SIGTERM the group, wait up to
+ * `graceMs` for it to exit, then SIGKILL anything still alive.
+ *
+ * Needed because a compiled NestJS API (`node dist`) installs shutdown hooks
+ * that catch SIGTERM and can hang on open Mongo connections — a single
+ * SIGTERM then "succeeds" (the call returns) while the process keeps
+ * listening on its port and holding DB connections. `lt dev test`'s
+ * residue-free teardown promise depends on the process actually being gone,
+ * so we escalate to SIGKILL after a grace period.
+ *
+ * Polls every 150ms so a process that exits cleanly returns near-instantly
+ * (only a hung process waits the full `graceMs`). Returns true if the process
+ * is gone by the end, false if it somehow survived even SIGKILL.
+ */
+function terminateProcessGroup(pid_1) {
+    return __awaiter(this, arguments, void 0, function* (pid, graceMs = 4000) {
+        if (!(0, dev_state_1.isValidPid)(pid))
+            return false;
+        if (!(0, dev_state_1.isPidAlive)(pid))
+            return true;
+        // Phase 1 — graceful: SIGTERM the group (single-PID fallback inside).
+        killProcessGroup(pid);
+        const deadline = Date.now() + Math.max(0, graceMs);
+        while (Date.now() < deadline) {
+            if (!(0, dev_state_1.isPidAlive)(pid))
+                return true;
+            yield delay(150);
+        }
+        // Phase 2 — forced: SIGKILL the group, then the single PID.
+        if (!(0, dev_state_1.isPidAlive)(pid))
+            return true;
+        try {
+            process.kill(-pid, 'SIGKILL');
+        }
+        catch (_a) {
+            /* group already gone or pid is not a group leader */
+        }
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch (_b) {
+            /* already dead */
+        }
+        yield delay(150);
+        return !(0, dev_state_1.isPidAlive)(pid);
+    });
+}
+/**
+ * Poll an HTTPS/HTTP URL until a matching response is observed or `timeoutMs`
+ * elapses.
+ *
+ * Used to wait for dev servers to become reachable before the next step
+ * (typically running a test suite). By default treats ANY HTTP status (1xx-5xx)
+ * as "up" — a 404 means the server is bound and answering, which is usually
+ * what we want to know. Pass `ready` to require a stricter status: an API
+ * readiness probe wants a real 2xx on `/meta`, because Caddy answers 502 while
+ * its upstream is still booting and the default predicate would accept that
+ * prematurely (the cause of the test-suite API-readiness race). Uses `curl`
+ * because it is universally available and handles HTTPS-with-self-signed-cert
+ * (Caddy) via `-k` for free.
+ *
+ * Resolves `true` on the first matching response, `false` on timeout. Never rejects.
+ */
+function waitForHttp(url, timeoutMs, ready = (status) => status >= 100 && status < 600) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        const tick = () => {
+            var _a;
+            const child = (0, child_process_1.spawn)('curl', ['-sk', '-o', '/dev/null', '-w', '%{http_code}', '--max-time', '2', url], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            let status = '';
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (status += String(b)));
+            child.on('close', () => {
+                const code = Number(status.trim());
+                // `000` (curl could not connect) parses to 0 → never "ready".
+                if (Number.isFinite(code) && code > 0 && ready(code))
+                    return resolve(true);
+                if (Date.now() - start > timeoutMs)
+                    return resolve(false);
+                setTimeout(tick, 500);
+            });
+            child.on('error', () => {
+                if (Date.now() - start > timeoutMs)
+                    return resolve(false);
+                setTimeout(tick, 500);
+            });
+        };
+        tick();
+    });
+}
+/** Promise-based delay used by the graceful→forced termination escalation. */
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/build/lib/dev-project.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiNeedsPortPatch = apiNeedsPortPatch;
 exports.appNeedsPortPatch = appNeedsPortPatch;
 exports.deriveDbName = deriveDbName;
+exports.deriveTestDbName = deriveTestDbName;
 exports.resolveLayout = resolveLayout;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -33,7 +34,10 @@ function appNeedsPortPatch(appDir) {
             /target:\s*'http:\/\/localhost:3000'/.test(c) ||
             /baseURL:\s*'http:\/\/localhost:3001'/.test(c) ||
             /url:\s*'http:\/\/localhost:3001'/.test(c) ||
-            /host:\s*'http:\/\/localhost:3001'/.test(c));
+            /host:\s*'http:\/\/localhost:3001'/.test(c) ||
+            // Unguarded Playwright `webServer` (no LT_DEV_ACTIVE guard) — patch it so
+            // `lt dev test`'s isolated stack is reused instead of a stray server.
+            (/webServer:\s*[[{]/.test(c) && !/webServer:\s*process\.env\.LT_DEV_ACTIVE/.test(c)));
     });
 }
 /** Read `dbName` from the API config (defaults to `<slug>-local`). */
@@ -49,6 +53,21 @@ function deriveDbName(apiDir, slug) {
     }
     return `${slug}-local`;
 }
+/**
+ * Derive the dedicated database name for the `lt dev test` stack from the
+ * project's dev DB name. Distinct from both `<…>-local` (developer DB) and
+ * the API unit-test DB (`<…>-e2e`), so Playwright E2E never touches developer
+ * or API-test data.
+ *
+ *   svl-sports-system-local → svl-sports-system-test
+ *
+ * Uses the `-test` suffix so it passes test-helper guards that only permit
+ * local/test databases (name ending in `-local` | `-ci` | `-e2e` | `-test`).
+ */
+function deriveTestDbName(devDbName) {
+    const base = devDbName.replace(/-(local|dev)$/i, '');
+    return `${base}-test`;
+}
 /**
  * Resolve layout starting from `cwd`. Walks up to find a workspace if
  * cwd is inside `projects/api/` or `projects/app/`.

package/build/lib/dev-state.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.paths = void 0;
+exports.paths = exports.TEST_SESSION_FILE = void 0;
 exports.allocateInternalPort = allocateInternalPort;
 exports.clearSession = clearSession;
 exports.isPidAlive = isPidAlive;
@@ -28,6 +28,8 @@ const path_1 = require("path");
 const REGISTRY_PATH = process.env.LT_DEV_REGISTRY_PATH || (0, path_1.join)((0, os_1.homedir)(), '.lenneTech', 'projects.json');
 const SESSION_DIR = '.lt-dev';
 const SESSION_FILE = 'state.json';
+/** Session file for the ephemeral `lt dev test` stack (runs parallel to the dev session). */
+exports.TEST_SESSION_FILE = 'state.test.json';
 /**
  * Allocate a free internal port for a Caddy upstream.
  *
@@ -44,8 +46,8 @@ function allocateInternalPort(start, taken) {
     throw new Error(`No free internal port in range [${start}, ${start + 1000})`);
 }
 /** Remove session state file (called by `lt dev down`). */
-function clearSession(root) {
-    const file = (0, path_1.join)(root, SESSION_DIR, SESSION_FILE);
+function clearSession(root, sessionFile = SESSION_FILE) {
+    const file = (0, path_1.join)(root, SESSION_DIR, sessionFile);
     if ((0, fs_1.existsSync)(file)) {
         try {
             (0, fs_1.rmSync)(file);
@@ -87,8 +89,8 @@ function loadRegistry() {
     return { projects: {}, version: 1 };
 }
 /** Load session state for a project root. */
-function loadSession(root) {
-    const file = (0, path_1.join)(root, SESSION_DIR, SESSION_FILE);
+function loadSession(root, sessionFile = SESSION_FILE) {
+    const file = (0, path_1.join)(root, SESSION_DIR, sessionFile);
     if (!(0, fs_1.existsSync)(file))
         return null;
     try {
@@ -126,10 +128,10 @@ function saveRegistry(reg) {
     }
 }
 /** Persist session state for a project root. */
-function saveSession(root, state) {
+function saveSession(root, state, sessionFile = SESSION_FILE) {
     const dir = (0, path_1.join)(root, SESSION_DIR);
     (0, fs_1.mkdirSync)(dir, { recursive: true });
-    (0, fs_1.writeFileSync)((0, path_1.join)(dir, SESSION_FILE), JSON.stringify(state, null, 2), 'utf8');
+    (0, fs_1.writeFileSync)((0, path_1.join)(dir, sessionFile), JSON.stringify(state, null, 2), 'utf8');
 }
 /** Collect all internal ports already claimed across the registry. */
 function takenInternalPorts(reg, excludeSlug) {