scanwarp 0.2.0 → 0.3.0

package/dist/dev/mcp-dev.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * MCP server for scanwarp dev mode.
+ *
+ * Connects to the running scanwarp dev instance via its local HTTP API
+ * and exposes monitoring data to AI coding tools (Cursor, Claude Code).
+ *
+ * Transport: stdio (Cursor and Claude Code connect via command execution).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevMcpServer = startDevMcpServer;
+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");
+// ─── HTTP client for the dev instance API ───
+async function fetchDevApi(port, path) {
+    const response = await fetch(`http://localhost:${port}${path}`);
+    if (!response.ok) {
+        throw new Error(`Dev API returned ${response.status}: ${await response.text()}`);
+    }
+    return response.json();
+}
+// ─── Tool implementations ───
+function formatUptime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds} seconds`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} minute${minutes !== 1 ? 's' : ''}`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m`;
+}
+async function getDevStatus(port) {
+    const data = await fetchDevApi(port, '/api/status');
+    const lines = [];
+    lines.push(`## Dev Mode Status\n`);
+    lines.push(`**Uptime:** ${formatUptime(data.uptime_ms)}`);
+    lines.push(`**Routes:** ${data.total_routes} total (${data.pages} pages, ${data.api_routes} API routes)`);
+    lines.push(`**Traces:** ${data.total_traces} traces, ${data.total_spans} spans`);
+    if (data.active_issues > 0) {
+        lines.push(`**Issues:** ${data.active_issues} active issues detected`);
+    }
+    else {
+        lines.push(`**Issues:** None detected`);
+    }
+    if (data.error_count > 0) {
+        lines.push(`**Errors:** ${data.error_count} errors recorded`);
+    }
+    const health = data.active_issues === 0 && data.error_count === 0 ? 'Healthy' : 'Issues detected';
+    lines.push(`\n**Overall:** ${health}`);
+    return lines.join('\n');
+}
+async function getDevIssues(port) {
+    const data = await fetchDevApi(port, '/api/issues');
+    if (data.issues.length === 0) {
+        return 'No active issues detected. Your app is running clean.';
+    }
+    const lines = [];
+    lines.push(`## Active Issues (${data.issues.length})\n`);
+    for (let i = 0; i < data.issues.length; i++) {
+        const issue = data.issues[i];
+        const icon = issue.severity === 'error' ? '🔴' : issue.severity === 'warning' ? '🟡' : '🔵';
+        lines.push(`### ${i + 1}. ${icon} [${issue.severity.toUpperCase()}] ${issue.message}`);
+        lines.push(`**Rule:** ${issue.rule}`);
+        if (issue.detail) {
+            lines.push(`**Detail:** ${issue.detail}`);
+        }
+        if (issue.suggestion) {
+            lines.push(`**Suggestion:** ${issue.suggestion}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+async function getDevRoutes(port) {
+    const data = await fetchDevApi(port, '/api/routes');
+    if (data.routes.length === 0) {
+        return 'No routes discovered. Make sure your dev server is running.';
+    }
+    const lines = [];
+    lines.push(`## Discovered Routes (${data.routes.length})\n`);
+    const statusIcon = {
+        healthy: '✅',
+        error: '❌',
+        slow: '⚠️',
+        unknown: '❓',
+    };
+    // Group by type
+    const pages = data.routes.filter((r) => r.type === 'page');
+    const apiRoutes = data.routes.filter((r) => r.type === 'api');
+    if (pages.length > 0) {
+        lines.push(`### Pages (${pages.length})\n`);
+        lines.push('| Route | Status | Response Time | Baseline |');
+        lines.push('|-------|--------|--------------|----------|');
+        for (const r of pages) {
+            const icon = statusIcon[r.status] || '❓';
+            const time = r.last_time_ms !== null ? `${r.last_time_ms}ms` : '-';
+            const baseline = r.baseline_ms !== null ? `${r.baseline_ms}ms` : '-';
+            const errNote = r.error_text ? ` (${r.error_text})` : '';
+            lines.push(`| ${r.path} | ${icon} ${r.status}${errNote} | ${time} | ${baseline} |`);
+        }
+        lines.push('');
+    }
+    if (apiRoutes.length > 0) {
+        lines.push(`### API Routes (${apiRoutes.length})\n`);
+        lines.push('| Route | Status | Response Time | Baseline |');
+        lines.push('|-------|--------|--------------|----------|');
+        for (const r of apiRoutes) {
+            const icon = statusIcon[r.status] || '❓';
+            const time = r.last_time_ms !== null ? `${r.last_time_ms}ms` : '-';
+            const baseline = r.baseline_ms !== null ? `${r.baseline_ms}ms` : '-';
+            const errNote = r.error_text ? ` (${r.error_text})` : '';
+            lines.push(`| ${r.path} | ${icon} ${r.status}${errNote} | ${time} | ${baseline} |`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+async function getSlowRoutes(port) {
+    const data = await fetchDevApi(port, '/api/slow-routes');
+    if (data.slow_routes.length === 0) {
+        return 'No slow routes detected. All routes are within their baseline performance.';
+    }
+    const lines = [];
+    lines.push(`## Slow Routes (${data.slow_routes.length})\n`);
+    for (const r of data.slow_routes) {
+        lines.push(`### ⚠️ ${r.path}`);
+        lines.push(`- **Current:** ${r.current_ms}ms`);
+        lines.push(`- **Baseline:** ${r.baseline_ms}ms`);
+        lines.push(`- **Slowdown:** ${r.ratio}x slower`);
+        if (r.bottleneck) {
+            lines.push(`- **Bottleneck:** \`${r.bottleneck.name}\` (${r.bottleneck.duration_ms}ms)`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+async function getRouteTraces(port, routePath, limit) {
+    const params = new URLSearchParams({ path: routePath, limit: String(limit) });
+    const data = await fetchDevApi(port, `/api/route-traces?${params}`);
+    if (data.traces.length === 0) {
+        return `No traces found for route \`${routePath}\`. The route may not have been hit yet.`;
+    }
+    const lines = [];
+    lines.push(`## Traces for \`${routePath}\` (${data.traces.length} most recent)\n`);
+    for (const trace of data.traces) {
+        const time = new Date(trace.timestamp).toLocaleTimeString();
+        const statusIcon = (trace.status_code && trace.status_code < 400) ? '✅' : '❌';
+        lines.push(`### ${statusIcon} ${trace.method} ${trace.route} — ${trace.duration_ms}ms (${time})`);
+        lines.push(`Trace ID: \`${trace.trace_id}\`\n`);
+        // Build waterfall
+        lines.push('```');
+        renderWaterfall(trace.spans, null, 0, lines, trace.spans[0]?.attributes?.['start_time'] || 0);
+        lines.push('```');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function renderWaterfall(spans, parentId, depth, lines, _baseTime) {
+    const children = spans.filter((s) => s.parent_span_id === parentId);
+    for (const span of children) {
+        const indent = '  '.repeat(depth);
+        const statusMark = span.status === 'ERROR' ? '✗' : '·';
+        const kindLabel = span.kind !== 'INTERNAL' ? ` [${span.kind}]` : '';
+        const dbStmt = span.attributes['db.statement'];
+        const detail = typeof dbStmt === 'string' ? ` — ${dbStmt.substring(0, 80)}` : '';
+        lines.push(`${indent}${statusMark} ${span.operation}${kindLabel}  ${span.duration_ms}ms  (${span.service})${detail}`);
+        renderWaterfall(spans, span.span_id, depth + 1, lines, _baseTime);
+    }
+}
+// ─── MCP Server setup ───
+async function startDevMcpServer(port) {
+    // Verify connection to dev instance
+    try {
+        await fetchDevApi(port, '/health');
+    }
+    catch {
+        console.error(`Error: Cannot connect to ScanWarp dev server on port ${port}`);
+        console.error(`Make sure 'scanwarp dev' is running first.`);
+        process.exit(1);
+    }
+    const server = new index_js_1.Server({
+        name: 'scanwarp-dev',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Register tools
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: 'get_dev_status',
+                    description: 'Get the current status of the ScanWarp dev mode monitoring — health, route count, issue count, uptime. Call this first to get an overview.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                {
+                    name: 'get_dev_issues',
+                    description: 'Get all active issues detected by the real-time analyzers — N+1 queries, unhandled errors, slow queries, missing error handling, slow external calls. Each issue includes severity, message, and a suggested fix.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                {
+                    name: 'get_dev_routes',
+                    description: 'Get all discovered routes with their current status (healthy/error/slow), last response time, and baseline comparison.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                {
+                    name: 'get_slow_routes',
+                    description: 'Get routes that are currently slower than their baseline, with bottleneck span info from traces. Useful for finding performance regressions.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+                {
+                    name: 'get_route_traces',
+                    description: 'Get recent traces for a specific route with the full span waterfall. Shows exactly what happens when a request hits a route — database queries, external API calls, processing time, errors.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            path: {
+                                type: 'string',
+                                description: 'The route path to get traces for (e.g., "/api/products", "/")',
+                            },
+                            limit: {
+                                type: 'number',
+                                description: 'Maximum number of recent traces to return (default: 5)',
+                            },
+                        },
+                        required: ['path'],
+                    },
+                },
+            ],
+        };
+    });
+    // Handle tool calls
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                case 'get_dev_status': {
+                    const result = await getDevStatus(port);
+                    return { content: [{ type: 'text', text: result }] };
+                }
+                case 'get_dev_issues': {
+                    const result = await getDevIssues(port);
+                    return { content: [{ type: 'text', text: result }] };
+                }
+                case 'get_dev_routes': {
+                    const result = await getDevRoutes(port);
+                    return { content: [{ type: 'text', text: result }] };
+                }
+                case 'get_slow_routes': {
+                    const result = await getSlowRoutes(port);
+                    return { content: [{ type: 'text', text: result }] };
+                }
+                case 'get_route_traces': {
+                    const { path: routePath, limit } = args;
+                    const result = await getRouteTraces(port, routePath, limit ?? 5);
+                    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,
+            };
+        }
+    });
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('ScanWarp dev MCP server running on stdio');
+}

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -14,6 +15,143 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types.js"), exports);
-__exportStar(require("./diagnoser.js"), exports);
-__exportStar(require("./correlator.js"), exports);
+const commander_1 = require("commander");
+const init_js_1 = require("./commands/init.js");
+const status_js_1 = require("./commands/status.js");
+const logs_js_1 = require("./commands/logs.js");
+const dev_js_1 = require("./commands/dev.js");
+const dev_mcp_js_1 = require("./commands/dev-mcp.js");
+const server_js_1 = require("./commands/server.js");
+const mcp_js_1 = require("./commands/mcp.js");
+const config_js_1 = require("./config.js");
+const program = new commander_1.Command();
+program
+    .name('scanwarp')
+    .description('Your AI writes your code. ScanWarp keeps it running.')
+    .version('0.3.0');
+program
+    .command('init')
+    .description('Initialize ScanWarp monitoring for your project')
+    .option('-s, --server <url>', 'ScanWarp server URL')
+    .option('-u, --url <url>', 'Production URL to monitor')
+    .option('--skip-vercel', 'Skip Vercel integration setup')
+    .option('--skip-mcp', 'Skip MCP configuration')
+    .option('--skip-instrumentation', 'Skip production instrumentation setup')
+    .action(async (options) => {
+    try {
+        // Use config as fallback for server URL
+        options.server = options.server || config_js_1.config.getServerUrl();
+        await (0, init_js_1.initCommand)(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('status')
+    .description('Check monitoring status')
+    .option('-s, --server <url>', 'ScanWarp server URL')
+    .action(async (options) => {
+    try {
+        options.server = options.server || config_js_1.config.getServerUrl();
+        await (0, status_js_1.statusCommand)(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('logs')
+    .alias('events')
+    .description('View recent events')
+    .option('-s, --server <url>', 'ScanWarp server URL')
+    .option('-f, --follow', 'Follow log output (live streaming)')
+    .option('-t, --type <type>', 'Filter by event type (error/slow/down/up)')
+    .option('--source <source>', 'Filter by source (monitor/vercel/stripe/supabase/github)')
+    .option('-l, --limit <number>', 'Number of events to show', '50')
+    .action(async (options) => {
+    try {
+        options.server = options.server || config_js_1.config.getServerUrl();
+        options.limit = parseInt(options.limit);
+        await (0, logs_js_1.logsCommand)(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('dev')
+    .description('Start your dev server with ScanWarp monitoring')
+    .option('-c, --command <cmd>', 'Dev server command to run (auto-detected if omitted)')
+    .option('-p, --port <number>', 'Port for local ScanWarp server')
+    .action(async (options) => {
+    try {
+        if (options.port)
+            options.port = parseInt(options.port);
+        await (0, dev_js_1.devCommand)(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('dev-mcp')
+    .description('Start MCP server for AI coding tools (connects to running scanwarp dev)')
+    .option('-p, --port <number>', 'Port of the running ScanWarp dev server', '3456')
+    .action(async (options) => {
+    try {
+        if (options.port)
+            options.port = parseInt(options.port);
+        await (0, dev_mcp_js_1.devMcpCommand)(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('server')
+    .alias('serve')
+    .description('Start ScanWarp server locally with SQLite (no Docker required)')
+    .option('-p, --port <number>', 'Port to listen on', '3000')
+    .option('--db-path <path>', 'SQLite database file path')
+    .action(async (options) => {
+    try {
+        if (options.port)
+            options.port = parseInt(options.port);
+        await (0, server_js_1.serverCommand)(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program
+    .command('incidents')
+    .description('View open incidents')
+    .option('-s, --server <url>', 'ScanWarp server URL', 'http://localhost:3000')
+    .action(() => {
+    console.log('Incidents command coming soon...');
+});
+program
+    .command('mcp')
+    .description('Start MCP server for AI coding tools (production monitoring)')
+    .option('-s, --server <url>', 'ScanWarp server URL')
+    .option('-t, --token <token>', 'API token for authentication')
+    .option('-p, --project <id>', 'Default project ID')
+    .action(async (options) => {
+    try {
+        await (0, mcp_js_1.mcpCommand)(options);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+program.parse();
+// Re-export from @scanwarp/core for backward compatibility
+__exportStar(require("@scanwarp/core"), exports);

package/dist/integrations/instrument.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupInstrumentation = setupInstrumentation;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const NEXTJS_INSTRUMENTATION = `export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    await import("@scanwarp/instrument");
+  }
+}
+`;
+async function setupInstrumentation(detected, serverUrl, projectId, shouldPrompt = true) {
+    let enableTracing = true;
+    if (shouldPrompt) {
+        const response = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'enableTracing',
+                message: 'Enable request tracing? (recommended)',
+                default: true,
+            },
+        ]);
+        enableTracing = response.enableTracing;
+    }
+    if (!enableTracing) {
+        console.log(chalk_1.default.gray('  Skipped\n'));
+        return;
+    }
+    console.log(chalk_1.default.gray('  Setting up production instrumentation for monitoring...\n'));
+    const cwd = process.cwd();
+    const isNextJs = detected.framework === 'Next.js';
+    const packageManager = detectPackageManager(cwd);
+    const serviceName = detected.projectName || 'my-app';
+    // Step 1: Install @scanwarp/instrument
+    const installSpinner = (0, ora_1.default)('Installing @scanwarp/instrument...').start();
+    try {
+        const installCmd = getInstallCommand(packageManager);
+        (0, child_process_1.execSync)(installCmd, { cwd, stdio: 'pipe' });
+        installSpinner.succeed('Installed @scanwarp/instrument');
+    }
+    catch {
+        installSpinner.fail('Failed to install @scanwarp/instrument');
+        console.log(chalk_1.default.yellow('  Run manually:'));
+        console.log(chalk_1.default.cyan(`  ${getInstallCommand(packageManager)}\n`));
+    }
+    // Step 2: Framework-specific setup
+    if (isNextJs) {
+        await setupNextJs(cwd);
+    }
+    else {
+        setupGenericNode();
+    }
+    // Step 3: Add env vars to .env.local or .env
+    const envPath = path_1.default.join(cwd, '.env');
+    const envLocalPath = path_1.default.join(cwd, '.env.local');
+    const targetEnv = fs_1.default.existsSync(envLocalPath) ? envLocalPath : envPath;
+    const envVars = {
+        SCANWARP_PROJECT_ID: projectId,
+        SCANWARP_SERVER: serverUrl,
+        SCANWARP_SERVICE_NAME: serviceName,
+    };
+    console.log(chalk_1.default.bold('\n  Environment variables:\n'));
+    for (const [key, val] of Object.entries(envVars)) {
+        console.log(chalk_1.default.cyan(`  ${key}=${val}`));
+    }
+    if (fs_1.default.existsSync(targetEnv)) {
+        const { writeEnv } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'writeEnv',
+                message: `Append to ${path_1.default.basename(targetEnv)}?`,
+                default: true,
+            },
+        ]);
+        if (writeEnv) {
+            appendEnvVars(targetEnv, envVars);
+        }
+    }
+    else {
+        // No .env file exists — create .env.local for Next.js, .env otherwise
+        const newEnvPath = isNextJs ? envLocalPath : envPath;
+        const { createEnv } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'createEnv',
+                message: `Create ${path_1.default.basename(newEnvPath)}?`,
+                default: true,
+            },
+        ]);
+        if (createEnv) {
+            const lines = Object.entries(envVars)
+                .map(([k, v]) => `${k}=${v}`)
+                .join('\n');
+            fs_1.default.writeFileSync(newEnvPath, `# ScanWarp tracing\n${lines}\n`);
+            console.log(chalk_1.default.green(`  ✓ Created ${path_1.default.basename(newEnvPath)}`));
+        }
+    }
+    // Step 4: Success message
+    console.log(chalk_1.default.bold.green('\n  ✓ Request tracing configured!\n'));
+    if (isNextJs) {
+        console.log(chalk_1.default.gray('  Traces will be sent automatically when your Next.js app starts.'));
+    }
+    else {
+        console.log(chalk_1.default.gray('  Add NODE_OPTIONS to your start command to enable tracing:'));
+        console.log(chalk_1.default.cyan(`\n  NODE_OPTIONS="--require @scanwarp/instrument" node ./dist/server.js\n`));
+        console.log(chalk_1.default.gray('  Or set it in your environment / package.json scripts:'));
+        console.log(chalk_1.default.cyan(`  "start": "NODE_OPTIONS='--require @scanwarp/instrument' node ./dist/server.js"`));
+    }
+    console.log('');
+}
+async function setupNextJs(cwd) {
+    // Step 2a: Create instrumentation.ts
+    const tsPath = path_1.default.join(cwd, 'instrumentation.ts');
+    const srcTsPath = path_1.default.join(cwd, 'src', 'instrumentation.ts');
+    const hasSrcDir = fs_1.default.existsSync(path_1.default.join(cwd, 'src'));
+    const targetPath = hasSrcDir ? srcTsPath : tsPath;
+    if (fs_1.default.existsSync(tsPath) || fs_1.default.existsSync(srcTsPath)) {
+        console.log(chalk_1.default.yellow('\n  ⚠ instrumentation.ts already exists'));
+        console.log(chalk_1.default.gray('  Add this to your register() function:\n'));
+        console.log(chalk_1.default.cyan('    await import("@scanwarp/instrument");'));
+    }
+    else {
+        const spinner = (0, ora_1.default)('Creating instrumentation.ts...').start();
+        fs_1.default.writeFileSync(targetPath, NEXTJS_INSTRUMENTATION);
+        const relPath = path_1.default.relative(cwd, targetPath);
+        spinner.succeed(`Created ${relPath}`);
+    }
+    // Step 2b: Patch next.config to enable instrumentationHook
+    await patchNextConfig(cwd);
+}
+async function patchNextConfig(cwd) {
+    // Find the next.config file
+    const candidates = [
+        'next.config.ts',
+        'next.config.mjs',
+        'next.config.js',
+    ];
+    let configPath = null;
+    for (const name of candidates) {
+        const fullPath = path_1.default.join(cwd, name);
+        if (fs_1.default.existsSync(fullPath)) {
+            configPath = fullPath;
+            break;
+        }
+    }
+    if (!configPath) {
+        console.log(chalk_1.default.yellow('  ⚠ No next.config file found'));
+        console.log(chalk_1.default.gray('  Add this to your next.config.js:\n'));
+        console.log(chalk_1.default.cyan('    experimental: { instrumentationHook: true }'));
+        return;
+    }
+    const content = fs_1.default.readFileSync(configPath, 'utf-8');
+    const configName = path_1.default.basename(configPath);
+    // Check if instrumentationHook is already set
+    if (content.includes('instrumentationHook')) {
+        console.log(chalk_1.default.green(`  ✓ ${configName} already has instrumentationHook`));
+        return;
+    }
+    // Try to patch the config automatically
+    // Look for an existing `experimental` block
+    if (content.includes('experimental')) {
+        // There's an existing experimental block — try to add instrumentationHook to it
+        const patched = content.replace(/experimental\s*:\s*\{/, 'experimental: {\n    instrumentationHook: true,');
+        if (patched !== content) {
+            fs_1.default.writeFileSync(configPath, patched);
+            console.log(chalk_1.default.green(`  ✓ Added instrumentationHook to ${configName}`));
+            return;
+        }
+    }
+    // Look for the config object to inject experimental block
+    // Match patterns like: `const nextConfig = {` or `module.exports = {` or `export default {`
+    const configObjectPattern = /((?:const\s+\w+\s*=|module\.exports\s*=|export\s+default)\s*\{)/;
+    const match = content.match(configObjectPattern);
+    if (match) {
+        const patched = content.replace(match[1], `${match[1]}\n  experimental: { instrumentationHook: true },`);
+        fs_1.default.writeFileSync(configPath, patched);
+        console.log(chalk_1.default.green(`  ✓ Added experimental.instrumentationHook to ${configName}`));
+        return;
+    }
+    // Could not auto-patch — instruct user
+    console.log(chalk_1.default.yellow(`  ⚠ Could not auto-patch ${configName}`));
+    console.log(chalk_1.default.gray('  Add this to your Next.js config:\n'));
+    console.log(chalk_1.default.cyan('    experimental: { instrumentationHook: true }\n'));
+}
+function setupGenericNode() {
+    console.log(chalk_1.default.bold('\n  Add tracing to your start command:\n'));
+    console.log(chalk_1.default.cyan(`  NODE_OPTIONS="--require @scanwarp/instrument" node ./dist/server.js`));
+    console.log('');
+    console.log(chalk_1.default.gray('  Or add as the first import in your entrypoint:'));
+    console.log(chalk_1.default.cyan('  import "@scanwarp/instrument";'));
+}
+function appendEnvVars(filePath, vars) {
+    const existing = fs_1.default.readFileSync(filePath, 'utf-8');
+    const additions = [];
+    for (const [key, val] of Object.entries(vars)) {
+        if (!existing.includes(key)) {
+            additions.push(`${key}=${val}`);
+        }
+    }
+    if (additions.length > 0) {
+        const separator = existing.endsWith('\n') ? '' : '\n';
+        fs_1.default.appendFileSync(filePath, `${separator}\n# ScanWarp tracing\n${additions.join('\n')}\n`);
+        console.log(chalk_1.default.green(`  ✓ Updated ${path_1.default.basename(filePath)}`));
+    }
+    else {
+        console.log(chalk_1.default.gray(`  ✓ Variables already present in ${path_1.default.basename(filePath)}`));
+    }
+}
+function detectPackageManager(cwd) {
+    if (fs_1.default.existsSync(path_1.default.join(cwd, 'bun.lockb')) || fs_1.default.existsSync(path_1.default.join(cwd, 'bun.lock')))
+        return 'bun';
+    if (fs_1.default.existsSync(path_1.default.join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs_1.default.existsSync(path_1.default.join(cwd, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+function getInstallCommand(pm) {
+    switch (pm) {
+        case 'bun':
+            return 'bun add @scanwarp/instrument';
+        case 'pnpm':
+            return 'pnpm add @scanwarp/instrument';
+        case 'yarn':
+            return 'yarn add @scanwarp/instrument';
+        case 'npm':
+            return 'npm install @scanwarp/instrument';
+    }
+}