@lenne.tech/cli 1.20.0 → 1.21.0

package/build/commands/ports/scan.js

@@ -0,0 +1,131 @@
+"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 });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const port_registry_1 = require("../../lib/port-registry");
+/**
+ * Rebuild the port registry from the filesystem.
+ *
+ * Walks the given directory (default: cwd) up to depth 3, looking for
+ * `lt.config.json` + `package.json` pairs or workspace markers. Re-allocates
+ * a slot for each new project found; preserves slots for projects whose
+ * names already exist in the registry.
+ */
+const ScanCommand = {
+    alias: [],
+    description: 'Rebuild port registry',
+    hidden: false,
+    name: 'scan',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { filesystem, parameters, print: { colors, info, success }, } = toolbox;
+        const startDir = parameters.first ? filesystem.path(parameters.first) : filesystem.cwd();
+        info('');
+        info(colors.bold(`Scanning for projects under ${startDir} ...`));
+        const found = walkForProjects(startDir, 0, 3);
+        info(colors.dim(`Found ${found.length} candidate project(s)`));
+        const registry = (0, port_registry_1.loadRegistry)();
+        let added = 0;
+        let kept = 0;
+        let dirty = false;
+        for (const project of found) {
+            const slug = (0, port_registry_1.projectSlug)(project.path);
+            const existing = registry.projects[slug];
+            if (existing) {
+                if (existing.path !== project.path) {
+                    existing.path = project.path;
+                    dirty = true;
+                }
+                kept++;
+                continue;
+            }
+            const slot = (0, port_registry_1.allocateSlot)(slug, registry);
+            registry.projects[slug] = { path: project.path, ports: (0, port_registry_1.portsForSlot)(slot), slot };
+            added++;
+            dirty = true;
+        }
+        if (dirty)
+            (0, port_registry_1.saveRegistry)(registry);
+        success(`Registry updated: ${added} new, ${kept} kept (total: ${Object.keys(registry.projects).length})`);
+        if (!parameters.options.fromGluegunMenu) {
+            process.exit();
+        }
+        return `ports scan: ${added} new`;
+    }),
+};
+/** A directory looks like a project if it has `package.json` with a non-empty `name` field. */
+function looksLikeProject(dir) {
+    if (!(0, fs_1.existsSync)((0, path_1.join)(dir, 'package.json')))
+        return false;
+    try {
+        const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(dir, 'package.json'), 'utf8'));
+        return Boolean(pkg.name);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Recursive project discovery.
+ *
+ * Stops descending into a directory as soon as a project marker is detected
+ * (lt.config.json with package.json, pnpm-workspace.yaml, or `projects/`).
+ * Skips dotdirs and `node_modules`. Skips symlinks (lstatSync) to avoid
+ * traversal loops on pathological filesystems.
+ */
+function walkForProjects(dir, depth, maxDepth) {
+    if (depth > maxDepth)
+        return [];
+    if (!(0, fs_1.existsSync)(dir))
+        return [];
+    const out = [];
+    // A project is detected if EITHER an lt.config.json exists OR a workspace marker is found.
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'lt.config.json'))) {
+        if (looksLikeProject(dir)) {
+            out.push({ path: dir });
+            return out; // don't recurse into a detected project
+        }
+    }
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'pnpm-workspace.yaml')) || (0, fs_1.existsSync)((0, path_1.join)(dir, 'projects'))) {
+        out.push({ path: dir });
+        return out;
+    }
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+    }
+    catch (_a) {
+        return [];
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules')
+            continue;
+        // Use the cheap Dirent check first — it doesn't need an extra syscall.
+        if (!entry.isDirectory()) {
+            // Could still be a symlink that points to a directory. Skip those to
+            // avoid traversal loops.
+            if (!entry.isSymbolicLink())
+                continue;
+            let s;
+            try {
+                s = (0, fs_1.lstatSync)((0, path_1.join)(dir, entry.name));
+            }
+            catch (_b) {
+                continue;
+            }
+            if (s.isSymbolicLink())
+                continue;
+        }
+        out.push(...walkForProjects((0, path_1.join)(dir, entry.name), depth + 1, maxDepth));
+    }
+    return out;
+}
+module.exports = ScanCommand;

package/build/commands/status.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const framework_detection_1 = require("../lib/framework-detection");
 const frontend_framework_detection_1 = require("../lib/frontend-framework-detection");
