@omega.js/desktop 0.53.0 → 0.54.1

package/dist/vendor/devkit/local.js

@@ -16,9 +16,9 @@
  *   into the monorepo is read-only and stops the boot loudly, any other local
  *   checkout is rebuilt and the invocation re-execs once
  *
- * Consumers: `omega dev --local` (@omega.js/web), `mgr i local`
- * (@omega.js/backend, @omega.js/desktop, @omega.js/extension), and the monorepo's
- * own scripts/watch-all.js (lock helpers + vendor propagation).
+ * Consumers: `omega dev --local` (@omega.js/web), @omega.js/manager's
+ * brand-root `omega i local` / `omega i live` (src/commands/install.js), and the
+ * monorepo's own scripts/watch-all.js (lock helpers + vendor propagation).
  */
 
 // Libraries
@@ -276,6 +276,43 @@ function regenerateBrandLockfile(installRoot, logger) {
   return regenerateLockfile({ root: installRoot, log: logger ? (line) => logger.log(line) : undefined });
 }
 
+/**
+ * Prune the install root's lockfile before a tree install (#862): npm's install
+ * honors a locked link just as its lock-only run does. Loaded lazily, as above.
+ * @param {string} installRoot - The brand root (or standalone target).
+ * @param {object} [logger] - Logger with log (silent when omitted).
+ */
+function pruneBrandLockfile(installRoot, logger) {
+  const { pruneLockfile } = require('./lockfile.js');
+  pruneLockfile({ root: installRoot, log: logger ? (line) => logger.log(line) : undefined });
+}
+
+/**
+ * Throw when any @omega.js package of the tree still resolves into a checkout
+ * (#862): a symlink under the install root's or any target's node_modules, or
+ * a resolution that lands in a monorepo. The one check `omega i live` ends on.
+ * @param {string} installRoot - The brand root (or standalone target).
+ */
+function assertRegistryTree(installRoot) {
+  for (const targetDir of discoverTargets(installRoot)) {
+    const scopeDir = path.join(targetDir, 'node_modules', SCOPE);
+    // No scope folder here: this target's copies are hoisted, or it has none.
+    if (!fs.existsSync(scopeDir)) continue;
+
+    for (const name of fs.readdirSync(scopeDir)) {
+      const installed = path.join(scopeDir, name);
+      if (fs.lstatSync(installed).isSymbolicLink()) {
+        throw new Error(`omega i live left ${installed} linked into ${path.resolve(scopeDir, fs.readlinkSync(installed))}`);
+      }
+    }
+  }
+
+  const monorepoRoot = resolveLinkedMonorepo(installRoot);
+  if (monorepoRoot) {
+    throw new Error(`omega i live left ${installRoot} linked into ${monorepoRoot}`);
+  }
+}
+
 /**
  * Whether the install root's lockfile is missing or disagrees with its
  * manifests' @omega.js registry specs: the deploy gate's own read (#938).
@@ -301,9 +338,10 @@ function brandLockfileStale(installRoot) {
  * ONE `npm install` materializes the links for the whole tree. Standalone
  * targets degenerate to themselves.
  *
- * Idempotent: dependencies already resolving to the monorepo copy are
- * skipped, and when nothing needs linking no install runs. An install is
- * followed by the brand's OWN lockfile regeneration (#938).
+ * Idempotent: dependencies already resolving to the monorepo copy AND
+ * already declaring its file: spec are 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.
@@ -339,13 +377,13 @@ async function linkLocalPackages(options) {
         continue;
       }
 
-      if (isLinkedTo(entry.dir, entry.name, target)) {
+      const spec = `file:${relativeSpecPath(entry.dir, target)}`;
+      if (isLinkedTo(entry.dir, entry.name, target) && entry.spec === spec) {
         actions.push({ name: entry.name, dir: entry.dir, target, action: 'skip' });
         logger && logger.log(`${entry.name}: already linked to the monorepo`);
         continue;
       }
 
-      const spec = `file:${relativeSpecPath(entry.dir, target)}`;
       if (entry.spec === spec) {
         // Spec already correct, only the install is missing — no rewrite,
         // so a committed relative spec is never churned to a new layout.
@@ -398,8 +436,9 @@ async function linkLocalPackages(options) {
  * 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. 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.
+ * agreeing with the manifests (#938): pruned before the install and
+ * regenerated after it, and regenerated alone when nothing flipped but the lock
+ * still disagrees. Every run but a dryRun ends on assertRegistryTree() (#862).
  * @param {object} options
  * @param {string} options.dir - Any directory inside the brand.
  * @param {object} [options.logger] - Logger with log/warn (silent when omitted).
@@ -456,12 +495,21 @@ async function restoreRegistrySpecs(options) {
   }
 
   if (installNeeded) {
+    // The prune below rewrites the lock, so a failed install puts it back too.
+    const lockPath = path.join(installRoot, 'package-lock.json');
+    const lockBackup = fs.existsSync(lockPath) ? fs.readFileSync(lockPath, 'utf8') : null;
+
     try {
+      // BEFORE the install (#862): npm keeps a locked link whose checkout
+      // satisfies the flipped spec, in the lock and in node_modules' hidden lock.
+      pruneBrandLockfile(installRoot, logger);
+      fs.rmSync(path.join(installRoot, 'node_modules', '.package-lock.json'), { force: true });
       await safeInstall('npm install', { log: true, config: { cwd: installRoot } });
     } catch (error) {
       for (const [manifestPath, contents] of manifestBackups) {
         fs.writeFileSync(manifestPath, contents);
       }
+      if (lockBackup !== null) fs.writeFileSync(lockPath, lockBackup);
       logger && logger.warn(`install failed — restored ${manifestBackups.size} manifest(s) to their file: specs`);
       throw error;
     }
@@ -476,6 +524,10 @@ async function restoreRegistrySpecs(options) {
     await regenerateBrandLockfile(installRoot, logger);
   }
 
+  // Every run, not only after an install: a brand already on registry specs
+  // can still be linked, which is the state this verb exists to end.
+  assertRegistryTree(installRoot);
+
   return actions;
 }
 

package/dist/vendor/devkit/lockfile.js

@@ -82,6 +82,34 @@ function dropDrift(lock, drift) {
   return dropped;
 }
 
+/**
+ * Prune `root`'s package-lock.json in place: the stale path entries, then the
+ * @omega.js entries the deploy gate refuses. The lock-only regeneration runs it
+ * first, and so does `omega i live` before its tree install
+ * ([#862](https://github.com/Omega-JS-Stack/omega/issues/862)), since that
+ * install honors the lock's old links just the same.
+ *
+ * @param {object} options
+ * @param {string} options.root - The install root whose lock is pruned.
+ * @param {function} [options.log] - Line sink (silent when omitted).
+ * @returns {void}
+ */
+function pruneLockfile({ root, log }) {
+  const { lockPath, lock, drift } = brandLockfileDrift({ root });
+
+  // No lock, or one without a `packages` map, has no entry to prune.
+  if (!lock || !lock.packages) return;
+
+  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`);
+}
+
 /**
  * Regenerate `root`'s package-lock.json from its manifests, lock-only: no
  * scripts, no node_modules writes.
@@ -92,19 +120,10 @@ function dropDrift(lock, drift) {
  * @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);
+  const lockPath = path.join(root, 'package-lock.json');
+  const original = jetpack.exists(lockPath) === 'file' ? jetpack.read(lockPath) : null;
 
-    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`);
-  }
+  pruneLockfile({ root, log });
 
   if (log) log(`Regenerating ${path.basename(root)}/package-lock.json...`);
 
