gina 0.4.0 → 0.4.1

package/framework/v0.4.1/lib/cmd/protocol/remove.js

@@ -0,0 +1,308 @@
+var fs      = require('fs');
+var console = lib.logger;
+
+var CmdHelper = require('./../helper');
+
+/**
+ * @module gina/lib/cmd/protocol/remove
+ */
+/**
+ * Removes a bundle's protocol assignment — deletes the bundle's explicit
+ * `server.protocol` / `server.scheme` / `server.allowHTTP1` override from its
+ * own `config/settings.json`, reverting the bundle to the project's default
+ * protocol+scheme (`def_protocol` / `def_scheme` from `~/.gina/projects.json`).
+ *
+ * It touches ONLY the bundle's own `settings.json`. It deliberately does NOT
+ * mutate the shared `~/.gina/ports.json` / `ports.reverse.json` port maps:
+ * `project:add` pre-allocates the full protocol×scheme×env matrix for every
+ * bundle, so the default-protocol port already exists and the allocation is not
+ * "owned" by an individual `protocol:set`. At config-load time `core/config.js`
+ * fills an absent `server.protocol`/`scheme` from the project default, so
+ * deleting the override is safe — provided the default-protocol port is
+ * allocated (verified by a guard; overridable with `--force`).
+ *
+ * Bundle-scoped per help.txt: `gina protocol:remove <bundle> @<project>`.
+ *
+ * Usage:
+ *  gina protocol:remove <bundle_name> @<project_name>
+ *  gina protocol:remove <bundle_name> @<project_name> --dry-run
+ *  gina protocol:remove <bundle_name> @<project_name> --dry-run --format=json
+ *
+ * @class Remove
+ * @constructor
+ * @param {object} opt - Parsed command-line options
+ * @param {object} opt.client - Socket client for terminal output
+ * @param {string[]} opt.argv - Full argv array
+ * @param {number} [opt.debugPort] - Node.js inspector port
+ * @param {boolean} [opt.debugBrkEnabled] - True when --inspect-brk is active
+ * @param {object} cmd - The cmd dispatcher object (lib/cmd/index.js)
+ *
+ * @example
+ *  // revert a bundle to the project default protocol
+ *  $ gina protocol:remove api @myproject
+ *  Reverted bundle [ api@myproject ] from http/2.0/https to the project default http/1.1/http.
+ *  You need to restart your bundle.
+ *
+ * @example
+ *  // preview only, machine-readable
+ *  $ gina protocol:remove api @myproject --dry-run --format=json
+ *  {"bundle":"api","project":"myproject","dryRun":true,"from":{"protocol":"http/2.0","scheme":"https"},"to":{"protocol":"http/1.1","scheme":"http"},"forcedMissingPortEnvs":[]}
+ */
+function Remove(opt, cmd) {
+    var self = {};
+
+    /**
+     * Wires CmdHelper, validates the bundle + project, then runs the revert.
+     *
+     * @inner
+     * @private
+     */
+    var init = function() {
+
+        // import CMD helpers
+        new CmdHelper(self, opt.client, { port: opt.debugPort, brkEnabled: opt.debugBrkEnabled });
+        // check CMD configuration
+        if (!isCmdConfigured()) return false;
+
+        // protocol:remove is bundle-scoped (per help.txt) — a bundle positional
+        // is required; the project is resolved by CmdHelper (cwd-inferred or @<project>).
+        if ( typeof(self.name) == 'undefined' || self.name == null ) {
+            console.error('protocol:remove requires a bundle: gina protocol:remove <bundle_name> @<project_name>');
+            process.exit(1);
+            return;
+        }
+        if ( self.projectName == null || typeof(self.projects[self.projectName]) == 'undefined' ) {
+            console.error('[ '+ self.projectName +' ] is not a registered project.');
+            process.exit(1);
+            return;
+        }
+
+        // populate bundlesByProject[...].configPaths (mirrors set.js setBundleOnly)
+        loadAssets();
+
+        remove();
+    }
+
+
+    /**
+     * Header-preserving read of a JSON config (mirrors connector/remove.js):
+     * captures the leading comment header verbatim and parses the body with the
+     * comment-tolerant global `requireJSON`.
+     *
+     * @inner
+     * @private
+     * @param {string} target
+     * @returns {{header: string, data: object}|null}
+     */
+    var readSettings = function(target) {
+        if ( !fs.existsSync(target) ) {
+            console.error('Bundle settings `'+ target +'` does not exist — nothing to remove.');
+            process.exit(1);
+            return null;
+        }
+        var raw;
+        try {
+            raw = fs.readFileSync(target, 'utf8');
+        } catch (e) {
+            console.error('Cannot read `'+ target +'`: '+ e.message);
+            process.exit(1);
+            return null;
+        }
+        var firstBrace = raw.indexOf('{');
+        var header     = (firstBrace > 0) ? raw.slice(0, firstBrace) : '';
+        var data;
+        try {
+            data = requireJSON(target) || {};
+        } catch (e) {
+            console.error('Cannot parse `'+ target +'`: '+ e.message);
+            process.exit(1);
+            return null;
+        }
+        return { header: header, data: data };
+    }
+
+
+    /**
+     * Header-preserving write (mirrors connector/remove.js::writeFile) + evicts
+     * the require cache so a re-read in the same process sees the change.
+     *
+     * @inner
+     * @private
+     * @param {string} target
+     * @param {string} header
+     * @param {object} data
+     */
+    var writeSettings = function(target, header, data) {
+        var body = JSON.stringify(data, null, 4);
+        var text = (header || '') + body + '\n';
+        lib.generator.createFileFromDataSync(text, target);
+        try { delete require.cache[require.resolve(target)]; } catch (e) { /* not cached */ }
+    }
+
+
+    /**
+     * Returns the list of the bundle's envs that have NO port allocated for the
+     * project default protocol+scheme. An empty list means reverting is safe;
+     * a non-empty list means at least one env would be unrunnable after the
+     * revert (config.js emergs on a missing port) unless --force is used.
+     *
+     * @inner
+     * @private
+     * @param {string} defProtocol
+     * @param {string} defScheme
+     * @returns {string[]}
+     */
+    var checkDefaultPort = function(defProtocol, defScheme) {
+        var missing      = [];
+        var key          = self.name + '@' + self.projectName;
+        var portsReverse = {};
+        var prPath       = (self.portsReversePath) ? self.portsReversePath : _(GINA_HOMEDIR + '/ports.reverse.json');
+        try {
+            if ( fs.existsSync(prPath) ) {
+                portsReverse = requireJSON(prPath);
+            }
+        } catch (e) {
+            portsReverse = {};
+        }
+
+        var envs = self.envs || [];
+        for (var i = 0; i < envs.length; i++) {
+            var env     = envs[i];
+            var hasPort = portsReverse[key]
+                && portsReverse[key][env]
+                && portsReverse[key][env][defProtocol]
+                && typeof(portsReverse[key][env][defProtocol][defScheme]) != 'undefined';
+            if ( !hasPort ) {
+                missing.push(env);
+            }
+        }
+        return missing;
+    }
+
+
+    /**
+     * Prints the revert result (or dry-run preview) as text, or a
+     * `{ bundle, project, dryRun, from, to, forcedMissingPortEnvs }` envelope
+     * with `--format=json`, then exits.
+     *
+     * @inner
+     * @private
+     * @param {string|null} curProtocol
+     * @param {string|null} curScheme
+     * @param {string} defProtocol
+     * @param {string} defScheme
+     * @param {string[]} missingEnvs
+     * @param {boolean} dryRun
+     * @param {string|null} format
+     */
+    var report = function(curProtocol, curScheme, defProtocol, defScheme, missingEnvs, dryRun, format) {
+        if ( /^json?/.test(format) ) {
+            process.stdout.write(JSON.stringify({
+                bundle                : self.name,
+                project               : self.projectName,
+                dryRun                : dryRun,
+                from                  : { protocol: curProtocol, scheme: curScheme },
+                to                    : { protocol: defProtocol, scheme: defScheme },
+                forcedMissingPortEnvs : missingEnvs
+            }));
+            return process.exit(0);
+        }
+
+        var fromStr = (curProtocol || '(none)') + '/' + (curScheme || '(none)');
+        var toStr   = defProtocol + '/' + defScheme;
+        if ( dryRun ) {
+            console.log('[ dry-run ] would revert [ '+ self.name +'@'+ self.projectName +' ] from '+ fromStr +' to the project default '+ toStr +' (no changes written).');
+        } else {
+            console.log('Reverted bundle [ '+ self.name +'@'+ self.projectName +' ] from '+ fromStr +' to the project default '+ toStr +'.');
+            if ( missingEnvs.length > 0 ) {
+                console.log('  warning: no default-protocol port for env(s): '+ missingEnvs.join(', ') +' — run `gina protocol:set '+ self.name +' @'+ self.projectName +'` before starting those.');
+            }
+            console.log('You need to restart your bundle.');
+        }
+        process.exit(0);
+    }
+
+
+    /**
+     * Resolves the bundle's settings.json, reads the current override, guards
+     * the default-protocol port, then deletes the override (reverting to the
+     * project default) — unless --dry-run.
+     *
+     * @inner
+     * @private
+     */
+    var remove = function() {
+        var p      = self.params || {};
+        var dryRun = !!p['dry-run'];
+        var force  = !!p['force'];
+        var format = p['format'] || null;
+
+        var projectConf = self.projects[self.projectName];
+        var defProtocol = projectConf.def_protocol;
+        var defScheme   = projectConf.def_scheme;
+        if ( !defProtocol || !defScheme ) {
+            console.error('Project [ '+ self.projectName +' ] has no default protocol/scheme — cannot revert. Run `gina protocol:set @'+ self.projectName +'` first.');
+            process.exit(1);
+            return;
+        }
+
+        // resolve the bundle's settings.json (same path set.js writes to)
+        var bundleConfig = (self.bundlesByProject && self.bundlesByProject[self.projectName])
+            ? self.bundlesByProject[self.projectName][self.name]
+            : null;
+        if ( !bundleConfig || !bundleConfig.configPaths || !bundleConfig.configPaths.settings ) {
+            console.error('Bundle [ '+ self.name +' ] is not registered inside `@'+ self.projectName +'`.');
+            process.exit(1);
+            return;
+        }
+        var settingsPath = _(bundleConfig.configPaths.settings, true);
+
+        var parsed = readSettings(settingsPath);
+        if (!parsed) return;
+        var settings = parsed.data;
+
+        var curProtocol = (settings.server && settings.server.protocol) ? settings.server.protocol : null;
+        var curScheme   = (settings.server && settings.server.scheme)   ? settings.server.scheme   : null;
+
+        // nothing to remove — no override, or the override already equals default
+        if ( curProtocol == null && curScheme == null ) {
+            console.log('Bundle [ '+ self.name +'@'+ self.projectName +' ] has no protocol override — it already uses the project default '+ defProtocol +'/'+ defScheme +'. Nothing to remove.');
+            process.exit(0);
+            return;
+        }
+        if ( curProtocol === defProtocol && curScheme === defScheme ) {
+            console.log('Bundle [ '+ self.name +'@'+ self.projectName +' ] already uses the project default '+ defProtocol +'/'+ defScheme +'. Nothing to remove.');
+            process.exit(0);
+            return;
+        }
+
+        // port guard: reverting to a default that has no allocated port would
+        // make the bundle unrunnable (config.js emergs). Refuse unless --force.
+        var missingEnvs = checkDefaultPort(defProtocol, defScheme);
+        if ( missingEnvs.length > 0 && !force ) {
+            console.error('Bundle [ '+ self.name +'@'+ self.projectName +' ] has no port allocated for the project default protocol '+ defProtocol +'/'+ defScheme +' (env: '+ missingEnvs.join(', ') +'). Run `gina protocol:set '+ self.name +' @'+ self.projectName +'` to (re)assign a port, or re-run with --force to revert anyway.');
+            process.exit(1);
+            return;
+        }
+
+        if ( dryRun ) {
+            return report(curProtocol, curScheme, defProtocol, defScheme, missingEnvs, true, format);
+        }
+
+        // revert: drop the bundle's protocol override so config.js falls back
+        // to the project default at load time.
+        if ( settings.server ) {
+            delete settings.server.protocol;
+            delete settings.server.scheme;
+            delete settings.server.allowHTTP1;
+        }
+        writeSettings(settingsPath, parsed.header, settings);
+
+        report(curProtocol, curScheme, defProtocol, defScheme, missingEnvs, false, format);
+    }
+
+
+    init()
+};
+
+module.exports = Remove

