@lenne.tech/cli 1.21.0 → 1.23.0

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. Run `lt dev install` to start the lt-dev service.');
+            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.'));
                     }
                 }
             }

package/build/lib/caddy.js

@@ -0,0 +1,183 @@
+"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.paths = void 0;
+exports.caddyAvailable = caddyAvailable;
+exports.caddyDaemonRunning = caddyDaemonRunning;
+exports.readCaddyfile = readCaddyfile;
+exports.reloadCaddy = reloadCaddy;
+exports.removeProjectBlock = removeProjectBlock;
+exports.renderProjectBlock = renderProjectBlock;
+exports.upsertProjectBlock = upsertProjectBlock;
+exports.validateCaddyfile = validateCaddyfile;
+exports.writeCaddyfile = writeCaddyfile;
+/**
+ * Caddy integration for `lt dev`.
+ *
+ * Caddy is the HTTPS engine: it provides automatic local TLS for
+ * `*.localhost` (no /etc/hosts edits needed — RFC 6761), atomic
+ * config reload, and a long-stable Caddyfile format. Compared to
+ * portless / mkcert / nginx, Caddy gives all of this with a single
+ * binary and no sudo daemon.
+ *
+ * Layout:
+ * - Global Caddyfile at `~/.lenneTech/Caddyfile` — one block per
+ *   project, marked with `# >>> lt-dev:<slug> >>>` / `# <<<`.
+ * - Atomic reload via `caddy reload --config ~/.lenneTech/Caddyfile`.
+ *
+ * Lifecycle is owned by `lt dev install` (one-time setup) and
+ * `lt dev up`/`lt dev down` (per-project block management).
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const CADDYFILE_PATH = process.env.LT_DEV_CADDYFILE || (0, path_1.join)((0, os_1.homedir)(), '.lenneTech', 'Caddyfile');
+const HEADER = '# Managed by `lt dev`. Per-project blocks are bounded by `# >>> lt-dev:<slug> >>>` markers.';
+/** Detect whether `caddy` is on PATH. */
+function caddyAvailable() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield runCaddy(['version']);
+        return result.ok;
+    });
+}
+/** Detect whether the Caddy admin endpoint is reachable (i.e. a daemon is running). */
+function caddyDaemonRunning() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            const child = (0, child_process_1.spawn)('curl', ['-fsS', '-o', '/dev/null', 'http://localhost:2019/config/'], {
+                stdio: ['ignore', 'ignore', 'ignore'],
+            });
+            child.on('error', () => resolve(false));
+            child.on('close', (code) => resolve(code === 0));
+        });
+    });
+}
+/** Read the current Caddyfile (or empty string). */
+function readCaddyfile() {
+    if (!(0, fs_1.existsSync)(CADDYFILE_PATH))
+        return '';
+    return (0, fs_1.readFileSync)(CADDYFILE_PATH, 'utf8');
+}
+/**
+ * Reload Caddy with the global Caddyfile. Caller is responsible for
+ * starting Caddy in the first place (typically via `lt dev install`).
+ */
+function reloadCaddy() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runCaddy(['reload', '--config', CADDYFILE_PATH, '--adapter', 'caddyfile']);
+    });
+}
+/**
+ * Remove a project block from the Caddyfile.
+ * Returns true if anything was removed.
+ */
+function removeProjectBlock(slug) {
+    const current = readCaddyfile();
+    const startMarker = `# >>> lt-dev:${slug} >>>`;
+    const endMarker = `# <<< lt-dev:${slug} <<<`;
+    const startIdx = current.indexOf(startMarker);
+    const endIdx = current.indexOf(endMarker);
+    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
+        return false;
+    const before = current.slice(0, startIdx).replace(/\n+$/, '');
+    const after = current.slice(endIdx + endMarker.length).replace(/^\n+/, '');
+    const next = [before, after].filter((s) => s.length > 0).join('\n\n');
+    writeCaddyfile(next);
+    return true;
+}
+/**
+ * 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) {
+        lines.push(`${route.hostname} {`);
+        lines.push(`  reverse_proxy 127.0.0.1:${route.upstreamPort}`);
+        lines.push('}');
+    }
+    lines.push(`# <<< lt-dev:${slug} <<<`);
+    return lines.join('\n');
+}
+/**
+ * Insert/replace a project block in the Caddyfile.
+ *
+ * Idempotent — re-applying with the same routes is a no-op.
+ * Returns true if the file was modified.
+ */
+function upsertProjectBlock(slug, routes) {
+    const current = readCaddyfile();
+    const block = renderProjectBlock(slug, routes);
+    const startMarker = `# >>> lt-dev:${slug} >>>`;
+    const endMarker = `# <<< lt-dev:${slug} <<<`;
+    const startIdx = current.indexOf(startMarker);
+    const endIdx = current.indexOf(endMarker);
+    let next;
+    if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+        const before = current.slice(0, startIdx).replace(/\n+$/, '');
+        const after = current.slice(endIdx + endMarker.length).replace(/^\n+/, '');
+        next = [before, block, after].filter((s) => s.length > 0).join('\n\n');
+    }
+    else {
+        next = current.length > 0 ? `${current.replace(/\n+$/, '')}\n\n${block}` : block;
+    }
+    if (next === current.replace(/\s+$/, ''))
+        return false;
+    writeCaddyfile(next);
+    return true;
+}
+/** Validate the current Caddyfile syntax. */
+function validateCaddyfile() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runCaddy(['validate', '--config', CADDYFILE_PATH, '--adapter', 'caddyfile']);
+    });
+}
+/** Write the Caddyfile, ensuring the parent directory exists. */
+function writeCaddyfile(content) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(CADDYFILE_PATH), { recursive: true });
+    const next = content.startsWith('#') ? content : `${HEADER}\n\n${content}`;
+    (0, fs_1.writeFileSync)(CADDYFILE_PATH, next.endsWith('\n') ? next : `${next}\n`, 'utf8');
+}
+/** Run a caddy subcommand and capture stdout/stderr. */
+function runCaddy(args) {
+    return new Promise((resolve) => {
+        var _a, _b;
+        const child = (0, child_process_1.spawn)('caddy', 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) => {
+            if (errored)
+                resolve({ exitCode: null, ok: false, stderr: 'caddy: command not found', stdout: '' });
+            else
+                resolve({ exitCode: code, ok: code === 0, stderr, stdout });
+        });
+    });
+}
+/** Path constants for tests + status displays. */
+exports.paths = {
+    caddyfile: CADDYFILE_PATH,
+};

