@lenne.tech/cli 1.32.1 → 1.34.0

package/build/extensions/frontend-helper.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FrontendHelper = void 0;
+const check_freshness_hooks_1 = require("../lib/check-freshness-hooks");
 const markdown_table_1 = require("../lib/markdown-table");
 const vendor_claude_md_1 = require("../lib/vendor-claude-md");
 /**
@@ -140,49 +141,54 @@ class FrontendHelper {
         return __awaiter(this, arguments, void 0, function* (dest, options = {}) {
             const { system, templateHelper } = this.toolbox;
             const { branch, copyPath, linkPath, skipInstall } = options;
-            // Use template extension for link/copy/branch operations
-            if (linkPath || copyPath || branch) {
-                const result = yield templateHelper.setup(dest, {
-                    branch,
-                    copyPath,
-                    isNuxt: true,
-                    linkPath,
-                    repoUrl: branch ? 'https://github.com/lenneTech/nuxt-base-starter.git' : undefined,
-                });
-                if (!result.success) {
-                    return { method: result.method, path: result.path, success: false };
-                }
-                // After a clone, flatten the wrapper layout so `projects/app/`
-                // IS the Nuxt app (the cloned root is the `create-nuxt-base`
-                // scaffolder, not the app — see flattenNuxtBaseTemplate).
-                // Skip on link mode: a symlink points at the user's local
-                // checkout and must not have its template subdir torn out.
-                if (result.method === 'clone') {
-                    yield this.flattenNuxtBaseTemplate(dest);
-                }
-                // Run install if not skipped and not a symlink
-                if (!skipInstall && result.method !== 'link') {
-                    try {
-                        const { pm } = this.toolbox;
-                        yield system.run(`cd "${dest}" && ${pm.install(pm.detect(dest))}`);
-                    }
-                    catch (err) {
-                        return { method: result.method, path: dest, success: false };
-                    }
-                }
-                return { method: result.method, path: result.path, success: true };
+            // Source the Nuxt app from the nuxt-base-starter repo (priority:
+            // link > copy > clone), mirroring the backend (nest-server-starter)
+            // flow. The default — no link/copy/branch — clones the repo's default
+            // branch, so a fresh init always integrates the CURRENT GitHub template.
+            //
+            // This deliberately replaces the former `create-nuxt-base@latest` npx
+            // path: that package is marked `private` and is no longer published
+            // (nuxt-base-starter commit b534af2 — "distribute via lt CLI fullstack
+            // template"), so `@latest` was frozen at an outdated copy and the
+            // bundled template drifted from GitHub. Cloning the repo directly is
+            // the same mechanism the backend already uses and removes that drift.
+            const result = yield templateHelper.setup(dest, {
+                branch,
+                copyPath,
+                isNuxt: true,
+                linkPath,
+                repoUrl: linkPath || copyPath ? undefined : 'https://github.com/lenneTech/nuxt-base-starter.git',
+            });
+            if (!result.success) {
+                return { method: result.method, path: result.path, success: false };
             }
-            // Default: use create-nuxt-base
-            try {
-                const { pm } = this.toolbox;
-                yield system.run(pm.exec(`create-nuxt-base@latest "${dest}"`));
-                // Fix package name - create-nuxt-base uses path as name which is invalid for lerna
+            // After a clone, flatten the wrapper layout so `dest` IS the Nuxt app
+            // (the cloned root carries the scaffolder; the app lives in
+            // `nuxt-base-template/` — see flattenNuxtBaseTemplate). Skip on link
+            // mode: a symlink points at the user's checkout and must not be torn out.
+            if (result.method === 'clone') {
+                yield this.flattenNuxtBaseTemplate(dest);
+            }
+            // Normalize the sub-project package name to a stable, valid workspace
+            // name ("app"). The template ships as `nuxt-base-template`; the former
+            // create-nuxt-base path renamed it the same way. Skip link mode — a
+            // symlinked checkout is shared with upstream and must not be mutated.
+            if (result.method !== 'link') {
                 yield this.fixPackageName(dest);
-                return { method: 'npx', path: dest, success: true };
             }
-            catch (err) {
-                return { method: 'npx', path: dest, success: false };
+            // Run install unless skipped or a symlink. Fullstack init installs at
+            // the monorepo level (skipInstall: true); standalone `lt frontend nuxt`
+            // installs here (create-nuxt-base used to handle that).
+            if (!skipInstall && result.method !== 'link') {
+                try {
+                    const { pm } = this.toolbox;
+                    yield system.run(`cd "${dest}" && ${pm.install(pm.detect(dest))}`);
+                }
+                catch (_a) {
+                    return { method: result.method, path: dest, success: false };
+                }
             }
+            return { method: result.method, path: result.path, success: true };
         });
     }
     /**
@@ -316,7 +322,6 @@ class FrontendHelper {
      */
     convertAppToNpmMode(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
             const { dest, targetVersion } = options;
             const { filesystem } = this.toolbox;
             const path = require('node:path');
@@ -375,13 +380,7 @@ class FrontendHelper {
                     // Remove vendor-specific scripts
                     if (pkg.scripts && typeof pkg.scripts === 'object') {
                         const scripts = pkg.scripts;
-                        delete scripts['check:vendor-freshness'];
-                        // Unhook freshness from check/check:fix/check:naf
-                        for (const scriptName of ['check', 'check:fix', 'check:naf']) {
-                            if ((_a = scripts[scriptName]) === null || _a === void 0 ? void 0 : _a.includes('check:vendor-freshness')) {
-                                scripts[scriptName] = scripts[scriptName].replace(/pnpm run check:vendor-freshness && /g, '');
-                            }
-                        }
+                        (0, check_freshness_hooks_1.unhookCheckFreshness)(scripts);
                     }
                     filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
                 }
@@ -576,18 +575,9 @@ class FrontendHelper {
                             'setTimeout(function(){process.exit(0)},5000)',
                             '"',
                         ].join('');
-                        // Hook freshness into check scripts
-                        const hookFreshness = (scriptName) => {
-                            const existing = scripts[scriptName];
-                            if (!existing)
-                                return;
-                            if (existing.includes('check:vendor-freshness'))
-                                return;
-                            scripts[scriptName] = `pnpm run check:vendor-freshness && ${existing}`;
-                        };
-                        hookFreshness('check');
-                        hookFreshness('check:fix');
-                        hookFreshness('check:naf');
+                        // Hook freshness into the check scripts (targets check:raw, never the
+                        // check.mjs wrapper). See the shared lib helper.
+                        (0, check_freshness_hooks_1.hookCheckFreshness)(scripts);
                     }
                     // Sort dependency maps alphabetically so merged-in entries
                     // (e.g. upstream `@nuxt/kit`) end up in the expected position

