@lenne.tech/cli 1.21.0 → 1.23.0

package/README.md

@@ -57,21 +57,27 @@ $ lt status
 $ lt completion install
 ```
 
-## Local dev orchestration (parallel projects)
+## Local dev orchestration (parallel projects, HTTPS URLs)
 
-Run multiple lt projects on the same machine without manually shuffling ports.
-Each project gets a deterministic port slot (`3000+slot*10` / `3001+slot*10`) and
-the matching env vars are injected into spawned dev servers automatically.
+Run multiple lt projects on the same machine without port collisions or
+cross-wiring. Each project gets stable HTTPS URLs (`<slug>.localhost`,
+`api.<slug>.localhost`) served by Caddy, and the matching env vars
+(`BASE_URL`, `APP_URL`, `NUXT_PUBLIC_*`, `NSC__MONGOOSE__URI`, …) are
+injected into the spawned dev servers automatically.
 
 ```bash
-# Once per project:
-$ lt local init                    # register slot + patch legacy hardcoded ports
+# Once per machine:
+$ lt dev install                   # verify Caddy, prep Caddyfile + local CA
+
+# Once per project (idempotent):
+$ lt dev migrate                   # patch legacy hardcoded ports + register
 
 # Daily:
-$ lt local up                      # start API + App
-$ lt local status                  # show running PIDs + bound ports
-$ lt local down                    # SIGTERM the process group
-$ lt ports                         # cross-project port overview
+$ lt dev up                        # start API + App behind Caddy
+$ lt dev status                    # current project status
+$ lt dev status --all              # all registered projects
+$ lt dev down                      # SIGTERM the process group + remove Caddy block
+$ lt dev doctor                    # diagnose Caddy / CA / DNS / port issues
 ```
 
 Full reference: [docs/commands.md → Local Development Commands](docs/commands.md#local-development-commands).

package/build/commands/{local/local.js → dev/dev.js}

@@ -10,21 +10,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Local development orchestration commands (`lt local <subcommand>`).
+ * Local development orchestration commands (`lt dev <subcommand>`).
  *
  * Subcommands:
- * - `init`   — register a port slot for this project
- * - `up`     — start API + App with project-specific ports
- * - `down`   — stop processes started by `up`
- * - `status` — show what is running
+ * - `install`   — one-time per-machine setup: caddy + LaunchAgent/systemd unit
+ * - `uninstall` — remove the lt-dev service (symmetric to install)
+ * - `migrate`   — register an existing project (idempotent ENV patches)
+ * - `up`        — start API + App behind Caddy with project-specific URLs
+ * - `down`      — stop the detached processes + remove the Caddy block
+ * - `status`    — show what is running
+ * - `doctor`    — diagnose Caddy/CA/DNS/port issues
+ * - `tunnel`    — Cloudflare quick tunnel to expose a running project publicly
  */
 module.exports = {
-    alias: ['l'],
-    description: 'Local dev orchestration',
+    alias: ['d'],
+    description: 'Local dev orchestration (Caddy + per-project URLs)',
     hidden: false,
-    name: 'local',
+    name: 'dev',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
-        yield toolbox.helper.showMenu('local');
-        return 'local';
+        yield toolbox.helper.showMenu('dev');
+        return 'dev';
     }),
 };

package/build/commands/dev/doctor.js

@@ -0,0 +1,144 @@
+"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 caddy_1 = require("../../lib/caddy");
+const dev_process_1 = require("../../lib/dev-process");
+const dev_service_1 = require("../../lib/dev-service");
+const dev_state_1 = require("../../lib/dev-state");
+/**
+ * Diagnose Caddy / CA / DNS / port issues for `lt dev`.
+ *
+ * Categorical output (OK / WARN / FAIL) so developers can quickly see
+ * what is missing on a fresh machine. Exit code 0 = all green,
+ * 1 = at least one FAIL.
+ *
+ * Checks our OWN LaunchAgent / systemd-user unit — not
+ * `brew services caddy`. The latter cannot host our Caddyfile.
+ */
+const DoctorCommand = {
+    alias: ['doc'],
+    description: 'Diagnose Caddy/CA/DNS/port issues',
+    hidden: false,
+    name: 'doctor',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { parameters, print: { colors, info }, } = toolbox;
+        info('');
+        info(colors.bold('lt dev doctor'));
+        info(colors.dim('─'.repeat(60)));
+        let fails = 0;
+        // 1. Caddy installed
+        const hasCaddy = yield (0, caddy_1.caddyAvailable)();
+        if (hasCaddy)
+            line('OK', colors.green, 'caddy on PATH');
+        else {
+            line('FAIL', colors.red, 'caddy not installed — run `brew install caddy` then `lt dev install`');
+            fails++;
+        }
+        // 2. Service installed (LaunchAgent / systemd-user)
+        const plat = (0, dev_service_1.platformSupported)();
+        if (plat === 'unsupported') {
+            line('WARN', colors.yellow, `service management not supported on ${process.platform} — run caddy manually`);
+        }
+        else {
+            const svc = yield (0, dev_service_1.getServiceStatus)();
+            const servicePaths = (0, dev_service_1.getServicePaths)();
+            if (svc.installed && svc.loaded) {
+                line('OK', colors.green, `lt-dev service loaded (${servicePaths.unitFile})`);
+            }
+            else if (svc.installed && !svc.loaded) {
+                line('FAIL', colors.red, `service file exists but is not loaded — run \`lt dev install\``);
+                fails++;
+            }
+            else {
+                line('FAIL', colors.red, `lt-dev service not installed — run \`lt dev install\``);
+                fails++;
+            }
+        }
+        // 3. Caddy daemon admin endpoint
+        if (hasCaddy) {
+            const daemon = yield (0, caddy_1.caddyDaemonRunning)();
+            if (daemon)
+                line('OK', colors.green, 'caddy admin (:2019) reachable');
+            else {
+                line('FAIL', colors.red, 'caddy admin (:2019) unreachable — run `lt dev install`');
+                fails++;
+            }
+        }
+        // 4. Caddyfile validates
+        if (hasCaddy) {
+            const v = yield (0, caddy_1.validateCaddyfile)();
+            if (v.ok)
+                line('OK', colors.green, `Caddyfile valid (${caddy_1.paths.caddyfile})`);
+            else
+                line('WARN', colors.yellow, `Caddyfile validation: ${v.stderr.split('\n')[0]}`);
+        }
+        // 4. Port 80 / 443 free or held by Caddy
+        for (const port of [80, 443]) {
+            const r = yield (0, dev_process_1.checkPortInUse)(port);
+            if (r === null)
+                line('WARN', colors.yellow, `lsof unavailable — cannot probe port ${port}`);
+            else if (!r.inUse)
+                line('OK', colors.green, `port ${port} free`);
+            else if (r.command === 'caddy')
+                line('OK', colors.green, `port ${port} held by caddy (pid ${r.pid})`);
+            else {
+                line('FAIL', colors.red, `port ${port} held by ${r.command} (pid ${r.pid}) — Caddy cannot bind`);
+                fails++;
+            }
+        }
+        // 5. *.localhost resolves to 127.0.0.1
+        const dnsOk = yield dnsResolvesLocalhost('lt-dev-doctor.localhost');
+        if (dnsOk)
+            line('OK', colors.green, '*.localhost resolves to 127.0.0.1 (RFC 6761)');
+        else
+            line('WARN', colors.yellow, '*.localhost may not resolve — check /etc/hosts or system resolver');
+        // 6. Registry
+        const reg = (0, dev_state_1.loadRegistry)();
+        const count = Object.keys(reg.projects).length;
+        line('OK', colors.green, `registry: ${count} project(s) at ${dev_state_1.paths.registry}`);
+        info('');
+        if (fails > 0)
+            info(colors.red(`✗ ${fails} fail(s) — see above`));
+        else
+            info(colors.green('✓ all checks passed'));
+        if (!parameters.options.fromGluegunMenu)
+            process.exit(fails > 0 ? 1 : 0);
+        return fails > 0 ? `dev doctor: ${fails} fails` : 'dev doctor: ok';
+        function line(tag, color, msg) {
+            info(`  ${color(`[${tag.padEnd(4)}]`)} ${msg}`);
+        }
+    }),
+};
+/**
+ * Probe DNS — RFC 6761 mandates *.localhost MUST resolve to loopback.
+ *
+ * On macOS the resolver returns `::1` first (IPv6 loopback); on Linux
+ * `127.0.0.1` (IPv4) is more common. Both are valid loopback addresses
+ * and Caddy listens on both, so we accept either.
+ */
+function dnsResolvesLocalhost(host) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)('node', [
+            '-e',
+            `require('dns').lookup(${JSON.stringify(host)}, { all: true }, (e, addrs) => {
+           if (e) process.exit(1);
+           const loopback = (addrs || []).some(a => a.address === '127.0.0.1' || a.address === '::1');
+           process.exit(loopback ? 0 : 1);
+         });`,
+        ], {
+            stdio: ['ignore', 'ignore', 'ignore'],
+        });
+        child.on('error', () => resolve(false));
+        child.on('close', (code) => resolve(code === 0));
+    });
+}
+module.exports = DoctorCommand;

