monomind 1.11.14 → 1.12.0

package/packages/@monomind/cli/dist/src/transfer/store/registry.js

@@ -206,12 +206,26 @@ export function serializeRegistry(registry) {
 }
 /**
  * Deserialize registry from JSON
+ *
+ * Caps the input string length before parsing to prevent OOM on a malicious or
+ * oversized registry fetched from IPFS / Pinata. The in-flight body is already
+ * capped by readBodyWithLimit (50 MB), but deserializeRegistry is also called
+ * with locally-cached data, so we add a 10 MB guard here too.
+ *
+ * We also reject non-semver and suspiciously long version strings to prevent
+ * version fields being used as a side-channel for large-payload injection.
  */
 export function deserializeRegistry(json) {
+    const MAX_JSON_BYTES = 10 * 1024 * 1024; // 10 MB
+    if (typeof json !== 'string' || json.length > MAX_JSON_BYTES) {
+        throw new Error(`Registry JSON too large: ${typeof json === 'string' ? json.length : typeof json} bytes (max ${MAX_JSON_BYTES})`);
+    }
     const registry = JSON.parse(json);
-    // Validate version
-    if (!registry.version) {
-        throw new Error('Invalid registry: missing version');
+    // Validate version — must be a non-empty semver-like string (e.g. "1.0.0").
+    if (!registry.version || typeof registry.version !== 'string'
+        || registry.version.length > 32
+        || !/^\d+\.\d+\.\d+/.test(registry.version)) {
+        throw new Error('Invalid registry: missing or malformed version');
     }
     return registry;
 }
@@ -266,9 +280,16 @@ export async function verifyRegistrySignature(registry) {
  */
 export function mergeRegistries(local, remote) {
     const merged = createRegistry(local.ipnsName);
+    // Cap combined input sizes to prevent OOM when merging a large remote registry.
+    // A remote registry fetched from IPFS could contain hundreds of thousands of
+    // entries; without a hard cap, patternMap grows unboundedly in memory.
+    const MAX_MERGE_PATTERNS = 10_000;
+    const MAX_MERGE_AUTHORS = 1_000;
     // Combine patterns, preferring newer versions
     const patternMap = new Map();
     for (const pattern of [...local.patterns, ...remote.patterns]) {
+        if (patternMap.size >= MAX_MERGE_PATTERNS && !patternMap.has(pattern.name))
+            continue;
         const existing = patternMap.get(pattern.name);
         if (!existing || new Date(pattern.lastUpdated) > new Date(existing.lastUpdated)) {
             patternMap.set(pattern.name, pattern);
@@ -278,6 +299,8 @@ export function mergeRegistries(local, remote) {
     // Combine authors
     const authorMap = new Map();
     for (const author of [...local.authors, ...remote.authors]) {
+        if (authorMap.size >= MAX_MERGE_AUTHORS && !authorMap.has(author.id))
+            continue;
         const existing = authorMap.get(author.id);
         if (!existing || author.patterns > existing.patterns) {
             authorMap.set(author.id, author);
@@ -294,8 +317,10 @@ export function mergeRegistries(local, remote) {
  * Generate pattern ID from name
  */
 export function generatePatternId(name) {
-    const normalized = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    const hash = crypto.createHash('sha256').update(name + Date.now()).digest('hex').slice(0, 8);
+    // Cap name before normalizing to prevent OOM from an extremely long input string
+    const safeName = typeof name === 'string' ? name.slice(0, 128) : '';
+    const normalized = safeName.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    const hash = crypto.createHash('sha256').update(safeName + Date.now()).digest('hex').slice(0, 8);
     return `${normalized}-${hash}`;
 }
 //# sourceMappingURL=registry.js.map

package/packages/@monomind/cli/dist/src/transfer/store/search.js

@@ -2,6 +2,16 @@
  * Pattern Search Service
  * Search and filter patterns from decentralized registry
  */
+/** Maximum query string length to prevent O(n*m) regex/includes DoS */
+const MAX_QUERY_LEN = 256;
+/** Hard cap on page size to prevent huge slice allocations */
+const MAX_PAGE_LIMIT = 200;
+/** Hard cap on offset to prevent absurdly large slice calculations */
+const MAX_OFFSET = 10_000;
+/** Hard cap on suggestion partial string length */
+const MAX_PARTIAL_LEN = 128;
+/** Hard cap on similar-pattern limit */
+const MAX_SIMILAR_LIMIT = 50;
 /**
  * Search patterns in registry
  */
@@ -9,7 +19,7 @@ export function searchPatterns(registry, options = {}) {
     let patterns = [...registry.patterns];
     // Text search
     if (options.query) {
-        const query = options.query.toLowerCase();
+        const query = String(options.query).slice(0, MAX_QUERY_LEN).toLowerCase();
         patterns = patterns.filter(p => p.name.toLowerCase().includes(query) ||
             p.displayName.toLowerCase().includes(query) ||
             p.description.toLowerCase().includes(query) ||
@@ -77,10 +87,12 @@ export function searchPatterns(registry, options = {}) {
         }
         return sortOrder === 'desc' ? -comparison : comparison;
     });
-    // Pagination
+    // Pagination — cap limit and offset to prevent huge slice allocations
     const total = patterns.length;
-    const limit = options.limit || 20;
-    const offset = options.offset || 0;
+    const rawLimit = typeof options.limit === 'number' && Number.isFinite(options.limit) ? options.limit : 20;
+    const limit = Math.min(Math.max(1, Math.floor(rawLimit)), MAX_PAGE_LIMIT);
+    const rawOffset = typeof options.offset === 'number' && Number.isFinite(options.offset) ? options.offset : 0;
+    const offset = Math.min(Math.max(0, Math.floor(rawOffset)), MAX_OFFSET);
     const page = Math.floor(offset / limit) + 1;
     patterns = patterns.slice(offset, offset + limit);
     return {
@@ -144,6 +156,7 @@ export function getPatternsByCategory(registry, categoryId) {
  * Get similar patterns (by tags and category)
  */
 export function getSimilarPatterns(registry, pattern, limit = 5) {
+    limit = Math.min(Math.max(1, Math.floor(limit)), MAX_SIMILAR_LIMIT);
     const scores = new Map();
     for (const p of registry.patterns) {
         if (p.id === pattern.id)
@@ -203,7 +216,9 @@ export function getTagCloud(registry) {
  */
 export function getSearchSuggestions(registry, partial, limit = 10) {
     const suggestions = new Set();
-    const query = partial.toLowerCase();
+    // Cap partial length to prevent O(n*m) DoS via enormous query strings
+    const query = String(partial).slice(0, MAX_PARTIAL_LEN).toLowerCase();
+    limit = Math.min(Math.max(1, Math.floor(limit)), MAX_SIMILAR_LIMIT);
     // Add matching pattern names
     for (const pattern of registry.patterns) {
         if (pattern.name.toLowerCase().includes(query)) {

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

@@ -4,7 +4,19 @@
  */
 import { createRequire } from 'module';
 import { execFileSync } from 'child_process';
-import * as semver from 'semver';
+// Inline semver shim — avoids external dependency
+const semver = {
+    valid: (v) => /^\d+\.\d+\.\d+/.test(v || '') ? v : null,
+    eq: (a, b) => a === b,
+    major: (v) => parseInt((v || '0').split('.')[0], 10),
+    minor: (v) => parseInt((v || '0').split('.')[1] || '0', 10),
+    patch: (v) => parseInt(((v || '0').split('.')[2] || '0').replace(/[^0-9].*/, ''), 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;
+    },
+};
 import { reserveCheck, recordCheck, getCachedVersions } from './rate-limiter.js';
 const require = createRequire(import.meta.url);
 const DEFAULT_CONFIG = {
@@ -45,6 +57,13 @@ const NPM_NAME_RE = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
 function isValidNpmName(name) {
     return NPM_NAME_RE.test(name) && !name.includes('..') && name.length <= 214;
 }
+// Cap registry response at 5 MB. The full npm registry payload for a package
+// can include the entire `versions` object (dozens of version entries with
+// dist/scripts/dependencies for each). A spoofed or compromised registry
+// endpoint could stream an arbitrarily large body; AbortSignal.timeout(5000)
+// only enforces a wall-clock deadline and does NOT cap bytes. Without this
+// cap, fetchPackageInfo will buffer an unbounded body into memory (OOM).
+const MAX_REGISTRY_RESPONSE_BYTES = 5 * 1024 * 1024; // 5 MB
 async function fetchPackageInfo(packageName) {
     if (!isValidNpmName(packageName))
         return null;
@@ -56,7 +75,42 @@ async function fetchPackageInfo(packageName) {
         if (!response.ok) {
             return null;
         }
-        return (await response.json());
+        // Reject immediately if Content-Length header exceeds cap
+        const contentLength = response.headers.get('content-length');
+        if (contentLength) {
+            const declared = parseInt(contentLength, 10);
+            if (Number.isFinite(declared) && declared > MAX_REGISTRY_RESPONSE_BYTES) {
+                return null;
+            }
+        }
+        // Stream body and enforce byte cap — prevents OOM if the server streams
+        // a large body that evades the Content-Length check (missing/wrong header).
+        if (!response.body)
+            return null;
+        const reader = response.body.getReader();
+        const chunks = [];
+        let totalBytes = 0;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value) {
+                totalBytes += value.byteLength;
+                if (totalBytes > MAX_REGISTRY_RESPONSE_BYTES) {
+                    await reader.cancel();
+                    return null;
+                }
+                chunks.push(value);
+            }
+        }
+        const buf = new Uint8Array(totalBytes);
+        let offset = 0;
+        for (const chunk of chunks) {
+            buf.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        const text = new TextDecoder('utf-8').decode(buf);
+        return JSON.parse(text);
     }
     catch {
         return null;
@@ -66,7 +120,8 @@ function getUpdateType(current, latest) {
     if (!semver.valid(current) || !semver.valid(latest)) {
         return 'none';
     }
-    if (semver.eq(current, latest)) {
+    // Not an upgrade (equal or downgrade)
+    if (!semver.gt(latest, current)) {
         return 'none';
     }
     if (semver.major(latest) > semver.major(current)) {
@@ -75,10 +130,7 @@ function getUpdateType(current, latest) {
     if (semver.minor(latest) > semver.minor(current)) {
         return 'minor';
     }
-    if (semver.patch(latest) > semver.patch(current)) {
-        return 'patch';
-    }
-    return 'none';
+    return 'patch';
 }
 function shouldAutoUpdate(updateType, priority, config) {
     if (updateType === 'none')

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

@@ -6,11 +6,32 @@ import { execFile } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import * as semver from 'semver';
+import { validateUpdate } from './validator.js';
+// Inline semver shim — avoids external dependency (semver is not in package.json)
+const semver = {
+    valid: (v) => /^\d+\.\d+\.\d+/.test(v || '') ? v : null,
+};
+/**
+ * Validate a npm package name.
+ * Allows scoped (@scope/name) and unscoped names; rejects path-traversal,
+ * shell metacharacters, and names that are too long to be legitimate.
+ * See https://docs.npmjs.com/cli/v9/configuring-npm/package-json#name
+ */
+function isValidPackageName(name) {
+    if (typeof name !== 'string' || name.length === 0 || name.length > 214)
+        return false;
+    // Scoped: @scope/name — both parts: lowercase alnum + hyphens + underscores + dots
+    if (name.startsWith('@')) {
+        return /^@[a-z0-9][a-z0-9_.-]*\/[a-z0-9][a-z0-9_.-]*$/.test(name);
+    }
+    // Unscoped: must not start with . or _ (legacy rule)
+    return /^[a-z0-9][a-z0-9_.-]*$/.test(name);
+}
+/** Max bytes we will read from the on-disk update history file. */
+const MAX_HISTORY_FILE_BYTES = 1 * 1024 * 1024; // 1 MB
 function execFileAsync(cmd, args) {
     return new Promise((resolve, reject) => execFile(cmd, args, (err) => (err ? reject(err) : resolve())));
 }
-import { validateUpdate } from './validator.js';
 const HISTORY_FILE = path.join(os.homedir(), '.monomind', 'update-history.json');
 const MAX_HISTORY_ENTRIES = 100;
 function ensureDir() {
@@ -22,8 +43,29 @@ function ensureDir() {
 export function loadHistory() {
     try {
         if (fs.existsSync(HISTORY_FILE)) {
+            // Guard against a bloated or attacker-crafted history file causing OOM.
+            const stat = fs.statSync(HISTORY_FILE);
+            if (stat.size > MAX_HISTORY_FILE_BYTES) {
+                return [];
+            }
             const content = fs.readFileSync(HISTORY_FILE, 'utf-8');
-            return JSON.parse(content);
+            const raw = JSON.parse(content);
+            if (!Array.isArray(raw))
+                return [];
+            // Sanitize each entry: reject any entry whose package name or version
+            // fails validation so that a tampered history file cannot inject
+            // arbitrary arguments into a subsequent npm install via rollbackUpdate().
+            return raw.filter((e) => {
+                if (typeof e !== 'object' || e === null)
+                    return false;
+                if (typeof e.package !== 'string' || !isValidPackageName(e.package))
+                    return false;
+                if (typeof e.fromVersion !== 'string' || !semver.valid(e.fromVersion))
+                    return false;
+                if (typeof e.toVersion !== 'string' || !semver.valid(e.toVersion))
+                    return false;
+                return true;
+            });
         }
     }
     catch {
@@ -68,6 +110,11 @@ export async function executeUpdate(update, installedPackages, dryRun = false) {
         // Execute npm install — use execFile to avoid shell injection
         const pkg = update.package;
         const version = update.latestVersion;
+        // Validate both package name and version before constructing the npm arg
+        // to prevent argument injection via a crafted UpdateCheckResult.
+        if (!isValidPackageName(pkg)) {
+            throw new Error(`Invalid package name: ${pkg}`);
+        }
         if (!semver.valid(version)) {
             throw new Error(`Invalid version: ${version}`);
         }

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

@@ -16,7 +16,24 @@ export { executeUpdate, executeMultipleUpdates, rollbackUpdate, getUpdateHistory
 import { checkForUpdates, DEFAULT_CONFIG, getInstalledVersion } from './checker.js';
 import { executeMultipleUpdates } from './executor.js';
 import { getCachedVersions } from './rate-limiter.js';
-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,
+    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;
+    },
+    lte: (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);
+        if (aMaj !== bMaj)
+            return aMaj < bMaj;
+        if (aMin !== bMin)
+            return aMin < bMin;
+        return aPat <= bPat;
+    },
+};
 /**
  * Synchronous — reads cached state from last check.
  * Returns a short inline string for the CLI version tagline, e.g.

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

@@ -20,6 +20,12 @@ export declare function shouldCheckForUpdates(intervalHours?: number): {
  * 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 declare function reserveCheck(intervalHours?: number): {
     allowed: boolean;

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.12.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",