witnora 0.8.1 → 0.9.0

package/dist/vendor/onegent-runtime/vendor-sandbox-egress.d.ts

@@ -0,0 +1,49 @@
+export type VendorSandboxHttpMethod = "GET";
+export interface VendorSandboxResourceRule {
+    id: string;
+    method: VendorSandboxHttpMethod;
+    pathPattern: RegExp;
+}
+export interface VendorSandboxEgressPolicy {
+    vendor: string;
+    allowedOrigin: string;
+    resources: readonly VendorSandboxResourceRule[];
+    timeoutMs: number;
+    maxRequestsPerMinute: number;
+}
+export type VendorSandboxAuditOutcome = "allowed" | "denied" | "rate_limited" | "timeout" | "http_error" | "failed";
+export interface VendorSandboxRequestAudit {
+    requestId: string;
+    timestamp: string;
+    vendor: string;
+    resource: string;
+    method: VendorSandboxHttpMethod;
+    origin: string;
+    outcome: VendorSandboxAuditOutcome;
+    durationMs: number;
+    status?: number;
+    errorCode?: VendorSandboxEgressErrorCode;
+}
+export type VendorSandboxEgressErrorCode = "ORIGIN_DENIED" | "METHOD_DENIED" | "RESOURCE_DENIED" | "RATE_LIMITED" | "TIMEOUT" | "HTTP_ERROR" | "REQUEST_FAILED";
+export declare class VendorSandboxEgressError extends Error {
+    readonly code: VendorSandboxEgressErrorCode;
+    readonly status?: number | undefined;
+    constructor(code: VendorSandboxEgressErrorCode, message: string, status?: number | undefined);
+}
+export interface VendorSandboxEgressRequest {
+    resource: string;
+    method: VendorSandboxHttpMethod;
+    path: string;
+    headers?: HeadersInit;
+}
+export interface BoundedVendorSandboxEgress {
+    requestJson(request: VendorSandboxEgressRequest): Promise<unknown>;
+    getAuditLog(): VendorSandboxRequestAudit[];
+}
+export interface BoundedVendorSandboxEgressOptions {
+    policy: VendorSandboxEgressPolicy;
+    fetch?: typeof fetch;
+    now?: () => number;
+}
+export declare function createBoundedVendorSandboxEgress(options: BoundedVendorSandboxEgressOptions): BoundedVendorSandboxEgress;
+//# sourceMappingURL=vendor-sandbox-egress.d.ts.map

package/dist/vendor/onegent-runtime/vendor-sandbox-egress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vendor-sandbox-egress.d.ts","sourceRoot":"","sources":["../../../../onegent-runtime/src/vendor-sandbox-egress.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,KAAK,CAAC;AAE5C,MAAM,WAAW,yBAAyB;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,uBAAuB,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,MAAM,yBAAyB,GACjC,SAAS,GACT,QAAQ,GACR,cAAc,GACd,SAAS,GACT,YAAY,GACZ,QAAQ,CAAC;AAEb,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,uBAAuB,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,yBAAyB,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,4BAA4B,CAAC;CAC1C;AAED,MAAM,MAAM,4BAA4B,GACpC,eAAe,GACf,eAAe,GACf,iBAAiB,GACjB,cAAc,GACd,SAAS,GACT,YAAY,GACZ,gBAAgB,CAAC;AAErB,qBAAa,wBAAyB,SAAQ,KAAK;aAE/B,IAAI,EAAE,4BAA4B;aAElC,MAAM,CAAC,EAAE,MAAM;gBAFf,IAAI,EAAE,4BAA4B,EAClD,OAAO,EAAE,MAAM,EACC,MAAM,CAAC,EAAE,MAAM,YAAA;CAKlC;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,uBAAuB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE,WAAW,IAAI,yBAAyB,EAAE,CAAC;CAC5C;AAED,MAAM,WAAW,iCAAiC;IAChD,MAAM,EAAE,yBAAyB,CAAC;IAClC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAID,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,iCAAiC,GACzC,0BAA0B,CA+G5B"}

package/dist/vendor/onegent-runtime/vendor-sandbox-egress.js

