scanwarp 0.2.0 → 0.3.0

package/dist/mcp/api.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScanWarpAPI = void 0;
+const axios_1 = __importDefault(require("axios"));
+class ScanWarpAPI {
+    client;
+    constructor(serverUrl, apiToken) {
+        this.client = axios_1.default.create({
+            baseURL: serverUrl,
+            headers: apiToken
+                ? {
+                    Authorization: `Bearer ${apiToken}`,
+                }
+                : {},
+        });
+    }
+    async getMonitors(projectId) {
+        const response = await this.client.get('/monitors', {
+            params: { project_id: projectId },
+        });
+        return response.data.monitors || response.data;
+    }
+    async getIncidents(options) {
+        const response = await this.client.get('/incidents', {
+            params: {
+                project_id: options.projectId,
+                status: options.status,
+                severity: options.severity,
+                limit: options.limit,
+            },
+        });
+        return response.data.incidents || response.data;
+    }
+    async getIncident(incidentId) {
+        const response = await this.client.get(`/incidents/${incidentId}`);
+        return response.data;
+    }
+    async getEvents(options) {
+        const response = await this.client.get('/events', {
+            params: {
+                project_id: options.projectId,
+                type: options.type,
+                source: options.source,
+                severity: options.severity,
+                limit: options.limit,
+            },
+        });
+        return response.data;
+    }
+    async resolveIncident(incidentId) {
+        await this.client.post(`/incidents/${incidentId}/resolve`);
+    }
+    async getProviderStatus() {
+        const response = await this.client.get('/provider-status');
+        return response.data;
+    }
+    async getProject(name) {
+        const response = await this.client.get('/projects', {
+            params: { name },
+        });
+        const projects = response.data;
+        return projects.length > 0 ? projects[0] : null;
+    }
+    async getRecentTraces(options) {
+        const response = await this.client.get('/traces', {
+            params: {
+                project_id: options.projectId,
+                limit: options.limit,
+                status: options.status,
+            },
+        });
+        return response.data.traces || [];
+    }
+    async getTraceDetail(traceId) {
+        const response = await this.client.get(`/traces/${traceId}`);
+        return response.data.spans || [];
+    }
+    async getIncidentTraces(incidentId) {
+        const response = await this.client.get(`/incidents/${incidentId}/traces`);
+        return response.data.spans || [];
+    }
+}
+exports.ScanWarpAPI = ScanWarpAPI;

