@lenne.tech/cli 1.34.0 → 1.35.1

package/build/commands/fullstack/add-api.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.help = void 0;
-const hoist_workspace_pnpm_config_1 = require("../../lib/hoist-workspace-pnpm-config");
 const workspace_integration_1 = require("../../lib/workspace-integration");
 /**
  * Add an API (`projects/api/`) to a fullstack workspace that currently
@@ -320,14 +319,12 @@ const NewCommand = {
         if (apiResult.method !== 'link') {
             (0, workspace_integration_1.writeApiConfig)({ apiDir: apiDest, apiMode, filesystem, frameworkMode });
         }
-        // Hoist pnpm config — `setupServerForFullstack` may have produced a
-        // sub-project package.json with `pnpm.overrides` etc. that pnpm
-        // ignores at non-root level.
-        (0, hoist_workspace_pnpm_config_1.hoistWorkspacePnpmConfig)({
-            filesystem,
-            projectDir: workspaceDir,
-            subProjects: ['projects/api', 'projects/app'],
-        });
+        // Normalize the workspace root: hoist pnpm config out of the sub-projects
+        // (`setupServerForFullstack` may have left `pnpm.overrides` etc. at a
+        // non-root level pnpm ignores), drop nested lockfiles the root supersedes,
+        // and guarantee a root `.dockerignore` (Docker never reads a sub-project's
+        // own when building from the root context).
+        (0, workspace_integration_1.finalizeWorkspaceRoot)({ filesystem, projectDir: workspaceDir });
         // Run install + format unless explicitly skipped (CI/agents may
         // want to chain multiple add-* calls before installing once).
         if (!skipInstall && !experimental) {

package/build/commands/fullstack/add-app.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.help = void 0;
-const hoist_workspace_pnpm_config_1 = require("../../lib/hoist-workspace-pnpm-config");
 const workspace_integration_1 = require("../../lib/workspace-integration");
 /**
  * Add a frontend app (`projects/app/`) to a fullstack workspace that
@@ -249,12 +248,11 @@ const NewCommand = {
                 warning('Continuing with npm mode for frontend.');
             }
         }
-        // Hoist pnpm config (frontend templates may carry pnpm.overrides too).
-        (0, hoist_workspace_pnpm_config_1.hoistWorkspacePnpmConfig)({
-            filesystem,
-            projectDir: workspaceDir,
-            subProjects: ['projects/api', 'projects/app'],
-        });
+        // Normalize the workspace root: hoist pnpm config (frontend templates may
+        // carry pnpm.overrides too), drop the frontend starter's standalone
+        // pnpm-lock.yaml the root supersedes, and guarantee a root `.dockerignore`
+        // (else the image inherits the host's node_modules, .output and .env).
+        (0, workspace_integration_1.finalizeWorkspaceRoot)({ filesystem, projectDir: workspaceDir });
         if (!skipInstall) {
             const installSpinner = spin('Install workspace packages');
             try {

package/build/commands/fullstack/init.js

@@ -16,7 +16,6 @@ const gluegun_1 = require("gluegun");
 const caddy_1 = require("../../lib/caddy");
 const dev_migrate_helper_1 = require("../../lib/dev-migrate-helper");
 const dev_project_1 = require("../../lib/dev-project");
-const hoist_workspace_pnpm_config_1 = require("../../lib/hoist-workspace-pnpm-config");
 const package_name_1 = require("../../lib/package-name");
 const vendor_claude_md_1 = require("../../lib/vendor-claude-md");
 const workspace_integration_1 = require("../../lib/workspace-integration");
@@ -621,14 +620,14 @@ const NewCommand = {
             else {
                 serverSpinner.warn('Nest Server Starter not integrated');
             }
-            // Hoist workspace-scoped pnpm config out of sub-projects. pnpm only
-            // honors `pnpm.overrides`, `pnpm.onlyBuiltDependencies`, and
-            // `pnpm.ignoredOptionalDependencies` at the workspace root; leaving
-            // them in projects/api/package.json or projects/app/package.json
-            // causes `WARN The field … was found in … This will not take
-            // effect. You should configure … at the root of the workspace
-            // instead.` and silently disables CVE overrides.
-            (0, hoist_workspace_pnpm_config_1.hoistWorkspacePnpmConfig)({ filesystem, projectDir, subProjects: ['projects/api', 'projects/app'] });
+            // Normalize the workspace root. Hoists workspace-scoped pnpm config out
+            // of the sub-projects (pnpm only honors `pnpm.overrides` etc. at the
+            // root — otherwise CVE overrides are silently disabled), drops the
+            // starters' standalone pnpm-lock.yaml files the root supersedes, and
+            // guarantees a root `.dockerignore` (else the images carry the host's
+            // node_modules, a stale .output, and a local .env that `nuxt build`
+            // bakes in).
+            (0, workspace_integration_1.finalizeWorkspaceRoot)({ filesystem, projectDir });
             // Install all packages
             if (!experimental) {
                 const installSpinner = spin('Install all packages');

package/build/commands/status.js

@@ -251,6 +251,8 @@ const StatusCommand = {
                     for (const [sub, host] of Object.entries(entry.subdomains)) {
                         info(`  ${sub.padEnd(6)} https://${host}`);
                     }
+                    // `loadRegistry` strips dbName from API-less entries, so its
+                    // presence alone means there is a database to advertise.
                     if (entry.dbName)
                         info(`  db     mongodb://127.0.0.1/${entry.dbName}`);
                     const session = (0, dev_state_1.loadSession)(registryRoot);

package/build/commands/ticket/list.js

@@ -61,6 +61,8 @@ const ListCommand = {
             if (entry) {
                 for (const [sub, host] of Object.entries(entry.subdomains))
                     info(`       ${sub.padEnd(4)} https://${host}`);
+                // `loadRegistry` strips dbName from API-less entries, so its presence
+                // alone means there is a database to show.
                 if (entry.dbName)
                     info(`       db   mongodb://127.0.0.1/${entry.dbName}`);
             }

package/build/extensions/server.js

@@ -1333,25 +1333,74 @@ class Server {
             // above works indirectly (via `bin/migrate.js` loading ts-node first),
             // but it's fragile: if somebody invokes migrate.js standalone, `require
             // ('../src/core')` would crash because Node cannot load TypeScript.
-            // Replace the file with the explicit, imo-pilot-proven variant that
-            // registers ts-node itself BEFORE requiring the vendored core and
-            // points at the specific migration.helper path (not the index hub).
+            //
+            // Two things this file must get right, both learned the hard way:
+            //   1. ts-node is registered ONLY when the core next to it is still
+            //      TypeScript. In the production image everything is compiled and
+            //      ts-node is pruned, so an unconditional `require('./ts-compiler')`
+            //      would throw MODULE_NOT_FOUND and — under `set -e` in the
+            //      entrypoint — take the whole container down before the server starts.
+            //   2. The Mongo URI comes from resolveMongoUri(), which falls back to
+            //      NSC__MONGOOSE__URI when config.env.ts is not loadable (Docker).
+            //      Reading `config.default.mongoose.uri` directly crashes there.
             const migrateJsPath = `${dest}/migrations-utils/migrate.js`;
-            filesystem.write(migrateJsPath, [
-                '// The vendored core is TypeScript-only (no prebuilt dist/). Register ts-node (via our',
-                '// custom bootstrap) before requiring any vendor module, so that .ts source files are',
-                '// transparently compiled on demand. Uses the same compiler config as the migrate CLI.',
-                "require('./ts-compiler');",
-                '',
-                "const { createMigrationStore } = require('../src/core/modules/migrate/helpers/migration.helper');",
-                "const config = require('../src/config.env');",
-                '',
-                'module.exports = createMigrationStore(',
-                '  config.default.mongoose.uri,',
-                "  'migrations' // optional, default is 'migrations'",
-                ');',
-                '',
-            ].join('\n'));
+            const migrateStoreTemplate = filesystem.read(path.join(__dirname, '..', 'templates', 'vendor-scripts', 'migrate-store.js'));
+            if (!migrateStoreTemplate) {
+                throw new Error('CLI build is missing templates/vendor-scripts/migrate-store.js — cannot generate migrations-utils/migrate.js.');
+            }
+            filesystem.write(migrateJsPath, migrateStoreTemplate);
+            // The generated migrate.js does `require('./mongo-uri')` (resolveMongoUri).
+            // Unlike ts-compiler.js (written below), that file is NOT generated here — it
+            // ships with nest-server-starter (the vendor clone base) and is copied into
+            // dist/ by `copy:migrations`. Assert it so a non-standard/older starter that
+            // lacks it fails loudly HERE instead of silently skipping every migration at
+            // container start (the entrypoint's `migrate up` is best-effort under `set -e`).
+            if (!filesystem.exists(`${dest}/migrations-utils/mongo-uri.js`)) {
+                this.toolbox.print.warning('  ⚠ migrations-utils/mongo-uri.js is missing — the generated migrate.js requires it ' +
+                    '(resolveMongoUri). Migrations will not run. It normally ships with nest-server-starter; ' +
+                    'add it (must export resolveMongoUri) so `migrate up` can resolve the Mongo URI.');
+            }
+            // Compile migrations to JavaScript. The production image prunes ts-node, so
+            // `migrate up` can only load plain .js migrations there. Without this the
+            // entrypoint's migration step never applies anything.
+            const tsconfigBuildPath = `${dest}/tsconfig.build.json`;
+            if (filesystem.exists(tsconfigBuildPath)) {
+                const tsconfigBuildRaw = filesystem.read(tsconfigBuildPath) || '';
+                if (!tsconfigBuildRaw.includes('migrations/**/*.ts')) {
+                    // 1. Extend `include` so tsc also emits the .ts migrations + helpers.
+                    const includePatched = tsconfigBuildRaw.replace(/"include":\s*\[\s*"src\/\*\*\/\*"\s*\]/, '"include": ["src/**/*", "migrations/**/*.ts", "migrations-utils/**/*.ts"]');
+                    if (includePatched === tsconfigBuildRaw) {
+                        this.toolbox.print.warning('  ⚠ tsconfig.build.json: could not extend "include" automatically — ' +
+                            'add "migrations/**/*.ts" and "migrations-utils/**/*.ts" manually, ' +
+                            'otherwise migrations are never compiled and the container skips them.');
+                    }
+                    else {
+                        // 2. Pin rootDir. Once `include` reaches beyond src/, tsc re-infers the
+                        //    rootDir from the common parent of ALL included files, which can
+                        //    shift the emit layout and relocate the entry point. An explicit
+                        //    "rootDir": "./" keeps the output mirroring the project tree:
+                        //    `dist/src/main.js` — which is exactly what the Docker entrypoint
+                        //    runs (see nest-server-starter/docker-entrypoint.sh) — plus
+                        //    `dist/migrations/` and `dist/migrations-utils/`. Without the pin the
+                        //    entry can move and the container's `node dist/src/main.js` dies with
+                        //    MODULE_NOT_FOUND. Newer starters ship the pin; older ones (pre-9.0) do not.
+                        let patched = includePatched;
+                        let rootDirPinned = /"rootDir"\s*:/.test(patched);
+                        if (!rootDirPinned) {
+                            const withRootDir = patched.replace(/("compilerOptions"\s*:\s*\{)/, '$1\n    "rootDir": "./",');
+                            if (withRootDir !== patched) {
+                                patched = withRootDir;
+                                rootDirPinned = true;
+                            }
+                        }
+                        filesystem.write(tsconfigBuildPath, patched);
+                        if (!rootDirPinned) {
+                            this.toolbox.print.warning('  ⚠ tsconfig.build.json: extended "include" but could not confirm "rootDir": "./" — ' +
+                                'add it manually, otherwise tsc may relocate the emit and `node dist/src/main.js` fails.');
+                        }
+                    }
+                }
+            }
             // ── 4b. (removed) ─────────────────────────────────────────────────────
             //
             // Previous versions copied three maintenance scripts into
