monomind 1.11.13 → 1.12.0

package/packages/@monomind/cli/dist/src/mcp-tools/security-tools.js

@@ -17,6 +17,21 @@ const require = createRequire(import.meta.url);
 let monofenceInstance = null;
 // Track if we've attempted install this session
 let installAttempted = false;
+// ── Security input bounds ─────────────────────────────────────────────────────
+// MonoFence runs multiple regex patterns over the entire input string (O(n × P)
+// complexity where P is the pattern count).  Uncapped input enables ReDoS-style
+// denial-of-service.  64 KB is more than enough for any real threat-scan
+// payload while preventing CPU exhaustion from megabyte-scale inputs.
+const MAX_SECURITY_INPUT_LEN = 64 * 1024; // 64 KB
+const MAX_SECURITY_K = 100;
+const MAX_SECURITY_VERDICT_LEN = 512;
+const MAX_SECURITY_THREAT_TYPE_LEN = 256;
+const MAX_SECURITY_MITIGATION_STRATEGY_LEN = 512;
+function capSecurityInput(raw, fieldName = 'input') {
+    if (typeof raw !== 'string')
+        throw new Error(`${fieldName} must be a string`);
+    return raw.length > MAX_SECURITY_INPUT_LEN ? raw.slice(0, MAX_SECURITY_INPUT_LEN) : raw;
+}
 /**
  * Get or create MonoFence instance (throws if unavailable)
  */
