cipher-security 2.0.4 → 2.0.5

package/lib/mcp/server.js

@@ -10,9 +10,10 @@
  */
 
 import { createInterface } from 'node:readline';
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const _version = (() => {
@@ -21,6 +22,38 @@ const _version = (() => {
   } catch { return 'unknown'; }
 })();
 
+/** Default memory directory — mirrors gateway/commands.js */
+function defaultMemoryDir() {
+  return join(homedir(), '.cipher', 'memory', 'default');
+}
+
+/** Find repo root for skills directory */
+function findRepoRoot() {
+  let dir = resolve(__dirname, '..', '..');
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, 'skills')) && (existsSync(join(dir, 'cli')) || existsSync(join(dir, 'package.json')))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return resolve(__dirname, '..', '..');
+}
+
+function skillsDir() {
+  return join(findRepoRoot(), 'skills');
+}
+
+/** MCP content block helper */
+function text(obj) {
+  return { content: [{ type: 'text', text: JSON.stringify(obj) }] };
+}
+
+function mcpError(msg) {
+  return { content: [{ type: 'text', text: JSON.stringify({ error: msg }) }], isError: true };
+}
+
 /**
  * MCP tool definitions — schema registry for all 14 tools.
  */
@@ -182,21 +215,215 @@ export class CipherMCPServer {
   async _dispatchTool(toolName, params) {
     try {
       switch (toolName) {
-        case 'cipher_stats':
-          return { content: [{ type: 'text', text: JSON.stringify({ status: 'ok', tool: toolName }) }] };
-        case 'cipher_store':
-          return { content: [{ type: 'text', text: JSON.stringify({ stored: true, type: params.memory_type }) }] };
-        case 'cipher_search':
-          return { content: [{ type: 'text', text: JSON.stringify({ query: params.query, results: [], total: 0 }) }] };
-        case 'cipher_context':
-          return { content: [{ type: 'text', text: JSON.stringify({ query: params.query, context: '' }) }] };
-        case 'cipher_consolidate':
-          return { content: [{ type: 'text', text: JSON.stringify({ consolidated: true }) }] };
+        // ── Memory tools ────────────────────────────────────────────
+        case 'cipher_store': {
+          const { CipherMemory, MemoryEntry, MemoryType } = await import('../memory/index.js');
+          const memory = new CipherMemory(defaultMemoryDir());
+          try {
+            const entry = new MemoryEntry({
+              content: params.content,
+              memoryType: Object.values(MemoryType).includes(params.memory_type) ? params.memory_type : MemoryType.NOTE,
+              severity: params.severity || '',
+              engagementId: params.engagement_id || '',
+              tags: params.tags || [],
+            });
+            const id = memory.store(entry);
+            return text({ id, type: params.memory_type, stored: true });
+          } finally { memory.close(); }
+        }
+
+        case 'cipher_search': {
+          const { AdaptiveRetriever, CipherMemory } = await import('../memory/index.js');
+          const memory = new CipherMemory(defaultMemoryDir());
+          try {
+            const retriever = new AdaptiveRetriever(memory);
+            const results = retriever.retrieve(params.query, params.engagement_id || '', params.limit || 10);
+            return text({
+              query: params.query,
+              count: results.length,
+              results: results.map(r => ({
+                content: r.content,
+                type: r.memoryType || '',
+                severity: r.severity || '',
+                targets: r.targets || [],
+                mitre: r.mitreAttack || [],
+              })),
+            });
+          } finally { memory.close(); }
+        }
+
+        case 'cipher_context': {
+          const { AdaptiveRetriever, CipherMemory } = await import('../memory/index.js');
+          const memory = new CipherMemory(defaultMemoryDir());
+          try {
+            const retriever = new AdaptiveRetriever(memory);
+            const results = retriever.retrieve(params.query, params.engagement_id || '', 10);
+            const contextText = results.map(r => r.content).join('\n\n');
+            // Simple token budget: ~4 chars per token
+            const maxChars = (params.max_tokens || 4000) * 4;
+            return text({ query: params.query, context: contextText.slice(0, maxChars) });
+          } finally { memory.close(); }
+        }
+
+        case 'cipher_consolidate': {
+          const { CipherMemory } = await import('../memory/index.js');
+          const memory = new CipherMemory(defaultMemoryDir());
+          try {
+            memory.symbolic.db.exec("INSERT INTO entries_fts(entries_fts) VALUES('rebuild')");
+            const stats = memory.consolidate();
+            return text({ consolidated: true, ...stats });
+          } finally { memory.close(); }
+        }
+
+        case 'cipher_stats': {
+          const { CipherMemory } = await import('../memory/index.js');
+          const memory = new CipherMemory(defaultMemoryDir());
+          try {
+            const memStats = memory.stats();
+            const sDir = skillsDir();
+            let skillCount = 0;
+            if (existsSync(sDir)) {
+              const walk = (d) => { try { for (const e of readdirSync(d)) { const p = join(d, e); try { if (statSync(p).isDirectory()) walk(p); else if (e === 'SKILL.md') skillCount++; } catch {} } } catch {} };
+              walk(sDir);
+            }
+            return text({ version: _version, memory: memStats, skills: skillCount });
+          } finally { memory.close(); }
+        }
+
+        // ── Pipeline tools ──────────────────────────────────────────
+        case 'cipher_scan': {
+          const { NucleiRunner, ScanProfile } = await import('../pipeline/scanner.js');
+          const runner = new NucleiRunner();
+          const result = await runner.scan(params.target, { profile: ScanProfile.fromDomain(params.profile || 'standard') });
+          return text({
+            target: params.target,
+            profile: params.profile || 'standard',
+            findings: (result.findings || []).length,
+            results: (result.findings || []).map(f => typeof f.toDict === 'function' ? f.toDict() : f),
+            status: 'completed',
+          });
+        }
+
+        case 'cipher_crawl': {
+          const { KatanaRunner } = await import('../pipeline/scanner.js');
+          const runner = new KatanaRunner();
+          const result = await runner.crawl(params.target, { depth: params.depth || 3 });
+          return text({
+            target: params.target,
+            urls: result.urls || [],
+            count: (result.urls || []).length,
+          });
+        }
+
+        case 'cipher_full_scan': {
+          const { ScanPipeline } = await import('../pipeline/scanner.js');
+          const pipeline = new ScanPipeline();
+          const result = await pipeline.fullScan(params.target, {
+            profile: params.profile || 'pentest',
+            engagementId: params.engagement_id || '',
+          });
+          return text({
+            target: params.target,
+            findings: (result.findings || []).length,
+            urls_crawled: (result.crawlResult?.urls || []).length,
+            status: 'completed',
+          });
+        }
+
+        case 'cipher_analyze_diff': {
+          const { SecurityDiffAnalyzer } = await import('../pipeline/github-actions.js');
+          const analyzer = new SecurityDiffAnalyzer();
+          const analysis = analyzer.analyzeDiff(params.diff);
+          return text({
+            risk_level: analysis.riskLevel?.value ?? analysis.riskLevel ?? 'info',
+            files_changed: analysis.filesChanged?.length ?? 0,
+            auth_changes: analysis.authChanges?.length ?? 0,
+            sql_changes: analysis.sqlChanges?.length ?? 0,
+            crypto_changes: analysis.cryptoChanges?.length ?? 0,
+            secrets_found: analysis.secrets?.length ?? 0,
+            summary: analysis.summary || '',
+          });
+        }
+
+        case 'cipher_detect_secrets': {
+          const { SecurityDiffAnalyzer } = await import('../pipeline/github-actions.js');
+          const analyzer = new SecurityDiffAnalyzer();
+          const analysis = analyzer.analyzeDiff(params.diff);
+          return text({
+            secrets: (analysis.secrets || []).map(s => typeof s.toDict === 'function' ? s.toDict() : s),
+            count: (analysis.secrets || []).length,
+          });
+        }
+
+        // ── Evolution tools ─────────────────────────────────────────
+        case 'cipher_score': {
+          const { ResponseScorer } = await import('../memory/index.js');
+          const scorer = new ResponseScorer();
+          const scored = scorer.score(params.query, params.response, params.mode || '');
+          return text({ score: scored.score, votes: scored.votes, feedback: scored.feedback });
+        }
+
+        case 'cipher_evolve': {
+          const { SkillEvolver } = await import('../memory/index.js');
+          const evolver = new SkillEvolver();
+          const result = evolver.recordOutcome(params.skill_path, params.success, params.score || 0);
+          return text({ skill: params.skill_path, evolved: true, ...result });
+        }
+
+        // ── Skills tools ────────────────────────────────────────────
+        case 'cipher_skills_search': {
+          const sDir = skillsDir();
+          const query = (params.query || '').toLowerCase();
+          const results = [];
+          if (existsSync(sDir)) {
+            const walk = (dir, relBase) => {
+              if (results.length >= 20) return;
+              try {
+                for (const entry of readdirSync(dir)) {
+                  if (results.length >= 20) return;
+                  const fullPath = join(dir, entry);
+                  try {
+                    if (statSync(fullPath).isDirectory()) { walk(fullPath, join(relBase, entry)); }
+                    else if (entry === 'SKILL.md') {
+                      const name = dirname(join(relBase, entry)).split('/').pop() || '';
+                      const rel = dirname(join(relBase, entry));
+                      if (!query || name.toLowerCase().includes(query) || rel.toLowerCase().includes(query)) {
+                        results.push({ name, path: rel });
+                      }
+                    }
+                  } catch {}
+                }
+              } catch {}
+            };
+            walk(sDir, '');
+          }
+          return text({ query: params.query, count: results.length, results });
+        }
+
+        case 'cipher_skills_domains': {
+          const sDir = skillsDir();
+          const domainMap = {};
+          if (existsSync(sDir)) {
+            for (const d of readdirSync(sDir).sort()) {
+              const dirPath = join(sDir, d);
+              try { if (d.startsWith('.') || !statSync(dirPath).isDirectory()) continue; } catch { continue; }
+              const techniquesDir = join(dirPath, 'techniques');
+              if (existsSync(techniquesDir)) {
+                try {
+                  domainMap[d] = readdirSync(techniquesDir).filter(t => { try { return statSync(join(techniquesDir, t)).isDirectory(); } catch { return false; } }).length;
+                } catch { domainMap[d] = 0; }
+              }
+            }
+          }
+          const total = Object.values(domainMap).reduce((a, b) => a + b, 0);
+          return text({ domains: domainMap, total_domains: Object.keys(domainMap).length, total_techniques: total });
+        }
+
         default:
-          return { content: [{ type: 'text', text: JSON.stringify({ tool: toolName, status: 'executed', params }) }] };
+          return mcpError(`Unknown tool: ${toolName}`);
       }
     } catch (err) {
-      return { content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }], isError: true };
+      return mcpError(err.message);
     }
   }
 

package/lib/pipeline/index.js

@@ -79,12 +79,14 @@ export {
   DOMXSSScanner,
 } from './dom-xss-scanner.js';
 
-// OSINT — intelligence gathering subprocess wrappers
+// OSINT — intelligence gathering (domains, IPs, usernames, emails, archives)
 export {
   isPrivateIP,
   OSINTResult,
   DomainIntelligence,
   IPIntelligence,
+  PeopleIntelligence,
+  ArchiveIntelligence,
   DocumentMetadata,
   OSINTPipeline,
 } from './osint.js';