@cirvix_ai/agent-control 0.1.2 → 0.1.5

package/src/core/baseline.mjs

@@ -0,0 +1,97 @@
+/**
+ * Agent Behavioral Baseline & Anomaly Detection.
+ *
+ * Tracks normal tools, endpoints, action frequencies, and resource patterns
+ * per agent, and detects significant statistical deviations.
+ *
+ * Example:
+ *   FinanceBot normally uses: Stripe, Salesforce, PostgreSQL, Slack
+ *   New behavior: AWS IAM, unknown MCP, external crypto API
+ *   Verdict: BEHAVIORAL DEVIATION (Score: 97/100)
+ */
+
+export class BehavioralBaseline {
+  constructor({
+    agentId,
+    normalTools = [],
+    normalDomains = [],
+    normalActions = [],
+    anomalyThreshold = 75,
+    minObservationsToEnforce = 10,
+  } = {}) {
+    this.agentId = agentId;
+    this.normalTools = new Set(normalTools);
+    this.normalDomains = new Set(normalDomains);
+    this.normalActions = new Set(normalActions);
+    this.anomalyThreshold = anomalyThreshold;
+    this.minObservationsToEnforce = minObservationsToEnforce;
+    this.observationCount = 0;
+  }
+
+  /**
+   * Learns from an observed action.
+   */
+  learn({ tool = null, domain = null, action = null }) {
+    this.observationCount += 1;
+    if (tool) this.normalTools.add(tool);
+    if (domain) this.normalDomains.add(domain);
+    if (action) this.normalActions.add(action);
+  }
+
+  /**
+   * Evaluates how severely an incoming action deviates from the baseline.
+   *
+   * @param {Object} call
+   * @param {string} call.tool
+   * @param {string} call.action
+   * @param {string} call.resource
+   * @returns {{ anomalyScore: number, isDeviation: boolean, reasons: string[] }}
+   */
+  scoreDeviation({ tool = null, action = null, resource = null }) {
+    if (this.observationCount < this.minObservationsToEnforce && this.normalTools.size === 0) {
+      return {
+        anomalyScore: 0,
+        isDeviation: false,
+        reasons: ["Insufficient baseline history to calculate deviation"],
+      };
+    }
+
+    let score = 0;
+    const reasons = [];
+
+    // Check unknown tool
+    if (tool && !this.normalTools.has(tool)) {
+      score += 45;
+      reasons.push(`Unknown tool '${tool}' never observed in baseline for agent ${this.agentId}`);
+    }
+
+    // Check unknown action
+    if (action && this.normalActions.size > 0 && !this.normalActions.has(action)) {
+      score += 25;
+      reasons.push(`Unusual action '${action}' outside baseline profile`);
+    }
+
+    // Check unknown external domain/destination in resource
+    if (resource && (resource.startsWith("http://") || resource.startsWith("https://"))) {
+      try {
+        const url = new URL(resource);
+        const host = url.hostname.toLowerCase();
+        if (this.normalDomains.size > 0 && !this.normalDomains.has(host)) {
+          score += 40;
+          reasons.push(`Unseen network destination '${host}' outside baseline domains`);
+        }
+      } catch {
+        // Not a standard URL
+      }
+    }
+
+    const anomalyScore = Math.min(100, score);
+    const isDeviation = anomalyScore >= this.anomalyThreshold;
+
+    return {
+      anomalyScore,
+      isDeviation,
+      reasons,
+    };
+  }
+}

package/src/core/config-store.mjs

