@umimoney/clawdbot-relay-plugin 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,115 @@
+/**
+ * @umimoney/clawdbot-relay-plugin
+ *
+ * Clawdbot plugin for connecting to UMI relay server.
+ * Enables real-time chat visibility in UMI web UI.
+ */
+interface RelayConfig {
+    /** UMI relay server URL (default: wss://server.umi.app/ws/relay) */
+    relayUrl?: string;
+    /** UMI API key (starts with umi_) */
+    apiKey: string;
+    /** Agent version string */
+    agentVersion?: string;
+    /** Agent capabilities */
+    capabilities?: string[];
+    /** Reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Max reconnect attempts (default: 10) */
+    maxReconnectAttempts?: number;
+    /** Initial reconnect delay in ms (default: 1000) */
+    reconnectDelayMs?: number;
+    /** Max reconnect delay in ms (default: 30000) */
+    maxReconnectDelayMs?: number;
+}
+interface RelayMessage {
+    type: string;
+    id: string;
+    timestamp: number;
+    agentId?: string;
+    [key: string]: any;
+}
+interface MessageHandler {
+    (message: RelayMessage): void;
+}
+interface StateUpdate {
+    state: 'idle' | 'thinking' | 'executing' | 'waiting_approval';
+    speechBubble?: string | null;
+    currentTask?: {
+        type: string;
+        chain?: string;
+        description: string;
+    } | null;
+}
+declare class UmiRelayClient {
+    private ws;
+    private config;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private pingInterval;
+    private messageHandlers;
+    private agentId;
+    private isAuthenticated;
+    constructor(config: RelayConfig);
+    /**
+     * Connect to the relay server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the relay server
+     */
+    disconnect(): void;
+    /**
+     * Send a chat message through the relay
+     */
+    sendMessage(content: string, metadata?: Record<string, any>): void;
+    /**
+     * Update agent state (shown in UMI Town)
+     */
+    updateState(state: StateUpdate): void;
+    /**
+     * Request approval for a transaction
+     */
+    requestApproval(params: {
+        transactionId: string;
+        chain: string;
+        transactionType: string;
+        amountUsd: number;
+        description: string;
+        expiresAt: string;
+        transactionData: any;
+    }): void;
+    /**
+     * Register a message handler
+     */
+    onMessage(handler: MessageHandler): () => void;
+    /**
+     * Check if connected and authenticated
+     */
+    get isConnected(): boolean;
+    private authenticate;
+    private handleMessage;
+    private notifyHandlers;
+    private sendPong;
+    private startPing;
+    private cleanup;
+    private scheduleReconnect;
+    private generateId;
+}
+interface ClawdbotContext {
+    injectMessage: (params: {
+        channel: string;
+        text: string;
+        metadata?: any;
+    }) => void;
+    registerSend: (channel: string, handler: (response: any) => void) => void;
+}
+interface ClawdbotPlugin {
+    id: string;
+    type: 'channel';
+    start: (ctx: ClawdbotContext, config: RelayConfig) => Promise<void>;
+    stop?: () => void;
+}
+declare const plugin: ClawdbotPlugin;
+
+export { type ClawdbotContext, type ClawdbotPlugin, type MessageHandler, type RelayConfig, type RelayMessage, type StateUpdate, UmiRelayClient, plugin as default, plugin as umiRelayPlugin };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @umimoney/clawdbot-relay-plugin
+ *
+ * Clawdbot plugin for connecting to UMI relay server.
+ * Enables real-time chat visibility in UMI web UI.
+ */
+interface RelayConfig {
+    /** UMI relay server URL (default: wss://server.umi.app/ws/relay) */
+    relayUrl?: string;
+    /** UMI API key (starts with umi_) */
+    apiKey: string;
+    /** Agent version string */
+    agentVersion?: string;
+    /** Agent capabilities */
+    capabilities?: string[];
+    /** Reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Max reconnect attempts (default: 10) */
+    maxReconnectAttempts?: number;
+    /** Initial reconnect delay in ms (default: 1000) */
+    reconnectDelayMs?: number;
+    /** Max reconnect delay in ms (default: 30000) */
+    maxReconnectDelayMs?: number;
+}
+interface RelayMessage {
+    type: string;
+    id: string;
+    timestamp: number;
+    agentId?: string;
+    [key: string]: any;
+}
+interface MessageHandler {
+    (message: RelayMessage): void;
+}
+interface StateUpdate {
+    state: 'idle' | 'thinking' | 'executing' | 'waiting_approval';
+    speechBubble?: string | null;
+    currentTask?: {
+        type: string;
+        chain?: string;
+        description: string;
+    } | null;
+}
+declare class UmiRelayClient {
+    private ws;
+    private config;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private pingInterval;
+    private messageHandlers;
+    private agentId;
+    private isAuthenticated;
+    constructor(config: RelayConfig);
+    /**
+     * Connect to the relay server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the relay server
+     */
+    disconnect(): void;
+    /**
+     * Send a chat message through the relay
+     */
+    sendMessage(content: string, metadata?: Record<string, any>): void;
+    /**
+     * Update agent state (shown in UMI Town)
+     */
+    updateState(state: StateUpdate): void;
+    /**
+     * Request approval for a transaction
+     */
+    requestApproval(params: {
+        transactionId: string;
+        chain: string;
+        transactionType: string;
+        amountUsd: number;
+        description: string;
+        expiresAt: string;
+        transactionData: any;
+    }): void;
+    /**
+     * Register a message handler
+     */
+    onMessage(handler: MessageHandler): () => void;
+    /**
+     * Check if connected and authenticated
+     */
+    get isConnected(): boolean;
+    private authenticate;
+    private handleMessage;
+    private notifyHandlers;
+    private sendPong;
+    private startPing;
+    private cleanup;
+    private scheduleReconnect;
+    private generateId;
+}
+interface ClawdbotContext {
+    injectMessage: (params: {
+        channel: string;
+        text: string;
+        metadata?: any;
+    }) => void;
+    registerSend: (channel: string, handler: (response: any) => void) => void;
+}
+interface ClawdbotPlugin {
+    id: string;
+    type: 'channel';
+    start: (ctx: ClawdbotContext, config: RelayConfig) => Promise<void>;
+    stop?: () => void;
+}
+declare const plugin: ClawdbotPlugin;
+
+export { type ClawdbotContext, type ClawdbotPlugin, type MessageHandler, type RelayConfig, type RelayMessage, type StateUpdate, UmiRelayClient, plugin as default, plugin as umiRelayPlugin };

