@lingyao037/openclaw-lingyao-cli 0.5.3 → 0.7.0

package/cli.mjs

@@ -31,6 +31,46 @@ const RED = '\x1b[31m';
 const CYAN = '\x1b[36m';
 const NC = '\x1b[0m';
 
+/**
+ * 获取机器的稳定标识符 (基于 MAC 地址)
+ */
+function getMachineId() {
+  try {
+    const interfaces = os.networkInterfaces();
+    let macStr = '';
+    
+    for (const name of Object.keys(interfaces)) {
+      const iface = interfaces[name];
+      if (!iface) continue;
+      
+      for (const alias of iface) {
+        if (!alias.internal && alias.mac && alias.mac !== '00:00:00:00:00:00') {
+          macStr += alias.mac;
+        }
+      }
+    }
+    
+    if (macStr) {
+      import('crypto').then(crypto => {
+         // this is async, but we want sync, so we just use require if possible
+      });
+      // fallback to simple hash since we can't use top level await here easily in older nodes
+      let hash = 0;
+      for (let i = 0; i < macStr.length; i++) {
+        const char = macStr.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+      }
+      return Math.abs(hash).toString(36).substring(0, 8);
+    }
+  } catch (e) {
+    // ignore
+  }
+  return Math.random().toString(36).substring(2, 10);
+}
+
+const MACHINE_ID = getMachineId();
+
 class LingyaoInstaller {
   constructor(customPath = null, skipDeps = true) {
     this.openclawPath = null;
@@ -444,11 +484,10 @@ class LingyaoInstaller {
     });
   }
 
-  // Generate a stable gateway ID
+  // 生成稳定的网关 ID
   generateGatewayId() {
     const host = os.hostname().split('.')[0].replace(/[^a-z0-9]/gi, '').toLowerCase();
-    const suffix = Math.random().toString(36).substring(2, 8);
-    return `gw_openclaw_${host}_default_${suffix}`;
+    return `gw_openclaw_${host}_${MACHINE_ID}_default`;
   }
 
   // Pair device flow: register gateway, init pairing, show QR, poll status

package/dist/index.d.ts

