@lenne.tech/cli 1.21.0 → 1.22.0

package/build/commands/dev/test.js

@@ -0,0 +1,191 @@
+"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 child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const caddy_1 = require("../../lib/caddy");
+const dev_env_bridge_1 = require("../../lib/dev-env-bridge");
+const dev_identity_1 = require("../../lib/dev-identity");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+/**
+ * One-shot E2E convenience wrapper.
+ *
+ * Ensures the project is up under `lt dev`, then runs the test command
+ * with the ENV bridge loaded, and optionally tears the session down at
+ * the end. Useful for TDD loops, CI reproduction, and "just test it"
+ * workflows where the developer doesn't want to remember three commands.
+ *
+ * Behaviour:
+ *   1. If no `lt dev up` session is alive: run `lt dev up` first.
+ *   2. Wait for the App URL to respond (best-effort, ~30s timeout).
+ *   3. Inherit the env from `<root>/.lt-dev/.env` (so VS Code IDE-style
+ *      runners get the same setup) and spawn the test command in the
+ *      App project.
+ *   4. With `--teardown` (default false): run `lt dev down` after.
+ *
+ * Usage:
+ *   lt dev test                       # ensure up + run pnpm test:e2e in app
+ *   lt dev test --api                 # run API tests instead (pnpm test in api)
+ *   lt dev test --teardown            # plus stop session after
+ *   lt dev test --debug               # PWDEBUG=1 + headed mode
+ *   lt dev test -- <args>             # forward args to the test runner
+ *   lt dev test -- --ui crm-login.spec.ts
+ */
+const TestCommand = {
+    alias: ['t'],
+    description: 'Ensure up + run E2E tests with lt dev env',
+    hidden: false,
+    name: 'test',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const { filesystem, parameters, print: { colors, error, info, success }, } = toolbox;
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        if (!layout.apiDir && !layout.appDir) {
+            error('No API or App project detected at this path.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev test: not a project';
+        }
+        const apiMode = Boolean(parameters.options.api);
+        const teardown = Boolean(parameters.options.teardown);
+        const debug = Boolean(parameters.options.debug);
+        // Forwarded args after `--` (gluegun puts them in parameters.array).
+        const forwarded = parameters.array || [];
+        const targetDir = apiMode ? layout.apiDir : layout.appDir;
+        if (!targetDir) {
+            error(`Cannot run ${apiMode ? 'API' : 'App'} tests — no ${apiMode ? 'apiDir' : 'appDir'} in layout.`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev test: target missing';
+        }
+        const identity = (0, dev_identity_1.buildIdentity)(layout.root);
+        // Pre-flight: Caddy + ensure up.
+        if (!apiMode) {
+            if (!(yield (0, caddy_1.caddyAvailable)())) {
+                error('caddy is not installed. Run `lt dev install` first.');
+                if (!parameters.options.fromGluegunMenu)
+                    process.exit(1);
+                return 'dev test: caddy missing';
+            }
+            if (!(yield (0, caddy_1.caddyDaemonRunning)())) {
+                error('caddy daemon not running. `brew services start caddy` first.');
+                if (!parameters.options.fromGluegunMenu)
+                    process.exit(1);
+                return 'dev test: caddy daemon down';
+            }
+            const reg = (0, dev_state_1.loadRegistry)();
+            const entry = reg.projects[identity.slug];
+            const session = (0, dev_state_1.loadSession)(layout.root);
+            const sessionAlive = session !== null &&
+                ((session.pids.api && (0, dev_state_1.isPidAlive)(session.pids.api)) || (session.pids.app && (0, dev_state_1.isPidAlive)(session.pids.app)));
+            if (!entry || !sessionAlive) {
+                info(colors.dim('Project not running — invoking `lt dev up` first ...'));
+                const upResult = yield runChild('lt', ['dev', 'up'], { cwd: layout.root, env: process.env, inherit: true });
+                if (upResult !== 0) {
+                    error(`lt dev up failed (exit ${upResult}).`);
+                    if (!parameters.options.fromGluegunMenu)
+                        process.exit(upResult !== null && upResult !== void 0 ? upResult : 1);
+                    return 'dev test: up failed';
+                }
+                // Wait for App URL to respond (best-effort).
+                const appHost = (_a = identity.subdomains.app) === null || _a === void 0 ? void 0 : _a.hostname;
+                if (appHost) {
+                    info(colors.dim(`Waiting for https://${appHost} to respond ...`));
+                    yield waitForUrl(`https://${appHost}`, 30000);
+                }
+            }
+        }
+        // Build env: process.env + bridge file (bridge wins for keys it defines).
+        const env = Object.assign(Object.assign({}, process.env), readBridgeEnv(layout.root));
+        if (debug) {
+            env.PWDEBUG = '1';
+            env.HEADED = '1';
+        }
+        // Pick the runner.
+        const pnpmBin = process.env.LT_PNPM_BIN || 'pnpm';
+        const args = apiMode ? ['run', 'test:e2e', ...forwarded] : ['run', 'test:e2e', ...forwarded];
+        info('');
+        info(colors.bold(`Running ${apiMode ? 'API' : 'App'} E2E tests for "${identity.slug}"`));
+        info(colors.dim(`  ${pnpmBin} ${args.join(' ')}`));
+        info(colors.dim(`  cwd: ${targetDir}`));
+        info('');
+        const exitCode = yield runChild(pnpmBin, args, { cwd: targetDir, env, inherit: true });
+        if (teardown) {
+            info('');
+            info(colors.dim('Tearing down lt dev session ...'));
+            yield runChild('lt', ['dev', 'down'], { cwd: layout.root, env: process.env, inherit: true });
+        }
+        if (exitCode === 0)
+            success('Tests passed.');
+        else
+            error(`Tests failed (exit ${exitCode}).`);
+        if (!parameters.options.fromGluegunMenu)
+            process.exit(exitCode !== null && exitCode !== void 0 ? exitCode : 1);
+        return `dev test: exit=${exitCode}`;
+    }),
+};
+/**
+ * Read the .lt-dev/.env bridge file as a key/value map.
+ * Returns an empty object if the file is missing.
+ */
+function readBridgeEnv(root) {
+    const file = (0, dev_env_bridge_1.envBridgePath)(root);
+    if (!(0, fs_1.existsSync)(file))
+        return {};
+    const out = {};
+    for (const line of (0, fs_1.readFileSync)(file, 'utf8').split(/\r?\n/)) {
+        const m = line.match(/^([A-Z][A-Z0-9_]*)=(.*)$/);
+        if (m)
+            out[m[1]] = m[2];
+    }
+    return out;
+}
+/** Spawn a child synchronously (waits for exit), inheriting stdio when requested. */
+function runChild(cmd, args, opts) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            cwd: opts.cwd,
+            env: opts.env,
+            stdio: opts.inherit ? 'inherit' : 'pipe',
+        });
+        child.on('error', () => resolve(1));
+        child.on('close', (code) => resolve(code));
+    });
+}
+/** Poll a URL until it responds or timeout elapses. */
+function waitForUrl(url, timeoutMs) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        const tick = () => {
+            var _a;
+            const child = (0, child_process_1.spawn)('curl', ['-sk', '-o', '/dev/null', '-w', '%{http_code}', '--max-time', '2', url], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            let status = '';
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (status += String(b)));
+            child.on('close', () => {
+                if (/^[1-5]\d\d$/.test(status.trim()))
+                    return resolve(true);
+                if (Date.now() - start > timeoutMs)
+                    return resolve(false);
+                setTimeout(tick, 500);
+            });
+            child.on('error', () => {
+                if (Date.now() - start > timeoutMs)
+                    return resolve(false);
+                setTimeout(tick, 500);
+            });
+        };
+        tick();
+    });
+}
+module.exports = TestCommand;

