@badgerclaw/connect 1.1.3 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@badgerclaw/connect",
-  "version": "1.1.3",
+  "version": "1.3.0",
   "description": "BadgerClaw channel plugin for OpenClaw",
   "type": "module",
   "dependencies": {
@@ -31,4 +31,4 @@
       "defaultChoice": "npm"
     }
   }
-}
+}

package/room-config.json

@@ -0,0 +1,5 @@
+{
+  "!oVrHNyMFgnOCfmjlLU:badger.signout.io": {
+    "autoReply": true
+  }
+}

package/src/group-mentions.ts

@@ -29,6 +29,39 @@ function resolveMatrixRoomConfigForGroup(params: ChannelGroupContext) {
 }
 
 export function resolveMatrixGroupRequireMention(params: ChannelGroupContext): boolean {
+  // Check per-room config first (set by /bot talk on|off)
+  try {
+    const fs = require("fs");
+    const path = require("path");
+    const configPath = path.join(
+      process.env.HOME || "/tmp",
+      ".openclaw/extensions/badgerclaw/room-config.json"
+    );
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const roomConfig = JSON.parse(raw) as Record<string, { autoReply?: boolean }>;
+    const rawGroupId = params.groupId?.trim() ?? "";
+    // Try multiple formats: raw, stripped prefixes, just the room ID part
+    const variants = [
+      rawGroupId,
+      rawGroupId.replace(/^badgerclaw:/, ""),
+      rawGroupId.replace(/^channel:/, ""),
+      rawGroupId.replace(/^room:/, ""),
+    ];
+    for (const variant of variants) {
+      if (variant && roomConfig[variant]?.autoReply === true) {
+        console.log(`[badgerclaw] room-config autoReply=true for ${variant}`);
+        return false;
+      }
+      if (variant && roomConfig[variant]?.autoReply === false) {
+        console.log(`[badgerclaw] room-config autoReply=false for ${variant}`);
+        return true;
+      }
+    }
+    console.log(`[badgerclaw] room-config: no match for groupId="${rawGroupId}", keys=${Object.keys(roomConfig).join(",")}`);
+  } catch (err) {
+    console.log(`[badgerclaw] room-config error: ${err}`);
+  }
+
   const resolved = resolveMatrixRoomConfigForGroup(params);
   if (resolved) {
     if (resolved.autoReply === true) {

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

@@ -39,6 +39,24 @@ export function registerMatrixAutoJoin(params: {
     const { AutojoinRoomsMixin } = loadMatrixSdk();
     AutojoinRoomsMixin.setupOnClient(client);
     logVerbose("badgerclaw: auto-join enabled for all invites");
+
+    // Also join any rooms with pending invites from before startup
+    (async () => {
+      try {
+        const syncData = await client.doRequest("GET", "/_matrix/client/v3/sync", { timeout: "0" });
+        const invitedRooms = Object.keys(syncData?.rooms?.invite ?? {});
+        for (const roomId of invitedRooms) {
+          try {
+            await client.joinRoom(roomId);
+            logVerbose(`badgerclaw: joined pending invite room ${roomId}`);
+          } catch (err) {
+            logVerbose(`badgerclaw: failed to join pending invite ${roomId}: ${err}`);
+          }
+        }
+      } catch {
+        // Ignore sync errors
+      }
+    })();
     return;
   }
 

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

@@ -0,0 +1,197 @@
+import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
+import * as fs from "fs";
+import * as path from "path";
+
+const ROOM_CONFIG_PATH = path.join(
+  process.env.HOME || "/tmp",
+  ".openclaw/extensions/badgerclaw/room-config.json"
+);
+
+// Session store path for core groupActivation
+const SESSION_STORE_PATH = path.join(
+  process.env.HOME || "/tmp",
+  ".openclaw/agents/main/sessions/sessions.json"
+);
+
+function loadRoomConfig(): Record<string, { autoReply?: boolean }> {
+  try {
+    return JSON.parse(fs.readFileSync(ROOM_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveRoomConfig(config: Record<string, { autoReply?: boolean }>): void {
+  fs.writeFileSync(ROOM_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function setGroupActivation(roomId: string, activation: "always" | "mention"): void {
+  try {
+    const store = JSON.parse(fs.readFileSync(SESSION_STORE_PATH, "utf-8"));
+    // Session key format: agent:main:badgerclaw:channel:!roomid (lowercase)
+    const sessionKey = `agent:main:badgerclaw:channel:${roomId.toLowerCase()}`;
+    if (!store[sessionKey]) {
+      store[sessionKey] = {};
+    }
+    store[sessionKey].groupActivation = activation;
+    fs.writeFileSync(SESSION_STORE_PATH, JSON.stringify(store, null, 2));
+    console.log(`[badgerclaw] set groupActivation=${activation} for ${sessionKey}`);
+  } catch (err) {
+    console.error(`[badgerclaw] failed to set groupActivation: ${err}`);
+  }
+}
+
+export function getRoomAutoReply(roomId: string): boolean | undefined {
+  const config = loadRoomConfig();
+  return config[roomId]?.autoReply;
+}
+
+export async function handleBotCommand(params: {
+  client: MatrixClient;
+  roomId: string;
+  senderId: string;
+  body: string;
+  selfUserId: string;
+}): Promise<boolean> {
+  const { client, roomId, senderId, body, selfUserId } = params;
+  const trimmed = body.trim();
+
+  if (!trimmed.startsWith("/bot")) {
+    return false;
+  }
+
+  const parts = trimmed.split(/\s+/);
+  const command = parts[1]?.toLowerCase();
+  const arg = parts[2]?.toLowerCase();
+  const arg2 = parts[3];
+
+  try {
+    switch (command) {
+      case "help": {
+        await client.sendMessage(roomId, {
+          msgtype: "m.text",
+          body: [
+            "🦡 BadgerClaw Bot Commands",
+            "",
+            "━━━ Available Everywhere ━━━",
+            "",
+            "/bot help",
+            "  Show this help message with all available commands.",
+            "  Works in: Any room or DM",
+            "",
+            "/bot talk on",
+            "  Enable auto-reply mode. The bot will respond to every",
+            "  message in this room without needing an @mention.",
+            "  Perfect for 1-on-1 rooms with your AI assistant.",
+            "  Works in: Any room or DM",
+            "",
+            "/bot talk off",
+            "  Disable auto-reply mode. The bot will only respond",
+            "  when @mentioned. Use this in busy group rooms where",
+            "  you don't want the bot responding to everything.",
+            "  Works in: Any room or DM",
+            "",
+            "/bot add <botname>",
+            "  Invite a bot to the current room. The bot username",
+            "  will be @<botname>_bot on this server.",
+            "  Example: /bot add jarvis → invites @jarvis_bot",
+            "  Works in: Any room",
+            "",
+            "━━━ BotBadger DM Only ━━━",
+            "",
+            "/bot new",
+            "  Create a new bot. Starts a guided flow to set up",
+            "  a bot name, username, and generate a pairing code",
+            "  for connecting to an OpenClaw instance.",
+            "  Works in: Direct message with BotBadger only",
+            "",
+            "/bot pair <name>",
+            "  Generate a new pairing code for an existing bot.",
+            "  Use this to connect or reconnect a bot to OpenClaw.",
+            "  Works in: Direct message with BotBadger only",
+            "",
+            "/bot delete <name>",
+            "  Permanently delete a bot and remove it from all rooms.",
+            "  This action cannot be undone.",
+            "  Works in: Direct message with BotBadger only",
+            "",
+            "/bot list",
+            "  List all your bots and their connection status.",
+            "  🟢 Connected — bot is online and responding",
+            "  🔴 Not connected — bot needs pairing",
+            "  Works in: Any room or DM",
+          ].join("\n"),
+        });
+        return true;
+      }
+
+      case "talk": {
+        if (arg === "on") {
+          const config = loadRoomConfig();
+          config[roomId] = { ...config[roomId], autoReply: true };
+          saveRoomConfig(config);
+          setGroupActivation(roomId, "always");
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "✅ Auto-reply enabled — I'll respond to every message in this room.",
+          });
+          return true;
+        }
+        if (arg === "off") {
+          const config = loadRoomConfig();
+          config[roomId] = { ...config[roomId], autoReply: false };
+          saveRoomConfig(config);
+          setGroupActivation(roomId, "mention");
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "✅ Auto-reply disabled — I'll only respond when @mentioned.",
+          });
+          return true;
+        }
+        await client.sendMessage(roomId, {
+          msgtype: "m.text",
+          body: "Usage: /bot talk on  or  /bot talk off",
+        });
+        return true;
+      }
+
+      case "add": {
+        const botName = arg;
+        if (!botName) {
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "Usage: /bot add <botname>",
+          });
+          return true;
+        }
+        const botUserId = `@${botName}_bot:badger.signout.io`;
+        try {
+          await client.inviteUser(botUserId, roomId);
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: `✅ Invited ${botUserId} to this room.`,
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: `❌ Failed to invite ${botUserId}: ${msg}`,
+          });
+        }
+        return true;
+      }
+
+      default: {
+        // Unknown /bot command — show help hint
+        await client.sendMessage(roomId, {
+          msgtype: "m.text",
+          body: "Unknown command. Type /bot help for available commands.",
+        });
+        return true;
+      }
+    }
+  } catch (err) {
+    console.error("badgerclaw: bot command error:", err);
+    return true; // Still consumed the command
+  }
+}

package/src/matrix/monitor/handler.ts

@@ -410,6 +410,19 @@ export function createMatrixRoomMessageHandler(params: MatrixMonitorHandlerParam
         return;
       }
 
+      // Handle /bot commands before anything else
+      if (bodyText.trim().startsWith("/bot")) {
+        const { handleBotCommand } = await import("./bot-commands.js");
+        const handled = await handleBotCommand({
+          client,
+          roomId,
+          senderId,
+          body: bodyText,
+          selfUserId,
+        });
+        if (handled) return;
+      }
+
       const { wasMentioned, hasExplicitMention } = resolveMentions({
         content,
         userId: selfUserId,