contextguard 0.1.7 → 0.2.0

package/dist/mcp-security-wrapper.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 /**
- * Copyright (c) 2025 Amir Mironi
+ * 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.
@@ -40,31 +40,40 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecurityLogger = exports.SecurityPolicy = exports.MCPSecurityWrapper = void 0;
+exports.SecurityLogger = exports.SecurityPolicy = exports.MCPSSEProxy = exports.MCPSecurityWrapper = void 0;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
 const crypto_1 = require("crypto");
+// ─── Security Policy ─────────────────────────────────────────────────────────
 class SecurityPolicy {
     constructor(config) {
         this.config = {
             maxToolCallsPerMinute: 30,
+            enablePromptInjectionDetection: true,
+            enableSensitiveDataDetection: true,
+            enablePathTraversalPrevention: true,
+            mode: "monitor", // Safe default — just log, don't block
             blockedPatterns: [],
             allowedFilePaths: [],
             alertThreshold: 5,
-            enablePromptInjectionDetection: true,
-            enableSensitiveDataDetection: true,
+            logPath: "./mcp_security.log",
+            logLevel: "info",
+            transport: "stdio",
+            port: 3100,
+            targetUrl: "",
             ...config,
         };
-        // Sensitive data patterns
         this.sensitiveDataPatterns = [
             /(?:password|secret|api[_-]?key|token)\s*[:=]\s*['"]?[\w\-.]+['"]?/gi,
-            /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, // Email
-            /\b\d{3}-\d{2}-\d{4}\b/g, // SSN
-            /sk-[a-zA-Z0-9]{20,}/g, // OpenAI API keys (20+ chars)
-            /ghp_[a-zA-Z0-9]{36}/g, // GitHub tokens
-            /AKIA[0-9A-Z]{16}/g, // AWS Access Keys
+            /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+            /\b\d{3}-\d{2}-\d{4}\b/g,
+            /sk-[a-zA-Z0-9]{20,}/g,
+            /ghp_[a-zA-Z0-9]{36}/g,
+            /AKIA[0-9A-Z]{16}/g,
+            /sk_(live|test)_[a-zA-Z0-9]{24,}/g,
         ];
-        // Prompt injection patterns
         this.promptInjectionPatterns = [
             /ignore\s+(previous|all)\s+(instructions|prompts)/gi,
             /system:\s*you\s+are\s+now/gi,
@@ -76,6 +85,12 @@ class SecurityPolicy {
             /override\s+previous/gi,
         ];
     }
+    get isBlockingMode() {
+        return this.config.mode === "block";
+    }
+    get rawConfig() {
+        return this.config;
+    }
     checkPromptInjection(text) {
         if (!this.config.enablePromptInjectionDetection)
             return [];
@@ -101,6 +116,8 @@ class SecurityPolicy {
         return violations;
     }
     checkFileAccess(filePath) {
+        if (!this.config.enablePathTraversalPrevention)
+            return [];
         const violations = [];
         if (filePath.includes("..")) {
             violations.push(`Path traversal attempt detected: ${filePath}`);
@@ -112,11 +129,10 @@ class SecurityPolicy {
             "/proc",
             "C:\\Windows\\System32",
         ];
-        if (dangerousPaths.some((dangerous) => filePath.startsWith(dangerous))) {
+        if (dangerousPaths.some((d) => filePath.startsWith(d))) {
             violations.push(`Access to dangerous path detected: ${filePath}`);
         }
-        if (this.config.allowedFilePaths &&
-            this.config.allowedFilePaths.length > 0) {
+        if (this.config.allowedFilePaths.length > 0) {
             const isAllowed = this.config.allowedFilePaths.some((allowed) => filePath.startsWith(allowed));
             if (!isAllowed) {
                 violations.push(`File path not in allowed list: ${filePath}`);
@@ -127,12 +143,13 @@ class SecurityPolicy {
     checkRateLimit(timestamps) {
         const oneMinuteAgo = Date.now() - 60000;
         const recentCalls = timestamps.filter((t) => t > oneMinuteAgo);
-        return recentCalls.length < (this.config.maxToolCallsPerMinute || 30);
+        return recentCalls.length < this.config.maxToolCallsPerMinute;
     }
 }
 exports.SecurityPolicy = SecurityPolicy;
+// ─── Security Logger ──────────────────────────────────────────────────────────
 class SecurityLogger {
-    constructor(logFile = "mcp_security.log") {
+    constructor(logFile = "./mcp_security.log") {
         this.events = [];
         this.logFile = logFile;
     }
@@ -168,6 +185,15 @@ class SecurityLogger {
     }
 }
 exports.SecurityLogger = SecurityLogger;
+// ─── Violation Handler (respects monitor vs block mode) ───────────────────────
+function buildErrorResponse(msg, code, message, violations) {
+    return (JSON.stringify({
+        jsonrpc: msg.jsonrpc,
+        id: msg.id,
+        error: { code, message, data: { violations } },
+    }) + "\n");
+}
+// ─── stdio Transport ─────────────────────────────────────────────────────────
 class MCPSecurityWrapper {
     constructor(serverCommand, policy, logger) {
         this.process = null;
@@ -192,31 +218,23 @@ class MCPSecurityWrapper {
         this.logger.logEvent("SERVER_START", "LOW", {
             command: this.serverCommand.join(" "),
             pid: this.process.pid,
+            mode: this.policy.rawConfig.mode,
         }, this.sessionId);
         this.process.stderr.pipe(process.stderr);
         this.process.stdout.on("data", (data) => {
-            const output = data.toString();
-            this.handleServerOutput(output);
+            this.handleServerOutput(data.toString());
         });
         process.stdin.on("data", (data) => {
-            const input = data.toString();
-            this.handleClientInput(input);
+            this.handleClientInput(data.toString());
         });
         this.process.on("exit", (code) => {
-            this.logger.logEvent("SERVER_EXIT", "MEDIUM", {
-                exitCode: code,
-            }, this.sessionId);
+            this.logger.logEvent("SERVER_EXIT", "MEDIUM", { exitCode: code }, this.sessionId);
             console.error("\n=== MCP Security Statistics ===");
             console.error(JSON.stringify(this.logger.getStatistics(), null, 2));
-            // Use setImmediate to allow pending I/O to complete
-            setImmediate(() => {
-                process.exit(code || 0);
-            });
+            setImmediate(() => process.exit(code || 0));
         });
         this.process.on("error", (err) => {
-            this.logger.logEvent("SERVER_ERROR", "HIGH", {
-                error: err.message,
-            }, this.sessionId);
+            this.logger.logEvent("SERVER_ERROR", "HIGH", { error: err.message }, this.sessionId);
             console.error("Server process error:", err);
         });
     }
@@ -225,9 +243,8 @@ class MCPSecurityWrapper {
         const lines = this.clientMessageBuffer.split("\n");
         this.clientMessageBuffer = lines.pop() || "";
         for (const line of lines) {
-            if (line.trim()) {
+            if (line.trim())
                 this.processClientMessage(line);
-            }
         }
     }
     processClientMessage(line) {
@@ -237,157 +254,414 @@ class MCPSecurityWrapper {
                 method: message.method,
                 id: message.id,
             }, this.sessionId);
-            const violations = [];
-            let shouldBlock = false;
-            if (message.method === "tools/call") {
-                const now = Date.now();
-                this.toolCallTimestamps.push(now);
-                // Clean up old timestamps to prevent memory leak
-                const oneMinuteAgo = now - 60000;
-                this.toolCallTimestamps = this.toolCallTimestamps.filter((t) => t > oneMinuteAgo);
-                if (!this.policy.checkRateLimit(this.toolCallTimestamps)) {
-                    violations.push("Rate limit exceeded for tool calls");
-                    shouldBlock = true;
-                    this.logger.logEvent("RATE_LIMIT_EXCEEDED", "HIGH", {
-                        method: message.method,
-                        toolName: message.params?.name,
-                    }, this.sessionId);
-                }
-                const paramsStr = JSON.stringify(message.params);
-                const injectionViolations = this.policy.checkPromptInjection(paramsStr);
-                violations.push(...injectionViolations);
-                const sensitiveViolations = this.policy.checkSensitiveData(paramsStr);
-                violations.push(...sensitiveViolations);
-                // Check multiple possible file path parameter locations
-                const filePathParams = [
-                    message.params?.arguments?.path,
-                    message.params?.arguments?.filePath,
-                    message.params?.arguments?.file,
-                    message.params?.arguments?.directory,
-                    message.params?.path,
-                    message.params?.filePath,
-                ].filter((path) => typeof path === "string");
-                for (const filePath of filePathParams) {
-                    const fileViolations = this.policy.checkFileAccess(filePath);
-                    violations.push(...fileViolations);
-                }
-                this.logger.logEvent("TOOL_CALL", violations.length > 0 ? "HIGH" : "LOW", {
-                    toolName: message.params?.name,
-                    hasViolations: violations.length > 0,
-                    violations,
-                }, this.sessionId);
-            }
+            const { violations, shouldBlock } = this.inspectOutbound(message);
             if (violations.length > 0) {
                 this.logger.logEvent("SECURITY_VIOLATION", "CRITICAL", {
                     violations,
-                    message: message,
                     blocked: shouldBlock,
                 }, this.sessionId);
                 console.error(`\n⚠️  SECURITY VIOLATIONS DETECTED:\n${violations.join("\n")}\n`);
                 if (shouldBlock) {
                     console.error("🚫 REQUEST BLOCKED\n");
-                    // Send error response back to client
                     if (message.id !== undefined) {
-                        const errorResponse = {
-                            jsonrpc: message.jsonrpc,
-                            id: message.id,
-                            error: {
-                                code: -32000,
-                                message: "Security violation: Request blocked",
-                                data: { violations },
-                            },
-                        };
-                        process.stdout.write(JSON.stringify(errorResponse) + "\n");
+                        process.stdout.write(buildErrorResponse(message, -32000, "Security violation: Request blocked", violations));
                     }
-                    return; // Don't forward to server
+                    return;
                 }
+                // monitor mode: log and warn but still forward
+                console.error('⚠️  MONITOR MODE — request forwarded (set mode: "block" to block)\n');
             }
-            if (this.process && this.process.stdin) {
-                this.process.stdin.write(line + "\n");
-            }
+            this.process?.stdin?.write(line + "\n");
         }
         catch (err) {
             this.logger.logEvent("PARSE_ERROR", "MEDIUM", {
                 error: err instanceof Error ? err.message : String(err),
                 line: line.substring(0, 100),
             }, this.sessionId);
-            console.error(`Failed to parse client message: ${err}`);
-            // Forward unparseable messages
-            if (this.process && this.process.stdin) {
-                this.process.stdin.write(line + "\n");
+            this.process?.stdin?.write(line + "\n");
+        }
+    }
+    /** Returns violations + whether to block (block only if mode==="block") */
+    inspectOutbound(message) {
+        const violations = [];
+        let shouldBlock = false;
+        if (message.method === "tools/call") {
+            const now = Date.now();
+            this.toolCallTimestamps.push(now);
+            this.toolCallTimestamps = this.toolCallTimestamps.filter((t) => t > now - 60000);
+            if (!this.policy.checkRateLimit(this.toolCallTimestamps)) {
+                violations.push("Rate limit exceeded for tool calls");
+                shouldBlock = this.policy.isBlockingMode; // only hard-block in block mode
+                this.logger.logEvent("RATE_LIMIT_EXCEEDED", "HIGH", {
+                    toolName: message.params?.name,
+                }, this.sessionId);
+            }
+            const paramsStr = JSON.stringify(message.params);
+            violations.push(...this.policy.checkPromptInjection(paramsStr));
+            violations.push(...this.policy.checkSensitiveData(paramsStr));
+            const filePathParams = [
+                message.params?.arguments?.path,
+                message.params?.arguments?.filePath,
+                message.params?.arguments?.file,
+                message.params?.arguments?.directory,
+                message.params?.path,
+                message.params?.filePath,
+            ].filter((p) => typeof p === "string");
+            for (const fp of filePathParams) {
+                violations.push(...this.policy.checkFileAccess(fp));
+            }
+            this.logger.logEvent("TOOL_CALL", violations.length > 0 ? "HIGH" : "LOW", {
+                toolName: message.params?.name,
+                hasViolations: violations.length > 0,
+                violations,
+            }, this.sessionId);
+            // In blocking mode, any violation blocks
+            if (violations.length > 0 && this.policy.isBlockingMode) {
+                shouldBlock = true;
             }
         }
+        return { violations, shouldBlock };
     }
     handleServerOutput(output) {
-        // Forward output immediately
-        process.stdout.write(output);
-        // Buffer and parse for logging
         this.serverMessageBuffer += output;
         const lines = this.serverMessageBuffer.split("\n");
         this.serverMessageBuffer = lines.pop() || "";
         for (const line of lines) {
-            if (line.trim()) {
-                try {
-                    const message = JSON.parse(line);
+            if (!line.trim())
+                continue;
+            let shouldForward = true;
+            try {
+                const message = JSON.parse(line);
+                const violations = this.policy.checkSensitiveData(JSON.stringify(message.result || message));
+                if (violations.length > 0) {
+                    this.logger.logEvent("SENSITIVE_DATA_LEAK", "CRITICAL", {
+                        violations,
+                        responseId: message.id,
+                    }, this.sessionId);
+                    console.error(`\n🚨 SENSITIVE DATA DETECTED IN RESPONSE:\n${violations.join("\n")}\n`);
+                    if (this.policy.isBlockingMode) {
+                        console.error("🚫 RESPONSE BLOCKED\n");
+                        if (message.id !== undefined) {
+                            process.stdout.write(buildErrorResponse(message, -32001, "Security violation: Response contains sensitive data", violations));
+                        }
+                        shouldForward = false;
+                    }
+                    else {
+                        console.error("⚠️  MONITOR MODE — response forwarded\n");
+                    }
+                }
+                else {
                     this.logger.logEvent("SERVER_RESPONSE", "LOW", {
                         id: message.id,
                         hasError: !!message.error,
                     }, this.sessionId);
                 }
-                catch (err) {
-                    // Log parse errors for server output
-                    this.logger.logEvent("SERVER_PARSE_ERROR", "LOW", {
-                        error: err instanceof Error ? err.message : String(err),
-                        line: line.substring(0, 100),
-                    }, this.sessionId);
-                }
             }
+            catch (err) {
+                this.logger.logEvent("SERVER_PARSE_ERROR", "LOW", {
+                    error: err instanceof Error ? err.message : String(err),
+                    line: line.substring(0, 100),
+                }, this.sessionId);
+            }
+            if (shouldForward)
+                process.stdout.write(line + "\n");
         }
     }
 }
 exports.MCPSecurityWrapper = MCPSecurityWrapper;
+// ─── SSE / HTTP Transport ────────────────────────────────────────────────────
+/**
+ * SSE proxy: listens on `port`, forwards every request to `targetUrl`,
+ * scanning both request body (outbound) and response body (inbound).
+ *
+ * Supports:
+ *   - Standard JSON-RPC over HTTP POST  (MCP HTTP transport)
+ *   - Server-Sent Events streams        (MCP SSE transport)
+ */
+class MCPSSEProxy {
+    constructor(policy, logger) {
+        this.toolCallTimestamps = [];
+        this.policy = policy;
+        this.logger = logger;
+        this.sessionId = (0, crypto_1.createHash)("md5")
+            .update(Date.now().toString())
+            .digest("hex")
+            .substring(0, 8);
+    }
+    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 = this.inspectOutbound(msg);
+                        violations = result.violations;
+                        shouldBlock = result.shouldBlock;
+                        if (violations.length > 0) {
+                            this.logger.logEvent("SECURITY_VIOLATION", "CRITICAL", {
+                                violations,
+                                blocked: shouldBlock,
+                            }, this.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;
+                        }
+                    }
+                    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 = this.policy.checkSensitiveData(JSON.stringify(msg.result || msg));
+                                        if (leakViolations.length > 0) {
+                                            this.logger.logEvent("SENSITIVE_DATA_LEAK", "CRITICAL", {
+                                                violations: leakViolations,
+                                            }, this.sessionId);
+                                            console.error(`\n🚨 SENSITIVE DATA IN SSE STREAM:\n${leakViolations.join("\n")}\n`);
+                                            if (this.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;
+                                            }
+                                        }
+                                    }
+                                    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 = this.policy.checkSensitiveData(JSON.stringify(msg.result || msg));
+                                if (leakViolations.length > 0) {
+                                    this.logger.logEvent("SENSITIVE_DATA_LEAK", "CRITICAL", {
+                                        violations: leakViolations,
+                                    }, this.sessionId);
+                                    if (this.policy.isBlockingMode && msg.id !== undefined) {
+                                        clientRes.end(JSON.stringify({
+                                            jsonrpc: "2.0",
+                                            id: msg.id,
+                                            error: {
+                                                code: -32001,
+                                                message: "Sensitive data blocked",
+                                            },
+                                        }));
+                                        return;
+                                    }
+                                }
+                            }
+                            catch {
+                                /* non-JSON */
+                            }
+                            clientRes.end(resBody);
+                        });
+                    }
+                });
+                proxyReq.on("error", (err) => {
+                    this.logger.logEvent("PROXY_ERROR", "HIGH", { error: err.message }, this.sessionId);
+                    clientRes.writeHead(502);
+                    clientRes.end("Bad Gateway");
+                });
+                if (rawBody.length > 0)
+                    proxyReq.write(rawBody);
+                proxyReq.end();
+            });
+        });
+        server.listen(port, () => {
+            this.logger.logEvent("SSE_PROXY_START", "LOW", {
+                port,
+                targetUrl,
+                mode: this.policy.rawConfig.mode,
+            }, this.sessionId);
+            console.error(`🛡️  ContextGuard SSE/HTTP proxy listening on port ${port}`);
+            console.error(`   → Forwarding to: ${targetUrl}`);
+            console.error(`   → Mode: ${this.policy.rawConfig.mode}\n`);
+        });
+    }
+    inspectOutbound(message) {
+        const violations = [];
+        let shouldBlock = false;
+        if (message.method === "tools/call") {
+            const now = Date.now();
+            this.toolCallTimestamps.push(now);
+            this.toolCallTimestamps = this.toolCallTimestamps.filter((t) => t > now - 60000);
+            if (!this.policy.checkRateLimit(this.toolCallTimestamps)) {
+                violations.push("Rate limit exceeded");
+                if (this.policy.isBlockingMode)
+                    shouldBlock = true;
+            }
+            const paramsStr = JSON.stringify(message.params);
+            violations.push(...this.policy.checkPromptInjection(paramsStr));
+            violations.push(...this.policy.checkSensitiveData(paramsStr));
+            const filePathParams = [
+                message.params?.arguments?.path,
+                message.params?.arguments?.filePath,
+            ].filter((p) => typeof p === "string");
+            for (const fp of filePathParams) {
+                violations.push(...this.policy.checkFileAccess(fp));
+            }
+            if (violations.length > 0 && this.policy.isBlockingMode)
+                shouldBlock = true;
+        }
+        return { violations, shouldBlock };
+    }
+}
+exports.MCPSSEProxy = MCPSSEProxy;
+// ─── CLI Entry Point ──────────────────────────────────────────────────────────
 async function main() {
     const args = process.argv.slice(2);
     if (args.length === 0 || args.includes("--help")) {
         console.log(`
-MCP Security Wrapper - MVP
+MCP Security Wrapper
 
 Usage:
+  # stdio transport (Claude Desktop)
   contextguard --server "node server.js" --config config.json
 
+  # SSE/HTTP transport proxy
+  contextguard --transport sse --port 3100 --target http://localhost:3000 --config config.json
+
 Options:
-  --server <command>    Command to start the MCP server (required)
-  --config <file>       Path to security config JSON file (optional)
-  --help               Show this help message
+  --server <cmd>        Command to start MCP server (stdio mode)
+  --transport <type>    stdio | sse | http  (default: stdio)
+  --port <n>            Proxy listen port   (SSE/HTTP mode, default: 3100)
+  --target <url>        Upstream server URL (SSE/HTTP mode)
+  --config <file>       Path to security config JSON (optional)
+  --help                Show this help
 
+Config options (config.json):
+  mode                  "monitor" (log only) | "block" (block + log)  default: monitor
+  maxToolCallsPerMinute number   default: 30
+  enablePromptInjectionDetection  boolean  default: true
+  enableSensitiveDataDetection    boolean  default: true
+  enablePathTraversalPrevention   boolean  default: true
+  allowedFilePaths      string[]
+  logPath               string   default: ./mcp_security.log
     `);
         process.exit(0);
     }
     let serverCommand = "";
     let configFile = "";
+    let transport = "stdio";
+    let port = 3100;
+    let targetUrl = "";
     for (let i = 0; i < args.length; i++) {
         if (args[i] === "--server" && args[i + 1]) {
-            serverCommand = args[i + 1];
-            i++;
+            serverCommand = args[++i];
         }
         else if (args[i] === "--config" && args[i + 1]) {
-            configFile = args[i + 1];
-            i++;
+            configFile = args[++i];
+        }
+        else if (args[i] === "--transport" && args[i + 1]) {
+            transport = args[++i];
+        }
+        else if (args[i] === "--port" && args[i + 1]) {
+            port = parseInt(args[++i], 10);
+        }
+        else if (args[i] === "--target" && args[i + 1]) {
+            targetUrl = args[++i];
         }
-    }
-    if (!serverCommand) {
-        console.error("Error: --server argument is required");
-        process.exit(1);
     }
     let config = {};
     if (configFile && fs.existsSync(configFile)) {
         config = JSON.parse(fs.readFileSync(configFile, "utf-8"));
     }
+    // CLI flags override config file
+    if (transport !== "stdio")
+        config.transport = transport;
+    if (port !== 3100)
+        config.port = port;
+    if (targetUrl)
+        config.targetUrl = targetUrl;
     const policy = new SecurityPolicy(config);
     const logger = new SecurityLogger(config.logPath);
-    const wrapper = new MCPSecurityWrapper(serverCommand.split(" "), policy, logger);
-    // console.log("ContextGuard is running");
-    await wrapper.start();
+    const effectiveTransport = config.transport || transport;
+    if (effectiveTransport === "sse" || effectiveTransport === "http") {
+        if (!config.targetUrl && !targetUrl) {
+            console.error("Error: --target <url> is required for SSE/HTTP transport");
+            process.exit(1);
+        }
+        const proxy = new MCPSSEProxy(policy, logger);
+        proxy.start(config.port || port, config.targetUrl || targetUrl);
+    }
+    else {
+        if (!serverCommand) {
+            console.error("Error: --server argument is required for stdio transport");
+            process.exit(1);
+        }
+        const wrapper = new MCPSecurityWrapper(serverCommand.split(" "), policy, logger);
+        await wrapper.start();
+    }
 }
 if (require.main === module) {
     main().catch((err) => {