@lenne.tech/cli 1.48.0 → 1.50.0

package/build/lib/dev-env.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildDevEnv = buildDevEnv;
+exports.internalUrl = internalUrl;
 /**
  * Build environment variables for `lt dev up`.
  *
@@ -41,13 +42,16 @@ function buildDevEnv(input) {
     const appSub = identity.subdomains.app;
     const apiUrl = apiSub ? `https://${apiSub.hostname}` : '';
     const appUrl = appSub ? `https://${appSub.hostname}` : '';
+    // Same two services, addressed the way Node can reach them. See `internalUrl`.
+    const apiInternal = internalUrl(apiInternalPort);
+    const appInternal = internalUrl(appInternalPort);
     const caPath = (0, dev_env_bridge_1.detectCaddyRootCa)();
-    const sharedKeys = Object.assign(Object.assign(Object.assign(Object.assign({ 
+    const sharedKeys = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ 
         // Marks the API + App processes as running under `lt dev`. Consumed by the
         // backend to relax dev-only behaviour (rate limiting, Better-Auth
         // user-cache) so E2E suites run without a separate VITEST/PLAYWRIGHT flag.
         // (Also written to the .lt-dev/.env bridge for external test runners.)
-        LT_DEV_ACTIVE: 'true' }, (apiUrl ? { BASE_URL: apiUrl, NSC__BASE_URL: apiUrl } : {})), (appUrl ? { APP_URL: appUrl, NSC__APP_URL: appUrl } : {})), (dbName ? { DATABASE_URL: buildPostgresUrl(dbName), NSC__MONGOOSE__URI: `mongodb://127.0.0.1/${dbName}` } : {})), (caPath ? { NODE_EXTRA_CA_CERTS: caPath } : {}));
+        LT_DEV_ACTIVE: 'true' }, (apiInternal ? { LT_DEV_API_INTERNAL_URL: apiInternal } : {})), (appInternal ? { LT_DEV_APP_INTERNAL_URL: appInternal } : {})), (apiUrl ? { BASE_URL: apiUrl, NSC__BASE_URL: apiUrl } : {})), (appUrl ? { APP_URL: appUrl, NSC__APP_URL: appUrl } : {})), (dbName ? { DATABASE_URL: buildPostgresUrl(dbName), NSC__MONGOOSE__URI: `mongodb://127.0.0.1/${dbName}` } : {})), (caPath ? { NODE_EXTRA_CA_CERTS: caPath } : {}));
     return {
         api: {
             env: Object.assign(Object.assign(Object.assign({}, baseEnv), sharedKeys), { 
@@ -59,10 +63,10 @@ function buildDevEnv(input) {
             internalPort: apiInternalPort,
         },
         app: {
-            env: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, baseEnv), sharedKeys), { 
+            env: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, baseEnv), sharedKeys), { 
                 // See API note above: pin the dev server to IPv4 so Caddy's
                 // `127.0.0.1` upstream is unambiguous.
-                HOST: '127.0.0.1', NITRO_HOST: '127.0.0.1' }), (apiUrl ? { API_URL: apiUrl, NUXT_API_URL: apiUrl, NUXT_PUBLIC_API_URL: apiUrl } : {})), (appUrl ? { NUXT_PUBLIC_SITE_URL: appUrl, SITE_URL: appUrl } : {})), { 
+                HOST: '127.0.0.1', NITRO_HOST: '127.0.0.1' }), (apiUrl ? { API_URL: apiUrl, NUXT_PUBLIC_API_URL: apiUrl } : {})), (apiInternal || apiUrl ? { NUXT_API_URL: apiInternal || apiUrl } : {})), (appUrl ? { NUXT_PUBLIC_SITE_URL: appUrl, SITE_URL: appUrl } : {})), { 
                 // Vite-API-Proxy is OFF by default in lt dev mode — Caddy serves
                 // both subdomains under HTTPS with shared cookie domain, so
                 // same-origin trickery is no longer required.
@@ -75,6 +79,42 @@ function buildDevEnv(input) {
         },
     };
 }
+/**
+ * The loopback address of a component, for anything that RESOLVES a name.
+ *
+ * `lt dev` is URL-first: a project is reached at `https://<slug>.localhost`, and
+ * Caddy proxies that to an opaque internal port. That promise holds for
+ * **browsers**. It does not hold for Node: on Windows `*.localhost` subdomains do
+ * not resolve at all (`dns.lookup('api.demo.localhost')` → ENOTFOUND, and `curl`
+ * agrees), while Chromium resolves them internally without asking a resolver.
+ *
+ * So the question at every call site is not "which URL" but **"who reads it"**:
+ *
+ * | | example | address to use |
+ * |---|---|---|
+ * | a browser resolves it | Playwright `baseURL`, a printed link | the public name |
+ * | Node resolves it | readiness probes, SSR fetches, a proxy target | **this** |
+ * | another binary resolves it | `cloudflared` | **this** |
+ * | nobody resolves it — it is COMPARED | `APP_URL` (CORS / `trustedOrigins`), the Caddy vhost matcher, the tunnel `Host:` header | the public name, untouched |
+ *
+ * That last row is why "rewrite every internal URL to 127.0.0.1" would be wrong:
+ * `APP_URL` is matched as a string against the `Origin` header a browser sends,
+ * and the browser arrives from `https://<slug>.localhost`. Rewriting it would
+ * break every login — on the platform where only a health probe was broken before.
+ *
+ * **Loopback on every platform, not only on Windows.** 127.0.0.1 works everywhere,
+ * so there is no branch to get wrong, and the path Windows depends on is the one
+ * macOS exercises daily. A branch only the other platform runs is an unchecked
+ * branch.
+ *
+ * One consequence to keep in mind: this goes PAST Caddy. For "is the component
+ * alive?" that is an advantage — it measures the component, not the proxy. For
+ * "does the routing work?" it is the wrong question, and that one belongs to
+ * `lt dev doctor` over the public name.
+ */
+function internalUrl(port) {
+    return port ? `http://127.0.0.1:${port}` : '';
+}
 /** Postgres convenience URL — used by Postgres-based projects (e.g. nest-base). */
 function buildPostgresUrl(dbName) {
     return `postgresql://${dbName}:${dbName}@localhost:5432/${dbName}`;

package/build/lib/dev-log-tail.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeLog = describeLog;
+exports.diagnoseLog = diagnoseLog;
+exports.findEarlyExits = findEarlyExits;
+exports.isSilentLog = isSilentLog;
+exports.tailLines = tailLines;
+/**
+ * What a component's log can tell someone whose component just died.
+ *
+ * Two silent failures made this necessary, both seen on a Windows laptop:
+ * `lt dev up` reported success for an API that was dead seconds later, and its
+ * log file existed, was even rotated, but stayed at 0 bytes, so nobody looked in
+ * the extra console window that held the actual error. A diagnosis therefore has
+ * to tell "the log says X" apart from "the log is empty", and say the latter out
+ * loud instead of printing nothing.
+ */
+const fs_1 = require("fs");
+/**
+ * The lines to print under "<name> is not running". Never an empty list: an
+ * empty or missing log is itself the finding.
+ */
+function describeLog(d) {
+    if (d.state === 'missing')
+        return [`No log at ${d.file}.`];
+    if (d.state === 'empty') {
+        return [`${d.file} is EMPTY — the output was not captured, so the reason is not in the log.`];
+    }
+    return [`Last lines of ${d.file}:`, ...d.tail.map((l) => `  ${l}`)];
+}
+/** Read `file` and keep its last `lines` non-empty lines. */
+function diagnoseLog(file, lines = 20) {
+    if (!(0, fs_1.existsSync)(file))
+        return { file, size: -1, state: 'missing', tail: [] };
+    const size = (0, fs_1.statSync)(file).size;
+    if (size === 0)
+        return { file, size, state: 'empty', tail: [] };
+    return { file, size, state: 'ok', tail: tailLines((0, fs_1.readFileSync)(file, 'utf8'), lines) };
+}
+/**
+ * Components whose pid is gone within `budgetMs` of their start.
+ *
+ * Catches what dies at once: a missing script, a package manager that cannot
+ * start, a crash before any watcher takes over. A crash under nodemon keeps the
+ * supervisor alive and is `lt dev status`'s job (`crashed` after the grace window).
+ */
+function findEarlyExits(components, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const sleep = (_a = opts.sleep) !== null && _a !== void 0 ? _a : ((ms) => new Promise((r) => setTimeout(r, ms)));
+        const watched = components.filter((c) => typeof c.pid === 'number');
+        const dead = new Set();
+        const deadline = Date.now() + opts.budgetMs;
+        do {
+            for (const c of watched)
+                if (!dead.has(c.name) && !opts.isAlive(c.pid))
+                    dead.add(c.name);
+            if (dead.size === watched.length)
+                break;
+            yield sleep(250);
+        } while (Date.now() < deadline);
+        return watched.filter((c) => dead.has(c.name)).map((c) => c.name);
+    });
+}
+/**
+ * True when a component has been up for `minAgeMs` and its log is still empty.
+ * A booting app writes within seconds (nuxt/nest print a banner), so an empty
+ * log after that means output is going somewhere else, not that nothing happened.
+ */
+function isSilentLog(d, startedAt, now, minAgeMs = 15000) {
+    if (d.state !== 'empty' || !startedAt)
+        return false;
+    const age = now - new Date(startedAt).getTime();
+    return Number.isFinite(age) && age >= minAgeMs;
+}
+/** Last `n` non-empty lines of `content`, oldest first. */
+function tailLines(content, n) {
+    return content
+        .split(/\r?\n/)
+        .filter((l) => l.trim().length > 0)
+        .slice(-n);
+}