@@ -0,0 +1,152 @@
+export class VendorSandboxEgressError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "VendorSandboxEgressError";
+    }
+}
+const MAX_AUDIT_ENTRIES = 100;
+export function createBoundedVendorSandboxEgress(options) {
+    const policy = validatePolicy(options.policy);
+    const requestFetch = options.fetch ?? fetch;
+    const now = options.now ?? Date.now;
+    const audit = [];
+    let requestSequence = 0;
+    let windowStartedAt = now();
+    let requestsInWindow = 0;
+    const record = (entry) => {
+        audit.push(Object.freeze({ ...entry }));
+        if (audit.length > MAX_AUDIT_ENTRIES)
+            audit.splice(0, audit.length - MAX_AUDIT_ENTRIES);
+    };
+    return Object.freeze({
+        requestJson: async (request) => {
+            const startedAt = now();
+            const requestId = `${policy.vendor}-${++requestSequence}`;
+            const method = request.method;
+            const url = safeUrl(request.path, policy.allowedOrigin);
+            const baseAudit = {
+                requestId,
+                timestamp: new Date(startedAt).toISOString(),
+                vendor: policy.vendor,
+                resource: request.resource,
+                method,
+                origin: url?.origin ?? policy.allowedOrigin,
+            };
+            const deny = (error) => {
+                record({ ...baseAudit, outcome: "denied", durationMs: elapsed(now, startedAt), errorCode: error.code });
+                throw error;
+            };
+            if (!url || url.origin !== policy.allowedOrigin || url.protocol !== "https:" || url.username || url.password || url.hash) {
+                return deny(new VendorSandboxEgressError("ORIGIN_DENIED", "Vendor sandbox request origin is not allowlisted."));
+            }
+            const resource = policy.resources.find((entry) => entry.id === request.resource);
+            if (!resource) {
+                return deny(new VendorSandboxEgressError("RESOURCE_DENIED", "Vendor sandbox resource is not allowlisted."));
+            }
+            if (method !== resource.method) {
+                return deny(new VendorSandboxEgressError("METHOD_DENIED", "Vendor sandbox HTTP method is not allowlisted for this resource."));
+            }
+            resource.pathPattern.lastIndex = 0;
+            if (!resource.pathPattern.test(`${url.pathname}${url.search}`)) {
+                return deny(new VendorSandboxEgressError("RESOURCE_DENIED", "Vendor sandbox path is not allowlisted for this resource."));
+            }
+            const current = now();
+            if (current - windowStartedAt >= 60_000) {
+                windowStartedAt = current;
+                requestsInWindow = 0;
+            }
+            if (requestsInWindow >= policy.maxRequestsPerMinute) {
+                const error = new VendorSandboxEgressError("RATE_LIMITED", "Vendor sandbox request limit exceeded. Retry after the current one-minute window.");
+                record({ ...baseAudit, outcome: "rate_limited", durationMs: elapsed(now, startedAt), errorCode: error.code });
+                throw error;
+            }
+            requestsInWindow += 1;
+            const controller = new AbortController();
+            let timedOut = false;
+            let timeout;
+            const operation = (async () => {
+                const response = await requestFetch(url, {
+                    method,
+                    headers: request.headers,
+                    redirect: "error",
+                    signal: controller.signal,
+                });
+                if (!response.ok) {
+                    throw new VendorSandboxEgressError("HTTP_ERROR", `Vendor sandbox returned HTTP ${response.status}.`, response.status);
+                }
+                return { payload: await response.json(), status: response.status };
+            })();
+            const timeoutOperation = new Promise((_, reject) => {
+                timeout = setTimeout(() => {
+                    timedOut = true;
+                    controller.abort();
+                    reject(new VendorSandboxEgressError("TIMEOUT", `Vendor sandbox request exceeded ${policy.timeoutMs} ms.`));
+                }, policy.timeoutMs);
+            });
+            try {
+                const result = await Promise.race([operation, timeoutOperation]);
+                record({ ...baseAudit, outcome: "allowed", durationMs: elapsed(now, startedAt), status: result.status });
+                return result.payload;
+            }
+            catch (cause) {
+                const error = cause instanceof VendorSandboxEgressError
+                    ? cause
+                    : timedOut
+                        ? new VendorSandboxEgressError("TIMEOUT", `Vendor sandbox request exceeded ${policy.timeoutMs} ms.`)
+                        : new VendorSandboxEgressError("REQUEST_FAILED", "Vendor sandbox request failed.");
+                record({
+                    ...baseAudit,
+                    outcome: error.code === "TIMEOUT" ? "timeout" : error.code === "HTTP_ERROR" ? "http_error" : "failed",
+                    durationMs: elapsed(now, startedAt),
+                    status: error.status,
+                    errorCode: error.code,
+                });
+                throw error;
+            }
+            finally {
+                if (timeout)
+                    clearTimeout(timeout);
+            }
+        },
+        getAuditLog: () => audit.map((entry) => ({ ...entry })),
+    });
+}
+function validatePolicy(policy) {
+    const origin = new URL(policy.allowedOrigin);
+    if (origin.protocol !== "https:" || origin.origin !== policy.allowedOrigin || origin.pathname !== "/" || origin.search || origin.hash) {
+        throw new Error("Vendor sandbox allowedOrigin must be an exact HTTPS origin without a path.");
+    }
+    if (!policy.vendor.trim())
+        throw new Error("Vendor sandbox policy vendor is required.");
+    if (!Number.isSafeInteger(policy.timeoutMs) || policy.timeoutMs < 100 || policy.timeoutMs > 30_000) {
+        throw new Error("Vendor sandbox timeoutMs must be an integer from 100 to 30000.");
+    }
+    if (!Number.isSafeInteger(policy.maxRequestsPerMinute) || policy.maxRequestsPerMinute < 1 || policy.maxRequestsPerMinute > 60) {
+        throw new Error("Vendor sandbox maxRequestsPerMinute must be an integer from 1 to 60.");
+    }
+    if (policy.resources.length === 0 || new Set(policy.resources.map((entry) => entry.id)).size !== policy.resources.length) {
+        throw new Error("Vendor sandbox policy requires unique resource rules.");
+    }
+    return Object.freeze({
+        ...policy,
+        resources: Object.freeze(policy.resources.map((entry) => Object.freeze({
+            ...entry,
+            pathPattern: new RegExp(entry.pathPattern.source, entry.pathPattern.flags),
+        }))),
+    });
+}
+function safeUrl(path, origin) {
+    try {
+        return new URL(path, `${origin}/`);
+    }
+    catch {
+        return undefined;
+    }
+}
+function elapsed(now, startedAt) {
+    return Math.max(0, Math.round(now() - startedAt));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "witnora",
-  "version": "0.8.1",
-  "description": "Canonical Witnora CLI entry point for autonomous-system evidence and assurance.",
+  "version": "0.9.0",
+  "description": "Witnora evidence, assurance release gates, runtime records, and regression CI for autonomous AI systems.",
   "type": "module",
   "license": "Apache-2.0",
   "homepage": "https://witnora.com/",
@@ -14,29 +14,49 @@
     "url": "https://github.com/Kakarottoooo/agentcert/issues"
   },
   "keywords": [
-    "ai-agents",
-    "assurance",
-    "evidence",
-    "audit",
+    "agent",
+    "browser-agent",
+    "ci",
+    "playwright",
     "agent-security",
-    "runtime-verification"
+    "llm",
+    "mcp",
+    "tripwire",
+    "evidence",
+    "assurance",
+    "authorization",
+    "audit"
   ],
   "bin": {
-    "witnora": "bin/witnora.js"
+    "witnora": "dist/cli.js"
+  },
+  "exports": {
+    "./cli": "./dist/cli.js",
+    "./browser-adapter-kit": {
+      "types": "./dist/vendor/onegent-runtime/browser-adapter-kit.d.ts",
+      "import": "./dist/vendor/onegent-runtime/browser-adapter-kit.js"
+    }
   },
   "files": [
-    "bin",
+    "dist",
     "README.md",
     "package.json"
   ],
   "scripts": {
-    "test": "node --test tests/*.test.mjs",
-    "prepack": "npm test"
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && tsc -p tsconfig.onegent-vendor.json",
+    "prepack": "npm run build",
+    "test": "vitest run tests",
+    "demo:report": "node dist/cli.js report --mcpbench ../../examples/reports/passing/results.json --out .witnora/demo --subject demo-agent"
   },
   "engines": {
     "node": ">=20"
   },
-  "dependencies": {
-    "agentcert": "0.8.1"
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.13"
+  },
+  "optionalDependencies": {
+    "pg": "^8.16.3"
   }
 }

package/bin/witnora.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-await import("agentcert/cli");