package/dist/index.js

@@ -0,0 +1,313 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  UmiRelayClient: () => UmiRelayClient,
+  default: () => index_default,
+  umiRelayPlugin: () => plugin
+});
+module.exports = __toCommonJS(index_exports);
+var import_ws = __toESM(require("ws"));
+var UmiRelayClient = class {
+  constructor(config) {
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimeout = null;
+    this.pingInterval = null;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.agentId = null;
+    this.isAuthenticated = false;
+    this.config = {
+      relayUrl: config.relayUrl || "wss://server.umi.app/ws/relay",
+      apiKey: config.apiKey,
+      agentVersion: config.agentVersion || "1.0.0",
+      capabilities: config.capabilities || ["chat"],
+      autoReconnect: config.autoReconnect ?? true,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      reconnectDelayMs: config.reconnectDelayMs ?? 1e3,
+      maxReconnectDelayMs: config.maxReconnectDelayMs ?? 3e4
+    };
+  }
+  /**
+   * Connect to the relay server
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        const url = `${this.config.relayUrl}?type=agent`;
+        console.log(`[UmiRelay] Connecting to ${url}`);
+        this.ws = new import_ws.default(url);
+        this.ws.on("open", () => {
+          console.log("[UmiRelay] Connected, authenticating...");
+          this.authenticate();
+        });
+        this.ws.on("message", (data) => {
+          try {
+            const message = JSON.parse(data.toString());
+            this.handleMessage(message, resolve, reject);
+          } catch (error) {
+            console.error("[UmiRelay] Failed to parse message:", error);
+          }
+        });
+        this.ws.on("close", () => {
+          console.log("[UmiRelay] Disconnected");
+          this.cleanup();
+          this.scheduleReconnect();
+        });
+        this.ws.on("error", (error) => {
+          console.error("[UmiRelay] WebSocket error:", error);
+          if (!this.isAuthenticated) {
+            reject(error);
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the relay server
+   */
+  disconnect() {
+    this.config.autoReconnect = false;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Send a chat message through the relay
+   */
+  sendMessage(content, metadata) {
+    if (!this.ws || this.ws.readyState !== import_ws.default.OPEN || !this.agentId) {
+      console.error("[UmiRelay] Cannot send message - not connected");
+      return;
+    }
+    const message = {
+      type: "agent:message",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId,
+      content,
+      metadata
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Update agent state (shown in UMI Town)
+   */
+  updateState(state) {
+    if (!this.ws || this.ws.readyState !== import_ws.default.OPEN || !this.agentId) {
+      console.error("[UmiRelay] Cannot update state - not connected");
+      return;
+    }
+    const message = {
+      type: "agent:state",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId,
+      ...state
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Request approval for a transaction
+   */
+  requestApproval(params) {
+    if (!this.ws || this.ws.readyState !== import_ws.default.OPEN || !this.agentId) {
+      console.error("[UmiRelay] Cannot request approval - not connected");
+      return;
+    }
+    const message = {
+      type: "agent:approval_request",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId,
+      ...params
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Register a message handler
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Check if connected and authenticated
+   */
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === import_ws.default.OPEN && this.isAuthenticated;
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  authenticate() {
+    if (!this.ws) return;
+    const authMessage = {
+      type: "agent:auth",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      apiKey: this.config.apiKey,
+      agentVersion: this.config.agentVersion,
+      capabilities: this.config.capabilities
+    };
+    this.ws.send(JSON.stringify(authMessage));
+  }
+  handleMessage(message, resolveConnect, rejectConnect) {
+    switch (message.type) {
+      case "platform:auth_success":
+        this.isAuthenticated = true;
+        this.agentId = message.agentId ?? null;
+        this.reconnectAttempts = 0;
+        console.log(`[UmiRelay] Authenticated as ${message.agentName} (${message.agentId})`);
+        this.startPing();
+        resolveConnect?.();
+        break;
+      case "platform:auth_failure":
+        console.error(`[UmiRelay] Authentication failed: ${message.error}`);
+        this.config.autoReconnect = false;
+        rejectConnect?.(new Error(message.error));
+        break;
+      case "platform:message":
+        console.log(`[UmiRelay] Received message: ${message.content}`);
+        this.notifyHandlers(message);
+        break;
+      case "platform:task_approve":
+        console.log(`[UmiRelay] Task approved: ${message.transactionId}`);
+        this.notifyHandlers(message);
+        break;
+      case "platform:task_reject":
+        console.log(`[UmiRelay] Task rejected: ${message.transactionId}`);
+        this.notifyHandlers(message);
+        break;
+      case "platform:ping":
+        this.sendPong();
+        break;
+      default:
+        this.notifyHandlers(message);
+    }
+  }
+  notifyHandlers(message) {
+    this.messageHandlers.forEach((handler) => {
+      try {
+        handler(message);
+      } catch (error) {
+        console.error("[UmiRelay] Handler error:", error);
+      }
+    });
+  }
+  sendPong() {
+    if (!this.ws || this.ws.readyState !== import_ws.default.OPEN) return;
+    this.ws.send(JSON.stringify({
+      type: "agent:pong",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId
+    }));
+  }
+  startPing() {
+  }
+  cleanup() {
+    this.isAuthenticated = false;
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  scheduleReconnect() {
+    if (!this.config.autoReconnect) return;
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      console.error("[UmiRelay] Max reconnect attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.config.reconnectDelayMs * Math.pow(2, this.reconnectAttempts - 1),
+      this.config.maxReconnectDelayMs
+    );
+    console.log(`[UmiRelay] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimeout = setTimeout(() => {
+      this.connect().catch((error) => {
+        console.error("[UmiRelay] Reconnect failed:", error);
+      });
+    }, delay);
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+};
+var relayClient = null;
+var plugin = {
+  id: "umi-relay",
+  type: "channel",
+  async start(ctx, config) {
+    relayClient = new UmiRelayClient(config);
+    relayClient.onMessage((message) => {
+      if (message.type === "platform:message") {
+        ctx.injectMessage({
+          channel: "umi",
+          text: message.content,
+          metadata: {
+            userId: message.userId,
+            agentId: message.agentId
+          }
+        });
+      }
+    });
+    ctx.registerSend("umi", (response) => {
+      if (relayClient?.isConnected) {
+        relayClient.sendMessage(response.text || response.content, response.metadata);
+      }
+    });
+    await relayClient.connect();
+    console.log("[UmiRelay] Plugin started");
+  },
+  stop() {
+    if (relayClient) {
+      relayClient.disconnect();
+      relayClient = null;
+    }
+    console.log("[UmiRelay] Plugin stopped");
+  }
+};
+var index_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UmiRelayClient,
+  umiRelayPlugin
+});

package/dist/index.mjs

@@ -0,0 +1,277 @@
+// src/index.ts
+import WebSocket from "ws";
+var UmiRelayClient = class {
+  constructor(config) {
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimeout = null;
+    this.pingInterval = null;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.agentId = null;
+    this.isAuthenticated = false;
+    this.config = {
+      relayUrl: config.relayUrl || "wss://server.umi.app/ws/relay",
+      apiKey: config.apiKey,
+      agentVersion: config.agentVersion || "1.0.0",
+      capabilities: config.capabilities || ["chat"],
+      autoReconnect: config.autoReconnect ?? true,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      reconnectDelayMs: config.reconnectDelayMs ?? 1e3,
+      maxReconnectDelayMs: config.maxReconnectDelayMs ?? 3e4
+    };
+  }
+  /**
+   * Connect to the relay server
+   */
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        const url = `${this.config.relayUrl}?type=agent`;
+        console.log(`[UmiRelay] Connecting to ${url}`);
+        this.ws = new WebSocket(url);
+        this.ws.on("open", () => {
+          console.log("[UmiRelay] Connected, authenticating...");
+          this.authenticate();
+        });
+        this.ws.on("message", (data) => {
+          try {
+            const message = JSON.parse(data.toString());
+            this.handleMessage(message, resolve, reject);
+          } catch (error) {
+            console.error("[UmiRelay] Failed to parse message:", error);
+          }
+        });
+        this.ws.on("close", () => {
+          console.log("[UmiRelay] Disconnected");
+          this.cleanup();
+          this.scheduleReconnect();
+        });
+        this.ws.on("error", (error) => {
+          console.error("[UmiRelay] WebSocket error:", error);
+          if (!this.isAuthenticated) {
+            reject(error);
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the relay server
+   */
+  disconnect() {
+    this.config.autoReconnect = false;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Send a chat message through the relay
+   */
+  sendMessage(content, metadata) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.agentId) {
+      console.error("[UmiRelay] Cannot send message - not connected");
+      return;
+    }
+    const message = {
+      type: "agent:message",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId,
+      content,
+      metadata
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Update agent state (shown in UMI Town)
+   */
+  updateState(state) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.agentId) {
+      console.error("[UmiRelay] Cannot update state - not connected");
+      return;
+    }
+    const message = {
+      type: "agent:state",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId,
+      ...state
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Request approval for a transaction
+   */
+  requestApproval(params) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.agentId) {
+      console.error("[UmiRelay] Cannot request approval - not connected");
+      return;
+    }
+    const message = {
+      type: "agent:approval_request",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId,
+      ...params
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Register a message handler
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Check if connected and authenticated
+   */
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.isAuthenticated;
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  authenticate() {
+    if (!this.ws) return;
+    const authMessage = {
+      type: "agent:auth",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      apiKey: this.config.apiKey,
+      agentVersion: this.config.agentVersion,
+      capabilities: this.config.capabilities
+    };
+    this.ws.send(JSON.stringify(authMessage));
+  }
+  handleMessage(message, resolveConnect, rejectConnect) {
+    switch (message.type) {
+      case "platform:auth_success":
+        this.isAuthenticated = true;
+        this.agentId = message.agentId ?? null;
+        this.reconnectAttempts = 0;
+        console.log(`[UmiRelay] Authenticated as ${message.agentName} (${message.agentId})`);
+        this.startPing();
+        resolveConnect?.();
+        break;
+      case "platform:auth_failure":
+        console.error(`[UmiRelay] Authentication failed: ${message.error}`);
+        this.config.autoReconnect = false;
+        rejectConnect?.(new Error(message.error));
+        break;
+      case "platform:message":
+        console.log(`[UmiRelay] Received message: ${message.content}`);
+        this.notifyHandlers(message);
+        break;
+      case "platform:task_approve":
+        console.log(`[UmiRelay] Task approved: ${message.transactionId}`);
+        this.notifyHandlers(message);
+        break;
+      case "platform:task_reject":
+        console.log(`[UmiRelay] Task rejected: ${message.transactionId}`);
+        this.notifyHandlers(message);
+        break;
+      case "platform:ping":
+        this.sendPong();
+        break;
+      default:
+        this.notifyHandlers(message);
+    }
+  }
+  notifyHandlers(message) {
+    this.messageHandlers.forEach((handler) => {
+      try {
+        handler(message);
+      } catch (error) {
+        console.error("[UmiRelay] Handler error:", error);
+      }
+    });
+  }
+  sendPong() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify({
+      type: "agent:pong",
+      id: this.generateId(),
+      timestamp: Date.now(),
+      agentId: this.agentId
+    }));
+  }
+  startPing() {
+  }
+  cleanup() {
+    this.isAuthenticated = false;
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  scheduleReconnect() {
+    if (!this.config.autoReconnect) return;
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      console.error("[UmiRelay] Max reconnect attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.config.reconnectDelayMs * Math.pow(2, this.reconnectAttempts - 1),
+      this.config.maxReconnectDelayMs
+    );
+    console.log(`[UmiRelay] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.reconnectTimeout = setTimeout(() => {
+      this.connect().catch((error) => {
+        console.error("[UmiRelay] Reconnect failed:", error);
+      });
+    }, delay);
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+};
+var relayClient = null;
+var plugin = {
+  id: "umi-relay",
+  type: "channel",
+  async start(ctx, config) {
+    relayClient = new UmiRelayClient(config);
+    relayClient.onMessage((message) => {
+      if (message.type === "platform:message") {
+        ctx.injectMessage({
+          channel: "umi",
+          text: message.content,
+          metadata: {
+            userId: message.userId,
+            agentId: message.agentId
+          }
+        });
+      }
+    });
+    ctx.registerSend("umi", (response) => {
+      if (relayClient?.isConnected) {
+        relayClient.sendMessage(response.text || response.content, response.metadata);
+      }
+    });
+    await relayClient.connect();
+    console.log("[UmiRelay] Plugin started");
+  },
+  stop() {
+    if (relayClient) {
+      relayClient.disconnect();
+      relayClient = null;
+    }
+    console.log("[UmiRelay] Plugin stopped");
+  }
+};
+var index_default = plugin;
+export {
+  UmiRelayClient,
+  index_default as default,
+  plugin as umiRelayPlugin
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@umimoney/clawdbot-relay-plugin",
+  "version": "0.1.0",
+  "description": "Clawdbot plugin for connecting to UMI relay server",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "clawdbot",
+    "umi",
+    "relay",
+    "agent",
+    "plugin"
+  ],
+  "author": "UMI Labs",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/claude-code"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.10",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/claude-code": "*"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/claude-code": {
+      "optional": true
+    }
+  }
+}