@lenne.tech/cli 1.21.0 → 1.22.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,23 @@ 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`
+ * - `install` — one-time per-machine setup (Caddy + local CA + LaunchAgent)
+ * - `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
  */
 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,110 @@
+"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_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.
+ */
+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`');
+            fails++;
+        }
+        // 2. Caddy daemon
+        if (hasCaddy) {
+            const daemon = yield (0, caddy_1.caddyDaemonRunning)();
+            if (daemon)
+                line('OK', colors.green, 'caddy daemon running (admin :2019 reachable)');
+            else {
+                line('FAIL', colors.red, 'caddy daemon not running — `brew services start caddy`');
+                fails++;
+            }
+        }
+        // 3. 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 says *.localhost MUST resolve to loopback. */
+function dnsResolvesLocalhost(host) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)('node', [
+            '-e',
+            `require('dns').lookup(${JSON.stringify(host)}, (e, a) => { process.exit(e || a !== '127.0.0.1' ? 1 : 0); })`,
+        ], {
+            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,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runShell = runShell;
+const child_process_1 = require("child_process");
+const caddy_1 = require("../../lib/caddy");
+/**
+ * One-time per-machine setup for `lt dev`.
+ *
+ * Idempotent — re-running diagnoses the current state and only acts on
+ * what is missing.
+ *
+ * Steps:
+ * 1. Ensure `caddy` is on PATH (suggest `brew install caddy` if missing)
+ * 2. Ensure `~/.lenneTech/Caddyfile` exists (empty stub if missing)
+ * 3. Ensure Caddy is running as a background service (suggest
+ *    `brew services start caddy`)
+ * 4. Trust the local Caddy CA (`caddy trust` — needs sudo once)
+ */
+const InstallCommand = {
+    alias: ['i'],
+    description: 'One-time setup: install + start Caddy, trust local CA',
+    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)));
+        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(`  → Install with: ${colors.cyan('brew install caddy')} (macOS)`);
+            info(`  → Linux:        ${colors.cyan('https://caddyserver.com/docs/install')}`);
+            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) {
+            error('Cannot continue setup until Caddy is installed.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(blocked ? 1 : 0);
+            return 'dev install: caddy missing';
+        }
+        // 3. Caddy daemon
+        const daemon = yield (0, caddy_1.caddyDaemonRunning)();
+        if (daemon) {
+            success('caddy daemon is running');
+        }
+        else {
+            warning('caddy daemon is not running.');
+            info(`  → Start as a service (macOS):  ${colors.cyan('brew services start caddy')}`);
+            info(`  → Start manually:              ${colors.cyan(`caddy run --config ${caddy_1.paths.caddyfile}`)}`);
+            blocked = true;
+        }
+        // 4. Validate Caddyfile (catches config issues early)
+        const validation = yield (0, caddy_1.validateCaddyfile)();
+        if (validation.ok) {
+            success('Caddyfile validates');
+        }
+        else {
+            warning('Caddyfile validation reported issues:');
+            info(colors.dim(validation.stderr.split('\n').slice(0, 3).join('\n')));
+        }
+        // 5. CA trust
+        info('');
+        info(colors.bold('Local CA'));
+        info('  Caddy installs a local CA on first run. To trust it system-wide,');
+        info('  execute (one-time, requires sudo):');
+        info(`    ${colors.cyan('sudo 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';
+    }),
+};
+// Helper: spawn a command and wait for it (used by tests / future
+// auto-install. Currently unused but exported for symmetry with doctor).
+function runShell(cmd, args) {
+    return new Promise((resolve) => {
+        var _a, _b;
+        const child = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        let errored = false;
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (stdout += String(b)));
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (b) => (stderr += String(b)));
+        child.on('error', () => (errored = true));
+        child.on('close', (code) => resolve({ ok: !errored && code === 0, stderr, stdout }));
+    });
+}
+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;

package/build/commands/dev/status.js

