limits-openclaw 0.0.6

package/dist/src/index.js

@@ -0,0 +1,299 @@
+/**
+ * limits-openclaw: register(api) entrypoint — wires before_tool_call and after_tool_call.
+ */
+import { loadConfig } from "./config.js";
+import { callEnforce } from "./enforcer.js";
+import { log } from "./logger.js";
+import { extractToken } from "./token.js";
+import { runConfigureWizard } from "./configure-wizard.js";
+let firstPreFired = false;
+function getEventAndCtx(args) {
+    if (args.length >= 2) {
+        return { event: args[0], ctx: args[1] };
+    }
+    const payload = args[0];
+    if (payload && typeof payload === "object" && "event" in payload) {
+        const p = payload;
+        return { event: p.event, ctx: p.ctx ?? p.context };
+    }
+    return { event: payload, ctx: undefined };
+}
+function getToolFromEvent(event) {
+    if (!event || typeof event !== "object")
+        return {};
+    const e = event;
+    return {
+        name: typeof e.toolName === "string" ? e.toolName : undefined,
+        args: e.toolParams ?? e.args ?? e.arguments,
+        toolCallId: typeof e.toolCallId === "string"
+            ? e.toolCallId
+            : typeof e.id === "string"
+                ? e.id
+                : undefined,
+    };
+}
+function buildContext(event, ctx) {
+    const e = event && typeof event === "object" ? event : {};
+    const c = ctx && typeof ctx === "object" ? ctx : {};
+    const requestId = (e.requestId ?? c.requestId);
+    const runId = (e.runId ?? c.runId);
+    const sessionKey = (e.sessionKey ?? c.sessionKey);
+    const agentId = (e.agentId ?? c.agentId);
+    const channel = (e.channel ?? c.channel);
+    const userMessageSummary = (e.userMessageSummary ?? c.userMessageSummary);
+    if (requestId === undefined &&
+        runId === undefined &&
+        sessionKey === undefined &&
+        agentId === undefined &&
+        channel === undefined &&
+        userMessageSummary === undefined) {
+        return undefined;
+    }
+    return {
+        ...(typeof requestId === "string" && { requestId }),
+        ...(typeof runId === "string" && { runId }),
+        ...(typeof sessionKey === "string" && { sessionKey }),
+        ...(typeof agentId === "string" && { agentId }),
+        ...(typeof channel === "string" && { channel }),
+        ...(typeof userMessageSummary === "string" && { userMessageSummary }),
+    };
+}
+function getResultFromPayload(args) {
+    const payload = args[0];
+    if (payload && typeof payload === "object" && "result" in payload) {
+        return payload.result;
+    }
+    if (args.length >= 2)
+        return args[1];
+    return undefined;
+}
+function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+const POLICY_MODES = ["INSTRUCTIONS", "CONDITIONS", "GUARDRAIL"];
+function registerPolicyTools(api) {
+    const config = loadConfig(api);
+    const baseUrl = config.baseUrl.replace(/\/$/, "");
+    const apiKey = config.apiToken;
+    if (!baseUrl || !apiKey || typeof api.registerTool !== "function") {
+        return;
+    }
+    api.registerTool({
+        name: "limits_generate_create_policy",
+        description: "Generate a new policy from natural language and create it on the Limits backend. Use when the user wants to add a new policy (e.g. block payment tools, add a guardrail).",
+        parameters: {
+            type: "object",
+            properties: {
+                input: {
+                    type: "string",
+                    description: "Natural-language description of the policy (what to block, allow, or require).",
+                },
+                mode: {
+                    type: "string",
+                    enum: POLICY_MODES,
+                    description: "INSTRUCTIONS | CONDITIONS | GUARDRAIL. Default INSTRUCTIONS. Use GUARDRAIL for rules that scan tool output.",
+                },
+                tools: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: 'Required. Specifies which tool calls this policy applies to. Use ["*"] to apply to all tools / all requests. Use exact tool names (e.g. "read_file") or dot-star prefix patterns (e.g. "stripe_.*") for specific tools. The backend also accepts "stripe_*" and normalizes it to "stripe_.*". Examples: ["*"], ["read_file"], ["stripe_.*", "payment_.*"].',
+                },
+            },
+            required: ["input", "tools"],
+        },
+        async execute(_id, params) {
+            const input = String(params?.input ?? "").trim();
+            if (!input)
+                return textResult("Error: input is required.");
+            const toolsRaw = params?.tools;
+            if (!Array.isArray(toolsRaw) ||
+                toolsRaw.length === 0 ||
+                !toolsRaw.every((t) => typeof t === "string" && t.trim() !== "")) {
+                return textResult('Error: tools is required and must be a non-empty array of strings. Use ["*"] for all tools / all requests, or specific tool names / prefix patterns (e.g. ["stripe_.*"]).');
+            }
+            const tools = toolsRaw;
+            const mode = params?.mode && POLICY_MODES.includes(params.mode) ? params.mode : "INSTRUCTIONS";
+            try {
+                const res = await fetch(`${baseUrl}/api/policies/generatecreate`, {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ input, mode, tools }),
+                });
+                const body = await res.text();
+                if (!res.ok)
+                    return textResult(`Limits API error (${res.status}): ${body || res.statusText}`);
+                return textResult(body || "Policy created.");
+            }
+            catch (err) {
+                return textResult(`Request failed: ${String(err)}`);
+            }
+        }
+    }, { optional: true });
+    api.registerTool({
+        name: "limits_generate_update_policy",
+        description: "Generate updates from natural language and apply them to an existing policy on the Limits backend. Use when the user wants to change an existing policy.",
+        parameters: {
+            type: "object",
+            properties: {
+                policyId: {
+                    type: "string",
+                    description: "The ID (UUID) of the existing policy to update.",
+                },
+                input: {
+                    type: "string",
+                    description: "Natural-language description of the changes or additions.",
+                },
+                mode: {
+                    type: "string",
+                    enum: POLICY_MODES,
+                    description: "INSTRUCTIONS | CONDITIONS | GUARDRAIL.",
+                },
+            },
+            required: ["policyId", "input"],
+        },
+        async execute(_id, params) {
+            const policyId = String(params?.policyId ?? "").trim();
+            const input = String(params?.input ?? "").trim();
+            if (!policyId || !input)
+                return textResult("Error: policyId and input are required.");
+            const mode = params?.mode && POLICY_MODES.includes(params.mode) ? params.mode : "INSTRUCTIONS";
+            try {
+                const res = await fetch(`${baseUrl}/api/policies/${encodeURIComponent(policyId)}/generateupdate`, {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ input, mode }),
+                });
+                const body = await res.text();
+                if (!res.ok)
+                    return textResult(`Limits API error (${res.status}): ${body || res.statusText}`);
+                return textResult(body || "Policy updated.");
+            }
+            catch (err) {
+                return textResult(`Request failed: ${String(err)}`);
+            }
+        }
+    }, { optional: true });
+    log("policy-generator tools registered (limits_generate_create_policy, limits_generate_update_policy)");
+}
+export function register(api) {
+    log("limits-openclaw loaded");
+    if (typeof api.on !== "function") {
+        log("api.on not available, hooks not registered");
+        return;
+    }
+    api.on("before_tool_call", async (...args) => {
+        if (!firstPreFired) {
+            firstPreFired = true;
+            log("before_tool_call observed");
+        }
+        const config = loadConfig(api);
+        if (!config.baseUrl) {
+            return config.failMode === "block"
+                ? { block: true, reason: "enforcement unavailable" }
+                : null;
+        }
+        const { event, ctx } = getEventAndCtx(args);
+        const apiToken = extractToken(config.tokenSource, event, ctx) ?? config.apiToken;
+        const tool = getToolFromEvent(event);
+        const context = buildContext(event, ctx);
+        const body = {
+            phase: "pre",
+            apiToken,
+            tool: { name: tool.name, args: tool.args, toolCallId: tool.toolCallId },
+            ...(context && Object.keys(context).length > 0 && { context }),
+        };
+        let response;
+        try {
+            response = await callEnforce(config, body);
+        }
+        catch {
+            response = null;
+        }
+        if (!response) {
+            if (config.failMode === "block") {
+                return { block: true, reason: "enforcement unavailable" };
+            }
+            return null;
+        }
+        if (response.action === "ALLOW")
+            return null;
+        if (response.action === "BLOCK") {
+            return {
+                block: true,
+                reason: typeof response.reason === "string"
+                    ? response.reason
+                    : "Blocked by policy",
+            };
+        }
+        if (response.action === "REWRITE" && "rewriteArgs" in response && response.rewriteArgs !== undefined) {
+            return { args: response.rewriteArgs };
+        }
+        return null;
+    });
+    api.on("after_tool_call", async (...args) => {
+        const config = loadConfig(api);
+        if (!config.baseUrl) {
+            if (config.failMode === "block") {
+                return { result: "[BLOCKED by policy — content withheld]" };
+            }
+            return null;
+        }
+        const { event, ctx } = getEventAndCtx(args);
+        const apiToken = extractToken(config.tokenSource, event, ctx) ?? config.apiToken;
+        const tool = getToolFromEvent(event);
+        const result = getResultFromPayload(args);
+        const context = buildContext(event, ctx);
+        const body = {
+            phase: "post",
+            apiToken,
+            tool: {
+                name: tool.name,
+                args: tool.args,
+                toolCallId: tool.toolCallId,
+                result,
+            },
+            ...(context && Object.keys(context).length > 0 && { context }),
+        };
+        let response;
+        try {
+            response = await callEnforce(config, body);
+        }
+        catch {
+            response = null;
+        }
+        if (!response) {
+            if (config.failMode === "block") {
+                return { result: "[BLOCKED by policy — content withheld]" };
+            }
+            return null;
+        }
+        if (response.action === "ALLOW")
+            return null;
+        if (response.action === "BLOCK") {
+            return { result: "[BLOCKED by policy — content withheld]" };
+        }
+        if (response.action === "REDACT" && response.redactedResult !== undefined) {
+            return { result: response.redactedResult };
+        }
+        if (response.action === "REWRITE" && response.rewrittenResult !== undefined) {
+            return { result: response.rewrittenResult };
+        }
+        return null;
+    });
+    registerPolicyTools(api);
+    if (typeof api.registerCli === "function") {
+        api.registerCli((opts) => {
+            const program = opts.program;
+            const root = program.command("limits").description("Limits OpenClaw plugin");
+            root.command("configure").description("Configure API token and base URL (wizard)").action(async () => {
+                await runConfigureWizard();
+            });
+        }, { commands: ["limits"] });
+    }
+}

