@lingyao037/openclaw-lingyao-cli 1.4.0 → 1.5.0

package/dist/cli.d.ts

@@ -1,213 +1,5 @@
-import { L as LingyaoRuntime, a as LingyaoAccount, D as DeviceToken, b as DeviceInfo, H as HealthStatus } from './types-XJDsfTRA.js';
-
-/**
- * Account storage and management
- */
-declare class AccountManager {
-    private runtime;
-    private accounts;
-    private pendingPairings;
-    /** Debounced flush for high-frequency updates (e.g. heartbeat lastSeen). */
-    private accountsSaveTimer;
-    private static readonly ACCOUNTS_SAVE_DEBOUNCE_MS;
-    constructor(runtime: LingyaoRuntime);
-    /**
-     * Initialize account manager from storage
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get account by device ID
-     */
-    getAccount(deviceId: string): LingyaoAccount | undefined;
-    /**
-     * Get account by device token
-     */
-    getAccountByToken(token: string): LingyaoAccount | undefined;
-    /**
-     * Get all active accounts
-     */
-    getActiveAccounts(): LingyaoAccount[];
-    /**
-     * Create a new pairing session
-     */
-    createPairingSession(code: string, expiresAt: number): Promise<void>;
-    /**
-     * Get pairing session by code
-     */
-    getPairingSession(code: string): PairingSession | undefined;
-    /**
-     * Remove a pending pairing (e.g. expired or cancelled)
-     */
-    deletePendingPairing(code: string): Promise<void>;
-    /**
-     * Confirm pairing and create account
-     */
-    confirmPairing(pairingCode: string, deviceToken: DeviceToken, deviceInfo: DeviceInfo): Promise<LingyaoAccount | null>;
-    /**
-     * Update account's last seen timestamp
-     */
-    updateLastSeen(deviceId: string): Promise<void>;
-    /**
-     * Persist any debounced account state immediately (e.g. before process/account shutdown).
-     */
-    flushPendingAccountsSave(): Promise<void>;
-    private scheduleDebouncedAccountsSave;
-    /**
-     * Revoke an account
-     */
-    revokeAccount(deviceId: string): Promise<boolean>;
-    /**
-     * Manually add a device by deviceId (user-initiated pairing).
-     * No pairing code or deviceToken required — the user explicitly
-     * trusts this device from the OpenClaw CLI.
-     */
-    addDevice(deviceId: string, deviceInfo: DeviceInfo): Promise<LingyaoAccount>;
-    /**
-     * Refresh device token
-     */
-    refreshDeviceToken(deviceId: string, newToken: DeviceToken): Promise<boolean>;
-    /**
-     * Clean up expired accounts
-     */
-    cleanupExpired(): Promise<void>;
-    /**
-     * Save accounts to storage (immediate; clears any pending debounced save).
-     */
-    private saveAccounts;
-    private persistAccounts;
-    /**
-     * Save pending pairings to storage
-     */
-    private savePendingPairings;
-}
-interface PairingSession {
-    code: string;
-    createdAt: number;
-    expiresAt: number;
-}
-
-/**
- * Probe status levels
- */
-declare enum ProbeStatus {
-    HEALTHY = "healthy",
-    DEGRADED = "degraded",
-    UNHEALTHY = "unhealthy"
-}
-/**
- * Health check result
- */
-interface HealthCheckResult {
-    status: ProbeStatus;
-    checks: Map<string, CheckResult>;
-    timestamp: number;
-}
-/**
- * Individual check result
- */
-interface CheckResult {
-    passed: boolean;
-    message?: string;
-    duration: number;
-    error?: Error;
-}
-/**
- * Channel status for reporting
- */
-interface ChannelStatus {
-    configured: boolean;
-    running: boolean;
-    lastError?: string;
-    activeAccounts: number;
-    uptime: number;
-    status: ProbeStatus;
-}
-/**
- * Probe - Channel health status and monitoring
- */
-declare class Probe {
-    private runtime;
-    private startTime;
-    private lastError;
-    private lastErrorTime;
-    private errorCounts;
-    private healthChecks;
-    constructor(runtime: LingyaoRuntime);
-    /**
-     * Register a custom health check
-     */
-    registerHealthCheck(name: string, check: HealthCheckFn): void;
-    /**
-     * Run all health checks
-     */
-    runHealthChecks(): Promise<HealthCheckResult>;
-    /**
-     * Get channel status for reporting
-     */
-    getChannelStatus(configured: boolean, running: boolean, activeAccounts?: number): ChannelStatus;
-    /**
-     * Get health status for API endpoint
-     */
-    getHealthStatus(activeConnections?: number, queuedMessages?: number): Promise<HealthStatus>;
-    /**
-     * Record an error
-     */
-    recordError(error: string, category?: string): void;
-    /**
-     * Get last error
-     */
-    getLastError(): string | null;
-    /**
-     * Clear last error
-     */
-    clearLastError(): void;
-    /**
-     * Get error counts by category
-     */
-    getErrorCounts(): Record<string, number>;
-    /**
-     * Reset error counts
-     */
-    resetErrorCounts(): void;
-    /**
-     * Get uptime in milliseconds
-     */
-    getUptime(): number;
-    /**
-     * Get uptime formatted as human-readable string
-     */
-    getUptimeString(): string;
-    /**
-     * Health check: uptime
-     */
-    private checkUptime;
-    /**
-     * Health check: errors
-     */
-    private checkErrors;
-    /**
-     * Create status adapter for OpenClaw integration
-     */
-    createStatusAdapter(configured: boolean): {
-        getStatus: (running: boolean, activeAccounts?: number, activeConnections?: number, queuedMessages?: number) => Promise<{
-            activeConnections: number;
-            queuedMessages: number;
-            configured: boolean;
-            running: boolean;
-            lastError?: string;
-            activeAccounts: number;
-            uptime: number;
-            status: ProbeStatus;
-        }>;
-    };
-}
-/**
- * Health check function signature
- */
-type HealthCheckFn = () => Promise<{
-    passed: boolean;
-    message?: string;
-}>;
+import { L as LingyaoRuntime } from './types-BFXkMaHp.js';
+import { A as AccountManager, P as Probe } from './probe-DW7_cF66.js';
 
 /**
  * CLI command handler for Lingyao plugin

package/dist/index.d.ts

@@ -1,8 +1,290 @@
-import { R as ResolvedAccount, L as LingyaoProbeResult } from './status-Bjzb8u67.js';
+import { R as ResolvedAccount, L as LingyaoProbeResult } from './status-n_XeBoR3.js';
 import * as openclaw_plugin_sdk from 'openclaw/plugin-sdk';
-import { PluginRuntime, ChannelPlugin } from 'openclaw/plugin-sdk';
-import { c as LingyaoConfig } from './types-XJDsfTRA.js';
-export { A as AckRequest, d as AgentMessage, b as DeviceInfo, D as DeviceToken, e as DiarySyncPayload, F as FailedEntry, H as HealthStatus, f as LINGYAO_SERVER_URL, a as LingyaoAccount, g as LingyaoAccountConfig, h as LingyaoMessage, L as LingyaoRuntime, M as MemorySyncPayload, i as MessageHandler, j as MessageType, N as NotifyAction, k as NotifyPayload, l as NotifyRequest, P as PairingCode, m as PairingConfirmRequest, n as PairingConfirmResponse, o as PollRequest, p as PollResponse, Q as QueuedMessage, S as SyncRequest, q as SyncResponse, T as TokenRefreshRequest, r as TokenRefreshResponse, W as WebSocketConnection, s as getLingyaoGatewayWsUrl } from './types-XJDsfTRA.js';
+import { PluginRuntime, OpenClawConfig, ChannelPlugin } from 'openclaw/plugin-sdk';
+import { L as LingyaoRuntime, a as LingyaoConfig } from './types-BFXkMaHp.js';
+export { A as AckRequest, b as AgentMessage, D as DeviceInfo, c as DeviceToken, d as DiarySyncPayload, F as FailedEntry, H as HealthStatus, e as LINGYAO_SERVER_URL, f as LingyaoAccount, g as LingyaoAccountConfig, h as LingyaoMessage, M as MemorySyncPayload, i as MessageHandler, j as MessageType, N as NotifyAction, k as NotifyPayload, l as NotifyRequest, P as PairingCode, m as PairingConfirmRequest, n as PairingConfirmResponse, o as PollRequest, p as PollResponse, Q as QueuedMessage, S as SyncRequest, q as SyncResponse, T as TokenRefreshRequest, r as TokenRefreshResponse, W as WebSocketConnection, s as getLingyaoGatewayWsUrl } from './types-BFXkMaHp.js';
+import { P as Probe, A as AccountManager } from './probe-DW7_cF66.js';
+
+/**
+ * Lingyao WebSocket Client
+ *
+ * 主动连接到 lingyao.live 服务器的 WebSocket 客户端
+ * 实现：
+ * - 自动连接和重连
+ * - 心跳机制
+ * - 消息发送和接收
+ * - 在线状态管理
+ */
+
+/**
+ * WebSocket 连接状态
+ */
+type ConnectionState = "connecting" | "connected" | "disconnected" | "error";
+/**
+ * WebSocket 消息类型（与 `lingyao/server/src/server.ts` 中 Gateway 协议一致）
+ */
+declare enum WSMessageType {
+    GATEWAY_REGISTER = "gateway_register",
+    GATEWAY_HEARTBEAT = "gateway_heartbeat",
+    GATEWAY_SEND_MESSAGE = "gateway_send_message",
+    GATEWAY_REGISTERED = "gateway_registered",
+    GATEWAY_HEARTBEAT_ACK = "gateway_heartbeat_ack",
+    MESSAGE_DELIVERED = "message_delivered",
+    MESSAGE_FAILED = "message_failed",
+    APP_MESSAGE = "app_message",
+    DEVICE_ONLINE = "device_online",
+    PAIRING_COMPLETED = "pairing_completed",
+    ERROR = "error"
+}
+/**
+ * WebSocket 消息基础格式
+ */
+interface WSMessage {
+    type: WSMessageType | string;
+    id: string;
+    timestamp: number;
+    payload?: unknown;
+}
+/**
+ * 接收到的 App 消息
+ */
+interface AppMessage extends WSMessage {
+    type: WSMessageType.APP_MESSAGE;
+    payload: {
+        deviceId: string;
+        message: {
+            id: string;
+            type: "sync_diary" | "sync_memory" | "heartbeat";
+            timestamp: number;
+            content: string;
+            metadata?: Record<string, unknown>;
+        };
+    };
+}
+/**
+ * WebSocket 客户端事件
+ */
+type WSClientEvent = {
+    type: "connected";
+    connectionId: string;
+} | {
+    type: "disconnected";
+    code: number;
+    reason: string;
+} | {
+    type: "error";
+    error: Error;
+} | {
+    type: "fatal_handshake";
+    reason: "http_404";
+} | {
+    type: "reconnect_aborted";
+    reason: "max_attempts";
+    attempts: number;
+} | {
+    type: "message";
+    message: WSMessage;
+} | {
+    type: "appMessage";
+    deviceId: string;
+    message: AppMessage["payload"]["message"];
+} | {
+    type: "pairing_completed";
+    deviceId: string;
+    deviceInfo: {
+        name: string;
+        platform: string;
+        version: string;
+    };
+    sessionId: string;
+};
+/**
+ * WebSocket 客户端配置
+ */
+interface WSClientConfig {
+    url: string;
+    gatewayId: string;
+    token?: string;
+    /** 重连退避的基准间隔（毫秒），第一次调度使用 `interval * multiplier^0` */
+    reconnectInterval: number;
+    /** 单次退避延迟上限（毫秒），默认 60s */
+    reconnectMaxDelayMs?: number;
+    /** 指数乘数，默认 2 */
+    reconnectBackoffMultiplier?: number;
+    /** 最大连续重连次数（不含首次 connect），0 表示不限制 */
+    reconnectMaxAttempts?: number;
+    heartbeatInterval: number;
+    /** 单帧入站最大字节，默认 {@link LINGYAO_DEFAULT_MAX_INCOMING_WS_BYTES} */
+    maxIncomingMessageBytes?: number;
+    messageHandler?: (message: AppMessage) => void | Promise<void>;
+    eventHandler?: (event: WSClientEvent) => void;
+}
+/**
+ * Lingyao WebSocket Client
+ *
+ * 主动连接到 lingyao.live 服务器的 WebSocket 客户端
+ */
+declare class LingyaoWSClient {
+    private config;
+    private ws;
+    private state;
+    private connectionId;
+    private heartbeatTimer;
+    private reconnectTimer;
+    /** When set, close handler will not schedule reconnect (e.g. HTTP 404 on upgrade). */
+    private suppressReconnect;
+    /** 自上次成功 `open` 以来已调度的重连次数（用于退避与上限） */
+    private reconnectAttempt;
+    private messageHandlers;
+    private logger;
+    constructor(runtime: LingyaoRuntime, config: WSClientConfig);
+    /**
+     * 连接到服务器
+     */
+    connect(): Promise<void>;
+    /**
+     * 设置 WebSocket 事件处理器
+     */
+    private setupWebSocketHandlers;
+    /**
+     * 处理连接打开
+     */
+    private handleOpen;
+    /**
+     * 处理接收消息
+     */
+    private handleMessage;
+    /**
+     * 处理连接错误
+     */
+    private handleErrorEvent;
+    /**
+     * 处理连接关闭
+     */
+    private handleClose;
+    /**
+     * 发送注册消息
+     */
+    private sendRegister;
+    /**
+     * 处理注册响应
+     */
+    private handleRegistered;
+    /**
+     * 发送心跳
+     */
+    private sendHeartbeat;
+    /**
+     * 处理心跳确认
+     */
+    private handleHeartbeatAck;
+    /**
+     * 启动心跳
+     */
+    private startHeartbeat;
+    /**
+     * 停止心跳
+     */
+    private stopHeartbeat;
+    /**
+     * 安排重连
+     */
+    private scheduleReconnect;
+    /**
+     * 发送消息到服务器
+     */
+    send(message: WSMessage): void;
+    /**
+     * 发送通知到鸿蒙 App
+     */
+    sendNotification(deviceId: string, notification: Record<string, unknown>): void;
+    /**
+     * 处理 App 消息
+     */
+    private handleAppMessage;
+    /**
+     * 处理消息发送成功
+     */
+    private handleMessageDelivered;
+    /**
+     * 设备上线（服务器可选推送）
+     */
+    private handleDeviceOnline;
+    /**
+     * 处理配对完成通知（来自 lingyao.live 服务器）
+     */
+    private handlePairingCompleted;
+    /**
+     * 处理消息发送失败
+     */
+    private handleMessageFailed;
+    /**
+     * 处理服务器错误
+     */
+    private handleError;
+    /**
+     * 注册消息处理器
+     */
+    registerMessageHandler(type: string, handler: (message: WSMessage) => void): void;
+    /**
+     * 发送事件
+     */
+    private emitEvent;
+    /**
+     * 更新 WebSocket 连接使用的 token
+     */
+    updateToken(token: string): void;
+    /**
+     * 断开连接
+     */
+    disconnect(): void;
+    /**
+     * 获取连接状态
+     */
+    getState(): ConnectionState;
+    /**
+     * 获取连接 ID
+     */
+    getConnectionId(): string | null;
+    /**
+     * 是否已连接
+     */
+    isConnected(): boolean;
+    /**
+     * 生成消息 ID
+     */
+    private generateMessageId;
+    /**
+     * 生成连接 ID
+     */
+    private generateConnectionId;
+}
+
+/**
+ * Narrow orchestrator surface for channel adapters.
+ * Adapters depend on this module instead of `orchestrator.ts`, avoiding fragile
+ * type-level coupling to the full `MultiAccountOrchestrator` implementation.
+ */
+
+/**
+ * Per-account fields that status/gateway-style adapters read via `getAccountState`.
+ */
+interface LingyaoAccountRuntimeState {
+    gatewayId: string;
+    startTime: number;
+    wsClient: LingyaoWSClient | null;
+    probe: Probe;
+}
+interface LingyaoOrchestratorHandle {
+    start(account: ResolvedAccount, context?: {
+        channelRuntime?: PluginRuntime['channel'];
+        cfg?: OpenClawConfig;
+    }): Promise<void>;
+    stop(accountId: string): Promise<void>;
+    getAccountState(accountId: string): LingyaoAccountRuntimeState | undefined;
+    getAccountManager(accountId: string): AccountManager | null;
+    sendNotification(accountId: string, deviceId: string, notification: Record<string, unknown>): boolean;
+}
 
 /**
  * Validate configuration object
@@ -14,7 +296,9 @@ declare function validateConfig(config: unknown): LingyaoConfig;
 declare function getDefaultConfig(): LingyaoConfig;
 
 declare const lingyaoPlugin: ChannelPlugin<ResolvedAccount, LingyaoProbeResult>;
-declare function initializeLingyaoRuntime(runtime: PluginRuntime): void;
+declare function initializeLingyaoRuntime(runtime: PluginRuntime, options?: {
+    lingyaoConfig?: Partial<LingyaoConfig>;
+}): void;
 
 declare const plugin: {
     id: string;
@@ -26,4 +310,4 @@ declare const plugin: {
     setChannelRuntime?: (runtime: openclaw_plugin_sdk.PluginRuntime) => void;
 };
 
-export { LingyaoConfig, plugin as default, getDefaultConfig, initializeLingyaoRuntime, lingyaoPlugin, validateConfig };
+export { type LingyaoAccountRuntimeState, LingyaoConfig, type LingyaoOrchestratorHandle, LingyaoRuntime, plugin as default, getDefaultConfig, initializeLingyaoRuntime, lingyaoPlugin, validateConfig };

package/dist/index.js

@@ -11,7 +11,7 @@ var globalRuntime = null;
 function setRuntime(runtime) {
   globalRuntime = runtime;
 }
-function adaptPluginRuntime(pr) {
+function adaptPluginRuntime(pr, lingyaoConfig) {
   const noop = (..._args) => {
   };
   const rawLogger = pr.logging?.getChildLogger?.() ?? {
@@ -28,7 +28,10 @@ function adaptPluginRuntime(pr) {
   const stateDir = pr.state?.resolveStateDir?.() ?? join(process.cwd(), ".lingyao-data");
   const storeDir = join(stateDir, "lingyao");
   return {
-    config: { enabled: true },
+    config: {
+      enabled: true,
+      ...lingyaoConfig
+    },
     logger: childLogger,
     storage: {
       async get(key) {
@@ -87,6 +90,8 @@ var lingyaoConfigSchema = z.object({
   dmPolicy: lingyaoDmPolicySchema.optional().default("pairing"),
   allowFrom: allowFromSchema.default([]),
   websocketHeartbeatIntervalMs: z.number().int().min(5e3).max(12e4).optional(),
+  notificationRatePerSecond: z.number().positive().max(500).optional(),
+  notificationBurst: z.number().int().positive().max(1e4).optional(),
   defaultAccount: z.string().min(1).optional(),
   accounts: z.record(lingyaoAccountConfigSchema).optional()
 });
@@ -118,6 +123,18 @@ var lingyaoChannelConfigSchema = {
         maximum: 12e4,
         description: "WebSocket gateway_heartbeat interval in ms (default: server register response). Use 5000\u201355000 for typical relay timeout."
       },
+      notificationRatePerSecond: {
+        type: "number",
+        minimum: 0.1,
+        maximum: 500,
+        description: "Token bucket refill rate for outbound App notifications (default 15). Override with LINGYAO_NOTIFY_RATE_PER_SEC env if runtime config is not merged."
+      },
+      notificationBurst: {
+        type: "integer",
+        minimum: 1,
+        maximum: 1e4,
+        description: "Max burst for outbound notifications (default 25). Env: LINGYAO_NOTIFY_BURST."
+      },
       accounts: {
         type: "object",
         additionalProperties: false,
@@ -2434,6 +2451,18 @@ var NotificationRateLimiter = class {
 };
 var DEFAULT_NOTIFY_REFILL_PER_SEC = 15;
 var DEFAULT_NOTIFY_BURST = 25;
+function resolveNotificationLimiterParams(cfg) {
+  const envRef = typeof process !== "undefined" ? process.env.LINGYAO_NOTIFY_RATE_PER_SEC : void 0;
+  const envBurst = typeof process !== "undefined" ? process.env.LINGYAO_NOTIFY_BURST : void 0;
+  const refillFromEnv = envRef !== void 0 && envRef !== "" ? Number(envRef) : Number.NaN;
+  const burstFromEnv = envBurst !== void 0 && envBurst !== "" ? Number(envBurst) : Number.NaN;
+  const refill = cfg.notificationRatePerSecond ?? (!Number.isNaN(refillFromEnv) && refillFromEnv > 0 ? refillFromEnv : void 0) ?? DEFAULT_NOTIFY_REFILL_PER_SEC;
+  const burst = cfg.notificationBurst ?? (!Number.isNaN(burstFromEnv) && burstFromEnv > 0 ? Math.floor(burstFromEnv) : void 0) ?? DEFAULT_NOTIFY_BURST;
+  return {
+    refillPerSecond: Math.min(500, Math.max(0.1, refill)),
+    burst: Math.min(1e4, Math.max(1, Math.floor(burst)))
+  };
+}
 
 // src/orchestrator.ts
 function getMachineId() {
@@ -2452,12 +2481,11 @@ function generateGatewayId(accountId) {
 var MultiAccountOrchestrator = class {
   runtime;
   accounts = /* @__PURE__ */ new Map();
