@kalera/munin-openclaw 1.2.0 → 1.2.7

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @kalera/munin-openclaw@1.2.0 build /home/runner/work/munin-for-agents/munin-for-agents/adapters/openclaw
+> @kalera/munin-openclaw@1.2.7 build /home/runner/work/munin-for-agents/munin-for-agents/adapters/openclaw
 > tsc -p tsconfig.json
 

package/SKILL.md

@@ -1,71 +1,83 @@
 ---
 name: "@kalera/munin-openclaw"
 description: "Munin - The Free (or $1.6/mo) Persistent Memory for OpenClaw. Stop your agent from having Alzheimer's."
-version: "1.0.1"
+version: "1.0.2"
 metadata:
   clawdbot:
     type: "plugin"
     permissions:
-      env: ["MUNIN_BASE_URL", "MUNIN_API_KEY"]
+      env: ["MUNIN_BASE_URL", "MUNIN_API_KEY", "MUNIN_PROJECT", "MUNIN_ENCRYPTION_KEY"]
 ---
 
-# 🐦 Munin: Reliable Memory for Your OpenClaw Agent
+# Munin: Reliable Memory for Your OpenClaw Agent
 
 <CRITICAL-INSTRUCTION>
 **HOW TO USE THIS SKILL**:
-The `munin_store_memory`, `munin_retrieve_memory`, and `munin_search_memories` actions are registered as native tools (MCP). 
-You MUST call them using your standard tool-calling interface (e.g. `callTool("munin_search_memories", {...})`). 
+All `munin_*` actions are registered as native tools (MCP).
+You MUST call them using your standard tool-calling interface (e.g. `callTool("munin_search_memories", {...})`).
 **DO NOT under any circumstances try to run them as shell commands or bash scripts.**
 </CRITICAL-INSTRUCTION>
 
-Your agent forgets everything the moment you close the tab. You've seen the "pro" solutions—Mem0, Zep, LangMem—and you've seen their **$20/month** price tags. 
+## Available Tools
 
-We think that's insane. 
+| Tool | Purpose |
+|------|---------|
+| `munin_store_memory` | Store or update a memory |
+| `munin_retrieve_memory` | Get memory by exact key |
+| `munin_search_memories` | Semantic search |
+| `munin_list_memories` | Paginated list of all memories |
+| `munin_recent_memories` | Most recently updated memories |
+| `munin_share_memory` | Share memories to other projects (Pro/Elite only) |
 
-**Munin** is the pragmatic alternative. It’s the "Reliable Friend" that sits on your agent’s shoulder and whispers: *"Hey, remember when pa Kal said he preferred Python over Node last week?"*
+## Before Any Task
+1. Call `munin_search_memories` with keywords relevant to the current task
+2. Call `munin_retrieve_memory` for detailed context on promising matches
+3. Present findings — DO NOT guess, verify from memory first
 
-### 💰 Why Munin? (The "No-Brainer" Math)
-
-| Feature | Mem0 / Zep | **Munin** |
-| :--- | :--- | :--- |
-| **Monthly Cost** | $19.00 - $249.00 | **Free** (or $1.60 Pro) |
-| **MCP Support** | Mixed | **Native / First-class** |
-| **Zero-Knowledge E2EE** | Optional / Complex | **Built-in (Client-side)** |
-| **Bullshit Factor** | High (Enterprise-synergy) | **Zero (Developer-first)** |
-
-**That’s a 10x - 150x price gap.** We aren't building "Enterprise Synergy Platforms". We're building a notebook for your AI.
+## After Completing a Task
+Call `munin_store_memory` with:
+- **title**: Concise summary (max 80 chars)
+- **content**: Detailed description including file paths, line numbers, decisions
+- **tags**: Relevant tags (e.g., `task`, `architecture`, `bug-fix`, `setup`, `decision`)
 
 ---
 
-## 🔒 Security & Privacy
+## E2EE & Hash Key
 
