badgerclaw 0.1.7 → 1.4.0

package/src/matrix/monitor/allowlist.ts

@@ -0,0 +1,94 @@
+import {
+  compileAllowlist,
+  normalizeStringEntries,
+  resolveCompiledAllowlistMatch,
+  type AllowlistMatch,
+} from "openclaw/plugin-sdk/matrix";
+
+function normalizeAllowList(list?: Array<string | number>) {
+  return normalizeStringEntries(list);
+}
+
+function normalizeMatrixUser(raw?: string | null): string {
+  const value = (raw ?? "").trim();
+  if (!value) {
+    return "";
+  }
+  if (!value.startsWith("@") || !value.includes(":")) {
+    return value.toLowerCase();
+  }
+  const withoutAt = value.slice(1);
+  const splitIndex = withoutAt.indexOf(":");
+  if (splitIndex === -1) {
+    return value.toLowerCase();
+  }
+  const localpart = withoutAt.slice(0, splitIndex).toLowerCase();
+  const server = withoutAt.slice(splitIndex + 1).toLowerCase();
+  if (!server) {
+    return value.toLowerCase();
+  }
+  return `@${localpart}:${server.toLowerCase()}`;
+}
+
+export function normalizeMatrixUserId(raw?: string | null): string {
+  const trimmed = (raw ?? "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  const lowered = trimmed.toLowerCase();
+  if (lowered.startsWith("badgerclaw:")) {
+    return normalizeMatrixUser(trimmed.slice("badgerclaw:".length));
+  }
+  if (lowered.startsWith("user:")) {
+    return normalizeMatrixUser(trimmed.slice("user:".length));
+  }
+  return normalizeMatrixUser(trimmed);
+}
+
+function normalizeMatrixAllowListEntry(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed === "*") {
+    return trimmed;
+  }
+  const lowered = trimmed.toLowerCase();
+  if (lowered.startsWith("badgerclaw:")) {
+    return `badgerclaw:${normalizeMatrixUser(trimmed.slice("badgerclaw:".length))}`;
+  }
+  if (lowered.startsWith("user:")) {
+    return `user:${normalizeMatrixUser(trimmed.slice("user:".length))}`;
+  }
+  return normalizeMatrixUser(trimmed);
+}
+
+export function normalizeMatrixAllowList(list?: Array<string | number>) {
+  return normalizeAllowList(list).map((entry) => normalizeMatrixAllowListEntry(entry));
+}
+
+export type MatrixAllowListMatch = AllowlistMatch<
+  "wildcard" | "id" | "prefixed-id" | "prefixed-user"
+>;
+type MatrixAllowListSource = Exclude<MatrixAllowListMatch["matchSource"], undefined>;
+
+export function resolveMatrixAllowListMatch(params: {
+  allowList: string[];
+  userId?: string;
+}): MatrixAllowListMatch {
+  const compiledAllowList = compileAllowlist(params.allowList);
+  const userId = normalizeMatrixUser(params.userId);
+  const candidates: Array<{ value?: string; source: MatrixAllowListSource }> = [
+    { value: userId, source: "id" },
+    { value: userId ? `badgerclaw:${userId}` : "", source: "prefixed-id" },
+    { value: userId ? `user:${userId}` : "", source: "prefixed-user" },
+  ];
+  return resolveCompiledAllowlistMatch({
+    compiledAllowlist: compiledAllowList,
+    candidates,
+  });
+}
+
+export function resolveMatrixAllowListMatches(params: { allowList: string[]; userId?: string }) {
+  return resolveMatrixAllowListMatch(params).allowed;
+}

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