-  notificationLimiter = new NotificationRateLimiter(
-    DEFAULT_NOTIFY_REFILL_PER_SEC,
-    DEFAULT_NOTIFY_BURST
-  );
+  notificationLimiter;
   constructor(runtime) {
     this.runtime = runtime;
+    const lim = resolveNotificationLimiterParams(runtime.config);
+    this.notificationLimiter = new NotificationRateLimiter(lim.refillPerSecond, lim.burst);
   }
   /**
    * Start an account: create components, register to server, connect WS.
@@ -3006,15 +3034,18 @@ var lingyaoPlugin = {
   directory: directoryAdapter,
   messaging: messagingAdapter
 };
-function initializeLingyaoRuntime(runtime) {
-  const adapted = adaptPluginRuntime(runtime);
+function initializeLingyaoRuntime(runtime, options) {
+  const adapted = adaptPluginRuntime(
+    runtime,
+    options?.lingyaoConfig
+  );
   setRuntime(adapted);
   orchestrator = new MultiAccountOrchestrator(adapted);
 }
 
 // src/runtime-api.ts
-function setLingyaoRuntime(runtime) {
-  initializeLingyaoRuntime(runtime);
+function setLingyaoRuntime(runtime, options) {
+  initializeLingyaoRuntime(runtime, options);
 }
 
 // src/index.ts