@lenne.tech/cli 1.22.0 → 1.23.0

package/build/commands/dev/dev.js

@@ -13,12 +13,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Local development orchestration commands (`lt dev <subcommand>`).
  *
  * Subcommands:
- * - `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
+ * - `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: ['d'],

package/build/commands/dev/doctor.js

@@ -12,6 +12,7 @@ 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`.
@@ -19,6 +20,9 @@ const dev_state_1 = require("../../lib/dev-state");
  * 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'],
@@ -36,20 +40,40 @@ const DoctorCommand = {
         if (hasCaddy)
             line('OK', colors.green, 'caddy on PATH');
         else {
-            line('FAIL', colors.red, 'caddy not installed — run `brew install caddy`');
+            line('FAIL', colors.red, 'caddy not installed — run `brew install caddy` then `lt dev install`');
             fails++;
         }
-        // 2. Caddy daemon
+        // 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 daemon running (admin :2019 reachable)');
+                line('OK', colors.green, 'caddy admin (:2019) reachable');
             else {
-                line('FAIL', colors.red, 'caddy daemon not running — `brew services start caddy`');
+                line('FAIL', colors.red, 'caddy admin (:2019) unreachable — run `lt dev install`');
                 fails++;
             }
         }
-        // 3. Caddyfile validates
+        // 4. Caddyfile validates
         if (hasCaddy) {
             const v = yield (0, caddy_1.validateCaddyfile)();
             if (v.ok)
@@ -94,12 +118,22 @@ const DoctorCommand = {
         }
     }),
 };
-/** Probe DNS — RFC 6761 says *.localhost MUST resolve to loopback. */
+/**
+ * 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)}, (e, a) => { process.exit(e || a !== '127.0.0.1' ? 1 : 0); })`,
+            `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'],
         });

package/build/commands/dev/install.js

@@ -9,25 +9,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runShell = runShell;
-const child_process_1 = require("child_process");
 const caddy_1 = require("../../lib/caddy");
+const dev_service_1 = require("../../lib/dev-service");
 /**
  * One-time per-machine setup for `lt dev`.
  *
- * Idempotent — re-running diagnoses the current state and only acts on
- * what is missing.
+ * 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:
- * 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)
+ * 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: 'One-time setup: install + start Caddy, trust local CA',
+    description: 'Setup Caddy service for lt dev',
     hidden: false,
     name: 'install',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
@@ -35,53 +43,95 @@ const InstallCommand = {
         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
+        // 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')}`);
+            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) {
-            error('Cannot continue setup until Caddy is installed.');
+            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. Caddy daemon
-        const daemon = yield (0, caddy_1.caddyDaemonRunning)();
-        if (daemon) {
-            success('caddy daemon is running');
+        // 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.');
         }
-        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}`)}`);
+        // 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;
         }
-        // 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')));
+            if (installResult.created)
+                success(installResult.message);
+            else
+                info(colors.dim(installResult.message));
         }
-        // 5. CA trust
+        // 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'));
-        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(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) {
@@ -95,19 +145,28 @@ const InstallCommand = {
         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 }));