package/build/lib/cloudflared.js

@@ -0,0 +1,129 @@
+"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.TRYCLOUDFLARE_URL_PATTERN = void 0;
+exports.buildQuickTunnelArgs = buildQuickTunnelArgs;
+exports.cloudflaredAvailable = cloudflaredAvailable;
+exports.extractTrycloudflareUrl = extractTrycloudflareUrl;
+exports.spawnQuickTunnel = spawnQuickTunnel;
+/**
+ * Cloudflare Tunnel integration for `lt dev tunnel`.
+ *
+ * Quick tunnels (no Cloudflare account, ephemeral URL) are the only
+ * mode supported here. Named tunnels would require multi-step Cloudflare
+ * setup (auth, DNS routing) which belongs in a separate command and is
+ * intentionally out of scope for this lib.
+ *
+ * The Caddy upstream stays unchanged: cloudflared connects to Caddy's
+ * HTTPS endpoint and rewrites the `Host` header to the configured
+ * `*.localhost` so Caddy's per-project block matches. Without that
+ * rewrite Cloudflare's edge would forward the random `*.trycloudflare.com`
+ * hostname which Caddy doesn't know.
+ */
+const child_process_1 = require("child_process");
+/**
+ * Match the trycloudflare URL anywhere in cloudflared's log output.
+ *
+ * cloudflared prints it in an ASCII-box on stderr (Linux/macOS) — exported
+ * here so tests can assert the exact pattern without spawning the binary.
+ */
+exports.TRYCLOUDFLARE_URL_PATTERN = /https:\/\/[a-z0-9][a-z0-9-]*\.trycloudflare\.com/i;
+/**
+ * Build the argv list for `cloudflared tunnel --url ...`. Pure helper.
+ *
+ * Why each flag:
+ *   --url             : the local upstream (Caddy's HTTPS endpoint)
+ *   --http-host-header: tells cloudflared to rewrite Host before forwarding,
+ *                       so Caddy's vhost match works for the public URL
+ *   --no-tls-verify   : Caddy serves a locally-signed cert that cloudflared
+ *                       cannot validate from outside the local trust store;
+ *                       disabling the check is safe because the upstream
+ *                       hop never leaves localhost
+ */
+function buildQuickTunnelArgs(opts) {
+    return [
+        'tunnel',
+        '--no-autoupdate',
+        '--no-tls-verify',
+        '--http-host-header',
+        opts.hostHeader,
+        '--url',
+        opts.upstreamUrl,
+    ];
+}
+/** Detect whether `cloudflared` is on PATH. */
+function cloudflaredAvailable() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            var _a;
+            const child = (0, child_process_1.spawn)('cloudflared', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
+            let stdout = '';
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (stdout += String(b)));
+            child.on('error', () => resolve({ installed: false }));
+            child.on('close', (code) => {
+                if (code !== 0)
+                    return resolve({ installed: false });
+                const match = stdout.match(/version\s+(\S+)/i);
+                resolve({ binary: 'cloudflared', installed: true, version: match === null || match === void 0 ? void 0 : match[1] });
+            });
+        });
+    });
+}
+/**
+ * Extract the trycloudflare URL from a chunk of cloudflared output.
+ * Returns the first match (cloudflared logs the URL exactly once).
+ */
+function extractTrycloudflareUrl(output) {
+    const match = output.match(exports.TRYCLOUDFLARE_URL_PATTERN);
+    return match ? match[0] : null;
+}
+/**
+ * Spawn a quick tunnel and resolve the public URL once cloudflared logs it.
+ *
+ * The returned `publicUrl` promise rejects if the child exits before
+ * surfacing a URL (timeout: ~30s, then cloudflared usually emits an
+ * error message and exits). The caller is expected to keep the
+ * process alive (foreground command) and `child.kill()` on Ctrl-C.
+ */
+function spawnQuickTunnel(opts) {
+    const args = buildQuickTunnelArgs(opts);
+    const child = (0, child_process_1.spawn)('cloudflared', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    const publicUrl = new Promise((resolve, reject) => {
+        var _a, _b;
+        let buffer = '';
+        let settled = false;
+        const onChunk = (chunk) => {
+            if (settled)
+                return;
+            buffer += String(chunk);
+            const url = extractTrycloudflareUrl(buffer);
+            if (url) {
+                settled = true;
+                resolve(url);
+            }
+        };
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', onChunk);
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', onChunk);
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error(`cloudflared exited (code ${code}) before publishing a tunnel URL.\n${buffer.slice(-500)}`));
+        });
+    });
+    return { child, publicUrl };
+}