monomind 1.11.14 → 1.12.0

package/packages/@monomind/cli/dist/src/services/config-file-manager.js

@@ -3,6 +3,7 @@
  * Shared JSON config file persistence with atomic writes and Zod validation
  */
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 /** Config file search paths in priority order */
 const CONFIG_FILENAMES = [
@@ -123,7 +124,7 @@ export class ConfigFileManager {
      * drop the first writer's API key.
      */
     set(cwd, key, value) {
-        const KNOWN_SET_SECTIONS = new Set(['version', 'agents', 'swarm', 'memory', 'mcp', 'cli', 'hooks', 'neural']);
+        const KNOWN_SET_SECTIONS = new Set(['version', 'agents', 'swarm', 'memory', 'mcp', 'cli', 'hooks', 'neural', 'providers']);
         const topSection = String(key).split('.')[0];
         if (!KNOWN_SET_SECTIONS.has(topSection)) {
             throw new Error(`Unknown config section: "${topSection}". Allowed: ${[...KNOWN_SET_SECTIONS].join(', ')}`);
@@ -181,6 +182,17 @@ export class ConfigFileManager {
     /** Import config from a specific path */
     importFrom(cwd, importPath) {
         const resolved = path.resolve(cwd, importPath);
+        // Guard against path traversal: the resolved path must be within the
+        // project cwd or the user's home directory.  Without this check an
+        // automated script can pass "/etc/passwd" or "../../.env" and exfiltrate
+        // files outside the project tree.
+        const projectRoot = path.resolve(cwd);
+        const home = os.homedir();
+        const isUnderProject = resolved === projectRoot || resolved.startsWith(projectRoot + path.sep);
+        const isUnderHome = resolved === home || resolved.startsWith(home + path.sep);
+        if (!isUnderProject && !isUnderHome) {
+            throw new Error(`Import path must be within the project directory or home directory: ${resolved}`);
+        }
         if (!fs.existsSync(resolved)) {
             throw new Error(`Import file not found: ${resolved}`);
         }
@@ -199,7 +211,7 @@ export class ConfigFileManager {
         // KNOWN_SECTIONS only validates top-level keys, leaving nested
         // {agents:{providers:[{__proto__:{...}}]}} unsanitized.
         const imported = sanitizeConfigObject(importedRaw);
-        const KNOWN_SECTIONS = new Set(['version', 'agents', 'swarm', 'memory', 'mcp', 'cli', 'hooks']);
+        const KNOWN_SECTIONS = new Set(['version', 'agents', 'swarm', 'memory', 'mcp', 'cli', 'hooks', 'neural', 'providers']);
         for (const key of Object.keys(imported)) {
             if (!KNOWN_SECTIONS.has(key)) {
                 throw new Error(`Unknown config section: "${key}"`);

package/packages/@monomind/cli/dist/src/services/headless-worker-executor.js

@@ -1017,6 +1017,12 @@ Analyze the above codebase context and provide your response following the forma
             let stdout = '';
             let stderr = '';
             let resolved = false;
+            // Cap stdout + stderr to 10 MB each to prevent OOM if a spawned Claude
+            // Code process emits unexpectedly large output (e.g. a worker that dumps
+            // a large file listing).  Once the cap is reached we stop appending; the
+            // truncation marker lets callers detect that output was cut.
+            const MAX_HEADLESS_OUTPUT_BYTES = 10 * 1024 * 1024; // 10 MB
+            const TRUNCATION_MARKER = '\n[... output truncated at 10 MB ...]';
             const cleanup = () => {
                 clearTimeout(timeoutHandle);
                 clearTimeout(sigkillTimer);
@@ -1024,7 +1030,12 @@ Analyze the above codebase context and provide your response following the forma
             };
             child.stdout?.on('data', (data) => {
                 const chunk = data.toString();
-                stdout += chunk;
+                if (stdout.length < MAX_HEADLESS_OUTPUT_BYTES) {
+                    stdout += chunk;
+                    if (stdout.length >= MAX_HEADLESS_OUTPUT_BYTES) {
+                        stdout = stdout.slice(0, MAX_HEADLESS_OUTPUT_BYTES) + TRUNCATION_MARKER;
+                    }
+                }
                 this.emit('output', {
                     executionId: options.executionId,
                     type: 'stdout',
@@ -1033,7 +1044,12 @@ Analyze the above codebase context and provide your response following the forma
             });
             child.stderr?.on('data', (data) => {
                 const chunk = data.toString();
-                stderr += chunk;
+                if (stderr.length < MAX_HEADLESS_OUTPUT_BYTES) {
+                    stderr += chunk;
+                    if (stderr.length >= MAX_HEADLESS_OUTPUT_BYTES) {
+                        stderr = stderr.slice(0, MAX_HEADLESS_OUTPUT_BYTES) + TRUNCATION_MARKER;
+                    }
+                }
                 this.emit('output', {
                     executionId: options.executionId,
                     type: 'stderr',

package/packages/@monomind/cli/dist/src/services/worker-daemon.js

@@ -10,7 +10,7 @@
  * - testgaps: Test coverage analysis (20 min interval)
  */
 import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync, statSync } from 'fs';
 import { cpus } from 'os';
 import { join, resolve } from 'path';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
@@ -106,14 +106,15 @@ export class WorkerDaemon extends EventEmitter {
             this.headlessAvailable = await this.headlessExecutor.isAvailable();
             if (this.headlessAvailable) {
                 this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events
-                this.headlessExecutor.on('execution:start', (data) => {
+                // Forward headless executor events.
+                // The executor emits 'start', 'complete', 'error' (not 'execution:*').
+                this.headlessExecutor.on('start', (data) => {
                     this.emit('headless:start', data);
                 });
-                this.headlessExecutor.on('execution:complete', (data) => {
+                this.headlessExecutor.on('complete', (data) => {
                     this.emit('headless:complete', data);
                 });
-                this.headlessExecutor.on('execution:error', (data) => {
+                this.headlessExecutor.on('error', (data) => {
                     this.emit('headless:error', data);
                 });
                 this.headlessExecutor.on('output', (data) => {
@@ -189,6 +190,12 @@ export class WorkerDaemon extends EventEmitter {
             return {};
         }
         try {
+            // Guard against OOM from an oversized config file (tampered or corrupted).
+            const configSize = statSync(configPath).size;
+            if (configSize > 1_048_576 /* 1 MB */) {
+                this.log('warn', `config.json is unusually large (${configSize} bytes) — ignoring daemon config`);
+                return {};
+            }
             const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
             // Support both flat keys at root and nested under scopes.project
             const cfg = raw?.scopes?.project ?? raw;
@@ -271,6 +278,12 @@ export class WorkerDaemon extends EventEmitter {
         // Try to restore state from file
         if (existsSync(this.config.stateFile)) {
             try {
+                // Guard against OOM from an oversized state file (tampered or corrupted).
+                const stateSize = statSync(this.config.stateFile).size;
+                if (stateSize > 5_242_880 /* 5 MB */) {
+                    this.log('warn', `daemon-state.json is unusually large (${stateSize} bytes) — starting with fresh state`);
+                    return;
+                }
                 const saved = JSON.parse(readFileSync(this.config.stateFile, 'utf-8'));
                 // CRITICAL: Restore worker config (including enabled flag) from saved state
                 // This fixes #950: daemon enable command not persisting worker state
@@ -555,6 +568,17 @@ export class WorkerDaemon extends EventEmitter {
         const state = this.workers.get(workerConfig.type);
         const workerId = `${workerConfig.type}_${Date.now()}`;
         const startTime = Date.now();
+        // Track the headless executionId assigned by HeadlessWorkerExecutor so we
+        // can cancel it precisely on timeout. The executor generates its own ID
+        // (format: `${type}_${ts}_${random}`) which never matches workerId, so we
+        // capture it from the 'start' event instead.
+        let headlessExecutionId = null;
+        const onHeadlessStart = (data) => {
+            headlessExecutionId = data.executionId ?? null;
+        };
+        if (this.headlessExecutor) {
+            this.headlessExecutor.on('start', onHeadlessStart);
+        }
         // Track running worker
         this.runningWorkers.add(workerConfig.type);
         state.isRunning = true;
@@ -566,11 +590,13 @@ export class WorkerDaemon extends EventEmitter {
             // cancelAll() was too broad — it would kill concurrent healthy workers.
             const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`, () => {
                 if (this.headlessExecutor) {
-                    // Try exact-ID cancel first; fall back to type-based cancel which
-                    // avoids killing unrelated concurrent workers (cancelByType).
-                    if (!this.headlessExecutor.cancel(workerId)) {
-                        this.headlessExecutor.cancelByType(workerConfig.type);
+                    // Use the exact executionId captured from the 'start' event.
+                    // Fall back to cancelByType only if we didn't capture an ID yet
+                    // (e.g. timeout fired before the executor emitted 'start').
+                    if (headlessExecutionId && this.headlessExecutor.cancel(headlessExecutionId)) {
+                        return;
                     }
+                    this.headlessExecutor.cancelByType(workerConfig.type);
                 }
             });
             const durationMs = Date.now() - startTime;
@@ -615,6 +641,10 @@ export class WorkerDaemon extends EventEmitter {
         finally {
             // Remove from running set and process queue
             this.runningWorkers.delete(workerConfig.type);
+            // Unsubscribe the executionId capture listener regardless of outcome
+            if (this.headlessExecutor) {
+                this.headlessExecutor.off('start', onHeadlessStart);
+            }
             this.processPendingWorkers();
         }
     }
@@ -752,7 +782,7 @@ export class WorkerDaemon extends EventEmitter {
             checks: {
                 envFilesProtected: !existsSync(join(this.projectRoot, '.env.local')),
                 gitIgnoreExists: existsSync(join(this.projectRoot, '.gitignore')),
-                noHardcodedSecrets: true, // Would need actual scanning
+                noHardcodedSecrets: null, // Not checked in local mode — requires AI-powered scan
             },
             riskLevel: 'low',
             recommendations: [],
@@ -779,8 +809,8 @@ export class WorkerDaemon extends EventEmitter {
             memoryUsage: process.memoryUsage(),
             uptime: process.uptime(),
             optimizations: {
-                cacheHitRate: 0.78,
-                avgResponseTime: 45,
+                cacheHitRate: null, // Not measured in local mode — requires AI-powered analysis
+                avgResponseTime: null, // Not measured in local mode — requires AI-powered analysis
             },
             note: 'Install Claude Code CLI for AI-powered optimization suggestions',
         };
@@ -1042,6 +1072,17 @@ export class WorkerDaemon extends EventEmitter {
         try {
             const logFile = join(this.config.logDir, 'daemon.log');
             appendFileSync(logFile, logMessage + '\n');
+            // Opportunistic rotation: keep the log under 10 MB. When exceeded,
+            // discard the oldest half so recent entries are always retained.
+            const MAX_LOG_BYTES = 10 * 1024 * 1024;
+            if (statSync(logFile).size > MAX_LOG_BYTES) {
+                const content = readFileSync(logFile, 'utf-8');
+                const lines = content.split('\n').filter(Boolean);
+                const trimmed = lines.slice(Math.floor(lines.length / 2)).join('\n') + '\n';
+                const tmp = `${logFile}.${process.pid}.${Date.now()}.tmp`;
+                writeFileSync(tmp, trimmed);
+                renameSync(tmp, logFile);
+            }
         }
         catch {
             // Ignore log write errors

package/packages/@monomind/cli/dist/src/transfer/anonymization/index.d.ts

@@ -11,9 +11,6 @@ export declare function detectPII(content: string): PIIDetectionResult;
  * Redact PII from a string
  */
 export declare function redactPII(content: string): string;
-/**
- * Apply anonymization to CFP document
- */
 export declare function anonymizeCFP(cfp: CFPFormat, level: AnonymizationLevel): {
     cfp: CFPFormat;
     transforms: string[];

package/packages/@monomind/cli/dist/src/transfer/anonymization/index.js

@@ -35,10 +35,15 @@ const REDACTIONS = {
 function hash(input) {
     return crypto.createHash('sha256').update(input).digest('hex');
 }
+/** Maximum content size for PII scanning/redaction (4 MB). */
+const MAX_SCAN_SIZE = 4 * 1024 * 1024;
 /**
  * Detect PII in a string
  */
 export function detectPII(content) {
+    if (content.length > MAX_SCAN_SIZE) {
+        throw new Error(`detectPII: content too large (${content.length} bytes; max ${MAX_SCAN_SIZE})`);
+    }
     const result = {
         found: false,
         count: 0,
@@ -85,6 +90,9 @@ function getSeverity(type) {
  * Redact PII from a string
  */
 export function redactPII(content) {
+    if (content.length > MAX_SCAN_SIZE) {
+        throw new Error(`redactPII: content too large (${content.length} bytes; max ${MAX_SCAN_SIZE})`);
+    }
     let result = content;
     for (const [type, pattern] of Object.entries(PII_PATTERNS)) {
         const replacement = REDACTIONS[type];
@@ -100,9 +108,16 @@ export function redactPII(content) {
 /**
  * Apply anonymization to CFP document
  */
+/** Maximum CFP payload size accepted for anonymization (10 MB). */
+const MAX_CFP_ANONYMIZE_SIZE = 10 * 1024 * 1024;
 export function anonymizeCFP(cfp, level) {
+    // Guard before deep clone to prevent OOM on a crafted large object
+    const serialized = JSON.stringify(cfp);
+    if (serialized.length > MAX_CFP_ANONYMIZE_SIZE) {
+        throw new Error(`anonymizeCFP: CFP payload too large (${serialized.length} bytes; max ${MAX_CFP_ANONYMIZE_SIZE})`);
+    }
     const transforms = [];
-    const anonymized = JSON.parse(JSON.stringify(cfp));
+    const anonymized = JSON.parse(serialized);
     // Level: Minimal
     if (['minimal', 'standard', 'strict', 'paranoid'].includes(level)) {
         // Redact author display name

package/packages/@monomind/cli/dist/src/transfer/export.js

@@ -49,6 +49,14 @@ export async function exportPatterns(cfp, options = {}) {
         // Write to file
         const ext = getFileExtension(format);
         outputPath = output.endsWith(ext) ? output : output + ext;
+        // Path traversal guard — output must resolve within the current working
+        // directory to prevent callers from writing to arbitrary filesystem paths.
+        const projectRoot = path.resolve(process.cwd());
+        const resolvedOutputPath = path.resolve(process.cwd(), outputPath);
+        if (!resolvedOutputPath.startsWith(projectRoot + path.sep) && resolvedOutputPath !== projectRoot) {
+            throw new Error(`Output path must resolve within the project directory: ${projectRoot}`);
+        }
+        outputPath = resolvedOutputPath;
         // Ensure directory exists
         const dir = path.dirname(outputPath);
         if (!fs.existsSync(dir)) {

package/packages/@monomind/cli/dist/src/transfer/ipfs/upload.js

@@ -6,6 +6,14 @@
  * @version 3.0.0
  */
 import * as crypto from 'crypto';
+/**
+ * Sanitize a user-supplied filename before embedding it inside a multipart
+ * Content-Disposition header.  Strip all CR/LF characters (MIME header injection)
+ * and cap length to prevent oversized headers.
+ */
+function sanitizeFileName(name) {
+    return name.replace(/[\r\n]/g, '').slice(0, 200);
+}
 /**
  * Get web3.storage token from environment or config
  */
@@ -42,7 +50,7 @@ async function uploadToWeb3Storage(content, options) {
             'Get a free token at: https://web3.storage');
     }
     const endpoint = options.endpoint || 'https://api.web3.storage';
-    const name = options.name || 'pattern.cfp.json';
+    const name = sanitizeFileName(options.name || 'pattern.cfp.json');
     console.log(`[IPFS] Uploading ${content.length} bytes to web3.storage...`);
     // Create FormData-like body for upload
     const boundary = '----WebKitFormBoundary' + crypto.randomBytes(16).toString('hex');
@@ -91,7 +99,7 @@ async function uploadToPinata(content, options) {
         throw new Error('Pinata API credentials not found. Set PINATA_API_KEY and PINATA_API_SECRET.\n' +
             'Get credentials at: https://pinata.cloud');
     }
-    const name = options.name || 'pattern.cfp.json';
+    const name = sanitizeFileName(options.name || 'pattern.cfp.json');
     console.log(`[IPFS] Uploading ${content.length} bytes to Pinata...`);
     const boundary = '----WebKitFormBoundary' + crypto.randomBytes(16).toString('hex');
     const metadata = JSON.stringify({ name });
@@ -277,14 +285,36 @@ export async function unpinContent(cid, options = {}) {
     console.log(`[IPFS] Demo unpinned`);
     return { success: true };
 }
+/** Allowlisted IPFS gateway hosts for SSRF prevention */
+const ALLOWED_GATEWAY_HOSTS_UPLOAD = new Set([
+    'w3s.link',
+    'gateway.pinata.cloud',
+    'cloudflare-ipfs.com',
+    'ipfs.io',
+    'dweb.link',
+]);
+function isAllowedGateway(gateway) {
+    try {
+        const parsed = new URL(gateway);
+        return parsed.protocol === 'https:' && ALLOWED_GATEWAY_HOSTS_UPLOAD.has(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Check if content exists on IPFS
  */
 export async function checkContent(cid, gateway = 'https://w3s.link') {
+    if (!isAllowedGateway(gateway)) {
+        console.warn(`[IPFS] Blocked checkContent: gateway not in allowlist: ${gateway}`);
+        return { exists: false };
+    }
     console.log(`[IPFS] Checking ${cid}...`);
     try {
         const response = await fetch(`${gateway}/ipfs/${cid}`, {
             method: 'HEAD',
+            signal: AbortSignal.timeout(10000),
         });
         if (response.ok) {
             const size = parseInt(response.headers.get('content-length') || '0', 10);
@@ -315,7 +345,7 @@ export function getIPNSURL(name, gateway = 'https://w3s.link') {
  */
 async function uploadToLocalIPFS(content, options) {
     const apiUrl = process.env.IPFS_API_URL || 'http://localhost:5001';
-    const name = options.name || 'pattern.cfp.json';
+    const name = sanitizeFileName(options.name || 'pattern.cfp.json');
     console.log(`[IPFS] Uploading ${content.length} bytes to ${apiUrl}...`);
     const boundary = '----IPFSBoundary' + crypto.randomBytes(16).toString('hex');
     const body = Buffer.concat([

package/packages/@monomind/cli/dist/src/transfer/serialization/cfp.js

@@ -107,11 +107,17 @@ export function serializeToBuffer(cfp, format) {
             return Buffer.from(json, 'utf-8');
     }
 }
+/** Maximum CFP payload size (10 MB) — prevents OOM on crafted inputs. */
+const MAX_CFP_SIZE = 10 * 1024 * 1024;
 /**
  * Deserialize CFP from string/buffer
  */
 export function deserializeCFP(data) {
     const str = typeof data === 'string' ? data : data.toString('utf-8');
+    // Guard against OOM before parsing
+    if (str.length > MAX_CFP_SIZE) {
+        throw new Error(`CFP payload too large (${str.length} bytes; max ${MAX_CFP_SIZE})`);
+    }
     let parsed;
     try {
         parsed = JSON.parse(str);
@@ -119,9 +125,9 @@ export function deserializeCFP(data) {
     catch (e) {
         throw new Error(`Invalid CFP file: ${e instanceof Error ? e.message : String(e)}`);
     }
-    // Validate magic bytes
+    // Validate magic bytes — use a fixed message to avoid reflecting arbitrary input
     if (parsed.magic !== 'CFP1') {
-        throw new Error(`Invalid CFP format: expected magic 'CFP1', got '${parsed.magic}'`);
+        throw new Error('Invalid CFP format: unexpected magic bytes');
     }
     return parsed;
 }
@@ -131,7 +137,7 @@ export function deserializeCFP(data) {
 export function validateCFP(cfp) {
     const errors = [];
     if (cfp.magic !== 'CFP1') {
-        errors.push(`Invalid magic bytes: ${cfp.magic}`);
+        errors.push('Invalid magic bytes');
     }
     if (!cfp.version) {
         errors.push('Missing version');

package/packages/@monomind/cli/dist/src/transfer/storage/gcs.js

@@ -105,7 +105,24 @@ export async function uploadToGCS(content, options = {}) {
         execFileSync('gcloud', uploadArgs, { encoding: 'utf-8', stdio: 'pipe', timeout: 60000 });
         // Set metadata if provided
         if (options.metadata && Object.keys(options.metadata).length > 0) {
-            const metadataJson = JSON.stringify(options.metadata);
+            // Cap metadata to prevent unbounded flag values; restrict key charset to
+            // alphanumeric/dash/underscore to avoid injection in --custom-metadata=<json>.
+            const MAX_META_KEY_LEN = 128;
+            const MAX_META_VAL_LEN = 512;
+            const MAX_META_ENTRIES = 20;
+            const safeMetadata = {};
+            let metaCount = 0;
+            for (const [k, v] of Object.entries(options.metadata)) {
+                if (metaCount >= MAX_META_ENTRIES)
+                    break;
+                if (typeof k !== 'string' || typeof v !== 'string')
+                    continue;
+                if (!/^[a-zA-Z0-9_-]+$/.test(k))
+                    continue;
+                safeMetadata[k.slice(0, MAX_META_KEY_LEN)] = v.slice(0, MAX_META_VAL_LEN);
+                metaCount++;
+            }
+            const metadataJson = JSON.stringify(safeMetadata);
             try {
                 const metaArgs = ['storage', 'objects', 'update', `gs://${config.bucket}/${objectPath}`, `--custom-metadata=${metadataJson}`];
                 if (config.projectId)
@@ -164,6 +181,15 @@ export async function downloadFromGCS(uri, config) {
         if (cfg?.projectId)
             downloadArgs.push(`--project=${cfg.projectId}`);
         execFileSync('gcloud', downloadArgs, { encoding: 'utf-8', stdio: 'pipe' });
+        const MAX_GCS_DOWNLOAD_BYTES = 50 * 1024 * 1024; // 50 MB
+        const fileSize = fs.statSync(tempFile).size;
+        if (fileSize > MAX_GCS_DOWNLOAD_BYTES) {
+            const resolvedTemp2 = path.resolve(tempFile);
+            if (resolvedTemp2.startsWith(path.resolve(tempDir)))
+                fs.unlinkSync(tempFile);
+            console.error(`[GCS] Downloaded file exceeds size limit (${fileSize} > ${MAX_GCS_DOWNLOAD_BYTES} bytes)`);
+            return null;
+        }
         const content = fs.readFileSync(tempFile);
         const resolvedTemp = path.resolve(tempFile);
         if (resolvedTemp.startsWith(path.resolve(tempDir))) {
@@ -215,9 +241,17 @@ export async function listGCSObjects(prefix, config) {
         const listArgs = ['storage', 'ls', '-l', uri, '--format=json'];
         if (cfg.projectId)
             listArgs.push(`--project=${cfg.projectId}`);
-        const result = execFileSync('gcloud', listArgs, { encoding: 'utf-8', stdio: 'pipe' });
+        const result = execFileSync('gcloud', listArgs, { encoding: 'utf-8', stdio: 'pipe', maxBuffer: 10 * 1024 * 1024 });
+        // Guard against gcloud returning a huge JSON payload that could OOM Node.
+        const MAX_LIST_BYTES = 10 * 1024 * 1024; // 10 MB
+        if (result.length > MAX_LIST_BYTES) {
+            console.error(`[GCS] listGCSObjects response too large (${result.length} bytes), truncating`);
+            return [];
+        }
         const objects = JSON.parse(result);
-        return objects.map((obj) => ({
+        if (!Array.isArray(objects))
+            return [];
+        return objects.slice(0, 10_000).map((obj) => ({
             name: obj.name,
             size: obj.size || 0,
             updated: obj.updated || new Date().toISOString(),

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

@@ -3,6 +3,46 @@
  * Secure discovery mechanism for finding patterns in decentralized environment
  */
 import * as crypto from 'crypto';
+/** Maximum bytes read from any IPFS gateway response to prevent OOM */
+const MAX_DISCOVERY_RESPONSE_BYTES = 10 * 1024 * 1024; // 10 MB
+/**
+ * Read a fetch response body with a hard byte cap.
+ * Aborts the stream early if the limit is exceeded.
+ */
+async function readBodyCapped(response, maxBytes = MAX_DISCOVERY_RESPONSE_BYTES) {
+    const lengthHeader = response.headers.get('content-length');
+    if (lengthHeader) {
+        const declared = parseInt(lengthHeader, 10);
+        if (Number.isFinite(declared) && declared > maxBytes) {
+            throw new Error(`Response too large: ${declared} bytes (max ${maxBytes})`);
+        }
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        return '';
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value) {
+            total += value.byteLength;
+            if (total > maxBytes) {
+                await reader.cancel();
+                throw new Error(`Response too large: exceeded ${maxBytes} bytes`);
+            }
+            chunks.push(value);
+        }
+    }
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+        combined.set(c, offset);
+        offset += c.byteLength;
+    }
+    return new TextDecoder('utf-8').decode(combined);
+}
 import { DEFAULT_STORE_CONFIG, } from './registry.js';
 /**
  * Pattern Store Discovery Service
@@ -136,7 +176,8 @@ export class PatternDiscovery {
                     signal: AbortSignal.timeout(10000),
                 });
                 if (response.ok) {
-                    const data = await response.json();
+                    const text = await readBodyCapped(response, 64 * 1024); // IPNS resolve is tiny
+                    const data = JSON.parse(text);
                     const cid = data.Path?.replace('/ipfs/', '') || '';
                     if (cid) {
                         const resolution = {
@@ -226,7 +267,7 @@ export class PatternDiscovery {
                 signal: AbortSignal.timeout(30000),
             });
             if (response.ok) {
-                const text = await response.text();
+                const text = await readBodyCapped(response);
                 try {
                     const registry = JSON.parse(text);
                     console.log(`[Discovery] Fetched registry with ${registry.patterns?.length || 0} patterns`);
@@ -257,7 +298,8 @@ export class PatternDiscovery {
                     signal: AbortSignal.timeout(15000),
                 });
                 if (response.ok) {
-                    const registry = await response.json();
+                    const altText = await readBodyCapped(response);
+                    const registry = JSON.parse(altText);
                     console.log(`[Discovery] Fetched registry from ${altGateway}`);
                     return registry;
                 }

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

@@ -11,6 +11,7 @@ import { DEFAULT_STORE_CONFIG } from './registry.js';
  * Handles secure download and verification of patterns
  */
 const MAX_DOWNLOAD_CACHE = 500;
+const MAX_PATTERN_FILE_BYTES = 50 * 1024 * 1024; // 50 MB — matches client.ts MAX_IPFS_RESPONSE_BYTES
 const ALLOWED_GATEWAYS = new Set([
     'https://w3s.link',
     'https://dweb.link',
@@ -362,6 +363,10 @@ export class PatternDownloader {
     async importPattern(filePath, strategy = 'merge') {
         console.log(`[Download] Importing pattern with strategy: ${strategy}`);
         try {
+            if (fs.statSync(filePath).size > MAX_PATTERN_FILE_BYTES) {
+                console.error(`[Download] Pattern file exceeds size limit (${MAX_PATTERN_FILE_BYTES} bytes)`);
+                return false;
+            }
             const content = fs.readFileSync(filePath, 'utf-8');
             const cfp = JSON.parse(content);
             // In production: Import to local pattern store

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

@@ -137,13 +137,17 @@ export class PatternPublisher {
         }
         catch (error) {
             console.error(`[Publish] Failed:`, error);
+            // Sanitize error message: strip control chars and cap length to prevent
+            // internal paths / stack traces from leaking into CLI output or logs.
+            const rawMsg = error instanceof Error ? error.message : String(error);
+            const safeMsg = rawMsg.replace(/[\x00-\x1f\x7f]/g, '?').slice(0, 256);
             return {
                 success: false,
                 patternId: '',
                 cid: '',
                 registryCid: '',
                 gatewayUrl: '',
-                message: `Publish failed: ${error}`,
+                message: `Publish failed: ${safeMsg}`,
             };
         }
     }
@@ -152,6 +156,14 @@ export class PatternPublisher {
      */
     async signContent(content, privateKeyPath) {
         const ed = await import('@noble/ed25519');
+        // Guard: cap key file size to prevent OOM on oversized or malicious files.
+        // A valid 32-byte Ed25519 seed encoded as hex is 64 chars; even with a
+        // newline and BOM the file should never exceed a few hundred bytes.
+        const MAX_KEY_FILE_BYTES = 4 * 1024; // 4 KB — generous upper bound
+        const keyFileStat = fs.statSync(privateKeyPath);
+        if (keyFileStat.size > MAX_KEY_FILE_BYTES) {
+            throw new Error(`Private key file exceeds size limit (${MAX_KEY_FILE_BYTES} bytes)`);
+        }
         const keyHex = fs.readFileSync(privateKeyPath, 'utf-8').trim();
         // Accept 64-char hex (32-byte seed) directly; otherwise derive via SHA-256
         const privKeyBytes = keyHex.length === 64

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

@@ -37,6 +37,14 @@ export declare function removePatternFromRegistry(registry: PatternRegistry, pat
 export declare function serializeRegistry(registry: PatternRegistry): string;
 /**
  * Deserialize registry from JSON
+ *
+ * Caps the input string length before parsing to prevent OOM on a malicious or
+ * oversized registry fetched from IPFS / Pinata. The in-flight body is already
+ * capped by readBodyWithLimit (50 MB), but deserializeRegistry is also called
+ * with locally-cached data, so we add a 10 MB guard here too.
+ *
+ * We also reject non-semver and suspiciously long version strings to prevent
+ * version fields being used as a side-channel for large-payload injection.
  */
 export declare function deserializeRegistry(json: string): PatternRegistry;
 /**