@lingyao037/openclaw-lingyao-cli 1.3.5 → 1.4.0

package/dist/cli.d.ts

@@ -1,4 +1,4 @@
-import { L as LingyaoRuntime, a as LingyaoAccount, D as DeviceToken, b as DeviceInfo, H as HealthStatus } from './types-BZMU9mea.js';
+import { L as LingyaoRuntime, a as LingyaoAccount, D as DeviceToken, b as DeviceInfo, H as HealthStatus } from './types-XJDsfTRA.js';
 
 /**
  * Account storage and management
@@ -7,6 +7,9 @@ declare class AccountManager {
     private runtime;
     private accounts;
     private pendingPairings;
+    /** Debounced flush for high-frequency updates (e.g. heartbeat lastSeen). */
+    private accountsSaveTimer;
+    private static readonly ACCOUNTS_SAVE_DEBOUNCE_MS;
     constructor(runtime: LingyaoRuntime);
     /**
      * Initialize account manager from storage
@@ -44,6 +47,11 @@ declare class AccountManager {
      * Update account's last seen timestamp
      */
     updateLastSeen(deviceId: string): Promise<void>;
+    /**
+     * Persist any debounced account state immediately (e.g. before process/account shutdown).
+     */
+    flushPendingAccountsSave(): Promise<void>;
+    private scheduleDebouncedAccountsSave;
     /**
      * Revoke an account
      */
@@ -63,9 +71,10 @@ declare class AccountManager {
      */
     cleanupExpired(): Promise<void>;
     /**
-     * Save accounts to storage
+     * Save accounts to storage (immediate; clears any pending debounced save).
      */
     private saveAccounts;
+    private persistAccounts;
     /**
      * Save pending pairings to storage
      */

package/dist/index.d.ts

@@ -1,27 +1,8 @@
-import { R as ResolvedAccount, L as LingyaoProbeResult } from './status-CS7AsRlS.js';
+import { R as ResolvedAccount, L as LingyaoProbeResult } from './status-Bjzb8u67.js';
 import * as openclaw_plugin_sdk from 'openclaw/plugin-sdk';
 import { PluginRuntime, ChannelPlugin } from 'openclaw/plugin-sdk';
-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 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;
-    type: "diary" | "memory" | "heartbeat";
-    from: string;
-    deviceId: string;
-    content: string;
-    metadata: Record<string, unknown>;
-    timestamp: number;
-}
+import { c as LingyaoConfig } from './types-XJDsfTRA.js';
+export { A as AckRequest, d as AgentMessage, b as DeviceInfo, D as DeviceToken, e as DiarySyncPayload, F as FailedEntry, H as HealthStatus, f as LINGYAO_SERVER_URL, a as LingyaoAccount, g as LingyaoAccountConfig, h as LingyaoMessage, L as LingyaoRuntime, M as MemorySyncPayload, i as MessageHandler, j as MessageType, N as NotifyAction, k as NotifyPayload, l as NotifyRequest, P as PairingCode, m as PairingConfirmRequest, n as PairingConfirmResponse, o as PollRequest, p as PollResponse, Q as QueuedMessage, S as SyncRequest, q as SyncResponse, T as TokenRefreshRequest, r as TokenRefreshResponse, W as WebSocketConnection, s as getLingyaoGatewayWsUrl } from './types-XJDsfTRA.js';
 
 /**
  * Validate configuration object
@@ -45,4 +26,4 @@ declare const plugin: {
     setChannelRuntime?: (runtime: openclaw_plugin_sdk.PluginRuntime) => void;
 };
 
-export { type AgentMessage, LingyaoConfig, plugin as default, getDefaultConfig, initializeLingyaoRuntime, lingyaoPlugin, validateConfig };
+export { LingyaoConfig, plugin as default, getDefaultConfig, initializeLingyaoRuntime, lingyaoPlugin, validateConfig };

package/dist/index.js

@@ -63,6 +63,99 @@ 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(),
+  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/adapters/config.ts
 function normalizeDmPolicy(raw) {
   switch (raw) {
@@ -128,13 +221,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 +859,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 +887,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 +952,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 +973,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 +1049,7 @@ var LingyaoWSClient = class {
         capabilities: {
           websocket: true,
           compression: false,
-          maxMessageSize: 1048576
-          // 1MB
+          maxMessageSize: LINGYAO_DEFAULT_MAX_MESSAGE_BYTES
         }
       }
     };
@@ -1006,11 +1113,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 +1220,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 +1312,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 +1441,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 +1550,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 +1765,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 +1884,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 +2107,7 @@ var Monitor = class {
 };
 
 // src/errors.ts
+var MAX_LAST_ERROR_ENTRIES = 128;
 var LingyaoError = class extends Error {
   code;
   severity;
@@ -2058,6 +2226,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 +2403,38 @@ 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;
+
 // src/orchestrator.ts
 function getMachineId() {
   try {
@@ -2247,6 +2452,10 @@ function generateGatewayId(accountId) {
 var MultiAccountOrchestrator = class {
   runtime;
   accounts = /* @__PURE__ */ new Map();
+  notificationLimiter = new NotificationRateLimiter(
+    DEFAULT_NOTIFY_REFILL_PER_SEC,
+    DEFAULT_NOTIFY_BURST
+  );
   constructor(runtime) {
     this.runtime = runtime;
   }
@@ -2261,8 +2470,30 @@ var MultiAccountOrchestrator = class {
       return;
     }
     this.runtime.logger.info(`Starting account "${accountId}"`);
-    const gatewayId = account.gatewayId ?? generateGatewayId(accountId);
     const storagePrefix = `lingyao:${accountId}`;
+    const gatewayIdKey = `${storagePrefix}:persistedGatewayId`;
+    let gatewayId = account.gatewayId;
+    if (!gatewayId) {
+      try {
+        const stored = await this.runtime.storage.get(gatewayIdKey);
+        if (stored && typeof stored === "string") {
+          gatewayId = stored;
+          this.runtime.logger.info(`Using persisted gatewayId: ${gatewayId}`);
+        }
+      } catch (e) {
+        this.runtime.logger.warn(`Failed to read persisted gatewayId`, e);
+      }
+    }
+    if (!gatewayId) {
+      gatewayId = generateGatewayId(accountId);
+      this.runtime.logger.info(`Generated new gatewayId: ${gatewayId}`);
+      try {
+        await this.runtime.storage.set(gatewayIdKey, gatewayId);
+        this.runtime.logger.info(`Persisted gatewayId: ${gatewayId}`);
+      } catch (e) {
+        this.runtime.logger.warn(`Failed to persist gatewayId`, e);
+      }
+    }
     const accountManager = new AccountManager(this.runtime);
     const probe = new Probe(this.runtime);
     const monitor = new Monitor(this.runtime);
@@ -2329,6 +2560,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`);
   }
@@ -2385,6 +2621,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
@@ -2417,7 +2659,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()
@@ -2444,17 +2686,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);
@@ -2587,12 +2826,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;
       }
     };
   }
@@ -2635,7 +2882,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();
@@ -2664,7 +2911,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);
@@ -2676,90 +2923,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() {