openclaw-bitchat 0.1.0

package/src/bridge.ts

@@ -0,0 +1,284 @@
+/**
+ * Bitchat Bridge
+ *
+ * Handles communication with the bitchat-node HTTP bridge.
+ * Supports both polling and WebSocket connections for real-time messages.
+ */
+
+import type { BitchatInboundMessage } from './index.js';
+import type { Logger } from './types.js';
+
+export interface BridgeOptions {
+  bridgeUrl: string;
+  nickname: string;
+  onMessage: (msg: BitchatInboundMessage) => Promise<void>;
+  logger: Logger;
+  pollIntervalMs?: number;
+}
+
+interface BridgeStatus {
+  connected: boolean;
+  peerID?: string;
+  nickname?: string;
+  peersCount?: number;
+}
+
+interface PendingMessage {
+  id: string;
+  type: 'public' | 'direct';
+  senderPeerID: string;
+  senderNickname: string;
+  text: string;
+  timestamp: number;
+}
+
+export class BitchatBridge {
+  private readonly bridgeUrl: string;
+  private readonly onMessage: (msg: BitchatInboundMessage) => Promise<void>;
+  private readonly logger: Logger;
+  private readonly pollIntervalMs: number;
+
+  private connected = false;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private lastMessageTimestamp = 0;
+  private ws: WebSocket | null = null;
+
+  constructor(options: BridgeOptions) {
+    this.bridgeUrl = options.bridgeUrl.replace(/\/$/, ''); // Remove trailing slash
+    this.onMessage = options.onMessage;
+    this.logger = options.logger;
+    this.pollIntervalMs = options.pollIntervalMs ?? 2000;
+  }
+
+  /**
+   * Connect to the bitchat-node bridge
+   */
+  async connect(): Promise<void> {
+    // First, verify the bridge is reachable
+    try {
+      const status = await this.getStatus();
+      this.logger.info(`[bitchat-bridge] Connected to bridge. PeerID: ${status.peerID}`);
+      this.connected = true;
+    } catch (err) {
+      this.logger.error('[bitchat-bridge] Failed to connect to bridge:', err);
+      throw err;
+    }
+
+    // Try WebSocket first, fall back to polling
+    const wsUrl = this.bridgeUrl.replace(/^http/, 'ws') + '/ws';
+    try {
+      await this.connectWebSocket(wsUrl);
+      this.logger.info('[bitchat-bridge] WebSocket connected');
+    } catch {
+      this.logger.info('[bitchat-bridge] WebSocket unavailable, using polling');
+      this.startPolling();
+    }
+  }
+
+  /**
+   * Disconnect from the bridge
+   */
+  async disconnect(): Promise<void> {
+    this.connected = false;
+    
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  /**
+   * Get bridge status
+   */
+  async getStatus(): Promise<BridgeStatus> {
+    const response = await fetch(`${this.bridgeUrl}/api/status`);
+    if (!response.ok) {
+      throw new Error(`Bridge status failed: ${response.status}`);
+    }
+    return response.json() as Promise<BridgeStatus>;
+  }
+
+  /**
+   * Send a public message to all peers
+   */
+  async sendPublicMessage(text: string): Promise<void> {
+    const response = await fetch(`${this.bridgeUrl}/api/send`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'public', text }),
+    });
+    
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to send public message: ${error}`);
+    }
+  }
+
+  /**
+   * Send a direct message to a specific peer
+   */
+  async sendDirectMessage(recipientPeerID: string, text: string): Promise<void> {
+    const response = await fetch(`${this.bridgeUrl}/api/send`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ type: 'direct', recipientPeerID, text }),
+    });
+    
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to send direct message: ${error}`);
+    }
+  }
+
+  /**
+   * Get list of known peers
+   */
+  async getPeers(): Promise<{ peerID: string; nickname: string; lastSeen: number }[]> {
+    const response = await fetch(`${this.bridgeUrl}/api/peers`);
+    if (!response.ok) {
+      throw new Error(`Failed to get peers: ${response.status}`);
+    }
+    return response.json() as Promise<{ peerID: string; nickname: string; lastSeen: number }[]>;
+  }
+
+  /**
+   * Get recent messages (for polling)
+   */
+  async getMessages(since?: number): Promise<PendingMessage[]> {
+    const url = since
+      ? `${this.bridgeUrl}/api/messages?since=${since}`
+      : `${this.bridgeUrl}/api/messages`;
+    
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to get messages: ${response.status}`);
+    }
+    return response.json() as Promise<PendingMessage[]>;
+  }
+
+  /**
+   * Register webhook for incoming messages
+   */
+  async registerWebhook(webhookUrl: string): Promise<void> {
+    const response = await fetch(`${this.bridgeUrl}/api/webhook`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ url: webhookUrl }),
+    });
+    
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to register webhook: ${error}`);
+    }
+  }
+
+  /**
+   * Connect via WebSocket for real-time messages
+   */
+  private async connectWebSocket(wsUrl: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        // Note: In Node.js, we'd use the 'ws' package
+        // This is a simplified version that may need adjustment
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const WebSocketImpl = typeof WebSocket !== 'undefined' ? WebSocket : require('ws');
+        const ws = new WebSocketImpl(wsUrl) as WebSocket;
+        this.ws = ws;
+        
+        const timeout = setTimeout(() => {
+          reject(new Error('WebSocket connection timeout'));
+        }, 5000);
+
+        ws.onopen = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+
+        ws.onerror = (err: Event) => {
+          clearTimeout(timeout);
+          reject(err);
+        };
+
+        ws.onmessage = async (event: MessageEvent) => {
+          try {
+            const data = JSON.parse(String(event.data));
+            if (data.type === 'message') {
+              await this.onMessage({
+                type: data.isDirect ? 'direct' : 'public',
+                senderPeerID: data.senderPeerID,
+                senderNickname: data.senderNickname,
+                text: data.text,
+                timestamp: data.timestamp,
+                messageId: data.id ?? `ws-${Date.now()}`,
+              });
+            }
+          } catch (err) {
+            this.logger.error('[bitchat-bridge] WebSocket message parse error:', err);
+          }
+        };
+
+        ws.onclose = () => {
+          this.logger.info('[bitchat-bridge] WebSocket closed');
+          this.ws = null;
+          // Reconnect or fall back to polling
+          if (this.connected) {
+            this.startPolling();
+          }
+        };
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   * Start polling for messages
+   */
+  private startPolling(): void {
+    if (this.pollTimer) {
+      return; // Already polling
+    }
+
+    this.logger.info(`[bitchat-bridge] Starting message polling (${this.pollIntervalMs}ms)`);
+    
+    this.pollTimer = setInterval(async () => {
+      if (!this.connected) {
+        return;
+      }
+      
+      try {
+        const messages = await this.getMessages(this.lastMessageTimestamp);
+        
+        for (const msg of messages) {
+          // Update timestamp to avoid duplicates
+          if (msg.timestamp > this.lastMessageTimestamp) {
+            this.lastMessageTimestamp = msg.timestamp;
+          }
+          
+          await this.onMessage({
+            type: msg.type,
+            senderPeerID: msg.senderPeerID,
+            senderNickname: msg.senderNickname,
+            text: msg.text,
+            timestamp: msg.timestamp,
+            messageId: msg.id,
+          });
+        }
+      } catch (err) {
+        this.logger.error('[bitchat-bridge] Poll error:', err);
+      }
+    }, this.pollIntervalMs);
+  }
+}

