@cirvix_ai/agent-control 0.1.2 → 0.1.5

package/src/core/ui/intercept.mjs

@@ -0,0 +1,103 @@
+/**
+ * SecurityIntercept — visually distinctive blocked-action panel.
+ *
+ * Animation MUST NOT delay enforcement. Decision is already computed.
+ * This only visualizes it with a short 300-800ms sequence.
+ */
+
+import { bold, dim, red, stripAnsi } from "../format.mjs";
+import { shouldAnimate, sleep } from "./controller.mjs";
+import { boxChars, truncate, padVisible } from "./theme.mjs";
+
+export function interceptBox(event) {
+  const W = 58;
+  const ch = boxChars();
+  const useAscii = ch.tl === "+";
+  // Use red border for intercept.
+  const h = useAscii ? ch.h : "═";
+  const v = useAscii ? ch.v : "║";
+  const tl = useAscii ? ch.tl : "╔";
+  const tr = useAscii ? ch.tr : "╗";
+  const bl = useAscii ? ch.bl : "╚";
+  const br = useAscii ? ch.br : "╝";
+  const mj = useAscii ? ch.lt : "╠";
+  const mid = mj + h.repeat(W + 2) + (useAscii ? ch.rt : "╣");
+
+  const rows = [
+    ["Agent", event.agent ?? "—"],
+    ["Tool", event.tool ?? event.action ?? "—"],
+    ["Target", event.resource ?? event.destination ?? "—"],
+    ["Risk", String(event.risk ?? "—").toUpperCase()],
+    ["Decision", "BLOCKED"],
+    ["Policy", event.policy ?? event.rule ?? "default-deny"],
+    ["Latency", `${event.latency_ms ?? "—"}ms`],
+  ];
+
+  const pad = (text) => {
+    const s = String(text);
+    const vis = stripAnsi(s).length;
+    if (vis > W) return s.slice(0, W - 1) + "…";
+    return s + " ".repeat(W - vis);
+  };
+
+  const lines = [];
+  lines.push(`  ${red(tl + h.repeat(W + 2) + tr)}`);
+  lines.push(`  ${red(v)} ${bold(pad("CIRVIX SECURITY INTERCEPT"))} ${red(v)}`);
+  lines.push(`  ${red(mid)}`);
+  for (const [k, val] of rows) {
+    const body = `${k}:`.padEnd(11) + String(val);
+    const painted = k === "Risk" || k === "Decision" ? red(pad(body)) : pad(body);
+    lines.push(`  ${red(v)} ${painted} ${red(v)}`);
+  }
+  lines.push(`  ${red(bl + h.repeat(W + 2) + br)}`);
+
+  const reason = event.reason ? `\n  ${dim(truncate(event.reason, 72))}\n` : "";
+  return lines.join("\n") + reason;
+}
+
+/**
+ * Animated intercept: spinner → risk → BLOCKED → policy.
+ * Total 300-800ms, but decision already made.
+ */
+export async function animateIntercept(event, { stream = process.stdout, pace = 700 } = {}) {
+  const enabled = shouldAnimate({ pace, json: false });
+  if (!enabled) {
+    stream.write(interceptBox(event) + "\n");
+    return;
+  }
+  const write = (s) => {
+    try {
+      stream.write(s);
+    } catch {}
+  };
+  const timers = [];
+  const hide = () => {
+    try {
+      stream.write("\u001b[?25l");
+    } catch {}
+  };
+  const show = () => {
+    try {
+      stream.write("\u001b[?25h");
+    } catch {}
+  };
+  hide();
+  // Phase 1: evaluating
+  write("  ◌ evaluating request...\r");
+  await sleep(Math.min(260, pace * 0.35), timers);
+  write("\x1b[2K");
+  // Phase 2: risk
+  const riskTone = event.risk === "critical" ? red : event.risk === "high" ? "\u001b[33m" : "";
+  write(`  ${riskTone}⚠ ${String(event.risk ?? "").toUpperCase()}\u001b[39m\n`);
+  await sleep(Math.min(160, pace * 0.2), timers);
+  // Phase 3: BLOCKED
+  write(`  ${red("✕ BLOCKED")}\n`);
+  await sleep(Math.min(160, pace * 0.2), timers);
+  // Phase 4: policy
+  write(`  ${dim(String(event.policy ?? event.rule ?? ""))}\n`);
+  await sleep(Math.min(120, pace * 0.15), timers);
+  // Phase 5: full box
+  write(interceptBox(event) + "\n");
+  show();
+  for (const t of timers) clearTimeout(t);
+}

package/src/core/ui/live.mjs

