monomind 1.11.14 → 1.13.0

package/packages/@monomind/cli/dist/src/update/rate-limiter.js

@@ -8,6 +8,12 @@ import * as os from 'os';
 const STATE_FILE = path.join(os.homedir(), '.monomind', 'update-state.json');
 const DEFAULT_INTERVAL_HOURS = 24;
 const MAX_CHECKS_PER_DAY = 10;
+// Hard cap on how many package version entries we persist. Prevents an
+// attacker who can write to the state file from inflating it unboundedly,
+// and protects recordCheck() from DoS via a huge incoming packageVersions map.
+const MAX_PACKAGE_VERSIONS = 100;
+// Hard cap on the state file size we are willing to read into memory.
+const MAX_STATE_FILE_BYTES = 1 * 1024 * 1024; // 1 MB
 function ensureDir() {
     const dir = path.dirname(STATE_FILE);
     if (!fs.existsSync(dir)) {
@@ -25,8 +31,36 @@ function getDefaultState() {
 export function loadState() {
     try {
         if (fs.existsSync(STATE_FILE)) {
+            // Guard against oversized state files (DoS / OOM) before reading
+            const stat = fs.statSync(STATE_FILE);
+            if (stat.size > MAX_STATE_FILE_BYTES) {
+                // State file is unreasonably large — discard and start fresh
+                try {
+                    fs.unlinkSync(STATE_FILE);
+                }
+                catch { /* ignore */ }
+                return getDefaultState();
+            }
             const content = fs.readFileSync(STATE_FILE, 'utf-8');
-            const state = JSON.parse(content);
+            // Block prototype pollution via JSON.parse reviver
+            const state = JSON.parse(content, (key, value) => {
+                if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+                    return undefined;
+                return value;
+            });
+            // Validate that packageVersions is a plain object (not an array/primitive)
+            if (!state.packageVersions || typeof state.packageVersions !== 'object' || Array.isArray(state.packageVersions)) {
+                state.packageVersions = {};
+            }
+            // Cap the number of package version entries to prevent bloat
+            const versionKeys = Object.keys(state.packageVersions);
+            if (versionKeys.length > MAX_PACKAGE_VERSIONS) {
+                const capped = {};
+                for (const k of versionKeys.slice(0, MAX_PACKAGE_VERSIONS)) {
+                    capped[k] = state.packageVersions[k];
+                }
+                state.packageVersions = capped;
+            }
             // Reset counter if new day
             const today = new Date().toISOString().split('T')[0];
             if (state.date !== today) {
@@ -86,14 +120,41 @@ export function shouldCheckForUpdates(intervalHours = DEFAULT_INTERVAL_HOURS) {
  * only after a successful reserveCheck, so that limit enforcement and
  * increment happen in the same synchronous turn (no await gap between
  * them), preventing two concurrent callers both seeing "allowed".
+ *
+ * IMPORTANT: performs a single loadState() → check → increment → saveState()
+ * cycle to eliminate the TOCTOU window that existed when this function
+ * delegated to shouldCheckForUpdates() (which called loadState() itself)
+ * and then called loadState() a second time to increment. Two callers
+ * sharing that gap could both see allowed=true and both increment.
  */
 export function reserveCheck(intervalHours = DEFAULT_INTERVAL_HOURS) {
-    const decision = shouldCheckForUpdates(intervalHours);
-    if (!decision.allowed)
-        return decision;
-    // Increment immediately, before any async work, so concurrent callers
-    // see an updated count on their next tick.
+    // Fast-path: environment gates that don't need file I/O
+    if (process.env.CI === 'true' || process.env.CONTINUOUS_INTEGRATION === 'true') {
+        return { allowed: false, reason: 'CI environment detected' };
+    }
+    if (process.env.MONOMIND_AUTO_UPDATE === 'false') {
+        return { allowed: false, reason: 'Auto-update disabled via environment' };
+    }
+    // Single load — check and increment in one synchronous cycle
     const state = loadState();
+    if (process.env.MONOMIND_FORCE_UPDATE !== 'true') {
+        // Daily limit
+        if (state.checksToday >= MAX_CHECKS_PER_DAY) {
+            return { allowed: false, reason: `Daily check limit (${MAX_CHECKS_PER_DAY}) reached` };
+        }
+        // Time interval
+        if (state.lastCheck) {
+            const hoursSinceLastCheck = (Date.now() - new Date(state.lastCheck).getTime()) / (1000 * 60 * 60);
+            if (hoursSinceLastCheck < intervalHours) {
+                const nextCheck = Math.ceil(intervalHours - hoursSinceLastCheck);
+                return {
+                    allowed: false,
+                    reason: `Last check was ${Math.floor(hoursSinceLastCheck)}h ago (next check in ~${nextCheck}h)`,
+                };
+            }
+        }
+    }
+    // Reserve the slot: increment and persist before any async work begins
     state.checksToday += 1;
     state.lastCheck = new Date().toISOString();
     saveState(state);
@@ -102,7 +163,18 @@ export function reserveCheck(intervalHours = DEFAULT_INTERVAL_HOURS) {
 export function recordCheck(packageVersions) {
     // Update only package versions; count/timestamp already incremented by reserveCheck
     const state = loadState();
-    state.packageVersions = { ...state.packageVersions, ...packageVersions };
+    // Merge only string-valued keys to block prototype pollution and type confusion.
+    // Also enforce the total cap so a large incoming map cannot bloat the state file.
+    const FORBIDDEN = new Set(['__proto__', 'constructor', 'prototype']);
+    for (const [k, v] of Object.entries(packageVersions)) {
+        if (FORBIDDEN.has(k))
+            continue;
+        if (typeof k !== 'string' || typeof v !== 'string')
+            continue;
+        if (Object.keys(state.packageVersions).length >= MAX_PACKAGE_VERSIONS)
+            break;
+        state.packageVersions[k] = v;
+    }
     saveState(state);
 }
 export function getCachedVersions() {

package/packages/@monomind/cli/dist/src/update/validator.js

@@ -2,9 +2,42 @@
  * Package validator for update compatibility
  * Ensures updates don't break the ecosystem
  */
-import * as semver from 'semver';
+// Inline semver shim — avoids external dependency (semver is not listed in package.json)
+const semver = {
+    valid: (v) => /^\d+\.\d+\.\d+/.test(v || '') ? v : null,
+    major: (v) => parseInt((v || '0').split('.')[0], 10),
+    gt: (a, b) => {
+        const [aMaj, aMin, aPat] = (a || '0').split('.').map(n => parseInt(n, 10) || 0);
+        const [bMaj, bMin, bPat] = (b || '0').split('.').map(n => parseInt(n, 10) || 0);
+        return aMaj !== bMaj ? aMaj > bMaj : aMin !== bMin ? aMin > bMin : aPat > bPat;
+    },
+    lt: (a, b) => {
+        const [aMaj, aMin, aPat] = (a || '0').split('.').map(n => parseInt(n, 10) || 0);
+        const [bMaj, bMin, bPat] = (b || '0').split('.').map(n => parseInt(n, 10) || 0);
+        return aMaj !== bMaj ? aMaj < bMaj : aMin !== bMin ? aMin < bMin : aPat < bPat;
+    },
+};
+// Maximum number of updates accepted in a single validateBulkUpdate call.
+// Without this cap a caller can DoS the validator by passing thousands of
+// update entries — each entry triggers validateUpdate which iterates over
+// COMPATIBILITY_MATRIX and BREAKING_CHANGES.
+const MAX_BULK_UPDATES = 50;
+// Version strings must look like semver (major.minor.patch with optional pre-release)
+// before we use them in string interpolation or comparisons.
+const SEMVER_RE = /^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/;
+// Package names: scoped (@scope/name) or plain, no shell-special chars.
+const PKG_NAME_RE = /^(@[a-zA-Z0-9][a-zA-Z0-9_.-]*\/)?[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
+function isSafeVersion(v) {
+    return typeof v === 'string' && v.length <= 64 && SEMVER_RE.test(v);
+}
+function isSafePackageName(p) {
+    return typeof p === 'string' && p.length <= 200 && PKG_NAME_RE.test(p);
+}
 // Known compatibility matrix between monomind packages
 const COMPATIBILITY_MATRIX = {
+    '@monomind/cli': {
+        '@monomind/security': { minVersion: '3.0.0-alpha.1' },
+    },
     '@monoes/monomindcli': {
         'monofence-ai': { minVersion: '1.0.0' },
     },
@@ -35,6 +68,18 @@ export function validateUpdate(packageName, fromVersion, toVersion, installedPac
         warnings: [],
         requiredPeerUpdates: [],
     };
+    // Guard inputs: reject untrusted or malformed strings before they flow into
+    // error messages or semver comparisons (which assume well-formed input).
+    if (!isSafePackageName(packageName)) {
+        result.valid = false;
+        result.incompatibilities.push('Invalid package name');
+        return result;
+    }
+    if (!isSafeVersion(fromVersion) || !isSafeVersion(toVersion)) {
+        result.valid = false;
+        result.incompatibilities.push('Invalid version string(s)');
+        return result;
+    }
     // Check if this is a major version bump
     if (semver.valid(fromVersion) && semver.valid(toVersion)) {
         const fromMajor = semver.major(fromVersion);
@@ -93,6 +138,12 @@ export function validateBulkUpdate(updates, currentPackages) {
         warnings: [],
         requiredPeerUpdates: [],
     };
+    // Cap the number of updates to prevent DoS via large arrays
+    if (!Array.isArray(updates) || updates.length > MAX_BULK_UPDATES) {
+        combinedResult.valid = false;
+        combinedResult.incompatibilities.push(`Too many updates: max ${MAX_BULK_UPDATES} allowed per call`);
+        return combinedResult;
+    }
     // Create a simulated state after all updates
     const simulatedPackages = { ...currentPackages };
     for (const update of updates) {

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.11.13",
+  "version": "1.13.0",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -87,8 +87,7 @@
   "dependencies": {
     "ws": "^8.18.0",
     "@noble/ed25519": "^2.1.0",
-    "@monoes/monograph": "^1.2.0",
-    "semver": "^7.6.0"
+    "@monoes/monograph": "^1.2.0"
   },
   "optionalDependencies": {
     "sql.js": "^1.14.1",