package/src/index.ts

@@ -0,0 +1,288 @@
+/**
+ * @openclaw/bitchat - Bitchat BLE Mesh Channel Plugin
+ *
+ * This plugin enables OpenClaw to communicate via the Bitchat
+ * peer-to-peer BLE mesh network.
+ *
+ * Architecture:
+ * - bitchat-node runs as a background service (separate process)
+ * - This plugin communicates with it via HTTP bridge
+ * - Inbound: webhook from bitchat-node → OpenClaw session
+ * - Outbound: OpenClaw → HTTP API → bitchat-node → BLE mesh
+ */
+
+import type { PluginApi, ChannelPlugin } from './types.js';
+import { BitchatBridge } from './bridge.js';
+
+// Plugin configuration interface
+export interface BitchatConfig {
+  enabled?: boolean;
+  nickname?: string;
+  bridgeUrl?: string;
+  webhookPath?: string;
+  autoStart?: boolean;
+  dmPolicy?: 'open' | 'allowlist' | 'disabled';
+  allowFrom?: string[];
+}
+
+// Message from bitchat-node
+export interface BitchatInboundMessage {
+  type: 'public' | 'direct';
+  senderPeerID: string;
+  senderNickname: string;
+  text: string;
+  timestamp: number;
+  messageId: string;
+}
+
+// Default config values
+const DEFAULT_CONFIG: Required<BitchatConfig> = {
+  enabled: true,
+  nickname: 'openclaw',
+  bridgeUrl: 'http://localhost:3939',
+  webhookPath: '/bitchat-webhook',
+  autoStart: false,
+  dmPolicy: 'open',
+  allowFrom: [],
+};
+
+// Bridge instance (singleton for the gateway)
+let bridge: BitchatBridge | null = null;
+
+/**
+ * Resolve channel config from OpenClaw config
+ */
+function resolveConfig(cfg: Record<string, unknown>): Required<BitchatConfig> {
+  const channelConfig = (cfg.channels as Record<string, unknown>)?.bitchat as BitchatConfig | undefined;
+  return {
+    ...DEFAULT_CONFIG,
+    ...channelConfig,
+  };
+}
+
+/**
+ * Check if a sender is allowed based on policy
+ */
+function isSenderAllowed(config: Required<BitchatConfig>, senderPeerID: string): boolean {
+  switch (config.dmPolicy) {
+    case 'disabled':
+      return false;
+    case 'allowlist':
+      return config.allowFrom.includes(senderPeerID) || config.allowFrom.includes('*');
+    case 'open':
+    default:
+      return true;
+  }
+}
+
+/**
+ * Create the Bitchat channel plugin
+ */
+function createBitchatPlugin(): ChannelPlugin {
+  return {
+    id: 'bitchat',
+    meta: {
+      id: 'bitchat',
+      label: 'Bitchat',
+      selectionLabel: 'Bitchat (BLE Mesh)',
+      docsPath: '/channels/bitchat',
+      docsLabel: 'bitchat',
+      blurb: 'Peer-to-peer BLE mesh network messaging.',
+      aliases: ['ble', 'mesh'],
+    },
+    capabilities: {
+      chatTypes: ['direct', 'group'] as const,
+      media: false, // BLE bandwidth is limited
+    },
+    config: {
+      listAccountIds: () => ['default'],
+      resolveAccount: (cfg: Record<string, unknown>, accountId?: string) => {
+        const config = resolveConfig(cfg);
+        return {
+          accountId: accountId ?? 'default',
+          enabled: config.enabled,
+          configured: Boolean(config.bridgeUrl),
+          config,
+        };
+      },
+      defaultAccountId: () => 'default',
+      isConfigured: (account: { configured?: boolean }) => account.configured ?? false,
+      describeAccount: (account: { accountId: string; enabled?: boolean; configured?: boolean }) => ({
+        accountId: account.accountId,
+        enabled: account.enabled ?? true,
+        configured: account.configured ?? false,
+      }),
+    },
+    security: {
+      resolveDmPolicy: ({ account }) => ({
+        policy: String(account.config?.dmPolicy ?? 'open'),
+        allowFrom: (account.config?.allowFrom as string[]) ?? [],
+        policyPath: 'channels.bitchat.dmPolicy',
+        allowFromPath: 'channels.bitchat.allowFrom',
+        approveHint: 'Add peer ID to channels.bitchat.allowFrom',
+        normalizeEntry: (raw: string) => raw.trim().toLowerCase(),
+      }),
+    },
+    messaging: {
+      normalizeTarget: ({ target }) => {
+        // Accept peer ID or nickname
+        const cleaned = target.replace(/^bitchat:/i, '').trim();
+        return { target: cleaned, normalized: cleaned };
+      },
+      targetResolver: {
+        looksLikeId: (target: string) => /^[a-f0-9]{16}$/i.test(target),
+        hint: '<peerID|nickname>',
+      },
+    },
+    outbound: {
+      deliveryMode: 'direct',
+      sendText: async ({ text, target }) => {
+        
+        if (!bridge) {
+          return { ok: false, error: 'Bitchat bridge not initialized' };
+        }
+
+        try {
+          // Determine if this is a DM or public message
+          const isDirect = target && target !== 'public' && target !== '*';
+          
+          if (isDirect) {
+            await bridge.sendDirectMessage(target, text);
+          } else {
+            await bridge.sendPublicMessage(text);
+          }
+          
+          return { ok: true };
+        } catch (err) {
+          const error = err instanceof Error ? err.message : String(err);
+          return { ok: false, error };
+        }
+      },
+    },
+  };
+}
+
+/**
+ * Main plugin registration
+ */
+export default function register(api: PluginApi): void {
+  const logger = api.logger;
+  
+  // Register the channel
+  const plugin = createBitchatPlugin();
+  api.registerChannel({ plugin });
+  
+  // Register background service to manage bridge connection
+  api.registerService({
+    id: 'bitchat-bridge',
+    start: async () => {
+      const cfg = api.config as Record<string, unknown>;
+      const config = resolveConfig(cfg);
+      
+      if (!config.enabled) {
+        logger.info('[bitchat] Channel disabled');
+        return;
+      }
+      
+      logger.info(`[bitchat] Starting bridge connection to ${config.bridgeUrl}`);
+      
+      bridge = new BitchatBridge({
+        bridgeUrl: config.bridgeUrl,
+        nickname: config.nickname,
+        onMessage: async (msg: BitchatInboundMessage) => {
+          // Check if sender is allowed
+          if (!isSenderAllowed(config, msg.senderPeerID)) {
+            logger.debug(`[bitchat] Ignoring message from unauthorized peer: ${msg.senderPeerID}`);
+            return;
+          }
+          
+          // Route message to OpenClaw session
+          try {
+            await api.injectMessage({
+              channel: 'bitchat',
+              senderId: msg.senderPeerID,
+              senderName: msg.senderNickname,
+              text: msg.text,
+              messageId: msg.messageId,
+              chatType: msg.type === 'direct' ? 'direct' : 'group',
+              timestamp: msg.timestamp,
+            });
+          } catch (err) {
+            logger.error('[bitchat] Failed to inject message:', err);
+          }
+        },
+        logger,
+      });
+      
+      await bridge.connect();
+      logger.info('[bitchat] Bridge connected');
+    },
+    stop: async () => {
+      if (bridge) {
+        await bridge.disconnect();
+        bridge = null;
+        logger.info('[bitchat] Bridge disconnected');
+      }
+    },
+  });
+  
+  // Register webhook handler for inbound messages
+  api.registerHttpHandler({
+    method: 'POST',
+    path: '/bitchat-webhook',
+    handler: async (req, res) => {
+      try {
+        const body = req.body as BitchatInboundMessage;
+        
+        if (!body || !body.senderPeerID || !body.text) {
+          res.status(400).json({ error: 'Invalid message format' });
+          return;
+        }
+        
+        const cfg = api.config as Record<string, unknown>;
+        const config = resolveConfig(cfg);
+        
+        if (!isSenderAllowed(config, body.senderPeerID)) {
+          res.status(403).json({ error: 'Sender not allowed' });
+          return;
+        }
+        
+        await api.injectMessage({
+          channel: 'bitchat',
+          senderId: body.senderPeerID,
+          senderName: body.senderNickname,
+          text: body.text,
+          messageId: body.messageId,
+          chatType: body.type === 'direct' ? 'direct' : 'group',
+          timestamp: body.timestamp,
+        });
+        
+        res.json({ ok: true });
+      } catch (err) {
+        logger.error('[bitchat] Webhook error:', err);
+        res.status(500).json({ error: 'Internal error' });
+      }
+    },
+  });
+  
+  // Register RPC methods for status
+  api.registerGatewayMethod('bitchat.status', async ({ respond }) => {
+    const cfg = api.config as Record<string, unknown>;
+    const config = resolveConfig(cfg);
+    
+    const status = {
+      enabled: config.enabled,
+      bridgeUrl: config.bridgeUrl,
+      connected: bridge?.isConnected() ?? false,
+      nickname: config.nickname,
+      dmPolicy: config.dmPolicy,
+    };
+    
+    respond(true, status);
+  });
+  
+  logger.info('[bitchat] Plugin registered');
+}
+
+// Export types
+export type { PluginApi, ChannelPlugin };