@omega.js/desktop 0.50.0 → 0.52.0

package/dist/vendor/devkit/local.js

@@ -261,6 +261,33 @@ function relativeSpecPath(fromDir, target) {
   return path.relative(fs.realpathSync(fromDir), fs.realpathSync(target)).split(path.sep).join('/');
 }
 
+/**
+ * Regenerate the install root's OWN lockfile after a flip (#938): inside the
+ * omega monorepo the tree install climbs to the monorepo root and writes that
+ * lockfile, so the brand's would stay stale. Loaded here rather than at the top:
+ * this module runs at every CLI boot (freshnessBoot), and the lockfile read
+ * pulls in @omega.js/config, which the boot has no use for.
+ * @param {string} installRoot - The brand root (or standalone target).
+ * @param {object} [logger] - Logger with log (silent when omitted).
+ * @returns {Promise<void>}
+ */
+function regenerateBrandLockfile(installRoot, logger) {
+  const { regenerateLockfile } = require('./lockfile.js');
+  return regenerateLockfile({ root: installRoot, log: logger ? (line) => logger.log(line) : undefined });
+}
+
+/**
+ * Whether the install root's lockfile is missing or disagrees with its
+ * manifests' @omega.js registry specs: the deploy gate's own read (#938).
+ * @param {string} installRoot - The brand root (or standalone target).
+ * @returns {boolean}
+ */
+function brandLockfileStale(installRoot) {
+  const { brandLockfileDrift } = require('./brand-version.js');
+  const { lock, drift } = brandLockfileDrift({ root: installRoot });
+  return !lock || drift.length > 0;
+}
+
 /**
  * file:-install a brand's @omega.js dependencies from the local monorepo.
  *
@@ -275,7 +302,8 @@ function relativeSpecPath(fromDir, target) {
  * targets degenerate to themselves.
  *
  * Idempotent: dependencies already resolving to the monorepo copy are
- * skipped, and when nothing needs linking no install runs.
+ * skipped, and when nothing needs linking no install runs. An install is
+ * followed by the brand's OWN lockfile regeneration (#938).
  * @param {object} options
  * @param {string} options.dir - Target directory to link from (any target in the brand).
  * @param {string} options.monorepoRoot - Monorepo root path.
@@ -347,6 +375,11 @@ async function linkLocalPackages(options) {
       logger && logger.warn(`install failed — restored ${manifestBackups.size} manifest(s) to their pre-link specs`);
       throw error;
     }
+
+    // Outside the rollback: the install succeeded, so the manifests and the
+    // tree already agree, and restoring the manifests now would split them.
+    // A failed regeneration puts the lock back itself and throws as what it is.
+    await regenerateBrandLockfile(installRoot, logger);
   }
 
   return actions;
@@ -364,7 +397,9 @@ async function linkLocalPackages(options) {
  * @omega.js/client in one brand. An explicit `range` still wins verbatim — the
  * caller owns that string. Idempotent: registry-spec'd entries are untouched;
  * nothing to flip → no install. Same transactional manifest restore as the
- * linker when the install fails.
+ * linker when the install fails. Either way the brand's OWN lockfile ends up
+ * agreeing with the manifests (#938): regenerated after the install, and
+ * regenerated alone when nothing flipped but the lock still disagrees.
  * @param {object} options
  * @param {string} options.dir - Any directory inside the brand.
  * @param {object} [options.logger] - Logger with log/warn (silent when omitted).
@@ -416,7 +451,11 @@ async function restoreRegistrySpecs(options) {
     }
   }
 
-  if (installNeeded && !dryRun) {
+  if (dryRun) {
+    return actions;
+  }
+
+  if (installNeeded) {
     try {
       await safeInstall('npm install', { log: true, config: { cwd: installRoot } });
     } catch (error) {
@@ -426,6 +465,15 @@ async function restoreRegistrySpecs(options) {
       logger && logger.warn(`install failed — restored ${manifestBackups.size} manifest(s) to their file: specs`);
       throw error;
     }
+
+    // Outside the rollback, as in linkLocalPackages: the flipped manifests and
+    // the installed tree agree, so only the lock is left to heal.
+    await regenerateBrandLockfile(installRoot, logger);
+  } else if (brandLockfileStale(installRoot)) {
+    // Nothing to flip, but the lock still disagrees (the specs were flipped
+    // before the lock was ever regenerated): this verb is the fix the deploy's
+    // lockfile gate names, so it heals the lock here too (#938).
+    await regenerateBrandLockfile(installRoot, logger);
   }
 
   return actions;
@@ -1548,6 +1596,34 @@ function healFailedMessage(result) {
   ].join('\n');
 }
 
+/**
+ * Leave the #350 prepare gate wired on a package this process just prepared
+ * ([#870](https://github.com/Omega-JS-Stack/omega/issues/870)). prepare-package
+ * rewrites `scripts.prepare` to its own UNGUARDED string on the way through, and
+ * a heal that left it there hands a consumer install the door back. The prepare
+ * script restores it in a `finally`, so this is the net for the case a finally
+ * cannot reach: a prepare killed outright, or one that never ran the gate at all.
+ * The guard is loaded from the devkit BESIDE the prepared package, the same hop
+ * the gated script's own relative require makes, and its path is built at runtime
+ * rather than written as a literal specifier, because devkit's vendored copies
+ * carry `src/` only and a relative require of `tools/` would send the vendor walk
+ * outside the module root.
+ * @param {object} options
+ * @param {string} options.monorepoRoot - The monorepo containing the package.
+ * @param {string} options.packageDir - The package that was prepared.
+ * @returns {boolean} Whether the manifest holds the gate now (true when the
+ *   checkout carries no guard to enforce).
+ */
+function keepPrepareGuarded(options) {
+  const { monorepoRoot, packageDir } = options;
+  const guardPath = path.join(monorepoRoot, 'packages', 'devkit', 'tools', 'prepare-guard.js');
+  if (!fs.existsSync(guardPath)) {
+    return true;
+  }
+
+  return require(guardPath).ensureGuarded({ packageDir }).guarded;
+}
+
 /**
  * Check that a locally-linked framework's dist is at least as new as its src —
  * reporting or rebuilding it when a src edit landed without a prepare, so
@@ -1661,6 +1737,10 @@ function ensureFreshLocalDist(options) {
       stdio: 'inherit',
       shell: process.platform === 'win32',
     });
+
+    // Whatever that prepare did, it does not get to leave the gate off (#870)
+    const guarded = inMonorepo ? keepPrepareGuarded({ monorepoRoot, packageDir: realDir }) : true;
+
     if (result.status !== 0) {
       const failure = `npm run prepare exited ${result.status === null ? String(result.error && result.error.message || 'spawn error') : result.status}`;
       if (inMonorepo) {
@@ -1671,6 +1751,21 @@ function ensureFreshLocalDist(options) {
       console.warn(`omega: rebuild failed (${failure} in ${realDir}) — continuing on the stale dist`);
       return { status: 'rebuild-failed', packageName, dir: realDir };
     }
+
+    // A prepare that ended with the gate off hands a consumer install the #350
+    // door back, so a heal that could not put it back is a FAILED heal like any
+    // other: the boot stops on it rather than running on an ungated package.
+    if (!guarded) {
+      return {
+        status: 'heal-failed',
+        packageName,
+        dir: realDir,
+        reason,
+        failure: 'npm run prepare left scripts.prepare off the #350 gate',
+        monorepoRoot,
+      };
+    }
+
     return { status: 'rebuilt', by: 'self', packageName, dir: realDir };
   });
 }

package/dist/vendor/devkit/lockfile.js

@@ -0,0 +1,127 @@
+/**
+ * lockfile: regenerate an install root's OWN package-lock.json
+ * ([#938](https://github.com/Omega-JS-Stack/omega/issues/938)).
+ *
+ * ONE helper for its three callers: the pack step (`pack-local`, the staged
+ * shape), `omega i local` (`linkLocalPackages`) and `omega i live`
+ * (`restoreRegistrySpecs`).
+ *
+ * Two things a plain `npm install` gets wrong here, and this answers both:
+ *   - `--prefix` makes npm treat `root` as the install root. Without it, npm in
+ *     a directory that is itself a WORKSPACE of an outer root (every in-repo
+ *     brand, under the omega monorepo's `brands/*`) climbs to that outer root
+ *     and writes ITS lockfile, leaving the brand's own untouched.
+ *   - npm KEEPS a locked link whose target's version satisfies a registry spec,
+ *     so a lock from the local era (`link: true` into a checkout already at the
+ *     published number) would survive the flip. Every @omega.js entry the
+ *     deploy gate would refuse (`brandLockfileDrift`) is dropped first, with its
+ *     link target, so npm resolves those afresh and keeps every other pin.
+ *   - npm also honors a STALE path entry, a folder the lock names that is no
+ *     longer on disk (a renamed target), and re-creates whatever link its
+ *     dependencies declare. Those entries go first, with everything under them
+ *     and every `node_modules/` link pointing into them.
+ *
+ * Transactional: a failed npm run writes the lock back byte for byte.
+ */
+const fs = require('fs');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+
+const { safeInstall } = require('./safe-install.js');
+const { brandLockfileDrift, staleLockPaths } = require('./brand-version.js');
+
+/** A path equal to base, or nested beneath it. */
+const under = (value, base) => value === base || value.startsWith(`${base}/`);
+
+/**
+ * Drop every stale path entry (`staleLockPaths`), everything nested under it,
+ * and every `node_modules/` entry whose `resolved` points into it.
+ *
+ * @param {object} lock - The parsed lock (mutated).
+ * @param {string} root - The install root the keys are relative to.
+ * @returns {string[]} The stale paths dropped (the outermost of each tree).
+ */
+function dropStalePaths(lock, root) {
+  const stale = staleLockPaths({ root, packages: lock.packages });
+  const outermost = stale.filter((key) => !stale.some((other) => other !== key && under(key, other)));
+
+  for (const [key, entry] of Object.entries(lock.packages)) {
+    const pointsInto = entry && typeof entry.resolved === 'string' && outermost.some((base) => under(entry.resolved, base));
+    if (outermost.some((base) => under(key, base)) || pointsInto) delete lock.packages[key];
+  }
+
+  return outermost;
+}
+
+/**
+ * Drop every lock entry `drift` names, plus a dropped link's target entry and
+ * everything nested under it (the checkout's own dependencies).
+ *
+ * @param {object} lock - The parsed lock (mutated).
+ * @param {Array<{ key: string|null, entry: object|undefined }>} drift - What the gate refused.
+ * @returns {string[]} The names whose entries were dropped.
+ */
+function dropDrift(lock, drift) {
+  const dropped = [];
+
+  for (const { name, key, entry } of drift) {
+    // An absent entry has nothing to drop (npm adds it from the manifest), and
+    // one inside a stale path is already gone with it.
+    if (!key || !lock.packages[key]) continue;
+
+    delete lock.packages[key];
+    dropped.push(name);
+
+    if (entry.link && entry.resolved) {
+      for (const other of Object.keys(lock.packages)) {
+        if (under(other, entry.resolved)) delete lock.packages[other];
+      }
+    }
+  }
+
+  return dropped;
+}
+
+/**
+ * Regenerate `root`'s package-lock.json from its manifests, lock-only: no
+ * scripts, no node_modules writes.
+ *
+ * @param {object} options
+ * @param {string} options.root - The install root whose lock is regenerated.
+ * @param {function} [options.log] - Line sink (silent when omitted).
+ * @returns {Promise<void>}
+ */
+async function regenerateLockfile({ root, log }) {
+  const { lockPath, lock, drift } = brandLockfileDrift({ root });
+  const original = lock ? jetpack.read(lockPath) : null;
+
+  if (lock && lock.packages) {
+    const pruned = dropStalePaths(lock, root);
+    const dropped = dropDrift(lock, drift);
+
+    if (pruned.length || dropped.length) {
+      jetpack.write(lockPath, `${JSON.stringify(lock, null, 2)}\n`);
+    }
+    if (log && pruned.length) log(`Pruned the lock entries of folders no longer on disk (${pruned.join(', ')}) so npm stops honoring what they declare`);
+    if (log && dropped.length) log(`Dropped the stale lock entries of ${dropped.join(', ')} so npm resolves them from the manifests`);
+  }
+
+  if (log) log(`Regenerating ${path.basename(root)}/package-lock.json...`);
+
+  // The REAL path: npm writes a link's `resolved` relative to the physical
+  // directory, so a prefix spelled through an alias (macOS /var for
+  // /private/var, a symlinked brand dir) reads those paths from the wrong place.
+  const prefix = fs.realpathSync(root);
+
+  try {
+    await safeInstall(
+      `npm install --package-lock-only --ignore-scripts --no-audit --no-fund --prefix "${prefix}"`,
+      { log: false, config: { cwd: prefix } },
+    );
+  } catch (error) {
+    if (original !== null) jetpack.write(lockPath, original);
+    throw error;
+  }
+}
+
+module.exports = { regenerateLockfile };