package/build/commands/dev/down.js

@@ -0,0 +1,76 @@
+"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 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_process_1 = require("../../lib/dev-process");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+/**
+ * Stop the processes started by `lt dev up` and remove the project's
+ * Caddy block.
+ *
+ * - SIGTERM is sent to the detached process GROUP (negative PID) so
+ *   children (Vite, Nest watcher) receive the signal too.
+ * - The Caddy block is removed and `caddy reload` is invoked, so the
+ *   subdomain stops resolving immediately.
+ */
+const DownCommand = {
+    alias: ['d'],
+    description: 'Stop API + App and remove Caddy block',
+    hidden: false,
+    name: 'down',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { filesystem, parameters, print: { colors, info, success, warning }, } = toolbox;
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        const identity = (0, dev_identity_1.buildIdentity)(layout.root);
+        const session = (0, dev_state_1.loadSession)(layout.root);
+        const stopped = [];
+        if (session) {
+            for (const [name, pid] of Object.entries(session.pids)) {
+                if (!pid)
+                    continue;
+                if (!(0, dev_state_1.isPidAlive)(pid)) {
+                    stopped.push(`${name} (pid ${pid}, already dead)`);
+                    continue;
+                }
+                if ((0, dev_process_1.killProcessGroup)(pid))
+                    stopped.push(`${name} (pid ${pid})`);
+                else
+                    warning(`Failed to stop ${name} (pid ${pid})`);
+            }
+            (0, dev_state_1.clearSession)(layout.root);
+        }
+        else {
+            info(colors.dim('No running processes registered for this project.'));
+        }
+        // Remove Caddy block (best-effort — even if no session was active).
+        const removed = (0, caddy_1.removeProjectBlock)(identity.slug);
+        if (removed) {
+            const r = yield (0, caddy_1.reloadCaddy)();
+            if (r.ok)
+                success(`Removed Caddy block for "${identity.slug}".`);
+            else
+                warning(`Removed Caddy block but reload failed: ${r.stderr.split('\n')[0]}`);
+        }
+        // Clear ENV bridge so subsequent test runs without `lt dev up`
+        // do not pick up stale URLs.
+        if ((0, dev_env_bridge_1.clearEnvBridge)(layout.root))
+            info(colors.dim('Removed .lt-dev/.env bridge.'));
+        if (stopped.length > 0)
+            success(`Stopped: ${stopped.join(', ')}`);
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `dev down: ${stopped.length} stopped`;
+    }),
+};
+module.exports = DownCommand;

