scanwarp 0.2.0 → 0.3.0

package/dist/commands/init.js

@@ -14,6 +14,7 @@ const stripe_js_1 = require("../integrations/stripe.js");
 const supabase_js_1 = require("../integrations/supabase.js");
 const mcp_js_1 = require("../integrations/mcp.js");
 const notifications_js_1 = require("../integrations/notifications.js");
+const instrument_js_1 = require("../integrations/instrument.js");
 const config_js_1 = require("../config.js");
 async function initCommand(options = {}) {
     console.log(chalk_1.default.bold.cyan('\n🚀 ScanWarp Setup\n'));
@@ -79,8 +80,22 @@ async function initCommand(options = {}) {
     const isConnected = await api.testConnection();
     if (!isConnected) {
         serverSpinner.fail(`Could not connect to ${serverUrl}`);
-        console.log(chalk_1.default.yellow('\n⚠ Make sure the ScanWarp server is running.'));
-        console.log(chalk_1.default.gray('  Run: cd apps/server && pnpm dev\n'));
+        if (options.server) {
+            // User explicitly provided a server URL — just report the error
+            console.log(chalk_1.default.yellow('\n⚠ Make sure the ScanWarp server is running at that URL.\n'));
+        }
+        else {
+            // No server specified, localhost failed — suggest deployment options
+            console.log(chalk_1.default.yellow('\n⚠ No local ScanWarp server found.\n'));
+            console.log(chalk_1.default.bold('  Option 1: Deploy a hosted server (60 seconds)\n'));
+            console.log(chalk_1.default.gray('    Railway: https://railway.com/template/scanwarp'));
+            console.log(chalk_1.default.gray('    Render:  https://render.com/deploy?repo=https://github.com/scanwarp/scanwarp\n'));
+            console.log(chalk_1.default.gray('    Then run:'));
+            console.log(chalk_1.default.white('    npx scanwarp init --server https://your-server-url.up.railway.app\n'));
+            console.log(chalk_1.default.bold('  Option 2: Run locally\n'));
+            console.log(chalk_1.default.gray('    docker compose up -d'));
+            console.log(chalk_1.default.gray('    npx scanwarp init --server http://localhost:3000\n'));
+        }
         process.exit(1);
     }
     serverSpinner.succeed(`Connected to ${serverUrl}`);
@@ -88,9 +103,11 @@ async function initCommand(options = {}) {
     config_js_1.config.setServerUrl(serverUrl);
     // Step 4: Create project and monitor
     const setupSpinner = (0, ora_1.default)('Setting up monitoring...').start();
+    let projectId;
     try {
         const project = await api.createProject(detected.projectName || 'my-app');
         const monitor = await api.createMonitor(project.id, productionUrl);
+        projectId = project.id;
         // Save project ID to config
         config_js_1.config.setProjectId(project.id);
         setupSpinner.succeed('Monitoring configured');
@@ -117,15 +134,20 @@ async function initCommand(options = {}) {
     if (detected.services.includes('Supabase')) {
         await (0, supabase_js_1.setupSupabase)(api);
     }
-    // Step 6: MCP Configuration
+    // Step 6: Request Tracing
+    if (!options.skipInstrumentation) {
+        console.log(chalk_1.default.bold('\n📡 Request Tracing\n'));
+        await (0, instrument_js_1.setupInstrumentation)(detected, serverUrl, projectId, false); // false = don't prompt, install by default
+    }
+    // Step 7: MCP Configuration
     if (!options.skipMcp) {
         console.log(chalk_1.default.bold('\n🤖 MCP Configuration\n'));
         await (0, mcp_js_1.setupMCP)(serverUrl);
     }
-    // Step 7: Notifications
+    // Step 8: Notifications
     console.log(chalk_1.default.bold('\n🔔 Notifications\n'));
     await (0, notifications_js_1.setupNotifications)();
-    // Step 8: Summary
+    // Step 9: Summary
     printSummary(api, productionUrl, detected);
 }
 function printSummary(api, url, _detected) {

package/dist/commands/mcp.js

@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Production MCP server command
+ * Connects to a running ScanWarp server and exposes monitoring data to AI coding tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpCommand = mcpCommand;
+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("../mcp/api.js");
+const tools_js_1 = require("../mcp/tools.js");
+async function mcpCommand(options = {}) {
+    const serverUrl = options.server || process.env.SCANWARP_SERVER_URL || 'http://localhost:3000';
+    const apiToken = options.token || process.env.SCANWARP_API_TOKEN;
+    const projectId = options.project || process.env.SCANWARP_PROJECT_ID;
+    // Initialize API client
+    const api = new api_js_1.ScanWarpAPI(serverUrl, apiToken);
+    // Create MCP server
+    const server = new index_js_1.Server({
+        name: 'scanwarp',
+        version: '0.3.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 (!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 (!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, projectId);
+                    return {
+                        contents: [
+                            {
+                                uri,
+                                mimeType: 'text/plain',
+                                text: status,
+                            },
+                        ],
+                    };
+                }
+                case 'scanwarp://incidents': {
+                    const incidents = await (0, tools_js_1.getIncidents)(api, 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
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('ScanWarp MCP server running on stdio');
+    console.error(`Connected to: ${serverUrl}`);
+    if (projectId) {
+        console.error(`Default project: ${projectId}`);
+    }
+}

package/dist/commands/server.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverCommand = serverCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+async function serverCommand(options) {
+    const port = options.port || 3000;
+    // Determine SQLite database path
+    const scanwarpDir = path_1.default.join(os_1.default.homedir(), '.scanwarp');
+    if (!fs_1.default.existsSync(scanwarpDir)) {
+        fs_1.default.mkdirSync(scanwarpDir, { recursive: true });
+    }
+    const dbPath = options.dbPath || path_1.default.join(scanwarpDir, 'scanwarp.db');
+    // Find the server entry point
+    const serverEntry = findServerEntry();
+    if (!serverEntry) {
+        console.error(chalk_1.default.red('Could not find @scanwarp/server. Make sure you are running from the ScanWarp repo or have @scanwarp/server installed.'));
+        process.exit(1);
+    }
+    console.log('');
+    console.log(chalk_1.default.bold('ScanWarp Server'));
+    console.log('');
+    console.log(`  ${chalk_1.default.dim('Port:')}     ${port}`);
+    console.log(`  ${chalk_1.default.dim('Database:')} SQLite → ${dbPath}`);
+    console.log(`  ${chalk_1.default.dim('Entry:')}    ${serverEntry}`);
+    console.log('');
+    // Spawn the server process with SQLite config
+    const env = {
+        ...process.env,
+        DATABASE_TYPE: 'sqlite',
+        SQLITE_PATH: dbPath,
+        PORT: String(port),
+    };
+    const child = (0, child_process_1.spawn)(process.execPath, [serverEntry], {
+        env,
+        stdio: 'inherit',
+        cwd: path_1.default.dirname(serverEntry),
+    });
+    child.on('error', (err) => {
+        console.error(chalk_1.default.red(`Failed to start server: ${err.message}`));
+        process.exit(1);
+    });
+    child.on('exit', (code) => {
+        if (code !== null && code !== 0) {
+            console.error(chalk_1.default.red(`Server exited with code ${code}`));
+        }
+        process.exit(code ?? 0);
+    });
+    // Forward signals for graceful shutdown
+    const signals = ['SIGINT', 'SIGTERM'];
+    for (const sig of signals) {
+        process.on(sig, () => {
+            child.kill(sig);
+        });
+    }
+}
+function findServerEntry() {
+    // Strategy 1: Monorepo sibling (packages/cli → apps/server)
+    const cliDir = path_1.default.resolve(__dirname, '..', '..');
+    const monorepoServer = path_1.default.resolve(cliDir, '..', '..', 'apps', 'server', 'dist', 'index.js');
+    if (fs_1.default.existsSync(monorepoServer)) {
+        return monorepoServer;
+    }
+    // Strategy 2: Check for tsx + source (dev mode)
+    const monorepoServerSrc = path_1.default.resolve(cliDir, '..', '..', 'apps', 'server', 'src', 'index.ts');
+    if (fs_1.default.existsSync(monorepoServerSrc)) {
+        // Check if tsx is available
+        const tsxPath = path_1.default.resolve(cliDir, '..', '..', 'node_modules', '.bin', 'tsx');
+        if (fs_1.default.existsSync(tsxPath)) {
+            return monorepoServerSrc;
+        }
+    }
+    // Strategy 3: node_modules (installed as dependency)
+    try {
+        const resolved = require.resolve('@scanwarp/server');
+        if (fs_1.default.existsSync(resolved)) {
+            return resolved;
+        }
+    }
+    catch {
+        // Module not found
+    }
+    // Strategy 4: Walk up looking for node_modules/@scanwarp/server
+    let dir = cliDir;
+    for (let i = 0; i < 5; i++) {
+        const candidate = path_1.default.join(dir, 'node_modules', '@scanwarp', 'server', 'dist', 'index.js');
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}