@@ -0,0 +1,51 @@
+/**
+ * LiveStream — `cirvix logs --watch` live security stream.
+ *
+ * Line-based updates, no full redraw, readable.
+ */
+
+import { dim, bold } from "../format.mjs";
+import { renderDecision } from "./decisions.mjs";
+
+export class LiveStream {
+  constructor({ stream = process.stdout, title = "CIRVIX LIVE · protection active" } = {}) {
+    this.stream = stream;
+    this.title = title;
+    this.started = false;
+  }
+
+  header() {
+    if (this.started) return;
+    this.started = true;
+    try {
+      this.stream.write(`\n  ${bold(this.title)}\n`);
+      this.stream.write(`  ${dim("─".repeat(60))}\n\n`);
+    } catch {}
+  }
+
+  push(event) {
+    this.header();
+    const line = renderDecision(event);
+    // For live, compact is preferred even for DENY to keep stream readable,
+    // but DENY still gets expanded with context on next line.
+    try {
+      // event already has ts; render with clock if present.
+      const clock = event.ts ? String(event.ts).slice(11, 19) : new Date().toISOString().slice(11, 19);
+      // If decision renderer already includes multiline, just prefix clock.
+      if (line.includes("\n")) {
+        const parts = line.split("\n");
+        this.stream.write(`  ${dim(clock)} ${parts[0].trimStart()}\n`);
+        for (let i = 1; i < parts.length; i++) this.stream.write(parts[i] + "\n");
+      } else {
+        this.stream.write(`  ${dim(clock)} ${line.trimStart()}\n`);
+      }
+    } catch {}
+  }
+
+  footer(stats) {
+    if (!stats) return;
+    try {
+      this.stream.write(`\n  ${dim(`${stats.records ?? 0} decisions · P99 ${stats.latency?.p99 ?? 0}ms`)}\n\n`);
+    } catch {}
+  }
+}

package/src/core/ui/primitives.mjs

