@badgerclaw/connect 1.3.2 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@badgerclaw/connect",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "BadgerClaw channel plugin for OpenClaw",
   "type": "module",
   "dependencies": {
@@ -30,5 +30,8 @@
       "localPath": "extensions/badgerclaw",
       "defaultChoice": "npm"
     }
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
   }
-}
+}

package/scripts/postinstall.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * postinstall.js — patches openclaw package.json exports map to expose
+ * plugin-sdk/compat subpath, which was removed in openclaw >=2026.3.24.
+ * This runs automatically after `npm install` in the plugin directory.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const OPENCLAW_PKG = path.join(
+  path.dirname(require.resolve('openclaw/package.json')),
+  'package.json'
+);
+
+const COMPAT_EXPORT = './plugin-sdk/compat';
+const COMPAT_ENTRY = {
+  types: './dist/plugin-sdk/compat.d.ts',
+  default: './dist/plugin-sdk/compat.js',
+};
+
+try {
+  const pkg = JSON.parse(fs.readFileSync(OPENCLAW_PKG, 'utf-8'));
+  if (!pkg.exports) pkg.exports = {};
+  if (!pkg.exports[COMPAT_EXPORT]) {
+    pkg.exports[COMPAT_EXPORT] = COMPAT_ENTRY;
+    fs.writeFileSync(OPENCLAW_PKG, JSON.stringify(pkg, null, 2));
+    console.log('[badgerclaw] patched openclaw exports map: added plugin-sdk/compat');
+  } else {
+    console.log('[badgerclaw] openclaw exports map already has plugin-sdk/compat');
+  }
+} catch (e) {
+  // Non-fatal — openclaw may not be installed yet
+  console.log('[badgerclaw] postinstall: could not patch openclaw exports map:', e.message);
+}

package/src/matrix/monitor/auto-join.ts

@@ -3,6 +3,7 @@ import type { RuntimeEnv } from "openclaw/plugin-sdk/matrix";
 import { getMatrixRuntime } from "../../runtime.js";
 import type { CoreConfig } from "../../types.js";
 import { loadMatrixSdk } from "../sdk-runtime.js";
+import { initRoomHistory } from "./chat-history.js";
 
 // Track clients that already have auto-join registered to prevent duplicate listeners
 const autoJoinRegistered = new WeakSet<object>();
