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

package/dist/index.d.ts

@@ -0,0 +1,1229 @@
+import { a as LingyaoAccountConfig, L as LingyaoRuntime, A as AccountManager, S as SyncRequest, b as SyncResponse, c as LingyaoMessage, D as DeviceInfo, d as DeviceToken, e as LingyaoConfig, N as NotifyPayload, H as HealthStatus } from './accounts-Bkwmg14Q.js';
+export { f as AckRequest, g as DiarySyncPayload, F as FailedEntry, h as LINGYAO_SERVER_URL, i as LingyaoAccount, M as MemorySyncPayload, j as MessageType, k as NotifyAction, l as NotifyRequest, P as PairingCode, m as PairingConfirmRequest, n as PairingConfirmResponse, o as PollRequest, p as PollResponse, Q as QueuedMessage, T as TokenRefreshRequest, q as TokenRefreshResponse, W as WebSocketConnection } from './accounts-Bkwmg14Q.js';
+
+/**
+ * Config Adapter - Account resolution, config validation
+ *
+ * serverUrl is NOT exposed to users — hardcoded as LINGYAO_SERVER_URL.
+ */
+
+/**
+ * Resolved account after config resolution.
+ */
+interface ResolvedAccount {
+    readonly id: string;
+    readonly enabled: boolean;
+    readonly dmPolicy: 'paired' | 'open' | 'deny';
+    readonly allowFrom: readonly string[];
+    readonly rawConfig: LingyaoAccountConfig;
+}
+
+/**
+ * 灵爻服务器 HTTP 客户端
+ *
+ * 主动连接到灵爻服务器，实现 Gateway 注册、心跳、消息推送
+ * 符合 openapi.yaml 规范
+ */
+
+/**
+ * 服务器 API 配置
+ */
+interface ServerConfig {
+    baseURL: string;
+    apiBase: string;
+    timeout: number;
+    connectionTimeout: number;
+}
+/**
+ * Gateway 注册响应
+ */
+interface GatewayRegisterResponse {
+    gatewayToken: string;
+    expiresAt: number;
+    webhookSecret: string;
+    serverConfig: {
+        heartbeatInterval: number;
+        maxOfflineMessages: number;
+        supportedMessageTypes: string[];
+    };
+}
+/**
+ * 心跳响应
+ */
+interface HeartbeatResponse {
+    serverTime: number;
+    pendingMessages: number;
+}
+/**
+ * 发送消息请求
+ */
+interface SendMessageRequest {
+    deviceId: string;
+    message: {
+        id: string;
+        type: 'notify_text' | 'notify_action';
+        timestamp: number;
+        payload: {
+            title?: string;
+            body?: string;
+            action?: {
+                type: 'open_memory' | 'view_diary' | 'custom';
+                params?: Record<string, unknown>;
+            };
+        };
+    };
+    options?: {
+        priority?: 'normal' | 'low' | 'high';
+        ttl?: number;
+    };
+}
+/**
+ * 发送消息响应
+ */
+interface SendMessageResponse {
+    messageId: string;
+    status: 'queued' | 'delivered' | 'failed';
+    deliveredAt: number | null;
+    queued: boolean;
+}
+/**
+ * Gateway 状态
+ */
+type GatewayStatus = 'online' | 'offline' | 'maintenance';
+/**
+ * HTTP 客户端实现
+ */
+declare class ServerHttpClient {
+    private runtime;
+    private config;
+    private axiosInstance;
+    private gatewayToken;
+    private webhookSecret;
+    private tokenExpiresAt;
+    private heartbeatInterval;
+    private heartbeatTimer;
+    private gatewayId;
+    private isRegistered;
+    private isConnecting;
+    private storagePrefix;
+    constructor(runtime: LingyaoRuntime, gatewayId: string, serverConfig?: Partial<ServerConfig>, storagePrefix?: string);
+    /**
+     * 注册 Gateway 到服务器
+     */
+    register(capabilities?: {
+        websocket?: boolean;
+        compression?: boolean;
+        maxMessageSize?: number;
+    }): Promise<GatewayRegisterResponse>;
+    /**
+     * 发送心跳
+     */
+    heartbeat(status?: GatewayStatus, activeConnections?: number): Promise<HeartbeatResponse>;
+    /**
+     * 发送消息到灵爻 App
+     */
+    sendMessage(deviceId: string, messageType: 'notify_text' | 'notify_action', payload: SendMessageRequest['message']['payload'], options?: SendMessageRequest['options']): Promise<SendMessageResponse>;
+    /**
+     * 启动心跳循环
+     */
+    private startHeartbeat;
+    /**
+     * 停止心跳循环
+     */
+    stopHeartbeat(): void;
+    /**
+     * 获取 Webhook Secret
+     */
+    getWebhookSecret(): string | null;
+    /**
+     * 获取 Gateway Token
+     */
+    getGatewayToken(): string | null;
+    /**
+     * 检查 Token 是否即将过期
+     */
+    isTokenExpiringSoon(thresholdMs?: number): boolean;
+    /**
+     * 检查是否已注册
+     */
+    isReady(): boolean;
+    /**
+     * 从存储恢复会话
+     */
+    restoreFromStorage(): Promise<boolean>;
+    /**
+     * Build a namespaced storage key for multi-account support
+     */
+    private storageKey;
+    /**
+     * 生成消息 ID
+     */
+    private generateMessageId;
+}
+
+/**
+ * Lingyao WebSocket Client
+ *
+ * 主动连接到 lingyao.live 服务器的 WebSocket 客户端
+ * 实现：
+ * - 自动连接和重连
+ * - 心跳机制
+ * - 消息发送和接收
+ * - 在线状态管理
+ */
+
+/**
+ * WebSocket 连接状态
+ */
+type ConnectionState = "connecting" | "connected" | "disconnected" | "error";
+/**
+ * WebSocket 消息类型
+ */
+declare enum WSMessageType {
+    REGISTER = "register",
+    HEARTBEAT = "heartbeat",
+    SEND_MESSAGE = "send_message",
+    ACK = "ack",
+    REGISTERED = "registered",
+    HEARTBEAT_ACK = "heartbeat_ack",
+    MESSAGE_DELIVERED = "message_delivered",
+    MESSAGE_FAILED = "message_failed",
+    APP_MESSAGE = "app_message",// 来自 App 的消息
+    DEVICE_ONLINE = "device_online",
+    ERROR = "error"
+}
+/**
+ * WebSocket 消息基础格式
+ */
+interface WSMessage {
+    type: WSMessageType | string;
+    id: string;
+    timestamp: number;
+    payload?: any;
+}
+/**
+ * 接收到的 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: "message";
+    message: WSMessage;
+} | {
+    type: "appMessage";
+    deviceId: string;
+    message: AppMessage["payload"]["message"];
+};
+/**
+ * WebSocket 客户端配置
+ */
+interface WSClientConfig {
+    url: string;
+    gatewayId: string;
+    token?: string;
+    reconnectInterval: number;
+    heartbeatInterval: 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;
+    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: any): void;
+    /**
+     * 处理 App 消息
+     */
+    private handleAppMessage;
+    /**
+     * 处理消息发送成功
+     */
+    private handleMessageDelivered;
+    /**
+     * 处理消息发送失败
+     */
+    private handleMessageFailed;
+    /**
+     * 处理服务器错误
+     */
+    private handleError;
+    /**
+     * 注册消息处理器
+     */
+    registerMessageHandler(type: string, handler: (message: WSMessage) => void): void;
+    /**
+     * 发送事件
+     */
+    private emitEvent;
+    /**
+     * 断开连接
+     */
+    disconnect(): void;
+    /**
+     * 获取连接状态
+     */
+    getState(): ConnectionState;
+    /**
+     * 获取连接 ID
+     */
+    getConnectionId(): string | null;
+    /**
+     * 是否已连接
+     */
+    isConnected(): boolean;
+    /**
+     * 生成消息 ID
+     */
+    private generateMessageId;
+    /**
+     * 生成连接 ID
+     */
+    private generateConnectionId;
+}
+
+/**
+ * Agent message format - messages passed directly to Agent
+ */
+interface AgentMessage {
+    id: string;
+    type: "diary" | "memory" | "heartbeat";
+    from: string;
+    deviceId: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    timestamp: number;
+}
+/**
+ * Message handler callback for delivering messages to Agent
+ */
+type MessageHandler = (message: AgentMessage) => void | Promise<void>;
+/**
+ * Message Processor - Handles incoming messages and routes them to Agent
+ */
+declare class MessageProcessor {
+    private runtime;
+    private accountManager;
+    private messageQueue;
+    private seenMessages;
+    private messageHandler;
+    private readonly maxQueueSize;
+    constructor(runtime: LingyaoRuntime, accountManager: AccountManager);
+    /**
+     * Initialize the message processor
+     */
+    initialize(): Promise<void>;
+    /**
+     * Set the message handler for delivering messages to Agent
+     */
+    setMessageHandler(handler: MessageHandler): void;
+    /**
+     * Get the currently registered Agent message handler.
+     */
+    getMessageHandler(): MessageHandler | null;
+    /**
+     * Deliver a normalized message directly to the registered Agent handler.
+     */
+    deliverToAgent(message: AgentMessage): Promise<void>;
+    /**
+     * Process sync request from app
+     */
+    processSync(deviceId: string, request: SyncRequest): Promise<SyncResponse>;
+    /**
+     * Process a single message
+     */
+    private processMessage;
+    /**
+     * Process diary sync - Pass directly to Agent
+     */
+    private processDiarySync;
+    /**
+     * Process memory sync - Pass directly to Agent
+     */
+    private processMemorySync;
+    /**
+     * Process sync acknowledgment
+     */
+    private processSyncAck;
+    /**
+     * Process heartbeat
+     */
+    private processHeartbeat;
+    /**
+     * Poll for new messages (long-polling)
+     */
+    pollMessages(deviceId: string, timeout?: number): Promise<LingyaoMessage[]>;
+    /**
+     * Queue a message for a device
+     */
+    queueMessage(deviceId: string, message: LingyaoMessage): boolean;
+    /**
+     * Acknowledge messages
+     */
+    acknowledgeMessages(messageIds: string[]): Promise<void>;
+    /**
+     * Check if message has been seen (deduplication)
+     */
+    private isMessageSeen;
+    /**
+     * Mark message as seen
+     */
+    private markMessageSeen;
+    /**
+     * Get queue size for a device
+     */
+    getQueueSize(deviceId: string): number;
+    /**
+     * Get total queue size
+     */
+    getTotalQueueSize(): number;
+}
+
+/**
+ * 监控和指标收集模块
+ */
+
+/**
+ * 指标类型
+ */
+declare enum MetricType {
+    COUNTER = "counter",
+    GAUGE = "gauge",
+    HISTOGRAM = "histogram"
+}
+/**
+ * 指标数据
+ */
+interface MetricData {
+    name: string;
+    type: MetricType;
+    value: number;
+    timestamp: number;
+    labels?: Record<string, string>;
+}
+/**
+ * 指标配置
+ */
+interface MetricConfig {
+    name: string;
+    type: MetricType;
+    description?: string;
+    labels?: string[];
+    buckets?: number[];
+}
+/**
+ * 监控指标管理器
+ */
+declare class MetricsManager {
+    private metrics;
+    private counters;
+    private gauges;
+    private histograms;
+    private histogramBuckets;
+    constructor(_runtime: LingyaoRuntime);
+    /**
+     * 初始化默认指标
+     */
+    private initializeDefaultMetrics;
+    /**
+     * 声明指标
+     */
+    declareMetric(config: MetricConfig): void;
+    /**
+     * 计数器增加
+     */
+    incrementCounter(name: string, value?: number, labels?: Record<string, string>): void;
+    /**
+     * 设置仪表盘值
+     */
+    setGauge(name: string, value: number, labels?: Record<string, string>): void;
+    /**
+     * 记录直方图值
+     */
+    recordHistogram(name: string, value: number, labels?: Record<string, string>): void;
+    /**
+     * 记录指标
+     */
+    private recordMetric;
+    /**
+     * 获取所有指标
+     */
+    getMetrics(): MetricData[];
+    /**
+     * 获取特定指标的当前值
+     */
+    getMetricValue(name: string): number | undefined;
+    /**
+     * 获取直方图统计数据
+     */
+    getHistogramStats(name: string): {
+        count: number;
+        min: number;
+        max: number;
+        avg: number;
+        p50: number;
+        p95: number;
+        p99: number;
+    } | null;
+    /**
+     * 重置所有指标
+     */
+    reset(): void;
+    /**
+     * 生成 Prometheus 格式的指标导出
+     */
+    exportPrometheus(): string;
+}
+/**
+ * 监控事件
+ */
+declare enum MonitoringEvent {
+    CONNECTION_OPEN = "connection_open",
+    CONNECTION_CLOSE = "connection_close",
+    CONNECTION_ERROR = "connection_error",
+    RECONNECT = "reconnect",
+    MESSAGE_RECEIVED = "message_received",
+    MESSAGE_SENT = "message_sent",
+    MESSAGE_DELIVERED = "message_delivered",
+    MESSAGE_FAILED = "message_failed",
+    HEARTBEAT_SENT = "heartbeat_sent",
+    HEARTBEAT_RECEIVED = "heartbeat_received",
+    HEARTBEAT_MISSED = "heartbeat_missed",
+    ERROR_OCCURRED = "error_occurred"
+}
+/**
+ * 监控事件数据
+ */
+interface MonitoringEventData {
+    event: MonitoringEvent;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+/**
+ * 监控器
+ */
+declare class Monitor {
+    private runtime;
+    private metrics;
+    private eventHandlers;
+    constructor(runtime: LingyaoRuntime);
+    /**
+     * 记录事件
+     */
+    recordEvent(event: MonitoringEvent, data?: Record<string, unknown>): void;
+    /**
+     * 为事件更新指标
+     */
+    private updateMetricsForEvent;
+    /**
+     * 注册事件处理器
+     */
+    on(event: MonitoringEvent, handler: (data: MonitoringEventData) => void): void;
+    /**
+     * 移除事件处理器
+     */
+    off(event: MonitoringEvent, handler: (data: MonitoringEventData) => void): void;
+    /**
+     * 获取指标管理器
+     */
+    getMetrics(): MetricsManager;
+    /**
+     * 获取摘要报告
+     */
+    getSummary(): {
+        uptime: number;
+        connections: number;
+        messages: {
+            sent: number;
+            received: number;
+            failed: number;
+        };
+        errors: number;
+        heartbeats: {
+            sent: number;
+            missed: number;
+        };
+    };
+}
+
+/**
+ * 错误处理模块
+ */
+
+/**
+ * 错误严重级别
+ */
+declare enum ErrorSeverity {
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high",
+    CRITICAL = "critical"
+}
+/**
+ * Lingyao 错误基类
+ */
+declare class LingyaoError extends Error {
+    readonly code: string;
+    readonly severity: ErrorSeverity;
+    readonly timestamp: number;
+    readonly context?: Record<string, unknown>;
+    readonly cause?: Error;
+    constructor(message: string, code: string, severity?: ErrorSeverity, context?: Record<string, unknown>, cause?: Error);
+    /**
+     * 转换为 JSON 可序列化格式
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * 错误处理器
+ */
+declare class ErrorHandler {
+    private runtime;
+    private errorCounts;
+    private lastErrors;
+    private errorThresholds;
+    constructor(runtime: LingyaoRuntime);
+    /**
+     * 处理错误
+     */
+    handleError(error: Error | LingyaoError): void;
+    /**
+     * 记录错误
+     */
+    private recordError;
+    /**
+     * 检查错误阈值
+     */
+    private checkThresholds;
+    /**
+     * 触发警报
+     */
+    private triggerAlert;
+    /**
+     * 设置错误阈值
+     */
+    setErrorThreshold(code: string, threshold: {
+        count: number;
+        window: number;
+    }): void;
+    /**
+     * 获取错误统计
+     */
+    getErrorStats(): {
+        byCode: Record<string, number>;
+        total: number;
+        recent: Array<{
+            code: string;
+            error: LingyaoError;
+            timestamp: number;
+        }>;
+    };
+    /**
+     * 重置错误计数
+     */
+    resetErrorCounts(code?: string): void;
+    /**
+     * 包装异步函数以自动处理错误
+     */
+    wrapAsync<T>(fn: () => Promise<T>, context?: {
+        operation?: string;
+        fallback?: T;
+        retryable?: boolean;
+    }): Promise<T>;
+    /**
+     * 创建带有错误处理的重试逻辑
+     */
+    retry<T>(fn: () => Promise<T>, options?: {
+        maxRetries?: number;
+        retryDelay?: number;
+        backoff?: boolean;
+        onRetry?: (error: Error, attempt: number) => void;
+    }): Promise<T>;
+    /**
+     * 判断错误是否可重试
+     */
+    isRetryable(error: Error): boolean;
+    /**
+     * 判断错误是否需要降级处理
+     */
+    shouldDegrade(error: Error): boolean;
+    /**
+     * 创建降级响应
+     */
+    createDegradedResponse<T>(fallback: T, error?: Error): {
+        success: false;
+        degraded: true;
+        fallback: T;
+        error?: Error;
+    };
+}
+
+/**
+ * Directory Adapter - List paired devices (peers)
+ *
+ * Implements ChannelDirectoryAdapter:
+ * - listPeers: return all active paired devices for an account
+ *
+ * SDK passes:
+ *   listPeers({ cfg, accountId?, query?, limit?, runtime })
+ *
+ * Returns ChannelDirectoryEntry[] with { kind, id, name?, ... }
+ *
+ * Uses AccountManager to get the device list.
+ * Each device is returned as a "user" peer (no groups in Lingyao).
+ */
+
+/**
+ * Matches SDK's ChannelDirectoryEntry.
+ */
+interface DirectoryEntry {
+    kind: 'user' | 'group' | 'channel';
+    id: string;
+    name?: string;
+    handle?: string;
+    avatarUrl?: string;
+    rank?: number;
+    raw?: unknown;
+}
+
+/**
+ * Status Adapter - Health checks and channel summary
+ *
+ * Implements ChannelStatusAdapter:
+ * - probeAccount: run health checks for a specific account
+ * - buildChannelSummary: aggregate status for a single account
+ *
+ * SDK passes:
+ *   probeAccount({ account, timeoutMs, cfg })
+ *   buildChannelSummary({ account, cfg, defaultAccountId, snapshot })
+ *
+ * Wraps existing Probe and Monitor classes.
+ */
+
+/**
+ * Probe result structure.
+ */
+interface LingyaoProbeResult {
+    ok: boolean;
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    wsConnected: boolean;
+    uptime?: number;
+    checks?: Record<string, {
+        passed: boolean;
+        message: string;
+        duration?: number;
+    }>;
+    error?: string;
+}
+
+/**
+ * Outbound Adapter - Send messages from Agent to App devices
+ *
+ * Implements ChannelOutboundAdapter:
+ * - deliveryMode: "direct" (synchronous via WS)
+ * - sendText: send plain text notification
+ * - sendPayload: send structured payload notification
+ * - resolveTarget: validate and resolve target deviceId
+ *
+ * SDK passes ChannelOutboundContext = { cfg, to, text, accountId?, ... }
+ * and expects OutboundDeliveryResult = { channel, messageId, ... } return.
+ *
+ * Routes through MultiAccountOrchestrator to the correct
+ * account's WS connection.
+ */
+
+/**
+ * Minimal subset of ChannelOutboundContext that we need.
+ */
+interface OutboundContext {
+    cfg?: unknown;
+    to: string;
+    text: string;
+    mediaUrl?: string;
+    accountId?: string | null;
+    silent?: boolean;
+}
+/**
+ * Minimal ChannelOutboundPayloadContext.
+ */
+interface OutboundPayloadContext extends OutboundContext {
+    payload: unknown;
+}
+/**
+ * OutboundDeliveryResult - what SDK expects back.
+ */
+interface DeliveryResult {
+    channel: string;
+    messageId: string;
+    chatId?: string;
+    timestamp?: number;
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * Gateway Adapter - Account lifecycle management
+ *
+ * Implements ChannelGatewayAdapter:
+ * - startAccount: create WS/HTTP connections for an account
+ * - stopAccount: tear down connections for an account
+ *
+ * Delegates to MultiAccountOrchestrator for all operations.
+ *
+ * SDK passes ChannelGatewayContext which includes:
+ *   cfg, accountId, account, runtime, abortSignal, log,
+ *   getStatus, setStatus, channelRuntime?
+ */
+
+/**
+ * Minimal subset of ChannelGatewayContext that we need.
+ * We define this locally to avoid importing internal SDK types.
+ */
+interface GatewayContext {
+    accountId: string;
+    account: ResolvedAccount;
+    cfg?: unknown;
+    runtime?: unknown;
+    abortSignal?: AbortSignal;
+    log?: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug?: (msg: string) => void;
+    };
+    getStatus?: () => unknown;
+    setStatus?: (next: unknown) => void;
+}
+
+/**
+ * Token management utilities
+ */
+declare class TokenManager {
+    constructor(_runtime: LingyaoRuntime);
+    /**
+     * Generate a new device token
+     */
+    generateDeviceToken(pairingId: string, deviceInfo: DeviceInfo, expiryDays?: number): DeviceToken;
+    /**
+     * Validate a device token
+     */
+    validateToken(token: string, storedSecret: string): boolean;
+    /**
+     * Check if token is expired
+     */
+    isTokenExpired(token: DeviceToken): boolean;
+    /**
+     * Refresh an existing token
+     */
+    refreshToken(oldToken: DeviceToken, expiryDays?: number): DeviceToken;
+    /**
+     * Extract device ID from token string
+     */
+    extractDeviceId(token: string): string | null;
+    /**
+     * Generate a unique device ID
+     */
+    private generateDeviceId;
+    /**
+     * Generate a random secret key
+     */
+    private generateSecret;
+    /**
+     * Generate a JWT-like token string
+     */
+    private generateTokenString;
+    /**
+     * Sign data with secret
+     */
+    private sign;
+    /**
+     * Base64URL encode without padding
+     */
+    private base64UrlEncode;
+}
+
+/**
+ * 灵爻频道插件 - 服务器中转模式
+ */
+declare class LingyaoChannel {
+    private runtime;
+    private config;
+    private accountManager;
+    private tokenManager;
+    private serverClient;
+    private wsClient;
+    private processor;
+    private probe;
+    private monitor;
+    private errorHandler;
+    private startTime;
+    private gatewayId;
+    private isRunning;
+    private messageHandler;
+    constructor(runtime: LingyaoRuntime, config: LingyaoConfig);
+    /**
+     * 初始化频道
+     */
+    initialize(): Promise<void>;
+    /**
+     * 启动频道
+     */
+    start(): Promise<void>;
+    /**
+     * 向 lingyao 服务器注册 Gateway
+     */
+    private registerToServer;
+    /**
+     * 处理来自鸿蒙 App 的消息
+     */
+    private handleAppMessage;
+    /**
+     * 处理同步消息（日记、记忆等）
+     */
+    private handleSyncMessage;
+    /**
+     * 映射消息类型
+     */
+    private mapMessageType;
+    /**
+     * 处理 WebSocket 客户端事件
+     */
+    private handleClientEvent;
+    /**
+     * 停止频道
+     */
+    stop(): Promise<void>;
+    /**
+     * 发送通知到设备
+     */
+    sendNotification(deviceId: string, notification: NotifyPayload): Promise<{
+        success: boolean;
+        error?: string;
+        queued?: boolean;
+    }>;
+    /**
+     * 发送文本到设备
+     */
+    sendText(deviceId: string, text: string): Promise<{
+        success: boolean;
+        error?: string;
+        queued?: boolean;
+    }>;
+    /**
+     * 获取健康状态
+     */
+    getHealthStatus(): Promise<HealthStatus>;
+    /**
+     * 获取配置
+     */
+    getConfig(): LingyaoConfig;
+    /**
+     * 更新配置
+     */
+    updateConfig(updates: Partial<LingyaoConfig>): Promise<void>;
+    /**
+     * 获取账号管理器
+     */
+    getAccountManager(): AccountManager;
+    /**
+     * 获取 Token 管理器
+     */
+    getTokenManager(): TokenManager;
+    /**
+     * 获取服务器客户端
+     */
+    getServerClient(): ServerHttpClient | null;
+    /**
+    /**
+     * 获取 WebSocket 客户端
+     */
+    getWSClient(): LingyaoWSClient | null;
+    /**
+     * 获取消息处理器
+     */
+    getMessageProcessor(): MessageProcessor | null;
+    /**
+     * 设置消息处理器
+     */
+    setMessageHandler(handler: (message: AgentMessage) => void | Promise<void>): void;
+    /**
+     * 获取监控器
+     */
+    getMonitor(): Monitor;
+    /**
+     * 获取错误处理器
+     */
+    getErrorHandler(): ErrorHandler;
+    /**
+     * 获取监控摘要
+     */
+    getMonitoringSummary(): {
+        uptime: number;
+        connections: number;
+        messages: {
+            sent: number;
+            received: number;
+            failed: number;
+        };
+        errors: number;
+        heartbeats: {
+            sent: number;
+            missed: number;
+        };
+    };
+    /**
+     * 获取错误统计
+     */
+    getErrorStats(): {
+        byCode: Record<string, number>;
+        total: number;
+        recent: Array<{
+            code: string;
+            error: LingyaoError;
+            timestamp: number;
+        }>;
+    };
+    /**
+     * 生成 Gateway ID
+     */
+    private generateGatewayId;
+    /**
+     * 获取运行时主机名
+     */
+    private getRuntimeHostname;
+}
+
+/**
+ * Validate configuration object
+ */
+declare function validateConfig(config: unknown): LingyaoConfig;
+/**
+ * Get default configuration
+ */
+declare function getDefaultConfig(): LingyaoConfig;
+
+/**
+ * Create a LingyaoChannel instance (legacy API).
+ * Use this for standalone usage without the OpenClaw SDK.
+ */
+declare function createPlugin(runtime: LingyaoRuntime, config?: Partial<LingyaoConfig>): Promise<LingyaoChannel>;
+/**
+ * Plugin metadata (legacy API).
+ */
+declare const pluginMetadata: {
+    name: string;
+    version: string;
+    description: string;
+    type: string;
+    capabilities: {
+        chatTypes: string[];
+        media: boolean;
+        reactions: boolean;
+        threads: boolean;
+    };
+    defaultConfig: LingyaoConfig;
+};
+declare const pluginEntry: {
+    id: string;
+    name: string;
+    description: string;
+    setRuntime(runtime: unknown): void;
+    readonly plugin: {
+        id: "lingyao";
+        meta: {
+            id: string;
+            label: string;
+            selectionLabel: string;
+            docsPath: string;
+            docsLabel: string;
+            blurb: string;
+            order: number;
+            aliases: string[];
+        };
+        capabilities: {
+            chatTypes: readonly ["direct"];
+            media: boolean;
+            reactions: boolean;
+            threads: boolean;
+            polls: boolean;
+            edit: boolean;
+            unsend: boolean;
+            reply: boolean;
+            effects: boolean;
+            groupManagement: boolean;
+            nativeCommands: boolean;
+            blockStreaming: boolean;
+        };
+        config: {
+            listAccountIds(cfg: unknown): string[];
+            resolveAccount(cfg: unknown, accountId?: string | null): ResolvedAccount;
+            isConfigured(_account: ResolvedAccount): boolean;
+            isEnabled(account: ResolvedAccount): boolean;
+        };
+        gateway: {
+            startAccount(ctx: GatewayContext): Promise<void>;
+            stopAccount(ctx: GatewayContext): Promise<void>;
+        };
+        outbound: {
+            deliveryMode: "direct";
+            sendText(ctx: OutboundContext): Promise<DeliveryResult>;
+            sendPayload(ctx: OutboundPayloadContext): Promise<DeliveryResult>;
+            resolveTarget(params: {
+                cfg?: unknown;
+                to?: string;
+                accountId?: string | null;
+            }): {
+                ok: true;
+                to: string;
+            } | {
+                ok: false;
+                error: Error;
+            };
+        };
+        status: {
+            probeAccount(params: {
+                account: ResolvedAccount;
+                timeoutMs: number;
+                cfg: unknown;
+            }): Promise<LingyaoProbeResult>;
+            buildChannelSummary(params: {
+                account: ResolvedAccount;
+                cfg: unknown;
+                defaultAccountId: string;
+                snapshot: Record<string, unknown>;
+            }): Promise<Record<string, unknown>>;
+        };
+        directory: {
+            listPeers(params: {
+                cfg: unknown;
+                accountId?: string | null;
+                query?: string | null;
+                limit?: number | null;
+                runtime?: unknown;
+            }): Promise<DirectoryEntry[]>;
+        };
+        messaging: {
+            normalizeTarget(raw: string): string | undefined;
+            resolveSessionTarget(params: {
+                kind: "group" | "channel";
+                id: string;
+                threadId?: string | null;
+            }): string | undefined;
+            inferTargetChatType(_params: {
+                to: string;
+            }): "direct" | undefined;
+        };
+    };
+    security: {
+        dm: {
+            channelKey: string;
+            resolvePolicy: (account: ResolvedAccount) => "paired" | "open" | "deny";
+            resolveAllowFrom: (account: ResolvedAccount) => readonly string[];
+            defaultPolicy: "paired";
+        };
+    };
+    pairing: {
+        text: {
+            idLabel: string;
+            message: string;
+            notify: (params: {
+                cfg: unknown;
+                id: string;
+            }) => Promise<void>;
+        };
+    };
+};
+
+export { type AgentMessage, DeviceInfo, DeviceToken, HealthStatus, LingyaoAccountConfig, LingyaoChannel, LingyaoConfig, LingyaoMessage, LingyaoRuntime, NotifyPayload, SyncRequest, SyncResponse, createPlugin, pluginEntry as default, getDefaultConfig, pluginMetadata, validateConfig };