@xpert-ai/plugin-community-wechat 0.1.0

package/dist/lib/views/wechat-personal-view.provider.js

@@ -0,0 +1,441 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable } from '@nestjs/common';
+import { readFile } from 'fs/promises';
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { renderRemoteReactIframeHtml, ViewExtensionProvider, getErrorMessage } from '@xpert-ai/plugin-sdk';
+import { AGENT_WORKBENCH_FIXED_SLOT, AGENT_WORKBENCH_MAIN_SLOT, WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_ICON, WECHAT_PERSONAL_PLUGIN_NAME, WECHAT_PERSONAL_PROVIDER_KEY, WECHAT_PERSONAL_REMOTE_ENTRY_KEY, WECHAT_PERSONAL_VIEW_KEY, WECHAT_PERSONAL_VIEW_PROVIDER_KEY } from '../constants.js';
+import { WechatPersonalConversationService } from '../conversation.service.js';
+import { WechatPersonalChannelStrategy } from '../wechat-personal-channel.strategy.js';
+const __filename = fileURLToPath(import.meta.url);
+const moduleDir = dirname(__filename);
+const requireFromHere = createRequire(__filename);
+const INTEGRATION_DETAIL_MAIN_TABS_SLOT = 'detail.main_tabs';
+const text = (en_US, zh_Hans) => ({ en_US, zh_Hans });
+const WECHAT_PERSONAL_VIEW_ICON = {
+    type: 'svg',
+    value: WECHAT_PERSONAL_ICON,
+    alt: 'Personal WeChat'
+};
+// plugin-sdk 3.10 still types view icons as strings, while contracts 3.11 accepts IconDefinition.
+const WECHAT_PERSONAL_VIEW_ICON_FOR_SDK = WECHAT_PERSONAL_VIEW_ICON;
+let WechatPersonalViewProvider = class WechatPersonalViewProvider {
+    constructor(conversationService, wechatChannel) {
+        this.conversationService = conversationService;
+        this.wechatChannel = wechatChannel;
+    }
+    supports(context) {
+        if (context.hostType === 'agent') {
+            return true;
+        }
+        if (context.hostType !== 'integration') {
+            return false;
+        }
+        return [getStringProperty(context.hostSnapshot, 'provider'), getStringProperty(context.hostSnapshot, 'type')].some((value) => value === WECHAT_PERSONAL_PROVIDER_KEY);
+    }
+    getViewManifests(context, slot) {
+        if (!isSupportedSlot(context, slot)) {
+            return [];
+        }
+        const isAgentFixedWorkbench = context.hostType === 'agent' && slot === AGENT_WORKBENCH_FIXED_SLOT;
+        const requiresFeatureActivation = context.hostType === 'agent';
+        return [
+            {
+                key: WECHAT_PERSONAL_VIEW_KEY,
+                title: text('Personal WeChat', '个人微信'),
+                description: text('Manage wx2.0 accounts, conversations, message logs, callbacks, and dispatch settings.', '管理 wx2.0 账号、会话、消息日志、回调和派发配置。'),
+                icon: WECHAT_PERSONAL_VIEW_ICON_FOR_SDK,
+                hostType: context.hostType,
+                slot,
+                order: 40,
+                refreshable: true,
+                ...(requiresFeatureActivation
+                    ? {
+                        activation: {
+                            requiredFeatures: [WECHAT_PERSONAL_FEATURE]
+                        }
+                    }
+                    : {}),
+                ...(isAgentFixedWorkbench
+                    ? {
+                        workbench: {
+                            fixed: true,
+                            menu: {
+                                enabled: true,
+                                label: text('Personal WeChat', '个人微信'),
+                                order: 40,
+                                icon: WECHAT_PERSONAL_VIEW_ICON_FOR_SDK
+                            }
+                        }
+                    }
+                    : {}),
+                source: {
+                    provider: WECHAT_PERSONAL_VIEW_PROVIDER_KEY,
+                    plugin: WECHAT_PERSONAL_PLUGIN_NAME
+                },
+                view: {
+                    type: 'remote_component',
+                    runtime: 'react',
+                    protocolVersion: 1,
+                    component: {
+                        isolation: 'iframe',
+                        entry: WECHAT_PERSONAL_REMOTE_ENTRY_KEY
+                    },
+                    dataSource: {
+                        mode: 'platform'
+                    }
+                },
+                dataSource: {
+                    mode: 'platform',
+                    querySchema: {
+                        supportsPagination: true,
+                        supportsSearch: true,
+                        supportsParameters: true,
+                        defaultPageSize: 30
+                    },
+                    cache: {
+                        enabled: false
+                    }
+                },
+                actions: [
+                    {
+                        key: 'refresh',
+                        label: text('Refresh', '刷新'),
+                        icon: 'ri-refresh-line',
+                        placement: 'toolbar',
+                        actionType: 'refresh'
+                    },
+                    {
+                        key: 'register_callback',
+                        label: text('Register Callback', '注册回调'),
+                        icon: 'ri-link',
+                        actionType: 'invoke'
+                    },
+                    {
+                        key: 'restart_conversation',
+                        label: text('Restart Conversation', '重置会话'),
+                        icon: 'ri-restart-line',
+                        actionType: 'invoke'
+                    },
+                    {
+                        key: 'send_text',
+                        label: text('Send Text', '发送文本'),
+                        icon: 'ri-send-plane-line',
+                        actionType: 'invoke'
+                    },
+                    {
+                        key: 'resend_message',
+                        label: text('Resend AI Reply', '重发 AI 回复'),
+                        icon: 'ri-repeat-line',
+                        actionType: 'invoke'
+                    },
+                    {
+                        key: 'set_account_enabled',
+                        label: text('Toggle Account', '启停账号'),
+                        icon: 'ri-toggle-line',
+                        actionType: 'invoke'
+                    }
+                ]
+            }
+        ];
+    }
+    async getRemoteComponentEntry(_context, viewKey, component) {
+        if (viewKey !== WECHAT_PERSONAL_VIEW_KEY || component.entry !== WECHAT_PERSONAL_REMOTE_ENTRY_KEY) {
+            return {
+                html: '<!doctype html><html><body>Unsupported remote component entry.</body></html>',
+                contentType: 'text/html; charset=utf-8'
+            };
+        }
+        const appScript = await readFile(join(moduleDir, '..', 'remote-components', WECHAT_PERSONAL_REMOTE_ENTRY_KEY, 'app.js'), 'utf8');
+        const react = await readPackageFile('react', 'umd/react.production.min.js');
+        const reactDom = await readPackageFile('react-dom', 'umd/react-dom.production.min.js');
+        return {
+            html: renderRemoteReactIframeHtml({
+                title: 'Personal WeChat Workbench',
+                lang: 'zh-Hans',
+                reactUmd: react,
+                reactDomUmd: reactDom,
+                appScript
+            }),
+            contentType: 'text/html; charset=utf-8'
+        };
+    }
+    async getViewData(context, viewKey, query) {
+        if (viewKey !== WECHAT_PERSONAL_VIEW_KEY) {
+            return {};
+        }
+        const parameters = normalizeViewParameters(query.parameters);
+        const integrationId = await this.resolveIntegrationId(context, parameters);
+        const table = getTableKey(parameters);
+        const tableQuery = getTableQuery(query, parameters);
+        if (!integrationId) {
+            if (context.hostType === 'agent') {
+                if (table) {
+                    return {
+                        scope: 'organization',
+                        integrationId: null,
+                        tableKey: table,
+                        table: await this.conversationService.getOrganizationWorkbenchTableData(table, tableQuery)
+                    };
+                }
+                return this.conversationService.getOrganizationWorkbenchData({
+                    search: query.search,
+                    page: query.page,
+                    pageSize: query.pageSize
+                });
+            }
+            return {
+                missingIntegration: true,
+                message: text('Select a personal WeChat integration to view runtime data.', '请选择个人微信集成后查看运行数据。')
+            };
+        }
+        if (table) {
+            return {
+                scope: 'integration',
+                integrationId,
+                tableKey: table,
+                table: await this.conversationService.getWorkbenchTableData(integrationId, table, tableQuery)
+            };
+        }
+        return this.conversationService.getWorkbenchData(integrationId, {
+            search: query.search,
+            page: query.page,
+            pageSize: query.pageSize
+        });
+    }
+    async executeViewAction(context, viewKey, actionKey, request) {
+        if (viewKey !== WECHAT_PERSONAL_VIEW_KEY) {
+            return failure('Unsupported view', '不支持的视图');
+        }
+        try {
+            if (actionKey === 'refresh') {
+                return success('Personal WeChat view refreshed', '个人微信视图已刷新');
+            }
+            const integrationId = await this.resolveIntegrationId(context, request.parameters, request.input);
+            if (!integrationId) {
+                return failure('Missing integration id', '缺少个人微信集成标识');
+            }
+            if (actionKey === 'restart_conversation') {
+                const targetId = getStringInput(request.input, 'bindingId') || getStringInput(request.input, 'id') || request.targetId;
+                if (!targetId) {
+                    return failure('Missing conversation target', '缺少可重置的会话目标');
+                }
+                await this.conversationService.restartConversationBinding(integrationId, String(targetId));
+                return success('Conversation reset', '会话已重置');
+            }
+            if (actionKey === 'register_callback') {
+                const integration = await this.wechatChannel.readIntegrationById(integrationId);
+                if (!integration) {
+                    return failure('Integration not found', '未找到个人微信集成');
+                }
+                const uuid = requireStringInput(request.input, 'uuid', 'Account uuid is required.');
+                const callbackConfig = this.conversationService.buildCallbackConfig(integration.id, integration.options?.callbackSecret);
+                const result = await this.wechatChannel.registerCallback({
+                    integrationId,
+                    uuid,
+                    callbackUrl: getStringInput(request.input, 'callbackUrl') || callbackConfig.webhookUrl,
+                    enabled: getBooleanInput(request.input, 'enabled', true)
+                });
+                if (!result.success) {
+                    return failure(result.error || 'Register callback failed', result.error || '注册回调失败');
+                }
+                return success('Callback registered', '回调已注册');
+            }
+            if (actionKey === 'send_text') {
+                const result = await this.wechatChannel.sendTextByIntegrationId(integrationId, {
+                    uuid: requireStringInput(request.input, 'uuid', 'Account uuid is required.'),
+                    contactId: requireStringInput(request.input, 'contactId', 'Contact id is required.'),
+                    content: requireStringInput(request.input, 'content', 'Text content is required.'),
+                    atUsers: getStringArrayInput(request.input, 'atUsers')
+                });
+                if (!result.success) {
+                    return failure(result.error || 'Send text failed', result.error || '发送文本失败');
+                }
+                return success('Text sent', '文本已发送');
+            }
+            if (actionKey === 'resend_message') {
+                const result = await this.conversationService.resendOutboundMessage(integrationId, request.targetId);
+                if (!result.success) {
+                    return failure(result.error || 'Resend failed', result.error || '重发失败');
+                }
+                return success('AI reply resent', 'AI 回复已重发');
+            }
+            if (actionKey === 'set_account_enabled') {
+                await this.conversationService.setAccountEnabled(integrationId, requireStringInput(request.input, 'uuid', 'Account uuid is required.'), getBooleanInput(request.input, 'enabled', true));
+                return success('Account setting updated', '账号接入设置已更新');
+            }
+            return failure('Unsupported action', '不支持的操作');
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            return {
+                success: false,
+                message: text(message, message)
+            };
+        }
+    }
+    async resolveIntegrationId(context, parameters, input) {
+        const explicitIntegrationId = getIntegrationId(context, parameters, input);
+        if (explicitIntegrationId) {
+            return explicitIntegrationId;
+        }
+        if (context.hostType !== 'agent') {
+            return null;
+        }
+        const xpertId = getAgentXpertId(context);
+        if (!xpertId) {
+            return null;
+        }
+        return this.conversationService.getBoundIntegrationIdForXpert(xpertId);
+    }
+};
+WechatPersonalViewProvider = __decorate([
+    Injectable(),
+    ViewExtensionProvider(WECHAT_PERSONAL_VIEW_PROVIDER_KEY),
+    __metadata("design:paramtypes", [WechatPersonalConversationService,
+        WechatPersonalChannelStrategy])
+], WechatPersonalViewProvider);
+export { WechatPersonalViewProvider };
+async function readPackageFile(packageName, relativePath) {
+    const packageRoot = dirname(requireFromHere.resolve(`${packageName}/package.json`));
+    return readFile(join(packageRoot, relativePath), 'utf8');
+}
+function isSupportedSlot(context, slot) {
+    if (context.hostType === 'integration') {
+        return slot === INTEGRATION_DETAIL_MAIN_TABS_SLOT;
+    }
+    if (context.hostType === 'agent') {
+        return slot === AGENT_WORKBENCH_FIXED_SLOT || slot === AGENT_WORKBENCH_MAIN_SLOT;
+    }
+    return false;
+}
+function normalizeViewParameters(parameters) {
+    if (!parameters) {
+        return {};
+    }
+    if (typeof parameters === 'string') {
+        return parseJsonObject(parameters);
+    }
+    if (typeof parameters === 'object' && !Array.isArray(parameters)) {
+        return parameters;
+    }
+    return {};
+}
+function getTableKey(parameters) {
+    const value = getStringProperty(parameters, 'table');
+    return value === 'accounts' || value === 'conversations' || value === 'messages' || value === 'logs' ? value : null;
+}
+function getTableQuery(query, parameters = normalizeViewParameters(query.parameters)) {
+    const rawFilters = parameters.filters;
+    const filtersFromJson = parseJsonObject(getStringProperty(parameters, 'filtersJson'));
+    return {
+        search: query.search,
+        page: query.page,
+        pageSize: query.pageSize,
+        filters: rawFilters && typeof rawFilters === 'object' && !Array.isArray(rawFilters)
+            ? rawFilters
+            : filtersFromJson
+    };
+}
+function parseJsonObject(value) {
+    if (!value) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function getIntegrationId(context, parameters, input) {
+    if (context.hostType === 'integration') {
+        return context.hostId || null;
+    }
+    return (getStringProperty(parameters, 'integrationId') ||
+        getStringInput(input, 'integrationId') ||
+        getStringProperty(context.hostSnapshot, 'integrationId') ||
+        null);
+}
+function getStringProperty(record, key) {
+    if (!record || typeof record !== 'object') {
+        return '';
+    }
+    const rawValue = record[key];
+    const value = Array.isArray(rawValue) ? rawValue[0] : rawValue;
+    if (typeof value === 'string') {
+        return value.trim();
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return '';
+}
+function getAgentXpertId(context) {
+    if (context.hostType !== 'agent') {
+        return '';
+    }
+    return getStringProperty(context, 'hostId') || getStringProperty(context.hostSnapshot, 'id');
+}
+function getStringInput(input, key) {
+    return getStringProperty(input, key);
+}
+function requireStringInput(input, key, error) {
+    const value = getStringInput(input, key);
+    if (!value) {
+        throw new Error(error);
+    }
+    return value;
+}
+function getBooleanInput(input, key, defaultValue) {
+    if (!input || typeof input !== 'object') {
+        return defaultValue;
+    }
+    const value = input[key];
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return ['true', '1', 'yes'].includes(value.trim().toLowerCase());
+    }
+    return defaultValue;
+}
+function getStringArrayInput(input, key) {
+    if (!input || typeof input !== 'object') {
+        return [];
+    }
+    const value = input[key];
+    if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === 'string' && Boolean(item.trim()));
+    }
+    if (typeof value === 'string') {
+        return value
+            .split(/[,\n，]/)
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+function success(en_US, zh_Hans) {
+    return {
+        success: true,
+        message: text(en_US, zh_Hans),
+        refresh: true
+    };
+}
+function failure(en_US, zh_Hans) {
+    return {
+        success: false,
+        message: text(en_US, zh_Hans)
+    };
+}

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

@@ -0,0 +1,33 @@
+import { IChatChannel, TChatChannelCapabilities, TChatChannelMeta, TChatContext, TChatEventContext, TChatEventHandlers, TChatInboundMessage, TChatSendResult, type PluginContext } from '@xpert-ai/plugin-sdk';
+import { IIntegration } from '@xpert-ai/contracts';
+import { TIntegrationWechatPersonalOptions, WechatPersonalInboundEvent } from './types.js';
+import { WechatPersonalClient } from './wechat-personal.client.js';
+export declare class WechatPersonalChannelStrategy implements IChatChannel<TIntegrationWechatPersonalOptions, WechatPersonalInboundEvent> {
+    private readonly client;
+    private readonly pluginContext;
+    private readonly logger;
+    private _integrationPermissionService;
+    constructor(client: WechatPersonalClient, pluginContext: PluginContext);
+    private get integrationPermissionService();
+    meta: TChatChannelMeta;
+    capabilities: TChatChannelCapabilities;
+    readIntegrationById(id: string): Promise<IIntegration<TIntegrationWechatPersonalOptions> | null>;
+    createEventHandler(ctx: TChatEventContext<TIntegrationWechatPersonalOptions>, handlers: TChatEventHandlers): (req: any, res: any, next?: any) => Promise<void>;
+    normalizeWebhookEvent(payload: unknown): WechatPersonalInboundEvent | null;
+    parseInboundMessage(event: WechatPersonalInboundEvent, _ctx: TChatEventContext<TIntegrationWechatPersonalOptions>): TChatInboundMessage | null;
+    sendText(ctx: TChatContext, content: string): Promise<TChatSendResult>;
+    sendTextByIntegrationId(integrationId: string, params: {
+        uuid?: string | null;
+        contactId?: string | null;
+        content: string;
+        atUsers?: string[] | null;
+    }): Promise<TChatSendResult>;
+    registerCallback(params: {
+        integrationId: string;
+        uuid: string;
+        callbackUrl: string;
+        enabled?: boolean;
+    }): Promise<TChatSendResult>;
+    private readIntegration;
+    private resolveMentions;
+}

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

@@ -0,0 +1,197 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var WechatPersonalChannelStrategy_1;
+import { randomUUID } from 'crypto';
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ChatChannel, INTEGRATION_PERMISSION_SERVICE_TOKEN } from '@xpert-ai/plugin-sdk';
+import { WECHAT_PERSONAL_CHANNEL_TYPE, WECHAT_PERSONAL_ICON } from './constants.js';
+import { WECHAT_PERSONAL_PLUGIN_CONTEXT } from './tokens.js';
+import { normalizeString, normalizeWechatPersonalInboundPayload } from './types.js';
+import { WechatPersonalClient } from './wechat-personal.client.js';
+const DEFAULT_TEXT_LIMIT = 4000;
+let WechatPersonalChannelStrategy = WechatPersonalChannelStrategy_1 = class WechatPersonalChannelStrategy {
+    constructor(client, pluginContext) {
+        this.client = client;
+        this.pluginContext = pluginContext;
+        this.logger = new Logger(WechatPersonalChannelStrategy_1.name);
+        this.meta = {
+            type: WECHAT_PERSONAL_CHANNEL_TYPE,
+            label: '个人微信 / WeChat Personal',
+            description: 'wx2.0 personal WeChat webhook and sendtext bridge',
+            icon: WECHAT_PERSONAL_ICON,
+            configSchema: {
+                type: 'object',
+                properties: {
+                    baseUrl: { type: 'string', description: 'wx2.0 HTTP base URL' },
+                    apiVersion: { type: 'string', description: 'wx2.0 v2 API prefix, default /v1/' },
+                    apiToken: { type: 'string', description: 'Optional wx2.0 token header' },
+                    timeoutMs: { type: 'number', description: 'Outbound wx2.0 request timeout in milliseconds' }
+                },
+                required: ['baseUrl']
+            }
+        };
+        this.capabilities = {
+            markdown: false,
+            card: false,
+            cardAction: false,
+            updateMessage: false,
+            mention: true,
+            group: true,
+            thread: false,
+            media: false,
+            textChunkLimit: DEFAULT_TEXT_LIMIT,
+            streamingUpdate: false
+        };
+    }
+    get integrationPermissionService() {
+        if (!this._integrationPermissionService) {
+            this._integrationPermissionService = this.pluginContext.resolve(INTEGRATION_PERMISSION_SERVICE_TOKEN);
+        }
+        return this._integrationPermissionService;
+    }
+    async readIntegrationById(id) {
+        if (!id) {
+            return null;
+        }
+        return this.integrationPermissionService.read(id, {
+            relations: ['tenant']
+        });
+    }
+    createEventHandler(ctx, handlers) {
+        const eventHandlers = handlers ?? {};
+        return async (req, res) => {
+            const event = this.normalizeWebhookEvent(req?.body);
+            if (!event) {
+                this.logger.debug(`[wechat-personal-event] ignore invalid payload integration=${ctx.integration.id}`);
+                res.status(200).send('success');
+                return;
+            }
+            const message = this.parseInboundMessage(event, ctx);
+            if (!message) {
+                this.logger.debug(`[wechat-personal-event] ignore non-message integration=${ctx.integration.id} uuid=${event.uuid || 'n/a'}`);
+                res.status(200).send('success');
+                return;
+            }
+            if (message.chatType === 'group' && message.mentions?.length) {
+                await eventHandlers.onMention?.(message, ctx);
+            }
+            else {
+                await eventHandlers.onMessage?.(message, ctx);
+            }
+            res.status(200).send('success');
+        };
+    }
+    normalizeWebhookEvent(payload) {
+        return normalizeWechatPersonalInboundPayload(payload);
+    }
+    parseInboundMessage(event, _ctx) {
+        const chatId = normalizeString(event.contactId);
+        const senderId = normalizeString(event.senderId) || chatId;
+        if (!chatId || !senderId) {
+            return null;
+        }
+        return {
+            messageId: event.messageId || randomUUID(),
+            chatId,
+            chatType: event.chatType,
+            senderId,
+            senderName: event.senderName,
+            content: event.content,
+            contentType: 'text',
+            mentions: event.chatType === 'group' ? this.resolveMentions(event) : undefined,
+            timestamp: event.timestamp || Date.now(),
+            raw: event.rawPayload ?? event.raw ?? event
+        };
+    }
+    async sendText(ctx, content) {
+        return this.sendTextByIntegrationId(ctx.integration.id, {
+            uuid: normalizeString(ctx.uuid),
+            contactId: ctx.chatId,
+            content
+        });
+    }
+    async sendTextByIntegrationId(integrationId, params) {
+        const integration = await this.readIntegration(params.uuid ? integrationId : '');
+        if (!integration) {
+            return {
+                success: false,
+                error: '个人微信集成不存在或不可访问。'
+            };
+        }
+        const uuid = normalizeString(params.uuid);
+        const contactId = normalizeString(params.contactId);
+        const content = normalizeString(params.content);
+        if (!uuid || !contactId || !content) {
+            return {
+                success: false,
+                error: '发送微信消息缺少 uuid/contactId/content。'
+            };
+        }
+        const result = await this.client.sendText(integration, {
+            uuid,
+            contactId,
+            content,
+            atUsers: Array.isArray(params.atUsers) ? params.atUsers.filter(Boolean) : []
+        });
+        return {
+            success: result.success,
+            messageId: result.messageId,
+            error: result.error
+        };
+    }
+    async registerCallback(params) {
+        const integration = await this.readIntegrationById(params.integrationId);
+        if (!integration) {
+            return {
+                success: false,
+                error: '个人微信集成不存在或不可访问。'
+            };
+        }
+        const result = await this.client.registerCallback({
+            integration,
+            uuid: params.uuid,
+            callbackUrl: params.callbackUrl,
+            enabled: params.enabled
+        });
+        return {
+            success: result.success,
+            messageId: result.messageId,
+            error: result.error
+        };
+    }
+    async readIntegration(integrationId) {
+        const id = normalizeString(integrationId);
+        if (!id) {
+            return null;
+        }
+        return this.readIntegrationById(id);
+    }
+    resolveMentions(event) {
+        const rawText = JSON.stringify(event.raw || {});
+        const ownerWxid = normalizeString(event.ownerWxid);
+        if (ownerWxid && rawText.includes(ownerWxid)) {
+            return [{ id: ownerWxid }];
+        }
+        if (/@[^\s]+/.test(`${event.content}\n${event.displayText || ''}`)) {
+            return [{ id: 'mentioned' }];
+        }
+        return undefined;
+    }
+};
+WechatPersonalChannelStrategy = WechatPersonalChannelStrategy_1 = __decorate([
+    Injectable(),
+    ChatChannel(WECHAT_PERSONAL_CHANNEL_TYPE),
+    __param(1, Inject(WECHAT_PERSONAL_PLUGIN_CONTEXT)),
+    __metadata("design:paramtypes", [WechatPersonalClient, Object])
+], WechatPersonalChannelStrategy);
+export { WechatPersonalChannelStrategy };