@wps365/openclaw-wpsxiezuo 1.6.0

package/dist/channel/event-handlers.d.ts

@@ -0,0 +1,61 @@
+/**
+ * WPS 入站事件处理 — Webhook HTTP + SDK 长连接双模式。
+ *
+ * 对标飞书 src/channel/event-handlers.ts：
+ * - Webhook: Express POST → challenge / 加解密 / 分发
+ * - SDK: open-event-sdk 映射为统一 WpsEventPayload
+ *
+ * 不包含业务逻辑（session / routing / reply），仅做事件基础设施。
+ */
+import type { WpsEventPayload } from "./event-types.js";
+import type { LogFacade } from "./types.js";
+export declare function shouldSkipNonMessageTopic(topic: unknown): boolean;
+type SdkMessageData = {
+    chat: {
+        id: string;
+        type: string;
+    };
+    message: {
+        id: string;
+        type: string;
+        content: unknown;
+        quote_msg_id?: string;
+        mentions?: unknown;
+        reply_to?: unknown;
+    };
+    sender: {
+        id: string;
+        type: string;
+        extended_attribute?: {
+            name?: string;
+        };
+    };
+    send_time: number;
+    quote_msg_id?: string;
+};
+export declare function buildMessageContent(msg: SdkMessageData["message"]): Record<string, unknown>;
+export declare function extractRichTextContent(richText: unknown): string[];
+/** 将 open-event-sdk 消息事件转为统一 WpsEventPayload */
+export declare function mapSdkMessageToPayload(data: SdkMessageData): WpsEventPayload;
+export type WebhookDecryptResult = {
+    ok: true;
+    payload: WpsEventPayload;
+} | {
+    ok: false;
+    error: string;
+    status?: number;
+};
+/**
+ * 处理单个 Webhook POST body：
+ * - challenge 验证 → 返回 { challenge }
+ * - 加密事件 → 签名校验 + 解密
+ * - 明文事件 → 直接透传
+ */
+export declare function processWebhookBody(body: unknown, creds: {
+    appId: string;
+    appSecret: string;
+}, enableEncryption: boolean, log?: LogFacade): {
+    challenge: string;
+} | WebhookDecryptResult;
+export {};
+//# sourceMappingURL=event-handlers.d.ts.map

package/dist/channel/event-types.d.ts

@@ -0,0 +1,88 @@
+/**
+ * WPS 入站事件类型定义。
+ * 对标飞书 src/channel/event-types.ts。
+ */
+/** Webhook 解密后或 SDK 映射后的统一入站事件结构 */
+export type WpsEventPayload = {
+    topic?: string;
+    event_id?: string;
+    company_id?: string;
+    chat?: {
+        id?: string;
+        type?: string;
+    };
+    message?: {
+        id?: string;
+        type?: string;
+        content?: Record<string, unknown>;
+        sender?: {
+            id?: string;
+            type?: string;
+        };
+        mentions?: Array<{
+            type?: string;
+            id?: string;
+            user_id?: string;
+            userId?: string;
+            open_id?: string;
+            offset?: number;
+            length?: number;
+            identity?: {
+                id?: string;
+                app_id?: string;
+                name?: string;
+                type?: string;
+                company_id?: string;
+            };
+        }>;
+        reply_to?: {
+            sender_id?: string;
+            sender?: {
+                id?: string;
+            };
+        };
+    };
+    /** 引用回复场景下被引用消息的 id（SDK v7 notification 顶层 quote_msg_id 字段） */
+    quote_msg_id?: string;
+    sender?: {
+        id?: string;
+        type?: string;
+        name?: string;
+    };
+    send_time?: number;
+};
+/** Webhook 加密事件外壳 */
+export type WpsEncryptedEvent = {
+    topic: string;
+    operation: string;
+    time: number;
+    nonce: string;
+    signature: string;
+    encrypted_data: string;
+};
+/** 入站消息附件元数据 */
+export type InboundAttachmentMeta = {
+    kind: "image" | "file";
+    name?: string;
+    fileId?: string;
+    url?: string;
+    mimeType?: string;
+    size?: number;
+    storageKey?: string;
+    width?: number;
+    height?: number;
+    thumbnailStorageKey?: string;
+    /** WPS cloud file: type="cloud", has link_url but no storage_key */
+    cloudType?: boolean;
+    cloudLinkUrl?: string;
+    cloudLinkId?: string;
+};
+/** 归一化后的入站消息 */
+export type NormalizedInboundMessage = {
+    kind: "text" | "image" | "file" | "rich_text" | "sticker" | "card" | "mixed" | "unknown";
+    plainText: string;
+    agentText: string;
+    attachments: InboundAttachmentMeta[];
+};
+export declare const MESSAGE_TOPIC = "kso.app_chat.message";
+//# sourceMappingURL=event-types.d.ts.map

