@lenne.tech/cli 1.33.0 → 1.35.0

package/build/lib/codex-plugin-utils.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_CODEX_PLUGIN_CONTENTS = void 0;
+exports.installCodexAgents = installCodexAgents;
+exports.installCodexPrompts = installCodexPrompts;
+exports.readCodexMarketplaceName = readCodexMarketplaceName;
+exports.readLocalCodexPluginContents = readLocalCodexPluginContents;
+/**
+ * Codex plugin setup helpers.
+ */
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const json_utils_1 = require("./json-utils");
+exports.EMPTY_CODEX_PLUGIN_CONTENTS = {
+    agents: [],
+    hooks: 0,
+    mcpServers: [],
+    prompts: [],
+    skills: [],
+};
+function installCodexAgents(pluginRoot) {
+    const sourceDir = (0, path_1.join)(pluginRoot, 'codex-agents');
+    if (!(0, fs_1.existsSync)(sourceDir)) {
+        return 0;
+    }
+    const targetDir = (0, path_1.join)((0, os_1.homedir)(), '.codex', 'agents');
+    (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+    let count = 0;
+    for (const entry of (0, fs_1.readdirSync)(sourceDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.toml'))
+            continue;
+        (0, fs_1.copyFileSync)((0, path_1.join)(sourceDir, entry.name), (0, path_1.join)(targetDir, entry.name));
+        count += 1;
+    }
+    return count;
+}
+function installCodexPrompts(pluginRoot) {
+    const sourceDir = (0, path_1.join)(pluginRoot, 'prompts');
+    if (!(0, fs_1.existsSync)(sourceDir)) {
+        return 0;
+    }
+    const targetDir = (0, path_1.join)((0, os_1.homedir)(), '.codex', 'prompts');
+    (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+    let count = 0;
+    for (const entry of (0, fs_1.readdirSync)(sourceDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith('.md'))
+            continue;
+        (0, fs_1.copyFileSync)((0, path_1.join)(sourceDir, entry.name), (0, path_1.join)(targetDir, entry.name));
+        count += 1;
+    }
+    return count;
+}
+function readCodexMarketplaceName(root) {
+    const path = (0, path_1.join)(root, '.agents', 'plugins', 'marketplace.json');
+    if (!(0, fs_1.existsSync)(path)) {
+        return null;
+    }
+    const parsed = (0, json_utils_1.safeJsonParse)((0, fs_1.readFileSync)(path, 'utf-8'));
+    return (parsed === null || parsed === void 0 ? void 0 : parsed.name) || null;
+}
+function readLocalCodexPluginContents(pluginRoot) {
+    const result = Object.assign({}, exports.EMPTY_CODEX_PLUGIN_CONTENTS);
+    const skillsDir = (0, path_1.join)(pluginRoot, 'skills');
+    if ((0, fs_1.existsSync)(skillsDir)) {
+        result.skills = (0, fs_1.readdirSync)(skillsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    const agentsDir = (0, path_1.join)(pluginRoot, 'codex-agents');
+    if ((0, fs_1.existsSync)(agentsDir)) {
+        result.agents = (0, fs_1.readdirSync)(agentsDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.toml'))
+            .map((entry) => entry.name.replace(/\.toml$/, ''))
+            .sort();
+    }
+    const promptsDir = (0, path_1.join)(pluginRoot, 'prompts');
+    if ((0, fs_1.existsSync)(promptsDir)) {
+        result.prompts = (0, fs_1.readdirSync)(promptsDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+            .map((entry) => entry.name.replace(/\.md$/, ''))
+            .sort();
+    }
+    const hooksPath = (0, path_1.join)(pluginRoot, 'hooks', 'hooks.json');
+    if ((0, fs_1.existsSync)(hooksPath)) {
+        const parsed = (0, json_utils_1.safeJsonParse)((0, fs_1.readFileSync)(hooksPath, 'utf-8'));
+        if (parsed === null || parsed === void 0 ? void 0 : parsed.hooks) {
+            for (const groups of Object.values(parsed.hooks)) {
+                for (const group of groups) {
+                    result.hooks += Array.isArray(group.hooks) ? group.hooks.length : 0;
+                }
+            }
+        }
+    }
+    const mcpPath = (0, path_1.join)(pluginRoot, '.mcp.json');
+    if ((0, fs_1.existsSync)(mcpPath)) {
+        const parsed = (0, json_utils_1.safeJsonParse)((0, fs_1.readFileSync)(mcpPath, 'utf-8'));
+        result.mcpServers = Object.keys((parsed === null || parsed === void 0 ? void 0 : parsed.mcpServers) || {}).sort();
+    }
+    return result;
+}

package/build/lib/dev-identity.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildIdentity = buildIdentity;
 exports.buildTestIdentity = buildTestIdentity;
 exports.buildTicketIdentity = buildTicketIdentity;
+exports.detectStandaloneKind = detectStandaloneKind;
 exports.isUnmodifiedTemplateName = isUnmodifiedTemplateName;
 exports.projectSlug = projectSlug;
 exports.slugify = slugify;
@@ -31,43 +32,46 @@ const path_1 = require("path");
  * - `projects/app` → `<slug>.localhost` (primary)
  * - `projects/<other>` → `<other>.<slug>.localhost`
  *
- * For standalone projects (single repo, no `projects/` directory):
+ * For standalone projects (single repo, no `projects/api` or `projects/app`):
  * - API project (config.env.ts present) → `api.<slug>.localhost`
  * - App project (nuxt.config.ts present) → `<slug>.localhost`
+ *
+ * Every combination is valid: api+app, api-only, and app-only.
  */
 function buildIdentity(root) {
     const slug = projectSlug(root);
     const subdomains = {};
-    const projectsDir = (0, path_1.join)(root, 'projects');
-    if ((0, fs_1.existsSync)(projectsDir)) {
-        // Monorepo: enumerate projects/* subdirectories.
-        const apiDir = (0, path_1.join)(projectsDir, 'api');
-        const appDir = (0, path_1.join)(projectsDir, 'app');
-        if ((0, fs_1.existsSync)(apiDir)) {
+    const apiDir = (0, path_1.join)(root, 'projects', 'api');
+    const appDir = (0, path_1.join)(root, 'projects', 'app');
+    const hasApi = (0, fs_1.existsSync)(apiDir);
+    const hasApp = (0, fs_1.existsSync)(appDir);
+    // Monorepo only when a known subproject is actually present. A bare (or
+    // unrelated) `projects/` directory must not shadow the standalone probe —
+    // it would yield an identity with zero subdomains and no routable URLs.
+    if (hasApi || hasApp) {
+        if (hasApi) {
             subdomains.api = {
                 hostname: `api.${slug}.localhost`,
                 isPrimaryApp: false,
                 subdir: 'projects/api',
             };
         }
-        if ((0, fs_1.existsSync)(appDir)) {
+        if (hasApp) {
             subdomains.app = {
                 hostname: `${slug}.localhost`,
                 isPrimaryApp: true,
                 subdir: 'projects/app',
             };
         }
+        return { root, slug, subdomains };
     }
-    else {
-        // Standalone — derive from project shape.
-        const isApi = (0, fs_1.existsSync)((0, path_1.join)(root, 'src', 'config.env.ts')) || (0, fs_1.existsSync)((0, path_1.join)(root, 'nest-cli.json'));
-        const isApp = (0, fs_1.existsSync)((0, path_1.join)(root, 'nuxt.config.ts'));
-        if (isApi) {
-            subdomains.api = { hostname: `api.${slug}.localhost`, isPrimaryApp: false, subdir: null };
-        }
-        if (isApp) {
-            subdomains.app = { hostname: `${slug}.localhost`, isPrimaryApp: true, subdir: null };
-        }
+    // Standalone — derive from project shape.
+    const { isApi, isApp } = detectStandaloneKind(root);
+    if (isApi) {
+        subdomains.api = { hostname: `api.${slug}.localhost`, isPrimaryApp: false, subdir: null };
+    }
+    if (isApp) {
+        subdomains.app = { hostname: `${slug}.localhost`, isPrimaryApp: true, subdir: null };
     }
     return { root, slug, subdomains };
 }
@@ -105,6 +109,22 @@ function buildTestIdentity(base, suffix = '-test') {
 function buildTicketIdentity(base, id) {
     return buildTestIdentity(base, `-${id}`);
 }
+/**
+ * Probe a single directory for the shape of a STANDALONE lt project.
+ *
+ * Single source of truth for "is this an API / an App?", shared by
+ * {@link buildIdentity} and `dev-project.ts#resolveLayout` so the identity
+ * (URLs) and the layout (which processes to spawn) can never disagree.
+ *
+ * Both flags can be true (a single repo holding both), and both can be false
+ * (not an lt-dev project).
+ */
+function detectStandaloneKind(dir) {
+    return {
+        isApi: (0, fs_1.existsSync)((0, path_1.join)(dir, 'src', 'config.env.ts')) || (0, fs_1.existsSync)((0, path_1.join)(dir, 'nest-cli.json')),
+        isApp: (0, fs_1.existsSync)((0, path_1.join)(dir, 'nuxt.config.ts')),
+    };
+}
 /**
  * package.json `name` values that are unchanged starter-template defaults.
  *

package/build/lib/dev-package-manager.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickPackageManager = pickPackageManager;
+/**
+ * Pick the package manager `lt dev` should drive for a given project dir.
+ *
+ * `lt dev up` and the related test/ticket flows used to hard-code `pnpm`
+ * for every monorepo. That breaks npm-only and yarn-only projects: a
+ * `pnpm install` invoked from inside `pnpm start` regenerates a
+ * pnpm-lock.yaml (which the project's .gitignore then refuses to track),
+ * fails on un-approved build scripts (bcrypt, sharp, esbuild) and exits
+ * non-zero — the supervised api/app processes die immediately and
+ * `lt dev status` reports them as `dead`.
+ *
+ * Detection order — highest precedence first:
+ *   1. `LT_PM_BIN` env var (generic override).
+ *   2. `LT_PNPM_BIN` env var (legacy — kept for backwards compatibility).
+ *   3. `pnpm-lock.yaml` in `cwd` → pnpm
+ *   4. `yarn.lock`       in `cwd` → yarn
+ *   5. `package-lock.json` in `cwd` → npm
+ *   6. Fallback: `pnpm` (preserves the historical default so nothing
+ *      breaks for the projects this CLI was originally written for).
+ *
+ * The detection is per-cwd so a monorepo with a pnpm api + npm app gets
+ * the correct command per component.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Resolve which package manager to drive for `cwd`. Pure — only filesystem
+ * existence checks, no exec. The override env vars take precedence so a
+ * CI pipeline can pin the manager without touching the lockfile.
+ *
+ * `cwd` is expected to be a project root (i.e. where the lockfile lives).
+ * For a monorepo with separate api/app dirs, call this once per dir.
+ */
+function pickPackageManager(cwd, env = process.env) {
+    const override = env.LT_PM_BIN || env.LT_PNPM_BIN;
+    if (override) {
+        return buildCommand(override, inferNameFromBin(override));
+    }
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(cwd, 'pnpm-lock.yaml'))) {
+        return buildCommand('pnpm', 'pnpm');
+    }
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(cwd, 'yarn.lock'))) {
+        return buildCommand('yarn', 'yarn');
+    }
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(cwd, 'package-lock.json'))) {
+        return buildCommand('npm', 'npm');
+    }
+    // Historical default — keep so projects without a lockfile (fresh
+    // scaffolds, vendored monorepos) behave exactly as before.
+    return buildCommand('pnpm', 'pnpm');
+}
+function buildCommand(bin, name) {
+    const isNpm = name === 'npm';
+    return {
+        bin,
+        exec(binary, args = []) {
+            // `npm exec` consumes the args before the binary name and treats
+            // anything after as its own flags unless separated by `--`. pnpm
+            // and yarn route them through unchanged. Without the separator
+            // `npm exec playwright test --shard=1/2` would parse `--shard`
+            // as an npm option, NOT a Playwright one.
+            return isNpm ? ['exec', '--', binary, ...args] : ['exec', binary, ...args];
+        },
+        installArgs: ['install'],
+        name,
+        runScript(script, extra = []) {
+            // pnpm + yarn accept the bare-script shortcut (`pnpm dev`), npm
+            // does not. Using `run <script>` is universally accepted so we
+            // route every manager through the same call.
+            return ['run', script, ...extra];
+        },
+    };
+}
+function inferNameFromBin(bin) {
+    const lower = bin.toLowerCase();
+    if (lower.endsWith('pnpm') || lower.includes('/pnpm')) {
+        return 'pnpm';
+    }
+    if (lower.endsWith('yarn') || lower.includes('/yarn')) {
+        return 'yarn';
+    }
+    if (lower.endsWith('npm') || lower.includes('/npm')) {
+        return 'npm';
+    }
+    return 'unknown';
+}

package/build/lib/dev-patches.js

@@ -127,7 +127,10 @@ function patchClaudeMd(file, options) {
     }
     else {
         const sep = content.endsWith('\n\n') ? '' : content.endsWith('\n') ? '\n' : '\n\n';
-        next = `${content}${sep}${block}\n`;
+        // No trailing newline: oxfmt strips it from .md files, so emitting one
+        // makes a freshly patched CLAUDE.md fail `format:check` (read-only) until
+        // the next `check` auto-fix. Keep the block flush with EOF.
+        next = `${content}${sep}${block}`;
     }
     if (next === content)
         return { file, patched: false, replacements: 0 };

package/build/lib/dev-project.js

@@ -8,6 +8,7 @@ exports.deriveTicketDbName = deriveTicketDbName;
 exports.resolveLayout = resolveLayout;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const dev_identity_1 = require("./dev-identity");
 const workspace_integration_1 = require("./workspace-integration");
 /**
  * Detect whether the API project still has the legacy hardcoded `port: 3000`.
@@ -85,20 +86,32 @@ function deriveTicketDbName(devDbName, ticketId) {
 /**
  * Resolve layout starting from `cwd`. Walks up to find a workspace if
  * cwd is inside `projects/api/` or `projects/app/`.
+ *
+ * A workspace marker alone never wins: it only selects the monorepo layout
+ * when `projects/api` or `projects/app` actually exists. Otherwise we fall
+ * through to the standalone probe — a single-package repo may legitimately
+ * carry a settings-only `pnpm-workspace.yaml` (pnpm 10/11 keeps `overrides`
+ * and build allowlists there), and an npm workspace may use `packages/*`
+ * rather than the lt `projects/*` convention.
  */
 function resolveLayout(cwd, filesystem) {
     const subContext = (0, workspace_integration_1.detectSubProjectContext)(cwd, filesystem);
     if (subContext)
         return monorepoLayout(subContext.workspaceRoot);
     const layout = (0, workspace_integration_1.detectWorkspaceLayout)(cwd, filesystem);
-    if (layout.hasWorkspace)
-        return monorepoLayout(layout.workspaceDir);
+    if (layout.hasWorkspace) {
+        const mono = monorepoLayout(layout.workspaceDir);
+        if (mono.apiDir || mono.appDir)
+            return mono;
+    }
     const workspaceRoot = (0, workspace_integration_1.findWorkspaceRoot)(cwd, filesystem);
-    if (workspaceRoot)
-        return monorepoLayout(workspaceRoot);
-    // Standalone project — figure out if it's API or App.
-    const isApi = (0, fs_1.existsSync)((0, path_1.join)(cwd, 'src', 'config.env.ts')) || (0, fs_1.existsSync)((0, path_1.join)(cwd, 'nest-cli.json'));
-    const isApp = (0, fs_1.existsSync)((0, path_1.join)(cwd, 'nuxt.config.ts'));
+    if (workspaceRoot) {
+        const mono = monorepoLayout(workspaceRoot);
+        if (mono.apiDir || mono.appDir)
+            return mono;
+    }
+    // Standalone project — API-only, App-only, or a single repo holding both.
+    const { isApi, isApp } = (0, dev_identity_1.detectStandaloneKind)(cwd);
     return {
         apiDir: isApi ? cwd : null,
         appDir: isApp ? cwd : null,

package/build/lib/dev-state.js

@@ -118,7 +118,7 @@ function loadRegistry() {
     try {
         const parsed = JSON.parse((0, fs_1.readFileSync)(REGISTRY_PATH, 'utf8'));
         if (parsed && typeof parsed === 'object' && parsed.version === 1 && typeof parsed.projects === 'object') {
-            return parsed;
+            return normalizeRegistry(parsed);
         }
     }
     catch (_a) {
@@ -184,6 +184,22 @@ function takenInternalPorts(reg, excludeSlug) {
     }
     return ports;
 }
+/**
+ * Drop a `dbName` from any entry that has no `api` subdomain. An App-only
+ * project has no database, yet older registries (written before `lt dev up`
+ * stopped persisting one for App-only stacks) still carry a derived name.
+ * Normalizing once on load lets every reader test `entry.dbName` alone,
+ * instead of repeating `entry.dbName && entry.subdomains.api` at each display.
+ */
+function normalizeRegistry(reg) {
+    var _a;
+    for (const entry of Object.values(reg.projects)) {
+        if ((entry === null || entry === void 0 ? void 0 : entry.dbName) && !((_a = entry.subdomains) === null || _a === void 0 ? void 0 : _a.api)) {
+            delete entry.dbName;
+        }
+    }
+    return reg;
+}
 /** True if two paths resolve to the same location (normalising symlinks, e.g. /var → /private/var). */
 function sameRealPath(a, b) {
     try {

package/build/lib/dev-test-session.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_INITIAL_ADMIN_ENV = void 0;
 exports.autoShardCount = autoShardCount;
 exports.bringUpTestSession = bringUpTestSession;
 exports.hasTestSession = hasTestSession;
@@ -47,6 +48,7 @@ const caddy_1 = require("./caddy");
 const dev_env_1 = require("./dev-env");
 const dev_env_bridge_1 = require("./dev-env-bridge");
 const dev_identity_1 = require("./dev-identity");
+const dev_package_manager_1 = require("./dev-package-manager");
 const dev_patches_1 = require("./dev-patches");
 const dev_process_1 = require("./dev-process");
 const dev_project_1 = require("./dev-project");
@@ -56,6 +58,25 @@ const TEST_APP_LOG = 'app.test.log';
 const TEST_BRIDGE_FILE = '.env.test';
 /** Internal port band for the test stack — distinct from the dev band (4000+). */
 const TEST_PORT_BASE = 4500;
+/**
+ * Throwaway initial-admin credentials for the isolated `lt dev test` database.
+ *
+ * The nest-server core auto-parses these `NSC__…` vars into
+ * `systemSetup.initialAdmin.*` and seeds the admin ONCE on an empty DB (it never
+ * overwrites an existing admin), so a set-up system exists before the suite runs.
+ * A fresh template project's standard auth E2E specs assume such a system — they
+ * do no self-setup — so without this they fail LOCALLY on the empty per-run DB.
+ * These are the exact values the lt-monorepo template CI uses
+ * (`.gitlab-ci.yml` / `.github/workflows/test.yml`), keeping CI ↔ local parity.
+ *
+ * Injected ONLY into the `lt dev test` API process (its DB is fresh + discarded
+ * per run), NEVER into `lt dev up` — no surprise admin in the persistent dev DB.
+ */
+exports.TEST_INITIAL_ADMIN_ENV = {
+    NSC__SYSTEM_SETUP__INITIAL_ADMIN__EMAIL: 'ci-admin@test.com',
+    NSC__SYSTEM_SETUP__INITIAL_ADMIN__NAME: 'CI Admin',
+    NSC__SYSTEM_SETUP__INITIAL_ADMIN__PASSWORD: 'CiThrowawayAdmin123!',
+};
 /**
  * Heuristic for the default local shard count (`--shard auto` / bare `--shard`).
  *
@@ -189,20 +210,27 @@ function bringUpTestSession(layout_1, baseIdentity_1, log_1) {
             dbName,
             identity: testIdentity,
         });
-        const pnpmBin = process.env.LT_PNPM_BIN || 'pnpm';
         const pids = {};
-        // --- API: compiled (`node dist`) for stability; fall back to `pnpm start`.
-        // `skipBuild` (sibling shards) reuses the dist the first shard produced. ---
+        // --- API: compiled (`node dist`) for stability; fall back to the project's
+        // own dev start script. `skipBuild` (sibling shards) reuses the dist the
+        // first shard produced. Per-component PM detection mirrors `lt dev up`:
+        // a monorepo with an npm api and a pnpm app must drive each correctly. ---
         if (layout.apiDir && apiPort) {
+            const apiPm = (0, dev_package_manager_1.pickPackageManager)(layout.apiDir);
             let build = 0;
             if (!skipBuild) {
                 log.info(log.dim('Building API (compiled, for stable long runs) …'));
-                build = yield (0, dev_process_1.runChildInherit)(pnpmBin, ['run', 'build'], { cwd: layout.apiDir, env: process.env });
+                build = yield (0, dev_process_1.runChildInherit)(apiPm.bin, apiPm.runScript('build'), { cwd: layout.apiDir, env: process.env });
             }
             const entry = ['dist/src/main.js', 'dist/main.js']
                 .map((rel) => (0, path_1.join)(layout.apiDir, rel))
                 .find((p) => (0, fs_1.existsSync)(p));
-            const apiEnv = Object.assign(Object.assign({}, devEnv.api.env), { NODE_ENV: 'local' });
+            // Seed a throwaway initial admin into the fresh, isolated test DB so the
+            // standard auth E2E specs run against a set-up system — locally exactly like
+            // the lt-monorepo template CI. Defaults first so an explicitly inherited
+            // `NSC__…INITIAL_ADMIN__…` still wins (deliberate override respected). Only
+            // reached from `lt dev test` — `lt dev up` never calls bringUpTestSession.
+            const apiEnv = Object.assign(Object.assign(Object.assign({}, exports.TEST_INITIAL_ADMIN_ENV), devEnv.api.env), { NODE_ENV: 'local' });
             let apiSpawn;
             if (build === 0 && entry) {
                 apiSpawn = (0, dev_process_1.spawnDetached)('node', [entry], {
@@ -212,8 +240,8 @@ function bringUpTestSession(layout_1, baseIdentity_1, log_1) {
                 });
             }
             else {
-                log.warn('compiled API not available — falling back to `pnpm start` (ts-node).');
-                apiSpawn = (0, dev_process_1.spawnDetached)(pnpmBin, ['start'], {
+                log.warn(`compiled API not available — falling back to \`${apiPm.bin} start\` (ts-node).`);
+                apiSpawn = (0, dev_process_1.spawnDetached)(apiPm.bin, apiPm.runScript('start'), {
                     cwd: layout.apiDir,
                     env: apiEnv,
                     logFile: (0, path_1.join)(layout.root, '.lt-dev', names.apiLog),
@@ -231,10 +259,14 @@ function bringUpTestSession(layout_1, baseIdentity_1, log_1) {
         // must be a cross-subdomain DOMAIN cookie — see the project's parseCookieHeader).
         // Rebuilt every run so the suite never hits stale code (no build-skip / reuse). ---
         if (layout.appDir && appPort) {
+            const appPm = (0, dev_package_manager_1.pickPackageManager)(layout.appDir);
             let appBuild = 0;
             if (!skipBuild) {
                 log.info(log.dim('Building App (nuxt build, for speed + prod-fidelity) …'));
-                appBuild = yield (0, dev_process_1.runChildInherit)(pnpmBin, ['run', 'build'], { cwd: layout.appDir, env: devEnv.app.env });
+                appBuild = yield (0, dev_process_1.runChildInherit)(appPm.bin, appPm.runScript('build'), {
+                    cwd: layout.appDir,
+                    env: devEnv.app.env,
+                });
             }
             const appEntry = ['.output/server/index.mjs']
                 .map((rel) => (0, path_1.join)(layout.appDir, rel))
@@ -248,8 +280,8 @@ function bringUpTestSession(layout_1, baseIdentity_1, log_1) {
                 });
             }
             else {
-                log.warn('built app not available — falling back to `pnpm dev` (slower: cold-compiles routes).');
-                appSpawn = (0, dev_process_1.spawnDetached)(pnpmBin, ['dev'], {
+                log.warn(`built app not available — falling back to \`${appPm.bin} dev\` (slower: cold-compiles routes).`);
+                appSpawn = (0, dev_process_1.spawnDetached)(appPm.bin, appPm.runScript('dev'), {
                     cwd: layout.appDir,
                     env: devEnv.app.env,
                     logFile: (0, path_1.join)(layout.root, '.lt-dev', names.appLog),
@@ -281,7 +313,10 @@ function bringUpTestSession(layout_1, baseIdentity_1, log_1) {
             if (!apiReady)
                 log.warn(`Test API did not answer 2xx on ${apiUrl}/meta within 120s — the first specs may skip.`);
         }
-        return { apiUrl, appEnv: devEnv.app.env, appUrl, dbName, pids, testIdentity };
+        // Expose THIS stack's API log path so the caller can point the auth E2E specs
+        // (via NEST_SERVER_LOG) at the exact isolated log — correct per shard.
+        const apiLogPath = layout.apiDir ? (0, path_1.join)(layout.root, '.lt-dev', names.apiLog) : undefined;
+        return { apiLogPath, apiUrl, appEnv: devEnv.app.env, appUrl, dbName, pids, testIdentity };
     });
 }
 /** True when a test session file exists (used by status/down). */
@@ -338,15 +373,22 @@ function runShardedTestSession(layout, baseIdentity, log, opts) {
             // suite runs under concurrent sharded load, so it can relax navigation /
             // test timeouts (N built SSR servers + N Chromium saturate the CPU and slow
             // every navigation) without loosening them for serial runs.
-            const env = Object.assign(Object.assign({}, ctx.appEnv), { LT_DEV_TEST_SHARDS: String(total), MONGO_URI: `mongodb://127.0.0.1/${ctx.dbName}` });
+            const env = Object.assign(Object.assign(Object.assign({}, ctx.appEnv), { LT_DEV_TEST_SHARDS: String(total), MONGO_URI: `mongodb://127.0.0.1/${ctx.dbName}` }), (ctx.apiLogPath ? { NEST_SERVER_LOG: ctx.apiLogPath } : {}));
             const logFile = (0, path_1.join)(layout.root, '.lt-dev', `shard.${index}.test.log`);
-            // Invoke Playwright DIRECTLY via `pnpm exec` (NOT `pnpm run test:e2e -- …`):
-            // forwarding option flags through `pnpm run`'s `--` is unreliable — pnpm
-            // passed the separator on to Playwright, which then read `--shard`/
-            // `--reporter` as file FILTERS (not options) → every shard ran the whole
-            // suite. `pnpm exec` hands args straight to the binary (mirrors CI).
-            const args = ['exec', 'playwright', 'test', `--shard=${index}/${total}`, '--reporter=line', ...opts.forwarded];
-            const code = yield (0, dev_process_1.runChildToFile)(opts.pnpmBin, args, { cwd: appDir, env, logFile });
+            // Invoke Playwright DIRECTLY via the manager's `exec` (NOT `<pm> run
+            // test:e2e -- …`): forwarding option flags through `<pm> run`'s `--`
+            // is unreliable — pnpm passed the separator on to Playwright, which
+            // then read `--shard` / `--reporter` as file FILTERS (not options) →
+            // every shard ran the whole suite. `<pm> exec` hands args straight
+            // to the binary (mirrors CI); the helper inserts `--` for npm so
+            // those flags don't get re-parsed as npm's own.
+            const args = opts.pm.exec('playwright', [
+                'test',
+                `--shard=${index}/${total}`,
+                '--reporter=line',
+                ...opts.forwarded,
+            ]);
+            const code = yield (0, dev_process_1.runChildToFile)(opts.pm.bin, args, { cwd: appDir, env, logFile });
             return { code, index, logFile };
         })));
         // Aggregate per-shard exit codes into a single result.

package/build/lib/dev-ticket.js

@@ -8,8 +8,8 @@ exports.dropDatabase = dropDatabase;
 exports.gitBranchExists = gitBranchExists;
 exports.gitFetch = gitFetch;
 exports.gitMainRepoRoot = gitMainRepoRoot;
+exports.installWorktreeDeps = installWorktreeDeps;
 exports.listWorktrees = listWorktrees;
-exports.pnpmInstall = pnpmInstall;
 exports.readTicketMarker = readTicketMarker;
 exports.resolveDevIdentity = resolveDevIdentity;
 exports.worktreeAdd = worktreeAdd;
@@ -43,6 +43,7 @@ const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const dev_identity_1 = require("./dev-identity");
+const dev_package_manager_1 = require("./dev-package-manager");
 const dev_patches_1 = require("./dev-patches");
 const dev_project_1 = require("./dev-project");
 const dev_state_1 = require("./dev-state");
@@ -183,6 +184,16 @@ function gitMainRepoRoot(cwd) {
     const commonDir = git(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
     return (0, path_1.dirname)(commonDir);
 }
+/**
+ * Install dependencies in a freshly-created worktree. Auto-detects the
+ * project's package manager from its lockfile (pnpm hard-links from the
+ * shared store → fast; npm + yarn install normally). Falls back to pnpm
+ * for fresh scaffolds without a lockfile yet.
+ */
+function installWorktreeDeps(dir) {
+    const pm = (0, dev_package_manager_1.pickPackageManager)(dir);
+    (0, child_process_1.execFileSync)(pm.bin, pm.installArgs, { cwd: dir, stdio: 'inherit' });
+}
 /** List all worktrees of the repo (parsed from `git worktree list --porcelain`). */
 function listWorktrees(repoDir) {
     let out = '';
@@ -208,11 +219,6 @@ function listWorktrees(repoDir) {
         result.push(finalizeWorktree(current));
     return result;
 }
-/** Install dependencies in a freshly-created worktree (pnpm hard-links from the shared store → fast). */
-function pnpmInstall(dir) {
-    const pnpmBin = process.env.LT_PNPM_BIN || 'pnpm';
-    (0, child_process_1.execFileSync)(pnpmBin, ['install'], { cwd: dir, stdio: 'inherit' });
-}
 /** Read the ticket id this worktree is tagged with, or null. */
 function readTicketMarker(root) {
     const file = (0, path_1.join)(root, dev_state_1.paths.sessionDir, TICKET_MARKER);