gina 0.6.33 → 0.7.0

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/connector/list.js

@@ -76,7 +76,9 @@ function List(opt, cmd) {
                 return;
             }
             listAll();
-            return;
+            // #B653 — was: return; — nothing ended the process, which hung
+            // wherever the CLI holds its MQ listener (the #B648 class)
+            return exitWhenFlushed();
         }
 
         if ( typeof(self.projects[self.projectName]) == 'undefined' ) {
@@ -98,7 +100,23 @@ function List(opt, cmd) {
             listProjectOnly(self.projectName);
         }
 
-        process.exit(0);
+        // #B653 — was: process.exit(0); — the JSON listings are written with
+        // process.stdout.write, which a pipe takes asynchronously
+        exitWhenFlushed();
+    };
+
+    /**
+     * Exits 0 once everything written to stdout has been handed to the OS.
+     *
+     * The JSON listings are written with `process.stdout.write`, which a pipe takes
+     * asynchronously, so exiting straight after it could cut a listing larger than
+     * the pipe buffer; the all-projects listing did not exit at all (#B653).
+     *
+     * @inner
+     * @private
+     */
+    var exitWhenFlushed = function() {
+        process.stdout.write('', function() { process.exit(0) });
     };
 
     /**

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/env/add.js

@@ -90,8 +90,8 @@ function Add(opt, cmd) {
 
 
     /**
-     * Dispatches to addEnvToProject (project-scoped) or registerEnv (global),
-     * depending on whether a project name was supplied.
+     * Dispatches to addEnvToProjectAndBundles (project-scoped) or registerEnv
+     * (global), depending on whether a project name was supplied.
      *
      * @inner
      * @private
@@ -100,7 +100,9 @@ function Add(opt, cmd) {
     var saveEnvs = function(projectName) {
         try {
             if (projectName) {
-                return addEnvToProject();
+                // #B643 — was: return addEnvToProject(); — that name resolved to the
+                // projects.json writer declared further down, not to this orchestrator
+                return addEnvToProjectAndBundles();
             }
             registerEnv();
         } catch (err) {
@@ -112,10 +114,19 @@ function Add(opt, cmd) {
      * Loads the project manifest and existing port data, builds the port-ignore list,
      * and either writes env.json directly (no bundles) or delegates to addEnvToBundles.
      *
+     * Before the port scan it snapshots the projects (what rollback restores) and
+     * lists the new envs on the in-memory project, because the scan limit is sized
+     * from that list. The projects.json writer it ends with is `addEnvToProject`.
+     *
+     * #B643 — this orchestrator used to be declared as `addEnvToProject` too, the
+     * name of that writer; the later declaration won, so `env:add <env> @<project>`
+     * ran the writer alone (no manifest check, no env.json, no port scan, no
+     * message, no exit).
+     *
      * @inner
      * @private
      */