package/dist/mcp/index.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const api_js_1 = require("./api.js");
+const tools_js_1 = require("./tools.js");
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let serverUrl = process.env.SCANWARP_SERVER_URL || 'http://localhost:3000';
+    let apiToken = process.env.SCANWARP_API_TOKEN;
+    let projectId = process.env.SCANWARP_PROJECT_ID;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--server' && args[i + 1]) {
+            serverUrl = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--token' && args[i + 1]) {
+            apiToken = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--project' && args[i + 1]) {
+            projectId = args[i + 1];
+            i++;
+        }
+    }
+    return { serverUrl, apiToken, projectId };
+}
+const config = parseArgs();
+if (!config.serverUrl) {
+    console.error('❌ Error: SCANWARP_SERVER_URL is not configured. Pass --server or set SCANWARP_SERVER_URL env var.');
+    process.exit(1);
+}
+// Initialize API client
+const api = new api_js_1.ScanWarpAPI(config.serverUrl, config.apiToken);
+// Create MCP server
+const server = new index_js_1.Server({
+    name: 'scanwarp',
+    version: '0.1.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+// List available tools
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'get_app_status',
+                description: 'Get overall health status of your application. Shows monitor status, active incidents, and provider health. Returns a concise plain English summary.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID to check status for',
+                        },
+                    },
+                    required: ['project_id'],
+                },
+            },
+            {
+                name: 'get_incidents',
+                description: 'List incidents with their diagnosis and fix suggestions. Can filter by status (open/resolved) and severity (critical/warning/info).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID',
+                        },
+                        status: {
+                            type: 'string',
+                            description: 'Filter by status: open or resolved',
+                            enum: ['open', 'resolved'],
+                        },
+                        severity: {
+                            type: 'string',
+                            description: 'Filter by severity: critical, warning, or info',
+                            enum: ['critical', 'warning', 'info'],
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of incidents to return (default: 10)',
+                        },
+                    },
+                    required: ['project_id'],
+                },
+            },
+            {
+                name: 'get_incident_detail',
+                description: 'Get full details for a specific incident including root cause, timeline, correlated events, and the complete fix prompt ready to use.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        incident_id: {
+                            type: 'string',
+                            description: 'Incident ID',
+                        },
+                    },
+                    required: ['incident_id'],
+                },
+            },
+            {
+                name: 'get_events',
+                description: 'Get recent events with optional filters. Useful for understanding patterns and troubleshooting.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Filter by event type (error, slow, down, up)',
+                        },
+                        source: {
+                            type: 'string',
+                            description: 'Filter by source (monitor, vercel, stripe, github, supabase, provider-status)',
+                        },
+                        severity: {
+                            type: 'string',
+                            description: 'Filter by severity (critical, high, medium, low)',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of events to return (default: 20)',
+                        },
+                    },
+                    required: ['project_id'],
+                },
+            },
+            {
+                name: 'resolve_incident',
+                description: 'Mark an incident as resolved. This will trigger resolution notifications to configured channels.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        incident_id: {
+                            type: 'string',
+                            description: 'Incident ID to resolve',
+                        },
+                    },
+                    required: ['incident_id'],
+                },
+            },
+            {
+                name: 'get_fix_prompt',
+                description: 'Get JUST the fix prompt for an incident - the exact text that can be used in an AI coding tool to fix the issue.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        incident_id: {
+                            type: 'string',
+                            description: 'Incident ID',
+                        },
+                    },
+                    required: ['incident_id'],
+                },
+            },
+            {
+                name: 'get_recent_traces',
+                description: 'List recent request traces from OpenTelemetry instrumentation. Shows root spans with summary info (duration, span count, error status). Filter by status to find failing requests.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of traces to return (default: 10)',
+                        },
+                        status: {
+                            type: 'string',
+                            description: 'Filter by trace status: "error" for traces with errors, "ok" for successful traces',
+                            enum: ['error', 'ok'],
+                        },
+                    },
+                    required: ['project_id'],
+                },
+            },
+            {
+                name: 'get_trace_detail',
+                description: 'Get the full request waterfall for a specific trace. Shows all spans as an indented tree with timing, status, and error details. Use this to understand exactly what happened during a request.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        trace_id: {
+                            type: 'string',
+                            description: 'Trace ID to inspect',
+                        },
+                    },
+                    required: ['trace_id'],
+                },
+            },
+            {
+                name: 'get_trace_for_incident',
+                description: 'Get the most relevant trace data for an incident, combined with the AI diagnosis and fix prompt. Shows the request waterfall alongside the root cause analysis.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        incident_id: {
+                            type: 'string',
+                            description: 'Incident ID',
+                        },
+                    },
+                    required: ['incident_id'],
+                },
+            },
+        ],
+    };
+});
+// Handle tool calls
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'get_app_status': {
+                const projectId = args.project_id;
+                const result = await (0, tools_js_1.getAppStatus)(api, projectId);
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'get_incidents': {
+                const { project_id, status, severity, limit } = args;
+                const result = await (0, tools_js_1.getIncidents)(api, project_id, {
+                    status,
+                    severity,
+                    limit,
+                });
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'get_incident_detail': {
+                const { incident_id } = args;
+                const result = await (0, tools_js_1.getIncidentDetail)(api, incident_id);
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'get_events': {
+                const { project_id, type, source, severity, limit } = args;
+                const result = await (0, tools_js_1.getEvents)(api, project_id, {
+                    type,
+                    source,
+                    severity,
+                    limit,
+                });
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'resolve_incident': {
+                const { incident_id } = args;
+                const result = await (0, tools_js_1.resolveIncident)(api, incident_id);
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'get_fix_prompt': {
+                const { incident_id } = args;
+                const result = await (0, tools_js_1.getFixPrompt)(api, incident_id);
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'get_recent_traces': {
+                const { project_id, limit, status } = args;
+                const result = await (0, tools_js_1.getRecentTraces)(api, project_id, { limit, status });
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'get_trace_detail': {
+                const { trace_id } = args;
+                const result = await (0, tools_js_1.getTraceDetail)(api, trace_id);
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            case 'get_trace_for_incident': {
+                const { incident_id } = args;
+                const result = await (0, tools_js_1.getTraceForIncident)(api, incident_id);
+                return {
+                    content: [{ type: 'text', text: result }],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+});
+// List resources
+server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+    if (!config.projectId) {
+        return { resources: [] };
+    }
+    return {
+        resources: [
+            {
+                uri: 'scanwarp://status',
+                name: 'Application Status',
+                description: 'Current health status of your application including monitors, incidents, and provider status',
+                mimeType: 'text/plain',
+            },
+            {
+                uri: 'scanwarp://incidents',
+                name: 'Active Incidents',
+                description: 'List of currently active incidents requiring attention',
+                mimeType: 'text/plain',
+            },
+        ],
+    };
+});
+// Handle resource reads
+server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (!config.projectId) {
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'text/plain',
+                    text: 'Error: SCANWARP_PROJECT_ID not configured. Pass --project or set SCANWARP_PROJECT_ID env var.',
+                },
+            ],
+        };
+    }
+    try {
+        switch (uri) {
+            case 'scanwarp://status': {
+                const status = await (0, tools_js_1.getAppStatus)(api, config.projectId);
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: 'text/plain',
+                            text: status,
+                        },
+                    ],
+                };
+            }
+            case 'scanwarp://incidents': {
+                const incidents = await (0, tools_js_1.getIncidents)(api, config.projectId, {
+                    status: 'open',
+                });
+                return {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: 'text/plain',
+                            text: incidents,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown resource: ${uri}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'text/plain',
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('ScanWarp MCP server running on stdio');
+    console.error(`Connected to: ${config.serverUrl}`);
+    if (config.projectId) {
+        console.error(`Default project: ${config.projectId}`);
+    }
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});