@impart-security/impart-mcp 0.1.3 → 0.2.0

package/dist/test/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/integration.test.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_child_process_1 = require("node:child_process");
+// Skip integration tests if IMPART_AUTH_TOKEN is not set
+if (!process.env["IMPART_AUTH_TOKEN"]) {
+    console.log("⊘ Integration tests skipped (IMPART_AUTH_TOKEN not set)");
+    process.exit(0);
+}
+const config_js_1 = require("../config.js");
+class MCPTestClient {
+    process;
+    requestId = 0;
+    responses = new Map();
+    buffer = "";
+    constructor() {
+        this.process = (0, node_child_process_1.spawn)("node", ["dist/index.js"], {
+            env: {
+                ...process.env,
+                IMPART_AUTH_TOKEN: config_js_1.config.authToken,
+                IMPART_API_BASE: config_js_1.config.apiBase,
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.process.stdout?.on("data", (data) => {
+            this.buffer += data.toString();
+            const lines = this.buffer.split("\n");
+            this.buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const response = JSON.parse(line);
+                        if (response.id !== undefined) {
+                            this.responses.set(response.id, response);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore non-JSON lines (like server logs)
+                    }
+                }
+            }
+        });
+    }
+    async initialize() {
+        const response = await this.sendRequest("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: {
+                name: "test-client",
+                version: "1.0.0",
+            },
+        });
+        node_assert_1.default.ok(response.result, "Initialize should succeed");
+    }
+    async listTools() {
+        const response = await this.sendRequest("tools/list");
+        if (!response.result) {
+            throw new Error("List tools returned no result");
+        }
+        return response.result;
+    }
+    async callTool(name, args = {}) {
+        const response = await this.sendRequest("tools/call", {
+            name,
+            arguments: args,
+        });
+        if (response.error) {
+            throw new Error(`Tool call failed: ${response.error.message}`);
+        }
+        if (!response.result) {
+            throw new Error("Tool call returned no result");
+        }
+        return response.result;
+    }
+    async sendRequest(method, params) {
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            ...(params && { params }),
+        };
+        this.process.stdin?.write(JSON.stringify(request) + "\n");
+        // Wait for response (with timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Request ${id} timed out`));
+            }, 30000);
+            const checkResponse = setInterval(() => {
+                const response = this.responses.get(id);
+                if (response) {
+                    clearInterval(checkResponse);
+                    clearTimeout(timeout);
+                    this.responses.delete(id);
+                    resolve(response);
+                }
+            }, 100);
+        });
+    }
+    close() {
+        this.process.kill();
+    }
+}
+(0, node_test_1.describe)("MCP Server Integration Tests", () => {
+    let client;
+    let toolNames = [];
+    (0, node_test_1.before)(async () => {
+        if (!process.env["IMPART_AUTH_TOKEN"]) {
+            throw new Error("IMPART_AUTH_TOKEN environment variable is required for integration tests");
+        }
+        client = new MCPTestClient();
+        await client.initialize();
+        const { tools } = await client.listTools();
+        toolNames = tools.map((t) => t.name);
+        console.log(`\nFound ${tools.length} tools to test`);
+    });
+    (0, node_test_1.describe)("Tool Discovery", () => {
+        (0, node_test_1.it)("should list all 26 tools", async () => {
+            node_assert_1.default.strictEqual(toolNames.length, 26, "Should have exactly 26 tools");
+        });
+        (0, node_test_1.it)("should have properly named tools with org ID suffix", async () => {
+            const expectedTools = [
+                "list_inspectors",
+                "list_rules_scripts",
+                "get_rules_script",
+                "list_rule_recipes",
+                "get_rule_recipe",
+                "generate_rule_recipe",
+                "create_rule_recipe",
+                "list_endpoints",
+                "list_tags",
+                "get_tag_metrics",
+                "list_observed_hosts",
+                "get_observed_host",
+                "list_specs",
+                "get_spec",
+                "list_api_bindings",
+                "create_api_binding",
+                "list_lists",
+                "get_list_items",
+                "create_list",
+                "update_list_items",
+                "create_label",
+                "list_labels",
+                "list_test_cases",
+                "get_test_case",
+                "get_requests",
+                "get_request_details",
+            ];
+            for (const expectedTool of expectedTools) {
+                const found = toolNames.some((name) => name.startsWith(expectedTool + "_"));
+                node_assert_1.default.ok(found, `Should have tool starting with ${expectedTool}`);
+            }
+        });
+    });
+    (0, node_test_1.describe)("Inspector Tools", () => {
+        (0, node_test_1.it)("should list inspectors", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_inspectors_"));
+            node_assert_1.default.ok(toolName, "Should have list_inspectors tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+    });
+    (0, node_test_1.describe)("Rules Tools", () => {
+        (0, node_test_1.it)("should list rules scripts", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_rules_scripts_"));
+            node_assert_1.default.ok(toolName, "Should have list_rules_scripts tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 5 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should list rule recipes", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_rule_recipes_"));
+            node_assert_1.default.ok(toolName, "Should have list_rule_recipes tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 5 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+    });
+    (0, node_test_1.describe)("API Inventory Tools", () => {
+        (0, node_test_1.it)("should list endpoints", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_endpoints_"));
+            node_assert_1.default.ok(toolName, "Should have list_endpoints tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should list specs", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_specs_"));
+            node_assert_1.default.ok(toolName, "Should have list_specs tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should list api bindings", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_api_bindings_"));
+            node_assert_1.default.ok(toolName, "Should have list_api_bindings tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should list observed hosts", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_observed_hosts_"));
+            node_assert_1.default.ok(toolName, "Should have list_observed_hosts tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+    });
+    (0, node_test_1.describe)("Analytics Tools", () => {
+        (0, node_test_1.it)("should get tag metrics", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("get_tag_metrics_"));
+            node_assert_1.default.ok(toolName, "Should have get_tag_metrics tool");
+            const result = await client.callTool(toolName, {
+                metric: ["http-request.count"],
+                from: "-24h",
+                until: "-0h",
+                max_results: 10,
+            });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should get requests", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("get_requests_"));
+            node_assert_1.default.ok(toolName, "Should have get_requests tool");
+            const result = await client.callTool(toolName, {
+                from: "-1d",
+                max_results: 10,
+            });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+    });
+    (0, node_test_1.describe)("Organization Tools", () => {
+        (0, node_test_1.it)("should list tags", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_tags_"));
+            node_assert_1.default.ok(toolName, "Should have list_tags tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should list labels", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_labels_"));
+            node_assert_1.default.ok(toolName, "Should have list_labels tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should list lists", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_lists_"));
+            node_assert_1.default.ok(toolName, "Should have list_lists tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+        (0, node_test_1.it)("should list test cases", async () => {
+            const toolName = toolNames.find((name) => name.startsWith("list_test_cases_"));
+            node_assert_1.default.ok(toolName, "Should have list_test_cases tool");
+            const result = await client.callTool(toolName, { page: 1, max_results: 10 });
+            node_assert_1.default.ok(result, "Should return result");
+        });
+    });
+    // Cleanup after all tests
+    process.on("exit", () => {
+        if (client) {
+            client.close();
+        }
+    });
+});

package/dist/test/rule-recipe.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/rule-recipe.test.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_child_process_1 = require("node:child_process");
+const config_js_1 = require("../config.js");
+class MCPTestClient {
+    process;
+    requestId = 0;
+    responses = new Map();
+    buffer = "";
+    constructor() {
+        this.process = (0, node_child_process_1.spawn)("node", ["dist/index.js"], {
+            env: {
+                ...process.env,
+                IMPART_AUTH_TOKEN: config_js_1.config.authToken,
+                IMPART_API_BASE: config_js_1.config.apiBase,
+            },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.process.stdout?.on("data", (data) => {
+            this.buffer += data.toString();
+            const lines = this.buffer.split("\n");
+            this.buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const response = JSON.parse(line);
+                        if (response.id !== undefined) {
+                            this.responses.set(response.id, response);
+                        }
+                    }
+                    catch (e) {
+                        // Ignore non-JSON lines (like server logs)
+                    }
+                }
+            }
+        });
+        this.process.stderr?.on("data", (_data) => {
+            // Optional: log stderr for debugging
+            // console.error("Server stderr:", _data.toString());
+        });
+    }
+    async initialize() {
+        const response = await this.sendRequest("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: {
+                name: "test-client",
+                version: "1.0.0",
+            },
+        });
+        node_assert_1.default.ok(response.result, "Initialize should succeed");
+    }
+    async callTool(name, args = {}) {
+        const response = await this.sendRequest("tools/call", {
+            name,
+            arguments: args,
+        });
+        if (response.error) {
+            throw new Error(`Tool call failed: ${response.error.message}`);
+        }
+        if (!response.result) {
+            throw new Error("Tool call returned no result");
+        }
+        return response.result;
+    }
+    async sendRequest(method, params) {
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            ...(params && { params }),
+        };
+        this.process.stdin?.write(JSON.stringify(request) + "\n");
+        // Wait for response (with timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Request ${id} timed out after 60s`));
+            }, 60000); // 60s timeout for Sparkle AI
+            const checkResponse = setInterval(() => {
+                const response = this.responses.get(id);
+                if (response) {
+                    clearInterval(checkResponse);
+                    clearTimeout(timeout);
+                    this.responses.delete(id);
+                    resolve(response);
+                }
+            }, 100);
+        });
+    }
+    close() {
+        this.process.kill();
+    }
+}
+(0, node_test_1.describe)("Rule Recipe Tools - Critical Fixes", () => {
+    let client;
+    let generateToolName;
+    let createToolName;
+    let listToolName;
+    let generatedComponents;
+    const testRuleRecipeId = `test-rule-${Date.now()}`;
+    (0, node_test_1.before)(async () => {
+        if (!process.env["IMPART_AUTH_TOKEN"]) {
+            throw new Error("IMPART_AUTH_TOKEN environment variable is required");
+        }
+        client = new MCPTestClient();
+        await client.initialize();
+        // Find tool names with org suffix
+        const orgSuffix = config_js_1.config.orgId.slice(-4);
+        generateToolName = `generate_rule_recipe_${orgSuffix}`;
+        createToolName = `create_rule_recipe_${orgSuffix}`;
+        listToolName = `list_rule_recipes_${orgSuffix}`;
+        console.log(`\nTesting with org suffix: ${orgSuffix}`);
+    });
+    (0, node_test_1.after)(() => {
+        client.close();
+    });
+    (0, node_test_1.describe)("Fix #1: Sparkle API query format", () => {
+        (0, node_test_1.it)("should generate rule recipe with properly formatted query", async () => {
+            console.log("\n  Testing generate_rule_recipe with Sparkle AI...");
+            const result = await client.callTool(generateToolName, {
+                query: "Create a simple rule recipe that blocks requests with user-agent containing 'badbot'",
+            });
+            // Verify result structure
+            node_assert_1.default.ok(result, "Should return a result");
+            const typedResult = result;
+            node_assert_1.default.ok(Array.isArray(typedResult.content), "Should have content array");
+            node_assert_1.default.ok(typedResult.content[0], "Should have first content item");
+            node_assert_1.default.strictEqual(typedResult.content[0].type, "text", "Should have text content");
+            const responseText = typedResult.content[0].text;
+            node_assert_1.default.ok(responseText.includes("Generated Rule Recipe Configuration"), "Should include success message");
+            node_assert_1.default.ok(responseText.includes("rate_limit"), "Should include rate_limit component");
+            node_assert_1.default.ok(responseText.includes("inspect_request"), "Should include inspect_request component");
+            node_assert_1.default.ok(responseText.includes("enforce"), "Should include enforce component");
+            node_assert_1.default.ok(responseText.includes("inspect_response"), "Should include inspect_response component");
+            // Extract the JSON components for next test
+            const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+            node_assert_1.default.ok(jsonMatch, "Should contain JSON components");
+            generatedComponents = jsonMatch[0];
+            console.log("  ✓ Sparkle AI generated rule recipe successfully");
+        });
+    });
+    (0, node_test_1.describe)("Fix #2 & #3: blocking_effect field naming and placement", () => {
+        (0, node_test_1.it)("should create rule recipe with snake_case blocking_effect", async () => {
+            console.log("\n  Testing create_rule_recipe with proper field naming...");
+            // Use simple components structure for testing
+            const simpleComponents = {
+                rate_limit: { clauses: [] },
+                inspect_request: { clauses: [] },
+                enforce: { clauses: [] },
+                inspect_response: { clauses: [] },
+            };
+            const result = await client.callTool(createToolName, {
+                name: testRuleRecipeId,
+                description: "Test rule recipe to verify field naming",
+                disabled: true, // Keep disabled so it doesn't affect anything
+                blocking_effect: "simulate", // ← snake_case, top-level
+                components: JSON.stringify(simpleComponents),
+            });
+            // Verify success
+            node_assert_1.default.ok(result, "Should return a result");
+            const typedResult = result;
+            node_assert_1.default.ok(typedResult.content[0], "Should have content");
+            node_assert_1.default.ok(typedResult.content[0].text.includes("created successfully"), "Should create successfully");
+            node_assert_1.default.ok(typedResult.content[0].text.includes(testRuleRecipeId), "Should include rule recipe name");
+            console.log("  ✓ Rule recipe created with snake_case blocking_effect");
+        });
+        (0, node_test_1.it)("should verify created rule recipe exists", async () => {
+            console.log("\n  Verifying rule recipe was created...");
+            const result = await client.callTool(listToolName, {
+                search: testRuleRecipeId,
+            });
+            const typedResult = result;
+            node_assert_1.default.ok(typedResult.content[0], "Should have content");
+            const responseText = typedResult.content[0].text;
+            node_assert_1.default.ok(responseText.includes(testRuleRecipeId), "Should find the created rule recipe");
+            node_assert_1.default.ok(responseText.includes("simulate"), "Should have simulate blocking effect");
+            console.log("  ✓ Rule recipe verified in list");
+        });
+    });
+    (0, node_test_1.describe)("Regression: blocking_effect in components should be stripped", () => {
+        (0, node_test_1.it)("should handle components with blocking_effect inside (legacy format)", async () => {
+            console.log("\n  Testing backward compatibility with blocking_effect in components...");
+            // Simulate what Sparkle might have generated in old format
+            const componentsWithBlockingEffect = {
+                rate_limit: { clauses: [] },
+                inspect_request: { clauses: [] },
+                enforce: { clauses: [] },
+                inspect_response: { clauses: [] },
+                blocking_effect: "block", // ← This should be stripped out
+            };
+            const result = await client.callTool(createToolName, {
+                name: `${testRuleRecipeId}-legacy`,
+                description: "Test backward compatibility",
+                disabled: true,
+                blocking_effect: "simulate", // ← Top-level should win
+                components: JSON.stringify(componentsWithBlockingEffect),
+            });
+            node_assert_1.default.ok(result, "Should handle legacy format");
+            const typedResult = result;
+            node_assert_1.default.ok(typedResult.content[0], "Should have content");
+            node_assert_1.default.ok(typedResult.content[0].text.includes("created successfully"), "Should create successfully");
+            console.log("  ✓ Legacy format handled correctly");
+        });
+    });
+    (0, node_test_1.describe)("Error handling", () => {
+        (0, node_test_1.it)("should handle invalid components JSON", async () => {
+            console.log("\n  Testing invalid JSON components...");
+            try {
+                await client.callTool(createToolName, {
+                    name: "invalid-components-test",
+                    disabled: true,
+                    components: "{invalid json}", // ← Invalid JSON
+                });
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("components must be valid JSON"), "Should have helpful error message");
+                console.log("  ✓ Invalid JSON rejected with clear error");
+            }
+        });
+        (0, node_test_1.it)("should handle missing required components", async () => {
+            console.log("\n  Testing missing required components...");
+            try {
+                const incompleteComponents = {
+                    rate_limit: { clauses: [] },
+                    // Missing inspect_request, enforce, inspect_response
+                };
+                await client.callTool(createToolName, {
+                    name: "incomplete-components-test",
+                    disabled: true,
+                    components: JSON.stringify(incompleteComponents),
+                });
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                console.log("  ✓ Incomplete components rejected by API");
+            }
+        });
+    });
+    (0, node_test_1.describe)("Full workflow", () => {
+        (0, node_test_1.it)("should complete full generate → create workflow", async () => {
+            if (!generatedComponents) {
+                console.log("  ⊘ Skipping - no generated components from previous test");
+                return;
+            }
+            console.log("\n  Testing full workflow: generate → create...");
+            // Parse and clean the generated components
+            const components = JSON.parse(generatedComponents);
+            // Remove blocking_effect if present
+            if ("blocking_effect" in components) {
+                delete components.blocking_effect;
+            }
+            if ("blockingEffect" in components) {
+                delete components.blockingEffect;
+            }
+            const result = await client.callTool(createToolName, {
+                name: `${testRuleRecipeId}-generated`,
+                description: "Created from Sparkle-generated components",
+                disabled: true,
+                blocking_effect: "simulate",
+                components: JSON.stringify(components),
+            });
+            node_assert_1.default.ok(result, "Should create from generated components");
+            const typedResult = result;
+            node_assert_1.default.ok(typedResult.content[0], "Should have content");
+            node_assert_1.default.ok(typedResult.content[0].text.includes("created successfully"), "Should create successfully");
+            console.log("  ✓ Full generate → create workflow completed");
+        });
+    });
+});

package/dist/test/smoke.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/smoke.test.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+/**
+ * Smoke tests that don't require API access
+ * These verify basic module loading and exports
+ */
+(0, node_test_1.describe)("MCP Server Smoke Tests", () => {
+    (0, node_test_1.it)("should load config module", async () => {
+        // Don't actually import if no token is set
+        if (process.env["IMPART_AUTH_TOKEN"]) {
+            const { config } = await import("../config.js");
+            node_assert_1.default.ok(config.authToken, "Config should have auth token");
+            node_assert_1.default.ok(config.orgId, "Config should have org ID");
+            node_assert_1.default.ok(config.apiBase, "Config should have API base");
+            node_assert_1.default.ok(config.userAgent, "Config should have user agent");
+        }
+        else {
+            console.log("⚠️  Skipping config test (no IMPART_AUTH_TOKEN)");
+        }
+    });
+    (0, node_test_1.it)("should load types module", async () => {
+        // Just verify the module loads without errors
+        await import("../types.js");
+        node_assert_1.default.ok(true, "Types module should load");
+    });
+    (0, node_test_1.it)("should have valid package.json", async () => {
+        const pkg = await import("../../package.json", { with: { type: "json" } });
+        node_assert_1.default.strictEqual(pkg.default.name, "@impart-security/impart-mcp");
+        node_assert_1.default.ok(pkg.default.version, "Should have version");
+        node_assert_1.default.strictEqual(pkg.default.main, "dist/index.js");
+    });
+});