@lenne.tech/cli 1.49.0 → 1.50.0

package/build/lib/dev-patches.js

@@ -125,7 +125,7 @@ function patchApiConfig(file) {
  * in place.
  */
 function patchClaudeMd(file, options) {
-    const { dbName, identity } = options;
+    const { apiPort, appPort, dbName, identity } = options;
     const startMarker = '<!-- lt-dev:url-block:start -->';
     const endMarker = '<!-- lt-dev:url-block:end -->';
     const apiSub = identity.subdomains.api;
@@ -150,10 +150,20 @@ function patchClaudeMd(file, options) {
         '**Active URLs for THIS project:**',
         '',
     ];
-    if (appSub)
-        lines.push(`- App: \`https://${appSub.hostname}\``);
-    if (apiSub)
-        lines.push(`- API: \`https://${apiSub.hostname}\``);
+    // Both addresses, with who each one is for. The block tells an agent never to
+    // assume `localhost:3000/3001` — so if it only named the `*.localhost` host, an
+    // agent following it would `curl` a name that does not resolve for Node on
+    // Windows, and fail silently. The browser address stays first: it is the one a
+    // human opens.
+    if (appSub) {
+        lines.push(`- App: \`https://${appSub.hostname}\`${appPort ? ` — from a script: \`http://127.0.0.1:${appPort}\`` : ''}`);
+    }
+    if (apiSub) {
+        lines.push(`- API: \`https://${apiSub.hostname}\`${apiPort ? ` — from a script: \`http://127.0.0.1:${apiPort}\`` : ''}`);
+    }
+    if (appPort || apiPort) {
+        lines.push('- The `*.localhost` names are resolved by BROWSERS. Node, `curl` and other tools may not resolve them (they do not on Windows) — use the loopback address from a script.');
+    }
     if (dbName)
         lines.push(`- DB: \`mongodb://127.0.0.1/${dbName}\``);
     lines.push('');

package/build/lib/dev-process.js

@@ -9,57 +9,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkPortInUse = checkPortInUse;
 exports.detachedSpawnCommand = detachedSpawnCommand;
+exports.httpStatus = httpStatus;
+exports.isPortBound = isPortBound;
 exports.killProcessGroup = killProcessGroup;
-exports.listenSnapshot = listenSnapshot;
+exports.planTermination = planTermination;
+exports.probePorts = probePorts;
 exports.rotateLogFile = rotateLogFile;
 exports.runChildInherit = runChildInherit;
 exports.runChildToFile = runChildToFile;
 exports.spawnDetached = spawnDetached;
 exports.terminateProcessGroup = terminateProcessGroup;
 exports.waitForHttp = waitForHttp;
+exports.windowsTrampoline = windowsTrampoline;
 /**
  * Process + port helpers for `lt dev`.
  *
  * - `spawnDetached`: detached child whose stdout/stderr go to a log file.
  *   The Claude Code session does NOT block waiting for it, and `lt dev down`
- *   can SIGTERM the entire process group via `process.kill(-pid, …)`.
- * - `listenSnapshot` / `checkPortInUse`: thin lsof wrappers used by
- *   `lt dev doctor` to detect port collisions.
+ *   can SIGTERM the entire process group (`killProcessGroup`, gated by
+ *   `planTermination`).
+ * - `probePorts`: which of a set of ports has a listener (a TCP connect, so it
+ *   answers on every platform) and — where the platform can say — who holds it.
  */
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const http_1 = require("http");
+const https_1 = require("https");
+const net_1 = require("net");
 const path_1 = require("path");
 const dev_state_1 = require("./dev-state");
-/**
- * Check via `lsof` whether a single TCP port is bound by a LISTEN socket.
- * Returns null if lsof is unavailable.
- */
-function checkPortInUse(port) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Promise((resolve) => {
-            var _a;
-            const child = (0, child_process_1.spawn)('lsof', ['-iTCP', `-sTCP:LISTEN`, '-nP', `-iTCP:${port}`], {
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let errored = false;
-            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (stdout += String(b)));
-            child.on('error', () => (errored = true));
-            child.on('close', () => {
-                if (errored)
-                    return resolve(null);
-                const lines = stdout.split('\n').filter((l) => l && !l.startsWith('COMMAND'));
-                const matching = lines.find((l) => new RegExp(`[: ]${port}\\s.*\\(LISTEN\\)`).test(l) || l.includes(`:${port} (LISTEN)`));
-                if (!matching)
-                    return resolve({ inUse: false });
-                const parts = matching.trim().split(/\s+/);
-                resolve({ command: parts[0], inUse: true, pid: Number(parts[1]) });
-            });
-        });
-    });
-}
+const platform_1 = require("./platform");
 /**
  * How a detached child is actually launched on this platform.
  *
@@ -77,9 +57,23 @@ function checkPortInUse(port) {
  *   - the cascade tries a high limit first, falling back on machines with a
  *     lower `kern.maxfilesperproc`; `2>/dev/null` keeps it best-effort.
  *
- * Windows gets the command directly. There is no `/bin/sh` to run the wrapper —
- * spawning it fails outright — and no RLIMIT_NOFILE for `ulimit` to raise, so
- * the wrapper has nothing to offer there even in principle.
+ * Windows has no `/bin/sh` and no RLIMIT_NOFILE, but it needs a wrapper for a
+ * different reason: **without one the log stays empty.** `detached` starts the
+ * child without a console. When that child is `cmd.exe` (cross-spawn runs every
+ * `.cmd` shim, `pnpm.cmd` included, through it), the console program below it
+ * gets a NEW console, and Windows then replaces the standard handles that
+ * `cmd.exe` merely inherited, our log file among them. The output lands in an
+ * extra console window instead, and `.lt-dev/*.log` stays at 0 bytes while the
+ * app runs. Measured on windows-latest (fake `pnpm.cmd` → node → node grandchild):
+ * 0 bytes this way, and 0 bytes even when `cmd.exe` redirects with `>>` itself.
+ * On the laptop an API died on start and its error sat unseen in that window.
+ *
+ * The fix is a small Node process in between (`windowsTrampoline`). libuv hands
+ * it the file explicitly, and it starts the real command with `stdio: 'inherit'`,
+ * which passes the handles explicitly again, so `cmd.exe` gets a console of its
+ * own and its children inherit both. Measured the same way: 94 child + 46
+ * grandchild lines in the file. The recorded pid is the trampoline's, so
+ * `taskkill /T` from it reaches the whole tree.
  *
  * Note for the POSIX path: because `spawn('/bin/sh', …)` almost always succeeds,
  * a bogus `cmd` does not surface as `pid === undefined` — the inner `exec` fails
@@ -88,70 +82,145 @@ function checkPortInUse(port) {
  * deliberately don't watch for that here: a detached, unref'd child's 127 exit is
  * racy to observe, and callers must be self-correcting against real crashes anyway.
  */
