genesis-ai-cli 14.9.0 → 14.11.0

package/dist/src/index.js

@@ -1438,6 +1438,65 @@ async function cmdAutonomous(subcommand, options) {
     console.log(c(`Unknown autonomous subcommand: ${subcommand}`, 'red'));
     console.log('Use: status, init, balance, approvals, approve, stop, agent, run');
 }
+/**
+ * v14.10: Observability stats command
+ */
+async function cmdStats(subcommand, options) {
+    const { getMCPMetrics } = await import('./mcp/index.js');
+    const { getMetricsRegistry } = await import('./observability/metrics.js');
+    console.log(c('\n=== GENESIS OBSERVABILITY STATS (v14.11) ===\n', 'bold'));
+    if (!subcommand || subcommand === 'mcp') {
+        const { mcpCallsTotal, mcpLatency, mcpConnectionsActive, mcpErrorsTotal, registry } = getMCPMetrics();
+        console.log(c('MCP Metrics:', 'cyan'));
+        console.log(`  Active connections: ${mcpConnectionsActive.get()}`);
+        console.log();
+        // Display Prometheus format
+        console.log(c('Prometheus Export:', 'dim'));
+        console.log(registry.toPrometheus());
+        return;
+    }
+    if (subcommand === 'prometheus') {
+        const registry = getMetricsRegistry('genesis');
+        console.log(registry.toPrometheus());
+        return;
+    }
+    if (subcommand === 'json') {
+        const { mcpCallsTotal, mcpLatency, mcpConnectionsActive, mcpErrorsTotal } = getMCPMetrics();
+        console.log(JSON.stringify({
+            mcp: {
+                activeConnections: mcpConnectionsActive.get(),
+            },
+            timestamp: new Date().toISOString(),
+        }, null, 2));
+        return;
+    }
+    if (subcommand === 'alert') {
+        // Test Slack alerts
+        const { getAlerter } = await import('./observability/alerting.js');
+        const alerter = getAlerter();
+        const slackUrl = process.env.SLACK_WEBHOOK_URL;
+        if (!slackUrl) {
+            console.log(c('Slack not configured.', 'yellow'));
+            console.log('Set SLACK_WEBHOOK_URL in your .env file to enable alerts.');
+            return;
+        }
+        console.log(c('Sending test alert to Slack...', 'cyan'));
+        const sent = await alerter.info('Genesis Test Alert', 'This is a test alert from Genesis observability system.', { labels: { test: 'true', version: '14.10' } });
+        if (sent) {
+            console.log(c('Test alert sent successfully!', 'green'));
+        }
+        else {
+            console.log(c('Failed to send test alert.', 'red'));
+        }
+        return;
+    }
+    console.log(c('Usage:', 'yellow'));
+    console.log('  genesis stats           - Show MCP stats');
+    console.log('  genesis stats mcp       - Show MCP stats');
+    console.log('  genesis stats prometheus - Prometheus format');
+    console.log('  genesis stats json      - JSON format');
+    console.log('  genesis stats alert     - Test Slack alert');
+}
 async function cmdHardware() {
     console.log(c('\n=== HARDWARE PROFILE ===\n', 'bold'));
     const hw = (0, index_js_1.detectHardware)();
@@ -1580,6 +1639,10 @@ ${c('Commands:', 'bold')}
   ${c('install', 'green')}               Install/update Genesis globally (npm)
   ${c('status', 'green')}                Show MCP servers status
   ${c('hardware', 'green')}              Show hardware profile & router config
+  ${c('stats', 'green')} [subcommand]    v14.10: Observability metrics
+    mcp              MCP call stats (default)
+    prometheus       Prometheus format
+    json             JSON format
   ${c('help', 'green')}                  Show this help
 
 ${c('MCP Servers (13):', 'bold')}
@@ -2046,6 +2109,10 @@ async function cmdInstall(options) {
 // Main
 // ============================================================================
 async function main() {
+    // v14.11: Install graceful shutdown handlers
+    const { installShutdownHandlers, registerDefaultHandlers } = await import('./lifecycle/shutdown.js');
+    installShutdownHandlers();
+    registerDefaultHandlers();
     const args = process.argv.slice(2);
     const command = args[0];
     if (!command || command === 'help' || command === '--help' || command === '-h') {
@@ -2203,6 +2270,10 @@ async function main() {
                 // v14.7: Autonomous bounty hunting
                 await cmdBounty(positional, options);
                 break;
+            case 'stats':
+                // v14.10: Observability stats
+                await cmdStats(positional, options);
+                break;
             default:
                 console.error(c(`Unknown command: ${command}`, 'red'));
                 console.log('Use "genesis help" for usage information');

package/dist/src/lifecycle/shutdown.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Graceful Shutdown Handler (v14.11)
+ *
+ * Ensures clean shutdown on SIGTERM/SIGINT:
+ * - Completes in-flight requests
+ * - Closes MCP connections
+ * - Flushes logs and metrics
+ * - Stops rate limiters
+ */
+type ShutdownHandler = () => Promise<void> | void;
+/**
+ * Register a shutdown handler
+ */
+export declare function onShutdown(handler: ShutdownHandler): void;
+/**
+ * Set shutdown timeout
+ */
+export declare function setShutdownTimeout(ms: number): void;
+/**
+ * Check if shutdown is in progress
+ */
+export declare function isShutdownInProgress(): boolean;
+/**
+ * Install signal handlers (call once at startup)
+ */
+export declare function installShutdownHandlers(): void;
+/**
+ * Register default Genesis shutdown handlers
+ */
+export declare function registerDefaultHandlers(): void;
+export {};

package/dist/src/lifecycle/shutdown.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Graceful Shutdown Handler (v14.11)
+ *
+ * Ensures clean shutdown on SIGTERM/SIGINT:
+ * - Completes in-flight requests
+ * - Closes MCP connections
+ * - Flushes logs and metrics
+ * - Stops rate limiters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onShutdown = onShutdown;
+exports.setShutdownTimeout = setShutdownTimeout;
+exports.isShutdownInProgress = isShutdownInProgress;
+exports.installShutdownHandlers = installShutdownHandlers;
+exports.registerDefaultHandlers = registerDefaultHandlers;
+const shutdownHandlers = [];
+let isShuttingDown = false;
+let shutdownTimeout = 30000; // 30s max shutdown time
+/**
+ * Register a shutdown handler
+ */
+function onShutdown(handler) {
+    shutdownHandlers.push(handler);
+}
+/**
+ * Set shutdown timeout
+ */
+function setShutdownTimeout(ms) {
+    shutdownTimeout = ms;
+}
+/**
+ * Check if shutdown is in progress
+ */
+function isShutdownInProgress() {
+    return isShuttingDown;
+}
+/**
+ * Execute graceful shutdown
+ */
+async function executeShutdown(signal) {
+    if (isShuttingDown) {
+        console.log(`[Shutdown] Already shutting down, ignoring ${signal}`);
+        return;
+    }
+    isShuttingDown = true;
+    console.log(`\n[Shutdown] Received ${signal}, starting graceful shutdown...`);
+    // Set a hard timeout
+    const forceExitTimer = setTimeout(() => {
+        console.error('[Shutdown] Timeout exceeded, forcing exit');
+        process.exit(1);
+    }, shutdownTimeout);
+    try {
+        // Run all handlers in reverse order (LIFO)
+        for (let i = shutdownHandlers.length - 1; i >= 0; i--) {
+            try {
+                await Promise.resolve(shutdownHandlers[i]());
+            }
+            catch (error) {
+                console.error(`[Shutdown] Handler ${i} failed:`, error);
+            }
+        }
+        console.log('[Shutdown] Graceful shutdown complete');
+        clearTimeout(forceExitTimer);
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('[Shutdown] Error during shutdown:', error);
+        clearTimeout(forceExitTimer);
+        process.exit(1);
+    }
+}
+/**
+ * Install signal handlers (call once at startup)
+ */
+function installShutdownHandlers() {
+    process.on('SIGTERM', () => executeShutdown('SIGTERM'));
+    process.on('SIGINT', () => executeShutdown('SIGINT'));
+    // Handle uncaught errors gracefully
+    process.on('uncaughtException', (error) => {
+        console.error('[Fatal] Uncaught exception:', error);
+        executeShutdown('uncaughtException').catch(() => process.exit(1));
+    });
+    process.on('unhandledRejection', (reason) => {
+        console.error('[Fatal] Unhandled rejection:', reason);
+        // Don't exit on unhandled rejection, just log it
+    });
+}
+/**
+ * Register default Genesis shutdown handlers
+ */
+function registerDefaultHandlers() {
+    // Close MCP connections
+    onShutdown(async () => {
+        try {
+            const { getMCPClient } = await import('../mcp/index.js');
+            const client = getMCPClient();
+            await client.close();
+            console.log('[Shutdown] MCP connections closed');
+        }
+        catch {
+            // MCP module may not be loaded
+        }
+    });
+    // Stop rate limiters
+    onShutdown(async () => {
+        try {
+            const { resetRateLimiter } = await import('./rate-limiter.js');
+            resetRateLimiter();
+            console.log('[Shutdown] Rate limiters stopped');
+        }
+        catch {
+            // Rate limiter may not be loaded
+        }
+    });
+    // Flush alerter
+    onShutdown(async () => {
+        try {
+            const { getAlerter } = await import('../observability/alerting.js');
+            const alerter = getAlerter();
+            await alerter.flush();
+            alerter.stop();
+            console.log('[Shutdown] Alerts flushed');
+        }
+        catch {
+            // Alerter may not be loaded
+        }
+    });
+}

package/dist/src/mcp/index.d.ts

@@ -30,6 +30,14 @@ export * from './parallel-executor.js';
 export * from './transformers.js';
 export * from './client-manager.js';
 import { MCPServerName } from '../types.js';
+import { Counter, Histogram } from '../observability/metrics.js';
+export declare function getMCPMetrics(): {
+    mcpCallsTotal: Counter;
+    mcpLatency: Histogram;
+    mcpConnectionsActive: import("../observability/metrics.js").Gauge;
+    mcpErrorsTotal: Counter;
+    registry: import("../observability/metrics.js").MetricsRegistry;
+};
 export type MCPMode = 'real' | 'simulated' | 'hybrid';
 export interface MCPCallOptions {
     timeout?: number;

package/dist/src/mcp/index.js

@@ -38,6 +38,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCP_SERVER_REGISTRY = exports.mcpClient = void 0;
+exports.getMCPMetrics = getMCPMetrics;
 exports.getMCPClient = getMCPClient;
 exports.resetMCPClient = resetMCPClient;
 exports.isSimulatedMode = isSimulatedMode;
@@ -57,6 +58,113 @@ __exportStar(require("./client-manager.js"), exports);
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const crypto_1 = require("crypto");
+const metrics_js_1 = require("../observability/metrics.js");
+const alerting_js_1 = require("../observability/alerting.js");
+const rate_limiter_js_1 = require("../lifecycle/rate-limiter.js");
+// ============================================================================
+// MCP Rate Limiters (v14.11 - Hardening)
+// Per-provider rate limits to respect API quotas
+// ============================================================================
+const PROVIDER_RATE_LIMITS = {
+    // OpenAI: 10,000 RPM (tier 2) = 166.67/sec
+    'openai': { maxTokens: 500, refillRate: 166 },
+    // Anthropic: 4,000 RPM = 66.67/sec
+    'anthropic': { maxTokens: 200, refillRate: 66 },
+    // GitHub: 5,000/hour = 1.39/sec
+    'github': { maxTokens: 50, refillRate: 1.4 },
+    // arXiv: 3/second
+    'arxiv': { maxTokens: 10, refillRate: 3 },
+    // Semantic Scholar: 100/second (generous)
+    'semantic-scholar': { maxTokens: 100, refillRate: 100 },
+    // Brave Search: 15/second
+    'brave-search': { maxTokens: 30, refillRate: 15 },
+    // Default for others: 10/second
+    'default': { maxTokens: 50, refillRate: 10 },
+};
+const providerRateLimiters = new Map();
+function getProviderRateLimiter(server) {
+    if (!providerRateLimiters.has(server)) {
+        const config = PROVIDER_RATE_LIMITS[server] || PROVIDER_RATE_LIMITS['default'];
+        providerRateLimiters.set(server, new rate_limiter_js_1.RateLimiter(config));
+    }
+    return providerRateLimiters.get(server);
+}
+// ============================================================================
+// MCP Metrics (v14.10 - Observability)
+// ============================================================================
+const metricsRegistry = (0, metrics_js_1.getMetricsRegistry)('genesis');
+const mcpCallsTotal = metricsRegistry.counter({
+    name: 'mcp_calls_total',
+    help: 'Total MCP tool calls',
+    labels: ['server', 'tool', 'status'],
+});
+const mcpLatency = metricsRegistry.histogram({
+    name: 'mcp_latency_seconds',
+    help: 'MCP call latency in seconds',
+    labels: ['server', 'tool'],
+    buckets: [0.1, 0.5, 1, 2, 5, 10, 30, 60],
+});
+const mcpConnectionsActive = metricsRegistry.gauge({
+    name: 'mcp_connections_active',
+    help: 'Active MCP server connections',
+});
+const mcpErrorsTotal = metricsRegistry.counter({
+    name: 'mcp_errors_total',
+    help: 'Total MCP errors by type',
+    labels: ['server', 'error_type'],
+});
+// Export for CLI stats
+function getMCPMetrics() {
+    return { mcpCallsTotal, mcpLatency, mcpConnectionsActive, mcpErrorsTotal, registry: metricsRegistry };
+}
+// ============================================================================
+// Security: Secret Sanitization (v14.11)
+// ============================================================================
+const SECRET_PATTERNS = [
+    /sk-[a-zA-Z0-9-_]{20,}/g, // OpenAI keys
+    /sk-ant-[a-zA-Z0-9-_]{20,}/g, // Anthropic keys
+    /ghp_[a-zA-Z0-9]{36}/g, // GitHub PAT
+    /gho_[a-zA-Z0-9]{36}/g, // GitHub OAuth
+    /[a-zA-Z0-9]{32,}/g, // Generic API keys (if looks like key)
+    /Bearer\s+[a-zA-Z0-9-_.]+/gi, // Bearer tokens
+    /password[=:]\s*["']?[^"'\s]+/gi, // Passwords in strings
+    /api[_-]?key[=:]\s*["']?[^"'\s]+/gi, // API keys in strings
+];
+function sanitizeSecrets(input) {
+    let sanitized = input;
+    for (const pattern of SECRET_PATTERNS) {
+        sanitized = sanitized.replace(pattern, (match) => {
+            // Keep first 4 chars for identification, redact rest
+            if (match.length > 8) {
+                return match.slice(0, 4) + '***REDACTED***';
+            }
+            return '***REDACTED***';
+        });
+    }
+    return sanitized;
+}
+function sanitizeObject(obj) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const lowerKey = key.toLowerCase();
+        // Redact known sensitive keys
+        if (lowerKey.includes('password') || lowerKey.includes('secret') ||
+            lowerKey.includes('token') || lowerKey.includes('key') ||
+            lowerKey.includes('auth') || lowerKey.includes('credential')) {
+            sanitized[key] = '***REDACTED***';
+        }
+        else if (typeof value === 'string') {
+            sanitized[key] = sanitizeSecrets(value);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            sanitized[key] = sanitizeObject(value);
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
 /**
  * Registry of MCP servers and how to spawn them.
  * These are the 18 MCP servers Genesis uses.
@@ -470,6 +578,8 @@ class MCPConnectionManager {
         if (this.logCalls) {
             console.log(`[MCP] Connected to ${server}`);
         }
+        // v14.10: Track active connections
+        mcpConnectionsActive.inc();
         return {
             client,
             transport,
@@ -480,37 +590,153 @@ class MCPConnectionManager {
     /**
      * Call a tool on an MCP server
      * v7.18: Added timeout wrapper for faster failure
+     * v14.10: Added structured logging with latency tracking
      */
     async callTool(server, tool, args) {
+        const startTime = performance.now();
+        const callId = `${server}.${tool}.${Date.now().toString(36)}`;
+        // v14.11: Rate limiting per provider
+        const rateLimiter = getProviderRateLimiter(server);
+        const rateCheck = rateLimiter.check(server);
+        if (!rateCheck.allowed) {
+            const waitMs = rateCheck.retryAfterMs || 1000;
+            if (this.logCalls) {
+                console.log(JSON.stringify({
+                    level: 'warn',
+                    time: Date.now(),
+                    msg: 'Rate limited, waiting',
+                    server,
+                    tool,
+                    waitMs,
+                }));
+            }
+            // Wait and retry
+            await new Promise(resolve => setTimeout(resolve, waitMs));
+        }
         const connection = await this.getConnection(server);
         if (this.logCalls) {
-            console.log(`[MCP] ${server}.${tool}(${JSON.stringify(args).slice(0, 100)}...)`);
+            // v14.11: Sanitize args to prevent secret leakage
+            const safeArgs = sanitizeObject(args);
+            console.log(JSON.stringify({
+                level: 'debug',
+                time: Date.now(),
+                msg: 'MCP call started',
+                callId,
+                server,
+                tool,
+                argsPreview: sanitizeSecrets(JSON.stringify(safeArgs).slice(0, 100)),
+            }));
         }
         // v7.18: Wrap call in timeout for faster failure (15s default, 30s/120s for heavy ops)
         const isHeavyOp = ['firecrawl_crawl', 'parse_paper_content', 'web_search'].includes(tool);
         const isImageGen = server === 'huggingface' || server === 'stability-ai' || tool.includes('generate') || tool.includes('infer');
         const callTimeout = isImageGen ? 120000 : isHeavyOp ? 30000 : 15000; // 120s for image gen (HF cold start)
-        const result = await Promise.race([
-            connection.client.callTool({
-                name: tool,
-                arguments: args,
-            }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP call to ${server}.${tool} timed out after ${callTimeout}ms`)), callTimeout)),
-        ]);
-        // Parse result content
-        const content = result.content;
-        if (content && content.length > 0) {
-            const first = content[0];
-            if (first.type === 'text' && typeof first.text === 'string') {
-                try {
-                    return JSON.parse(first.text);
+        // v14.11: Retry with exponential backoff (3 attempts)
+        const maxRetries = 3;
+        let lastError = null;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const result = await Promise.race([
+                    connection.client.callTool({
+                        name: tool,
+                        arguments: args,
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP call to ${server}.${tool} timed out after ${callTimeout}ms`)), callTimeout)),
+                ]);
+                const latencyMs = Math.round(performance.now() - startTime);
+                // v14.10: Track metrics
+                mcpCallsTotal.inc({ server, tool, status: 'success' });
+                mcpLatency.observe(latencyMs / 1000, { server, tool });
+                if (this.logCalls) {
+                    console.log(JSON.stringify({
+                        level: 'info',
+                        time: Date.now(),
+                        msg: 'MCP call completed',
+                        callId,
+                        server,
+                        tool,
+                        latencyMs,
+                        success: true,
+                        attempt: attempt + 1,
+                    }));
                 }
-                catch {
-                    return first.text;
+                // Parse result content
+                const content = result.content;
+                if (content && content.length > 0) {
+                    const first = content[0];
+                    if (first.type === 'text' && typeof first.text === 'string') {
+                        try {
+                            return JSON.parse(first.text);
+                        }
+                        catch {
+                            return first.text;
+                        }
+                    }
                 }
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                const errorMsg = lastError.message || '';
+                // v14.11: Only retry on transient errors (timeout, rate limit, server error)
+                const isRetryable = errorMsg.includes('timed out') ||
+                    errorMsg.includes('rate limit') ||
+                    errorMsg.includes('429') ||
+                    errorMsg.includes('503') ||
+                    errorMsg.includes('ECONNRESET');
+                if (!isRetryable || attempt === maxRetries - 1) {
+                    break; // Don't retry on permanent errors or last attempt
+                }
+                // Exponential backoff with jitter: 1s, 2s, 4s
+                const baseDelay = Math.pow(2, attempt) * 1000;
+                const jitter = Math.random() * baseDelay * 0.3;
+                const delay = baseDelay + jitter;
+                if (this.logCalls) {
+                    console.log(JSON.stringify({
+                        level: 'warn',
+                        time: Date.now(),
+                        msg: 'MCP call failed, retrying',
+                        callId,
+                        server,
+                        tool,
+                        attempt: attempt + 1,
+                        nextRetryMs: Math.round(delay),
+                        error: errorMsg,
+                    }));
+                }
+                await new Promise(resolve => setTimeout(resolve, delay));
             }
         }
-        return result;
+        // All retries failed
+        const latencyMs = Math.round(performance.now() - startTime);
+        const errorType = lastError?.message?.includes('timed out') ? 'timeout' : 'error';
+        // v14.10: Track error metrics
+        mcpCallsTotal.inc({ server, tool, status: 'error' });
+        mcpLatency.observe(latencyMs / 1000, { server, tool });
+        mcpErrorsTotal.inc({ server, error_type: errorType });
+        // v14.10: Send alert on MCP failures (if Slack configured)
+        try {
+            const alerter = (0, alerting_js_1.getAlerter)();
+            await alerter.warning(`MCP call failed: ${server}.${tool}`, lastError?.message || 'Unknown error', { labels: { server, tool, errorType, latencyMs: String(latencyMs), retries: String(maxRetries) } });
+        }
+        catch {
+            // Don't fail main operation if alerting fails
+        }
+        if (this.logCalls) {
+            console.log(JSON.stringify({
+                level: 'error',
+                time: Date.now(),
+                msg: 'MCP call failed after retries',
+                callId,
+                server,
+                tool,
+                latencyMs,
+                success: false,
+                retries: maxRetries,
+                error: lastError?.message,
+            }));
+        }
+        throw lastError || new Error(`MCP call to ${server}.${tool} failed`);
     }
     /**
      * List available tools on an MCP server (names only)
@@ -558,6 +784,8 @@ class MCPConnectionManager {
             }
             connection.connected = false;
             this.connections.delete(server);
+            // v14.10: Track active connections
+            mcpConnectionsActive.dec();
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "14.9.0",
+  "version": "14.11.0",
   "description": "Fully Autonomous AI System with RSI (Recursive Self-Improvement) - Self-funding, Self-deploying, Production Memory, A2A Protocol & Governance",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",