@xpert-ai/plugin-community-wechat 0.1.0

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

@@ -0,0 +1,100 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { XpertTypeEnum } from '@xpert-ai/contracts';
+import { WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_MIDDLEWARE_NAME, WECHAT_PERSONAL_PLUGIN_NAME, WECHAT_PERSONAL_RUNTIME_FEATURE, WECHAT_PERSONAL_TEMPLATE_PROVIDER_KEY, WECHAT_PERSONAL_VIEW_PROVIDER_KEY } from './constants.js';
+const WECHAT_PERSONAL_ADMIN_TEMPLATE_KEY = 'wechat-personal-admin-assistant';
+const WECHAT_PERSONAL_USER_TEMPLATE_KEY = 'wechat-personal-user-assistant';
+const WECHAT_PERSONAL_ADMIN_TEMPLATE_FILE = 'xpert-wechat-personal-admin-assistant.yaml';
+const WECHAT_PERSONAL_USER_TEMPLATE_FILE = 'xpert-wechat-personal-user-assistant.yaml';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function getTemplateCandidates(templateFile) {
+    const runtimeDir = __dirname;
+    return [
+        join(runtimeDir, '..', templateFile),
+        join(runtimeDir, templateFile),
+        join(process.cwd(), 'community/integrations/wechat/src', templateFile),
+        join(process.cwd(), 'dist/community/integrations/wechat', templateFile)
+    ];
+}
+function readTemplateDsl(templateFile) {
+    const candidates = getTemplateCandidates(templateFile);
+    const templatePath = candidates.find((candidate) => existsSync(candidate));
+    if (!templatePath) {
+        throw new Error(`Personal WeChat xpert DSL template file not found: ${candidates.join(', ')}`);
+    }
+    return readFileSync(templatePath, 'utf8');
+}
+export const wechatPersonalTemplates = [
+    {
+        key: WECHAT_PERSONAL_ADMIN_TEMPLATE_KEY,
+        name: 'Personal WeChat Admin Assistant',
+        title: '个人微信管理员',
+        description: '管理组织内 wx2.0 个人微信集成、账号、会话、消息日志和回调配置的管理员助手模板。',
+        category: 'Integration',
+        type: XpertTypeEnum.Agent,
+        targetApps: ['data-xpert'],
+        targetAppMeta: {
+            'data-xpert': {
+                types: ['business-assistant', 'assistant-tool', 'workbench-view'],
+                capabilities: [WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_RUNTIME_FEATURE, 'wechat-personal-workbench'],
+                requiredPlugins: [WECHAT_PERSONAL_PLUGIN_NAME],
+                defaultConfig: {
+                    assistantKind: 'wechat-personal-admin-assistant',
+                    businessDomain: 'wechat-personal',
+                    role: 'admin',
+                    managedBy: 'data-xpert',
+                    middlewareProvider: WECHAT_PERSONAL_MIDDLEWARE_NAME,
+                    viewProvider: WECHAT_PERSONAL_VIEW_PROVIDER_KEY
+                }
+            }
+        },
+        dslContent: readTemplateDsl(WECHAT_PERSONAL_ADMIN_TEMPLATE_FILE),
+        order: 45,
+        default: false,
+        startPrompts: [
+            '请汇总组织内所有个人微信集成的账号状态和最近错误。',
+            '帮我生成每个 wx2.0 账号的回调配置步骤。',
+            '检查最近 AI 回复发送失败的微信消息，并给出排查建议。'
+        ],
+        releaseNotes: '创建组织级个人微信运行管理助手。',
+        xpertName: '个人微信管理员',
+        providerKey: WECHAT_PERSONAL_TEMPLATE_PROVIDER_KEY
+    },
+    {
+        key: WECHAT_PERSONAL_USER_TEMPLATE_KEY,
+        name: 'Personal WeChat User Assistant',
+        title: '个人微信会话助手',
+        description: '通过 wx2.0 接收个人微信消息、交给 Agent 处理，并把最终文本回复发回微信的使用者助手模板。',
+        category: 'Integration',
+        type: XpertTypeEnum.Agent,
+        targetApps: ['data-xpert'],
+        targetAppMeta: {
+            'data-xpert': {
+                types: ['business-assistant', 'assistant-tool'],
+                capabilities: [WECHAT_PERSONAL_FEATURE, WECHAT_PERSONAL_RUNTIME_FEATURE, 'wechat-personal-workbench'],
+                requiredPlugins: [WECHAT_PERSONAL_PLUGIN_NAME],
+                defaultConfig: {
+                    assistantKind: 'wechat-personal-user-assistant',
+                    businessDomain: 'wechat-personal',
+                    role: 'user',
+                    managedBy: 'data-xpert',
+                    middlewareProvider: WECHAT_PERSONAL_MIDDLEWARE_NAME,
+                    viewProvider: WECHAT_PERSONAL_VIEW_PROVIDER_KEY
+                }
+            }
+        },
+        dslContent: readTemplateDsl(WECHAT_PERSONAL_USER_TEMPLATE_FILE),
+        order: 46,
+        default: false,
+        startPrompts: [
+            '请作为微信会话助手，帮我自然回复用户消息。',
+            '如果微信群消息触发了你，请只围绕当前被触发的问题简洁回复。',
+            '当微信用户缺少上下文时，先提出一个澄清问题。'
+        ],
+        releaseNotes: '创建个人微信消息收发会话助手。',
+        xpertName: '个人微信会话助手',
+        providerKey: WECHAT_PERSONAL_TEMPLATE_PROVIDER_KEY
+    }
+];