package/build/commands/dev/install.js

@@ -0,0 +1,172 @@
+"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 caddy_1 = require("../../lib/caddy");
+const dev_service_1 = require("../../lib/dev-service");
+/**
+ * One-time per-machine setup for `lt dev`.
+ *
+ * Owns the full Caddy lifecycle through a dedicated LaunchAgent
+ * (macOS) / systemd-user unit (Linux). This intentionally bypasses
+ * `brew services caddy`, whose plist hardcodes
+ * `--config /opt/homebrew/etc/Caddyfile` and would crash-loop against
+ * our `~/.lenneTech/Caddyfile` location — which is the bug that
+ * blocked the first real install.
+ *
+ * Steps (each idempotent — safe to re-run):
+ *   1. Verify `caddy` is on PATH (suggest install instructions otherwise)
+ *   2. Ensure `~/.lenneTech/Caddyfile` exists (stub written if missing)
+ *   3. Detect conflicting `brew services caddy` and tell the user to
+ *      stop it — it would fight us for ports 80/443
+ *   4. Install + bootstrap our LaunchAgent/systemd unit
+ *   5. Wait for the Caddy admin endpoint to respond
+ *   6. Validate the Caddyfile
+ *   7. Surface the `sudo -E HOME="$HOME" caddy trust` instruction for
+ *      installing the local CA (HOME must survive sudo so caddy can
+ *      find its CA files under the *user* profile, not /var/root)
+ */
+const InstallCommand = {
+    alias: ['i'],
+    description: 'Setup Caddy service for lt dev',
+    hidden: false,
+    name: 'install',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { parameters, print: { colors, error, info, success, warning }, } = toolbox;
+        info('');
+        info(colors.bold('lt dev install — one-time per-machine setup'));
+        info(colors.dim('─'.repeat(60)));
+        const plat = (0, dev_service_1.platformSupported)();
+        if (plat === 'unsupported') {
+            error(`Service management is not supported on ${process.platform}. Only macOS and Linux are covered.`);
+            info(`  Workaround: run \`${colors.cyan(`caddy run --config ${caddy_1.paths.caddyfile}`)}\` manually.`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev install: unsupported platform';
+        }
+        let blocked = false;
+        // 1. caddy on PATH
+        const hasCaddy = yield (0, caddy_1.caddyAvailable)();
+        if (hasCaddy) {
+            success('caddy is on PATH');
+        }
+        else {
+            warning('caddy is not installed.');
+            info(`  → macOS: ${colors.cyan('brew install caddy')}`);
+            info(`  → Linux: ${colors.cyan('https://caddyserver.com/docs/install')}`);
+            info('  (Do NOT start it via `brew services` — `lt dev install` runs its own service.)');
+            blocked = true;
+        }
+        // 2. Caddyfile stub
+        (0, caddy_1.writeCaddyfile)('# lt dev — managed Caddyfile\n# Add per-project blocks via `lt dev up`.\n');
+        success(`Caddyfile present at ${caddy_1.paths.caddyfile}`);
+        if (!hasCaddy) {
+            info('');
+            error('Cannot continue setup until Caddy is installed. Re-run `lt dev install` afterwards.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(blocked ? 1 : 0);
+            return 'dev install: caddy missing';
+        }
+        // 3. brew services conflict warning
+        const brewConflict = yield detectBrewCaddyConflict();
+        if (brewConflict) {
+            warning('A `brew services caddy` instance is registered.');
+            info(`  Stop it (it crash-loops against our Caddyfile): ${colors.cyan('brew services stop caddy')}`);
+            info('  `lt dev install` runs its own service — the brew one is no longer needed.');
+        }
+        // 4. Install our LaunchAgent / systemd unit
+        const paths = (0, dev_service_1.getServicePaths)();
+        info('');
+        info(`Installing ${plat === 'darwin' ? 'LaunchAgent' : 'systemd-user unit'} at:`);
+        info(colors.dim(`  ${paths.unitFile}`));
+        const installResult = yield (0, dev_service_1.installService)();
+        if (!installResult.ok) {
+            error(installResult.message);
+            blocked = true;
+        }
+        else {
+            if (installResult.created)
+                success(installResult.message);
+            else
+                info(colors.dim(installResult.message));
+        }
+        // 5. Wait for admin endpoint
+        if (installResult.ok) {
+            info(colors.dim('Waiting for Caddy admin endpoint (:2019) ...'));
+            const ready = yield (0, dev_service_1.waitForServiceReady)(8000);
+            const status = yield (0, dev_service_1.getServiceStatus)();
+            if (ready && status.daemonReachable) {
+                success(`Caddy daemon ready${status.pid ? ` (pid ${status.pid})` : ''}.`);
+            }
+            else if (status.loaded && !status.daemonReachable) {
+                warning('Service is loaded but admin endpoint did not respond within 8s.');
+                info(colors.dim(`  Logs: ${paths.logFile} / ${paths.errFile}`));
+                blocked = true;
+            }
+            else {
+                warning('Caddy daemon did not start. See logs:');
+                info(colors.dim(`  ${paths.logFile}`));
+                info(colors.dim(`  ${paths.errFile}`));
+                blocked = true;
+            }
+        }
+        // 6. Validate Caddyfile
+        if (installResult.ok) {
+            const validation = yield (0, caddy_1.validateCaddyfile)();
+            if (validation.ok)
+                success('Caddyfile validates');
+            else
+                warning(`Caddyfile validation: ${validation.stderr.split('\n').slice(0, 2).join(' / ')}`);
+        }
+        // 7. CA trust
+        info('');
+        info(colors.bold('Local CA trust'));
+        info('  Caddy creates its local CA on first run. To trust it system-wide,');
+        info('  run this once (HOME must be preserved so sudo keeps the user-scoped');
+        info('  CA, otherwise caddy looks in /var/root and fails):');
+        info(`    ${colors.cyan('sudo -E HOME="$HOME" caddy trust')}`);
+        info(`  Browsers will then accept ${colors.cyan('https://*.localhost')} without warnings.`);
+        info('');
+        if (blocked) {
+            warning('Setup incomplete. Address the items above and re-run `lt dev install`.');
+        }
+        else {
+            success('Setup complete. Use `lt dev migrate` in a project, then `lt dev up`.');
+        }
+        if (!parameters.options.fromGluegunMenu)
+            process.exit(blocked ? 1 : 0);
+        return blocked ? 'dev install: incomplete' : 'dev install: ok';
+    }),
+};
+/**
+ * Quick `brew services list` scan for a registered caddy service.
+ * Returns true on macOS if any entry contains "caddy" — error/started
+ * alike, both are conflicts. Always returns false on non-darwin or
+ * when `brew` is unavailable (no false positives).
+ */
+function detectBrewCaddyConflict() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (process.platform !== 'darwin')
+            return false;
+        return new Promise((resolve) => {
+            var _a;
+            const { spawn } = require('child_process');
+            const child = spawn('brew', ['services', 'list'], { stdio: ['ignore', 'pipe', 'ignore'] });
+            let out = '';
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (out += String(b)));
+            child.on('error', () => resolve(false));
+            child.on('close', () => {
+                const conflict = /\bcaddy\b/.test(out) && !/^caddy\s+none\b/m.test(out);
+                resolve(conflict);
+            });
+        });
+    });
+}
+module.exports = InstallCommand;

