badgerclaw 0.1.7 → 1.4.0

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/direct.ts

@@ -0,0 +1,152 @@
+import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
+
+type DirectMessageCheck = {
+  roomId: string;
+  senderId?: string;
+  selfUserId?: string;
+};
+
+type DirectRoomTrackerOptions = {
+  log?: (message: string) => void;
+  includeMemberCountInLogs?: boolean;
+};
+
+const DM_CACHE_TTL_MS = 30_000;
+
+/**
+ * Check if an error is a Matrix M_NOT_FOUND response (missing state event).
+ * The bot-sdk throws MatrixError with errcode/statusCode on the error object.
+ */
+function isMatrixNotFoundError(err: unknown): boolean {
+  if (typeof err !== "object" || err === null) return false;
+  const e = err as { errcode?: string; statusCode?: number };
+  return e.errcode === "M_NOT_FOUND" || e.statusCode === 404;
+}
+
+export function createDirectRoomTracker(client: MatrixClient, opts: DirectRoomTrackerOptions = {}) {
+  const log = opts.log ?? (() => {});
+  const includeMemberCountInLogs = opts.includeMemberCountInLogs === true;
+  let lastDmUpdateMs = 0;
+  let cachedSelfUserId: string | null = null;
+  const memberCountCache = new Map<string, { count: number; ts: number }>();
+
+  const ensureSelfUserId = async (): Promise<string | null> => {
+    if (cachedSelfUserId) {
+      return cachedSelfUserId;
+    }
+    try {
+      cachedSelfUserId = await client.getUserId();
+    } catch {
+      cachedSelfUserId = null;
+    }
+    return cachedSelfUserId;
+  };
+
+  const refreshDmCache = async (): Promise<void> => {
+    const now = Date.now();
+    if (now - lastDmUpdateMs < DM_CACHE_TTL_MS) {
+      return;
+    }
+    lastDmUpdateMs = now;
+    try {
+      await client.dms.update();
+    } catch (err) {
+      log(`badgerclaw: dm cache refresh failed (${String(err)})`);
+    }
+  };
+
+  const resolveMemberCount = async (roomId: string): Promise<number | null> => {
+    const cached = memberCountCache.get(roomId);
+    const now = Date.now();
+    if (cached && now - cached.ts < DM_CACHE_TTL_MS) {
+      return cached.count;
+    }
+    try {
+      const members = await client.getJoinedRoomMembers(roomId);
+      const count = members.length;
+      memberCountCache.set(roomId, { count, ts: now });
+      return count;
+    } catch (err) {
+      log(`badgerclaw: dm member count failed room=${roomId} (${String(err)})`);
+      return null;
+    }
+  };
+
+  const hasDirectFlag = async (roomId: string, userId?: string): Promise<boolean> => {
+    const target = userId?.trim();
+    if (!target) {
+      return false;
+    }
+    try {
+      const state = await client.getRoomStateEvent(roomId, "m.room.member", target);
+      return state?.is_direct === true;
+    } catch {
+      return false;
+    }
+  };
+
+  return {
+    isDirectMessage: async (params: DirectMessageCheck): Promise<boolean> => {
+      const { roomId, senderId } = params;
+      await refreshDmCache();
+
+      // Check m.direct account data (most authoritative)
+      if (client.dms.isDm(roomId)) {
+        log(`badgerclaw: dm detected via m.direct room=${roomId}`);
+        return true;
+      }
+
+      const selfUserId = params.selfUserId ?? (await ensureSelfUserId());
+      const directViaState =
+        (await hasDirectFlag(roomId, senderId)) || (await hasDirectFlag(roomId, selfUserId ?? ""));
+      if (directViaState) {
+        log(`badgerclaw: dm detected via member state room=${roomId}`);
+        return true;
+      }
+
+      // Conservative fallback: 2-member rooms without an explicit room name are likely
+      // DMs with broken m.direct / is_direct flags. This has been observed on Continuwuity
+      // where m.direct pointed to the wrong room and is_direct was never set on the invite.
+      // Unlike the removed heuristic, this requires two signals (member count + no name)
+      // to avoid false positives on named 2-person group rooms.
+      //
+      // Performance: member count is cached (resolveMemberCount). The room name state
+      // check is not cached but only runs for the subset of 2-member rooms that reach
+      // this fallback path (no m.direct, no is_direct). In typical deployments this is
+      // a small minority of rooms.
+      //
+      // Note: there is a narrow race where a room name is being set concurrently with
+      // this check. The consequence is a one-time misclassification that self-corrects
+      // on the next message (once the state event is synced). This is acceptable given
+      // the alternative of an additional API call on every message.
+      const memberCount = await resolveMemberCount(roomId);
+      if (memberCount === 2) {
+        try {
+          const nameState = await client.getRoomStateEvent(roomId, "m.room.name", "");
+          if (!nameState?.name?.trim()) {
+            log(`badgerclaw: dm detected via fallback (2 members, no room name) room=${roomId}`);
+            return true;
+          }
+        } catch (err: unknown) {
+          // Missing state events (M_NOT_FOUND) are expected for unnamed rooms and
+          // strongly indicate a DM. Any other error (network, auth) is ambiguous,
+          // so we fall through to classify as group rather than guess.
+          if (isMatrixNotFoundError(err)) {
+            log(`badgerclaw: dm detected via fallback (2 members, no room name) room=${roomId}`);
+            return true;
+          }
+          log(
+            `badgerclaw: dm fallback skipped (room name check failed: ${String(err)}) room=${roomId}`,
+          );
+        }
+      }
+
+      if (!includeMemberCountInLogs) {
+        log(`badgerclaw: dm check room=${roomId} result=group`);
+        return false;
+      }
+      log(`badgerclaw: dm check room=${roomId} result=group members=${memberCount ?? "unknown"}`);
+      return false;
+    },
+  };
+}