package/dist/src/logger.js

@@ -0,0 +1,22 @@
+/**
+ * Safe logger for limits-openclaw. Never logs apiToken, request body, or tool args.
+ */
+const PREFIX = "[limits-openclaw]";
+export function log(message, ...safeArgs) {
+    const safe = safeArgs.map((a) => typeof a === "string" || typeof a === "number" || typeof a === "boolean"
+        ? a
+        : "[object]");
+    console.log(PREFIX, message, ...safe);
+}
+export function warn(message, ...safeArgs) {
+    const safe = safeArgs.map((a) => typeof a === "string" || typeof a === "number" || typeof a === "boolean"
+        ? a
+        : "[object]");
+    console.warn(PREFIX, message, ...safe);
+}
+export function error(message, ...safeArgs) {
+    const safe = safeArgs.map((a) => typeof a === "string" || typeof a === "number" || typeof a === "boolean"
+        ? a
+        : "[object]");
+    console.error(PREFIX, message, ...safe);
+}

package/dist/src/token.js

@@ -0,0 +1,36 @@
+/**
+ * Extract API token from a dot-separated path (event, ctx, or env).
+ * Never throws; returns undefined if path is missing or invalid.
+ */
+export function extractToken(tokenSource, event, ctx) {
+    if (typeof tokenSource !== "string" || !tokenSource.trim()) {
+        return undefined;
+    }
+    const path = tokenSource.trim().split(".");
+    if (path.length < 2) {
+        return undefined;
+    }
+    const [root, ...rest] = path;
+    let obj;
+    if (root === "event") {
+        obj = event;
+    }
+    else if (root === "ctx") {
+        obj = ctx;
+    }
+    else if (root === "env") {
+        const key = rest.join(".");
+        const val = process.env[key];
+        return typeof val === "string" ? val : undefined;
+    }
+    else {
+        return undefined;
+    }
+    for (const key of rest) {
+        if (obj === null || obj === undefined || typeof obj !== "object") {
+            return undefined;
+        }
+        obj = obj[key];
+    }
+    return typeof obj === "string" ? obj : undefined;
+}

