gina 0.7.0 → 0.7.1

package/framework/v0.7.1/lib/cmd/bundle/inc/boot-lines.js

@@ -0,0 +1,263 @@
+/**
+ * @module gina/lib/cmd/bundle/inc/boot-lines
+ *
+ * The boot lines `gina bundle:start` passes on to its client (#B691).
+ *
+ * A bundle started through the framework daemon writes each levelled line twice:
+ * to its own stdout (the logger's `default` container) and to the MQ listener (the
+ * `mq` container), which forwards the line to the `gina tail` sessions attached at
+ * that instant and keeps no backlog. The daemon reads the bundle's stdout only as a
+ * startup watchdog (`start.js`), and until 0.7.1 it passed on nothing from it but an
+ * emerg and the started and URL lines. So a warning the bundle logged while it
+ * booted reached no operator whose tail attached after the boot: the ordinary
+ * `gina bundle:start`, then `gina tail`, and a container whose init script starts
+ * the bundle before its tail.
+ *
+ * `createBootLineFilter()` reads that stdout during the boot and returns the entries
+ * logged at warn and above, for `start.js` to write to its client. Each entry comes
+ * back as the bundle rendered it, colour codes included. `emerg` is left to the
+ * abort path in `start.js`; info, notice and debug stay out.
+ *
+ * No `fs`, no framework globals: require-by-path unit-testable. It lives in `inc/`
+ * so the command loader never takes it for a `bundle:<action>` handler.
+ */
+'use strict';
+
+/**
+ * The level names passed on: every name the logger defines at severity 1 to 4. The
+ * logger renders the name the caller used, and it recommends `warning` and `err`
+ * over their deprecated aliases `warn` and `error`, so all six are matched.
+ *
+ * @constant
+ * @type {string[]}
+ */
+var FORWARDED_LEVELS = ['alert', 'crit', 'error', 'err', 'warn', 'warning'];
+
+/**
+ * The longest line read, in characters. A longer line is dropped, up to its
+ * newline: no boot warning is that long, and the daemon must not buffer a
+ * bundle's output without bound.
+ *
+ * @constant
+ * @type {number}
+ */
+var MAX_PENDING = 64 * 1024;
+
+/**
+ * The longest entry passed on, in characters. An entry reaching it is passed on as
+ * read so far, and the rest of it is dropped.
+ *
+ * @constant
+ * @type {number}
+ */
+var MAX_ENTRY = 64 * 1024;
+
+/**
+ * The start of an entry once colour codes are stripped: the logger's default
+ * template `[%d] [%s][%a] %m`, whose level name is padded to a fixed width, as in
+ * `[2026 Sep 27 06:17:10] [warn   ][api@shop] …`. Group 1 is the level name.
+ *
+ * @constant
+ * @type {RegExp}
+ * @private
+ */
+var HEADER_RE = /^\[[^\]\n]+\] \[([a-z]+) *\]\[/;
+
+/**
+ * Every SGR (colour or style) escape sequence, for stripping.
+ *
+ * @constant
+ * @type {RegExp}
+ * @private
+ */
+var SGR_ALL_RE = /\x1b\[[0-9;]*m/g;
+
+/**
+ * Whether a line holds an SGR escape sequence.
+ *
+ * @constant
+ * @type {RegExp}
+ * @private
+ */
+var SGR_ANY_RE = /\x1b\[[0-9;]*m/;
+
+/**
+ * An SGR sequence closing a colour or style at the end of a line. The logger's
+ * `format()` wraps a whole message in ONE colour block, so the line that carries
+ * the close is the entry's last.
+ *
+ * @constant
+ * @type {RegExp}
+ * @private
+ */
+var SGR_CLOSE_AT_END_RE = /\x1b\[(?:0|22|23|24|27|28|29|39|49)?m[ \t]*$/;
+
+/**
+ * Reads the level of a line that starts an entry: a text header, or a JSON line
+ * (a logger rendering JSON writes one object per entry).
+ *
+ * @inner
+ * @private
+ * @param {string} line - One complete line, without its line ending
+ * @returns {?{level: string, closed: boolean}} The entry's level and whether this
+ *   line is also its last, or null when the line starts no entry
+ */
+function readHeader(line) {
+    if ( line.charAt(0) == '{' ) {
+        try {
+            var obj = JSON.parse(line);
+            if ( obj && typeof(obj.level) == 'string' ) {
+                return { level: obj.level.toLowerCase(), closed: true };
+            }
+        } catch (parseErr) {
+            // not JSON: no entry starts here
+        }
+        return null;
+    }
+
+    var m = line.replace(SGR_ALL_RE, '').match(HEADER_RE);
+    if (!m) {
+        return null;
+    }
+    return {
+        level : m[1],
+        // without colour codes nothing marks where the entry ends: the line is all of it
+        closed: !SGR_ANY_RE.test(line) || SGR_CLOSE_AT_END_RE.test(line)
+    };
+}
+
+/**
+ * The filter `createBootLineFilter()` returns.
+ *
+ * @typedef {object} BootLineFilter
+ * @property {function((string|Buffer)): string[]} push - Reads one chunk of the
+ *   bundle's stdout; returns the entries at warn and above that the chunk
+ *   completed, in order, each as rendered and without a trailing newline
+ */
+
+/**
+ * Creates the filter for one bundle's boot. A chunk may split a line or carry
+ * several: a line is read once its newline arrives, and an entry spanning several
+ * lines is returned once its colour block closes or the next entry starts.
+ *
+ * @returns {BootLineFilter} A filter holding the state of this bundle's output only
+ *
+ * @example
+ *  var bootLines = require('./inc/boot-lines');
+ *  var filter    = bootLines.createBootLineFilter();
+ *
+ *  child.stdout.on('data', function(data) {
+ *      var entries = filter.push(data);
+ *      // e.g. ['\x1b[33m[2026 Sep 27 06:17:11] [warn   ][api@shop] [ SWIG ] … \x1b[39m']
+ *      if (entries.length) client.write('\n' + entries.join('\n') + '\n');
+ *  });
+ */
+function createBootLineFilter() {
+    var pending  = ''    // the start of a line whose newline has not arrived yet
+      , skipping = false // dropping the rest of a line longer than MAX_PENDING
+      , entry    = null  // the entry being read: { forward: boolean, text: string }
+    ;
+
+    /**
+     * Ends the entry being read; keeps it when it is passed on.
+     *
+     * @inner
+     * @private
+     * @param {string[]} out - The entries this push completed
+     */
+    function finish(out) {
+        if (entry && entry.forward) {
+            out.push(entry.text);
+        }
+        entry = null;
+    }
+
+    /**
+     * Reads one complete line.
+     *
+     * @inner
+     * @private
+     * @param {string} line - Without its newline
+     * @param {string[]} out - The entries this push completed
+     */
+    function readLine(line, out) {
+        if ( line.charCodeAt(line.length - 1) === 13 ) { // a CRLF line ending
+            line = line.slice(0, -1);
+        }
+
+        var header = readHeader(line);
+        if (header) {
+            finish(out); // a new entry ends the one before it
+            var forward = FORWARDED_LEVELS.indexOf(header.level) > -1;
+            entry = { forward: forward, text: forward ? line : '' };
+            if (header.closed) {
+                finish(out);
+            }
+            return;
+        }
+
+        if (!entry) { // a line outside any entry: a raw write
+            return;
+        }
+        var closes = SGR_CLOSE_AT_END_RE.test(line);
+        if (entry.forward) {
+            if ( entry.text.length + 1 + line.length > MAX_ENTRY ) {
+                finish(out); // passed on as read so far,
+                entry = { forward: false, text: '' }; // and the rest of it read and dropped
+            } else {
+                entry.text += '\n' + line;
+            }
+        }
+        if (closes) {
+            finish(out);
+        }
+    }
+
+    /**
+     * Reads one chunk of the bundle's stdout.
+     *
+     * @param {string|Buffer} chunk - As read from the child's stdout
+     * @returns {string[]} The entries at warn and above this chunk completed, in order
+     */
+    function push(chunk) {
+        var out = [];
+        if ( chunk === null || typeof(chunk) == 'undefined' ) {
+            return out;
+        }
+
+        var text = String(chunk), start = 0, nl = -1, line = null;
+        while ( (nl = text.indexOf('\n', start)) > -1 ) {
+            line  = pending + text.slice(start, nl);
+            start = nl + 1;
+            pending = '';
+            if (skipping) { // the end of a line too long to read
+                skipping = false;
+                continue;
+            }
+            if (line.length > MAX_PENDING) {
+                continue;
+            }
+            readLine(line, out);
+        }
+
+        if (!skipping) {
+            var rest = text.slice(start);
+            if ( pending.length + rest.length > MAX_PENDING ) {
+                pending  = '';
+                skipping = true;
+            } else {
+                pending += rest;
+            }
+        }
+        return out;
+    }
+
+    return { push: push };
+}
+
+module.exports = {
+    createBootLineFilter: createBootLineFilter,
+    FORWARDED_LEVELS    : FORWARDED_LEVELS,
+    MAX_PENDING         : MAX_PENDING,
+    MAX_ENTRY           : MAX_ENTRY
+};

package/framework/v0.7.1/lib/cmd/bundle/inc/name.js

@@ -0,0 +1,70 @@
+/**
+ * @module gina/lib/cmd/bundle/inc/name
+ *
+ * The rule a NEW bundle name must pass (#B665): `gina bundle:add` and the destination of
+ * `gina bundle:copy` and `gina bundle:rename` apply it before they write anything. A bundle
+ * name becomes a key in the project's `manifest.json` and `env.json`, the source directory
+ * `src/<name>`, part of every `<bundle>@<project>` string in `ports.json` and
+ * `ports.reverse.json`, and part of its process title. The CLI used to check only a name's
+ * first character, so it registered names holding shell and regular-expression syntax, and
+ * names every object inherits (`constructor`), which the manifest's
+ * `typeof(bundles[name]) != 'undefined'` tests take for an existing bundle.
+ *
+ * The rule is the scope-name rule (`lib/cmd/scope/inc/name.js`, #B626, #B639). A name
+ * registered before it existed keeps working: the commands apply it to a name the manifest
+ * does not hold yet.
+ *
+ * No `fs`, no framework globals — require-by-path unit-testable. It lives in `inc/` so the
+ * command loader never takes it for a `bundle:<action>` handler.
+ */
+'use strict';
+
+var scopeName = require('../../scope/inc/name');
+
+/**
+ * Whether `name` is a bundle name the CLI may register: letters, digits, `_`, `.` and `-`,
+ * starting with a lowercase letter, a digit, `_` or `.`; neither `.` nor `..`; and not a
+ * property every object inherits.
+ *
+ * @param {*} name - Candidate bundle name
+ * @returns {boolean} True when the scope-name rule accepts it
+ *
+ * @example
+ *  isValidBundleName('api');           // true
+ *  isValidBundleName('design-system'); // true
+ *  isValidBundleName('Admin');         // false — starts with an uppercase letter
+ *  isValidBundleName('a$b');           // false — `$` is not allowed
+ *  isValidBundleName('constructor');   // false — every object inherits it
+ */
+function isValidBundleName(name) {
+    return scopeName.isValidScopeName(name);
+}
+
+/**
+ * The refusal message for a name `isValidBundleName()` rejects. A reserved name is named as
+ * such; any other name gets the character rule. The value is JSON-quoted, so whitespace and
+ * control characters stay visible.
+ *
+ * @param {*} name - The rejected name
+ * @returns {string} The message, naming the value
+ *
+ * @example
+ *  describeInvalidBundleName('constructor');
+ *  // '"constructor" is not a valid bundle name: it is a property every object inherits, ...'
+ *  describeInvalidBundleName('a b');
+ *  // '"a b" is not a valid bundle name: use letters, digits, ...'
+ */
+function describeInvalidBundleName(name) {
+    var shown = JSON.stringify(String(name));
+    if ( scopeName.isReservedName(name) ) {
+        return shown + ' is not a valid bundle name: it is a property every object inherits, so it'
+            + ' cannot be used as a key in the project manifest.';
+    }
+    return shown + ' is not a valid bundle name: use letters, digits, `_`, `.` and `-`, starting with a'
+        + ' lowercase letter, a digit, `_` or `.` (`.` and `..` are refused).';
+}
+
+module.exports = {
+    isValidBundleName         : isValidBundleName,
+    describeInvalidBundleName : describeInvalidBundleName
+};

package/framework/{v0.7.0 → v0.7.1}/lib/cmd/bundle/remove.js

@@ -4,6 +4,7 @@ var rl          = readline.createInterface(process.stdin, process.stdout);
 
 var CmdHelper   = require('./../helper');
 var console     = lib.logger;
+var escapeRegex = require('./inc/name-rewrite').escapeRegex;
 
 /**
  * @module gina/lib/cmd/bundle/remove
@@ -218,7 +219,10 @@ function Remove(opt, cmd) {
         for (let protocol in ports) {
             for (let scheme in ports[protocol]) {
                 for (let port in ports[protocol][scheme]) {
-                    re = new RegExp(bundle +"\@"+ self.projectName +"\/");
+                    // #B665 — the names are matched literally, from the start of the value:
+                    // `api@shop/` matched `myapi@shop/dev`, whose ports went with this bundle's.
+                    // was: re = new RegExp(bundle +"\@"+ self.projectName +"\/");
+                    re = new RegExp('^' + escapeRegex(bundle +'@'+ self.projectName +'/'));
                     if ( re.test(ports[protocol][scheme][port]) ) {
                         delete ports[protocol][scheme][port];
                     }
@@ -227,7 +231,9 @@ function Remove(opt, cmd) {
         }
 
         for (let bundleAddress in portsReverse) {
-            re = new RegExp(bundle +"\@"+ self.projectName);
+            // #B665 — the whole key, literally: `api@shop` matched `myapi@shop` and `api@shopping`.
+            // was: re = new RegExp(bundle +"\@"+ self.projectName);
+            re = new RegExp('^' + escapeRegex(bundle +'@'+ self.projectName) + '$');
             if ( re.test(bundleAddress) ) {
                 delete portsReverse[bundleAddress];
             }

package/framework/{v0.7.0 → v0.7.1}/lib/cmd/bundle/rename.js

@@ -3,6 +3,7 @@ var console = lib.logger;
 
 var CmdHelper   = require('./../helper');
 var nameRewrite = require('./inc/name-rewrite');
+var bundleNameRule = require('./inc/name');
 
 /**
  * @module gina/lib/cmd/bundle/rename
@@ -350,6 +351,9 @@ function Rename(opt, cmd) {
      * (unless `--dry-run`) moves the directory, rewrites the name footprint, and
      * rekeys every registry surface — all snapshot-guarded for rollback.
      *
+     * A new name the manifest does not hold yet must pass the bundle-name rule
+     * (`inc/name.js`), before the dry-run report and before anything moves (#B665).
+     *
      * @inner
      * @private
      */
@@ -373,6 +377,16 @@ function Rename(opt, cmd) {
             process.exit(1);
             return;
         }
+        // #B665 — the whole new name must pass the bundle-name rule (`inc/name.js`):
+        // isValidName() checks only its first character. A name the manifest already
+        // holds, as an own key (a destination overwritten under --force), keeps working.
+        var destRegistered = !!(self.projectData && self.projectData.bundles)
+            && Object.prototype.hasOwnProperty.call(self.projectData.bundles, dest);
+        if ( !destRegistered && !bundleNameRule.isValidBundleName(dest) ) {
+            console.error( bundleNameRule.describeInvalidBundleName(dest) );
+            process.exit(1);
+            return;
+        }
 
         // source must exist (registered + on disk)
         var srcEntry = (self.bundlesByProject && self.bundlesByProject[project])

package/framework/{v0.7.0 → v0.7.1}/lib/cmd/bundle/start.js

@@ -2,6 +2,8 @@ const fs            = require('fs');
 const { EventEmitter }  = require('events');
 const { spawn }     = require('child_process');
 const { execSync }  = require('child_process');
+// #B665 (2026-09-27) — execFileSync: the reinstall's framework:link step runs from an argument vector.
+const { execFileSync } = require('child_process');
 const util = require('util');
 const promisify = require('util').promisify;
 
@@ -9,6 +11,10 @@ var CmdHelper   = require('./../helper');
 // Runtime detection (Bun vs Node) for the PM-aware reinstall below. Required by a
 // plain relative path (the bare `lib/<name>` form is unavailable in CLI/daemon scope).
 var runtime     = require(__dirname + '/../../../../../utils/runtime.js');
+// #B691 (2026-09-27) — picks a bundle's warn-and-above boot lines out of its stdout for the
+// client. Relative path: the bare `lib/<name>` form is unavailable in CLI/daemon scope.
+var bootLines   = require('./inc/boot-lines');
+var escapeRegex = require('./inc/name-rewrite').escapeRegex;
 // `lib` is previously defiened as this file is required by anoth
 // For user output
 var terminal    = lib.logger;
@@ -84,8 +90,10 @@ function Start(opt, cmd) {
 
     /**
      * Checks if the project's node_modules need to be reinstalled due to an arch/platform mismatch.
-     * Reinstalls via `npm install` (or `bun install` under Bun) if needed, then
-     * calls cb(false) to proceed.
+     * Reinstalls via `npm install` (or `bun install` under Bun) if needed, re-links
+     * gina with this install's own `bin/gina framework:link`, run under the current
+     * runtime from an argument vector without a shell (#B665), then calls cb(false)
+     * to proceed.
      * @inner
      * @private
      * @param {object} opt
@@ -193,14 +201,18 @@ function Start(opt, cmd) {
             var result = null; resultError = false;
             try {
                 result = execSync(npmCmd).toString();
-                var ginaBin = execSync('which gina').toString().trim();
-                // Run the gina bin under the current runtime so a no-node Bun image
-                // can't fail on the `#!/usr/bin/env node` shebang. Under Node, linkCmd
-                // is byte-identical to the previous direct invocation (zero Node delta).
-                var linkCmd = runtime.isBun()
-                                  ? runtime.runtimeBinary() +' '+ ginaBin +' framework:link @'+ self.projectName
-                                  : ginaBin +' framework:link @'+ self.projectName;
-                execSync(linkCmd);
+                // #B665 (2026-09-27) — this install's own bin/gina, run from an argument vector,
+                // without a shell: `which gina` could find no gina or a different install, and
+                // the project name reached `sh` unquoted. runtimeBinary() keeps the Bun
+                // behaviour (the running Bun binary, so a no-node image never meets the
+                // `#!/usr/bin/env node` shebang); under Node it returns the running node.
+                // was: var ginaBin = execSync('which gina').toString().trim();
+                // was: var linkCmd = runtime.isBun()
+                // was:                   ? runtime.runtimeBinary() +' '+ ginaBin +' framework:link @'+ self.projectName
+                // was:                   : ginaBin +' framework:link @'+ self.projectName;
+                // was: execSync(linkCmd);
+                var ginaBin = require('path').resolve(__dirname, '../../../../..', 'bin/gina');
+                execFileSync(runtime.runtimeBinary(process.execPath), [ginaBin, 'framework:link', '@' + self.projectName]);
             } catch (err) {
                 resultError = err;
             }
@@ -257,7 +269,8 @@ function Start(opt, cmd) {
 
 
     /**
-     * Spawns the bundle process, monitors stdout for start/error signals, and calls end().
+     * Spawns the bundle process, monitors stdout for start/error signals, passes the
+     * bundle's warn-and-above boot lines on to the client (#B691), and calls end().
      * @inner
      * @private
      * @param {object} opt
@@ -437,11 +450,19 @@ function Start(opt, cmd) {
                     var checkCaseCount = 2
                         // The 2 flags we need to free the child.stdout if we do not want the command to wait for a timeout
                         // NB.: you can place flag by using terminal.notice
-                        , checkCaseRe = new RegExp('('+bundle + '@' + self.projectName + ' mounted !|Bundle started !)', 'g')
+                        // #B665 — the name is matched literally: `a+b` never matched its own
+                        // `mounted !` line, so the start never counted the bundle as mounted and
+                        // killed it after its timeout, and a `(` threw.
+                        // was: , checkCaseRe = new RegExp('('+bundle + '@' + self.projectName + ' mounted !|Bundle started !)', 'g')
+                        , checkCaseRe = new RegExp('('+ escapeRegex(bundle + '@' + self.projectName) + ' mounted !|Bundle started !)', 'g')
                         , url = null
                         , debuggerOn = null
                     ;
                     var port = '', errorFound = false;
+                    // #B691 (2026-09-27) — one filter per spawned bundle. The MQ listener keeps no
+                    // backlog, so a line the bundle logs while it boots reaches only a `gina tail`
+                    // attached before it: the bundle's warn-and-above boot lines go to this client too.
+                    var bootLineFilter = bootLines.createBootLineFilter(), bootLinesShown = false;
                     child.stdout.on('data', function(data) {
                         // terminal.log(data);
 
@@ -450,6 +471,20 @@ function Start(opt, cmd) {
                         // 'default' container) triggers child.kill('SIGKILL') and silences the error.
                         if (isStarting) return;
 
+                        // #B691 — pass the bundle's warn-and-above boot lines on to the client, ahead
+                        // of the checks below, so a warning comes before the started or aborted line.
+                        // The first one starts a new line: `Trying to start bundle [ … ]` ends without
+                        // one. A fault here must never break a start.
+                        try {
+                            var _bootEntries = bootLineFilter.push(data);
+                            if ( _bootEntries.length && !opt.client.destroyed ) {
+                                opt.client.write( (bootLinesShown ? '' : '\n') + _bootEntries.join('\n') + '\n' );
+                                bootLinesShown = true;
+                            }
+                        } catch (bootLinesErr) {
+                            terminal.debug('[bundle:start] boot lines not passed on: '+ bootLinesErr.message);
+                        }
+
                         // handle errors
                         if ( /EADDRINUSE.*port/i.test(data) && !errorFound ) {
                             terminal.log(data);

package/framework/{v0.7.0 → v0.7.1}/lib/cmd/bundle/stop.js

@@ -1,9 +1,27 @@
-const { execSync } = require('child_process');
+// #B665 (2026-09-27) — execFileSync: the ps fallback lists processes without a shell.
+// const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 var fs = require('fs');
-var exec = require('child_process').exec;
+// #B665 S2 (2026-09-27) — the SIGKILL is sent with process.kill, not through sh.
+// var exec = require('child_process').exec;
 
 var CmdHelper = require('./../helper');
+// #B665 (2026-09-27) — the ps fallback matches the names as literal text
+var escapeRegex = require('./inc/name-rewrite').escapeRegex;
 var console = lib.logger;
+
+/**
+ * Output cap for the `ps -ef` listing of the missing-pid-file fallback, which is
+ * read whole since the shell pipeline that filtered it is gone: Node's 1 MB
+ * default could be exceeded on a host running many processes with long command
+ * lines (#B665).
+ *
+ * @constant
+ * @inner
+ * @type {number}
+ */
+var PS_MAX_BUFFER = 64 * 1024 * 1024;
+
 /**
  * @module gina/lib/cmd/bundle/stop
  */
@@ -59,6 +77,11 @@ function Stop(opt, cmd) {
 
     /**
      * Reads the bundle PID file and sends SIGKILL, or falls back to ps lookup.
+     * Only a positive integer is read as a pid (#B693), and the signal is sent
+     * with `process.kill`, not through a shell (#B665).
+     * The fallback runs `ps -ef` without a shell and keeps the first process whose
+     * title is exactly `gina: <bundle>@<project>`, ending at whitespace or the end
+     * of the line, skipping lines that name `grep` (#B665).
      * @inner
      * @private
      * @param {object} opt
@@ -90,14 +113,37 @@ function Stop(opt, cmd) {
             var pidPath = _(GINA_RUNDIR +'/'+ bundle +'@'+ self.projectName +'.pid', true);
             try {
                 proc = fs.readFileSync(_(GINA_RUNDIR+'/'+bundle + '@' + self.projectName +'.pid')).toString().replace(/\n/g, '');
-                proc = parseInt(proc);
+                // #B693 (2026-09-27) — only a positive integer is a pid: parseInt made `-1` a
+                // broadcast to every process the user may signal, and `12abc` pid 12. Anything
+                // else reads as "is not running", as NaN did.
+                // was: proc = parseInt(proc);
+                proc = ( /^[1-9]\d*$/.test(proc.trim()) ) ? parseInt(proc.trim(), 10) : null;
 
             } catch(err) {
                 isSpecialCase = true;
                 // Some how pid file could have been deleted leaving a zombie process running
-                var list = execSync("ps -ef | grep -v grep | grep 'gina: "+ bundle + '@' + self.projectName +"' | awk '{print $2\" \"$8$9}'").toString().replace(/\n$/, '').split(/\n/g);
-                if (list.length && list[0] != '') {
-                    proc = ~~list[0].split(/\s+/)[0];
+                // #B665 (2026-09-27) — `ps` runs from an argument vector, without a shell, and its
+                // listing is filtered here: the names reached a `ps | grep | awk` command line
+                // single-quoted, so a `'` in a name broke out into the shell. The title must end
+                // at whitespace or the end of the line, so `api@shop` no longer matches the
+                // process of `api@shopping` (measured on macOS and Linux); lines naming `grep`
+                // are skipped as `grep -v grep` did.
+                // was: var list = execSync("ps -ef | grep -v grep | grep 'gina: "+ bundle + '@' + self.projectName +"' | awk '{print $2\" \"$8$9}'").toString().replace(/\n$/, '').split(/\n/g);
+                var titleRe = new RegExp('gina: ' + escapeRegex(bundle + '@' + self.projectName) + '(\\s|$)');
+                var psOut = '';
+                try {
+                    psOut = execFileSync('ps', ['-ef'], { maxBuffer: PS_MAX_BUFFER }).toString();
+                } catch (psErr) {
+                    // no `ps` (a slim container image): nothing matches, as before; a `ps` that
+                    // failed after printing keeps what it printed, as the pipeline did
+                    psOut = (psErr && psErr.stdout) ? psErr.stdout.toString() : '';
+                }
+                var list = psOut.split(/\n/).filter(function(line) {
+                    return line.indexOf('grep') < 0 && titleRe.test(line);
+                });
+                if (list.length) {
+                    // column 2 of `ps -ef` is the PID
+                    proc = ~~list[0].trim().split(/\s+/)[1];
                 } else {
                     error = err.toString();
                     console.debug(error);
@@ -112,7 +158,17 @@ function Stop(opt, cmd) {
                 //console.debug('\n'+ row.join('\n'));
                 //console.debug('kill -TERM ', proc, arr);
 
-                exec('kill -9 ' + proc, function(err, data) {
+                // #B665 S2 (2026-09-27) — the SIGKILL is sent in-process: `kill -9 <pid>` ran through
+                // sh. Its outcome is handled on the next turn of the event loop, as the exec
+                // callback was, and a failed signal (ESRCH, EPERM) is the callback's error.
+                // was: exec('kill -9 ' + proc, function(err, data) {
+                var killErr = null;
+                try {
+                    process.kill(proc, 'SIGKILL');
+                } catch (e) {
+                    killErr = e;
+                }
+                setImmediate(function(err) {
                     // just in case
                     if ( new _(pidPath).existsSync() ) {
                         isSpecialCase = true;
@@ -135,7 +191,7 @@ function Stop(opt, cmd) {
                             end(opt, cmd, isBulkStop, bundleIndex)
                         }
                     }
-                })
+                }, killErr)
             } else { // not running
                 //console.info('Bundle `' + bundle + '@' + self.projectName + '` is not running');
                 opt.client.write('  [ ' + bundle + '@' + self.projectName + ' ] is not running\n');

package/framework/{v0.7.0 → v0.7.1}/lib/cmd/env/remove.js

@@ -2,6 +2,7 @@ var fs          = require('fs');
 
 var CmdHelper   = require('./../helper');
 var console = lib.logger;
+var escapeRegex = require('./../bundle/inc/name-rewrite').escapeRegex;
 
 /**
  * @module gina/lib/cmd/env/remove
@@ -111,7 +112,10 @@ function Remove(opt, cmd) {
             , envs = requireJSON(envsPath);
 
 
-        var patt = new RegExp("\@"+ self.projectName +"/"+ env +"$");
+        // #B665 — the project and environment names are matched literally: a `.` matched
+        // any character, so removing `dev` from `my.app` also removed `my-app`'s entries.
+        // was: var patt = new RegExp("\@"+ self.projectName +"/"+ env +"$");
+        var patt = new RegExp('@' + escapeRegex(self.projectName +'/'+ env) + '$');
         for (let protocol in ports) {
             for (let scheme  in ports[protocol]) {
                 for (let p in ports[protocol][scheme]) {
@@ -122,7 +126,8 @@ function Remove(opt, cmd) {
             }
         }
 
-        patt = new RegExp("\@"+ self.projectName +"$");
+        // was: patt = new RegExp("\@"+ self.projectName +"$");
+        patt = new RegExp('@' + escapeRegex(self.projectName) + '$');
         for (let bundle in portsReverse) {
             if ( patt.test(bundle) ) {
                 for (let e in portsReverse[bundle]) {