package/dist/channel/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Channel module exports
+ */
+export * from "./event-types.js";
+export * from "./event-crypto.js";
+export * from "./event-handlers.js";
+export * from "./sdk-provider.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/channel/plugin.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WPS ChannelPlugin 契约实现。
+ *
+ * 对标飞书 src/channel/plugin.ts：实现 ChannelPlugin 接口的全部能力面。
+ * 依赖方向：channel/ → core/（不反向）。
+ */
+import type { ChannelPlugin, ResolvedWpsAccount, PluginRuntime } from "./types.js";
+export declare function setPluginRuntime(rt: PluginRuntime): void;
+export declare function getPluginRuntime(): PluginRuntime;
+export declare const wpsPlugin: ChannelPlugin<ResolvedWpsAccount>;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/channel/register-tool-bridge.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 工具注册桥接模块。
+ *
+ * OpenClaw 的 api.registerTool 在 register() 阶段提供，
+ * 但需要在 startAccount() 阶段（gateway 完全启动后）才能有效注册工具。
+ * 此模块保存函数引用，供 startAccount() 延迟调用。
+ */
+type RegisterToolFn = (tool: unknown, opts?: {
+    name?: string;
+}) => void;
+export declare function setSavedRegisterTool(fn: RegisterToolFn): void;
+export declare function getSavedRegisterTool(): RegisterToolFn | null;
+export {};
+//# sourceMappingURL=register-tool-bridge.d.ts.map

package/dist/channel/sdk-client-options.d.ts

@@ -0,0 +1,24 @@
+import type { Dispatcher } from "open-event-sdk";
+import type { WpsConfig } from "../core/config.js";
+export type BaseSdkClientOptions = {
+    appId: string;
+    appSecret: string;
+    dispatcher: Dispatcher;
+    logLevel: number;
+    endpoint?: string;
+};
+export type ExtendedSdkClientOptions = BaseSdkClientOptions & {
+    pongTimeout: number;
+    autoReconnect: boolean;
+    reconnectBaseInterval: number;
+    reconnectMaxInterval: number;
+    reconnectMultiplier: number;
+    reconnectMaxRetry: number;
+    reconnectJitter: number;
+};
+/**
+ * Build client options with stable defaults so all SDK entry points share
+ * the same heartbeat and reconnect behavior.
+ */
+export declare function buildSdkClientOptions(base: BaseSdkClientOptions, sdkCfg?: WpsConfig["sdk"]): ExtendedSdkClientOptions;
+//# sourceMappingURL=sdk-client-options.d.ts.map

package/dist/channel/sdk-helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OpenClaw Plugin SDK 运行时辅助函数。
+ *
+ * SDK 由 OpenClaw 宿主在运行时提供，这里做安全加载和 fallback。
+ * 对标飞书 src/core/ 中的 sdk 辅助。
+ */
+export declare const SDK_DEFAULT_ACCOUNT_ID: string;
+export declare function emptyPluginConfigSchema(): unknown;
+export declare function buildChannelConfigSchema(schema: unknown): unknown;
+export declare function formatPairingApproveHint(channel: string): string;
+export declare function waitUntilAbort(signal: AbortSignal, onAbort: () => Promise<void>): Promise<void>;
+//# sourceMappingURL=sdk-helpers.d.ts.map

