@xpert-ai/plugin-community-wechat 0.1.0

package/dist/lib/wechat-personal-integration.strategy.d.ts

@@ -0,0 +1,56 @@
+import { IIntegration, TIntegrationProvider } from '@xpert-ai/contracts';
+import { IntegrationStrategy, TIntegrationStrategyParams } from '@xpert-ai/plugin-sdk';
+import { TIntegrationWechatPersonalOptions } from './types.js';
+export declare const WECHAT_PERSONAL_CALLBACK_HINTS: readonly ["推荐：wx2.0 config webhook.allMessagePushUrl / AllMsgPushUrl 指向 Xpert webhook URL", "兼容：对单个账号调用 /message/SetCallback?key=<uuid> 设置 CallbackURL", "消息回复：Xpert 插件调用 wx2.0 /v1/message/sendtext，失败时可回退旧接口"];
+type WechatPersonalIntegrationViewExtensionMeta = {
+    key: string;
+    provider: string;
+    plugin: string;
+    hostType: 'integration';
+    slot: 'detail.main_tabs';
+    viewType: 'remote_component';
+    runtime: 'react';
+    entry: string;
+};
+type WechatPersonalIntegrationProviderMeta = TIntegrationProvider & {
+    targetApps?: string[];
+    targetAppMeta?: {
+        'data-xpert'?: {
+            types?: string[];
+            capabilities?: string[];
+            runtime?: {
+                viewProviders?: string[];
+            };
+            extensions?: {
+                views?: WechatPersonalIntegrationViewExtensionMeta[];
+            };
+        };
+    };
+    extensions?: {
+        views?: WechatPersonalIntegrationViewExtensionMeta[];
+    };
+    extensionViews?: WechatPersonalIntegrationViewExtensionMeta[];
+};
+export declare class WechatPersonalIntegrationStrategy implements IntegrationStrategy<TIntegrationWechatPersonalOptions> {
+    readonly meta: WechatPersonalIntegrationProviderMeta;
+    execute(_integration: IIntegration<TIntegrationWechatPersonalOptions>, _payload: TIntegrationStrategyParams): Promise<any>;
+    validateConfig(config: TIntegrationWechatPersonalOptions, integration?: IIntegration<TIntegrationWechatPersonalOptions>): Promise<{
+        webhookUrl: string;
+        callback: {
+            mode: string;
+            callbackUrl: string;
+            globalWebhookConfigKeys: string[];
+            setCallback: {
+                method: string;
+                urlTemplate: string;
+                body: {
+                    CallbackURL: string;
+                    Enabled: boolean;
+                };
+            };
+            expectedAckMs: number;
+            subscriptionHints: ("推荐：wx2.0 config webhook.allMessagePushUrl / AllMsgPushUrl 指向 Xpert webhook URL" | "兼容：对单个账号调用 /message/SetCallback?key=<uuid> 设置 CallbackURL" | "消息回复：Xpert 插件调用 wx2.0 /v1/message/sendtext，失败时可回退旧接口")[];
+        };
+    }>;
+}
+export {};

package/dist/lib/wechat-personal-integration.strategy.js

