securenow 5.2.2 → 5.3.0

package/cli/monitor.js

@@ -0,0 +1,458 @@
+'use strict';
+
+const { api, requireAuth } = require('./client');
+const config = require('./config');
+const ui = require('./ui');
+
+function resolveApp(flags) {
+  return flags.app || config.getDefaultApp();
+}
+
+// ── Traces ──
+
+async function tracesList(args, flags) {
+  requireAuth();
+  const appKey = resolveApp(flags);
+  if (!appKey) {
+    ui.error('No app specified. Use --app <key> or set a default with `securenow config set defaultApp <key>`');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Fetching traces');
+  try {
+    const query = {
+      serviceName: appKey,
+      limit: flags.limit || 20,
+    };
+    if (flags.start) query.start = flags.start;
+    if (flags.end) query.end = flags.end;
+
+    const data = await api.get('/traces/recent', { query });
+    const traces = Array.isArray(data) ? data : data.traces || [];
+    s.stop(`Found ${traces.length} trace${traces.length !== 1 ? 's' : ''}`);
+
+    if (flags.json) { ui.json(traces); return; }
+
+    console.log('');
+    const rows = traces.map(t => [
+      ui.c.dim(ui.truncate(t.traceID || t.traceId || t._id, 16)),
+      t.operationName || t.name || t.serviceName || '—',
+      ui.httpStatusColor(t.statusCode || t.httpStatusCode || '—'),
+      ui.durationColor(t.durationNano ? t.durationNano / 1e6 : t.duration),
+      t.httpMethod || t.method || '—',
+      ui.truncate(t.httpUrl || t.url || t.httpRoute || '', 40),
+      ui.timeAgo(t.timestamp),
+    ]);
+
+    ui.table(['Trace ID', 'Operation', 'Status', 'Duration', 'Method', 'URL', 'Time'], rows);
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to fetch traces');
+    throw err;
+  }
+}
+
+async function tracesShow(args, flags) {
+  requireAuth();
+  const traceId = args[0];
+  if (!traceId) {
+    ui.error('Trace ID is required. Usage: securenow traces show <traceId>');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Fetching trace details');
+  try {
+    const data = await api.get(`/traces/${traceId}`);
+    s.stop('Trace loaded');
+
+    if (flags.json) { ui.json(data); return; }
+
+    const trace = data.trace || data;
+    console.log('');
+    ui.heading(`Trace ${traceId}`);
+    console.log('');
+
+    if (trace.spans && trace.spans.length) {
+      ui.subheading(`Spans (${trace.spans.length})`);
+      console.log('');
+      const rows = trace.spans.map(span => [
+        ui.c.dim(ui.truncate(span.spanID || span.spanId, 16)),
+        span.operationName || span.name || '—',
+        ui.httpStatusColor(span.statusCode || '—'),
+        ui.durationColor(span.durationNano ? span.durationNano / 1e6 : span.duration),
+        span.kind || '—',
+      ]);
+      ui.table(['Span ID', 'Operation', 'Status', 'Duration', 'Kind'], rows);
+    }
+
+    if (trace.rootSpan || trace.serviceName) {
+      console.log('');
+      ui.keyValue([
+        ['Service', trace.serviceName || '—'],
+        ['Root Operation', trace.rootOperationName || trace.rootSpan?.operationName || '—'],
+        ['Duration', trace.durationMs ? `${trace.durationMs}ms` : '—'],
+        ['Timestamp', trace.startTime ? new Date(trace.startTime).toLocaleString() : '—'],
+      ]);
+    }
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to fetch trace');
+    throw err;
+  }
+}
+
+async function tracesAnalyze(args, flags) {
+  requireAuth();
+  const traceId = args[0];
+  if (!traceId) {
+    ui.error('Trace ID is required. Usage: securenow traces analyze <traceId>');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Analyzing trace with AI');
+  try {
+    const result = await api.post('/traces/analyze', { traceId });
+    s.stop('Analysis complete');
+
+    if (flags.json) { ui.json(result); return; }
+
+    console.log('');
+    ui.heading('AI Trace Analysis');
+    console.log('');
+    console.log(result.analysis || result.message || JSON.stringify(result, null, 2));
+    console.log('');
+  } catch (err) {
+    s.fail('Analysis failed');
+    throw err;
+  }
+}
+
+// ── Logs ──
+
+async function logsList(args, flags) {
+  requireAuth();
+  const appKey = resolveApp(flags);
+  if (!appKey) {
+    ui.error('No app specified. Use --app <key> or set a default.');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Fetching logs');
+  try {
+    const minutes = parseInt(flags.minutes || '60', 10);
+    const now = Date.now();
+    const query = {
+      serviceName: appKey,
+      limit: flags.limit || 50,
+      start: flags.start || new Date(now - minutes * 60 * 1000).toISOString(),
+      end: flags.end || new Date(now).toISOString(),
+    };
+    if (flags.level) query.level = flags.level;
+
+    const data = await api.get('/logs', { query });
+    const logs = Array.isArray(data) ? data : data.logs || [];
+    s.stop(`Found ${logs.length} log${logs.length !== 1 ? 's' : ''}`);
+
+    if (flags.json) { ui.json(logs); return; }
+
+    console.log('');
+    for (const log of logs) {
+      const level = (log.severityText || log.level || 'INFO').toUpperCase();
+      const levelColor = {
+        ERROR: ui.c.red, WARN: ui.c.yellow, WARNING: ui.c.yellow,
+        INFO: ui.c.cyan, DEBUG: ui.c.dim,
+      }[level] || ui.c.white;
+
+      const time = ui.c.dim(log.timestamp ? new Date(log.timestamp).toLocaleTimeString() : '');
+      const body = log.body || log.message || log.severityText || '';
+
+      console.log(`  ${time} ${levelColor(level.padEnd(7))} ${body}`);
+
+      if (log.traceId && flags.verbose) {
+        console.log(`  ${ui.c.dim(`  trace=${log.traceId} span=${log.spanId || ''}`)}`);
+      }
+    }
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to fetch logs');
+    throw err;
+  }
+}
+
+async function logsTrace(args, flags) {
+  requireAuth();
+  const traceId = args[0];
+  if (!traceId) {
+    ui.error('Trace ID required. Usage: securenow logs trace <traceId>');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Fetching logs for trace');
+  try {
+    const data = await api.get(`/logs/trace/${traceId}`);
+    const logs = Array.isArray(data) ? data : data.logs || [];
+    s.stop(`Found ${logs.length} log${logs.length !== 1 ? 's' : ''}`);
+
+    if (flags.json) { ui.json(logs); return; }
+
+    console.log('');
+    for (const log of logs) {
+      const level = (log.severityText || log.level || 'INFO').toUpperCase();
+      const levelColor = {
+        ERROR: ui.c.red, WARN: ui.c.yellow, WARNING: ui.c.yellow,
+        INFO: ui.c.cyan, DEBUG: ui.c.dim,
+      }[level] || ui.c.white;
+
+      const time = ui.c.dim(log.timestamp ? new Date(log.timestamp).toLocaleTimeString() : '');
+      console.log(`  ${time} ${levelColor(level.padEnd(7))} ${log.body || log.message || ''}`);
+    }
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to fetch logs');
+    throw err;
+  }
+}
+
+// ── Issues ──
+
+async function issuesList(args, flags) {
+  requireAuth();
+  const s = ui.spinner('Fetching issues');
+  try {
+    const query = {};
+    const appKey = resolveApp(flags);
+    if (appKey) query.serviceName = appKey;
+    if (flags.status) query.status = flags.status;
+
+    const data = await api.get('/issues', { query });
+    const issues = Array.isArray(data) ? data : data.issues || [];
+    s.stop(`Found ${issues.length} issue${issues.length !== 1 ? 's' : ''}`);
+
+    if (flags.json) { ui.json(issues); return; }
+
+    console.log('');
+    const rows = issues.map(i => [
+      ui.c.dim(ui.truncate(i._id, 12)),
+      ui.statusBadge(i.severity || i.level || 'medium'),
+      ui.statusBadge(i.status || 'open'),
+      ui.truncate(i.title || i.message || i.type || '', 50),
+      i.serviceName || '—',
+      i.count != null ? String(i.count) : '—',
+      ui.timeAgo(i.lastSeen || i.createdAt),
+    ]);
+
+    ui.table(['ID', 'Severity', 'Status', 'Title', 'App', 'Count', 'Last Seen'], rows);
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to fetch issues');
+    throw err;
+  }
+}
+
+async function issuesShow(args, flags) {
+  requireAuth();
+  const id = args[0];
+  if (!id) {
+    ui.error('Issue ID required. Usage: securenow issues show <id>');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Fetching issue');
+  try {
+    const issue = await api.get(`/issues/${id}`);
+    s.stop('Issue loaded');
+
+    if (flags.json) { ui.json(issue); return; }
+
+    console.log('');
+    ui.heading(issue.title || issue.type || `Issue ${id}`);
+    console.log('');
+    ui.keyValue([
+      ['ID', issue._id],
+      ['Status', ui.statusBadge(issue.status || 'open')],
+      ['Severity', ui.statusBadge(issue.severity || issue.level || 'medium')],
+      ['App', issue.serviceName || '—'],
+      ['Type', issue.type || '—'],
+      ['Count', issue.count != null ? String(issue.count) : '—'],
+      ['First Seen', issue.firstSeen ? new Date(issue.firstSeen).toLocaleString() : '—'],
+      ['Last Seen', issue.lastSeen ? new Date(issue.lastSeen).toLocaleString() : '—'],
+    ]);
+
+    if (issue.message || issue.description) {
+      ui.subheading('Description');
+      console.log(`\n  ${issue.message || issue.description}\n`);
+    }
+
+    if (issue.analysis) {
+      ui.subheading('AI Analysis');
+      console.log(`\n  ${issue.analysis}\n`);
+    }
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to fetch issue');
+    throw err;
+  }
+}
+
+async function issuesResolve(args, flags) {
+  requireAuth();
+  const id = args[0];
+  if (!id) {
+    ui.error('Issue ID required. Usage: securenow issues resolve <id>');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Resolving issue');
+  try {
+    await api.patch(`/issues/${id}`, { status: 'resolved' });
+    s.stop('Issue resolved');
+  } catch (err) {
+    s.fail('Failed to resolve issue');
+    throw err;
+  }
+}
+
+// ── Notifications ──
+
+async function notificationsList(args, flags) {
+  requireAuth();
+  const s = ui.spinner('Fetching notifications');
+  try {
+    const query = { limit: flags.limit || 20, page: flags.page || 1 };
+    const data = await api.get('/notifications', { query });
+    const notifications = Array.isArray(data) ? data : data.notifications || data.data || [];
+    s.stop(`Found ${notifications.length} notification${notifications.length !== 1 ? 's' : ''}`);
+
+    if (flags.json) { ui.json(data); return; }
+
+    console.log('');
+    const rows = notifications.map(n => [
+      ui.c.dim(ui.truncate(n._id, 12)),
+      ui.statusBadge(n.read ? 'read' : 'unread'),
+      ui.truncate(n.title || n.message || n.type || '', 50),
+      n.ip || '—',
+      n.severity ? ui.statusBadge(n.severity) : '—',
+      ui.timeAgo(n.createdAt),
+    ]);
+
+    ui.table(['ID', 'Status', 'Title', 'IP', 'Severity', 'Time'], rows);
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to fetch notifications');
+    throw err;
+  }
+}
+
+async function notificationsRead(args, flags) {
+  requireAuth();
+  const id = args[0];
+  if (!id) {
+    ui.error('Notification ID required. Usage: securenow notifications read <id>');
+    process.exit(1);
+  }
+
+  const s = ui.spinner('Marking as read');
+  try {
+    await api.put(`/notifications/${id}`, { read: true });
+    s.stop('Notification marked as read');
+  } catch (err) {
+    s.fail('Failed to mark notification');
+    throw err;
+  }
+}
+
+async function notificationsReadAll() {
+  requireAuth();
+  const s = ui.spinner('Marking all as read');
+  try {
+    await api.put('/notifications/read-all');
+    s.stop('All notifications marked as read');
+  } catch (err) {
+    s.fail('Failed to mark notifications');
+    throw err;
+  }
+}
+
+async function notificationsUnread() {
+  requireAuth();
+  try {
+    const data = await api.get('/notifications/unread-count');
+    const count = data.count ?? data.unreadCount ?? data;
+    console.log(`\n  ${ui.c.bold(String(count))} unread notification${count !== 1 ? 's' : ''}\n`);
+  } catch (err) {
+    throw err;
+  }
+}
+
+// ── Status / Dashboard Overview ──
+
+async function status(args, flags) {
+  requireAuth();
+  const s = ui.spinner('Fetching dashboard overview');
+  try {
+    const [apps, unread] = await Promise.all([
+      api.get('/applications'),
+      api.get('/notifications/unread-count').catch(() => ({ count: 0 })),
+    ]);
+
+    s.stop('Dashboard loaded');
+
+    console.log('');
+    ui.heading('SecureNow Dashboard');
+    console.log('');
+
+    ui.keyValue([
+      ['Applications', String(apps.length)],
+      ['Unread Alerts', String(unread.count ?? unread.unreadCount ?? 0)],
+    ]);
+
+    if (apps.length > 0) {
+      ui.subheading('Applications');
+      console.log('');
+      const rows = apps.map(app => [
+        app.name,
+        ui.c.dim(app.key),
+        app.hosts?.length ? app.hosts.join(', ') : ui.c.dim('—'),
+      ]);
+      ui.table(['Name', 'Key', 'Hosts'], rows);
+    }
+
+    const appKey = resolveApp(flags);
+    if (appKey) {
+      try {
+        const protectionData = await api.get('/applications/protection-status', { query: { serviceName: appKey } });
+        if (protectionData) {
+          ui.subheading(`Protection Status (${appKey})`);
+          console.log('');
+          const status = protectionData.status || protectionData;
+          if (typeof status === 'object') {
+            ui.keyValue(Object.entries(status).map(([k, v]) => [k, String(v)]));
+          } else {
+            console.log(`  ${status}`);
+          }
+        }
+      } catch {}
+    }
+
+    console.log('');
+  } catch (err) {
+    s.fail('Failed to load dashboard');
+    throw err;
+  }
+}
+
+module.exports = {
+  tracesList,
+  tracesShow,
+  tracesAnalyze,
+  logsList,
+  logsTrace,
+  issuesList,
+  issuesShow,
+  issuesResolve,
+  notificationsList,
+  notificationsRead,
+  notificationsReadAll,
+  notificationsUnread,
+  status,
+};