@@ -39,7 +39,11 @@ declare class ErrorHandler {
     private errorCounts;
     private lastErrors;
     private errorThresholds;
+    private cleanupTimer;
+    private errorTimestamps;
     constructor(runtime: LingyaoRuntime);
+    destroy(): void;
+    private cleanupOldErrors;
     /**
      * 处理错误
      */
@@ -604,6 +608,10 @@ declare class LingyaoWSClient {
      * 发送事件
      */
     private emitEvent;
+    /**
+     * 更新 WebSocket 连接使用的 token
+     */
+    updateToken(token: string): void;
     /**
      * 断开连接
      */

package/dist/index.js

@@ -344,7 +344,8 @@ function createSetupAdapter() {
 }
 
 // src/orchestrator.ts
-import { hostname } from "os";
+import { hostname, networkInterfaces } from "os";
+import { createHash as createHash2 } from "crypto";
 
 // src/types.ts
 var LINGYAO_SERVER_URL = "https://api.lingyao.live";
@@ -762,6 +763,10 @@ var LingyaoWSClient = class {
     this.connectionId = null;
     this.stopHeartbeat();
     this.emitEvent({ type: "disconnected", code, reason });
+    if (code === 1008) {
+      this.logger.error("WebSocket closed with 1008 (Invalid Token). Stopping reconnect loop.");
+      return;
+    }
     if (code !== 1e3) {
       this.scheduleReconnect();
     }
@@ -956,6 +961,12 @@ var LingyaoWSClient = class {
       this.config.eventHandler(event);
     }
   }
+  /**
+   * 更新 WebSocket 连接使用的 token
+   */
+  updateToken(token) {
+    this.config.token = token;
+  }
   /**
    * 断开连接
    */
@@ -1661,9 +1672,12 @@ var MessageProcessor = class {
   markMessageSeen(messageId) {
     this.seenMessages.add(messageId);
     if (this.seenMessages.size > 1e4) {
-      const entries = Array.from(this.seenMessages);
-      for (let i = 0; i < entries.length / 2; i++) {
-        this.seenMessages.delete(entries[i]);
+      let count = 0;
+      const targetDeletes = Math.floor(this.seenMessages.size / 2);
+      for (const id of this.seenMessages) {
+        this.seenMessages.delete(id);
+        count++;
+        if (count >= targetDeletes) break;
       }
     }
   }
@@ -2009,12 +2023,14 @@ var MetricsManager = class {
    * 记录指标
    */
   recordMetric(data) {
-    this.metrics.set(`${data.name}_${Date.now()}`, data);
+    const key = `${data.name}_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    this.metrics.set(key, data);
     if (this.metrics.size > 1e4) {
-      const entries = Array.from(this.metrics.entries());
-      entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-      for (let i = 0; i < 1e3; i++) {
-        this.metrics.delete(entries[i][0]);
+      let count = 0;
+      const deleteCount = Math.floor(this.metrics.size * 0.1);
+      for (const k of this.metrics.keys()) {
+        this.metrics.delete(k);
+        if (++count >= deleteCount) break;
       }
     }
   }
@@ -2268,12 +2284,39 @@ var ErrorHandler = class {
   errorCounts = /* @__PURE__ */ new Map();
   lastErrors = /* @__PURE__ */ new Map();
   errorThresholds = /* @__PURE__ */ new Map();
+  cleanupTimer = null;
+  errorTimestamps = /* @__PURE__ */ new Map();
   constructor(runtime) {
     this.runtime = runtime;
+    this.cleanupTimer = setInterval(() => this.cleanupOldErrors(), 5 * 60 * 1e3);
+    if (this.cleanupTimer.unref) {
+      this.cleanupTimer.unref();
+    }
     this.setErrorThreshold("CONNECTION_ERROR", { count: 5, window: 6e4 });
     this.setErrorThreshold("AUTHENTICATION_ERROR", { count: 3, window: 6e4 });
     this.setErrorThreshold("NETWORK_ERROR", { count: 10, window: 6e4 });
   }
+  destroy() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  cleanupOldErrors() {
+    const now = Date.now();
+    for (const [code, timestamps] of this.errorTimestamps.entries()) {
+      const thresholdConfig = this.errorThresholds.get(code);
+      const windowMs = thresholdConfig?.window || 36e5;
+      const validTimestamps = timestamps.filter((ts) => now - ts <= windowMs);
+      if (validTimestamps.length === 0) {
+        this.errorTimestamps.delete(code);
+        this.errorCounts.delete(code);
+      } else {
+        this.errorTimestamps.set(code, validTimestamps);
+        this.errorCounts.set(code, validTimestamps.length);
+      }
+    }
+  }
   /**
    * 处理错误
    */
@@ -2299,18 +2342,18 @@ var ErrorHandler = class {
    */
   recordError(error) {
     const key = error.code;
-    const count = (this.errorCounts.get(key) || 0) + 1;
-    this.errorCounts.set(key, count);
+    const timestamp = Date.now();
+    const thresholdConfig = this.errorThresholds.get(key);
+    const windowMs = thresholdConfig?.window || 36e5;
+    let timestamps = this.errorTimestamps.get(key) || [];
+    timestamps = timestamps.filter((ts) => timestamp - ts <= windowMs);
+    timestamps.push(timestamp);
+    this.errorTimestamps.set(key, timestamps);
+    this.errorCounts.set(key, timestamps.length);
     this.lastErrors.set(key, {
       error,
-      timestamp: Date.now()
+      timestamp
     });
-    setTimeout(() => {
-      const lastError = this.lastErrors.get(key);
-      if (lastError && lastError.timestamp === error.timestamp) {
-        this.errorCounts.set(key, (this.errorCounts.get(key) || 0) - 1);
-      }
-    }, 36e5);
   }
   /**
    * 检查错误阈值
@@ -2484,10 +2527,30 @@ var ErrorHandler = class {
 };
 
 // src/orchestrator.ts
+function getMachineId() {
+  try {
+    const interfaces = networkInterfaces();
+    let macStr = "";
+    for (const name of Object.keys(interfaces)) {
+      const iface = interfaces[name];
+      if (!iface) continue;
+      for (const alias of iface) {
+        if (!alias.internal && alias.mac && alias.mac !== "00:00:00:00:00:00") {
+          macStr += alias.mac;
+        }
+      }
+    }
+    if (macStr) {
+      return createHash2("md5").update(macStr).digest("hex").substring(0, 8);
+    }
+  } catch (e) {
+  }
+  return Math.random().toString(36).substring(2, 10);
+}
+var MACHINE_ID = getMachineId();
 function generateGatewayId(accountId) {
   const host = hostname().split(".")[0].replace(/[^a-z0-9]/gi, "").toLowerCase();
-  const suffix = Math.random().toString(36).substring(2, 8);
-  return `gw_openclaw_${host}_${accountId}_${suffix}`;
+  return `gw_openclaw_${host}_${MACHINE_ID}_${accountId}`;
 }
 var MultiAccountOrchestrator = class {
   runtime;
@@ -2767,6 +2830,12 @@ var MultiAccountOrchestrator = class {
             code: event.code,
             reason: event.reason
           });
+          if (event.code === 1008) {
+            this.runtime.logger.warn(`[${state.accountId}] Token invalid (1008). Forcing re-registration...`);
+            this.handleInvalidToken(state).catch((err) => {
+              this.runtime.logger.error(`[${state.accountId}] Failed to re-register after 1008`, err);
+            });
+          }
           break;
         case "error":
           this.runtime.logger.error(`[${state.accountId}] WS error`, event.error);
@@ -2799,13 +2868,36 @@ var MultiAccountOrchestrator = class {
       this.runtime.logger.error(`[${state.accountId}] Failed to auto-bind device: ${deviceId}`, error);
     }
   }
+  /**
+   * Handle invalid token by re-registering the gateway and reconnecting WS
+   */
+  async handleInvalidToken(state) {
+    if (!state.httpClient || !state.wsClient) {
+      return;
+    }
+    try {
+      this.runtime.logger.info(`[${state.accountId}] Requesting new gateway token...`);
+      const response = await state.httpClient.register({
+        websocket: true,
+        compression: false,
+        maxMessageSize: 1048576
+      });
+      this.runtime.logger.info(`[${state.accountId}] Obtained new token. Reconnecting WS...`);
+      state.wsClient.updateToken(response.gatewayToken);
+      await state.wsClient.connect();
+    } catch (error) {
+      this.runtime.logger.error(`[${state.accountId}] Failed to handle invalid token`, error);
+      state.errorHandler.handleError(error);
+    }
+  }
 };
 
 // src/channel.ts
-import { hostname as hostname2 } from "os";
+import { createHash as createHash4 } from "crypto";
+import { hostname as hostname2, networkInterfaces as networkInterfaces2 } from "os";
 
 // src/token.ts
-import { randomBytes as randomBytes2, createHash as createHash2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { randomBytes as randomBytes2, createHash as createHash3, timingSafeEqual as timingSafeEqual2 } from "crypto";
 var TokenManager = class {
   constructor(_runtime) {
     void _runtime;
@@ -2921,7 +3013,7 @@ var TokenManager = class {
    * Sign data with secret
    */
   sign(data, secret) {
-    return createHash2("sha256").update(data + secret).digest("base64");
+    return createHash3("sha256").update(data + secret).digest("base64");
   }
   /**
    * Base64URL encode without padding
@@ -2932,6 +3024,27 @@ var TokenManager = class {
 };
 
 // src/channel.ts
+function getMachineId2() {
+  try {
+    const interfaces = networkInterfaces2();
+    let macStr = "";
+    for (const name of Object.keys(interfaces)) {
+      const iface = interfaces[name];
+      if (!iface) continue;
+      for (const alias of iface) {
+        if (!alias.internal && alias.mac && alias.mac !== "00:00:00:00:00:00") {
+          macStr += alias.mac;
+        }
+      }
+    }
+    if (macStr) {
+      return createHash4("md5").update(macStr).digest("hex").substring(0, 8);
+    }
+  } catch (e) {
+  }
+  return Math.random().toString(36).substring(2, 10);
+}
+var MACHINE_ID2 = getMachineId2();
 var LingyaoChannel = class {
   runtime;
   config;
@@ -3313,8 +3426,7 @@ var LingyaoChannel = class {
    */
   generateGatewayId() {
     const hostname3 = this.getRuntimeHostname();
-    const randomSuffix = Math.random().toString(36).substring(2, 8);
-    return `gw_openclaw_${hostname3}_${randomSuffix}`;
+    return `gw_openclaw_${hostname3}_${MACHINE_ID2}`;
   }
   /**
    * 获取运行时主机名