@@ -0,0 +1,153 @@
+"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_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");
+/**
+ * Show what is running.
+ *
+ * Default: status for the current project (PIDs + URLs + DB).
+ * `--all`: list every project in the central registry with health checks.
+ */
+const StatusCommand = {
+    alias: ['s'],
+    description: 'Show lt dev status',
+    hidden: false,
+    name: 'status',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        const { filesystem, parameters, print: { colors, info, warning }, } = toolbox;
+        const all = Boolean(parameters.options.all);
+        const reg = (0, dev_state_1.loadRegistry)();
+        if (all) {
+            info('');
+            info(colors.bold('All registered lt dev projects'));
+            info(colors.dim('─'.repeat(60)));
+            const slugs = Object.keys(reg.projects).sort();
+            if (slugs.length === 0) {
+                warning('No projects registered. Run `lt dev migrate` in a project.');
+            }
+            else {
+                for (const slug of slugs) {
+                    const e = reg.projects[slug];
+                    const session = (0, dev_state_1.loadSession)(e.path);
+                    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;
+                    const status = apiAlive || appAlive ? colors.green('●') : colors.dim('○');
+                    info(`  ${status} ${slug.padEnd(30)} ${colors.dim(e.path)}`);
+                    for (const [sub, host] of Object.entries(e.subdomains))
+                        info(`     ${sub.padEnd(6)} https://${host}`);
+                }
+            }
+            info('');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit();
+            return 'dev status: all';
+        }
+        const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
+        const identity = (0, dev_identity_1.buildIdentity)(layout.root);
+        const entry = reg.projects[identity.slug];
+        info('');
+        info(colors.bold(`lt dev status: ${identity.slug}`));
+        info(colors.dim('─'.repeat(60)));
+        if (!entry) {
+            warning('Not registered. Run `lt dev migrate` first.');
+            // Show what migrate would do (legacy code present?) so the user
+            // can judge urgency before running it.
+            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) {
+                info(colors.dim('  Legacy hardcoded ports detected — `lt dev migrate` will patch:'));
+                legacyFiles.forEach((f) => info(colors.dim(`    - ${f}`)));
+            }
+            else {
+                info(colors.dim('  Code is already env-aware; `lt dev migrate` will only register + patch CLAUDE.md.'));
+            }
+            info('');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit();
+            return 'dev status: not registered';
+        }
+        for (const [sub, host] of Object.entries(entry.subdomains)) {
+            const port = sub === 'api' ? entry.internalPorts.api : entry.internalPorts.app;
+            info(`  ${sub.padEnd(6)} https://${host}${port ? colors.dim(`  →  127.0.0.1:${port}`) : ''}`);
+        }
+        if (entry.dbName)
+            info(`  db     mongodb://127.0.0.1/${entry.dbName}`);
+        // Patch status — quick view whether legacy ports are still in source.
+        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) {
+            info('');
+            warning('  Legacy hardcoded ports still present:');
+            legacyFiles.forEach((f) => info(colors.dim(`    - ${f}`)));
+            info(colors.dim('  Run `lt dev migrate` to patch them; otherwise Caddy may proxy into the void.'));
+        }
+        // Caddy status — quick view whether the daemon is reachable.
+        {
+            const caddyOk = yield (0, caddy_1.caddyAvailable)();
+            const daemonOk = caddyOk ? yield (0, caddy_1.caddyDaemonRunning)() : false;
+            info('');
+            if (!caddyOk) {
+                warning('  Caddy not installed — run `lt dev install` first.');
+            }
+            else if (!daemonOk) {
+                warning('  Caddy daemon not running — `brew services start caddy`.');
+            }
+            else {
+                info(colors.dim('  Caddy: ready'));
+            }
+        }
+        info('');
+        const session = (0, dev_state_1.loadSession)(layout.root);
+        if (!session) {
+            info(colors.dim('  no `lt dev up` session active'));
+        }
+        else {
+            const apiAlive = session.pids.api ? (0, dev_state_1.isPidAlive)(session.pids.api) : false;
+            const appAlive = session.pids.app ? (0, dev_state_1.isPidAlive)(session.pids.app) : false;
+            info(`  api: ${apiAlive ? colors.green('running') : colors.red('dead')} (pid ${(_a = session.pids.api) !== null && _a !== void 0 ? _a : '-'})`);
+            info(`  app: ${appAlive ? colors.green('running') : colors.red('dead')} (pid ${(_b = session.pids.app) !== null && _b !== void 0 ? _b : '-'})`);
+            info(colors.dim(`  started: ${session.startedAt}`));
+            // Live port snapshot
+            const ports = [entry.internalPorts.api, entry.internalPorts.app].filter((p) => typeof p === 'number');
+            if (ports.length > 0) {
+                info('');
+                info(colors.bold('  Live upstream state'));
+                const snap = yield (0, dev_process_1.listenSnapshot)(ports);
+                for (const p of ports) {
+                    const r = snap.get(p);
+                    info(`    ${p}: ${r ? colors.green(`bound to ${r.command} (pid ${r.pid})`) : colors.dim('free')}`);
+                }
+            }
+        }
+        info('');
+        if (!parameters.options.fromGluegunMenu)
+            process.exit();
+        return `dev status: ${identity.slug}`;
+    }),
+};
+module.exports = StatusCommand;