-**Trust Statement:**
-Data stays where you tell it to stay. All data is encrypted locally (if E2EE is enabled) and isolated by your Context Core. We are completely blind to your plaintext.
+Every E2EE project uses a Hash Key — the password the user set in the WebUI.
 
-**External Endpoints:**
-Data is sent ONLY to your `MUNIN_BASE_URL`. We don't phone home. We don't sell your "memories" to train models.
+**Setup:** Set `MUNIN_ENCRYPTION_KEY=<hash-key>` in your environment. The adapter automatically passes this key to all tool calls.
 
-## 💎 E2EE with GraphRAG (Elite Tier)
+**Critical:**
+- Wrong Hash Key → all reads/writes fail. Re-confirm with the user.
+- NEVER log or share the Hash Key in plain text.
+- NEVER hardcode the Hash Key in scripts.
 
-If your Munin project has **E2EE with GraphRAG** enabled, standard E2EE rules apply PLUS:
-- You **MUST** generate a vector embedding of the plaintext content locally before encrypting.
-- You **MUST** include the embedding array in the `store` payload: `{ "content": "encrypted...", "embedding": [0.1, -0.02, ...], "encryptionMeta": {...} }`.
-- Munin will use this vector for zero-knowledge semantic search. It will reject the request if the embedding is missing.
+### E2EE + GraphRAG (Elite Tier)
+`munin_store_memory` payload MUST include an `embedding` field (encrypted vector generated client-side). Server returns HTTP 400 if missing.
 
----
+### Sharing Across Projects
+Use `munin_share_memory({ memoryIds: [...], targetProjectIds: [...] })` (Pro/Elite only).
+- Target project must share the same Hash Key to read encrypted content.
+- If target has E2EE ON and key differs → shared memory is unreadable until the target's Hash Key is updated.
 
-## 🚀 Setup (Fast & Honest)
+---
 