+/**
+ * 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/status.js

@@ -115,7 +115,7 @@ const StatusCommand = {
                 warning('  Caddy not installed — run `lt dev install` first.');
             }
             else if (!daemonOk) {
-                warning('  Caddy daemon not running — `brew services start caddy`.');
+                warning('  Caddy daemon not running — run `lt dev install` to (re)start the lt-dev service.');
             }
             else {
                 info(colors.dim('  Caddy: ready'));

package/build/commands/dev/test.js

@@ -77,7 +77,7 @@ const TestCommand = {
                 return 'dev test: caddy missing';
             }
             if (!(yield (0, caddy_1.caddyDaemonRunning)())) {
-                error('caddy daemon not running. `brew services start caddy` first.');
+                error('caddy daemon not running. Run `lt dev install` first.');
                 if (!parameters.options.fromGluegunMenu)
                     process.exit(1);
                 return 'dev test: caddy daemon down';

package/build/commands/dev/tunnel.js

@@ -0,0 +1,142 @@
+"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 cloudflared_1 = require("../../lib/cloudflared");
+const dev_identity_1 = require("../../lib/dev-identity");
+const dev_project_1 = require("../../lib/dev-project");
+const dev_state_1 = require("../../lib/dev-state");
+/**
+ * Expose a running `lt dev up` project to the public internet via a
+ * Cloudflare Quick Tunnel.
+ *
+ * Quick tunnel = no Cloudflare account, ephemeral `*.trycloudflare.com`
+ * URL, runs in the foreground until Ctrl-C. Designed for ad-hoc work:
+ *   - mobile / tablet preview from outside the LAN
+ *   - sharing a feature with a teammate during review
+ *   - landing webhooks from external services
+ *
+ * Caveats (printed at runtime):
+ *   - Auth cookies set on `<slug>.localhost` are NOT valid on the
+ *     `*.trycloudflare.com` domain — log in again on the public URL.
+ *   - The default tunnel exposes ONLY the App subdomain (the API stays
+ *     on `*.localhost`). Use `--api` to tunnel the API instead, or
+ *     start a second `lt dev tunnel --api` in parallel.
+ *   - Better-Auth's `trustedOrigins` won't include the random tunnel
+ *     URL — login flows that validate the origin will reject the
+ *     request unless you add the URL explicitly to your API config.
+ *
+ * Not yet supported (deliberate, separate command if needed later):
+ *   - named tunnels with persistent URL (`cloudflared tunnel create`)
+ *   - parallel multi-host tunnels in one process
+ *   - background/detached mode (use a separate shell for now)
+ */
+const TunnelCommand = {
+    alias: ['tun'],
+    description: 'Cloudflare quick-tunnel to a running app',
+    hidden: false,
+    name: 'tunnel',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        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 tunnel: not a project';
+        }
+        const apiMode = Boolean(parameters.options.api);
+        const identity = (0, dev_identity_1.buildIdentity)(layout.root);
+        const targetSub = apiMode ? identity.subdomains.api : identity.subdomains.app;
+        if (!targetSub) {
+            error(`No ${apiMode ? 'API' : 'App'} subdomain configured for "${identity.slug}".`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev tunnel: no target';
+        }
+        // Pre-flight: cloudflared installed
+        const available = yield (0, cloudflared_1.cloudflaredAvailable)();
+        if (!available.installed) {
+            error('cloudflared is not installed.');
+            info(`  → ${colors.cyan('brew install cloudflared')} (macOS)`);
+            info(`  → ${colors.cyan('https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/')} (Linux/Windows)`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev tunnel: cloudflared missing';
+        }
+        // Pre-flight: Caddy must be up — without it cloudflared would forward
+        // to a dead upstream and the public URL would 502.
+        if (!(yield (0, caddy_1.caddyDaemonRunning)())) {
+            error('Caddy daemon is not running — run `lt dev install` first.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev tunnel: caddy down';
+        }
+        const registry = (0, dev_state_1.loadRegistry)();
+        if (!registry.projects[identity.slug]) {
+            warning(`Project "${identity.slug}" is not in the lt-dev registry. Run \`lt dev up\` first.`);
+            info('  (Continuing anyway — Caddy may have a stale block.)');
+        }
+        const upstreamUrl = `https://${targetSub.hostname}`;
+        info('');
+        info(colors.bold(`lt dev tunnel — Cloudflare Quick Tunnel`));
+        info(colors.dim('─'.repeat(60)));
+        info(`  Upstream: ${colors.cyan(upstreamUrl)}`);
+        info(colors.dim(`  cloudflared ${available.version || 'unknown'}`));
+        info('');
+        info(colors.dim('Starting tunnel — this typically takes 5-10 seconds ...'));
+        const tunnel = (0, cloudflared_1.spawnQuickTunnel)({ hostHeader: targetSub.hostname, upstreamUrl });
+        // Wire stderr through so users see cloudflared progress / errors.
+        (_a = tunnel.child.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+            process.stderr.write(String(chunk));
+        });
+        let publicUrl;
+        try {
+            publicUrl = yield tunnel.publicUrl;
+        }
+        catch (err) {
+            error(`Tunnel failed to start: ${err.message}`);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev tunnel: failed';
+        }
+        info('');
+        success(`Public URL: ${colors.cyan(publicUrl)}`);
+        info('');
+        info(colors.bold('Heads up:'));
+        info('  • Auth cookies set on the localhost domain are NOT valid on the tunnel URL.');
+        info(`  • Better-Auth's trustedOrigins must include ${colors.cyan(publicUrl)} for login to succeed.`);
+        if (!apiMode) {
+            info(`  • This tunnel exposes ONLY the App. The API stays on \`${((_b = identity.subdomains.api) === null || _b === void 0 ? void 0 : _b.hostname) || '—'}\`.`);
+            info('    For full external usage, start a second `lt dev tunnel --api` in another shell.');
+        }
+        info('');
+        info(colors.dim('Stop with Ctrl-C.'));
+        // Keep the foreground alive until the child exits (Ctrl-C → SIGINT
+        // is forwarded to the child by the terminal, child exits, we exit).
+        const exitCode = yield new Promise((resolve) => {
+            tunnel.child.on('close', resolve);
+            const forward = (sig) => {
+                if (!tunnel.child.killed)
+                    tunnel.child.kill(sig);
+            };
+            process.on('SIGINT', forward);
+            process.on('SIGTERM', forward);
+        });
+        info('');
+        info(colors.dim(`cloudflared exited (code ${exitCode !== null && exitCode !== void 0 ? exitCode : 'unknown'}).`));
+        if (!parameters.options.fromGluegunMenu)
+            process.exit(exitCode !== null && exitCode !== void 0 ? exitCode : 0);
+        return `dev tunnel: exit=${exitCode}`;
+    }),
+};
+module.exports = TunnelCommand;

package/build/commands/dev/uninstall.js

