@lenne.tech/cli 1.39.0 → 1.40.0

package/build/commands/dev/up.js

@@ -9,9 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.help = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const caddy_1 = require("../../lib/caddy");
+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");
@@ -112,6 +114,10 @@ const UpCommand = {
         // suffixed so the stack is fully isolated from the base dev session and every
         // other ticket. Without a ticket this is the plain project identity.
         const { dbName, identity, ticket } = (0, dev_ticket_1.resolveDevIdentity)(layout, { ticket: parameters.options.ticket });
+        // `--api-compiled`: run the API compiled (`node dist`) instead of ts-node.
+        // Trades hot reload for stability — ts-node intermittently dies under browser
+        // load without a stacktrace (DEV-2525); `lt dev test` already runs compiled.
+        const apiCompiled = (0, dev_api_launch_1.isApiCompiledRequested)(parameters.options);
         // Guard against two checkouts of the SAME project (same package.json "name"
         // → same slug → shared URLs / ports / DB / Caddy block). If another checkout
         // is already RUNNING under this slug, abort with a clear message — otherwise
@@ -321,7 +327,7 @@ const UpCommand = {
         if (identity.subdomains.app)
             info(`  app: https://${identity.subdomains.app.hostname}  →  127.0.0.1:${appPort}`);
         if (identity.subdomains.api)
-            info(`  api: https://${identity.subdomains.api.hostname}  →  127.0.0.1:${apiPort}`);
+            info(`  api: https://${identity.subdomains.api.hostname}  →  127.0.0.1:${apiPort}${apiCompiled ? colors.dim('  (compiled, no hot reload)') : ''}`);
         if (identity.subdomains.api)
             info(`  db:  mongodb://127.0.0.1/${dbName}`);
         info('');
@@ -353,6 +359,11 @@ const UpCommand = {
             if (apiHealth === 'running') {
                 pids.api = existingSession === null || existingSession === void 0 ? void 0 : existingSession.pids.api;
                 kept.push('api');
+                // `--api-compiled` only takes effect when the API (re)starts; a healthy API is
+                // kept as-is (force-restarting it would contradict the keep logic), so tell the
+                // user how to switch a currently-running ts-node API to compiled.
+                if (apiCompiled)
+                    info(colors.dim('  --api-compiled: API already running — `lt dev down` first to switch it.'));
             }
             else {
                 yield reclaimPort(existingSession === null || existingSession === void 0 ? void 0 : existingSession.pids.api, apiPort, apiHealth !== null && apiHealth !== void 0 ? apiHealth : 'dead');
@@ -361,11 +372,20 @@ const UpCommand = {
                 // regenerate a foreign lockfile + crash on un-approved build
                 // scripts when run against an npm-only project.
                 const apiPm = (0, dev_package_manager_1.pickPackageManager)(layout.apiDir);
-                const apiResult = (0, dev_process_1.spawnDetached)(apiPm.bin, apiPm.runScript('start'), {
-                    cwd: layout.apiDir,
-                    env: devEnv.api.env,
-                    logFile: (0, path_1.join)(layout.root, '.lt-dev', 'api.log'),
-                });
+                const apiLogFile = (0, path_1.join)(layout.root, '.lt-dev', 'api.log');
+                const apiResult = apiCompiled
+                    ? yield (0, dev_api_launch_1.startCompiledApi)({
+                        apiDir: layout.apiDir,
+                        env: devEnv.api.env,
+                        log: { info, warn: warning },
+                        logFile: apiLogFile,
+                        pm: apiPm,
+                    })
+                    : (0, dev_process_1.spawnDetached)(apiPm.bin, apiPm.runScript('start'), {
+                        cwd: layout.apiDir,
+                        env: devEnv.api.env,
+                        logFile: apiLogFile,
+                    });
                 if (apiResult) {
                     pids.api = apiResult.pid;
                     started.push('api');
@@ -502,4 +522,28 @@ const UpCommand = {
         return `dev up: api=${pids.api}, app=${pids.app}`;
     }),
 };
-module.exports = UpCommand;
+exports.help = {
+    aliases: ['u'],
+    configuration: 'Ephemeral dev-orchestration flags — no lt.config counterpart. Override the spawn binary for both processes via the LT_PNPM_BIN env var.',
+    description: 'Start the API + App behind Caddy under stable https://<slug>.localhost URLs. Health-aware and idempotent: re-running (re)starts only the component(s) that are not truly serving.',
+    examples: ['dev up', 'dev up --api-compiled', 'dev up --ticket DEV-1234'],
+    features: [
+        'Registers a Caddy block and allocates opaque internal ports (4000+).',
+        'Spawns API + App detached; persists PIDs to <root>/.lt-dev/state.json.',
+        'Self-heals legacy hardcoded ports and restarts only the down component(s).',
+    ],
+    name: 'up',
+    options: [
+        {
+            description: 'Run the API compiled (node dist/src/main.js) instead of ts-node — trades hot reload for stability under browser load (DEV-2525). Builds + migrates first; falls back to the ts-node start if the build fails. Only applies when the API (re)starts.',
+            flag: '--api-compiled',
+            type: 'boolean',
+        },
+        {
+            description: 'Suffix the slug / URLs / DB for an isolated ticket stack (also auto-detected from a .lt-dev/ticket marker).',
+            flag: '--ticket',
+            type: 'string',
+        },
+    ],
+};
+module.exports = Object.assign(UpCommand, { help: exports.help });

package/build/lib/dev-api-launch.js

@@ -0,0 +1,89 @@
+"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.findCompiledEntry = findCompiledEntry;
+exports.isApiCompiledRequested = isApiCompiledRequested;
+exports.startCompiledApi = startCompiledApi;
+/**
+ * Launch strategy for the API process under `lt dev up`.
+ *
+ * By default `lt dev up` runs the API via ts-node (`<pm> run start` → nodemon →
+ * ts-node src/main.ts) for hot reload. Under a browser driving the app, that
+ * ts-node process intermittently dies WITHOUT a stacktrace (dev-SSR load plus
+ * ts-node's heavier footprint) — see DEV-2525. `lt dev test` already sidesteps
+ * this by running the API COMPILED (`node dist/src/main.js`); this module brings
+ * the same option to `lt dev up`, opt-in via `--api-compiled`. The trade-off is
+ * NO hot reload, so it stays opt-in — the caller decides stability vs. reload.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const dev_process_1 = require("./dev-process");
+/** Candidate compiled entry points, in preference order. Single-sourced so `lt dev test` agrees. */
+const COMPILED_ENTRIES = ['dist/src/main.js', 'dist/main.js'];
+/** Resolve the compiled API entry point in `apiDir`, or `undefined` if none was built. */
+function findCompiledEntry(apiDir) {
+    return COMPILED_ENTRIES.map((rel) => (0, node_path_1.join)(apiDir, rel)).find((candidate) => (0, node_fs_1.existsSync)(candidate));
+}
+/**
+ * True when the caller opted into the compiled API via `--api-compiled`.
+ *
+ * gluegun parses argv with yargs-parser and declares no booleans, so the flag
+ * arrives in several shapes: a value-less `--api-compiled` → boolean `true`, but
+ * `--api-compiled=true` → the STRING `'true'` and `--api-compiled=1` → the NUMBER
+ * `1`. A bare `=== true` check silently ignores the latter two and drops the very
+ * stability fix the user asked for. This is an ENABLE flag, so a mis-parse fails
+ * SAFE (default ts-node) — but the repo convention is to honour `true`/`'true'`
+ * too (see `dev-ticket.ts#keepDbFlag` for the destructive-flag counterpart).
+ */
+function isApiCompiledRequested(options = {}) {
+    const affirmative = (value) => value === true || ['1', 'true', 'yes'].includes(String(value).toLowerCase());
+    return affirmative(options.apiCompiled) || affirmative(options['api-compiled']);
+}
+/**
+ * Build the API and start it compiled (`node dist/src/main.js`). Applies pending
+ * migrations first for parity with the ts-node path it replaces (`<pm> run start`
+ * = `migrate:up && start:local`). Falls back to the ts-node start when the build
+ * fails or produces no dist entry, so this never leaves the developer with a dead
+ * API. Returns the detached spawn result (`undefined` when nothing was started).
+ */
+function startCompiledApi(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apiDir, env, log, logFile, pm } = options;
+        log.info('Building API (compiled, for stability — no hot reload) …');
+        const build = yield (0, dev_process_1.runChildInherit)(pm.bin, pm.runScript('build'), { cwd: apiDir, env });
+        const entry = findCompiledEntry(apiDir);
+        if (build === 0 && entry) {
+            if (hasScript(apiDir, 'migrate:up')) {
+                const migrate = yield (0, dev_process_1.runChildInherit)(pm.bin, pm.runScript('migrate:up'), { cwd: apiDir, env });
+                if (migrate !== 0) {
+                    // Parity with `migrate:up && start:local`: a failed migration must PREVENT the server
+                    // from starting rather than boot it against a half-migrated DB behind a "Started" banner.
+                    log.warn(`migrate:up failed (exit ${String(migrate)}) — API NOT started (would run on an un-migrated DB).`);
+                    return undefined;
+                }
+            }
+            return (0, dev_process_1.spawnDetached)('node', [entry], { cwd: apiDir, env: Object.assign(Object.assign({}, env), { NODE_ENV: 'local' }), logFile });
+        }
+        log.warn(`compiled API unavailable (build exit ${String(build)}) — falling back to \`${pm.bin} start\` (ts-node).`);
+        return (0, dev_process_1.spawnDetached)(pm.bin, pm.runScript('start'), { cwd: apiDir, env, logFile });
+    });
+}
+/** True when `package.json` in `apiDir` defines a script named `name`. */
+function hasScript(apiDir, name) {
+    var _a;
+    try {
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(apiDir, 'package.json'), 'utf8'));
+        return typeof ((_a = pkg.scripts) === null || _a === void 0 ? void 0 : _a[name]) === 'string';
+    }
+    catch (_b) {
+        return false;
+    }
+}

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

