openclaw-brokerkit 0.1.0

package/dist/src/generated/operator-v1.js

@@ -0,0 +1,57 @@
+// Generated by scripts/generate-operator-v1.mjs. Do not edit.
+export const OPERATOR_V1_SCHEMA_SHA256 = "a4510c3d0e1ddf32dfb8e8bd684677ade3f3d6541912d42720af8c43ef11c2eb";
+export const operatorV1 = {
+    apiVersion: "brokerkit.io/operator/v1",
+    statuses: [
+        "pending",
+        "active",
+        "denied",
+        "canceled",
+        "expired",
+        "consumed",
+        "revoked",
+    ],
+    actions: ["approve", "deny", "cancel", "revoke"],
+    risks: ["unknown", "low", "medium", "high", "critical"],
+    eventKinds: [
+        "request.created",
+        "request.approved",
+        "request.denied",
+        "request.canceled",
+        "request.expired",
+        "request.consumed",
+        "request.revoked",
+        "request.updated",
+    ],
+    errorCodes: [
+        "invalid_request",
+        "unauthorized",
+        "forbidden",
+        "not_found",
+        "revision_conflict",
+        "invalid_transition",
+        "constraint_exceeded",
+        "idempotency_conflict",
+        "cursor_expired",
+        "rate_limited",
+        "temporarily_unavailable",
+        "internal_error",
+    ],
+    limits: {
+        id: 128,
+        requester: 80,
+        operation: 500,
+        reason: 2000,
+        actor: 200,
+        title: 200,
+        summary: 2000,
+        facts: 20,
+        factLabel: 80,
+        factValue: 500,
+        cursor: 1024,
+        page: 100,
+        idempotencyKey: 200,
+        errorMessage: 500,
+        correlationId: 200,
+    },
+};

package/dist/src/http.js

