xingp14-clawlink 0.1.2

package/bin/clawlink-cli.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// ClawLink CLI - Connect to ClawLink Hub from any environment
+
+import WebSocket from 'ws';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const HUB_URL = process.env.CLAWLINK_HUB_URL || 'ws://localhost:8080';
+const AGENT_ID = process.env.CLAWLINK_AGENT_ID || 'cli-agent';
+const AUTH_TOKEN = process.env.CLAWLINK_TOKEN || 'change-me';
+const AUTO_JOIN = (process.env.CLAWLINK_AUTO_JOIN || '').split(',').filter(Boolean);
+
+function log(msg) {
+  console.log(`[ClawLink] ${msg}`);
+}
+
+function send(ws, msg) {
+  ws.send(JSON.stringify(msg));
+}
+
+async function main() {
+  log(`Connecting to ${HUB_URL} as ${AGENT_ID}...`);
+  
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`${HUB_URL}?agentId=${AGENT_ID}&token=${AUTH_TOKEN}`);
+    
+    ws.on('open', () => {
+      log('Connected!');
+      
+      // Auto-join topics
+      for (const topic of AUTO_JOIN) {
+        log(`Auto-joining ${topic}...`);
+        send(ws, { type: 'join', topic });
+      }
+      
+      // Handle commands
+      if (command === 'join') {
+        const topic = args[1];
+        if (!topic) {
+          log('Usage: clawlink join <topic>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Joining topic: ${topic}`);
+        send(ws, { type: 'join', topic });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'leave') {
+        const topic = args[1];
+        if (!topic) {
+          log('Usage: clawlink leave <topic>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Leaving topic: ${topic}`);
+        send(ws, { type: 'leave', topic });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'send') {
+        const topic = args[1];
+        const content = args.slice(2).join(' ');
+        if (!topic || !content) {
+          log('Usage: clawlink send <topic> <message>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Sending to ${topic}: ${content}`);
+        send(ws, { type: 'message', topic, content });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'list') {
+        send(ws, { type: 'topics_list' });
+        setTimeout(() => { ws.close(); resolve(); }, 2000);
+      }
+      else if (command === 'memory-write') {
+        const key = args[1];
+        const value = args.slice(2).join(' ');
+        if (!key || !value) {
+          log('Usage: clawlink memory-write <key> <value>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Writing memory: ${key} = ${value}`);
+        send(ws, { type: 'memory_write', key, value });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'memory-read') {
+        const key = args[1];
+        if (!key) {
+          log('Usage: clawlink memory-read <key>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Reading memory: ${key}`);
+        send(ws, { type: 'memory_read', key });
+        setTimeout(() => { ws.close(); resolve(); }, 2000);
+      }
+      else if (command === 'shell') {
+        // Interactive shell mode
+        log('Entering shell mode. Commands: join, leave, send, list, memory-write, memory-read, exit');
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (line) => {
+          const cmd = line.trim().split(' ');
+          switch (cmd[0]) {
+            case 'join':
+              send(ws, { type: 'join', topic: cmd[1] });
+              break;
+            case 'leave':
+              send(ws, { type: 'leave', topic: cmd[1] });
+              break;
+            case 'send':
+              send(ws, { type: 'message', topic: cmd[1], content: cmd.slice(2).join(' ') });
+              break;
+            case 'list':
+              send(ws, { type: 'topics_list' });
+              break;
+            case 'memory-write':
+              send(ws, { type: 'memory_write', key: cmd[1], value: cmd.slice(2).join(' ') });
+              break;
+            case 'memory-read':
+              send(ws, { type: 'memory_read', key: cmd[1] });
+              break;
+            case 'exit':
+              ws.close();
+              resolve();
+              break;
+          }
+        });
+      }
+      else if (command) {
+        log(`Unknown command: ${command}`);
+        log('Commands: join, leave, send, list, memory-write, memory-read, shell');
+        ws.close();
+        resolve();
+      }
+      else {
+        // Interactive mode - listen for messages
+        log('Connected. Waiting for messages...');
+        log('Commands: join, leave, send, list, memory-write, memory-read, exit');
+      }
+    });
+
+    ws.on('message', (data) => {
+      const msg = JSON.parse(data);
+      switch (msg.type) {
+        case 'welcome':
+          log(`Welcome! Agent ID: ${msg.agentId}`);
+          break;
+        case 'message':
+          log(`[${msg.topic}] ${msg.from}: ${msg.content}`);
+          break;
+        case 'join':
+          log(`[${msg.topic}] ${msg.agent} joined`);
+          break;
+        case 'leave':
+          log(`[${msg.topic}] ${msg.agent} left`);
+          break;
+        case 'topics_list':
+          log(`Topics: ${JSON.stringify(msg.topics)}`);
+          break;
+        case 'topic_members':
+          log(`Members in ${msg.topic}: ${JSON.stringify(msg.agents)}`);
+          break;
+        case 'memory_update':
+          log(`Memory updated: ${msg.key} = ${msg.value} (by ${msg.from})`);
+          break;
+        case 'memory_value':
+          log(`Memory ${msg.key}: ${msg.value} (exists: ${msg.exists})`);
+          break;
+        case 'error':
+          log(`Error: ${msg.code} - ${msg.message}`);
+          break;
+      }
+    });
+
+    ws.on('error', (err) => {
+      log(`Error: ${err.message}`);
+      reject(err);
+    });
+
+    ws.on('close', () => {
+      log('Disconnected');
+    });
+  });
+}
+
+main().catch(console.error);

package/dist/bin/clawlink-cli.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// ClawLink CLI - Connect to ClawLink Hub from any environment
+
+import WebSocket from 'ws';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const HUB_URL = process.env.CLAWLINK_HUB_URL || 'ws://localhost:8080';
+const AGENT_ID = process.env.CLAWLINK_AGENT_ID || 'cli-agent';
+const AUTH_TOKEN = process.env.CLAWLINK_TOKEN || 'change-me';
+const AUTO_JOIN = (process.env.CLAWLINK_AUTO_JOIN || '').split(',').filter(Boolean);
+
+function log(msg) {
+  console.log(`[ClawLink] ${msg}`);
+}
+
+function send(ws, msg) {
+  ws.send(JSON.stringify(msg));
+}
+
+async function main() {
+  log(`Connecting to ${HUB_URL} as ${AGENT_ID}...`);
+  
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(`${HUB_URL}?agentId=${AGENT_ID}&token=${AUTH_TOKEN}`);
+    
+    ws.on('open', () => {
+      log('Connected!');
+      
+      // Auto-join topics
+      for (const topic of AUTO_JOIN) {
+        log(`Auto-joining ${topic}...`);
+        send(ws, { type: 'join', topic });
+      }
+      
+      // Handle commands
+      if (command === 'join') {
+        const topic = args[1];
+        if (!topic) {
+          log('Usage: clawlink join <topic>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Joining topic: ${topic}`);
+        send(ws, { type: 'join', topic });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'leave') {
+        const topic = args[1];
+        if (!topic) {
+          log('Usage: clawlink leave <topic>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Leaving topic: ${topic}`);
+        send(ws, { type: 'leave', topic });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'send') {
+        const topic = args[1];
+        const content = args.slice(2).join(' ');
+        if (!topic || !content) {
+          log('Usage: clawlink send <topic> <message>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Sending to ${topic}: ${content}`);
+        send(ws, { type: 'message', topic, content });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'list') {
+        send(ws, { type: 'topics_list' });
+        setTimeout(() => { ws.close(); resolve(); }, 2000);
+      }
+      else if (command === 'memory-write') {
+        const key = args[1];
+        const value = args.slice(2).join(' ');
+        if (!key || !value) {
+          log('Usage: clawlink memory-write <key> <value>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Writing memory: ${key} = ${value}`);
+        send(ws, { type: 'memory_write', key, value });
+        setTimeout(() => { ws.close(); resolve(); }, 1000);
+      }
+      else if (command === 'memory-read') {
+        const key = args[1];
+        if (!key) {
+          log('Usage: clawlink memory-read <key>');
+          ws.close();
+          resolve();
+          return;
+        }
+        log(`Reading memory: ${key}`);
+        send(ws, { type: 'memory_read', key });
+        setTimeout(() => { ws.close(); resolve(); }, 2000);
+      }
+      else if (command === 'shell') {
+        // Interactive shell mode
+        log('Entering shell mode. Commands: join, leave, send, list, memory-write, memory-read, exit');
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (line) => {
+          const cmd = line.trim().split(' ');
+          switch (cmd[0]) {
+            case 'join':
+              send(ws, { type: 'join', topic: cmd[1] });
+              break;
+            case 'leave':
+              send(ws, { type: 'leave', topic: cmd[1] });
+              break;
+            case 'send':
+              send(ws, { type: 'message', topic: cmd[1], content: cmd.slice(2).join(' ') });
+              break;
+            case 'list':
+              send(ws, { type: 'topics_list' });
+              break;
+            case 'memory-write':
+              send(ws, { type: 'memory_write', key: cmd[1], value: cmd.slice(2).join(' ') });
+              break;
+            case 'memory-read':
+              send(ws, { type: 'memory_read', key: cmd[1] });
+              break;
+            case 'exit':
+              ws.close();
+              resolve();
+              break;
+          }
+        });
+      }
+      else if (command) {
+        log(`Unknown command: ${command}`);
+        log('Commands: join, leave, send, list, memory-write, memory-read, shell');
+        ws.close();
+        resolve();
+      }
+      else {
+        // Interactive mode - listen for messages
+        log('Connected. Waiting for messages...');
+        log('Commands: join, leave, send, list, memory-write, memory-read, exit');
+      }
+    });
+
+    ws.on('message', (data) => {
+      const msg = JSON.parse(data);
+      switch (msg.type) {
+        case 'welcome':
+          log(`Welcome! Agent ID: ${msg.agentId}`);
+          break;
+        case 'message':
+          log(`[${msg.topic}] ${msg.from}: ${msg.content}`);
+          break;
+        case 'join':
+          log(`[${msg.topic}] ${msg.agent} joined`);
+          break;
+        case 'leave':
+          log(`[${msg.topic}] ${msg.agent} left`);
+          break;
+        case 'topics_list':
+          log(`Topics: ${JSON.stringify(msg.topics)}`);
+          break;
+        case 'topic_members':
+          log(`Members in ${msg.topic}: ${JSON.stringify(msg.agents)}`);
+          break;
+        case 'memory_update':
+          log(`Memory updated: ${msg.key} = ${msg.value} (by ${msg.from})`);
+          break;
+        case 'memory_value':
+          log(`Memory ${msg.key}: ${msg.value} (exists: ${msg.exists})`);
+          break;
+        case 'error':
+          log(`Error: ${msg.code} - ${msg.message}`);
+          break;
+      }
+    });
+
+    ws.on('error', (err) => {
+      log(`Error: ${err.message}`);
+      reject(err);
+    });
+
+    ws.on('close', () => {
+      log('Disconnected');
+    });
+  });
+}
+
+main().catch(console.error);

package/dist/index.js

@@ -0,0 +1,231 @@
+// ClawLink Plugin for OpenClaw
+// Enables OpenClaw agents to connect to ClawLink hub
+
+import { WebSocket } from 'ws';
+
+class ClawLinkChannel {
+  constructor() {
+    this.name = 'clawlink';
+    this.ws = null;
+    this.config = null;
+    this.ctx = null;
+    this.reconnectTimer = null;
+    this.pingTimer = null;
+    this.pendingMessages = new Map();
+    this.messageHandlers = [];
+    this.topics = new Set();
+    this.agentId = '';
+  }
+
+  async initialize(ctx) {
+    this.ctx = ctx;
+    const config = ctx.config;
+    this.config = config;
+    this.agentId = config.agentId;
+    
+    if (config.autoJoin) {
+      for (const topic of config.autoJoin) {
+        this.topics.add(topic);
+      }
+    }
+    if (config.topics) {
+      for (const topic of config.topics) {
+        this.topics.add(topic);
+      }
+    }
+
+    this.connect();
+  }
+
+  connect() {
+    if (!this.config || !this.ctx) return;
+
+    const url = `${this.config.hubUrl}?agentId=${encodeURIComponent(this.config.agentId)}&token=${encodeURIComponent(this.config.token)}`;
+    
+    try {
+      this.ws = new WebSocket(url);
+
+      this.ws.onopen = () => {
+        this.ctx?.logger?.info(`[ClawLink] Connected to hub: ${this.config?.hubUrl}`);
+        
+        for (const topic of this.topics) {
+          this.send({ type: 'join', topic });
+        }
+        
+        this.pingTimer = setInterval(() => {
+          if (this.ws?.readyState === WebSocket.OPEN) {
+            this.send({ type: 'ping' });
+          }
+        }, 25000);
+      };
+
+      this.ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          this.handleMessage(msg);
+        } catch (e) {
+          this.ctx?.logger?.error('[ClawLink] Failed to parse message:', e);
+        }
+      };
+
+      this.ws.onclose = (event) => {
+        this.ctx?.logger?.warn(`[ClawLink] Disconnected (code: ${event.code})`);
+        this.scheduleReconnect();
+      };
+
+      this.ws.onerror = (error) => {
+        this.ctx?.logger?.error('[ClawLink] WebSocket error:', error);
+      };
+    } catch (e) {
+      this.ctx?.logger?.error('[ClawLink] Failed to connect:', e);
+      this.scheduleReconnect();
+    }
+  }
+
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.ctx?.logger?.info('[ClawLink] Attempting to reconnect...');
+      this.connect();
+    }, 5000);
+  }
+
+  handleMessage(msg) {
+    switch (msg.type) {
+      case 'welcome':
+        this.ctx?.logger?.info(`[ClawLink] Authenticated as ${msg.agentId}`);
+        break;
+
+      case 'message':
+        if (msg.from !== this.agentId) {
+          this.ctx?.dispatch({
+            channel: 'clawlink',
+            id: msg.id,
+            from: msg.from,
+            text: msg.content,
+            topic: msg.topic,
+            timestamp: msg.timestamp,
+          });
+        }
+        break;
+
+      case 'join':
+        this.ctx?.logger?.debug(`[ClawLink] Agent ${msg.agent} joined ${msg.topic}`);
+        break;
+
+      case 'leave':
+        this.ctx?.logger?.debug(`[ClawLink] Agent ${msg.agent} left ${msg.topic}`);
+        break;
+
+      case 'history':
+        this.ctx?.logger?.debug(`[ClawLink] Received ${msg.messages?.length || 0} historical messages for ${msg.topic}`);
+        for (const historicalMsg of (msg.messages || [])) {
+          if (historicalMsg.from !== this.agentId) {
+            this.ctx?.dispatch({
+              channel: 'clawlink',
+              id: historicalMsg.id,
+              from: historicalMsg.from,
+              text: historicalMsg.content,
+              topic: historicalMsg.topic,
+              timestamp: historicalMsg.timestamp,
+              isHistorical: true,
+            });
+          }
+        }
+        break;
+
+      case 'pong':
+        break;
+
+      case 'memory_update':
+        this.ctx?.logger?.debug(`[ClawLink] Memory updated: ${msg.key} by ${msg.from}`);
+        break;
+
+      case 'error':
+        this.ctx?.logger?.error(`[ClawLink] Server error: ${msg.code} - ${msg.message}`);
+        break;
+
+      case 'memory_result':
+        if (msg.mid && this.pendingMessages.has(msg.mid)) {
+          const resolve = this.pendingMessages.get(msg.mid);
+          this.pendingMessages.delete(msg.mid);
+          resolve(msg.value ?? null);
+        }
+        break;
+    }
+
+    for (const handler of this.messageHandlers) {
+      try {
+        handler(msg);
+      } catch (e) {
+        this.ctx?.logger?.error('[ClawLink] Handler error:', e);
+      }
+    }
+  }
+
+  send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      try {
+        this.ws.send(JSON.stringify(msg));
+      } catch (e) {
+        this.ctx?.logger?.error('[ClawLink] Failed to send message:', e);
+      }
+    } else {
+      this.ctx?.logger?.warn('[ClawLink] Cannot send: WebSocket not connected');
+    }
+  }
+
+  async sendMessage(topic, content) {
+    this.send({ type: 'message', topic, content });
+  }
+
+  async joinTopic(topic) {
+    this.topics.add(topic);
+    this.send({ type: 'join', topic });
+  }
+
+  async leaveTopic(topic) {
+    this.topics.delete(topic);
+    this.send({ type: 'leave', topic });
+  }
+
+  async writeMemory(key, value) {
+    this.send({ type: 'memory_write', key, value });
+  }
+
+  async readMemory(key) {
+    return new Promise((resolve) => {
+      const mid = Date.now().toString();
+      this.pendingMessages.set(mid, resolve);
+      this.send({ type: 'memory_read', key, mid });
+      
+      setTimeout(() => {
+        if (this.pendingMessages.has(mid)) {
+          this.pendingMessages.delete(mid);
+          resolve(null);
+        }
+      }, 5000);
+    });
+  }
+
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+
+  async shutdown() {
+    if (this.pingTimer) clearInterval(this.pingTimer);
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    
+    for (const topic of this.topics) {
+      this.send({ type: 'leave', topic });
+    }
+    
+    if (this.ws) {
+      this.ws.close(1000, 'Agent shutting down');
+    }
+  }
+}
+
+export default new ClawLinkChannel();

package/dist/openclaw.plugin.json

@@ -0,0 +1,61 @@
+{
+  "id": "clawlink",
+  "name": "ClawLink",
+  "description": "Connect to ClawLink Hub for topic-based multi-agent communication and shared memory",
+  "version": "0.1.0",
+  "channels": ["clawlink"],
+  "skills": ["./skills/clawlink"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": {
+        "type": "boolean",
+        "default": true,
+        "description": "Enable the ClawLink channel"
+      },
+      "hubUrl": {
+        "type": "string",
+        "description": "WebSocket URL of the ClawLink Hub (e.g., ws://vm153:8080)",
+        "default": "ws://localhost:8080"
+      },
+      "agentId": {
+        "type": "string",
+        "description": "Unique agent identifier for this OpenClaw instance"
+      },
+      "token": {
+        "type": "string",
+        "description": "Authentication token for the ClawLink Hub"
+      },
+      "autoJoin": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Topics to automatically join on startup"
+      },
+      "topics": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Alias for autoJoin (topics to subscribe to)"
+      }
+    },
+    "required": ["hubUrl", "agentId", "token"]
+  },
+  "uiHints": {
+    "hubUrl": {
+      "label": "Hub URL",
+      "placeholder": "ws://vm153:8080",
+      "help": "WebSocket endpoint of your ClawLink Hub"
+    },
+    "agentId": {
+      "label": "Agent ID",
+      "placeholder": "my-agent",
+      "help": "Unique name that identifies this agent in topics"
+    },
+    "token": {
+      "label": "Hub Token",
+      "placeholder": "ClawLink2026",
+      "sensitive": true,
+      "help": "Authentication token (get from Hub administrator)"
+    }
+  }
+}