@yemi33/minions 0.1.1949 → 0.1.1950

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-14T23:08:33.100Z"
+  "cachedAt": "2026-05-15T00:20:53.688Z"
 }

package/engine/shared.js

@@ -2335,6 +2335,11 @@ function sanitizePath(file, baseDir) {
 
 const _DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 
+// DoS caps for the recursive walk. Reaching either limit is treated as
+// "dangerous" — see hasDangerousKey() for rationale (P-e8b1d3a6 / F6).
+const HAS_DANGEROUS_KEY_MAX_DEPTH = 64;
+const HAS_DANGEROUS_KEY_MAX_NODES = 10000;
+
 /**
  * Detect the presence of prototype-pollution attack keys in a JSON-decoded payload.
  *
@@ -2345,43 +2350,55 @@ const _DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
  * but downstream code that shallow-merges the payload into a target object
  * CAN elevate it into a prototype write.
  *
- * Contract is **rejection, not sanitization**: we inspect the top level plus
- * one level deep and return a boolean. Deeper walks are intentionally skipped
- * to avoid their own DoS pathologies on adversarial inputs.
+ * Contract is **rejection, not sanitization**: we walk the full tree and
+ * return a boolean. To avoid DoS via deeply-nested or pathologically-wide
+ * inputs (stack exhaustion, unbounded CPU), the walk is capped:
+ *
+ * - Recursion depth > {@link HAS_DANGEROUS_KEY_MAX_DEPTH} (64) → return true.
+ * - Total visited nodes > {@link HAS_DANGEROUS_KEY_MAX_NODES} (10000) → return true.
+ *   Every recursive call counts (including primitive leaves and array elements),
+ *   so a pathologically wide payload trips the cap even if no key is dangerous.
+ *
+ * Returning `true` on overflow is the safe-by-default policy: the sole
+ * caller (dashboard.js request-body guard) rejects on `true`, so degrading
+ * to rejection is conservative. The caps also protect against cyclic
+ * objects, since each visit increments the node counter.
  *
  * - Null / undefined / primitives → false.
  * - Arrays are transparent: each element is checked at the same depth as the
- *   array itself (an array does NOT consume a depth level).
- * - Max object nesting inspected: 1. Dangerous keys at object-depth 2+
- *   are intentionally NOT flagged.
+ *   array itself (an array does NOT consume a depth level), but each element
+ *   visit increments the node counter.
  * - Never mutates the input.
  *
  * @param {*} obj - any JSON-decoded value
  * @param {number} [_depth=0] - internal recursion counter; do not pass externally
- * @returns {boolean} true if any forbidden key is present at object-depth ≤ 1
+ * @param {{n:number}} [_nodeCount={n:0}] - internal mutable node counter; do not pass externally
+ * @returns {boolean} true if any forbidden key is present, or if the depth/node cap is exceeded
  */
-function hasDangerousKey(obj, _depth = 0) {
+function hasDangerousKey(obj, _depth = 0, _nodeCount = { n: 0 }) {
+  // DoS caps: count EVERY visited node (including primitive leaves and
+  // array elements per F6 contract), and bail conservatively on either cap.
+  // Returning `true` on overflow is the safe-by-default policy since the
+  // sole caller (dashboard.js request-body guard) rejects on `true`.
+  if (++_nodeCount.n > HAS_DANGEROUS_KEY_MAX_NODES) return true;
+  if (_depth > HAS_DANGEROUS_KEY_MAX_DEPTH) return true;
+
   if (obj === null || obj === undefined || typeof obj !== 'object') return false;
 
   // Arrays are transparent — preserve depth when recursing into elements.
   if (Array.isArray(obj)) {
     for (const elt of obj) {
-      if (hasDangerousKey(elt, _depth)) return true;
+      if (hasDangerousKey(elt, _depth, _nodeCount)) return true;
     }
     return false;
   }
 
-  // Object: check own keys at the current depth.
+  // Object: check own keys at the current depth, then recurse into values.
   for (const key of Object.keys(obj)) {
     if (_DANGEROUS_KEYS.has(key)) return true;
   }
-
-  // Stop after one level of object nesting. Deeper recursion is an explicit
-  // non-goal (see DoS note in the header).
-  if (_depth >= 1) return false;
-
   for (const v of Object.values(obj)) {
-    if (hasDangerousKey(v, _depth + 1)) return true;
+    if (hasDangerousKey(v, _depth + 1, _nodeCount)) return true;
   }
   return false;
 }
@@ -3822,6 +3839,8 @@ module.exports = {
   isAllowedOrigin,
   buildSecurityHeaders,
   hasDangerousKey,
+  HAS_DANGEROUS_KEY_MAX_DEPTH,
+  HAS_DANGEROUS_KEY_MAX_NODES,
   validateProjectName,
   validateProjectPath,
   validatePid,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1949",
+  "version": "0.1.1950",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"