@badgerclaw/connect 1.1.2 → 1.2.0

package/package.json

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

package/src/group-mentions.ts

@@ -29,6 +29,17 @@ function resolveMatrixRoomConfigForGroup(params: ChannelGroupContext) {
 }
 
 export function resolveMatrixGroupRequireMention(params: ChannelGroupContext): boolean {
+  // Check per-room config first (set by /bot talk on|off)
+  try {
+    const { getRoomAutoReply } = require("./matrix/monitor/bot-commands.js");
+    const roomId = params.groupId?.trim() ?? "";
+    const roomAutoReply = getRoomAutoReply(roomId);
+    if (roomAutoReply === true) return false;
+    if (roomAutoReply === false) return true;
+  } catch {
+    // bot-commands module not available, fall through
+  }
+
   const resolved = resolveMatrixRoomConfigForGroup(params);
   if (resolved) {
     if (resolved.autoReply === true) {

package/src/matrix/client/backup.ts

@@ -1,7 +1,8 @@
 import type { MatrixClient } from "@vector-im/matrix-bot-sdk";
-import { appendFileSync, mkdirSync } from "node:fs";
+import { appendFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { generateKeyPairSync } from "node:crypto";
 import { getMatrixLogService } from "../sdk-runtime.js";
 
 export type KeyBackupStatus = {
@@ -10,19 +11,12 @@ export type KeyBackupStatus = {
   deviceId: string | null;
 };
 
-export async function getEncryptionKeyBackupStatus(
-  client: MatrixClient,
-): Promise<KeyBackupStatus> {
+export async function getEncryptionKeyBackupStatus(client: MatrixClient): Promise<KeyBackupStatus> {
   const LogService = getMatrixLogService();
   try {
     const backupInfo = await client.getKeyBackupVersion();
     const whoami = await client.getWhoAmI();
-    const deviceId = whoami.device_id ?? null;
-    return {
-      enabled: backupInfo !== null,
-      version: backupInfo?.version ?? null,
-      deviceId,
-    };
+    return { enabled: backupInfo !== null, version: backupInfo?.version ?? null, deviceId: whoami.device_id ?? null };
   } catch (err) {
     LogService.warn("MatrixKeyBackup", "Failed to check key backup status:", err);
     return { enabled: false, version: null, deviceId: null };
@@ -33,17 +27,12 @@ export async function setupKeyBackup(client: MatrixClient): Promise<void> {
   const LogService = getMatrixLogService();
 
   let deviceId = "(unknown)";
-  try {
-    const whoami = await client.getWhoAmI();
-    deviceId = whoami.device_id ?? deviceId;
-  } catch {
-    // Non-fatal
-  }
+  try { deviceId = (await client.getWhoAmI()).device_id ?? deviceId; } catch { /* non-fatal */ }
 
   LogService.info("MatrixKeyBackup", `Crypto ready — device ID: ${deviceId}`);
 
   if (!client.crypto) {
-    LogService.info("MatrixKeyBackup", "Crypto client not available, skipping key backup setup");
+    LogService.info("MatrixKeyBackup", "Crypto not available, skipping backup setup");
     return;
   }
 
@@ -51,45 +40,52 @@ export async function setupKeyBackup(client: MatrixClient): Promise<void> {
     let backupInfo = await client.getKeyBackupVersion();
 
     if (!backupInfo) {
-      // No backup exists — create one now
-      LogService.info("MatrixKeyBackup", "No key backup found — creating server-side key backup");
-      try {
-        backupInfo = await (client as any).signAndCreateKeyBackupVersion({
-          algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
-          auth_data: {},
-        });
-        LogService.info("MatrixKeyBackup", `Created new key backup version ${backupInfo?.version}`);
-      } catch (createErr) {
-        LogService.warn("MatrixKeyBackup", "Failed to create key backup version:", createErr);
-        return;
-      }
+      LogService.info("MatrixKeyBackup", "No backup found — generating Curve25519 key pair and creating backup version");
+
+      // Generate X25519 (Curve25519) key pair using Node crypto
+      const { publicKey: pubKeyObj, privateKey: privKeyObj } = generateKeyPairSync("x25519");
+      const pubKeyRaw = pubKeyObj.export({ type: "spki", format: "der" }).slice(-32);
+      const privKeyRaw = privKeyObj.export({ type: "pkcs8", format: "der" }).slice(-32);
+      const publicKeyBase64 = pubKeyRaw.toString("base64");
+      const privateKeyBase64 = privKeyRaw.toString("base64");
+
+      // Create the backup version on the server
+      await client.signAndCreateKeyBackupVersion({
+        algorithm: "m.megolm_backup.v1.curve25519-aes-sha2",
+        auth_data: { public_key: publicKeyBase64 },
+      } as any);
+
+      // Save private key for cross-device restore
+      const backupDir = join(homedir(), ".openclaw", "backup");
+      mkdirSync(backupDir, { recursive: true });
+      writeFileSync(
+        join(backupDir, `private-key-${deviceId}.json`),
+        JSON.stringify({ privateKey: privateKeyBase64, deviceId, created: new Date().toISOString() }),
+        { mode: 0o600 }
+      );
+
+      backupInfo = await client.getKeyBackupVersion();
+      LogService.info("MatrixKeyBackup", `Created backup version ${backupInfo?.version}`);
     }
 
     if (!backupInfo) {
-      LogService.warn("MatrixKeyBackup", "Key backup info unavailable after creation attempt");
+      LogService.warn("MatrixKeyBackup", "No backup info after creation attempt");
       return;
     }
 
     await client.crypto.enableKeyBackup(backupInfo);
-    LogService.info(
-      "MatrixKeyBackup",
-      `Key backup enabled (version ${backupInfo.version}) on device ${deviceId} — keys will upload automatically`,
-    );
-    _persistBackupRecord(backupInfo.version, deviceId);
+    LogService.info("MatrixKeyBackup", `Backup enabled v${backupInfo.version} on ${deviceId} — uploading room keys`);
+    _persistRecord(backupInfo.version, deviceId);
   } catch (err) {
-    LogService.warn("MatrixKeyBackup", "Key backup setup failed:", err);
+    LogService.warn("MatrixKeyBackup", "Backup setup failed:", err);
   }
 }
 
-function _persistBackupRecord(version: string, deviceId: string): void {
+function _persistRecord(version: string, deviceId: string): void {
   try {
     const dir = join(homedir(), ".openclaw", "backup");
     mkdirSync(dir, { recursive: true });
-    const path = join(dir, "key-backup-record.log");
-    const entry =
-      JSON.stringify({ version, deviceId, timestamp: new Date().toISOString() }) + "\n";
-    appendFileSync(path, entry, "utf8");
-  } catch {
-    // Non-fatal — backup is enabled, record persistence is best-effort
-  }
+    appendFileSync(join(dir, "key-backup-record.log"),
+      JSON.stringify({ version, deviceId, timestamp: new Date().toISOString() }) + "\n");
+  } catch { /* non-fatal */ }
 }

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

@@ -0,0 +1,173 @@
+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"
+);
+
+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));
+}
+
+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);
+          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);
+          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,