-function detachedSpawnCommand(cmd, args, platform = process.platform) {
+function detachedSpawnCommand(cmd, args, platform = process.platform, nodePath = process.execPath) {
     if (platform === 'win32')
-        return { args, command: cmd };
+        return { args: ['-e', windowsTrampoline(), '--', cmd, ...args], command: nodePath };
     const raiseFdLimit = 'ulimit -n 65536 2>/dev/null || ulimit -n 10240 2>/dev/null || true';
     return { args: ['-c', `${raiseFdLimit}; exec "$0" "$@"`, cmd, ...args], command: '/bin/sh' };
 }
-/** Send SIGTERM to a detached process group; falls back to single-PID kill. */
-function killProcessGroup(pid) {
-    if (!(0, dev_state_1.isValidPid)(pid))
-        return false;
-    try {
-        process.kill(-pid, 'SIGTERM');
-        return true;
-    }
-    catch (_a) {
+/**
+ * HTTP status of `url`, or null when the request could not be made at all.
+ *
+ * Node's own client rather than `curl`. That removes three separate hazards at
+ * once, all of which were live:
+ *
+ * - **`curl -o /dev/null` fails on Windows.** `/dev/null` is a file path there,
+ *   not the null device (`NUL` is), so curl exits **23 — "client returned ERROR
+ *   on write"** *after* a perfectly successful request. Any caller reading the
+ *   exit code concluded the service was down. That is exactly what made
+ *   `lt dev up` refuse with "caddy daemon is not running" against a Caddy that
+ *   was running and answering 200.
+ * - **`curl` is an external dependency** we do not need.
+ * - a spawn per probe, where a socket does.
+ *
+ * TLS verification is off for https URLs, matching the `-k` this replaces: the
+ * targets are local Caddy vhosts with a private CA.
+ */
+function httpStatus(url, timeoutMs = 2000) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+        };
         try {
-            process.kill(pid, 'SIGTERM');
-            return true;
+            const parsed = new URL(url);
+            const client = parsed.protocol === 'https:' ? https_1.request : http_1.request;
+            const request = client(url, { rejectUnauthorized: false, timeout: timeoutMs }, (response) => {
+                var _a;
+                // The body is irrelevant; draining it lets the socket close promptly.
+                response.resume();
+                done((_a = response.statusCode) !== null && _a !== void 0 ? _a : null);
+            });
+            request.on('timeout', () => {
+                request.destroy();
+                done(null);
+            });
+            request.on('error', () => done(null));
+            request.end();
         }
-        catch (_b) {
-            return false;
+        catch (_a) {
+            done(null);
         }
-    }
+    });
 }
 /**
- * Multi-port lsof snapshot — single subprocess for N ports.
- * Returns map<port, {command, pid}> for ports that are in use.
+ * True when something accepts a TCP connection on `127.0.0.1:port`.
+ *
+ * 127.0.0.1 rather than `localhost`: the components bind it explicitly
+ * (`dev-env.ts` sets `HOST`/`NITRO_HOST`) and Caddy proxies to it, while
+ * `localhost` can resolve to `::1` first and miss an IPv4-only listener — the
+ * trap `caddy.ts` already documents for the reverse proxy.
  */