@@ -0,0 +1,217 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from '@nestjs/common';
+import { IntegrationStrategyKey } from '@xpert-ai/plugin-sdk';
+import { WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_ICON, WECHAT_PERSONAL_PLUGIN_NAME, WECHAT_PERSONAL_PROVIDER_KEY, WECHAT_PERSONAL_REMOTE_ENTRY_KEY, WECHAT_PERSONAL_RUNTIME_FEATURE, WECHAT_PERSONAL_VIEW_KEY, WECHAT_PERSONAL_VIEW_PROVIDER_KEY, WECHAT_PERSONAL_WORKBENCH_FEATURE } from './constants.js';
+import { normalizeApiVersion, normalizeBaseUrl, normalizeGroupTriggerMode, normalizeKeywords, normalizeTimeoutMs } from './types.js';
+export const WECHAT_PERSONAL_CALLBACK_HINTS = [
+    '推荐：wx2.0 config webhook.allMessagePushUrl / AllMsgPushUrl 指向 Xpert webhook URL',
+    '兼容：对单个账号调用 /message/SetCallback?key=<uuid> 设置 CallbackURL',
+    '消息回复：Xpert 插件调用 wx2.0 /v1/message/sendtext，失败时可回退旧接口'
+];
+const WECHAT_PERSONAL_INTEGRATION_VIEW_EXTENSION = {
+    key: WECHAT_PERSONAL_VIEW_KEY,
+    provider: WECHAT_PERSONAL_VIEW_PROVIDER_KEY,
+    plugin: WECHAT_PERSONAL_PLUGIN_NAME,
+    hostType: 'integration',
+    slot: 'detail.main_tabs',
+    viewType: 'remote_component',
+    runtime: 'react',
+    entry: WECHAT_PERSONAL_REMOTE_ENTRY_KEY
+};
+let WechatPersonalIntegrationStrategy = class WechatPersonalIntegrationStrategy {
+    constructor() {
+        this.meta = {
+            name: WECHAT_PERSONAL_PROVIDER_KEY,
+            label: {
+                en_US: 'Personal WeChat (wx2.0)',
+                zh_Hans: '个人微信 wx2.0'
+            },
+            icon: {
+                type: 'svg',
+                value: WECHAT_PERSONAL_ICON
+            },
+            description: {
+                en_US: 'Bridge wx2.0 personal WeChat webhooks and outbound text replies to Xpert agents.',
+                zh_Hans: '连接 wx2.0 个人微信 webhook 与 Xpert Agent 文本回复。'
+            },
+            targetApps: ['data-xpert'],
+            targetAppMeta: {
+                'data-xpert': {
+                    types: ['integration', 'workbench-view'],
+                    capabilities: [WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_RUNTIME_FEATURE, WECHAT_PERSONAL_WORKBENCH_FEATURE],
+                    runtime: {
+                        viewProviders: [WECHAT_PERSONAL_VIEW_PROVIDER_KEY]
+                    },
+                    extensions: {
+                        views: [WECHAT_PERSONAL_INTEGRATION_VIEW_EXTENSION]
+                    }
+                }
+            },
+            extensions: {
+                views: [WECHAT_PERSONAL_INTEGRATION_VIEW_EXTENSION]
+            },
+            extensionViews: [WECHAT_PERSONAL_INTEGRATION_VIEW_EXTENSION],
+            webhook: true,
+            schema: {
+                type: 'object',
+                properties: {
+                    baseUrl: {
+                        type: 'string',
+                        title: {
+                            en_US: 'wx2.0 Base URL',
+                            zh_Hans: 'wx2.0 服务地址'
+                        },
+                        description: {
+                            en_US: 'Example: http://127.0.0.1:8058',
+                            zh_Hans: '例如：http://127.0.0.1:8058'
+                        }
+                    },
+                    apiVersion: {
+                        type: 'string',
+                        title: {
+                            en_US: 'API Version Prefix',
+                            zh_Hans: 'API 版本前缀'
+                        },
+                        default: '/v1/'
+                    },
+                    timeoutMs: {
+                        type: 'number',
+                        title: {
+                            en_US: 'Request Timeout (ms)',
+                            zh_Hans: '请求超时（毫秒）'
+                        },
+                        default: 10000
+                    },
+                    apiToken: {
+                        type: 'string',
+                        title: {
+                            en_US: 'API Token',
+                            zh_Hans: 'API Token'
+                        },
+                        description: {
+                            en_US: 'Optional token header reserved for wx2.0 TokenAuth.',
+                            zh_Hans: '可选，作为 token header 发送，兼容后续 wx2.0 TokenAuth。'
+                        },
+                        'x-ui': {
+                            component: 'password'
+                        }
+                    },
+                    preferLanguage: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Preferred Language',
+                            zh_Hans: '首选语言'
+                        },
+                        enum: ['en', 'zh-Hans'],
+                        default: 'zh-Hans'
+                    },
+                    callbackSecret: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Callback Secret',
+                            zh_Hans: '回调密钥'
+                        },
+                        description: {
+                            en_US: 'Optional secret passed by query secret or x-wechat-callback-secret header.',
+                            zh_Hans: '可选，通过 query secret 或 x-wechat-callback-secret header 校验。'
+                        },
+                        'x-ui': {
+                            component: 'password'
+                        }
+                    },
+                    groupTriggerMode: {
+                        type: 'string',
+                        title: {
+                            en_US: 'Group Trigger Mode',
+                            zh_Hans: '群聊触发方式'
+                        },
+                        enum: ['mention_or_keywords', 'all', 'mentions', 'keywords', 'off'],
+                        default: 'mention_or_keywords'
+                    },
+                    groupKeywords: {
+                        type: 'array',
+                        title: {
+                            en_US: 'Group Keywords',
+                            zh_Hans: '群聊关键词'
+                        },
+                        items: {
+                            type: 'string'
+                        }
+                    },
+                    ignoreSelfMessages: {
+                        type: 'boolean',
+                        title: {
+                            en_US: 'Ignore Self Messages',
+                            zh_Hans: '忽略自己发出的消息'
+                        },
+                        default: true
+                    },
+                    fallbackToLegacySendText: {
+                        type: 'boolean',
+                        title: {
+                            en_US: 'Fallback to Legacy SendText',
+                            zh_Hans: '失败时回退旧发送接口'
+                        },
+                        default: true
+                    }
+                },
+                required: ['baseUrl'],
+                secret: ['apiToken', 'callbackSecret']
+            }
+        };
+    }
+    async execute(_integration, _payload) {
+        return null;
+    }
+    async validateConfig(config, integration) {
+        const baseUrl = normalizeBaseUrl(config?.baseUrl);
+        if (!baseUrl) {
+            throw new Error('wx2.0 baseUrl is required');
+        }
+        try {
+            new URL(baseUrl);
+        }
+        catch {
+            throw new Error('wx2.0 baseUrl must be a valid URL');
+        }
+        config.apiVersion = normalizeApiVersion(config.apiVersion);
+        config.timeoutMs = normalizeTimeoutMs(config.timeoutMs);
+        config.groupTriggerMode = normalizeGroupTriggerMode(config.groupTriggerMode);
+        config.groupKeywords = normalizeKeywords(config.groupKeywords);
+        config.ignoreSelfMessages = config.ignoreSelfMessages !== false;
+        config.fallbackToLegacySendText = config.fallbackToLegacySendText !== false;
+        const apiBaseUrl = (process.env.API_BASE_URL || '').replace(/\/+$/, '');
+        const integrationId = integration?.id || '<save_and_get_your_integration_id>';
+        const callbackSecret = config.callbackSecret?.trim();
+        const callbackUrl = `${apiBaseUrl}/api/wechat-personal/webhook/${integrationId}${callbackSecret ? `?secret=${encodeURIComponent(callbackSecret)}` : ''}`;
+        const redactedCallbackUrl = `${apiBaseUrl}/api/wechat-personal/webhook/${integrationId}${callbackSecret ? '?secret=***' : ''}`;
+        return {
+            webhookUrl: callbackUrl,
+            callback: {
+                mode: 'http',
+                callbackUrl,
+                globalWebhookConfigKeys: ['webhook.allMessagePushUrl', 'AllMsgPushUrl'],
+                setCallback: {
+                    method: 'POST',
+                    urlTemplate: `${baseUrl}/message/SetCallback?key=<uuid>`,
+                    body: {
+                        CallbackURL: redactedCallbackUrl,
+                        Enabled: true
+                    }
+                },
+                expectedAckMs: 1500,
+                subscriptionHints: [...WECHAT_PERSONAL_CALLBACK_HINTS]
+            }
+        };
+    }
+};
+WechatPersonalIntegrationStrategy = __decorate([
+    Injectable(),
+    IntegrationStrategyKey(WECHAT_PERSONAL_PROVIDER_KEY)
+], WechatPersonalIntegrationStrategy);
+export { WechatPersonalIntegrationStrategy };