package/src/matrix/monitor/events.ts

@@ -0,0 +1,250 @@
+import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
+import type { PluginRuntime, RuntimeLogger } from "openclaw/plugin-sdk/matrix";
+import type { MatrixAuth } from "../client.js";
+import { sendReadReceiptMatrix } from "../send.js";
+import type { MatrixRawEvent } from "./types.js";
+import { EventType } from "./types.js";
+
+const matrixMonitorListenerRegistry = (() => {
+  // Prevent duplicate listener registration when both bundled and extension
+  // paths attempt to start monitors against the same shared client.
+  const registeredClients = new WeakSet<object>();
+  return {
+    tryRegister(client: object): boolean {
+      if (registeredClients.has(client)) {
+        return false;
+      }
+      registeredClients.add(client);
+      return true;
+    },
+  };
+})();
+
+function createSelfUserIdResolver(client: Pick<MatrixClient, "getUserId">) {
+  let selfUserId: string | undefined;
+  let selfUserIdLookup: Promise<string | undefined> | undefined;
+
+  return async (): Promise<string | undefined> => {
+    if (selfUserId) {
+      return selfUserId;
+    }
+    if (!selfUserIdLookup) {
+      selfUserIdLookup = client
+        .getUserId()
+        .then((userId) => {
+          selfUserId = userId;
+          return userId;
+        })
+        .catch(() => undefined)
+        .finally(() => {
+          if (!selfUserId) {
+            selfUserIdLookup = undefined;
+          }
+        });
+    }
+    return await selfUserIdLookup;
+  };
+}
+
+export function registerMatrixMonitorEvents(params: {
+  client: MatrixClient;
+  auth: MatrixAuth;
+  logVerboseMessage: (message: string) => void;
+  warnedEncryptedRooms: Set<string>;
+  warnedCryptoMissingRooms: Set<string>;
+  logger: RuntimeLogger;
+  formatNativeDependencyHint: PluginRuntime["system"]["formatNativeDependencyHint"];
+  onRoomMessage: (roomId: string, event: MatrixRawEvent) => void | Promise<void>;
+}): void {
+  if (!matrixMonitorListenerRegistry.tryRegister(params.client)) {
+    params.logVerboseMessage("badgerclaw: skipping duplicate listener registration for client");
+    return;
+  }
+
+  const {
+    client,
+    auth,
+    logVerboseMessage,
+    warnedEncryptedRooms,
+    warnedCryptoMissingRooms,
+    logger,
+    formatNativeDependencyHint,
+    onRoomMessage,
+  } = params;
+
+  const resolveSelfUserId = createSelfUserIdResolver(client);
+  client.on("room.message", (roomId: string, event: MatrixRawEvent) => {
+    const eventId = event?.event_id;
+    const senderId = event?.sender;
+    if (eventId && senderId) {
+      void (async () => {
+        const currentSelfUserId = await resolveSelfUserId();
+        if (!currentSelfUserId || senderId === currentSelfUserId) {
+          return;
+        }
+        await sendReadReceiptMatrix(roomId, eventId, client).catch((err) => {
+          logVerboseMessage(
+            `badgerclaw: early read receipt failed room=${roomId} id=${eventId}: ${String(err)}`,
+          );
+        });
+      })();
+    }
+
+    onRoomMessage(roomId, event);
+  });
+
+  client.on("room.encrypted_event", (roomId: string, event: MatrixRawEvent) => {
+    const eventId = event?.event_id ?? "unknown";
+    const eventType = event?.type ?? "unknown";
+    logVerboseMessage(`badgerclaw: encrypted event room=${roomId} type=${eventType} id=${eventId}`);
+  });
+
+  client.on("room.decrypted_event", (roomId: string, event: MatrixRawEvent) => {
+    const eventId = event?.event_id ?? "unknown";
+    const eventType = event?.type ?? "unknown";
+    logVerboseMessage(`badgerclaw: decrypted event room=${roomId} type=${eventType} id=${eventId}`);
+  });
+
+  client.on(
+    "room.failed_decryption",
+    async (roomId: string, event: MatrixRawEvent, error: Error) => {
+      logger.warn("Failed to decrypt message", {
+        roomId,
+        eventId: event.event_id,
+        error: error.message,
+      });
+      logVerboseMessage(
+        `badgerclaw: failed decrypt room=${roomId} id=${event.event_id ?? "unknown"} error=${error.message}`,
+      );
+    },
+  );
+
+  client.on("room.invite", (roomId: string, event: MatrixRawEvent) => {
+    const eventId = event?.event_id ?? "unknown";
+    const sender = event?.sender ?? "unknown";
+    const isDirect = (event?.content as { is_direct?: boolean } | undefined)?.is_direct === true;
+    logVerboseMessage(
+      `badgerclaw: invite room=${roomId} sender=${sender} direct=${String(isDirect)} id=${eventId}`,
+    );
+  });
+
+  client.on("room.join", (roomId: string, event: MatrixRawEvent) => {
+    const eventId = event?.event_id ?? "unknown";
+    logVerboseMessage(`badgerclaw: join room=${roomId} id=${eventId}`);
+  });
+
+  client.on("room.event", (roomId: string, event: MatrixRawEvent) => {
+    const eventType = event?.type ?? "unknown";
+    if (eventType === EventType.RoomMessageEncrypted) {
+      logVerboseMessage(
+        `badgerclaw: encrypted raw event room=${roomId} id=${event?.event_id ?? "unknown"}`,
+      );
+      if (auth.encryption !== true && !warnedEncryptedRooms.has(roomId)) {
+        warnedEncryptedRooms.add(roomId);
+        const warning =
+          "badgerclaw: encrypted event received without encryption enabled; set channels.badgerclaw.encryption=true and verify the device to decrypt";
+        logger.warn(warning, { roomId });
+      }
+      if (auth.encryption === true && !client.crypto && !warnedCryptoMissingRooms.has(roomId)) {
+        warnedCryptoMissingRooms.add(roomId);
+        const hint = formatNativeDependencyHint({
+          packageName: "@matrix-org/matrix-sdk-crypto-nodejs",
+          manager: "pnpm",
+          downloadCommand: "node node_modules/@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js",
+        });
+        const warning = `badgerclaw: encryption enabled but crypto is unavailable; ${hint}`;
+        logger.warn(warning, { roomId });
+      }
+      return;
+    }
+    if (eventType === EventType.RoomMember) {
+      const membership = (event?.content as { membership?: string } | undefined)?.membership;
+      const stateKey = (event as { state_key?: string }).state_key ?? "";
+      logVerboseMessage(
+        `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)}`);
+        }
+      })();
+    }
+  });
+}