-1. **Get your Munin key:** Grab a **free** cloud key at [munin.kalera.dev](https://munin.kalera.dev).
-2. **Configure OpenClaw:** Once installed via `openclaw plugins install @kalera/munin-openclaw`, you can set your API key and Context Core ID directly via the OpenClaw CLI without manually editing any config files:
+## Setup
 
+1. **Install the plugin:**
    ```bash
-   openclaw config set plugins.entries.munin-openclaw.config.apiKey "your-api-key-here"
-   openclaw config set plugins.entries.munin-openclaw.config.projectId "your-context-core-id"
+   openclaw plugins install @kalera/munin-openclaw
    ```
-   *(Alternatively, you can just set `MUNIN_BASE_URL`, `MUNIN_API_KEY`, and `MUNIN_PROJECT` environment variables).*
-
-3. **Profit:** Your agent now has long-term memory. No more repeating yourself.
+2. **Get your key:** [munin.kalera.dev](https://munin.kalera.dev)
+3. **Configure:**
+   ```bash
+   openclaw config set plugins.entries.munin-openclaw.config.apiKey "your-api-key"
+   openclaw config set plugins.entries.munin-openclaw.config.projectId "your-project-id"
+   ```
+   Or via env vars: `MUNIN_BASE_URL`, `MUNIN_API_KEY`, `MUNIN_PROJECT`
+4. **E2EE:** Add `MUNIN_ENCRYPTION_KEY=<hash-key>` if the project has E2EE enabled.
+5. **Restart OpenClaw** — the agent will now have access to all `munin_*` tools.
+6. **Profit.**
 
----
-*Built with ❤️ by Kalera for the OpenClaw Ecosystem.*
+*Built with ❤️ by Kalera for the OpenClaw Ecosystem.*

package/dist/index.d.ts

@@ -1,9 +1,20 @@
+import { z } from "zod";
 declare const _default: {
     id: string;
     name: string;
     description: string;
     kind: string;
-    configSchema: any;
-    register(api: any): void;
+    configSchema: z.ZodObject<{
+        baseUrl: z.ZodDefault<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    register(api: {
+        logger: {
+            warn: (msg: string) => void;
+        };
+        registerTool: (tool: Record<string, unknown>) => void;
+        pluginConfig?: Record<string, unknown>;
+    }): void;
 };
 export default _default;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { MuninClient } from "@kalera/munin-sdk";
+import { resolveProjectId } from "@kalera/munin-runtime";
 import { Type } from "@sinclair/typebox";
 import { z } from "zod";
 export default {
@@ -19,12 +20,21 @@ export default {
             process.env.MUNIN_BASE_URL ||
             "https://munin.kalera.dev";
         const apiKey = api.pluginConfig?.apiKey || process.env.MUNIN_API_KEY;
-        const projectId = api.pluginConfig?.projectId || process.env.MUNIN_PROJECT;
+        const projectId = api.pluginConfig?.projectId ||
+            process.env.MUNIN_PROJECT ||
+            resolveProjectId(); // walk-up fallback for .env files
+        const encryptionKey = process.env.MUNIN_ENCRYPTION_KEY;
         if (!apiKey || !projectId) {
             api.logger.warn("Munin apiKey or projectId is missing. Munin tools will not be registered.");
             return;
         }
         const client = new MuninClient({ baseUrl, apiKey });
+        // Helper: inject encryptionKey if set (only for E2EE-compatible tools)
+        const enrichPayload = (payload) => encryptionKey ? { ...payload, encryptionKey } : payload;
+        const handleResult = (res) => ({
+            content: [{ type: "text", text: JSON.stringify(res.data, null, 2) }],
+            details: res.data,
+        });
         api.registerTool({
             name: "munin_store_memory",
             label: "Store Munin Memory",
@@ -36,16 +46,8 @@ export default {
                 title: Type.Optional(Type.String({ description: "Human-readable title." })),
             }),
             async execute(_toolCallId, payload) {
-                const res = await client.invoke(projectId, "store", payload);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(res.data, null, 2),
-                        },
-                    ],
-                    details: res.data,
-                };
+                const res = await client.invoke(projectId, "store", enrichPayload(payload));
+                return handleResult(res);
             },
         });
         api.registerTool({
@@ -53,22 +55,12 @@ export default {
             label: "Retrieve Munin Memory",
             description: "Retrieve a memory by its key from Munin.",
             parameters: Type.Object({
-                key: Type.String({
-                    description: "The unique identifier of the memory.",
-                }),
+                key: Type.String({ description: "The unique identifier of the memory." }),
             }),
             async execute(_toolCallId, params) {
                 const { key } = params;
-                const res = await client.invoke(projectId, "retrieve", { key });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(res.data, null, 2),
-                        },
-                    ],
-                    details: res.data,
-                };
+                const res = await client.invoke(projectId, "retrieve", enrichPayload({ key }));
+                return handleResult(res);
             },
         });
         api.registerTool({
@@ -80,16 +72,47 @@ export default {
             }),
             async execute(_toolCallId, params) {
                 const { query } = params;
-                const res = await client.invoke(projectId, "search", { query });
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(res.data, null, 2),
-                        },
-                    ],
-                    details: res.data,
-                };
+                const res = await client.invoke(projectId, "search", enrichPayload({ query }));
+                return handleResult(res);
+            },
+        });
+        api.registerTool({
+            name: "munin_list_memories",
+            label: "List Munin Memories",
+            description: "List all memories with pagination support.",
+            parameters: Type.Object({
+                limit: Type.Optional(Type.Number({ description: "Max results (default: 10)." })),
+                offset: Type.Optional(Type.Number({ description: "Pagination offset (default: 0)." })),
+            }),
+            async execute(_toolCallId, params) {
+                const res = await client.invoke(projectId, "list", enrichPayload(params));
+                return handleResult(res);
+            },
+        });
+        api.registerTool({
+            name: "munin_recent_memories",
+            label: "Recent Munin Memories",
+            description: "Get the most recently updated memories.",
+            parameters: Type.Object({
+                limit: Type.Optional(Type.Number({ description: "Max results (default: 10)." })),
+            }),
+            async execute(_toolCallId, params) {
+                const res = await client.invoke(projectId, "recent", enrichPayload(params));
+                return handleResult(res);
+            },
+        });
+        api.registerTool({
+            name: "munin_share_memory",
+            label: "Share Munin Memories",
+            description: "Share one or more memories to other projects. Requires Pro/Elite tier. Target project must share the same Hash Key for encrypted content.",
+            parameters: Type.Object({
+                memoryIds: Type.Array(Type.String(), { description: "Array of memory IDs to share." }),
+                targetProjectIds: Type.Array(Type.String(), { description: "Array of target project IDs." }),
+            }),
+            async execute(_toolCallId, params) {
+                const { memoryIds, targetProjectIds } = params;
+                const res = await client.invoke(projectId, "share", enrichPayload({ memoryIds, targetProjectIds }));
+                return handleResult(res);
             },
         });
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kalera/munin-openclaw",
-  "version": "1.2.0",
+  "version": "1.2.7",
   "type": "module",
   "openclaw": {
     "extensions": [
@@ -16,8 +16,8 @@
   "dependencies": {
     "@sinclair/typebox": "^0.34.49",
     "zod": "^4.3.6",
-    "@kalera/munin-sdk": "1.2.0",
-    "@kalera/munin-runtime": "1.2.0"
+    "@kalera/munin-sdk": "1.2.6",
+    "@kalera/munin-runtime": "1.2.6"
   },
   "devDependencies": {
     "openclaw": "^2026.3.28",

package/src/index.ts

@@ -1,4 +1,6 @@
 import { MuninClient } from "@kalera/munin-sdk";
+import { resolveProjectId } from "@kalera/munin-runtime";
+import type { MuninAction } from "@kalera/munin-sdk";
 import { Type } from "@sinclair/typebox";
 import { z } from "zod";
 
@@ -14,16 +16,23 @@ export default {
       .describe("The base URL for your Munin server."),
     apiKey: z.string().optional().describe("Your API key for Munin."),
     projectId: z.string().optional().describe("Your Context Core ID (e.g. proj_xxx)."),
-  }) as any,
-  register(api: any) {
+  }),
+  register(api: {
+    logger: { warn: (msg: string) => void };
+    registerTool: (tool: Record<string, unknown>) => void;
+    pluginConfig?: Record<string, unknown>;
+  }) {
     const baseUrl =
-      (api.pluginConfig?.baseUrl as string) ||
+      (api.pluginConfig?.baseUrl as string | undefined) ||
       process.env.MUNIN_BASE_URL ||
       "https://munin.kalera.dev";
     const apiKey =
-      (api.pluginConfig?.apiKey as string) || process.env.MUNIN_API_KEY;
+      (api.pluginConfig?.apiKey as string | undefined) || process.env.MUNIN_API_KEY;
     const projectId =
-      (api.pluginConfig?.projectId as string) || process.env.MUNIN_PROJECT;
+      (api.pluginConfig?.projectId as string | undefined) ||
+      process.env.MUNIN_PROJECT ||
+      resolveProjectId(); // walk-up fallback for .env files
+    const encryptionKey = process.env.MUNIN_ENCRYPTION_KEY;
 
     if (!apiKey || !projectId) {
       api.logger.warn(
@@ -34,6 +43,15 @@ export default {
 
     const client = new MuninClient({ baseUrl, apiKey });
 
+    // Helper: inject encryptionKey if set (only for E2EE-compatible tools)
+    const enrichPayload = (payload: Record<string, unknown>): Record<string, unknown> =>
+      encryptionKey ? { ...payload, encryptionKey } : payload;
+
+    const handleResult = (res: { data?: unknown }) => ({
+      content: [{ type: "text" as const, text: JSON.stringify(res.data, null, 2) }],
+      details: res.data,
+    });
+
     api.registerTool({
       name: "munin_store_memory",
       label: "Store Munin Memory",
@@ -41,24 +59,12 @@ export default {
       parameters: Type.Object({
         key: Type.String({ description: "Unique identifier for the memory." }),
         content: Type.String({ description: "The content of the memory." }),
-        tags: Type.Optional(
-          Type.String({ description: "Comma-separated list of tags." }),
-        ),
-        title: Type.Optional(
-          Type.String({ description: "Human-readable title." }),
-        ),
+        tags: Type.Optional(Type.String({ description: "Comma-separated list of tags." })),
+        title: Type.Optional(Type.String({ description: "Human-readable title." })),
       }),
-      async execute(_toolCallId: string, payload: any) {
-        const res = await client.invoke(projectId, "store", payload);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(res.data, null, 2),
-            },
-          ],
-          details: res.data,
-        };
+      async execute(_toolCallId: string, payload: Record<string, unknown>) {
+        const res = await client.invoke(projectId, "store" as MuninAction, enrichPayload(payload));
+        return handleResult(res);
       },
     });
 
@@ -67,22 +73,12 @@ export default {
       label: "Retrieve Munin Memory",
       description: "Retrieve a memory by its key from Munin.",
       parameters: Type.Object({
-        key: Type.String({
-          description: "The unique identifier of the memory.",
-        }),
+        key: Type.String({ description: "The unique identifier of the memory." }),
       }),
-      async execute(_toolCallId: string, params: any) {
+      async execute(_toolCallId: string, params: Record<string, unknown>) {
         const { key } = params;
-        const res = await client.invoke(projectId, "retrieve", { key });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(res.data, null, 2),
-            },
-          ],
-          details: res.data,
-        };
+        const res = await client.invoke(projectId, "retrieve" as MuninAction, enrichPayload({ key }));
+        return handleResult(res);
       },
     });
 
@@ -93,18 +89,52 @@ export default {
       parameters: Type.Object({
         query: Type.String({ description: "The search term." }),
       }),
-      async execute(_toolCallId: string, params: any) {
+      async execute(_toolCallId: string, params: Record<string, unknown>) {
         const { query } = params;
-        const res = await client.invoke(projectId, "search", { query });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(res.data, null, 2),
-            },
-          ],
-          details: res.data,
-        };
+        const res = await client.invoke(projectId, "search" as MuninAction, enrichPayload({ query }));
+        return handleResult(res);
+      },
+    });
+
+    api.registerTool({
+      name: "munin_list_memories",
+      label: "List Munin Memories",
+      description: "List all memories with pagination support.",
+      parameters: Type.Object({
+        limit: Type.Optional(Type.Number({ description: "Max results (default: 10)." })),
+        offset: Type.Optional(Type.Number({ description: "Pagination offset (default: 0)." })),
+      }),
+      async execute(_toolCallId: string, params: Record<string, unknown>) {
+        const res = await client.invoke(projectId, "list" as MuninAction, enrichPayload(params));
+        return handleResult(res);
+      },
+    });
+
+    api.registerTool({
+      name: "munin_recent_memories",
+      label: "Recent Munin Memories",
+      description: "Get the most recently updated memories.",
+      parameters: Type.Object({
+        limit: Type.Optional(Type.Number({ description: "Max results (default: 10)." })),
+      }),
+      async execute(_toolCallId: string, params: Record<string, unknown>) {
+        const res = await client.invoke(projectId, "recent" as MuninAction, enrichPayload(params));
+        return handleResult(res);
+      },
+    });
+
+    api.registerTool({
+      name: "munin_share_memory",
+      label: "Share Munin Memories",
+      description: "Share one or more memories to other projects. Requires Pro/Elite tier. Target project must share the same Hash Key for encrypted content.",
+      parameters: Type.Object({
+        memoryIds: Type.Array(Type.String(), { description: "Array of memory IDs to share." }),
+        targetProjectIds: Type.Array(Type.String(), { description: "Array of target project IDs." }),
+      }),
+      async execute(_toolCallId: string, params: Record<string, unknown>) {
+        const { memoryIds, targetProjectIds } = params;
+        const res = await client.invoke(projectId, "share" as MuninAction, enrichPayload({ memoryIds, targetProjectIds }));
+        return handleResult(res);
       },
     });
   },