-    var addEnvToProject = function() {
+    var addEnvToProjectAndBundles = function() {
         var file    = _(self.projects[self.projectName].path + '/env.json')
             , ports = require(_(GINA_HOMEDIR + '/ports.json'))
         ;
@@ -143,6 +154,19 @@ function Add(opt, cmd) {
         for (let b in self.project.bundles) {
             self.bundles.push(b)
         }
+        // #B643 — what rollback restores: taken before anything below adds the new
+        // envs to the in-memory projects (the listing just below, and setPorts for
+        // every bundle), which rollback used to write back instead
+        self.projectsSnapshot = JSON.clone(self.projects);
+        // #B643 — list the new envs on the project before the port scan: the scan
+        // limit (getBundleScanLimit) is sized from this list, and setPorts only adds
+        // them once the first bundle's scan is done — so that scan came up short and
+        // the bundle's last slot was written as port 0 (`~~undefined`)
+        for (let n = 0; n < self.envs.length; ++n) {
+            if ( self.projects[self.projectName].envs.indexOf(self.envs[n]) < 0 ) {
+                self.projects[self.projectName].envs.push(self.envs[n])
+            }
+        }
 
         // to env.json file
         if ( !fs.existsSync(file) ) {
@@ -255,7 +279,8 @@ function Add(opt, cmd) {
         // to ~/.gina/projects.json
         for (; e < newEnvs.length; ++e) {
             if (envs.indexOf(newEnvs[e]) < 0 ) {
-                modified = true;
+                // #B643 — was: modified = true; (an undeclared implicit global,
+                // never read)
                 envs.push(newEnvs[e])
             }
         }
@@ -338,7 +363,8 @@ function Add(opt, cmd) {
 
     /**
      * Restores env.json, ports.json, ports.reverse.json, and projects.json to
-     * their pre-operation state, then exits with code 1.
+     * their pre-operation state, then exits with code 1. projects.json comes from
+     * the snapshot the orchestrator took before adding the new envs (#B643).
      *
      * @inner
      * @private
@@ -359,7 +385,8 @@ function Add(opt, cmd) {
             lib.generator.createFileFromDataSync(self.portsReverseData, self.portsReversePath);
 
             // restore projects.json
-            lib.generator.createFileFromDataSync(self.projects, self.projectConfigPath);
+            // #B643 — was: lib.generator.createFileFromDataSync(self.projects, self.projectConfigPath);
+            lib.generator.createFileFromDataSync(self.projectsSnapshot || self.projects, self.projectConfigPath);
 
             process.exit(1)
         };

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/env/set.js

@@ -42,6 +42,10 @@ function Set(opt, cmd){
 
         if (modified)
             save(self.settings, self.target);
+        // #B653 — no key to set: nothing ended the process, so it hung wherever
+        // the CLI holds its MQ listener (the #B648 class)
+        else
+            end();
     };
 
     /**

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/env/unset.js

@@ -39,6 +39,10 @@ function Unset(opt, cmd){
 
         if (modified)
             save(self.settings, self.target)
+
+        // #B653 — nothing ended the process here, so it hung wherever the CLI
+        // holds its MQ listener (the #B648 class)
+        process.exit(0)
     }
 
     /**

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/framework/init.js

@@ -330,6 +330,30 @@ function Initialize(opt) {
         done()
     }
 
+    /**
+     * Creates or updates `~/.gina/main.json` for the running release, then exports
+     * the release's culture, timezone, log level, prefix and global-mode defaults.
+     *
+     * On the first run of a new short version (a minor crossing, e.g. 0.6 → 0.7),
+     * every per-version dict (`def_culture`, `archs`, `cultures`, …) that has no
+     * entry for the release gets a copy of the previous short version's entry, and
+     * `frameworks[<release>]` is seeded from the template when absent. Only missing
+     * entries are filled, so the step is idempotent, and it runs whether or not a
+     * registrar (bin/cli's start sync, gina-container, post_install) wrote
+     * `frameworks[<release>]` first (#B680).
+     *
+     * After the commit, `main.json` is dropped from Node's require cache, so the
+     * later steps that `require()` it read the migrated file (#B681).
+     *
+     * @private
+     * @param {function} done - Step callback; called with the error only when a
+     *        missing `main.json` cannot be created. Any other failure throws, and
+     *        the `begin()` chain exits the process.
+     * @returns {void}
+     * @example
+     * // A 0.6 main.json read by 0.7.0: def_culture {'0.6':'fr_FR'} gains '0.7':'fr_FR'
+     * // and the step logs `Migrating main.json: 0.6 → 0.7`; a second run changes nothing.
+     */
     self.checkIfMain = function(done) {
         console.debug('Checking main...');
         var source      = getPath('gina').root + '/resources/home/main.json';
@@ -362,28 +386,49 @@ function Initialize(opt) {
         mainConfig      = whisper(dic, mainConfig);
 
         // MIGRATION — first run on a new short version (e.g. 0.1 → 0.2, 0.5 → 1.0).
-        // If the new release key is absent, copy all namespaced keys from the most recent
-        // previous short version. Downgrade is free: old keys are never removed from main.json,
-        // so switching back just re-reads the already-present keys.
-        if (typeof(mainConfig['frameworks'][self.release]) === 'undefined') {
-            var _prevShort = null;
-            for (var _fk in mainConfig['frameworks']) {
-                if (_fk === '_comment') continue;
-                if (!_prevShort || parseFloat(_fk) > parseFloat(_prevShort)) _prevShort = _fk;
-            }
-            if (_prevShort) {
-                console.info('Migrating main.json: ' + _prevShort + ' → ' + self.release);
-                for (var _mk in mainConfig) {
-                    if (_mk === '_comment' || _mk === 'def_framework') continue;
-                    var _mv = mainConfig[_mk];
-                    if (_mv !== null && typeof _mv === 'object' && !Array.isArray(_mv) && typeof(_mv[_prevShort]) !== 'undefined') {
-                        mainConfig[_mk][self.release] = JSON.clone(_mv[_prevShort]);
-                    }
+        // Every per-version dict with no entry for the new release gets a copy of the
+        // entry of the most recent previous short version. Downgrade is free: old keys
+        // are never removed from main.json, so switching back just re-reads the
+        // already-present keys.
+        //
+        // #B680 — the trigger is a dict MISSING the release, not frameworks[release]
+        // being absent: bin/cli's bundle|project:start sync, every gina-container boot
+        // and post_install's end() (after a framework:set that failed) register
+        // frameworks[<new short>] without migrating, which used to skip this migration
+        // for good, leave def_culture[release] undefined, and make defCulture.split()
+        // below throw on every later command.
+        // For the same reason the previous short is picked among the OTHER short
+        // versions: the release itself may already be registered, and a key such as
+        // `latest` is not a short version. Only missing entries are filled, so a file
+        // that is already migrated is left as it is.
+        var _prevShort = null;
+        for (var _fk in mainConfig['frameworks']) {
+            if (_fk === '_comment' || _fk === self.release || !/^\d+\.\d+$/.test(_fk)) continue;
+            if (!_prevShort || parseFloat(_fk) > parseFloat(_prevShort)) _prevShort = _fk;
+        }
+        if (_prevShort) {
+            var _migrated = 0;
+            for (var _mk in mainConfig) {
+                // frameworks is seeded below, never copied: frameworks[<prev>] lists the
+                // previous short's versions, not this one's.
+                if (_mk === '_comment' || _mk === 'def_framework' || _mk === 'frameworks') continue;
+                var _mv = mainConfig[_mk];
+                if (
+                    _mv !== null && typeof _mv === 'object' && !Array.isArray(_mv)
+                    && typeof(_mv[_prevShort]) !== 'undefined'
+                    && typeof(_mv[self.release]) === 'undefined'
+                ) {
+                    if (!_migrated) console.info('Migrating main.json: ' + _prevShort + ' → ' + self.release);
+                    mainConfig[_mk][self.release] = JSON.clone(_mv[_prevShort]);
+                    ++_migrated;
                 }
-                // Seed the frameworks array for the new release from the template (current version only)
-                mainConfig['frameworks'][self.release] = JSON.clone(data['frameworks'][self.release] || []);
             }
         }
+        // Seed the frameworks array for the new release from the template (current version
+        // only) — only when absent, so an entry a registrar wrote first is kept.
+        if (typeof(mainConfig['frameworks'][self.release]) === 'undefined') {
+            mainConfig['frameworks'][self.release] = JSON.clone(data['frameworks'][self.release] || []);
+        }
         // END MIGRATION
 
         // check if new definitions after update
@@ -465,6 +510,18 @@ function Initialize(opt) {
 
         // commit
         lib.generator.createFileFromDataSync(mainConfig, target);
+        // #B681 — the later steps read main.json with require(), and Node's require
+        // cache still holds the object read at the top of this step: the file as it
+        // was before whisper() and the migration (whisper returns a new object, so the
+        // cached one never changes). On a minor crossing checkArch then found no
+        // archs[<release>] and the first command exited 1. Dropping the entry makes
+        // their next require() read the file just written. Once per process: init's
+        // check chain runs from onComplete only, never per online command.
+        try {
+            delete require.cache[require.resolve(target)];
+        } catch (cacheErr) {
+            console.debug('Could not drop '+ target +' from the require cache: '+ (cacheErr.message || cacheErr));
+        }
 
         process.env.TZ = defTimezone;
         process.env.LOG_LEVEL = defLogLevel;

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/helper.js

@@ -422,8 +422,11 @@ function CmdHelper(cmd, client, debug) {
                     else if ( /^project\:import/i.test(cmd.task) ) {
                         let newHomeDir = _(getUserHome() +'/.'+ cmd.projectName, true);
                         let pathArg = argv.find(arg => arg.startsWith('--path=')) || null;
+                        // #B644 — the value is everything after the FIRST `=`: `split('=')[1]`
+                        // cut a path holding `=` short, and the import then refused the cut
+                        // path as one that "no longer exists".
                         let pathValue = pathArg
-                                ? pathArg.split('=')[1].replace(/['"]/g, '')
+                                ? pathArg.substring('--path='.length).replace(/['"]/g, '')
                                 : null;
                         if ( pathValue && pathValue != cmd.projectLocation ) {
                             // Making sure the prefix is the right one
@@ -1770,14 +1773,22 @@ function CmdHelper(cmd, client, debug) {
     /**
      * Returns a sorted list of all port numbers currently registered in
      * ports.json and ports.reverse.json, excluding those already assigned to
-     * the current project's bundles.
+     * the current project's bundles. Both files are read from disk on every call
+     * (#B643), so a caller that scans once per bundle sees the ports it has just
+     * assigned.
      * Assigns itself to the global `getPortsList`.
      *
      * @global
      * @returns {string[]} Sorted array of port number strings
      */
     getPortsList = function() {
-        var ports = require(_(GINA_HOMEDIR + '/ports.json'));
+        // #B643 — read the registries from disk, not through require(): the cached
+        // copy stays stale after setPorts rewrites them whenever the home path holds
+        // a symlink (setPorts purges require.cache by the unresolved path, while the
+        // cache keys are realpaths), so a multi-bundle env:add gave every bundle the
+        // same new ports
+        // was: var ports = require(_(GINA_HOMEDIR + '/ports.json'));
+        var ports = requireJSON(_(GINA_HOMEDIR + '/ports.json', true));
         var portsList = []; // list of all ports to ignore whles scanning
         var protocols = cmd.projects[cmd.projectName].protocols;
         var schemes = cmd.projects[cmd.projectName].schemes;
@@ -1792,7 +1803,8 @@ function CmdHelper(cmd, client, debug) {
             }
         }
         // double checking
-        var portsReverse = require(_(GINA_HOMEDIR + '/ports.reverse.json'));
+        // #B643 — was: var portsReverse = require(_(GINA_HOMEDIR + '/ports.reverse.json'));
+        var portsReverse = requireJSON(_(GINA_HOMEDIR + '/ports.reverse.json', true));
         for (let bundle in portsReverse) {
             for (let env in portsReverse[bundle]) {
                 for (let protocole in portsReverse[bundle][env]) {

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/port/list.js

@@ -215,7 +215,11 @@ function List(opt, cmd) {
                 return end('Saved to `'+ filename +'`');
             }
 
-            return process.stdout.write(data);
+            // #B653 — exit once the data is handed to the OS: this returned with
+            // nothing ending the process, which hung wherever the CLI holds its
+            // MQ listener (the #B648 class)
+            // was: return process.stdout.write(data);
+            return process.stdout.write(data, function() { end() });
         }
 
         if ( /^json$/.test(self.format) ) {
@@ -225,11 +229,16 @@ function List(opt, cmd) {
                 var filename = targetObj.toString();
                 // save to ~/.gina/ports.reverse.json
                 lib.generator.createFileFromDataSync( data, filename );
-                console.log('Saved to `'+ filename +'`');
-                return;
+                // #B653 — end like the conf branch above (this returned with
+                // nothing ending the process)
+                // was: console.log('Saved to `'+ filename +'`');
+                // was: return;
+                return end('Saved to `'+ filename +'`');
             }
 
-            return process.stdout.write(data);
+            // #B653 — exit once the data is handed to the OS (see above)
+            // was: return process.stdout.write(data);
+            return process.stdout.write(data, function() { end() });
         }
 
 

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/port/reset.js

@@ -1,5 +1,6 @@
 const fs            = require('fs');
-const { execSync }  = require('child_process');
+// #B663 (2026-09-25) — no child process any more: reset() reads the bundle list in-process.
+// const { execSync }  = require('child_process');
 
 var console     = lib.logger;
 var CmdHelper   = require('./../helper');
@@ -68,6 +69,10 @@ function Reset(opt, cmd) {
         if ( self.projectName && isDefined('project', self.projectName) ) {
             loadAssets();
             reset()
+        } else {
+            // #B653 — no registered project to reset: nothing ended the process,
+            // so it hung wherever the CLI holds its MQ listener (the #B648 class)
+            process.exit(0)
         }
         // if (self.projectName && isDefined(self.projectName) && !self.name) {
         //     listProjectOnly()
@@ -84,17 +89,33 @@ function Reset(opt, cmd) {
      * Removes all existing port entries for the project from ports.json and
      * ports.reverse.json, then calls addBundlePorts to re-assign fresh ports.
      *
+     * The project's bundle names come from the manifest loadAssets() has already
+     * loaded (`self.bundlesByProject[<project>]`, the `manifest.json` `bundles`
+     * keys that `bundle:list` prints), in-process: no child process, no shell (#B663).
+     *
      * @inner
      * @private
+     * @returns {void}
      */
     var reset = function() {
         // get bundles list
-        var bundlesCollection = null, out = null;
-        try {
-            out = execSync('$(which gina) bundle:list @'+ self.projectName +' --format=json').toString().replace(/(\n|\r)$/, '').split(/(\n|\r)/g);
-            out = out[out.length-1];
-            bundlesCollection = JSON.parse(out);
-        } catch (err) {}// silently ...
+        // #B663 (2026-09-25) — read in-process instead of a `$(which gina) bundle:list …` child
+        // run through a shell: with no `gina` on PATH, or `gina` under a path containing a
+        // space, the child failed, the catch swallowed it, and the loop below died on a null
+        // list (TypeError, exit 1) before anything was written. The child also ran whichever
+        // `gina` PATH found first, without this process's GINA_HOMEDIR, and the project name
+        // reached the shell unquoted.
+        // var bundlesCollection = null, out = null;
+        // try {
+        //     out = execSync('$(which gina) bundle:list @'+ self.projectName +' --format=json').toString().replace(/(\n|\r)$/, '').split(/(\n|\r)/g);
+        //     out = out[out.length-1];
+        //     bundlesCollection = JSON.parse(out);
+        // } catch (err) {}// silently ...
+        var bundlesCollection = [];
+        var projectBundles = self.bundlesByProject[self.projectName] || {};
+        for (let bundleName in projectBundles) {
+            bundlesCollection.push({ bundle: bundleName, project: self.projectName });
+        }
 
         // remove definitions from port.reverse.json & port.json
         var i       = 0

package/framework/{v0.6.33 → v0.7.0}/lib/cmd/project/add.js

@@ -46,10 +46,34 @@ function Add(opt, cmd) {
         }
     ;
 
+    /**
+     * Returns the value of a `--<name>=<value>` argument: everything after the
+     * FIRST `=`, so a value may itself hold `=`. The name must start the argument,
+     * so a flag spelled inside another flag's value (`--path=/srv/a--scope=b`) is
+     * not read as that flag (#B644).
+     *
+     * @inner
+     * @private
+     * @param {string} arg - One `process.argv` element
+     * @param {string} name - The flag name, without the leading `--`
+     * @returns {?string} The value (possibly empty), or null when `arg` is not that flag
+     *
+     * @example
+     *  flagValue('--path=/srv/a=b/app', 'path')     // → '/srv/a=b/app'
+     *  flagValue('--path=/srv/a--scope=b', 'scope') // → null
+     */
+    var flagValue = function(arg, name) {
+        var prefix = '--' + name + '=';
+        return ( typeof(arg) == 'string' && arg.indexOf(prefix) === 0 ) ? arg.substring(prefix.length) : null;
+    }
+
     /**
      * Parses argv flags, ensures the project directory exists, creates package.json,
      * manifest.json, and env.json, optionally adding scope/env via sub-commands.
      *
+     * Each flag is read by flagValue(): its name must start the argument and its
+     * value is everything after the first `=` (#B644).
+     *
      * On `project:add`, a `--scope` / `--env` value the shared name rules reject
      * (`scope/inc/name.js`, `env/inc/name.js`) is refused before anything is written,
      * exit 1 (#B640). `project:import` skips that check: the CLI bootstrap only lets
@@ -72,25 +96,32 @@ function Add(opt, cmd) {
         // import CMD helpers
         new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
 
+        // #B644 — the flags used to be matched anywhere in an argument, and their
+        // values taken as the text between the first and the second `=`. So a value
+        // holding `=` was cut short (`--scope=a=b` registered `a`; on a fresh registry
+        // a `--path` holding `=` sent the manifest to the cut directory, exit 1), and
+        // a `--path` value containing `--scope=` or `--env=` was read as that flag too.
         for (let i=3, len=process.argv.length; i<len; i++) {
-            if ( /\-\-start\-port\-from\=/.test(process.argv[i]) ) {
-                self.startFrom = process.argv[i].split(/\=/)[1]
+            let value = null;
+
+            if ( (value = flagValue(process.argv[i], 'start-port-from')) !== null ) {
+                self.startFrom = value
             }
 
-            if ( /\-\-homedir\=/.test(process.argv[i]) ) {
-                self.projectHomedir = process.argv[i].split(/\=/)[1]
+            if ( (value = flagValue(process.argv[i], 'homedir')) !== null ) {
+                self.projectHomedir = value
             }
 
-            if ( /\-\-scope\=/.test(process.argv[i]) ) {
-                self.scope = process.argv[i].split(/\=/)[1]
+            if ( (value = flagValue(process.argv[i], 'scope')) !== null ) {
+                self.scope = value
             }
 
-            if ( /\-\-env\=/.test(process.argv[i]) ) {
-                self.env = process.argv[i].split(/\=/)[1]
+            if ( (value = flagValue(process.argv[i], 'env')) !== null ) {
+                self.env = value
             }
 
-            if ( /\-\-path\=/.test(process.argv[i]) ) {
-                self.projectLocation = process.argv[i].split(/\=/)[1];
+            if ( (value = flagValue(process.argv[i], 'path')) !== null ) {
+                self.projectLocation = value;
                 self.projectManifestPath = _(self.projectLocation + '/manifest.json', true);
             }
         }
@@ -152,7 +183,8 @@ function Add(opt, cmd) {
             console.warn('[ package.json ] already exists in this location: '+ file + '\nUpdating package.json...');
             // Merge existing package.json with framework template; createPackageFile calls end()
             // which writes projects.json and calls process.exit(0). Without this, the process
-            // hangs indefinitely because MQSpeaker keeps the event loop alive.
+            // hangs wherever bin/cli has bound its MQ log listener, which keeps the event loop
+            // alive (the MQ speaker's socket is unref'd).
             createPackageFile( file.toString(), true );
         }
 
@@ -535,6 +567,10 @@ function Add(opt, cmd) {
      * Writes the project entry to projects.json, runs addBundlePorts and
      * addBundleToManifest in import mode, links gina, and exits the process.
      *
+     * `def_scope` / `def_env` are written from the project's current defaults (the
+     * registry's, for a new project): `--scope` / `--env` only register a missing
+     * scope or environment, and never change them — `scope:use` / `env:use` do (#B644).
+     *
      * @inner
      * @private
      * @param {boolean} [created] - When true, use all available protocols/schemes (new project)
@@ -555,14 +591,19 @@ function Add(opt, cmd) {
             process.exit(1)
         }
 
-        if ( /^$true/i.test(local.imported) ) {
-            if (self.scope) {
-                self.defaultScope = self.scope
-            }
-            if (self.env) {
-                self.defaultEnv = self.env
-            }
-        }
+        // #B644 — this import-only branch never ran: `/^$true/` cannot match (`$`
+        // asserts the end of the input before `true`). It stays off: `--scope` /
+        // `--env` register a missing scope or environment (the children in init()),
+        // and a project's defaults are changed with `scope:use` / `env:use`. Reviving
+        // it would change the defaults every `project:import --scope/--env` writes.
+        // if ( /^$true/i.test(local.imported) ) {
+        //     if (self.scope) {
+        //         self.defaultScope = self.scope
+        //     }
+        //     if (self.env) {
+        //         self.defaultEnv = self.env
+        //     }
+        // }
 
         projects[self.projectName] = {
             "path"              : self.projectLocation,
@@ -654,7 +695,9 @@ function Add(opt, cmd) {
                 error = ginaModule.rmSync();
 
                 if (error instanceof Error) {
-                    console.error(err.stack);
+                    // #B644 — this printed `err`, which does not exist here: a failed
+                    // removal died on a ReferenceError instead of reporting itself.
+                    console.error(error.stack);
                     process.exit(1);
                 } else {
                     linkGina(onError, onSuccess)