@@ -0,0 +1,279 @@
+import { timingSafeEqual } from "node:crypto";
+import { createReadStream, existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { pluginErrorCode } from "./errors.js";
+export function createHttpHandler(runtime, rootDir, capability) {
+    const uiDir = path.join(rootDir, "dist", "ui");
+    const rateLimit = createRateLimiter(120, 60_000);
+    return async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        if (url.pathname.startsWith("/plugins/brokerkit/api/v1/"))
+            return handleApi(req, res, url, runtime, capability, rateLimit);
+        return serveUi(req, res, url, uiDir);
+    };
+}
+async function handleApi(req, res, url, runtime, capability, rateLimit) {
+    if (!runtime || !capability)
+        return json(res, 404, { error: { code: "not_found" } });
+    if (!authorized(req.headers.authorization, capability))
+        return json(res, 401, { error: { code: "not_authorized" } });
+    if (req.headers.origin !== "null")
+        return json(res, 403, { error: { code: "not_authorized" } });
+    if (url.search)
+        return json(res, 400, { error: { code: "invalid_input" } });
+    if (!rateLimit(req.socket.remoteAddress ?? "local"))
+        return json(res, 429, { error: { code: "rate_limited" } });
+    try {
+        if (req.method === "GET" &&
+            url.pathname === "/plugins/brokerkit/api/v1/snapshot")
+            return json(res, 200, runtime().snapshot());
+        const detail = url.pathname.match(/^\/plugins\/brokerkit\/api\/v1\/requests\/([^/]+)$/);
+        if (req.method === "GET" && detail) {
+            const handle = decodeHandle(detail[1]);
+            const request = runtime()
+                .snapshot()
+                .requests.find((value) => value.handle === handle);
+            return request
+                ? json(res, 200, request)
+                : json(res, 404, { error: { code: "request_not_found" } });
+        }
+        const decision = url.pathname.match(/^\/plugins\/brokerkit\/api\/v1\/requests\/([^/]+)\/(approve|deny|cancel|revoke)$/);
+        if (req.method === "POST" && decision) {
+            if (!isJSON(req.headers["content-type"]))
+                throw new Error("invalid_input");
+            const input = parseDecisionInput(await readJSON(req), decision[2]);
+            const result = await runtime().decide(decodeHandle(decision[1]), decision[2], input.expectedRevision, "openclaw:control-ui", input.options);
+            return json(res, 200, result);
+        }
+    }
+    catch (error) {
+        const mapped = mapHttpError(error);
+        return json(res, mapped.status, { error: { code: mapped.code } });
+    }
+    return json(res, 404, { error: { code: "not_found" } });
+}
+function serveUi(req, res, url, uiDir) {
+    if (url.search || !url.pathname.startsWith("/plugins/brokerkit/ui/"))
+        return json(res, 404, { error: { code: "not_found" } });
+    if (req.method !== "GET")
+        return json(res, 405, { error: { code: "invalid_input" } });
+    const relative = url.pathname.replace(/^\/plugins\/brokerkit\/ui\/?/, "") || "index.html";
+    if (relative.includes(".."))
+        return json(res, 404, {});
+    let file = path.join(uiDir, relative);
+    if (!existsSync(file) || !statSync(file).isFile())
+        file = path.join(uiDir, "index.html");
+    res.statusCode = 200;
+    res.setHeader("content-type", contentType(file));
+    res.setHeader("cache-control", file.endsWith("index.html")
+        ? "no-store"
+        : "public, max-age=31536000, immutable");
+    res.setHeader("content-security-policy", "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; frame-ancestors 'self'");
+    securityHeaders(res);
+    createReadStream(file).pipe(res);
+    return true;
+}
+function authorized(header, capability) {
+    const token = header?.startsWith("Bearer ") ? header.slice(7) : "";
+    const left = Buffer.from(token);
+    const right = Buffer.from(capability);
+    return left.length === right.length && timingSafeEqual(left, right);
+}
+async function readJSON(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const value = Buffer.from(chunk);
+        size += value.length;
+        if (size > 16_384)
+            throw new Error("invalid_input");
+        chunks.push(value);
+    }
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+        assertUniqueObjectKeys(text);
+        const value = JSON.parse(text);
+        if (!record(value))
+            throw new Error("invalid_input");
+        return value;
+    }
+    catch {
+        throw new Error("invalid_input");
+    }
+}
+function assertUniqueObjectKeys(text) {
+    let index = 0;
+    const whitespace = () => {
+        while (/\s/u.test(text[index] ?? ""))
+            index += 1;
+    };
+    const string = () => {
+        const start = index;
+        if (text[index] !== '"')
+            throw new Error("invalid_input");
+        index += 1;
+        while (index < text.length) {
+            if (text[index] === "\\") {
+                index += 2;
+                continue;
+            }
+            if (text[index] === '"') {
+                index += 1;
+                return JSON.parse(text.slice(start, index));
+            }
+            index += 1;
+        }
+        throw new Error("invalid_input");
+    };
+    const value = (depth) => {
+        if (depth > 32)
+            throw new Error("invalid_input");
+        whitespace();
+        if (text[index] === '"')
+            return void string();
+        if (text[index] === "{") {
+            index += 1;
+            whitespace();
+            const keys = new Set();
+            if (text[index] === "}")
+                return void (index += 1);
+            for (;;) {
+                whitespace();
+                const key = string();
+                if (keys.has(key))
+                    throw new Error("invalid_input");
+                keys.add(key);
+                whitespace();
+                if (text[index] !== ":")
+                    throw new Error("invalid_input");
+                index += 1;
+                value(depth + 1);
+                whitespace();
+                if (text[index] === "}")
+                    return void (index += 1);
+                if (text[index] !== ",")
+                    throw new Error("invalid_input");
+                index += 1;
+            }
+        }
+        if (text[index] === "[") {
+            index += 1;
+            whitespace();
+            if (text[index] === "]")
+                return void (index += 1);
+            for (;;) {
+                value(depth + 1);
+                whitespace();
+                if (text[index] === "]")
+                    return void (index += 1);
+                if (text[index] !== ",")
+                    throw new Error("invalid_input");
+                index += 1;
+            }
+        }
+        const start = index;
+        while (index < text.length && !/[\s,}\]]/u.test(text[index] ?? ""))
+            index += 1;
+        if (start === index)
+            throw new Error("invalid_input");
+        JSON.parse(text.slice(start, index));
+    };
+    value(0);
+    whitespace();
+    if (index !== text.length)
+        throw new Error("invalid_input");
+}
+function json(res, status, value) {
+    res.statusCode = status;
+    res.setHeader("content-type", "application/json");
+    res.setHeader("cache-control", "no-store");
+    res.setHeader("content-security-policy", "default-src 'none'");
+    securityHeaders(res);
+    res.end(JSON.stringify(value));
+    return true;
+}
+function securityHeaders(res) {
+    res.setHeader("x-content-type-options", "nosniff");
+    res.setHeader("referrer-policy", "no-referrer");
+    res.setHeader("cross-origin-resource-policy", "same-origin");
+}
+function decodeHandle(value) {
+    if (!value || value.length > 256)
+        throw new Error("invalid_input");
+    const decoded = decodeURIComponent(value);
+    if (!/^[A-Za-z0-9_-]{22,256}$/u.test(decoded))
+        throw new Error("invalid_input");
+    return decoded;
+}
+function isJSON(value) {
+    return Boolean(value && /^application\/json(?:\s*;|$)/iu.test(value));
+}
+function mapHttpError(error) {
+    const code = pluginErrorCode(error);
+    if (code === "invalid_input")
+        return { code, status: 400 };
+    if (code === "request_not_found")
+        return { code, status: 404 };
+    if (code === "revision_stale" || code === "request_terminal")
+        return { code, status: 409 };
+    if (code === "action_not_allowed")
+        return { code, status: 422 };
+    if (code === "source_unavailable")
+        return { code, status: 503 };
+    return { code: "internal_error", status: 500 };
+}
+function parseDecisionInput(body, action) {
+    if (Object.keys(body).some((key) => key !== "expectedRevision" && key !== "reason" && key !== "constraints") ||
+        !positiveSafeInteger(body.expectedRevision) ||
+        (body.reason !== undefined && typeof body.reason !== "string"))
+        throw new Error("invalid_input");
+    const options = {};
+    if (typeof body.reason === "string" && body.reason.trim()) {
+        const reason = body.reason.trim();
+        if (Buffer.byteLength(reason, "utf8") > 2000)
+            throw new Error("invalid_input");
+        options.reason = reason;
+    }
+    if (body.constraints !== undefined) {
+        if (action !== "approve" || !record(body.constraints))
+            throw new Error("invalid_input");
+        const constraints = body.constraints;
+        if (Object.keys(constraints).some((key) => key !== "durationSeconds" && key !== "maxUses") ||
+            !positiveSafeInteger(constraints.durationSeconds) ||
+            !positiveSafeInteger(constraints.maxUses))
+            throw new Error("invalid_input");
+        options.constraints = {
+            duration_seconds: constraints.durationSeconds,
+            max_uses: constraints.maxUses,
+        };
+    }
+    return { expectedRevision: body.expectedRevision, options };
+}
+function record(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function positiveSafeInteger(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function createRateLimiter(limit, windowMs) {
+    const entries = new Map();
+    return (key) => {
+        const now = Date.now();
+        const current = entries.get(key);
+        if (!current || current.resetAt <= now) {
+            entries.set(key, { count: 1, resetAt: now + windowMs });
+            return true;
+        }
+        current.count += 1;
+        return current.count <= limit;
+    };
+}
+function contentType(file) {
+    if (file.endsWith(".js"))
+        return "text/javascript";
+    if (file.endsWith(".css"))
+        return "text/css";
+    if (file.endsWith(".svg"))
+        return "image/svg+xml";
+    return "text/html; charset=utf-8";
+}

package/dist/src/operator-v1.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { operatorV1 } from "./generated/operator-v1.js";
+const timestamp = z.iso.datetime({ offset: true });
+const nonNegativeInteger = z.number().int().nonnegative().safe();
+const positiveInteger = z.number().int().positive().safe();
+const status = z.enum(operatorV1.statuses);
+const action = z.enum(operatorV1.actions);
+const fact = z.object({
+    label: z.string().min(1).max(operatorV1.limits.factLabel),
+    value: z.string().min(1).max(operatorV1.limits.factValue),
+});
+const presentation = z.object({
+    risk: z.enum(operatorV1.risks),
+    title: z.string().min(1).max(operatorV1.limits.title),
+    summary: z.string().max(operatorV1.limits.summary).optional(),
+    facts: z.array(fact).max(operatorV1.limits.facts).optional(),
+});
+export const brokerRequestSchema = z.object({
+    id: z.string().min(1).max(operatorV1.limits.id),
+    revision: positiveInteger,
+    requester: z.string().min(1).max(operatorV1.limits.requester),
+    operation: z.string().min(1).max(operatorV1.limits.operation),
+    status,
+    requested_at: timestamp,
+    pending_expires_at: timestamp.optional(),
+    active_expires_at: timestamp.optional(),
+    requested_duration_seconds: positiveInteger,
+    requested_max_uses: positiveInteger,
+    granted_max_uses: positiveInteger.nullable(),
+    used_count: nonNegativeInteger,
+    request_reason: z.string().max(operatorV1.limits.reason).optional(),
+    decided_at: timestamp.optional(),
+    decided_by: z.string().max(operatorV1.limits.actor).optional(),
+    decided_on_behalf_of: z.string().max(operatorV1.limits.actor).optional(),
+    decision_reason: z.string().max(operatorV1.limits.reason).optional(),
+    presentation,
+    presentation_unavailable: z.boolean().optional(),
+    allowed_actions: z
+        .array(action)
+        .max(operatorV1.actions.length)
+        .refine((value) => new Set(value).size === value.length),
+    approval_bounds: z
+        .object({
+        max_duration_seconds: nonNegativeInteger,
+        max_uses: positiveInteger,
+    })
+        .optional(),
+});
+const requestPageSchema = z.object({
+    requests: z.array(brokerRequestSchema).max(operatorV1.limits.page),
+    next_cursor: z.string().min(1).max(operatorV1.limits.cursor).optional(),
+    event_cursor: z.string().min(1).max(operatorV1.limits.cursor).optional(),
+});
+const brokerEventSchema = z.object({
+    cursor: z.string().min(1).max(operatorV1.limits.cursor),
+    kind: z.enum(operatorV1.eventKinds),
+    request_id: z.string().min(1).max(operatorV1.limits.id),
+    revision: positiveInteger,
+    status,
+    occurred_at: timestamp,
+    used_count: nonNegativeInteger,
+});
+const descriptorSchema = z.object({
+    api_version: z.literal(operatorV1.apiVersion),
+});
+const healthSchema = z.object({ status: z.string().min(1).max(128) });
+const errorEnvelopeSchema = z.object({
+    error: z.object({
+        code: z.enum(operatorV1.errorCodes),
+        message: z.string().min(1).max(operatorV1.limits.errorMessage),
+        correlation_id: z.string().min(1).max(operatorV1.limits.correlationId),
+    }),
+});
+export function parseDescriptor(value) {
+    return descriptorSchema.parse(value);
+}
+export function parseHealth(value) {
+    return healthSchema.parse(value);
+}
+export function parseRequest(value) {
+    return brokerRequestSchema.parse(value);
+}
+export function parseRequestPage(value) {
+    return requestPageSchema.parse(value);
+}
+export function parseBrokerEvent(value) {
+    return brokerEventSchema.parse(value);
+}
+export function parseErrorEnvelope(value) {
+    const result = errorEnvelopeSchema.safeParse(value);
+    return result.success ? result.data : undefined;
+}