@neuroverseos/governance 0.1.0 → 0.1.2

package/dist/chunk-Z2S2HIV5.js

@@ -0,0 +1,100 @@
+import {
+  evaluateGuard
+} from "./chunk-B4NF3OLW.js";
+import {
+  loadWorld
+} from "./chunk-M3TZFGHO.js";
+
+// src/adapters/express.ts
+function methodToCategory(method) {
+  switch (method.toUpperCase()) {
+    case "GET":
+    case "HEAD":
+    case "OPTIONS":
+      return "read";
+    case "POST":
+    case "PUT":
+    case "PATCH":
+      return "write";
+    case "DELETE":
+      return "delete";
+    default:
+      return "other";
+  }
+}
+function defaultMapRequest(req) {
+  const method = (req.method ?? "GET").toUpperCase();
+  const path = req.path ?? req.url ?? "/";
+  return {
+    intent: `${method} ${path}`,
+    tool: "http",
+    scope: path,
+    actionCategory: methodToCategory(method),
+    direction: "input",
+    args: {
+      method,
+      path,
+      ...req.params ?? {},
+      ...req.query ?? {}
+    }
+  };
+}
+function defaultOnBlock(verdict, _req, res, statusCode) {
+  const body = {
+    error: "Governance policy violation",
+    reason: verdict.reason ?? "Action not permitted",
+    ruleId: verdict.ruleId,
+    status: verdict.status
+  };
+  if (res.status && res.json) {
+    res.status(statusCode).json(body);
+  } else if (res.send) {
+    res.statusCode = statusCode;
+    res.send(JSON.stringify(body));
+  } else if (res.end) {
+    res.statusCode = statusCode;
+    res.end();
+  }
+}
+async function createGovernanceMiddleware(worldPath, options) {
+  const world = await loadWorld(worldPath);
+  return createGovernanceMiddlewareFromWorld(world, options);
+}
+function createGovernanceMiddlewareFromWorld(world, options = {}) {
+  const engineOptions = {
+    trace: options.trace ?? false,
+    level: options.level
+  };
+  const mapRequest = options.mapRequest ?? defaultMapRequest;
+  const blockStatusCode = options.blockStatusCode ?? 403;
+  return async function neuroVerseGovernance(req, res, next) {
+    try {
+      const event = mapRequest(req);
+      const verdict = evaluateGuard(event, world, engineOptions);
+      options.onEvaluate?.(verdict, event, req);
+      if (verdict.status === "ALLOW") {
+        next();
+        return;
+      }
+      if (verdict.status === "PAUSE") {
+        const approved = await options.onPause?.(verdict, req);
+        if (approved) {
+          next();
+          return;
+        }
+      }
+      if (options.onBlock) {
+        options.onBlock(verdict, req, res);
+      } else {
+        defaultOnBlock(verdict, req, res, blockStatusCode);
+      }
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+
+export {
+  createGovernanceMiddleware,
+  createGovernanceMiddlewareFromWorld
+};