monomind 1.11.14 → 1.12.0

package/packages/@monomind/cli/dist/src/commands/hive-mind.js

@@ -10,7 +10,14 @@ import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import { spawn as childSpawn, execSync } from 'child_process';
 import { mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
+import { join, resolve as resolvePath, sep } from 'path';
+// Input length caps
+const MAX_OBJECTIVE_LEN = 2_000;
+const MAX_TASK_DESC_LEN = 4_000;
+const MAX_MESSAGE_LEN = 2_000;
+const MAX_KEY_LEN = 256;
+const MAX_VALUE_LEN = 65_536;
+const MAX_AGENT_ID_LEN = 128;
 // Hive topologies
 const TOPOLOGIES = [
     { value: 'hierarchical', label: 'Hierarchical', hint: 'Queen-led with worker agents' },
@@ -177,11 +184,21 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
             `Consensus: ${output.highlight(flags.consensus || 'byzantine')}`,
             `MCP Tools: ${output.success('Full Monomind integration enabled')}`
         ]);
-        // Ensure sessions directory exists
-        const sessionsDir = join('.hive-mind', 'sessions');
+        // Ensure sessions directory exists (anchor to process.cwd() so relative paths
+        // don't escape when the caller changes directory)
+        const baseDir = resolvePath(process.cwd());
+        const sessionsDir = resolvePath(baseDir, '.hive-mind', 'sessions');
+        // Guard: sessions directory must stay inside cwd
+        if (!sessionsDir.startsWith(baseDir + sep) && sessionsDir !== baseDir) {
+            throw new Error('Sessions directory path traversal detected');
+        }
         await mkdir(sessionsDir, { recursive: true });
         const safeSwarmId = swarmId.replace(/[^a-zA-Z0-9_-]/g, '_');
         const promptFile = join(sessionsDir, `hive-mind-prompt-${safeSwarmId}.txt`);
+        // Guard: prompt file must stay inside sessions directory
+        if (!resolvePath(promptFile).startsWith(sessionsDir + sep)) {
+            throw new Error('Prompt file path traversal detected');
+        }
         await writeFile(promptFile, hiveMindPrompt, 'utf8');
         output.writeln();
         output.printSuccess(`Hive Mind prompt saved to: ${promptFile}`);
