@lenne.tech/cli 1.41.1 → 1.41.3

package/build/lib/dev-patches.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addToGitignore = addToGitignore;
 exports.autoPatch = autoPatch;
+exports.canonicaliseBridgeSpan = canonicaliseBridgeSpan;
 exports.patchApiConfig = patchApiConfig;
 exports.patchClaudeMd = patchClaudeMd;
 exports.patchNuxtConfig = patchNuxtConfig;
@@ -13,10 +14,33 @@ exports.patchPlaywrightConfig = patchPlaywrightConfig;
  * defaults and make it env-aware so it can be served behind Caddy
  * under `https://<slug>.localhost`.
  *
- * Each patch is a regex-based replace that matches only the legacy
- * form. Already-patched files are no-ops.
+ * Most patches are regex-based replaces that match only the legacy
+ * form; the marker-bracketed `lt-dev:bridge` block in
+ * playwright.config.ts is located by its markers instead. Already-patched
+ * files are no-ops — including when the consumer's own formatter has since
+ * restyled an injected block: that block is compared SEMANTICALLY (see
+ * `BRIDGE_VERSION` / `normaliseBridgeBlock`), not byte-for-byte.
  */
 const fs_1 = require("fs");
+/**
+ * Version of the `lt-dev:bridge` block emitted into a consumer's
+ * `playwright.config.ts`. It travels IN the markers
+ * (`// >>> lt-dev:bridge v2 >>>`), which is what makes a genuine upgrade
+ * detectable independently of formatting.
+ *
+ * **Bump this on every change to `bridgeBlock`** — including a
+ * formatting-only one. The content comparison deliberately ignores quote
+ * style and whitespace (the consumer's formatter owns that file), so
+ * without a bump a cosmetic fix would never reach already-patched
+ * projects. That is exactly what happened to 1.32.1's `"utf8"` → `'utf8'`
+ * fix, which is why the version exists.
+ */
+const BRIDGE_VERSION = 2;
+/** Matches any bridge marker, versioned or not — v1 shipped without one. */
+const BRIDGE_START_RE = /\/\/ >>> lt-dev:bridge(?: v(\d+))? >>>/;
+const BRIDGE_END_RE = /\/\/ <<< lt-dev:bridge(?: v(\d+))? <<</;
+/** Imports the bridge block owns; a stray copy outside it must be dropped. */
+const BRIDGE_IMPORT_RE = /^\s*import \{[^}]*__ltDev(?:Exists|Read|Dirname|Resolve)[^}]*\} from '[^']*';?\s*$/gm;
 /** Append entry to .gitignore if not already present. */
 function addToGitignore(root, entry) {
     const path = `${root}/.gitignore`;
@@ -40,6 +64,29 @@ function autoPatch(file) {
         return patchPlaywrightConfig(file);
     return { file, patched: false, replacements: 0 };
 }
+/**
+ * Replace the `lt-dev:bridge` span inside a whole file with its canonical
+ * comparison form, leaving every other byte untouched.
+ *
+ * For callers that must decide "is this file exactly what `autoPatch` would
+ * produce, or did a developer edit it?" — most importantly
+ * `dev-ticket.ts#isPristineLtDevPatch`, which gates whether `lt ticket stop`
+ * may discard a dirty config. Since the patcher deliberately tolerates the
+ * consumer formatter restyling the block, such a comparison MUST tolerate it
+ * too; otherwise a formatter-touched config reads as real developer work and
+ * the worktree removal is refused.
+ *
+ * Everything outside the markers stays byte-exact on purpose — being lenient
+ * there could let genuine work be silently discarded.
+ */
+function canonicaliseBridgeSpan(content) {
+    const start = BRIDGE_START_RE.exec(content);
+    const end = BRIDGE_END_RE.exec(content);
+    if (!start || !end || end.index <= start.index)
+        return content;
+    const endsAt = end.index + end[0].length;
+    return (content.slice(0, start.index) + normaliseBridgeBlock(content.slice(start.index, endsAt)) + content.slice(endsAt));
+}
 /**
  * API: make the server listen port honour `process.env.PORT` (injected by
  * `lt dev up` for its Caddy upstream). Handles two patterns found in
@@ -164,8 +211,12 @@ function patchNuxtConfig(file) {
  * any env.
  *
  * Patches applied (each idempotent):
- *   1. Top-of-file: `if (existsSync('.lt-dev/.env')) loadEnv(...)` block,
- *      bracketed by `// >>> lt-dev:bridge >>>` markers.
+ *   1. Top-of-file: a dotenv loader that searches UP from cwd for
+ *      `.lt-dev/.env`, bracketed by `// >>> lt-dev:bridge vN >>>` markers.
+ *      Re-injected when the marker's version differs from `BRIDGE_VERSION`
+ *      (a genuine upgrade) or when the block's CODE differs semantically
+ *      (tampering / corruption) — but NOT when the consumer's formatter
+ *      merely restyled it, which owns this file and must stay free to.
  *   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
@@ -180,6 +231,7 @@ function patchNuxtConfig(file) {
  *   6. `slowMo: 10` → `0` (pointless per-action delay, multiplied across shards).
  */
 function patchPlaywrightConfig(file) {
+    var _a;
     if (!(0, fs_1.existsSync)(file))
         return { file, patched: false, replacements: 0 };
     const before = (0, fs_1.readFileSync)(file, 'utf8');
@@ -198,8 +250,8 @@ function patchPlaywrightConfig(file) {
     //    a direct `playwright test` run) usually sit in `projects/app`. The
     //    original cwd-only resolve missed it, so direct runs fell back to
     //    `localhost:3001` and could collide with a parallel project.
-    const bridgeStart = '// >>> lt-dev:bridge >>>';
-    const bridgeEnd = '// <<< lt-dev:bridge <<<';
+    const bridgeStart = `// >>> lt-dev:bridge v${BRIDGE_VERSION} >>>`;
+    const bridgeEnd = `// <<< lt-dev:bridge v${BRIDGE_VERSION} <<<`;
     const bridgeBlock = [
         bridgeStart,
         '// Auto-load <root>/.lt-dev/.env when `lt dev up` is active so',
@@ -228,16 +280,47 @@ function patchPlaywrightConfig(file) {
         '}',
         bridgeEnd,
     ].join('\n');
-    const bridgeStartIdx = after.indexOf(bridgeStart);
-    const bridgeEndIdx = after.indexOf(bridgeEnd);
-    if (bridgeStartIdx === -1) {
+    // Locate ANY bridge marker, versioned or not — v1 shipped unversioned and
+    // must still be recognised (and upgraded) rather than double-injected.
+    const startMatch = BRIDGE_START_RE.exec(after);
+    const endMatch = BRIDGE_END_RE.exec(after);
+    const bridgeStartIdx = startMatch ? startMatch.index : -1;
+    const bridgeEndIdx = endMatch ? endMatch.index : -1;
+    // A start marker without a well-ordered end marker is a corrupted block: the
+    // slice arithmetic below would duplicate everything between the two (and the
+    // user's code with it). `patchClaudeMd` already guards its span this way.
+    const spanIsSane = bridgeStartIdx !== -1 && bridgeEndIdx > bridgeStartIdx;
+    if (bridgeStartIdx === -1 || !spanIsSane) {
+        // Markers present but unusable (e.g. reversed). Strip the STRAY MARKERS
+        // ONLY — never the text between them: with the markers out of order that
+        // text is the user's own code, not our block, so slicing the span out
+        // would delete their work (and slicing it in would duplicate it).
+        if (!spanIsSane)
+            after = after.replace(BRIDGE_START_RE, '').replace(BRIDGE_END_RE, '');
+        // A formatter with organize-imports may have hoisted the block's imports
+        // out of the markers; leaving them behind would duplicate the `__ltDev*`
+        // bindings and break the consumer's config with a duplicate-identifier
+        // error. They are ours to own, so it is safe to drop them.
+        after = after.replace(BRIDGE_IMPORT_RE, '').replace(/^\n+/, '');
         after = `${bridgeBlock}\n${after}`;
         count++;
     }
-    else if (bridgeEndIdx !== -1) {
-        const rebuilt = after.slice(0, bridgeStartIdx) + bridgeBlock + after.slice(bridgeEndIdx + bridgeEnd.length);
-        if (rebuilt !== after) {
-            after = rebuilt;
+    else {
+        const existing = after.slice(bridgeStartIdx, bridgeEndIdx + endMatch[0].length);
+        // Two independent reasons to re-inject:
+        //  (a) VERSION — the marker carries the block's version, so a genuine
+        //      upgrade is detected regardless of how the consumer formatted it.
+        //      This is what keeps formatting-only fixes shippable (see
+        //      BRIDGE_VERSION); an unversioned v1 marker yields `undefined` here.
+        //  (b) CODE — the block's code differs semantically, i.e. it was tampered
+        //      with or corrupted. Cosmetic reformatting by the consumer's own
+        //      formatter is deliberately NOT a reason: rewriting it back on every
+        //      run is what used to leave playwright.config.ts permanently dirty in
+        //      the working tree, with formatter and patcher flipping it forever.
+        const existingVersion = Number((_a = startMatch[1]) !== null && _a !== void 0 ? _a : 0);
+        if (existingVersion !== BRIDGE_VERSION || normaliseBridgeBlock(existing) !== normaliseBridgeBlock(bridgeBlock)) {
+            const head = after.slice(0, bridgeStartIdx).replace(BRIDGE_IMPORT_RE, '');
+            after = head + bridgeBlock + after.slice(bridgeEndIdx + endMatch[0].length);
             count++;
         }
     }
@@ -307,3 +390,30 @@ function patchPlaywrightConfig(file) {
     (0, fs_1.writeFileSync)(file, after, 'utf8');
     return { file, patched: true, replacements: count };
 }
+/**
+ * Canonical form of a bridge block for comparison purposes.
+ *
+ * Compares only the CODE: comment lines are dropped entirely, so rewording
+ * a comment never triggers a rewrite — and, crucially, code that a reflow
+ * folded behind a `//` VANISHES from the comparison and is therefore
+ * detected as changed. A plain `\s+ → ' '` collapse would erase newlines
+ * instead, which makes a fully commented-out (inert) loader normalise
+ * identically to a live one: the block would silently never load
+ * `.lt-dev/.env` again and Playwright would fall back to `localhost:3001`.
+ *
+ * Quote style and intra-line whitespace are normalised away because the
+ * consumer's formatter owns this file (which direction it flips is
+ * project-specific — do not assume). Blind spot to keep in mind: a change
+ * that differs ONLY in quotes or whitespace is invisible here, which is
+ * what `BRIDGE_VERSION` is for.
+ */
+function normaliseBridgeBlock(s) {
+    return s
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l !== '' && !l.startsWith('//'))
+        .join(' ')
+        .replace(/['"]/g, '"')
+        .replace(/\s+/g, ' ')
+        .trim();
+}

package/build/lib/dev-test-session.js

@@ -13,9 +13,11 @@ exports.TEST_INITIAL_ADMIN_ENV = void 0;
 exports.ensurePlaywrightBrowsers = ensurePlaywrightBrowsers;
 exports.autoShardCount = autoShardCount;
 exports.bringUpTestSession = bringUpTestSession;
+exports.buildShardPlaywrightInvocation = buildShardPlaywrightInvocation;
 exports.hasTestSession = hasTestSession;
 exports.resolveTestSession = resolveTestSession;
 exports.runShardedTestSession = runShardedTestSession;
+exports.shardReportDir = shardReportDir;
 exports.tearDownAllTestSessions = tearDownAllTestSessions;
 exports.tearDownTestSession = tearDownTestSession;
 /**
@@ -341,6 +343,45 @@ function bringUpTestSession(layout_1, baseIdentity_1, log_1) {
         return { apiLogPath, apiUrl, appEnv: devEnv.app.env, appUrl, dbName, pids, testIdentity };
     });
 }
+/**
+ * Build the Playwright CLI argv + per-shard env overrides for ONE shard of a
+ * `lt dev test --shard` run.
+ *
+ * DEV-2676 — reporter handling: this path must NOT pass `--reporter`. A CLI
+ * `--reporter` REPLACES the project's whole `reporter` list from
+ * playwright.config.ts (Playwright resolves CLI-over-config, it never appends —
+ * `Runner._parseConfig` in playwright's `lib/runner/index.js` does
+ * `result.reporter = [...configOverrides.reporter]`), silently dropping any
+ * release gate a project wires in AS a reporter. SVL's DEV-2098 gate (`./tests/no-skips.reporter.ts`)
+ * turns a run RED when a spec was skipped; the old `--reporter=line` here
+ * clobbered it, so a skipped test passed with exit 0 under `--shard` — the exact
+ * hole this closes. Omitting `--reporter` lets the configured reporters run (the
+ * gate included); Playwright auto-prepends a compact `line` (local) / `dot` (CI)
+ * reporter when none of them claim stdio, so the captured per-shard log stays
+ * readable without us overriding anything.
+ *
+ * The HTML reporter is the only common config reporter that is shard-hostile:
+ * every shard shares one project dir and would write the same
+ * `playwright-report/`, racing each other's report files. We hand each shard its
+ * own HTML output dir and force `open: never` (defensive — the non-TTY,
+ * file-captured child never auto-opens a browser anyway). Both env vars are
+ * inert for a project without an HTML reporter, so the fix stays generic.
+ *
+ * Playwright is invoked via the manager's `exec` (NOT `<pm> run test:e2e -- …`):
+ * forwarding option flags through `<pm> run`'s `--` is unreliable — pnpm passed
+ * the separator on to Playwright, which then read `--shard` as a file FILTER, so
+ * every shard ran the whole suite. `exec` hands args straight to the binary
+ * (mirrors CI); the helper inserts `--` for npm so those flags survive.
+ */
+function buildShardPlaywrightInvocation(pm, shardIndex, total, forwarded, htmlReportDir) {
+    return {
+        args: pm.exec('playwright', ['test', `--shard=${shardIndex}/${total}`, ...forwarded]),
+        env: {
+            PLAYWRIGHT_HTML_OPEN: 'never',
+            PLAYWRIGHT_HTML_OUTPUT_DIR: htmlReportDir,
+        },
+    };
+}
 /** True when a test session file exists (used by status/down). */
 function hasTestSession(root) {
     return (0, dev_state_1.loadSession)(root, dev_state_1.TEST_SESSION_FILE) !== null;
@@ -396,21 +437,14 @@ function runShardedTestSession(layout, baseIdentity, log, opts) {
             // suite runs under concurrent sharded load, so it can relax navigation /
             // test timeouts (N built SSR servers + N Chromium saturate the CPU and slow
             // every navigation) without loosening them for serial runs.
-            const env = Object.assign(Object.assign(Object.assign({}, ctx.appEnv), { LT_DEV_TEST_SHARDS: String(total), MONGO_URI: `mongodb://127.0.0.1/${ctx.dbName}` }), (ctx.apiLogPath ? { NEST_SERVER_LOG: ctx.apiLogPath } : {}));
+            // Reporter + shard args come from the shared helper, which deliberately
+            // does NOT inject `--reporter` so the project's own release gate (e.g.
+            // SVL's DEV-2098 no-skips reporter) still runs under `--shard` (DEV-2676),
+            // and isolates the HTML report per shard.
+            const reportDir = shardReportDir(layout.root, index);
+            const { args, env: reporterEnv } = buildShardPlaywrightInvocation(opts.pm, index, total, opts.forwarded, reportDir);
+            const env = Object.assign(Object.assign(Object.assign(Object.assign({}, ctx.appEnv), { LT_DEV_TEST_SHARDS: String(total), MONGO_URI: `mongodb://127.0.0.1/${ctx.dbName}` }), (ctx.apiLogPath ? { NEST_SERVER_LOG: ctx.apiLogPath } : {})), reporterEnv);
             const logFile = (0, path_1.join)(layout.root, '.lt-dev', `shard.${index}.test.log`);
-            // Invoke Playwright DIRECTLY via the manager's `exec` (NOT `<pm> run
-            // test:e2e -- …`): forwarding option flags through `<pm> run`'s `--`
-            // is unreliable — pnpm passed the separator on to Playwright, which
-            // then read `--shard` / `--reporter` as file FILTERS (not options) →
-            // every shard ran the whole suite. `<pm> exec` hands args straight
-            // to the binary (mirrors CI); the helper inserts `--` for npm so
-            // those flags don't get re-parsed as npm's own.
-            const args = opts.pm.exec('playwright', [
-                'test',
-                `--shard=${index}/${total}`,
-                '--reporter=line',
-                ...opts.forwarded,
-            ]);
             const code = yield (0, dev_process_1.runChildToFile)(opts.pm.bin, args, { cwd: appDir, env, logFile });
             return { code, index, logFile };
         })));
@@ -426,6 +460,16 @@ function runShardedTestSession(layout, baseIdentity, log, opts) {
         return failed === 0 ? 0 : 1;
     });
 }
+/**
+ * The per-shard HTML report directory. Distinct per shard (the `<index>` in the
+ * path) so N shards never race on a shared `playwright-report/` — this is the
+ * actual isolation `buildShardPlaywrightInvocation`'s `PLAYWRIGHT_HTML_OUTPUT_DIR`
+ * relies on. Extracted as a pure helper so the shard-distinctness guarantee is
+ * unit-testable without booting the (deliberately untested) real orchestrator.
+ */
+function shardReportDir(root, shardIndex) {
+    return (0, path_1.join)(root, '.lt-dev', `shard.${shardIndex}.playwright-report`);
+}
 /**
  * Tear down the unsharded test stack AND every sharded stack discovered on disk
  * (`state.test.<i>.json` in `.lt-dev/`). Used by `lt dev test down` so a

package/build/lib/dev-ticket.js

@@ -824,7 +824,17 @@ function isPristineLtDevPatch(worktreePath, relPath) {
     try {
         (0, fs_1.writeFileSync)(tmp, head, 'utf8');
         (0, dev_patches_1.autoPatch)(tmp);
-        return (0, fs_1.readFileSync)(tmp, 'utf8') === current;
+        const derived = (0, fs_1.readFileSync)(tmp, 'utf8');
+        if (derived === current)
+            return true;
+        // The patcher deliberately lets the consumer's formatter restyle the
+        // injected `lt-dev:bridge` block (quote style, wrapping) without rewriting
+        // it — so a byte-exact comparison would classify a merely reformatted
+        // playwright.config.ts as real developer work and make `lt ticket stop`
+        // refuse to remove the worktree. Compare the bridge span in its canonical
+        // form; everything OUTSIDE the markers stays byte-exact, so genuine edits
+        // are still never auto-discarded.
+        return (0, dev_patches_1.canonicaliseBridgeSpan)(derived) === (0, dev_patches_1.canonicaliseBridgeSpan)(current);
     }
     catch (_c) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/cli",
-  "version": "1.41.1",
+  "version": "1.41.3",
   "description": "lenne.Tech CLI: lt",
   "keywords": [
     "lenne.Tech",
@@ -46,14 +46,10 @@
     "start:build": "npm run build && node bin/lt --compiled-build",
     "start:compiled": "node bin/lt --compiled-build",
     "test": "jest --testTimeout=60000",
-    "watch": "jest --watch",
-    "release": "standard-version && git push --follow-tags origin main",
-    "release:minor": "standard-version --release-as minor && git push --follow-tags origin main",
-    "release:major": "standard-version --release-as major && git push --follow-tags origin main"
+    "watch": "jest --watch"
   },
   "files": [
     "tsconfig.json",
-    "tslint.json",
     "build",
     "LICENSE",
     "README.md",
@@ -96,7 +92,6 @@
     "jest": "30.4.2",
     "prettier": "3.8.3",
     "rimraf": "6.1.3",
-    "standard-version": "9.5.0",
     "ts-jest": "29.4.11"
   },
   "//overrides": {