monomind 1.11.13 → 1.12.0

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

@@ -5,13 +5,22 @@
  * exported by the published @monoes/monograph@1.2.0. Everything else has been
  * moved to the real package.
  */
-import { join } from 'path';
-import { existsSync, readFileSync } from 'fs';
+import { join, resolve, relative } from 'path';
+import { existsSync, readFileSync, statSync } from 'fs';
 import { openDb, closeDb, countNodes } from '@monoes/monograph';
+const MAX_GROUP_CONFIG_BYTES = 1 * 1024 * 1024; // 1 MB
 function readGroupConfig(configPath) {
     if (!existsSync(configPath))
         return [];
     try {
+        // Guard: only allow paths within cwd to prevent traversal to /etc/passwd etc.
+        const resolved = resolve(configPath);
+        const rel = relative(process.cwd(), resolved);
+        if (rel.startsWith('..') || resolve(rel) === resolve('/'))
+            return [];
+        // OOM guard: skip files larger than 1 MB
+        if (statSync(configPath).size > MAX_GROUP_CONFIG_BYTES)
+            return [];
         const raw = readFileSync(configPath, 'utf-8');
         return JSON.parse(raw);
     }

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

@@ -54,16 +54,29 @@ const monographQueryTool = {
         const { hybridQuery } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
-            const limit = input.limit ?? 20;
+            // Cap limit: passed directly to SQLite queries and hybridQuery; an
+            // unlimited value saturates memory with rows.
+            const MAX_QUERY_LIMIT = 1_000;
+            const rawLimit = input.limit ?? 20;
+            const limit = Number.isFinite(rawLimit) && rawLimit > 0
+                ? Math.min(Math.floor(rawLimit), MAX_QUERY_LIMIT)
+                : 20;
+            // Cap query: passed to FTS5 and hybridQuery; very long queries waste
+            // parse time and can stress the FTS tokenizer.
+            const MAX_MONOGRAPH_QUERY_LEN = 16 * 1024;
+            const rawQuery = input.query;
+            const query = typeof rawQuery === 'string' && rawQuery.length > MAX_MONOGRAPH_QUERY_LEN
+                ? rawQuery.slice(0, MAX_MONOGRAPH_QUERY_LEN)
+                : rawQuery;
             const label = input.label;
             if (process.env['MONOGRAPH_EMBEDDINGS'] === 'true') {
-                const results = await hybridQuery(db, input.query, { limit, label });
+                const results = await hybridQuery(db, query, { limit, label });
                 if (results.length === 0)
                     return text('No results found.');
                 const lines = results.map(r => `[${r.label ?? '?'}] ${r.name ?? r.id}  ${r.filePath ?? ''}  (score: ${r.score.toFixed(4)})`);
                 return text(lines.join('\n'));
             }
-            const results = ftsSearch(db, input.query, limit, label);
+            const results = ftsSearch(db, query, limit, label);
             if (results.length === 0)
                 return text('No results found.');
             const lines = results.map(r => `[${r.label}] ${r.name}  ${r.filePath ?? ''}  (score: ${r.rank.toFixed(3)})`);
@@ -141,7 +154,12 @@ const monographGodNodesTool = {
         const { openDb, closeDb } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
-            const limit = input.limit ?? 20;
+            // Cap limit: passed directly to the SQL LIMIT clause.
+            const MAX_GOD_NODES_LIMIT = 1_000;
+            const rawGodLimit = input.limit ?? 20;
+            const limit = Number.isFinite(rawGodLimit) && rawGodLimit > 0
+                ? Math.min(Math.floor(rawGodLimit), MAX_GOD_NODES_LIMIT)
+                : 20;
             const excluded = ['File', 'Folder', 'Community', 'Concept'];
             const rows = db.prepare(`
         SELECT n.id, n.label, n.name, n.file_path,
@@ -234,12 +252,20 @@ const monographCommunityTool = {
         required: ['id'],
     },
     handler: async (input) => {
+        // Validate community ID — must be a finite integer. parseInt(NaN) or a float
+        // would silently become 0 in SQLite (NaN → NULL → 0 coercion), which would
+        // return all nodes in community 0 instead of an error.
+        const rawId = typeof input.id === 'number' ? input.id : parseInt(String(input.id), 10);
+        if (!Number.isFinite(rawId) || rawId !== Math.floor(rawId)) {
+            return text(`Invalid community ID: ${input.id} (must be an integer)`);
+        }
+        const communityId = rawId;
         const { openDb, closeDb } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
-            const rows = db.prepare('SELECT * FROM nodes WHERE community_id = ?').all(parseInt(input.id, 10));
+            const rows = db.prepare('SELECT * FROM nodes WHERE community_id = ?').all(communityId);
             if (rows.length === 0)
-                return text(`No nodes in community ${input.id}`);
+                return text(`No nodes in community ${communityId}`);
             return text(rows.map(r => `[${r.label}] ${r.name}  ${r.file_path ?? ''}`).join('\n'));
         }
         finally {
@@ -259,7 +285,12 @@ const monographSurprisesTool = {
         const { openDb, closeDb } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
-            const limit = input.limit ?? 20;
+            // Cap limit: passed directly to the SQL LIMIT clause.
+            const MAX_SURPRISES_LIMIT = 1_000;
+            const rawSurprisesLimit = input.limit ?? 20;
+            const limit = Number.isFinite(rawSurprisesLimit) && rawSurprisesLimit > 0
+                ? Math.min(Math.floor(rawSurprisesLimit), MAX_SURPRISES_LIMIT)
+                : 20;
             const rows = db.prepare(`
         SELECT e.*, n1.name as src_name, n2.name as tgt_name
         FROM edges e
@@ -293,8 +324,18 @@ const monographSuggestTool = {
         const { hybridQuery } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
-            const limit = input.limit ?? 10;
-            const task = input.task ?? '';
+            // Cap limit and task: limit is passed directly to SQL LIMIT clause;
+            // task is forwarded to hybridQuery (embedding path) or FTS.
+            const MAX_SUGGEST_LIMIT = 1_000;
+            const MAX_SUGGEST_TASK_LEN = 16 * 1024;
+            const rawSuggestLimit = input.limit ?? 10;
+            const limit = Number.isFinite(rawSuggestLimit) && rawSuggestLimit > 0
+                ? Math.min(Math.floor(rawSuggestLimit), MAX_SUGGEST_LIMIT)
+                : 10;
+            const rawTask = input.task ?? '';
+            const task = typeof rawTask === 'string' && rawTask.length > MAX_SUGGEST_TASK_LEN
+                ? rawTask.slice(0, MAX_SUGGEST_TASK_LEN)
+                : rawTask;
             // When a task is provided and embeddings are enabled, use semantic search
             // to find relevant nodes and surface edge-level questions about them.
             if (task && process.env['MONOGRAPH_EMBEDDINGS'] === 'true') {
@@ -357,7 +398,13 @@ const monographVisualizeTool = {
         const { openDb, closeDb, toJson, toHtml, toSvg } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
-            const limit = input.maxNodes ?? 500;
+            // Cap maxNodes: passed to SQL LIMIT clause for both nodes (n) and edges
+            // (n*3).  Without a cap an attacker requests all rows from both tables.
+            const MAX_EXPORT_NODES = 10_000;
+            const rawMaxNodes = input.maxNodes ?? 500;
+            const limit = Number.isFinite(rawMaxNodes) && rawMaxNodes > 0
+                ? Math.min(Math.floor(rawMaxNodes), MAX_EXPORT_NODES)
+                : 500;
             const nodes = db.prepare('SELECT * FROM nodes LIMIT ?').all(limit);
             const edges = db.prepare('SELECT * FROM edges LIMIT ?').all(limit * 3);
             const fmt = input.format ?? 'html';
@@ -479,13 +526,19 @@ const monographSnapshotTool = {
     handler: async (input) => {
         const { openDb, closeDb, snapshotFromDb } = await import('@monoes/monograph');
         const { writeFileSync, mkdirSync } = await import('fs');
+        const { resolve: resolvePath } = await import('path');
         const db = openDb(getDbPath());
         try {
             const snapshot = snapshotFromDb(db);
-            const name = input.name ?? new Date().toISOString().replace(/[:.]/g, '-');
-            const snapshotDir = join(getProjectCwd(), '.monomind', 'snapshots');
+            const rawName = input.name ?? new Date().toISOString().replace(/[:.]/g, '-');
+            const SAFE_NAME_RE = /^[a-zA-Z0-9_.\-]+$/;
+            if (!SAFE_NAME_RE.test(rawName))
+                return text(`Invalid snapshot name: ${rawName}`);
+            const snapshotDir = resolvePath(join(getProjectCwd(), '.monomind', 'snapshots'));
             mkdirSync(snapshotDir, { recursive: true });
-            const outPath = join(snapshotDir, `${name}.json`);
+            const outPath = join(snapshotDir, `${rawName}.json`);
+            if (!resolvePath(outPath).startsWith(snapshotDir))
+                return text(`Path traversal detected in snapshot name`);
             writeFileSync(outPath, JSON.stringify(snapshot, null, 2));
             return text(`Snapshot saved: ${outPath}\n  nodes: ${snapshot.nodes.length}  edges: ${snapshot.edges.length}`);
         }
@@ -508,18 +561,37 @@ const monographDiffTool = {
     },
     handler: async (input) => {
         const { openDb, closeDb, snapshotFromDb, diffSnapshots } = await import('@monoes/monograph');
-        const { readFileSync, existsSync } = await import('fs');
-        const snapshotDir = join(getProjectCwd(), '.monomind', 'snapshots');
-        const beforePath = join(snapshotDir, `${input.before}.json`);
+        const { readFileSync, existsSync, statSync: statSyncSnap } = await import('fs');
+        const { resolve: resolvePath } = await import('path');
+        const MAX_SNAPSHOT_BYTES = 100 * 1024 * 1024; // 100 MB
+        const snapshotDir = resolvePath(join(getProjectCwd(), '.monomind', 'snapshots'));
+        // Reject snapshot names containing path separators or traversal sequences
+        const SAFE_SNAPSHOT_NAME = /^[a-zA-Z0-9_.\-]+$/;
+        const beforeName = input.before;
+        if (!SAFE_SNAPSHOT_NAME.test(beforeName))
+            return text(`Invalid snapshot name: ${beforeName}`);
+        const beforePath = join(snapshotDir, `${beforeName}.json`);
+        if (!resolvePath(beforePath).startsWith(snapshotDir))
+            return text(`Path traversal detected in snapshot name`);
         if (!existsSync(beforePath)) {
             return text(`Snapshot not found: ${beforePath}\nCreate one first with monograph_snapshot.`);
         }
+        if (statSyncSnap(beforePath).size > MAX_SNAPSHOT_BYTES) {
+            return text(`Snapshot too large to diff: ${beforePath}`);
+        }
         const before = JSON.parse(readFileSync(beforePath, 'utf-8'));
         let after;
         if (input.after) {
-            const afterPath = join(snapshotDir, `${input.after}.json`);
+            const afterName = input.after;
+            if (!SAFE_SNAPSHOT_NAME.test(afterName))
+                return text(`Invalid snapshot name: ${afterName}`);
+            const afterPath = join(snapshotDir, `${afterName}.json`);
+            if (!resolvePath(afterPath).startsWith(snapshotDir))
+                return text(`Path traversal detected in snapshot name`);
             if (!existsSync(afterPath))
                 return text(`Snapshot not found: ${afterPath}`);
+            if (statSyncSnap(afterPath).size > MAX_SNAPSHOT_BYTES)
+                return text(`Snapshot too large to diff: ${afterPath}`);
             after = JSON.parse(readFileSync(afterPath, 'utf-8'));
         }
         else {
@@ -614,9 +686,19 @@ const monographContextTool = {
         const { getMonographContext } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
+            // Cap name and filePath: forwarded to parameterized SQL via getMonographContext.
+            // Very long strings waste memory before the query even executes.
+            const MAX_CTX_NAME_LEN = 512;
+            const MAX_CTX_PATH_LEN = 4 * 1024;
+            const rawCtxName = input.name;
+            const ctxName = typeof rawCtxName === 'string' && rawCtxName.length > MAX_CTX_NAME_LEN
+                ? rawCtxName.slice(0, MAX_CTX_NAME_LEN) : rawCtxName;
+            const rawCtxPath = input.filePath;
+            const ctxPath = typeof rawCtxPath === 'string' && rawCtxPath.length > MAX_CTX_PATH_LEN
+                ? rawCtxPath.slice(0, MAX_CTX_PATH_LEN) : rawCtxPath;
             const result = getMonographContext(db, {
-                name: input.name,
-                filePath: input.filePath,
+                name: ctxName,
+                filePath: ctxPath,
             });
             return text(JSON.stringify(result, null, 2));
         }
@@ -643,10 +725,22 @@ const monographImpactTool = {
         const { getMonographImpact } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
+            // Cap name/filePath; enforce depth ≤ 6 as documented in the schema description.
+            const MAX_IMPACT_NAME_LEN = 512;
+            const MAX_IMPACT_PATH_LEN = 4 * 1024;
+            const rawImpactName = input.name;
+            const impactName = typeof rawImpactName === 'string' && rawImpactName.length > MAX_IMPACT_NAME_LEN
+                ? rawImpactName.slice(0, MAX_IMPACT_NAME_LEN) : rawImpactName;
+            const rawImpactPath = input.filePath;
+            const impactPath = typeof rawImpactPath === 'string' && rawImpactPath.length > MAX_IMPACT_PATH_LEN
+                ? rawImpactPath.slice(0, MAX_IMPACT_PATH_LEN) : rawImpactPath;
+            const rawDepth = input.depth;
+            const depth = typeof rawDepth === 'number' && Number.isFinite(rawDepth) && rawDepth > 0
+                ? Math.min(Math.floor(rawDepth), 6) : rawDepth;
             const result = getMonographImpact(db, {
-                name: input.name,
-                filePath: input.filePath,
-                depth: input.depth,
+                name: impactName,
+                filePath: impactPath,
+                depth,
             });
             return text(JSON.stringify(result, null, 2));
         }
@@ -818,7 +912,14 @@ const monographCypherTool = {
         const { getMonographCypher } = await import('@monoes/monograph');
         const db = openDb(getDbPath());
         try {
-            const result = getMonographCypher(db, input.query);
+            // Cap query: forwarded to the Cypher query engine; very long strings
+            // waste parse time and can stress the query compiler.
+            const MAX_CYPHER_QUERY_LEN = 16 * 1024;
+            const rawCypherQuery = input.query;
+            const cypherQuery = typeof rawCypherQuery === 'string' && rawCypherQuery.length > MAX_CYPHER_QUERY_LEN
+                ? rawCypherQuery.slice(0, MAX_CYPHER_QUERY_LEN)
+                : rawCypherQuery;
+            const result = getMonographCypher(db, cypherQuery);
             if (result.error)
                 return text(`Error: ${result.error}`);
             if (result.rows.length === 0)
@@ -865,7 +966,18 @@ const monographGroupQueryTool = {
     handler: async (input) => {
         const { runGroupQuery } = await import('@monoes/monograph');
         const configPath = input.configPath ?? join(getProjectCwd(), 'group.yaml');
-        const results = await runGroupQuery(configPath, input.query, input.limit);
+        // Cap query and limit forwarded to runGroupQuery.
+        const MAX_GROUP_QUERY_LEN = 16 * 1024;
+        const MAX_GROUP_LIMIT = 1_000;
+        const rawGroupQuery = input.query;
+        const groupQuery = typeof rawGroupQuery === 'string' && rawGroupQuery.length > MAX_GROUP_QUERY_LEN
+            ? rawGroupQuery.slice(0, MAX_GROUP_QUERY_LEN)
+            : rawGroupQuery;
+        const rawGroupLimit = input.limit;
+        const groupLimit = Number.isFinite(rawGroupLimit) && (rawGroupLimit ?? 0) > 0
+            ? Math.min(Math.floor(rawGroupLimit), MAX_GROUP_LIMIT)
+            : rawGroupLimit;
+        const results = await runGroupQuery(configPath, groupQuery, groupLimit);
         if (results.length === 0)
             return text('No results found.');
         const lines = results.map(r => `[${r.label}] ${r.name}  ${r.filePath ?? ''}  repo:${r.repo}  (score: ${r.score.toFixed(4)})`);
@@ -1039,10 +1151,20 @@ const monographAugmentTool = {
     handler: async (input) => {
         const { augmentContext } = await import('@monoes/monograph');
         const repoPath = getProjectCwd();
+        // Cap query (forwarded to FTS/embedding in augmentContext) and topK
+        // (controls how many context nodes are retrieved).
+        const MAX_AUGMENT_QUERY_LEN = 16 * 1024;
+        const MAX_AUGMENT_TOP_K = 100;
+        const rawAugmentQuery = input.query;
+        const augmentQuery = typeof rawAugmentQuery === 'string' && rawAugmentQuery.length > MAX_AUGMENT_QUERY_LEN
+            ? rawAugmentQuery.slice(0, MAX_AUGMENT_QUERY_LEN) : rawAugmentQuery;
+        const rawTopK = input.topK ?? 10;
+        const topK = Number.isFinite(rawTopK) && rawTopK > 0
+            ? Math.min(Math.floor(rawTopK), MAX_AUGMENT_TOP_K) : 10;
         const result = await augmentContext({
-            query: input.query,
+            query: augmentQuery,
             repoPath,
-            topK: input.topK ?? 10,
+            topK,
             format: input.format ?? 'markdown',
         });
         return text(result);

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

@@ -147,7 +147,12 @@ export const neuralTools = [
         },
         handler: async (input) => {
             const store = loadNeuralStore();
-            const modelId = input.modelId || `model-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+            // Cap modelId to prevent DoS via oversized object keys written to the neural store JSON.
+            const MAX_MODEL_ID_LEN = 256;
+            const rawModelId = input.modelId || `model-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+            const modelId = typeof rawModelId === 'string' && rawModelId.length > MAX_MODEL_ID_LEN
+                ? rawModelId.slice(0, MAX_MODEL_ID_LEN)
+                : rawModelId;
             const RESERVED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
             if (RESERVED_KEYS.has(modelId)) {
                 return { success: false, error: 'Invalid modelId' };
@@ -160,8 +165,19 @@ export const neuralTools = [
             if (Object.keys(store.models ?? {}).length >= MAX_MODELS) {
                 return { success: false, error: `Model store full (max ${MAX_MODELS}). Delete old models first.` };
             }
-            const modelType = input.modelType;
-            const epochs = input.epochs || 10;
+            // Runtime-validate modelType against the allowed enum. The JSON schema
+            // declares an enum but callers that bypass schema validation (e.g. direct
+            // MCP calls) can pass arbitrary strings, which would be stored verbatim.
+            const VALID_MODEL_TYPES = new Set(['moe', 'transformer', 'classifier', 'embedding']);
+            const rawModelType = input.modelType;
+            if (!rawModelType || !VALID_MODEL_TYPES.has(rawModelType)) {
+                return { success: false, error: `Invalid modelType "${rawModelType}". Must be one of: moe, transformer, classifier, embedding` };
+            }
+            const modelType = rawModelType;
+            // Cap epochs to prevent storing absurdly large numbers in the JSON store.
+            const MAX_EPOCHS = 10000;
+            const rawEpochs = typeof input.epochs === 'number' && Number.isFinite(input.epochs) ? input.epochs : 10;
+            const epochs = Math.max(1, Math.min(Math.floor(rawEpochs), MAX_EPOCHS));
             const model = {
                 id: modelId,
                 name: `${modelType}-model`,
@@ -225,7 +241,7 @@ export const neuralTools = [
                 try {
                     const patternsPath = join(getNeuralDir(), PATTERNS_FILE);
                     let existing = [];
-                    if (existsSync(patternsPath)) {
+                    if (existsSync(patternsPath) && statSync(patternsPath).size <= MAX_NEURAL_STORE_BYTES) {
                         const raw = readFileSync(patternsPath, 'utf-8');
                         const parsed = JSON.parse(raw);
                         if (Array.isArray(parsed))
@@ -282,7 +298,12 @@ export const neuralTools = [
         },
         handler: async (input) => {
             const store = loadNeuralStore();
-            const modelId = input.modelId;
+            // Cap modelId to prevent O(n) hash/compare cost on absurdly long keys.
+            const MAX_MODEL_ID_LEN_PRED = 256;
+            const rawModelIdPred = input.modelId;
+            const modelId = typeof rawModelIdPred === 'string' && rawModelIdPred.length > MAX_MODEL_ID_LEN_PRED
+                ? rawModelIdPred.slice(0, MAX_MODEL_ID_LEN_PRED)
+                : rawModelIdPred;
             const inputText = typeof input.input === 'string' ? input.input.slice(0, 16 * 1024) : '';
             const topK = Math.max(1, Math.min(input.topK || 3, 50));
             const RESERVED_KEYS_PRED = new Set(['__proto__', 'constructor', 'prototype']);
@@ -309,7 +330,7 @@ export const neuralTools = [
             const cliPatternsRaw = [];
             try {
                 const cliPath = join(getNeuralDir(), PATTERNS_FILE);
-                if (existsSync(cliPath)) {
+                if (existsSync(cliPath) && statSync(cliPath).size <= MAX_NEURAL_STORE_BYTES) {
                     const raw = JSON.parse(readFileSync(cliPath, 'utf-8'));
                     if (Array.isArray(raw)) {
                         const mcpIds = new Set(mcpPatterns.map(p => p.id));
@@ -412,7 +433,12 @@ export const neuralTools = [
                     return { success: false, error: `Pattern store full (max ${MAX_PATTERNS}). Run neural_compress first.` };
                 }
                 const patternId = `pattern-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-                const patternName = input.name || 'Unnamed pattern';
+                // Cap name length to prevent DoS in generateEmbedding (hash path is O(n))
+                const MAX_PATTERN_NAME_LENGTH = 16 * 1024; // 16 KB
+                const rawPatternName = input.name || 'Unnamed pattern';
+                const patternName = typeof rawPatternName === 'string' && rawPatternName.length > MAX_PATTERN_NAME_LENGTH
+                    ? rawPatternName.slice(0, MAX_PATTERN_NAME_LENGTH)
+                    : rawPatternName;
                 // Generate embedding from pattern name/content
                 const embedding = await generateEmbedding(patternName, 384);
                 const pattern = {
@@ -437,7 +463,12 @@ export const neuralTools = [
                 };
             }
             if (action === 'search') {
-                const query = input.query;
+                // Cap query length to prevent DoS in generateEmbedding (hash path is O(n))
+                const MAX_SEARCH_QUERY_LENGTH = 16 * 1024; // 16 KB — matches neural_predict cap
+                const rawQuery = input.query;
+                const query = typeof rawQuery === 'string' && rawQuery.length > MAX_SEARCH_QUERY_LENGTH
+                    ? rawQuery.slice(0, MAX_SEARCH_QUERY_LENGTH)
+                    : rawQuery;
                 // Generate query embedding for real similarity search
                 const queryEmbedding = await generateEmbedding(query, 384);
                 // Calculate REAL cosine similarity against stored patterns
@@ -606,7 +637,11 @@ export const neuralTools = [
         handler: async (input) => {
             const store = loadNeuralStore();
             if (input.modelId) {
-                const modelId = input.modelId;
+                const MAX_MODEL_ID_LEN_STATUS = 256;
+                const rawModelIdStatus = input.modelId;
+                const modelId = typeof rawModelIdStatus === 'string' && rawModelIdStatus.length > MAX_MODEL_ID_LEN_STATUS
+                    ? rawModelIdStatus.slice(0, MAX_MODEL_ID_LEN_STATUS)
+                    : rawModelIdStatus;
                 if (NEURAL_RESERVED_KEYS.has(modelId)) {
                     return { success: false, error: 'Invalid modelId' };
                 }

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

@@ -12,7 +12,7 @@
  * Note: Some optimization suggestions are illustrative
  */
 import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, writeFileSync, renameSync, unlinkSync, readdirSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, writeFileSync, renameSync, unlinkSync, readdirSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import * as os from 'node:os';
 // Storage paths
@@ -32,10 +32,11 @@ function ensurePerfDir() {
         mkdirSync(dir, { recursive: true });
     }
 }
+const MAX_PERF_STORE_BYTES = 50 * 1024 * 1024; // 50 MB
 function loadPerfStore() {
     try {
         const path = getPerfPath();
-        if (existsSync(path)) {
+        if (existsSync(path) && statSync(path).size <= MAX_PERF_STORE_BYTES) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
@@ -226,8 +227,20 @@ export const performanceTools = [
         },
         handler: async (input) => {
             const store = loadPerfStore();
-            const suite = input.suite || 'all';
-            const iterations = input.iterations || 100;
+            // Validate suite against enum to prevent uncapped string from being stored
+            // as a benchmark key on disk.
+            const VALID_SUITES = new Set(['all', 'memory', 'neural', 'swarm', 'io']);
+            const rawSuite = input.suite || 'all';
+            const suite = VALID_SUITES.has(rawSuite) ? rawSuite : 'all';
+            // Cap iterations to prevent event-loop blocking DoS.  The `neural`
+            // suite runs an O(n³) 64×64 matrix multiply per iteration; at 10 000
+            // iterations it already completes in milliseconds.  Uncapped, a caller
+            // could pass iterations=9_999_999 and block the process for minutes.
+            const MAX_BENCHMARK_ITERATIONS = 10_000;
+            const rawIterations = typeof input.iterations === 'number' ? input.iterations : 100;
+            const iterations = Number.isFinite(rawIterations) && rawIterations > 0
+                ? Math.min(Math.floor(rawIterations), MAX_BENCHMARK_ITERATIONS)
+                : 100;
             const warmup = input.warmup !== false;
             // REAL benchmark functions
             const benchmarkFunctions = {
@@ -356,7 +369,11 @@ export const performanceTools = [
             },
         },
         handler: async (input) => {
-            const target = input.target || 'all';
+            // Validate target against enum to prevent arbitrary string from being
+            // stored in the perf store and echoed in the response.
+            const VALID_PROFILE_TARGETS = new Set(['all', 'memory', 'io', 'cpu']);
+            const rawTarget = input.target || 'all';
+            const target = VALID_PROFILE_TARGETS.has(rawTarget) ? rawTarget : 'all';
             const durationSec = Math.min(input.duration || 1, 10);
             const durationMs = durationSec * 1000;
             const cpuBefore = process.cpuUsage();
@@ -457,7 +474,11 @@ export const performanceTools = [
             },
         },
         handler: async (input) => {
-            const target = input.target || 'all';
+            // Validate target against enum — the value is echoed in the response and
+            // stored to the perf store; an unvalidated string could inflate disk state.
+            const VALID_OPT_TARGETS = new Set(['all', 'memory', 'latency', 'throughput']);
+            const rawOptTarget = input.target || 'all';
+            const target = VALID_OPT_TARGETS.has(rawOptTarget) ? rawOptTarget : 'all';
             const aggressive = input.aggressive === true;
             // Snapshot system state BEFORE optimizations
             const loadBefore = os.loadavg();
@@ -559,8 +580,15 @@ export const performanceTools = [
             },
         },
         handler: async (input) => {
-            const metric = input.metric || 'all';
-            const aggregation = input.aggregation || 'avg';
+            // Validate metric and aggregation against their enums.  Both values are
+            // later used as property index keys on plain objects — an attacker who
+            // passes "__proto__" or "constructor" could cause prototype pollution.
+            const VALID_METRICS = new Set(['cpu', 'memory', 'latency', 'throughput', 'all']);
+            const VALID_AGGREGATIONS = new Set(['avg', 'min', 'max', 'p50', 'p95', 'p99']);
+            const rawMetric = input.metric || 'all';
+            const metric = VALID_METRICS.has(rawMetric) ? rawMetric : 'all';
+            const rawAggregation = input.aggregation || 'avg';
+            const aggregation = VALID_AGGREGATIONS.has(rawAggregation) ? rawAggregation : 'avg';
             // Get REAL system metrics
             const memUsage = process.memoryUsage();
             const loadAvg = os.loadavg();
@@ -641,11 +669,18 @@ export const performanceTools = [
                     timestamp: new Date().toISOString(),
                 };
             }
-            const selectedMetric = allMetrics[metric];
+            // Use Object.hasOwn to prevent prototype chain traversal when indexing
+            // by caller-supplied metric/aggregation strings.
+            const selectedMetric = Object.hasOwn(allMetrics, metric)
+                ? allMetrics[metric]
+                : allMetrics.cpu;
+            const aggValue = Object.hasOwn(selectedMetric, aggregation)
+                ? selectedMetric[aggregation]
+                : undefined;
             return {
                 _real: ['cpu', 'memory'].includes(metric),
                 metric,
-                value: selectedMetric[aggregation],
+                value: aggValue,
                 unit: selectedMetric.unit,
                 details: selectedMetric,
                 timestamp: new Date().toISOString(),

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

@@ -5,7 +5,7 @@
  *
  * @module @monomind/cli/mcp-tools/progress
  */
-import { existsSync, readdirSync, readFileSync, writeFileSync, renameSync, mkdirSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, writeFileSync, renameSync, mkdirSync, statSync } from 'fs';
 import { join, basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
 // Get project root - handles both src and dist paths
@@ -53,6 +53,9 @@ function countFilesAndLines(dir, ext = '.ts') {
                 else if (entry.isFile() && entry.name.endsWith(ext)) {
                     files++;
                     try {
+                        // Skip files > 1 MB to avoid loading generated/minified bundles into memory.
+                        if (statSync(fullPath).size > 1024 * 1024)
+                            continue;
                         const content = readFileSync(fullPath, 'utf-8');
                         lines += content.split('\n').length;
                     }
@@ -120,7 +123,7 @@ async function calculateProgress() {
     // Count CLI commands (from commands/index.ts)
     let cliCommands = 28; // Default to known count
     const commandsIndexPath = join(PACKAGES_DIR, '@monomind/cli/src/commands/index.ts');
-    if (existsSync(commandsIndexPath)) {
+    if (existsSync(commandsIndexPath) && statSync(commandsIndexPath).size <= 1024 * 1024) {
         try {
             const content = readFileSync(commandsIndexPath, 'utf-8');
             const matches = content.match(/export const commands.*\[([^\]]+)\]/s);
@@ -133,7 +136,7 @@ async function calculateProgress() {
     // Count MCP tools
     let mcpTools = 100; // Approximate
     const toolsIndexPath = join(PACKAGES_DIR, '@monomind/cli/src/mcp-tools/index.ts');
-    if (existsSync(toolsIndexPath)) {
+    if (existsSync(toolsIndexPath) && statSync(toolsIndexPath).size <= 1024 * 1024) {
         try {
             const content = readFileSync(toolsIndexPath, 'utf-8');
             mcpTools = (content.match(/export.*Tools/g) || []).length * 10 || 100;
@@ -143,7 +146,7 @@ async function calculateProgress() {
     // Count hooks subcommands (count const *Command definitions)
     let hooksSubcommands = 27; // Default to documented count
     const hooksPath = join(PACKAGES_DIR, '@monomind/cli/src/commands/hooks.ts');
-    if (existsSync(hooksPath)) {
+    if (existsSync(hooksPath) && statSync(hooksPath).size <= 1024 * 1024) {
         try {
             const content = readFileSync(hooksPath, 'utf-8');
             // Count command definitions like "const fooCommand: Command = {"

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

@@ -4,6 +4,10 @@
  * Used by system_metrics to report real request counts.
  */
 const MAX_TRACKED_TOOLS = 500;
+const MAX_TOOL_NAME_LEN = 256;
+// Keys that would corrupt Object.prototype or its constructor if used as plain
+// object property keys without Object.hasOwn() protection.
+const FORBIDDEN_TOOL_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
 let counts = {
     total: 0,
     success: 0,
@@ -17,7 +21,17 @@ export function trackRequest(toolName, success) {
         counts.success++;
     else
         counts.errors++;
-    if (Object.keys(counts.byTool).length < MAX_TRACKED_TOOLS || toolName in counts.byTool) {
+    // Guard against prototype pollution via toolName.
+    // The previous `toolName in counts.byTool` check traversed the prototype
+    // chain, so "__proto__" was always truthy and could corrupt Object.prototype.
+    // Use Object.hasOwn() instead, and reject forbidden key names outright.
+    if (typeof toolName !== 'string' ||
+        toolName.length === 0 ||
+        toolName.length > MAX_TOOL_NAME_LEN ||
+        FORBIDDEN_TOOL_NAMES.has(toolName)) {
+        return; // Drop invalid tool names silently
+    }
+    if (Object.keys(counts.byTool).length < MAX_TRACKED_TOOLS || Object.hasOwn(counts.byTool, toolName)) {
         counts.byTool[toolName] = (counts.byTool[toolName] || 0) + 1;
     }
 }