@@ -295,10 +312,14 @@ async function spawnClaudeCodeInstance(swarmId, swarmName, objective, workers, f
         spinner.fail('Failed to prepare Claude Code coordination');
         const errorMessage = error instanceof Error ? error.message : String(error);
         output.printError(`Error: ${errorMessage}`);
-        // Try to save prompt as fallback
+        // Try to save prompt as fallback — write inside cwd to avoid path issues
         try {
             const safeSwarmIdFallback = swarmId.replace(/[^a-zA-Z0-9_-]/g, '_');
-            const promptFile = `hive-mind-prompt-${safeSwarmIdFallback}-fallback.txt`;
+            const fallbackDir = resolvePath(process.cwd());
+            const promptFile = join(fallbackDir, `hive-mind-prompt-${safeSwarmIdFallback}-fallback.txt`);
+            if (!resolvePath(promptFile).startsWith(fallbackDir + sep)) {
+                throw new Error('Fallback path traversal');
+            }
             const workerGroups = groupWorkersByType(workers);
             const hiveMindPrompt = generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGroups, flags);
             await writeFile(promptFile, hiveMindPrompt, 'utf8');
@@ -502,12 +523,13 @@ const spawnCommand = {
     ],
     action: async (ctx) => {
         // Parse count with fallback to default
-        const count = ctx.flags.count || 1;
+        const rawCount = ctx.flags.count || 1;
+        const count = Number.isFinite(rawCount) ? Math.max(1, Math.min(rawCount, 50)) : 1;
         const role = ctx.flags.role || 'worker';
         const agentType = ctx.flags.type || 'worker';
         const prefix = ctx.flags.prefix || 'hive-worker';
         const launchClaude = ctx.flags.claude;
-        let objective = ctx.flags.objective || ctx.args.join(' ');
+        let objective = (ctx.flags.objective || ctx.args.join(' ')).slice(0, MAX_OBJECTIVE_LEN);
         output.printInfo(`Spawning ${count} ${role} agent(s)...`);
         try {
             const result = await callMCPTool('hive-mind_spawn', {
@@ -761,12 +783,13 @@ const taskCommand = {
         { command: 'monomind hive-mind task -d "Security review" -p critical -c', description: 'Critical task with consensus' }
     ],
     action: async (ctx) => {
-        let description = ctx.flags.description || ctx.args.join(' ');
+        let description = (ctx.flags.description || ctx.args.join(' ')).slice(0, MAX_TASK_DESC_LEN);
         if (!description && ctx.interactive) {
             description = await input({
                 message: 'Task description:',
                 validate: (v) => v.length > 0 || 'Description is required'
             });
+            description = description.slice(0, MAX_TASK_DESC_LEN);
         }
         if (!description) {
             output.printError('Task description is required');
@@ -888,7 +911,7 @@ const joinCommand = {
         { name: 'role', short: 'r', description: 'Agent role (worker, specialist, scout)', type: 'string', default: 'worker' }
     ],
     action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId;
+        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
         if (!agentId) {
             output.printError('Agent ID is required. Use --agent-id or -a flag, or provide as argument.');
             return { success: false, exitCode: 1 };
@@ -914,7 +937,7 @@ const leaveCommand = {
     description: 'Remove an agent from the hive mind',
     options: [{ name: 'agent-id', short: 'a', description: 'Agent ID to remove', type: 'string' }],
     action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId;
+        const agentId = (ctx.args[0] || ctx.flags['agent-id'] || ctx.flags.agentId || '').slice(0, MAX_AGENT_ID_LEN);
         if (!agentId) {
             output.printError('Agent ID required.');
             return { success: false, exitCode: 1 };
@@ -986,13 +1009,13 @@ const broadcastCommand = {
         { name: 'from', short: 'f', description: 'Sender agent ID', type: 'string' }
     ],
     action: async (ctx) => {
-        const message = ctx.args.join(' ') || ctx.flags.message;
+        const message = (ctx.args.join(' ') || ctx.flags.message || '').slice(0, MAX_MESSAGE_LEN);
         if (!message) {
             output.printError('Message required. Use --message or -m flag.');
             return { success: false, exitCode: 1 };
         }
         try {
-            const result = await callMCPTool('hive-mind_broadcast', { message, priority: ctx.flags.priority, fromId: ctx.flags.from });
+            const result = await callMCPTool('hive-mind_broadcast', { message, priority: ctx.flags.priority, fromId: typeof ctx.flags.from === 'string' ? ctx.flags.from.slice(0, MAX_AGENT_ID_LEN) : undefined });
             if (!result.success) {
                 output.printError(result.error || 'Failed');
                 return { success: false, exitCode: 1 };
@@ -1017,8 +1040,8 @@ const memorySubCommand = {
     ],
     action: async (ctx) => {
         const action = ctx.flags.action || 'list';
-        const key = ctx.flags.key;
-        const value = ctx.flags.value;
+        const key = typeof ctx.flags.key === 'string' ? ctx.flags.key.slice(0, MAX_KEY_LEN) : undefined;
+        const value = typeof ctx.flags.value === 'string' ? ctx.flags.value.slice(0, MAX_VALUE_LEN) : undefined;
         if ((action === 'get' || action === 'delete') && !key) {
             output.printError('Key required for get/delete.');
             return { success: false, exitCode: 1 };

package/packages/@monomind/cli/dist/src/commands/hooks.js

@@ -27,8 +27,10 @@ function readCoverageFromDisk() {
         const summaryPath = join(cwd, relPath);
         if (existsSync(summaryPath)) {
             try {
-                const raw = JSON.parse(readFileSync(summaryPath, 'utf-8'));
-                return parseCoverageSummaryJson(raw, relPath);
+                if (statSync(summaryPath).size <= 4_194_304) {
+                    const raw = JSON.parse(readFileSync(summaryPath, 'utf-8'));
+                    return parseCoverageSummaryJson(raw, relPath);
+                }
             }
             catch {
                 // malformed, try next
@@ -40,8 +42,10 @@ function readCoverageFromDisk() {
         const lcovPath = join(cwd, relPath);
         if (existsSync(lcovPath)) {
             try {
-                const raw = readFileSync(lcovPath, 'utf-8');
-                return parseLcovInfo(raw, relPath);
+                if (statSync(lcovPath).size <= 8_388_608) {
+                    const raw = readFileSync(lcovPath, 'utf-8');
+                    return parseLcovInfo(raw, relPath);
+                }
             }
             catch {
                 // malformed, try next
@@ -52,8 +56,10 @@ function readCoverageFromDisk() {
     const nycPath = join(cwd, '.nyc_output', 'out.json');
     if (existsSync(nycPath)) {
         try {
-            const raw = JSON.parse(readFileSync(nycPath, 'utf-8'));
-            return parseCoverageSummaryJson(raw, '.nyc_output/out.json');
+            if (statSync(nycPath).size <= 4_194_304) {
+                const raw = JSON.parse(readFileSync(nycPath, 'utf-8'));
+                return parseCoverageSummaryJson(raw, '.nyc_output/out.json');
+            }
         }
         catch {
             // malformed
@@ -1785,9 +1791,11 @@ const intelligenceCommand = {
                 try {
                     const pStat = statSync(persistence.patternsFile);
                     patternsFileSize = pStat.size;
-                    const pData = JSON.parse(readFileSync(persistence.patternsFile, 'utf-8'));
-                    if (Array.isArray(pData))
-                        patternsFileEntries = pData.length;
+                    if (patternsFileSize <= 4_194_304) {
+                        const pData = JSON.parse(readFileSync(persistence.patternsFile, 'utf-8'));
+                        if (Array.isArray(pData))
+                            patternsFileEntries = pData.length;
+                    }
                 }
                 catch { /* ignore */ }
             }
@@ -1796,9 +1804,12 @@ const intelligenceCommand = {
             let lastAdaptationFromDisk = null;
             if (persistence.statsExist) {
                 try {
-                    const sData = JSON.parse(readFileSync(persistence.statsFile, 'utf-8'));
-                    trajectoriesFromDisk = sData?.trajectoriesRecorded ?? 0;
-                    lastAdaptationFromDisk = sData?.lastAdaptation ?? null;
+                    const sStat = statSync(persistence.statsFile);
+                    if (sStat.size <= 524_288) {
+                        const sData = JSON.parse(readFileSync(persistence.statsFile, 'utf-8'));
+                        trajectoriesFromDisk = sData?.trajectoriesRecorded ?? 0;
+                        lastAdaptationFromDisk = sData?.lastAdaptation ?? null;
+                    }
                 }
                 catch { /* ignore */ }
             }
@@ -3375,10 +3386,12 @@ const statuslineCommand = {
             for (const lPath of learningJsonPaths) {
                 if (fs.existsSync(lPath)) {
                     try {
-                        const data = JSON.parse(fs.readFileSync(lPath, 'utf-8'));
-                        if (data.intelligence?.score !== undefined) {
-                            intelligencePct = Math.min(100, Math.floor(data.intelligence.score));
-                            break;
+                        if (fs.statSync(lPath).size <= 524_288) {
+                            const data = JSON.parse(fs.readFileSync(lPath, 'utf-8'));
+                            if (data.intelligence?.score !== undefined) {
+                                intelligencePct = Math.min(100, Math.floor(data.intelligence.score));
+                                break;
+                            }
                         }
                     }
                     catch { /* ignore */ }
@@ -3500,9 +3513,11 @@ const statuslineCommand = {
         const settingsPath = path.join(process.cwd(), '.claude', 'settings.json');
         if (fs.existsSync(settingsPath)) {
             try {
-                const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-                if (settings.hooks) {
-                    hooksStats.enabled = Object.values(settings.hooks).filter((h) => h && typeof h === 'object').length;
+                if (fs.statSync(settingsPath).size <= 524_288) {
+                    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+                    if (settings.hooks) {
+                        hooksStats.enabled = Object.values(settings.hooks).filter((h) => h && typeof h === 'object').length;
+                    }
                 }
             }
             catch { /* ignore */ }
@@ -3585,12 +3600,14 @@ const statuslineCommand = {
         const vectorsPath = path.join(process.cwd(), '.monomind', 'vectors.json');
         if (fs.existsSync(vectorsPath) && agentdbStats.vectorCount === 0) {
             try {
-                const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));
-                if (Array.isArray(data)) {
-                    agentdbStats.vectorCount = data.length;
-                }
-                else if (data.vectors) {
-                    agentdbStats.vectorCount = Object.keys(data.vectors).length;
+                if (fs.statSync(vectorsPath).size <= 8_388_608) {
+                    const data = JSON.parse(fs.readFileSync(vectorsPath, 'utf-8'));
+                    if (Array.isArray(data)) {
+                        agentdbStats.vectorCount = data.length;
+                    }
+                    else if (data.vectors) {
+                        agentdbStats.vectorCount = Object.keys(data.vectors).length;
+                    }
                 }
             }
             catch { /* ignore */ }

package/packages/@monomind/cli/dist/src/commands/init.js

@@ -99,7 +99,7 @@ const initAction = async (ctx) => {
                 const { spawn } = await import('child_process');
                 const pidFile = path.join(ctx.cwd, '.monomind', 'monograph-watch.pid');
                 let alreadyRunning = false;
-                if (fs.existsSync(pidFile)) {
+                if (fs.existsSync(pidFile) && fs.statSync(pidFile).size <= 32) {
                     const existingPid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
                     if (!isNaN(existingPid)) {
                         try {
@@ -738,9 +738,14 @@ const upgradeCommand = {
             // Try to read control URL for dashboard progress events (best-effort)
             let controlUrl = 'http://localhost:4242';
             try {
-                const ctrlCfg = JSON.parse(fs.readFileSync(path.join(process.cwd(), '.monomind', 'control.json'), 'utf-8'));
-                if (ctrlCfg.url)
-                    controlUrl = ctrlCfg.url;
+                const ctrlPath = path.join(process.cwd(), '.monomind', 'control.json');
+                if (fs.existsSync(ctrlPath) && fs.statSync(ctrlPath).size <= 4096) {
+                    const ctrlCfg = JSON.parse(fs.readFileSync(ctrlPath, 'utf-8'));
+                    // Only allow localhost/127.0.0.1 URLs to prevent SSRF via attacker-controlled control.json
+                    if (typeof ctrlCfg.url === 'string' && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(ctrlCfg.url)) {
+                        controlUrl = ctrlCfg.url;
+                    }
+                }
             }
             catch { }
             const emitUpgradeProgress = async (projDir, status, current, total) => {

package/packages/@monomind/cli/dist/src/commands/issues.js

@@ -106,9 +106,9 @@ const claimCommand = {
         },
     ],
     action: async (ctx) => {
-        const issueId = (ctx.flags.issue || ctx.args[0]);
-        const agentStr = ctx.flags.agent;
-        const userStr = ctx.flags.user;
+        const issueId = (ctx.flags.issue || ctx.args[0])?.slice(0, 256);
+        const agentStr = ctx.flags.agent?.slice(0, 256);
+        const userStr = ctx.flags.user?.slice(0, 256);
         if (!issueId) {
             output.printError('Issue ID is required');
             return { success: false, exitCode: 1 };
@@ -120,13 +120,13 @@ const claimCommand = {
         const claimant = agentStr
             ? {
                 type: 'agent',
-                agentType: agentStr.split(':')[0],
-                agentId: agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`,
+                agentType: agentStr.split(':')[0].slice(0, 64),
+                agentId: (agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`).slice(0, 128),
             }
             : {
                 type: 'human',
-                userId: userStr.split(':')[0],
-                name: userStr.split(':')[1] || userStr.split(':')[0],
+                userId: userStr.split(':')[0].slice(0, 128),
+                name: (userStr.split(':')[1] || userStr.split(':')[0]).slice(0, 128),
             };
         const service = getClaimService(ctx.cwd);
         await service.initialize();
@@ -165,9 +165,9 @@ const releaseCommand = {
         },
     ],
     action: async (ctx) => {
-        const issueId = (ctx.flags.issue || ctx.args[0]);
-        const agentStr = ctx.flags.agent;
-        const userStr = ctx.flags.user;
+        const issueId = (ctx.flags.issue || ctx.args[0])?.slice(0, 256);
+        const agentStr = ctx.flags.agent?.slice(0, 256);
+        const userStr = ctx.flags.user?.slice(0, 256);
         if (!issueId) {
             output.printError('Issue ID is required');
             return { success: false, exitCode: 1 };
@@ -179,13 +179,13 @@ const releaseCommand = {
         const claimant = agentStr
             ? {
                 type: 'agent',
-                agentType: agentStr.split(':')[0],
-                agentId: agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`,
+                agentType: agentStr.split(':')[0].slice(0, 64),
+                agentId: (agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`).slice(0, 128),
             }
             : {
                 type: 'human',
-                userId: userStr.split(':')[0],
-                name: userStr.split(':')[1] || userStr.split(':')[0],
+                userId: userStr.split(':')[0].slice(0, 128),
+                name: (userStr.split(':')[1] || userStr.split(':')[0]).slice(0, 128),
             };
         const service = getClaimService(ctx.cwd);
         await service.initialize();
@@ -210,10 +210,10 @@ const handoffCommand = {
         { name: 'reason', short: 'r', type: 'string', description: 'Handoff reason', default: 'Handoff requested' },
     ],
     action: async (ctx) => {
-        const issueId = (ctx.flags.issue || ctx.args[0]);
-        const toStr = ctx.flags.to;
-        const fromStr = ctx.flags.from;
-        const reason = ctx.flags.reason;
+        const issueId = (ctx.flags.issue || ctx.args[0])?.slice(0, 256);
+        const toStr = ctx.flags.to?.slice(0, 256);
+        const fromStr = ctx.flags.from?.slice(0, 256);
+        const reason = (ctx.flags.reason || 'Handoff requested').slice(0, 512);
         if (!issueId || !toStr) {
             output.printError('Issue ID and --to are required');
             return { success: false, exitCode: 1 };
@@ -257,7 +257,7 @@ const statusCommand = {
         { name: 'note', short: 'n', type: 'string', description: 'Status note' },
     ],
     action: async (ctx) => {
-        const issueId = (ctx.flags.issue || ctx.args[0]);
+        const issueId = (ctx.flags.issue || ctx.args[0])?.slice(0, 256);
         if (!issueId) {
             output.printError('Issue ID is required');
             return { success: false, exitCode: 1 };
@@ -265,8 +265,11 @@ const statusCommand = {
         const service = getClaimService(ctx.cwd);
         await service.initialize();
         const newStatus = ctx.flags.set;
-        const progress = ctx.flags.progress;
-        const note = ctx.flags.note;
+        const rawProgress = ctx.flags.progress;
+        const progress = rawProgress !== undefined
+            ? Math.max(0, Math.min(100, Math.floor(rawProgress)))
+            : undefined;
+        const note = ctx.flags.note?.slice(0, 512);
         try {
             if (newStatus) {
                 await service.updateStatus(issueId, newStatus, note);
@@ -301,7 +304,7 @@ const stealableCommand = {
         { name: 'type', short: 't', type: 'string', description: 'Filter by agent type' },
     ],
     action: async (ctx) => {
-        const agentType = ctx.flags.type;
+        const agentType = ctx.flags.type?.slice(0, 64);
         const service = getClaimService(ctx.cwd);
         await service.initialize();
         const stealable = await service.getStealable(agentType);
@@ -331,16 +334,16 @@ const stealCommand = {
         { name: 'agent', short: 'a', type: 'string', description: 'Steal as agent', required: true },
     ],
     action: async (ctx) => {
-        const issueId = (ctx.flags.issue || ctx.args[0]);
-        const agentStr = ctx.flags.agent;
+        const issueId = (ctx.flags.issue || ctx.args[0])?.slice(0, 256);
+        const agentStr = (ctx.flags.agent || '').slice(0, 256);
         if (!issueId) {
             output.printError('Issue ID is required');
             return { success: false, exitCode: 1 };
         }
         const stealer = {
             type: 'agent',
-            agentType: agentStr.split(':')[0],
-            agentId: agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`,
+            agentType: agentStr.split(':')[0].slice(0, 64),
+            agentId: (agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`).slice(0, 128),
         };
         const service = getClaimService(ctx.cwd);
         await service.initialize();

package/packages/@monomind/cli/dist/src/commands/mcp.js

@@ -88,10 +88,15 @@ const startCommand = {
         { command: 'monomind mcp start -f', description: 'Force restart (kill existing)' }
     ],
     action: async (ctx) => {
-        const port = ctx.flags.port ?? 3000;
-        const host = ctx.flags.host ?? 'localhost';
+        const rawPort = ctx.flags.port ?? 3000;
+        const port = Number.isFinite(rawPort) && rawPort >= 1 && rawPort <= 65535 ? Math.floor(rawPort) : 3000;
+        const rawHost = ctx.flags.host ?? 'localhost';
+        // Cap host length and reject control chars to prevent injection
+        const host = typeof rawHost === 'string' ? rawHost.slice(0, 253).replace(/[\x00-\x1f]/g, '') : 'localhost';
         const transport = ctx.flags.transport ?? 'stdio';
-        const tools = ctx.flags.tools || 'all';
+        const rawTools = ctx.flags.tools || 'all';
+        // Cap tools string to prevent DoS via oversized comma-separated lists
+        const tools = typeof rawTools === 'string' ? rawTools.slice(0, 2000) : 'all';
         const daemon = ctx.flags.daemon ?? false;
         const force = ctx.flags.force ?? false;
         output.writeln();
@@ -599,14 +604,15 @@ const logsCommand = {
     action: async (ctx) => {
         const lines = ctx.flags.lines || 50;
         // Try to find and read the actual log file
-        const { existsSync, readFileSync } = await import('fs');
+        const { existsSync, readFileSync, statSync } = await import('fs');
         const { join } = await import('path');
+        const MAX_MCP_LOG_BYTES = 10 * 1024 * 1024; // 10 MB
         const logPaths = [
             join(ctx.cwd, '.monomind', 'logs', 'mcp-server.log'),
             join(ctx.cwd, '.monomind', 'logs', 'daemon.log'),
             join(ctx.cwd, '.monomind', 'mcp.log'),
         ];
-        const logFile = logPaths.find(p => existsSync(p));
+        const logFile = logPaths.find(p => existsSync(p) && statSync(p).size <= MAX_MCP_LOG_BYTES);
         output.writeln();
         output.writeln(output.bold('MCP Server Logs'));
         output.writeln(output.dim('─'.repeat(50)));

package/packages/@monomind/cli/dist/src/commands/memory.js

@@ -511,6 +511,11 @@ const editCommand = {
             output.printError(`File not found: ${filePath}`);
             return { success: false, exitCode: 1 };
         }
+        const MAX_MEMORY_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+        if (fs.statSync(filePath).size > MAX_MEMORY_FILE_BYTES) {
+            output.printError(`Memory file too large (> 50 MB): ${filePath}`);
+            return { success: false, exitCode: 1 };
+        }
         let entries;
         try {
             const raw = fs.readFileSync(filePath, 'utf8');
@@ -763,6 +768,11 @@ const deleteCommand = {
             output.printError(`File not found: ${filePath}`);
             return { success: false, exitCode: 1 };
         }
+        const MAX_MEMORY_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
+        if (fs.statSync(filePath).size > MAX_MEMORY_FILE_BYTES) {
+            output.printError(`Memory file too large (> 50 MB): ${filePath}`);
+            return { success: false, exitCode: 1 };
+        }
         let entries;
         try {
             const raw = fs.readFileSync(filePath, 'utf8');

package/packages/@monomind/cli/dist/src/commands/migrate.js

@@ -47,7 +47,7 @@ const statusCommand = {
         let hasV2Config = false;
         let hasv1Config = false;
         try {
-            if (fs.existsSync(v2ConfigPath)) {
+            if (fs.existsSync(v2ConfigPath) && fs.statSync(v2ConfigPath).size <= MAX_MIGRATE_FILE_BYTES) {
                 const raw = fs.readFileSync(v2ConfigPath, 'utf-8');
                 const parsed = JSON.parse(raw);
                 if (parsed.version === '2' || parsed.version === 2 || !parsed.version) {
@@ -110,7 +110,7 @@ const statusCommand = {
         const migrationStatePath = path.join(cwd, '.monomind', 'migration-state.json');
         let migrationState = null;
         try {
-            if (fs.existsSync(migrationStatePath)) {
+            if (fs.existsSync(migrationStatePath) && fs.statSync(migrationStatePath).size <= MAX_MIGRATE_FILE_BYTES) {
                 const raw = fs.readFileSync(migrationStatePath, 'utf-8');
                 const parsed = JSON.parse(raw);
                 migrationState = parsed.status || 'unknown';
@@ -214,7 +214,7 @@ const runCommand = {
         if (!target || target === 'config') {
             const v2ConfigPath = path.join(cwd, 'monomind.config.json');
             try {
-                if (fs.existsSync(v2ConfigPath)) {
+                if (fs.existsSync(v2ConfigPath) && fs.statSync(v2ConfigPath).size <= MAX_MIGRATE_FILE_BYTES) {
                     const raw = fs.readFileSync(v2ConfigPath, 'utf-8');
                     const parsed = JSON.parse(raw);
                     if (parsed.version === '2' || parsed.version === 2 || !parsed.version) {
@@ -415,7 +415,7 @@ const verifyCommand = {
         // Check 1: Migration state file exists
         let migrationState = null;
         try {
-            if (fs.existsSync(migrationStatePath)) {
+            if (fs.existsSync(migrationStatePath) && fs.statSync(migrationStatePath).size <= MAX_MIGRATE_FILE_BYTES) {
                 const raw = fs.readFileSync(migrationStatePath, 'utf-8');
                 migrationState = JSON.parse(raw);
                 checks.push({ check: 'Migration state file', result: 'passed' });
@@ -432,7 +432,7 @@ const verifyCommand = {
         // Check 2: v1 config exists and is valid JSON
         const v1ConfigPath = path.join(v1Dir, 'config.json');
         try {
-            if (fs.existsSync(v1ConfigPath)) {
+            if (fs.existsSync(v1ConfigPath) && fs.statSync(v1ConfigPath).size <= MAX_MIGRATE_FILE_BYTES) {
                 const raw = fs.readFileSync(v1ConfigPath, 'utf-8');
                 JSON.parse(raw); // validate JSON
                 checks.push({ check: 'v1 config (valid JSON)', result: 'passed' });

package/packages/@monomind/cli/dist/src/commands/monograph.js

@@ -255,16 +255,27 @@ const searchCommand = {
         { command: 'monomind monograph search -q "pipeline" --mode semantic', description: 'Semantic (embedding) search' },
     ],
     action: async (ctx) => {
-        const query = ctx.flags.query;
-        const limit = parseInt(ctx.flags.limit || '15', 10);
-        const label = ctx.flags.label;
-        const mode = ctx.flags.mode ?? 'hybrid';
+        const rawQuery = ctx.flags.query;
+        const rawLimit = parseInt(ctx.flags.limit || '15', 10);
+        const rawLabel = ctx.flags.label;
+        const rawMode = ctx.flags.mode ?? 'hybrid';
         const root = resolve(ctx.flags.path ?? process.cwd());
         const dbPath = getDbPath(root);
+        // Cap query to prevent SQLite FTS DoS from multi-MB query strings
+        const MAX_QUERY_LEN = 2048;
+        const query = typeof rawQuery === 'string' ? rawQuery.slice(0, MAX_QUERY_LEN) : '';
         if (!query) {
             output.printError('--query is required');
             return { success: false, exitCode: 1 };
         }
+        // Clamp limit to prevent huge result sets from causing OOM
+        const limit = isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 500) : 15;
+        // Validate mode to an explicit allowlist
+        const VALID_MODES = new Set(['bm25', 'semantic', 'hybrid']);
+        const mode = VALID_MODES.has(rawMode) ? rawMode : 'hybrid';
+        // Cap label to prevent oversized SQL filter values
+        const MAX_LABEL_LEN = 64;
+        const label = typeof rawLabel === 'string' ? rawLabel.slice(0, MAX_LABEL_LEN) : undefined;
         if (!existsSync(dbPath)) {
             output.printWarning('No knowledge graph found. Run: monomind monograph build');
             return { success: false, exitCode: 1 };
@@ -345,7 +356,9 @@ const statsCommand = {
     ],
     action: async (ctx) => {
         const root = resolve(ctx.flags.path ?? process.cwd());
-        const top = parseInt(ctx.flags.top || '10', 10);
+        const rawTop = parseInt(ctx.flags.top || '10', 10);
+        // Clamp top-N to prevent arbitrarily large SQL LIMIT values
+        const top = isFinite(rawTop) && rawTop > 0 ? Math.min(rawTop, 200) : 10;
         const dbPath = getDbPath(root);
         if (!existsSync(dbPath)) {
             output.printWarning('No knowledge graph found. Run: monomind monograph build');

package/packages/@monomind/cli/dist/src/commands/monovector/backup.js

@@ -461,7 +461,14 @@ const restoreSubcommand = {
                 output.printError(`File not found: ${inputPath}`);
                 return { success: false, exitCode: 1 };
             }
-            // Read file
+            // Read file — check size first to avoid OOM on a runaway or corrupt file.
+            const fileSize = fs.statSync(inputPath).size;
+            const MAX_BACKUP_BYTES = 500 * 1024 * 1024; // 500 MB
+            if (fileSize > MAX_BACKUP_BYTES) {
+                spinner.fail('Backup file too large');
+                output.printError(`Backup file exceeds size limit (${formatBytes(fileSize)} > ${formatBytes(MAX_BACKUP_BYTES)})`);
+                return { success: false, exitCode: 1 };
+            }
             let content;
             if (inputPath.endsWith('.gz')) {
                 const zlib = await import('zlib');
@@ -473,7 +480,6 @@ const restoreSubcommand = {
             else {
                 content = fs.readFileSync(inputPath, 'utf-8');
             }
-            const fileSize = fs.statSync(inputPath).size;
             spinner.succeed(`Read backup file (${formatBytes(fileSize)})`);
             // Determine format
             const isJson = content.trim().startsWith('{');

package/packages/@monomind/cli/dist/src/commands/monovector/benchmark.js

@@ -151,13 +151,26 @@ export const benchmarkCommand = {
     ],
     action: async (ctx) => {
         const config = getConnectionConfig(ctx);
-        const numVectors = parseInt(ctx.flags.vectors || '10000', 10);
-        const dimensions = parseInt(ctx.flags.dimensions || '1536', 10);
-        const numQueries = parseInt(ctx.flags.queries || '100', 10);
-        const topK = parseInt(ctx.flags.k || '10', 10);
-        const metric = ctx.flags.metric || 'cosine';
-        const indexType = ctx.flags.index || 'hnsw';
-        const batchSize = parseInt(ctx.flags['batch-size'] || '1000', 10);
+        // Clamp numeric inputs to safe ranges to prevent DoS via OOM
+        const numVectors = Math.min(Math.max(1, parseInt(ctx.flags.vectors || '10000', 10)), 1_000_000);
+        const dimensions = Math.min(Math.max(1, parseInt(ctx.flags.dimensions || '1536', 10)), 65536);
+        const numQueries = Math.min(Math.max(1, parseInt(ctx.flags.queries || '100', 10)), 10_000);
+        const topK = Math.min(Math.max(1, parseInt(ctx.flags.k || '10', 10)), 10_000);
+        // Validate metric and indexType against allowlists to prevent SQL injection
+        const VALID_METRICS = ['cosine', 'l2', 'inner'];
+        const VALID_INDEX_TYPES = ['hnsw', 'ivfflat', 'none'];
+        const rawMetric = ctx.flags.metric || 'cosine';
+        const rawIndexType = ctx.flags.index || 'hnsw';
+        const metric = VALID_METRICS.includes(rawMetric) ? rawMetric : 'cosine';
+        const indexType = VALID_INDEX_TYPES.includes(rawIndexType) ? rawIndexType : 'hnsw';
+        const batchSize = Math.min(Math.max(1, parseInt(ctx.flags['batch-size'] || '1000', 10)), 100_000);
+        // Validate schema identifier against safe pattern to prevent SQL injection
+        const rawSchema = config.schema || 'monomind';
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/.test(rawSchema)) {
+            output.printError('Invalid schema name. Only alphanumeric characters and underscores are allowed.');
+            return { success: false, exitCode: 1 };
+        }
+        config.schema = rawSchema;
         const cleanup = ctx.flags.cleanup !== false;
         output.writeln();
         output.writeln(output.bold('MonoVector Performance Benchmark'));