package/dist/lib/workflow/index.d.ts

@@ -0,0 +1,5 @@
+export * from './wechat-personal-trigger-aggregation.service.js';
+export * from './wechat-personal-trigger-aggregation.types.js';
+export * from './wechat-personal-trigger-flush.processor.js';
+export * from './wechat-personal-trigger.strategy.js';
+export * from './wechat-personal-trigger.types.js';

package/dist/lib/workflow/index.js

@@ -0,0 +1,5 @@
+export * from './wechat-personal-trigger-aggregation.service.js';
+export * from './wechat-personal-trigger-aggregation.types.js';
+export * from './wechat-personal-trigger-flush.processor.js';
+export * from './wechat-personal-trigger.strategy.js';
+export * from './wechat-personal-trigger.types.js';

package/dist/lib/workflow/wechat-personal-trigger-aggregation.service.d.ts

@@ -0,0 +1,10 @@
+import { type Cache } from 'cache-manager';
+import { WechatPersonalTriggerAggregationState } from './wechat-personal-trigger-aggregation.types.js';
+export declare class WechatPersonalTriggerAggregationService {
+    private readonly cacheManager;
+    constructor(cacheManager: Cache);
+    save(state: WechatPersonalTriggerAggregationState, ttlSeconds?: number): Promise<void>;
+    get(aggregateKey: string): Promise<WechatPersonalTriggerAggregationState | null>;
+    clear(aggregateKey: string): Promise<void>;
+    private buildKey;
+}

package/dist/lib/workflow/wechat-personal-trigger-aggregation.service.js

@@ -0,0 +1,39 @@
+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); }
+};
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable } from '@nestjs/common';
+const DEFAULT_AGGREGATION_TTL_SECONDS = 2 * 60 * 60;
+let WechatPersonalTriggerAggregationService = class WechatPersonalTriggerAggregationService {
+    constructor(cacheManager) {
+        this.cacheManager = cacheManager;
+    }
+    async save(state, ttlSeconds = DEFAULT_AGGREGATION_TTL_SECONDS) {
+        await this.cacheManager.set(this.buildKey(state.aggregateKey), state, ttlSeconds * 1000);
+    }
+    async get(aggregateKey) {
+        const state = await this.cacheManager.get(this.buildKey(aggregateKey));
+        return state ?? null;
+    }
+    async clear(aggregateKey) {
+        await this.cacheManager.del(this.buildKey(aggregateKey));
+    }
+    buildKey(aggregateKey) {
+        return `wechat-personal:trigger:aggregate:${aggregateKey}`;
+    }
+};
+WechatPersonalTriggerAggregationService = __decorate([
+    Injectable(),
+    __param(0, Inject(CACHE_MANAGER)),
+    __metadata("design:paramtypes", [Object])
+], WechatPersonalTriggerAggregationService);
+export { WechatPersonalTriggerAggregationService };