+const port_registry_1 = require("../lib/port-registry");
 const workspace_integration_1 = require("../lib/workspace-integration");
 /**
  * Show project status and context
@@ -22,7 +23,7 @@ const StatusCommand = {
     hidden: false,
     name: 'status',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
+        var _a, _b, _c;
         const { filesystem, print: { colors, info, success, warning }, system, } = toolbox;
         const cwd = filesystem.cwd();
         info('');
@@ -107,7 +108,7 @@ const StatusCommand = {
                     projectInfo.projectType = 'node';
                 }
             }
-            catch (_c) {
+            catch (_d) {
                 // Ignore parse errors
             }
         }
@@ -136,7 +137,7 @@ const StatusCommand = {
                         });
                     }
                 }
-                catch (_d) {
+                catch (_e) {
                     // ignore
                 }
             }
@@ -152,7 +153,7 @@ const StatusCommand = {
                         });
                     }
                 }
-                catch (_e) {
+                catch (_f) {
                     // ignore
                 }
             }
@@ -167,7 +168,7 @@ const StatusCommand = {
                 projectInfo.gitBranch = (branch === null || branch === void 0 ? void 0 : branch.trim()) || null;
             }
         }
-        catch (_f) {
+        catch (_g) {
             // Not a git repository
         }
         // Get Node/npm versions
@@ -175,7 +176,7 @@ const StatusCommand = {
             projectInfo.nodeVersion = ((_a = (yield system.run('node --version 2>/dev/null'))) === null || _a === void 0 ? void 0 : _a.trim()) || null;
             projectInfo.npmVersion = ((_b = (yield system.run('npm --version 2>/dev/null'))) === null || _b === void 0 ? void 0 : _b.trim()) || null;
         }
-        catch (_g) {
+        catch (_h) {
             // Ignore errors
         }
         // Display project info
@@ -234,6 +235,36 @@ const StatusCommand = {
                 info(colors.dim('  Hint: `lt fullstack add-app` to integrate a Nuxt or Angular app.'));
             }
         }
+        // Local dev orchestration registry — surface slot/ports if registered.
+        // Helps users discover that `lt local` is set up for this project, and
+        // gives a quick inline answer to "what ports does this project use?".
+        {
+            const registryRoot = ((_c = projectInfo.workspaceSubProject) === null || _c === void 0 ? void 0 : _c.root) ||
+                (projectInfo.workspaceLayout.hasWorkspace ? projectInfo.workspaceLayout.workspaceDir : cwd);
+            if (registryRoot) {
+                const slug = (0, port_registry_1.projectSlug)(registryRoot);
+                const entry = (0, port_registry_1.loadRegistry)().projects[slug];
+                if (entry) {
+                    info('');
+                    info(colors.bold('Local dev orchestration (lt local):'));
+                    const ports = (0, port_registry_1.portsForSlot)(entry.slot);
+                    info(`  Slot:     ${entry.slot}`);
+                    info(`  API:      http://localhost:${ports.api}`);
+                    info(`  App:      http://localhost:${ports.app}`);
+                    if (entry.dbName)
+                        info(`  DB:       mongodb://127.0.0.1/${entry.dbName}`);
+                    const state = (0, port_registry_1.loadLocalState)(registryRoot);
+                    const apiAlive = (state === null || state === void 0 ? void 0 : state.pids.api) ? (0, port_registry_1.isPidAlive)(state.pids.api) : false;
+                    const appAlive = (state === null || state === void 0 ? void 0 : state.pids.app) ? (0, port_registry_1.isPidAlive)(state.pids.app) : false;
+                    if (apiAlive || appAlive) {
+                        info(`  Running:  api ${apiAlive ? colors.green('●') : colors.dim('○')}  app ${appAlive ? colors.green('●') : colors.dim('○')}`);
+                    }
+                    else {
+                        info(colors.dim('  Hint: `lt local up` to start API + App with these ports.'));
+                    }
+                }
+            }
+        }
         // Show monorepo subprojects if we detected any (typically at monorepo root)
         if (projectInfo.monorepoSubprojects.length > 0) {
             info('');

package/build/extensions/server.js

@@ -1975,21 +1975,31 @@ class Server {
                     literal.setLiteralValue(secretMap.get(text));
                     continue;
                 }
-                // Replace database names (nest-server-ci -> projectDir-ci)
+                // Replace database names so the project gets project-specific DB
+                // names. Matches BOTH the legacy `nest-server-{env}` form AND the
+                // current `nest-server-starter-{env}` form used by the public
+                // nest-server-starter repo. Examples:
+                //   nest-server-starter-local       → ${projectDir}-local
+                //   nest-server-starter-production  → ${projectDir}-production
+                //   nest-server-ci                  → ${projectDir}-ci  (legacy)
+                // The optional `(?:starter-)?` non-capturing group is what fixes
+                // the previously-broken case where dbName: 'nest-server-starter-local'
+                // turned into 'svl-sports-system-starter-local' (-starter- stayed).
                 if (text.includes('nest-server-')) {
-                    literal.setLiteralValue(text.replace(/nest-server-/g, `${projectDir}-`));
+                    literal.setLiteralValue(text.replace(/nest-server-(?:starter-)?/g, `${projectDir}-`));
                 }
             }
             sourceFile.saveSync();
         }
         catch (_a) {
-            // Fallback to regex-based approach if ts-morph fails
+            // Fallback to regex-based approach if ts-morph fails. Same matcher
+            // as the AST branch — keep them in sync.
             let content = this.filesystem.read(configPath);
             if (!content) {
                 return;
             }
             content = this.replaceSecretOrPrivateKeys(content);
-            content = content.replace(/nest-server-(\w+)/g, `${projectDir}-$1`);
+            content = content.replace(/nest-server-(?:starter-)?(\w+)/g, `${projectDir}-$1`);
             this.filesystem.write(configPath, content);
         }
     }

package/build/lib/local-patches.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoPatch = autoPatch;
+exports.patchApiConfig = patchApiConfig;
+exports.patchClaudeMd = patchClaudeMd;
+exports.patchNuxtConfig = patchNuxtConfig;
+exports.patchPlaywrightConfig = patchPlaywrightConfig;
+/**
+ * Idempotent patches for legacy projects that still have hardcoded
+ * dev ports. Applied by `lt local init --patch`.
+ *
+ * Each patch is a regex-based replace that matches only the legacy
+ * form. Already-patched files are no-ops.
+ */
+const fs_1 = require("fs");
+/** Run the appropriate patch based on filename. */
+function autoPatch(file) {
+    if (file.endsWith('config.env.ts'))
+        return patchApiConfig(file);
+    if (file.endsWith('nuxt.config.ts'))
+        return patchNuxtConfig(file);
+    if (file.endsWith('playwright.config.ts'))
+        return patchPlaywrightConfig(file);
+    return { file, patched: false, replacements: 0 };
+}
+/**
+ * Patch nest-server-starter-style `src/config.env.ts`:
+ * - `port: 3000,` → `port: Number(process.env.PORT) || 3000,`
+ *
+ * Idempotent — files already patched return `patched: false`. Missing
+ * files are also a no-op (matches `patchClaudeMd` behavior).
+ */
+function patchApiConfig(file) {
+    if (!(0, fs_1.existsSync)(file)) {
+        return { file, patched: false, replacements: 0 };
+    }
+    const before = (0, fs_1.readFileSync)(file, 'utf8');
+    let count = 0;
+    const after = before.replace(/^(\s*)port:\s*3000\s*,$/gm, (_match, indent) => {
+        count++;
+        return `${indent}port: Number(process.env.PORT) || 3000,`;
+    });
+    if (count === 0) {
+        return { file, patched: false, replacements: 0 };
+    }
+    (0, fs_1.writeFileSync)(file, after, 'utf8');
+    return { file, patched: true, replacements: count };
+}
+/**
+ * Inject a "Local Development (Parallel Projects)" block with the
+ * project's concrete ports into CLAUDE.md. Idempotent — re-running
+ * with the same ports is a no-op; re-running with different ports
+ * updates the block in place.
+ *
+ * The block is delimited by HTML comments so it can be located and
+ * replaced reliably.
+ */
+function patchClaudeMd(file, options) {
+    const { apiPort, appPort, dbName, slug } = options;
+    const startMarker = '<!-- lt-local:port-block:start -->';
+    const endMarker = '<!-- lt-local:port-block:end -->';
+    const dbLine = dbName ? `- DB:  \`mongodb://127.0.0.1/${dbName}\`\n` : '';
+    const block = [
+        startMarker,
+        '## Local Development (lt local)',
+        '',
+        `This project is registered with \`lt local\` (slug: \`${slug}\`). Use these commands to run alongside other lt-projects without port collisions:`,
+        '',
+        '```bash',
+        'lt local up        # Start API + App with project-specific ports',
+        'lt local down      # Stop the detached processes',
+        'lt local status    # Show running PIDs + bound ports',
+        'lt ports           # Inspect all reserved + bound dev ports',
+        '```',
+        '',
+        '**Active ports for THIS project:**',
+        '',
+        `- API: \`http://localhost:${apiPort}\``,
+        `- App: \`http://localhost:${appPort}\``,
+        dbLine,
+        'Env vars (set automatically by `lt local up`): `PORT`, `BASE_URL`, `APP_URL`, `NUXT_API_URL`, `NUXT_PUBLIC_API_URL`, `NUXT_PUBLIC_SITE_URL`, `NUXT_PUBLIC_STORAGE_PREFIX`, `NSC__MONGOOSE__URI`. **Never assume ports 3000/3001 for this project** — they may belong to a parallel project.',
+        '',
+        endMarker,
+    ]
+        .filter((line) => line !== null && line !== undefined)
+        .join('\n');
+    let content = '';
+    if ((0, fs_1.existsSync)(file)) {
+        content = (0, fs_1.readFileSync)(file, 'utf8');
+    }
+    else {
+        // Don't create CLAUDE.md from scratch — only patch if it exists.
+        return { file, patched: false, replacements: 0 };
+    }
+    const startIdx = content.indexOf(startMarker);
+    const endIdx = content.indexOf(endMarker);
+    let next;
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        // Replace existing block in place — the block does not include
+        // surrounding whitespace, so we slice exactly from start to end-of-marker.
+        const before = content.slice(0, startIdx);
+        const after = content.slice(endIdx + endMarker.length);
+        next = before + block + after;
+    }
+    else {
+        // Append at the end with one blank line separator + trailing newline
+        const sep = content.endsWith('\n\n') ? '' : content.endsWith('\n') ? '\n' : '\n\n';
+        next = `${content}${sep}${block}\n`;
+    }
+    // Idempotent check: if nothing changed, don't write
+    if (next === content) {
+        return { file, patched: false, replacements: 0 };
+    }
+    (0, fs_1.writeFileSync)(file, next, 'utf8');
+    return { file, patched: true, replacements: 1 };
+}
+/**
+ * Patch nuxt-base-template-style `nuxt.config.ts`:
+ * - `port: 3001,` → `port: Number(process.env.PORT) || 3001,`
+ * - `target: 'http://localhost:3000'` → `target: process.env.NUXT_API_URL || 'http://localhost:3000'`
+ *
+ * Missing files are a no-op (matches `patchClaudeMd` behavior).
+ */
+function patchNuxtConfig(file) {
+    if (!(0, fs_1.existsSync)(file)) {
+        return { file, patched: false, replacements: 0 };
+    }
+    const before = (0, fs_1.readFileSync)(file, 'utf8');
+    let count = 0;
+    let after = before.replace(/^(\s*)port:\s*3001\s*,$/gm, (_match, indent) => {
+        count++;
+        return `${indent}port: Number(process.env.PORT) || 3001,`;
+    });
+    after = after.replace(/target:\s*'http:\/\/localhost:3000'/g, () => {
+        count++;
+        return `target: process.env.NUXT_API_URL || 'http://localhost:3000'`;
+    });
+    if (count === 0) {
+        return { file, patched: false, replacements: 0 };
+    }
+    (0, fs_1.writeFileSync)(file, after, 'utf8');
+    return { file, patched: true, replacements: count };
+}
+/**
+ * Patch nuxt-base-template-style `playwright.config.ts`:
+ * - `baseURL: 'http://localhost:3001'` → uses NUXT_PUBLIC_SITE_URL
+ * - `host: 'http://localhost:3001'`    → uses NUXT_PUBLIC_SITE_URL
+ * - `url: 'http://localhost:3001'`     → uses NUXT_PUBLIC_SITE_URL
+ *
+ * Missing files are a no-op (matches `patchClaudeMd` behavior).
+ */
+function patchPlaywrightConfig(file) {
+    if (!(0, fs_1.existsSync)(file)) {
+        return { file, patched: false, replacements: 0 };
+    }
+    const before = (0, fs_1.readFileSync)(file, 'utf8');
+    let count = 0;
+    let after = before.replace(/baseURL:\s*'http:\/\/localhost:3001'/g, () => {
+        count++;
+        return `baseURL: process.env.NUXT_PUBLIC_SITE_URL || 'http://localhost:3001'`;
+    });
+    after = after.replace(/host:\s*'http:\/\/localhost:3001'/g, () => {
+        count++;
+        return `host: process.env.NUXT_PUBLIC_SITE_URL || 'http://localhost:3001'`;
+    });
+    after = after.replace(/url:\s*'http:\/\/localhost:3001'/g, () => {
+        count++;
+        return `url: process.env.NUXT_PUBLIC_SITE_URL || 'http://localhost:3001'`;
+    });
+    if (count === 0) {
+        return { file, patched: false, replacements: 0 };
+    }
+    (0, fs_1.writeFileSync)(file, after, 'utf8');
+    return { file, patched: true, replacements: count };
+}