-function listenSnapshot(ports) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = new Map();
-        if (ports.length === 0)
-            return result;
-        return new Promise((resolve) => {
-            var _a;
-            const portArgs = ports.flatMap((p) => ['-iTCP', `-iTCP:${p}`]);
-            const child = (0, child_process_1.spawn)('lsof', ['-sTCP:LISTEN', '-nP', ...portArgs], { stdio: ['ignore', 'pipe', 'pipe'] });
-            let stdout = '';
-            let errored = false;
-            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (stdout += String(b)));
-            child.on('error', () => (errored = true));
-            child.on('close', () => {
-                if (errored)
-                    return resolve(result);
-                for (const line of stdout.split('\n')) {
-                    if (!line || line.startsWith('COMMAND'))
-                        continue;
-                    const parts = line.trim().split(/\s+/);
-                    if (parts.length < 9)
-                        continue;
-                    const command = parts[0];
-                    const pid = Number(parts[1]);
-                    const name = parts[8];
-                    const portMatch = name.match(/:(\d+)$/);
-                    if (!portMatch)
-                        continue;
-                    const port = Number(portMatch[1]);
-                    if (ports.includes(port) && /\(LISTEN\)/.test(line)) {
-                        result.set(port, { command, pid });
-                    }
-                }
-                resolve(result);
-            });
-        });
+function isPortBound(port, timeoutMs = 700) {
+    return new Promise((resolve) => {
+        const socket = new net_1.Socket();
+        let settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(value);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once('connect', () => done(true));
+        socket.once('timeout', () => done(false));
+        socket.once('error', () => done(false));
+        socket.connect(port, '127.0.0.1');
+    });
+}
+/**
+ * End a detached process tree: SIGTERM to its group on POSIX (single-PID
+ * fallback), `taskkill /T /F` on Windows — forceful there, see `killWindowsTree`.
+ *
+ * Returns false without signalling anything when `planTermination` refuses the pid.
+ */
+function killProcessGroup(pid, options = {}) {
+    const plan = planTermination(pid, options.platform);
+    if (plan.kind === 'refuse')
+        return false;
+    if (plan.kind === 'taskkill')
+        return killWindowsTree(plan.target, options);
+    return signalGroup(plan.target, 'SIGTERM', options);
+}
+/**
+ * Decide whether `pid` may be signalled, and how. Pure — the only gate between
+ * a number read from disk (`state.json`) or from `lsof` and a real signal.
+ *
+ * Refused, and why each one matters:
+ * - **Not a plausible pid** (`isValidPid`): 0, negative, fractional, NaN.
+ * - **pid 1** on POSIX: `-1` is not a process group, it is the kill(2)
+ *   BROADCAST — every process this user may signal. On 2026-09-23 a test called
+ *   `killProcessGroup(1)`; the SIGTERM took down every terminal and session and
+ *   the Mac rebooted two minutes later. A corrupted `state.json` holding `1`
+ *   would do the same through `lt dev down`. And pid 1 itself is launchd/init.
+ * - **pid ≤ 4** on Windows: 0 is the idle process, 4 is `System`.
+ * - **This process and its parent**: a group signal to either reaches the CLI
+ *   itself and whatever launched it.
+ */
+function planTermination(pid, platform = process.platform, self = { pid: process.pid, ppid: process.ppid }) {
+    if (!(0, dev_state_1.isValidPid)(pid))
+        return { kind: 'refuse', reason: `not a valid pid: ${String(pid)}` };
+    const windows = (0, platform_1.isWindows)(platform);
+    if (pid <= (windows ? 4 : 1))
+        return { kind: 'refuse', reason: `pid ${pid} is a system process` };
+    if (pid === self.pid || pid === self.ppid)
+        return { kind: 'refuse', reason: `pid ${pid} is this CLI or its parent` };
+    const target = pid;
+    return windows ? { kind: 'taskkill', target } : { kind: 'group', target };
+}
+/**
+ * Probe `ports` for listeners and, where the platform can tell, their owners.
+ *
+ * The connects run in parallel — one round trip to loopback, not N.
+ */
+function probePorts(ports_1) {
+    return __awaiter(this, arguments, void 0, function* (ports, options = {}) {
+        const unique = [...new Set(ports)];
+        if (unique.length === 0) {
+            return { bound: new Set(), owners: new Map(), ownersUnavailable: false };
+        }
+        const results = yield Promise.all(unique.map((port) => __awaiter(this, void 0, void 0, function* () { return [port, yield isPortBound(port)]; })));
+        const bound = new Set(results.filter(([, up]) => up).map(([port]) => port));
+        if (bound.size === 0) {
+            // Nothing to attribute; skip the subprocess entirely.
+            return { bound, owners: new Map(), ownersUnavailable: false };
+        }
+        const owners = yield portOwners([...bound], options);
+        return { bound, owners: owners !== null && owners !== void 0 ? owners : new Map(), ownersUnavailable: owners === null };
     });
 }
 /**
@@ -194,7 +263,7 @@ function rotateLogFile(logFile) {
  */
 function runChildInherit(cmd, args, opts) {
     return new Promise((resolve) => {
-        const child = (0, child_process_1.spawn)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: 'inherit' });
+        const child = (0, platform_1.spawnCmd)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: 'inherit' });
         child.on('error', () => resolve(1));
         child.on('close', (code) => resolve(code));
     });
