monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/transfer/tests/test-store.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env npx tsx
+/**
+ * Pattern Store Test Suite
+ * Tests list, search, download, and publish functionality
+ */
+import { createDiscoveryService } from '../store/discovery.js';
+import { searchPatterns, getSearchSuggestions, getTagCloud } from '../store/search.js';
+import { createDownloader } from '../store/download.js';
+import { createPublisher } from '../store/publish.js';
+import { createSeraphineGenesis } from '../models/seraphine.js';
+// Test results tracking
+const results = [];
+function logTest(name, passed, details) {
+    results.push({ test: name, passed, details });
+    const icon = passed ? '✅' : '❌';
+    console.log(`${icon} ${name}${details ? `: ${details}` : ''}`);
+}
+async function runTests() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════════════╗');
+    console.log('║        PATTERN STORE TEST SUITE                          ║');
+    console.log('║        Testing List, Search, Download, Publish           ║');
+    console.log('╚══════════════════════════════════════════════════════════╝');
+    console.log('');
+    // ==========================================================================
+    // 1. DISCOVERY TESTS
+    // ==========================================================================
+    console.log('─── Discovery Tests ───────────────────────────────────────');
+    try {
+        const discovery = createDiscoveryService();
+        logTest('Discovery service created', true);
+        // List registries
+        const registries = discovery.listRegistries();
+        logTest('List registries', registries.length > 0, `Found ${registries.length} registries`);
+        // Discover registry
+        const result = await discovery.discoverRegistry();
+        logTest('Discover registry', result.success, result.success
+            ? `Loaded ${result.registry?.patterns.length || 0} patterns`
+            : result.error);
+        // Cache test
+        if (result.success) {
+            const cachedResult = await discovery.discoverRegistry();
+            logTest('Cache hit', cachedResult.fromCache, 'Second request from cache');
+        }
+        console.log('');
+        // ==========================================================================
+        // 2. SEARCH TESTS
+        // ==========================================================================
+        console.log('─── Search Tests ──────────────────────────────────────────');
+        if (result.success && result.registry) {
+            const registry = result.registry;
+            // Basic search
+            const basicSearch = searchPatterns(registry);
+            logTest('Basic search', basicSearch.patterns.length > 0, `Found ${basicSearch.total} patterns`);
+            // Query search
+            const querySearch = searchPatterns(registry, { query: 'routing' });
+            logTest('Query search', true, `Query "routing" found ${querySearch.patterns.length} patterns`);
+            // Category filter
+            const categorySearch = searchPatterns(registry, { category: 'routing' });
+            logTest('Category filter', true, `Category "routing" found ${categorySearch.patterns.length} patterns`);
+            // Tag search
+            const tagSearch = searchPatterns(registry, { tags: ['genesis'] });
+            logTest('Tag search', true, `Tag "genesis" found ${tagSearch.patterns.length} patterns`);
+            // Verified filter
+            const verifiedSearch = searchPatterns(registry, { verified: true });
+            logTest('Verified filter', true, `Verified patterns: ${verifiedSearch.patterns.length}`);
+            // Sort by downloads
+            const sortedSearch = searchPatterns(registry, {
+                sortBy: 'downloads',
+                sortOrder: 'desc',
+            });
+            logTest('Sort by downloads', true, `Top pattern: ${sortedSearch.patterns[0]?.displayName || 'none'}`);
+            // Pagination
+            const page1 = searchPatterns(registry, { limit: 5, offset: 0 });
+            logTest('Pagination', page1.pageSize === 5, `Page 1 with ${page1.patterns.length} patterns, hasMore: ${page1.hasMore}`);
+            // Search suggestions
+            const suggestions = getSearchSuggestions(registry, 'rou');
+            logTest('Search suggestions', suggestions.length >= 0, `Suggestions for "rou": ${suggestions.slice(0, 3).join(', ')}`);
+            // Tag cloud
+            const tagCloud = getTagCloud(registry);
+            logTest('Tag cloud', tagCloud.size > 0, `${tagCloud.size} unique tags`);
+        }
+        console.log('');
+        // ==========================================================================
+        // 3. DOWNLOAD TESTS
+        // ==========================================================================
+        console.log('─── Download Tests ────────────────────────────────────────');
+        if (result.success && result.registry && result.registry.patterns.length > 0) {
+            const pattern = result.registry.patterns[0];
+            const downloader = createDownloader();
+            logTest('Downloader created', true);
+            // Download with progress
+            let progressCalled = false;
+            const downloadResult = await downloader.downloadPattern(pattern, {
+                verify: true,
+            }, (progress) => {
+                progressCalled = true;
+            });
+            logTest('Download pattern', downloadResult.success, downloadResult.success
+                ? `Downloaded ${downloadResult.size} bytes`
+                : 'Failed');
+            logTest('Progress callback', progressCalled, progressCalled ? 'Progress events received' : 'No progress events');
+            logTest('Checksum verification', downloadResult.verified !== undefined, `Verified: ${downloadResult.verified}`);
+            // Cache stats
+            const cacheStats = downloader.getCacheStats();
+            logTest('Cache statistics', cacheStats.count >= 0, `${cacheStats.count} items, ${cacheStats.totalSize} bytes`);
+        }
+        console.log('');
+        // ==========================================================================
+        // 4. PUBLISH TESTS
+        // ==========================================================================
+        console.log('─── Publish Tests ─────────────────────────────────────────');
+        const cfp = createSeraphineGenesis();
+        const publisher = createPublisher();
+        logTest('Publisher created', true);
+        // Validation
+        const validation = publisher.validateForPublish(cfp, {
+            name: 'test-pattern',
+            displayName: 'Test Pattern',
+            description: 'A test pattern for validation',
+            categories: ['testing'],
+            tags: ['test', 'validation', 'demo'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish validation', validation.length === 0, validation.length === 0 ? 'All validations passed' : validation.join(', '));
+        // Preview
+        const preview = publisher.createPreview(cfp, {
+            name: 'seraphine-genesis',
+            displayName: 'Seraphine Genesis',
+            description: 'The foundational pattern model',
+            categories: ['routing', 'coordination'],
+            tags: ['genesis', 'foundational'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish preview', preview !== null, `Preview created for ${preview.name}`);
+        // Publish (mock)
+        const publishResult = await publisher.publishPattern(cfp, {
+            name: 'test-pattern',
+            displayName: 'Test Pattern',
+            description: 'A test pattern published to IPFS',
+            categories: ['testing'],
+            tags: ['test', 'demo', 'hello-world'],
+            license: 'MIT',
+            anonymize: 'standard',
+        });
+        logTest('Publish to IPFS', publishResult.success, publishResult.success
+            ? `CID: ${publishResult.cid.slice(0, 20)}...`
+            : publishResult.message);
+        console.log('');
+        // ==========================================================================
+        // 5. INTEGRATION TEST
+        // ==========================================================================
+        console.log('─── Integration Test ──────────────────────────────────────');
+        // Full workflow: discover -> search -> download
+        const store = createDiscoveryService();
+        const discoverResult = await store.discoverRegistry();
+        if (discoverResult.success && discoverResult.registry) {
+            const searchResult = searchPatterns(discoverResult.registry, {
+                query: 'seraphine',
+            });
+            if (searchResult.patterns.length > 0) {
+                const dl = createDownloader();
+                const dlResult = await dl.downloadPattern(searchResult.patterns[0], {
+                    verify: true,
+                });
+                logTest('Full workflow', dlResult.success, 'Discover → Search → Download completed');
+            }
+            else {
+                logTest('Full workflow', true, 'Discover → Search completed (no download)');
+            }
+        }
+    }
+    catch (error) {
+        console.error('Test error:', error);
+        logTest('Test suite', false, `Error: ${error}`);
+    }
+    // ==========================================================================
+    // SUMMARY
+    // ==========================================================================
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('                      TEST SUMMARY                          ');
+    console.log('═══════════════════════════════════════════════════════════');
+    console.log('');
+    const passed = results.filter(r => r.passed).length;
+    const failed = results.filter(r => !r.passed).length;
+    const total = results.length;
+    console.log(`   Total Tests: ${total}`);
+    console.log(`   ✅ Passed: ${passed}`);
+    console.log(`   ❌ Failed: ${failed}`);
+    console.log('');
+    if (failed === 0) {
+        console.log('   🎉 All tests passed!');
+        console.log('');
+        console.log('   📦 Store Features Verified:');
+        console.log('      - Registry discovery via IPNS');
+        console.log('      - Pattern search with filters');
+        console.log('      - Download with verification');
+        console.log('      - Publish with anonymization');
+        console.log('');
+    }
+    else {
+        console.log('   ⚠️ Some tests failed. Please review the output above.');
+    }
+    process.exit(failed > 0 ? 1 : 0);
+}
+// Run tests
+runTests().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=test-store.js.map

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/dist/src/workflow/condition-evaluator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Evaluate a simple boolean expression with variable substitution.
+ *
+ * 1. Replace `{{variable}}` references using the provided context.
+ * 2. Reject any expression containing dangerous patterns.
+ * 3. Validate that all remaining tokens are safe.
+ * 4. Evaluate using `new Function` with strict mode.
+ */
+export declare function evaluateCondition(expression: string, context: Record<string, unknown>): boolean;
+//# sourceMappingURL=condition-evaluator.d.ts.map