package/dist/lib/workflow/wechat-personal-trigger-aggregation.types.d.ts

@@ -0,0 +1,30 @@
+export declare const WECHAT_PERSONAL_TRIGGER_FLUSH_MESSAGE_TYPE: import("@xpert-ai/plugin-sdk").StructuredHandoffMessageType;
+export interface WechatPersonalTriggerFlushPayload extends Record<string, unknown> {
+    aggregateKey: string;
+    version: number;
+}
+export interface WechatPersonalTriggerAggregationMessageContext {
+    integrationId: string;
+    uuid: string;
+    ownerWxid?: string;
+    contactId: string;
+    chatType?: 'private' | 'group';
+    senderId?: string;
+    language?: string;
+    messageId?: string;
+}
+export interface WechatPersonalTriggerAggregationState {
+    aggregateKey: string;
+    integrationId: string;
+    conversationUserKey: string;
+    xpertId: string;
+    version: number;
+    inputParts: string[];
+    lastMessageAt: number;
+    conversationId?: string;
+    tenantId: string;
+    organizationId?: string;
+    executorUserId?: string;
+    endUserId?: string;
+    latestMessage: WechatPersonalTriggerAggregationMessageContext;
+}

package/dist/lib/workflow/wechat-personal-trigger-aggregation.types.js

@@ -0,0 +1,2 @@
+import { defineChannelMessageType } from '@xpert-ai/plugin-sdk';
+export const WECHAT_PERSONAL_TRIGGER_FLUSH_MESSAGE_TYPE = defineChannelMessageType('wechat_personal', 'trigger_flush', 1);

package/dist/lib/workflow/wechat-personal-trigger-flush.processor.d.ts

@@ -0,0 +1,8 @@
+import { HandoffMessage, IHandoffProcessor, ProcessContext, ProcessResult } from '@xpert-ai/plugin-sdk';
+import { WechatPersonalTriggerFlushPayload } from './wechat-personal-trigger-aggregation.types.js';
+import { WechatPersonalTriggerStrategy } from './wechat-personal-trigger.strategy.js';
+export declare class WechatPersonalTriggerFlushProcessor implements IHandoffProcessor<WechatPersonalTriggerFlushPayload> {
+    private readonly triggerStrategy;
+    constructor(triggerStrategy: WechatPersonalTriggerStrategy);
+    process(message: HandoffMessage<WechatPersonalTriggerFlushPayload>, _ctx: ProcessContext): Promise<ProcessResult>;
+}

package/dist/lib/workflow/wechat-personal-trigger-flush.processor.js

@@ -0,0 +1,39 @@
+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 { HandoffProcessorStrategy } from '@xpert-ai/plugin-sdk';
+import { WECHAT_PERSONAL_TRIGGER_FLUSH_MESSAGE_TYPE } from './wechat-personal-trigger-aggregation.types.js';
+import { WechatPersonalTriggerStrategy } from './wechat-personal-trigger.strategy.js';
+let WechatPersonalTriggerFlushProcessor = class WechatPersonalTriggerFlushProcessor {
+    constructor(triggerStrategy) {
+        this.triggerStrategy = triggerStrategy;
+    }
+    async process(message, _ctx) {
+        if (!message.payload?.aggregateKey || !message.payload?.version) {
+            return {
+                status: 'dead',
+                reason: 'Missing aggregateKey or version in WeChat personal trigger flush payload'
+            };
+        }
+        await this.triggerStrategy.flushBufferedConversation(message.payload);
+        return { status: 'ok' };
+    }
+};
+WechatPersonalTriggerFlushProcessor = __decorate([
+    Injectable(),
+    HandoffProcessorStrategy(WECHAT_PERSONAL_TRIGGER_FLUSH_MESSAGE_TYPE, {
+        types: [WECHAT_PERSONAL_TRIGGER_FLUSH_MESSAGE_TYPE],
+        policy: {
+            lane: 'main'
+        }
+    }),
+    __metadata("design:paramtypes", [WechatPersonalTriggerStrategy])
+], WechatPersonalTriggerFlushProcessor);
+export { WechatPersonalTriggerFlushProcessor };

