scanwarp 0.1.0

package/dist/api.js

@@ -0,0 +1,58 @@
+"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;
+    serverUrl;
+    constructor(serverUrl = 'http://localhost:3000') {
+        this.serverUrl = serverUrl;
+        this.client = axios_1.default.create({
+            baseURL: serverUrl,
+            timeout: 10000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    async createProject(name) {
+        try {
+            // Check if project exists
+            const { data: existing } = await this.client.get('/projects', {
+                params: { name },
+            });
+            if (existing && existing.length > 0) {
+                return { id: existing[0].id };
+            }
+        }
+        catch {
+            // Project doesn't exist, will create
+        }
+        const { data } = await this.client.post('/projects', { name });
+        return data;
+    }
+    async createMonitor(projectId, url) {
+        const { data } = await this.client.post('/monitors', {
+            project_id: projectId,
+            url,
+            check_interval_seconds: 60,
+        });
+        return data.monitor;
+    }
+    async testConnection() {
+        try {
+            const { data } = await this.client.get('/health');
+            return data.status === 'ok';
+        }
+        catch {
+            return false;
+        }
+    }
+    async getWebhookUrl(path) {
+        return `${this.serverUrl}${path}`;
+    }
+}
+exports.ScanWarpAPI = ScanWarpAPI;

package/dist/commands/init.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const detector_js_1 = require("../detector.js");
+const api_js_1 = require("../api.js");
+const vercel_js_1 = require("../integrations/vercel.js");
+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 config_js_1 = require("../config.js");
+async function initCommand(options = {}) {
+    console.log(chalk_1.default.bold.cyan('\n🚀 ScanWarp Setup\n'));
+    console.log(chalk_1.default.gray('Your AI writes your code. ScanWarp keeps it running.\n'));
+    // Step 1: Auto-detect project
+    const spinner = (0, ora_1.default)('Detecting project...').start();
+    const detected = (0, detector_js_1.detectProject)();
+    spinner.succeed('Project detected');
+    // Print what was found
+    console.log(chalk_1.default.bold('\n✓ Project Details:'));
+    if (detected.framework) {
+        console.log(chalk_1.default.green(`  ✓ Framework: ${detected.framework}`));
+    }
+    if (detected.hosting) {
+        console.log(chalk_1.default.green(`  ✓ Hosting: ${detected.hosting}`));
+    }
+    if (detected.services.length > 0) {
+        console.log(chalk_1.default.green(`  ✓ Services: ${detected.services.join(', ')}`));
+    }
+    if (detected.projectName) {
+        console.log(chalk_1.default.green(`  ✓ Project: ${detected.projectName}`));
+    }
+    if (!detected.hasPackageJson) {
+        console.log(chalk_1.default.yellow('\n⚠ No package.json found. Are you in a Node.js project?'));
+    }
+    // Step 2: Get production URL
+    const defaultUrl = options.url || (0, detector_js_1.generateDefaultUrl)(detected);
+    const { productionUrl } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'productionUrl',
+            message: 'What is your production URL?',
+            default: defaultUrl,
+            validate: (input) => {
+                try {
+                    new URL(input);
+                    return true;
+                }
+                catch {
+                    return 'Please enter a valid URL (e.g., https://example.com)';
+                }
+            },
+        },
+    ]);
+    // Validate URL is reachable
+    const urlSpinner = (0, ora_1.default)('Checking if URL is reachable...').start();
+    try {
+        const response = await fetch(productionUrl, { method: 'HEAD' });
+        if (response.ok) {
+            urlSpinner.succeed(`URL is reachable (${response.status})`);
+        }
+        else {
+            urlSpinner.warn(`URL returned ${response.status} (continuing anyway)`);
+        }
+    }
+    catch (error) {
+        urlSpinner.warn('Could not reach URL (continuing anyway)');
+    }
+    // Step 3: Connect to ScanWarp server
+    const serverUrl = options.server || 'http://localhost:3000';
+    const api = new api_js_1.ScanWarpAPI(serverUrl);
+    const serverSpinner = (0, ora_1.default)('Connecting to ScanWarp server...').start();
+    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'));
+        process.exit(1);
+    }
+    serverSpinner.succeed(`Connected to ${serverUrl}`);
+    // Save server URL to config
+    config_js_1.config.setServerUrl(serverUrl);
+    // Step 4: Create project and monitor
+    const setupSpinner = (0, ora_1.default)('Setting up monitoring...').start();
+    try {
+        const project = await api.createProject(detected.projectName || 'my-app');
+        const monitor = await api.createMonitor(project.id, productionUrl);
+        // Save project ID to config
+        config_js_1.config.setProjectId(project.id);
+        setupSpinner.succeed('Monitoring configured');
+        console.log(chalk_1.default.green(`\n  ✓ Project ID: ${project.id}`));
+        console.log(chalk_1.default.green(`  ✓ Monitor ID: ${monitor.id}`));
+        console.log(chalk_1.default.green(`  ✓ Checking ${productionUrl} every 60 seconds\n`));
+    }
+    catch (error) {
+        setupSpinner.fail('Failed to set up monitoring');
+        console.error(chalk_1.default.red('\nError:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    // Step 5: Provider integrations
+    console.log(chalk_1.default.bold('\n📦 Provider Integrations\n'));
+    // Vercel
+    if (detected.hosting === 'Vercel' && !options.skipVercel) {
+        await (0, vercel_js_1.setupVercel)(api, detected);
+    }
+    // Stripe
+    if (detected.services.includes('Stripe')) {
+        await (0, stripe_js_1.setupStripe)(api);
+    }
+    // Supabase
+    if (detected.services.includes('Supabase')) {
+        await (0, supabase_js_1.setupSupabase)(api);
+    }
+    // Step 6: 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
+    console.log(chalk_1.default.bold('\n🔔 Notifications\n'));
+    await (0, notifications_js_1.setupNotifications)();
+    // Step 8: Summary
+    printSummary(api, productionUrl, detected);
+}
+function printSummary(api, url, _detected) {
+    console.log(chalk_1.default.bold.green('\n✨ Setup Complete!\n'));
+    console.log(chalk_1.default.bold('Your monitoring is now active:'));
+    console.log(chalk_1.default.gray(`  • Monitoring: ${url}`));
+    console.log(chalk_1.default.gray(`  • Check interval: Every 60 seconds`));
+    console.log(chalk_1.default.gray(`  • Dashboard: ${api.serverUrl}\n`));
+    console.log(chalk_1.default.bold('Next steps:'));
+    console.log(chalk_1.default.gray('  1. Deploy your app to trigger monitoring'));
+    console.log(chalk_1.default.gray('  2. Visit the dashboard to see events and incidents'));
+    console.log(chalk_1.default.gray('  3. Check your notifications for any alerts\n'));
+    console.log(chalk_1.default.bold('Useful commands:'));
+    console.log(chalk_1.default.gray('  • scanwarp status    - Check monitoring status'));
+    console.log(chalk_1.default.gray('  • scanwarp events    - View recent events'));
+    console.log(chalk_1.default.gray('  • scanwarp incidents - View open incidents\n'));
+    console.log(chalk_1.default.cyan('Happy shipping! 🚀\n'));
+}

package/dist/commands/logs.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logsCommand = logsCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_js_1 = require("../api.js");
+async function logsCommand(options = {}) {
+    const serverUrl = options.server || 'http://localhost:3000';
+    const api = new api_js_1.ScanWarpAPI(serverUrl);
+    const limit = options.limit || 50;
+    if (options.follow) {
+        await streamLogs(api, options);
+    }
+    else {
+        await fetchLogs(api, { ...options, limit });
+    }
+}
+async function fetchLogs(api, options) {
+    const spinner = (0, ora_1.default)('Fetching events...').start();
+    try {
+        const params = {
+            limit: options.limit,
+        };
+        if (options.type) {
+            params.type = options.type;
+        }
+        if (options.source) {
+            params.source = options.source;
+        }
+        const response = await api.client.get('/events', { params });
+        spinner.stop();
+        const events = response.data.events;
+        if (events.length === 0) {
+            console.log(chalk_1.default.yellow('\nNo events found.\n'));
+            return;
+        }
+        console.log(chalk_1.default.bold.cyan(`\n📋 Recent Events (${events.length})\n`));
+        // Reverse to show oldest first
+        events.reverse();
+        for (const event of events) {
+            printEvent(event);
+        }
+        console.log(chalk_1.default.gray(`\nShowing ${events.length} events`));
+        console.log(chalk_1.default.gray('Use --follow to stream live events\n'));
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch events');
+        console.log(chalk_1.default.red(`\nError: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        process.exit(1);
+    }
+}
+async function streamLogs(api, options) {
+    console.log(chalk_1.default.bold.cyan('\n📡 Streaming events (Ctrl+C to stop)\n'));
+    let lastEventId = null;
+    let isFirstFetch = true;
+    const poll = async () => {
+        try {
+            const params = {
+                limit: 20,
+            };
+            if (options.type) {
+                params.type = options.type;
+            }
+            if (options.source) {
+                params.source = options.source;
+            }
+            const response = await api.client.get('/events', { params });
+            const events = response.data.events;
+            // Filter to only show new events
+            let newEvents = events;
+            if (lastEventId) {
+                const lastIndex = events.findIndex((e) => e.id === lastEventId);
+                if (lastIndex > -1) {
+                    newEvents = events.slice(0, lastIndex);
+                }
+            }
+            if (newEvents.length > 0) {
+                if (!isFirstFetch) {
+                    // Show new events (they come in reverse chronological order)
+                    for (let i = newEvents.length - 1; i >= 0; i--) {
+                        printEvent(newEvents[i]);
+                    }
+                }
+                else {
+                    // On first fetch, show the most recent event
+                    printEvent(newEvents[0]);
+                    isFirstFetch = false;
+                }
+                lastEventId = newEvents[0].id;
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`\nError: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+    };
+    // Initial fetch
+    await poll();
+    // Poll every 2 seconds
+    const intervalId = setInterval(poll, 2000);
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+        clearInterval(intervalId);
+        console.log(chalk_1.default.gray('\n\nStopped streaming.\n'));
+        process.exit(0);
+    });
+}
+function printEvent(event) {
+    const timestamp = new Date(event.created_at).toLocaleTimeString();
+    const severityColor = getSeverityColor(event.severity);
+    const typeIcon = getTypeIcon(event.type);
+    const sourceTag = chalk_1.default.gray(`[${event.source}]`);
+    console.log(`${chalk_1.default.gray(timestamp)} ${typeIcon} ${chalk_1.default[severityColor](event.severity.toUpperCase().padEnd(8))} ${sourceTag} ${event.message}`);
+}
+function getSeverityColor(severity) {
+    switch (severity.toLowerCase()) {
+        case 'critical':
+            return 'red';
+        case 'high':
+            return 'red';
+        case 'medium':
+            return 'yellow';
+        case 'low':
+            return 'blue';
+        default:
+            return 'gray';
+    }
+}
+function getTypeIcon(type) {
+    switch (type.toLowerCase()) {
+        case 'error':
+            return '✗';
+        case 'down':
+            return '↓';
+        case 'up':
+            return '↑';
+        case 'slow':
+            return '⚠';
+        default:
+            return '•';
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_js_1 = require("../api.js");
+async function statusCommand(options = {}) {
+    const serverUrl = options.server || 'http://localhost:3000';
+    const api = new api_js_1.ScanWarpAPI(serverUrl);
+    const spinner = (0, ora_1.default)('Fetching status...').start();
+    try {
+        // Fetch monitors and incidents
+        const [monitorsResponse, incidentsResponse] = await Promise.all([
+            api.client.get('/monitors'),
+            api.client.get('/incidents', { params: { status: 'open' } }),
+        ]);
+        spinner.stop();
+        const monitors = monitorsResponse.data.monitors;
+        const incidents = incidentsResponse.data.incidents;
+        // Print header
+        console.log(chalk_1.default.bold.cyan('\n📊 ScanWarp Status\n'));
+        // Print monitors
+        if (monitors.length === 0) {
+            console.log(chalk_1.default.yellow('No monitors configured yet.'));
+            console.log(chalk_1.default.gray('Run "scanwarp init" to set up monitoring.\n'));
+            return;
+        }
+        console.log(chalk_1.default.bold('Monitors:\n'));
+        for (const monitor of monitors) {
+            const statusIcon = getStatusIcon(monitor.status);
+            const statusColor = getStatusColor(monitor.status);
+            const lastChecked = monitor.last_checked_at
+                ? formatRelativeTime(new Date(monitor.last_checked_at))
+                : 'never';
+            console.log(`  ${statusIcon} ${chalk_1.default[statusColor](monitor.status.toUpperCase().padEnd(7))} ${monitor.url}`);
+            console.log(chalk_1.default.gray(`     Last checked: ${lastChecked} • Every ${monitor.check_interval_seconds}s`));
+        }
+        // Print summary
+        const upCount = monitors.filter((m) => m.status === 'up').length;
+        const downCount = monitors.filter((m) => m.status === 'down').length;
+        const unknownCount = monitors.filter((m) => m.status === 'unknown').length;
+        console.log(chalk_1.default.bold(`\nSummary: ${monitors.length} total`));
+        if (upCount > 0)
+            console.log(chalk_1.default.green(`  ✓ ${upCount} up`));
+        if (downCount > 0)
+            console.log(chalk_1.default.red(`  ✗ ${downCount} down`));
+        if (unknownCount > 0)
+            console.log(chalk_1.default.gray(`  ? ${unknownCount} unknown`));
+        // Print active incidents
+        if (incidents.length > 0) {
+            console.log(chalk_1.default.bold.red(`\n⚠ ${incidents.length} Active Incident${incidents.length > 1 ? 's' : ''}:\n`));
+            for (const incident of incidents) {
+                const severityIcon = getSeverityIcon(incident.severity);
+                const severityColor = getSeverityColor(incident.severity);
+                console.log(`  ${severityIcon} ${chalk_1.default[severityColor](incident.severity.toUpperCase())} • ${incident.status}`);
+                if (incident.diagnosis_text) {
+                    const preview = incident.diagnosis_text.substring(0, 80);
+                    console.log(chalk_1.default.gray(`     ${preview}${incident.diagnosis_text.length > 80 ? '...' : ''}`));
+                }
+                console.log(chalk_1.default.gray(`     Created: ${formatRelativeTime(new Date(incident.created_at))}`));
+                console.log(chalk_1.default.gray(`     View: scanwarp incidents\n`));
+            }
+        }
+        else {
+            console.log(chalk_1.default.green('\n✓ No active incidents'));
+        }
+        console.log(chalk_1.default.gray(`\nServer: ${serverUrl}\n`));
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch status');
+        if (error instanceof Error && 'code' in error && error.code === 'ECONNREFUSED') {
+            console.log(chalk_1.default.red('\n✗ Could not connect to ScanWarp server'));
+            console.log(chalk_1.default.gray(`  Server: ${serverUrl}`));
+            console.log(chalk_1.default.yellow('  Make sure the server is running.\n'));
+        }
+        else {
+            console.log(chalk_1.default.red(`\nError: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        }
+        process.exit(1);
+    }
+}
+function getStatusIcon(status) {
+    switch (status) {
+        case 'up':
+            return chalk_1.default.green('●');
+        case 'down':
+            return chalk_1.default.red('●');
+        default:
+            return chalk_1.default.gray('●');
+    }
+}
+function getStatusColor(status) {
+    switch (status) {
+        case 'up':
+            return 'green';
+        case 'down':
+            return 'red';
+        default:
+            return 'gray';
+    }
+}
+function getSeverityIcon(severity) {
+    switch (severity.toLowerCase()) {
+        case 'critical':
+            return '🚨';
+        case 'warning':
+            return '⚠️';
+        default:
+            return 'ℹ️';
+    }
+}
+function getSeverityColor(severity) {
+    switch (severity.toLowerCase()) {
+        case 'critical':
+            return 'red';
+        case 'warning':
+            return 'yellow';
+        default:
+            return 'blue';
+    }
+}
+function formatRelativeTime(date) {
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffSecs = Math.floor(diffMs / 1000);
+    const diffMins = Math.floor(diffSecs / 60);
+    const diffHours = Math.floor(diffMins / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    if (diffSecs < 60)
+        return `${diffSecs}s ago`;
+    if (diffMins < 60)
+        return `${diffMins}m ago`;
+    if (diffHours < 24)
+        return `${diffHours}h ago`;
+    return `${diffDays}d ago`;
+}

package/dist/config.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.ConfigManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.scanwarp');
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
+class ConfigManager {
+    config = {};
+    constructor() {
+        this.load();
+    }
+    ensureConfigDir() {
+        if (!fs_1.default.existsSync(CONFIG_DIR)) {
+            fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+    }
+    load() {
+        try {
+            if (fs_1.default.existsSync(CONFIG_FILE)) {
+                const content = fs_1.default.readFileSync(CONFIG_FILE, 'utf-8');
+                this.config = JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load config:', error);
+            this.config = {};
+        }
+    }
+    save() {
+        try {
+            this.ensureConfigDir();
+            fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to save config:', error);
+        }
+    }
+    get(key) {
+        return this.config[key];
+    }
+    set(key, value) {
+        this.config[key] = value;
+        this.save();
+    }
+    getAll() {
+        return { ...this.config };
+    }
+    clear() {
+        this.config = {};
+        this.save();
+    }
+    getServerUrl() {
+        return this.config.serverUrl || 'http://localhost:3000';
+    }
+    setServerUrl(url) {
+        this.set('serverUrl', url);
+    }
+    getProjectId() {
+        return this.config.projectId;
+    }
+    setProjectId(id) {
+        this.set('projectId', id);
+    }
+    getApiToken() {
+        return this.config.apiToken;
+    }
+    setApiToken(token) {
+        this.set('apiToken', token);
+    }
+}
+exports.ConfigManager = ConfigManager;
+exports.config = new ConfigManager();