message-nexus 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -36,7 +36,7 @@ __export(index_exports, {
   PostMessageDriver: () => PostMessageDriver,
   WebSocketDriver: () => WebSocketDriver,
   createEmitter: () => createEmitter,
-  default: () => MessageBridge
+  default: () => MessageNexus
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -94,7 +94,7 @@ var BroadcastDriver = class extends BaseDriver {
 };
 
 // src/drivers/MittDriver.ts
-var eventIndicator = "message_bridge_message_event";
+var eventIndicator = "message_nexus_message_event";
 var MittDriver = class extends BaseDriver {
   constructor(emitter) {
     super();
@@ -163,11 +163,26 @@ var PostMessageDriver = class extends BaseDriver {
 };
 
 // src/utils/logger.ts
+function isLogger(value) {
+  if (value == null || typeof value !== "object") return false;
+  const logger = value;
+  return typeof logger.addHandler === "function" && typeof logger.setMinLevel === "function" && typeof logger.enable === "function" && typeof logger.disable === "function" && typeof logger.isEnabled === "function" && typeof logger.debug === "function" && typeof logger.info === "function" && typeof logger.warn === "function" && typeof logger.error === "function";
+}
 var Logger = class {
-  constructor(context, minLevel = "info" /* INFO */) {
+  constructor(context, minLevel = "info" /* INFO */, enabled = false) {
     this.handlers = [];
     this.context = context;
     this.minLevel = minLevel;
+    this.enabled = enabled;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  isEnabled() {
+    return this.enabled;
   }
   addHandler(handler) {
     this.handlers.push(handler);
@@ -180,7 +195,7 @@ var Logger = class {
     return levels.indexOf(level) >= levels.indexOf(this.minLevel);
   }
   log(level, message, metadata) {
-    if (!this.shouldLog(level)) return;
+    if (!this.enabled || !this.shouldLog(level)) return;
     const entry = {
       level,
       timestamp: Date.now(),
@@ -203,9 +218,19 @@ var Logger = class {
     this.log("error" /* ERROR */, message, metadata);
   }
 };
+function genTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toLocaleTimeString("zh-CN", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3
+  });
+}
 var createConsoleHandler = () => {
   return (entry) => {
-    const timestamp = new Date(entry.timestamp).toISOString();
+    const timestamp = genTimestamp();
     const prefix = `[${timestamp}] [${entry.level.toUpperCase()}] [${entry.context || "app"}]`;
     const logFn = entry.level === "debug" /* DEBUG */ ? console.debug : entry.level === "info" /* INFO */ ? console.info : entry.level === "warn" /* WARN */ ? console.warn : console.error;
     if (entry.metadata) {
@@ -231,13 +256,16 @@ var WebSocketDriver = class extends BaseDriver {
     this.retryInterval = (typeof options.reconnect === "object" ? options.reconnect.retryInterval : void 0) ?? 5e3;
     this.logger = options.logger || new Logger("WebSocketDriver");
     this.logger.addHandler(createConsoleHandler());
+    this.onStatusChange = options.onStatusChange;
     this.connect();
   }
   connect() {
+    this.onStatusChange?.("connecting");
     this.ws = new WebSocket(this.url);
     this.ws.addEventListener("open", () => {
       this.logger.info("WebSocket connected", { url: this.url });
       this.retryCount = 0;
+      this.onStatusChange?.("connected");
     });
     this.ws.addEventListener("message", (event) => {
       try {
@@ -255,6 +283,7 @@ var WebSocketDriver = class extends BaseDriver {
     });
     this.ws.addEventListener("error", (event) => {
       this.logger.error("WebSocket error", { event });
+      this.onStatusChange?.("error");
     });
     this.ws.addEventListener("close", () => {
       this.logger.info("WebSocket connection closed", {
@@ -264,6 +293,8 @@ var WebSocketDriver = class extends BaseDriver {
       });
       if (!this.isManuallyClosed && this.reconnectEnabled && this.retryCount < this.maxRetries) {
         this.scheduleReconnect();
+      } else {
+        this.onStatusChange?.("disconnected");
       }
     });
   }
@@ -276,6 +307,7 @@ var WebSocketDriver = class extends BaseDriver {
       maxRetries: this.maxRetries,
       url: this.url
     });
+    this.onStatusChange?.("connecting");
     this.reconnectTimer = window.setTimeout(() => {
       this.connect();
     }, delay);
@@ -306,6 +338,7 @@ var WebSocketDriver = class extends BaseDriver {
       this.ws.close();
       this.ws = null;
     }
+    this.onStatusChange?.("disconnected");
   }
   destroy() {
     this.close();
@@ -320,7 +353,7 @@ function createEmitter() {
 }
 
 // src/index.ts
-var MessageBridge = class {
+var MessageNexus = class {
   constructor(driver, options) {
     this.cleanupInterval = null;
     this.messageQueue = [];
@@ -339,45 +372,45 @@ var MessageBridge = class {
     this.driver = driver;
     this.instanceId = options?.instanceId || crypto.randomUUID();
     this.timeout = options?.timeout ?? 1e4;
-    this.logger = options?.logger || new Logger("MessageBridge");
-    this.logger.addHandler(createConsoleHandler());
+    if (options?.logger && isLogger(options.logger)) {
+      this.logger = options.logger;
+    } else {
+      this.logger = new Logger("MessageNexus");
+    }
+    const loggerEnabled = options?.loggerEnabled ?? false;
+    if (loggerEnabled) {
+      this.logger.enable();
+      this.logger.addHandler(createConsoleHandler());
+      this.logger.info("MessageNexus initialized", {
+        instanceId: this.instanceId,
+        timeout: this.timeout
+      });
+    }
     this.pendingTasks = /* @__PURE__ */ new Map();
-    this.incomingMessages = /* @__PURE__ */ new Map();
-    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.invokeHandlers = /* @__PURE__ */ new Map();
+    this.notificationHandlers = /* @__PURE__ */ new Map();
     this.cleanupInterval = null;
     this.driver.onMessage = (data) => this._handleIncoming(data);
-    this.logger.info("MessageBridge initialized", {
-      instanceId: this.instanceId,
-      timeout: this.timeout
-    });
-    this.cleanupInterval = window.setInterval(() => {
-      const now = Date.now();
-      for (const [id, msg] of this.incomingMessages.entries()) {
-        if (now - msg.timestamp > this.timeout * 2) {
-          this.incomingMessages.delete(id);
-        }
-      }
-    }, 6e4);
   }
-  async request(typeOrOptions) {
+  async invoke(methodOrOptions) {
     const id = crypto.randomUUID();
-    let type;
-    let payload;
+    let method;
+    let params;
     let to;
     let metadata;
     let timeout;
     let retryCount = 0;
     let retryDelay = 1e3;
-    if (typeof typeOrOptions === "string") {
-      type = typeOrOptions;
-      payload = void 0;
+    if (typeof methodOrOptions === "string") {
+      method = methodOrOptions;
+      params = void 0;
       to = void 0;
       metadata = {};
       timeout = this.timeout;
     } else {
-      const opts = typeOrOptions;
-      type = opts.type;
-      payload = opts.payload;
+      const opts = methodOrOptions;
+      method = opts.method;
+      params = opts.params;
       to = opts.to;
       metadata = opts.metadata || {};
       timeout = opts.timeout ?? this.timeout;
@@ -390,16 +423,20 @@ var MessageBridge = class {
           this.pendingTasks.delete(id);
           this.metrics.messagesFailed++;
           this.metrics.pendingMessages--;
-          reject(new Error(`Message timeout: ${type} (${id})`));
+          reject(new Error(`Message timeout: ${method} (${id})`));
         }, timeout);
         this.pendingTasks.set(id, { resolve, reject, timer, timestamp: Date.now() });
+        const rpcRequest = {
+          jsonrpc: "2.0",
+          method,
+          params,
+          id
+        };
         const message = {
-          id,
-          type,
-          payload,
           from: this.instanceId,
           to,
-          metadata: { ...metadata, timestamp: Date.now() }
+          metadata: { ...metadata, timestamp: Date.now() },
+          payload: rpcRequest
         };
         this._sendMessage(message);
       }).catch((error) => {
@@ -416,20 +453,26 @@ var MessageBridge = class {
     return attempt(0);
   }
   _sendMessage(message) {
+    const payload = message.payload;
+    const isRequest = "method" in payload;
+    const messageId = "id" in payload ? String(payload.id) : void 0;
+    const typeOrMethod = isRequest ? payload.method : "RESPONSE";
     try {
       this.driver.send(message);
       this.metrics.messagesSent++;
-      this.metrics.pendingMessages++;
-      this.logger.debug("Message sent", { messageId: message.id, type: message.type });
+      if (isRequest && messageId !== void 0) {
+        this.metrics.pendingMessages++;
+      }
+      this.logger.debug("Message sent", { messageId, type: typeOrMethod });
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       this.metrics.messagesFailed++;
-      this.logger.error("Failed to send message", { error: err.message, messageId: message.id });
+      this.logger.error("Failed to send message", { error: err.message, messageId });
       this.errorHandler?.(err, { message });
       if (this.messageQueue.length < this.maxQueueSize) {
         this.messageQueue.push(message);
         this.logger.debug("Message queued", {
-          messageId: message.id,
+          messageId,
           queueSize: this.messageQueue.length + 1
         });
       } else {
@@ -462,55 +505,145 @@ var MessageBridge = class {
       }
     }
   }
+  notify(methodOrOptions) {
+    let method;
+    let params;
+    let to;
+    let metadata;
+    if (typeof methodOrOptions === "string") {
+      method = methodOrOptions;
+      params = void 0;
+      to = void 0;
+      metadata = {};
+    } else {
+      const opts = methodOrOptions;
+      method = opts.method;
+      params = opts.params;
+      to = opts.to;
+      metadata = opts.metadata || {};
+    }
+    const rpcNotification = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    const message = {
+      from: this.instanceId,
+      to,
+      metadata: { ...metadata, timestamp: Date.now() },
+      payload: rpcNotification
+    };
+    this._sendMessage(message);
+  }
   _validateMessage(data) {
     if (!data || typeof data !== "object") return false;
-    const msg = data;
-    if (typeof msg.id !== "string") return false;
-    if (typeof msg.type !== "string") return false;
-    if (msg.from && typeof msg.from !== "string") return false;
-    if (msg.to && typeof msg.to !== "string") return false;
-    if (msg.metadata && typeof msg.metadata !== "object") return false;
-    if (msg.isResponse !== void 0 && typeof msg.isResponse !== "boolean") return false;
+    const env = data;
+    if (typeof env.from !== "string") return false;
+    if (env.to !== void 0 && typeof env.to !== "string") return false;
+    if (env.metadata !== void 0 && typeof env.metadata !== "object") return false;
+    const payload = env.payload;
+    if (!payload || typeof payload !== "object") return false;
+    if (payload.jsonrpc !== "2.0") return false;
+    const isRequest = "method" in payload;
+    const isResponse = "result" in payload || "error" in payload;
+    if (!isRequest && !isResponse) return false;
     return true;
   }
-  _handleIncoming(data) {
+  async _handleIncoming(data) {
     if (!this._validateMessage(data)) {
       this.logger.error("Invalid message format received", { data });
       this.errorHandler?.(new Error("Invalid message format received"), { data });
       this.metrics.messagesFailed++;
       return;
     }
-    const { id, to, type, payload, isResponse, error, from } = data;
-    if (to && to !== this.instanceId) {
+    const envelope = data;
+    const payload = envelope.payload;
+    if (envelope.to && envelope.to !== this.instanceId) {
       this.logger.debug("Message filtered: not for this instance", {
-        messageId: id,
-        to,
+        messageId: "id" in payload ? payload.id : void 0,
+        to: envelope.to,
         instanceId: this.instanceId
       });
       return;
     }
-    if (isResponse && this.pendingTasks.has(id)) {
-      const { resolve, reject, timer, timestamp } = this.pendingTasks.get(id);
-      clearTimeout(timer);
-      this.pendingTasks.delete(id);
-      const latency = Date.now() - timestamp;
-      this.metrics.messagesReceived++;
-      this.metrics.pendingMessages--;
-      this.metrics.totalLatency += latency;
-      this.metrics.averageLatency = this.metrics.totalLatency / this.metrics.messagesReceived;
-      this.logger.debug("Response received", { messageId: id, latency });
-      if (error) reject(error);
-      else resolve(payload);
-      this._notifyMetrics();
+    if ("result" in payload || "error" in payload) {
+      const response = payload;
+      const id = String(response.id);
+      if (this.pendingTasks.has(id)) {
+        const { resolve, reject, timer, timestamp } = this.pendingTasks.get(id);
+        clearTimeout(timer);
+        this.pendingTasks.delete(id);
+        const latency = Date.now() - timestamp;
+        this.metrics.messagesReceived++;
+        this.metrics.pendingMessages--;
+        this.metrics.totalLatency += latency;
+        this.metrics.averageLatency = this.metrics.totalLatency / this.metrics.messagesReceived;
+        this.logger.debug("Response received", { messageId: id, latency });
+        if (response.error) {
+          const err = new Error(response.error.message);
+          err.code = response.error.code;
+          err.data = response.error.data;
+          reject(err);
+        } else {
+          resolve(response.result);
+        }
+        this._notifyMetrics();
+      } else {
+        this.logger.warn("Orphaned response received", { messageId: id });
+      }
       return;
     }
-    if (isResponse) {
-      this.logger.warn("Orphaned response received", { messageId: id });
-      return;
+    if ("method" in payload) {
+      if ("id" in payload) {
+        const request = payload;
+        const id = String(request.id);
+        this.logger.debug("Invoke message received", {
+          messageId: id,
+          type: request.method,
+          from: envelope.from
+        });
+        const context = {
+          messageId: id,
+          from: envelope.from,
+          to: envelope.to,
+          metadata: envelope.metadata
+        };
+        const handler = this.invokeHandlers.get(request.method);
+        if (handler) {
+          try {
+            const result = await handler(request.params, context);
+            this._reply(id, envelope.from, result);
+          } catch (error) {
+            this._replyError(id, envelope.from, error);
+          }
+        } else {
+          const err = new Error(`Method not found: ${request.method}`);
+          err.code = -32601;
+          this._replyError(id, envelope.from, err);
+        }
+      } else {
+        const notification = payload;
+        this.logger.debug("Notification message received", {
+          type: notification.method,
+          from: envelope.from
+        });
+        const context = {
+          from: envelope.from,
+          to: envelope.to,
+          metadata: envelope.metadata
+        };
+        const handlers = this.notificationHandlers.get(notification.method);
+        if (handlers) {
+          handlers.forEach((handler) => {
+            try {
+              handler(notification.params, context);
+            } catch (error) {
+              this.logger.error("Error in notification handler", { error: String(error) });
+            }
+          });
+        }
+      }
     }
-    this.logger.debug("Command message received", { messageId: id, type, from });
-    this.incomingMessages.set(id, { from, type, timestamp: Date.now() });
-    this.messageHandlers.forEach((handler) => handler(data));
   }
   getMetrics() {
     return { ...this.metrics, pendingMessages: this.pendingTasks.size };
@@ -523,30 +656,65 @@ var MessageBridge = class {
     const metrics = this.getMetrics();
     this.metricsCallbacks.forEach((callback) => callback(metrics));
   }
-  onCommand(handler) {
-    this.messageHandlers.add(handler);
-    return () => this.messageHandlers.delete(handler);
+  handle(method, handler) {
+    if (this.invokeHandlers.has(method)) {
+      this.logger.warn(`Overriding existing handler for method: ${method}`);
+    }
+    this.invokeHandlers.set(method, handler);
+    return () => this.invokeHandlers.delete(method);
+  }
+  removeHandler(method) {
+    this.invokeHandlers.delete(method);
   }
-  reply(messageId, payload, error) {
-    const incoming = this.incomingMessages.get(messageId);
-    if (!incoming) {
-      throw new Error(`Message not found: ${messageId}`);
+  onNotification(method, handler) {
+    if (!this.notificationHandlers.has(method)) {
+      this.notificationHandlers.set(method, /* @__PURE__ */ new Set());
+    }
+    this.notificationHandlers.get(method).add(handler);
+    return () => this.offNotification(method, handler);
+  }
+  offNotification(method, handler) {
+    const handlers = this.notificationHandlers.get(method);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.notificationHandlers.delete(method);
+      }
     }
-    const responsePayload = payload;
-    const responseError = error;
-    this.driver.send({
+  }
+  _reply(messageId, to, payload) {
+    const rpcResponse = {
+      jsonrpc: "2.0",
       id: messageId,
-      type: `${incoming.type}_RESPONSE`,
-      payload: responsePayload,
-      error: responseError,
-      isResponse: true,
+      result: payload
+    };
+    const message = {
       from: this.instanceId,
-      to: incoming.from
-    });
-    this.incomingMessages.delete(messageId);
+      to,
+      payload: rpcResponse
+    };
+    this.driver.send(message);
+  }
+  _replyError(messageId, to, error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const rpcResponse = {
+      jsonrpc: "2.0",
+      id: messageId,
+      error: {
+        code: err.code || -32e3,
+        message: err.message,
+        data: err.data
+      }
+    };
+    const message = {
+      from: this.instanceId,
+      to,
+      payload: rpcResponse
+    };
+    this.driver.send(message);
   }
   destroy() {
-    this.logger.info("MessageBridge destroying", {
+    this.logger.info("MessageNexus destroying", {
       instanceId: this.instanceId,
       pendingMessages: this.pendingTasks.size,
       queuedMessages: this.messageQueue.length,
@@ -557,7 +725,8 @@ var MessageBridge = class {
       clearInterval(this.cleanupInterval);
       this.cleanupInterval = null;
     }
-    this.messageHandlers.clear();
+    this.invokeHandlers.clear();
+    this.notificationHandlers.clear();
     this.metricsCallbacks.clear();
   }
 };