package/dist/lib/workflow/wechat-personal-trigger.strategy.d.ts

@@ -0,0 +1,65 @@
+import type { ChecklistItem, TWorkflowTriggerMeta } from '@xpert-ai/contracts';
+import { IWorkflowTriggerStrategy, type PluginContext, TWorkflowTriggerParams } from '@xpert-ai/plugin-sdk';
+import { Repository } from 'typeorm';
+import { WechatPersonalTriggerBindingEntity } from '../entities/wechat-personal-trigger-binding.entity.js';
+import { WechatPersonalChatDispatchService } from '../handoff/wechat-personal-chat-dispatch.service.js';
+import { WechatPersonalMessage } from '../message.js';
+import { WechatPersonalChannelStrategy } from '../wechat-personal-channel.strategy.js';
+import { WechatPersonalTriggerFlushPayload } from './wechat-personal-trigger-aggregation.types.js';
+import { WechatPersonalTriggerAggregationService } from './wechat-personal-trigger-aggregation.service.js';
+import { TWechatPersonalTriggerConfig } from './wechat-personal-trigger.types.js';
+type WechatPersonalTenantScope = {
+    tenantId?: string | null;
+    organizationId?: string | null;
+};
+export declare class WechatPersonalTriggerStrategy implements IWorkflowTriggerStrategy<TWechatPersonalTriggerConfig> {
+    private readonly dispatchService;
+    private readonly aggregationService;
+    private readonly wechatChannel;
+    private readonly bindingRepository;
+    private readonly pluginContext;
+    private readonly logger;
+    private readonly callbacks;
+    private _integrationPermissionService;
+    private _handoffPermissionService;
+    readonly meta: TWorkflowTriggerMeta;
+    readonly bootstrap: {
+        mode: "replay_publish";
+        critical: boolean;
+    };
+    constructor(dispatchService: WechatPersonalChatDispatchService, aggregationService: WechatPersonalTriggerAggregationService, wechatChannel: WechatPersonalChannelStrategy, bindingRepository: Repository<WechatPersonalTriggerBindingEntity>, pluginContext: PluginContext);
+    private get integrationPermissionService();
+    private get handoffPermissionService();
+    validate(payload: TWorkflowTriggerParams<TWechatPersonalTriggerConfig>): Promise<ChecklistItem[]>;
+    publish(payload: TWorkflowTriggerParams<TWechatPersonalTriggerConfig>, callback: (payload: any) => void): Promise<void>;
+    stop(payload: TWorkflowTriggerParams<TWechatPersonalTriggerConfig>): Promise<void>;
+    getBinding(integrationId: string, scope?: WechatPersonalTenantScope | null): Promise<WechatPersonalTriggerBindingEntity | null>;
+    getBoundXpertId(integrationId: string): Promise<string | null>;
+    getBindingByXpertId(xpertId: string): Promise<WechatPersonalTriggerBindingEntity | null>;
+    getBoundIntegrationId(xpertId: string): Promise<string | null>;
+    clearBufferedConversation(conversationUserKey: string): Promise<void>;
+    handleInboundMessage(params: {
+        integrationId: string;
+        input?: string;
+        wechatMessage: WechatPersonalMessage;
+        conversationId?: string;
+        conversationUserKey?: string;
+        tenantId: string;
+        organizationId?: string;
+        executorUserId?: string;
+        endUserId?: string;
+    }): Promise<boolean>;
+    flushBufferedConversation(payload: WechatPersonalTriggerFlushPayload): Promise<boolean>;
+    private buildFlushMessage;
+    private dispatchInboundMessage;
+    private resolveBindingContext;
+    private normalizeAggregateKey;
+    private normalizePositiveSeconds;
+    private normalizeNonNegativeSeconds;
+    private removeBindingFromStore;
+    private removeBindingsByXpertId;
+    private resolveRequestTenantScope;
+    private resolveQueryTenantScope;
+    private scopedWhere;
+}
+export {};