indra-mcp 0.1.0

package/build/index.js

@@ -0,0 +1,443 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+// Setup debug logging directory and file
+const homeDir = os.homedir();
+const indraDir = path.join(homeDir, '.indra');
+if (!fs.existsSync(indraDir)) {
+    fs.mkdirSync(indraDir, { recursive: true });
+}
+const logFilePath = path.join(indraDir, 'mcp-debug.log');
+function logDebug(message) {
+    const timestamp = new Date().toISOString();
+    try {
+        fs.appendFileSync(logFilePath, `[${timestamp}] ${message}\n`, 'utf8');
+    }
+    catch (err) {
+        console.error(`Failed to write to debug log: ${err}`);
+    }
+}
+logDebug('--------------------------------------------------');
+logDebug('Indra MCP Broker initializing Step 3 Edge client...');
+// Resolve Edge worker URL
+const edgeUrl = process.env.INDRA_EDGE_URL || 'http://127.0.0.1:8787';
+logDebug(`[EDGE] Targeting Edge Worker at: ${edgeUrl}`);
+// Parse --config argument
+const cliArgs = process.argv.slice(2);
+let configPath = '';
+for (let i = 0; i < cliArgs.length; i++) {
+    if (cliArgs[i] === '--config' && i + 1 < cliArgs.length) {
+        configPath = cliArgs[i + 1];
+        break;
+    }
+}
+if (!configPath) {
+    logDebug('[FATAL] No --config path provided in command-line arguments.');
+    console.error('Error: --config <path> argument is required.');
+    process.exit(1);
+}
+logDebug(`[CONFIG] Loading tools configuration from: ${configPath}`);
+let serversConfig = {};
+try {
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    const parsedConfig = JSON.parse(configContent);
+    serversConfig = parsedConfig.mcpServers || {};
+}
+catch (err) {
+    logDebug(`[FATAL] Failed to read or parse configuration file: ${err.message}`);
+    console.error(`Error loading config file: ${err.message}`);
+    process.exit(1);
+}
+let activeTask = process.env.INDRA_TASK || "Initialize Session";
+let missionToken = "";
+const agentName = process.env.INDRA_AGENT_NAME || "dev-agent";
+// Perform cryptographic Edge session handshake during startup
+async function startSession() {
+    logDebug('[HANDSHAKE] Preparing cryptographic session handshake...');
+    // 1. Generate local ephemeral session key
+    const sessionKeyPair = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
+    const publicJwk = sessionKeyPair.publicKey.export({ format: 'jwk' });
+    const privateKeyPath = path.join(homeDir, '.indra', 'private.pem');
+    let fidoKey = 'dev-fido-key';
+    let signature = 'dev-signature';
+    let idToken = 'dev-session';
+    let derivedFidoID = 'dev-fido-key';
+    const useMockDev = process.env.INDRA_DEV_MODE === 'true';
+    // 2. If trust anchor private key exists and dev mode is disabled, execute asymmetric signature
+    if (fs.existsSync(privateKeyPath) && !useMockDev) {
+        logDebug(`[HANDSHAKE] Found local private key at: ${privateKeyPath}`);
+        try {
+            const privateKeyPem = fs.readFileSync(privateKeyPath, 'utf8');
+            const privateKey = crypto.createPrivateKey(privateKeyPem);
+            // Load corresponding public key in SPKI base64 format (FidoKey)
+            const publicKey = crypto.createPublicKey(privateKey);
+            const pubKeyDer = publicKey.export({ format: 'der', type: 'spki' });
+            fidoKey = pubKeyDer.toString('base64');
+            // Calculate SHA-256 derived FIDO ID
+            const hashHex = crypto.createHash('sha256').update(pubKeyDer).digest().slice(0, 8).toString('hex');
+            derivedFidoID = `indra_fido_${hashHex}`;
+            // Payload signed is: verifyMissionName|derivedFidoID|idToken|jwkStr
+            const payloadStr = `${agentName || activeTask}|${derivedFidoID}|${idToken}|${JSON.stringify(publicJwk)}`;
+            const signer = crypto.createSign('SHA256');
+            signer.update(payloadStr);
+            signature = signer.sign(privateKey, 'base64');
+            logDebug(`[HANDSHAKE-SIGN] Signature generated successfully for derived ID: ${derivedFidoID}`);
+        }
+        catch (err) {
+            logDebug(`[HANDSHAKE-ERROR] Failed to sign handshake: ${err.message}. Bypassing signature...`);
+        }
+    }
+    else {
+        if (useMockDev) {
+            logDebug(`[HANDSHAKE] INDRA_DEV_MODE is enabled. Starting in Development Mock Handshake mode.`);
+        }
+        else {
+            logDebug(`[HANDSHAKE] No private key found at ${privateKeyPath}. Starting in Development Mock Handshake mode.`);
+        }
+    }
+    // 3. Make POST request to start session
+    try {
+        const startUrl = `${edgeUrl}/api/mission/start`;
+        logDebug(`[HANDSHAKE-POST] Calling ${startUrl} ...`);
+        const resp = await fetch(startUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                fidoKey,
+                mission: activeTask,
+                idToken,
+                signature,
+                publicJwk,
+                agentName
+            })
+        });
+        if (!resp.ok) {
+            const errText = await resp.text();
+            throw new Error(`Edge Worker returned status ${resp.status}: ${errText}`);
+        }
+        const resJson = await resp.json();
+        missionToken = resJson.missionToken;
+        logDebug(`[HANDSHAKE-SUCCESS] Session registered successfully on Edge. Session Token: ${missionToken}`);
+    }
+    catch (err) {
+        logDebug(`[FATAL-HANDSHAKE-FAILED] Handshake process failed: ${err.message}`);
+        console.error(`Indra Handshake Failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+// Sync the dynamic task description back to the Edge Worker
+async function updateTaskOnEdge(task) {
+    logDebug(`[SYNC-TASK] Syncing active task description: "${task}"`);
+    try {
+        const resp = await fetch(`${edgeUrl}/api/mission/update-task`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Indra-Mission-Token': missionToken
+            },
+            body: JSON.stringify({ task })
+        });
+        if (!resp.ok) {
+            const errText = await resp.text();
+            logDebug(`[SYNC-TASK-ERROR] Edge Worker returned error code ${resp.status}: ${errText}`);
+        }
+        else {
+            activeTask = task;
+            logDebug(`[SYNC-TASK-SUCCESS] Task successfully updated on Edge to: "${task}"`);
+        }
+    }
+    catch (err) {
+        logDebug(`[SYNC-TASK-ERROR] Failed HTTP request to Edge Worker: ${err.message}`);
+    }
+}
+// Request validation from the Edge Worker for a tool call
+async function validateToolCallOnEdge(tool, args) {
+    logDebug(`[VALIDATION] Requesting validation from Edge for tool: "${tool}"`);
+    try {
+        const resp = await fetch(`${edgeUrl}/api/mission/validate`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Indra-Mission-Token': missionToken
+            },
+            body: JSON.stringify({
+                tool,
+                arguments: args
+            })
+        });
+        if (!resp.ok) {
+            const errText = await resp.text();
+            logDebug(`[VALIDATION-ERROR] Edge validation request failed with status ${resp.status}: ${errText}`);
+            return { allow: true, reason: `Allowed (Edge Worker server error: ${resp.status})` };
+        }
+        const decision = await resp.json();
+        return {
+            allow: decision.allow,
+            reason: decision.reason || "Approved by Edge"
+        };
+    }
+    catch (err) {
+        logDebug(`[VALIDATION-ERROR] Failed to connect to Edge Worker: ${err.message}`);
+        return { allow: true, reason: `Allowed (Edge Worker connection failure)` };
+    }
+}
+// Revoke session token on shutdown
+async function stopSession() {
+    if (!missionToken)
+        return;
+    logDebug(`[SHUTDOWN] Revoking session token: ${missionToken}`);
+    try {
+        await fetch(`${edgeUrl}/api/mission/stop`, {
+            method: 'POST',
+            headers: {
+                'X-Indra-Mission-Token': missionToken
+            }
+        });
+        logDebug('[SHUTDOWN] Session revoked successfully.');
+    }
+    catch (err) {
+        logDebug(`[SHUTDOWN-ERROR] Failed to revoke session: ${err.message}`);
+    }
+}
+const childServers = {};
+const toolToChildMap = new Map();
+let pendingListId = null;
+const pendingListResponses = new Map();
+let pendingInitId = null;
+const pendingInitResponses = new Map();
+// Define our custom task management tools
+const indraCustomTools = [
+    {
+        name: "set_active_task",
+        description: "Sets or updates the current active task description in the Indra security firewall. Call this tool immediately whenever the developer gives you a new goal, prompt, or redirects your target.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task: {
+                    type: "string",
+                    description: "The description of the new task or developer instruction."
+                }
+            },
+            required: ["task"]
+        }
+    }
+];
+// Initialize and start session
+await startSession();
+// Spawn child servers from configuration
+for (const [name, server] of Object.entries(serversConfig)) {
+    logDebug(`[SPAWN] Starting child tool server: ${name} (command: ${server.command}, args: ${JSON.stringify(server.args)})`);
+    try {
+        const childProcess = spawn(server.command, server.args || [], {
+            env: { ...process.env, ...(server.env || {}) },
+            shell: false
+        });
+        const childObj = {
+            name,
+            process: childProcess,
+            buffer: '',
+            tools: []
+        };
+        childServers[name] = childObj;
+        childProcess.stdout.on('data', (data) => {
+            childObj.buffer += data.toString();
+            let newlineIdx;
+            while ((newlineIdx = childObj.buffer.indexOf('\n')) !== -1) {
+                const line = childObj.buffer.slice(0, newlineIdx).trim();
+                childObj.buffer = childObj.buffer.slice(newlineIdx + 1);
+                if (line) {
+                    handleChildMessage(name, line);
+                }
+            }
+        });
+        childProcess.stderr.on('data', (data) => {
+            logDebug(`[${name} - STDERR] ${data.toString().trim()}`);
+            process.stderr.write(data);
+        });
+        childProcess.on('close', (code) => {
+            logDebug(`[PROCESS] Child server ${name} exited with code ${code}`);
+        });
+    }
+    catch (err) {
+        logDebug(`[SPAWN-ERROR] Failed to spawn child server ${name}: ${err.message}`);
+    }
+}
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+});
+rl.on('line', (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return;
+    try {
+        const msg = JSON.parse(trimmed);
+        handleClientMessage(msg, trimmed);
+    }
+    catch (err) {
+        logDebug(`[ERROR] Failed to parse JSON-RPC line from client: ${trimmed}. Error: ${err.message}`);
+    }
+});
+async function handleClientMessage(msg, rawLine) {
+    const method = msg.method;
+    const id = msg.id;
+    logDebug(`[CLIENT-IN] Received JSON-RPC method="${method}" id="${id}"`);
+    if (method === 'initialize') {
+        logDebug('[CLIENT-INITIALIZE] Initiating handshake...');
+        pendingInitId = id;
+        for (const [name, child] of Object.entries(childServers)) {
+            const initPayload = { ...msg, id: `init:${name}` };
+            child.process.stdin.write(JSON.stringify(initPayload) + '\n');
+        }
+        return;
+    }
+    if (method === 'tools/list') {
+        logDebug('[CLIENT-DISCOVERY] Tools list requested.');
+        pendingListId = id;
+        pendingListResponses.clear();
+        for (const [name, child] of Object.entries(childServers)) {
+            const listPayload = { ...msg, id: `list:${name}` };
+            child.process.stdin.write(JSON.stringify(listPayload) + '\n');
+        }
+        return;
+    }
+    if (method === 'tools/call') {
+        const toolName = msg.params?.name;
+        const toolArgs = msg.params?.arguments || {};
+        logDebug(`[CLIENT-TOOL-CALL] Tool call: "${toolName}" with args: ${JSON.stringify(toolArgs)}`);
+        // Intercept and handle dynamic task updates
+        if (toolName === 'set_active_task') {
+            const newTask = toolArgs.task || '';
+            logDebug(`[CLIENT-SET-TASK] Dynamic task update intercepted: "${newTask}"`);
+            await updateTaskOnEdge(newTask);
+            const successResponse = {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Indra security firewall task updated successfully to: "${newTask}"`
+                        }
+                    ]
+                }
+            };
+            process.stdout.write(JSON.stringify(successResponse) + '\n');
+            return;
+        }
+        // Direct Edge validate call
+        const decision = await validateToolCallOnEdge(toolName, toolArgs);
+        if (!decision.allow) {
+            logDebug(`[EVALUATION-DECISION] ❌ BLOCKED: ${decision.reason}`);
+            const errorResponse = {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Blocked by Indra Firewall: ${decision.reason}`
+                        }
+                    ],
+                    isError: true
+                }
+            };
+            process.stdout.write(JSON.stringify(errorResponse) + '\n');
+            return;
+        }
+        logDebug(`[EVALUATION-DECISION] ✅ ALLOWED: ${decision.reason}`);
+        const targetServerName = toolToChildMap.get(toolName);
+        if (!targetServerName || !childServers[targetServerName]) {
+            logDebug(`[ERROR] Tool "${toolName}" not registered on any child server.`);
+            const errorResponse = {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: -32601,
+                    message: `Method not found: Tool "${toolName}" is not registered on any active server.`
+                }
+            };
+            process.stdout.write(JSON.stringify(errorResponse) + '\n');
+            return;
+        }
+        childServers[targetServerName].process.stdin.write(rawLine + '\n');
+        return;
+    }
+    if (method && method.startsWith('notifications/')) {
+        for (const child of Object.values(childServers)) {
+            child.process.stdin.write(rawLine + '\n');
+        }
+        return;
+    }
+    for (const child of Object.values(childServers)) {
+        child.process.stdin.write(rawLine + '\n');
+    }
+}
+function handleChildMessage(serverName, line) {
+    try {
+        const msg = JSON.parse(line);
+        const id = msg.id;
+        if (id && String(id).startsWith('init:')) {
+            pendingInitResponses.set(serverName, msg);
+            if (pendingInitResponses.size === Object.keys(childServers).length) {
+                let mergedCapabilities = {};
+                for (const resp of pendingInitResponses.values()) {
+                    mergedCapabilities = { ...mergedCapabilities, ...(resp.result?.capabilities || {}) };
+                }
+                const finalResponse = {
+                    jsonrpc: "2.0",
+                    id: pendingInitId,
+                    result: {
+                        protocolVersion: "2024-11-05",
+                        capabilities: mergedCapabilities,
+                        serverInfo: { name: "indra-mcp-broker", version: "0.1.1" }
+                    }
+                };
+                process.stdout.write(JSON.stringify(finalResponse) + '\n');
+                pendingInitId = null;
+            }
+            return;
+        }
+        if (id && String(id).startsWith('list:')) {
+            const tools = msg.result?.tools || [];
+            childServers[serverName].tools = tools;
+            for (const t of tools) {
+                toolToChildMap.set(t.name, serverName);
+            }
+            pendingListResponses.set(serverName, tools);
+            if (pendingListResponses.size === Object.keys(childServers).length) {
+                const allTools = [...indraCustomTools]; // inject our set_active_task tool
+                for (const list of pendingListResponses.values()) {
+                    allTools.push(...list);
+                }
+                const finalResponse = {
+                    jsonrpc: "2.0",
+                    id: pendingListId,
+                    result: { tools: allTools }
+                };
+                process.stdout.write(JSON.stringify(finalResponse) + '\n');
+                pendingListId = null;
+            }
+            return;
+        }
+        process.stdout.write(line + '\n');
+    }
+    catch (err) {
+        logDebug(`[CHILD-ERROR] Failed to parse response from child ${serverName}: ${line}. Error: ${err.message}`);
+    }
+}
+// Graceful exit handlers
+async function cleanupAndExit() {
+    await stopSession();
+    for (const child of Object.values(childServers)) {
+        child.process.kill('SIGINT');
+    }
+    process.exit(0);
+}
+process.on('SIGINT', cleanupAndExit);
+process.on('SIGTERM', cleanupAndExit);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "indra-mcp",
+  "version": "0.1.0",
+  "main": "build/index.js",
+  "bin": {
+    "indra-mcp": "build/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "build"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.4"
+  }
+}