package/build/extensions/server.js

@@ -46,6 +46,7 @@ exports.Server = void 0;
 const crypto = __importStar(require("crypto"));
 const path_1 = require("path");
 const ts = __importStar(require("typescript"));
+const check_freshness_hooks_1 = require("../lib/check-freshness-hooks");
 const markdown_table_1 = require("../lib/markdown-table");
 const vendor_claude_md_1 = require("../lib/vendor-claude-md");
 /**
@@ -1005,6 +1006,20 @@ class Server {
                 // Best-effort — if we can't read upstream pkg, the starter's own
                 // deps should still cover most of the framework's needs.
             }
+            // Snapshot the upstream lockfile too. The shallow clone ships
+            // pnpm-lock.yaml, which pins EXACT versions for every transitive
+            // dependency the vendored core imports directly (cron, jose,
+            // fs-capacitor, graphql-ws, ws, …) but that nest-server never declares
+            // as a direct dep. Step 5b below resolves the core's import closure
+            // against this so those packages become direct project deps.
+            let upstreamLockRaw = '';
+            try {
+                upstreamLockRaw = filesystem.read(`${tmpClone}/pnpm-lock.yaml`) || '';
+            }
+            catch (_b) {
+                // Best-effort — without the lockfile, the closure step falls back to
+                // the upstream package.json ranges (still better than nothing).
+            }
             // Snapshot the upstream CLAUDE.md for section-merge into projects/api/CLAUDE.md.
             // The nest-server CLAUDE.md contains framework-specific instructions that
             // Claude Code needs to work correctly with the vendored source (API conventions,
@@ -1017,7 +1032,7 @@ class Server {
                     upstreamClaudeMd = claudeMdContent;
                 }
             }
-            catch (_b) {
+            catch (_c) {
                 // Non-fatal — if missing, the project CLAUDE.md just won't get upstream sections.
             }
             // Snapshot the upstream commit SHA for traceability in VENDOR.md.
@@ -1026,7 +1041,7 @@ class Server {
                 const sha = yield system.run(`git -C ${tmpClone} rev-parse HEAD`);
                 upstreamCommit = (sha || '').trim();
             }
-            catch (_c) {
+            catch (_d) {
                 // Non-fatal — VENDOR.md will just show an empty SHA.
             }
             try {
@@ -1309,7 +1324,7 @@ class Server {
                             }
                         }
                     }
-                    catch (_d) {
+                    catch (_e) {
                         // skip unreadable file
                     }
                 }
@@ -1419,6 +1434,25 @@ class Server {
                             }
                         }
                     }
+                    // ── 5b. Backfill the vendored core's transitive import closure ──
+                    //
+                    // The merge above only covers nest-server's *declared* dependencies.
+                    // The vendored core ALSO imports packages that used to arrive
+                    // transitively through the @lenne.tech/nest-server npm dep
+                    // (cron←@nestjs/schedule, jose←better-auth, fs-capacitor←graphql-upload,
+                    // graphql-ws / ws). Once vendored, those imports are direct, so under
+                    // pnpm's isolated node_modules they are unresolvable unless declared
+                    // as direct deps → TS2307 at build time. Scan the core's bare imports
+                    // and add any missing package (+ matching @types) at the EXACT version
+                    // pinned by the upstream lockfile.
+                    this.gatherVendorCoreImportClosure({
+                        coreDir,
+                        deps,
+                        devDeps,
+                        lockRaw: upstreamLockRaw,
+                        upstreamDeps,
+                        upstreamDevDeps,
+                    });
                     // Add a script to run the local bin/migrate.js. The starter's
                     // existing migrate:* scripts are already correct for npm mode; we
                     // need them pointing at the local bin + local ts-compiler.
@@ -1458,26 +1492,9 @@ class Server {
                             '"',
                         ].join('');
                         // Hook vendor-freshness as the first step of check / check:fix /
-                        // check:naf. Non-blocking (exit 0 even on mismatch), so it just
-                        // surfaces the warning at the top of the log.
-                        const hookFreshness = (scriptName) => {
-                            const existing = scripts[scriptName];
-                            if (!existing)
-                                return;
-                            if (existing.includes('check:vendor-freshness'))
-                                return;
-                            const installPrefix = 'pnpm install && ';
-                            if (existing.startsWith(installPrefix)) {
-                                scripts[scriptName] =
-                                    `${installPrefix}pnpm run check:vendor-freshness && ${existing.slice(installPrefix.length)}`;
-                            }
-                            else {
-                                scripts[scriptName] = `pnpm run check:vendor-freshness && ${existing}`;
-                            }
-                        };
-                        hookFreshness('check');
-                        hookFreshness('check:fix');
-                        hookFreshness('check:naf');
+                        // check:naf (non-blocking; surfaces a warning at the top of the log).
+                        // Targets check:raw — never the check.mjs wrapper. See lib helper.
+                        (0, check_freshness_hooks_1.hookCheckFreshness)(scripts);
                     }
                     filesystem.write(pkgPath, pkg, { jsonIndent: 2 });
                 }
@@ -1708,7 +1725,13 @@ class Server {
             // Scan all consumer files for stale bare-specifier imports that the
             // codemod should have rewritten. A single miss causes a compile error,
             // so catching it here with a clear message saves the user debugging time.
-            const staleImports = this.findStaleImports(dest, '@lenne.tech/nest-server');
+            const staleImports = this.findStaleImports(dest, '@lenne.tech/nest-server', 
+            // Match only real import/export/require specifiers in single/double
+            // quotes — NOT comment references like
+            // `node_modules/@lenne.tech/nest-server/...` (backticks, no keyword),
+            // which the codemod legitimately leaves untouched. A naive substring
+            // match flagged config.env.ts's JSDoc path as a false positive.
+            /(?:from|import|export|require)\s*\(?\s*['"]@lenne\.tech\/nest-server(?:\/[^'"]*)?['"]/);
             if (staleImports.length > 0) {
                 const { print } = this.toolbox;
                 print.warning(`⚠ ${staleImports.length} file(s) still contain '@lenne.tech/nest-server' imports after vendor conversion:`);
@@ -2218,17 +2241,11 @@ class Server {
                 // (they'll come back via node_modules when nest-server is installed)
                 // We only remove deps that are ALSO in nest-server's package.json.
                 // For safety, we don't remove any dep the consumer might use directly.
-                // Remove vendor-specific scripts
+                // Remove vendor-specific scripts + unhook vendor-freshness (see lib helper).
                 const scripts = pkg.scripts || {};
-                delete scripts['check:vendor-freshness'];
                 delete scripts['vendor:sync'];
                 delete scripts['vendor:propose-upstream'];
-                // Unhook vendor-freshness from check / check:fix / check:naf
-                for (const key of ['check', 'check:fix', 'check:naf']) {
-                    if (scripts[key] && typeof scripts[key] === 'string') {
-                        scripts[key] = scripts[key].replace(/pnpm run check:vendor-freshness && /g, '');
-                    }
-                }
+                (0, check_freshness_hooks_1.unhookCheckFreshness)(scripts);
                 // Restore migrate scripts to npm-mode paths
                 const migrateCompiler = 'ts:./node_modules/@lenne.tech/nest-server/dist/core/modules/migrate/helpers/ts-compiler.js';
                 const migrateStore = '--store ./migrations-utils/migrate.js --migrations-dir ./migrations';
@@ -2363,6 +2380,177 @@ class Server {
         }
         return stale;
     }
+    /**
+     * Backfills the vendored core's transitive import closure into the
+     * project's dependencies. After vendoring, `src/core/**` imports packages
+     * that previously arrived transitively via the `@lenne.tech/nest-server`
+     * npm dependency (e.g. `cron`, `jose`, `fs-capacitor`, `graphql-ws`,
+     * `ws`). nest-server never declares these as direct deps, so the
+     * upstream-deps merge misses them — yet the vendored code imports them
+     * directly, which pnpm's isolated node_modules cannot resolve → TS2307 at
+     * build time.
+     *
+     * Scans every `.ts` file under the vendored core for bare import
+     * specifiers, drops Node builtins and already-declared packages, and adds
+     * the remainder (plus any matching `@types/*`) using EXACT versions read
+     * from the upstream `pnpm-lock.yaml`. Mutates `deps`/`devDeps` in place.
+     */
+    gatherVendorCoreImportClosure(options) {
+        const { coreDir, deps, devDeps, lockRaw, upstreamDeps, upstreamDevDeps } = options;
+        const { print } = this.toolbox;
+        const builtins = new Set(require('module').builtinModules);
+        // Compare two dotted versions numerically (major.minor.patch) — used to
+        // pick the highest when the lockfile pins multiple copies (e.g. ws 7/8).
+        const compareVersions = (a, b) => {
+            const pa = a.split('.').map((n) => parseInt(n, 10) || 0);
+            const pb = b.split('.').map((n) => parseInt(n, 10) || 0);
+            for (let i = 0; i < 3; i++) {
+                if ((pa[i] || 0) !== (pb[i] || 0)) {
+                    return (pa[i] || 0) - (pb[i] || 0);
+                }
+            }
+            return 0;
+        };
+        // Parse `<name>@<version>` keys from the lockfile's `packages:` section
+        // into a name→version map (highest version wins). pnpm-lock v9 lists
+        // every package (direct + transitive) there with a clean 2-space indent.
+        const parseLockVersions = (raw) => {
+            const map = {};
+            let inPackages = false;
+            for (const line of raw.split('\n')) {
+                if (/^packages:\s*$/.test(line)) {
+                    inPackages = true;
+                    continue;
+                }
+                if (inPackages && /^\S/.test(line)) {
+                    break; // reached the next top-level section
+                }
+                if (!inPackages) {
+                    continue;
+                }
+                const matched = line.match(/^ {2}(['"]?)(.+?)\1:\s*$/);
+                if (!matched) {
+                    continue;
+                }
+                let key = matched[2] || '';
+                const paren = key.indexOf('('); // strip pnpm peer suffix
+                if (paren >= 0) {
+                    key = key.slice(0, paren);
+                }
+                const at = key.lastIndexOf('@');
+                if (at <= 0) {
+                    continue;
+                }
+                const name = key.slice(0, at);
+                const version = key.slice(at + 1);
+                if (!/^\d/.test(version)) {
+                    continue; // ranges / non-versions
+                }
+                const current = map[name];
+                if (!current || compareVersions(version, current) > 0) {
+                    map[name] = version;
+                }
+            }
+            return map;
+        };
+        // Reduce an import specifier to its package name (or null for relative
+        // paths and Node builtins, which need no dependency entry).
+        const packageNameOf = (spec) => {
+            if (!spec || spec.startsWith('.') || spec.startsWith('/')) {
+                return null;
+            }
+            const bare = spec.startsWith('node:') ? spec.slice('node:'.length) : spec;
+            const parts = bare.split('/');
+            const name = bare.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0] || '';
+            // Drop Node builtins, the framework package itself (never a dependency
+            // of its own vendored code), and anything that is not a syntactically
+            // valid npm package name (defensive guard).
+            if (!name || builtins.has(name) || name === '@lenne.tech/nest-server') {
+                return null;
+            }
+            return /^(?:@[\w.~-]+\/)?[\w.~-]+$/.test(name) ? name : null;
+        };
+        // Collect every bare specifier imported by the vendored core. Parse the
+        // TypeScript AST (ts-morph) rather than scanning text, so that prose in
+        // comments/strings — a JSDoc `import … from '@lenne.tech/nest-server'`
+        // example, or an English `… distinguishable from "never set"` — is never
+        // mistaken for a real import (which a naive regex did).
+        const imported = new Set();
+        const { Project, SyntaxKind } = require('ts-morph');
+        const scanProject = new Project({
+            skipAddingFilesFromTsConfig: true,
+            skipFileDependencyResolution: true,
+        });
+        const sourceFiles = scanProject.addSourceFilesAtPaths(`${coreDir}/**/*.ts`);
+        for (const sourceFile of sourceFiles) {
+            // `import … from 'x'` and `export … from 'x'`
+            for (const decl of [...sourceFile.getImportDeclarations(), ...sourceFile.getExportDeclarations()]) {
+                const spec = decl.getModuleSpecifierValue();
+                const name = spec ? packageNameOf(spec) : null;
+                if (name) {
+                    imported.add(name);
+                }
+            }
+            // `import x = require('x')`
+            for (const decl of sourceFile.getDescendantsOfKind(SyntaxKind.ImportEqualsDeclaration)) {
+                const ref = decl
+                    .getModuleReference()
+                    .getText()
+                    .match(/^require\(\s*['"]([^'"]+)['"]\s*\)$/);
+                const name = ref ? packageNameOf(ref[1] || '') : null;
+                if (name) {
+                    imported.add(name);
+                }
+            }
+            // Dynamic `import('x')` / `require('x')` calls
+            for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+                const callee = call.getExpression().getText();
+                if (callee !== 'import' && callee !== 'require') {
+                    continue;
+                }
+                const arg = call.getArguments()[0];
+                if (arg && arg.getKind() === SyntaxKind.StringLiteral) {
+                    const name = packageNameOf(arg.getLiteralText());
+                    if (name) {
+                        imported.add(name);
+                    }
+                }
+            }
+        }
+        const lockVersions = parseLockVersions(lockRaw);
+        const added = [];
+        const unresolved = [];
+        for (const name of [...imported].sort()) {
+            if (name in deps || name in devDeps) {
+                continue; // already declared by the starter or the upstream merge
+            }
+            const version = lockVersions[name] || upstreamDeps[name] || upstreamDevDeps[name];
+            if (!version) {
+                unresolved.push(name);
+                continue;
+            }
+            deps[name] = version;
+            added.push(`${name}@${version}`);
+            // Add a matching @types/* (for packages that ship no own types) so the
+            // vendored core type-checks. Handles scoped names
+            // (@scope/x → @types/scope__x) too.
+            const typesName = name.startsWith('@') ? `@types/${name.slice(1).replace('/', '__')}` : `@types/${name}`;
+            if (!(typesName in deps) && !(typesName in devDeps)) {
+                const typesVersion = lockVersions[typesName] || upstreamDevDeps[typesName];
+                if (typesVersion) {
+                    devDeps[typesName] = typesVersion;
+                }
+            }
+        }
+        if (added.length > 0) {
+            print.info(`  vendored core closure: added ${added.length} transitive dep(s) → ${added.join(', ')}`);
+        }
+        if (unresolved.length > 0) {
+            print.warning(`⚠ ${unresolved.length} vendored-core import(s) could not be resolved to a version ` +
+                `(absent from the upstream lock and package.json): ${unresolved.join(', ')}. ` +
+                'Add them to projects/api/package.json manually if the build fails.');
+        }
+    }
     /**
      * Checks whether an import specifier resolves to the vendored core directory.
      * Used during vendor→npm import rewriting.

package/build/lib/check-freshness-hooks.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Helpers for (un)hooking the vendor-freshness step in a project's `check`
+ * scripts during vendor-mode conversion. Extracted so the logic is unit-tested
+ * (server.ts + frontend-helper.ts call these instead of inline closures).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hookCheckFreshness = hookCheckFreshness;
+exports.unhookCheckFreshness = unhookCheckFreshness;
+const WRAPPER_HINT = 'check.mjs';
+const FRESHNESS_STEP = 'pnpm run check:vendor-freshness';
+const INSTALL_PREFIX = 'pnpm install && ';
+/**
+ * Prepend the `check:vendor-freshness` step to the relevant check scripts.
+ *
+ * - Skips a script that already includes the step (idempotent) or that IS the
+ *   `node scripts/check.mjs` wrapper (the wrapper only orchestrates the real
+ *   chain — vendor-freshness belongs in that chain).
+ * - Targets `check:raw` instead of `check` when the project runs the wrapper,
+ *   so freshness becomes a step the wrapper executes.
+ * - Preserves a leading `pnpm install && ` so install stays first.
+ *
+ * Assumes the caller has already defined `scripts['check:vendor-freshness']`.
+ * Mutates `scripts` in place.
+ */
+function hookCheckFreshness(scripts) {
+    const hook = (name) => {
+        const existing = scripts[name];
+        if (!existing || existing.includes('check:vendor-freshness') || existing.includes(WRAPPER_HINT)) {
+            return;
+        }
+        scripts[name] = existing.startsWith(INSTALL_PREFIX)
+            ? `${INSTALL_PREFIX}${FRESHNESS_STEP} && ${existing.slice(INSTALL_PREFIX.length)}`
+            : `${FRESHNESS_STEP} && ${existing}`;
+    };
+    // Prefer the raw chain when the project runs the check.mjs wrapper.
+    hook(scripts['check:raw'] ? 'check:raw' : 'check');
+    hook('check:fix');
+    hook('check:naf');
+}
+/**
+ * Remove the vendor-freshness step (and its script) from a project's check
+ * scripts — the inverse of {@link hookCheckFreshness}, used when converting a
+ * project back to npm mode. Mutates `scripts` in place.
+ */
+function unhookCheckFreshness(scripts) {
+    delete scripts['check:vendor-freshness'];
+    for (const name of ['check', 'check:raw', 'check:fix', 'check:naf']) {
+        if (typeof scripts[name] === 'string') {
+            scripts[name] = scripts[name].replace(/pnpm run check:vendor-freshness && /g, '');
+        }
+    }
+}

package/build/lib/codex-cli.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CODEX_MARKETPLACE_ROOT = void 0;
+exports.findCodexCli = findCodexCli;
+exports.runCodexCommand = runCodexCommand;
+/**
+ * Codex CLI utilities.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+exports.DEFAULT_CODEX_MARKETPLACE_ROOT = process.env.LT_CODEX_MARKETPLACE_ROOT || '/Users/kaihaase/code/lenneTech/codex';
+function findCodexCli() {
+    const possiblePaths = [
+        (0, path_1.join)((0, os_1.homedir)(), '.local', 'bin', 'codex'),
+        (0, path_1.join)((0, os_1.homedir)(), '.codex', 'bin', 'codex'),
+        '/usr/local/bin/codex',
+        '/opt/homebrew/bin/codex',
+        '/usr/bin/codex',
+    ];
+    for (const path of possiblePaths) {
+        if ((0, fs_1.existsSync)(path)) {
+            return path;
+        }
+    }
+    try {
+        const result = (0, child_process_1.spawnSync)('which', ['codex'], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const path = (result.stdout || '').trim();
+        if (result.status === 0 && path && (0, fs_1.existsSync)(path)) {
+            return path;
+        }
+    }
+    catch (_a) {
+        // Codex CLI not found in PATH.
+    }
+    return null;
+}
+function runCodexCommand(cli, args) {
+    try {
+        const result = (0, child_process_1.spawnSync)(cli, args, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return {
+            output: result.stdout + result.stderr,
+            success: result.status === 0,
+        };
+    }
+    catch (err) {
+        return {
+            output: err.message,
+            success: false,
+        };
+    }
+}