@@ -0,0 +1,126 @@
+import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
+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>();
+
+export function registerMatrixAutoJoin(params: {
+  client: MatrixClient;
+  cfg: CoreConfig;
+  runtime: RuntimeEnv;
+}) {
+  const { client, cfg, runtime } = params;
+  const core = getMatrixRuntime();
+  const logVerbose = (message: string) => {
+    if (!core.logging.shouldLogVerbose()) {
+      return;
+    }
+    runtime.log?.(message);
+  };
+  const autoJoin = cfg.channels?.badgerclaw?.autoJoin ?? "always";
+  const autoJoinAllowlist = cfg.channels?.badgerclaw?.autoJoinAllowlist ?? [];
+
+  if (autoJoin === "off") {
+    return;
+  }
+
+  // Prevent duplicate listener registration on the same client instance
+  if (autoJoinRegistered.has(client)) {
+    logVerbose("badgerclaw: auto-join already registered for this client, skipping");
+    return;
+  }
+  autoJoinRegistered.add(client);
+
+  // After joining a room, send a notice in encrypted rooms to force Megolm session rotation.
+  // When the bot joins, other clients may use a cached outbound Megolm session that doesn't
+  // include the bot. Sending a message causes compliant clients to detect the new member and
+  // rotate their session so subsequent messages are decryptable by the bot.
+  async function postJoinEncryptionHandshake(roomId: string) {
+    try {
+      const encryptionState = await client
+        .getRoomStateEvent(roomId, "m.room.encryption", "")
+        .catch(() => null);
+
+      if (!encryptionState) {
+        logVerbose(`badgerclaw: room ${roomId} is not encrypted, skipping handshake`);
+        return;
+      }
+
+      logVerbose(`badgerclaw: room ${roomId} is encrypted, sending notice to trigger key rotation`);
+      await client.sendNotice(
+        roomId,
+        "🔐 Connected — encryption active.\n\n" +
+          "I'll respond when @mentioned. To toggle auto-reply:\n" +
+          "• /bot talk on — I'll respond to every message\n" +
+          "• /bot talk off — I'll only respond when @mentioned\n" +
+          "• /bot help — see all commands",
+      );
+      logVerbose(`badgerclaw: sent encryption handshake + hint notice in room ${roomId}`);
+    } catch (err) {
+      runtime.log?.(`badgerclaw: encryption handshake failed for room ${roomId}: ${String(err)}`);
+    }
+  }
+
+  if (autoJoin === "always") {
+    // Use the built-in autojoin mixin for "always" mode
+    const { AutojoinRoomsMixin } = loadMatrixSdk();
+    AutojoinRoomsMixin.setupOnClient(client);
+    logVerbose("badgerclaw: auto-join enabled for all invites");
+
+    // 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;
+  }
+
+  // For "allowlist" mode, handle invites manually
+  client.on("room.invite", async (roomId: string, _inviteEvent: unknown) => {
+    if (autoJoin !== "allowlist") {
+      return;
+    }
+
+    // Get room alias if available
+    let alias: string | undefined;
+    let altAliases: string[] = [];
+    try {
+      const aliasState = await client
+        .getRoomStateEvent(roomId, "m.room.canonical_alias", "")
+        .catch(() => null);
+      alias = aliasState?.alias;
+      altAliases = Array.isArray(aliasState?.alt_aliases) ? aliasState.alt_aliases : [];
+    } catch {
+      // Ignore errors
+    }
+
+    const allowed =
+      autoJoinAllowlist.includes("*") ||
+      autoJoinAllowlist.includes(roomId) ||
+      (alias ? autoJoinAllowlist.includes(alias) : false) ||
+      altAliases.some((value) => autoJoinAllowlist.includes(value));
+
+    if (!allowed) {
+      logVerbose(`badgerclaw: invite ignored (not in allowlist) room=${roomId}`);
+      return;
+    }
+
+    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

@@ -0,0 +1,431 @@
+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"
+);
+
+type RoomConfig = {
+  autoReply?: boolean; // legacy — kept for migration
+  activeBots?: string[]; // per-bot auto-reply list
+};
+
+function loadRoomConfig(): Record<string, RoomConfig> {
+  try {
+    return JSON.parse(fs.readFileSync(ROOM_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveRoomConfig(config: Record<string, RoomConfig>): 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"));
+    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}`);
+  }
+}
+
+/**
+ * Check if a specific bot has auto-reply enabled in a room.
+ * Returns true if the bot is in the activeBots list.
+ * Migrates legacy autoReply boolean to activeBots format.
+ */
+export function isBotAutoReplyEnabled(roomId: string, botUserId: string): boolean | undefined {
+  const config = loadRoomConfig();
+  const normalizedRoomId = roomId.toLowerCase();
+  const keys = Object.keys(config);
+  const matchedKey = keys.find((k) => k.toLowerCase() === normalizedRoomId);
+  if (!matchedKey) return undefined;
+
+  const room = config[matchedKey];
+
+  // New format: check activeBots list
+  if (Array.isArray(room.activeBots)) {
+    return room.activeBots.some(
+      (b) => b.toLowerCase() === botUserId.toLowerCase()
+    );
+  }
+
+  // Legacy migration: if autoReply is set but no activeBots, treat as legacy
+  if (typeof room.autoReply === "boolean") {
+    return room.autoReply;
+  }
+
+  return undefined;
+}
+
+// Legacy compat export
+export function getRoomAutoReply(roomId: string): boolean | undefined {
+  const config = loadRoomConfig();
+  const normalizedRoomId = roomId.toLowerCase();
+  const keys = Object.keys(config);
+  const matchedKey = keys.find((k) => k.toLowerCase() === normalizedRoomId);
+  if (!matchedKey) return undefined;
+
+  const room = config[matchedKey];
+  if (Array.isArray(room.activeBots) && room.activeBots.length > 0) {
+    return true; // At least one bot is active
+  }
+  return room.autoReply;
+}
+
+function addBotToActive(roomId: string, botUserId: string): void {
+  const config = loadRoomConfig();
+  const normalizedRoomId = roomId.toLowerCase();
+  if (!config[normalizedRoomId]) {
+    config[normalizedRoomId] = {};
+  }
+  const room = config[normalizedRoomId];
+  if (!Array.isArray(room.activeBots)) {
+    room.activeBots = [];
+  }
+  const botLower = botUserId.toLowerCase();
+  if (!room.activeBots.some((b) => b.toLowerCase() === botLower)) {
+    room.activeBots.push(botUserId);
+  }
+  // Clear legacy field
+  delete room.autoReply;
+  saveRoomConfig(config);
+}
+
+function removeAllActiveBots(roomId: string): void {
+  const config = loadRoomConfig();
+  const normalizedRoomId = roomId.toLowerCase();
+  if (!config[normalizedRoomId]) {
+    config[normalizedRoomId] = {};
+  }
+  config[normalizedRoomId].activeBots = [];
+  delete config[normalizedRoomId].autoReply;
+  saveRoomConfig(config);
+}
+
+function getDisplayName(userId: string): string {
+  return userId.split(":")[0];
+}
+
+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();
+
+  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.",
+            "",
+            "/bot talk on",
+            "  Enable auto-reply for this bot. It will respond to",
+            "  every message without needing an @mention.",
+            "  If multiple bots are in the room, specify which one:",
+            "  /bot talk on @botname",
+            "",
+            "/bot talk off",
+            "  Disable auto-reply for ALL bots in this room.",
+            "  All bots go back to mention-only mode.",
+            "",
+            "/bot add <botname>",
+            "  Invite a bot to the current room.",
+            "  Example: /bot add jarvis → invites @jarvis_bot",
+            "  Also accepts: /bot add @jarvis_bot",
+            "",
+            "/bot list",
+            "  List all bots in this room and their auto-reply status.",
+            "",
+            "━━━ BotBadger DM Only ━━━",
+            "",
+            "/bot new — Create a new bot",
+            "/bot pair <name> — Get a pairing code",
+            "/bot delete <name> — Permanently delete a bot",
+          ].join("\n"),
+        });
+        return true;
+      }
+
+      case "talk": {
+        // Resolve bot members in the room
+        const botSuffix = "_bot:badger.signout.io";
+        let roomBots: string[] = [];
+        try {
+          const members = await client.getJoinedRoomMembers(roomId);
+          roomBots = members.filter((m: string) => m.includes(botSuffix) && m !== selfUserId);
+        } catch {
+          // If we can't list members, proceed as single-bot
+        }
+        const multipleBots = roomBots.length > 0;
+
+        // Check if a specific bot was mentioned: /bot talk on @botname
+        const mentionArg = parts.slice(3).join(" ").trim();
+        const mentionedBot = mentionArg
+          ? mentionArg.startsWith("@") ? mentionArg : `@${mentionArg}`
+          : null;
+
+        // If a bot was mentioned and it's not us, ignore the command (let that bot handle it)
+        if (mentionedBot) {
+          const mentionLower = mentionedBot.toLowerCase();
+          const selfLower = selfUserId.toLowerCase();
+          const selfLocalpart = selfLower.split(":")[0];
+          if (!selfLower.startsWith(mentionLower) && !mentionLower.startsWith(selfLocalpart)) {
+            return false;
+          }
+        }
+
+        if (arg === "on") {
+          // Multiple bots + no specific mention → ask which bot
+          if (multipleBots && !mentionedBot) {
+            const allBots = [selfUserId, ...roomBots];
+            const config = loadRoomConfig();
+            const normalizedRoomId = roomId.toLowerCase();
+            const active = config[normalizedRoomId]?.activeBots ?? [];
+
+            const botList = allBots
+              .map((b, i) => {
+                const name = getDisplayName(b);
+                const isActive = active.some((a) => a.toLowerCase() === b.toLowerCase());
+                return `  ${i + 1}. ${name} ${isActive ? "🟢 auto-reply on" : "⚪ mention-only"}`;
+              })
+              .join("\n");
+
+            await client.sendMessage(roomId, {
+              msgtype: "m.text",
+              body: [
+                "🦡 Multiple bots in this room:",
+                "",
+                botList,
+                "",
+                "Specify which bot: /bot talk on @botname",
+              ].join("\n"),
+            });
+            return true;
+          }
+
+          // Add THIS bot to activeBots
+          addBotToActive(roomId, selfUserId);
+          setGroupActivation(roomId, "always");
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: `✅ Auto-reply enabled for ${getDisplayName(selfUserId)} — I'll respond to every message in this room.`,
+          });
+          return true;
+        }
+
+        if (arg === "off") {
+          // Kill switch — remove ALL bots from activeBots
+          removeAllActiveBots(roomId);
+          setGroupActivation(roomId, "mention");
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "✅ Auto-reply disabled for all bots — bots will only respond when @mentioned.",
+          });
+          return true;
+        }
+
+        await client.sendMessage(roomId, {
+          msgtype: "m.text",
+          body: "Usage: /bot talk on [@botname]  or  /bot talk off",
+        });
+        return true;
+      }
+
+      case "add": {
+        let rawName = parts.slice(2).join(" ").trim();
+        if (!rawName) {
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "Usage: /bot add <botname>\nExample: /bot add jarvis  or  /bot add @jarvis_bot",
+          });
+          return true;
+        }
+        rawName = rawName.replace(/^@/, "").split(":")[0].replace(/_bot$/i, "").toLowerCase();
+        const addBotUserId = `@${rawName}_bot:badger.signout.io`;
+        const addBotDisplay = `@${rawName}_bot`;
+        try {
+          await client.inviteUser(addBotUserId, roomId);
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: `✅ Invited ${addBotDisplay} to this room.`,
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const cleanMsg = msg.replace(/:badger\.signout\.io/g, "");
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: `❌ Failed to invite ${addBotDisplay}: ${cleanMsg}`,
+          });
+        }
+        return true;
+      }
+
+      case "list": {
+        const botSuffix2 = "_bot:badger.signout.io";
+        let botsInRoom: string[] = [];
+        try {
+          const members = await client.getJoinedRoomMembers(roomId);
+          botsInRoom = members.filter((m: string) => m.includes(botSuffix2));
+        } catch {
+          botsInRoom = [selfUserId];
+        }
+
+        if (botsInRoom.length === 0) {
+          await client.sendMessage(roomId, {
+            msgtype: "m.text",
+            body: "No bots in this room.",
+          });
+          return true;
+        }
+
+        const config = loadRoomConfig();
+        const normalizedRoomId = roomId.toLowerCase();
+        const active = config[normalizedRoomId]?.activeBots ?? [];
+        // Legacy: if autoReply is true and no activeBots, all bots are active
+        const legacyAllActive = !Array.isArray(config[normalizedRoomId]?.activeBots) && config[normalizedRoomId]?.autoReply === true;
+
+        const botList = botsInRoom
+          .map((b) => {
+            const displayName = getDisplayName(b);
+            const isMe = b === selfUserId;
+            const isActive = legacyAllActive || active.some((a) => a.toLowerCase() === b.toLowerCase());
+            return `  ${isActive ? "🟢" : "⚪"} ${displayName}${isMe ? " (me)" : ""} — ${isActive ? "auto-reply on" : "mention-only"}`;
+          })
+          .join("\n");
+
+        await client.sendMessage(roomId, {
+          msgtype: "m.text",
+          body: [
+            "🦡 Bots in this room:",
+            "",
+            botList,
+            "",
+            `${botsInRoom.length} bot${botsInRoom.length === 1 ? "" : "s"} total`,
+          ].join("\n"),
+        });
+        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",
+          body: "Unknown command. Type /bot help for available commands.",
+        });
+        return true;
+      }
+    }
+  } catch (err) {
+    console.error("badgerclaw: bot command error:", err);
+    return true;
+  }
+}