package/dist/vendor/devkit/merge-line-files.js

@@ -23,8 +23,16 @@
 //   - The Default section is replaced with the new framework's defaults.
 //   - Keys that already had values (in either Default or Custom) keep those values
 //     in the same section they were in.
-//   - Keys the user added to the Default section that are NOT in the new framework's
-//     defaults migrate to the Custom section (so framework cleanups don't lose user data).
+//   - The Default section is COMPLETELY managed ([#926](https://github.com/Omega-JS-Stack/omega/issues/926)):
+//     a line the new framework block no longer carries LEAVES the consumer, so a
+//     rule the framework retires or rewrites actually takes effect everywhere. A
+//     retired framework line and a line a user typed inside the framework block
+//     cannot be told apart, and the block header already says it is overwritten on
+//     every setup, so `.gitignore` and `AGENTS.md` drop it. Lines a user owns
+//     belong under the Custom marker, which stays verbatim.
+//   - .env is the one exception: a retired key holding a NON-EMPTY value migrates
+//     to the Custom section (that value is data, not a rule), while an empty
+//     retired key (`KEY=` / `KEY=""`) drops like any other retired line.
 //   - .env values are normalized to **double-quoted** form on every merge:
 //       KEY=raw-value         →   KEY="raw-value"
 //       KEY="already-quoted"  →   KEY="already-quoted"  (left alone)
