@lingyao037/openclaw-lingyao-cli 0.3.0-alpha.1

package/dist/index.js

@@ -0,0 +1,3332 @@
+// src/runtime.ts
+var globalRuntime = null;
+function setRuntime(runtime) {
+  globalRuntime = runtime;
+}
+
+// src/adapters/config.ts
+function extractAccounts(cfg) {
+  const channels = cfg?.channels;
+  const lingyao = channels?.lingyao;
+  const accounts = lingyao?.accounts;
+  if (!accounts) return {};
+  return accounts;
+}
+function createConfigAdapter() {
+  return {
+    listAccountIds(cfg) {
+      const accounts = extractAccounts(cfg);
+      return Object.keys(accounts);
+    },
+    resolveAccount(cfg, accountId) {
+      const accounts = extractAccounts(cfg);
+      const ids = Object.keys(accounts);
+      if (ids.length === 0) {
+        accounts["default"] = {};
+      }
+      const resolvedId = accountId ?? (ids.includes("default") ? "default" : ids[0]);
+      if (!resolvedId) {
+        throw new Error("No lingyao accounts configured");
+      }
+      const accountConfig = accounts[resolvedId];
+      if (!accountConfig) {
+        throw new Error(`Account "${resolvedId}" not found`);
+      }
+      return {
+        id: resolvedId,
+        enabled: accountConfig?.enabled !== false,
+        dmPolicy: accountConfig?.dmPolicy ?? "paired",
+        allowFrom: Object.freeze(accountConfig?.allowFrom ?? []),
+        rawConfig: accountConfig
+      };
+    },
+    isConfigured(_account) {
+      return true;
+    },
+    isEnabled(account) {
+      return account.enabled;
+    }
+  };
+}
+
+// src/adapters/gateway.ts
+function createGatewayAdapter(getOrchestrator2) {
+  return {
+    async startAccount(ctx) {
+      const orchestrator2 = getOrchestrator2();
+      if (!orchestrator2) {
+        throw new Error("Orchestrator not initialized. Ensure setRuntime was called.");
+      }
+      ctx.log?.info(`Starting account "${ctx.accountId}"`);
+      await orchestrator2.start(ctx.account);
+      ctx.log?.info(`Account "${ctx.accountId}" started successfully`);
+    },
+    async stopAccount(ctx) {
+      const orchestrator2 = getOrchestrator2();
+      if (!orchestrator2) {
+        throw new Error("Orchestrator not initialized");
+      }
+      ctx.log?.info(`Stopping account "${ctx.accountId}"`);
+      await orchestrator2.stop(ctx.accountId);
+    }
+  };
+}
+
+// src/adapters/status.ts
+function createStatusAdapter(getOrchestrator2, _runtime) {
+  return {
+    async probeAccount(params) {
+      const orchestrator2 = getOrchestrator2();
+      if (!orchestrator2) {
+        return {
+          ok: false,
+          status: "unhealthy",
+          wsConnected: false,
+          error: "Orchestrator not initialized"
+        };
+      }
+      const state = orchestrator2.getAccountState(params.account.id);
+      if (!state) {
+        return {
+          ok: false,
+          status: "unhealthy",
+          wsConnected: false,
+          error: "Account not started"
+        };
+      }
+      try {
+        const healthResult = await state.probe.runHealthChecks();
+        const wsConnected = state.wsClient?.isConnected() ?? false;
+        let status = "healthy";
+        switch (healthResult.status) {
+          case "healthy":
+            status = wsConnected ? "healthy" : "degraded";
+            break;
+          case "degraded":
+            status = "degraded";
+            break;
+          case "unhealthy":
+            status = "unhealthy";
+            break;
+        }
+        const checks = {};
+        for (const [name, result] of healthResult.checks) {
+          checks[name] = {
+            passed: result.passed,
+            message: result.message ?? "",
+            duration: result.duration
+          };
+        }
+        return {
+          ok: status !== "unhealthy",
+          status,
+          wsConnected,
+          uptime: Date.now() - state.startTime,
+          checks
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          status: "unhealthy",
+          wsConnected: false,
+          error: error.message
+        };
+      }
+    },
+    async buildChannelSummary(params) {
+      const orchestrator2 = getOrchestrator2();
+      const accountId = params.account.id;
+      const state = orchestrator2?.getAccountState(accountId);
+      const runningIds = orchestrator2?.getRunningAccountIds() ?? [];
+      return {
+        accountId,
+        status: state?.status ?? "stopped",
+        wsConnected: state?.wsClient?.isConnected() ?? false,
+        isDefault: accountId === params.defaultAccountId,
+        running: runningIds.includes(accountId),
+        uptime: state ? Date.now() - state.startTime : 0
+      };
+    }
+  };
+}
+
+// src/adapters/directory.ts
+function createDirectoryAdapter(getOrchestrator2) {
+  return {
+    async listPeers(params) {
+      const orchestrator2 = getOrchestrator2();
+      if (!orchestrator2) {
+        return [];
+      }
+      const accountId = params.accountId ?? "default";
+      const accountManager = orchestrator2.getAccountManager(accountId);
+      if (!accountManager) {
+        return [];
+      }
+      const activeAccounts = accountManager.getActiveAccounts();
+      let entries = activeAccounts.map((account) => ({
+        kind: "user",
+        id: account.deviceId,
+        name: account.deviceInfo.name || account.deviceId,
+        handle: account.deviceId,
+        raw: account
+      }));
+      if (params.query) {
+        const q = params.query.toLowerCase();
+        entries = entries.filter(
+          (e) => e.id.toLowerCase().includes(q) || (e.name?.toLowerCase().includes(q) ?? false)
+        );
+      }
+      if (params.limit != null && params.limit > 0) {
+        entries = entries.slice(0, params.limit);
+      }
+      return entries;
+    }
+  };
+}
+
+// src/adapters/messaging.ts
+var PREFIX = "lingyao:";
+function createMessagingAdapter() {
+  return {
+    normalizeTarget(raw) {
+      if (!raw || typeof raw !== "string") {
+        return void 0;
+      }
+      const target = raw.startsWith(PREFIX) ? raw.slice(PREFIX.length) : raw;
+      if (!target) {
+        return void 0;
+      }
+      return target;
+    },
+    resolveSessionTarget(params) {
+      return `${PREFIX}${params.id}`;
+    },
+    inferTargetChatType(_params) {
+      return "direct";
+    }
+  };
+}
+
+// src/adapters/outbound.ts
+function createOutboundAdapter(getOrchestrator2) {
+  return {
+    deliveryMode: "direct",
+    async sendText(ctx) {
+      const orchestrator2 = getOrchestrator2();
+      if (!orchestrator2) {
+        throw new Error("Orchestrator not initialized");
+      }
+      const accountId = ctx.accountId ?? "default";
+      const sent = orchestrator2.sendNotification(
+        accountId,
+        ctx.to,
+        { title: "OpenClaw", body: ctx.text }
+      );
+      if (!sent) {
+        throw new Error(
+          `Failed to send text to device "${ctx.to}" on account "${accountId}": not connected`
+        );
+      }
+      return {
+        channel: "lingyao",
+        messageId: `out_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        chatId: ctx.to,
+        timestamp: Date.now()
+      };
+    },
+    async sendPayload(ctx) {
+      const orchestrator2 = getOrchestrator2();
+      if (!orchestrator2) {
+        throw new Error("Orchestrator not initialized");
+      }
+      const accountId = ctx.accountId ?? "default";
+      const payload = ctx.payload;
+      const sent = orchestrator2.sendNotification(
+        accountId,
+        ctx.to,
+        payload
+      );
+      if (!sent) {
+        throw new Error(
+          `Failed to send payload to device "${ctx.to}" on account "${accountId}": not connected`
+        );
+      }
+      return {
+        channel: "lingyao",
+        messageId: `out_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        chatId: ctx.to,
+        timestamp: Date.now()
+      };
+    },
+    resolveTarget(params) {
+      const raw = params.to;
+      if (!raw || typeof raw !== "string" || raw.trim().length === 0) {
+        return { ok: false, error: new Error("Target deviceId is empty or missing") };
+      }
+      return { ok: true, to: raw.trim() };
+    }
+  };
+}
+
+// src/orchestrator.ts
+import { hostname } from "os";
+
+// src/types.ts
+var LINGYAO_SERVER_URL = "https://api.lingyao.live";
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["SYNC_DIARY"] = "sync_diary";
+  MessageType2["SYNC_MEMORY"] = "sync_memory";
+  MessageType2["SYNC_ACK"] = "sync_ack";
+  MessageType2["NOTIFY_TEXT"] = "notify_text";
+  MessageType2["NOTIFY_ACTION"] = "notify_action";
+  MessageType2["HEARTBEAT"] = "heartbeat";
+  MessageType2["PAIRING_REQUEST"] = "pairing_request";
+  MessageType2["PAIRING_CONFIRM"] = "pairing_confirm";
+  return MessageType2;
+})(MessageType || {});
+
+// src/server-client.ts
+import axios from "axios";
+function isAxiosError(error) {
+  return typeof error === "object" && error !== null && "isAxiosError" in error && error.isAxiosError === true;
+}
+var ServerHttpClient = class {
+  runtime;
+  config;
+  axiosInstance;
+  gatewayToken = null;
+  webhookSecret = null;
+  tokenExpiresAt = 0;
+  heartbeatInterval = 3e4;
+  heartbeatTimer = null;
+  gatewayId;
+  isRegistered = false;
+  isConnecting = false;
+  storagePrefix;
+  constructor(runtime, gatewayId, serverConfig = {}, storagePrefix = "lingyao") {
+    this.runtime = runtime;
+    this.gatewayId = gatewayId;
+    this.storagePrefix = storagePrefix;
+    this.config = {
+      baseURL: serverConfig.baseURL || "https://api.lingyao.live",
+      apiBase: serverConfig.apiBase || "/v1",
+      timeout: serverConfig.timeout || 3e4,
+      connectionTimeout: serverConfig.connectionTimeout || 5e3
+    };
+    this.axiosInstance = axios.create({
+      baseURL: this.config.baseURL + this.config.apiBase,
+      timeout: this.config.timeout,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.axiosInstance.interceptors.request.use(
+      (config) => {
+        if (this.gatewayToken && config.headers) {
+          config.headers.Authorization = `Bearer ${this.gatewayToken}`;
+        }
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+    this.axiosInstance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (isAxiosError(error)) {
+          if (error.response?.status === 401) {
+            this.runtime.logger.warn("Token expired, attempting to re-register...");
+            await this.register();
+          }
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+  /**
+   * 注册 Gateway 到服务器
+   */
+  async register(capabilities = {}) {
+    if (this.isConnecting) {
+      throw new Error("Registration already in progress");
+    }
+    this.isConnecting = true;
+    try {
+      this.runtime.logger.info(`Registering gateway ${this.gatewayId} to server...`);
+      const response = await this.axiosInstance.post(
+        "/gateway/register",
+        {
+          gatewayId: this.gatewayId,
+          version: "0.1.0",
+          capabilities: {
+            websocket: false,
+            compression: false,
+            ...capabilities
+          }
+        }
+      );
+      const data = response.data;
+      this.gatewayToken = data.gatewayToken;
+      this.webhookSecret = data.webhookSecret;
+      this.tokenExpiresAt = data.expiresAt;
+      this.heartbeatInterval = data.serverConfig.heartbeatInterval;
+      this.isRegistered = true;
+      await this.runtime.storage.set(this.storageKey("gatewayToken"), this.gatewayToken);
+      await this.runtime.storage.set(this.storageKey("webhookSecret"), this.webhookSecret);
+      await this.runtime.storage.set(this.storageKey("tokenExpiresAt"), this.tokenExpiresAt);
+      await this.runtime.storage.set(this.storageKey("serverConfig"), data.serverConfig);
+      this.runtime.logger.info("Gateway registered successfully", {
+        expiresAt: new Date(this.tokenExpiresAt).toISOString(),
+        heartbeatInterval: this.heartbeatInterval
+      });
+      this.startHeartbeat();
+      return data;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        const axiosError = error;
+        const status = axiosError.response?.status;
+        const data = axiosError.response?.data;
+        if (status === 409) {
+          throw new Error("Gateway already registered");
+        } else if (status === 400) {
+          throw new Error(`Invalid request: ${data?.details || "Unknown error"}`);
+        }
+        throw new Error(`Registration failed: ${axiosError.message}`);
+      }
+      throw error;
+    } finally {
+      this.isConnecting = false;
+    }
+  }
+  /**
+   * 发送心跳
+   */
+  async heartbeat(status = "online", activeConnections = 0) {
+    if (!this.isRegistered || !this.gatewayToken) {
+      throw new Error("Gateway not registered");
+    }
+    try {
+      const response = await this.axiosInstance.post(
+        "/gateway/heartbeat",
+        {
+          timestamp: Date.now(),
+          status,
+          activeConnections
+        }
+      );
+      return response.data;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        const axiosError = error;
+        this.runtime.logger.error("Heartbeat failed", {
+          status: axiosError.response?.status,
+          data: axiosError.response?.data
+        });
+      }
+      throw error;
+    }
+  }
+  /**
+   * 发送消息到灵爻 App
+   */
+  async sendMessage(deviceId, messageType, payload, options) {
+    if (!this.isRegistered || !this.gatewayToken) {
+      throw new Error("Gateway not registered");
+    }
+    const messageId = this.generateMessageId();
+    try {
+      const response = await this.axiosInstance.post(
+        "/gateway/messages",
+        {
+          deviceId,
+          message: {
+            id: messageId,
+            type: messageType,
+            timestamp: Date.now(),
+            payload
+          },
+          options: options || {}
+        }
+      );
+      this.runtime.logger.debug("Message sent", {
+        messageId,
+        deviceId,
+        status: response.data.status
+      });
+      return response.data;
+    } catch (error) {
+      if (isAxiosError(error)) {
+        const axiosError = error;
+        const status = axiosError.response?.status;
+        const data = axiosError.response?.data;
+        if (status === 404) {
+          throw new Error(`Device not found: ${deviceId}`);
+        } else if (status === 429) {
+          throw new Error("Message queue full, please retry later");
+        }
+        throw new Error(`Send message failed: ${data?.error || axiosError.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 启动心跳循环
+   */
+  startHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setInterval(
+      async () => {
+        try {
+          await this.heartbeat();
+        } catch (error) {
+          this.runtime.logger.error("Heartbeat error", error);
+        }
+      },
+      this.heartbeatInterval
+    );
+    this.runtime.logger.info("Heartbeat started", {
+      interval: this.heartbeatInterval
+    });
+  }
+  /**
+   * 停止心跳循环
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+      this.runtime.logger.info("Heartbeat stopped");
+    }
+  }
+  /**
+   * 获取 Webhook Secret
+   */
+  getWebhookSecret() {
+    return this.webhookSecret;
+  }
+  /**
+   * 获取 Gateway Token
+   */
+  getGatewayToken() {
+    return this.gatewayToken;
+  }
+  /**
+   * 检查 Token 是否即将过期
+   */
+  isTokenExpiringSoon(thresholdMs = 7 * 24 * 60 * 60 * 1e3) {
+    return this.tokenExpiresAt - Date.now() < thresholdMs;
+  }
+  /**
+   * 检查是否已注册
+   */
+  isReady() {
+    return this.isRegistered && !!this.gatewayToken;
+  }
+  /**
+   * 从存储恢复会话
+   */
+  async restoreFromStorage() {
+    try {
+      const token = await this.runtime.storage.get(this.storageKey("gatewayToken"));
+      const secret = await this.runtime.storage.get(this.storageKey("webhookSecret"));
+      const expiresAt = await this.runtime.storage.get(this.storageKey("tokenExpiresAt"));
+      const serverConfig = await this.runtime.storage.get(this.storageKey("serverConfig"));
+      if (token && secret && expiresAt && serverConfig) {
+        if (expiresAt > Date.now()) {
+          this.gatewayToken = token;
+          this.webhookSecret = secret;
+          this.tokenExpiresAt = expiresAt;
+          this.heartbeatInterval = serverConfig.heartbeatInterval;
+          this.isRegistered = true;
+          this.startHeartbeat();
+          this.runtime.logger.info("Session restored from storage", {
+            expiresAt: new Date(this.tokenExpiresAt).toISOString()
+          });
+          return true;
+        } else {
+          this.runtime.logger.warn("Stored token expired, need to re-register");
+        }
+      }
+    } catch (error) {
+      this.runtime.logger.error("Failed to restore session from storage", error);
+    }
+    return false;
+  }
+  /**
+   * Build a namespaced storage key for multi-account support
+   */
+  storageKey(name) {
+    return `${this.storagePrefix}:${name}`;
+  }
+  /**
+   * 生成消息 ID
+   */
+  generateMessageId() {
+    return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+  }
+};
+
+// src/websocket-client.ts
+import WebSocket from "ws";
+var LingyaoWSClient = class {
+  config;
+  ws = null;
+  state = "disconnected";
+  connectionId = null;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  messageHandlers = /* @__PURE__ */ new Map();
+  logger;
+  constructor(runtime, config) {
+    this.logger = runtime.logger;
+    this.config = { ...config };
+    this.registerMessageHandler("registered" /* REGISTERED */, this.handleRegistered.bind(this));
+    this.registerMessageHandler("heartbeat_ack" /* HEARTBEAT_ACK */, this.handleHeartbeatAck.bind(this));
+    this.registerMessageHandler("message_delivered" /* MESSAGE_DELIVERED */, this.handleMessageDelivered.bind(this));
+    this.registerMessageHandler("message_failed" /* MESSAGE_FAILED */, this.handleMessageFailed.bind(this));
+    this.registerMessageHandler("app_message" /* APP_MESSAGE */, this.handleAppMessage.bind(this));
+    this.registerMessageHandler("error" /* ERROR */, this.handleError.bind(this));
+  }
+  /**
+   * 连接到服务器
+   */
+  async connect() {
+    if (this.state === "connecting" || this.state === "connected") {
+      this.logger.warn("WebSocket already connecting or connected");
+      return;
+    }
+    this.state = "connecting";
+    this.emitEvent({ type: "disconnected", code: 0, reason: "Reconnecting" });
+    try {
+      this.logger.info(`Connecting to Lingyao server: ${this.config.url}`);
+      const wsUrl = this.config.token ? `${this.config.url}?token=${encodeURIComponent(this.config.token)}` : this.config.url;
+      this.ws = new WebSocket(wsUrl, {
+        headers: {
+          "X-Gateway-ID": this.config.gatewayId
+        }
+      });
+      this.setupWebSocketHandlers();
+    } catch (error) {
+      this.state = "error";
+      this.emitEvent({ type: "error", error });
+      this.scheduleReconnect();
+    }
+  }
+  /**
+   * 设置 WebSocket 事件处理器
+   */
+  setupWebSocketHandlers() {
+    if (!this.ws) return;
+    this.ws.on("open", () => {
+      this.handleOpen();
+    });
+    this.ws.on("message", async (data) => {
+      await this.handleMessage(data);
+    });
+    this.ws.on("error", (error) => {
+      this.handleErrorEvent(error);
+    });
+    this.ws.on("close", (code, reason) => {
+      this.handleClose(code, reason.toString());
+    });
+  }
+  /**
+   * 处理连接打开
+   */
+  handleOpen() {
+    this.state = "connected";
+    this.connectionId = this.generateConnectionId();
+    this.logger.info("WebSocket connected to Lingyao server", {
+      connectionId: this.connectionId
+    });
+    this.emitEvent({
+      type: "connected",
+      connectionId: this.connectionId
+    });
+    this.sendRegister();
+    this.startHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  /**
+   * 处理接收消息
+   */
+  async handleMessage(data) {
+    try {
+      const message = JSON.parse(data.toString());
+      this.logger.debug("Received message from server", { type: message.type });
+      const handler = this.messageHandlers.get(message.type);
+      if (handler) {
+        handler(message);
+      } else {
+        this.logger.warn("No handler for message type", { type: message.type });
+      }
+      this.emitEvent({ type: "message", message });
+    } catch (error) {
+      this.logger.error("Error handling message", error);
+    }
+  }
+  /**
+   * 处理连接错误
+   */
+  handleErrorEvent(error) {
+    this.logger.error("WebSocket error", error);
+    this.state = "error";
+    this.emitEvent({ type: "error", error });
+  }
+  /**
+   * 处理连接关闭
+   */
+  handleClose(code, reason) {
+    this.logger.warn("WebSocket connection closed", { code, reason });
+    this.state = "disconnected";
+    this.connectionId = null;
+    this.stopHeartbeat();
+    this.emitEvent({ type: "disconnected", code, reason });
+    if (code !== 1e3) {
+      this.scheduleReconnect();
+    }
+  }
+  /**
+   * 发送注册消息
+   */
+  sendRegister() {
+    const message = {
+      type: "register" /* REGISTER */,
+      id: this.generateMessageId(),
+      timestamp: Date.now(),
+      payload: {
+        gatewayId: this.config.gatewayId,
+        version: "0.2.0",
+        capabilities: {
+          websocket: true,
+          compression: false,
+          maxMessageSize: 1048576
+          // 1MB
+        }
+      }
+    };
+    this.send(message);
+  }
+  /**
+   * 处理注册响应
+   */
+  handleRegistered(message) {
+    this.logger.info("Gateway registered to Lingyao server", {
+      messageId: message.id
+    });
+  }
+  /**
+   * 发送心跳
+   */
+  sendHeartbeat() {
+    const message = {
+      type: "heartbeat" /* HEARTBEAT */,
+      id: this.generateMessageId(),
+      timestamp: Date.now(),
+      payload: {
+        timestamp: Date.now(),
+        status: "online"
+      }
+    };
+    this.send(message);
+  }
+  /**
+   * 处理心跳确认
+   */
+  handleHeartbeatAck(_message) {
+    this.logger.debug("Heartbeat acknowledged");
+  }
+  /**
+   * 启动心跳
+   */
+  startHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setInterval(() => {
+      if (this.state === "connected") {
+        this.sendHeartbeat();
+      }
+    }, this.config.heartbeatInterval);
+  }
+  /**
+   * 停止心跳
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /**
+   * 安排重连
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      return;
+    }
+    this.logger.info(`Scheduling reconnect in ${this.config.reconnectInterval}ms`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, this.config.reconnectInterval);
+  }
+  /**
+   * 发送消息到服务器
+   */
+  send(message) {
+    if (!this.ws || this.state !== "connected") {
+      throw new Error("WebSocket not connected");
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+      this.logger.debug("Sent message to server", { type: message.type });
+    } catch (error) {
+      this.logger.error("Failed to send message", error);
+      throw error;
+    }
+  }
+  /**
+   * 发送通知到鸿蒙 App
+   */
+  sendNotification(deviceId, notification) {
+    const message = {
+      type: "send_message" /* SEND_MESSAGE */,
+      id: this.generateMessageId(),
+      timestamp: Date.now(),
+      payload: {
+        deviceId,
+        message: {
+          id: this.generateMessageId(),
+          type: "notify_action",
+          timestamp: Date.now(),
+          payload: notification
+        }
+      }
+    };
+    this.send(message);
+  }
+  /**
+   * 处理 App 消息
+   */
+  handleAppMessage(message) {
+    if (message.type !== "app_message" /* APP_MESSAGE */) return;
+    const appMessage = message;
+    this.logger.info("Received message from App", {
+      deviceId: appMessage.payload.deviceId,
+      messageType: appMessage.payload.message.type
+    });
+    if (this.config.messageHandler) {
+      Promise.resolve(this.config.messageHandler(appMessage)).catch((error) => {
+        this.logger.error("Error handling App message", error);
+      });
+    }
+  }
+  /**
+   * 处理消息发送成功
+   */
+  handleMessageDelivered(message) {
+    this.logger.debug("Message delivered successfully", {
+      messageId: message.id
+    });
+  }
+  /**
+   * 处理消息发送失败
+   */
+  handleMessageFailed(message) {
+    this.logger.warn("Message delivery failed", {
+      messageId: message.id
+    });
+  }
+  /**
+   * 处理服务器错误
+   */
+  handleError(message) {
+    this.logger.error("Server error", message);
+  }
+  /**
+   * 注册消息处理器
+   */
+  registerMessageHandler(type, handler) {
+    this.messageHandlers.set(type, handler);
+  }
+  /**
+   * 发送事件
+   */
+  emitEvent(event) {
+    if (this.config.eventHandler) {
+      this.config.eventHandler(event);
+    }
+  }
+  /**
+   * 断开连接
+   */
+  disconnect() {
+    this.logger.info("Disconnecting WebSocket from Lingyao server");
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.state = "disconnected";
+    this.connectionId = null;
+  }
+  /**
+   * 获取连接状态
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * 获取连接 ID
+   */
+  getConnectionId() {
+    return this.connectionId;
+  }
+  /**
+   * 是否已连接
+   */
+  isConnected() {
+    return this.state === "connected";
+  }
+  /**
+   * 生成消息 ID
+   */
+  generateMessageId() {
+    return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+  }
+  /**
+   * 生成连接 ID
+   */
+  generateConnectionId() {
+    return `conn_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+  }
+};
+
+// src/accounts.ts
+var STORAGE_KEY_ACCOUNTS = "lingyao:accounts";
+var STORAGE_KEY_PENDING_PAIRINGS = "lingyao:pending_pairings";
+var AccountManager = class {
+  runtime;
+  accounts = /* @__PURE__ */ new Map();
+  pendingPairings = /* @__PURE__ */ new Map();
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  /**
+   * Initialize account manager from storage
+   */
+  async initialize() {
+    try {
+      const stored = await this.runtime.storage.get(STORAGE_KEY_ACCOUNTS);
+      if (stored && Array.isArray(stored)) {
+        for (const account of stored) {
+          this.accounts.set(account.deviceId, account);
+        }
+      }
+      const pending = await this.runtime.storage.get(STORAGE_KEY_PENDING_PAIRINGS);
+      if (pending && Array.isArray(pending)) {
+        const now = Date.now();
+        for (const session of pending) {
+          if (session.expiresAt > now) {
+            this.pendingPairings.set(session.code, session);
+          }
+        }
+      }
+      this.runtime.logger.info(
+        `AccountManager initialized: ${this.accounts.size} accounts, ${this.pendingPairings.size} pending pairings`
+      );
+    } catch (error) {
+      this.runtime.logger.error("Failed to initialize AccountManager", error);
+    }
+  }
+  /**
+   * Get account by device ID
+   */
+  getAccount(deviceId) {
+    return this.accounts.get(deviceId);
+  }
+  /**
+   * Get account by device token
+   */
+  getAccountByToken(token) {
+    for (const account of this.accounts.values()) {
+      if (account.deviceToken.token === token) {
+        return account;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all active accounts
+   */
+  getActiveAccounts() {
+    return Array.from(this.accounts.values()).filter(
+      (acc) => acc.status === "active"
+    );
+  }
+  /**
+   * Create a new pairing session
+   */
+  async createPairingSession(code, expiresAt) {
+    const session = {
+      code,
+      createdAt: Date.now(),
+      expiresAt
+    };
+    this.pendingPairings.set(code, session);
+    await this.savePendingPairings();
+  }
+  /**
+   * Get pairing session by code
+   */
+  getPairingSession(code) {
+    return this.pendingPairings.get(code);
+  }
+  /**
+   * Remove a pending pairing (e.g. expired or cancelled)
+   */
+  async deletePendingPairing(code) {
+    if (!this.pendingPairings.delete(code)) {
+      return;
+    }
+    await this.savePendingPairings();
+  }
+  /**
+   * Confirm pairing and create account
+   */
+  async confirmPairing(pairingCode, deviceToken, deviceInfo) {
+    const session = this.pendingPairings.get(pairingCode);
+    if (!session) {
+      return null;
+    }
+    const now = Date.now();
+    if (session.expiresAt < now) {
+      this.pendingPairings.delete(pairingCode);
+      await this.savePendingPairings();
+      return null;
+    }
+    const account = {
+      deviceId: deviceToken.deviceId,
+      deviceInfo,
+      deviceToken,
+      pairedAt: now,
+      lastSeenAt: now,
+      status: "active"
+    };
+    this.accounts.set(deviceToken.deviceId, account);
+    this.pendingPairings.delete(pairingCode);
+    await Promise.all([
+      this.saveAccounts(),
+      this.savePendingPairings()
+    ]);
+    this.runtime.logger.info(
+      `Account paired: ${deviceToken.deviceId} (${deviceInfo.name})`
+    );
+    return account;
+  }
+  /**
+   * Update account's last seen timestamp
+   */
+  async updateLastSeen(deviceId) {
+    const account = this.accounts.get(deviceId);
+    if (account) {
+      account.lastSeenAt = Date.now();
+      await this.saveAccounts();
+    }
+  }
+  /**
+   * Revoke an account
+   */
+  async revokeAccount(deviceId) {
+    const account = this.accounts.get(deviceId);
+    if (!account) {
+      return false;
+    }
+    account.status = "revoked";
+    await this.saveAccounts();
+    this.runtime.logger.info(`Account revoked: ${deviceId}`);
+    return true;
+  }
+  /**
+   * Refresh device token
+   */
+  async refreshDeviceToken(deviceId, newToken) {
+    const account = this.accounts.get(deviceId);
+    if (!account) {
+      return false;
+    }
+    account.deviceToken = newToken;
+    await this.saveAccounts();
+    this.runtime.logger.info(`Token refreshed for: ${deviceId}`);
+    return true;
+  }
+  /**
+   * Clean up expired accounts
+   */
+  async cleanupExpired() {
+    const now = Date.now();
+    const expired = [];
+    for (const [deviceId, account] of this.accounts.entries()) {
+      if (account.deviceToken.expiresAt < now) {
+        expired.push(deviceId);
+      }
+    }
+    for (const deviceId of expired) {
+      this.accounts.delete(deviceId);
+    }
+    if (expired.length > 0) {
+      await this.saveAccounts();
+      this.runtime.logger.info(`Cleaned up ${expired.length} expired accounts`);
+    }
+  }
+  /**
+   * Save accounts to storage
+   */
+  async saveAccounts() {
+    const accounts = Array.from(this.accounts.values());
+    await this.runtime.storage.set(STORAGE_KEY_ACCOUNTS, accounts);
+  }
+  /**
+   * Save pending pairings to storage
+   */
+  async savePendingPairings() {
+    const sessions = Array.from(this.pendingPairings.values());
+    await this.runtime.storage.set(STORAGE_KEY_PENDING_PAIRINGS, sessions);
+  }
+};
+
+// src/crypto.ts
+import { createHmac, createHash, randomBytes, timingSafeEqual } from "crypto";
+var CryptoManager = class {
+  /**
+   * Sign a message with HMAC-SHA256
+   */
+  static signMessage(message, secret) {
+    const messageString = this.prepareMessageForSigning(message);
+    return createHmac("sha256", secret).update(messageString).digest("base64");
+  }
+  /**
+   * Verify a message signature
+   */
+  static verifyMessage(message, signature, secret) {
+    try {
+      const expectedSignature = this.signMessage(message, secret);
+      const expectedBuffer = Buffer.from(expectedSignature);
+      const providedBuffer = Buffer.from(signature);
+      if (expectedBuffer.length !== providedBuffer.length) {
+        return false;
+      }
+      return timingSafeEqual(expectedBuffer, providedBuffer);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Sign any data string
+   */
+  static sign(data, secret) {
+    return createHmac("sha256", secret).update(data).digest("base64");
+  }
+  /**
+   * Verify data signature
+   */
+  static verify(data, signature, secret) {
+    try {
+      const expectedSignature = this.sign(data, secret);
+      const expectedBuffer = Buffer.from(expectedSignature);
+      const providedBuffer = Buffer.from(signature);
+      if (expectedBuffer.length !== providedBuffer.length) {
+        return false;
+      }
+      return timingSafeEqual(expectedBuffer, providedBuffer);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Generate a random nonce
+   */
+  static generateNonce() {
+    return randomBytes(16).toString("hex");
+  }
+  /**
+   * Hash data using SHA-256
+   */
+  static hash(data) {
+    return createHash("sha256").update(data).digest("hex");
+  }
+  /**
+   * Generate a cryptographically random ID
+   */
+  static generateId() {
+    return randomBytes(16).toString("hex");
+  }
+  /**
+   * Prepare message for signing by serializing in a deterministic way
+   */
+  static prepareMessageForSigning(message) {
+    const parts = [
+      message.id,
+      message.type,
+      message.timestamp.toString(),
+      message.from,
+      message.to,
+      JSON.stringify(message.payload)
+    ];
+    return parts.join("|");
+  }
+  /**
+   * Encrypt data (for future use)
+   */
+  static encrypt(data, _key) {
+    const iv = randomBytes(16);
+    return {
+      encrypted: data,
+      // Placeholder
+      iv: iv.toString("hex")
+    };
+  }
+  /**
+   * Decrypt data (for future use)
+   */
+  static decrypt(encrypted, _key, _iv) {
+    return encrypted;
+  }
+  /**
+   * Derive a key from a password and salt
+   */
+  static deriveKey(password, salt) {
+    return createHmac("sha256", salt).update(password).digest("hex");
+  }
+  /**
+   * Generate a fingerprint for a device
+   */
+  static generateDeviceFingerprint(deviceInfo) {
+    const data = JSON.stringify(deviceInfo, Object.keys(deviceInfo).sort());
+    return this.hash(data).substring(0, 16);
+  }
+  /**
+   * Verify message timestamp is within acceptable range
+   */
+  static verifyTimestamp(timestamp, maxDriftSeconds = 300) {
+    const now = Date.now();
+    const drift = Math.abs(now - timestamp);
+    return drift <= maxDriftSeconds * 1e3;
+  }
+  /**
+   * Check if a message is a replay attack
+   */
+  static checkReplay(messageId, seenMessages, _maxAge = 36e5) {
+    return seenMessages.has(messageId);
+  }
+  /**
+   * Mark a message as seen to prevent replay
+   */
+  static markMessageSeen(messageId, seenMessages, _maxAge = 36e5) {
+    seenMessages.add(messageId);
+    if (seenMessages.size > 1e4) {
+      const entries = Array.from(seenMessages);
+      for (let i = 0; i < entries.length / 2; i++) {
+        seenMessages.delete(entries[i]);
+      }
+    }
+  }
+};
+
+// src/bot.ts
+var MessageProcessor = class {
+  runtime;
+  accountManager;
+  messageQueue = /* @__PURE__ */ new Map();
+  seenMessages = /* @__PURE__ */ new Set();
+  messageHandler = null;
+  maxQueueSize = 100;
+  constructor(runtime, accountManager) {
+    this.runtime = runtime;
+    this.accountManager = accountManager;
+  }
+  /**
+   * 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");
+      return;
+    }
+    await this.messageHandler(message);
+  }
+  /**
+   * Process sync request from app
+   */
+  async processSync(deviceId, request) {
+    const account = this.accountManager.getAccount(deviceId);
+    if (!account) {
+      return {
+        processed: [],
+        failed: request.messages.map((m) => ({
+          id: m.id,
+          error: "Device not found"
+        }))
+      };
+    }
+    const processed = [];
+    const failed = [];
+    for (const message of request.messages) {
+      try {
+        if (message.signature) {
+          const isValid = CryptoManager.verifyMessage(
+            message,
+            message.signature,
+            account.deviceToken.secret
+          );
+          if (!isValid) {
+            failed.push({ id: message.id, error: "Invalid signature" });
+            continue;
+          }
+        }
+        if (this.isMessageSeen(message.id)) {
+          this.runtime.logger.debug(`Duplicate message ignored: ${message.id}`);
+          processed.push(message.id);
+          continue;
+        }
+        if (!CryptoManager.verifyTimestamp(message.timestamp)) {
+          failed.push({ id: message.id, error: "Invalid timestamp" });
+          continue;
+        }
+        const result = await this.processMessage(deviceId, message);
+        if (result.success) {
+          processed.push(message.id);
+          this.markMessageSeen(message.id);
+        } else {
+          failed.push({ id: message.id, error: result.error ?? "Processing failed" });
+        }
+      } catch (error) {
+        this.runtime.logger.error(`Error processing message ${message.id}`, error);
+        failed.push({ id: message.id, error: "Internal error" });
+      }
+    }
+    return { processed, failed };
+  }
+  /**
+   * Process a single message
+   */
+  async processMessage(deviceId, message) {
+    this.runtime.logger.debug(
+      `Processing message ${message.type} from ${deviceId}`
+    );
+    switch (message.type) {
+      case "sync_diary" /* SYNC_DIARY */:
+        return await this.processDiarySync(deviceId, message);
+      case "sync_memory" /* SYNC_MEMORY */:
+        return await this.processMemorySync(deviceId, message);
+      case "sync_ack" /* SYNC_ACK */:
+        return await this.processSyncAck(deviceId, message);
+      case "heartbeat" /* HEARTBEAT */:
+        return await this.processHeartbeat(deviceId, message);
+      default:
+        return { success: false, error: "Unknown message type" };
+    }
+  }
+  /**
+   * Process diary sync - Pass directly to Agent
+   */
+  async processDiarySync(deviceId, message) {
+    try {
+      const payload = message.payload;
+      const agentMessage = {
+        id: message.id,
+        type: "diary",
+        from: `lingyao:${deviceId}`,
+        deviceId,
+        content: payload.content,
+        metadata: {
+          diaryId: payload.diaryId,
+          title: payload.title,
+          emotion: payload.emotion,
+          tags: payload.tags,
+          mediaUrls: payload.mediaUrls,
+          createdAt: payload.createdAt,
+          updatedAt: payload.updatedAt
+        },
+        timestamp: message.timestamp
+      };
+      await this.deliverToAgent(agentMessage);
+      this.runtime.logger.info(
+        `Diary message passed to Agent: ${payload.diaryId} from ${deviceId}`
+      );
+      return { success: true };
+    } catch (error) {
+      this.runtime.logger.error("Diary sync error", error);
+      return { success: false, error: "Failed to sync diary" };
+    }
+  }
+  /**
+   * Process memory sync - Pass directly to Agent
+   */
+  async processMemorySync(deviceId, message) {
+    try {
+      const payload = message.payload;
+      const agentMessage = {
+        id: message.id,
+        type: "memory",
+        from: `lingyao:${deviceId}`,
+        deviceId,
+        content: payload.content,
+        metadata: {
+          memoryId: payload.memoryId,
+          memoryType: payload.type,
+          importance: payload.importance,
+          ...payload.metadata,
+          timestamp: payload.timestamp
+        },
+        timestamp: message.timestamp
+      };
+      await this.deliverToAgent(agentMessage);
+      this.runtime.logger.info(
+        `Memory message passed to Agent: ${payload.memoryId} from ${deviceId}`
+      );
+      return { success: true };
+    } catch (error) {
+      this.runtime.logger.error("Memory sync error", error);
+      return { success: false, error: "Failed to sync memory" };
+    }
+  }
+  /**
+   * Process sync acknowledgment
+   */
+  async processSyncAck(_deviceId, message) {
+    try {
+      this.runtime.logger.debug(`Sync ack received: ${message.id}`);
+      return { success: true };
+    } catch (error) {
+      this.runtime.logger.error("Sync ack error", error);
+      return { success: false, error: "Failed to process ack" };
+    }
+  }
+  /**
+   * Process heartbeat
+   */
+  async processHeartbeat(deviceId, _message) {
+    try {
+      await this.accountManager.updateLastSeen(deviceId);
+      return { success: true };
+    } catch (error) {
+      this.runtime.logger.error("Heartbeat error", error);
+      return { success: false, error: "Failed to process heartbeat" };
+    }
+  }
+  /**
+   * Poll for new messages (long-polling)
+   */
+  async pollMessages(deviceId, timeout = 3e4) {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const checkInterval = 100;
+      const checkForMessages = () => {
+        const queue = this.messageQueue.get(deviceId);
+        const messages = queue?.filter((m) => !m.delivered) ?? [];
+        if (messages.length > 0) {
+          for (const msg of messages) {
+            msg.delivered = true;
+          }
+          resolve(messages.map((m) => m.message));
+          return;
+        }
+        const elapsed = Date.now() - startTime;
+        if (elapsed >= timeout) {
+          resolve([]);
+          return;
+        }
+        setTimeout(checkForMessages, checkInterval);
+      };
+      checkForMessages();
+    });
+  }
+  /**
+   * Queue a message for a device
+   */
+  queueMessage(deviceId, message) {
+    let queue = this.messageQueue.get(deviceId);
+    if (!queue) {
+      queue = [];
+      this.messageQueue.set(deviceId, queue);
+    }
+    if (queue.length >= this.maxQueueSize) {
+      const oldestIndex = queue.findIndex((m) => !m.delivered);
+      if (oldestIndex >= 0) {
+        queue.splice(oldestIndex, 1);
+      } else {
+        this.runtime.logger.warn(
+          `Message queue full for ${deviceId}, dropping message`
+        );
+        return false;
+      }
+    }
+    queue.push({
+      message,
+      deviceId,
+      createdAt: Date.now(),
+      delivered: false
+    });
+    this.runtime.logger.debug(
+      `Message queued for ${deviceId}: ${message.id}`
+    );
+    return true;
+  }
+  /**
+   * Acknowledge messages
+   */
+  async acknowledgeMessages(messageIds) {
+    for (const deviceId of this.messageQueue.keys()) {
+      const queue = this.messageQueue.get(deviceId);
+      if (!queue) continue;
+      for (const msgId of messageIds) {
+        const index = queue.findIndex((m) => m.message.id === msgId);
+        if (index >= 0) {
+          queue.splice(index, 1);
+        }
+      }
+      if (queue.length === 0) {
+        this.messageQueue.delete(deviceId);
+      }
+    }
+    this.runtime.logger.debug(`Acknowledged ${messageIds.length} messages`);
+  }
+  /**
+   * Check if message has been seen (deduplication)
+   */
+  isMessageSeen(messageId) {
+    return this.seenMessages.has(messageId);
+  }
+  /**
+   * Mark message as seen
+   */
+  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]);
+      }
+    }
+  }
+  /**
+   * Get queue size for a device
+   */
+  getQueueSize(deviceId) {
+    const queue = this.messageQueue.get(deviceId);
+    return queue?.filter((m) => !m.delivered).length ?? 0;
+  }
+  /**
+   * Get total queue size
+   */
+  getTotalQueueSize() {
+    let total = 0;
+    for (const queue of this.messageQueue.values()) {
+      total += queue.filter((m) => !m.delivered).length;
+    }
+    return total;
+  }
+};
+
+// src/probe.ts
+var Probe = class {
+  runtime;
+  startTime = Date.now();
+  lastError = null;
+  lastErrorTime = null;
+  errorCounts = /* @__PURE__ */ new Map();
+  healthChecks = /* @__PURE__ */ new Map();
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.registerHealthCheck("uptime", this.checkUptime);
+    this.registerHealthCheck("errors", this.checkErrors);
+  }
+  /**
+   * Register a custom health check
+   */
+  registerHealthCheck(name, check) {
+    this.healthChecks.set(name, check);
+  }
+  /**
+   * Run all health checks
+   */
+  async runHealthChecks() {
+    const checks = /* @__PURE__ */ new Map();
+    let overallStatus = "healthy" /* HEALTHY */;
+    for (const [name, checkFn] of this.healthChecks.entries()) {
+      const start = Date.now();
+      try {
+        const result = await checkFn();
+        const duration = Date.now() - start;
+        checks.set(name, {
+          passed: result.passed,
+          message: result.message,
+          duration
+        });
+        if (!result.passed && overallStatus === "healthy" /* HEALTHY */) {
+          overallStatus = "degraded" /* DEGRADED */;
+        }
+      } catch (error) {
+        const duration = Date.now() - start;
+        checks.set(name, {
+          passed: false,
+          message: "Health check failed with exception",
+          duration,
+          error
+        });
+        overallStatus = "unhealthy" /* UNHEALTHY */;
+      }
+    }
+    return {
+      status: overallStatus,
+      checks,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Get channel status for reporting
+   */
+  getChannelStatus(configured, running, activeAccounts = 0) {
+    return {
+      configured,
+      running,
+      lastError: this.lastError ?? void 0,
+      activeAccounts,
+      uptime: Date.now() - this.startTime,
+      status: running ? "healthy" /* HEALTHY */ : "unhealthy" /* UNHEALTHY */
+    };
+  }
+  /**
+   * Get health status for API endpoint
+   */
+  async getHealthStatus(activeConnections = 0, queuedMessages = 0) {
+    const healthResult = await this.runHealthChecks();
+    let status;
+    switch (healthResult.status) {
+      case "healthy" /* HEALTHY */:
+        status = "healthy";
+        break;
+      case "degraded" /* DEGRADED */:
+        status = "degraded";
+        break;
+      case "unhealthy" /* UNHEALTHY */:
+        status = "unhealthy";
+        break;
+    }
+    return {
+      status,
+      uptime: Date.now() - this.startTime,
+      activeConnections,
+      queuedMessages,
+      lastError: this.lastError ?? void 0
+    };
+  }
+  /**
+   * Record an error
+   */
+  recordError(error, category = "general") {
+    this.lastError = error;
+    this.lastErrorTime = Date.now();
+    const count = this.errorCounts.get(category) ?? 0;
+    this.errorCounts.set(category, count + 1);
+    this.runtime.logger.error(`[${category}] ${error}`);
+  }
+  /**
+   * Get last error
+   */
+  getLastError() {
+    if (this.lastErrorTime && Date.now() - this.lastErrorTime < 3e5) {
+      return this.lastError;
+    }
+    return null;
+  }
+  /**
+   * Clear last error
+   */
+  clearLastError() {
+    this.lastError = null;
+    this.lastErrorTime = null;
+  }
+  /**
+   * Get error counts by category
+   */
+  getErrorCounts() {
+    return Object.fromEntries(this.errorCounts);
+  }
+  /**
+   * Reset error counts
+   */
+  resetErrorCounts() {
+    this.errorCounts.clear();
+  }
+  /**
+   * Get uptime in milliseconds
+   */
+  getUptime() {
+    return Date.now() - this.startTime;
+  }
+  /**
+   * Get uptime formatted as human-readable string
+   */
+  getUptimeString() {
+    const uptime = this.getUptime();
+    const seconds = Math.floor(uptime / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+      return `${days}d ${hours % 24}h ${minutes % 60}m`;
+    } else if (hours > 0) {
+      return `${hours}h ${minutes % 60}m`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    } else {
+      return `${seconds}s`;
+    }
+  }
+  /**
+   * Health check: uptime
+   */
+  checkUptime = async () => {
+    const uptime = this.getUptime();
+    return {
+      passed: uptime > 0,
+      message: `Uptime: ${this.getUptimeString()}`,
+      duration: 0
+    };
+  };
+  /**
+   * Health check: errors
+   */
+  checkErrors = async () => {
+    const recentErrors = this.lastErrorTime && Date.now() - this.lastErrorTime < 6e4;
+    return {
+      passed: !recentErrors,
+      message: recentErrors ? `Recent error: ${this.lastError}` : "No recent errors",
+      duration: 0
+    };
+  };
+  /**
+   * Create status adapter for OpenClaw integration
+   */
+  createStatusAdapter(configured) {
+    return {
+      getStatus: async (running, activeAccounts = 0, activeConnections = 0, queuedMessages = 0) => ({
+        ...this.getChannelStatus(configured, running, activeAccounts),
+        activeConnections,
+        queuedMessages
+      })
+    };
+  }
+};
+
+// src/metrics.ts
+var MetricsManager = class {
+  metrics = /* @__PURE__ */ new Map();
+  counters = /* @__PURE__ */ new Map();
+  gauges = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  histogramBuckets = /* @__PURE__ */ new Map();
+  constructor(_runtime) {
+    this.initializeDefaultMetrics();
+  }
+  /**
+   * 初始化默认指标
+   */
+  initializeDefaultMetrics() {
+    this.declareMetric({
+      name: "lingyao_connection_count",
+      type: "gauge" /* GAUGE */,
+      description: "\u5F53\u524D\u6D3B\u8DC3\u8FDE\u63A5\u6570"
+    });
+    this.declareMetric({
+      name: "lingyao_connection_total",
+      type: "counter" /* COUNTER */,
+      description: "\u603B\u8FDE\u63A5\u6B21\u6570"
+    });
+    this.declareMetric({
+      name: "lingyao_disconnection_total",
+      type: "counter" /* COUNTER */,
+      description: "\u603B\u65AD\u5F00\u8FDE\u63A5\u6B21\u6570"
+    });
+    this.declareMetric({
+      name: "lingyao_message_total",
+      type: "counter" /* COUNTER */,
+      description: "\u603B\u6D88\u606F\u6570",
+      labels: ["direction", "type"]
+    });
+    this.declareMetric({
+      name: "lingyao_message_failed_total",
+      type: "counter" /* COUNTER */,
+      description: "\u5931\u8D25\u6D88\u606F\u603B\u6570",
+      labels: ["direction", "reason"]
+    });
+    this.declareMetric({
+      name: "lingyao_message_latency",
+      type: "histogram" /* HISTOGRAM */,
+      description: "\u6D88\u606F\u5904\u7406\u5EF6\u8FDF",
+      buckets: [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4]
+    });
+    this.declareMetric({
+      name: "lingyao_error_total",
+      type: "counter" /* COUNTER */,
+      description: "\u9519\u8BEF\u603B\u6570",
+      labels: ["type", "severity"]
+    });
+    this.declareMetric({
+      name: "lingyao_heartbeat_total",
+      type: "counter" /* COUNTER */,
+      description: "\u5FC3\u8DF3\u603B\u6570"
+    });
+    this.declareMetric({
+      name: "lingyao_heartbeat_missed_total",
+      type: "counter" /* COUNTER */,
+      description: "\u5FC3\u8DF3\u4E22\u5931\u603B\u6570"
+    });
+    this.declareMetric({
+      name: "lingyao_reconnect_total",
+      type: "counter" /* COUNTER */,
+      description: "\u91CD\u8FDE\u6B21\u6570"
+    });
+    this.declareMetric({
+      name: "lingyao_queue_size",
+      type: "gauge" /* GAUGE */,
+      description: "\u5F53\u524D\u961F\u5217\u5927\u5C0F"
+    });
+  }
+  /**
+   * 声明指标
+   */
+  declareMetric(config) {
+    if (config.type === "histogram" /* HISTOGRAM */ && config.buckets) {
+      this.histogramBuckets.set(config.name, config.buckets);
+    }
+  }
+  /**
+   * 计数器增加
+   */
+  incrementCounter(name, value = 1, labels) {
+    const current = this.counters.get(name) || 0;
+    this.counters.set(name, current + value);
+    this.recordMetric({
+      name,
+      type: "counter" /* COUNTER */,
+      value: current + value,
+      timestamp: Date.now(),
+      labels
+    });
+  }
+  /**
+   * 设置仪表盘值
+   */
+  setGauge(name, value, labels) {
+    this.gauges.set(name, value);
+    this.recordMetric({
+      name,
+      type: "gauge" /* GAUGE */,
+      value,
+      timestamp: Date.now(),
+      labels
+    });
+  }
+  /**
+   * 记录直方图值
+   */
+  recordHistogram(name, value, labels) {
+    let values = this.histograms.get(name);
+    if (!values) {
+      values = [];
+      this.histograms.set(name, values);
+    }
+    values.push(value);
+    this.recordMetric({
+      name,
+      type: "histogram" /* HISTOGRAM */,
+      value,
+      timestamp: Date.now(),
+      labels
+    });
+  }
+  /**
+   * 记录指标
+   */
+  recordMetric(data) {
+    this.metrics.set(`${data.name}_${Date.now()}`, 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]);
+      }
+    }
+  }
+  /**
+   * 获取所有指标
+   */
+  getMetrics() {
+    return Array.from(this.metrics.values());
+  }
+  /**
+   * 获取特定指标的当前值
+   */
+  getMetricValue(name) {
+    if (this.counters.has(name)) {
+      return this.counters.get(name);
+    }
+    if (this.gauges.has(name)) {
+      return this.gauges.get(name);
+    }
+    return void 0;
+  }
+  /**
+   * 获取直方图统计数据
+   */
+  getHistogramStats(name) {
+    const values = this.histograms.get(name);
+    if (!values || values.length === 0) {
+      return null;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const count = sorted.length;
+    const sum = sorted.reduce((a, b) => a + b, 0);
+    return {
+      count,
+      min: sorted[0],
+      max: sorted[count - 1],
+      avg: sum / count,
+      p50: sorted[Math.floor(count * 0.5)],
+      p95: sorted[Math.floor(count * 0.95)],
+      p99: sorted[Math.floor(count * 0.99)]
+    };
+  }
+  /**
+   * 重置所有指标
+   */
+  reset() {
+    this.metrics.clear();
+    this.counters.clear();
+    this.gauges.clear();
+    this.histograms.clear();
+  }
+  /**
+   * 生成 Prometheus 格式的指标导出
+   */
+  exportPrometheus() {
+    const lines = [];
+    for (const [name, value] of [...this.counters, ...this.gauges]) {
+      lines.push(`${name} ${value}`);
+    }
+    for (const [name] of this.histograms) {
+      const stats = this.getHistogramStats(name);
+      if (stats) {
+        lines.push(`${name}_count ${stats.count}`);
+        lines.push(`${name}_sum ${stats.avg * stats.count}`);
+        lines.push(`${name}_bucket{le="+Inf"} ${stats.count}`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+var Monitor = class {
+  runtime;
+  metrics;
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.metrics = new MetricsManager(runtime);
+  }
+  /**
+   * 记录事件
+   */
+  recordEvent(event, data = {}) {
+    const eventData = {
+      event,
+      timestamp: Date.now(),
+      data
+    };
+    this.updateMetricsForEvent(event, data);
+    const handlers = this.eventHandlers.get(event) || [];
+    handlers.forEach((handler) => {
+      try {
+        handler(eventData);
+      } catch (error) {
+        this.runtime.logger.error("Error in monitoring event handler", error);
+      }
+    });
+    this.runtime.logger.debug(`Monitoring event: ${event}`, data);
+  }
+  /**
+   * 为事件更新指标
+   */
+  updateMetricsForEvent(event, data) {
+    switch (event) {
+      case "connection_open" /* CONNECTION_OPEN */:
+        this.metrics.incrementCounter("lingyao_connection_total");
+        this.metrics.setGauge("lingyao_connection_count", data.activeConnections || 1);
+        break;
+      case "connection_close" /* CONNECTION_CLOSE */:
+        this.metrics.incrementCounter("lingyao_disconnection_total");
+        this.metrics.setGauge("lingyao_connection_count", data.activeConnections || 0);
+        break;
+      case "reconnect" /* RECONNECT */:
+        this.metrics.incrementCounter("lingyao_reconnect_total");
+        break;
+      case "message_received" /* MESSAGE_RECEIVED */:
+        this.metrics.incrementCounter("lingyao_message_total", 1, {
+          direction: "in",
+          type: data.messageType || "unknown"
+        });
+        break;
+      case "message_sent" /* MESSAGE_SENT */:
+        this.metrics.incrementCounter("lingyao_message_total", 1, {
+          direction: "out",
+          type: data.messageType || "unknown"
+        });
+        break;
+      case "message_delivered" /* MESSAGE_DELIVERED */:
+        if (data.latency) {
+          this.metrics.recordHistogram("lingyao_message_latency", data.latency);
+        }
+        break;
+      case "message_failed" /* MESSAGE_FAILED */:
+        this.metrics.incrementCounter("lingyao_message_failed_total", 1, {
+          direction: data.direction || "unknown",
+          reason: data.reason || "unknown"
+        });
+        break;
+      case "heartbeat_sent" /* HEARTBEAT_SENT */:
+        this.metrics.incrementCounter("lingyao_heartbeat_total");
+        break;
+      case "heartbeat_missed" /* HEARTBEAT_MISSED */:
+        this.metrics.incrementCounter("lingyao_heartbeat_missed_total");
+        break;
+      case "error_occurred" /* ERROR_OCCURRED */:
+        this.metrics.incrementCounter("lingyao_error_total", 1, {
+          type: data.errorType || "unknown",
+          severity: data.severity || "medium"
+        });
+        break;
+    }
+  }
+  /**
+   * 注册事件处理器
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, []);
+    }
+    this.eventHandlers.get(event).push(handler);
+  }
+  /**
+   * 移除事件处理器
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      const index = handlers.indexOf(handler);
+      if (index > -1) {
+        handlers.splice(index, 1);
+      }
+    }
+  }
+  /**
+   * 获取指标管理器
+   */
+  getMetrics() {
+    return this.metrics;
+  }
+  /**
+   * 获取摘要报告
+   */
+  getSummary() {
+    return {
+      uptime: Date.now() - this.runtime.startTime,
+      connections: this.metrics.getMetricValue("lingyao_connection_total") || 0,
+      messages: {
+        sent: this.metrics.getMetricValue("lingyao_message_total") || 0,
+        received: this.metrics.getMetricValue("lingyao_message_total") || 0,
+        failed: this.metrics.getMetricValue("lingyao_message_failed_total") || 0
+      },
+      errors: this.metrics.getMetricValue("lingyao_error_total") || 0,
+      heartbeats: {
+        sent: this.metrics.getMetricValue("lingyao_heartbeat_total") || 0,
+        missed: this.metrics.getMetricValue("lingyao_heartbeat_missed_total") || 0
+      }
+    };
+  }
+};
+
+// src/errors.ts
+var LingyaoError = class extends Error {
+  code;
+  severity;
+  timestamp;
+  context;
+  cause;
+  constructor(message, code, severity = "medium" /* MEDIUM */, context, cause) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.severity = severity;
+    this.timestamp = Date.now();
+    this.context = context;
+    this.cause = cause;
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+   * 转换为 JSON 可序列化格式
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      severity: this.severity,
+      timestamp: this.timestamp,
+      context: this.context,
+      cause: this.cause?.message,
+      stack: this.stack
+    };
+  }
+};
+var ConnectionError = class extends LingyaoError {
+  constructor(message, context, cause) {
+    super(message, "CONNECTION_ERROR", "high" /* HIGH */, context, cause);
+  }
+};
+var RetryableError = class extends LingyaoError {
+  retryable;
+  retryAfter;
+  maxRetries;
+  constructor(message, context, cause) {
+    super(message, "RETRYABLE_ERROR", "low" /* LOW */, context, cause);
+    this.retryable = true;
+    this.retryAfter = context?.retryAfter;
+    this.maxRetries = context?.maxRetries;
+  }
+};
+var ErrorHandler = class {
+  runtime;
+  errorCounts = /* @__PURE__ */ new Map();
+  lastErrors = /* @__PURE__ */ new Map();
+  errorThresholds = /* @__PURE__ */ new Map();
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.setErrorThreshold("CONNECTION_ERROR", { count: 5, window: 6e4 });
+    this.setErrorThreshold("AUTHENTICATION_ERROR", { count: 3, window: 6e4 });
+    this.setErrorThreshold("NETWORK_ERROR", { count: 10, window: 6e4 });
+  }
+  /**
+   * 处理错误
+   */
+  handleError(error) {
+    const lingyaoError = error instanceof LingyaoError ? error : new LingyaoError(error.message, "UNKNOWN_ERROR", "medium" /* MEDIUM */, {}, error);
+    this.recordError(lingyaoError);
+    switch (lingyaoError.severity) {
+      case "low" /* LOW */:
+        this.runtime.logger.debug(lingyaoError.message, lingyaoError.toJSON());
+        break;
+      case "medium" /* MEDIUM */:
+        this.runtime.logger.warn(lingyaoError.message, lingyaoError.toJSON());
+        break;
+      case "high" /* HIGH */:
+      case "critical" /* CRITICAL */:
+        this.runtime.logger.error(lingyaoError.message, lingyaoError.toJSON());
+        break;
+    }
+    this.checkThresholds(lingyaoError);
+  }
+  /**
+   * 记录错误
+   */
+  recordError(error) {
+    const key = error.code;
+    const count = (this.errorCounts.get(key) || 0) + 1;
+    this.errorCounts.set(key, count);
+    this.lastErrors.set(key, {
+      error,
+      timestamp: Date.now()
+    });
+    setTimeout(() => {
+      const lastError = this.lastErrors.get(key);
+      if (lastError && lastError.timestamp === error.timestamp) {
+        this.errorCounts.set(key, (this.errorCounts.get(key) || 0) - 1);
+      }
+    }, 36e5);
+  }
+  /**
+   * 检查错误阈值
+   */
+  checkThresholds(error) {
+    const threshold = this.errorThresholds.get(error.code);
+    if (!threshold) {
+      return;
+    }
+    const count = this.errorCounts.get(error.code) || 0;
+    if (count >= threshold.count) {
+      this.runtime.logger.error(
+        `Error threshold exceeded for ${error.code}`,
+        {
+          code: error.code,
+          count,
+          threshold: threshold.count,
+          window: threshold.window
+        }
+      );
+      this.triggerAlert(error, count);
+    }
+  }
+  /**
+   * 触发警报
+   */
+  triggerAlert(error, count) {
+    this.runtime.logger.error("ALERT", {
+      type: "error_threshold_exceeded",
+      error: error.toJSON(),
+      count
+    });
+  }
+  /**
+   * 设置错误阈值
+   */
+  setErrorThreshold(code, threshold) {
+    this.errorThresholds.set(code, threshold);
+  }
+  /**
+   * 获取错误统计
+   */
+  getErrorStats() {
+    const byCode = {};
+    let total = 0;
+    for (const [code, count] of this.errorCounts) {
+      byCode[code] = count;
+      total += count;
+    }
+    const recent = Array.from(this.lastErrors.entries()).map(([code, { error, timestamp }]) => ({ code, error, timestamp })).sort((a, b) => b.timestamp - a.timestamp).slice(0, 10);
+    return { byCode, total, recent };
+  }
+  /**
+   * 重置错误计数
+   */
+  resetErrorCounts(code) {
+    if (code) {
+      this.errorCounts.delete(code);
+      this.lastErrors.delete(code);
+    } else {
+      this.errorCounts.clear();
+      this.lastErrors.clear();
+    }
+  }
+  /**
+   * 包装异步函数以自动处理错误
+   */
+  async wrapAsync(fn, context) {
+    try {
+      return await fn();
+    } catch (error) {
+      const operation = context?.operation || "unknown";
+      if (error instanceof LingyaoError) {
+        this.handleError(error);
+      } else if (context?.retryable) {
+        const retryableError = new RetryableError(
+          `Operation "${operation}" failed`,
+          { operation },
+          error
+        );
+        this.handleError(retryableError);
+      } else {
+        this.handleError(new LingyaoError(
+          `Operation "${operation}" failed: ${error.message}`,
+          "OPERATION_FAILED",
+          "medium" /* MEDIUM */,
+          { operation },
+          error
+        ));
+      }
+      if (context?.fallback !== void 0) {
+        return context.fallback;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 创建带有错误处理的重试逻辑
+   */
+  async retry(fn, options = {}) {
+    const {
+      maxRetries = 3,
+      retryDelay = 1e3,
+      backoff = true,
+      onRetry
+    } = options;
+    let lastError = null;
+    let delay = retryDelay;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (attempt === maxRetries) {
+          break;
+        }
+        if (onRetry) {
+          onRetry(lastError, attempt + 1);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (backoff) {
+          delay *= 2;
+        }
+      }
+    }
+    throw new RetryableError(
+      `Operation failed after ${maxRetries + 1} attempts`,
+      { maxRetries },
+      lastError ?? new Error("Unknown retry failure")
+    );
+  }
+  /**
+   * 判断错误是否可重试
+   */
+  isRetryable(error) {
+    if (error instanceof RetryableError) {
+      return error.retryable;
+    }
+    if (error instanceof LingyaoError) {
+      switch (error.code) {
+        case "NETWORK_ERROR":
+        case "TIMEOUT_ERROR":
+        case "CONNECTION_ERROR":
+          return true;
+        default:
+          return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * 判断错误是否需要降级处理
+   */
+  shouldDegrade(error) {
+    if (error instanceof LingyaoError) {
+      return error.severity === "high" /* HIGH */ || error.severity === "critical" /* CRITICAL */;
+    }
+    return false;
+  }
+  /**
+   * 创建降级响应
+   */
+  createDegradedResponse(fallback, error) {
+    return {
+      success: false,
+      degraded: true,
+      fallback,
+      error
+    };
+  }
+};
+
+// src/orchestrator.ts
+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}`;
+}
+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) {
+    const { id: accountId } = account;
+    const existing = this.accounts.get(accountId);
+    if (existing?.status === "running") {
+      this.runtime.logger.warn(`Account "${accountId}" is already running`);
+      return;
+    }
+    this.runtime.logger.info(`Starting account "${accountId}"`);
+    const gatewayId = generateGatewayId(accountId);
+    const storagePrefix = `lingyao:${accountId}`;
+    const accountManager = new AccountManager(this.runtime);
+    const messageProcessor = new MessageProcessor(this.runtime, accountManager);
+    const probe = new Probe(this.runtime);
+    const monitor = new Monitor(this.runtime);
+    const errorHandler = new ErrorHandler(this.runtime);
+    const httpClient = new ServerHttpClient(
+      this.runtime,
+      gatewayId,
+      { baseURL: LINGYAO_SERVER_URL },
+      storagePrefix
+    );
+    const state = {
+      accountId,
+      wsClient: null,
+      httpClient,
+      accountManager,
+      messageProcessor,
+      probe,
+      monitor,
+      errorHandler,
+      status: "starting",
+      startTime: Date.now(),
+      gatewayId
+    };
+    this.accounts.set(accountId, state);
+    try {
+      await accountManager.initialize();
+      await messageProcessor.initialize();
+      if (this.messageHandler) {
+        messageProcessor.setMessageHandler(this.messageHandler);
+      }
+      await this.registerToServer(state);
+      const wsClient = new LingyaoWSClient(this.runtime, {
+        url: `${LINGYAO_SERVER_URL}/v1/gateway/ws`,
+        gatewayId,
+        token: httpClient.getGatewayToken() ?? void 0,
+        reconnectInterval: 5e3,
+        heartbeatInterval: 3e4,
+        messageHandler: this.createMessageHandler(state),
+        eventHandler: this.createEventHandler(state)
+      });
+      await wsClient.connect();
+      state.wsClient = wsClient;
+      state.status = "running";
+      this.runtime.logger.info(`Account "${accountId}" started successfully`);
+    } catch (error) {
+      state.status = "error";
+      this.runtime.logger.error(`Failed to start account "${accountId}"`, error);
+      throw error;
+    }
+  }
+  /**
+   * Stop an account: disconnect WS, stop heartbeat.
+   */
+  async stop(accountId) {
+    const state = this.accounts.get(accountId);
+    if (!state || state.status === "stopped") {
+      return;
+    }
+    this.runtime.logger.info(`Stopping account "${accountId}"`);
+    state.status = "stopping";
+    if (state.wsClient) {
+      state.wsClient.disconnect();
+      state.wsClient = null;
+    }
+    if (state.httpClient) {
+      state.httpClient.stopHeartbeat();
+    }
+    state.status = "stopped";
+    this.runtime.logger.info(`Account "${accountId}" stopped`);
+  }
+  /**
+   * Stop all running accounts.
+   */
+  async stopAll() {
+    const stops = Array.from(this.accounts.keys()).map((id) => this.stop(id));
+    await Promise.all(stops);
+  }
+  /**
+   * Get account state by ID.
+   */
+  getAccountState(accountId) {
+    return this.accounts.get(accountId);
+  }
+  /**
+   * Get account's WS client.
+   */
+  getWSClient(accountId) {
+    return this.accounts.get(accountId)?.wsClient ?? null;
+  }
+  /**
+   * Get account's HTTP client.
+   */
+  getHttpClient(accountId) {
+    return this.accounts.get(accountId)?.httpClient ?? null;
+  }
+  /**
+   * Get account's AccountManager.
+   */
+  getAccountManager(accountId) {
+    return this.accounts.get(accountId)?.accountManager ?? null;
+  }
+  /**
+   * Get account's Probe.
+   */
+  getProbe(accountId) {
+    return this.accounts.get(accountId)?.probe ?? null;
+  }
+  /**
+   * Get account's Monitor.
+   */
+  getMonitor(accountId) {
+    return this.accounts.get(accountId)?.monitor ?? null;
+  }
+  /**
+   * Send notification to a device on a specific account.
+   * Returns true if sent, false if WS not connected.
+   */
+  sendNotification(accountId, deviceId, notification) {
+    const wsClient = this.getWSClient(accountId);
+    if (!wsClient || !wsClient.isConnected()) {
+      return false;
+    }
+    wsClient.sendNotification(deviceId, notification);
+    return true;
+  }
+  /**
+   * List all running account IDs.
+   */
+  getRunningAccountIds() {
+    return Array.from(this.accounts.entries()).filter(([, state]) => state.status === "running").map(([id]) => id);
+  }
+  /**
+   * Register to lingyao server for a specific account.
+   */
+  async registerToServer(state) {
+    if (!state.httpClient) {
+      throw new Error("HTTP client not available");
+    }
+    try {
+      const restored = await state.httpClient.restoreFromStorage();
+      if (restored) {
+        this.runtime.logger.info(`Account "${state.accountId}": session restored from storage`);
+        return;
+      }
+      this.runtime.logger.info(`Account "${state.accountId}": registering to server...`, {
+        gatewayId: state.gatewayId
+      });
+      const response = await state.httpClient.register({
+        websocket: true,
+        compression: false,
+        maxMessageSize: 1048576
+      });
+      this.runtime.logger.info(`Account "${state.accountId}": registered successfully`, {
+        expiresAt: new Date(response.expiresAt).toISOString()
+      });
+    } catch (error) {
+      this.runtime.logger.error(`Account "${state.accountId}": registration failed`, error);
+    }
+  }
+  /**
+   * Create message handler for inbound App messages on a specific account.
+   */
+  createMessageHandler(state) {
+    return async (message) => {
+      try {
+        const appMessage = message.payload;
+        const deviceId = appMessage.deviceId;
+        const msg = appMessage.message;
+        this.runtime.logger.info(`[${state.accountId}] Received message from App`, {
+          deviceId,
+          messageType: msg.type,
+          messageId: msg.id
+        });
+        state.monitor.recordEvent("message_received" /* MESSAGE_RECEIVED */, {
+          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 });
+        }
+      } catch (error) {
+        this.runtime.logger.error(`[${state.accountId}] Error handling App message`, error);
+        state.monitor.recordEvent("error_occurred" /* ERROR_OCCURRED */, {
+          errorType: "message_handling"
+        });
+      }
+    };
+  }
+  /**
+   * Handle sync message (diary or memory).
+   */
+  async handleSyncMessage(state, deviceId, message) {
+    if (!state.messageProcessor) {
+      this.runtime.logger.warn(`[${state.accountId}] Message processor not initialized`);
+      return;
+    }
+    const agentMessage = {
+      id: message.id,
+      type: message.type === "sync_diary" ? "diary" : "memory",
+      from: deviceId,
+      deviceId,
+      content: message.content,
+      metadata: message.metadata || {},
+      timestamp: message.timestamp
+    };
+    await state.messageProcessor.deliverToAgent(agentMessage);
+  }
+  /**
+   * Create event handler for WS connection events on a specific account.
+   */
+  createEventHandler(state) {
+    return (event) => {
+      switch (event.type) {
+        case "connected":
+          this.runtime.logger.info(`[${state.accountId}] WS connected`, {
+            connectionId: event.connectionId
+          });
+          state.monitor.recordEvent("connection_open" /* CONNECTION_OPEN */, {
+            connectionId: event.connectionId
+          });
+          break;
+        case "disconnected":
+          this.runtime.logger.warn(`[${state.accountId}] WS disconnected`, {
+            code: event.code,
+            reason: event.reason
+          });
+          state.monitor.recordEvent("connection_close" /* CONNECTION_CLOSE */, {
+            code: event.code,
+            reason: event.reason
+          });
+          break;
+        case "error":
+          this.runtime.logger.error(`[${state.accountId}] WS error`, event.error);
+          state.probe.recordError(event.error.message, "websocket");
+          state.monitor.recordEvent("connection_error" /* CONNECTION_ERROR */, {
+            error: event.error
+          });
+          state.errorHandler.handleError(event.error);
+          break;
+      }
+    };
+  }
+};
+
+// src/channel.ts
+import { hostname as hostname2 } from "os";
+
+// src/token.ts
+import { randomBytes as randomBytes2, createHash as createHash2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+var TokenManager = class {
+  constructor(_runtime) {
+    void _runtime;
+  }
+  /**
+   * Generate a new device token
+   */
+  generateDeviceToken(pairingId, deviceInfo, expiryDays = 30) {
+    const deviceId = this.generateDeviceId();
+    const secret = this.generateSecret();
+    const token = this.generateTokenString(deviceId, secret);
+    const expiresAt = Date.now() + expiryDays * 24 * 60 * 60 * 1e3;
+    return {
+      deviceId,
+      pairingId,
+      token,
+      secret,
+      expiresAt,
+      deviceInfo
+    };
+  }
+  /**
+   * Validate a device token
+   */
+  validateToken(token, storedSecret) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) {
+        return false;
+      }
+      const [headerB64, payloadB64, signatureB64] = parts;
+      const expectedSignature = this.sign(`${headerB64}.${payloadB64}`, storedSecret);
+      const providedSignature = Buffer.from(signatureB64, "base64url").toString("utf-8");
+      return timingSafeEqual2(
+        Buffer.from(expectedSignature, "utf-8"),
+        Buffer.from(providedSignature, "utf-8")
+      );
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if token is expired
+   */
+  isTokenExpired(token) {
+    return token.expiresAt < Date.now();
+  }
+  /**
+   * Refresh an existing token
+   */
+  refreshToken(oldToken, expiryDays = 30) {
+    const newSecret = this.generateSecret();
+    const newTokenString = this.generateTokenString(
+      oldToken.deviceId,
+      newSecret
+    );
+    const expiresAt = Date.now() + expiryDays * 24 * 60 * 60 * 1e3;
+    return {
+      ...oldToken,
+      token: newTokenString,
+      secret: newSecret,
+      expiresAt
+    };
+  }
+  /**
+   * Extract device ID from token string
+   */
+  extractDeviceId(token) {
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) {
+        return null;
+      }
+      const payload = JSON.parse(
+        Buffer.from(parts[1], "base64url").toString("utf-8")
+      );
+      return payload.did || null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Generate a unique device ID
+   */
+  generateDeviceId() {
+    return `lingyao_${randomBytes2(16).toString("hex")}`;
+  }
+  /**
+   * Generate a random secret key
+   */
+  generateSecret() {
+    return randomBytes2(32).toString("hex");
+  }
+  /**
+   * Generate a JWT-like token string
+   */
+  generateTokenString(deviceId, secret) {
+    const header = {
+      alg: "HS256",
+      typ: "LingyaoToken"
+    };
+    const payload = {
+      did: deviceId,
+      iat: Date.now()
+    };
+    const headerB64 = this.base64UrlEncode(JSON.stringify(header));
+    const payloadB64 = this.base64UrlEncode(JSON.stringify(payload));
+    const signature = this.sign(`${headerB64}.${payloadB64}`, secret);
+    const signatureB64 = this.base64UrlEncode(signature);
+    return `${headerB64}.${payloadB64}.${signatureB64}`;
+  }
+  /**
+   * Sign data with secret
+   */
+  sign(data, secret) {
+    return createHash2("sha256").update(data + secret).digest("base64");
+  }
+  /**
+   * Base64URL encode without padding
+   */
+  base64UrlEncode(data) {
+    return Buffer.from(data).toString("base64url").replace(/=/g, "");
+  }
+};
+
+// src/channel.ts
+var LingyaoChannel = class {
+  runtime;
+  config;
+  accountManager;
+  tokenManager;
+  serverClient = null;
+  wsClient = null;
+  processor = null;
+  probe;
+  monitor;
+  errorHandler;
+  startTime = 0;
+  gatewayId;
+  isRunning = false;
+  messageHandler = null;
+  constructor(runtime, config) {
+    this.runtime = runtime;
+    this.config = config;
+    this.startTime = Date.now();
+    this.gatewayId = this.generateGatewayId();
+    setRuntime(runtime);
+    this.accountManager = new AccountManager(runtime);
+    this.tokenManager = new TokenManager(runtime);
+    this.probe = new Probe(runtime);
+    this.monitor = new Monitor(runtime);
+    this.errorHandler = new ErrorHandler(runtime);
+    this.serverClient = new ServerHttpClient(runtime, this.gatewayId, {
+      baseURL: LINGYAO_SERVER_URL,
+      apiBase: "/v1"
+    });
+  }
+  /**
+   * 初始化频道
+   */
+  async initialize() {
+    this.runtime.logger.info("Initializing Lingyao Channel (Server Relay Mode)...");
+    await this.accountManager.initialize();
+    this.processor = new MessageProcessor(
+      this.runtime,
+      this.accountManager
+    );
+    await this.processor.initialize();
+    if (this.messageHandler) {
+      this.processor.setMessageHandler(this.messageHandler);
+    }
+    this.runtime.logger.info("Lingyao Channel initialized successfully");
+  }
+  /**
+   * 启动频道
+   */
+  async start() {
+    if (this.isRunning) {
+      this.runtime.logger.warn("Lingyao Channel is already running");
+      return;
+    }
+    this.runtime.logger.info("Starting Lingyao Channel...");
+    try {
+      await this.registerToServer();
+      this.wsClient = new LingyaoWSClient(this.runtime, {
+        url: `${LINGYAO_SERVER_URL}/v1/gateway/ws`,
+        gatewayId: this.gatewayId,
+        token: this.serverClient?.getGatewayToken() ?? void 0,
+        reconnectInterval: 5e3,
+        heartbeatInterval: 3e4,
+        messageHandler: this.handleAppMessage.bind(this),
+        eventHandler: this.handleClientEvent.bind(this)
+      });
+      await this.wsClient.connect();
+      this.isRunning = true;
+      this.runtime.logger.info("Lingyao Channel started successfully");
+    } catch (error) {
+      this.runtime.logger.error("Failed to start Lingyao Channel", error);
+      throw error;
+    }
+  }
+  /**
+   * 向 lingyao 服务器注册 Gateway
+   */
+  async registerToServer() {
+    if (!this.serverClient) {
+      throw new Error("Server client not available");
+    }
+    try {
+      const restored = await this.serverClient.restoreFromStorage();
+      if (restored) {
+        this.runtime.logger.info("Previous server registration restored");
+        return;
+      }
+      this.runtime.logger.info("Registering to lingyao server...", {
+        gatewayId: this.gatewayId
+      });
+      const registerResponse = await this.serverClient.register({
+        websocket: true,
+        compression: false,
+        maxMessageSize: 1048576
+      });
+      this.runtime.logger.info("Registered to lingyao server successfully", {
+        expiresAt: new Date(registerResponse.expiresAt).toISOString(),
+        heartbeatInterval: registerResponse.serverConfig.heartbeatInterval
+      });
+    } catch (error) {
+      const err = error;
+      this.runtime.logger.error("Failed to register to server", err);
+      this.runtime.logger.info("Will attempt WebSocket connection anyway");
+    }
+  }
+  /**
+   * 处理来自鸿蒙 App 的消息
+   */
+  async handleAppMessage(message) {
+    try {
+      const appMessage = message.payload;
+      const deviceId = appMessage.deviceId;
+      const msg = appMessage.message;
+      this.runtime.logger.info("Received message from App", {
+        deviceId,
+        messageType: msg.type,
+        messageId: msg.id
+      });
+      this.monitor.recordEvent("message_received" /* MESSAGE_RECEIVED */, {
+        deviceId,
+        messageType: msg.type,
+        messageId: msg.id
+      });
+      switch (msg.type) {
+        case "sync_diary":
+        case "sync_memory":
+          await this.handleSyncMessage(deviceId, msg);
+          break;
+        case "heartbeat":
+          this.monitor.recordEvent("heartbeat_received" /* HEARTBEAT_RECEIVED */, {
+            deviceId
+          });
+          break;
+        default:
+          this.runtime.logger.warn("Unknown message type", { type: msg.type });
+      }
+    } catch (error) {
+      this.runtime.logger.error("Error handling App message", error);
+      this.monitor.recordEvent("error_occurred" /* ERROR_OCCURRED */, {
+        errorType: "message_handling",
+        severity: "medium"
+      });
+    }
+  }
+  /**
+   * 处理同步消息（日记、记忆等）
+   */
+  async handleSyncMessage(deviceId, message) {
+    if (!this.processor) {
+      this.runtime.logger.warn("Message processor not initialized");
+      return;
+    }
+    const agentMessage = {
+      id: message.id,
+      type: this.mapMessageType(message.type),
+      from: deviceId,
+      deviceId,
+      content: message.content,
+      metadata: message.metadata || {},
+      timestamp: message.timestamp
+    };
+    await this.processor.deliverToAgent(agentMessage);
+  }
+  /**
+   * 映射消息类型
+   */
+  mapMessageType(appType) {
+    return appType === "sync_diary" ? "diary" : "memory";
+  }
+  /**
+   * 处理 WebSocket 客户端事件
+   */
+  handleClientEvent(event) {
+    this.runtime.logger.debug("WebSocket client event", { type: event.type });
+    switch (event.type) {
+      case "connected":
+        this.runtime.logger.info("Connected to Lingyao server", {
+          connectionId: event.connectionId
+        });
+        this.monitor.recordEvent("connection_open" /* CONNECTION_OPEN */, {
+          connectionId: event.connectionId
+        });
+        break;
+      case "disconnected":
+        this.runtime.logger.warn("Disconnected from Lingyao server", {
+          code: event.code,
+          reason: event.reason
+        });
+        this.monitor.recordEvent("connection_close" /* CONNECTION_CLOSE */, {
+          code: event.code,
+          reason: event.reason
+        });
+        break;
+      case "error":
+        this.runtime.logger.error("WebSocket client error", event.error);
+        this.probe.recordError(event.error.message, "websocket");
+        this.monitor.recordEvent("connection_error" /* CONNECTION_ERROR */, {
+          error: event.error
+        });
+        this.errorHandler.handleError(
+          new ConnectionError(
+            `WebSocket error: ${event.error.message}`,
+            { event: event.type },
+            event.error
+          )
+        );
+        break;
+    }
+  }
+  /**
+   * 停止频道
+   */
+  async stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.runtime.logger.info("Stopping Lingyao Channel...");
+    this.isRunning = false;
+    if (this.wsClient) {
+      this.wsClient.disconnect();
+      this.wsClient = null;
+    }
+    if (this.serverClient) {
+      this.serverClient.stopHeartbeat();
+    }
+    this.runtime.logger.info("Lingyao Channel stopped");
+  }
+  /**
+   * 发送通知到设备
+   */
+  async sendNotification(deviceId, notification) {
+    if (!this.wsClient || !this.wsClient.isConnected()) {
+      this.monitor.recordEvent("message_failed" /* MESSAGE_FAILED */, {
+        deviceId,
+        reason: "not_connected",
+        direction: "out"
+      });
+      return {
+        success: false,
+        error: "Not connected to Lingyao server"
+      };
+    }
+    try {
+      this.wsClient.sendNotification(deviceId, notification);
+      this.monitor.recordEvent("message_sent" /* MESSAGE_SENT */, {
+        deviceId,
+        messageType: "notification"
+      });
+      return { success: true };
+    } catch (error) {
+      const err = error;
+      this.monitor.recordEvent("message_failed" /* MESSAGE_FAILED */, {
+        deviceId,
+        reason: err.message,
+        direction: "out"
+      });
+      return {
+        success: false,
+        error: err.message
+      };
+    }
+  }
+  /**
+   * 发送文本到设备
+   */
+  async sendText(deviceId, text) {
+    return await this.sendNotification(deviceId, {
+      title: "OpenClaw",
+      body: text
+    });
+  }
+  /**
+   * 获取健康状态
+   */
+  async getHealthStatus() {
+    const activeConnections = this.wsClient?.isConnected() ? 1 : 0;
+    const queuedMessages = this.processor?.getTotalQueueSize() ?? 0;
+    const lastError = this.probe.getLastError() ?? void 0;
+    let status = "healthy";
+    if (lastError) {
+      status = "degraded";
+    }
+    if (!this.config.enabled) {
+      status = "unhealthy";
+    }
+    if (!this.wsClient?.isConnected()) {
+      status = "degraded";
+    }
+    const uptime = Date.now() - this.startTime;
+    return {
+      status,
+      uptime,
+      activeConnections,
+      queuedMessages,
+      lastError
+    };
+  }
+  /**
+   * 获取配置
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * 更新配置
+   */
+  async updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+    this.runtime.logger.info("Configuration updated", updates);
+  }
+  /**
+   * 获取账号管理器
+   */
+  getAccountManager() {
+    return this.accountManager;
+  }
+  /**
+   * 获取 Token 管理器
+   */
+  getTokenManager() {
+    return this.tokenManager;
+  }
+  /**
+   * 获取服务器客户端
+   */
+  getServerClient() {
+    return this.serverClient;
+  }
+  /**
+  /**
+   * 获取 WebSocket 客户端
+   */
+  getWSClient() {
+    return this.wsClient;
+  }
+  /**
+   * 获取消息处理器
+   */
+  getMessageProcessor() {
+    return this.processor;
+  }
+  /**
+   * 设置消息处理器
+   */
+  setMessageHandler(handler) {
+    this.messageHandler = handler;
+    if (this.processor) {
+      this.processor.setMessageHandler(handler);
+    }
+    this.runtime.logger.info("Message handler registered for Agent integration");
+  }
+  /**
+   * 获取监控器
+   */
+  getMonitor() {
+    return this.monitor;
+  }
+  /**
+   * 获取错误处理器
+   */
+  getErrorHandler() {
+    return this.errorHandler;
+  }
+  /**
+   * 获取监控摘要
+   */
+  getMonitoringSummary() {
+    return this.monitor.getSummary();
+  }
+  /**
+   * 获取错误统计
+   */
+  getErrorStats() {
+    return this.errorHandler.getErrorStats();
+  }
+  /**
+   * 生成 Gateway ID
+   */
+  generateGatewayId() {
+    const hostname3 = this.getRuntimeHostname();
+    const randomSuffix = Math.random().toString(36).substring(2, 8);
+    return `gw_openclaw_${hostname3}_${randomSuffix}`;
+  }
+  /**
+   * 获取运行时主机名
+   */
+  getRuntimeHostname() {
+    try {
+      return hostname2().split(".")[0].replace(/[^a-z0-9]/gi, "").toLowerCase();
+    } catch {
+      return "unknown";
+    }
+  }
+};
+
+// src/config-schema.ts
+import { z } from "zod";
+var lingyaoConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  maxOfflineMessages: z.number().int().min(1).max(1e3).optional().default(100),
+  tokenExpiryDays: z.number().int().min(1).max(365).optional().default(30)
+});
+function validateConfig(config) {
+  return lingyaoConfigSchema.parse(config);
+}
+function getDefaultConfig() {
+  return {
+    enabled: true,
+    maxOfflineMessages: 100,
+    tokenExpiryDays: 30
+  };
+}
+
+// src/index.ts
+var orchestrator = null;
+function getOrchestrator() {
+  return orchestrator;
+}
+var configAdapter = createConfigAdapter();
+var messagingAdapter = createMessagingAdapter();
+var gatewayAdapter = createGatewayAdapter(getOrchestrator);
+var directoryAdapter = createDirectoryAdapter(getOrchestrator);
+var outboundAdapter = createOutboundAdapter(getOrchestrator);
+var statusAdapter = null;
+function getStatusAdapter(runtime) {
+  if (!statusAdapter) {
+    statusAdapter = createStatusAdapter(getOrchestrator, runtime);
+  }
+  return statusAdapter;
+}
+var securityOptions = {
+  dm: {
+    channelKey: "lingyao",
+    resolvePolicy: (account) => account.dmPolicy,
+    resolveAllowFrom: (account) => account.allowFrom,
+    defaultPolicy: "paired"
+  }
+};
+var pairingOptions = {
+  text: {
+    idLabel: "\u8BBE\u5907 ID",
+    message: "\u8BBE\u5907\u5DF2\u6279\u51C6\u914D\u5BF9",
+    notify: async (params) => {
+      const orc = getOrchestrator();
+      if (!orc) return;
+      const config = params.cfg;
+      const channels = config.channels;
+      const lingyao = channels?.lingyao;
+      const accountIds = lingyao?.accounts ? Object.keys(lingyao.accounts) : ["default"];
+      for (const accountId of accountIds) {
+        const sent = orc.sendNotification(accountId, params.id, {
+          type: "pairing_confirmed",
+          message: pairingOptions.text.message
+        });
+        if (sent) break;
+      }
+    }
+  }
+};
+function buildPluginBase(runtime) {
+  return {
+    id: "lingyao",
+    meta: {
+      id: "lingyao",
+      label: "\u7075\u723B",
+      selectionLabel: "\u7075\u723B (HarmonyOS)",
+      docsPath: "/channels/lingyao",
+      docsLabel: "\u7075\u723B\u6587\u6863",
+      blurb: "\u901A\u8FC7 lingyao.live \u670D\u52A1\u5668\u4E2D\u8F6C\u4E0E\u9E3F\u8499\u7075\u723B App \u53CC\u5411\u540C\u6B65\u65E5\u8BB0\u548C\u8BB0\u5FC6",
+      order: 50,
+      aliases: ["lingyao", "\u7075\u723B"]
+    },
+    capabilities: {
+      chatTypes: ["direct"],
+      media: false,
+      reactions: false,
+      threads: false,
+      polls: false,
+      edit: false,
+      unsend: false,
+      reply: false,
+      effects: false,
+      groupManagement: false,
+      nativeCommands: false,
+      blockStreaming: true
+    },
+    config: configAdapter,
+    gateway: gatewayAdapter,
+    outbound: outboundAdapter,
+    status: getStatusAdapter(runtime),
+    directory: directoryAdapter,
+    messaging: messagingAdapter
+  };
+}
+async function createPlugin(runtime, config = {}) {
+  const fullConfig = { ...getDefaultConfig(), ...config };
+  const validatedConfig = validateConfig(fullConfig);
+  const channel = new LingyaoChannel(runtime, validatedConfig);
+  await channel.initialize();
+  return channel;
+}
+var pluginMetadata = {
+  name: "lingyao",
+  version: "0.3.0",
+  description: "Lingyao Channel Plugin - bidirectional sync via lingyao.live server relay",
+  type: "channel",
+  capabilities: {
+    chatTypes: ["direct"],
+    media: false,
+    reactions: false,
+    threads: false
+  },
+  defaultConfig: getDefaultConfig()
+};
+var pluginEntry = {
+  id: "lingyao",
+  name: "Lingyao",
+  description: "Lingyao Channel Plugin - bidirectional sync via lingyao.live",
+  setRuntime(runtime) {
+    const rt = runtime;
+    setRuntime(rt);
+    orchestrator = new MultiAccountOrchestrator(rt);
+  },
+  get plugin() {
+    const rt = orchestrator?.runtime;
+    if (!rt) {
+      throw new Error("Runtime not set. Call setRuntime() before accessing plugin.");
+    }
+    return buildPluginBase(rt);
+  },
+  // Security and pairing options for createChatChannelPlugin composition
+  security: securityOptions,
+  pairing: pairingOptions
+};
+var index_default = pluginEntry;
+export {
+  LINGYAO_SERVER_URL,
+  LingyaoChannel,
+  MessageType,
+  createPlugin,
+  index_default as default,
+  getDefaultConfig,
+  pluginMetadata,
+  validateConfig
+};
+//# sourceMappingURL=index.js.map