@@ -0,0 +1,280 @@
+/**
+ * Safe Configuration & Rollback Management for CIRVIX AgentControl.
+ *
+ * Ensures CIRVIX never silently damages, overwrites, or corrupts existing
+ * agent configurations (Claude Code, Cursor, Windsurf, Cline, Roo Code, etc.).
+ *
+ * Capabilities:
+ * - Non-destructive schema-aware JSON/JSONC parsing and serialization
+ * - Automated pre-modification backups (.cirvix/backups/<timestamp>/)
+ * - Safe transactional write with atomic replacement
+ * - Full rollback of previous configurations
+ * - Strict schema validation and circular-proxy detection
+ */
+
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { normalizeFsPath } from "./windows.mjs";
+
+/**
+ * Strips comments from JSONC (JSON with comments) strings without external deps.
+ */
+export function stripJsonComments(text) {
+  if (typeof text !== "string") return "";
+  let insideString = false;
+  let stringChar = "";
+  let isEscaped = false;
+  let result = "";
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const next = text[i + 1];
+
+    if (insideString) {
+      result += char;
+      if (isEscaped) {
+        isEscaped = false;
+      } else if (char === "\\") {
+        isEscaped = true;
+      } else if (char === stringChar) {
+        insideString = false;
+      }
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      insideString = true;
+      stringChar = char;
+      result += char;
+      continue;
+    }
+
+    // Line comment: //
+    if (char === "/" && next === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      if (i < text.length) result += text[i]; // keep newline
+      continue;
+    }
+
+    // Block comment: /* ... */
+    if (char === "/" && next === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i++; // skip closing /
+      continue;
+    }
+
+    result += char;
+  }
+
+  // Remove trailing commas before } or ]
+  return result.replace(/,\s*([}\]])/g, "$1");
+}
+
+/**
+ * Parses JSON or JSONC safely. Returns null on parse error.
+ */
+export function parseConfigJson(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    try {
+      const stripped = stripJsonComments(raw);
+      return JSON.parse(stripped);
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Computes sha256 hash of a string or buffer.
+ */
+export function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+/**
+ * Backup and Rollback Manager.
+ */
+export class ConfigBackupManager {
+  constructor({ stateDir = join(process.cwd(), ".cirvix") } = {}) {
+    this.stateDir = stateDir;
+    this.backupDir = join(stateDir, "backups");
+  }
+
+  /**
+   * Creates a backup of one or more configuration files before modifying them.
+   *
+   * @param {string[]} filePaths
+   * @param {string} [reason="pre-integration"]
+   * @returns {Promise<{ backupId: string, timestamp: string, files: Array<{ path: string, backupPath: string, sha: string }> }>}
+   */
+  async createBackup(filePaths, reason = "pre-integration") {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupId = `backup-${timestamp}`;
+    const targetDir = join(this.backupDir, backupId);
+    await mkdir(targetDir, { recursive: true });
+
+    const backedUp = [];
+
+    for (const filePath of filePaths) {
+      const resolved = resolve(filePath);
+      try {
+        const content = await readFile(resolved);
+        const hash = sha256(content);
+        const safeName = normalizeFsPath(resolved).replace(/[:/\\]/g, "_");
+        const backupPath = join(targetDir, safeName);
+
+        await writeFile(backupPath, content);
+        backedUp.push({
+          path: resolved,
+          backupPath,
+          sha: hash,
+        });
+      } catch (err) {
+        // File may not exist yet; record as non-existent
+        backedUp.push({
+          path: resolved,
+          backupPath: null,
+          sha: null,
+          notExisted: true,
+        });
+      }
+    }
+
+    const manifest = {
+      backupId,
+      timestamp: new Date().toISOString(),
+      reason,
+      files: backedUp,
+    };
+
+    await writeFile(join(targetDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+    return manifest;
+  }
+
+  /**
+   * Lists available backups, newest first.
+   */
+  async listBackups() {
+    try {
+      const entries = await readdir(this.backupDir, { withFileTypes: true });
+      const manifests = [];
+
+      for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("backup-")) continue;
+        const manifestPath = join(this.backupDir, entry.name, "manifest.json");
+        try {
+          const raw = await readFile(manifestPath, "utf8");
+          manifests.push(JSON.parse(raw));
+        } catch {}
+      }
+
+      return manifests.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Restores configuration files from a backup.
+   *
+   * @param {string} [backupId] - Defaults to latest backup if omitted.
+   * @returns {Promise<{ restored: string[], removed: string[], backupId: string }>}
+   */
+  async rollback(backupId = null) {
+    const backups = await this.listBackups();
+    if (backups.length === 0) {
+      throw new Error("No CIRVIX backups found in " + this.backupDir);
+    }
+
+    const target = backupId ? backups.find((b) => b.backupId === backupId) : backups[0];
+    if (!target) {
+      throw new Error(`Backup "${backupId}" not found.`);
+    }
+
+    const restored = [];
+    const removed = [];
+
+    for (const file of target.files) {
+      if (file.notExisted) {
+        // The file did not exist before CIRVIX created it. Remove it cleanly.
+        try {
+          const { unlink } = await import("node:fs/promises");
+          await unlink(file.path);
+          removed.push(file.path);
+        } catch {}
+      } else if (file.backupPath) {
+        await mkdir(dirname(file.path), { recursive: true });
+        await copyFile(file.backupPath, file.path);
+        restored.push(file.path);
+      }
+    }
+
+    return { restored, removed, backupId: target.backupId };
+  }
+}
+
+/**
+ * Safe configuration patcher helper.
+ */
+export class SafeConfigPatcher {
+  constructor(options = {}) {
+    this.backupManager = new ConfigBackupManager(options);
+  }
+
+  async patchJson(filePath, updateFn) {
+    const raw = await readFile(filePath, "utf8");
+    const parsed = parseConfigJson(raw) || {};
+    const updated = await updateFn(parsed);
+    await this.backupManager.createBackup([filePath]);
+    await writeFile(filePath, JSON.stringify(updated, null, 2), "utf8");
+    return updated;
+  }
+}
+
+/**
+ * Validates an MCP server map to ensure no circular references to cirvix
+ * and that each server has required fields.
+ */
+export function validateMcpServersMap(serverMap) {
+  const errors = [];
+  if (!serverMap || typeof serverMap !== "object") {
+    errors.push("Server map must be an object.");
+    return { ok: false, errors };
+  }
+
+  for (const [name, def] of Object.entries(serverMap)) {
+    if (!def || typeof def !== "object") {
+      errors.push(`Server "${name}" definition must be an object.`);
+      continue;
+    }
+
+    if (name === "cirvix") {
+      // CIRVIX server itself must specify command and arguments
+      if (!def.command && !def.url) {
+        errors.push(`CIRVIX entry in server map must have a command or url.`);
+      }
+      continue;
+    }
+
+    if (!def.command && !def.url) {
+      errors.push(`Server "${name}" must define either "command" or "url".`);
+    }
+
+    // Circular check: does an upstream invoke cirvix gateway with circular arguments?
+    if (typeof def.command === "string" && def.command.includes("cirvix") && Array.isArray(def.args)) {
+      if (def.args.includes("gateway")) {
+        errors.push(`Server "${name}" circularly invokes "cirvix gateway".`);
+      }
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+  };
+}

package/src/core/detect.mjs

@@ -15,6 +15,7 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve, sep } from "node:path";
+import { detectFleet } from "../adapters/index.mjs";
 
 /** Best-effort read; a missing or unreadable file is simply "not present". */
 async function readJson(path) {
@@ -93,39 +94,9 @@ const FRAMEWORK_MARKERS = [
   { id: "mcp-sdk", label: "MCP SDK", deps: ["@modelcontextprotocol/sdk"] },
 ];
 
-export async function detectRuntimes() {
-  const found = [];
-
-  for (const probe of RUNTIME_PROBES) {
-    // Merge across every config path a runtime uses rather than stopping at
-    // the first that exists. Claude Code, for example, has both
-    // ~/.claude/settings.json and ~/.claude.json, and MCP servers may live in
-    // either — breaking early reports "0 MCP servers" for a machine that has
-    // several, which is exactly the false clean bill this tool must not give.
-    const paths = [];
-    const servers = {};
-
-    for (const path of probe.paths) {
-      if (!(await exists(path))) continue;
-      paths.push(path);
-      const config = await readJson(path);
-      Object.assign(servers, config?.[probe.mcpKey] ?? {});
-    }
-
-    if (paths.length === 0) continue;
-
-    found.push({
-      id: probe.id,
-      label: probe.label,
-      path: paths[0],
-      paths,
-      governed: isGoverned(servers),
-      serverCount: Object.keys(servers).length,
-      servers,
-    });
-  }
-
-  return found;
+export async function detectRuntimes(cwd = process.cwd(), options = {}) {
+  const { runtimes } = await detectFleet(cwd, options);
+  return runtimes;
 }
 
 /** A runtime is governed when its MCP traffic routes through the gateway. */

package/src/core/entitlements.mjs

@@ -96,6 +96,7 @@ export const TIERS = {
     shareableReplay: false,
     policyPacks: 2,
     sharedPolicy: false,
+    customPolicies: false,
   },
   starter: {
     id: "starter",
@@ -112,6 +113,7 @@ export const TIERS = {
     shareableReplay: "local",
     policyPacks: 6,
     sharedPolicy: false,
+    customPolicies: true,
   },
   pro: {
     id: "pro",
@@ -128,6 +130,7 @@ export const TIERS = {
     shareableReplay: "full",
     policyPacks: null,
     sharedPolicy: "basic",
+    customPolicies: true,
   },
   team: {
     id: "team",
@@ -144,6 +147,7 @@ export const TIERS = {
     shareableReplay: "team",
     policyPacks: null,
     sharedPolicy: "full",
+    customPolicies: true,
   },
   enterprise: {
     id: "enterprise",
@@ -163,6 +167,7 @@ export const TIERS = {
     shareableReplay: "team",
     policyPacks: null,
     sharedPolicy: "full",
+    customPolicies: true,
   },
 };
 
@@ -269,6 +274,7 @@ export function nextTier(id) {
 export function can(licence, feature) {
   const tier = tierFor(licence?.tier);
   switch (feature) {
+    case "customPolicies": return tier.customPolicies === true;
     case "persistentSecrets": return tier.persistentSecrets === true;
     case "approvals": return tier.approvals === true;
     case "attestation": return tier.attestation === true;