@@ -222,7 +291,7 @@ function runChildToFile(cmd, args, opts) {
     return new Promise((resolve) => {
         let child;
         try {
-            child = (0, child_process_1.spawn)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: ['ignore', out, out] });
+            child = (0, platform_1.spawnCmd)(cmd, args, { cwd: opts.cwd, env: opts.env, stdio: ['ignore', out, out] });
         }
         catch (_a) {
             close();
@@ -261,11 +330,13 @@ function spawnDetached(cmd, args, opts) {
     let child;
     try {
         const spawned = detachedSpawnCommand(cmd, args);
-        child = (0, child_process_1.spawn)(spawned.command, spawned.args, {
+        child = (0, platform_1.spawnCmd)(spawned.command, spawned.args, {
             cwd: opts.cwd,
             detached: true,
             env: opts.env,
             stdio: ['ignore', out, out],
+            // Windows only: keep the trampoline's console out of sight. No effect on POSIX.
+            windowsHide: true,
         });
         // spawn reports "could not start this at all" (missing executable, bad cwd)
         // through an ASYNCHRONOUS 'error' event — the try/catch around spawn() never
@@ -309,36 +380,37 @@ function spawnDetached(cmd, args, opts) {
  * is gone by the end, false if it somehow survived even SIGKILL.
  */
 function terminateProcessGroup(pid_1) {
-    return __awaiter(this, arguments, void 0, function* (pid, graceMs = 4000) {
-        if (!(0, dev_state_1.isValidPid)(pid))
+    return __awaiter(this, arguments, void 0, function* (pid, graceMs = 4000, options = {}) {
+        var _a;
+        const plan = planTermination(pid, options.platform);
+        if (plan.kind === 'refuse')
             return false;
-        if (!(0, dev_state_1.isPidAlive)(pid))
+        const isAlive = (_a = options.isAlive) !== null && _a !== void 0 ? _a : dev_state_1.isPidAlive;
+        if (!isAlive(plan.target))
             return true;
         // Phase 1 — graceful: SIGTERM the group (single-PID fallback inside).
-        killProcessGroup(pid);
+        // On Windows there is no such thing: `killProcessGroup` is already `/T /F`
+        // there, so the two phases collapse into one. The polling stays, because the
+        // RETURN VALUE still has to be honest about whether the pid actually went.
+        killProcessGroup(plan.target, options);
         const deadline = Date.now() + Math.max(0, graceMs);
         while (Date.now() < deadline) {
-            if (!(0, dev_state_1.isPidAlive)(pid))
+            if (!isAlive(plan.target))
                 return true;
             yield delay(150);
         }
         // Phase 2 — forced: SIGKILL the group, then the single PID.
-        if (!(0, dev_state_1.isPidAlive)(pid))
+        if (!isAlive(plan.target))
             return true;
-        try {
-            process.kill(-pid, 'SIGKILL');
-        }
-        catch (_a) {
-            /* group already gone or pid is not a group leader */
-        }
-        try {
-            process.kill(pid, 'SIGKILL');
+        if (plan.kind === 'taskkill') {
+            // Nothing harder exists; a second `/T /F` is the only escalation there is.
+            killWindowsTree(plan.target, options);
         }
-        catch (_b) {
-            /* already dead */
+        else {
+            signalGroup(plan.target, 'SIGKILL', options);
         }
         yield delay(150);
-        return !(0, dev_state_1.isPidAlive)(pid);
+        return !isAlive(plan.target);
     });
 }
 /**
@@ -369,32 +441,195 @@ abort = () => false) {
     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)));
-            const retry = () => {
+            httpStatus(url, 2000).then((status) => {
+                if (status !== null && ready(status)) {
+                    return resolve(true);
+                }
                 // Order matters: a LAST probe already ran above, so a server that came up
                 // just before dying is still reported ready. Only then does `abort` end it.
-                if (Date.now() - start > timeoutMs || abort())
+                if (abort()) {
                     return resolve(false);
-                setTimeout(tick, 500);
-            };
-            child.on('close', () => {
-                const code = Number(status.trim());
-                // `000` (curl could not connect) parses to 0 → never "ready".
-                if (Number.isFinite(code) && code > 0 && ready(code))
-                    return resolve(true);
-                retry();
+                }
+                if (Date.now() - start >= timeoutMs) {
+                    return resolve(false);
+                }
+                setTimeout(tick, 250);
             });
-            child.on('error', retry);
         };
         tick();
     });
 }
+/**
+ * Source of the Windows trampoline (see `detachedSpawnCommand`), run as `node -e`.
+ * cross-spawn is required by absolute path because `-e` resolves modules from the
+ * child's cwd, i.e. the user's project, not from the CLI. It exits with the
+ * command's code, so a dead command still reads as a dead pid.
+ */
+function windowsTrampoline() {
+    const crossSpawnPath = JSON.stringify(require.resolve('cross-spawn'));
+    return [
+        `const spawn = require(${crossSpawnPath});`,
+        'const [cmd, ...args] = process.argv.slice(1);',
+        "const child = spawn(cmd, args, { stdio: 'inherit', windowsHide: true });",
+        "child.on('error', (e) => { process.stderr.write('lt dev: could not start ' + cmd + ': ' + e.message + '\\n'); process.exit(127); });",
+        "child.on('exit', (code) => process.exit(code === null ? 1 : code));",
+    ].join(' '); // one line: a newline inside a Windows command-line argument is asking for trouble
+}
+/** stdout of a command, or null when it could not run. */
+function captureStdout(command, args) {
+    return new Promise((resolve) => {
+        var _a;
+        const child = (0, child_process_1.spawn)(command, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        let stdout = '';
+        let errored = false;
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (stdout += String(b)));
+        child.on('error', () => (errored = true));
+        child.on('close', () => resolve(errored ? null : stdout));
+    });
+}
 /** Promise-based delay used by the graceful→forced termination escalation. */
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/**
+ * Windows has no process groups in this sense, and **no gentle step.**
+ *
+ * `taskkill /PID <pid> /T` without `/F` was measured on a Windows laptop (a node
+ * parent with two children holding port 3999): it fails on the children ("must be
+ * forcefully terminated") and leaves the port bound — i.e. it looks like a refusal,
+ * not like a graceful stop. Only `/T /F` actually ends the tree and frees the
+ * port. So on Windows this function is forceful where its POSIX twin is polite,
+ * and two consequences follow that a caller has to know:
+ *
+ * - **Shutdown hooks do not run.** No SIGTERM handler, no `onApplicationShutdown`,
+ *   no ordered close of a Mongo connection. In practice the components write
+ *   nothing on exit that the next start does not rebuild, but "in practice" is not
+ *   "never": a project that holds something open at shutdown gets no chance there.
+ * - **`/T` walks the child TREE from a snapshot, not a process group.** A
+ *   grandchild that has been re-parented (its parent exited first) is no longer in
+ *   that tree and survives. The negative-PID kill on POSIX has no such hole,
+ *   because group membership is inherited and does not change when a parent dies.
+ *
+ * The pid is the one `spawnDetached` recorded. On Windows that is cross-spawn's
+ * `cmd.exe`, and the package manager plus everything it started hang below it — so
+ * the tree walk should reach them. That part is NOT yet measured on a real
+ * `lt dev` stack — only on the synthetic tree above.
+ */
+function killWindowsTree(target, options) {
+    var _a, _b;
+    const run = (_a = options.run) !== null && _a !== void 0 ? _a : ((command, args) => (0, platform_1.spawnCmdSync)(command, args, { stdio: 'ignore' }));
+    const isAlive = (_b = options.isAlive) !== null && _b !== void 0 ? _b : dev_state_1.isPidAlive;
+    const result = run('taskkill', ['/PID', String(target), '/T', '/F']);
+    // taskkill exits non-zero when the pid is already gone, which is success for us.
+    return result.status === 0 || !isAlive(target);
+}
+/** `lsof` path. Parses the positional column layout. */
+function lsofPortOwners(ports, capture) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const portArgs = ports.flatMap((p) => ['-iTCP', `-iTCP:${p}`]);
+        const stdout = yield capture('lsof', ['-sTCP:LISTEN', '-nP', ...portArgs]);
+        if (stdout === null)
+            return null;
+        const result = new Map();
+        for (const line of stdout.split('\n')) {
+            if (!line || line.startsWith('COMMAND'))
+                continue;
+            const parts = line.trim().split(/\s+/);
+            if (parts.length < 9)
+                continue;
+            const portMatch = parts[8].match(/:(\d+)$/);
+            if (!portMatch)
+                continue;
+            const port = Number(portMatch[1]);
+            if (ports.includes(port) && /\(LISTEN\)/.test(line)) {
+                result.set(port, { command: parts[0], pid: Number(parts[1]) });
+            }
+        }
+        return result;
+    });
+}
+/**
+ * Owning process per port, or null when the lookup could not run.
+ *
+ * POSIX asks `lsof`. Windows asks `netstat -ano` for the pid and `tasklist` for
+ * the name — both ship with the OS and neither needs PowerShell, so this works
+ * in cmd.exe too.
+ */
+function portOwners(ports, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const capture = (_a = options.capture) !== null && _a !== void 0 ? _a : captureStdout;
+        return (0, platform_1.isWindows)(options.platform) ? windowsPortOwners(ports, capture) : lsofPortOwners(ports, capture);
+    });
+}
+/**
+ * The one place in `src/` that signals a negative pid. It accepts only a
+ * `SignalTarget`, i.e. a pid `planTermination` has cleared — never a raw number.
+ * Returns true when either the group or the single pid took the signal.
+ */
+function signalGroup(target, signal, options) {
+    var _a;
+    const send = (_a = options.signal) !== null && _a !== void 0 ? _a : ((pid, sig) => process.kill(pid, sig));
+    try {
+        send(-target, signal);
+        return true;
+    }
+    catch (_b) {
+        // Not a group leader, or the group is gone: fall back to the pid itself.
+        try {
+            send(target, signal);
+            return true;
+        }
+        catch (_c) {
+            return false;
+        }
+    }
+}
+/** `netstat -ano` + `tasklist` path. */
+function windowsPortOwners(ports, capture) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const netstat = yield capture('netstat', ['-ano']);
+        if (netstat === null)
+            return null;
+        const pidByPort = new Map();
+        for (const line of netstat.split('\n')) {
+            // `  TCP    127.0.0.1:4000   0.0.0.0:0   LISTENING   1234`
+            const parts = line.trim().split(/\s+/);
+            if (parts.length < 5 || !/^TCP$/i.test(parts[0]) || !/^LISTENING$/i.test(parts[3]))
+                continue;
+            const portMatch = parts[1].match(/:(\d+)$/);
+            const pid = Number(parts[4]);
+            if (!portMatch || !Number.isInteger(pid))
+                continue;
+            const port = Number(portMatch[1]);
+            if (ports.includes(port) && !pidByPort.has(port))
+                pidByPort.set(port, pid);
+        }
+        const names = yield windowsProcessNames([...new Set(pidByPort.values())], capture);
+        const result = new Map();
+        for (const [port, pid] of pidByPort) {
+            result.set(port, { command: (_a = names.get(pid)) !== null && _a !== void 0 ? _a : String(pid), pid });
+        }
+        return result;
+    });
+}
+/** Image name per pid via `tasklist`, best effort — an unnamed pid is still a pid. */
+function windowsProcessNames(pids, capture) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const names = new Map();
+        if (pids.length === 0)
+            return names;
+        // `/FO CSV /NH` keeps the output parseable without a header line.
+        const filters = pids.flatMap((pid) => ['/FI', `PID eq ${pid}`]);
+        const out = yield capture('tasklist', [...filters, '/FO', 'CSV', '/NH']);
+        if (out === null)
+            return names;
+        for (const line of out.split('\n')) {
+            const match = line.match(/^"([^"]+)","(\d+)"/);
+            if (match)
+                names.set(Number(match[2]), match[1]);
+        }
+        return names;
+    });
+}

