@cirvix_ai/agent-control 0.1.3 → 0.2.0

package/src/adapters/roo-code.mjs

@@ -0,0 +1,106 @@
+/**
+ * Roo Code Adapter for CIRVIX AgentControl.
+ *
+ * Supports:
+ * - VS Code globalStorage roo_code_mcp_settings.json across Windows, macOS, Linux
+ * - Workspace .roomodes and .clinerules
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BaseAgentAdapter } from "./base.mjs";
+
+export class RooCodeAdapter extends BaseAgentAdapter {
+  constructor() {
+    super({
+      id: "roo-code",
+      label: "Roo Code",
+      type: "extension",
+      mcpKey: "mcpServers",
+    });
+  }
+
+  async detect(cwd) {
+    const home = homedir();
+    const candidatePaths = [
+      join(cwd, ".roo", "mcp_settings.json"),
+      // Windows
+      join(home, "AppData", "Roaming", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json"),
+      // macOS
+      join(home, "Library", "Application Support", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json"),
+      // Linux
+      join(home, ".config", "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json"),
+    ];
+
+    const existingPaths = [];
+    const servers = {};
+    let configFound = null;
+
+    for (const p of candidatePaths) {
+      if (await this.fileExists(p)) {
+        existingPaths.push(p);
+        const data = await this.readJson(p);
+        if (data) {
+          if (!configFound) configFound = data;
+          Object.assign(servers, data[this.mcpKey] ?? {});
+        }
+      }
+    }
+
+    const hasModes = (await this.fileExists(join(cwd, ".roomodes"))) || (await this.fileExists(join(cwd, ".clinerules")));
+    const detected = existingPaths.length > 0 || hasModes;
+
+    const isIntegrated = Object.entries(servers).some(([name, def]) => this.isCirvixServer(name, def));
+
+    return {
+      detected,
+      paths: existingPaths,
+      targetConfigPath: existingPaths[0] ?? candidatePaths[1],
+      config: configFound,
+      servers,
+      serverCount: Object.keys(servers).length,
+      isIntegrated,
+      hasConfig: existingPaths.length > 0,
+      executable: null,
+      metadata: {
+        hasModes,
+      },
+    };
+  }
+
+  async generateIntegrationPlan(cwd, options = {}) {
+    const info = await this.detect(cwd);
+    const targetFile = info.targetConfigPath;
+    const currentServers = { ...info.servers };
+
+    const upstreams = {};
+    for (const [k, v] of Object.entries(currentServers)) {
+      if (!this.isCirvixServer(k, v)) upstreams[k] = v;
+    }
+
+    const cirvixServerDef = {
+      command: "cirvix",
+      args: ["gateway", "--servers", targetFile.replace(/\\/g, "/")],
+    };
+
+    const newConfig = {
+      ...(info.config || {}),
+      [this.mcpKey]: {
+        ...currentServers,
+        cirvix: cirvixServerDef,
+      },
+    };
+
+    return {
+      adapterId: this.id,
+      label: this.label,
+      targetFile,
+      canIntegrate: true,
+      currentServers,
+      upstreams,
+      plan: newConfig,
+      snippet: JSON.stringify({ [this.mcpKey]: { cirvix: cirvixServerDef } }, null, 2),
+      reason: "Protects Roo Code autonomous task execution via CIRVIX gateway.",
+    };
+  }
+}

package/src/adapters/vscode.mjs

@@ -0,0 +1,104 @@
+/**
+ * VS Code Standard MCP Adapter for CIRVIX AgentControl.
+ *
+ * Supports:
+ * - User mcp.json across Windows, macOS, Linux
+ * - Workspace .vscode/mcp.json
+ * - Uses the "servers" root key per VS Code MCP specification
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BaseAgentAdapter } from "./base.mjs";
+
+export class VSCodeAdapter extends BaseAgentAdapter {
+  constructor() {
+    super({
+      id: "vscode",
+      label: "VS Code (MCP)",
+      type: "editor",
+      mcpKey: "servers",
+    });
+  }
+
+  async detect(cwd) {
+    const home = homedir();
+    const candidatePaths = [
+      join(cwd, ".vscode", "mcp.json"),
+      // Windows
+      join(home, "AppData", "Roaming", "Code", "User", "mcp.json"),
+      // macOS
+      join(home, "Library", "Application Support", "Code", "User", "mcp.json"),
+      // Linux
+      join(home, ".config", "Code", "User", "mcp.json"),
+    ];
+
+    const existingPaths = [];
+    const servers = {};
+    let configFound = null;
+
+    for (const p of candidatePaths) {
+      if (await this.fileExists(p)) {
+        existingPaths.push(p);
+        const data = await this.readJson(p);
+        if (data) {
+          if (!configFound) configFound = data;
+          const map = data.servers ?? data.mcpServers ?? {};
+          Object.assign(servers, map);
+        }
+      }
+    }
+
+    const detected = existingPaths.length > 0;
+    const isIntegrated = Object.entries(servers).some(([name, def]) => this.isCirvixServer(name, def));
+
+    return {
+      detected,
+      paths: existingPaths,
+      targetConfigPath: existingPaths[0] ?? candidatePaths[1],
+      config: configFound,
+      servers,
+      serverCount: Object.keys(servers).length,
+      isIntegrated,
+      hasConfig: existingPaths.length > 0,
+      executable: null,
+      metadata: {},
+    };
+  }
+
+  async generateIntegrationPlan(cwd, options = {}) {
+    const info = await this.detect(cwd);
+    const targetFile = info.targetConfigPath;
+    const currentServers = { ...info.servers };
+
+    const upstreams = {};
+    for (const [k, v] of Object.entries(currentServers)) {
+      if (!this.isCirvixServer(k, v)) upstreams[k] = v;
+    }
+
+    const cirvixServerDef = {
+      command: "cirvix",
+      args: ["gateway", "--servers", targetFile.replace(/\\/g, "/")],
+    };
+
+    const newConfig = {
+      ...(info.config || {}),
+      [this.mcpKey]: {
+        ...currentServers,
+        cirvix: cirvixServerDef,
+      },
+    };
+
+    return {
+      adapterId: this.id,
+      label: this.label,
+      targetFile,
+      canIntegrate: true,
+      currentServers,
+      upstreams,
+      plan: newConfig,
+      snippet: JSON.stringify({ [this.mcpKey]: { cirvix: cirvixServerDef } }, null, 2),
+      reason: "Protects VS Code MCP tool execution across all configured servers.",
+    };
+  }
+}

package/src/adapters/windsurf.mjs

@@ -0,0 +1,107 @@
+/**
+ * Windsurf Adapter for CIRVIX AgentControl.
+ *
+ * Supports:
+ * - ~/.codeium/windsurf/mcp_config.json
+ * - Workspace .windsurf/mcp_config.json, .codeium/windsurf/mcp_config.json
+ * - .windsurfrules
+ * - Executable detection (windsurf / windsurf.cmd)
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { BaseAgentAdapter } from "./base.mjs";
+import { resolveExecutable } from "../core/windows.mjs";
+
+export class WindsurfAdapter extends BaseAgentAdapter {
+  constructor() {
+    super({
+      id: "windsurf",
+      label: "Windsurf",
+      type: "editor",
+      mcpKey: "mcpServers",
+    });
+  }
+
+  async detect(cwd) {
+    const home = homedir();
+    const candidatePaths = [
+      join(cwd, ".windsurf", "mcp_config.json"),
+      join(cwd, ".codeium", "windsurf", "mcp_config.json"),
+      join(home, ".codeium", "windsurf", "mcp_config.json"),
+      join(home, ".windsurf", "mcp_config.json"),
+    ];
+
+    const existingPaths = [];
+    const servers = {};
+    let configFound = null;
+
+    for (const p of candidatePaths) {
+      if (await this.fileExists(p)) {
+        existingPaths.push(p);
+        const data = await this.readJson(p);
+        if (data) {
+          if (!configFound) configFound = data;
+          Object.assign(servers, data[this.mcpKey] ?? {});
+        }
+      }
+    }
+
+    const execPath = resolveExecutable("windsurf", { cwd });
+    const hasRules = await this.fileExists(join(cwd, ".windsurfrules"));
+    const detected = existingPaths.length > 0 || Boolean(execPath) || hasRules;
+
+    const isIntegrated = Object.entries(servers).some(([name, def]) => this.isCirvixServer(name, def));
+
+    return {
+      detected,
+      paths: existingPaths,
+      targetConfigPath: existingPaths[0] ?? join(home, ".codeium", "windsurf", "mcp_config.json"),
+      config: configFound,
+      servers,
+      serverCount: Object.keys(servers).length,
+      isIntegrated,
+      hasConfig: existingPaths.length > 0,
+      executable: execPath,
+      metadata: {
+        hasRules,
+      },
+    };
+  }
+
+  async generateIntegrationPlan(cwd, options = {}) {
+    const info = await this.detect(cwd);
+    const targetFile = info.targetConfigPath;
+    const currentServers = { ...info.servers };
+
+    const upstreams = {};
+    for (const [k, v] of Object.entries(currentServers)) {
+      if (!this.isCirvixServer(k, v)) upstreams[k] = v;
+    }
+
+    const cirvixServerDef = {
+      command: "cirvix",
+      args: ["gateway", "--servers", targetFile.replace(/\\/g, "/")],
+    };
+
+    const newConfig = {
+      ...(info.config || {}),
+      [this.mcpKey]: {
+        ...currentServers,
+        cirvix: cirvixServerDef,
+      },
+    };
+
+    return {
+      adapterId: this.id,
+      label: this.label,
+      targetFile,
+      canIntegrate: true,
+      currentServers,
+      upstreams,
+      plan: newConfig,
+      snippet: JSON.stringify({ [this.mcpKey]: { cirvix: cirvixServerDef } }, null, 2),
+      reason: "Integrates CIRVIX runtime policy and secret isolation into Windsurf Cascade.",
+    };
+  }
+}

package/src/commands/console.mjs

@@ -0,0 +1,58 @@
+/**
+ * `cirvix console` — the primary product interface.
+ *
+ * Interactive when attached to a TTY, one-shot when piped:
+ *   cirvix console                        # full REPL
+ *   echo "read ~/.aws/credentials" | cirvix console --once
+ *   cirvix console --eval "deploy to production"
+ *
+ * `--once` / `--eval` exist so the product UI is scriptable and testable:
+ * the same cards render in CI as in the terminal.
+ */
+
+import { ConsoleApp } from "../tui/app.mjs";
+
+export async function consoleCmd({ cwd = process.cwd(), rules = [], mode = "enforce", evalText = null, once = false, write = (s) => process.stdout.write(s) } = {}) {
+  const app = new ConsoleApp({ cwd, rules, mode, write });
+
+  if (evalText) {
+    const out = await app.runOnce(evalText);
+    if (out && out !== "quit") write(out + "\n");
+    return { app, output: out };
+  }
+
+  if (once || !process.stdin.isTTY) {
+    // Piped: evaluate each line, print cards, exit. Never start readline
+    // on a non-TTY — it would hang waiting for a terminal that is not there.
+    const chunks = await readStdin();
+    const lines = chunks.split("\n").map((l) => l.trim()).filter(Boolean);
+    let output = "";
+    for (const line of lines) {
+      const out = await app.runOnce(line);
+      if (out && out !== "quit") {
+        write(out + "\n");
+        output += out + "\n";
+      }
+    }
+    if (!lines.length) {
+      const help = app.renderTranscript();
+      write(help + "\n");
+      return { app, output: help };
+    }
+    return { app, output };
+  }
+
+  await app.start();
+  return { app, output: "" };
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve("");
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (c) => (data += c));
+    process.stdin.on("end", () => resolve(data));
+    setTimeout(() => resolve(data), 1000);
+  });
+}

