gina 0.3.13-alpha.2 → 0.3.13

package/framework/{v0.3.13-alpha.2 → v0.3.13}/core/server.isaac.js

@@ -64,15 +64,28 @@ var refreshCore = function() {
         }
     }
 
-    // Update lib & helpers
-    delete require.cache[require.resolve(_(libPath +'/index.js', true))];
-    require.cache[_(libPath +'/index.js', true)] = require( _(libPath +'/index.js', true) );
-    require.cache[_(corePath + '/gna.js', true)].exports.lib = require.cache[_(libPath +'/index.js', true)];
-
-    // Update plugins
-    delete require.cache[require.resolve(_(corePath +'/plugins/index.js', true))];
-    require.cache[_(corePath +'/plugins/index.js', true)] = require( _(corePath +'/plugins/index.js', true) );
-    require.cache[_(corePath + '/gna.js', true)].exports.plugins = require.cache[_(corePath +'/plugins/index.js', true)];
+    // Update lib & helpers.
+    //
+    // `require.cache[<path>] = require(<path>)` would overwrite the cache entry
+    // — which Node expects to be a `Module` instance with an `.exports` property
+    // — with the lib registry's *exports object* directly. Subsequent plain
+    // `require('../../lib')` calls then read `require.cache[<path>].exports` and
+    // get `undefined` (the registry object has no `.exports` key), surfacing as
+    // `Cannot read properties of undefined (reading 'Collection')` / `(reading
+    // 'Cache')` etc. in the controller render delegates after a dev-mode hot
+    // reload. Fix: delete the entry and let the next require() rebuild a proper
+    // Module, then point gna.js's captured `.lib` at the fresh exports — the
+    // same `.exports`-preserving shape the loop above already uses.
+    var libIndexPath = _(libPath +'/index.js', true);
+    delete require.cache[require.resolve(libIndexPath)];
+    var freshLib = require( libIndexPath );
+    require.cache[_(corePath + '/gna.js', true)].exports.lib = freshLib;
+
+    // Update plugins — same fix as above.
+    var pluginsIndexPath = _(corePath +'/plugins/index.js', true);
+    delete require.cache[require.resolve(pluginsIndexPath)];
+    var freshPlugins = require( pluginsIndexPath );
+    require.cache[_(corePath + '/gna.js', true)].exports.plugins = freshPlugins;
 }
 
 // Express compatibility