@@ -1471,6 +1520,79 @@ class Server {
                         scripts['migrate:test:up'] = `NODE_ENV=test node ./bin/migrate.js up ${migrateArgs}`;
                         scripts['migrate:preview:up'] = `NODE_ENV=preview node ./bin/migrate.js up ${migrateArgs}`;
                         scripts['migrate:prod:up'] = `NODE_ENV=production node ./bin/migrate.js up ${migrateArgs}`;
+                        // Make the production build carry a runnable migration setup.
+                        //
+                        // The image has no ts-node, and the docker entrypoint looks for
+                        // `dist/bin/migrate.js`. Without these three scripts the entrypoint
+                        // silently skips migrations forever — the failure mode is invisible
+                        // until the first real data migration quietly does not run.
+                        //
+                        //   copy:bin          ships bin/migrate.js into dist/
+                        //   copy:migrations   ships only the .js helpers (the .ts migrations
+                        //                     are compiled by tsc, see tsconfig.build.json)
+                        //   prune:migrations  drops the *.d.ts / *.js.map that tsc emits next
+                        //                     to each compiled migration — the runner would
+                        //                     otherwise pick the declaration file up as a
+                        //                     second migration and throw on `export declare`
+                        //
+                        // Define each only if the project doesn't already have it, so a
+                        // deliberate customization survives a re-run (older starters simply
+                        // lack them → still repaired).
+                        if (typeof scripts['copy:bin'] !== 'string') {
+                            scripts['copy:bin'] = 'cpy ./bin ./dist/ || true';
+                        }
+                        if (typeof scripts['copy:migrations'] !== 'string') {
+                            scripts['copy:migrations'] =
+                                'cpy "./migrations-utils/*.js" ./dist/migrations-utils/ && cpy ./tsconfig.json ./dist/';
+                        }
+                        if (typeof scripts['prune:migrations'] !== 'string') {
+                            scripts['prune:migrations'] = 'rimraf --glob "./dist/migrations/*.d.ts" "./dist/migrations/*.js.map"';
+                        }
+                        // Wire the three steps into the build. Order among them is irrelevant:
+                        // all three only need to run AFTER tsc, which `build` does first
+                        // (copy:bin/copy:migrations copy source files; prune only cleans
+                        // tsc's dist/migrations output). A step is already covered when it is
+                        // named directly in `build` or reachable through a `copy` aggregator
+                        // that `build` runs (newer starters). Older starters have no such
+                        // aggregator, so append to `build` — the one script guaranteed to
+                        // exist and to run tsc first; without this the sub-scripts are defined
+                        // but never invoked and the image ships without dist/bin/migrate.js.
+                        //
+                        // Use the package-manager `run` the project's own scripts already use
+                        // (older starters: npm, newer: pnpm); a hard-coded `pnpm run` would
+                        // make `build` die with "pnpm: command not found" in an npm project.
+                        const scriptText = Object.values(scripts)
+                            .filter((v) => typeof v === 'string')
+                            .join('\n');
+                        const pmRun = /\bpnpm\s+run\b/.test(scriptText)
+                            ? 'pnpm run'
+                            : /\byarn\s+run\b/.test(scriptText)
+                                ? 'yarn run'
+                                : /\bnpm\s+run\b/.test(scriptText)
+                                    ? 'npm run'
+                                    : 'pnpm run';
+                        if (typeof scripts.build === 'string') {
+                            const copyAggregator = typeof scripts.copy === 'string' ? scripts.copy : '';
+                            const covered = (step) => scripts.build.includes(step) || copyAggregator.includes(step);
+                            const missingSteps = ['copy:bin', 'copy:migrations', 'prune:migrations'].filter((s) => !covered(s));
+                            if (missingSteps.length > 0) {
+                                scripts.build = `${scripts.build}${missingSteps.map((s) => ` && ${pmRun} ${s}`).join('')}`;
+                            }
+                        }
+                        else {
+                            this.toolbox.print.warning('  ⚠ package.json has no "build" script — copy:bin/copy:migrations/prune:migrations were defined but ' +
+                                'not wired in; the production image may ship without dist/bin/migrate.js and skip migrations.');
+                        }
+                        // prune:migrations needs `rimraf`, copy:* need `cpy` (cpy-cli). Older
+                        // starters ship cpy-cli but not rimraf — add whatever is missing so
+                        // `build` doesn't die on an absent binary.
+                        const devDependencies = (pkg.devDependencies && typeof pkg.devDependencies === 'object'
+                            ? pkg.devDependencies
+                            : (pkg.devDependencies = {}));
+                        if (typeof devDependencies.rimraf !== 'string')
+                            devDependencies.rimraf = '^6.0.1';
+                        if (typeof devDependencies['cpy-cli'] !== 'string')
+                            devDependencies['cpy-cli'] = '^6.0.0';
                         // Vendor freshness check: reads VENDOR.md baseline version and
                         // compares against npm registry. Non-blocking (always exits 0).
                         // Uses a short inline script — no external file needed.

package/build/lib/angular-environments.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAngularEnvironmentsDir = findAngularEnvironmentsDir;
+exports.patchAngularEnvironments = patchAngularEnvironments;
+exports.stageHosts = stageHosts;
+/**
+ * Rewrite the hardcoded localhost URLs in an Angular app's environment files
+ * to the deployed TurboOps stage URLs.
+ *
+ * WHY: a Nuxt app reads its API URL from the stage env at runtime
+ * (`NUXT_PUBLIC_API_URL`, injected by TurboOps). Angular has no such runtime
+ * config — `ng build --configuration production` BAKES `environment.prod.ts`
+ * into the bundle. Without this patch a deployed Angular app ships
+ * `apiUrl: 'http://127.0.0.1:3000/graphql'` and calls the end user's own
+ * machine.
+ *
+ * Stage mapping (TurboOps knows exactly two stages, `dev` and `production`):
+ *
+ *   environment.prod.ts     → production → <domain>     + api.<domain>
+ *   environment.develop.ts  → dev        → dev.<domain> + api.dev.<domain>
+ *   environment.test.ts     → dev        → dev.<domain> + api.dev.<domain>
+ *
+ * `environment.ts` is the local-dev config and is deliberately left alone.
+ * `environment.test.ts` and `environment.develop.ts` are identical in
+ * ng-base-starter (both `prefix: 'app-test'`); with no TurboOps "test" stage,
+ * the non-production stage is `dev` for both.
+ *
+ * Only the URL ORIGIN (scheme + host + optional port) is replaced — the path
+ * (`/graphql`, `/api`) is preserved, so a project that customised it keeps its
+ * routes. That also makes the patch idempotent AND re-runnable with a new
+ * domain: an already-deployed URL is rewritten to the new one instead of being
+ * skipped (the old `http://127.0.0.1:3000`-only replace silently did nothing
+ * on the second run).
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+/** Which environment file belongs to which TurboOps stage. */
+const ENVIRONMENT_STAGES = {
+    'environment.develop.ts': 'dev',
+    'environment.prod.ts': 'production',
+    'environment.test.ts': 'dev',
+};
+/**
+ * Locate the Angular `environments/` directory for a project root.
+ * Returns null for non-Angular apps (e.g. Nuxt), which makes the whole
+ * patch a no-op there.
+ */
+function findAngularEnvironmentsDir(projectRoot) {
+    const candidates = [(0, path_1.join)('projects', 'app', 'src', 'environments'), (0, path_1.join)('src', 'environments')];
+    for (const rel of candidates) {
+        const dir = (0, path_1.join)(projectRoot, rel);
+        if ((0, fs_1.existsSync)(dir))
+            return dir;
+    }
+    return null;
+}
+/**
+ * Point every stage-specific Angular environment file at the deployed URLs.
+ * Returns one {@link PatchResult} per file that exists (empty array when the
+ * project is not an Angular app).
+ */
+function patchAngularEnvironments(options) {
+    const dir = findAngularEnvironmentsDir(options.projectRoot);
+    if (!dir)
+        return [];
+    const results = [];
+    for (const [fileName, stage] of Object.entries(ENVIRONMENT_STAGES)) {
+        const file = (0, path_1.join)(dir, fileName);
+        if (!(0, fs_1.existsSync)(file))
+            continue;
+        results.push(patchEnvironmentFile(file, options.domain, stage));
+    }
+    return results;
+}
+/**
+ * Public hostnames of a stage. The API always lives one label in front of the
+ * app host, so `dev` nests as `api.dev.<domain>`.
+ */
+function stageHosts(domain, stage) {
+    const app = stage === 'production' ? domain : `dev.${domain}`;
+    return { api: `api.${app}`, app };
+}
+/** Rewrite the four URL properties of a single environment file. */
+function patchEnvironmentFile(file, domain, stage) {
+    const hosts = stageHosts(domain, stage);
+    const original = (0, fs_1.readFileSync)(file, 'utf8');
+    let content = original;
+    let replacements = 0;
+    let recognized = 0;
+    const rewriteOrigin = (property, origin) => {
+        // (property: )(quote)scheme://host[:port](path)(same quote)
+        const pattern = new RegExp(`(${property}:\\s*)(['"])[a-z]+://[^'"/]+([^'"]*)\\2`, 'g');
+        content = content.replace(pattern, (match, prefix, quote, path) => {
+            recognized++;
+            const next = `${prefix}${quote}${origin}${path}${quote}`;
+            if (next !== match)
+                replacements++;
+            return next;
+        });
+    };
+    rewriteOrigin('apiUrl', `https://${hosts.api}`);
+    rewriteOrigin('restUrl', `https://${hosts.api}`);
+    rewriteOrigin('wsUrl', `wss://${hosts.api}`);
+    rewriteOrigin('appUrl', `https://${hosts.app}`);
+    if (replacements > 0)
+        (0, fs_1.writeFileSync)(file, content, 'utf8');
+    return { file, patched: replacements > 0, recognized: recognized > 0, replacements };
+}

package/build/lib/dev-env.js

@@ -52,14 +52,14 @@ function buildDevEnv(input) {
             internalPort: apiInternalPort,
         },
         app: {
-            env: 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({}, 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 } : {})), { 
                 // 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.
-                NUXT_PUBLIC_API_PROXY: 'false', NUXT_PUBLIC_STORAGE_PREFIX: identity.slug, PORT: String(appInternalPort) }),
+                NUXT_PUBLIC_API_PROXY: 'false', NUXT_PUBLIC_STORAGE_PREFIX: identity.slug, PORT: String(appInternalPort) }), (process.platform === 'darwin' ? { TMPDIR: '/tmp' } : {})),
             internalPort: appInternalPort,
         },
     };

