clawclamp 0.1.4 → 0.1.5

package/README.md

@@ -0,0 +1,45 @@
+# Clawclamp
+
+Clawclamp adds Cedar-based authorization to OpenClaw tool calls. It evaluates every tool invocation via a Cedar policy, records allow/deny decisions to an audit log, and exposes a gateway UI for reviewing logs and granting short-term approvals.
+
+## Features
+
+- Cedar policy enforcement for `before_tool_call`.
+- Long-term authorization via policy (defaults allow low-risk tools).
+- Short-term authorization via expiring grants.
+- Audit UI for allowed/denied/gray-mode tool calls.
+- Gray mode: denied calls are still executed but logged as overrides.
+
+## Configuration
+
+Configure under `plugins.entries.clawclamp.config`:
+
+```yaml
+plugins:
+  entries:
+    clawclamp:
+      enabled: true
+      config:
+        mode: enforce
+        principalId: openclaw
+        policyStoreUri: file:///path/to/policy-store.json
+        policyFailOpen: false
+        risk:
+          default: high
+          overrides:
+            read: low
+            web_search: medium
+            exec: high
+        grants:
+          defaultTtlSeconds: 900
+          maxTtlSeconds: 3600
+        audit:
+          maxEntries: 500
+          includeParams: true
+```
+
+`policyStoreUri` points to a Cedar policy store JSON (file:// or https://). `policyStoreLocal` can be set to a raw JSON string for the policy store. If omitted, the plugin uses a built-in policy store that permits low-risk tools and requires a grant for other risks.
+
+## UI
+
+Open the gateway path `/plugins/clawclamp` to view audit logs, toggle gray mode, and create short-term grants.

package/assets/app.js

@@ -0,0 +1,152 @@
+const API_BASE = "/plugins/clawclamp/api";
+
+const qs = (id) => document.getElementById(id);
+
+const modeEl = qs("mode");
+const modeNoteEl = qs("mode-note");
+const enforceBtn = qs("mode-enforce");
+const grayBtn = qs("mode-gray");
+const refreshBtn = qs("refresh");
+const grantForm = qs("grant-form");
+const grantToolInput = qs("grant-tool");
+const grantTtlInput = qs("grant-ttl");
+const grantNoteInput = qs("grant-note");
+const grantHint = qs("grant-hint");
+const grantsEl = qs("grants");
+const auditEl = qs("audit");
+
+async function fetchJson(path, opts = {}) {
+  const res = await fetch(path, {
+    headers: { "content-type": "application/json" },
+    ...opts,
+  });
+  const payload = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const message = payload.error || `Request failed (${res.status})`;
+    throw new Error(message);
+  }
+  return payload;
+}
+
+function formatTime(iso) {
+  if (!iso) return "-";
+  const date = new Date(iso);
+  return date.toLocaleTimeString();
+}
+
+function renderMode(state) {
+  modeEl.textContent = state.mode === "gray" ? "Gray Mode" : "Enforce";
+  modeNoteEl.textContent =
+    state.mode === "gray"
+      ? "Denied tool calls are still executed but marked in audit logs."
+      : "Denied tool calls are blocked.";
+  enforceBtn.disabled = state.mode === "enforce";
+  grayBtn.disabled = state.mode === "gray";
+  grantHint.textContent =
+    `Default TTL ${state.grants.defaultTtlSeconds}s, max ${state.grants.maxTtlSeconds}s.`;
+}
+
+function renderGrants(grants) {
+  if (!grants.length) {
+    grantsEl.innerHTML = "<div class=\"note\">No active grants.</div>";
+    return;
+  }
+  grantsEl.innerHTML = "";
+  grants.forEach((grant) => {
+    const item = document.createElement("div");
+    item.className = "list-item";
+    item.innerHTML = `
+      <div>
+        <strong>${grant.toolName}</strong><br />
+        <span class="note">Expires ${new Date(grant.expiresAt).toLocaleString()}</span>
+      </div>
+      <button class="btn ghost" data-id="${grant.id}">Revoke</button>
+    `;
+    item.querySelector("button").addEventListener("click", async () => {
+      await fetchJson(`${API_BASE}/grants/${grant.id}`, { method: "DELETE" });
+      await refreshAll();
+    });
+    grantsEl.appendChild(item);
+  });
+}
+
+function decisionBadge(decision) {
+  if (decision === "allow_grayed") return "gray";
+  if (decision === "deny") return "deny";
+  return "allow";
+}
+
+function renderAudit(entries) {
+  if (!entries.length) {
+    auditEl.innerHTML = "<div class=\"note\">No audit entries yet.</div>";
+    return;
+  }
+
+  const header = document.createElement("div");
+  header.className = "table-row header";
+  header.innerHTML = "<div>Time</div><div>Tool</div><div>Decision</div><div>Risk</div><div>Details</div>";
+
+  auditEl.innerHTML = "";
+  auditEl.appendChild(header);
+
+  entries.forEach((entry) => {
+    const row = document.createElement("div");
+    row.className = "table-row";
+    const badgeClass = decisionBadge(entry.decision);
+    row.innerHTML = `
+      <div>${formatTime(entry.timestamp)}</div>
+      <div class="mono">${entry.toolName}</div>
+      <div class="badge ${badgeClass}">${entry.decision}</div>
+      <div>${entry.risk}</div>
+      <div>${entry.reason || entry.error || ""}</div>
+    `;
+    auditEl.appendChild(row);
+  });
+}
+
+async function refreshAll() {
+  const state = await fetchJson(`${API_BASE}/state`);
+  renderMode(state);
+  const grants = await fetchJson(`${API_BASE}/grants`);
+  renderGrants(grants.grants || []);
+  const logs = await fetchJson(`${API_BASE}/logs`);
+  renderAudit(logs.entries || []);
+}
+
+refreshBtn.addEventListener("click", () => {
+  refreshAll();
+});
+
+enforceBtn.addEventListener("click", async () => {
+  await fetchJson(`${API_BASE}/mode`, {
+    method: "POST",
+    body: JSON.stringify({ mode: "enforce" }),
+  });
+  await refreshAll();
+});
+
+grayBtn.addEventListener("click", async () => {
+  await fetchJson(`${API_BASE}/mode`, {
+    method: "POST",
+    body: JSON.stringify({ mode: "gray" }),
+  });
+  await refreshAll();
+});
+
+grantForm.addEventListener("submit", async (event) => {
+  event.preventDefault();
+  const toolName = grantToolInput.value.trim();
+  const ttlSeconds = grantTtlInput.value ? Number(grantTtlInput.value) : undefined;
+  const note = grantNoteInput.value.trim();
+  await fetchJson(`${API_BASE}/grants`, {
+    method: "POST",
+    body: JSON.stringify({ toolName, ttlSeconds, note: note || undefined }),
+  });
+  grantToolInput.value = "";
+  grantTtlInput.value = "";
+  grantNoteInput.value = "";
+  await refreshAll();
+});
+
+refreshAll();
+setInterval(refreshAll, 10_000);