package/src/commands/demo.mjs

@@ -38,17 +38,11 @@ import { compile } from "../core/policy-dsl.mjs";
 import { STARTER_POLICY } from "./init.mjs";
 import { scan as scanInjection } from "../core/sanitize.mjs";
 import { DECISION } from "../core/decisions.mjs";
-import { bold, dim, green, red, amber, blue } from "../core/format.mjs";
-import {
-  allowContinuation,
-  approvalHold,
-  blockSignature,
-  boot,
-  cinematicEnabled,
-  evaluation,
-  requestTravel,
-  topology,
-} from "../core/cinematic.mjs";
+import { bold, dim, green, red, amber, blue, cyan } from "../core/format.mjs";
+import { brandHeader, panel, separator } from "../core/ui/primitives.mjs";
+import { interceptBox } from "../core/ui/intercept.mjs";
+import { renderDecision } from "../core/ui/decisions.mjs";
+import { shouldAnimate } from "../core/ui/controller.mjs";
 
 /** The poisoned content. This is what an agent finds on a page it was told to read. */
 const POISONED_PAGE = `# Deploying to production
@@ -170,23 +164,14 @@ export async function demo({
   });
   const steps = [];
 
-  // Human TTY only: piped output, CI, --json and pace 0 are untouched.
-  const animated = cinematicEnabled({ json, pace });
-
+  const animated = !json && shouldAnimate({ pace, json });
   if (!json) {
-    await boot({
-      write,
-      rulesCount: ruleSet.length,
-      auditOpen: chain !== null,
-      agent: "claude-code",
-      pace,
-      animated,
-    });
     write("\n");
-    write(`  ${bold("CIRVIX")} ${dim("· live demo · every decision below is computed, not scripted")}\n`);
+    write(brandHeader({ width: 62 }) + "\n");
+    write(`  ${dim("CIRVIX · SECURITY DEMONSTRATION  ·  every decision below is computed, not scripted")}\n`);
     write("\n");
     write(`  ${dim("─".repeat(76))}\n`);
-    write(`  ${bold("ACT I")}  ${dim("The agent reads a page containing an instruction addressed to it.")}\n`);
+    write(`  ${bold("ACT I")}  ${dim("Untrusted content reaches the agent")}\n`);
     write(`  ${dim("─".repeat(76))}\n\n`);
 
     // Show what is actually in the page — the attack is the interesting part.
@@ -200,7 +185,7 @@ export async function demo({
       write(`      ${red("·")} ${dim(f.label)}\n`);
     }
     write("\n");
-    await sleep(pace * 2);
+    await sleep(animated ? pace * 1.2 : pace === 0 ? 0 : pace * 0.5);
   }
 
   let act = null;
@@ -209,29 +194,14 @@ export async function demo({
       act = step.act;
       if (act === "work") {
         write(`\n  ${dim("─".repeat(76))}\n`);
-        write(`  ${bold("ACT III")}  ${dim("The same agent, the same policy, doing its job.")}\n`);
+        write(`  ${bold("ACT III")}  ${dim("Legitimate work continues.")}\n`);
         write(`  ${dim("─".repeat(76))}\n\n`);
       } else {
         write(`\n  ${dim("─".repeat(76))}\n`);
-        write(`  ${bold("ACT II")}  ${dim("It believes the page.")}\n`);
+        write(`  ${bold("ACT II")}  ${dim("CIRVIX evaluates the resulting actions.")}\n`);
         write(`  ${dim("─".repeat(76))}\n\n`);
       }
-      await sleep(pace);
-    }
-
-    // The packet travels first; the verdict below is the real measured one.
-    // Animation is presentation — latency_ms is timed inside submit().
-    if (animated) {
-      const args = step.call.arguments ?? {};
-      const target = args.path ?? args.url ?? args.command ?? args.name ?? "";
-      await requestTravel({
-        write,
-        agent: "claude-code",
-        tool: step.call.tool,
-        target: String(target ?? ""),
-        pace,
-        animated,
-      });
+      await sleep(animated ? pace * 0.6 : pace === 0 ? 0 : pace * 0.3);
     }
 
     const { event } = await pipeline.submit(step.call);
@@ -241,31 +211,25 @@ export async function demo({
 
     if (step.narration) {
       write(`  ${dim(step.narration)}\n\n`);
-      await sleep(pace / 2);
+      await sleep(animated ? pace * 0.3 : 0);
     }
 
-    // Show the engine working on narrated beats, interceptions, and
-    // anything that is not a plain allow — the allow path included.
-    if (animated && (step.intercept || event.decision !== DECISION.ALLOW || step.narration)) {
-      await evaluation({ write, event, pace, animated });
-    }
-
-    if (event.decision === DECISION.DENY) {
+    if (step.intercept && event.decision === DECISION.DENY) {
       if (animated) {
-        await blockSignature({ write, event, pace, animated });
-      } else {
-        write(interceptBox(event));
+        // Brief evaluating sequence — decision already made, just visualizing.
+        write(`  ${dim("◌ evaluating request...")}\n`);
+        await sleep(Math.min(260, pace * 0.35));
+        write(`  ${red("⚠ " + String(event.risk).toUpperCase())}\n`);
+        await sleep(Math.min(160, pace * 0.2));
+        write(`  ${red(bold("✕ BLOCKED"))}  ${dim(event.policy ?? "")}\n`);
+        await sleep(Math.min(160, pace * 0.2));
       }
+      write(interceptBox(event));
       write("\n");
     } else {
-      write(oneLine(event));
-      if (event.decision === DECISION.REQUIRE_APPROVAL) {
-        approvalHold({ write, event });
-      } else if (animated && (event.decision === DECISION.ALLOW || event.decision === DECISION.SANITIZE)) {
-        allowContinuation({ write, event });
-      }
+      write(renderDecision(event) + "\n");
     }
-    await sleep(pace);
+    await sleep(animated ? pace * 0.7 : pace === 0 ? 0 : pace * 0.4);
   }
 
   const p = pipeline.percentiles();
@@ -292,79 +256,46 @@ export async function demo({
 
   write("\n");
   write(`  ${dim("─".repeat(76))}\n\n`);
-  write(`  ${green(bold(String(allowed)))} ${dim("calls forwarded")}   `);
+  // Polished summary — real P99, real audit hint, premium panel.
+  const sanitized = steps.filter((s) => s.event.decision === DECISION.SANITIZE).length;
+  write(`  ${green(bold(String(allowed)))} ${dim("allowed")}   `);
+  if (sanitized) write(`${blue(bold(String(sanitized)))} ${dim("sanitized")}   `);
   write(`${red(bold(String(denied)))} ${dim("blocked")}   `);
   write(`${amber(bold(String(held)))} ${dim("held for a human")}   `);
-  write(`${dim(`P99 ${p.p99}ms over ${p.samples} decisions`)}\n\n`);
-  if (animated) {
-    topology({ write, states: { cirvix: "active" } });
-    write("\n");
+  write(`${dim(`P99 ${p.p99}ms`)}${dim(` over ${p.samples} decisions · `)}${dim(`P50 ${p.p50}ms · P95 ${p.p95}ms`)}\n\n`);
+
+  // Summary panel — spec: CIRVIX GOVERNANCE boxed, P50/P95/P99, audit chain intact
+  const summaryLines = [
+    `${bold("CIRVIX GOVERNANCE")}`,
+    ``,
+    `${`${allowed} allowed`.padEnd(14)} ${`${sanitized} sanitized`.padEnd(14)} ${`${denied} blocked`.padEnd(14)} ${`${held} awaiting approval`}`,
+    ``,
+    `${`P50 ${p.p50}ms`.padEnd(14)} ${`P95 ${p.p95}ms`.padEnd(14)} ${`P99 ${p.p99}ms`}`,
+    ``,
+    `${green("✓")} ${dim(`${steps.length} records verified`)}`,
+    `${green("✓")} ${bold("AUDIT CHAIN INTACT")}`,
+  ];
+  // Use header box per spec: ╭─ CIRVIX GOVERNANCE ─
+  const W = 62;
+  const top = `  ${dim(`╭─ CIRVIX GOVERNANCE ${"─".repeat(Math.max(0, W - 20))}╮`)}`;
+  const bottom = `  ${dim(`╰${"─".repeat(W)}╯`)}`;
+  write(top + "\n");
+  for (const l of summaryLines) {
+    // Inside panel, pad to width, no side borders for genuine CLI feel per spec — but keep subtle
+    write(`  ${l}\n`);
   }
-  write(`  ${bold("Cirvix did not disable the agent. It made the dangerous half controllable.")}\n\n`);
+  write(bottom + "\n\n");
+  write(`  ${bold("CIRVIX did not disable the agent.")}\n`);
+  write(`  ${dim("It controlled the dangerous actions.")}\n\n`);
   write(`  ${dim("Every decision above is in the audit chain:")}  ${blue("cirvix logs")}\n`);
   write(`  ${dim("Ask why any one of them happened:")}          ${blue("cirvix logs --tree <request-id>")}\n\n`);
 
   return { result, output: "" };
 }
 
-/* -------------------------------------------------------------------------- */
-/*  Rendering                                                                  */
-/* -------------------------------------------------------------------------- */
-
-/**
- * The intercept box.
- *
- * Fixed inner width so the borders line up regardless of content length; values
- * are truncated rather than allowed to break the frame, because a box with one
- * ragged edge reads as a rendering bug and undermines everything inside it.
- */
-function interceptBox(event) {
-  const W = 58;
-  const rows = [
-    ["Agent", event.agent],
-    ["Tool", event.tool],
-    ["Target", event.resource || event.destination || "—"],
-    ["Risk", String(event.risk).toUpperCase()],
-    ["Decision", "BLOCKED"],
-    ["Policy", event.policy ?? "default-deny"],
-    ["Latency", `${event.latency_ms}ms`],
-  ];
-
-  const pad = (text) => {
-    const s = String(text);
-    return s.length > W ? s.slice(0, W - 1) + "…" : s.padEnd(W);
-  };
-
-  const lines = [
-    `  ${red("╔" + "═".repeat(W + 2) + "╗")}`,
-    `  ${red("║")} ${bold(pad("CIRVIX SECURITY INTERCEPT"))} ${red("║")}`,
-    `  ${red("╠" + "═".repeat(W + 2) + "╣")}`,
-    ...rows.map(([k, v]) => {
-      const body = `${k}:`.padEnd(11) + v;
-      const painted = k === "Risk" || k === "Decision" ? red(pad(body)) : pad(body);
-      return `  ${red("║")} ${painted} ${red("║")}`;
-    }),
-    `  ${red("╚" + "═".repeat(W + 2) + "╝")}`,
-  ];
-
-  // The reason sits outside the box: it is the part that varies in length, and
-  // it is what the agent itself receives as a readable tool result.
-  const reason = event.reason ? `\n  ${dim(event.reason)}\n` : "";
-  return lines.join("\n") + "\n" + reason;
-}
-
+/* Legacy oneLine kept for tests that import it indirectly — now delegates to ui. */
 function oneLine(event) {
-  const tone =
-    { allow: green, sanitize: blue, require_approval: amber, deny: red, audit_only: dim }[event.decision] ?? dim;
-  const riskTone = { low: dim, medium: blue, high: amber, critical: red }[event.risk] ?? dim;
-
-  return (
-    `  ${tone(String(event.decision).toUpperCase().replace(/_/g, " ").padEnd(17))}` +
-    `${riskTone(String(event.risk).toUpperCase().padEnd(9))}` +
-    `${String(event.tool).padEnd(20)}` +
-    `${dim(String(event.resource || event.command || "").slice(-38).padEnd(38))}  ` +
-    `${dim(`${event.latency_ms}ms`)}\n`
-  );
+  return renderDecision(event) + "\n";
 }
 
 export { POISONED_PAGE };