@lenne.tech/cli 1.24.1 → 1.26.0

package/build/lib/dev-env.js

@@ -35,7 +35,12 @@ function buildDevEnv(input) {
     const apiUrl = apiSub ? `https://${apiSub.hostname}` : '';
     const appUrl = appSub ? `https://${appSub.hostname}` : '';
     const caPath = (0, dev_env_bridge_1.detectCaddyRootCa)();
-    const sharedKeys = Object.assign(Object.assign(Object.assign(Object.assign({}, (apiUrl ? { BASE_URL: apiUrl, NSC__BASE_URL: apiUrl } : {})), (appUrl ? { APP_URL: appUrl, NSC__APP_URL: appUrl } : {})), (dbName ? { DATABASE_URL: buildPostgresUrl(dbName), NSC__MONGOOSE__URI: `mongodb://127.0.0.1/${dbName}` } : {})), (caPath ? { NODE_EXTRA_CA_CERTS: caPath } : {}));
+    const sharedKeys = Object.assign(Object.assign(Object.assign(Object.assign({ 
+        // Marks the API + App processes as running under `lt dev`. Consumed by the
+        // backend to relax dev-only behaviour (rate limiting, Better-Auth
+        // user-cache) so E2E suites run without a separate VITEST/PLAYWRIGHT flag.
+        // (Also written to the .lt-dev/.env bridge for external test runners.)
+        LT_DEV_ACTIVE: 'true' }, (apiUrl ? { BASE_URL: apiUrl, NSC__BASE_URL: apiUrl } : {})), (appUrl ? { APP_URL: appUrl, NSC__APP_URL: appUrl } : {})), (dbName ? { DATABASE_URL: buildPostgresUrl(dbName), NSC__MONGOOSE__URI: `mongodb://127.0.0.1/${dbName}` } : {})), (caPath ? { NODE_EXTRA_CA_CERTS: caPath } : {}));
     return {
         api: {
             env: Object.assign(Object.assign(Object.assign({}, baseEnv), sharedKeys), { 

package/build/lib/dev-install-helper.js

@@ -0,0 +1,136 @@
+"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.runInstall = runInstall;
+const caddy_1 = require("./caddy");
+const dev_service_1 = require("./dev-service");
+/**
+ * Run the one-time per-machine `lt dev` setup. Idempotent — safe to
+ * re-run. When `opts.auto` is set the heading reflects that it was
+ * triggered by another command (e.g. `lt dev init`).
+ */
+function runInstall(toolbox_1) {
+    return __awaiter(this, arguments, void 0, function* (toolbox, opts = {}) {
+        const { print: { colors, error, info, success, warning }, } = toolbox;
+        info('');
+        info(colors.bold(opts.auto ? 'Preparing this machine for lt dev (lt dev install)' : 'lt dev install — one-time per-machine setup'));
+        info(colors.dim('─'.repeat(60)));
+        const plat = (0, dev_service_1.platformSupported)();
+        if (plat === 'unsupported') {
+            error(`Service management is not supported on ${process.platform}. Only macOS and Linux are covered.`);
+            info(`  Workaround: run \`${colors.cyan(`caddy run --config ${caddy_1.paths.caddyfile}`)}\` manually.`);
+            return { blocked: true, caddyMissing: false, ok: false, unsupported: true };
+        }
+        let blocked = false;
+        // 1. caddy on PATH
+        const hasCaddy = yield (0, caddy_1.caddyAvailable)();
+        if (hasCaddy) {
+            success('caddy is on PATH');
+        }
+        else {
+            warning('caddy is not installed.');
+            info(`  → macOS: ${colors.cyan('brew install caddy')}`);
+            info(`  → Linux: ${colors.cyan('https://caddyserver.com/docs/install')}`);
+            info('  (Do NOT start it via `brew services` — `lt dev install` runs its own service.)');
+            blocked = true;
+        }
+        // 2. Caddyfile stub
+        (0, caddy_1.writeCaddyfile)('# lt dev — managed Caddyfile\n# Add per-project blocks via `lt dev up`.\n');
+        success(`Caddyfile present at ${caddy_1.paths.caddyfile}`);
+        if (!hasCaddy) {
+            info('');
+            error('Cannot continue setup until Caddy is installed. Re-run `lt dev install` afterwards.');
+            return { blocked: true, caddyMissing: true, ok: false, unsupported: false };
+        }
+        // 3. brew services conflict warning
+        const brewConflict = yield detectBrewCaddyConflict();
+        if (brewConflict) {
+            warning('A `brew services caddy` instance is registered.');
+            info(`  Stop it (it crash-loops against our Caddyfile): ${colors.cyan('brew services stop caddy')}`);
+            info('  `lt dev install` runs its own service — the brew one is no longer needed.');
+        }
+        // 4. Install our LaunchAgent / systemd unit
+        const paths = (0, dev_service_1.getServicePaths)();
+        info('');
+        info(`Installing ${plat === 'darwin' ? 'LaunchAgent' : 'systemd-user unit'} at:`);
+        info(colors.dim(`  ${paths.unitFile}`));
+        const installResult = yield (0, dev_service_1.installService)();
+        if (!installResult.ok) {
+            error(installResult.message);
+            blocked = true;
+        }
+        else if (installResult.created) {
+            success(installResult.message);
+        }
+        else {
+            info(colors.dim(installResult.message));
+        }
+        // 5. Wait for admin endpoint
+        if (installResult.ok) {
+            info(colors.dim('Waiting for Caddy admin endpoint (:2019) ...'));
+            const ready = yield (0, dev_service_1.waitForServiceReady)(8000);
+            const status = yield (0, dev_service_1.getServiceStatus)();
+            if (ready && status.daemonReachable) {
+                success(`Caddy daemon ready${status.pid ? ` (pid ${status.pid})` : ''}.`);
+            }
+            else if (status.loaded && !status.daemonReachable) {
+                warning('Service is loaded but admin endpoint did not respond within 8s.');
+                info(colors.dim(`  Logs: ${paths.logFile} / ${paths.errFile}`));
+                blocked = true;
+            }
+            else {
+                warning('Caddy daemon did not start. See logs:');
+                info(colors.dim(`  ${paths.logFile}`));
+                info(colors.dim(`  ${paths.errFile}`));
+                blocked = true;
+            }
+        }
+        // 6. Validate Caddyfile
+        if (installResult.ok) {
+            const validation = yield (0, caddy_1.validateCaddyfile)();
+            if (validation.ok)
+                success('Caddyfile validates');
+            else
+                warning(`Caddyfile validation: ${validation.stderr.split('\n').slice(0, 2).join(' / ')}`);
+        }
+        // 7. CA trust
+        info('');
+        info(colors.bold('Local CA trust'));
+        info('  Caddy creates its local CA on first run. To trust it system-wide,');
+        info('  run this once (HOME must be preserved so sudo keeps the user-scoped');
+        info('  CA, otherwise caddy looks in /var/root and fails):');
+        info(`    ${colors.cyan('sudo -E HOME="$HOME" caddy trust')}`);
+        info(`  Browsers will then accept ${colors.cyan('https://*.localhost')} without warnings.`);
+        return { blocked, caddyMissing: false, ok: installResult.ok, unsupported: false };
+    });
+}
+/**
+ * Quick `brew services list` scan for a registered caddy service.
+ * Returns true on macOS if any entry contains "caddy" — error/started
+ * alike, both are conflicts. Always returns false on non-darwin or
+ * when `brew` is unavailable (no false positives).
+ */
+function detectBrewCaddyConflict() {
+    if (process.platform !== 'darwin')
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        var _a;
+        const { spawn } = require('child_process');
+        const child = spawn('brew', ['services', 'list'], { stdio: ['ignore', 'pipe', 'ignore'] });
+        let out = '';
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (b) => (out += String(b)));
+        child.on('error', () => resolve(false));
+        child.on('close', () => {
+            const conflict = /\bcaddy\b/.test(out) && !/^caddy\s+none\b/m.test(out);
+            resolve(conflict);
+        });
+    });
+}

package/build/lib/dev-migrate-helper.js

@@ -1,20 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.printMigrateResult = printMigrateResult;
 exports.runMigrate = runMigrate;
 /**
- * Reusable migrate logic — used by `commands/dev/migrate.ts` (interactive
- * + verbose) and `commands/fullstack/init.ts` (silent best-effort after
- * project creation).
+ * Reusable init/migrate logic — used by `commands/dev/init.ts` (interactive
+ * + verbose, also chained from `commands/dev/install.ts`) and
+ * `commands/fullstack/init.ts` (silent best-effort after project creation).
  *
  * Returns a structured result so callers can decide what to print.
  * Idempotent — safe to run multiple times.
  */
 const fs_1 = require("fs");
+const gluegun_1 = require("gluegun");
 const path_1 = require("path");
 const dev_identity_1 = require("./dev-identity");
 const dev_patches_1 = require("./dev-patches");
 const dev_project_1 = require("./dev-project");
 const dev_state_1 = require("./dev-state");
+const package_name_1 = require("./package-name");
+/**
+ * Print a `runMigrate` result via the toolbox. Shared by `lt dev init`
+ * and the auto-init step of `lt dev install` so both render identically.
+ * Does NOT print Caddy-install hints — chaining handles that separately.
+ */
+function printMigrateResult(toolbox, result) {
+    const { print: { colors, info, success }, } = toolbox;
+    info('');
+    info(colors.bold(`Initializing "${result.identity.slug}" for lt dev`));
+    info(colors.dim('─'.repeat(60)));
+    if (result.identity.subdomains.app)
+        info(`  App URL: https://${result.identity.subdomains.app.hostname}`);
+    if (result.identity.subdomains.api)
+        info(`  API URL: https://${result.identity.subdomains.api.hostname}`);
+    info(`  DB:      mongodb://127.0.0.1/${result.dbName}`);
+    info('');
+    if (result.renamedTemplatePackage) {
+        success(`renamed root package.json name → "${result.renamedTemplatePackage}" (was unmodified template default)`);
+    }
+    if (result.codePatches.length > 0) {
+        for (const r of result.codePatches) {
+            if (r.patched)
+                success(`patched ${r.replacements}× in ${r.file}`);
+            else
+                info(colors.dim(`already patched: ${r.file}`));
+        }
+    }
+    else {
+        info(colors.dim('  patches: not needed (already env-aware)'));
+    }
+    result.claudePatches.filter((r) => r.patched).forEach((r) => success(`updated CLAUDE.md URL block: ${r.file}`));
+    if (result.registryUpdated) {
+        success(`registered in ${process.env.LT_DEV_REGISTRY_PATH || '~/.lenneTech/projects.json'}`);
+    }
+    if (result.addedGitignoreEntry)
+        success('added `.lt-dev/` to .gitignore');
+    if (result.alreadyMigrated) {
+        info(colors.dim('  Project was already initialized — nothing changed.'));
+    }
+}
 /**
  * Run all migration steps for a resolved project.
  *
@@ -22,6 +65,17 @@ const dev_state_1 = require("./dev-state");
  */
 function runMigrate(input) {
     const { layout } = input;
+    // 0. If the root package.json still carries an unmodified starter-template
+    //    name (e.g. `lt-monorepo` from a raw `git clone`), rewrite it to the
+    //    directory basename before deriving identity. Otherwise every cloned
+    //    project would slug to `lt-monorepo` and collide on
+    //    `https://lt-monorepo.localhost`. `lt fullstack init` already handles
+    //    this — the call here is the safety net for projects that bypassed
+    //    init (e.g. manual `git clone lenneTech/lt-monorepo my-project`).
+    const renamedTemplatePackage = (0, package_name_1.renameUnmodifiedTemplatePackage)({
+        filesystem: gluegun_1.filesystem,
+        projectRoot: layout.root,
+    });
     const identity = (0, dev_identity_1.buildIdentity)(layout.root);
     const dbName = (0, dev_project_1.deriveDbName)(layout.apiDir, identity.slug);
     // 1. Code patches (config.env.ts, nuxt.config.ts, playwright.config.ts).
@@ -68,7 +122,7 @@ function runMigrate(input) {
     const addedGitignoreEntry = (0, dev_patches_1.addToGitignore)(layout.root, '.lt-dev/');
     const codePatched = codePatches.filter((r) => r.patched).length > 0;
     const claudePatched = claudePatches.filter((r) => r.patched).length > 0;
-    const alreadyMigrated = !codePatched && !claudePatched && !registryChanged && !addedGitignoreEntry;
+    const alreadyMigrated = !codePatched && !claudePatched && !registryChanged && !addedGitignoreEntry && !renamedTemplatePackage;
     return {
         addedGitignoreEntry,
         alreadyMigrated,
@@ -77,5 +131,6 @@ function runMigrate(input) {
         dbName,
         identity,
         registryUpdated: registryChanged,
+        renamedTemplatePackage,
     };
 }

package/build/lib/dev-patches.js

@@ -7,7 +7,7 @@ exports.patchClaudeMd = patchClaudeMd;
 exports.patchNuxtConfig = patchNuxtConfig;
 exports.patchPlaywrightConfig = patchPlaywrightConfig;
 /**
- * Idempotent patches applied by `lt dev migrate`.
+ * Idempotent patches applied by `lt dev init`.
  *
  * Goal: take a project that still has hardcoded `localhost:3000`
  * defaults and make it env-aware so it can be served behind Caddy
@@ -40,16 +40,32 @@ function autoPatch(file) {
         return patchPlaywrightConfig(file);
     return { file, patched: false, replacements: 0 };
 }
-/** API: `port: 3000,` → `port: Number(process.env.PORT) || 3000,`. */
+/**
+ * API: make the server listen port honour `process.env.PORT` (injected by
+ * `lt dev up` for its Caddy upstream). Handles two patterns found in
+ * nest-server `config.env.ts` files:
+ *
+ *  - the legacy literal `port: 3000,` (e.g. in `deployedConfig()`)
+ *  - the offers-pattern `port: process.env.NSC__PORT ? parseInt(process.env.NSC__PORT, 10) : 3000`
+ *    found in `localConfig()` — `lt dev` runs the API in local mode, so this
+ *    line MUST be patched too or the API ignores the assigned port.
+ *
+ * Idempotent — lines that already read `process.env.PORT` are left untouched.
+ */
 function patchApiConfig(file) {
     if (!(0, fs_1.existsSync)(file))
         return { file, patched: false, replacements: 0 };
     const before = (0, fs_1.readFileSync)(file, 'utf8');
     let count = 0;
-    const after = before.replace(/^(\s*)port:\s*3000\s*,$/gm, (_m, indent) => {
+    let after = before.replace(/^(\s*)port:\s*3000\s*,$/gm, (_m, indent) => {
         count++;
         return `${indent}port: Number(process.env.PORT) || 3000,`;
     });
+    // localConfig() keeps the NSC__PORT operator override; PORT (lt dev) wins.
+    after = after.replace(/^(\s*)port:\s*process\.env\.NSC__PORT\s*\?[^\n]*:\s*3000\s*,$/gm, (_m, indent) => {
+        count++;
+        return `${indent}port: Number(process.env.PORT) || (process.env.NSC__PORT ? parseInt(process.env.NSC__PORT, 10) : 3000),`;
+    });
     if (count === 0)
         return { file, patched: false, replacements: 0 };
     (0, fs_1.writeFileSync)(file, after, 'utf8');
@@ -69,6 +85,7 @@ function patchClaudeMd(file, options) {
     const appSub = identity.subdomains.app;
     const lines = [
         startMarker,
+        '',
         '## Local Development (lt dev)',
         '',
         `This project is registered with \`lt dev\` (slug: \`${identity.slug}\`). Use these commands to run alongside other lt projects without cross-wiring or port collisions:`,
@@ -77,9 +94,12 @@ function patchClaudeMd(file, options) {
         'lt dev up        # Start API + App behind Caddy with project-specific URLs',
         'lt dev down      # Stop the detached processes + remove Caddy block',
         'lt dev status    # Show running PIDs + bound URLs',
+        'lt dev test      # Ensure up + run the E2E suite with project URLs injected',
         'lt dev doctor    # Diagnose Caddy/CA/DNS/port issues',
         '```',
         '',
+        '**Start and test local apps via `lt dev`** — never `pnpm dev` / `pnpm start` / a bare `playwright test` directly; those bind the framework default ports (3000/3001) and collide with parallel projects.',
+        '',
         '**Active URLs for THIS project:**',
         '',
     ];
@@ -88,7 +108,7 @@ function patchClaudeMd(file, options) {
     if (apiSub)
         lines.push(`- API: \`https://${apiSub.hostname}\``);
     if (dbName)
-        lines.push(`- DB:  \`mongodb://127.0.0.1/${dbName}\``);
+        lines.push(`- DB: \`mongodb://127.0.0.1/${dbName}\``);
     lines.push('');
     lines.push('Env vars set automatically by `lt dev up`: `BASE_URL`, `APP_URL`, `NUXT_API_URL`, `NUXT_PUBLIC_API_URL`, `NUXT_PUBLIC_SITE_URL`, `NUXT_PUBLIC_STORAGE_PREFIX`, `NSC__MONGOOSE__URI`, `DATABASE_URL`. **Never assume `localhost:3000` / `localhost:3001` for this project** — those are the framework defaults, not the active URLs.');
     lines.push('');
@@ -159,30 +179,52 @@ function patchPlaywrightConfig(file) {
             return `${key}: process.env.NUXT_PUBLIC_SITE_URL || 'http://localhost:3001'`;
         });
     }
-    // 2. Top-of-file dotenv bridge — only inject if not already present.
+    // 2. Top-of-file dotenv bridge — inject it, or replace an outdated block.
+    //    The loader walks UP from cwd to find `.lt-dev/.env`: that file lives
+    //    at the repo root, while playwright.config.ts (and the process cwd of
+    //    a direct `playwright test` run) usually sit in `projects/app`. The
+    //    original cwd-only resolve missed it, so direct runs fell back to
+    //    `localhost:3001` and could collide with a parallel project.
     const bridgeStart = '// >>> lt-dev:bridge >>>';
     const bridgeEnd = '// <<< lt-dev:bridge <<<';
-    if (!after.includes(bridgeStart)) {
-        const bridgeBlock = [
-            bridgeStart,
-            '// Auto-load <root>/.lt-dev/.env when `lt dev up` is active so',
-            '// external test runners (CLI, IDE, VS Code Playwright Extension)',
-            '// pick up project URLs + Caddy CA without inheriting the parent shell.',
-            "import { existsSync as __ltDevExists, readFileSync as __ltDevRead } from 'node:fs';",
-            "import { resolve as __ltDevResolve } from 'node:path';",
-            "const __ltDevEnvFile = __ltDevResolve(process.cwd(), '.lt-dev/.env');",
-            'if (__ltDevExists(__ltDevEnvFile)) {',
-            '  for (const __ln of __ltDevRead(__ltDevEnvFile, "utf8").split(/\\r?\\n/)) {',
-            '    const __m = __ln.match(/^([A-Z][A-Z0-9_]*)=(.*)$/);',
-            '    if (__m && process.env[__m[1]] === undefined) process.env[__m[1]] = __m[2];',
-            '  }',
-            '}',
-            bridgeEnd,
-            '',
-        ].join('\n');
-        after = bridgeBlock + after;
+    const bridgeBlock = [
+        bridgeStart,
+        '// Auto-load <root>/.lt-dev/.env when `lt dev up` is active so',
+        '// external test runners (CLI, IDE, VS Code Playwright Extension)',
+        '// pick up project URLs + Caddy CA without inheriting the parent shell.',
+        '// Searches upward from cwd because `.lt-dev/` sits at the repo root',
+        '// while playwright.config.ts (and cwd) usually sit in projects/app.',
+        "import { existsSync as __ltDevExists, readFileSync as __ltDevRead } from 'node:fs';",
+        "import { dirname as __ltDevDirname, resolve as __ltDevResolve } from 'node:path';",
+        "let __ltDevEnvFile = '';",
+        'for (let __ltDevDir = process.cwd(), __i = 0; __i < 6; __i++) {',
+        "  const __candidate = __ltDevResolve(__ltDevDir, '.lt-dev/.env');",
+        '  if (__ltDevExists(__candidate)) { __ltDevEnvFile = __candidate; break; }',
+        '  const __parent = __ltDevDirname(__ltDevDir);',
+        '  if (__parent === __ltDevDir) break;',
+        '  __ltDevDir = __parent;',
+        '}',
+        'if (__ltDevEnvFile) {',
+        '  for (const __ln of __ltDevRead(__ltDevEnvFile, "utf8").split(/\\r?\\n/)) {',
+        '    const __m = __ln.match(/^([A-Z][A-Z0-9_]*)=(.*)$/);',
+        '    if (__m && process.env[__m[1]] === undefined) process.env[__m[1]] = __m[2];',
+        '  }',
+        '}',
+        bridgeEnd,
+    ].join('\n');
+    const bridgeStartIdx = after.indexOf(bridgeStart);
+    const bridgeEndIdx = after.indexOf(bridgeEnd);
+    if (bridgeStartIdx === -1) {
+        after = `${bridgeBlock}\n${after}`;
         count++;
     }
+    else if (bridgeEndIdx !== -1) {
+        const rebuilt = after.slice(0, bridgeStartIdx) + bridgeBlock + after.slice(bridgeEndIdx + bridgeEnd.length);
+        if (rebuilt !== after) {
+            after = rebuilt;
+            count++;
+        }
+    }
     if (count === 0)
         return { file, patched: false, replacements: 0 };
     (0, fs_1.writeFileSync)(file, after, 'utf8');

package/build/lib/dev-process.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkPortInUse = checkPortInUse;
 exports.killProcessGroup = killProcessGroup;
 exports.listenSnapshot = listenSnapshot;
+exports.rotateLogFile = rotateLogFile;
 exports.spawnDetached = spawnDetached;
 /**
  * Process + port helpers for `lt dev`.
@@ -114,9 +115,43 @@ function listenSnapshot(ports) {
         });
     });
 }
+/**
+ * Rotate a log file: rename existing `<logFile>` to `<logFile>.1`, dropping
+ * any previous `.1`. Keeps exactly one prior generation so the most recent
+ * `lt dev down`-able session stays inspectable without unbounded growth.
+ *
+ * Returns `{ rotated: false }` when no prior log exists.
+ */
+function rotateLogFile(logFile) {
+    let previousSize;
+    try {
+        previousSize = (0, fs_1.statSync)(logFile).size;
+    }
+    catch (_a) {
+        return { rotated: false };
+    }
+    const archivePath = `${logFile}.1`;
+    try {
+        (0, fs_1.unlinkSync)(archivePath);
+    }
+    catch (_b) {
+        /* nothing to remove */
+    }
+    try {
+        (0, fs_1.renameSync)(logFile, archivePath);
+    }
+    catch (_c) {
+        return { rotated: false };
+    }
+    return { archivePath, previousSize, rotated: true };
+}
 /**
  * Spawn a detached child whose stdio is redirected to a log file.
  *
+ * Rotates any previous log first (one generation kept as `<logFile>.1`) so
+ * each session starts with a fresh file. Prevents the multi-day accumulation
+ * that produced ~10 GB logs under continuous `up`/`down` cycles.
+ *
  * The parent's copy of the log file descriptor is closed in `finally`
  * — the child has already inherited its own fd before `spawn` returns,
  * so closing prevents fd leaks and avoids racing-write artifacts on
@@ -126,6 +161,7 @@ function listenSnapshot(ports) {
  */
 function spawnDetached(cmd, args, opts) {
     (0, fs_1.mkdirSync)((0, path_1.dirname)(opts.logFile), { recursive: true });
+    const rotated = rotateLogFile(opts.logFile);
     const out = (0, fs_1.openSync)(opts.logFile, 'a');
     let child;
     try {
@@ -136,7 +172,9 @@ function spawnDetached(cmd, args, opts) {
             stdio: ['ignore', out, out],
         });
         child.unref();
-        return child.pid;
+        if (child.pid === undefined)
+            return undefined;
+        return { pid: child.pid, rotated };
     }
     catch (_a) {
         return undefined;