@lingyao037/openclaw-lingyao-cli 0.3.3 → 0.3.5

package/dist/index.d.ts

@@ -1,12 +1,31 @@
 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';
 
+/**
+ * Messaging Adapter - Target normalization and session resolution
+ *
+ * Implements ChannelMessagingAdapter:
+ * - normalizeTarget: strip "lingyao:" prefix, return pure deviceId
+ * - resolveSessionTarget: return "lingyao:{id}" format
+ * - inferTargetChatType: always "direct" (Lingyao has no groups)
+ */
+/**
+ * SDK-compatible messaging interfaces
+ */
+type ChatType = 'direct' | 'group';
+
 /**
  * Config Adapter - Account resolution, config validation
  *
  * serverUrl is NOT exposed to users — hardcoded as LINGYAO_SERVER_URL.
  */
 
+/**
+ * OpenClawConfig - compatible with SDK interface
+ */
+interface OpenClawConfig$4 {
+    channels?: Record<string, unknown>;
+}
 /**
  * Resolved account after config resolution.
  */
@@ -767,10 +786,14 @@ declare class ErrorHandler {
  */
 
 /**
- * Matches SDK's ChannelDirectoryEntry.
+ * SDK-compatible directory interfaces
  */
-interface DirectoryEntry {
-    kind: 'user' | 'group' | 'channel';
+interface OpenClawConfig$3 {
+    channels?: Record<string, unknown>;
+}
+type ChannelDirectoryEntryKind = 'user' | 'group' | 'channel';
+interface ChannelDirectoryEntry {
+    kind: ChannelDirectoryEntryKind;
     id: string;
     name?: string;
     handle?: string;
@@ -778,6 +801,15 @@ interface DirectoryEntry {
     rank?: number;
     raw?: unknown;
 }
+interface RuntimeEnv$1 {
+}
+interface ChannelDirectoryListParams {
+    cfg: OpenClawConfig$3;
+    accountId?: string | null;
+    query?: string | null;
+    limit?: number | null;
+    runtime: RuntimeEnv$1;
+}
 
 /**
  * Status Adapter - Health checks and channel summary
@@ -793,6 +825,18 @@ interface DirectoryEntry {
  * Wraps existing Probe and Monitor classes.
  */
 
+/**
+ * SDK-compatible status interfaces
+ */
+interface OpenClawConfig$2 {
+    channels?: Record<string, unknown>;
+}
+interface ChannelAccountSnapshot$1 {
+    accountId: string;
+    configured: boolean;
+    enabled: boolean;
+    running: boolean;
+}
 /**
  * Probe result structure.
  */
@@ -826,26 +870,23 @@ interface LingyaoProbeResult {
  */
 
 /**
- * Minimal subset of ChannelOutboundContext that we need.
+ * SDK-compatible outbound interfaces
  */
-interface OutboundContext {
-    cfg?: unknown;
+interface OpenClawConfig$1 {
+    channels?: Record<string, unknown>;
+}
+interface ChannelOutboundContext {
+    cfg: OpenClawConfig$1;
     to: string;
     text: string;
     mediaUrl?: string;
     accountId?: string | null;
     silent?: boolean;
 }
-/**
- * Minimal ChannelOutboundPayloadContext.
- */
-interface OutboundPayloadContext extends OutboundContext {
+interface ChannelOutboundPayloadContext extends ChannelOutboundContext {
     payload: unknown;
 }
-/**
- * OutboundDeliveryResult - what SDK expects back.
- */
-interface DeliveryResult {
+interface OutboundDeliveryResult {
     channel: string;
     messageId: string;
     chatId?: string;
@@ -862,29 +903,40 @@ interface DeliveryResult {
  *
  * Delegates to MultiAccountOrchestrator for all operations.
  *
- * SDK passes ChannelGatewayContext which includes:
+ * SDK passes ChannelGatewayContext with required fields:
  *   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.
+ * SDK-compatible ChannelGatewayContext interface
  */
-interface GatewayContext {
+interface ChannelGatewayContext<ResolvedAccount = unknown> {
+    cfg: OpenClawConfig;
     accountId: string;
     account: ResolvedAccount;
-    cfg?: unknown;
-    runtime?: unknown;
-    abortSignal?: AbortSignal;
+    runtime: RuntimeEnv;
+    abortSignal: AbortSignal;
     log?: {
         info: (msg: string) => void;
-        warn: (msg: string) => void;
-        error: (msg: string) => void;
+        warn?: (msg: string) => void;
+        error?: (msg: string) => void;
         debug?: (msg: string) => void;
     };
-    getStatus?: () => unknown;
-    setStatus?: (next: unknown) => void;
+    getStatus: () => ChannelAccountSnapshot;
+    setStatus: (next: ChannelAccountSnapshot) => void;
+    channelRuntime?: unknown;
+}
+interface OpenClawConfig {
+    channels?: Record<string, unknown>;
+}
+interface RuntimeEnv {
+}
+interface ChannelAccountSnapshot {
+    accountId: string;
+    configured: boolean;
+    enabled: boolean;
+    running: boolean;
 }
 
 /**
@@ -1147,21 +1199,21 @@ declare const pluginEntry: {
             blockStreaming: boolean;
         };
         config: {
-            listAccountIds(cfg: unknown): string[];
-            resolveAccount(cfg: unknown, accountId?: string | null): ResolvedAccount;
-            isConfigured(_account: ResolvedAccount): boolean;
-            isEnabled(account: ResolvedAccount): boolean;
+            listAccountIds(cfg: OpenClawConfig$4): string[];
+            resolveAccount(cfg: OpenClawConfig$4, accountId?: string | null): ResolvedAccount;
+            isConfigured(_account: ResolvedAccount, _cfg: OpenClawConfig$4): boolean;
+            isEnabled(account: ResolvedAccount, _cfg: OpenClawConfig$4): boolean;
         };
         gateway: {
-            startAccount(ctx: GatewayContext): Promise<void>;
-            stopAccount(ctx: GatewayContext): Promise<void>;
+            startAccount(ctx: ChannelGatewayContext<ResolvedAccount>): Promise<void>;
+            stopAccount(ctx: ChannelGatewayContext<ResolvedAccount>): Promise<void>;
         };
         outbound: {
             deliveryMode: "direct";
-            sendText(ctx: OutboundContext): Promise<DeliveryResult>;
-            sendPayload(ctx: OutboundPayloadContext): Promise<DeliveryResult>;
+            sendText(ctx: ChannelOutboundContext): Promise<OutboundDeliveryResult>;
+            sendPayload(ctx: ChannelOutboundPayloadContext): Promise<OutboundDeliveryResult>;
             resolveTarget(params: {
-                cfg?: unknown;
+                cfg?: OpenClawConfig$1;
                 to?: string;
                 accountId?: string | null;
             }): {
@@ -1176,34 +1228,28 @@ declare const pluginEntry: {
             probeAccount(params: {
                 account: ResolvedAccount;
                 timeoutMs: number;
-                cfg: unknown;
+                cfg: OpenClawConfig$2;
             }): Promise<LingyaoProbeResult>;
             buildChannelSummary(params: {
                 account: ResolvedAccount;
-                cfg: unknown;
+                cfg: OpenClawConfig$2;
                 defaultAccountId: string;
-                snapshot: Record<string, unknown>;
+                snapshot: ChannelAccountSnapshot$1;
             }): Promise<Record<string, unknown>>;
         };
         directory: {
-            listPeers(params: {
-                cfg: unknown;
-                accountId?: string | null;
-                query?: string | null;
-                limit?: number | null;
-                runtime?: unknown;
-            }): Promise<DirectoryEntry[]>;
+            listPeers(params: ChannelDirectoryListParams): Promise<ChannelDirectoryEntry[]>;
         };
         messaging: {
             normalizeTarget(raw: string): string | undefined;
             resolveSessionTarget(params: {
-                kind: "group" | "channel";
+                kind: "user" | "group" | "channel";
                 id: string;
-                threadId?: string | null;
+                threadId?: string | number | null;
             }): string | undefined;
             inferTargetChatType(_params: {
                 to: string;
-            }): "direct" | undefined;
+            }): ChatType | undefined;
         };
     };
     security: {

package/dist/index.js

@@ -40,10 +40,10 @@ function createConfigAdapter() {
         rawConfig: accountConfig
       };
     },
-    isConfigured(_account) {
+    isConfigured(_account, _cfg) {
       return true;
     },
-    isEnabled(account) {
+    isEnabled(account, _cfg) {
       return account.enabled;
     }
   };
@@ -241,11 +241,10 @@ function createOutboundAdapter(getOrchestrator2) {
         throw new Error("Orchestrator not initialized");
       }
       const accountId = ctx.accountId ?? "default";
-      const payload = ctx.payload;
       const sent = orchestrator2.sendNotification(
         accountId,
         ctx.to,
-        payload
+        ctx.payload
       );
       if (!sent) {
         throw new Error(