package/build/lib/dev-identity.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildIdentity = buildIdentity;
 exports.buildTestIdentity = buildTestIdentity;
 exports.buildTicketIdentity = buildTicketIdentity;
+exports.detectStandaloneKind = detectStandaloneKind;
 exports.isUnmodifiedTemplateName = isUnmodifiedTemplateName;
 exports.projectSlug = projectSlug;
 exports.slugify = slugify;
@@ -31,43 +32,46 @@ const path_1 = require("path");
  * - `projects/app` → `<slug>.localhost` (primary)
  * - `projects/<other>` → `<other>.<slug>.localhost`
  *
- * For standalone projects (single repo, no `projects/` directory):
+ * For standalone projects (single repo, no `projects/api` or `projects/app`):
  * - API project (config.env.ts present) → `api.<slug>.localhost`
  * - App project (nuxt.config.ts present) → `<slug>.localhost`
+ *
+ * Every combination is valid: api+app, api-only, and app-only.
  */
 function buildIdentity(root) {
     const slug = projectSlug(root);
     const subdomains = {};
-    const projectsDir = (0, path_1.join)(root, 'projects');
-    if ((0, fs_1.existsSync)(projectsDir)) {
-        // Monorepo: enumerate projects/* subdirectories.
-        const apiDir = (0, path_1.join)(projectsDir, 'api');
-        const appDir = (0, path_1.join)(projectsDir, 'app');
-        if ((0, fs_1.existsSync)(apiDir)) {
+    const apiDir = (0, path_1.join)(root, 'projects', 'api');
+    const appDir = (0, path_1.join)(root, 'projects', 'app');
+    const hasApi = (0, fs_1.existsSync)(apiDir);
+    const hasApp = (0, fs_1.existsSync)(appDir);
+    // Monorepo only when a known subproject is actually present. A bare (or
+    // unrelated) `projects/` directory must not shadow the standalone probe —
+    // it would yield an identity with zero subdomains and no routable URLs.
+    if (hasApi || hasApp) {
+        if (hasApi) {
             subdomains.api = {
                 hostname: `api.${slug}.localhost`,
                 isPrimaryApp: false,
                 subdir: 'projects/api',
             };
         }
-        if ((0, fs_1.existsSync)(appDir)) {
+        if (hasApp) {
             subdomains.app = {
                 hostname: `${slug}.localhost`,
                 isPrimaryApp: true,
                 subdir: 'projects/app',
             };
         }
+        return { root, slug, subdomains };
     }
-    else {
-        // Standalone — derive from project shape.
-        const isApi = (0, fs_1.existsSync)((0, path_1.join)(root, 'src', 'config.env.ts')) || (0, fs_1.existsSync)((0, path_1.join)(root, 'nest-cli.json'));
-        const isApp = (0, fs_1.existsSync)((0, path_1.join)(root, 'nuxt.config.ts'));
-        if (isApi) {
-            subdomains.api = { hostname: `api.${slug}.localhost`, isPrimaryApp: false, subdir: null };
-        }
-        if (isApp) {
-            subdomains.app = { hostname: `${slug}.localhost`, isPrimaryApp: true, subdir: null };
-        }
+    // Standalone — derive from project shape.
+    const { isApi, isApp } = detectStandaloneKind(root);
+    if (isApi) {
+        subdomains.api = { hostname: `api.${slug}.localhost`, isPrimaryApp: false, subdir: null };
+    }
+    if (isApp) {
+        subdomains.app = { hostname: `${slug}.localhost`, isPrimaryApp: true, subdir: null };
     }
     return { root, slug, subdomains };
 }
@@ -105,6 +109,22 @@ function buildTestIdentity(base, suffix = '-test') {
 function buildTicketIdentity(base, id) {
     return buildTestIdentity(base, `-${id}`);
 }
+/**
+ * Probe a single directory for the shape of a STANDALONE lt project.
+ *
+ * Single source of truth for "is this an API / an App?", shared by
+ * {@link buildIdentity} and `dev-project.ts#resolveLayout` so the identity
+ * (URLs) and the layout (which processes to spawn) can never disagree.
+ *
+ * Both flags can be true (a single repo holding both), and both can be false
+ * (not an lt-dev project).
+ */
+function detectStandaloneKind(dir) {
+    return {
+        isApi: (0, fs_1.existsSync)((0, path_1.join)(dir, 'src', 'config.env.ts')) || (0, fs_1.existsSync)((0, path_1.join)(dir, 'nest-cli.json')),
+        isApp: (0, fs_1.existsSync)((0, path_1.join)(dir, 'nuxt.config.ts')),
+    };
+}
 /**
  * package.json `name` values that are unchanged starter-template defaults.
  *

package/build/lib/dev-project.js

@@ -8,6 +8,7 @@ exports.deriveTicketDbName = deriveTicketDbName;
 exports.resolveLayout = resolveLayout;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const dev_identity_1 = require("./dev-identity");
 const workspace_integration_1 = require("./workspace-integration");
 /**
  * Detect whether the API project still has the legacy hardcoded `port: 3000`.
@@ -85,20 +86,32 @@ function deriveTicketDbName(devDbName, ticketId) {
 /**
  * Resolve layout starting from `cwd`. Walks up to find a workspace if
  * cwd is inside `projects/api/` or `projects/app/`.
+ *
+ * A workspace marker alone never wins: it only selects the monorepo layout
+ * when `projects/api` or `projects/app` actually exists. Otherwise we fall
+ * through to the standalone probe — a single-package repo may legitimately
+ * carry a settings-only `pnpm-workspace.yaml` (pnpm 10/11 keeps `overrides`
+ * and build allowlists there), and an npm workspace may use `packages/*`
+ * rather than the lt `projects/*` convention.
  */
 function resolveLayout(cwd, filesystem) {
     const subContext = (0, workspace_integration_1.detectSubProjectContext)(cwd, filesystem);
     if (subContext)
         return monorepoLayout(subContext.workspaceRoot);
     const layout = (0, workspace_integration_1.detectWorkspaceLayout)(cwd, filesystem);
-    if (layout.hasWorkspace)
-        return monorepoLayout(layout.workspaceDir);
+    if (layout.hasWorkspace) {
+        const mono = monorepoLayout(layout.workspaceDir);
+        if (mono.apiDir || mono.appDir)
+            return mono;
+    }
     const workspaceRoot = (0, workspace_integration_1.findWorkspaceRoot)(cwd, filesystem);
-    if (workspaceRoot)
-        return monorepoLayout(workspaceRoot);
-    // Standalone project — 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'));
+    if (workspaceRoot) {
+        const mono = monorepoLayout(workspaceRoot);
+        if (mono.apiDir || mono.appDir)
+            return mono;
+    }
+    // Standalone project — API-only, App-only, or a single repo holding both.
+    const { isApi, isApp } = (0, dev_identity_1.detectStandaloneKind)(cwd);
     return {
         apiDir: isApi ? cwd : null,
         appDir: isApp ? cwd : null,

package/build/lib/dev-state.js

@@ -118,7 +118,7 @@ function loadRegistry() {
     try {
         const parsed = JSON.parse((0, fs_1.readFileSync)(REGISTRY_PATH, 'utf8'));
         if (parsed && typeof parsed === 'object' && parsed.version === 1 && typeof parsed.projects === 'object') {
-            return parsed;
+            return normalizeRegistry(parsed);
         }
     }
     catch (_a) {
@@ -184,6 +184,22 @@ function takenInternalPorts(reg, excludeSlug) {
     }
     return ports;
 }
+/**
+ * Drop a `dbName` from any entry that has no `api` subdomain. An App-only
+ * project has no database, yet older registries (written before `lt dev up`
+ * stopped persisting one for App-only stacks) still carry a derived name.
+ * Normalizing once on load lets every reader test `entry.dbName` alone,
+ * instead of repeating `entry.dbName && entry.subdomains.api` at each display.
+ */
+function normalizeRegistry(reg) {
+    var _a;
+    for (const entry of Object.values(reg.projects)) {
+        if ((entry === null || entry === void 0 ? void 0 : entry.dbName) && !((_a = entry.subdomains) === null || _a === void 0 ? void 0 : _a.api)) {
+            delete entry.dbName;
+        }
+    }
+    return reg;
+}
 /** True if two paths resolve to the same location (normalising symlinks, e.g. /var → /private/var). */
 function sameRealPath(a, b) {
     try {