@lenne.tech/cli 1.25.0 → 1.26.0

package/build/commands/dev/up.js

@@ -40,13 +40,48 @@ const dev_state_1 = require("../../lib/dev-state");
  *   NSC__MONGOOSE__URI, NSC__BASE_URL, NSC__APP_URL, DATABASE_URL,
  *   NUXT_PUBLIC_API_PROXY=false (Caddy makes vite-proxy obsolete).
  */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}
+function formatRotationNote(label, archivePath, previousSize) {
+    const size = formatBytes(previousSize);
+    const huge = previousSize > 100 * 1024 * 1024 ? ' (large — consider fixing noisy warnings)' : '';
+    return `Rotated previous ${label} log → ${archivePath} (${size})${huge}`;
+}
+/**
+ * Print the project's bound URLs (app, api, db) as a small info block.
+ *
+ * Used in two places so the user always sees the URLs next to the PIDs —
+ * once after a successful `up` and once when `up` short-circuits on
+ * "Already running". Falls back gracefully when only one of api/app is
+ * present (single-side projects).
+ */
+function printProjectUrls(info, options) {
+    if (options.appHostname) {
+        const arrow = options.appUpstreamPort ? `  →  127.0.0.1:${options.appUpstreamPort}` : '';
+        info(`  app: https://${options.appHostname}${arrow}`);
+    }
+    if (options.apiHostname) {
+        const arrow = options.apiUpstreamPort ? `  →  127.0.0.1:${options.apiUpstreamPort}` : '';
+        info(`  api: https://${options.apiHostname}${arrow}`);
+    }
+    if (options.dbName) {
+        info(`  db:  mongodb://127.0.0.1/${options.dbName}`);
+    }
+}
 const UpCommand = {
     alias: ['u'],
     description: 'Start API + App behind Caddy',
     hidden: false,
     name: 'up',
     run: (toolbox) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         const { filesystem, parameters, print: { colors, error, info, success, warning }, } = toolbox;
         const layout = (0, dev_project_1.resolveLayout)(filesystem.cwd(), filesystem);
         if (!layout.apiDir && !layout.appDir) {
@@ -110,6 +145,17 @@ const UpCommand = {
             const appUp = existingSession.pids.app ? (0, dev_state_1.isPidAlive)(existingSession.pids.app) : false;
             if (apiUp || appUp) {
                 warning(`Already running (api pid ${(_a = existingSession.pids.api) !== null && _a !== void 0 ? _a : '-'}, app pid ${(_b = existingSession.pids.app) !== null && _b !== void 0 ? _b : '-'}).`);
+                // Surface the bound URLs so the user can copy them out without having
+                // to look up `lt dev status` separately. Falls back to the in-process
+                // identity/registry data — both sources stay in sync via saveRegistry.
+                const existingEntry = (0, dev_state_1.loadRegistry)().projects[identity.slug];
+                printProjectUrls(info, {
+                    apiHostname: (_c = identity.subdomains.api) === null || _c === void 0 ? void 0 : _c.hostname,
+                    apiUpstreamPort: existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.internalPorts.api,
+                    appHostname: (_d = identity.subdomains.app) === null || _d === void 0 ? void 0 : _d.hostname,
+                    appUpstreamPort: existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.internalPorts.app,
+                    dbName: (_e = existingEntry === null || existingEntry === void 0 ? void 0 : existingEntry.dbName) !== null && _e !== void 0 ? _e : (0, dev_project_1.deriveDbName)(layout.apiDir, identity.slug),
+                });
                 info('Run `lt dev down` first.');
                 if (!parameters.options.fromGluegunMenu)
                     process.exit(1);
@@ -120,10 +166,10 @@ const UpCommand = {
         const reg = (0, dev_state_1.loadRegistry)();
         const entry = reg.projects[identity.slug];
         const taken = (0, dev_state_1.takenInternalPorts)(reg, identity.slug);
-        const apiPort = (_c = entry === null || entry === void 0 ? void 0 : entry.internalPorts.api) !== null && _c !== void 0 ? _c : (layout.apiDir ? (0, dev_state_1.allocateInternalPort)(4000, taken) : undefined);
+        const apiPort = (_f = entry === null || entry === void 0 ? void 0 : entry.internalPorts.api) !== null && _f !== void 0 ? _f : (layout.apiDir ? (0, dev_state_1.allocateInternalPort)(4000, taken) : undefined);
         if (apiPort)
             taken.add(apiPort);
-        const appPort = (_d = entry === null || entry === void 0 ? void 0 : entry.internalPorts.app) !== null && _d !== void 0 ? _d : (layout.appDir ? (0, dev_state_1.allocateInternalPort)(4000, taken) : undefined);
+        const appPort = (_g = entry === null || entry === void 0 ? void 0 : entry.internalPorts.app) !== null && _g !== void 0 ? _g : (layout.appDir ? (0, dev_state_1.allocateInternalPort)(4000, taken) : undefined);
         // Pre-flight: internal ports free?
         const portsToCheck = [apiPort, appPort].filter((p) => typeof p === 'number');
         const snap = yield (0, dev_process_1.listenSnapshot)(portsToCheck);
@@ -174,23 +220,32 @@ const UpCommand = {
         });
         const pnpmBin = process.env.LT_PNPM_BIN || 'pnpm';
         const pids = {};
+        const rotationNotes = [];
         if (layout.apiDir && (0, fs_1.existsSync)((0, path_1.join)(layout.apiDir, 'package.json')) && apiPort) {
-            const apiPid = (0, dev_process_1.spawnDetached)(pnpmBin, ['start'], {
+            const apiResult = (0, dev_process_1.spawnDetached)(pnpmBin, ['start'], {
                 cwd: layout.apiDir,
                 env: devEnv.api.env,
                 logFile: (0, path_1.join)(layout.root, '.lt-dev', 'api.log'),
             });
-            if (apiPid)
-                pids.api = apiPid;
+            if (apiResult) {
+                pids.api = apiResult.pid;
+                if (apiResult.rotated.rotated && apiResult.rotated.archivePath !== undefined) {
+                    rotationNotes.push(formatRotationNote('api', apiResult.rotated.archivePath, (_h = apiResult.rotated.previousSize) !== null && _h !== void 0 ? _h : 0));
+                }
+            }
         }
         if (layout.appDir && (0, fs_1.existsSync)((0, path_1.join)(layout.appDir, 'package.json')) && appPort) {
-            const appPid = (0, dev_process_1.spawnDetached)(pnpmBin, ['dev'], {
+            const appResult = (0, dev_process_1.spawnDetached)(pnpmBin, ['dev'], {
                 cwd: layout.appDir,
                 env: devEnv.app.env,
                 logFile: (0, path_1.join)(layout.root, '.lt-dev', 'app.log'),
             });
-            if (appPid)
-                pids.app = appPid;
+            if (appResult) {
+                pids.app = appResult.pid;
+                if (appResult.rotated.rotated && appResult.rotated.archivePath !== undefined) {
+                    rotationNotes.push(formatRotationNote('app', appResult.rotated.archivePath, (_j = appResult.rotated.previousSize) !== null && _j !== void 0 ? _j : 0));
+                }
+            }
         }
         // Persist.
         const subdomainMap = {};
@@ -209,8 +264,20 @@ const UpCommand = {
         // custom shell scripts) can pick up the URLs without inheriting our shell.
         const bridgePath = (0, dev_env_bridge_1.writeEnvBridge)(layout.root, devEnv, dbName);
         info(colors.dim(`ENV bridge: ${bridgePath}`));
-        success(`Started: api pid=${(_e = pids.api) !== null && _e !== void 0 ? _e : '-'}, app pid=${(_f = pids.app) !== null && _f !== void 0 ? _f : '-'}`);
+        success(`Started: api pid=${(_k = pids.api) !== null && _k !== void 0 ? _k : '-'}, app pid=${(_l = pids.app) !== null && _l !== void 0 ? _l : '-'}`);
+        // Echo the bound URLs next to the PIDs as well — the "Starting" block
+        // prints them before the spawn, but on a long boot log they scroll out
+        // of view, so repeating them here keeps PID + URL visually grouped.
+        printProjectUrls(info, {
+            apiHostname: (_m = identity.subdomains.api) === null || _m === void 0 ? void 0 : _m.hostname,
+            apiUpstreamPort: apiPort,
+            appHostname: (_o = identity.subdomains.app) === null || _o === void 0 ? void 0 : _o.hostname,
+            appUpstreamPort: appPort,
+            dbName,
+        });
         info(colors.dim('Logs: <root>/.lt-dev/api.log, <root>/.lt-dev/app.log'));
+        for (const note of rotationNotes)
+            info(colors.dim(note));
         info(colors.dim('Stop with: lt dev down'));
         // Best-effort: kill orphaned children if neither spawned (unlikely, but tidy).
         if (Object.keys(pids).length === 0) {

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

@@ -11,11 +11,13 @@ exports.runMigrate = runMigrate;
  * 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.
@@ -32,6 +34,9 @@ function printMigrateResult(toolbox, result) {
         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)
@@ -60,6 +65,17 @@ function printMigrateResult(toolbox, result) {
  */
 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).
@@ -106,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,
@@ -115,5 +131,6 @@ function runMigrate(input) {
         dbName,
         identity,
         registryUpdated: registryChanged,
+        renamedTemplatePackage,
     };
 }

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;

package/build/lib/package-name.js

@@ -1,6 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnmodifiedTemplateName = isUnmodifiedTemplateName;
+exports.renameUnmodifiedTemplatePackage = renameUnmodifiedTemplatePackage;
 exports.setPackageName = setPackageName;
+const path_1 = require("path");
+const dev_identity_1 = require("./dev-identity");
+/**
+ * package.json `name` values that are unchanged starter-template defaults.
+ *
+ * When a user clones a template manually (`git clone lenneTech/lt-monorepo
+ * my-project`) instead of running `lt fullstack init`, the `name` field
+ * stays at the template's default. That field is what
+ * `dev-identity#projectSlug` reads to derive `<slug>.localhost`, so every
+ * cloned project would collide on `https://lt-monorepo.localhost`.
+ *
+ * `lt fullstack init` rewrites this field already (see `setPackageName`);
+ * the detection here is the safety net for projects that bypassed init.
+ */
+const UNMODIFIED_TEMPLATE_NAMES = new Set(['lt-monorepo']);
+/**
+ * True when `name` matches a known unmodified starter template default.
+ */
+function isUnmodifiedTemplateName(name) {
+    return typeof name === 'string' && UNMODIFIED_TEMPLATE_NAMES.has(name);
+}
+/**
+ * If the package.json at `<projectRoot>/package.json` still carries an
+ * unmodified starter-template `name` (e.g. `lt-monorepo` from a raw
+ * `git clone`), rewrite it to the directory basename — which is what the
+ * user actually called their project when they cloned the folder.
+ *
+ * Returns the new name if a rewrite happened, `null` otherwise. Reasons
+ * for `null`: missing/unreadable package.json, name already custom, or the
+ * directory basename itself is in the deny list (pathological case of a
+ * fresh clone into a literal `lt-monorepo` folder — leaving the file
+ * untouched is correct behaviour there).
+ *
+ * Idempotent — safe to call from every `lt dev init` invocation.
+ */
+function renameUnmodifiedTemplatePackage(options) {
+    const { filesystem, projectRoot } = options;
+    const packageJsonPath = filesystem.path(projectRoot, 'package.json');
+    if (!filesystem.exists(packageJsonPath))
+        return null;
+    const pkg = filesystem.read(packageJsonPath, 'json');
+    if (!pkg || typeof pkg !== 'object' || Array.isArray(pkg))
+        return null;
+    const currentName = typeof pkg.name === 'string' ? pkg.name : null;
+    if (!isUnmodifiedTemplateName(currentName))
+        return null;
+    // Slugify the directory basename: npm names must be lowercase and
+    // URL-safe, and this keeps the rewritten value consistent with what
+    // `lt fullstack init` writes (which kebab-cases its --name arg) and
+    // with `dev-identity#projectSlug` (which slugifies whatever it reads
+    // back). Anything else would produce a slug mismatch between
+    // package.json and `<slug>.localhost`.
+    const derived = (0, dev_identity_1.slugify)((0, path_1.basename)(projectRoot));
+    if (!derived || isUnmodifiedTemplateName(derived))
+        return null;
+    const written = setPackageName({ filesystem, name: derived, packageJsonPath });
+    return written ? derived : null;
+}
 /**
  * Set the `name` field of a package.json on disk.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/cli",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "lenne.Tech CLI: lt",
   "keywords": [
     "lenne.Tech",