@@ -47,6 +47,7 @@ const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const caddy_1 = require("./caddy");
+const dev_api_launch_1 = require("./dev-api-launch");
 const dev_env_1 = require("./dev-env");
 const dev_env_bridge_1 = require("./dev-env-bridge");
 const dev_identity_1 = require("./dev-identity");
@@ -245,9 +246,7 @@ function bringUpTestSession(layout_1, baseIdentity_1, log_1) {
                 log.info(log.dim('Building API (compiled, for stable long runs) …'));
                 build = yield (0, dev_process_1.runChildInherit)(apiPm.bin, apiPm.runScript('build'), { cwd: layout.apiDir, env: process.env });
             }
-            const entry = ['dist/src/main.js', 'dist/main.js']
-                .map((rel) => (0, path_1.join)(layout.apiDir, rel))
-                .find((p) => (0, fs_1.existsSync)(p));
+            const entry = (0, dev_api_launch_1.findCompiledEntry)(layout.apiDir);
             // Seed a throwaway initial admin into the fresh, isolated test DB so the
             // standard auth E2E specs run against a set-up system — locally exactly like
             // the lt-monorepo template CI. Defaults first so an explicitly inherited

package/docs/commands.md

@@ -433,6 +433,13 @@ lt dev up
 
 **Alias:** `lt d u`
 
