@lenne.tech/cli 1.48.0 → 1.50.0

package/build/commands/dev/doctor.js

@@ -117,18 +117,31 @@ const DoctorCommand = {
                 line('WARN', colors.yellow, `Caddyfile validation: ${v.stderr.split('\n')[0]}`);
         }
         // 4. Port 80 / 443 free or held by Caddy
+        //
+        // "Is it bound" is now a TCP connect, so it answers on every platform — the
+        // old `lsof`-only probe degraded to a WARN on Windows and doctor then exited
+        // 0 while nothing worked. Only the OCCUPANT'S NAME can still be unavailable,
+        // and that is reported as its own state rather than folded into either
+        // verdict: a bound port we cannot attribute is not "free", and it is not
+        // proof that Caddy is blocked either.
+        const portProbe = yield (0, dev_process_1.probePorts)([80, 443]);
         for (const port of [80, 443]) {
-            const r = yield (0, dev_process_1.checkPortInUse)(port);
-            if (r === null)
-                line('WARN', colors.yellow, `lsof unavailable — cannot probe port ${port}`);
-            else if (!r.inUse)
+            if (!portProbe.bound.has(port)) {
                 line('OK', colors.green, `port ${port} free`);
-            else if (r.command === 'caddy')
-                line('OK', colors.green, `port ${port} held by caddy (pid ${r.pid})`);
-            else {
-                line('FAIL', colors.red, `port ${port} held by ${r.command} (pid ${r.pid}) — Caddy cannot bind`);
-                fails++;
+                continue;
+            }
+            const owner = portProbe.owners.get(port);
+            if (!owner) {
+                line('WARN', colors.yellow, `port ${port} is in use but the occupant could not be identified` +
+                    `${portProbe.ownersUnavailable ? ' (no lsof/netstat available)' : ''}`);
+                continue;
             }
+            if (owner.command.toLowerCase().startsWith('caddy')) {
+                line('OK', colors.green, `port ${port} held by caddy (pid ${owner.pid})`);
+                continue;
+            }
+            line('FAIL', colors.red, `port ${port} held by ${owner.command} (pid ${owner.pid}) — Caddy cannot bind`);
+            fails++;
         }
         // 5. *.localhost resolves to 127.0.0.1
         const dnsOk = yield dnsResolvesLocalhost('lt-dev-doctor.localhost');
@@ -273,7 +286,11 @@ const DoctorCommand = {
  */
 function dnsResolvesLocalhost(host) {
     return new Promise((resolve) => {
-        const child = (0, child_process_1.spawn)('node', [
+        const child = (0, child_process_1.spawn)(
+        // `process.execPath`, not a bare `node`: the CLI may run from a Node that
+        // is not on PATH at all (a version manager, a packaged install), and a
+        // different `node` on PATH would answer for a different runtime.
+        process.execPath, [
             '-e',
             `require('dns').lookup(${JSON.stringify(host)}, { all: true }, (e, addrs) => {
            if (e) process.exit(1);

package/build/commands/dev/down.js

@@ -16,12 +16,20 @@ 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");
 const dev_ticket_1 = require("../../lib/dev-ticket");
+const platform_1 = require("../../lib/platform");
 /**
  * Stop the processes started by `lt dev up` and remove the project's
  * Caddy block.
  *
- * - SIGTERM is sent to the detached process GROUP (negative PID) so
- *   children (Vite, Nest watcher) receive the signal too.
+ * - POSIX: SIGTERM to the detached process GROUP (negative PID), so children
+ *   (Vite, Nest watcher) receive it too and can shut down gracefully. No
+ *   escalation — `down` is the polite stop.
+ * - Windows: `taskkill /T /F`, i.e. FORCED, while `up`'s reclaim keeps the
+ *   two-phase `terminateProcessGroup`. Not a choice: Windows has no gentle step
+ *   (`/T` without `/F` was measured to leave the tree and its port alive), so
+ *   shutdown hooks do not run there. Details in `killWindowsTree`.
+ * - Either way the pid is verified gone afterwards; a survivor is reported,
+ *   never listed as stopped.
  * - The Caddy block is removed and `caddy reload` is invoked, so the
  *   subdomain stops resolving immediately.
  */
@@ -46,10 +54,27 @@ const DownCommand = {
                     stopped.push(`${name} (pid ${pid}, already dead)`);
                     continue;
                 }
-                if ((0, dev_process_1.killProcessGroup)(pid))
+                // A pid the plan refuses (1, this CLI, a system pid — i.e. a corrupted
+                // state.json) is neither signalled nor offered as a copy-paste kill hint:
+                // `kill -9 -1` is the broadcast that rebooted a Mac on 2026-09-23.
+                const plan = (0, dev_process_1.planTermination)(pid);
+                if (plan.kind === 'refuse') {
+                    warning(`Not stopping ${name}: ${plan.reason} — .lt-dev/state.json looks corrupted.`);
+                    continue;
+                }
+                (0, dev_process_1.killProcessGroup)(pid);
+                // Verify rather than assume: `killProcessGroup` reports that the signal
+                // was delivered, not that the process went. A compiled API with shutdown
+                // hooks can sit on SIGTERM while it waits for Mongo; claiming "stopped"
+                // then sends the user into the next `lt dev up` with a port collision
+                // nobody can trace back.
+                if (yield waitForExit(pid, 3000)) {
                     stopped.push(`${name} (pid ${pid})`);
-                else
-                    warning(`Failed to stop ${name} (pid ${pid})`);
+                }
+                else {
+                    warning(`${name} (pid ${pid}) did not stop — it may still hold its port.`);
+                    info(colors.dim(`  Check with \`lt dev status\`; force it with ${forceKillHint(pid)}`));
+                }
             }
             (0, dev_state_1.clearSession)(layout.root);
         }
@@ -98,3 +123,21 @@ const DownCommand = {
     }),
 };
 module.exports = DownCommand;
+/** The command that actually ends a process tree on this platform. */
+function forceKillHint(pid) {
+    // `/F` is not optional on Windows: measured, `taskkill /PID <pid> /T` without it
+    // fails on the children and leaves the port bound.
+    return (0, platform_1.isWindows)() ? `\`taskkill /PID ${pid} /T /F\`` : `\`kill -9 -${pid}\``;
+}
+/** Poll until `pid` is gone, or the budget runs out. */
+function waitForExit(pid, budgetMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const deadline = Date.now() + budgetMs;
+        while (Date.now() < deadline) {
+            if (!(0, dev_state_1.isPidAlive)(pid))
+                return true;
+            yield new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        return !(0, dev_state_1.isPidAlive)(pid);
+    });
+}

package/build/commands/dev/status.js

@@ -9,7 +9,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
 const caddy_1 = require("../../lib/caddy");
+const dev_log_tail_1 = require("../../lib/dev-log-tail");
 const dev_process_1 = require("../../lib/dev-process");
 const dev_project_1 = require("../../lib/dev-project");
 const dev_state_1 = require("../../lib/dev-state");
@@ -50,7 +52,7 @@ const StatusCommand = {
                     if (e.internalPorts.app)
                         allPorts.push(e.internalPorts.app);
                 }
-                const snap = yield (0, dev_process_1.listenSnapshot)(allPorts);
+                const probe = yield (0, dev_process_1.probePorts)(allPorts);
                 for (const slug of slugs) {
                     const e = reg.projects[slug];
                     const session = (0, dev_state_1.loadSession)(e.path);
@@ -60,14 +62,14 @@ const StatusCommand = {
                     if (e.internalPorts.api) {
                         comps.push((0, dev_state_1.classifyComponentHealth)({
                             pid: session === null || session === void 0 ? void 0 : session.pids.api,
-                            portBound: snap.has(e.internalPorts.api),
+                            portBound: probe.bound.has(e.internalPorts.api),
                             startedAt: session === null || session === void 0 ? void 0 : session.startedAt,
                         }));
                     }
                     if (e.internalPorts.app) {
                         comps.push((0, dev_state_1.classifyComponentHealth)({
                             pid: session === null || session === void 0 ? void 0 : session.pids.app,
-                            portBound: snap.has(e.internalPorts.app),
+                            portBound: probe.bound.has(e.internalPorts.app),
                             startedAt: session === null || session === void 0 ? void 0 : session.startedAt,
                         }));
                     }
@@ -186,15 +188,15 @@ const StatusCommand = {
             // ts-node leaves nodemon alive ("waiting for file changes"), so the
             // wrapper PID alone reads as "running" while nothing serves the port.
             const ports = [entry.internalPorts.api, entry.internalPorts.app].filter((p) => typeof p === 'number');
-            const snap = yield (0, dev_process_1.listenSnapshot)(ports);
+            const probe = yield (0, dev_process_1.probePorts)(ports);
             const apiHealth = (0, dev_state_1.classifyComponentHealth)({
                 pid: session.pids.api,
-                portBound: entry.internalPorts.api ? snap.has(entry.internalPorts.api) : false,
+                portBound: entry.internalPorts.api ? probe.bound.has(entry.internalPorts.api) : false,
                 startedAt: session.startedAt,
             });
             const appHealth = (0, dev_state_1.classifyComponentHealth)({
                 pid: session.pids.app,
-                portBound: entry.internalPorts.app ? snap.has(entry.internalPorts.app) : false,
+                portBound: entry.internalPorts.app ? probe.bound.has(entry.internalPorts.app) : false,
                 startedAt: session.startedAt,
             });
             const label = (health) => health === 'running'
@@ -216,8 +218,13 @@ const StatusCommand = {
                 info('');
                 info(colors.bold('  Live upstream state'));
                 for (const p of ports) {
-                    const r = snap.get(p);
-                    info(`    ${p}: ${r ? colors.green(`bound to ${r.command} (pid ${r.pid})`) : colors.dim('free')}`);
+                    if (!probe.bound.has(p)) {
+                        info(`    ${p}: ${colors.dim('free')}`);
+                        continue;
+                    }
+                    const owner = probe.owners.get(p);
+                    // "bound" is measured; the occupant's name is not always obtainable.
+                    info(`    ${p}: ${owner ? colors.green(`bound to ${owner.command} (pid ${owner.pid})`) : colors.green('bound')}`);
                 }
             }
             // Surface any present-but-not-serving component (crashed OR dead) and
@@ -241,6 +248,23 @@ const StatusCommand = {
                 info('');
                 warning(`  ${down.join(' + ')} not serving${crashed ? ' (supervisor still up — crashed)' : ''}. ` +
                     `Run \`lt dev up\` to restart ${down.length === 1 ? 'it' : 'them'}.`);
+                // Why it is down is in its log, so show it here instead of sending the
+                // reader to look. An empty log is said out loud: that is a finding too.
+                for (const name of down) {
+                    (0, dev_log_tail_1.describeLog)((0, dev_log_tail_1.diagnoseLog)((0, path_1.join)(layout.root, '.lt-dev', `${name}.log`), 8)).forEach((l) => info(colors.dim(`  ${l}`)));
+                }
+            }
+            // A log that exists but stays empty while its component runs: the output
+            // is going somewhere else (on Windows it once went to an extra console
+            // window). Worse than no log, because it looks trustworthy.
+            for (const [name, present] of [
+                ['api', apiPresent],
+                ['app', appPresent],
+            ]) {
+                const logDiagnosis = (0, dev_log_tail_1.diagnoseLog)((0, path_1.join)(layout.root, '.lt-dev', `${name}.log`));
+                if (present && !down.includes(name) && (0, dev_log_tail_1.isSilentLog)(logDiagnosis, session.startedAt, Date.now())) {
+                    warning(`  ${name}: ${logDiagnosis.file} is still EMPTY — its output is not being captured.`);
+                }
             }
         }
         // Isolated test stack (`lt dev test`), if one is up / left with --keep.

package/build/commands/dev/test.js

@@ -23,8 +23,10 @@ const dev_ticket_1 = require("../../lib/dev-ticket");
  * 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).
+ * That DB outlives the run, so pending migrations are applied to it before the
+ * API starts; a project's Playwright global-setup may reset it on top (the CLI
+ * does not). The stack is torn down automatically when the run finishes
+ * (residue-free).
  *
  * 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.
@@ -225,7 +227,7 @@ const TestCommand = {
         try {
             const ctx = yield (0, dev_test_session_1.bringUpTestSession)(layout, identity, log, { devDbName });
             const env = Object.assign(Object.assign(Object.assign(Object.assign({}, process.env), readBridgeEnv(layout.root)), { 
-                // Playwright global-setup resets THIS db (allow-listed) before the suite.
+                // THIS db, for a project whose global-setup resets or cleans it (allow-listed).
                 MONGO_URI: `mongodb://127.0.0.1/${ctx.dbName}` }), (ctx.apiLogPath ? { NEST_SERVER_LOG: ctx.apiLogPath } : {}));
             if (debug) {
                 env.PWDEBUG = '1';

package/build/commands/dev/up.js

@@ -17,6 +17,7 @@ const dev_api_launch_1 = require("../../lib/dev-api-launch");
 const dev_env_1 = require("../../lib/dev-env");
 const dev_env_bridge_1 = require("../../lib/dev-env-bridge");
 const dev_identity_1 = require("../../lib/dev-identity");
+const dev_log_tail_1 = require("../../lib/dev-log-tail");
 const dev_package_manager_1 = require("../../lib/dev-package-manager");
 const dev_patches_1 = require("../../lib/dev-patches");
 const dev_process_1 = require("../../lib/dev-process");
@@ -144,17 +145,6 @@ const UpCommand = {
             // plugin hook surfaces the ticket context per prompt instead (from the
             // gitignored `.lt-dev/ticket` marker). For the base project we keep the
             // committed URL block up to date as before.
-            if (!ticket) {
-                const claudeCandidates = [
-                    (0, path_1.join)(layout.root, 'CLAUDE.md'),
-                    ...(layout.apiDir ? [(0, path_1.join)(layout.apiDir, 'CLAUDE.md')] : []),
-                    ...(layout.appDir ? [(0, path_1.join)(layout.appDir, 'CLAUDE.md')] : []),
-                ];
-                const patched = claudeCandidates.map((f) => (0, dev_patches_1.patchClaudeMd)(f, { dbName, identity })).filter((r) => r.patched);
-                if (patched.length > 0) {
-                    info(colors.dim(`updated CLAUDE.md URL block in ${patched.length} file(s)`));
-                }
-            }
             // Always keep `.lt-dev/` (state, env bridge, ticket marker) out of git.
             if ((0, dev_patches_1.addToGitignore)(layout.root, '.lt-dev/')) {
                 info(colors.dim('added `.lt-dev/` to .gitignore'));
@@ -231,11 +221,16 @@ const UpCommand = {
                 // process). Free-checking a reused port would falsely abort a partial
                 // restart of just the crashed half.
                 const portsToCheck = [apiPortReused ? undefined : apiPort, appPortReused ? undefined : appPort].filter((p) => typeof p === 'number');
-                const snap = yield (0, dev_process_1.listenSnapshot)(portsToCheck);
+                const probe = yield (0, dev_process_1.probePorts)(portsToCheck);
                 for (const p of portsToCheck) {
-                    const r = snap.get(p);
-                    if (r)
-                        throw new Error(`Internal port ${p} already in use by ${r.command} (pid ${r.pid}).`);
+                    if (!probe.bound.has(p))
+                        continue;
+                    const owner = probe.owners.get(p);
+                    // The port is occupied either way; naming the occupant is a courtesy the
+                    // platform may not be able to extend.
+                    throw new Error(owner
+                        ? `Internal port ${p} already in use by ${owner.command} (pid ${owner.pid}).`
+                        : `Internal port ${p} already in use by an unidentified process.`);
                 }
                 // Reserve immediately so a concurrent `lt dev up` sees these as taken.
                 const subdomainMap = {};
@@ -257,6 +252,26 @@ const UpCommand = {
                 process.exit(1);
             return 'dev up: port in use';
         }
+        // The CLAUDE.md URL block is written HERE, after the internal ports are
+        // resolved, so it can name both addresses: the `*.localhost` name a browser
+        // opens and the loopback address a script must use. It used to run before
+        // allocation, where only the name existed — which is why an agent following
+        // the block had nothing but a hostname that does not resolve for Node on
+        // Windows. NEVER for a ticket worktree: that CLAUDE.md is git-tracked and
+        // would carry per-ticket URLs into a commit.
+        if (!ticket) {
+            const claudeCandidates = [
+                (0, path_1.join)(layout.root, 'CLAUDE.md'),
+                ...(layout.apiDir ? [(0, path_1.join)(layout.apiDir, 'CLAUDE.md')] : []),
+                ...(layout.appDir ? [(0, path_1.join)(layout.appDir, 'CLAUDE.md')] : []),
+            ];
+            const patched = claudeCandidates
+                .map((f) => (0, dev_patches_1.patchClaudeMd)(f, { apiPort, appPort, dbName, identity }))
+                .filter((r) => r.patched);
+            if (patched.length > 0) {
+                info(colors.dim(`updated CLAUDE.md URL block in ${patched.length} file(s)`));
+            }
+        }
         // ── Health-aware (re)start decision ──────────────────────────────────────
         // Probe the just-resolved ports so we can tell a still-serving component
         // from a crashed one (supervisor PID alive, port free). Only dead/crashed
@@ -269,18 +284,18 @@ const UpCommand = {
         // false-positive the `starting` state exists to prevent).
         const hasApi = Boolean(layout.apiDir && (0, fs_1.existsSync)((0, path_1.join)(layout.apiDir, 'package.json')) && apiPort);
         const hasApp = Boolean(layout.appDir && (0, fs_1.existsSync)((0, path_1.join)(layout.appDir, 'package.json')) && appPort);
-        const healthSnap = yield (0, dev_process_1.listenSnapshot)([apiPort, appPort].filter((p) => typeof p === 'number'));
+        const healthProbe = yield (0, dev_process_1.probePorts)([apiPort, appPort].filter((p) => typeof p === 'number'));
         const apiHealth = hasApi
             ? (0, dev_state_1.classifyComponentHealth)({
                 pid: existingSession === null || existingSession === void 0 ? void 0 : existingSession.pids.api,
-                portBound: !!apiPort && healthSnap.has(apiPort),
+                portBound: !!apiPort && healthProbe.bound.has(apiPort),
                 startedAt: existingSession === null || existingSession === void 0 ? void 0 : existingSession.startedAt,
             })
             : undefined;
         const appHealth = hasApp
             ? (0, dev_state_1.classifyComponentHealth)({
                 pid: existingSession === null || existingSession === void 0 ? void 0 : existingSession.pids.app,
-                portBound: !!appPort && healthSnap.has(appPort),
+                portBound: !!appPort && healthProbe.bound.has(appPort),
                 startedAt: existingSession === null || existingSession === void 0 ? void 0 : existingSession.startedAt,
             })
             : undefined;
@@ -374,9 +389,19 @@ const UpCommand = {
         const reclaimPort = (prevPid, port, health) => __awaiter(void 0, void 0, void 0, function* () {
             if (health === 'crashed' && prevPid)
                 yield (0, dev_process_1.terminateProcessGroup)(prevPid);
-            const bound = port ? healthSnap.get(port) : undefined;
-            if (bound === null || bound === void 0 ? void 0 : bound.pid)
-                yield (0, dev_process_1.terminateProcessGroup)(bound.pid);
+            if (!port || !healthProbe.bound.has(port))
+                return;
+            const owner = healthProbe.owners.get(port);
+            if (owner === null || owner === void 0 ? void 0 : owner.pid) {
+                yield (0, dev_process_1.terminateProcessGroup)(owner.pid);
+                return;
+            }
+            // Occupied, but the platform could not name the occupant — so there is
+            // nothing to terminate. Saying so beats respawning onto a taken port and
+            // letting the component fail with an address-in-use nobody connects to this.
+            warning(`port ${port} is in use and the occupant could not be identified` +
+                `${healthProbe.ownersUnavailable ? ' (no lsof/netstat available)' : ''} — ` +
+                'not reclaiming it; the component may fail to bind.');
         });
         if (hasApi && layout.apiDir && apiPort) {
             if (isKeepable(apiHealth)) {
@@ -454,6 +479,19 @@ const UpCommand = {
         //     grace window indefinitely.
         const startedAt = started.length > 0 ? new Date().toISOString() : ((_h = existingSession === null || existingSession === void 0 ? void 0 : existingSession.startedAt) !== null && _h !== void 0 ? _h : new Date().toISOString());
         (0, dev_state_1.saveSession)(layout.root, { pids, startedAt });
+        // A component that dies right after its start used to be reported as
+        // "Started": the spawn succeeded, and nothing looked again. Watch the fresh
+        // pids for a moment and show what the log says (or that it is empty).
+        const earlyExits = yield (0, dev_log_tail_1.findEarlyExits)(started.map((name) => ({ name, pid: pids[name] })), { budgetMs: 3000, isAlive: dev_state_1.isPidAlive });
+        if (earlyExits.length > 0) {
+            for (const name of earlyExits) {
+                error(`${name} exited right after its start (pid ${pids[name]}).`);
+                (0, dev_log_tail_1.describeLog)((0, dev_log_tail_1.diagnoseLog)((0, path_1.join)(layout.root, '.lt-dev', `${name}.log`))).forEach((l) => info(l));
+            }
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return `dev up: ${earlyExits.join('+')} exited on start`;
+        }
         // Write the ENV bridge so external tools (Playwright, IDE test runners,
         // custom shell scripts) can pick up the URLs without inheriting our shell.
         const bridgePath = (0, dev_env_bridge_1.writeEnvBridge)(layout.root, devEnv, dbName);

package/build/commands/fullstack/init.js

@@ -488,7 +488,7 @@ const NewCommand = {
             yield system.run(`cd ${projectDir} && git init --initial-branch=dev`);
         }
         catch (err) {
-            error(`Failed to initialize git: ${err.message}`);
+            ngBaseSpinner.fail(`Failed to initialize git: ${err.message}`);
             (0, fail_run_1.failRun)(toolbox);
             return;
         }
@@ -498,7 +498,7 @@ const NewCommand = {
                 yield system.run(`cd ${projectDir} && git remote add origin ${gitLink}`);
             }
             catch (err) {
-                error(`Failed to add remote: ${err.message}`);
+                ngBaseSpinner.fail(`Failed to add remote: ${err.message}`);
                 (0, fail_run_1.failRun)(toolbox);
                 return;
             }
@@ -526,7 +526,7 @@ const NewCommand = {
             });
         }
         if (!frontendResult.success) {
-            error(`Failed to set up ${frontend} frontend: ${frontendResult.path}`);
+            ngBaseSpinner.fail(`Failed to set up ${frontend} frontend: ${frontendResult.path}`);
             (0, fail_run_1.failRun)(toolbox);
             return;
         }
@@ -774,6 +774,15 @@ const NewCommand = {
             // For tests
             return `new workspace ${projectDir} with ${name}`;
         }
+        else {
+            // The frontend setup reported success but left no `projects/app`. Without this
+            // branch the command fell off the end here: no message, no failing exit code,
+            // and `ngBaseSpinner` still spinning — which keeps the event loop alive (see
+            // the spinner note in CLAUDE.md), so the process never returned at all.
+            ngBaseSpinner.fail(`${frontend} was set up but "${projectDir}/projects/app" does not exist — cannot continue`);
+            (0, fail_run_1.failRun)(toolbox);
+            return;
+        }
     }),
 };
 exports.default = NewCommand;

package/build/commands/git/squash.js

@@ -129,7 +129,10 @@ const NewCommand = {
         const mergeBaseSpin = spin(`Get merge ${base}`);
         const mergeBase = yield git.getMergeBase(base);
         if (!mergeBase) {
-            error('No merge base found!');
+            // `fail` rather than `error` + `return`: a running spinner holds the event
+            // loop open (ora resumes stdin and keeps a render interval), so the old
+            // shape did not just print and leave — the command never exited at all.
+            mergeBaseSpin.fail(`No merge base found with ${base}!`);
             return;
         }
         mergeBaseSpin.succeed();

package/build/extensions/api-mode.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiMode = void 0;
 const glob_1 = require("glob");
 const path_1 = require("path");
+const config_env_graphql_1 = require("../lib/config-env-graphql");
 /**
  * API Mode processing for nest-server-starter template
  *
@@ -46,11 +47,18 @@ class ApiMode {
                 // REST mode: remove graphql regions, keep rest regions
                 yield this.removeMode(projectPath, manifest, 'graphql', 'rest');
                 yield this.modifyConfigEnvForRest(projectPath);
+                this.assertGraphQlDisabled(projectPath);
             }
             else if (mode === 'GraphQL') {
                 // GraphQL mode: remove rest regions, keep graphql regions
                 yield this.removeMode(projectPath, manifest, 'rest', 'graphql');
             }
+            // Both conversions above must leave no marker behind. Verified rather than
+            // assumed: a strip that quietly does nothing reports success just as loudly as
+            // one that worked (see assertNoMarkersRemain).
+            if (mode !== 'Both') {
+                this.assertNoMarkersRemain(projectPath, mode === 'Rest' ? 'graphql' : 'rest');
+            }
             // Remove manifest and strip-markers script
             this.filesystem.remove(manifestPath);
             this.filesystem.remove((0, path_1.join)(projectPath, 'scripts', 'strip-api-mode-markers.mjs'));
@@ -167,6 +175,67 @@ class ApiMode {
             this.cleanOrphanImports(projectPath);
         });
     }
+    /**
+     * Final check of the REST conversion: every environment block in `config.env.ts`
+     * must disable GraphQL.
+     *
+     * `CoreModule.forRoot` reads a missing `graphQl` as ENABLED, so a block without it
+     * yields a project that fails at START time with `Cannot determine a GraphQL output
+     * type for the "arguments"` — long after the generator reported success. Every step
+     * before this one REPLACES an existing property; none of them adds a missing one, so
+     * nothing guaranteed the outcome.
+     *
+     * Repairs what it can (insert the switch) and throws when a block still lacks it,
+     * rather than handing over a project that cannot boot.
+     */
+    assertGraphQlDisabled(projectPath) {
+        const configPath = (0, path_1.join)(projectPath, 'src', 'config.env.ts');
+        const content = this.filesystem.read(configPath);
+        if (!content) {
+            return;
+        }
+        const { added, content: repaired } = (0, config_env_graphql_1.disableGraphQlInEveryEnvBlock)(content);
+        if (added.length > 0) {
+            this.filesystem.write(configPath, repaired);
+        }
+        const offenders = (0, config_env_graphql_1.envBlocksWithoutGraphQlDisabled)(repaired);
+        if (offenders.length > 0) {
+            throw new Error(`REST conversion incomplete: src/config.env.ts has no \`graphQl: false\` in ${offenders.join(', ')}. ` +
+                'The framework treats a missing switch as GraphQL ENABLED, and the server would fail to start. ' +
+                'Add it to those environment blocks and re-run.');
+        }
+    }
+    /**
+     * Refuse to hand over a project that still carries markers of the removed mode.
+     *
+     * A leftover `// #region graphql` announces a mode the project does not have — and,
+     * worse, means the region CONTENT is still there: resolvers, graphql-only wiring,
+     * e2e specs. That is what a silent no-op looks like from the outside, and the strip
+     * used to be exactly that on Windows (fixed in the glob helper above): it reported
+     * success while touching nothing.
+     *
+     * Cheap, and it fails at generation time instead of in the user's editor.
+     */
+    assertNoMarkersRemain(projectPath, removedMarker) {
+        const marked = [];
+        for (const dir of ['src', 'tests']) {
+            const base = (0, path_1.join)(projectPath, dir);
+            if (!this.filesystem.exists(base)) {
+                continue;
+            }
+            for (const file of this.globFiles(base, '**/*.ts')) {
+                const content = this.filesystem.read(file);
+                if ((content === null || content === void 0 ? void 0 : content.includes(`// #region ${removedMarker}`)) || (content === null || content === void 0 ? void 0 : content.includes(`// #endregion ${removedMarker}`))) {
+                    marked.push(`${dir}/${(0, path_1.basename)(file)}`);
+                }
+            }
+        }
+        if (marked.length > 0) {
+            throw new Error(`API-mode conversion incomplete: ${marked.length} file(s) still carry \`// #region ${removedMarker}\` ` +
+                `markers (${marked.slice(0, 5).join(', ')}${marked.length > 5 ? ', …' : ''}). ` +
+                'The region content was not removed, so this project still contains code of a mode it does not have.');
+        }
+    }
     /**
      * Resolve a POSIX-style glob pattern against `baseDir` and return the
      * matching files as absolute, OS-native paths.

package/build/extensions/frontend-helper.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FrontendHelper = void 0;
 const check_freshness_hooks_1 = require("../lib/check-freshness-hooks");
 const markdown_table_1 = require("../lib/markdown-table");
-const strip_comments_1 = require("../lib/strip-comments");
+const module_specifiers_1 = require("../lib/module-specifiers");
 const strip_vendor_schema_augmentation_1 = require("../lib/strip-vendor-schema-augmentation");
 const vendor_claude_md_1 = require("../lib/vendor-claude-md");
 /**
@@ -399,7 +399,7 @@ class FrontendHelper {
                 }
             }
             // ── Post-conversion verification ─────────────────────────────────────
-            const stale = this.findStaleFrontendImports(dest, /from\s+['"]\..*\/core['"]/);
+            const stale = this.findStaleFrontendImports(dest, module_specifiers_1.isRelativeCoreImport);
             if (stale.length > 0) {
                 const { print } = this.toolbox;
                 print.warning(`${stale.length} file(s) still contain relative core imports after npm conversion:`);
@@ -716,8 +716,7 @@ class FrontendHelper {
                 ].join('\n'));
             }
             // ── Post-conversion verification ─────────────────────────────────────
-            // Only match actual import/from statements, not comments or strings
-            const staleImports = this.findStaleFrontendImports(dest, /(?:^|\s)(?:import|from)\s+['"][^'"]*@lenne\.tech\/nuxt-extensions/m, 'app/core/');
+            const staleImports = this.findStaleFrontendImports(dest, (specifier) => (0, module_specifiers_1.isPackageImport)(specifier, '@lenne.tech/nuxt-extensions'), 'app/core/');
             if (staleImports.length > 0) {
                 const { print } = this.toolbox;
                 print.warning(`${staleImports.length} file(s) still contain '@lenne.tech/nuxt-extensions' imports after vendor conversion:`);
@@ -826,20 +825,20 @@ class FrontendHelper {
     /**
      * Scan consumer files for stale imports matching a pattern.
      */
-    findStaleFrontendImports(appDir, needle, skipPathContaining) {
+    findStaleFrontendImports(appDir, matches, skipPathContaining) {
         const { filesystem } = this.toolbox;
         const allFiles = this.walkConsumerFiles(appDir);
         const stale = [];
         for (const absFile of allFiles) {
             if (skipPathContaining && absFile.includes(skipPathContaining))
                 continue;
-            // Strip comments first — a docblock that DOCUMENTS the conversion legitimately quotes the
-            // very import syntax this looks for, and would otherwise be reported as a file the user has
-            // to fix by hand. Same false-positive class that hit the backend detector on
-            // nest-server-starter's bootstrap-diagnostics.spec.ts.
-            const content = (0, strip_comments_1.stripComments)(filesystem.read(absFile) || '');
-            const matches = typeof needle === 'string' ? content.includes(needle) : needle.test(content);
-            if (matches) {
+            // Ask the parser for the file's module specifiers instead of searching its text.
+            // A docblock that DOCUMENTS the conversion quotes the very import syntax a text
+            // search looks for, and blanking comments first does not hold either — see
+            // src/lib/module-specifiers.ts. A comment is not part of the AST, so the whole
+            // false-positive class is gone rather than worked around.
+            const specifiers = (0, module_specifiers_1.fileImportedSpecifiers)(absFile, (path) => filesystem.read(path) || undefined);
+            if (specifiers.some(matches)) {
                 stale.push(absFile.replace(`${appDir}/`, ''));
             }
         }