@@ -124,4 +143,4 @@ async function regenerateLockfile({ root, log }) {
   }
 }
 
-module.exports = { regenerateLockfile };
+module.exports = { pruneLockfile, regenerateLockfile };

package/dist/vendor/devkit/logger.js

@@ -1,5 +1,5 @@
 // Build-time logger — timestamped, tag-scoped console output for CLI commands, gulp
-// tasks, and test runners. `new Logger('setup')` then logger.log/error/warn/info,
+// tasks, and test runners. `new Logger('setup')` then logger.log/error/warn/info/debug,
 // which prints `[HH:MM:SS] [@omega.js/<package>:setup] message`.
 //
 // NOT for app/runtime logging — frameworks with runtime logging needs (e.g. desktop's
@@ -87,8 +87,13 @@ function Logger(name) {
 }
 
 // Make methods that log to console with the tag and time: [xx:xx:xx] [@omega.js/pkg:name] message
-['log', 'error', 'warn', 'info'].forEach((method) => {
+['log', 'error', 'warn', 'info', 'debug'].forEach((method) => {
   Logger.prototype[method] = function () {
+    // debug is the one opt-in level (docs/shared/logging.md): OMEGA_DEBUG, read live.
+    if (method === 'debug' && !process.env.OMEGA_DEBUG) {
+      return;
+    }
+
     const time = new Date().toLocaleTimeString('en-US', {
       hour12: false,
       hour:   '2-digit',