@lingyao037/openclaw-lingyao-cli 1.3.2 → 1.3.4

package/cli.mjs

@@ -38,20 +38,19 @@ const NC = '\x1b[0m';
 function getMachineId() {
   try {
     const interfaces = os.networkInterfaces();
-    const macs = [];
+    const macSet = new Set();
 
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;
       for (const alias of iface) {
         if (!alias.internal && alias.mac && alias.mac !== '00:00:00:00:00:00') {
-          macs.push(alias.mac);
+          macSet.add(alias.mac);
         }
       }
     }
 
-    if (macs.length > 0) {
-      macs.sort();
-      const macStr = macs.join('');
+    if (macSet.size > 0) {
+      const macStr = [...macSet].sort().join('');
       // MD5 哈希，与 orchestrator.ts 保持一致
       return createHash('md5').update(macStr).digest('hex').substring(0, 8);
     }

package/dist/index.d.ts

@@ -5,7 +5,13 @@ import { c as LingyaoConfig } from './types-BZMU9mea.js';
 export { A as AckRequest, b as DeviceInfo, D as DeviceToken, d as DiarySyncPayload, F as FailedEntry, H as HealthStatus, e as LINGYAO_SERVER_URL, a as LingyaoAccount, f as LingyaoAccountConfig, g as LingyaoMessage, L as LingyaoRuntime, M as MemorySyncPayload, h as MessageType, N as NotifyAction, i as NotifyPayload, j as NotifyRequest, P as PairingCode, k as PairingConfirmRequest, l as PairingConfirmResponse, m as PollRequest, n as PollResponse, Q as QueuedMessage, S as SyncRequest, o as SyncResponse, T as TokenRefreshRequest, p as TokenRefreshResponse, W as WebSocketConnection, q as getLingyaoGatewayWsUrl } from './types-BZMU9mea.js';
 
 /**
- * Agent message format - messages passed directly to Agent
+ * Agent message types — used for type-safe message passing.
+ *
+ * NOTE: MessageProcessor has been removed. Inbound messages are now dispatched
+ * directly via SDK's dispatchInboundDirectDmWithRuntime in orchestrator.ts.
+ */
+/**
+ * Agent message format - messages passed to Agent
  */
 interface AgentMessage {
     id: string;

package/dist/index.js

@@ -156,7 +156,10 @@ function createGatewayAdapter(getOrchestrator2) {
         throw new Error("Orchestrator not initialized. Ensure setRuntime was called.");
       }
       ctx.log?.info(`Starting account "${ctx.accountId}"`);
-      await orchestrator2.start(ctx.account);
+      await orchestrator2.start(ctx.account, {
+        channelRuntime: ctx.channelRuntime,
+        cfg: ctx.cfg
+      });
       ctx.log?.info(`Account "${ctx.accountId}" started successfully`);
     },
     async stopAccount(ctx) {
@@ -443,6 +446,9 @@ function resolveLingyaoWsHeartbeatIntervalMs(account, httpClient) {
   return Math.max(MIN_MS, Math.min(ms, MAX_MS));
 }
 
+// src/orchestrator.ts
+import { dispatchInboundDirectDmWithRuntime } from "openclaw/plugin-sdk/channel-inbound";
+
 // src/server-client.ts
 import axios from "axios";
 function isAxiosError(error) {
@@ -1403,60 +1409,6 @@ var AccountManager = class {
   }
 };
 
-// src/bot.ts
-var MessageProcessor = class {
-  runtime;
-  messageHandler = null;
-  constructor(runtime) {
-    this.runtime = runtime;
-  }
-  /**
-   * Initialize the message processor
-   */
-  async initialize() {
-    this.runtime.logger.info("Message Processor initialized");
-  }
-  /**
-   * Set the message handler for delivering messages to Agent
-   */
-  setMessageHandler(handler) {
-    this.messageHandler = handler;
-  }
-  /**
-   * Get the currently registered Agent message handler.
-   */
-  getMessageHandler() {
-    return this.messageHandler;
-  }
-  /**
-   * Deliver a normalized message directly to the registered Agent handler.
-   */
-  async deliverToAgent(message) {
-    if (!this.messageHandler) {
-      this.runtime.logger.warn("No message handler set, message not delivered to Agent", {
-        messageId: message.id,
-        type: message.type,
-        deviceId: message.deviceId
-      });
-      return;
-    }
-    this.runtime.logger.info("Delivering message to Agent", {
-      messageId: message.id,
-      type: message.type,
-      from: message.from,
-      deviceId: message.deviceId,
-      contentLength: message.content?.length ?? 0
-    });
-    try {
-      await this.messageHandler(message);
-      this.runtime.logger.info("Agent handler completed", { messageId: message.id });
-    } catch (error) {
-      this.runtime.logger.error("Agent handler threw error", { messageId: message.id, error });
-      throw error;
-    }
-  }
-};
-
 // src/probe.ts
 var Probe = class {
   runtime;
@@ -2282,16 +2234,16 @@ var ErrorHandler = class {
 function getMachineId() {
   try {
     const interfaces = networkInterfaces();
-    const macs = [];
+    const macSet = /* @__PURE__ */ new Set();
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;
       for (const alias of iface) {
         if (!alias.internal && alias.mac && alias.mac !== "00:00:00:00:00:00") {
-          macs.push(alias.mac);
+          macSet.add(alias.mac);
         }
       }
     }
-    macs.sort();
+    const macs = [...macSet].sort();
     if (macs.length > 0) {
       return createHash("md5").update(macs.join("")).digest("hex").substring(0, 8);
     }
@@ -2307,32 +2259,13 @@ function generateGatewayId(accountId) {
 var MultiAccountOrchestrator = class {
   runtime;
   accounts = /* @__PURE__ */ new Map();
-  messageHandler = null;
   constructor(runtime) {
     this.runtime = runtime;
   }
-  /**
-   * Set the message handler for delivering messages to the Agent.
-   * Propagates to all running accounts.
-   */
-  setMessageHandler(handler) {
-    this.messageHandler = handler;
-    for (const state of this.accounts.values()) {
-      if (state.messageProcessor) {
-        state.messageProcessor.setMessageHandler(handler);
-      }
-    }
-  }
-  /**
-   * Get the current message handler (for gateway adapter injection).
-   */
-  getMessageHandler() {
-    return this.messageHandler;
-  }
   /**
    * Start an account: create components, register to server, connect WS.
    */
-  async start(account) {
+  async start(account, context) {
     const { id: accountId } = account;
     const existing = this.accounts.get(accountId);
     if (existing?.status === "running") {
@@ -2343,7 +2276,6 @@ var MultiAccountOrchestrator = class {
     const gatewayId = account.gatewayId ?? generateGatewayId(accountId);
     const storagePrefix = `lingyao:${accountId}`;
     const accountManager = new AccountManager(this.runtime);
-    const messageProcessor = new MessageProcessor(this.runtime);
     const probe = new Probe(this.runtime);
     const monitor = new Monitor(this.runtime);
     const errorHandler = new ErrorHandler(this.runtime);
@@ -2358,21 +2290,18 @@ var MultiAccountOrchestrator = class {
       wsClient: null,
       httpClient,
       accountManager,
-      messageProcessor,
       probe,
       monitor,
       errorHandler,
       status: "starting",
       startTime: Date.now(),
-      gatewayId
+      gatewayId,
+      channelRuntime: context?.channelRuntime,
+      cfg: context?.cfg
     };
     this.accounts.set(accountId, state);
     try {
       await accountManager.initialize();
-      await messageProcessor.initialize();
-      if (this.messageHandler) {
-        messageProcessor.setMessageHandler(this.messageHandler);
-      }
       await this.registerToServer(state);
       const wsHeartbeatMs = resolveLingyaoWsHeartbeatIntervalMs(account, httpClient);
       this.runtime.logger.info(`Lingyao WebSocket heartbeat interval: ${wsHeartbeatMs}ms (relay serverConfig / config)`);
@@ -2548,33 +2477,87 @@ var MultiAccountOrchestrator = class {
     };
   }
   /**
-   * Handle sync message (diary or memory).
+   * Handle sync message (diary or memory) via SDK dispatch pipeline.
    */
   async handleSyncMessage(state, deviceId, message) {
-    if (!state.messageProcessor) {
-      this.runtime.logger.warn(`[${state.accountId}] Message processor not initialized, dropping message`, {
+    if (!state.channelRuntime || !state.cfg) {
+      this.runtime.logger.warn(`[${state.accountId}] channelRuntime/cfg not available, cannot dispatch to Agent`, {
         messageId: message.id,
         messageType: message.type,
         deviceId
       });
       return;
     }
-    this.runtime.logger.info(`[${state.accountId}] Routing sync message to Agent`, {
+    this.runtime.logger.info(`[${state.accountId}] Dispatching sync message to Agent via SDK pipeline`, {
       messageId: message.id,
       messageType: message.type,
       deviceId,
       contentLength: message.content?.length ?? 0
     });
-    const agentMessage = {
-      id: message.id,
-      type: message.type === "sync_diary" ? "diary" : "memory",
-      from: deviceId,
-      deviceId,
-      content: message.content,
-      metadata: message.metadata || {},
-      timestamp: message.timestamp
+    const dmRuntime = {
+      channel: {
+        routing: {
+          resolveAgentRoute: state.channelRuntime.routing.resolveAgentRoute
+        },
+        session: {
+          resolveStorePath: state.channelRuntime.session.resolveStorePath,
+          readSessionUpdatedAt: state.channelRuntime.session.readSessionUpdatedAt,
+          recordInboundSession: state.channelRuntime.session.recordInboundSession
+        },
+        reply: {
+          resolveEnvelopeFormatOptions: state.channelRuntime.reply.resolveEnvelopeFormatOptions,
+          formatAgentEnvelope: state.channelRuntime.reply.formatAgentEnvelope,
+          finalizeInboundContext: state.channelRuntime.reply.finalizeInboundContext,
+          dispatchReplyWithBufferedBlockDispatcher: state.channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher
+        }
+      }
     };
-    await state.messageProcessor.deliverToAgent(agentMessage);
+    try {
+      await dispatchInboundDirectDmWithRuntime({
+        cfg: state.cfg,
+        runtime: dmRuntime,
+        channel: "lingyao",
+        channelLabel: "\u7075\u723B",
+        accountId: state.accountId,
+        peer: { kind: "direct", id: deviceId },
+        senderId: deviceId,
+        senderAddress: deviceId,
+        recipientAddress: state.gatewayId,
+        conversationLabel: `\u7075\u723B DM with ${deviceId}`,
+        rawBody: message.content,
+        messageId: message.id,
+        timestamp: message.timestamp,
+        bodyForAgent: message.content,
+        provider: "lingyao",
+        surface: "lingyao",
+        extraContext: {
+          messageType: message.type === "sync_diary" ? "diary" : "memory",
+          metadata: message.metadata || {}
+        },
+        deliver: async (payload) => {
+          const sent = this.sendNotification(state.accountId, deviceId, {
+            type: "agent_reply",
+            text: payload.text,
+            mediaUrl: payload.mediaUrl,
+            mediaUrls: payload.mediaUrls
+          });
+          if (!sent) {
+            this.runtime.logger.warn(
+              `[${state.accountId}] Failed to deliver Agent reply to ${deviceId}: WS not connected`
+            );
+          }
+        },
+        onRecordError: (err) => {
+          this.runtime.logger.error(`[${state.accountId}] Failed to record inbound session`, err);
+        },
+        onDispatchError: (err, info) => {
+          this.runtime.logger.error(`[${state.accountId}] Dispatch error`, { err, kind: info.kind });
+        }
+      });
+    } catch (error) {
+      this.runtime.logger.error(`[${state.accountId}] dispatchInboundDirectDmWithRuntime failed`, error);
+      throw error;
+    }
   }
   /**
    * Create event handler for WS connection events on a specific account.