@@ -79,7 +94,13 @@ const monofenceScanTool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         const quick = args.quick;
         try {
             const defender = await getMonoFence();
@@ -153,9 +174,16 @@ const monofenceAnalyzeTool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         const searchSimilar = args.searchSimilar !== false;
-        const k = args.k || 5;
+        const rawK = args.k || 5;
+        const k = Number.isFinite(rawK) && rawK > 0 ? Math.min(Math.floor(rawK), MAX_SECURITY_K) : 5;
         try {
             const defender = await getMonoFence();
             const result = await defender.detect(input);
@@ -282,11 +310,23 @@ const monofenceLearnTool = {
         required: ['input', 'wasAccurate'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         const wasAccurate = args.wasAccurate;
-        const verdict = args.verdict;
-        const threatType = args.threatType;
-        const mitigationStrategy = args.mitigationStrategy;
+        const rawVerdict = args.verdict;
+        const verdict = typeof rawVerdict === 'string' && rawVerdict.length > MAX_SECURITY_VERDICT_LEN
+            ? rawVerdict.slice(0, MAX_SECURITY_VERDICT_LEN) : rawVerdict;
+        const rawThreatType = args.threatType;
+        const threatType = typeof rawThreatType === 'string' && rawThreatType.length > MAX_SECURITY_THREAT_TYPE_LEN
+            ? rawThreatType.slice(0, MAX_SECURITY_THREAT_TYPE_LEN) : rawThreatType;
+        const rawMitigationStrategy = args.mitigationStrategy;
+        const mitigationStrategy = typeof rawMitigationStrategy === 'string' && rawMitigationStrategy.length > MAX_SECURITY_MITIGATION_STRATEGY_LEN
+            ? rawMitigationStrategy.slice(0, MAX_SECURITY_MITIGATION_STRATEGY_LEN) : rawMitigationStrategy;
         const mitigationSuccess = args.mitigationSuccess;
         try {
             const defender = await getMonoFence();
@@ -344,7 +384,13 @@ const monofenceIsSafeTool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         try {
             await getMonoFence(); // triggers auto-install if package is missing
             const { isSafe } = await import('monofence-ai');
@@ -384,7 +430,13 @@ const monofenceHasPIITool = {
         required: ['input'],
     },
     handler: async (args) => {
-        const input = args.input;
+        let input;
+        try {
+            input = capSecurityInput(args.input);
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: e.message }) }], isError: true };
+        }
         try {
             const defender = await getMonoFence();
             const hasPII = defender.hasPII(input);

package/packages/@monomind/cli/dist/src/mcp-tools/session-tools.js

@@ -131,6 +131,19 @@ export const sessionTools = [
         },
         handler: async (input) => {
             const sessionId = `session-${Date.now()}-${randomBytes(6).toString('hex')}`;
+            // Cap name and description: both are persisted verbatim to the session
+            // JSON file on disk.  Without a cap, an attacker can inflate the session
+            // store by supplying a very long name or description.
+            const MAX_SESSION_NAME_LEN = 256;
+            const MAX_SESSION_DESC_LEN = 4 * 1024;
+            const rawSessionName = input.name;
+            const sessionName = typeof rawSessionName === 'string' && rawSessionName.length > MAX_SESSION_NAME_LEN
+                ? rawSessionName.slice(0, MAX_SESSION_NAME_LEN)
+                : rawSessionName;
+            const rawSessionDesc = input.description;
+            const sessionDesc = typeof rawSessionDesc === 'string' && rawSessionDesc.length > MAX_SESSION_DESC_LEN
+                ? rawSessionDesc.slice(0, MAX_SESSION_DESC_LEN)
+                : rawSessionDesc;
             // Load related data based on options
             const data = loadRelatedStores({
                 includeMemory: input.includeMemory,
@@ -146,8 +159,8 @@ export const sessionTools = [
             };
             const session = {
                 sessionId,
-                name: input.name,
-                description: input.description,
+                name: sessionName,
+                description: sessionDesc,
                 savedAt: new Date().toISOString(),
                 stats,
                 data: Object.keys(data).length > 0 ? data : undefined,
@@ -211,17 +224,25 @@ export const sessionTools = [
                         const { storeEntry } = await import('../memory/memory-initializer.js');
                         const memoryData = session.data.memory;
                         if (memoryData.entries) {
+                            // Cap individual key and value lengths before writing to the DB.
+                            // A malicious or corrupted session file could contain arbitrarily
+                            // long strings; without caps these flow straight into the HNSW
+                            // embedder and SQL layer, causing OOM or DoS.
+                            const MAX_RESTORE_KEY = 1_000;
+                            const MAX_RESTORE_VALUE = 100_000;
+                            const MAX_RESTORE_NS = 200;
                             for (const entry of Object.values(memoryData.entries)) {
-                                const key = entry.key || entry.id || '';
-                                const value = entry.value || entry.content || '';
-                                if (key && value) {
-                                    await storeEntry({
-                                        key,
-                                        value,
-                                        namespace: entry.namespace || 'restored',
-                                        upsert: true,
-                                    });
-                                }
+                                let key = entry.key || entry.id || '';
+                                let value = entry.value || entry.content || '';
+                                if (!key || !value)
+                                    continue;
+                                if (key.length > MAX_RESTORE_KEY)
+                                    key = key.slice(0, MAX_RESTORE_KEY);
+                                if (value.length > MAX_RESTORE_VALUE)
+                                    value = value.slice(0, MAX_RESTORE_VALUE);
+                                const rawNs = entry.namespace || 'restored';
+                                const namespace = rawNs.length > MAX_RESTORE_NS ? rawNs.slice(0, MAX_RESTORE_NS) : rawNs;
+                                await storeEntry({ key, value, namespace, upsert: true });
                             }
                         }
                     }
@@ -353,14 +374,24 @@ export const sessionTools = [
             const session = loadSession(sessionId);
             if (session) {
                 const path = getSessionPath(sessionId);
-                const stat = statSync(path);
+                // Guard against TOCTOU: the file could be deleted between loadSession()
+                // and statSync().  Catch ENOENT (and any other fs error) so the MCP
+                // handler never throws an unhandled exception; callers get a clean
+                // response instead of a server-side crash.
+                let fileSize = 0;
+                try {
+                    fileSize = statSync(path).size;
+                }
+                catch {
+                    // File deleted or inaccessible after loadSession succeeded
+                }
                 return {
                     sessionId: session.sessionId,
                     name: session.name,
                     description: session.description,
                     savedAt: session.savedAt,
                     stats: session.stats,
-                    fileSize: stat.size,
+                    fileSize,
                     hasData: {
                         memory: !!session.data?.memory,
                         tasks: !!session.data?.tasks,

package/packages/@monomind/cli/dist/src/mcp-tools/swarm-tools.js

@@ -64,7 +64,13 @@ export const swarmTools = [
         handler: async (input) => {
             const topology = input.topology || 'hierarchical-mesh';
             const maxAgents = Math.min(Math.max(input.maxAgents || 8, 1), 50);
-            const strategy = input.strategy || 'specialized';
+            // Cap strategy and config string fields: all are persisted in the swarm
+            // JSON store.  topology is already validated against VALID_TOPOLOGIES so
+            // an invalid long value is rejected; the others have no validation.
+            const MAX_SWARM_FIELD_LEN = 256;
+            const rawStrategy = input.strategy || 'specialized';
+            const strategy = typeof rawStrategy === 'string' && rawStrategy.length > MAX_SWARM_FIELD_LEN
+                ? rawStrategy.slice(0, MAX_SWARM_FIELD_LEN) : rawStrategy;
             const config = (input.config || {});
             if (!VALID_TOPOLOGIES.has(topology)) {
                 return {
@@ -85,9 +91,15 @@ export const swarmTools = [
                     topology,
                     maxAgents,
                     strategy,
-                    communicationProtocol: config.communicationProtocol || 'message-bus',
+                    communicationProtocol: (() => {
+                        const raw = config.communicationProtocol || 'message-bus';
+                        return typeof raw === 'string' && raw.length > MAX_SWARM_FIELD_LEN ? raw.slice(0, MAX_SWARM_FIELD_LEN) : raw;
+                    })(),
                     autoScaling: config.autoScaling ?? true,
-                    consensusMechanism: config.consensusMechanism || 'majority',
+                    consensusMechanism: (() => {
+                        const raw = config.consensusMechanism || 'majority';
+                        return typeof raw === 'string' && raw.length > MAX_SWARM_FIELD_LEN ? raw.slice(0, MAX_SWARM_FIELD_LEN) : raw;
+                    })(),
                 },
                 createdAt: now,
                 updatedAt: now,

package/packages/@monomind/cli/dist/src/mcp-tools/system-tools.js

@@ -9,7 +9,7 @@
  * - os module for system information
  */
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as os from 'node:os';
@@ -43,10 +43,11 @@ function ensureSystemDir() {
         mkdirSync(dir, { recursive: true });
     }
 }
+const MAX_SYSTEM_STORE_BYTES = 50 * 1024 * 1024; // 50 MB
 function loadMetrics() {
     try {
         const path = getMetricsPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= MAX_SYSTEM_STORE_BYTES) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
@@ -128,7 +129,9 @@ export const systemTools = [
         },
         handler: async (input) => {
             const store = loadMetrics();
-            const category = input.category || 'all';
+            const VALID_CATEGORIES = new Set(['all', 'cpu', 'memory', 'agents', 'tasks', 'requests']);
+            const rawCategory = input.category || 'all';
+            const category = VALID_CATEGORIES.has(rawCategory) ? rawCategory : 'all';
             // Get REAL system metrics via Node.js APIs
             const memUsage = process.memoryUsage();
             const loadAvg = os.loadavg();
@@ -182,7 +185,7 @@ export const systemTools = [
             if (_metricsSource === 'none') {
                 try {
                     const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
-                    if (existsSync(agentStorePath)) {
+                    if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_SYSTEM_STORE_BYTES) {
                         const agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
                         const agents = Object.values(agentStore.agents || {});
                         agentCounts = {
@@ -195,7 +198,7 @@ export const systemTools = [
                 catch { /* agent store not available */ }
                 try {
                     const taskStorePath = join(getProjectCwd(), STORAGE_DIR, 'tasks', 'store.json');
-                    if (existsSync(taskStorePath)) {
+                    if (existsSync(taskStorePath) && statSync(taskStorePath).size <= MAX_SYSTEM_STORE_BYTES) {
                         const taskStore = JSON.parse(readFileSync(taskStorePath, 'utf-8'));
                         const tasks = Object.values(taskStore.tasks || {});
                         taskCounts = {
@@ -438,7 +441,11 @@ export const systemTools = [
             if (!input.confirm) {
                 return { success: false, error: 'Reset requires confirmation' };
             }
-            const component = input.component || 'metrics';
+            // Validate component against the allowed set to prevent unbounded string
+            // reflection in the response message.
+            const VALID_COMPONENTS = new Set(['all', 'metrics', 'agents', 'tasks']);
+            const rawComponent = input.component || 'metrics';
+            const component = VALID_COMPONENTS.has(rawComponent) ? rawComponent : 'metrics';
             // Reset metrics to defaults
             const defaultMetrics = {
                 startTime: new Date().toISOString(),
@@ -530,7 +537,7 @@ export const systemTools = [
             const storePath = join(getProjectCwd(), '.monomind', 'tasks', 'store.json');
             let tasks = [];
             try {
-                if (existsSync(storePath)) {
+                if (existsSync(storePath) && statSync(storePath).size <= MAX_SYSTEM_STORE_BYTES) {
                     const data = readFileSync(storePath, 'utf-8');
                     const store = JSON.parse(data);
                     tasks = Object.values(store.tasks || {});

package/packages/@monomind/cli/dist/src/mcp-tools/task-tools.js

@@ -71,15 +71,36 @@ export const taskTools = [
         handler: async (input) => {
             const store = loadTaskStore();
             const taskId = `task-${Date.now()}-${randomBytes(4).toString('hex')}`;
+            // Cap all string fields: they are persisted verbatim to the task JSON store.
+            const MAX_TASK_TYPE_LEN = 128;
+            const MAX_TASK_DESC_LEN = 64 * 1024; // 64 KB — realistic task descriptions
+            const MAX_TASK_ASSIGNEE_LEN = 256;
+            const MAX_TASK_ASSIGNEES = 100;
+            const MAX_TASK_TAG_LEN = 128;
+            const MAX_TASK_TAGS = 50;
+            const rawTaskType = input.type;
+            const taskType = typeof rawTaskType === 'string' && rawTaskType.length > MAX_TASK_TYPE_LEN
+                ? rawTaskType.slice(0, MAX_TASK_TYPE_LEN) : rawTaskType;
+            const rawTaskDesc = input.description;
+            const taskDesc = typeof rawTaskDesc === 'string' && rawTaskDesc.length > MAX_TASK_DESC_LEN
+                ? rawTaskDesc.slice(0, MAX_TASK_DESC_LEN) : rawTaskDesc;
+            const rawAssignTo = input.assignTo || [];
+            const assignedTo = Array.isArray(rawAssignTo)
+                ? rawAssignTo.slice(0, MAX_TASK_ASSIGNEES).map(a => typeof a === 'string' && a.length > MAX_TASK_ASSIGNEE_LEN ? a.slice(0, MAX_TASK_ASSIGNEE_LEN) : a)
+                : [];
+            const rawTags = input.tags || [];
+            const tags = Array.isArray(rawTags)
+                ? rawTags.slice(0, MAX_TASK_TAGS).map(t => typeof t === 'string' && t.length > MAX_TASK_TAG_LEN ? t.slice(0, MAX_TASK_TAG_LEN) : t)
+                : [];
             const task = {
                 taskId,
-                type: input.type,
-                description: input.description,
+                type: taskType,
+                description: taskDesc,
                 priority: input.priority || 'normal',
                 status: 'pending',
                 progress: 0,
-                assignedTo: input.assignTo || [],
-                tags: input.tags || [],
+                assignedTo,
+                tags,
                 createdAt: new Date().toISOString(),
                 startedAt: null,
                 completedAt: null,
@@ -172,8 +193,13 @@ export const taskTools = [
             }
             // Sort by creation date (newest first)
             tasks.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-            // Apply limit
-            const limit = input.limit || 50;
+            // Apply limit — cap to 1 000 to prevent returning the entire task store
+            // in one response, which could cause OOM on large deployments.
+            const MAX_TASK_LIMIT = 1_000;
+            const rawLimit = typeof input.limit === 'number' ? input.limit : 50;
+            const limit = Number.isFinite(rawLimit) && rawLimit > 0
+                ? Math.min(Math.floor(rawLimit), MAX_TASK_LIMIT)
+                : 50;
             tasks = tasks.slice(0, limit);
             return {
                 tasks: tasks.map(t => ({
@@ -225,7 +251,7 @@ export const taskTools = [
                     const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
                     try {
                         let agentStore = { agents: {} };
-                        if (existsSync(agentStorePath)) {
+                        if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
                             const agentRaw = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
                             if (agentRaw && typeof agentRaw === 'object' && !Object.prototype.hasOwnProperty.call(agentRaw, '__proto__')) {
                                 agentStore = agentRaw;
@@ -298,7 +324,15 @@ export const taskTools = [
                     task.progress = Math.min(100, Math.max(0, input.progress));
                 }
                 if (input.assignTo) {
-                    task.assignedTo = input.assignTo;
+                    // Cap array and element lengths — task_create already does this;
+                    // task_update must apply the same guards so the on-disk store
+                    // cannot be inflated via the update path.
+                    const MAX_TASK_ASSIGNEE_LEN = 256;
+                    const MAX_TASK_ASSIGNEES = 100;
+                    const rawAssignTo = input.assignTo;
+                    task.assignedTo = Array.isArray(rawAssignTo)
+                        ? rawAssignTo.slice(0, MAX_TASK_ASSIGNEES).map(a => typeof a === 'string' && a.length > MAX_TASK_ASSIGNEE_LEN ? a.slice(0, MAX_TASK_ASSIGNEE_LEN) : a)
+                        : task.assignedTo;
                 }
                 saveTaskStore(store);
                 return {
@@ -343,7 +377,7 @@ export const taskTools = [
             const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
             let agentStore = { agents: {} };
             try {
-                if (existsSync(agentStorePath)) {
+                if (existsSync(agentStorePath) && statSync(agentStorePath).size <= MAX_TASK_STORE_BYTES) {
                     agentStore = JSON.parse(readFileSync(agentStorePath, 'utf-8'));
                 }
             }
@@ -426,7 +460,15 @@ export const taskTools = [
             if (task) {
                 task.status = 'cancelled';
                 task.completedAt = new Date().toISOString();
-                task.result = { cancelReason: input.reason || 'Cancelled by user' };
+                // Cap reason: persisted verbatim to the task store on disk.
+                // Without a cap an attacker can inflate the store with an arbitrarily
+                // large cancellation reason string.
+                const MAX_CANCEL_REASON_LEN = 1024;
+                const rawReason = input.reason;
+                const cancelReason = typeof rawReason === 'string' && rawReason.length > MAX_CANCEL_REASON_LEN
+                    ? rawReason.slice(0, MAX_CANCEL_REASON_LEN)
+                    : (rawReason || 'Cancelled by user');
+                task.result = { cancelReason };
                 saveTaskStore(store);
                 return {
                     success: true,

package/packages/@monomind/cli/dist/src/mcp-tools/terminal-tools.js

@@ -1,6 +1,7 @@
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 // Storage paths
@@ -19,10 +20,11 @@ function ensureTerminalDir() {
         mkdirSync(dir, { recursive: true });
     }
 }
+const MAX_TERMINAL_STORE_BYTES = 10 * 1024 * 1024; // 10 MB
 function loadTerminalStore() {
     try {
         const path = getTerminalPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= MAX_TERMINAL_STORE_BYTES) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
@@ -74,14 +76,40 @@ export const terminalTools = [
                     safeEnv[k] = String(v);
                 }
             }
+            // Validate workingDir: must exist, be a directory, and not escape to
+            // system-sensitive paths. Fall back to project cwd if invalid.
+            let resolvedWorkingDir = getProjectCwd();
+            if (input.workingDir && typeof input.workingDir === 'string') {
+                const candidate = resolve(input.workingDir);
+                const projectCwd = getProjectCwd();
+                const home = homedir();
+                // Allow paths under project cwd or user home directory only.
+                const isUnderProject = candidate === projectCwd || candidate.startsWith(projectCwd + '/') || candidate.startsWith(projectCwd + '\\');
+                const isUnderHome = candidate === home || candidate.startsWith(home + '/') || candidate.startsWith(home + '\\');
+                if ((isUnderProject || isUnderHome) && existsSync(candidate)) {
+                    try {
+                        if (statSync(candidate).isDirectory()) {
+                            resolvedWorkingDir = candidate;
+                        }
+                    }
+                    catch {
+                        // Leave resolvedWorkingDir as default
+                    }
+                }
+            }
             const id = `term-${Date.now()}-${randomBytes(4).toString('hex')}`;
+            // Cap session name: stored in terminal JSON store on disk.
+            const MAX_TERMINAL_NAME_LEN = 256;
+            const rawTerminalName = input.name || `Terminal ${Object.keys(store.sessions).length + 1}`;
+            const terminalName = typeof rawTerminalName === 'string' && rawTerminalName.length > MAX_TERMINAL_NAME_LEN
+                ? rawTerminalName.slice(0, MAX_TERMINAL_NAME_LEN) : rawTerminalName;
             const session = {
                 id,
-                name: input.name || `Terminal ${Object.keys(store.sessions).length + 1}`,
+                name: terminalName,
                 status: 'active',
                 createdAt: new Date().toISOString(),
                 lastActivity: new Date().toISOString(),
-                workingDir: input.workingDir || getProjectCwd(),
+                workingDir: resolvedWorkingDir,
                 history: [],
                 env: safeEnv,
             };
@@ -114,7 +142,13 @@ export const terminalTools = [
         handler: async (input) => {
             const store = loadTerminalStore();
             const sessionId = input.sessionId;
-            const command = input.command;
+            // Cap command: the metacharacter regex check at line 220 is O(n), and the
+            // raw command is stored verbatim in session history (up to 200 entries).
+            // A realistic shell command is well under 64 KB; cap there.
+            const MAX_TERMINAL_COMMAND_LEN = 64 * 1024;
+            const rawCommand = input.command;
+            const command = typeof rawCommand === 'string' && rawCommand.length > MAX_TERMINAL_COMMAND_LEN
+                ? rawCommand.slice(0, MAX_TERMINAL_COMMAND_LEN) : rawCommand;
             const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
             // Reject inherited keys (incl. toString/hasOwnProperty/etc.) so a tampered
             // store.json can't redirect bracket access into Object.prototype.

package/packages/@monomind/cli/dist/src/mcp-tools/transfer-tools.js

@@ -59,7 +59,13 @@ export const transferTools = [
         handler: async (input) => {
             try {
                 const { detectPII } = await import('../transfer/anonymization/index.js');
-                const result = detectPII(input.content);
+                // detectPII runs multiple PII regexes over the entire string — O(n × patterns).
+                // Cap to 1 MB to prevent ReDoS-style DoS from oversized content.
+                const MAX_PII_CONTENT_LEN = 1024 * 1024; // 1 MB
+                const rawContent = input.content;
+                const content = typeof rawContent === 'string' && rawContent.length > MAX_PII_CONTENT_LEN
+                    ? rawContent.slice(0, MAX_PII_CONTENT_LEN) : rawContent;
+                const result = detectPII(content);
                 return createResult(result);
             }
             catch (error) {
@@ -88,7 +94,13 @@ export const transferTools = [
         handler: async (input) => {
             try {
                 const { resolveIPNS } = await import('../transfer/ipfs/client.js');
-                const result = await resolveIPNS(input.name);
+                // Cap IPNS name length — uncapped strings may trigger O(n) path parsing
+                // inside the IPFS client or be reflected in error messages.
+                const MAX_IPNS_NAME_LEN = 512;
+                const rawName = input.name;
+                const name = typeof rawName === 'string' && rawName.length > MAX_IPNS_NAME_LEN
+                    ? rawName.slice(0, MAX_IPNS_NAME_LEN) : rawName;
+                const result = await resolveIPNS(name);
                 return createResult({ success: true, cid: result });
             }
             catch (error) {
@@ -132,7 +144,18 @@ export const transferTools = [
         handler: async (input) => {
             try {
                 const store = await getPatternStore();
-                const results = store.search(input);
+                // Cap query and limit to prevent DoS via large string or result set.
+                const MAX_TRANSFER_QUERY_LEN = 4 * 1024;
+                const MAX_TRANSFER_LIMIT = 500;
+                const inp = input;
+                const cappedInput = {
+                    ...inp,
+                    query: typeof inp.query === 'string' && inp.query.length > MAX_TRANSFER_QUERY_LEN
+                        ? inp.query.slice(0, MAX_TRANSFER_QUERY_LEN) : inp.query,
+                    limit: typeof inp.limit === 'number' && Number.isFinite(inp.limit)
+                        ? Math.min(Math.floor(Math.max(inp.limit, 1)), MAX_TRANSFER_LIMIT) : inp.limit,
+                };
+                const results = store.search(cappedInput);
                 return createResult(results);
             }
             catch (error) {
@@ -296,7 +319,17 @@ export const transferTools = [
                 if (!result.success || !result.registry) {
                     return createResult({ error: result.error || 'Failed to discover registry' }, true);
                 }
-                const opts = input;
+                // Cap query and limit before forwarding to searchPlugins.
+                const MAX_PLUGIN_QUERY_LEN = 4 * 1024;
+                const MAX_PLUGIN_LIMIT = 500;
+                const rawOpts = input;
+                const opts = {
+                    ...rawOpts,
+                    query: typeof rawOpts.query === 'string' && rawOpts.query.length > MAX_PLUGIN_QUERY_LEN
+                        ? rawOpts.query.slice(0, MAX_PLUGIN_QUERY_LEN) : rawOpts.query,
+                    limit: typeof rawOpts.limit === 'number' && Number.isFinite(rawOpts.limit)
+                        ? Math.min(Math.floor(Math.max(rawOpts.limit, 1)), MAX_PLUGIN_LIMIT) : rawOpts.limit,
+                };
                 const searchResult = searchPlugins(result.registry, opts);
                 return createResult(searchResult);
             }

package/packages/@monomind/cli/dist/src/mcp-tools/wasm-agent-tools.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM Agent MCP Tools
+ *
+ * Exposes @monoes/rvagent-wasm operations via MCP protocol.
+ * All tools gracefully degrade when the WASM package is not installed.
+ */
+import type { MCPTool } from './types.js';
+export declare const wasmAgentTools: MCPTool[];
+//# sourceMappingURL=wasm-agent-tools.d.ts.map