package/build/commands/dev/up.js

@@ -0,0 +1,228 @@
+"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 caddy_1 = require("../../lib/caddy");
+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_patches_1 = require("../../lib/dev-patches");
+const dev_process_1 = require("../../lib/dev-process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+/**
+ * Start API + App behind Caddy with project-specific URLs.
+ *
+ * Pre-flight:
+ * - Caddy must be installed and running (otherwise points to install)
+ * - No existing `lt dev up` session for THIS project
+ * - Internal upstream ports must be free
+ *
+ * Process:
+ * 1. Resolve layout + identity
+ * 2. Allocate (or reuse) internal upstream ports
+ * 3. Upsert Caddy block + reload
+ * 4. Spawn API + App detached, log into `<root>/.lt-dev/{api,app}.log`
+ * 5. Persist registry entry + session state
+ *
+ * Env-vars injected (see lib/dev-env.ts):
+ *   PORT, BASE_URL, APP_URL, NUXT_API_URL, NUXT_PUBLIC_API_URL,
+ *   NUXT_PUBLIC_SITE_URL, NUXT_PUBLIC_STORAGE_PREFIX,
+ *   NSC__MONGOOSE__URI, NSC__BASE_URL, NSC__APP_URL, DATABASE_URL,
+ *   NUXT_PUBLIC_API_PROXY=false (Caddy makes vite-proxy obsolete).
+ */
+const UpCommand = {
+    alias: ['u'],
+    description: 'Start API + App behind Caddy',
+    hidden: false,
+    name: 'up',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const { filesystem, parameters, print: { colors, error, info, success, warning }, } = toolbox;
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        if (!layout.apiDir && !layout.appDir) {
+            error('No API or App project detected at this path. Run `lt dev migrate` first.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev up: not a project';
+        }
+        // Pre-flight: Caddy
+        if (!(yield (0, caddy_1.caddyAvailable)())) {
+            error('caddy is not installed. Run `lt dev install` first.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev up: caddy missing';
+        }
+        if (!(yield (0, caddy_1.caddyDaemonRunning)())) {
+            error('caddy daemon is not running. Start it: `brew services start caddy`.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev up: caddy daemon down';
+        }
+        const identity = (0, dev_identity_1.buildIdentity)(layout.root);
+        const dbName = (0, dev_project_1.deriveDbName)(layout.apiDir, identity.slug);
+        // Sanft auto-migrate sichere Operationen (ohne Code-Modifikation):
+        // CLAUDE.md-URL-Block einfügen + .gitignore ergänzen.
+        // Code-Patches (config.env.ts, nuxt.config.ts) bleiben explizit `lt dev migrate`.
+        {
+            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)`));
+            }
+            if ((0, dev_patches_1.addToGitignore)(layout.root, '.lt-dev/')) {
+                info(colors.dim('added `.lt-dev/` to .gitignore'));
+            }
+        }
+        // Warnung bei Legacy-Code (hardcoded ports) — kein Auto-Patch.
+        {
+            const legacyFiles = [];
+            if (layout.apiDir) {
+                const f = (0, dev_project_1.apiNeedsPortPatch)(layout.apiDir);
+                if (f)
+                    legacyFiles.push(f);
+            }
+            if (layout.appDir)
+                legacyFiles.push(...(0, dev_project_1.appNeedsPortPatch)(layout.appDir));
+            if (legacyFiles.length > 0) {
+                warning('Legacy hardcoded ports detected — Caddy will proxy correctly only after running `lt dev migrate`:');
+                legacyFiles.forEach((f) => info(colors.dim(`  - ${f}`)));
+                info(colors.dim('  (Continuing — env-aware files will work; legacy files may bind on 3000/3001 and miss Caddy.)'));
+            }
+        }
+        // Already running?
+        const existingSession = (0, dev_state_1.loadSession)(layout.root);
+        if (existingSession) {
+            const apiUp = existingSession.pids.api ? (0, dev_state_1.isPidAlive)(existingSession.pids.api) : false;
+            const appUp = existingSession.pids.app ? (0, dev_state_1.isPidAlive)(existingSession.pids.app) : false;
+            if (apiUp || appUp) {
+                warning(`Already running (api pid ${(_a = existingSession.pids.api) !== null && _a !== void 0 ? _a : '-'}, app pid ${(_b = existingSession.pids.app) !== null && _b !== void 0 ? _b : '-'}).`);
+                info('Run `lt dev down` first.');
+                if (!parameters.options.fromGluegunMenu)
+                    process.exit(1);
+                return 'dev up: already running';
+            }
+        }
+        // Allocate internal ports (reuse existing if registered).
+        const reg = (0, dev_state_1.loadRegistry)();
+        const entry = reg.projects[identity.slug];
+        const taken = (0, dev_state_1.takenInternalPorts)(reg, identity.slug);
+        const apiPort = (_c = entry === null || entry === void 0 ? void 0 : entry.internalPorts.api) !== null && _c !== void 0 ? _c : (layout.apiDir ? (0, dev_state_1.allocateInternalPort)(4000, taken) : undefined);
+        if (apiPort)
+            taken.add(apiPort);
+        const appPort = (_d = entry === null || entry === void 0 ? void 0 : entry.internalPorts.app) !== null && _d !== void 0 ? _d : (layout.appDir ? (0, dev_state_1.allocateInternalPort)(4000, taken) : undefined);
+        // Pre-flight: internal ports free?
+        const portsToCheck = [apiPort, appPort].filter((p) => typeof p === 'number');
+        const snap = yield (0, dev_process_1.listenSnapshot)(portsToCheck);
+        for (const p of portsToCheck) {
+            const r = snap.get(p);
+            if (r) {
+                error(`Internal port ${p} already in use by ${r.command} (pid ${r.pid}).`);
+                if (!parameters.options.fromGluegunMenu)
+                    process.exit(1);
+                return 'dev up: port in use';
+            }
+        }
+        // Caddy block + reload.
+        const routes = [];
+        if (identity.subdomains.api && apiPort)
+            routes.push({ hostname: identity.subdomains.api.hostname, upstreamPort: apiPort });
+        if (identity.subdomains.app && appPort)
+            routes.push({ hostname: identity.subdomains.app.hostname, upstreamPort: appPort });
+        if (routes.length === 0) {
+            error('No subdomains to expose (project has neither api nor app).');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev up: nothing to expose';
+        }
+        (0, caddy_1.upsertProjectBlock)(identity.slug, routes);
+        const reload = yield (0, caddy_1.reloadCaddy)();
+        if (!reload.ok) {
+            error(`caddy reload failed:\n${reload.stderr}`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev up: caddy reload failed';
+        }
+        info('');
+        info(colors.bold(`Starting "${identity.slug}"`));
+        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(`  db:  mongodb://127.0.0.1/${dbName}`);
+        info('');
+        // Build env per process.
+        const devEnv = (0, dev_env_1.buildDevEnv)({
+            apiInternalPort: apiPort !== null && apiPort !== void 0 ? apiPort : 0,
+            appInternalPort: appPort !== null && appPort !== void 0 ? appPort : 0,
+            baseEnv: process.env,
+            dbName,
+            identity,
+        });
+        const pnpmBin = process.env.LT_PNPM_BIN || 'pnpm';
+        const pids = {};
+        if (layout.apiDir && (0, fs_1.existsSync)((0, path_1.join)(layout.apiDir, 'package.json')) && apiPort) {
+            const apiPid = (0, dev_process_1.spawnDetached)(pnpmBin, ['start'], {
+                cwd: layout.apiDir,
+                env: devEnv.api.env,
+                logFile: (0, path_1.join)(layout.root, '.lt-dev', 'api.log'),
+            });
+            if (apiPid)
+                pids.api = apiPid;
+        }
+        if (layout.appDir && (0, fs_1.existsSync)((0, path_1.join)(layout.appDir, 'package.json')) && appPort) {
+            const appPid = (0, dev_process_1.spawnDetached)(pnpmBin, ['dev'], {
+                cwd: layout.appDir,
+                env: devEnv.app.env,
+                logFile: (0, path_1.join)(layout.root, '.lt-dev', 'app.log'),
+            });
+            if (appPid)
+                pids.app = appPid;
+        }
+        // Persist.
+        const subdomainMap = {};
+        for (const [k, v] of Object.entries(identity.subdomains))
+            subdomainMap[k] = v.hostname;
+        reg.projects[identity.slug] = {
+            dbName,
+            internalPorts: { api: apiPort, app: appPort },
+            lastUsedAt: new Date().toISOString(),
+            path: layout.root,
+            subdomains: subdomainMap,
+        };
+        (0, dev_state_1.saveRegistry)(reg);
+        (0, dev_state_1.saveSession)(layout.root, { pids, startedAt: new Date().toISOString() });
+        // 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);
+        info(colors.dim(`ENV bridge: ${bridgePath}`));
+        success(`Started: api pid=${(_e = pids.api) !== null && _e !== void 0 ? _e : '-'}, app pid=${(_f = pids.app) !== null && _f !== void 0 ? _f : '-'}`);
+        info(colors.dim('Logs: <root>/.lt-dev/api.log, <root>/.lt-dev/app.log'));
+        info(colors.dim('Stop with: lt dev down'));
+        // Best-effort: kill orphaned children if neither spawned (unlikely, but tidy).
+        if (Object.keys(pids).length === 0) {
+            warning('Nothing was spawned. Check package.json scripts (`start` for api, `dev` for app).');
+            if (pids.api)
+                (0, dev_process_1.killProcessGroup)(pids.api);
+            if (pids.app)
+                (0, dev_process_1.killProcessGroup)(pids.app);
+        }
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `dev up: api=${pids.api}, app=${pids.app}`;
+    }),
+};
+module.exports = UpCommand;

package/build/commands/fullstack/init.js

@@ -12,6 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+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 workspace_integration_1 = require("../../lib/workspace-integration");
 const add_api_1 = __importDefault(require("./add-api"));
@@ -27,7 +31,7 @@ const NewCommand = {
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
         // Retrieve the tools we need
-        const { config, filesystem, frontendHelper, git, helper, parameters, patching, print: { error, info, spin, success }, prompt: { ask, confirm }, server, strings: { kebabCase }, system, template, } = toolbox;
+        const { config, filesystem, frontendHelper, git, helper, parameters, patching, print: { colors, error, info, spin, success }, prompt: { ask, confirm }, server, strings: { kebabCase }, system, template, } = toolbox;
         // Start timer
         const timer = system.startTimer();
         // Info
@@ -637,6 +641,22 @@ const NewCommand = {
                     return;
                 }
             }
+            // Best-effort `lt dev migrate` so the workspace is ready for `lt dev up`
+            // out-of-the-box: registers the slug in `~/.lenneTech/projects.json`,
+            // injects the URL block into CLAUDE.md, adds `.lt-dev/` to .gitignore.
+            // Failures here are non-fatal — `init` itself remains successful.
+            let devMigrateOk = false;
+            try {
+                const layout = (0, dev_project_1.resolveLayout)(projectDir, gluegun_1.filesystem);
+                const migrate = (0, dev_migrate_helper_1.runMigrate)({ layout });
+                devMigrateOk = true;
+                if (!migrate.alreadyMigrated) {
+                    info(colors.dim(`  registered "${migrate.identity.slug}" with \`lt dev\``));
+                }
+            }
+            catch (_1) {
+                /* best-effort — never block init */
+            }
             // We're done, so show what to do next
             info('');
             success(`Generated fullstack workspace with ${frontend} in ${projectDir} with ${name} app in ${helper.msToMinutesAndSeconds(timer())}m.`);
@@ -652,7 +672,21 @@ const NewCommand = {
             else {
                 info(`  Run ${name}`);
                 info(`  $ cd ${projectDir}`);
-                info(`  $ ${toolbox.pm.run('start')}`);
+                if (devMigrateOk) {
+                    // Prefer lt dev up — sets up Caddy + HTTPS URLs + cross-wiring guards.
+                    const caddyOk = yield (0, caddy_1.caddyAvailable)();
+                    if (caddyOk) {
+                        info('  $ lt dev up   # start API + App behind Caddy with project-specific URLs');
+                    }
+                    else {
+                        info('  $ lt dev install   # one-time per machine: verify Caddy + CA');
+                        info('  $ lt dev up        # then: start API + App behind Caddy');
+                    }
+                    info(colors.dim(`  (fallback: ${toolbox.pm.run('start')} runs the classic localhost:3000/3001 mode)`));
+                }
+                else {
+                    info(`  $ ${toolbox.pm.run('start')}`);
+                }
             }
             info('');
             if (!toolbox.parameters.options.fromGluegunMenu) {

package/build/commands/status.js

@@ -10,9 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
+const dev_identity_1 = require("../lib/dev-identity");
+const dev_state_1 = require("../lib/dev-state");
 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
@@ -235,32 +236,31 @@ 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?".
+        // Local dev orchestration registry — surface URLs if registered.
+        // Helps users discover that `lt dev` is set up for this project, and
+        // gives a quick inline answer to "what URLs 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];
+                const slug = (0, dev_identity_1.projectSlug)(registryRoot);
+                const entry = (0, dev_state_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}`);
+                    info(colors.bold('Local dev orchestration (lt dev):'));
+                    for (const [sub, host] of Object.entries(entry.subdomains)) {
+                        info(`  ${sub.padEnd(6)} https://${host}`);
+                    }
                     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;
+                        info(`  db     mongodb://127.0.0.1/${entry.dbName}`);
+                    const session = (0, dev_state_1.loadSession)(registryRoot);
+                    const apiAlive = (session === null || session === void 0 ? void 0 : session.pids.api) ? (0, dev_state_1.isPidAlive)(session.pids.api) : false;
+                    const appAlive = (session === null || session === void 0 ? void 0 : session.pids.app) ? (0, dev_state_1.isPidAlive)(session.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.'));
+                        info(colors.dim('  Hint: `lt dev up` to start API + App behind Caddy.'));
                     }
                 }
             }