contextguard 0.1.7 → 0.2.0

package/dist/sse-proxy.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Amir Mironi
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSSEProxy = void 0;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const policy_1 = require("./policy");
+const logger_1 = require("./logger");
+const mcp_1 = require("./types/mcp");
+/**
+ * Create an SSE/HTTP proxy for MCP servers
+ * @param policyConfig - Policy configuration
+ * @returns SSE proxy functions
+ */
+const createSSEProxy = (policyConfig) => {
+    const policy = (0, policy_1.createPolicyChecker)(policyConfig);
+    const logger = (0, logger_1.createLogger)(policyConfig.logPath);
+    const sessionId = (0, mcp_1.generateSessionId)();
+    let toolCallTimestamps = [];
+    /**
+     * Inspect outbound request for security violations
+     */
+    const inspectOutbound = (message) => {
+        const violations = [];
+        let shouldBlock = false;
+        if (message.method === "tools/call") {
+            const now = Date.now();
+            toolCallTimestamps.push(now);
+            toolCallTimestamps = toolCallTimestamps.filter((t) => t > now - 60000);
+            if (!policy.checkRateLimit(toolCallTimestamps)) {
+                violations.push("Rate limit exceeded");
+                if (policy.isBlockingMode())
+                    shouldBlock = true;
+            }
+            if (message.params?.name) {
+                violations.push(...policy.checkToolAccess(message.params.name));
+            }
+            const paramsStr = JSON.stringify(message.params);
+            violations.push(...policy.checkPromptInjection(paramsStr));
+            violations.push(...policy.checkSensitiveData(paramsStr));
+            violations.push(...policy.checkBlockedPatterns(paramsStr));
+            violations.push(...policy.checkSQLInjection(paramsStr));
+            violations.push(...policy.checkXSS(paramsStr));
+            violations.push(...policy.checkCustomRules(paramsStr));
+            const filePathParams = [
+                message.params?.arguments?.path,
+                message.params?.arguments?.filePath,
+            ].filter((p) => typeof p === "string");
+            for (const fp of filePathParams) {
+                violations.push(...policy.checkFileAccess(fp));
+            }
+            if (violations.length > 0 && policy.isBlockingMode()) {
+                shouldBlock = true;
+            }
+        }
+        return { violations, shouldBlock };
+    };
+    return {
+        /**
+         * Start the SSE/HTTP proxy server
+         */
+        start: (port, targetUrl) => {
+            const target = new URL(targetUrl);
+            const isHttps = target.protocol === "https:";
+            const server = http.createServer((clientReq, clientRes) => {
+                // ── 1. Collect request body ──────────────────────────────────────────
+                const chunks = [];
+                clientReq.on("data", (chunk) => chunks.push(chunk));
+                clientReq.on("end", () => {
+                    const rawBody = Buffer.concat(chunks);
+                    const bodyStr = rawBody.toString();
+                    // ── 2. Inspect request ──────────────────────────────────────────────
+                    let violations = [];
+                    let shouldBlock = false;
+                    if (bodyStr) {
+                        try {
+                            const msg = JSON.parse(bodyStr);
+                            const result = inspectOutbound(msg);
+                            violations = result.violations;
+                            shouldBlock = result.shouldBlock;
+                            if (violations.length > 0) {
+                                logger.logEvent("SECURITY_VIOLATION", "CRITICAL", {
+                                    violations,
+                                    blocked: shouldBlock,
+                                }, sessionId);
+                                console.error(`\n⚠️  SECURITY VIOLATIONS DETECTED:\n${violations.join("\n")}\n`);
+                            }
+                            if (shouldBlock) {
+                                console.error("🚫 REQUEST BLOCKED\n");
+                                clientRes.writeHead(403, {
+                                    "Content-Type": "application/json",
+                                });
+                                clientRes.end(JSON.stringify({
+                                    jsonrpc: "2.0",
+                                    id: msg.id,
+                                    error: {
+                                        code: -32000,
+                                        message: "Security violation: Request blocked",
+                                        data: { violations },
+                                    },
+                                }));
+                                return;
+                            }
+                            else if (violations.length > 0) {
+                                console.error('⚠️  MONITOR MODE — request forwarded (set mode: "block" to block)\n');
+                            }
+                        }
+                        catch {
+                            // non-JSON body — forward as-is
+                        }
+                    }
+                    // ── 3. Forward to upstream ──────────────────────────────────────────
+                    const options = {
+                        hostname: target.hostname,
+                        port: target.port || (isHttps ? 443 : 80),
+                        path: target.pathname + clientReq.url?.replace(/^[^?]*/, "") ||
+                            target.pathname,
+                        method: clientReq.method,
+                        headers: {
+                            ...clientReq.headers,
+                            host: target.host,
+                        },
+                    };
+                    const lib = isHttps ? https : http;
+                    const proxyReq = lib.request(options, (proxyRes) => {
+                        const isSSE = proxyRes.headers["content-type"]?.includes("text/event-stream");
+                        clientRes.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+                        if (isSSE) {
+                            // Stream SSE events, scanning each data line
+                            let sseBuffer = "";
+                            proxyRes.on("data", (chunk) => {
+                                sseBuffer += chunk.toString();
+                                const lines = sseBuffer.split("\n");
+                                sseBuffer = lines.pop() || "";
+                                for (const line of lines) {
+                                    if (line.startsWith("data:")) {
+                                        const data = line.slice(5).trim();
+                                        try {
+                                            const msg = JSON.parse(data);
+                                            const leakViolations = policy.checkSensitiveData(JSON.stringify(msg.result || msg));
+                                            if (leakViolations.length > 0) {
+                                                logger.logEvent("SENSITIVE_DATA_LEAK", "CRITICAL", {
+                                                    violations: leakViolations,
+                                                }, sessionId);
+                                                console.error(`\n🚨 SENSITIVE DATA IN SSE STREAM:\n${leakViolations.join("\n")}\n`);
+                                                if (policy.isBlockingMode()) {
+                                                    // Replace event with error event
+                                                    clientRes.write(`data: ${JSON.stringify({
+                                                        jsonrpc: "2.0",
+                                                        id: msg.id,
+                                                        error: {
+                                                            code: -32001,
+                                                            message: "Sensitive data blocked",
+                                                        },
+                                                    })}\n\n`);
+                                                    continue;
+                                                }
+                                                else {
+                                                    console.error("⚠️  MONITOR MODE — event forwarded\n");
+                                                }
+                                            }
+                                        }
+                                        catch {
+                                            /* non-JSON SSE data */
+                                        }
+                                    }
+                                    clientRes.write(line + "\n");
+                                }
+                            });
+                            proxyRes.on("end", () => {
+                                if (sseBuffer)
+                                    clientRes.write(sseBuffer);
+                                clientRes.end();
+                            });
+                        }
+                        else {
+                            // Regular HTTP — collect response, scan, forward
+                            const resChunks = [];
+                            proxyRes.on("data", (chunk) => resChunks.push(chunk));
+                            proxyRes.on("end", () => {
+                                const resBody = Buffer.concat(resChunks).toString();
+                                try {
+                                    const msg = JSON.parse(resBody);
+                                    const leakViolations = policy.checkSensitiveData(JSON.stringify(msg.result || msg));
+                                    if (leakViolations.length > 0) {
+                                        logger.logEvent("SENSITIVE_DATA_LEAK", "CRITICAL", {
+                                            violations: leakViolations,
+                                        }, sessionId);
+                                        console.error(`\n🚨 SENSITIVE DATA IN RESPONSE:\n${leakViolations.join("\n")}\n`);
+                                        if (policy.isBlockingMode() && msg.id !== undefined) {
+                                            console.error("🚫 RESPONSE BLOCKED\n");
+                                            clientRes.end(JSON.stringify({
+                                                jsonrpc: "2.0",
+                                                id: msg.id,
+                                                error: {
+                                                    code: -32001,
+                                                    message: "Sensitive data blocked",
+                                                },
+                                            }));
+                                            return;
+                                        }
+                                        else {
+                                            console.error("⚠️  MONITOR MODE — response forwarded\n");
+                                        }
+                                    }
+                                }
+                                catch {
+                                    /* non-JSON */
+                                }
+                                clientRes.end(resBody);
+                            });
+                        }
+                    });
+                    proxyReq.on("error", (err) => {
+                        logger.logEvent("PROXY_ERROR", "HIGH", { error: err.message }, sessionId);
+                        clientRes.writeHead(502);
+                        clientRes.end("Bad Gateway");
+                    });
+                    if (rawBody.length > 0)
+                        proxyReq.write(rawBody);
+                    proxyReq.end();
+                });
+            });
+            server.listen(port, () => {
+                logger.logEvent("SSE_PROXY_START", "LOW", {
+                    port,
+                    targetUrl,
+                    mode: policy.getConfig().mode,
+                }, sessionId);
+                console.error(`🛡️  ContextGuard SSE/HTTP proxy listening on port ${port}`);
+                console.error(`   → Forwarding to: ${targetUrl}`);
+                console.error(`   → Mode: ${policy.getConfig().mode}\n`);
+            });
+        },
+        getLogger: () => logger,
+    };
+};
+exports.createSSEProxy = createSSEProxy;