package/build/commands/dev/migrate.js

@@ -0,0 +1,96 @@
+"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 caddy_1 = require("../../lib/caddy");
+const dev_migrate_helper_1 = require("../../lib/dev-migrate-helper");
+const dev_project_1 = require("../../lib/dev-project");
+/**
+ * Register an existing project with `lt dev` and apply idempotent
+ * env-aware patches.
+ *
+ * Idempotent — re-running with no changes is a no-op. Safe to invoke
+ * automatically after `lt fullstack init` or by developers manually.
+ *
+ * Steps (delegated to `lib/dev-migrate-helper.ts#runMigrate`):
+ * 1. Resolve workspace layout (api/app dirs, root)
+ * 2. Build identity (slug + subdomains)
+ * 3. Patch hardcoded ports → env-aware fallbacks (config.env.ts,
+ *    nuxt.config.ts, playwright.config.ts)
+ * 4. Inject CLAUDE.md URL block (root + each subproject)
+ * 5. Persist project to ~/.lenneTech/projects.json
+ * 6. Add `.lt-dev/` to .gitignore
+ *
+ * Closes with a hint to run `lt dev install` if Caddy is missing.
+ */
+const MigrateCommand = {
+    alias: ['m'],
+    description: 'Migrate an existing project to lt dev (idempotent)',
+    hidden: false,
+    name: 'migrate',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        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 (src/config.env.ts) or App (nuxt.config.ts) project detected at this path.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev migrate: not a project';
+        }
+        const result = (0, dev_migrate_helper_1.runMigrate)({ layout });
+        info('');
+        info(colors.bold(`Migrating "${result.identity.slug}"`));
+        info(colors.dim('─'.repeat(60)));
+        if (result.identity.subdomains.app)
+            info(`  App URL: https://${result.identity.subdomains.app.hostname}`);
+        if (result.identity.subdomains.api)
+            info(`  API URL: https://${result.identity.subdomains.api.hostname}`);
+        info(`  DB:      mongodb://127.0.0.1/${result.dbName}`);
+        info('');
+        // Code patches
+        if (result.codePatches.length > 0) {
+            for (const r of result.codePatches) {
+                if (r.patched)
+                    success(`patched ${r.replacements}× in ${r.file}`);
+                else
+                    info(colors.dim(`already patched: ${r.file}`));
+            }
+        }
+        else {
+            info(colors.dim('  patches: not needed (already env-aware)'));
+        }
+        // CLAUDE.md
+        result.claudePatches.filter((r) => r.patched).forEach((r) => success(`updated CLAUDE.md URL block: ${r.file}`));
+        // Registry
+        if (result.registryUpdated) {
+            success(`registered in ${process.env.LT_DEV_REGISTRY_PATH || '~/.lenneTech/projects.json'}`);
+        }
+        // .gitignore
+        if (result.addedGitignoreEntry)
+            success('added `.lt-dev/` to .gitignore');
+        if (result.alreadyMigrated) {
+            info(colors.dim('  Project was already fully migrated — nothing changed.'));
+        }
+        info('');
+        success('Migration complete.');
+        // Hint: Caddy installed?
+        const caddyOk = yield (0, caddy_1.caddyAvailable)();
+        if (!caddyOk) {
+            warning('Caddy is not installed yet. Run `lt dev install` first, then `lt dev up`.');
+        }
+        else {
+            info('Start the project with `lt dev up`.');
+        }
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `dev migrate: ${result.identity.slug}`;
+    }),
+};
+module.exports = MigrateCommand;