@@ -0,0 +1,123 @@
+/**
+ * Primitives — Panel, Table, Badge, Logo, Status helpers.
+ *
+ * Zero deps, unicode with ASCII fallback, respects NO_COLOR via format.mjs.
+ */
+
+import { bold, dim, stripAnsi, supportsUnicode } from "../format.mjs";
+import { boxChars, truncate, padVisible } from "./theme.mjs";
+
+/** CIRVIX ASCII logo (5 lines). Compact, premium, not gamey. */
+export const LOGO_LINES = [
+  " ██████╗██╗██████╗ ██╗   ██╗██╗██╗  ██╗",
+  "██╔════╝██║██╔══██╗██║   ██║██║╚██╗██╔╝",
+  "██║     ██║██████╔╝██║   ██║██║ ╚███╔╝ ",
+  "██║     ██║██╔══██╗╚██╗ ██╔╝██║ ██╔██╗ ",
+  "╚██████╗██║██║  ██║ ╚████╔╝ ██║██╔╝ ██╗",
+  " ╚═════╝╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚═╝  ╚═╝",
+];
+
+export const LOGO_SUBTITLE = "AI AGENT RUNTIME GOVERNANCE";
+
+/**
+ * Draw a rounded panel with optional title.
+ *
+ * @param {object} opts
+ * @param {string} [opts.title]
+ * @param {string[]} opts.lines — already formatted (may contain ANSI)
+ * @param {number} [opts.width] — inner width, default 58
+ * @param {boolean} [opts.heavy] — use heavy border for intercept
+ */
+export function panel({ title, lines = [], width = 58, heavy = false } = {}) {
+  const ch = boxChars();
+  const h = heavy ? ch.hHeavy : ch.h;
+  const v = heavy ? ch.vHeavy : ch.v;
+
+  // Compute actual inner width from content if not provided.
+  let inner = width;
+  if (!width) {
+    inner = Math.max(...lines.map((l) => stripAnsi(l).length), title ? stripAnsi(title).length : 0) + 2;
+    inner = Math.max(40, Math.min(72, inner));
+  }
+
+  const top = `╭${h.repeat(inner + 2)}╮`;
+  const bottom = `╰${h.repeat(inner + 2)}╯`;
+  // For ascii fallback, boxChars returns +/-, so above uses unicode literals.
+  // Rebuild with actual chars for ascii.
+  const useAscii = !supportsUnicode();
+  const topLine = useAscii ? `${ch.tl}${ch.h.repeat(inner + 2)}${ch.tr}` : top;
+  const bottomLine = useAscii ? `${ch.bl}${ch.h.repeat(inner + 2)}${ch.br}` : bottom;
+  const vert = useAscii ? ch.v : v;
+
+  const out = [];
+  out.push(`  ${topLine}`);
+  if (title) {
+    const t = truncate(title, inner);
+    out.push(`  ${vert} ${padVisible(t, inner)} ${vert}`);
+    out.push(`  ${vert} ${" ".repeat(inner)} ${vert}`);
+  } else {
+    out.push(`  ${vert} ${" ".repeat(inner)} ${vert}`);
+  }
+  for (const line of lines) {
+    const clean = truncate(stripAnsi(line), inner);
+    // Preserve ANSI: pad based on visible length.
+    const padded = padVisible(line, inner);
+    // Ensure we truncate ANSI correctly — if original had ANSI, we need to re-truncate safely.
+    // Simpler: use padded which already uses visibleWidth.
+    out.push(`  ${vert} ${padded} ${vert}`);
+  }
+  out.push(`  ${vert} ${" ".repeat(inner)} ${vert}`);
+  out.push(`  ${bottomLine}`);
+  return out.join("\n");
+}
+
+/**
+ * Render the full brand header — logo boxed.
+ */
+export function brandHeader({ width = 58 } = {}) {
+  const ch = boxChars();
+  const useAscii = !supportsUnicode();
+  const h = ch.h;
+  const top = useAscii ? `${ch.tl}${h.repeat(width + 2)}${ch.tr}` : `╭${h.repeat(width + 2)}╮`;
+  const bottom = useAscii ? `${ch.bl}${h.repeat(width + 2)}${ch.br}` : `╰${h.repeat(width + 2)}╯`;
+  const vert = useAscii ? ch.v : ch.v;
+
+  const lines = [];
+  lines.push(`  ${top}`);
+  lines.push(`  ${vert} ${" ".repeat(width)} ${vert}`);
+  for (const l of LOGO_LINES) {
+    const padded = l.padStart(Math.floor((width + l.length) / 2)).padEnd(width);
+    lines.push(`  ${vert} ${padded} ${vert}`);
+  }
+  lines.push(`  ${vert} ${" ".repeat(width)} ${vert}`);
+  const sub = LOGO_SUBTITLE.padStart(Math.floor((width + LOGO_SUBTITLE.length) / 2)).padEnd(width);
+  lines.push(`  ${vert} ${dim(sub)} ${vert}`);
+  lines.push(`  ${vert} ${" ".repeat(width)} ${vert}`);
+  lines.push(`  ${bottom}`);
+  return lines.join("\n");
+}
+
+/** Simple key/value rows aligned. */
+export function keyValueRows(rows, { keyWidth } = {}) {
+  const w = keyWidth ?? Math.max(...rows.map(([k]) => stripAnsi(String(k)).length));
+  return rows.map(([k, v]) => `  ${String(k).padEnd(w + 2)}${v}`);
+}
+
+/** Separator line. */
+export function separator(width = 60, char = "─") {
+  const ch = supportsUnicode() ? char : "-";
+  return dim("  " + ch.repeat(width));
+}
+
+/** Badge: ● ONLINE / ● ENFORCING etc. with color. */
+export function badge(label, state, tone) {
+  const dot = "●";
+  return `${tone(`${dot} ${state}`)} ${dim(label)}`;
+}
+
+/** Truncate path for display, never show secret values. */
+export function safeTarget(value, max = 44) {
+  const s = String(value ?? "");
+  if (s.length <= max) return s;
+  return "…" + s.slice(-(max - 1));
+}

package/src/core/ui/theme.mjs

@@ -0,0 +1,92 @@
+/**
+ * Theme — semantic palette + box characters, with NO_COLOR and ASCII fallbacks.
+ *
+ * Never rely on color alone; every semantic token also has a text label
+ * (ALLOW/BLOCKED etc.) rendered elsewhere.
+ */
+
+import { bold, dim, green, red, amber, blue, cyan, gray, stripAnsi, supportsUnicode } from "../format.mjs";
+
+export const palette = {
+  success: green,
+  critical: red,
+  warning: amber,
+  info: blue,
+  muted: dim,
+  subtle: gray,
+  accent: cyan,
+  strong: bold,
+};
+
+export const riskTone = {
+  low: dim,
+  medium: blue,
+  high: amber,
+  critical: red,
+};
+
+export const decisionTone = {
+  allow: green,
+  sanitize: blue,
+  require_approval: amber,
+  deny: red,
+  audit_only: dim,
+};
+
+export function toneForDecision(decision) {
+  return decisionTone[String(decision ?? "").toLowerCase()] ?? dim;
+}
+
+export function toneForRisk(risk) {
+  return riskTone[String(risk ?? "").toLowerCase()] ?? dim;
+}
+
+/** Box characters, unicode primary, ascii fallback. */
+export function boxChars() {
+  if (supportsUnicode()) {
+    return {
+      tl: "╭",
+      tr: "╮",
+      bl: "╰",
+      br: "╯",
+      h: "─",
+      v: "│",
+      lt: "├",
+      rt: "┤",
+      mt: "┬",
+      mb: "┴",
+      cross: "┼",
+      // heavy for intercept
+      hHeavy: "━",
+      vHeavy: "┃",
+    };
+  }
+  return {
+    tl: "+",
+    tr: "+",
+    bl: "+",
+    br: "+",
+    h: "-",
+    v: "|",
+    lt: "+",
+    rt: "+",
+    mt: "+",
+    mb: "+",
+    cross: "+",
+    hHeavy: "=",
+    vHeavy: "|",
+  };
+}
+
+/** Safe width truncation with ANSI stripped. */
+export function truncate(str, n) {
+  const s = String(str ?? "");
+  if (s.length <= n) return s;
+  return s.slice(0, n - 1) + "…";
+}
+
+export function padVisible(str, width) {
+  const vis = stripAnsi(String(str)).length;
+  if (vis >= width) return String(str);
+  return String(str) + " ".repeat(width - vis);
+}