package/assets/index.html

@@ -0,0 +1,75 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>OpenClaw Clawclamp</title>
+    <link rel="stylesheet" href="/plugins/clawclamp/assets/styles.css" />
+  </head>
+  <body>
+    <div class="page">
+      <header class="header">
+        <div>
+          <p class="eyebrow">OpenClaw - Clawclamp</p>
+          <h1>Tool Authorization & Audit</h1>
+          <p class="subhead">
+            Cedar-backed policy decisions with short-term grants and gray-mode overrides.
+          </p>
+        </div>
+        <div class="header-actions">
+          <button id="refresh" class="btn ghost">Refresh</button>
+        </div>
+      </header>
+
+      <section class="grid">
+        <div class="card">
+          <h2>Mode</h2>
+          <div class="mode-row">
+            <div>
+              <div class="label">Current mode</div>
+              <div id="mode" class="value">Loading...</div>
+              <div id="mode-note" class="note"></div>
+            </div>
+            <div class="mode-actions">
+              <button id="mode-enforce" class="btn">Enforce</button>
+              <button id="mode-gray" class="btn warn">Gray</button>
+            </div>
+          </div>
+        </div>
+
+        <div class="card">
+          <h2>Short-Term Grant</h2>
+          <form id="grant-form" class="grant-form">
+            <label>
+              Tool name
+              <input id="grant-tool" placeholder="exec (or *)" required />
+            </label>
+            <label>
+              TTL (seconds)
+              <input id="grant-ttl" type="number" min="60" step="60" />
+            </label>
+            <label>
+              Note
+              <input id="grant-note" placeholder="Reason / ticket" />
+            </label>
+            <button class="btn primary" type="submit">Create Grant</button>
+            <div id="grant-hint" class="note"></div>
+          </form>
+        </div>
+
+        <div class="card">
+          <h2>Active Grants</h2>
+          <div id="grants" class="list"></div>
+        </div>
+      </section>
+
+      <section class="card">
+        <h2>Audit Log</h2>
+        <div class="note">Most recent tool calls (allowed, denied, and gray-mode overrides).</div>
+        <div class="table" id="audit"></div>
+      </section>
+    </div>
+
+    <script type="module" src="/plugins/clawclamp/assets/app.js"></script>
+  </body>
+</html>