@@ -325,6 +338,12 @@ function ServerEngineClass(options) {
         // #H3 — CONTINUATION flood defense (CVE-2024-27316, CVE-2024-27983)
         // #H7 — configurable via settings.json http2Options.maxSessionInvalidFrames (default 1000)
         http2Options.maxSessionInvalidFrames = _h2Opts.maxSessionInvalidFrames || 1000;
+        // #H9 — rapid-reset rate limit: max new streams accepted per session per
+        // rolling 1s window before the session is GOAWAY'd + closed. Defends against
+        // CVE-2023-44487-style rapid-reset floods (open then immediately RST streams
+        // faster than maxConcurrentStreams alone can throttle). Configurable via
+        // settings.json http2Options.maxStreamsPerSecond (default 200).
+        var _maxStreamsPerSec = _h2Opts.maxStreamsPerSecond || 200;
         var http2   = require('http2');
         switch (options.scheme) {
             case 'http':
@@ -345,7 +364,8 @@ function ServerEngineClass(options) {
             activeSessions : 0,
             totalStreams    : 0,
             goawayCount     : 0,
-            rstCount        : 0
+            rstCount        : 0,
+            rapidResetBlocked : 0
         };
         server._h2Metrics = _h2Metrics;
 
@@ -369,6 +389,30 @@ function ServerEngineClass(options) {
 
             session.on('stream', (stream) => {
                 _h2Metrics.totalStreams++;
+
+                // #H9 — rapid-reset rate limit. Count new streams in a rolling 1s
+                // window per session; on breach send GOAWAY(ENHANCE_YOUR_CALM) and
+                // close the session so a flood cannot exhaust the worker.
+                var _now = Date.now();
+                if (typeof session._streamWindowStart === 'undefined' || (_now - session._streamWindowStart) >= 1000) {
+                    session._streamWindowStart = _now;
+                    session._streamWindowCount = 0;
+                }
+                session._streamWindowCount++;
+                if (session._streamWindowCount > _maxStreamsPerSec) {
+                    _h2Metrics.rapidResetBlocked++;
+                    console.warn('[ SERVER ] HTTP/2 rapid-reset rate limit exceeded — ' + session._streamWindowCount + ' streams in <1s (limit ' + _maxStreamsPerSec + '); sending GOAWAY + closing session');
+                    session.goaway(http2.constants.NGHTTP2_ENHANCE_YOUR_CALM);
+                    session.close();
+                    // Deliberately return before registering the per-stream
+                    // `rstCode` listener below: the session is being torn down,
+                    // so the breaching stream needs no per-stream accounting.
+                    // Breached streams are counted by `rapidResetBlocked`, not
+                    // `rstCount` — the two metrics stay cleanly separated
+                    // (proactive block vs. observed client RST_STREAM).
+                    return;
+                }
+
                 stream.on('rstCode', (code) => {
                     if (code !== 0) _h2Metrics.rstCount++;
                 });
@@ -630,7 +674,8 @@ function ServerEngineClass(options) {
                         activeSessions : server._h2Metrics.activeSessions,
                         totalStreams    : server._h2Metrics.totalStreams,
                         goawayCount    : server._h2Metrics.goawayCount,
-                        rstCount       : server._h2Metrics.rstCount
+                        rstCount       : server._h2Metrics.rstCount,
+                        rapidResetBlocked : server._h2Metrics.rapidResetBlocked
                     };
                 }
                 const infoStatus = JSON.stringify(infoPayload);

package/framework/{v0.3.13-alpha.2 → v0.3.13}/core/template/boilerplate/bundle/config/settings.server.json

@@ -21,12 +21,14 @@
     * initialWindowSize        : flow-control window in bytes (default: 655350 = 10× Node default)
     * maxSessionRejectedStreams : RST flood defense — CVE-2019-9514, CVE-2023-44487 (default: 100)
     * maxSessionInvalidFrames  : CONTINUATION flood defense — CVE-2024-27316, CVE-2024-27983 (default: 1000)
+    * maxStreamsPerSecond       : rapid-reset rate limit — max new streams per session per rolling 1s window before GOAWAY + close — CVE-2023-44487 (default: 200)
     */
     // "http2Options": {
     //     "maxConcurrentStreams": 256,
     //     "initialWindowSize": 655350,
     //     "maxSessionRejectedStreams": 100,
-    //     "maxSessionInvalidFrames": 1000
+    //     "maxSessionInvalidFrames": 1000,
+    //     "maxStreamsPerSecond": 200
     // },
 
     /**

package/framework/{v0.3.13-alpha.2 → v0.3.13}/core/template/boilerplate/bundle/index.js

@@ -40,23 +40,33 @@ var ${bundle} = require('gina');
 //    // expressSession.name = 'myDb';
 //    //
 //    // var StoreClass = new SessionStore(expressSession);  // returns connector-specific Store class
+//    //
+//    // Recommended: keep the session secret out of tracked source via the
+//    // ${secret:KEY} placeholder pattern. Put it in bundle/config/session.json:
+//    //   { "secret": "${secret:SESSION_SECRET}" }
+//    // then read via self.getConfig('session').secret. lib/secrets fills
+//    // the placeholder from process.env.SESSION_SECRET at config-load time.
+//    // See https://gina.io/docs/guides/secrets for details.
+//    //
 //    // app.use(session({
-//    //     secret           : process.env.SESSION_SECRET || 'changeme',
+//    //     secret           : self.getConfig('session').secret,  // ${secret:SESSION_SECRET}
 //    //     resave           : false,
 //    //     saveUninitialized: false,
 //    //     store            : new StoreClass(),
 //    //     cookie           : { maxAge: 86400000 }
 //    // }));
 //    //
-//    // #CSRF2 — signed double-submit token middleware. Reads
-//    // process.env.GINA_CSRF_SECRET (generate with `openssl rand -base64 64`).
+//    // #CSRF2 — signed double-submit token middleware. Reads its HMAC secret
+//    // from settings.json > csrf.secret (recommended; supports ${secret:KEY}
+//    // placeholders), or falls back to process.env.GINA_CSRF_SECRET
+//    // (back-compat). Generate the secret once with `openssl rand -base64 64`.
 //    // MUST be registered AFTER the session middleware. Per-route opt-out
 //    // for webhook receivers via `routing.json > "csrfExempt": true`.
 //    // var csrf = ${bundle}.plugins.Csrf();
 //    // app.use(csrf);
 //
 //    // you can also use express middleware components directly (no #CSRF1 hardening)
-//    // eg.: app.use( expressSession({secret: '1234567890QWERTY'}) );
+//    // eg.: app.use( expressSession({secret: process.env.SESSION_SECRET}) );
 //
 //    //then notify the server that startup sequence can be resumed
 //    event.emit('complete', app);// this is important !

package/framework/v0.3.13/core/template/boilerplate/bundle_public/manifest.webmanifest

@@ -0,0 +1,17 @@
+{
+    "name": "Gina Bundle",
+    "short_name": "Gina",
+    "description": "A Gina bundle — edit this manifest to describe your app.",
+    "start_url": "/",
+    "scope": "/",
+    "display": "standalone",
+    "theme_color": "#2b2b2b",
+    "background_color": "#ffffff",
+    "icons": [
+        {
+            "src": "/favicon.ico",
+            "sizes": "any",
+            "type": "image/x-icon"
+        }
+    ]
+}

package/framework/v0.3.13/core/template/boilerplate/bundle_public/readme.md

@@ -0,0 +1,20 @@
+`public` is the public directory.
+
+## Progressive Web App (PWA)
+
+This bundle is scaffolded with a starter PWA setup:
+
+- `manifest.webmanifest` — the web app manifest (name, theme colour, icons, ...). Edit it to describe your app.
+- `sw.js` — a service worker with a basic cache-first strategy. Edit `CACHE_NAME` and the precache list for your app.
+
+The default layout (`templates/html/layouts/main.html`) already links the manifest and registers the service worker.
+
+### Icons
+
+No icon binaries ship with the scaffold — drop your own PNGs into this directory:
+
+- `icon-192.png` — 192x192
+- `icon-512.png` — 512x512
+- `apple-touch-icon.png` — 180x180, used by `main.html` for the iOS home-screen icon
+
+`favicon.ico` is the baseline icon already wired into `manifest.webmanifest`. Once you add the PNGs above, extend the `icons` array in `manifest.webmanifest` to point at them.

package/framework/v0.3.13/core/template/boilerplate/bundle_public/sw.js

@@ -0,0 +1,122 @@
+/**
+ * Service worker for a Gina bundle — basic cache-first strategy.
+ *
+ * Starting point only: it pre-caches a small app shell on install and serves
+ * cached responses first, falling back to the network. Edit CACHE_NAME and
+ * PRECACHE_URLS for your app, and extend the fetch strategy as needed
+ * (network-first for APIs, stale-while-revalidate for assets, ...).
+ *
+ * Registered by the default layout (templates/html/layouts/main.html). Served
+ * at /sw.js: a service worker's scope is the directory it is served from, so
+ * keeping it at the public root gives it whole-origin scope.
+ */
+
+'use strict';
+
+/**
+ * Cache bucket name. Bump the version suffix whenever the precache list or any
+ * cached asset changes — the activate handler purges every other bucket.
+ *
+ * @constant {string}
+ */
+var CACHE_NAME = 'gina-bundle-cache-v1';
+
+/**
+ * App-shell URLs pre-cached at install time. Keep this list short — just the
+ * entry points needed to render the first screen offline.
+ *
+ * @constant {string[]}
+ */
+var PRECACHE_URLS = [
+    '/',
+    '/manifest.webmanifest'
+];
+
+/**
+ * Install handler — opens the cache bucket, pre-caches the app shell, then
+ * activates this worker immediately instead of waiting for open clients to
+ * close.
+ *
+ * @param {ExtendableEvent} event - The service worker `install` event.
+ * @returns {void}
+ *
+ * @example
+ * // Fired automatically by the browser after registration.
+ */
+self.addEventListener('install', function (event) {
+    event.waitUntil(
+        caches.open(CACHE_NAME).then(function (cache) {
+            return cache.addAll(PRECACHE_URLS);
+        })
+    );
+    self.skipWaiting();
+});
+
+/**
+ * Activate handler — purges cache buckets left over from previous versions,
+ * then takes control of open clients without waiting for a reload.
+ *
+ * @param {ExtendableEvent} event - The service worker `activate` event.
+ * @returns {void}
+ *
+ * @example
+ * // Fired automatically by the browser once the new worker takes over.
+ */
+self.addEventListener('activate', function (event) {
+    event.waitUntil(
+        caches.keys().then(function (keys) {
+            return Promise.all(keys.map(function (key) {
+                return (key === CACHE_NAME) ? null : caches.delete(key);
+            }));
+        })
+    );
+    self.clients.claim();
+});
+
+/**
+ * Fetch handler — cache-first. Returns the cached response when one exists,
+ * otherwise fetches from the network and caches a copy of successful
+ * same-origin GET responses for next time. When the network is unreachable
+ * and nothing is cached, navigations fall back to the precached app shell.
+ *
+ * @param {FetchEvent} event - The service worker `fetch` event.
+ * @returns {void}
+ *
+ * @example
+ * // Fired automatically by the browser for every same-scope request.
+ */
+self.addEventListener('fetch', function (event) {
+    // Only GET requests are cacheable — let the browser handle the rest.
+    if (event.request.method !== 'GET') {
+        return;
+    }
+
+    event.respondWith(
+        caches.match(event.request).then(function (cached) {
+            if (cached) {
+                return cached;
+            }
+
+            return fetch(event.request).then(function (response) {
+                // Only cache valid, basic (same-origin) responses.
+                if (!response || response.status !== 200 || response.type !== 'basic') {
+                    return response;
+                }
+
+                var copy = response.clone();
+                caches.open(CACHE_NAME).then(function (cache) {
+                    cache.put(event.request, copy);
+                });
+
+                return response;
+            }).catch(function () {
+                // Offline with no cached copy — fall back to the precached app
+                // shell for navigations so the page still renders; other
+                // requests surface the network error as they normally would.
+                if (event.request.mode === 'navigate') {
+                    return caches.match('/');
+                }
+            });
+        })
+    );
+});

package/framework/{v0.3.13-alpha.2 → v0.3.13}/core/template/boilerplate/bundle_templates/html/layouts/main.html

@@ -9,6 +9,20 @@
         <meta name="robots" content="index, follow, noarchive">
         <meta name="distribution" content="global">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <link rel="manifest" href="/manifest.webmanifest">
+        <meta name="theme-color" content="#2b2b2b">
+        <link rel="apple-touch-icon" href="/apple-touch-icon.png">
+        <script>
+            // Progressive Web App — register the service worker (see public/sw.js).
+            // Edit or remove this block to change PWA behaviour.
+            if ('serviceWorker' in navigator) {
+                window.addEventListener('load', function () {
+                    navigator.serviceWorker.register('/sw.js').catch(function (err) {
+                        console.warn('Service worker registration failed:', err);
+                    });
+                });
+            }
+        </script>
     </head>
     <body>
         <div class="outer-wrap">

package/framework/{v0.3.13-alpha.2 → v0.3.13}/core/template/conf/settings.json

@@ -31,11 +31,13 @@
     // initialWindowSize        : flow-control window in bytes (Node default: 65535, Gina default: 655350 = 10×).
     // maxSessionRejectedStreams : RST flood defense — CVE-2019-9514, CVE-2023-44487 (default: 100).
     // maxSessionInvalidFrames  : CONTINUATION flood defense — CVE-2024-27316, CVE-2024-27983 (default: 1000).
+    // maxStreamsPerSecond       : rapid-reset rate limit — max new streams per session per rolling 1s window before GOAWAY + close — CVE-2023-44487 (default: 200).
     "http2Options": {
       "maxConcurrentStreams": 256,
       "initialWindowSize": 655350,
       "maxSessionRejectedStreams": 100,
-      "maxSessionInvalidFrames": 1000
+      "maxSessionInvalidFrames": 1000,
+      "maxStreamsPerSecond": 200
     },
     // Compare with core/content.encoding
     // This is the prefered order when it comes to respond with compressed content
@@ -83,9 +85,14 @@
     }
   },
   // #CSRF2 / #CSRF3 — signed double-submit token middleware + Origin/Referer
-  // pre-filter applied by gina.plugins.Csrf(). The secret lives in
-  // `process.env.GINA_CSRF_SECRET` (NOT in this file) — generate with
-  // `openssl rand -base64 64` and store in env.json or your shell profile.
+  // pre-filter applied by gina.plugins.Csrf(). Generate the HMAC secret with
+  // `openssl rand -base64 64`.
+  //
+  //   secret         — HMAC signing key. Supports ${secret:KEY} placeholders
+  //                    (lib/secrets fills them from process.env at config-load
+  //                    time). Falls back to process.env.GINA_CSRF_SECRET when
+  //                    this field is empty or absent (back-compat). Example:
+  //                    "secret": "${secret:MY_CSRF_KEY}".
   //   cookieName     — cookie name issued on safe methods
   //   headerName     — request header read on mutating methods
   //   fieldName      — form field read on mutating methods

package/framework/{v0.3.13-alpha.2 → v0.3.13}/helpers/json/src/main.js

@@ -21,21 +21,35 @@ module.exports = function(){
     // `JSON.clone()` is a prototype defined in `GINA_DIR//lib/prototypes.json_clone`
 
     /**
-     * Load a json file and removing comments if found
+     * Load a JSON file, stripping JS-style block (`/* ... *\/`) and line (`// ...`)
+     * comments before parsing. Trailing commas before `}`/`]` are tolerated with
+     * a warning. Line-comment stripping is per-line on the leftmost `//`: when
+     * that `//` is preceded by `:` (URL protocol), `"` (inside a string value),
+     * or `\` (escape), the entire line is treated as data and left alone — so
+     * values like `"http://host//:rest"` round-trip unchanged.
      *
-     * @param {string} filename - path to json content
+     * On a real syntax error the helper logs via `console.emerg` and exits with
+     * code 1; on unexpected I/O failure it rethrows.
      *
-     * @return {object} jsonObject
+     * @param {string} filename - absolute or relative path to the JSON-with-comments file
+     *
+     * @return {object} parsed JSON object
+     *
+     * @example
+     * // file: app.json
+     * //   {
+     * //     "url": "https://example.com/foo",
+     * //     // a bare line-comment separator
+     * //     "value": 1
+     * //   }
+     * var config = requireJSON(__dirname + '/app.json');
+     * // → { url: 'https://example.com/foo', value: 1 }
      * */
     requireJSON = function(filename){
 
         //console.debug('[ Helpers ][ requireJSON ] ', filename);
 
-        var i                       = null
-            , len                   = null
-            , commentsWithSlashes = null
-            , jsonStr               = null
-        ;
+        var jsonStr = null;
 
         try {
             if (
@@ -60,22 +74,24 @@ module.exports = function(){
             jsonStr   = jsonStr.replace(/(\/\*([^*]|[\r\n]|(\*+([^*\/]|[\r\n])))*\*+\/)/g, '');
         }
 
-        // line style comments
-        commentsWithSlashes = jsonStr.match(/\/\/(.*)?/g);
-
-        len = ( commentsWithSlashes) ? commentsWithSlashes.length : 0;
-        if (commentsWithSlashes && len > 0) {
-            i = 0;
-            for(; i< len; ++i) {
-                // ignore urls
-                // if ( /(\:|\")/.test( jsonStr.substring(jsonStr.indexOf(commentsWithSlashes[i])-1,1) ) ) {
-                if ( /(\:|\")/.test( jsonStr.substr(jsonStr.indexOf(commentsWithSlashes[i])-1,1) ) ) {
-                    continue;
+        // line style comments — per-line, leftmost `//` only. When the leftmost
+        // `//` on a line is preceded by `:` (URL protocol), `"` (inside a string
+        // value), or `\` (escape), the entire line is treated as data and left
+        // alone — mirrors the original greedy-from-first-match heuristic so
+        // values like "http://host//:rest" round-trip unchanged.
+        jsonStr = jsonStr.split('\n').map(function(line) {
+            var idx = line.indexOf('//');
+            if (idx === -1) {
+                return line;
+            }
+            if (idx > 0) {
+                var prev = line.charAt(idx - 1);
+                if (prev === ':' || prev === '"' || prev === '\\') {
+                    return line;
                 }
-
-                jsonStr = jsonStr.replace(commentsWithSlashes[i], '');
             }
-        }
+            return line.substring(0, idx);
+        }).join('\n');
 
         try {
             return JSON.parse(jsonStr)

package/framework/{v0.3.13-alpha.2 → v0.3.13}/lib/cmd/bundle/mcp-start.js

@@ -4,6 +4,7 @@ var console     = lib.logger;
 var mcpServer   = lib.mcpServer;
 var mcpDispatch = lib.mcpDispatch;
 var mcpHttp     = lib.mcpHttp;
+var secrets     = lib.secrets;
 
 /**
  * @module gina/lib/cmd/bundle/mcp-start
@@ -136,6 +137,19 @@ function MCPStart(opt, cmd) {
             return end( new Error(mcpPath +' is not a valid MCP manifest (missing `tools` array)') );
         }
 
+        // ${secret:KEY} placeholder substitution. The cmd handler loads mcp.json
+        // directly (it is not part of the bundle-config tree walked by
+        // core/config.js::loadBundleConfig), so the resolver hook on bundle
+        // start does NOT see this document. Run resolve() here so that
+        // `server.authToken` (and any other future placeholder field in
+        // mcp.json) gets filled from process.env before downstream readers
+        // pick it up.
+        try {
+            secrets.resolve(mcpDoc);
+        } catch (secretErr) {
+            return end( new Error('Failed to resolve secrets in '+ mcpPath +': '+ secretErr.message) );
+        }
+
         var baseUrl = buildBaseUrl(bundle, mcpDoc);
 
         // Loud, one-time notice about the tools that look session-scoped.
@@ -399,8 +413,10 @@ function MCPStart(opt, cmd) {
     /**
      * Resolves the static bearer token. Precedence:
      *   1. `--auth-token=<token>` CLI flag
-     *   2. `mcp.json > server > authToken`
-     *   3. `process.env.GINA_MCP_AUTH_TOKEN`
+     *   2. `mcp.json > server > authToken` — supports `${secret:KEY}` placeholders
+     *      (resolved at handler entry by `lib/secrets` against `process.env`).
+     *   3. `process.env.GINA_MCP_AUTH_TOKEN` — direct fallback when neither the
+     *      CLI flag nor the mcp.json field is set.
      *   4. `null` (no auth; loopback bind is the security boundary)
      *
      * @private

package/framework/{v0.3.13-alpha.2 → v0.3.13}/lib/index.js

@@ -128,6 +128,11 @@ function Lib() {
         // instance with an HTTP endpoint (POST, JSON/SSE negotiation, batch,
         // Mcp-Session-Id lifecycle). Auth / Origin checks land in Phase 2b S2.
         mcpHttp         : _require('./mcp-http'),
+        // ${secret:KEY} placeholder resolver for bundle JSON configs. Walks
+        // the merged config object in place at config-load time (per-bundle,
+        // inside loadBundleConfig). Default backend reads process.env[KEY];
+        // fail-closed on unset/empty values. See lib/secrets/src/main.js.
+        secrets         : _require('./secrets'),
     };
 
     /**

package/framework/{v0.3.13-alpha.2 → v0.3.13}/lib/logger/src/containers/file/index.js

@@ -10,11 +10,8 @@ const net                 = require('net');
 
 var helpers = null;
 
+// #M22 — merge-eval fallback removed (sister fix to lib/merge/src/main.js direct json_clone require)
 var merge     = require(__dirname + '/../../../../merge');
-if ( typeof(merge) != 'function' ) {
-    // if needed for unit tests
-    merge = eval(fs.readFileSync(__dirname +'/../../../../merge/src/main.js').toString())
-}
 
 function FileContainer(opt, loggers) {
     var self = {

package/framework/{v0.3.13-alpha.2 → v0.3.13}/lib/logger/src/containers/mq/index.js

@@ -4,11 +4,8 @@ const fs          = require('fs');
 const net         = require('net');
 const util        = require('util');
 const promisify   = util.promisify;
+// #M22 — merge-eval fallback removed (sister fix to lib/merge/src/main.js direct json_clone require)
 var merge         = require(__dirname +'/../../../../merge');
-if ( typeof(merge) != 'function' ) {
-    // if needed for unit tests
-    merge = eval(fs.readFileSync(__dirname +'/../../../../merge/src/main.js').toString())
-}
 function MqContainer(opt, loggers) {
     var self = {
         // flow or container name/id

package/framework/{v0.3.13-alpha.2 → v0.3.13}/lib/logger/src/main.js

@@ -63,11 +63,8 @@ var merge           = require('../../merge');
 var inherits        = require('../../inherits');
 var helpers         = require('../../../helpers');
 
+// #M22 — merge-eval fallback removed; the circular chain that produced a partial merge was broken at the merge.js side (direct require of utils/prototypes.json_clone instead of helpers/index.js's for-loop loader, which transitively required lib/logger).
 // BO - publishing hack
-if ( typeof(merge) != 'function' ) {
-    // if needed for unit tests
-    merge = eval(fs.readFileSync(__dirname +'/../../merge/src/main.js').toString())
-}
 if ( typeof(JSON.clone) == 'undefined' ) {
     require(__dirname +'/../../../helpers/prototypes')()
 }

package/framework/{v0.3.13-alpha.2 → v0.3.13}/lib/merge/src/main.js

@@ -583,7 +583,8 @@ function Merge() {
 if ( ( typeof(module) !== 'undefined' ) && module.exports ) {
     // for unit tests
     if ( typeof(JSON.clone) == 'undefined' ) {
-        require('../../../helpers');
+        // #M22 — direct require of the clone primitive instead of helpers/index.js's for-loop loader (which transitively requires lib/logger and returns a partial merge under circular load)
+        JSON.clone = require(__dirname + '/../../../../../utils/prototypes.json_clone');
     }
     // Publish as node.js module
     module.exports = Merge()

package/framework/v0.3.13/lib/secrets/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "gina-lib-secrets",
+  "version": "1.0.0",
+  "description": "Resolver for ${secret:KEY} placeholders in bundle JSON configs. Substituted at config-load time from a pluggable backend (default: process.env).",
+  "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.3.13/lib/secrets/src/backends/env.js

@@ -0,0 +1,60 @@
+'use strict';
+/*
+ * 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 lib/secrets/backends/env
+ * @description `process.env`-backed resolver for `${secret:KEY}` placeholders.
+ * Reads the raw value from `process.env[key]`. Throws the generic
+ * `'Secret resolution failed'` Error when the env var is unset or empty —
+ * the user-facing message intentionally omits the key name. The key is
+ * attached non-enumerably to the thrown Error as `_ginaSecretKey` so
+ * callers can log it at debug level without leaking it through `toString()`.
+ */
+
+/**
+ * Resolve a secret key against `process.env`.
+ *
+ * @memberof module:lib/secrets/backends/env
+ * @function resolve
+ * @param {string} key - Placeholder key, e.g. `'DB_PASSWORD'`
+ * @returns {string} Non-empty env-var value
+ * @throws {Error} `'Secret resolution failed'` when `process.env[key]` is unset or empty
+ *
+ * @example
+ * var env = require('./backends/env');
+ * process.env.DB_PASSWORD = 's3cret';
+ * env.resolve('DB_PASSWORD'); // → 's3cret'
+ *
+ * @example
+ * delete process.env.MISSING;
+ * try {
+ *     env.resolve('MISSING');
+ * } catch (e) {
+ *     e.message;          // 'Secret resolution failed'  ← no key name
+ *     e._ginaSecretKey;   // 'MISSING'                  ← non-enumerable, for debug logging
+ * }
+ */
+function resolve(key) {
+    var value = process.env[key];
+    if (typeof value !== 'string' || value === '') {
+        var err = new Error('Secret resolution failed');
+        Object.defineProperty(err, '_ginaSecretKey', {
+            value: key,
+            enumerable: false,
+            configurable: true,
+            writable: true
+        });
+        throw err;
+    }
+    return value;
+}
+
+module.exports = {
+    resolve: resolve
+};