monomind 1.11.14 → 1.13.0

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();
         }
     }
@@ -731,6 +761,59 @@ export class WorkerDaemon extends EventEmitter {
             },
             scannedAt: Date.now(),
         };
+        // Enrich with monograph graph stats for LLM context injection.
+        // Lazy-import to avoid hard dependency; silently skip on any error.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    // Node/edge counts
+                    map['graph'] = {
+                        nodes: countNodes(db),
+                        edges: countEdges(db),
+                    };
+                    // Top 3 god nodes (high degree internal files) — same SQL as monograph_god_nodes tool
+                    const excluded = ['File', 'Folder', 'Community', 'Concept'];
+                    const rows = db.prepare(`
+            SELECT n.name, n.file_path, n.start_line,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN (${excluded.map(() => '?').join(',')})
+            GROUP BY n.id HAVING degree > 0
+            ORDER BY degree DESC LIMIT 3
+          `).all(...excluded);
+                    if (rows.length > 0) {
+                        map['topFiles'] = rows.map(r => ({
+                            ref: r.file_path
+                                ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
+                                : r.name,
+                            degree: r.degree,
+                        }));
+                    }
+                    // Index staleness via git — same approach as monograph_health tool
+                    try {
+                        const { execSync } = await import('child_process');
+                        const lastHash = db.prepare("SELECT value FROM meta WHERE key = 'last_commit_hash' LIMIT 1").get()?.value;
+                        if (lastHash) {
+                            const countOut = execSync(`git -C ${JSON.stringify(this.projectRoot)} rev-list --count ${lastHash}..HEAD`, { timeout: 5000 }).toString().trim();
+                            const commitsBehind = parseInt(countOut, 10);
+                            if (!isNaN(commitsBehind)) {
+                                map['graphStaleness'] = { commitsBehind };
+                            }
+                        }
+                    }
+                    catch { /* git unavailable — skip staleness */ }
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+        }
+        catch { /* monograph unavailable — skip graph enrichment */ }
         const metricsFileTmp1 = metricsFile + '.tmp';
         writeFileSync(metricsFileTmp1, JSON.stringify(map, null, 2));
         renameSync(metricsFileTmp1, metricsFile);
@@ -752,12 +835,74 @@ 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: [],
             note: 'Install Claude Code CLI for AI-powered security analysis',
         };
+        // Enrich with monograph high-centrality files and surprising cross-community edges.
+        // God-node files are high-value targets for security review: they are imported by
+        // many consumers, so a vulnerability there has the largest blast radius.
+        // Cross-community edges reveal unexpected coupling that may indicate hidden attack surfaces.
+        try {
+            const { openDb, closeDb } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const godFileRows = db.prepare(`
+            SELECT n.file_path,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN ('File','Folder','Community','Concept')
+              AND n.file_path IS NOT NULL
+              AND n.file_path NOT LIKE '%node_modules%'
+              AND n.file_path NOT LIKE '%/dist/%'
+              AND n.file_path NOT LIKE '%.test.%'
+              AND n.file_path NOT LIKE '%.spec.%'
+            GROUP BY n.file_path
+            ORDER BY degree DESC
+            LIMIT 5
+          `).all();
+                    const surpriseRows = db.prepare(`
+            SELECT n1.name as src_name, n2.name as tgt_name, e.relation, e.confidence_score,
+                   n1.file_path as src_file, n2.file_path as tgt_file
+            FROM edges e
+            JOIN nodes n1 ON n1.id = e.source_id
+            JOIN nodes n2 ON n2.id = e.target_id
+            WHERE e.confidence != 'EXTRACTED'
+              AND n1.community_id IS NOT NULL
+              AND n2.community_id IS NOT NULL
+              AND n1.community_id != n2.community_id
+            ORDER BY e.confidence_score ASC
+            LIMIT 5
+          `).all();
+                    if (godFileRows.length > 0) {
+                        audit['priorityScanTargets'] = godFileRows.map(r => ({
+                            file: r.file_path.replace(this.projectRoot + '/', '').replace(this.projectRoot + '\\', ''),
+                            degree: r.degree,
+                            reason: 'high-centrality: vulnerability here affects the most consumers',
+                        }));
+                    }
+                    if (surpriseRows.length > 0) {
+                        audit['unexpectedCoupling'] = surpriseRows.map(r => ({
+                            edge: `${r.src_name} --${r.relation}--> ${r.tgt_name}`,
+                            srcFile: r.src_file ?? '(unknown)',
+                            tgtFile: r.tgt_file ?? '(unknown)',
+                            confidenceScore: r.confidence_score,
+                            reason: 'cross-community edge: may indicate hidden dependency or attack surface',
+                        }));
+                    }
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+        }
+        catch { /* monograph unavailable — skip graph enrichment */ }
         const auditFileTmp = auditFile + '.tmp';
         writeFileSync(auditFileTmp, JSON.stringify(audit, null, 2));
         renameSync(auditFileTmp, auditFile);
