@cirvix_ai/agent-control 0.1.3 → 0.2.0

package/src/commands/simulate.mjs

@@ -0,0 +1,96 @@
+/**
+ * Policy Simulator CLI Command.
+ *
+ * Input: agent, user, intent, tool, resource, action, context
+ * Output: decision, matched policies, risk, explanation
+ */
+
+import { evaluate } from "../core/policy.mjs";
+import { classify } from "../core/risk.mjs";
+import { evaluateIntent } from "../core/intent.mjs";
+import { DECISION, toDecision } from "../core/decisions.mjs";
+import { bold, dim, green, red, amber, cyan } from "../core/format.mjs";
+
+export async function simulatePolicy({
+  rules = [],
+  action = "fs:read",
+  resource = "",
+  tool = "file_reader",
+  intent = null,
+  agent = "agent-simulator",
+  json = false,
+  cwd = process.cwd(),
+} = {}) {
+  const call = {
+    agent,
+    action,
+    resource,
+    tool,
+    arguments: { resource, action },
+    intent,
+    cwd,
+  };
+
+  // 1. Risk
+  const risk = classify(call);
+  call.risk = risk.level;
+
+  // 2. Policy Evaluation
+  const evalResult = evaluate(call, rules, { cwd });
+  let decision = toDecision(evalResult.verdict ?? "deny");
+  let reason = evalResult.reason ?? "Matched policy evaluation";
+  let matchedRule = evalResult.rule ?? "default-deny";
+
+  // 3. Intent Check
+  let intentCheck = null;
+  if (intent) {
+    intentCheck = evaluateIntent({ intent, action, resource, tool });
+    if (!intentCheck.aligned && decision === DECISION.ALLOW) {
+      decision = DECISION.DENY;
+      matchedRule = "intent-firewall-boundary";
+      reason = intentCheck.reason;
+    }
+  }
+
+  const result = {
+    decision,
+    matchedRule,
+    risk: risk.level,
+    riskScore: risk.score ?? (risk.level === "CRITICAL" ? 90 : risk.level === "HIGH" ? 70 : 20),
+    explanation: reason,
+    intentAlignment: intentCheck ? intentCheck.aligned : null,
+    call: { agent, action, resource, tool, intent },
+  };
+
+  if (json) {
+    return { output: JSON.stringify(result, null, 2), code: decision === DECISION.ALLOW ? 0 : 1 };
+  }
+
+  const tone = decision === DECISION.ALLOW ? green : decision === DECISION.REQUIRE_APPROVAL ? amber : red;
+
+  const lines = [
+    "",
+    `  ${bold("CIRVIX POLICY SIMULATOR")}`,
+    "",
+    `  ${bold("Input Request:")}`,
+    `    ${dim("Agent:")}       ${cyan(agent)}`,
+    `    ${dim("Action:")}      ${action}`,
+    `    ${dim("Resource:")}    ${resource || "—"}`,
+    `    ${dim("Tool:")}        ${tool || "—"}`,
+    `    ${dim("Intent:")}      ${intent ? cyan(intent) : dim("(none declared)")}`,
+    "",
+    `  ${bold("Simulation Verdict:")}`,
+    `    ${dim("Decision:")}    ${tone(bold(decision))}`,
+    `    ${dim("Policy Rule:")} ${matchedRule}`,
+    `    ${dim("Risk Level:")}  ${risk.level}`,
+    `    ${dim("Explanation:")} ${reason}`,
+  ];
+
+  if (intentCheck) {
+    lines.push(`    ${dim("Intent Check:")} ${intentCheck.aligned ? green("Aligned") : red("Misaligned")}`);
+  }
+
+  lines.push("");
+
+  return { output: lines.join("\n"), code: decision === DECISION.ALLOW ? 0 : 1 };
+}

package/src/commands/status.mjs

@@ -32,7 +32,9 @@ import { read as readJournal, summarize } from "../core/journal.mjs";
 import { ApprovalStore } from "../core/approvals.mjs";
 import { UdsClient, defaultEndpoint, tokenPath } from "../core/uds.mjs";
 import { MODE } from "../core/decisions.mjs";