package/src/core/verified.mjs

@@ -0,0 +1,108 @@
+/**
+ * Cirvix Verified & MCP Trust Layer.
+ *
+ * Implements security verification for MCP servers and tools:
+ * - Provenance and publisher tracking
+ * - Tool poisoning / description tampering detection
+ * - Unpinned network egress analysis
+ * - Trust score computation (0-100)
+ * - Verification status: VERIFIED | REVIEW_REQUIRED | SUSPICIOUS | BLOCKED
+ */
+
+export const VERIFICATION_STATUS = {
+  VERIFIED: "VERIFIED",
+  REVIEW_REQUIRED: "REVIEW_REQUIRED",
+  SUSPICIOUS: "SUSPICIOUS",
+  BLOCKED: "BLOCKED",
+};
+
+/**
+ * Scans an MCP server declaration and its tools for security risks and assigns trust score.
+ *
+ * @param {Object} server
+ * @param {string} server.name
+ * @param {string} [server.publisher]
+ * @param {string} [server.version]
+ * @param {Array}  [server.tools]
+ * @param {Array}  [server.destinations]
+ * @returns {Object} Inspection report
+ */
+export function inspectMcpServer({
+  name,
+  publisher = null,
+  version = null,
+  tools = [],
+  destinations = [],
+} = {}) {
+  let trustScore = 70; // Starting baseline for unverified server
+  const findings = [];
+
+  // Publisher trust
+  const knownTrustedPublishers = ["anthropic", "google", "github", "stripe", "aws", "cirvix"];
+  if (publisher && knownTrustedPublishers.includes(publisher.toLowerCase())) {
+    trustScore += 25;
+  } else if (!publisher) {
+    trustScore -= 15;
+    findings.push("Missing publisher provenance metadata");
+  }
+
+  // Network destinations check
+  for (const dest of destinations) {
+    const dLower = String(dest).toLowerCase();
+    if (dLower.includes("169.254.") || dLower.includes("metadata.google")) {
+      trustScore = 0;
+      findings.push(`Dangerous cloud metadata destination declared: ${dest}`);
+      return {
+        name,
+        trustScore: 0,
+        status: VERIFICATION_STATUS.BLOCKED,
+        findings,
+      };
+    }
+  }
+
+  // Tools inspection
+  for (const tool of tools) {
+    const desc = (tool.description ?? "").toLowerCase();
+    const toolName = (tool.name ?? "").toLowerCase();
+
+    // Check for tool poisoning / prompt injection markers in description
+    if (
+      desc.includes("ignore previous instructions") ||
+      desc.includes("system prompt") ||
+      desc.includes("do not tell the user") ||
+      desc.includes("send secrets to")
+    ) {
+      trustScore = 0;
+      findings.push(`Tool poisoning detected in tool '${tool.name}': suspicious prompt injection phrases in description`);
+      return {
+        name,
+        trustScore: 0,
+        status: VERIFICATION_STATUS.BLOCKED,
+        findings,
+      };
+    }
+
+    // Check for excessive wildcard permissions or raw shell execution
+    if (toolName === "bash" || toolName === "exec" || toolName === "eval") {
+      trustScore -= 20;
+      findings.push(`Tool '${tool.name}' exposes raw shell/process execution capability`);
+    }
+  }
+
+  trustScore = Math.max(0, Math.min(100, trustScore));
+
+  let status = VERIFICATION_STATUS.REVIEW_REQUIRED;
+  if (trustScore >= 85) status = VERIFICATION_STATUS.VERIFIED;
+  else if (trustScore < 50) status = VERIFICATION_STATUS.SUSPICIOUS;
+
+  return {
+    name,
+    publisher,
+    version,
+    trustScore,
+    status,
+    findings,
+    scannedAt: new Date().toISOString(),
+  };
+}