package/dist/test/integration/mock-saas.test.js

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { createServer } from "http";
+/**
+ * Integration test: real HTTP server, real enforcer client, full pre+post flow.
+ * SaaS returns BLOCK for stripe.* tools, ALLOW for others.
+ */
+describe("mock-saas integration", () => {
+    let server;
+    let baseUrl;
+    let beforeHandler = null;
+    let afterHandler = null;
+    beforeAll(async () => {
+        await new Promise((resolve) => {
+            server = createServer((req, res) => {
+                if (req.method !== "POST" || req.url !== "/openclaw/enforce") {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                let body = "";
+                req.on("data", (ch) => (body += ch));
+                req.on("end", () => {
+                    try {
+                        const data = JSON.parse(body);
+                        const name = data.tool?.name ?? "";
+                        const isStripe = /^stripe\./.test(name) || name.startsWith("stripe_");
+                        if (data.phase === "pre" || data.phase === "post") {
+                            if (isStripe) {
+                                res.writeHead(200, { "Content-Type": "application/json" });
+                                res.end(JSON.stringify({
+                                    action: "BLOCK",
+                                    reason: "Stripe tools are disabled in this environment",
+                                }));
+                            }
+                            else {
+                                res.writeHead(200, { "Content-Type": "application/json" });
+                                res.end(JSON.stringify({ action: "ALLOW" }));
+                            }
+                        }
+                        else {
+                            res.writeHead(400);
+                            res.end();
+                        }
+                    }
+                    catch {
+                        res.writeHead(400);
+                        res.end();
+                    }
+                });
+            });
+            server.listen(0, "127.0.0.1", () => {
+                const addr = server.address();
+                const port = typeof addr === "object" && addr && "port" in addr ? addr.port : 0;
+                baseUrl = `http://127.0.0.1:${port}`;
+                resolve();
+            });
+        });
+    });
+    afterAll(() => {
+        return new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+    });
+    it("registers and runs pre-hook: stripe tool blocked, other allowed", async () => {
+        const api = {
+            config: {
+                plugins: {
+                    entries: {
+                        "limits-openclaw": {
+                            enabled: true,
+                            config: {
+                                baseUrl: baseUrl,
+                                failMode: "allow",
+                                tokenSource: "event.metadata.apiToken",
+                            },
+                        },
+                    },
+                },
+            },
+            on(event, handler) {
+                if (event === "before_tool_call")
+                    beforeHandler = handler;
+                if (event === "after_tool_call")
+                    afterHandler = handler;
+            },
+        };
+        const { register } = await import("../../src/index.js");
+        register(api);
+        const eventStripe = {
+            toolName: "stripe_charge",
+            toolParams: { amount: 100 },
+            metadata: { apiToken: "sk_test" },
+        };
+        const resultBlocked = await beforeHandler(eventStripe, undefined);
+        expect(resultBlocked).toEqual({
+            block: true,
+            reason: "Stripe tools are disabled in this environment",
+        });
+        const eventSafe = {
+            toolName: "read_file",
+            toolParams: { path: "/tmp/foo" },
+            metadata: { apiToken: "sk_test" },
+        };
+        const resultAllowed = await beforeHandler(eventSafe, undefined);
+        expect(resultAllowed).toBe(null);
+    });
+    it("post-hook: stripe result blocked, other allowed", async () => {
+        const api = {
+            config: {
+                plugins: {
+                    entries: {
+                        "limits-openclaw": {
+                            enabled: true,
+                            config: {
+                                baseUrl: baseUrl,
+                                failMode: "allow",
+                                tokenSource: "event.metadata.apiToken",
+                            },
+                        },
+                    },
+                },
+            },
+            on(event, handler) {
+                if (event === "after_tool_call")
+                    afterHandler = handler;
+            },
+        };
+        const { register } = await import("../../src/index.js");
+        register(api);
+        const stripeResult = await afterHandler({
+            toolName: "stripe_charge",
+            metadata: { apiToken: "sk_test" },
+        }, { chargeId: "ch_secret" }, undefined);
+        expect(stripeResult).toEqual({
+            result: "[BLOCKED by policy — content withheld]",
+        });
+        const safeResult = await afterHandler({
+            toolName: "read_file",
+            metadata: { apiToken: "sk_test" },
+        }, { content: "hello" }, undefined);
+        expect(safeResult).toBe(null);
+    });
+});

package/dist/test/unit/failmode.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const callEnforceMock = vi.fn();
+vi.mock("../../src/enforcer.js", () => ({ callEnforce: callEnforceMock }));
+describe("failmode", () => {
+    let beforeHandler = null;
+    let afterHandler = null;
+    function createApi(failMode) {
+        return {
+            config: {
+                plugins: {
+                    entries: {
+                        "limits-openclaw": {
+                            enabled: true,
+                            config: {
+                                baseUrl: "https://api.test.com",
+                                failMode: failMode,
+                                tokenSource: "event.metadata.apiToken",
+                            },
+                        },
+                    },
+                },
+            },
+            on(event, handler) {
+                if (event === "before_tool_call")
+                    beforeHandler = handler;
+                if (event === "after_tool_call")
+                    afterHandler = handler;
+            },
+        };
+    }
+    beforeEach(async () => {
+        callEnforceMock.mockReset();
+        beforeHandler = null;
+        afterHandler = null;
+    });
+    it("SaaS unreachable with failMode allow returns null (pre)", async () => {
+        callEnforceMock.mockResolvedValue(null);
+        const { register } = await import("../../src/index.js");
+        register(createApi("allow"));
+        const event = { toolName: "bash", metadata: { apiToken: "sk_ok" } };
+        const result = await beforeHandler(event, undefined);
+        expect(result).toBe(null);
+    });
+    it("SaaS unreachable with failMode block returns block (pre)", async () => {
+        callEnforceMock.mockResolvedValue(null);
+        const { register } = await import("../../src/index.js");
+        register(createApi("block"));
+        const event = { toolName: "bash", metadata: { apiToken: "sk_ok" } };
+        const result = await beforeHandler(event, undefined);
+        expect(result).toEqual({
+            block: true,
+            reason: "enforcement unavailable",
+        });
+    });
+    it("no baseUrl with failMode block returns block (pre)", async () => {
+        const api = {
+            config: {
+                plugins: {
+                    entries: {
+                        "limits-openclaw": {
+                            enabled: true,
+                            config: {
+                                baseUrl: "",
+                                failMode: "block",
+                                tokenSource: "event.metadata.apiToken",
+                            },
+                        },
+                    },
+                },
+            },
+            on(event, handler) {
+                if (event === "before_tool_call")
+                    beforeHandler = handler;
+            },
+        };
+        const { register } = await import("../../src/index.js");
+        register(api);
+        const result = await beforeHandler({ toolName: "x" }, undefined);
+        expect(result).toEqual({
+            block: true,
+            reason: "enforcement unavailable",
+        });
+    });
+    it("SaaS unreachable with failMode block (post) returns blocked result", async () => {
+        callEnforceMock.mockResolvedValue(null);
+        const { register } = await import("../../src/index.js");
+        register(createApi("block"));
+        const result = await afterHandler({ toolName: "get", metadata: { apiToken: "sk_ok" } }, { data: "secret" }, undefined);
+        expect(result).toEqual({
+            result: "[BLOCKED by policy — content withheld]",
+        });
+    });
+    it("timeout / network error returns null when failMode allow", async () => {
+        callEnforceMock.mockRejectedValue(new Error("network error"));
+        const { register } = await import("../../src/index.js");
+        register(createApi("allow"));
+        const event = { toolName: "ping", metadata: { apiToken: "sk_ok" } };
+        const result = await beforeHandler(event, undefined);
+        expect(result).toBe(null);
+    });
+});

package/dist/test/unit/post.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const callEnforceMock = vi.fn();
+vi.mock("../../src/enforcer.js", () => ({ callEnforce: callEnforceMock }));
+describe("postHook", () => {
+    let afterHandler = null;
+    beforeEach(async () => {
+        callEnforceMock.mockReset();
+        afterHandler = null;
+        const api = {
+            config: {
+                plugins: {
+                    entries: {
+                        "limits-openclaw": {
+                            enabled: true,
+                            config: {
+                                baseUrl: "https://api.test.com",
+                                failMode: "allow",
+                                tokenSource: "event.metadata.apiToken",
+                            },
+                        },
+                    },
+                },
+            },
+            on(event, handler) {
+                if (event === "after_tool_call")
+                    afterHandler = handler;
+            },
+        };
+        const { register } = await import("../../src/index.js");
+        register(api);
+    });
+    async function runPost(event, result, ctx) {
+        if (!afterHandler)
+            throw new Error("after_tool_call not registered");
+        if (result !== undefined && ctx !== undefined)
+            return afterHandler(event, result, ctx);
+        if (result !== undefined)
+            return afterHandler(event, result);
+        return afterHandler({ ...event, result: undefined }, undefined);
+    }
+    it("ALLOW returns null", async () => {
+        callEnforceMock.mockResolvedValue({ action: "ALLOW" });
+        const event = {
+            toolName: "read_file",
+            metadata: { apiToken: "sk_ok" },
+        };
+        const result = await runPost(event, { content: "data" }, undefined);
+        expect(result).toBe(null);
+    });
+    it("BLOCK returns blocked result message", async () => {
+        callEnforceMock.mockResolvedValue({
+            action: "BLOCK",
+            reason: "Sensitive output",
+        });
+        const event = { toolName: "query_db", metadata: { apiToken: "sk_ok" } };
+        const result = await runPost(event, { rows: [] }, undefined);
+        expect(result).toEqual({
+            result: "[BLOCKED by policy — content withheld]",
+        });
+    });
+    it("REDACT returns { result: redactedResult }", async () => {
+        callEnforceMock.mockResolvedValue({
+            action: "REDACT",
+            redactedResult: "[REDACTED]",
+        });
+        const event = { toolName: "get_user", metadata: { apiToken: "sk_ok" } };
+        const result = await runPost(event, { email: "a@b.com" }, undefined);
+        expect(result).toEqual({ result: "[REDACTED]" });
+    });
+    it("REWRITE returns { result: rewrittenResult }", async () => {
+        callEnforceMock.mockResolvedValue({
+            action: "REWRITE",
+            rewrittenResult: { summary: "Safe summary" },
+        });
+        const event = { toolName: "run_report", metadata: { apiToken: "sk_ok" } };
+        const result = await runPost(event, { raw: "long..." }, undefined);
+        expect(result).toEqual({ result: { summary: "Safe summary" } });
+    });
+});