package/build/lib/local-project.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiNeedsPortPatch = apiNeedsPortPatch;
+exports.appNeedsPortPatch = appNeedsPortPatch;
+exports.resolveLayout = resolveLayout;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const workspace_integration_1 = require("./workspace-integration");
+/**
+ * Detect whether the API project still has the legacy hardcoded
+ * `port: 3000`. Returns the absolute file path if a patch is needed,
+ * null if already env-aware (or no file).
+ */
+function apiNeedsPortPatch(apiDir) {
+    const file = (0, path_1.join)(apiDir, 'src', 'config.env.ts');
+    if (!(0, fs_1.existsSync)(file))
+        return null;
+    const content = (0, fs_1.readFileSync)(file, 'utf8');
+    // Match `port: 3000,` exactly (not yet env-wrapped).
+    return /port:\s*3000\s*,/.test(content) ? file : null;
+}
+/**
+ * Detect whether the App project still has hardcoded `port: 3001` or a
+ * hardcoded vite-proxy `target: 'http://localhost:3000'`. Returns an
+ * array of absolute file paths that need patching.
+ */
+function appNeedsPortPatch(appDir) {
+    const candidates = [(0, path_1.join)(appDir, 'nuxt.config.ts'), (0, path_1.join)(appDir, 'playwright.config.ts')];
+    return candidates.filter((file) => {
+        if (!(0, fs_1.existsSync)(file))
+            return false;
+        const c = (0, fs_1.readFileSync)(file, 'utf8');
+        return (/port:\s*3001\s*,/.test(c) ||
+            /target:\s*'http:\/\/localhost:3000'/.test(c) ||
+            /baseURL:\s*'http:\/\/localhost:3001'/.test(c) ||
+            /url:\s*'http:\/\/localhost:3001'/.test(c) ||
+            /host:\s*'http:\/\/localhost:3001'/.test(c));
+    });
+}
+/**
+ * Resolve the project layout starting from `cwd`. Walks up to find a
+ * monorepo workspace if cwd is inside `projects/api/` or `projects/app/`.
+ */
+function resolveLayout(cwd, filesystem) {
+    // Inside a sub-project? → walk to workspace root.
+    const subContext = (0, workspace_integration_1.detectSubProjectContext)(cwd, filesystem);
+    if (subContext) {
+        return monorepoLayout(subContext.workspaceRoot);
+    }
+    // Workspace root directly?
+    const layout = (0, workspace_integration_1.detectWorkspaceLayout)(cwd, filesystem);
+    if (layout.hasWorkspace) {
+        return monorepoLayout(layout.workspaceDir);
+    }
+    // Walk up to find a workspace.
+    const workspaceRoot = (0, workspace_integration_1.findWorkspaceRoot)(cwd, filesystem);
+    if (workspaceRoot) {
+        return monorepoLayout(workspaceRoot);
+    }
+    // Fall back to standalone — figure out if it's API or App.
+    const isApi = (0, fs_1.existsSync)((0, path_1.join)(cwd, 'src', 'config.env.ts')) || (0, fs_1.existsSync)((0, path_1.join)(cwd, 'nest-cli.json'));
+    const isApp = (0, fs_1.existsSync)((0, path_1.join)(cwd, 'nuxt.config.ts'));
+    return {
+        apiDir: isApi ? cwd : null,
+        appDir: isApp ? cwd : null,
+        name: readPackageName(cwd) || basename(cwd),
+        root: cwd,
+        workspace: false,
+    };
+}
+function basename(p) {
+    return p.replace(/\/+$/, '').split('/').pop() || 'project';
+}
+/** Build the layout for an lt-monorepo workspace root. */
+function monorepoLayout(workspaceRoot) {
+    const apiDir = (0, path_1.join)(workspaceRoot, 'projects', 'api');
+    const appDir = (0, path_1.join)(workspaceRoot, 'projects', 'app');
+    return {
+        apiDir: (0, fs_1.existsSync)(apiDir) ? apiDir : null,
+        appDir: (0, fs_1.existsSync)(appDir) ? appDir : null,
+        name: readPackageName(workspaceRoot) || basename(workspaceRoot),
+        root: workspaceRoot,
+        workspace: true,
+    };
+}
+/** Read the `name` field from `package.json`, scrubbed to just the bare name (no scope). */
+function readPackageName(dir) {
+    const pkgPath = (0, path_1.join)(dir, 'package.json');
+    if (!(0, fs_1.existsSync)(pkgPath))
+        return null;
+    try {
+        const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
+        if (!pkg.name)
+            return null;
+        // Strip npm scope: @lenne.tech/foo → foo
+        return pkg.name.includes('/') ? pkg.name.split('/').pop() : pkg.name;
+    }
+    catch (_a) {
+        return null;
+    }
+}