package/dist/supabase-client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2025 Amir Mironi
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { SecurityEvent } from "./types";
+/**
+ * Supabase configuration
+ */
+export interface SupabaseConfig {
+    url: string;
+    serviceKey: string;
+    agentId?: string;
+}
+/**
+ * Supabase client for agent-dashboard communication
+ */
+export interface SupabaseClient {
+    reportEvent: (event: SecurityEvent) => Promise<void>;
+    fetchPolicy: (agentId: string) => Promise<any>;
+    updateAgentStatus: (agentId: string, status: string) => Promise<void>;
+}
+/**
+ * Create a Supabase client
+ */
+export declare const createSupabaseClient: (config: SupabaseConfig) => SupabaseClient;

package/dist/supabase-client.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Amir Mironi
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSupabaseClient = void 0;
+/**
+ * Create a Supabase client
+ */
+const createSupabaseClient = (config) => {
+    const { url, serviceKey } = config;
+    /**
+     * Make a request to Supabase REST API
+     */
+    const makeRequest = async (method, path, body) => {
+        const response = await fetch(`${url}/rest/v1${path}`, {
+            method,
+            headers: {
+                "Content-Type": "application/json",
+                apikey: serviceKey,
+                Authorization: `Bearer ${serviceKey}`,
+                Prefer: "return=representation",
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Supabase request failed: ${error}`);
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : null;
+    };
+    return {
+        /**
+         * Report a security event to Supabase
+         */
+        reportEvent: async (event) => {
+            try {
+                await makeRequest("POST", "/security_events", {
+                    agent_id: config.agentId,
+                    event_type: event.eventType,
+                    severity: event.severity,
+                    details: event.details,
+                    session_id: event.sessionId,
+                    timestamp: event.timestamp,
+                });
+            }
+            catch (error) {
+                console.error("Failed to report event to Supabase:", error);
+                // Don't throw - we don't want to break the agent if reporting fails
+            }
+        },
+        /**
+         * Fetch policy configuration for an agent
+         */
+        fetchPolicy: async (agentId) => {
+            try {
+                const result = await makeRequest("GET", `/agent_policies?agent_id=eq.${agentId}&select=*&limit=1`);
+                if (result && result.length > 0) {
+                    return result[0].policy;
+                }
+                return null;
+            }
+            catch (error) {
+                console.error("Failed to fetch policy from Supabase:", error);
+                return null;
+            }
+        },
+        /**
+         * Update agent status
+         */
+        updateAgentStatus: async (agentId, status) => {
+            try {
+                await makeRequest("POST", "/agent_status", {
+                    agent_id: agentId,
+                    status,
+                    last_seen: new Date().toISOString(),
+                });
+            }
+            catch (error) {
+                console.error("Failed to update agent status:", error);
+            }
+        },
+    };
+};
+exports.createSupabaseClient = createSupabaseClient;

package/dist/types/database.types.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Copyright (c) 2026 Amir Mironi
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export type SecuritySeverity = "LOW" | "MEDIUM" | "HIGH" | "CRITICAL";
+export interface Database {
+    public: {
+        Tables: {
+            policies: {
+                Row: {
+                    id: string;
+                    agent_id: string;
+                    maxToolCallsPerMinute?: number;
+                    blockedPatterns?: string[];
+                    allowedFilePaths?: string[];
+                    alertThreshold?: number;
+                    enablePromptInjectionDetection?: boolean;
+                    enableSensitiveDataDetection?: boolean;
+                    enablePathTraversalPrevention?: boolean;
+                    mode?: "monitor" | "block";
+                    logPath?: string;
+                    enableProFeatures?: boolean;
+                    licenseFilePath?: string;
+                    transport?: "stdio" | "sse" | "http";
+                    port?: number;
+                    targetUrl?: string;
+                    allowedTools?: string[];
+                    blockedTools?: string[];
+                    alertWebhook?: string;
+                    alertOnSeverity?: string[];
+                    enableSQLInjectionDetection?: boolean;
+                    enableSemanticDetection?: boolean;
+                    enableXSSDetection?: boolean;
+                    customRules?: Array<{
+                        name: string;
+                        pattern: string;
+                        severity?: string;
+                    }>;
+                    created_at: string;
+                    updated_at: string;
+                };
+                Insert: {
+                    id?: string;
+                    agent_id: string;
+                    maxToolCallsPerMinute?: number;
+                    blockedPatterns?: string[];
+                    allowedFilePaths?: string[];
+                    alertThreshold?: number;
+                    enablePromptInjectionDetection?: boolean;
+                    enableSensitiveDataDetection?: boolean;
+                    enablePathTraversalPrevention?: boolean;
+                    mode?: "monitor" | "block";
+                    logPath?: string;
+                    enableProFeatures?: boolean;
+                    licenseFilePath?: string;
+                    transport?: "stdio" | "sse" | "http";
+                    port?: number;
+                    targetUrl?: string;
+                    allowedTools?: string[];
+                    blockedTools?: string[];
+                    alertWebhook?: string;
+                    alertOnSeverity?: string[];
+                    enableSQLInjectionDetection?: boolean;
+                    enableSemanticDetection?: boolean;
+                    enableXSSDetection?: boolean;
+                    customRules?: Array<{
+                        name: string;
+                        pattern: string;
+                        severity?: string;
+                    }>;
+                    created_at?: string;
+                    updated_at?: string;
+                };
+                Update: {
+                    id?: string;
+                    agent_id?: string;
+                    maxToolCallsPerMinute?: number;
+                    blockedPatterns?: string[];
+                    allowedFilePaths?: string[];
+                    alertThreshold?: number;
+                    enablePromptInjectionDetection?: boolean;
+                    enableSensitiveDataDetection?: boolean;
+                    enablePathTraversalPrevention?: boolean;
+                    mode?: "monitor" | "block";
+                    logPath?: string;
+                    enableProFeatures?: boolean;
+                    licenseFilePath?: string;
+                    transport?: "stdio" | "sse" | "http";
+                    port?: number;
+                    targetUrl?: string;
+                    allowedTools?: string[];
+                    blockedTools?: string[];
+                    alertWebhook?: string;
+                    alertOnSeverity?: string[];
+                    enableSQLInjectionDetection?: boolean;
+                    enableSemanticDetection?: boolean;
+                    enableXSSDetection?: boolean;
+                    customRules?: Array<{
+                        name: string;
+                        pattern: string;
+                        severity?: string;
+                    }>;
+                    created_at?: string;
+                    updated_at?: string;
+                };
+            };
+            events: {
+                Row: {
+                    id: string;
+                    agent_id: string;
+                    session_id: string;
+                    event_type: string;
+                    severity: SecuritySeverity;
+                    details: Record<string, unknown>;
+                    timestamp: string;
+                    created_at: string;
+                };
+                Insert: {
+                    id?: string;
+                    agent_id: string;
+                    session_id: string;
+                    event_type: string;
+                    severity: SecuritySeverity;
+                    details: Record<string, unknown>;
+                    timestamp: string;
+                    created_at?: string;
+                };
+                Update: {
+                    id?: string;
+                    agent_id?: string;
+                    session_id?: string;
+                    event_type?: string;
+                    severity?: SecuritySeverity;
+                    details?: Record<string, unknown>;
+                    timestamp?: string;
+                    created_at?: string;
+                };
+            };
+            agents: {
+                Row: {
+                    id: string;
+                    agent_id: string;
+                    status: AgentStatus;
+                    last_seen: string;
+                    created_at: string;
+                    updated_at: string;
+                };
+                Insert: {
+                    id?: string;
+                    agent_id: string;
+                    status: AgentStatus;
+                    last_seen: string;
+                    created_at?: string;
+                    updated_at?: string;
+                };
+                Update: {
+                    id?: string;
+                    agent_id?: string;
+                    status?: AgentStatus;
+                    last_seen?: string;
+                    created_at?: string;
+                    updated_at?: string;
+                };
+            };
+        };
+        Views: {
+            event_statistics: {
+                Row: {
+                    agent_id: string;
+                    event_type: string;
+                    severity: SecuritySeverity;
+                    count: number;
+                    hour: string;
+                };
+            };
+        };
+        Functions: {
+            cleanup_old_events: {
+                Args: {
+                    days_to_keep?: number;
+                };
+                Returns: number;
+            };
+        };
+    };
+}
+/**
+ * Agent status types
+ */
+export type AgentStatus = "online" | "offline" | "error";
+/**
+ * Security event from database
+ */
+export type SecurityEventRow = Database["public"]["Tables"]["events"]["Row"];
+/**
+ * Agent policy from database
+ */
+export type AgentPolicyRow = Database["public"]["Tables"]["policies"]["Row"];
+/**
+ * Agent status from database
+ */
+export type AgentStatusRow = Database["public"]["Tables"]["agents"]["Row"];
+/**
+ * Event statistics from view
+ */
+export type EventStatisticsRow = Database["public"]["Views"]["event_statistics"]["Row"];
+/**
+ * Insert types for convenience
+ */
+export type SecurityEventInsert = Database["public"]["Tables"]["events"]["Insert"];
+export type AgentPolicyInsert = Database["public"]["Tables"]["policies"]["Insert"];
+export type AgentStatusInsert = Database["public"]["Tables"]["agents"]["Insert"];
+/**
+ * Update types for convenience
+ */
+export type SecurityEventUpdate = Database["public"]["Tables"]["events"]["Update"];
+export type AgentPolicyUpdate = Database["public"]["Tables"]["policies"]["Update"];
+export type AgentStatusUpdate = Database["public"]["Tables"]["agents"]["Update"];

package/dist/types/database.types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Amir Mironi
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/mcp.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2026 Amir Mironi
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * MCP JSON-RPC message structure
+ */
+export interface MCPMessage {
+    jsonrpc: string;
+    id?: string | number;
+    method?: string;
+    params?: {
+        name?: string;
+        arguments?: Record<string, string>;
+        path?: string;
+        filePath?: string;
+        [key: string]: unknown;
+    };
+    result?: unknown;
+    error?: unknown;
+}
+/**
+ * Generate a unique session ID
+ */
+export declare const generateSessionId: () => string;

package/dist/types/mcp.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Amir Mironi
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSessionId = void 0;
+const crypto_1 = require("crypto");
+/**
+ * Generate a unique session ID
+ */
+const generateSessionId = () => (0, crypto_1.createHash)("md5").update(Date.now().toString()).digest("hex").substring(0, 8);
+exports.generateSessionId = generateSessionId;