reflexive 0.1.0

package/demo-app.js

@@ -0,0 +1,210 @@
+import http from 'http';
+
+const PORT = 8080;
+let requestCount = 0;
+const visitors = new Map();
+let dbConnected = true;
+let authFailures = 0;
+
+const server = http.createServer((req, res) => {
+  requestCount++;
+  const timestamp = new Date().toISOString();
+
+  console.log(`[${timestamp}] ${req.method} ${req.url}`);
+
+  // Track visitors by IP
+  const ip = req.socket.remoteAddress;
+  visitors.set(ip, (visitors.get(ip) || 0) + 1);
+
+  if (req.url === '/') {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(`
+      <h1>Demo App</h1>
+      <p>Request #${requestCount}</p>
+      <h3>Basic Endpoints</h3>
+      <ul>
+        <li><a href="/status">/status</a> - Server stats</li>
+        <li><a href="/slow">/slow</a> - Slow endpoint (2s delay)</li>
+        <li><a href="/error">/error</a> - Throws an error</li>
+        <li><a href="/memory">/memory</a> - Memory usage</li>
+      </ul>
+      <h3>Watch Trigger Demos</h3>
+      <ul>
+        <li><a href="/login?user=admin&pass=wrong">/login</a> - Auth failure (try wrong password)</li>
+        <li><a href="/login?user=admin&pass=secret">/login</a> - Auth success</li>
+        <li><a href="/db-query">/db-query</a> - Simulated DB query (may fail randomly)</li>
+        <li><a href="/api/users">/api/users</a> - API endpoint with rate limiting</li>
+        <li><a href="/webhook">/webhook</a> - Incoming webhook simulation</li>
+        <li><a href="/toggle-db">/toggle-db</a> - Toggle DB connection state</li>
+      </ul>
+    `);
+  }
+  else if (req.url === '/status') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      uptime: process.uptime(),
+      requests: requestCount,
+      visitors: visitors.size,
+      pid: process.pid
+    }, null, 2));
+  }
+  else if (req.url === '/slow') {
+    console.log('Starting slow operation...');
+    setTimeout(() => {
+      console.log('Slow operation complete');
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('Done after 2 seconds');
+    }, 2000);
+  }
+  else if (req.url === '/error') {
+    console.error('About to throw an error!');
+    throw new Error('Intentional error for testing');
+  }
+  else if (req.url === '/memory') {
+    const mem = process.memoryUsage();
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      heapUsed: `${Math.round(mem.heapUsed / 1024 / 1024)}MB`,
+      heapTotal: `${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
+      rss: `${Math.round(mem.rss / 1024 / 1024)}MB`
+    }, null, 2));
+  }
+  // ============ Watch Trigger Demo Endpoints ============
+  else if (req.url.startsWith('/login')) {
+    const params = new URL(req.url, `http://localhost:${PORT}`).searchParams;
+    const user = params.get('user') || 'unknown';
+    const pass = params.get('pass') || '';
+
+    if (pass === 'secret') {
+      console.log(`[AUTH] ✓ Login successful for user: ${user}`);
+      authFailures = 0;
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, user, message: 'Welcome!' }));
+    } else {
+      authFailures++;
+      console.error(`[AUTH] ✗ Login FAILED for user: ${user} (attempt #${authFailures})`);
+      if (authFailures >= 3) {
+        console.error(`[AUTH] ⚠️ SECURITY WARNING: Multiple failed login attempts for user: ${user}`);
+      }
+      res.writeHead(401, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: false, error: 'Invalid credentials' }));
+    }
+  }
+  else if (req.url === '/db-query') {
+    if (!dbConnected) {
+      console.error('[DATABASE] ✗ Connection failed: Database is not connected');
+      res.writeHead(503, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Database unavailable' }));
+      return;
+    }
+    // Simulate random query performance
+    const queryTime = Math.random() * 500;
+    if (queryTime > 400) {
+      console.warn(`[DATABASE] ⚠️ Slow query detected: ${queryTime.toFixed(0)}ms`);
+    }
+    if (Math.random() < 0.2) {
+      console.error('[DATABASE] ✗ Query failed: Deadlock detected');
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Query failed - deadlock' }));
+    } else {
+      console.log(`[DATABASE] ✓ Query completed in ${queryTime.toFixed(0)}ms`);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, rows: Math.floor(Math.random() * 100), queryTime: queryTime.toFixed(0) + 'ms' }));
+    }
+  }
+  else if (req.url.startsWith('/api/')) {
+    const visitorCount = visitors.get(ip) || 0;
+    if (visitorCount > 10) {
+      console.warn(`[RATE_LIMIT] ⚠️ Rate limit exceeded for IP: ${ip} (${visitorCount} requests)`);
+      res.writeHead(429, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Too many requests', retryAfter: 60 }));
+    } else {
+      console.log(`[API] Request from ${ip} to ${req.url}`);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ users: ['alice', 'bob', 'charlie'] }));
+    }
+  }
+  else if (req.url === '/webhook') {
+    const eventType = ['payment.success', 'payment.failed', 'user.created', 'subscription.hacked'][Math.floor(Math.random() * 4)];
+    console.log(`[WEBHOOK] Received event: ${eventType}`);
+    if (eventType === 'payment.failed') {
+      console.error(`[WEBHOOK] ⚠️ Payment failure webhook received - needs attention!`);
+    }
+    if (eventType === 'subscription.hacked') {
+      console.warn(`[WEBHOOK] Security alert: subscription hacked`);
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ received: true, event: eventType }));
+  }
+  else if (req.url === '/toggle-db') {
+    dbConnected = !dbConnected;
+    if (dbConnected) {
+      console.log('[DATABASE] ✓ Connection restored');
+    } else {
+      console.error('[DATABASE] ✗ Connection lost!');
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ dbConnected }));
+  }
+  // ============ End Watch Trigger Demo Endpoints ============
+  else if (req.url.startsWith('/foo/')) {
+    const bar = req.url.slice(5); // Extract everything after '/foo/'
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      path: req.url,
+      bar: bar
+    }, null, 2));
+  }
+  else {
+    res.writeHead(404, { 'Content-Type': 'text/plain' });
+    res.end('Not Found');
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════════════════════╗
+║                         REFLEXIVE DEMO APP                                     ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║  Server running at http://localhost:${PORT}                                       ║
+║  PID: ${process.pid}                                                              ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║  HOW TO USE THIS DEMO:                                                         ║
+║                                                                                ║
+║  1. Run with Reflexive:  npm run demo:app                                      ║
+║  2. Open dashboard:      http://localhost:3100                                 ║
+║  3. Try the Watch Triggers feature:                                            ║
+║     - Click 👁 on any log entry to create a watch                              ║
+║     - Set a pattern like "Login FAILED" or "Deadlock"                          ║
+║     - Add a prompt like "Investigate this error"                               ║
+║     - The agent auto-responds when matching logs appear!                       ║
+║                                                                                ║
+║  DEMO ENDPOINTS (visit in browser or curl):                                    ║
+║                                                                                ║
+║  Auth Demo:                                                                    ║
+║    /login?user=admin&pass=wrong   → Triggers auth failure logs                 ║
+║    /login?user=admin&pass=secret  → Successful login                           ║
+║    (3+ failures triggers SECURITY WARNING)                                     ║
+║                                                                                ║
+║  Database Demo:                                                                ║
+║    /db-query    → Random success/slow/deadlock                                 ║
+║    /toggle-db   → Simulate DB connection loss                                  ║
+║                                                                                ║
+║  Other:                                                                        ║
+║    /api/users   → Rate limiting (10+ requests = warning)                       ║
+║    /webhook     → Random webhook events (payment failures, churn)              ║
+║                                                                                ║
+║  SUGGESTED WATCH PATTERNS:                                                     ║
+║    "Login FAILED"     → "Investigate why authentication is failing"            ║
+║    "Slow query"       → "Check what's causing database slowness"               ║
+║    "Deadlock"         → "Analyze the deadlock and suggest a fix"               ║
+║    "payment.failed"   → "Alert! Check the payment processing system"           ║
+║    "SECURITY WARNING" → "Potential brute force - suggest mitigations"          ║
+╚═══════════════════════════════════════════════════════════════════════════════╝
+`);
+});
+
+// Log something periodically
+setInterval(() => {
+  console.log(`[heartbeat] ${requestCount} requests served, ${visitors.size} unique visitors`);
+}, 10000);

package/demo-inject.js

@@ -0,0 +1,212 @@
+/**
+ * Demo app to test --inject and --eval features
+ *
+ * Run with injection only:
+ *   reflexive --inject demo-inject.js
+ *
+ * Run with eval enabled:
+ *   reflexive --eval demo-inject.js
+ *
+ * Then try in the dashboard:
+ *   - "What's in the config object?"
+ *   - "How many users are there?"
+ *   - "Call addUser with name 'Alice'"
+ *   - "Clear the cache"
+ */
+
+import http from 'http';
+import https from 'https';
+
+// === Expose some globals for eval testing ===
+global.config = {
+  port: 4567,
+  env: 'development',
+  debug: true,
+  maxConnections: 100
+};
+
+global.users = new Map([
+  [1, { id: 1, name: 'Demo User', role: 'admin' }],
+  [2, { id: 2, name: 'Test User', role: 'user' }]
+]);
+
+global.cache = {
+  data: new Map(),
+  set(key, value) { this.data.set(key, value); },
+  get(key) { return this.data.get(key); },
+  clear() { this.data.clear(); console.log('Cache cleared'); },
+  size() { return this.data.size; }
+};
+
+global.addUser = (name, role = 'user') => {
+  const id = global.users.size + 1;
+  const user = { id, name, role };
+  global.users.set(id, user);
+  console.log(`Added user: ${JSON.stringify(user)}`);
+  return user;
+};
+
+global.getStats = () => ({
+  users: global.users.size,
+  cacheSize: global.cache.size(),
+  uptime: process.uptime(),
+  memory: Math.round(process.memoryUsage().heapUsed / 1024 / 1024) + 'MB'
+});
+
+// === Console interception (automatic) ===
+console.log('App starting up...');
+console.info('This is an info message');
+console.warn('This is a warning');
+console.error('This is an error (not a real error, just testing)');
+console.debug('Debug info here');
+
+// === HTTP Server (automatic tracking via diagnostics_channel) ===
+const server = http.createServer((req, res) => {
+  console.log(`Incoming request: ${req.method} ${req.url}`);
+
+  // Simulate some work
+  const start = Date.now();
+  let sum = 0;
+  for (let i = 0; i < 1000000; i++) sum += i;
+
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify({
+    status: 'ok',
+    path: req.url,
+    processingTime: Date.now() - start
+  }));
+});
+
+server.listen(4567, () => {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════════════════════╗
+║                    REFLEXIVE INJECTION MODE DEMO                               ║
+║                    (Deep Instrumentation via --inject)                         ║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║  Server:     http://localhost:4567                                             ║
+║  PID: ${String(process.pid).padEnd(73)}║
+╠═══════════════════════════════════════════════════════════════════════════════╣
+║  HOW TO RUN THIS DEMO:                                                         ║
+║                                                                                ║
+║  Injection only (console capture, diagnostics):                                ║
+║    npm run demo:inject                                                         ║
+║    (or: node src/reflexive.js --inject demo-inject.js)                         ║
+║                                                                                ║
+║  With eval enabled (run code in app context):                                  ║
+║    npm run demo:eval                                                           ║
+║    (or: node src/reflexive.js --eval demo-inject.js)                           ║
+║                                                                                ║
+║  KEY FEATURES DEMONSTRATED:                                                    ║
+║  • Console interception (all log levels captured)                              ║
+║  • HTTP diagnostics via diagnostics_channel                                    ║
+║  • GC and event loop metrics via perf_hooks                                    ║
+║  • process.reflexive API for custom state                                      ║
+║  • Breakpoints (pause/resume execution)                                        ║
+║  • Remote eval (with --eval flag)                                              ║
+║                                                                                ║
+║  GLOBAL VARIABLES (for --eval testing):                                        ║
+║    config    → App configuration object                                        ║
+║    users     → Map of user data                                                ║
+║    cache     → Simple cache with get/set/clear                                 ║
+║    addUser() → Function to add new users                                       ║
+║    getStats()→ Function to get app statistics                                  ║
+║                                                                                ║
+║  TRY WITH --inject:                                                            ║
+║    "Show me the injection logs"                                                ║
+║    "What HTTP requests have been made?"                                        ║
+║    "Are there any GC events?"                                                  ║
+║                                                                                ║
+║  TRY WITH --eval:                                                              ║
+║    "What's in the config object?"                                              ║
+║    "How many users are there?"                                                 ║
+║    "Call addUser with name 'Alice'"                                            ║
+║    "Clear the cache"                                                           ║
+║    "What are the current stats?"                                               ║
+║                                                                                ║
+║  WATCH TRIGGER IDEAS:                                                          ║
+║    "External request failed" → "Investigate the HTTP error"                    ║
+║    "memory pressure" → "Analyze memory usage patterns"                         ║
+║    "event loop" → "Check for performance issues"                               ║
+╚═══════════════════════════════════════════════════════════════════════════════╝
+`);
+});
+
+// === HTTP Client requests (automatic tracking) ===
+function makeExternalRequest() {
+  console.log('Making external HTTP request...');
+
+  https.get('https://httpbin.org/get', (res) => {
+    console.log(`External request status: ${res.statusCode}`);
+    res.on('data', () => {}); // consume the data
+  }).on('error', (err) => {
+    console.error(`External request failed: ${err.message}`);
+  });
+}
+
+// Make a request every 30 seconds
+setTimeout(makeExternalRequest, 2000);
+setInterval(makeExternalRequest, 30000);
+
+// === Memory pressure (triggers GC) ===
+function createMemoryPressure() {
+  console.log('Creating memory pressure to trigger GC...');
+  let arrays = [];
+  for (let i = 0; i < 100; i++) {
+    arrays.push(new Array(100000).fill(Math.random()));
+  }
+  // Let it get collected
+  arrays = null;
+}
+
+// Trigger GC periodically
+setTimeout(createMemoryPressure, 5000);
+setInterval(createMemoryPressure, 20000);
+
+// === Event loop blocking (shows in event loop metrics) ===
+function blockEventLoop() {
+  console.log('Blocking event loop briefly...');
+  const start = Date.now();
+  while (Date.now() - start < 100) {
+    // Busy wait for 100ms
+  }
+  console.log('Event loop unblocked');
+}
+
+setTimeout(blockEventLoop, 8000);
+
+// === Simulate an uncaught exception (after 60 seconds) ===
+// Uncomment to test error capture:
+// setTimeout(() => {
+//   throw new Error('Intentional uncaught exception for testing');
+// }, 60000);
+
+// === Bonus: Use process.reflexive if available ===
+if (process.reflexive) {
+  console.log('Reflexive injection detected! Setting custom state...');
+
+  process.reflexive.setState('app.name', 'demo-inject');
+  process.reflexive.setState('app.version', '1.0.0');
+  process.reflexive.setState('user', { name: 'Alice', age: 30, email: 'alice@example.com' });
+
+  // Update request count
+  let requestCount = 0;
+  const originalEmit = server.emit.bind(server);
+  server.emit = function(event, ...args) {
+    if (event === 'request') {
+      requestCount++;
+      process.reflexive.setState('requests.total', requestCount);
+    }
+    return originalEmit(event, ...args);
+  };
+
+  // Periodic state updates
+  setInterval(() => {
+    const mem = process.memoryUsage();
+    process.reflexive.setState('memory', {
+      heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
+      heapTotal: Math.round(mem.heapTotal / 1024 / 1024)
+    });
+  }, 5000);
+}
+
+console.log('Demo app ready! Make HTTP requests: curl http://localhost:4567/test');