@@ -110,24 +118,23 @@ function mergeLineBasedFiles(existingContent, newContent, fileName) {
     }
   }
 
-  // User-added stuff in their Default section that the new framework doesn't know about
-  // → migrate to Custom so it's preserved without being clobbered next setup.
+  // Anything in the existing Default section the new framework block no longer
+  // carries. The block is COMPLETELY managed (#926), so it DROPS: a retired
+  // framework line and a line the user typed into the framework block cannot be
+  // told apart, and the block header already says it is overwritten on every
+  // setup. The one exception is an .env key holding a real value, which is the
+  // user's DATA rather than a rule, so it migrates down to Custom; an empty one
+  // drops with the rest. .gitignore and AGENTS.md migrate nothing.
   const migratedToCustom = [];
-  for (const line of existingDefault) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
+  if (isEnvFile) {
+    for (const line of existingDefault) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
 
-    if (isEnvFile) {
       const key = trimmed.split('=')[0].trim();
-      if (key && !newDefaultKeys.has(key) && !existingCustomKeys.has(key)) {
+      if (key && !newDefaultKeys.has(key) && !existingCustomKeys.has(key) && !envValueIsEmpty(trimmed)) {
         migratedToCustom.push(normalizeEnvLine(line));
       }
-    } else {
-      // .gitignore: line not in new defaults → migrate.
-      const inNew = newLines.some((nl) => nl.trim() === trimmed);
-      if (!inNew) {
-        migratedToCustom.push(line);
-      }
     }
   }
 
@@ -186,7 +193,7 @@ function normalizeEnvLine(line) {
   if (eqIdx < 0) return line; // no `=` — not a KEY=VALUE line
 
   const key = trimmed.slice(0, eqIdx).trim();
-  let value = trimmed.slice(eqIdx + 1);
+  const value = trimmed.slice(eqIdx + 1);
 
   // Strip trailing whitespace + inline comment-after-value (rare; we only strip a # that follows a space).
   // We do NOT strip # inside quoted values. Detect that by checking if value starts with a quote.

package/dist/vendor/devkit/omega-bin.js

@@ -253,9 +253,10 @@ async function run({ hostName, hostRun, argv = process.argv.slice(2) }) {
   const target = findTarget(process.cwd());
 
   // No context — the bootstrap case (a verb run in a fresh directory has
-  // no framework dep yet, by definition). Run the HOST framework's CLI, exactly
-  // like the pre-dispatcher bins did, and say which one so a hoist-winner at a
-  // brand root is never a silent mystery.
+  // no framework dep yet, by definition). Run the INSTALLED @omega.js/manager
+  // when one resolves, else the HOST framework's CLI exactly like the
+  // pre-dispatcher bins did, and say which one so a hoist-winner at a brand
+  // root is never a silent mystery.
   if (!target) {
     // …but ONLY for a verb that cannot write. The fallback hands a mutating verb
     // to whichever framework won npm's bin link, and that verb scaffolds its own
@@ -279,6 +280,20 @@ async function run({ hostName, hostRun, argv = process.argv.slice(2) }) {
       process.exit(1);
     }
 
+    // The manager wins a contextless run whenever the install carries one: the
+    // verbs that survive the refusal above are the ones that run where no
+    // target exists yet (onboard, create, new), and those are the manager's own.
+    // Without this, a fresh brand-template clone that installed ONLY
+    // @omega.js/manager still ran the backend, because the manager DEPENDS on
+    // the backend and npm's arbitrary hoist winner linked the backend's bin:
+    // `npx omega onboard` answered `Unknown command`
+    // ([#908](https://github.com/Omega-JS-Stack/omega/issues/908)).
+    const manager = tryResolveCli(MANAGER, process.cwd());
+    if (manager.cliPath) {
+      console.error(`omega: no target context found from ${process.cwd()}: running ${MANAGER}`);
+      return require(manager.cliPath).run();
+    }
+
     console.error(`omega: no target context found from ${process.cwd()} — running ${hostName}`);
     return hostRun();
   }