@theihtisham/agent-shadow-brain 5.1.1 → 6.0.0

package/dist/brain/mcp-server.js

@@ -1,6 +1,6 @@
 // src/brain/mcp-server.ts — JSON-RPC 2.0 MCP server over HTTP
 // Exposes analysis tools via Model Context Protocol
-// v5.0.1 — Infinite Intelligence Edition (Cursor + Claude Code + Kilo Code compatible)
+// v6.0.0 — Hive Mind Edition (Cursor + Claude Code + Codex + Copilot + sub-agent frameworks)
 import * as http from 'http';
 export class MCPServer {
     constructor(orchestrator, options) {
@@ -11,6 +11,8 @@ export class MCPServer {
         this.options = {
             port: options?.port ?? 7342,
             host: options?.host ?? 'localhost',
+            authToken: options?.authToken ?? process.env.SHADOW_BRAIN_MCP_TOKEN ?? '',
+            corsOrigin: options?.corsOrigin ?? `http://${options?.host ?? 'localhost'}:${options?.port ?? 7342}`,
         };
         this.toolHandlers = {
             analyze: this.handleAnalyze.bind(this),
@@ -32,8 +34,375 @@ export class MCPServer {
             status: this.handleStatus.bind(this),
             modules: this.handleModules.bind(this),
             auto_config: this.handleAutoConfig.bind(this),
+            // v5.2.0 — Subconscious Singularity
+            subconscious_inject: this.handleSubconsciousInject.bind(this),
+            global_recall: this.handleGlobalRecall.bind(this),
+            global_stats: this.handleGlobalStats.bind(this),
+            attach_status: this.handleAttachStatus.bind(this),
+            global_timeline: this.handleGlobalTimeline.bind(this),
+            firewall_check: this.handleFirewallCheck.bind(this),
+            agent_handoff: this.handleAgentHandoff.bind(this),
+            // v6.0.0 — Hive Mind tools
+            subagent_sliver: this.handleSubagentSliver.bind(this),
+            subagent_quarantine_list: this.handleSubagentQuarantineList.bind(this),
+            subagent_graduate: this.handleSubagentGraduate.bind(this),
+            subagent_reject: this.handleSubagentReject.bind(this),
+            causal_link: this.handleCausalLink.bind(this),
+            causal_trace: this.handleCausalTrace.bind(this),
+            causal_influence: this.handleCausalInfluence.bind(this),
+            collision_declare: this.handleCollisionDeclare.bind(this),
+            collision_list: this.handleCollisionList.bind(this),
+            dream_run: this.handleDreamRun.bind(this),
+            dream_list: this.handleDreamList.bind(this),
+            reputation_sign: this.handleReputationSign.bind(this),
+            reputation_score: this.handleReputationScore.bind(this),
+            reputation_badge: this.handleReputationBadge.bind(this),
+            debate_run: this.handleDebateRun.bind(this),
+            premortem_run: this.handlePremortemRun.bind(this),
+            branch_state: this.handleBranchState.bind(this),
+            attention_heatmap: this.handleAttentionHeatmap.bind(this),
+            tokens_record: this.handleTokensRecord.bind(this),
+            tokens_report: this.handleTokensReport.bind(this),
+            forget_consolidate: this.handleForgetConsolidate.bind(this),
+            formal_generate: this.handleFormalGenerate.bind(this),
+            calibration_record: this.handleCalibrationRecord.bind(this),
+            calibration_scores: this.handleCalibrationScores.bind(this),
+            airgap_status: this.handleAirGapStatus.bind(this),
+            airgap_enable: this.handleAirGapEnable.bind(this),
+            airgap_disable: this.handleAirGapDisable.bind(this),
+            quarantine_list: this.handleQuarantineList.bind(this),
+            quarantine_promote: this.handleQuarantinePromote.bind(this),
+            voice_process: this.handleVoiceProcess.bind(this),
+            garden_snapshot: this.handleGardenSnapshot.bind(this),
+            pr_review_generate: this.handlePRReviewGenerate.bind(this),
+            exchange_export: this.handleExchangeExport.bind(this),
+            exchange_import: this.handleExchangeImport.bind(this),
+            exchange_list: this.handleExchangeList.bind(this),
+            hive_status: this.handleHiveStatus.bind(this),
         };
     }
+    // ── v6.0 Hive Mind handlers ────────────────────────────────────────────────
+    async handleSubagentSliver(params) {
+        const { getSubAgentBridge } = await import('./subagent-bridge.js');
+        const b = getSubAgentBridge();
+        const req = await b.registerSpawn({
+            parentAgent: params.parentAgent ?? 'claude-code',
+            subAgentId: params.subAgentId ?? `sub-${Date.now()}`,
+            framework: params.framework ?? 'claude-code-task',
+            taskDescription: params.taskDescription ?? '',
+            projectDir: params.projectDir ?? process.cwd(),
+            tokenBudget: params.tokenBudget,
+        });
+        return b.computeSliver(req);
+    }
+    async handleSubagentQuarantineList(_params) {
+        const { getSubAgentBridge } = await import('./subagent-bridge.js');
+        const b = getSubAgentBridge();
+        await b.init();
+        return b.listQuarantine();
+    }
+    async handleSubagentGraduate(params) {
+        const { getSubAgentBridge } = await import('./subagent-bridge.js');
+        return { ok: await getSubAgentBridge().graduate(params.memoryId) };
+    }
+    async handleSubagentReject(params) {
+        const { getSubAgentBridge } = await import('./subagent-bridge.js');
+        return { ok: await getSubAgentBridge().reject(params.memoryId, params.reason) };
+    }
+    async handleCausalLink(params) {
+        const { getCausalChains } = await import('./causal-chains.js');
+        return getCausalChains().link(params.effectId, params.causeId, params.rationale, params.strength ?? 1.0);
+    }
+    async handleCausalTrace(params) {
+        const { getCausalChains } = await import('./causal-chains.js');
+        return getCausalChains().trace(params.memoryId, { maxDepth: params.maxDepth ?? 8 });
+    }
+    async handleCausalInfluence(params) {
+        const { getCausalChains } = await import('./causal-chains.js');
+        return getCausalChains().influence(params.memoryId, { maxDepth: params.maxDepth ?? 6 });
+    }
+    async handleCollisionDeclare(params) {
+        const { getCollisionDetective } = await import('./collision-detective.js');
+        return getCollisionDetective().declareIntent(params.agentTool, params.sessionId, params.filePath, params.startLine, params.endLine, params.intent, params.ttlMs);
+    }
+    async handleCollisionList(_params) {
+        const { getCollisionDetective } = await import('./collision-detective.js');
+        const d = getCollisionDetective();
+        await d.init();
+        return { intents: d.activeIntents(), alerts: d.activeAlerts(), stats: d.getStats() };
+    }
+    async handleDreamRun(_params) {
+        const { getDreamEngine } = await import('./dream-engine.js');
+        return getDreamEngine().dreamOnce();
+    }
+    async handleDreamList(params) {
+        const { getDreamEngine } = await import('./dream-engine.js');
+        const d = getDreamEngine();
+        await d.init();
+        return d.listDreams({ unacknowledgedOnly: params.unacknowledgedOnly, limit: params.limit });
+    }
+    async handleReputationSign(params) {
+        const { getReputationLedger } = await import('./reputation-ledger.js');
+        return getReputationLedger().sign({
+            agentTool: params.agentTool,
+            agentVersion: params.agentVersion,
+            projectId: params.projectId,
+            decision: params.decision,
+            category: params.category,
+            confidence: params.confidence ?? 0.8,
+        });
+    }
+    async handleReputationScore(params) {
+        const { getReputationLedger } = await import('./reputation-ledger.js');
+        const l = getReputationLedger();
+        await l.init();
+        return l.getScore(params.agentTool, params.agentVersion);
+    }
+    async handleReputationBadge(params) {
+        const { getReputationLedger } = await import('./reputation-ledger.js');
+        const l = getReputationLedger();
+        await l.init();
+        return { badge: l.badge(params.agentTool, params.agentVersion) };
+    }
+    async handleDebateRun(params) {
+        const { getSwarmDebate } = await import('./swarm-debate.js');
+        return getSwarmDebate().debate(params.question, params.context ?? '', { turns: params.turns ?? 2 });
+    }
+    async handlePremortemRun(params) {
+        const { getPreMortem } = await import('./pre-mortem.js');
+        return getPreMortem().run(params.taskDescription, params.projectDir ?? process.cwd());
+    }
+    async handleBranchState(params) {
+        const { getBranchBrain } = await import('./branch-brain.js');
+        return getBranchBrain().getState(params.projectDir ?? process.cwd());
+    }
+    async handleAttentionHeatmap(params) {
+        const { getAttentionHeatmap } = await import('./attention-heatmap.js');
+        return getAttentionHeatmap().compute({
+            decisionText: params.decisionText,
+            candidateMemoryIds: params.candidateMemoryIds ?? [],
+            agentTool: params.agentTool ?? 'claude-code',
+        });
+    }
+    async handleTokensRecord(params) {
+        const { getTokenEconomy } = await import('./token-economy.js');
+        return getTokenEconomy().record({
+            agentTool: params.agentTool,
+            model: params.model,
+            inputTokens: params.inputTokens,
+            outputTokens: params.outputTokens,
+            taskCategory: params.taskCategory,
+        });
+    }
+    async handleTokensReport(_params) {
+        const { getTokenEconomy } = await import('./token-economy.js');
+        return getTokenEconomy().report();
+    }
+    async handleForgetConsolidate(_params) {
+        const { getForgettingCurve } = await import('./forgetting-curve.js');
+        return getForgettingCurve().runConsolidation();
+    }
+    async handleFormalGenerate(params) {
+        const { getFormalBridge } = await import('./formal-verification-bridge.js');
+        return getFormalBridge().generateFromText(params.text, params.sourceId);
+    }
+    async handleCalibrationRecord(params) {
+        const { getCalibrationMonitor } = await import('./calibration-monitor.js');
+        return getCalibrationMonitor().record({
+            agentTool: params.agentTool,
+            category: params.category,
+            claim: params.claim,
+            claimedConfidence: params.claimedConfidence,
+            actualOutcome: params.actualOutcome,
+            outcomeAt: new Date(),
+        });
+    }
+    async handleCalibrationScores(_params) {
+        const { getCalibrationMonitor } = await import('./calibration-monitor.js');
+        const m = getCalibrationMonitor();
+        await m.init();
+        return m.listScores();
+    }
+    async handleAirGapStatus(_params) {
+        const { getAirGapMode } = await import('./air-gap.js');
+        const a = getAirGapMode();
+        await a.init();
+        return a.status();
+    }
+    async handleAirGapEnable(params) {
+        const { getAirGapMode } = await import('./air-gap.js');
+        await getAirGapMode().enable(params.policy ?? 'strict');
+        return { ok: true };
+    }
+    async handleAirGapDisable(_params) {
+        const { getAirGapMode } = await import('./air-gap.js');
+        await getAirGapMode().disable();
+        return { ok: true };
+    }
+    async handleQuarantineList(params) {
+        const { getHallucinationQuarantine } = await import('./hallucination-quarantine.js');
+        const q = getHallucinationQuarantine();
+        await q.init();
+        return q.list({ pendingOnly: params.pendingOnly });
+    }
+    async handleQuarantinePromote(params) {
+        const { getHallucinationQuarantine } = await import('./hallucination-quarantine.js');
+        return { ok: await getHallucinationQuarantine().promote(params.id, params.projectId, params.agentTool ?? 'claude-code') };
+    }
+    async handleVoiceProcess(params) {
+        const { getVoiceMode } = await import('./voice-mode.js');
+        return getVoiceMode().process({ transcript: params.transcript, confidence: params.confidence, projectDir: params.projectDir });
+    }
+    async handleGardenSnapshot(params) {
+        const { getBrainGarden } = await import('./brain-garden.js');
+        return getBrainGarden().snapshot(params.limit ?? 100);
+    }
+    async handlePRReviewGenerate(params) {
+        const { getPRAutoReview } = await import('./pr-auto-review.js');
+        return getPRAutoReview().generate({
+            repo: params.repo,
+            prNumber: params.prNumber,
+            projectDir: params.projectDir ?? process.cwd(),
+            diffSummary: params.diffSummary,
+            changedFiles: params.changedFiles ?? [],
+        });
+    }
+    async handleExchangeExport(params) {
+        const { getBrainExchange } = await import('./brain-exchange.js');
+        return getBrainExchange().export({
+            name: params.name,
+            description: params.description ?? '',
+            author: params.author ?? 'anonymous',
+            categories: params.categories,
+            tags: params.tags,
+            limit: params.limit,
+            minImportance: params.minImportance,
+        });
+    }
+    async handleExchangeImport(params) {
+        const { getBrainExchange } = await import('./brain-exchange.js');
+        return getBrainExchange().import(params.filePath, { projectDir: params.projectDir ?? process.cwd(), agentTool: params.agentTool });
+    }
+    async handleExchangeList(_params) {
+        const { getBrainExchange } = await import('./brain-exchange.js');
+        return getBrainExchange().listLocal();
+    }
+    async handleHiveStatus(_params) {
+        const [{ getSubAgentBridge }, { getCausalChains }, { getCollisionDetective }, { getDreamEngine }, { getReputationLedger }, { getTokenEconomy }, { getFormalBridge }, { getAirGapMode }, { getGlobalBrain },] = await Promise.all([
+            import('./subagent-bridge.js'),
+            import('./causal-chains.js'),
+            import('./collision-detective.js'),
+            import('./dream-engine.js'),
+            import('./reputation-ledger.js'),
+            import('./token-economy.js'),
+            import('./formal-verification-bridge.js'),
+            import('./air-gap.js'),
+            import('./global-brain.js'),
+        ]);
+        const sabb = getSubAgentBridge();
+        const causal = getCausalChains();
+        const collisions = getCollisionDetective();
+        const dream = getDreamEngine();
+        const rep = getReputationLedger();
+        const tokens = getTokenEconomy();
+        const formal = getFormalBridge();
+        const airgap = getAirGapMode();
+        const brain = getGlobalBrain();
+        await Promise.all([sabb.init(), causal.init(), collisions.init(), dream.init(), rep.init(), tokens.init(), formal.init(), airgap.init(), brain.init()]);
+        return {
+            version: '6.0.0',
+            modules: {
+                sabb: sabb.getStats(),
+                causal: causal.stats(),
+                collision: collisions.getStats(),
+                dream: dream.getStats(),
+                reputation: rep.stats(),
+                tokenEconomy: await tokens.report(),
+                formalBridge: formal.stats(),
+                airGap: airgap.status(),
+            },
+            localFirst: true,
+            totalAgentsConnected: brain.getStats().totalAgents,
+            totalMemoriesStored: brain.getStats().totalEntries,
+            generatedAt: new Date(),
+        };
+    }
+    // v5.2.0 handlers
+    async handleSubconsciousInject(params) {
+        const { getSubconscious } = await import('./subconscious.js');
+        const { GlobalBrain } = await import('./global-brain.js');
+        const projectDir = params.projectDir || process.cwd();
+        const agentTool = params.agentTool || 'claude-code';
+        const briefing = await getSubconscious().generateBriefing({
+            agentTool,
+            projectDir,
+            projectId: GlobalBrain.projectIdFor(projectDir),
+            currentTask: params.currentTask,
+        });
+        return briefing;
+    }
+    async handleGlobalRecall(params) {
+        const { getGlobalBrain } = await import('./global-brain.js');
+        const brain = getGlobalBrain();
+        await brain.init();
+        return brain.recall({
+            projectId: params.projectId,
+            agentTool: params.agentTool,
+            category: params.category,
+            keywords: params.keywords,
+            limit: params.limit ?? 20,
+            minImportance: params.minImportance,
+        });
+    }
+    async handleGlobalStats(_params) {
+        const { getGlobalBrain } = await import('./global-brain.js');
+        const { getAllCacheStats } = await import('./l0-cache.js');
+        const brain = getGlobalBrain();
+        await brain.init();
+        return {
+            brain: brain.getStats(),
+            caches: getAllCacheStats(),
+        };
+    }
+    async handleAttachStatus(params) {
+        const { getHookInstaller } = await import('./session-hooks.js');
+        const projectDir = params.projectDir || process.cwd();
+        const detected = await getHookInstaller().detectInstalled(projectDir);
+        return { detected, projectDir };
+    }
+    async handleGlobalTimeline(params) {
+        const { getGlobalBrain, GlobalBrain } = await import('./global-brain.js');
+        const projectDir = params.projectDir;
+        const brain = getGlobalBrain();
+        await brain.init();
+        return brain.timeline({
+            projectId: projectDir ? GlobalBrain.projectIdFor(projectDir) : params.projectId,
+            agentTool: params.agentTool,
+            category: params.category,
+            limit: params.limit ?? 30,
+        });
+    }
+    async handleFirewallCheck(params) {
+        const { AgentFirewall } = await import('./agent-firewall.js');
+        return new AgentFirewall().check({
+            command: params.command,
+            filePath: params.filePath,
+            url: params.url,
+            content: params.content,
+            toolName: params.toolName,
+        });
+    }
+    async handleAgentHandoff(params) {
+        const { AgentHandoff } = await import('./agent-handoff.js');
+        const projectDir = params.projectDir || process.cwd();
+        return new AgentHandoff().generate({
+            fromAgent: params.fromAgent || 'cursor',
+            toAgent: params.toAgent || 'codex',
+            projectDir,
+            task: params.task,
+            limit: params.limit ?? 12,
+        });
+    }
     async start() {
         this.server = http.createServer(async (req, res) => {
             if (!req.url) {
@@ -41,16 +410,27 @@ export class MCPServer {
                 return;
             }
             const url = new URL(req.url, `http://${req.headers.host}`);
-            // CORS headers — permissive for Cursor, Claude Code, and other AI tools
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Accept');
+            const origin = req.headers.origin;
+            const allowedOrigin = this.options.corsOrigin;
+            if (!origin || allowedOrigin === origin || allowedOrigin === '*') {
+                res.setHeader('Access-Control-Allow-Origin', origin || allowedOrigin);
+            }
+            res.setHeader('Vary', 'Origin');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, Accept, X-Shadow-Brain-Token');
             res.setHeader('Access-Control-Max-Age', '86400');
             if (req.method === 'OPTIONS') {
                 res.writeHead(204);
                 res.end();
                 return;
             }
+            if (!this.isAuthorized(req)) {
+                this.sendJSON(res, 401, {
+                    error: 'Unauthorized',
+                    message: 'Set SHADOW_BRAIN_MCP_TOKEN or pass --auth-token, then send Bearer or X-Shadow-Brain-Token.',
+                });
+                return;
+            }
             if (req.method === 'POST' && (url.pathname === '/mcp' || url.pathname === '/')) {
                 await this.handleHTTPMCPRequest(req, res);
             }
@@ -61,7 +441,7 @@ export class MCPServer {
                 // Lightweight health endpoint for tool connectivity checks
                 this.sendJSON(res, 200, {
                     status: 'ok',
-                    version: '5.0.1',
+                    version: '5.2.0',
                     uptime: process.uptime(),
                     tools: Object.keys(this.toolHandlers).length,
                 });
@@ -165,8 +545,8 @@ export class MCPServer {
             },
             serverInfo: {
                 name: 'agent-shadow-brain',
-                version: '5.0.1',
-                description: 'World\'s #1 AI coding intelligence layer — infinite memory, multi-agent consensus, self-evolving',
+                version: '5.2.0',
+                description: 'Cross-agent memory and safety layer for AI coding agents',
             },
         };
     }
@@ -454,7 +834,7 @@ export class MCPServer {
     async handleStatus(params) {
         const status = this.orchestrator.getStatus?.() || {};
         return {
-            version: '5.0.1',
+            version: '5.2.0',
             ...status,
         };
     }
@@ -480,7 +860,7 @@ export class MCPServer {
             const instance = this.orchestrator[mod.key];
             modules.push({
                 name: mod.name,
-                version: '5.0.1',
+                version: '5.2.0',
                 status: instance ? 'active' : 'idle',
             });
         }
@@ -673,6 +1053,91 @@ export class MCPServer {
                 description: 'Auto-detect project configuration — languages, frameworks, AI tools',
                 inputSchema: { type: 'object', properties: {} },
             },
+            // v5.2.0 — Subconscious Singularity
+            {
+                name: 'subconscious_inject',
+                description: 'Generate a session-start briefing — proactive context injection for the agent (v5.2.0)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectDir: { type: 'string', description: 'Project directory (defaults to cwd)' },
+                        agentTool: { type: 'string', description: 'Agent tool name (claude-code, cursor, cline, etc.)' },
+                        currentTask: { type: 'string', description: 'Optional task hint for similarity search' },
+                    },
+                },
+            },
+            {
+                name: 'global_recall',
+                description: 'Recall from the singleton global brain — works across all projects + all agents (v5.2.0)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectId: { type: 'string' },
+                        agentTool: { type: 'string' },
+                        category: { type: 'string' },
+                        keywords: { type: 'array', items: { type: 'string' } },
+                        limit: { type: 'number' },
+                        minImportance: { type: 'number' },
+                    },
+                },
+            },
+            {
+                name: 'global_stats',
+                description: 'Get global brain + L0 cache stats (v5.2.0)',
+                inputSchema: { type: 'object', properties: {} },
+            },
+            {
+                name: 'attach_status',
+                description: 'Detect which AI agents are installed on this machine (v5.2.0)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectDir: { type: 'string' },
+                    },
+                },
+            },
+            {
+                name: 'global_timeline',
+                description: 'Show the proof timeline of what agents learned and when (v5.2.0)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectDir: { type: 'string' },
+                        projectId: { type: 'string' },
+                        agentTool: { type: 'string' },
+                        category: { type: 'string' },
+                        limit: { type: 'number' },
+                    },
+                },
+            },
+            {
+                name: 'firewall_check',
+                description: 'Agent Safety Firewall — check a command, file path, URL, or prompt before the agent acts',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string' },
+                        filePath: { type: 'string' },
+                        url: { type: 'string' },
+                        content: { type: 'string' },
+                        toolName: { type: 'string' },
+                    },
+                },
+            },
+            {
+                name: 'agent_handoff',
+                description: 'Create a cross-agent continuation packet from one AI coding agent to another',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        fromAgent: { type: 'string' },
+                        toAgent: { type: 'string' },
+                        projectDir: { type: 'string' },
+                        task: { type: 'string' },
+                        limit: { type: 'number' },
+                    },
+                },
+            },
         ];
     }
     // ── HTTP Handling ──────────────────────────────────────────────────────
@@ -704,15 +1169,24 @@ export class MCPServer {
             'Content-Type': 'text/event-stream',
             'Cache-Control': 'no-cache',
             Connection: 'keep-alive',
-            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Origin': this.options.corsOrigin,
         });
-        res.write(`event: connected\ndata: {"clientId":"${clientId}","version":"5.0.1"}\n\n`);
+        res.write(`event: connected\ndata: {"clientId":"${clientId}","version":"5.2.0"}\n\n`);
         const client = { res, id: clientId };
         this.sseClients.set(clientId, client);
         req.on('close', () => {
             this.sseClients.delete(clientId);
         });
     }
+    isAuthorized(req) {
+        if (!this.options.authToken)
+            return true;
+        const auth = req.headers.authorization || '';
+        const tokenHeader = req.headers['x-shadow-brain-token'];
+        const bearer = auth.startsWith('Bearer ') ? auth.slice('Bearer '.length) : '';
+        const token = Array.isArray(tokenHeader) ? tokenHeader[0] : tokenHeader;
+        return bearer === this.options.authToken || token === this.options.authToken;
+    }
     broadcastSSE(event, data) {
         const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
         const deadClients = [];