@lenne.tech/cli 1.26.0 → 1.27.0

package/build/commands/claude/plugins.js

@@ -19,20 +19,22 @@ const shell_config_1 = require("../../lib/shell-config");
 function installPlugin(plugin, cli, toolbox) {
     return __awaiter(this, void 0, void 0, function* () {
         const { print: { error, info, spin }, } = toolbox;
-        // Step 1: Install or update plugin
+        // Step 1: Install or update plugin.
+        //
+        // `claude plugin install` is a no-op for an already-installed plugin: it reports
+        // "already installed" and leaves the active version pinned to whatever was installed
+        // before. To actually pull a newer release from the (freshly updated) marketplace
+        // cache, an existing install must be bumped with `claude plugin update`.
         const fullPluginName = `${plugin.pluginName}@${plugin.marketplaceName}`;
         const pluginSpinner = spin(`Installing/updating ${plugin.pluginName}`);
-        const installResult = (0, claude_cli_1.runClaudeCommand)(cli, `plugin install ${fullPluginName}`);
+        let installResult = (0, claude_cli_1.runClaudeCommand)(cli, `plugin install ${fullPluginName}`);
         let pluginAction = 'installed';
-        if (installResult.output.includes('already') || installResult.output.includes('up to date')) {
-            pluginAction = 'up to date';
+        if (installResult.output.includes('already installed')) {
+            // Plugin was already present — follow up with an update to reach the latest version.
+            installResult = (0, claude_cli_1.runClaudeCommand)(cli, `plugin update ${fullPluginName}`);
+            pluginAction = installResult.output.includes('already') ? 'up to date' : 'updated';
         }
-        else if (installResult.output.includes('update') || installResult.output.includes('upgrade')) {
-            pluginAction = 'updated';
-        }
-        if (installResult.success ||
-            installResult.output.includes('already') ||
-            installResult.output.includes('up to date')) {
+        if (installResult.success || installResult.output.includes('already')) {
             pluginSpinner.succeed(`${plugin.pluginName} ${pluginAction}`);
         }
         else {
@@ -42,6 +44,7 @@ function installPlugin(plugin, cli, toolbox) {
             info('Manual installation:');
             info(`  /plugin marketplace add ${plugin.marketplaceRepo}`);
             info(`  /plugin install ${fullPluginName}`);
+            info(`  /plugin update ${fullPluginName}`);
             return { action: 'failed', contents: plugin_utils_1.EMPTY_PLUGIN_CONTENTS, postInstall: null, success: false };
         }
         // Step 2: Read plugin contents

package/build/commands/dev/down.js

@@ -15,6 +15,7 @@ const dev_identity_1 = require("../../lib/dev-identity");
 const dev_process_1 = require("../../lib/dev-process");
 const dev_project_1 = require("../../lib/dev-project");
 const dev_state_1 = require("../../lib/dev-state");
+const dev_test_session_1 = require("../../lib/dev-test-session");
 /**
  * Stop the processes started by `lt dev up` and remove the project's
  * Caddy block.
@@ -66,6 +67,17 @@ const DownCommand = {
         // do not pick up stale URLs.
         if ((0, dev_env_bridge_1.clearEnvBridge)(layout.root))
             info(colors.dim('Removed .lt-dev/.env bridge.'));
+        // Also tear down any isolated test stack (`lt dev test`) for this project,
+        // so `lt dev down` always leaves a clean slate.
+        if ((0, dev_test_session_1.hasTestSession)(layout.root)) {
+            const { stopped: testStopped } = yield (0, dev_test_session_1.tearDownTestSession)(layout, identity, {
+                dim: colors.dim,
+                info,
+                warn: warning,
+            });
+            if (testStopped.length > 0)
+                success(`Stopped test stack: ${testStopped.join(', ')}`);
+        }
         if (stopped.length > 0)
             success(`Stopped: ${stopped.join(', ')}`);
         if (!parameters.options.fromGluegunMenu)

package/build/commands/dev/status.js

@@ -26,7 +26,7 @@ const StatusCommand = {
     hidden: false,
     name: 'status',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const { filesystem, parameters, print: { colors, info, warning }, } = toolbox;
         const all = Boolean(parameters.options.all);
         const reg = (0, dev_state_1.loadRegistry)();
@@ -144,6 +144,24 @@ const StatusCommand = {
                 }
             }
         }
+        // Isolated test stack (`lt dev test`), if one is up / left with --keep.
+        const testSession = (0, dev_state_1.loadSession)(layout.root, dev_state_1.TEST_SESSION_FILE);
+        if (testSession) {
+            const testEntry = reg.projects[`${identity.slug}-test`];
+            info('');
+            info(colors.bold('  Isolated test stack (lt dev test)'));
+            if (testEntry) {
+                for (const [sub, host] of Object.entries(testEntry.subdomains))
+                    info(`    ${sub.padEnd(6)} https://${host}`);
+                if (testEntry.dbName)
+                    info(`    db     mongodb://127.0.0.1/${testEntry.dbName}`);
+            }
+            const apiAlive = testSession.pids.api ? (0, dev_state_1.isPidAlive)(testSession.pids.api) : false;
+            const appAlive = testSession.pids.app ? (0, dev_state_1.isPidAlive)(testSession.pids.app) : false;
+            info(`    api: ${apiAlive ? colors.green('running') : colors.red('dead')} (pid ${(_c = testSession.pids.api) !== null && _c !== void 0 ? _c : '-'})`);
+            info(`    app: ${appAlive ? colors.green('running') : colors.red('dead')} (pid ${(_d = testSession.pids.app) !== null && _d !== void 0 ? _d : '-'})`);
+            info(colors.dim('    stop: lt dev test down'));
+        }
         info('');
         if (!parameters.options.fromGluegunMenu)
             process.exit();

package/build/commands/dev/test.js

@@ -9,45 +9,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const caddy_1 = require("../../lib/caddy");
 const dev_env_bridge_1 = require("../../lib/dev-env-bridge");
 const dev_identity_1 = require("../../lib/dev-identity");
+const dev_process_1 = require("../../lib/dev-process");
 const dev_project_1 = require("../../lib/dev-project");
-const dev_state_1 = require("../../lib/dev-state");
+const dev_test_session_1 = require("../../lib/dev-test-session");
 /**
  * One-shot E2E convenience wrapper.
  *
- * Ensures the project is up under `lt dev`, then runs the test command
- * with the ENV bridge loaded, and optionally tears the session down at
- * the end. Useful for TDD loops, CI reproduction, and "just test it"
- * workflows where the developer doesn't want to remember three commands.
+ * App mode (default) runs the Playwright suite against a fully ISOLATED test
+ * stack (own URLs / ports / Caddy block / dedicated `<…>-test` database) that
+ * runs parallel to — and never touches — the developer's `lt dev up` session.
+ * Playwright's global-setup resets that dedicated DB once before the first test.
+ * The stack is torn down automatically when the run finishes (residue-free).
  *
- * Behaviour:
- *   1. If no `lt dev up` session is alive: run `lt dev up` first.
- *   2. Wait for the App URL to respond (best-effort, ~30s timeout).
- *   3. Inherit the env from `<root>/.lt-dev/.env` (so VS Code IDE-style
- *      runners get the same setup) and spawn the test command in the
- *      App project.
- *   4. With `--teardown` (default false): run `lt dev down` after.
+ * API mode (`--api`) runs the standalone API test suite (`pnpm test:e2e` in the
+ * API), which already isolates itself on its own DB — no stack is brought up.
  *
  * Usage:
- *   lt dev test                       # ensure up + run pnpm test:e2e in app
- *   lt dev test --api                 # run API tests instead (pnpm test in api)
- *   lt dev test --teardown            # plus stop session after
- *   lt dev test --debug               # PWDEBUG=1 + headed mode
- *   lt dev test -- <args>             # forward args to the test runner
- *   lt dev test -- --ui crm-login.spec.ts
+ *   lt dev test                  # isolated Playwright E2E (auto teardown)
+ *   lt dev test --keep           # leave the test stack up afterwards (debug)
+ *   lt dev test down             # tear the test stack down (residue-free)
+ *   lt dev test --api            # run API tests instead (already isolated)
+ *   lt dev test --debug          # PWDEBUG=1 + headed
+ *   lt dev test --shard          # shard across 2 isolated stacks (default — stable)
+ *   lt dev test --shard N        # shard across N isolated stacks (parallel)
+ *   lt dev test --shard auto     # size N from this machine's CPU + RAM
+ *   lt dev test -- <args>        # forward args to Playwright
  */
 const TestCommand = {
     alias: ['t'],
-    description: 'Ensure up + run E2E tests with lt dev env',
+    description: 'Run E2E tests in an isolated, parallel test stack (auto teardown)',
     hidden: false,
     name: 'test',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
-        const { filesystem, parameters, print: { colors, error, info, success }, } = toolbox;
+        const { filesystem, parameters, print: { colors, error, info, success, warning }, } = toolbox;
         const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
         if (!layout.apiDir && !layout.appDir) {
             error('No API or App project detected at this path.');
@@ -55,74 +54,193 @@ const TestCommand = {
                 process.exit(1);
             return 'dev test: not a project';
         }
+        const identity = (0, dev_identity_1.buildIdentity)(layout.root);
+        const log = { dim: colors.dim, info, warn: warning };
+        // Sub-command: `lt dev test down` — tear the test stack(s) down + exit.
+        // Reclaims both the unsharded stack and any leftover sharded stacks.
+        if (parameters.first === 'down') {
+            const { stopped } = yield (0, dev_test_session_1.tearDownAllTestSessions)(layout, identity, log);
+            if (stopped.length > 0)
+                success(`Test stack down: ${stopped.join(', ')}`);
+            else
+                info(colors.dim('No test stack was running.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit();
+            return 'dev test: down';
+        }
         const apiMode = Boolean(parameters.options.api);
-        const teardown = Boolean(parameters.options.teardown);
+        const keep = Boolean(parameters.options.keep) || parameters.options.teardown === false;
         const debug = Boolean(parameters.options.debug);
-        // Forwarded args after `--` (gluegun puts them in parameters.array).
         const forwarded = parameters.array || [];
-        const targetDir = apiMode ? layout.apiDir : layout.appDir;
-        if (!targetDir) {
-            error(`Cannot run ${apiMode ? 'API' : 'App'} tests — no ${apiMode ? 'apiDir' : 'appDir'} in layout.`);
-            if (!parameters.options.fromGluegunMenu)
-                process.exit(1);
-            return 'dev test: target missing';
+        const pnpmBin = process.env.LT_PNPM_BIN || 'pnpm';
+        // `--shard N` → run the suite split across N fully-isolated stacks in
+        // parallel. A bare `--shard` defaults to 2 — the stable sweet spot for a
+        // heavy built-SSR suite (N>=3 over-subscribes the perf cores → flaky; see
+        // autoShardCount). `--shard auto` instead sizes N from this machine's CPU+RAM.
+        const SHARD_DEFAULT = 2;
+        const shardRaw = (_a = parameters.options.shard) !== null && _a !== void 0 ? _a : parameters.options.shards;
+        let shardTotal;
+        if (shardRaw !== undefined) {
+            if (shardRaw === true)
+                shardTotal = SHARD_DEFAULT;
+            else if (String(shardRaw).toLowerCase() === 'auto')
+                shardTotal = (0, dev_test_session_1.autoShardCount)();
+            else
+                shardTotal = Math.floor(Number(shardRaw));
         }
-        const identity = (0, dev_identity_1.buildIdentity)(layout.root);
-        // Pre-flight: Caddy + ensure up.
-        if (!apiMode) {
-            if (!(yield (0, caddy_1.caddyAvailable)())) {
-                error('caddy is not installed. Run `lt dev install` first.');
+        // -------------------------------------------------------------------------
+        // API mode — standalone, already isolated on its own DB. No stack needed.
+        // -------------------------------------------------------------------------
+        if (apiMode) {
+            if (!layout.apiDir) {
+                error('No API project in this layout.');
                 if (!parameters.options.fromGluegunMenu)
                     process.exit(1);
-                return 'dev test: caddy missing';
+                return 'dev test: no api';
             }
-            if (!(yield (0, caddy_1.caddyDaemonRunning)())) {
-                error('caddy daemon not running. Run `lt dev install` first.');
-                if (!parameters.options.fromGluegunMenu)
-                    process.exit(1);
-                return 'dev test: caddy daemon down';
+            info(colors.bold(`Running API tests for "${identity.slug}" (isolated DB)`));
+            const code = yield (0, dev_process_1.runChildInherit)(pnpmBin, ['run', 'test:e2e', ...forwarded], {
+                cwd: layout.apiDir,
+                env: process.env,
+            });
+            if (code === 0)
+                success('API tests passed.');
+            else
+                error(`API tests failed (exit ${code}).`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(code !== null && code !== void 0 ? code : 1);
+            return `dev test: api exit=${code}`;
+        }
+        // -------------------------------------------------------------------------
+        // App mode — isolated Playwright stack.
+        // -------------------------------------------------------------------------
+        if (!layout.appDir) {
+            error('No App project in this layout.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev test: no app';
+        }
+        if (!(yield (0, caddy_1.caddyAvailable)())) {
+            error('caddy is not installed. Run `lt dev install` first.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev test: caddy missing';
+        }
+        if (!(yield (0, caddy_1.caddyDaemonRunning)())) {
+            error('caddy daemon not running. Run `lt dev install` first.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev test: caddy daemon down';
+        }
+        // Pre-flight (#3): if the project's playwright.config is not env-aware
+        // (hardcoded baseURL or an unguarded `webServer`), the suite would IGNORE
+        // the isolated stack we are about to build and hit localhost:3001 instead —
+        // wasting a full build on a stack nothing uses. Abort early with the fix,
+        // unless `--force`.
+        const unpatched = (0, dev_project_1.appNeedsPortPatch)(layout.appDir).some((f) => f.endsWith('playwright.config.ts'));
+        if (unpatched && !parameters.options.force) {
+            error("This project's playwright.config.ts is not env-aware (hardcoded baseURL or unguarded webServer).");
+            error('`lt dev test` would build an isolated stack the suite then IGNORES (tests would hit localhost:3001).');
+            info(colors.dim('Fix: run `lt dev init` to make baseURL env-aware + guard the webServer — or pass --force.'));
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev test: playwright.config not env-aware (run lt dev init or --force)';
+        }
+        // -------------------------------------------------------------------------
+        // Sharded mode (`--shard N`) — N fully-isolated stacks + parallel
+        // `--shard=i/N`, the local CI-parity matrix. Each shard has its own DB so
+        // there is no cross-shard contention. Auto-teardown of ALL shards (or
+        // `--keep` them for `lt dev test down`).
+        // -------------------------------------------------------------------------
+        if (shardTotal !== undefined && shardTotal > 1) {
+            let allTornDown = false;
+            const teardownAll = () => __awaiter(void 0, void 0, void 0, function* () {
+                if (allTornDown || keep)
+                    return;
+                allTornDown = true;
+                yield (0, dev_test_session_1.tearDownAllTestSessions)(layout, identity, log, { silent: true });
+            });
+            const onShardSignal = () => {
+                teardownAll()
+                    .catch(() => undefined)
+                    .finally(() => process.exit(130));
+            };
+            process.on('SIGINT', onShardSignal);
+            process.on('SIGTERM', onShardSignal);
+            let shardExit = 1;
+            try {
+                info('');
+                info(colors.bold(`Running isolated Playwright E2E for "${identity.slug}" sharded across ${shardTotal} stacks`));
+                shardExit = yield (0, dev_test_session_1.runShardedTestSession)(layout, identity, log, { forwarded, pnpmBin, total: shardTotal });
+            }
+            catch (e) {
+                error(`Failed to run sharded E2E: ${e.message}`);
+                shardExit = 1;
             }
-            const reg = (0, dev_state_1.loadRegistry)();
-            const entry = reg.projects[identity.slug];
-            const session = (0, dev_state_1.loadSession)(layout.root);
-            const sessionAlive = session !== null &&
-                ((session.pids.api && (0, dev_state_1.isPidAlive)(session.pids.api)) || (session.pids.app && (0, dev_state_1.isPidAlive)(session.pids.app)));
-            if (!entry || !sessionAlive) {
-                info(colors.dim('Project not running — invoking `lt dev up` first ...'));
-                const upResult = yield runChild('lt', ['dev', 'up'], { cwd: layout.root, env: process.env, inherit: true });
-                if (upResult !== 0) {
-                    error(`lt dev up failed (exit ${upResult}).`);
-                    if (!parameters.options.fromGluegunMenu)
-                        process.exit(upResult !== null && upResult !== void 0 ? upResult : 1);
-                    return 'dev test: up failed';
+            finally {
+                process.off('SIGINT', onShardSignal);
+                process.off('SIGTERM', onShardSignal);
+                if (keep) {
+                    info('');
+                    info(colors.dim('Test stacks left running (--keep). Stop them with: `lt dev test down`.'));
                 }
-                // Wait for App URL to respond (best-effort).
-                const appHost = (_a = identity.subdomains.app) === null || _a === void 0 ? void 0 : _a.hostname;
-                if (appHost) {
-                    info(colors.dim(`Waiting for https://${appHost} to respond ...`));
-                    yield waitForUrl(`https://${appHost}`, 30000);
+                else {
+                    yield teardownAll();
                 }
             }
+            if (shardExit === 0)
+                success('Tests passed (all shards).');
+            else
+                error(`Tests failed (exit ${shardExit}).`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(shardExit !== null && shardExit !== void 0 ? shardExit : 1);
+            return `dev test: sharded exit=${shardExit}`;
         }
-        // Build env: process.env + bridge file (bridge wins for keys it defines).
-        const env = Object.assign(Object.assign({}, process.env), readBridgeEnv(layout.root));
-        if (debug) {
-            env.PWDEBUG = '1';
-            env.HEADED = '1';
-        }
-        // Pick the runner.
-        const pnpmBin = process.env.LT_PNPM_BIN || 'pnpm';
-        const args = apiMode ? ['run', 'test:e2e', ...forwarded] : ['run', 'test:e2e', ...forwarded];
-        info('');
-        info(colors.bold(`Running ${apiMode ? 'API' : 'App'} E2E tests for "${identity.slug}"`));
-        info(colors.dim(`  ${pnpmBin} ${args.join(' ')}`));
-        info(colors.dim(`  cwd: ${targetDir}`));
-        info('');
-        const exitCode = yield runChild(pnpmBin, args, { cwd: targetDir, env, inherit: true });
-        if (teardown) {
+        let tornDown = false;
+        const teardown = () => __awaiter(void 0, void 0, void 0, function* () {
+            if (tornDown || keep)
+                return;
+            tornDown = true;
+            yield (0, dev_test_session_1.tearDownTestSession)(layout, identity, log);
+        });
+        // Residue-free teardown even on Ctrl-C / kill.
+        const onSignal = () => {
+            teardown()
+                .catch(() => undefined)
+                .finally(() => process.exit(130));
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        let exitCode = 1;
+        try {
+            const ctx = yield (0, dev_test_session_1.bringUpTestSession)(layout, identity, log);
+            const env = Object.assign(Object.assign(Object.assign({}, process.env), readBridgeEnv(layout.root)), { 
+                // Playwright global-setup resets THIS db (allow-listed) before the suite.
+                MONGO_URI: `mongodb://127.0.0.1/${ctx.dbName}` });
+            if (debug) {
+                env.PWDEBUG = '1';
+                env.HEADED = '1';
+            }
             info('');
-            info(colors.dim('Tearing down lt dev session ...'));
-            yield runChild('lt', ['dev', 'down'], { cwd: layout.root, env: process.env, inherit: true });
+            info(colors.bold(`Running isolated Playwright E2E for "${identity.slug}"`));
+            info(colors.dim(`  app: ${ctx.appUrl}   db: ${ctx.dbName}`));
+            info('');
+            exitCode = yield (0, dev_process_1.runChildInherit)(pnpmBin, ['run', 'test:e2e', ...forwarded], { cwd: layout.appDir, env });
+        }
+        catch (e) {
+            error(`Failed to run isolated E2E: ${e.message}`);
+            exitCode = 1;
+        }
+        finally {
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+            if (keep) {
+                info('');
+                info(colors.dim('Test stack left running (--keep). Stop it with: `lt dev test down`.'));
+            }
+            else {
+                yield teardown();
+            }
         }
         if (exitCode === 0)
             success('Tests passed.');
@@ -134,11 +252,11 @@ const TestCommand = {
     }),
 };
 /**
- * Read the .lt-dev/.env bridge file as a key/value map.
- * Returns an empty object if the file is missing.
+ * Read the test ENV bridge (`.lt-dev/.env.test`) as a key/value map.
+ * Returns an empty object if missing.
  */
 function readBridgeEnv(root) {
-    const file = (0, dev_env_bridge_1.envBridgePath)(root);
+    const file = (0, dev_env_bridge_1.envBridgePath)(root, '.env.test');
     if (!(0, fs_1.existsSync)(file))
         return {};
     const out = {};
@@ -149,43 +267,4 @@ function readBridgeEnv(root) {
     }
     return out;
 }
-/** Spawn a child synchronously (waits for exit), inheriting stdio when requested. */
-function runChild(cmd, args, opts) {
-    return new Promise((resolve) => {
-        const child = (0, child_process_1.spawn)(cmd, args, {
-            cwd: opts.cwd,
-            env: opts.env,
-            stdio: opts.inherit ? 'inherit' : 'pipe',
-        });
-        child.on('error', () => resolve(1));
-        child.on('close', (code) => resolve(code));
-    });
-}
-/** Poll a URL until it responds or timeout elapses. */
-function waitForUrl(url, timeoutMs) {
-    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', () => {
-                if (/^[1-5]\d\d$/.test(status.trim()))
-                    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();
-    });
-}
 module.exports = TestCommand;

package/build/lib/dev-env-bridge.js

@@ -24,8 +24,8 @@ const os_1 = require("os");
 const path_1 = require("path");
 const HEADER = `# Managed by \`lt dev up\` — do NOT edit, will be overwritten.\n# Removed by \`lt dev down\`. Loaded by Playwright + other tools.\n`;
 /** Remove the ENV bridge file. No-op if missing. */
-function clearEnvBridge(projectRoot) {
-    const file = envBridgePath(projectRoot);
+function clearEnvBridge(projectRoot, fileName = '.env') {
+    const file = envBridgePath(projectRoot, fileName);
     if (!(0, fs_1.existsSync)(file))
         return false;
     try {
@@ -61,16 +61,16 @@ function detectCaddyRootCa() {
     return null;
 }
 /** Resolve the path to the ENV bridge file for a project. */
-function envBridgePath(projectRoot) {
-    return (0, path_1.join)(projectRoot, '.lt-dev', '.env');
+function envBridgePath(projectRoot, fileName = '.env') {
+    return (0, path_1.join)(projectRoot, '.lt-dev', fileName);
 }
 /**
  * Write the ENV bridge file. Idempotent — same content = no rewrite.
  *
  * Returns the absolute path that was written.
  */
-function writeEnvBridge(projectRoot, devEnv, dbName) {
-    const file = envBridgePath(projectRoot);
+function writeEnvBridge(projectRoot, devEnv, dbName, fileName = '.env') {
+    const file = envBridgePath(projectRoot, fileName);
     const lines = [];
     // The App-side env is the more "external" one (Playwright, browser tools).
     // We expose every URL/storage/api key the App env carries.

package/build/lib/dev-identity.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildIdentity = buildIdentity;
+exports.buildTestIdentity = buildTestIdentity;
 exports.projectSlug = projectSlug;
 exports.slugify = slugify;
 /**
@@ -67,6 +68,23 @@ function buildIdentity(root) {
     }
     return { root, slug, subdomains };
 }
+/**
+ * Derive an ephemeral "test" identity from a base identity (used by
+ * `lt dev test`). Suffixes the slug and every subdomain hostname with
+ * `-test`, so the test stack runs on its own URLs / ports / Caddy block,
+ * fully parallel to (and isolated from) the dev session.
+ *
+ *   svl.localhost      → svl-test.localhost
+ *   api.svl.localhost  → api.svl-test.localhost
+ */
+function buildTestIdentity(base, suffix = '-test') {
+    const slug = `${base.slug}${suffix}`;
+    const subdomains = {};
+    for (const [sub, value] of Object.entries(base.subdomains)) {
+        subdomains[sub] = Object.assign(Object.assign({}, value), { hostname: value.isPrimaryApp ? `${slug}.localhost` : `${sub}.${slug}.localhost` });
+    }
+    return { root: base.root, slug, subdomains };
+}
 /**
  * Read the bare project name from package.json (scope stripped).
  * Falls back to directory basename if no package.json or no `name`.

package/build/lib/dev-migrate-helper.js

@@ -78,15 +78,25 @@ function runMigrate(input) {
     });
     const identity = (0, dev_identity_1.buildIdentity)(layout.root);
     const dbName = (0, dev_project_1.deriveDbName)(layout.apiDir, identity.slug);
-    // 1. Code patches (config.env.ts, nuxt.config.ts, playwright.config.ts).
+    // 1. Code patches. Run `autoPatch` over EVERY existing config file (not just
+    //    the ones a port-detector flags): the patches are idempotent, and some —
+    //    e.g. the playwright.config `ignoreHTTPSErrors` + shard-aware
+    //    `LT_DEV_TEST_SHARDS` timeout block — apply to configs that are already
+    //    env-aware. So `lt dev init` makes any project fully `lt dev test --shard`
+    //    ready in one command; an up-to-date config is a no-op (`patched: false`).
     const filesToPatch = [];
     if (layout.apiDir) {
-        const f = (0, dev_project_1.apiNeedsPortPatch)(layout.apiDir);
-        if (f)
-            filesToPatch.push(f);
+        const apiCfg = (0, path_1.join)(layout.apiDir, 'src', 'config.env.ts');
+        if ((0, fs_1.existsSync)(apiCfg))
+            filesToPatch.push(apiCfg);
+    }
+    if (layout.appDir) {
+        for (const rel of ['nuxt.config.ts', 'playwright.config.ts']) {
+            const f = (0, path_1.join)(layout.appDir, rel);
+            if ((0, fs_1.existsSync)(f))
+                filesToPatch.push(f);
+        }
     }
-    if (layout.appDir)
-        filesToPatch.push(...(0, dev_project_1.appNeedsPortPatch)(layout.appDir));
     const codePatches = filesToPatch.map((f) => (0, dev_patches_1.autoPatch)(f));
     // 2. CLAUDE.md URL block (root + each subproject — only patches existing files).
     const claudeCandidates = [