package/dist/lib/wechat-personal.client.d.ts

@@ -0,0 +1,29 @@
+import { IIntegration } from '@xpert-ai/contracts';
+import { TIntegrationWechatPersonalOptions } from './types.js';
+export interface WechatPersonalSendTextInput {
+    uuid: string;
+    contactId: string;
+    content: string;
+    atUsers?: string[];
+}
+export interface WechatPersonalSendResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+    raw?: unknown;
+}
+export declare class WechatPersonalClient {
+    sendText(integration: IIntegration<TIntegrationWechatPersonalOptions>, input: WechatPersonalSendTextInput): Promise<WechatPersonalSendResult>;
+    registerCallback(params: {
+        integration: IIntegration<TIntegrationWechatPersonalOptions>;
+        uuid: string;
+        callbackUrl: string;
+        enabled?: boolean;
+    }): Promise<WechatPersonalSendResult>;
+    private buildV2Url;
+    private postJson;
+    private readPayload;
+    private resolveResponseCode;
+    private resolveResponseText;
+    private resolveMessageId;
+}

package/dist/lib/wechat-personal.client.js

@@ -0,0 +1,146 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from '@nestjs/common';
+import { normalizeApiVersion, normalizeBaseUrl, normalizeString, normalizeTimeoutMs } from './types.js';
+let WechatPersonalClient = class WechatPersonalClient {
+    async sendText(integration, input) {
+        const options = integration.options || {};
+        const primary = await this.postJson(integration, this.buildV2Url(options, 'message/sendtext'), {
+            uuid: input.uuid,
+            contactid: input.contactId,
+            textcontent: input.content,
+            atusers: input.atUsers ?? []
+        });
+        if (primary.success || options.fallbackToLegacySendText === false) {
+            return primary;
+        }
+        const legacy = await this.postJson(integration, `${normalizeBaseUrl(options.baseUrl)}/message/SendTextMessage?key=${encodeURIComponent(input.uuid)}`, {
+            MsgItem: [
+                {
+                    ToUserName: input.contactId,
+                    TextContent: input.content,
+                    MsgType: 1,
+                    AtWxIDList: input.atUsers ?? []
+                }
+            ]
+        });
+        if (!legacy.success) {
+            return {
+                ...legacy,
+                error: `${primary.error || 'primary send failed'}; fallback: ${legacy.error || 'legacy send failed'}`
+            };
+        }
+        return legacy;
+    }
+    async registerCallback(params) {
+        const baseUrl = normalizeBaseUrl(params.integration.options?.baseUrl);
+        return this.postJson(params.integration, `${baseUrl}/message/SetCallback?key=${encodeURIComponent(params.uuid)}`, {
+            CallbackURL: params.callbackUrl,
+            Enabled: params.enabled !== false
+        });
+    }
+    buildV2Url(options, path) {
+        const baseUrl = normalizeBaseUrl(options.baseUrl);
+        const apiVersion = normalizeApiVersion(options.apiVersion);
+        return `${baseUrl}${apiVersion}${path.replace(/^\/+/, '')}`;
+    }
+    async postJson(integration, url, body) {
+        const options = integration.options || {};
+        if (!normalizeBaseUrl(options.baseUrl)) {
+            return {
+                success: false,
+                error: 'wx2.0 baseUrl is required'
+            };
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), normalizeTimeoutMs(options.timeoutMs));
+        try {
+            const headers = {
+                'Content-Type': 'application/json'
+            };
+            const token = normalizeString(options.apiToken);
+            if (token) {
+                headers.token = token;
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal
+            });
+            const payload = await this.readPayload(response);
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: `wx2.0 HTTP ${response.status}`,
+                    raw: payload
+                };
+            }
+            const code = this.resolveResponseCode(payload);
+            if (typeof code === 'number' && code !== 0 && code !== 200) {
+                return {
+                    success: false,
+                    error: this.resolveResponseText(payload) || `wx2.0 returned code ${code}`,
+                    raw: payload
+                };
+            }
+            return {
+                success: true,
+                messageId: this.resolveMessageId(payload),
+                raw: payload
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async readPayload(response) {
+        const text = await response.text().catch(() => '');
+        if (!text) {
+            return null;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    resolveResponseCode(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return undefined;
+        }
+        const record = payload;
+        const value = record.code ?? record.Code;
+        return typeof value === 'number' ? value : undefined;
+    }
+    resolveResponseText(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return typeof payload === 'string' ? payload : undefined;
+        }
+        const record = payload;
+        return normalizeString(record.text || record.Text || record.message || record.Message) || undefined;
+    }
+    resolveMessageId(payload) {
+        if (!payload || typeof payload !== 'object') {
+            return undefined;
+        }
+        const record = payload;
+        const data = record.data && typeof record.data === 'object' ? record.data : record;
+        return normalizeString(data.newmsgid || data.newMsgId || data.messageId || data.msgid) || undefined;
+    }
+};
+WechatPersonalClient = __decorate([
+    Injectable()
+], WechatPersonalClient);
+export { WechatPersonalClient };