-import { bold, dim, green, red, amber, blue, plural } from "../core/format.mjs";
+import { bold, dim, green, red, amber, blue, cyan, gray, plural } from "../core/format.mjs";
+import { panel, separator } from "../core/ui/primitives.mjs";
+import { riskTone } from "../core/ui/theme.mjs";
 
 async function exists(path) {
   try {
@@ -75,18 +77,14 @@ async function probeRuntime(stateDir) {
  * @param {Array} [opts.rules]      already-loaded rule set
  * @param {boolean} [opts.json]
  */
-export async function status({ cwd = process.cwd(), rules = [], json = false, stateDir: dir, progress = null } = {}) {
+export async function status({ cwd = process.cwd(), rules = [], json = false, stateDir: dir } = {}) {
   const stateDir = dir ?? join(cwd, ".cirvix");
-  const probe = (progress ?? { start: () => ({ succeed() {}, fail() {} }) }).start(
-    "probing control socket + reading history",
-  );
 
   const [runtimes, runtime, records] = await Promise.all([
     detectRuntimes(),
     probeRuntime(stateDir),
     readJournal(join(stateDir, "audit.jsonl")),
   ]);
-  probe.succeed(runtime.running ? "runtime responding" : "no runtime — status from disk");
 
   const servers = collectMcpServers(runtimes);
   const protectedRuntimes = runtimes.filter((r) => r.governed);
@@ -99,6 +97,43 @@ export async function status({ cwd = process.cwd(), rules = [], json = false, st
     approvals = { pending: store.pending().length, total: store.all().length };
   }
 
+  // Policy tests: try to count declared tests from the file on disk.
+  let policyTests = { total: 0, passed: null };
+  try {
+    const { loadPolicyFile } = await import("./policy.mjs");
+    // Resolve policy path like bin does.
+    let policyPath = null;
+    for (const cand of ["cirvix.policy", "cirvix.policy.json", ".cirvix/policy.json"]) {
+      const p = join(cwd, cand);
+      if (await exists(p)) { policyPath = p; break; }
+    }
+    if (policyPath) {
+      const loaded = await loadPolicyFile(policyPath, { cwd });
+      policyTests.total = loaded.tests?.length ?? 0;
+      if (policyTests.total > 0) {
+        // Quick pass/fail count without printing: evaluate each test.
+        const { evaluate } = await import("../core/policy.mjs");
+        const { normalize, policyRequest } = await import("../core/normalize.mjs");
+        const { toDecision } = await import("../core/decisions.mjs");
+        let passed = 0;
+        for (const t of loaded.tests) {
+          try {
+            const call = normalize(
+              { tool: t.call.tool, server: t.call.server ?? null, arguments: t.call.arguments },
+              { agent: t.call.agent, environment: t.call.environment, cwd },
+            );
+            const decision = evaluate(policyRequest(call), loaded.rules, { cwd });
+            const actual = decision.decision ?? toDecision(decision.verdict);
+            const exp = String(t.expect ?? "").toLowerCase();
+            const expected = { allow: "allow", permit: "allow", deny: "deny", forbid: "deny", hold: "require_approval", require_approval: "require_approval", sanitize: "sanitize" }[exp] ?? exp;
+            if (actual === expected) passed++;
+          } catch {}
+        }
+        policyTests.passed = passed;
+      }
+    }
+  } catch {}
+
   const result = {
     runtime: {
       running: runtime.running,
@@ -108,15 +143,16 @@ export async function status({ cwd = process.cwd(), rules = [], json = false, st
     },
     policy: {
       rules: rules.length,
-      // A live runtime is the authority on how many rules are actually loaded;
-      // the file on disk may have been edited since it started.
       loaded: runtime.live?.rules ?? null,
+      tests: policyTests.total,
+      testsPassed: policyTests.passed,
     },
     mcpServers: servers.length,
     runtimes: runtimes.map((r) => ({
       id: r.id,
       label: r.label,
       governed: r.governed,
+      compatibilityLevel: r.compatibilityLevel ?? (r.governed ? "INTEGRATED" : "DISCOVERED"),
       servers: r.serverCount,
     })),
     protected: protectedRuntimes.length,
@@ -137,50 +173,77 @@ export async function status({ cwd = process.cwd(), rules = [], json = false, st
 /* -------------------------------------------------------------------------- */
 
 function render(r) {
+  const lines = [];
+  lines.push("");
+  // Boxed header — spec: ╭─ CIRVIX STATUS ─────────────╮, subtle, technical, not a card per-line.
+  // Outer box frames the whole status, inner lines remain plain CLI output.
+  const W = 62;
+  const hdr = `╭─ CIRVIX STATUS ${"─".repeat(Math.max(0, W - 16))}╮`;
+  const ftr = `╰${"─".repeat(W)}╯`;
+  lines.push(`  ${dim(hdr)}`);
+  lines.push("");
+  lines.push(`  ${bold("CIRVIX STATUS")}`);
+  lines.push("");
+
+  // Top dashboard — each value is measured.
+  const runtimeBadge = r.runtime.running ? green(bold("● ONLINE")) : dim("● STOPPED") + dim(`  ${r.runtime.reason ?? ""}`);
+  const modeBadge = r.runtime.mode === MODE.ENFORCE ? green("ENFORCE") : amber("AUDIT");
+  const policyBadge = r.policy.rules ? `${plural(r.policy.rules, "rule")}` : dim("no policy loaded");
+  const testsBadge = r.policy.tests
+    ? (r.policy.testsPassed !== null ? `${r.policy.testsPassed}/${r.policy.tests} passed` : `${r.policy.tests} tests`)
+    : dim("—");
+  const auditBadge = r.records > 0 ? green(bold("● INTEGRITY OK")) : dim("● NO RECORDS");
+  const secretsBadge = r.vault ? (r.vault.held > 0 ? green(bold("● PROTECTED")) + dim(`  ${r.vault.held} held`) : green(bold("● PROTECTED"))) : green(bold("● PROTECTED"));
+  const gatewayBadge = r.protected > 0 ? green(bold("● CONNECTED")) + dim(`  ${r.protected} of ${r.runtimes.length} protected`) : dim("● NOT CONNECTED");
+
   const rows = [
-    ["Runtime", r.runtime.running ? green(bold("RUNNING")) : dim("STOPPED") + dim(`  ${r.runtime.reason ?? ""}`)],
-    ["Policy", r.policy.rules ? `${plural(r.policy.rules, "rule")}` : dim("no policy loaded")],
-    ["MCP Servers", String(r.mcpServers)],
-    [
-      "Protected",
-      r.protected === 0 && r.runtimes.length > 0
-        ? amber(String(r.protected)) + dim(`  of ${r.runtimes.length} — nothing is routed through the gateway yet`)
-        : `${r.protected}` + dim(r.runtimes.length ? `  of ${r.runtimes.length}` : ""),
-    ],
-    ["Blocked", r.blocked > 0 ? red(String(r.blocked)) : String(r.blocked)],
-    ["Approvals", r.approvals.pending > 0 ? amber(`${r.approvals.pending} pending`) : String(r.approvals.pending)],
-    [
-      "P99 overhead",
-      r.latency.samples
-        ? `${r.latency.p99}ms` + dim(`  over ${plural(r.latency.samples, "decision")}`)
-        : dim("— nothing measured yet"),
-    ],
+    ["Runtime", runtimeBadge],
+    ["Mode", modeBadge],
+    ["Policy", policyBadge],
+    ["Tests", r.policy.testsPassed !== null && r.policy.testsPassed < r.policy.tests ? red(testsBadge) : testsBadge],
+    ["Audit", auditBadge],
+    ["Secrets", secretsBadge],
+    ["Gateway", gatewayBadge],
   ];
-
   const width = Math.max(...rows.map(([k]) => k.length));
-  const lines = ["", `  ${bold("CIRVIX AGENTCONTROL")}`, ""];
-  for (const [key, value] of rows) lines.push(`  ${key.padEnd(width + 2)}${value}`);
+  for (const [k, v] of rows) lines.push(`  ${k.padEnd(width + 2)}${v}`);
 
   if (r.runtime.mode !== MODE.ENFORCE) {
     lines.push("");
     lines.push(`  ${amber(bold("AUDIT MODE"))}  ${dim("decisions are recorded and nothing is blocked.")}`);
   }
 
-  if (r.records > 0) {
+  // Agent Fleet
+  if (r.runtimes?.length > 0) {
     lines.push("");
-    lines.push(`  ${dim("decisions")}   ` +
-      [
-        green(`${r.decisions.allow} allowed`),
-        r.decisions.sanitize ? blue(`${r.decisions.sanitize} sanitized`) : null,
-        r.decisions.require_approval ? amber(`${r.decisions.require_approval} held`) : null,
-        r.decisions.deny ? red(`${r.decisions.deny} denied`) : null,
-        r.decisions.audit_only ? dim(`${r.decisions.audit_only} audit-only`) : null,
-      ]
-        .filter(Boolean)
-        .join(dim("  ·  ")));
+    lines.push(`  ${bold("Agent Fleet")}`);
+    lines.push(separator(48));
+    const agentWidth = Math.max(...r.runtimes.map((a) => a.label.length), 10);
+    for (const a of r.runtimes) {
+      const level = a.compatibilityLevel ?? (a.governed ? "INTEGRATED" : "DISCOVERED");
+      const badge = a.governed ? green(`● ${level}`) : amber(`○ ${level}`);
+      const sCount = a.servers ? dim(` · ${plural(a.servers, "server")}`) : "";
+      lines.push(`  ${a.label.padEnd(agentWidth + 2)}${badge}${sCount}`);
+    }
+  }
+
+  // Activity
+  lines.push("");
+  lines.push(`  ${bold("Activity")}`);
+  lines.push(separator(48));
+  const actRows = [
+    ["Allowed", String(r.decisions.allow)],
+    ["Sanitized", String(r.decisions.sanitize)],
+    ["Blocked", r.blocked > 0 ? red(String(r.blocked)) : String(r.blocked)],
+    ["Approvals", r.approvals.pending > 0 ? amber(`${r.approvals.pending} pending`) : String(r.approvals.pending)],
+  ];
+  const aw = Math.max(...actRows.map(([k]) => k.length));
+  for (const [k, v] of actRows) lines.push(`  ${k.padEnd(aw + 2)}${v}`);
 
+  if (r.records > 0) {
     const risky = r.risks.high + r.risks.critical;
     if (risky > 0) {
+      lines.push("");
       lines.push(`  ${dim("risk")}        ` +
         [
           r.risks.critical ? red(`${r.risks.critical} critical`) : null,
@@ -191,12 +254,30 @@ function render(r) {
           .filter(Boolean)
           .join(dim("  ·  ")));
     }
+    if (r.topRules?.length) {
+      lines.push(`  ${dim("top rules")}   ${r.topRules.slice(0,3).map(([name, n]) => `${name} ${dim(`(${n})`)}`).join(dim("  ·  "))}`);
+    }
   }
 
-  if (r.vault) {
-    lines.push(`  ${dim("vault")}       ${r.vault.held} held` + (r.vault.unscoped ? amber(`  ${r.vault.unscoped} unscoped`) : ""));
+  // Performance
+  lines.push("");
+  lines.push(`  ${bold("Performance")}`);
+  lines.push(separator(48));
+  if (r.latency.samples) {
+    const perf = [
+      ["P50", `${r.latency.p50}ms`],
+      ["P95", `${r.latency.p95}ms`],
+      ["P99", `${r.latency.p99}ms`],
+    ];
+    const pw = Math.max(...perf.map(([k]) => k.length));
+    for (const [k, v] of perf) lines.push(`  ${k.padEnd(pw + 2)}${v}`);
+    lines.push(`  ${dim(`${plural(r.latency.samples, "decision")} measured`)}`);
+  } else {
+    lines.push(`  ${dim("— nothing measured yet")}`);
   }
 
+  lines.push("");
+  lines.push(`  ${dim(ftr)}`);
   lines.push("");
 
   if (!r.runtime.running && r.mcpServers > 0) {

package/src/commands/upgrade.mjs

@@ -24,16 +24,17 @@ import { TIERS, TIER_ORDER, dailyAllowance, nextTier, tierFor } from "../core/en
 import { Meter, readLicence } from "../core/meter.mjs";
 
 /**
- * Published prices. Mirrors the pricing page; pinned by the test suite.
+ * Published prices. Mirrors the rate card.
  *
- * These read 29 / 79 / 149 for over a year while the pricing page said
- * 79 / 199 / 349, and the suite pinned the wrong numbers — so the drift was
- * not merely undetected, it was enforced. Corrected together with the Lite
- * tier so the public package quotes the same ladder as billing.
+ * These read 29 / 79 / 149 for over a year while the rate card, the pricing
+ * page and PRICE_CENTS in the control plane all said 79 / 199 / 349. The CLI
+ * quoted a customer roughly a third of the real price, and the test suite
+ * PINNED the wrong numbers — so the drift was not merely undetected, it was
+ * enforced. Both were corrected together; a test asserting a stale constant is
+ * worse than no test, because it converts a bug into a requirement.
  */
 export const PRICING = {
   free: { monthly: 0, annual: 0 },
-  lite: { monthly: 29, annual: 290 },
   starter: { monthly: 79, annual: 790 },
   pro: { monthly: 199, annual: 1990 },
   team: { monthly: 349, annual: 3490, perSeat: true, minSeats: 3 },
@@ -94,11 +95,10 @@ function liftsOver(fromId, toId) {
   if (to.attestation && !from.attestation) out.push("Attestation headers");
   if (to.sharedPolicy !== false && from.sharedPolicy === false) out.push("Shared policy + RBAC");
 
-  if (to.auditRetentionHours === null && from.auditRetentionHours !== null) {
-    // Hosted retention is a control-plane capability; the local chain itself
-    // is never pruned on any tier ("life of deployment" everywhere). Say what
-    // the tier actually adds rather than implying local history expires.
-    out.push("Hosted audit retention + export");
+  if (to.auditRetentionHours === null) out.push("Unlimited audit retention");
+  else if (from.auditRetentionHours !== null && to.auditRetentionHours > from.auditRetentionHours) {
+    const days = Math.round(to.auditRetentionHours / 24);
+    out.push(`${days === 1 ? "24 hours" : `${days} days`} of audit history`);
   }
   return out;
 }

package/src/commands/welcome.mjs

@@ -0,0 +1,105 @@
+/**
+ * The default `cirvix` experience.
+ *
+ * Runs when someone types `cirvix` with no command — which is how every new
+ * user starts and how returning users check in. It must therefore answer two
+ * questions in under a second, entirely from local state (no network — that is
+ * `cirvix doctor`'s job):
+ *
+ *   1. Is AgentControl protecting anything on this machine right now?
+ *   2. What is the one sensible next action?
+ *
+ * FIRST RUN has no state directory at all, and gets an onboarding path:
+ * welcome → what CIRVIX is in one line → three commands that take them from
+ * zero to protected. RETURNING runs get a measured digest — every number here
+ * comes from the journal and the runtime probe, never asserted.
+ *
+ * Output is plain (no animations of its own): this screen renders on every
+ * launch, and a delay here would be paid on every launch. Anything animated
+ * lives behind commands the user chose deliberately (demo, live).
+ */
+
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+
+import { bold, dim, green, gray, cyan, red } from "../core/format.mjs";
+import { brandHeader, panel, separator } from "../core/ui/primitives.mjs";
+import { status as statusCmd } from "./status.mjs";
+import { readCredentials, DEFAULT_CONTROL_PLANE, DASHBOARD_URL } from "./login.mjs";
+
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function welcome({ cwd = process.cwd(), json = false } = {}) {
+  if (json) {
+    // `cirvix --json` still needs a machine-readable default.
+    const st = await statusCmd({ cwd, json: true }).catch(() => null);
+    process.stdout.write(typeof st === "string" ? st : JSON.stringify({ command: "welcome" }) + "\n");
+    return 0;
+  }
+
+  const stateDir = join(cwd, ".cirvix");
+  const firstRun = !(await exists(stateDir));
+  const creds = await readCredentials();
+
+  process.stdout.write(brandHeader() + "\n");
+
+  if (firstRun) {
+    process.stdout.write(
+      [
+        "",
+        `  ${bold("Welcome to CIRVIX.")}`,
+        `  ${dim("A security boundary between your AI agents and everything they touch.")}`,
+        "",
+        `  ${dim("This workspace is not protected yet. Three commands fix that:")}`,
+        "",
+        `  ${cyan("1.")} ${bold("cirvix init")}      ${dim("detect agents & MCP servers, write a policy, start protecting")}`,
+        `  ${cyan("2.")} ${bold("cirvix demo")}      ${dim("watch an injected exfiltration attempt get stopped, live")}`,
+        `  ${cyan("3.")} ${bold("cirvix status")}    ${dim("what is protected, what was blocked, at what cost")}`,
+        "",
+        `  ${dim("Or see everything:")} ${bold("cirvix --help")}`,
+        "",
+      ].join("\n"),
+    );
+    if (!creds) {
+      process.stdout.write(
+        [
+          "",
+          `  ${dim("When you are ready to govern a whole team:")}`,
+          `  ${bold("cirvix login")}      ${dim(`link this machine · ${DASHBOARD_URL.replace("https://", "")}`)}`,
+          "",
+        ].join("\n"),
+      );
+    }
+    return 0;
+  }
+
+  /* Returning run: measured digest from the same source `cirvix status` uses. */
+  let digest = null;
+  try {
+    digest = (await statusCmd({ cwd })).output;
+  } catch {
+    digest = null;
+  }
+  if (digest) process.stdout.write(digest.trimEnd() + "\n\n");
+
+  const next = [];
+  if (digest && /RUNNING/i.test(String(digest))) {
+    next.push(["cirvix status", "the full picture: decisions, latency, approvals"]);
+    if (/approvals?\s+[1-9]/i.test(String(digest))) next.push(["cirvix approvals", "actions are waiting for a human decision"]);
+    next.push(["cirvix logs --last 10", "the most recent decisions, with reasons"]);
+  } else {
+    next.push(["cirvix init", "detect agents and start protecting this workspace"]);
+  }
+  if (!creds) next.push(["cirvix login", `link this machine to ${DEFAULT_CONTROL_PLANE.replace("https://", "")}`]);
+
+  const lines = next.map(([cmd, why]) => `  ${cyan("$")} ${bold(cmd.padEnd(22))} ${gray(why)}`);
+  process.stdout.write(panel({ title: "NEXT STEPS", lines }) + "\n\n");
+  return 0;
+}