package/build/lib/dev-project.js

@@ -94,7 +94,20 @@ function deriveTicketDbName(devDbName, ticketId) {
  * and build allowlists there), and an npm workspace may use `packages/*`
  * rather than the lt `projects/*` convention.
  */
-function resolveLayout(cwd, filesystem) {
+function resolveLayout(cwdOrRelative, filesystem) {
+    // Absolutised HERE rather than at the call sites, so no caller can inherit the
+    // trap. `lt fullstack init` passes `kebabCase(name)` — a bare relative segment
+    // — and the resulting `root` was written verbatim into `~/.lenneTech/projects.json`
+    // as the project's `path`. Everything that later asks "does this checkout still
+    // exist?" then resolved it against whatever directory the process happened to
+    // start in: `planRegistryPrune` declared a live project orphaned and reclaimed
+    // its slug and reserved ports, and `detectSlugConflict` produced the nonsense
+    // "slug 't-5' is also registered to another checkout: t-5".
+    //
+    // Not Windows-specific. It surfaced there because those projects were created
+    // by `lt fullstack init`; on macOS the entries happen to come from `lt dev up`
+    // run inside the project, where the cwd is already absolute.
+    const cwd = (0, path_1.resolve)(cwdOrRelative);
     const subContext = (0, workspace_integration_1.detectSubProjectContext)(cwd, filesystem);
     if (subContext)
         return monorepoLayout(subContext.workspaceRoot);