package/dist/lib/wechat-personal.controller.d.ts

@@ -0,0 +1,50 @@
+import { type PluginContext } from '@xpert-ai/plugin-sdk';
+import { WechatPersonalConversationService } from './conversation.service.js';
+import { WechatPersonalChannelStrategy } from './wechat-personal-channel.strategy.js';
+type HttpRequestLike = {
+    user?: unknown;
+    protocol?: string;
+    headers?: Record<string, unknown>;
+    get?: (name: string) => string | undefined;
+};
+export declare class WechatPersonalController {
+    private readonly conversation;
+    private readonly wechatChannel;
+    private readonly pluginContext;
+    private _integrationPermissionService;
+    constructor(conversation: WechatPersonalConversationService, wechatChannel: WechatPersonalChannelStrategy, pluginContext: PluginContext);
+    private get integrationPermissionService();
+    webhook(integrationId: string, req: HttpRequestLike, body: unknown, querySecret?: string): Promise<string>;
+    getIntegrationSelectOptions(req: HttpRequestLike, keyword?: string): Promise<{
+        value: string;
+        label: string;
+        description?: string;
+        icon?: string;
+    }[]>;
+    getCallbackConfig(integrationId: string): Promise<{
+        webhookUrl: string;
+        globalWebhookUrl: string;
+        setCallbackUrlTemplate: string;
+        setCallbackCurlTemplate: string;
+    }>;
+    registerCallback(integrationId: string, uuid: string, body: {
+        callbackUrl?: string;
+        enabled?: boolean;
+    }): Promise<import("@xpert-ai/plugin-sdk").TChatSendResult>;
+    sendText(integrationId: string, body: {
+        uuid?: string;
+        contactId?: string;
+        contactid?: string;
+        text?: string;
+        content?: string;
+        textcontent?: string;
+        atUsers?: string[];
+        atusers?: string[];
+    }): Promise<import("@xpert-ai/plugin-sdk").TChatSendResult>;
+    private readWechatPersonalIntegration;
+    private verifyCallbackSecret;
+    private fetchProviderSelectOptions;
+    private parseBodyToObject;
+    private toSafeString;
+}
+export {};