package/assets/styles.css

@@ -0,0 +1,252 @@
+:root {
+  color-scheme: light;
+  --bg: #f5f1ea;
+  --panel: #ffffff;
+  --ink: #1b1b1b;
+  --muted: #5b5b5b;
+  --accent: #1a4dff;
+  --accent-2: #ff8b2c;
+  --warn: #d64b31;
+  --border: #e5ddd0;
+  --shadow: 0 12px 40px rgba(0, 0, 0, 0.08);
+  --radius: 16px;
+  --mono: "IBM Plex Mono", "SFMono-Regular", "Menlo", "Consolas", monospace;
+  --sans: "Space Grotesk", "Avenir Next", "Segoe UI", sans-serif;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font-family: var(--sans);
+  background: radial-gradient(circle at top, #fdfbf7 0%, var(--bg) 50%, #efe7db 100%);
+  color: var(--ink);
+}
+
+.page {
+  max-width: 1180px;
+  margin: 0 auto;
+  padding: 32px 24px 48px;
+}
+
+.header {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 24px;
+  padding: 24px;
+  background: var(--panel);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  border: 1px solid var(--border);
+  margin-bottom: 24px;
+}
+
+.eyebrow {
+  margin: 0 0 8px;
+  text-transform: uppercase;
+  letter-spacing: 0.2em;
+  font-size: 0.7rem;
+  color: var(--muted);
+}
+
+h1 {
+  margin: 0 0 6px;
+  font-size: 2.2rem;
+}
+
+.subhead {
+  margin: 0;
+  color: var(--muted);
+}
+
+.header-actions {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: 20px;
+  margin-bottom: 24px;
+}
+
+.card {
+  background: var(--panel);
+  border-radius: var(--radius);
+  padding: 20px;
+  border: 1px solid var(--border);
+  box-shadow: var(--shadow);
+}
+
+h2 {
+  margin: 0 0 12px;
+  font-size: 1.2rem;
+}
+
+.mode-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+}
+
+.mode-actions {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.label {
+  font-size: 0.8rem;
+  color: var(--muted);
+}
+
+.value {
+  font-size: 1.4rem;
+  font-weight: 600;
+}
+
+.note {
+  font-size: 0.85rem;
+  color: var(--muted);
+  margin-top: 6px;
+}
+
+.btn {
+  padding: 10px 16px;
+  border-radius: 999px;
+  border: 1px solid var(--border);
+  background: #fff;
+  cursor: pointer;
+  font-weight: 600;
+}
+
+.btn.primary {
+  background: var(--accent);
+  color: #fff;
+  border-color: var(--accent);
+}
+
+.btn.warn {
+  background: var(--warn);
+  color: #fff;
+  border-color: var(--warn);
+}
+
+.btn.ghost {
+  background: transparent;
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.grant-form {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.grant-form label {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  font-size: 0.85rem;
+  color: var(--muted);
+}
+
+input {
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 10px 12px;
+  font-size: 0.95rem;
+  font-family: var(--sans);
+}
+
+.list {
+  display: grid;
+  gap: 10px;
+}
+
+.list-item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px;
+  border-radius: 12px;
+  border: 1px solid var(--border);
+  background: #faf7f1;
+  font-size: 0.9rem;
+}
+
+.list-item strong {
+  font-family: var(--mono);
+}
+
+.table {
+  display: grid;
+  gap: 8px;
+  margin-top: 12px;
+}
+
+.table-row {
+  display: grid;
+  grid-template-columns: 140px 120px 1fr 100px 120px;
+  gap: 12px;
+  align-items: center;
+  padding: 10px 12px;
+  border-radius: 12px;
+  border: 1px solid var(--border);
+  background: #fcfbf8;
+  font-size: 0.85rem;
+}
+
+.table-row.header {
+  background: #f0e8db;
+  font-weight: 700;
+}
+
+.table-row .mono {
+  font-family: var(--mono);
+}
+
+.badge {
+  padding: 4px 8px;
+  border-radius: 999px;
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  font-weight: 700;
+  justify-self: start;
+}
+
+.badge.allow {
+  background: rgba(26, 77, 255, 0.15);
+  color: #1a4dff;
+}
+
+.badge.deny {
+  background: rgba(214, 75, 49, 0.15);
+  color: #d64b31;
+}
+
+.badge.gray {
+  background: rgba(255, 139, 44, 0.2);
+  color: #c15c00;
+}
+
+@media (max-width: 900px) {
+  .table-row {
+    grid-template-columns: 120px 100px 1fr;
+    grid-template-rows: auto auto;
+  }
+  .table-row > :nth-child(4),
+  .table-row > :nth-child(5) {
+    grid-column: 1 / -1;
+  }
+}

package/index.ts

@@ -1,103 +1,39 @@
-
-import { CedarEngine } from "./src/cedar-engine.js";
-import { AuditStore } from "./src/audit-store.js";
-import { createServer } from "./src/server.js";
-import type { OpenClawPluginApi, PluginHookBeforeToolCallEvent, PluginHookToolContext } from "../../src/plugins/types.js";
-
-export const plugin = {
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { resolveClawClampConfig, clawClampConfigSchema } from "./src/config.js";
+import { createClawClampHttpHandler } from "./src/http.js";
+import { createClawClampService } from "./src/guard.js";
+
+const plugin = {
   id: "clawclamp",
-  name: "ClawClamp Policy Audit",
-  description: "Cedarling-based permission control with audit logging and dry-run mode.",
+  name: "Clawclamp",
+  description: "Cedar-based authorization guard with tool audit logging.",
+  configSchema: clawClampConfigSchema,
   register(api: OpenClawPluginApi) {
-    const engine = new CedarEngine({
-      mode: (api.pluginConfig?.mode as string) || "monitor",
-      policyStoreUrl: api.pluginConfig?.policyStoreUrl as string,
-    });
-
-    const auditStore = new AuditStore(api.config.workspaceDir || process.cwd());
-
-    // Register Hook: before_tool_call
-    api.on("before_tool_call", async (event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext) => {
-      const { toolName, params, runId } = event;
-      const { agentId, sessionId } = ctx;
-
-      const principal = `User::"${agentId || "unknown"}"`;
-      const action = `Action::"tool:${toolName}"`;
-      const resource = `Resource::"global"`;
-
-      const result = await engine.authorize({
-        principal,
-        action,
-        resource,
-        context: {
-          sessionId,
-          runId,
-          params,
-          timestamp: Date.now(),
-        },
-      });
-
-      const shouldBlock =
-        result.decision === "Deny" && engine.getMode() === "enforce";
-
-      // Log the event
-      auditStore.append({
-        timestamp: new Date().toISOString(),
-        runId,
-        principal,
-        action,
-        resource,
-        decision: result.decision,
-        mode: engine.getMode(),
-        diagnostics: result.diagnostics,
-        blocked: shouldBlock,
-      });
-
-      if (shouldBlock) {
-        return {
-          block: true,
-          blockReason: `Cedar Policy Denied: ${result.diagnostics.join("; ")}`,
-        };
-      }
-    });
-
-    // Register HTTP Route for Audit Dashboard
+    const config = resolveClawClampConfig(api.pluginConfig);
+    const stateDir = api.runtime.state.resolveStateDir();
+    const service = createClawClampService({ api, config, stateDir });
+
+    api.on(
+      "before_tool_call",
+      async (event, ctx) => service.handleBeforeToolCall(event, ctx),
+      { priority: -10 },
+    );
+    api.on("after_tool_call", async (event, ctx) => service.handleAfterToolCall(event, ctx));
+
+    const assetsDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "assets");
     api.registerHttpRoute({
-      path: "/",
-      auth: "plugin",
+      path: "/plugins/clawclamp",
+      auth: "gateway",
       match: "prefix",
-      handler: async (req, res) => {
-        // Mock router logic for demonstration
-        if (req.method === "GET" && (req.url === "/" || req.url === "")) {
-            const app = createServer(engine, auditStore);
-            const response = await app.request("/");
-            const html = await response.text();
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end(html);
-            return true;
-        }
-        
-        if (req.method === "POST" && req.url === "/mode") {
-             let body = '';
-             req.on('data', (chunk: any) => body += chunk);
-             req.on('end', () => {
-                 const params = new URLSearchParams(body);
-                 const mode = params.get('mode');
-                 if (mode === 'enforce' || mode === 'monitor') {
-                     engine.setMode(mode);
-                 }
-                 res.writeHead(302, { 'Location': './' });
-                 res.end();
-             });
-             return true;
-        }
-        
-        return false;
-      },
+      handler: createClawClampHttpHandler({
+        stateDir,
+        config,
+        assetsDir,
+      }),
     });
-
-    api.logger.info("Cedar Audit Plugin Activated");
-  }
+  },
 };
 
 export default plugin;

package/openclaw.plugin.json

@@ -1,29 +1,10 @@
 {
   "id": "clawclamp",
-  "name": "ClawClamp Policy Audit",
-  "description": "Cedarling-based permission control with audit logging and dry-run mode.",
+  "name": "Clawclamp",
+  "description": "Cedar-based authorization guard with tool audit logging and gray-mode override.",
   "configSchema": {
     "type": "object",
-    "properties": {
-      "mode": {
-        "type": "string",
-        "enum": ["enforce", "monitor"],
-        "default": "monitor"
-      },
-      "policyStoreUrl": {
-        "type": "string",
-        "default": "https://example.com/policy-store.json"
-      }
-    }
-  },
-  "uiHints": {
-    "mode": {
-      "label": "Mode",
-      "help": "Set to 'enforce' to block unauthorized tools, or 'monitor' to only log them."
-    },
-    "policyStoreUrl": {
-      "label": "Policy Store URL",
-      "help": "URL to the Cedarling policy store JSON."
-    }
+    "additionalProperties": false,
+    "properties": {}
   }
 }