@lingyao037/openclaw-lingyao-cli 1.3.6 → 1.5.0

package/dist/index.js

@@ -11,7 +11,7 @@ var globalRuntime = null;
 function setRuntime(runtime) {
   globalRuntime = runtime;
 }
-function adaptPluginRuntime(pr) {
+function adaptPluginRuntime(pr, lingyaoConfig) {
   const noop = (..._args) => {
   };
   const rawLogger = pr.logging?.getChildLogger?.() ?? {
@@ -28,7 +28,10 @@ function adaptPluginRuntime(pr) {
   const stateDir = pr.state?.resolveStateDir?.() ?? join(process.cwd(), ".lingyao-data");
   const storeDir = join(stateDir, "lingyao");
   return {
-    config: { enabled: true },
+    config: {
+      enabled: true,
+      ...lingyaoConfig
+    },
     logger: childLogger,
     storage: {
       async get(key) {
@@ -63,6 +66,113 @@ function adaptPluginRuntime(pr) {
   };
 }
 
+// src/config-schema.ts
+import { z } from "zod";
+var lingyaoDmPolicySchema = z.enum(["pairing", "allowlist", "open"]);
+var allowFromSchema = z.array(z.string()).optional();
+var lingyaoAccountConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  dmPolicy: lingyaoDmPolicySchema.optional(),
+  allowFrom: allowFromSchema,
+  websocketHeartbeatIntervalMs: z.number().int().min(5e3).max(12e4).optional()
+});
+var lingyaoAccountConfigLooseSchema = z.object({
+  enabled: z.boolean().optional(),
+  dmPolicy: z.unknown().optional(),
+  allowFrom: z.array(z.string()).optional(),
+  gatewayId: z.string().optional(),
+  websocketHeartbeatIntervalMs: z.number().optional(),
+  maxOfflineMessages: z.number().optional(),
+  tokenExpiryDays: z.number().optional()
+}).passthrough();
+var lingyaoConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  dmPolicy: lingyaoDmPolicySchema.optional().default("pairing"),
+  allowFrom: allowFromSchema.default([]),
+  websocketHeartbeatIntervalMs: z.number().int().min(5e3).max(12e4).optional(),
+  notificationRatePerSecond: z.number().positive().max(500).optional(),
+  notificationBurst: z.number().int().positive().max(1e4).optional(),
+  defaultAccount: z.string().min(1).optional(),
+  accounts: z.record(lingyaoAccountConfigSchema).optional()
+});
+var lingyaoChannelConfigSchema = {
+  schema: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true
+      },
+      dmPolicy: {
+        type: "string",
+        enum: ["pairing", "allowlist", "open"],
+        default: "pairing"
+      },
+      allowFrom: {
+        type: "array",
+        items: { type: "string" },
+        default: []
+      },
+      defaultAccount: {
+        type: "string"
+      },
+      websocketHeartbeatIntervalMs: {
+        type: "integer",
+        minimum: 5e3,
+        maximum: 12e4,
+        description: "WebSocket gateway_heartbeat interval in ms (default: server register response). Use 5000\u201355000 for typical relay timeout."
+      },
+      notificationRatePerSecond: {
+        type: "number",
+        minimum: 0.1,
+        maximum: 500,
+        description: "Token bucket refill rate for outbound App notifications (default 15). Override with LINGYAO_NOTIFY_RATE_PER_SEC env if runtime config is not merged."
+      },
+      notificationBurst: {
+        type: "integer",
+        minimum: 1,
+        maximum: 1e4,
+        description: "Max burst for outbound notifications (default 25). Env: LINGYAO_NOTIFY_BURST."
+      },
+      accounts: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          enabled: {
+            type: "boolean",
+            default: true
+          },
+          dmPolicy: {
+            type: "string",
+            enum: ["pairing", "allowlist", "open"]
+          },
+          allowFrom: {
+            type: "array",
+            items: { type: "string" }
+          },
+          websocketHeartbeatIntervalMs: {
+            type: "integer",
+            minimum: 5e3,
+            maximum: 12e4
+          }
+        },
+        default: {}
+      }
+    }
+  }
+};
+function validateConfig(config) {
+  return lingyaoConfigSchema.parse(config);
+}
+function getDefaultConfig() {
+  return {
+    enabled: true,
+    dmPolicy: "pairing",
+    allowFrom: []
+  };
+}
+
 // src/adapters/config.ts
 function normalizeDmPolicy(raw) {
   switch (raw) {
@@ -128,13 +238,15 @@ function createConfigAdapter() {
       if (!accountConfig) {
         throw new Error(`Account "${resolvedId}" not found`);
       }
+      const parsed = lingyaoAccountConfigLooseSchema.safeParse(accountConfig);
+      const ac = parsed.success ? parsed.data : {};
       return {
         id: resolvedId,
         accountId: resolvedId,
-        enabled: accountConfig?.enabled !== false,
-        dmPolicy: normalizeDmPolicy(accountConfig?.dmPolicy),
-        allowFrom: accountConfig?.allowFrom ?? [],
-        gatewayId: accountConfig?.gatewayId,
+        enabled: ac.enabled !== false,
+        dmPolicy: normalizeDmPolicy(ac.dmPolicy),
+        allowFrom: Array.isArray(ac.allowFrom) ? ac.allowFrom : [],
+        gatewayId: typeof ac.gatewayId === "string" ? ac.gatewayId : void 0,
         rawConfig: accountConfig
       };
     },
@@ -764,6 +876,8 @@ var ServerHttpClient = class {
 
 // src/websocket-client.ts
 import WebSocket from "ws";
+var LINGYAO_DEFAULT_MAX_MESSAGE_BYTES = 1048576;
+var LINGYAO_DEFAULT_MAX_INCOMING_WS_BYTES = 2048576;
 function isWebsocketUpgradeNotFoundError(message) {
   return /Unexpected server response:\s*404/i.test(message) || /\b404\b/.test(message);
 }
@@ -790,6 +904,8 @@ var LingyaoWSClient = class {
   reconnectTimer = null;
   /** When set, close handler will not schedule reconnect (e.g. HTTP 404 on upgrade). */
   suppressReconnect = false;
+  /** 自上次成功 `open` 以来已调度的重连次数（用于退避与上限） */
+  reconnectAttempt = 0;
   messageHandlers = /* @__PURE__ */ new Map();
   logger;
   constructor(runtime, config) {
@@ -853,6 +969,7 @@ var LingyaoWSClient = class {
    */
   handleOpen() {
     this.state = "connected";
+    this.reconnectAttempt = 0;
     this.connectionId = this.generateConnectionId();
     this.logger.info("WebSocket connected to Lingyao server", {
       connectionId: this.connectionId
@@ -873,6 +990,14 @@ var LingyaoWSClient = class {
    */
   async handleMessage(data) {
     try {
+      const maxBytes = this.config.maxIncomingMessageBytes ?? LINGYAO_DEFAULT_MAX_INCOMING_WS_BYTES;
+      if (data.length > maxBytes) {
+        this.logger.warn("Dropped oversize WebSocket frame", {
+          bytes: data.length,
+          maxBytes
+        });
+        return;
+      }
       const message = JSON.parse(data.toString());
       const rawType = String(message.type);
       const handlerKey = normalizeIncomingGatewayMessageType(rawType);
@@ -941,8 +1066,7 @@ var LingyaoWSClient = class {
         capabilities: {
           websocket: true,
           compression: false,
-          maxMessageSize: 1048576
-          // 1MB
+          maxMessageSize: LINGYAO_DEFAULT_MAX_MESSAGE_BYTES
         }
       }
     };
@@ -1006,11 +1130,33 @@ var LingyaoWSClient = class {
     if (this.reconnectTimer) {
       return;
     }
-    this.logger.info(`Scheduling reconnect in ${this.config.reconnectInterval}ms`);
+    const maxAttempts = this.config.reconnectMaxAttempts ?? 0;
+    if (maxAttempts > 0 && this.reconnectAttempt >= maxAttempts) {
+      this.logger.error("Reconnect aborted: max attempts reached", {
+        attempts: this.reconnectAttempt,
+        maxAttempts
+      });
+      this.emitEvent({
+        type: "reconnect_aborted",
+        reason: "max_attempts",
+        attempts: this.reconnectAttempt
+      });
+      return;
+    }
+    const base = this.config.reconnectInterval;
+    const mult = this.config.reconnectBackoffMultiplier ?? 2;
+    const cap = this.config.reconnectMaxDelayMs ?? 6e4;
+    const pow = Math.pow(mult, this.reconnectAttempt);
+    const delay = Math.min(base * pow, cap);
+    this.logger.info(`Scheduling reconnect`, {
+      delayMs: delay,
+      attempt: this.reconnectAttempt
+    });
+    this.reconnectAttempt += 1;
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.connect();
-    }, this.config.reconnectInterval);
+    }, delay);
   }
   /**
    * 发送消息到服务器
@@ -1091,9 +1237,9 @@ var LingyaoWSClient = class {
     if (this.config.eventHandler) {
       this.config.eventHandler({
         type: "pairing_completed",
-        deviceId: payload?.deviceId,
-        deviceInfo: payload?.deviceInfo,
-        sessionId: payload?.sessionId
+        deviceId: payload?.deviceId ?? "",
+        deviceInfo: payload?.deviceInfo ?? { name: "", platform: "", version: "" },
+        sessionId: payload?.sessionId ?? ""
       });
     }
   }
@@ -1183,10 +1329,13 @@ var LingyaoWSClient = class {
 // src/accounts.ts
 var STORAGE_KEY_ACCOUNTS = "lingyao:accounts";
 var STORAGE_KEY_PENDING_PAIRINGS = "lingyao:pending_pairings";
-var AccountManager = class {
+var AccountManager = class _AccountManager {
   runtime;
   accounts = /* @__PURE__ */ new Map();
   pendingPairings = /* @__PURE__ */ new Map();
+  /** Debounced flush for high-frequency updates (e.g. heartbeat lastSeen). */
+  accountsSaveTimer = null;
+  static ACCOUNTS_SAVE_DEBOUNCE_MS = 3e3;
   constructor(runtime) {
     this.runtime = runtime;
   }
@@ -1309,7 +1458,31 @@ var AccountManager = class {
     const account = this.accounts.get(deviceId);
     if (account) {
       account.lastSeenAt = Date.now();
-      await this.saveAccounts();
+      this.scheduleDebouncedAccountsSave();
+    }
+  }
+  /**
+   * Persist any debounced account state immediately (e.g. before process/account shutdown).
+   */
+  async flushPendingAccountsSave() {
+    if (this.accountsSaveTimer) {
+      clearTimeout(this.accountsSaveTimer);
+      this.accountsSaveTimer = null;
+    }
+    await this.persistAccounts();
+  }
+  scheduleDebouncedAccountsSave() {
+    if (this.accountsSaveTimer) {
+      return;
+    }
+    this.accountsSaveTimer = setTimeout(() => {
+      this.accountsSaveTimer = null;
+      void this.persistAccounts().catch(
+        (e) => this.runtime.logger.error("Failed to save accounts (debounced)", e)
+      );
+    }, _AccountManager.ACCOUNTS_SAVE_DEBOUNCE_MS);
+    if (this.accountsSaveTimer.unref) {
+      this.accountsSaveTimer.unref();
     }
   }
   /**
@@ -1394,9 +1567,16 @@ var AccountManager = class {
     }
   }
   /**
-   * Save accounts to storage
+   * Save accounts to storage (immediate; clears any pending debounced save).
    */
   async saveAccounts() {
+    if (this.accountsSaveTimer) {
+      clearTimeout(this.accountsSaveTimer);
+      this.accountsSaveTimer = null;
+    }
+    await this.persistAccounts();
+  }
+  async persistAccounts() {
     const accounts = Array.from(this.accounts.values());
     await this.runtime.storage.set(STORAGE_KEY_ACCOUNTS, accounts);
   }
@@ -1602,6 +1782,7 @@ var Probe = class {
 };
 
 // src/metrics.ts
+var MAX_HISTOGRAM_SAMPLES_PER_NAME = 1e4;
 var MetricsManager = class {
   metrics = /* @__PURE__ */ new Map();
   counters = /* @__PURE__ */ new Map();
@@ -1720,6 +1901,9 @@ var MetricsManager = class {
       this.histograms.set(name, values);
     }
     values.push(value);
+    if (values.length > MAX_HISTOGRAM_SAMPLES_PER_NAME) {
+      values.splice(0, values.length - MAX_HISTOGRAM_SAMPLES_PER_NAME);
+    }
     this.recordMetric({
       name,
       type: "histogram" /* HISTOGRAM */,
@@ -1940,6 +2124,7 @@ var Monitor = class {
 };
 
 // src/errors.ts
+var MAX_LAST_ERROR_ENTRIES = 128;
 var LingyaoError = class extends Error {
   code;
   severity;
@@ -2058,6 +2243,11 @@ var ErrorHandler = class {
       error,
       timestamp
     });
+    while (this.lastErrors.size > MAX_LAST_ERROR_ENTRIES) {
+      const oldest = this.lastErrors.keys().next().value;
+      if (oldest === void 0) break;
+      this.lastErrors.delete(oldest);
+    }
   }
   /**
    * 检查错误阈值
@@ -2230,6 +2420,50 @@ var ErrorHandler = class {
   }
 };
 
+// src/notification-rate-limit.ts
+var NotificationRateLimiter = class {
+  constructor(refillPerSecond, burst) {
+    this.refillPerSecond = refillPerSecond;
+    this.burst = burst;
+  }
+  buckets = /* @__PURE__ */ new Map();
+  /**
+   * Attempt to consume one send slot for `accountId`. Returns false if rate-limited.
+   */
+  tryConsume(accountId) {
+    const now = Date.now();
+    let b = this.buckets.get(accountId);
+    if (!b) {
+      b = { tokens: this.burst, lastUpdate: now };
+      this.buckets.set(accountId, b);
+    }
+    const elapsedSec = (now - b.lastUpdate) / 1e3;
+    if (elapsedSec > 0) {
+      b.tokens = Math.min(this.burst, b.tokens + elapsedSec * this.refillPerSecond);
+      b.lastUpdate = now;
+    }
+    if (b.tokens >= 1) {
+      b.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+};
+var DEFAULT_NOTIFY_REFILL_PER_SEC = 15;
+var DEFAULT_NOTIFY_BURST = 25;
+function resolveNotificationLimiterParams(cfg) {
+  const envRef = typeof process !== "undefined" ? process.env.LINGYAO_NOTIFY_RATE_PER_SEC : void 0;
+  const envBurst = typeof process !== "undefined" ? process.env.LINGYAO_NOTIFY_BURST : void 0;
+  const refillFromEnv = envRef !== void 0 && envRef !== "" ? Number(envRef) : Number.NaN;
+  const burstFromEnv = envBurst !== void 0 && envBurst !== "" ? Number(envBurst) : Number.NaN;
+  const refill = cfg.notificationRatePerSecond ?? (!Number.isNaN(refillFromEnv) && refillFromEnv > 0 ? refillFromEnv : void 0) ?? DEFAULT_NOTIFY_REFILL_PER_SEC;
+  const burst = cfg.notificationBurst ?? (!Number.isNaN(burstFromEnv) && burstFromEnv > 0 ? Math.floor(burstFromEnv) : void 0) ?? DEFAULT_NOTIFY_BURST;
+  return {
+    refillPerSecond: Math.min(500, Math.max(0.1, refill)),
+    burst: Math.min(1e4, Math.max(1, Math.floor(burst)))
+  };
+}
+
 // src/orchestrator.ts
 function getMachineId() {
   try {
@@ -2247,8 +2481,11 @@ function generateGatewayId(accountId) {
 var MultiAccountOrchestrator = class {
   runtime;
   accounts = /* @__PURE__ */ new Map();
+  notificationLimiter;
   constructor(runtime) {
     this.runtime = runtime;
+    const lim = resolveNotificationLimiterParams(runtime.config);
+    this.notificationLimiter = new NotificationRateLimiter(lim.refillPerSecond, lim.burst);
   }
   /**
    * Start an account: create components, register to server, connect WS.
@@ -2351,6 +2588,11 @@ var MultiAccountOrchestrator = class {
     if (state.httpClient) {
       state.httpClient.stopHeartbeat();
     }
+    try {
+      await state.accountManager.flushPendingAccountsSave();
+    } catch (e) {
+      this.runtime.logger.error(`[${accountId}] Failed to flush account storage`, e);
+    }
     state.status = "stopped";
     this.runtime.logger.info(`Account "${accountId}" stopped`);
   }
@@ -2407,6 +2649,12 @@ var MultiAccountOrchestrator = class {
       this.runtime.logger.warn(`[${accountId}] Cannot send notification: WS not connected`, { deviceId });
       return false;
     }
+    if (!this.notificationLimiter.tryConsume(accountId)) {
+      this.runtime.logger.warn(`[${accountId}] Notification rate limited (relay protection)`, {
+        deviceId
+      });
+      return false;
+    }
     this.runtime.logger.info(`[${accountId}] Sending notification to device`, {
       deviceId,
       notificationType: notification.type
@@ -2439,7 +2687,7 @@ var MultiAccountOrchestrator = class {
       const response = await state.httpClient.register({
         websocket: true,
         compression: false,
-        maxMessageSize: 1048576
+        maxMessageSize: LINGYAO_DEFAULT_MAX_MESSAGE_BYTES
       });
       this.runtime.logger.info(`Account "${state.accountId}": registered successfully`, {
         expiresAt: new Date(response.expiresAt).toISOString()
@@ -2466,17 +2714,14 @@ var MultiAccountOrchestrator = class {
           deviceId,
           messageType: msg.type
         });
-        switch (msg.type) {
-          case "sync_diary":
-          case "sync_memory":
-            await this.handleSyncMessage(state, deviceId, msg);
-            break;
-          case "heartbeat":
-            await state.accountManager.updateLastSeen(deviceId);
-            state.monitor.recordEvent("heartbeat_received" /* HEARTBEAT_RECEIVED */, { deviceId });
-            break;
-          default:
-            this.runtime.logger.warn(`[${state.accountId}] Unknown message type`, { type: msg.type });
+        if (msg.type === "sync_diary" || msg.type === "sync_memory") {
+          const syncBody = msg;
+          await this.handleSyncMessage(state, deviceId, syncBody);
+        } else if (msg.type === "heartbeat") {
+          await state.accountManager.updateLastSeen(deviceId);
+          state.monitor.recordEvent("heartbeat_received" /* HEARTBEAT_RECEIVED */, { deviceId });
+        } else {
+          this.runtime.logger.warn(`[${state.accountId}] Unknown message type`, { type: msg.type });
         }
       } catch (error) {
         this.runtime.logger.error(`[${state.accountId}] Error handling App message`, error);
@@ -2609,12 +2854,20 @@ var MultiAccountOrchestrator = class {
           break;
         case "fatal_handshake":
           if (event.reason === "http_404") {
-            void this.handleWsHandshake404(state);
+            this.handleWsHandshake404(state).catch((err) => {
+              this.runtime.logger.error(`[${state.accountId}] WS 404 recovery (async) failed`, err);
+            });
           }
           break;
         case "pairing_completed":
           this.handlePairingCompleted(state, event);
           break;
+        case "reconnect_aborted":
+          this.runtime.logger.error(`[${state.accountId}] WebSocket reconnect aborted`, {
+            reason: event.reason,
+            attempts: event.attempts
+          });
+          break;
       }
     };
   }
@@ -2657,7 +2910,7 @@ var MultiAccountOrchestrator = class {
       const response = await httpClient.register({
         websocket: true,
         compression: false,
-        maxMessageSize: 1048576
+        maxMessageSize: LINGYAO_DEFAULT_MAX_MESSAGE_BYTES
       });
       wsClient.updateToken(response.gatewayToken);
       await wsClient.connect();
@@ -2686,7 +2939,7 @@ var MultiAccountOrchestrator = class {
       const response = await state.httpClient.register({
         websocket: true,
         compression: false,
-        maxMessageSize: 1048576
+        maxMessageSize: LINGYAO_DEFAULT_MAX_MESSAGE_BYTES
       });
       this.runtime.logger.info(`[${state.accountId}] Obtained new token. Reconnecting WS...`);
       state.wsClient.updateToken(response.gatewayToken);
@@ -2698,90 +2951,6 @@ var MultiAccountOrchestrator = class {
   }
 };
 
-// src/config-schema.ts
-import { z } from "zod";
-var lingyaoDmPolicySchema = z.enum(["pairing", "allowlist", "open"]);
-var allowFromSchema = z.array(z.string()).optional();
-var lingyaoAccountConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  dmPolicy: lingyaoDmPolicySchema.optional(),
-  allowFrom: allowFromSchema,
-  websocketHeartbeatIntervalMs: z.number().int().min(5e3).max(12e4).optional()
-});
-var lingyaoConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  dmPolicy: lingyaoDmPolicySchema.optional().default("pairing"),
-  allowFrom: allowFromSchema.default([]),
-  websocketHeartbeatIntervalMs: z.number().int().min(5e3).max(12e4).optional(),
-  defaultAccount: z.string().min(1).optional(),
-  accounts: z.record(lingyaoAccountConfigSchema).optional()
-});
-var lingyaoChannelConfigSchema = {
-  schema: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      enabled: {
-        type: "boolean",
-        default: true
-      },
-      dmPolicy: {
-        type: "string",
-        enum: ["pairing", "allowlist", "open"],
-        default: "pairing"
-      },
-      allowFrom: {
-        type: "array",
-        items: { type: "string" },
-        default: []
-      },
-      defaultAccount: {
-        type: "string"
-      },
-      websocketHeartbeatIntervalMs: {
-        type: "integer",
-        minimum: 5e3,
-        maximum: 12e4,
-        description: "WebSocket gateway_heartbeat interval in ms (default: server register response). Use 5000\u201355000 for typical relay timeout."
-      },
-      accounts: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          enabled: {
-            type: "boolean",
-            default: true
-          },
-          dmPolicy: {
-            type: "string",
-            enum: ["pairing", "allowlist", "open"]
-          },
-          allowFrom: {
-            type: "array",
-            items: { type: "string" }
-          },
-          websocketHeartbeatIntervalMs: {
-            type: "integer",
-            minimum: 5e3,
-            maximum: 12e4
-          }
-        },
-        default: {}
-      }
-    }
-  }
-};
-function validateConfig(config) {
-  return lingyaoConfigSchema.parse(config);
-}
-function getDefaultConfig() {
-  return {
-    enabled: true,
-    dmPolicy: "pairing",
-    allowFrom: []
-  };
-}
-
 // src/api.ts
 var orchestrator = null;
 function getOrchestrator() {
@@ -2865,15 +3034,18 @@ var lingyaoPlugin = {
   directory: directoryAdapter,
   messaging: messagingAdapter
 };
-function initializeLingyaoRuntime(runtime) {
-  const adapted = adaptPluginRuntime(runtime);
+function initializeLingyaoRuntime(runtime, options) {
+  const adapted = adaptPluginRuntime(
+    runtime,
+    options?.lingyaoConfig
+  );
   setRuntime(adapted);
   orchestrator = new MultiAccountOrchestrator(adapted);
 }
 
 // src/runtime-api.ts
-function setLingyaoRuntime(runtime) {
-  initializeLingyaoRuntime(runtime);
+function setLingyaoRuntime(runtime, options) {
+  initializeLingyaoRuntime(runtime, options);
 }
 
 // src/index.ts