@lenne.tech/cli 1.21.0 → 1.23.0

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

package/build/commands/dev/test.js

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

package/build/commands/dev/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;