@@ -73,6 +74,9 @@ export function registerMatrixAutoJoin(params: {
     // AutojoinRoomsMixin handles the join, so listen for room.join to run post-join logic
     client.on("room.join", async (roomId: string, _joinEvent: unknown) => {
       logVerbose(`badgerclaw: bot joined room ${roomId} (always mode), running post-join handshake`);
+      if (cfg.chatHistory?.enabled) {
+        initRoomHistory(roomId);
+      }
       await postJoinEncryptionHandshake(roomId);
     });
     return;
@@ -111,6 +115,9 @@ export function registerMatrixAutoJoin(params: {
     try {
       await client.joinRoom(roomId);
       logVerbose(`badgerclaw: joined room ${roomId}`);
+      if (cfg.chatHistory?.enabled) {
+        initRoomHistory(roomId);
+      }
       await postJoinEncryptionHandshake(roomId);
     } catch (err) {
       runtime.error?.(`badgerclaw: failed to join room ${roomId}: ${String(err)}`);

package/src/matrix/monitor/bot-commands.ts

@@ -342,6 +342,80 @@ export async function handleBotCommand(params: {
         return true;
       }
 
+      case "delete": {
+        const nameArg = parts.slice(2).join(" ").trim().replace(/^@/, "").split(":")[0].replace(/_bot$/i, "").toLowerCase();
+        if (!nameArg) {
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "Usage: /bot delete <name>\nExample: /bot delete jarvis\n\n⚠️ This permanently deletes the bot from the database and Matrix.",
+          });
+          return true;
+        }
+
+        const botUserId = `@${nameArg}_bot:badger.signout.io`;
+
+        // Load JWT token from ~/.badgerclaw/auth.json
+        let apiToken: string | null = null;
+        try {
+          const authPath = require("path").join(process.env.HOME || "/tmp", ".badgerclaw", "auth.json");
+          const authData = JSON.parse(require("fs").readFileSync(authPath, "utf-8"));
+          apiToken = authData.access_token || null;
+        } catch {
+          // no token
+        }
+
+        if (!apiToken) {
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "❌ Not authenticated. Run `badgerclaw login` first.",
+          });
+          return true;
+        }
+
+        // Find the bot by user_id via API
+        try {
+          const listResp = await fetch("https://api.badgerclaw.ai/api/v1/bots", {
+            headers: { Authorization: `Bearer ${apiToken}`, "Content-Type": "application/json" },
+          });
+          if (!listResp.ok) throw new Error(`Failed to list bots: ${listResp.status}`);
+          const bots: Array<{ id: string; bot_user_id: string; bot_name: string }> = await listResp.json();
+          const bot = bots.find((b) => b.bot_user_id.toLowerCase() === botUserId.toLowerCase());
+
+          if (!bot) {
+            await client.sendMessage(roomId, {
+              msgtype: "m.text",
+              body: `❌ Bot @${nameArg}_bot not found. Check the name and try again.`,
+            });
+            return true;
+          }
+
+          // Delete permanently
+          const delResp = await fetch(`https://api.badgerclaw.ai/api/v1/bots/${bot.id}`, {
+            method: "DELETE",
+            headers: { Authorization: `Bearer ${apiToken}`, "Content-Type": "application/json" },
+          });
+
+          if (delResp.ok) {
+            await client.sendMessage(roomId, {
+              msgtype: "m.text",
+              body: `🗑️ Bot **${bot.bot_name}** (@${nameArg}_bot) permanently deleted.`,
+            });
+          } else {
+            const err = await delResp.json().catch(() => ({ detail: delResp.statusText }));
+            await client.sendMessage(roomId, {
+              msgtype: "m.text",
+              body: `❌ Failed to delete bot: ${err.detail || delResp.status}`,
+            });
+          }
+        } catch (e) {
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: `❌ Error deleting bot: ${e}`,
+          });
+        }
+        return true;
+      }
+
       default: {
         await client.sendMessage(roomId, {
           msgtype: "m.text",

package/src/matrix/monitor/chat-history.ts

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const HISTORY_DIR = path.join(os.homedir(), ".openclaw", "extensions", "badgerclaw", "history");
+const MAX_MESSAGES = 200;
+
+export interface HistoryEntry {
+  ts: string;       // ISO timestamp
+  sender: string;   // display name or username
+  text: string;     // message text
+  role: "user" | "bot";
+}
+
+export function getHistoryPath(roomId: string): string {
+  // Sanitize roomId for filename: replace ! and : with safe chars
+  const safe = roomId.replace(/[!:]/g, "_").replace(/\./g, "-");
+  return path.join(HISTORY_DIR, `${safe}.md`);
+}
+
+export function ensureHistoryDir(): void {
+  if (!fs.existsSync(HISTORY_DIR)) {
+    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+  }
+}
+
+export function readHistory(roomId: string): HistoryEntry[] {
+  const filePath = getHistoryPath(roomId);
+  if (!fs.existsSync(filePath)) return [];
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    const lines = content.split("\n").filter((l: string) => l.startsWith("["));
+    return lines.map((line: string) => {
+      // Format: [2026-03-27T08:05:00Z] [user] sender: text
+      const match = line.match(/^\[([^\]]+)\] \[(user|bot)\] ([^:]+): (.+)$/);
+      if (!match) return null;
+      return { ts: match[1], role: match[2] as "user" | "bot", sender: match[3], text: match[4] };
+    }).filter(Boolean) as HistoryEntry[];
+  } catch {
+    return [];
+  }
+}
+
+export function appendHistory(roomId: string, entry: HistoryEntry, roomName?: string): void {
+  ensureHistoryDir();
+  const filePath = getHistoryPath(roomId);
+
+  // Read existing, append, trim to 200
+  let entries = readHistory(roomId);
+  entries.push(entry);
+  if (entries.length > MAX_MESSAGES) {
+    entries = entries.slice(entries.length - MAX_MESSAGES);
+  }
+
+  // Write header + entries
+  const header = `# Chat History — ${roomId}\n# Group: ${roomName || roomId} | Updated: ${new Date().toISOString()}\n# Last ${MAX_MESSAGES} messages (rolling)\n\n`;
+  const body = entries.map(e => `[${e.ts}] [${e.role}] ${e.sender}: ${e.text}`).join("\n");
+  fs.writeFileSync(filePath, header + body + "\n", "utf8");
+}
+
+export function formatHistoryForContext(roomId: string): string | null {
+  const entries = readHistory(roomId);
+  if (entries.length === 0) return null;
+  const lines = entries.map(e => `${e.sender}: ${e.text}`).join("\n");
+  return `## Recent conversation history (last ${entries.length} messages):\n${lines}\n\n---\n`;
+}
+
+export function initRoomHistory(roomId: string, roomName?: string): void {
+  ensureHistoryDir();
+  const filePath = getHistoryPath(roomId);
+  if (!fs.existsSync(filePath)) {
+    const header = `# Chat History — ${roomId}\n# Group: ${roomName || roomId} | Created: ${new Date().toISOString()}\n# Last ${MAX_MESSAGES} messages (rolling)\n\n`;
+    fs.writeFileSync(filePath, header, "utf8");
+  }
+}

package/src/matrix/monitor/events.ts

@@ -164,5 +164,87 @@ export function registerMatrixMonitorEvents(params: {
         `badgerclaw: member event room=${roomId} stateKey=${stateKey} membership=${membership ?? "unknown"}`,
       );
     }
+
+    // Auto-pair: iOS app sends this event after generating a pair code
+    // The plugin redeems the code and adds the bot account to OpenClaw config
+    if (eventType === "com.badgerclaw.autopair") {
+      const content = event?.content as {
+        pair_code?: string;
+        bot_name?: string;
+        bot_user_id?: string;
+        owner_matrix_id?: string;
+      } | undefined;
+
+      const pairCode = content?.pair_code;
+      const botName = content?.bot_name;
+      const botUserId = content?.bot_user_id;
+
+      if (!pairCode || !botUserId) {
+        logVerboseMessage(`badgerclaw: autopair event missing fields room=${roomId}`);
+        return;
+      }
+
+      logger.info(`badgerclaw: autopair event received — redeeming code for ${botUserId}`, { roomId });
+
+      void (async () => {
+        try {
+          const resp = await fetch("https://api.badgerclaw.ai/api/v1/pairing/redeem", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code: pairCode }),
+          });
+
+          if (!resp.ok) {
+            const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+            logger.warn(`badgerclaw: autopair redeem failed for ${botUserId}: ${err.detail || resp.status}`);
+            return;
+          }
+
+          const data = await resp.json() as {
+            homeserver: string;
+            access_token: string;
+            user_id: string;
+            bot_name: string;
+            device_id: string;
+          };
+
+          // Write new bot account to OpenClaw config
+          const fs = await import("fs");
+          const configPath = require("path").join(process.env.HOME || "/tmp", ".openclaw", "openclaw.json");
+          const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+
+          if (!config.channels) config.channels = {};
+          if (!config.channels.badgerclaw) config.channels.badgerclaw = {};
+          if (!config.channels.badgerclaw.accounts) config.channels.badgerclaw.accounts = {};
+
+          // Derive account key from bot localpart (e.g. @think_bot:... → "think")
+          const localpart = data.user_id.split(":")[0].replace("@", "").replace(/_bot$/, "");
+
+          config.channels.badgerclaw.accounts[localpart] = {
+            userId: data.user_id,
+            accessToken: data.access_token,
+            homeserver: data.homeserver,
+            encryption: true,
+            deviceId: data.device_id,
+          };
+
+          fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+          logger.info(`badgerclaw: ✅ autopair complete — added account "${localpart}" (${data.user_id}) to OpenClaw config. Restart gateway to activate.`);
+
+          // Notify in the room
+          try {
+            await client.sendMessage(roomId, {
+              msgtype: "m.text",
+              body: `✅ Bot **${data.bot_name}** (${data.user_id}) has been automatically paired and added to your OpenClaw instance.\n\nRestart your OpenClaw gateway to activate: \`openclaw gateway restart\``,
+            });
+          } catch {
+            // non-fatal
+          }
+        } catch (e) {
+          logger.error(`badgerclaw: autopair failed for ${botUserId}: ${String(e)}`);
+        }
+      })();
+    }
   });
 }