+**Flags:**
+- `--api-compiled` — run the API **compiled** (`node dist/src/main.js`) instead of ts-node. Trades hot reload for stability: under sustained browser / dev-SSR load the ts-node API process intermittently dies without a stacktrace (DEV-2525); the compiled `node` process does not. Opt-in — omit it for the default ts-node hot-reload start. Details:
+  - Builds the API first, then applies pending migrations (`migrate:up`) for parity with the default `migrate:up && start:local`; a failed migration aborts the start rather than booting against a half-migrated DB.
+  - Auto-falls-back to the ts-node `start` if the build fails or produces no `dist` entry, so you never end up with a dead API.
+  - Only takes effect when the API actually (re)starts. A healthy running API is kept as-is — run `lt dev down` first to switch a live ts-node API to compiled.
+  - Accepted spellings: `--api-compiled` or `--api-compiled=true`.
+
 **Environment variables injected:**
 | Variable | Consumer | Example value |
 |----------|----------|---------------|
@@ -467,8 +474,10 @@ Behaviour:
   reclaims any orphaned listener still squatting the reused port.
 
 This is the fix for the "`status` says api running but no data loads" case: a
-crashed ts-node dev API is healed by simply re-running `lt dev up` (it does not
-fall back to compiled `node dist` — ts-node is kept so code edits hot-reload).
+crashed ts-node dev API is healed by simply re-running `lt dev up`. The **automatic**
+heal keeps ts-node (it does not silently switch to compiled `node dist`, so code
+edits still hot-reload); pass the explicit `--api-compiled` flag (see **Flags** above)
+when you deliberately want to trade hot reload for compiled stability.
 
 **Logs:** `<root>/.lt-dev/api.log`, `<root>/.lt-dev/app.log` (append-mode).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/cli",
-  "version": "1.39.0",
+  "version": "1.40.0",
   "description": "lenne.Tech CLI: lt",
   "keywords": [
     "lenne.Tech",