package/build/lib/dev-package-manager.js

@@ -74,16 +74,20 @@ function buildCommand(bin, name) {
         },
     };
 }
+/**
+ * Manager behind an override like `LT_PM_BIN`.
+ *
+ * Reads the file NAME, split on both separators and stripped of a Windows launcher
+ * extension: there the binary is `C:\\…\\pnpm.cmd`, which neither `endsWith('pnpm')`
+ * nor `includes('/pnpm')` matched — the override then resolved to `unknown` and the
+ * caller drove the wrong manager.
+ */
 function inferNameFromBin(bin) {
-    const lower = bin.toLowerCase();
-    if (lower.endsWith('pnpm') || lower.includes('/pnpm')) {
-        return 'pnpm';
-    }
-    if (lower.endsWith('yarn') || lower.includes('/yarn')) {
-        return 'yarn';
-    }
-    if (lower.endsWith('npm') || lower.includes('/npm')) {
-        return 'npm';
+    var _a;
+    const file = (_a = bin.toLowerCase().split(/[\\/]/).pop()) !== null && _a !== void 0 ? _a : '';
+    const name = file.replace(/\.(bat|cmd|exe|ps1)$/, '');
+    if (name === 'pnpm' || name === 'yarn' || name === 'npm') {
+        return name;
     }
     return 'unknown';
 }

package/build/lib/dev-patches.js

@@ -125,7 +125,7 @@ function patchApiConfig(file) {
  * in place.
  */
 function patchClaudeMd(file, options) {
-    const { dbName, identity } = options;
+    const { apiPort, appPort, dbName, identity } = options;
     const startMarker = '<!-- lt-dev:url-block:start -->';
     const endMarker = '<!-- lt-dev:url-block:end -->';
     const apiSub = identity.subdomains.api;
@@ -150,10 +150,20 @@ function patchClaudeMd(file, options) {
         '**Active URLs for THIS project:**',
         '',
     ];
-    if (appSub)
-        lines.push(`- App: \`https://${appSub.hostname}\``);
-    if (apiSub)
-        lines.push(`- API: \`https://${apiSub.hostname}\``);
+    // Both addresses, with who each one is for. The block tells an agent never to
+    // assume `localhost:3000/3001` — so if it only named the `*.localhost` host, an
+    // agent following it would `curl` a name that does not resolve for Node on
+    // Windows, and fail silently. The browser address stays first: it is the one a
+    // human opens.
+    if (appSub) {
+        lines.push(`- App: \`https://${appSub.hostname}\`${appPort ? ` — from a script: \`http://127.0.0.1:${appPort}\`` : ''}`);
+    }
+    if (apiSub) {
+        lines.push(`- API: \`https://${apiSub.hostname}\`${apiPort ? ` — from a script: \`http://127.0.0.1:${apiPort}\`` : ''}`);
+    }
+    if (appPort || apiPort) {
+        lines.push('- The `*.localhost` names are resolved by BROWSERS. Node, `curl` and other tools may not resolve them (they do not on Windows) — use the loopback address from a script.');
+    }
     if (dbName)
         lines.push(`- DB: \`mongodb://127.0.0.1/${dbName}\``);
     lines.push('');