@@ -0,0 +1,92 @@
+"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_service_1 = require("../../lib/dev-service");
+/**
+ * Symmetric counterpart to `lt dev install`.
+ *
+ * Removes the LaunchAgent / systemd-user unit, stops the running Caddy
+ * daemon, and optionally purges all lt-dev state (Caddyfile, logs).
+ *
+ * What it does NOT touch:
+ *   - the caddy binary itself (`brew uninstall caddy` remains the
+ *     user's choice — we don't presume they want to drop the tool)
+ *   - per-project state under `<project>/.lt-dev/` (use `lt dev down`)
+ *   - the trusted CA in the system keychain (use
+ *     `sudo -E HOME="$HOME" caddy untrust` if desired)
+ *
+ * Flags:
+ *   --purge      — also remove ~/.lenneTech/Caddyfile and caddy logs
+ *   --noConfirm  — skip the purge confirmation prompt
+ */
+const UninstallCommand = {
+    alias: ['un'],
+    description: 'Remove lt dev Caddy service',
+    hidden: false,
+    name: 'uninstall',
+    run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
+        const { parameters, print: { colors, error, info, success, warning }, prompt: { confirm }, } = toolbox;
+        info('');
+        info(colors.bold('lt dev uninstall — remove the lt-dev Caddy service'));
+        info(colors.dim('─'.repeat(60)));
+        const plat = (0, dev_service_1.platformSupported)();
+        if (plat === 'unsupported') {
+            info('No managed service to remove on this platform.');
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(0);
+            return 'dev uninstall: nothing to do';
+        }
+        const paths = (0, dev_service_1.getServicePaths)();
+        const result = yield (0, dev_service_1.uninstallService)();
+        if (!result.ok) {
+            error(result.message);
+            if (!parameters.options.fromGluegunMenu)
+                process.exit(1);
+            return 'dev uninstall: failed';
+        }
+        if (result.removed.length === 0) {
+            info(colors.dim('Service was not installed.'));
+        }
+        else {
+            success(`Removed: ${result.removed.join(', ')}`);
+        }
+        // Optional purge of related state files.
+        const purge = Boolean(parameters.options.purge) ||
+            (!parameters.options.noConfirm && (yield confirm('Also remove the Caddyfile and lt-dev caddy logs?', false)));
+        if (purge) {
+            const toRemove = [caddy_1.paths.caddyfile, paths.logFile, paths.errFile, (0, path_1.join)(paths.logFile, '..', 'ports.json')];
+            for (const file of toRemove) {
+                if ((0, fs_1.existsSync)(file)) {
+                    try {
+                        (0, fs_1.unlinkSync)(file);
+                        success(`Removed ${file}`);
+                    }
+                    catch (e) {
+                        warning(`Failed to remove ${file}: ${e.message}`);
+                    }
+                }
+            }
+        }
+        else {
+            info(colors.dim(`Kept: ${caddy_1.paths.caddyfile}`));
+            info(colors.dim(`Kept: ${paths.logFile}`));
+        }
+        info('');
+        info(`To reinstall: ${colors.cyan('lt dev install')}. To also remove caddy itself: ${colors.cyan('brew uninstall caddy')}.`);
+        if (!parameters.options.fromGluegunMenu)
+            process.exit(0);
+        return 'dev uninstall: ok';
+    }),
+};
+module.exports = UninstallCommand;

package/build/commands/dev/up.js

@@ -63,7 +63,7 @@ const UpCommand = {
             return 'dev up: caddy missing';
         }
         if (!(yield (0, caddy_1.caddyDaemonRunning)())) {
-            error('caddy daemon is not running. Start it: `brew services start caddy`.');
+            error('caddy daemon is not running. Run `lt dev install` to start the lt-dev service.');
             if (!parameters.options.fromGluegunMenu)
                 process.exit(1);
             return 'dev up: caddy daemon down';

package/build/lib/caddy.js

@@ -94,7 +94,21 @@ function removeProjectBlock(slug) {
     writeCaddyfile(next);
     return true;
 }
-/** Generate the Caddyfile block for one project's routes. */
+/**
+ * Generate the Caddyfile block for one project's routes.
+ *
+ * Upstream uses `127.0.0.1:<port>` explicitly — paired with
+ * `HOST=127.0.0.1` injected into the dev-server processes (see
+ * `dev-env.ts`). This guarantees a single, unambiguous loopback path:
+ *
+ *   - Vite/Nuxt/Nest, when given `HOST=127.0.0.1`, bind exclusively
+ *     to IPv4. There is no second IPv6 listener that could shadow
+ *     the port (which had been the source of the 502 / hanging
+ *     requests when two processes both registered on `[::1]:<port>`).
+ *   - `localhost` as Caddy upstream resolves to `::1` first on macOS,
+ *     so it would still pick the IPv6 family and miss the IPv4 bind.
+ *     Pinning to `127.0.0.1` removes that ambiguity entirely.
+ */
 function renderProjectBlock(slug, routes) {
     const lines = [`# >>> lt-dev:${slug} >>>`];
     for (const route of routes) {