package/src/matrix/monitor/handler.ts

@@ -30,6 +30,7 @@ import {
   resolveMatrixAllowListMatch,
   resolveMatrixAllowListMatches,
 } from "./allowlist.js";
+import { appendHistory, formatHistoryForContext } from "./chat-history.js";
 import {
   resolveMatrixBodyForAgent,
   resolveMatrixInboundSenderLabel,
@@ -630,13 +631,33 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
       });
 
       const groupSystemPrompt = roomConfig?.systemPrompt?.trim() || undefined;
+
+      // Append inbound user message to chat history
+      if (cfg.chatHistory?.enabled) {
+        appendHistory(roomId, {
+          ts: new Date().toISOString(),
+          role: "user",
+          sender: senderName || senderId,
+          text: bodyText,
+        }, roomName);
+      }
+
+      // Inject rolling history into BodyForAgent context
+      let bodyForAgent = resolveMatrixBodyForAgent({
+        isDirectMessage,
+        bodyText,
+        senderLabel,
+      });
+      if (cfg.chatHistory?.enabled) {
+        const history = formatHistoryForContext(roomId);
+        if (history) {
+          bodyForAgent = history + bodyForAgent;
+        }
+      }
+
       const ctxPayload = core.channel.reply.finalizeInboundContext({
         Body: body,
-        BodyForAgent: resolveMatrixBodyForAgent({
-          isDirectMessage,
-          bodyText,
-          senderLabel,
-        }),
+        BodyForAgent: bodyForAgent,
         RawBody: bodyText,
         CommandBody: bodyText,
         From: isDirectMessage ? `badgerclaw:${senderId}` : `badgerclaw:channel:${roomId}`,
@@ -775,6 +796,15 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
               accountId: route.accountId,
               tableMode,
             });
+            if (cfg.chatHistory?.enabled && payload?.text) {
+              const botSender = resolveMatrixSenderUsername(selfUserId) || selfUserId;
+              appendHistory(roomId, {
+                ts: new Date().toISOString(),
+                role: "bot",
+                sender: botSender,
+                text: payload.text,
+              }, roomName);
+            }
             didSendReply = true;
           },
           onError: (err, info) => {

package/src/types.ts

@@ -114,5 +114,8 @@ export type CoreConfig = {
     ackReaction?: string;
     ackReactionScope?: "group-mentions" | "group-all" | "direct" | "all" | "off" | "none";
   };
+  chatHistory?: {
+    enabled: boolean;
+  };
   [key: string]: unknown;
 };