package/dist/channel/sdk-provider.d.ts

@@ -0,0 +1,23 @@
+/**
+ * WPS SDK Provider - 管理 open-event-sdk 长连接生命周期
+ *
+ * 参考 openclaw-wps-xiezuo-helper/packages/channel-plugin/src/wps-sdk-provider.ts
+ * 实现 WebSocket 长连接的启动、状态检查和优雅关闭
+ */
+import { Dispatcher } from "open-event-sdk";
+import type { WpsConfig } from "../core/config.js";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+export type SdkProviderResult = {
+    shutdown: () => void;
+};
+/**
+ * 启动 WPS 开放平台长连接（open-event-sdk）
+ * 连接在超时内未建立则抛出错误
+ */
+export declare function startSdkProvider(opts: {
+    config: WpsConfig;
+    api: OpenClawPluginApi;
+    dispatcher: Dispatcher;
+    abortSignal?: AbortSignal;
+}): Promise<SdkProviderResult>;
+//# sourceMappingURL=sdk-provider.d.ts.map

package/dist/channel/types.d.ts

@@ -0,0 +1,324 @@
+/**
+ * OpenClaw Plugin SDK 类型定义。
+ *
+ * OpenClaw 在运行时注入 SDK，这里定义插件侧使用的契约类型。
+ * v1 中 plugin-sdk-types.ts 全部用 any，v2 给出结构化定义。
+ */
+export type OpenClawPluginApi = {
+    runtime: PluginRuntime;
+    logger?: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+        debug?: (msg: string) => void;
+    };
+    registerChannel: (opts: {
+        plugin: ChannelPlugin<unknown>;
+    }) => void;
+    registerTool?: (tool: unknown, opts?: {
+        name?: string;
+    }) => void;
+    on?: (hookName: string, handler: (...args: unknown[]) => unknown, opts?: {
+        priority?: number;
+    }) => void;
+};
+export type PluginRuntime = {
+    log?: LogFacade;
+    config?: Record<string, unknown>;
+    channel: {
+        text: {
+            chunkMarkdownText: (text: string, limit: number) => string[];
+        };
+    };
+};
+export type LogFacade = {
+    info?: (...args: unknown[]) => void;
+    warn?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+    debug?: (...args: unknown[]) => void;
+};
+export type ToolRegistration = {
+    name: string;
+    description: string;
+    parameters: unknown;
+    execute: (id: string, params: Record<string, unknown>) => Promise<unknown>;
+};
+export type OpenClawConfig = Record<string, unknown> & {
+    channels?: Record<string, unknown>;
+};
+export type ChannelPlugin<TAccount = unknown> = {
+    id: string;
+    meta: ChannelMeta;
+    capabilities: ChannelCapabilities;
+    reload?: {
+        configPrefixes: string[];
+    };
+    configSchema?: unknown;
+    messaging: ChannelMessaging;
+    config: ChannelConfig<TAccount>;
+    security: ChannelSecurity;
+    pairing: ChannelPairing;
+    groups: ChannelGroups;
+    outbound: ChannelOutbound;
+    status: ChannelStatus<TAccount>;
+    gateway: ChannelGateway;
+    onboarding: ChannelOnboarding;
+    agentPrompt?: ChannelAgentPromptAdapter;
+    actions?: ChannelMessageActionAdapter;
+};
+export type ChannelMeta = {
+    id: string;
+    label: string;
+    selectionLabel: string;
+    docsPath: string;
+    docsLabel: string;
+    blurb: string;
+    aliases: string[];
+    order: number;
+};
+export type ChannelCapabilities = {
+    chatTypes: ("direct" | "group")[];
+    media: boolean;
+    threads: boolean;
+    nativeCommands: boolean;
+    blockStreaming: boolean;
+};
+export type ChannelMessaging = {
+    normalizeTarget: (raw: string) => string;
+    targetResolver: {
+        hint: string;
+        looksLikeId: (raw: string) => boolean;
+    };
+};
+export type ChannelConfig<TAccount> = {
+    listAccountIds: () => string[];
+    resolveAccount: (cfg: unknown) => TAccount;
+    defaultAccountId: () => string;
+    setAccountEnabled: (opts: {
+        cfg: unknown;
+        enabled: boolean;
+    }) => unknown;
+    deleteAccount: (opts: {
+        cfg: unknown;
+    }) => unknown;
+    isConfigured: (account: TAccount, cfg: unknown) => boolean;
+    describeAccount: (account: TAccount) => Record<string, unknown>;
+    resolveAllowFrom: (opts: {
+        cfg: unknown;
+    }) => string[];
+    formatAllowFrom: (opts: {
+        allowFrom: unknown[];
+    }) => string[];
+};
+export type ChannelSecurity = {
+    resolveDmPolicy: (opts: {
+        cfg: unknown;
+    }) => {
+        policy: string;
+        allowFrom: string[];
+        policyPath: string;
+        allowFromPath: string;
+        approveHint: string;
+        normalizeEntry: (entry: string) => string;
+    };
+    collectWarnings: (opts: {
+        cfg: unknown;
+    }) => string[];
+};
+export type ChannelPairing = {
+    idLabel: string;
+    normalizeAllowEntry: (entry: string) => string;
+    notifyApproval: (opts: {
+        cfg: unknown;
+        id: string;
+    }) => Promise<void>;
+};
+export type ChannelGroups = {
+    resolveRequireMention: (opts: {
+        cfg: unknown;
+        groupId?: string;
+    }) => boolean;
+    resolveToolPolicy: (opts: {
+        cfg: unknown;
+        groupId?: string;
+    }) => string | undefined;
+};
+export type ChannelOutbound = {
+    deliveryMode: "direct";
+    textChunkLimit: number;
+    chunker: (text: string, limit: number) => string[];
+    chunkerMode: string;
+    resolveTarget: (opts: {
+        to?: string;
+        allowFrom?: unknown[];
+    }) => {
+        ok: boolean;
+        to?: string;
+        error?: Error;
+    };
+    sendText: (opts: {
+        cfg: unknown;
+        to: string;
+        text: string;
+    }) => Promise<unknown>;
+    sendMedia: (opts: {
+        cfg: unknown;
+        to: string;
+        mediaUrl: string;
+        mimeType?: string;
+    }) => Promise<unknown>;
+};
+export type ChannelStatusIssue = {
+    channel: string;
+    accountId: string;
+    kind: "config" | "health" | "auth";
+    message: string;
+    fix?: string;
+};
+export type ChannelStatus<TAccount> = {
+    defaultRuntime: Record<string, unknown>;
+    collectStatusIssues: (accounts: TAccount[]) => ChannelStatusIssue[];
+    buildChannelSummary: (opts: {
+        snapshot: Record<string, unknown>;
+    }) => Record<string, unknown>;
+    probeAccount: (opts: {
+        account: TAccount;
+    }) => Promise<Record<string, unknown>>;
+    buildAccountSnapshot: (opts: {
+        account: TAccount;
+        runtime?: Record<string, unknown>;
+        probe?: Record<string, unknown>;
+    }) => Record<string, unknown>;
+};
+export type RuntimeEnv = {
+    log?: (...args: unknown[]) => void;
+    error?: (...args: unknown[]) => void;
+    writeStdout?: (value: string) => void;
+    writeJson?: (value: unknown, space?: number) => void;
+    exit?: (code?: number) => void;
+};
+/**
+ * channelRuntime 表面 — 由 createPluginRuntime().channel 创建。
+ * 外部插件通过 ctx.channelRuntime 访问 AI reply/routing/session 等高级功能。
+ * @see PluginRuntimeChannel in openclaw/dist/plugin-sdk/src/plugins/runtime/types-channel.d.ts
+ */
+export type ChannelRuntimeSurface = {
+    reply: {
+        dispatchReplyFromConfig: (params: {
+            ctx: Record<string, unknown>;
+            cfg: unknown;
+            dispatcher: unknown;
+            replyOptions?: Record<string, unknown>;
+        }) => Promise<unknown>;
+        dispatchReplyWithBufferedBlockDispatcher: (params: {
+            ctx: Record<string, unknown>;
+            cfg: unknown;
+            dispatcherOptions: {
+                deliver: (payload: {
+                    text?: string;
+                    [k: string]: unknown;
+                }, info: {
+                    kind: string;
+                }) => Promise<void>;
+                responsePrefix?: string;
+                humanDelay?: unknown;
+                onError?: (err: unknown, info: {
+                    kind: string;
+                }) => void;
+            };
+            replyOptions?: Record<string, unknown>;
+        }) => Promise<unknown>;
+        createReplyDispatcherWithTyping: (opts: unknown) => {
+            dispatcher: unknown;
+            replyOptions: Record<string, unknown>;
+            markDispatchIdle: () => void;
+            markRunComplete: () => void;
+        };
+        resolveHumanDelayConfig: (cfg: unknown, agentId: string) => unknown;
+        finalizeInboundContext: <T extends Record<string, unknown>>(ctx: T, opts?: Record<string, unknown>) => T;
+        [key: string]: unknown;
+    };
+    routing: {
+        resolveAgentRoute: (opts: {
+            cfg: unknown;
+            channel: string;
+            accountId?: string;
+            peer: {
+                kind: string;
+                id: string;
+            };
+        }) => {
+            agentId: string;
+            sessionKey?: string;
+            accountId?: string;
+        };
+        buildAgentSessionKey: (...args: unknown[]) => string;
+        [key: string]: unknown;
+    };
+    session: {
+        resolveStorePath: (...args: unknown[]) => string;
+        recordInboundSession: (...args: unknown[]) => unknown;
+        [key: string]: unknown;
+    };
+    text: {
+        chunkMarkdownText: (text: string, limit: number) => string[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+export type GatewayContext = {
+    accountId: string;
+    cfg: unknown;
+    runtime: RuntimeEnv;
+    channelRuntime?: ChannelRuntimeSurface;
+    abortSignal: AbortSignal;
+    log?: LogFacade;
+    getStatus?: () => Record<string, unknown>;
+    setStatus: (status: Record<string, unknown>) => void;
+};
+export type ChannelGateway = {
+    startAccount: (ctx: GatewayContext) => Promise<void>;
+};
+export type ChannelOnboarding = {
+    channel: string;
+    getStatus: (opts: {
+        cfg: unknown;
+    }) => Promise<{
+        channel: string;
+        configured: boolean;
+        statusLines: string[];
+        selectionHint: string;
+        quickstartScore: number;
+    }>;
+    configure: (opts: {
+        cfg: unknown;
+    }) => Promise<{
+        cfg: unknown;
+    }>;
+};
+export type ChannelAgentPromptAdapter = {
+    messageToolHints?: (params: {
+        cfg: unknown;
+        accountId?: string | null;
+    }) => string[];
+};
+export type ChannelMessageActionAdapter = {
+    describeMessageTool: (params: Record<string, unknown>) => {
+        actions?: readonly string[] | null;
+    } | null | undefined;
+    handleAction?: (ctx: ChannelMessageActionContext) => Promise<unknown>;
+};
+export type ChannelMessageActionContext = {
+    channel: string;
+    action: string;
+    cfg: unknown;
+    params: Record<string, unknown>;
+    accountId?: string | null;
+};
+export type ResolvedWpsAccount = {
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+    config: import("../core/config.js").WpsConfig;
+};
+//# sourceMappingURL=types.d.ts.map