package/framework/{v0.4.0 → v0.4.1}/lib/cmd/protocol/set.js

@@ -135,6 +135,18 @@ function Set(opt, cmd) {
             return;
         }
 
+        // Non-interactive guard: without a TTY (container, CI, piped/detached
+        // stdin) the module-scope readline closes on stdin EOF and the rl.prompt()
+        // below would throw ERR_USE_AFTER_CLOSE. Fail fast pointing at the flags.
+        if ( !process.stdin.isTTY || rl.closed ) {
+            console.error(
+                'protocol:set needs interactive input for '+ actionType +' ('+ name +') that cannot be read: stdin is not interactive (no TTY).\n'
+                + 'Re-run passing both --protocol and --scheme:\n'
+                + '  gina protocol:set <your args> --protocol=<http/1.1|http/2.0> --scheme=<http|https>'
+            );
+            return process.exit(1);
+        }
+
         choicesOpt.push('cancel');
 
         for (var p = 0, len = choicesOpt.length; p < len; ++p) {

package/framework/{v0.4.0 → v0.4.1}/lib/cmd/service/list.js

@@ -1,5 +1,6 @@
 var fs      = require('fs');
 var console = lib.logger;
+var fmt     = lib.cmdStatusFormat;
 
 var CmdHelper = require('./../helper');
 
@@ -105,8 +106,8 @@ function List(opt, cmd) {
             var srcExists  = src && fs.existsSync(_(ginaProject.path + '/' + src));
             var status     = srcExists ? 'ok' : '?!';
             var ports      = portsReverse[name + '@gina'] || null;
-            var preferred  = pickPreferredPort(ports);
-            var runState   = readPidfile(name);
+            var preferred  = fmt.pickPreferredPort(ports);
+            var runState   = fmt.readPidfile(GINA_HOMEDIR + '/run', name, 'gina');
 
             json.push({
                 service : name,
@@ -121,7 +122,7 @@ function List(opt, cmd) {
             var portLabel  = preferred
                 ? preferred.scheme + ' ' + preferred.env + ' ' + preferred.protocol + ' ' + preferred.port
                 : '(no port)';
-            var line = stateLabel + ' ' + pad(name, 14) + ' ' + portLabel;
+            var line = stateLabel + ' ' + fmt.pad(name, 14) + ' ' + portLabel;
             if (runState.running && runState.pid) {
                 line += '  pid ' + runState.pid;
             }
@@ -145,85 +146,6 @@ function List(opt, cmd) {
         process.exit(0);
     };
 
-    /**
-     * Right-pads `s` with spaces to reach `width`. Used for column alignment
-     * in the text output.
-     *
-     * @inner
-     * @private
-     * @param {string} s
-     * @param {number} width
-     * @returns {string}
-     */
-    var pad = function (s, width) {
-        var out = String(s || '');
-        while (out.length < width) {
-            out += ' ';
-        }
-        return out;
-    };
-
-    /**
-     * Picks the "preferred" port to display for a service: dev env, http/2.0
-     * https first, falling back to http/1.1 https, then http/1.1 http.
-     *
-     * @inner
-     * @private
-     * @param {object|null} ports - Port record from ports.reverse.json
-     * @returns {{env: string, scheme: string, protocol: string, port: number}|null}
-     */
-    var pickPreferredPort = function (ports) {
-        if (!ports) return null;
-        var envKey = ports.dev ? 'dev' : Object.keys(ports)[0];
-        if (!envKey) return null;
-        var env = ports[envKey];
-        if (!env) return null;
-
-        if (env['http/2.0'] && env['http/2.0'].https) {
-            return { env: envKey, scheme: 'http/2.0', protocol: 'https', port: env['http/2.0'].https };
-        }
-        if (env['http/1.1'] && env['http/1.1'].https) {
-            return { env: envKey, scheme: 'http/1.1', protocol: 'https', port: env['http/1.1'].https };
-        }
-        if (env['http/1.1'] && env['http/1.1'].http) {
-            return { env: envKey, scheme: 'http/1.1', protocol: 'http', port: env['http/1.1'].http };
-        }
-        return null;
-    };
-
-    /**
-     * Reads `~/.gina/run/<name>@gina.pid` and probes the process with
-     * `process.kill(pid, 0)`. Returns `running: false` on a stale pidfile
-     * but does not delete it — clean-up is bundle:stop's job.
-     *
-     * @inner
-     * @private
-     * @param {string} name - Service name (without the @gina suffix)
-     * @returns {{running: boolean, pid: number|null}}
-     */
-    var readPidfile = function (name) {
-        var pidPath = _(GINA_HOMEDIR + '/run/' + name + '@gina.pid');
-        if ( !fs.existsSync(pidPath) ) {
-            return { running: false, pid: null };
-        }
-        var raw;
-        try {
-            raw = fs.readFileSync(pidPath, 'utf8').trim();
-        } catch (e) {
-            return { running: false, pid: null };
-        }
-        var pid = parseInt(raw, 10);
-        if ( isNaN(pid) || pid <= 0 ) {
-            return { running: false, pid: null };
-        }
-        try {
-            process.kill(pid, 0);
-            return { running: true, pid: pid };
-        } catch (e) {
-            return { running: false, pid: null };
-        }
-    };
-
     init();
 }
 

package/framework/{v0.4.0 → v0.4.1}/lib/cmd/view/add.js

@@ -237,6 +237,19 @@ function Add(opt, cmd) {
         var folder  = _(local.src + '/templates');
 
         if ( fs.existsSync(target) || fs.existsSync(folder) ) {
+            // Non-interactive guard: without a TTY (container, CI, piped/detached
+            // stdin) the module-scope readline closes on stdin EOF and rl.prompt()
+            // would throw ERR_USE_AFTER_CLOSE. view:add has no skip flag, so fail
+            // fast and point at the existing files to remove for a clean recreate.
+            if ( !process.stdin.isTTY || rl.closed ) {
+                console.error(
+                    'Templates already exist for [ '+ local.bundle +'@'+ self.projectName +' ], and stdin is not interactive (no TTY) to confirm an override.\n'
+                    + 'Re-run in an interactive terminal, or remove the existing files first to recreate them:\n'
+                    + '  '+ target +'\n'
+                    + '  '+ folder
+                );
+                return process.exit(1);
+            }
             rl.setPrompt('Found templates for [ '+ local.bundle +'@'+ self.projectName +' ]. Do you want to override ? (yes|no) > \n');
             rl.prompt();
 

package/framework/v0.4.1/lib/cmd-status-format/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "gina-lib-cmd-status-format",
+  "version": "1.0.0",
+  "description": "Shared run-state / port display primitives (pad, pickPreferredPort, readPidfile) for the bundle:list / service:list / bundle:status / project:status CLI commands.",
+  "authors": [
+    {
+      "name": "Martin-Luther ETOUMAN",
+      "email": "contact@gina.io"
+    }
+  ],
+  "copyright": "Copyright (c) 2009-2026 Rhinostone <contact@gina.io>",
+  "engines": {
+    "node": ">=0.10.22"
+  },
+  "main": "src/main",
+  "license": "MIT"
+}

package/framework/v0.4.1/lib/cmd-status-format/src/main.js

@@ -0,0 +1,142 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2026 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * @module gina/lib/cmd-status-format
+ *
+ * Shared run-state / port display primitives for the bundle- and project-level
+ * CLI status commands (`bundle:list`, `service:list`, `bundle:status`,
+ * `project:status`). Each of those handlers previously carried its own
+ * byte-identical copy of `pad`, `pickPreferredPort`, and `readPidfile`; this
+ * module is the single source of truth.
+ *
+ * This module is pure — it requires only node builtins (`fs`, `path`), does
+ * not require `lib.*`, and does not read framework globals (`GINA_HOMEDIR`,
+ * `_`). Callers pass the run directory in (see {@link readPidfile}), so the
+ * module is unit-testable by a direct `require`. Same contract as
+ * {@link module:gina/lib/routing-introspect}.
+ *
+ * @example
+ * var fmt       = lib.cmdStatusFormat;
+ * var preferred = fmt.pickPreferredPort(ports);          // {env,scheme,protocol,port} | null
+ * var runState  = fmt.readPidfile(GINA_HOMEDIR + '/run', 'api', 'myproject');
+ * var line      = fmt.pad('api', 16) + ' ' + (preferred ? preferred.port : '(no port)');
+ */
+
+var fs   = require('fs');
+var path = require('path');
+
+/**
+ * Right-pads `s` with spaces to reach `width`. Used to align the port column
+ * after the bundle / service name in the text output. Coerces a falsy input
+ * to the empty string and never truncates (a string already at or beyond
+ * `width` is returned unchanged).
+ *
+ * @memberof module:gina/lib/cmd-status-format
+ * @param   {string} s
+ * @param   {number} width
+ * @returns {string}
+ *
+ * @example
+ * pad('api', 8);   // 'api     '
+ * pad('', 3);      // '   '
+ * pad('toolong', 4); // 'toolong' (unchanged — already wider than 4)
+ */
+var pad = function(s, width) {
+    var out = String(s || '');
+    while (out.length < width) {
+        out += ' ';
+    }
+    return out;
+};
+
+/**
+ * Picks the "preferred" port to display for a bundle / service from its
+ * `ports.reverse.json` record: the `dev` env when present (else the first env
+ * key), then `http/2.0 https` → `http/1.1 https` → `http/1.1 http`. Returns
+ * null when no port is allocated.
+ *
+ * @memberof module:gina/lib/cmd-status-format
+ * @param   {object|null} ports - Port record from ports.reverse.json
+ * @returns {{env: string, scheme: string, protocol: string, port: number}|null}
+ *
+ * @example
+ * pickPreferredPort({ dev: { 'http/2.0': { https: 4208 } } });
+ * // { env: 'dev', scheme: 'http/2.0', protocol: 'https', port: 4208 }
+ *
+ * @example
+ * pickPreferredPort(null);  // null
+ */
+var pickPreferredPort = function(ports) {
+    if (!ports) return null;
+    var envKey = ports.dev ? 'dev' : Object.keys(ports)[0];
+    if (!envKey) return null;
+    var env = ports[envKey];
+    if (!env) return null;
+
+    if (env['http/2.0'] && env['http/2.0'].https) {
+        return { env: envKey, scheme: 'http/2.0', protocol: 'https', port: env['http/2.0'].https };
+    }
+    if (env['http/1.1'] && env['http/1.1'].https) {
+        return { env: envKey, scheme: 'http/1.1', protocol: 'https', port: env['http/1.1'].https };
+    }
+    if (env['http/1.1'] && env['http/1.1'].http) {
+        return { env: envKey, scheme: 'http/1.1', protocol: 'http', port: env['http/1.1'].http };
+    }
+    return null;
+};
+
+/**
+ * Reads `<runDir>/<bundleName>@<projectName>.pid` and probes the pid with
+ * `process.kill(pid, 0)`. Returns `running: false` on a missing, unreadable,
+ * non-numeric, non-positive, or stale pidfile — and never deletes the file
+ * (clean-up stays with `bundle:stop`).
+ *
+ * `runDir` is passed in (rather than read from the `GINA_HOMEDIR` global) so
+ * the module stays pure and unit-testable. CLI-daemon callers pass
+ * `GINA_HOMEDIR + '/run'`; `service:list` passes `'gina'` as the project to
+ * resolve `<name>@gina.pid`.
+ *
+ * @memberof module:gina/lib/cmd-status-format
+ * @param   {string} runDir      - Directory holding the pidfiles (e.g. ~/.gina/run)
+ * @param   {string} bundleName
+ * @param   {string} projectName
+ * @returns {{running: boolean, pid: number|null}}
+ *
+ * @example
+ * readPidfile('/home/u/.gina/run', 'api', 'myproject');
+ * // { running: true, pid: 12345 }  — when the process is alive
+ */
+var readPidfile = function(runDir, bundleName, projectName) {
+    var pidPath = path.join(runDir, bundleName + '@' + projectName + '.pid');
+    if ( !fs.existsSync(pidPath) ) {
+        return { running: false, pid: null };
+    }
+    var raw;
+    try {
+        raw = fs.readFileSync(pidPath, 'utf8').trim();
+    } catch (e) {
+        return { running: false, pid: null };
+    }
+    var pid = parseInt(raw, 10);
+    if ( isNaN(pid) || pid <= 0 ) {
+        return { running: false, pid: null };
+    }
+    try {
+        process.kill(pid, 0);
+        return { running: true, pid: pid };
+    } catch (e) {
+        return { running: false, pid: null };
+    }
+};
+
+module.exports = {
+    pad               : pad,
+    pickPreferredPort : pickPreferredPort,
+    readPidfile       : readPidfile
+};

package/framework/{v0.4.0 → v0.4.1}/lib/collection/src/main.js

@@ -1,7 +1,4 @@
 'use strict';
-if ( typeof(module) !== 'undefined' && module.exports ) {
-    var lib = require('../../index');
-}
 
 /**
  * @module lib/collection

package/framework/{v0.4.0 → v0.4.1}/lib/index.js

@@ -114,6 +114,10 @@ function Lib() {
         // and bundle:mcp to parse URL patterns, methods, requirements, and derive
         // stable tool / operation identifiers.
         routingIntrospect: _require('./routing-introspect'),
+        // Shared run-state / port display primitives (pad, pickPreferredPort,
+        // readPidfile) for the bundle:list / service:list / bundle:status /
+        // project:status CLI handlers. Pure (same contract as routing-introspect).
+        cmdStatusFormat : _require('./cmd-status-format'),
         // Single source of truth for the connector driver → npm package + semver
         // range mapping. Consumed by the connector:* CLI handlers (connector:add
         // install hint + connector:add --install range resolution + connector:list

package/framework/{v0.4.0 → v0.4.1}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gina-framework",
-  "version": "0.3.16-alpha.3",
+  "version": "0.4.1-alpha.2",
   "dependencies": {
     "@rhinostone/swig": "^2.5.1",
     "intl-messageformat": "^11.2.4",

package/gna.js

@@ -15,14 +15,14 @@
 'use strict';
 
 // Framework core — the main gna module (lifecycle hooks, lib, etc.)
-var _gna = require('./framework/v0.4.0/core/gna');
+var _gna = require('./framework/v0.4.1/core/gna');
 
 // SuperController and EntitySuper — loaded from their source modules
-var SuperController = require('./framework/v0.4.0/core/controller');
-var EntitySuper     = require('./framework/v0.4.0/core/model/entity');
+var SuperController = require('./framework/v0.4.1/core/controller');
+var EntitySuper     = require('./framework/v0.4.1/core/model/entity');
 
 // uuid — from the lib registry
-var uuid = require('./framework/v0.4.0/lib/uuid');
+var uuid = require('./framework/v0.4.1/lib/uuid');
 
 module.exports = {