@impart-security/impart-mcp 0.1.0 → 0.1.1

package/README.md

@@ -82,6 +82,7 @@ To use Impart MCP with Claude Desktop, you'll need to configure the MCP server i
            "impart": {
                "command": "npx",
                "args": [
+                   "-y",
                    "@impart-security/impart-mcp"
                ],
                "env": {
@@ -117,7 +118,10 @@ Add the Impart MCP server configuration:
   "mcpServers": {
     "impart": {
       "command": "npx",
-      "args": ["@impart-security/impart-mcp"],
+      "args": [
+        "-y",
+        "@impart-security/impart-mcp"
+      ],
       "env": {
         "IMPART_AUTH_TOKEN": "your_auth_token"
       }
@@ -140,4 +144,3 @@ ISC
 
 For support, please contact Impart support or open an issue on GitHub. 
 
-

package/dist/client.d.ts

@@ -0,0 +1,4 @@
+import type { AxiosInstance, AxiosRequestConfig } from "axios";
+export declare const createClient: () => AxiosInstance;
+export declare const client: AxiosInstance;
+export declare function makeRequest<T>(config: AxiosRequestConfig): Promise<T>;

package/dist/client.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = exports.createClient = void 0;
+exports.makeRequest = makeRequest;
+const axios_1 = __importDefault(require("axios"));
+const config_js_1 = require("./config.js");
+// Create axios instance with default configuration
+const createClient = () => {
+    const client = axios_1.default.create({
+        baseURL: config_js_1.config.apiBase,
+        headers: {
+            Authorization: `Bearer ${config_js_1.config.authToken}`,
+            "User-Agent": config_js_1.config.userAgent,
+            "X-Impart-Org-ID": config_js_1.config.orgId,
+            "Content-Type": "application/json",
+        },
+    });
+    // Add request interceptor for error handling
+    client.interceptors.response.use((response) => response, (error) => {
+        if (error.response) {
+            const { status, data } = error.response;
+            throw new Error(`API request failed with status ${status}: ${JSON.stringify(data)}`);
+        }
+        throw error;
+    });
+    return client;
+};
+exports.createClient = createClient;
+// Export default client instance
+exports.client = (0, exports.createClient)();
+// Helper function to make API requests with proper typing
+async function makeRequest(config) {
+    const response = await exports.client.request(config);
+    return response.data;
+}

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export declare const config: {
+    readonly apiBase: string;
+    readonly authToken: string;
+    readonly orgId: string;
+    readonly userAgent: "impart-mcp/1.0.0";
+};

package/dist/config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const getOrgId_js_1 = require("./getOrgId.js");
+const { env } = process;
+if (!env["IMPART_AUTH_TOKEN"]) {
+    throw new Error("IMPART_AUTH_TOKEN environment variable is required");
+}
+// Export configuration
+exports.config = {
+    apiBase: env["IMPART_API_BASE"] ?? "https://api.impartsecurity.net/v0",
+    authToken: env["IMPART_AUTH_TOKEN"],
+    orgId: (0, getOrgId_js_1.getOrgId)(env["IMPART_AUTH_TOKEN"]),
+    userAgent: "impart-mcp/1.0.0",
+};

package/dist/getOrgId.d.ts

@@ -0,0 +1 @@
+export declare function getOrgId(accessToken: string): string;

package/dist/getOrgId.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrgId = getOrgId;
+function getOrgId(accessToken) {
+    let sub = "";
+    try {
+        const tokenData = accessToken.split(".")[1];
+        const decodedTokenRaw = atob(tokenData ?? "");
+        const decodedToken = JSON.parse(decodedTokenRaw);
+        if (decodedToken.sub) {
+            sub = decodedToken.sub;
+        }
+    }
+    catch {
+        throw new Error("Failed to parse access token");
+    }
+    if (!sub.startsWith("org:")) {
+        throw new Error("Access token is not for an organization");
+    }
+    return sub.substring(4);
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,1090 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const config_js_1 = require("./config.js");
+// Create server instance
+const server = new mcp_js_1.McpServer({
+    name: "impart-mcp",
+    version: "1.0.0",
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+// Helper function to validate page parameter
+function validatePage(page) {
+    return Math.max(1, page); // Ensure page is at least 1
+}
+// Helper function for making Impart API requests
+async function makeImpartRequest(endpoint, queryParams, method = "GET", body) {
+    const headers = {
+        "User-Agent": config_js_1.config.userAgent,
+        Accept: "application/security.impart.api.v0+json",
+        Authorization: `Bearer ${config_js_1.config.authToken}`,
+    };
+    if (body) {
+        headers["Content-Type"] = "application/json";
+    }
+    const url = new URL(`${config_js_1.config.apiBase}/orgs/${config_js_1.config.orgId}/${endpoint}`);
+    if (queryParams) {
+        Object.entries(queryParams).forEach(([key, value]) => {
+            if (value !== null && value !== undefined) {
+                if (Array.isArray(value)) {
+                    value.forEach((v) => url.searchParams.append(key, v.toString()));
+                }
+                else {
+                    url.searchParams.append(key, value.toString());
+                }
+            }
+        });
+    }
+    try {
+        const response = await fetch(url.toString(), {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : "",
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        console.error("Error making Impart request:", error);
+        return null;
+    }
+}
+// Register tools with consistent naming patterns
+server.tool("list_inspectors", "Get a list of inspectors for the organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum value: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ page, max_results }) => {
+    const queryParams = {
+        page: validatePage(page),
+        max_results,
+    };
+    const data = await makeImpartRequest("inspectors", queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch inspectors: Unknown error" },
+            ],
+        };
+    }
+    const inspectors = data.items || [];
+    if (inspectors.length === 0) {
+        return {
+            content: [
+                { type: "text", text: "No inspectors found for this organization." },
+            ],
+        };
+    }
+    const formattedInspectors = inspectors.map((inspector) => [
+        `ID: ${inspector.id}`,
+        `Version: ${inspector.version}`,
+        `Last Seen: ${inspector.last_seen}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedInspectors.join("\n") }],
+    };
+});
+// Rules Script Tools
+server.tool("list_rules_scripts", "Get a list of rules scripts for your Impart organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum value: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+    type: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter by type of rule script ('custom' or 'core')"),
+    exclude_src: zod_1.z
+        .boolean()
+        .default(false)
+        .describe("Whether to exclude the rule script source"),
+    exclude_revisions: zod_1.z
+        .boolean()
+        .default(false)
+        .describe("Whether to exclude rule script revisions"),
+    is_disabled: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter by disabled status ('true' or 'false')"),
+    label: zod_1.z.array(zod_1.z.string()).optional().describe("Filter by label slugs"),
+}, async ({ page, max_results, type, exclude_src, exclude_revisions, is_disabled, label, }) => {
+    const queryParams = {
+        page: validatePage(page),
+        max_results,
+        type,
+        exclude_src,
+        exclude_revisions,
+        is_disabled,
+        label,
+    };
+    const data = await makeImpartRequest("rules_scripts", queryParams);
+    if (!data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Unable to fetch rules scripts: Unknown error",
+                },
+            ],
+        };
+    }
+    const scripts = data.items || [];
+    if (scripts.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No rules scripts found for this organization.",
+                },
+            ],
+        };
+    }
+    const formattedScripts = scripts.map((script) => [
+        `ID: ${script.id}`,
+        `Name: ${script.name}`,
+        `Description: ${script.description ?? "N/A"}`,
+        `Type: ${script.type}`,
+        `Disabled: ${script.disabled}`,
+        `Blocking Effect: ${script.blocking_effect}`,
+        `Language: ${script.lang}`,
+        `Revision: ${script.revision}`,
+        `Labels: ${script.labels.join(", ")}`,
+        `Created By: ${script.created_by}`,
+        `Created At: ${script.created_at}`,
+        `Updated By: ${script.updated_by}`,
+        `Updated At: ${script.updated_at}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedScripts.join("\n") }],
+    };
+});
+server.tool("get_rules_script", "Get details of a specific rules script", {
+    rules_script_id: zod_1.z
+        .string()
+        .describe("The unique identifier of the rules script"),
+    revision: zod_1.z.number().optional().describe("The specific revision to fetch"),
+}, async ({ rules_script_id, revision }) => {
+    if (!rules_script_id) {
+        return {
+            content: [
+                { type: "text", text: "Error: rules_script_id is required." },
+            ],
+        };
+    }
+    const queryParams = revision ? { revision } : undefined;
+    const data = await makeImpartRequest(`rules_scripts/${rules_script_id}`, queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch rules script: Unknown error" },
+            ],
+        };
+    }
+    const formattedScript = [
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Type: ${data.type}`,
+        `Disabled: ${data.disabled}`,
+        `Blocking Effect: ${data.blocking_effect}`,
+        `Language: ${data.lang}`,
+        `Source Code: ${data.src ?? "N/A"}`,
+        `Autogenerated Explanation: ${data.autogenerated_explanation ?? "N/A"}`,
+        `Revision: ${data.revision}`,
+        `Dependencies: ${(data.dependencies ?? []).join(", ")}`,
+        `Labels: ${data.labels.join(", ")}`,
+        `Created By: ${data.created_by}`,
+        `Created At: ${data.created_at}`,
+        `Updated By: ${data.updated_by}`,
+        `Updated At: ${data.updated_at}`,
+        "---",
+        "Revisions:",
+    ];
+    data.revisions.forEach((revision) => {
+        formattedScript.push(`  Revision: ${revision.revision}`, `  Created By: ${revision.created_by}`, `  Created At: ${revision.created_at}`, "---");
+    });
+    return {
+        content: [{ type: "text", text: formattedScript.join("\n") }],
+    };
+});
+server.tool("create_rules_script", "Creates a new rules script for the organization", {
+    name: zod_1.z.string().describe("The name of the rules script"),
+    src: zod_1.z
+        .string()
+        .describe("The base64-encoded source code of the rules script"),
+    lang: zod_1.z
+        .string()
+        .default("assemblyscript")
+        .describe("The language of the script"),
+    description: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional description of the script"),
+    blocking_effect: zod_1.z
+        .string()
+        .default("block")
+        .describe("Effect when rule blocks"),
+    disabled: zod_1.z
+        .boolean()
+        .default(false)
+        .describe("Whether the script is disabled"),
+    labels: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe("Optional list of label slugs"),
+}, async ({ name, src, lang, description, blocking_effect, disabled, labels, }) => {
+    const payload = {
+        name,
+        src,
+        lang,
+        description,
+        blocking_effect,
+        disabled,
+        labels: labels ?? [],
+    };
+    const data = await makeImpartRequest("rules_scripts", undefined, "POST", payload);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to create rules script" }],
+        };
+    }
+    const formattedScript = [
+        "Rules script created successfully:",
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Language: ${data.lang}`,
+        `Blocking Effect: ${data.blocking_effect}`,
+        `Disabled: ${data.disabled}`,
+        `Labels: ${data.labels.join(", ")}`,
+        `Created At: ${data.created_at}`,
+        "---",
+    ].join("\n");
+    return {
+        content: [{ type: "text", text: formattedScript }],
+    };
+});
+server.tool("update_rules_script", "Updates an existing rules script", {
+    rules_script_id: zod_1.z
+        .string()
+        .describe("The ID of the rules script to update"),
+    name: zod_1.z.string().describe("The name of the rules script"),
+    src: zod_1.z.string().describe("The source code of the rules script"),
+    lang: zod_1.z
+        .string()
+        .default("assemblyscript")
+        .describe("The language of the script"),
+    description: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional description of the script"),
+    blocking_effect: zod_1.z
+        .string()
+        .default("block")
+        .describe("Effect when rule blocks"),
+    disabled: zod_1.z
+        .boolean()
+        .default(false)
+        .describe("Whether the script is disabled"),
+    labels: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe("Optional list of label slugs"),
+}, async ({ rules_script_id, name, src, lang, description, blocking_effect, disabled, labels, }) => {
+    if (!rules_script_id) {
+        return {
+            content: [
+                { type: "text", text: "Error: rules_script_id is required." },
+            ],
+        };
+    }
+    const payload = {
+        name,
+        src,
+        lang,
+        description,
+        blocking_effect,
+        disabled,
+        labels: labels ?? [],
+    };
+    const data = await makeImpartRequest(`rules_scripts/${rules_script_id}`, undefined, "PUT", payload);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to update rules script" }],
+        };
+    }
+    const formattedScript = [
+        "Rules script updated successfully:",
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Language: ${data.lang}`,
+        `Blocking Effect: ${data.blocking_effect}`,
+        `Disabled: ${data.disabled}`,
+        `Labels: ${data.labels.join(", ")}`,
+        `Updated At: ${data.updated_at}`,
+        "---",
+    ].join("\n");
+    return {
+        content: [{ type: "text", text: formattedScript }],
+    };
+});
+server.tool("write_rule_script", "Generate a rule script using Impart's LLM", {
+    query: zod_1.z.string().describe("Description of the rule you want to generate"),
+}, async ({ query }) => {
+    const payload = {
+        agent: "rule_generator",
+        query,
+    };
+    const data = await makeImpartRequest("sparkle", undefined, "POST", payload);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Error: Failed to generate rule script" },
+            ],
+        };
+    }
+    if (!data.output) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: No output received from the Sparkle API",
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            { type: "text", text: `Generated Rule Script:\n\n${data.output}` },
+        ],
+    };
+});
+server.tool("validate_rules_script", "Validate a rules script", {
+    src: zod_1.z
+        .string()
+        .describe("The base64-encoded source code of the rules script to validate"),
+    lang: zod_1.z
+        .string()
+        .default("assemblyscript")
+        .describe("The language of the rules script"),
+}, async ({ src, lang }) => {
+    if (!src) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: The source code (src) is required and must be base64 encoded.",
+                },
+            ],
+        };
+    }
+    const payload = {
+        src,
+        lang,
+    };
+    const data = await makeImpartRequest("rules_script_validate", undefined, "POST", payload);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to validate rules script" }],
+        };
+    }
+    const diagnostics = data.diagnostics || [];
+    if (diagnostics.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Validation successful! No errors or warnings found.",
+                },
+            ],
+        };
+    }
+    const formattedDiagnostics = diagnostics.map((diagnostic) => `${diagnostic.severity.toUpperCase()} at line ${diagnostic.line}, column ${diagnostic.column}: ${diagnostic.message}`);
+    return {
+        content: [
+            {
+                type: "text",
+                text: "Validation completed with the following issues:\n" +
+                    formattedDiagnostics.join("\n"),
+            },
+        ],
+    };
+});
+server.tool("list_endpoints", "Get an inventory of endpoints for the organization", {
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ max_results }) => {
+    const queryParams = { max_results };
+    const data = await makeImpartRequest("endpoints", queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch endpoints: Unknown error" },
+            ],
+        };
+    }
+    const endpoints = data.items || [];
+    if (endpoints.length === 0) {
+        return {
+            content: [
+                { type: "text", text: "No endpoints found for this organization." },
+            ],
+        };
+    }
+    const formattedEndpoints = endpoints.map((endpoint) => [
+        `ID: ${endpoint.id}`,
+        `Spec ID: ${endpoint.spec_id}`,
+        `Path: ${endpoint.path}`,
+        `Method: ${endpoint.method}`,
+        `Source: ${endpoint.source}`,
+        `Orphaned: ${endpoint.orphaned}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedEndpoints.join("\n") }],
+    };
+});
+server.tool("list_tags", "Get a list of tags for your Impart organization", {
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ max_results }) => {
+    const queryParams = { max_results };
+    const data = await makeImpartRequest("tags", queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch tags: Unknown error" },
+            ],
+        };
+    }
+    const tags = data.items || [];
+    if (tags.length === 0) {
+        return {
+            content: [
+                { type: "text", text: "No tags found for this organization." },
+            ],
+        };
+    }
+    const formattedTags = tags.map((tag) => [
+        `Name: ${tag.name}`,
+        `Display Name: ${tag.display_name}`,
+        `Type: ${tag.type}`,
+        `Description: ${tag.description ?? "N/A"}`,
+        `Risk Statement: ${tag.risk_statement ?? "N/A"}`,
+        `External URL: ${tag.external_url ?? "N/A"}`,
+        `Category: ${tag.category}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedTags.join("\n") }],
+    };
+});
+server.tool("get_tag_metrics", "Get timeseries metrics for one or more tags", {
+    metric: zod_1.z
+        .array(zod_1.z.string())
+        .default(["http-request.count"])
+        .describe("List of metric names"),
+    from_time: zod_1.z.string().default("-1d").describe("Start time"),
+    until_time: zod_1.z.string().default("-0h").describe("End time"),
+    spec_id: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe("Optional list of spec IDs"),
+    collection_id: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe("Optional list of collection IDs"),
+    endpoint_id: zod_1.z
+        .array(zod_1.z.string())
+        .optional()
+        .describe("Optional list of endpoint IDs"),
+    rollup: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional time window rollup resolution"),
+    unlearned: zod_1.z
+        .string()
+        .default("include")
+        .describe("How to handle unlearned endpoints"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ metric, from_time, until_time, spec_id, collection_id, endpoint_id, rollup, unlearned, max_results, }) => {
+    const queryParams = {
+        metric,
+        from: from_time,
+        until: until_time,
+        spec_id,
+        collection_id,
+        endpoint_id,
+        rollup,
+        unlearned,
+        max_results,
+    };
+    const data = await makeImpartRequest("timeseries/tags", queryParams);
+    if (!data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Unable to fetch timeseries metrics: Unknown error",
+                },
+            ],
+        };
+    }
+    const metrics = data.items || [];
+    if (metrics.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No timeseries metrics found for the specified tags.",
+                },
+            ],
+        };
+    }
+    const formattedMetrics = metrics.map((metric) => [
+        `Metric: ${metric.metric}`,
+        `From: ${metric.from}`,
+        `Until: ${metric.until}`,
+        `Increment: ${metric.inc} seconds`,
+        `Total Points: ${metric.total_points}`,
+        `Data: ${metric.data.join(", ")}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedMetrics.join("\n") }],
+    };
+});
+server.tool("list_observed_hosts", "Get a list of observed hosts for your Impart organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum value: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ page, max_results }) => {
+    const queryParams = {
+        page: validatePage(page),
+        max_results,
+    };
+    const data = await makeImpartRequest("observed_hosts", queryParams);
+    if (!data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Unable to fetch observed hosts: Unknown error",
+                },
+            ],
+        };
+    }
+    const hosts = data.items || [];
+    if (hosts.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No observed hosts found for this organization.",
+                },
+            ],
+        };
+    }
+    const formattedHosts = hosts.map((host) => [
+        `ID: ${host.id}`,
+        `Name: ${host.name || "N/A"}`,
+        `IP Address: ${host.ip_address || "N/A"}`,
+        `Last Seen: ${host.last_seen || "N/A"}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedHosts.join("\n") }],
+    };
+});
+server.tool("get_observed_host", "Get details of a specific observed host", {
+    observed_host_id: zod_1.z
+        .string()
+        .describe("The unique identifier of the observed host"),
+}, async ({ observed_host_id }) => {
+    if (!observed_host_id) {
+        return {
+            content: [
+                { type: "text", text: "Error: observed_host_id is required." },
+            ],
+        };
+    }
+    const data = await makeImpartRequest(`observed_hosts/${observed_host_id}`);
+    if (!data) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Unable to fetch observed host: Unknown error",
+                },
+            ],
+        };
+    }
+    const formattedHost = [
+        `ID: ${data.id}`,
+        `Hostname: ${data.hostname ?? "N/A"}`,
+        `Port: ${data.port ?? "N/A"}`,
+        `Created At: ${data.created_at ?? "N/A"}`,
+        `Observed At: ${data.observed_at ?? "N/A"}`,
+        `Suspected Healthcheck: ${data.suspected_healthcheck ?? false}`,
+        "---",
+        "Related IDs:",
+    ];
+    if (data.related_ids && data.related_ids.length > 0) {
+        data.related_ids.forEach((id) => formattedHost.push(`  - ${id}`));
+    }
+    else {
+        formattedHost.push("  No related IDs");
+    }
+    return {
+        content: [{ type: "text", text: formattedHost.join("\n") }],
+    };
+});
+server.tool("list_specs", "Get a list of specs for your Impart organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum value: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ page, max_results }) => {
+    const queryParams = {
+        page: validatePage(page),
+        max_results,
+    };
+    const data = await makeImpartRequest("specs", queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch specs: Unknown error" },
+            ],
+        };
+    }
+    const specs = data.items || [];
+    if (specs.length === 0) {
+        return {
+            content: [
+                { type: "text", text: "No specs found for this organization." },
+            ],
+        };
+    }
+    const formattedSpecs = specs.map((spec) => [
+        `ID: ${spec.id}`,
+        `Name: ${spec.name}`,
+        `Revision: ${spec.revision}`,
+        `Score: ${spec.score}`,
+        `Created By: ${spec.created_by}`,
+        `Created At: ${spec.created_at}`,
+        `Updated By: ${spec.updated_by}`,
+        `Updated At: ${spec.updated_at}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedSpecs.join("\n") }],
+    };
+});
+server.tool("get_spec", "Get details of a specific spec", {
+    spec_id: zod_1.z.string().describe("The unique identifier of the spec"),
+    revision: zod_1.z.number().optional().describe("The specific revision to fetch"),
+}, async ({ spec_id, revision }) => {
+    if (!spec_id) {
+        return {
+            content: [{ type: "text", text: "Error: spec_id is required." }],
+        };
+    }
+    const queryParams = revision ? { revision } : undefined;
+    const data = await makeImpartRequest(`specs/${spec_id}`, queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch spec: Unknown error" },
+            ],
+        };
+    }
+    const formattedSpec = [
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Revision: ${data.revision}`,
+        `Score: ${data.score}`,
+        `Created By: ${data.created_by}`,
+        `Created At: ${data.created_at}`,
+        `Updated By: ${data.updated_by}`,
+        `Updated At: ${data.updated_at}`,
+        "---",
+        "Revisions:",
+    ];
+    if (data.revisions && data.revisions.length > 0) {
+        data.revisions.forEach((revision) => {
+            formattedSpec.push(`  Revision: ${revision.revision}`, `  Created By: ${revision.created_by}`, `  Created At: ${revision.created_at}`, "---");
+        });
+    }
+    formattedSpec.push(`Specification (Base64 Encoded):\n${data.spec ?? "N/A"}`);
+    return {
+        content: [{ type: "text", text: formattedSpec.join("\n") }],
+    };
+});
+server.tool("list_api_bindings", "Get a list of API bindings for the organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum value: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ page, max_results }) => {
+    const queryParams = {
+        page: validatePage(page),
+        max_results,
+    };
+    const data = await makeImpartRequest("api_bindings", queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch API bindings: Unknown error" },
+            ],
+        };
+    }
+    const bindings = data.items || [];
+    if (bindings.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No API bindings found for this organization.",
+                },
+            ],
+        };
+    }
+    const formattedBindings = bindings.map((binding) => [
+        `ID: ${binding.id}`,
+        `Name: ${binding.name}`,
+        `Type: ${binding.type}`,
+        `Host: ${binding.host}`,
+        `Status: ${binding.status}`,
+        `Created At: ${binding.created_at}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedBindings.join("\n") }],
+    };
+});
+server.tool("create_api_binding", "Create a new API binding for the organization", {
+    name: zod_1.z.string().describe("The name of the API binding"),
+    binding_type: zod_1.z
+        .string()
+        .describe("The type of binding ('apiKey', 'basic', 'bearer', or 'oauth2')"),
+    host: zod_1.z.string().describe("The host to bind to"),
+    api_binding_source: zod_1.z
+        .string()
+        .describe("Location of the binding ('header', 'query', or 'cookie')"),
+    binding_value: zod_1.z.string().describe("The value of the binding"),
+    description: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional description of the binding"),
+    patch_operations: zod_1.z
+        .array(zod_1.z.record(zod_1.z.any()))
+        .optional()
+        .describe("Optional list of JSON patch operations"),
+    enable_learning: zod_1.z
+        .boolean()
+        .default(true)
+        .describe("Whether to enable learning for this binding"),
+}, async ({ name, binding_type, host, api_binding_source, binding_value, description, patch_operations, enable_learning, }) => {
+    const payload = {
+        name,
+        type: binding_type,
+        host,
+        source: api_binding_source,
+        value: binding_value,
+        description,
+        patch_operations: patch_operations ?? [],
+        enable_learning,
+    };
+    const data = await makeImpartRequest("api_bindings", undefined, "POST", payload);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to create API binding" }],
+        };
+    }
+    const formattedBinding = [
+        "API Binding created successfully:",
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Type: ${data.type}`,
+        `Host: ${data.host}`,
+        `Source: ${data.source}`,
+        `Status: ${data.status}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Learning Enabled: ${data.enable_learning}`,
+        `Created At: ${data.created_at}`,
+        "---",
+    ].join("\n");
+    return {
+        content: [{ type: "text", text: formattedBinding }],
+    };
+});
+server.tool("list_lists", "Get a list of lists for the organization", {
+    kind: zod_1.z.string().optional().describe("The list kind to query for"),
+    subkind: zod_1.z.string().optional().describe("The list subkind to query for"),
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ kind, subkind, page, max_results }) => {
+    const queryParams = {
+        kind,
+        subkind,
+        page: validatePage(page),
+        max_results,
+    };
+    const data = await makeImpartRequest("lists", queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch lists: Unknown error" },
+            ],
+        };
+    }
+    const lists = data.items || [];
+    if (lists.length === 0) {
+        return {
+            content: [
+                { type: "text", text: "No lists found for this organization." },
+            ],
+        };
+    }
+    const formattedLists = lists.map((list) => [
+        `ID: ${list.id}`,
+        `Name: ${list.name}`,
+        `Kind: ${list.kind}`,
+        `Subkind: ${list.subkind ?? "N/A"}`,
+        `Description: ${list.description ?? "N/A"}`,
+        `Created At: ${list.created_at}`,
+        `Updated At: ${list.updated_at}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedLists.join("\n") }],
+    };
+});
+server.tool("get_list_items", "Get items from a specific list", {
+    list_id: zod_1.z.string().describe("The ID of the list"),
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ list_id, page, max_results }) => {
+    if (!list_id) {
+        return {
+            content: [{ type: "text", text: "Error: list_id is required." }],
+        };
+    }
+    const queryParams = {
+        page: validatePage(page),
+        max_results,
+    };
+    const data = await makeImpartRequest(`lists/${list_id}/items`, queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch list items: Unknown error" },
+            ],
+        };
+    }
+    const items = data.items || [];
+    if (items.length === 0) {
+        return {
+            content: [{ type: "text", text: "No items found in this list." }],
+        };
+    }
+    const formattedItems = items.map((item) => [`Value: ${item.value}`, `Created At: ${item.created_at}`, "---"].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedItems.join("\n") }],
+    };
+});
+server.tool("create_list", "Creates a new list for the organization", {
+    name: zod_1.z.string().describe("Name of the list"),
+    kind: zod_1.z.string().describe("The kind of list"),
+    subkind: zod_1.z.string().optional().describe("Optional subkind of list"),
+    description: zod_1.z.string().optional().describe("Optional description"),
+    functionality: zod_1.z
+        .string()
+        .default("add/remove")
+        .describe("List functionality"),
+    items: zod_1.z
+        .array(zod_1.z.record(zod_1.z.any()))
+        .optional()
+        .describe("Optional initial list items"),
+}, async ({ name, kind, subkind, description, functionality, items }) => {
+    const payload = {
+        name,
+        kind,
+        subkind,
+        description,
+        functionality,
+        items: items ?? [],
+    };
+    const data = await makeImpartRequest("lists", undefined, "POST", payload);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to create list" }],
+        };
+    }
+    const formattedList = [
+        "List created successfully:",
+        `ID: ${data.id}`,
+        `Name: ${data.name}`,
+        `Kind: ${data.kind}`,
+        `Subkind: ${data.subkind ?? "N/A"}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Created At: ${data.created_at}`,
+        "---",
+    ].join("\n");
+    return {
+        content: [{ type: "text", text: formattedList }],
+    };
+});
+server.tool("update_list_items", "Updates items in a list", {
+    list_id: zod_1.z.string().describe("The ID of the list to update"),
+    items: zod_1.z
+        .array(zod_1.z.record(zod_1.z.any()))
+        .describe("The items to update in the list"),
+}, async ({ list_id, items }) => {
+    if (!list_id) {
+        return {
+            content: [{ type: "text", text: "Error: list_id is required." }],
+        };
+    }
+    const payload = { items };
+    const data = await makeImpartRequest(`lists/${list_id}/items`, undefined, "PATCH", payload);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to update list items" }],
+        };
+    }
+    return {
+        content: [{ type: "text", text: "List items updated successfully" }],
+    };
+});
+server.tool("create_label", "Creates a new label for the organization", {
+    name: zod_1.z.string().describe("Name of the label"),
+    description: zod_1.z.string().optional().describe("Optional description"),
+    color: zod_1.z.string().default("gray").describe("Label color"),
+}, async ({ name, description, color }) => {
+    const payload = {
+        name,
+        description,
+        color,
+    };
+    const data = await makeImpartRequest("labels", undefined, "POST", payload);
+    if (!data) {
+        return {
+            content: [{ type: "text", text: "Failed to create label" }],
+        };
+    }
+    const formattedLabel = [
+        "Label created successfully:",
+        `Slug: ${data.slug}`,
+        `Name: ${data.name}`,
+        `Description: ${data.description ?? "N/A"}`,
+        `Color: ${data.color}`,
+        `Created At: ${data.created_at}`,
+        "---",
+    ].join("\n");
+    return {
+        content: [{ type: "text", text: formattedLabel }],
+    };
+});
+server.tool("list_labels", "Get a list of labels for the organization", {
+    page: zod_1.z
+        .number()
+        .default(1)
+        .describe("The page of results to return (minimum: 1)"),
+    max_results: zod_1.z
+        .number()
+        .default(100)
+        .describe("The maximum number of results to return"),
+}, async ({ page, max_results }) => {
+    const queryParams = {
+        page: validatePage(page),
+        max_results,
+    };
+    const data = await makeImpartRequest("labels", queryParams);
+    if (!data) {
+        return {
+            content: [
+                { type: "text", text: "Unable to fetch labels: Unknown error" },
+            ],
+        };
+    }
+    const labels = data.items || [];
+    if (labels.length === 0) {
+        return {
+            content: [
+                { type: "text", text: "No labels found for this organization." },
+            ],
+        };
+    }
+    const formattedLabels = labels.map((label) => [
+        `Slug: ${label.slug}`,
+        `Name: ${label.name}`,
+        `Description: ${label.description ?? "N/A"}`,
+        `Color: ${label.color}`,
+        `Created At: ${label.created_at}`,
+        "---",
+    ].join("\n"));
+    return {
+        content: [{ type: "text", text: formattedLabels.join("\n") }],
+    };
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("Impart MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/types.d.ts

@@ -0,0 +1,158 @@
+export interface BaseResponse {
+    error?: string;
+}
+export interface RulesScript {
+    id: string;
+    name: string;
+    description?: string;
+    type: string;
+    disabled: boolean;
+    blocking_effect: string;
+    lang: string;
+    src?: string;
+    revision: number;
+    labels: string[];
+    created_by: string;
+    created_at: string;
+    updated_by: string;
+    updated_at: string;
+    autogenerated_explanation?: string;
+    dependencies?: string[];
+}
+export interface RulesScriptRevision {
+    revision: number;
+    created_by: string;
+    created_at: string;
+}
+export interface RulesScriptResponse extends BaseResponse {
+    items: RulesScript[];
+}
+export interface RulesScriptDetailResponse extends RulesScript, BaseResponse {
+    revisions: RulesScriptRevision[];
+}
+export interface Inspector {
+    id: string;
+    version: string;
+    last_seen: string;
+}
+export interface InspectorsResponse extends BaseResponse {
+    items: Inspector[];
+}
+export interface ObservedHost {
+    id: string;
+    name: string;
+    ip_address: string;
+    last_seen: string;
+    hostname?: string;
+    port?: string;
+    created_at?: string;
+    observed_at?: string;
+    suspected_healthcheck?: boolean;
+    related_ids?: string[];
+}
+export interface ObservedHostsResponse extends BaseResponse {
+    items: ObservedHost[];
+}
+export interface Spec {
+    id: string;
+    name: string;
+    revision: number;
+    score: number;
+    created_by: string;
+    created_at: string;
+    updated_by: string;
+    updated_at: string;
+    spec?: string;
+}
+export interface SpecRevision {
+    revision: number;
+    created_by: string;
+    created_at: string;
+}
+export interface SpecsResponse extends BaseResponse {
+    items: Spec[];
+}
+export interface SpecDetailResponse extends Spec, BaseResponse {
+    revisions: SpecRevision[];
+}
+export interface ApiBinding {
+    id: string;
+    name: string;
+    type: string;
+    host: string;
+    status: string;
+    created_at: string;
+    source: string;
+    value: string;
+    description?: string;
+    enable_learning: boolean;
+    patch_operations?: Record<string, unknown>[];
+}
+export interface ApiBindingsResponse extends BaseResponse {
+    items: ApiBinding[];
+}
+export interface List {
+    id: string;
+    name: string;
+    kind: string;
+    subkind?: string;
+    description?: string;
+    functionality: string;
+    created_at: string;
+    updated_at: string;
+    items?: Record<string, unknown>[];
+}
+export interface ListsResponse extends BaseResponse {
+    items: List[];
+}
+export interface ListItem {
+    value: string;
+    created_at: string;
+}
+export interface ListItemsResponse extends BaseResponse {
+    items: ListItem[];
+}
+export interface Label {
+    slug: string;
+    name: string;
+    description?: string;
+    color: string;
+    created_at: string;
+}
+export interface LabelsResponse extends BaseResponse {
+    items: Label[];
+}
+export interface Tag {
+    name: string;
+    display_name: string;
+    type: string;
+    description?: string;
+    risk_statement?: string;
+    external_url?: string;
+    category: string;
+}
+export interface TagsResponse extends BaseResponse {
+    items: Tag[];
+}
+export interface TimeseriesMetric {
+    metric: string;
+    from: string;
+    until: string;
+    inc: number;
+    total_points: number;
+    data: number[];
+}
+export interface TimeseriesResponse extends BaseResponse {
+    items: TimeseriesMetric[];
+}
+export interface Endpoint {
+    id: string;
+    spec_id: string;
+    path: string;
+    method: string;
+    source: string;
+    orphaned: boolean;
+}
+export interface EndpointsResponse extends BaseResponse {
+    items: Endpoint[];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@impart-security/impart-mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Model Context Protocol (MCP) implementation for interacting with Impart's API",
   "author": "Impart Security",
   "license": "Apache-2.0",