@@ -779,8 +924,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',
         };
@@ -897,13 +1042,95 @@ export class WorkerDaemon extends EventEmitter {
      * Local ultralearn worker (fallback when headless unavailable)
      */
     async runUltralearnWorkerLocal() {
-        return {
+        const result = {
             timestamp: new Date().toISOString(),
             mode: 'local',
             patternsLearned: 0,
             insightsGained: [],
-            note: 'Install Claude Code CLI for AI-powered deep learning',
         };
+        // Enrich with monograph community clusters and bridge-node patterns for LLM context injection.
+        // Bridge nodes (symbols that cross community boundaries) are architecturally significant —
+        // they represent coupling points an LLM should be aware of when reasoning about change impact.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const nodeCount = countNodes(db);
+                    const edgeCount = countEdges(db);
+                    const communityRows = db.prepare(`
+            SELECT community_id, COUNT(*) AS member_count
+            FROM nodes
+            WHERE community_id IS NOT NULL
+              AND label NOT IN ('File','Folder','Community','Concept')
+            GROUP BY community_id
+            ORDER BY member_count DESC
+            LIMIT 5
+          `).all();
+                    const bridgeRows = db.prepare(`
+            SELECT n.name, n.label, n.file_path, n.start_line,
+                   COUNT(DISTINCT e.id) AS cross_edges
+            FROM nodes n
+            JOIN edges e ON (e.source_id = n.id OR e.target_id = n.id)
+            JOIN nodes n2 ON (
+              CASE WHEN e.source_id = n.id THEN e.target_id ELSE e.source_id END = n2.id
+            )
+            WHERE n.community_id IS NOT NULL
+              AND n2.community_id IS NOT NULL
+              AND n.community_id != n2.community_id
+              AND n.label NOT IN ('File','Folder','Community','Concept')
+              AND (n.file_path IS NULL OR (
+                n.file_path NOT LIKE '%node_modules%'
+                AND n.file_path NOT LIKE '%/dist/%'
+                AND n.file_path NOT LIKE '%.test.%'
+                AND n.file_path NOT LIKE '%.spec.%'
+              ))
+            GROUP BY n.id
+            ORDER BY cross_edges DESC
+            LIMIT 5
+          `).all();
+                    const insights = result['insightsGained'];
+                    if (communityRows.length > 0) {
+                        insights.push({
+                            category: 'community_clusters',
+                            description: `Top ${communityRows.length} community clusters by size`,
+                            items: communityRows.map(r => ({
+                                communityId: r.community_id,
+                                memberCount: r.member_count,
+                            })),
+                        });
+                    }
+                    if (bridgeRows.length > 0) {
+                        insights.push({
+                            category: 'bridge_nodes',
+                            description: `Top ${bridgeRows.length} bridge nodes crossing community boundaries (high coupling risk)`,
+                            items: bridgeRows.map(r => {
+                                const loc = r.file_path
+                                    ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
+                                    : '(unknown)';
+                                return {
+                                    name: r.name,
+                                    label: r.label,
+                                    location: loc,
+                                    crossCommunityEdges: r.cross_edges,
+                                };
+                            }),
+                        });
+                        result['patternsLearned'] = bridgeRows.length + communityRows.length;
+                    }
+                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+            else {
+                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep learning';
+            }
+        }
+        catch { /* monograph unavailable — return minimal result */ }
+        return result;
     }
     /**
      * Local refactor worker (fallback when headless unavailable)
@@ -921,13 +1148,106 @@ export class WorkerDaemon extends EventEmitter {
      * Local deepdive worker (fallback when headless unavailable)
      */
     async runDeepdiveWorkerLocal() {
-        return {
+        const deepdiveFile = join(this.projectRoot, '.monomind', 'metrics', 'deepdive.json');
+        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
+        if (!existsSync(metricsDir)) {
+            mkdirSync(metricsDir, { recursive: true });
+        }
+        const result = {
             timestamp: new Date().toISOString(),
             mode: 'local',
-            analysisDepth: 'shallow',
+            analysisDepth: 'graph',
             findings: [],
-            note: 'Install Claude Code CLI for AI-powered deep code analysis',
         };
+        // Enrich with monograph god nodes and high-degree file analysis for LLM context injection.
+        // Lazy-import to avoid hard dependency; silently skip on any error.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const nodeCount = countNodes(db);
+                    const edgeCount = countEdges(db);
+                    const godNodeRows = db.prepare(`
+            SELECT n.name, n.file_path, n.label,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN ('File','Folder','Community','Concept')
+              AND (n.file_path IS NULL OR (
+                n.file_path NOT LIKE '%node_modules%'
+                AND n.file_path NOT LIKE '%/dist/%'
+                AND n.file_path NOT LIKE '%.test.%'
+                AND n.file_path NOT LIKE '%.spec.%'
+              ))
+            GROUP BY n.id
+            ORDER BY degree DESC
+            LIMIT 5
+          `).all();
+                    const godNodes = godNodeRows.map(r => ({
+                        name: r.name,
+                        label: r.label,
+                        file: r.file_path ?? '(unknown)',
+                        degree: r.degree,
+                    }));
+                    const fileRows = db.prepare(`
+            SELECT n.file_path,
+                   COUNT(DISTINCT e2.id) AS in_deg,
+                   COUNT(DISTINCT e1.id) AS out_deg
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label = 'File'
+              AND n.file_path NOT LIKE '%node_modules%'
+              AND n.file_path NOT LIKE '%/dist/%'
+              AND n.file_path NOT LIKE '%.test.%'
+              AND n.file_path NOT LIKE '%.spec.%'
+            GROUP BY n.id
+            ORDER BY (in_deg + out_deg) DESC
+            LIMIT 5
+          `).all();
+                    const highDegFiles = fileRows.map(r => ({
+                        file: r.file_path
+                            .replace(this.projectRoot + '/', '')
+                            .replace(this.projectRoot + '\\', ''),
+                        inDegree: r.in_deg,
+                        outDegree: r.out_deg,
+                        totalDegree: r.in_deg + r.out_deg,
+                    }));
+                    const findings = [];
+                    if (godNodes.length > 0) {
+                        findings.push({
+                            category: 'god_nodes',
+                            description: `Top ${godNodes.length} high-centrality symbols (most imported/referenced)`,
+                            items: godNodes,
+                        });
+                    }
+                    if (highDegFiles.length > 0) {
+                        findings.push({
+                            category: 'high_degree_files',
+                            description: `Top ${highDegFiles.length} files by total edge degree (import + export connections)`,
+                            items: highDegFiles,
+                        });
+                    }
+                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
+                    result['findings'] = findings;
+                    result['analysisDepth'] = 'graph';
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+            else {
+                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep analysis';
+            }
+        }
+        catch { /* monograph unavailable — return minimal result */ }
+        const deepdiveFileTmp = deepdiveFile + '.tmp';
+        writeFileSync(deepdiveFileTmp, JSON.stringify(result, null, 2));
+        renameSync(deepdiveFileTmp, deepdiveFile);
+        return result;
     }
     /**
      * Local benchmark worker
@@ -1042,6 +1362,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;
 }