@chen0825/aiapp-ability 0.1.0 → 0.1.2

package/lib/abilities/dingtalk/index.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 钉钉能力模块
+ */
+import { BatchSendRobotMsgRequest, BatchSendResponse, RobotMsgKey } from '../../types/dingtalk';
+import { AbilityProvider } from '../../types';
+/**
+ * 简化的 Markdown 通知参数
+ */
+export interface MarkdownNotificationParams {
+    /** 接收者用户 ID 列表 */
+    userIds: string[];
+    /** 消息标题 */
+    title: string;
+    /** Markdown 格式的消息内容 */
+    text: string;
+}
+/**
+ * 通用批量发送参数
+ */
+export interface BatchNotificationParams<T extends RobotMsgKey = RobotMsgKey> {
+    /** 接收者用户 ID 列表 */
+    userIds: string[];
+    /** 消息类型 */
+    msgKey: T;
+    /** 消息参数 */
+    msgParam: Record<string, unknown>;
+}
+/**
+ * 钉钉能力提供者
+ *
+ * 必须配置以下环境变量：
+ * - DINGTALK_APP_KEY: 钉钉应用 AppKey
+ * - DINGTALK_APP_SECRET: 钉钉应用 AppSecret
+ * - DINGTALK_ROBOT_CODE: 钉钉机器人编码
+ * - DINGTALK_API_URL: 钉钉 API 基础 URL
+ */
+export declare class DingTalkProvider implements AbilityProvider {
+    readonly name = "dingtalk";
+    readonly version = "1.0.0";
+    private dingtalkApiClient;
+    constructor();
+    /**
+     * 获取 appKey
+     */
+    private getAppKey;
+    /**
+     * 获取 appSecret
+     */
+    private getAppSecret;
+    /**
+     * 获取机器人编码
+     */
+    private getRobotCode;
+    /**
+     * 获取 API 基础 URL
+     */
+    private getApiUrl;
+    /**
+     * 获取企业内部应用的 accessToken（每次调用都重新获取）
+     */
+    getAccessToken(): Promise<{
+        success: boolean;
+        accessToken?: string;
+        message?: string;
+    }>;
+    /**
+     * 批量发送机器人消息
+     */
+    batchSendRobotMessage<T extends RobotMsgKey>(params: BatchSendRobotMsgRequest<T>): Promise<BatchSendResponse>;
+    /**
+     * 分批发送机器人消息（超过20人时自动分批）
+     */
+    private batchSendInChunks;
+    /**
+     * 发送 Markdown 消息
+     */
+    sendMarkdownMessage(params: MarkdownNotificationParams): Promise<BatchSendResponse>;
+    /**
+     * 通用批量发送接口
+     */
+    sendBatchNotification<T extends RobotMsgKey>(params: BatchNotificationParams<T>): Promise<BatchSendResponse>;
+    /**
+     * 初始化（重新加载环境变量配置）
+     */
+    initialize(): Promise<void>;
+    /**
+     * 将数组分割成指定大小的块
+     */
+    private chunkArray;
+}
+/** 默认钉钉提供者实例 */
+export declare const dingtalkProvider: DingTalkProvider;

package/lib/abilities/dingtalk/index.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * 钉钉能力模块
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dingtalkProvider = exports.DingTalkProvider = void 0;
+const http_client_1 = require("../../core/http-client");
+const environment_1 = require("../../core/environment");
+/** 钉钉API批量发送限制：每次最多20人 */
+const BATCH_SEND_LIMIT = 20;
+/**
+ * 钉钉能力提供者
+ *
+ * 必须配置以下环境变量：
+ * - DINGTALK_APP_KEY: 钉钉应用 AppKey
+ * - DINGTALK_APP_SECRET: 钉钉应用 AppSecret
+ * - DINGTALK_ROBOT_CODE: 钉钉机器人编码
+ * - DINGTALK_API_URL: 钉钉 API 基础 URL
+ */
+class DingTalkProvider {
+    constructor() {
+        this.name = 'dingtalk';
+        this.version = '1.0.0';
+        const envConfig = (0, environment_1.getDingTalkEnvConfig)();
+        this.dingtalkApiClient = new http_client_1.HttpClient(envConfig.apiUrl || 'https://api.dingtalk.com');
+    }
+    /**
+     * 获取 appKey
+     */
+    getAppKey() {
+        return (0, environment_1.getDingTalkEnvConfig)().appKey;
+    }
+    /**
+     * 获取 appSecret
+     */
+    getAppSecret() {
+        return (0, environment_1.getDingTalkEnvConfig)().appSecret;
+    }
+    /**
+     * 获取机器人编码
+     */
+    getRobotCode() {
+        return (0, environment_1.getDingTalkEnvConfig)().robotCode;
+    }
+    /**
+     * 获取 API 基础 URL
+     */
+    getApiUrl() {
+        return (0, environment_1.getDingTalkEnvConfig)().apiUrl || 'https://api.dingtalk.com';
+    }
+    /**
+     * 获取企业内部应用的 accessToken（每次调用都重新获取）
+     */
+    async getAccessToken() {
+        const appKey = this.getAppKey();
+        const appSecret = this.getAppSecret();
+        if (!appKey || !appSecret) {
+            return {
+                success: false,
+                message: '未配置环境变量 DINGTALK_APP_KEY 或 DINGTALK_APP_SECRET',
+            };
+        }
+        try {
+            const response = await fetch(`${this.getApiUrl()}/v1.0/oauth2/accessToken`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ appKey, appSecret }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error('获取 accessToken 失败:', errorText);
+                return {
+                    success: false,
+                    message: `获取 accessToken 失败: ${response.status}`,
+                };
+            }
+            const data = await response.json();
+            if (!data.accessToken) {
+                return {
+                    success: false,
+                    message: '获取 accessToken 失败: 响应中无 accessToken',
+                };
+            }
+            return {
+                success: true,
+                accessToken: data.accessToken,
+            };
+        }
+        catch (error) {
+            console.error('获取 accessToken 异常:', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : '获取 accessToken 异常',
+            };
+        }
+    }
+    /**
+     * 批量发送机器人消息
+     */
+    async batchSendRobotMessage(params) {
+        const tokenResult = await this.getAccessToken();
+        if (!tokenResult.success || !tokenResult.accessToken) {
+            return {
+                success: false,
+                message: tokenResult.message || '获取 accessToken 失败',
+            };
+        }
+        if (!params.userIds || params.userIds.length === 0) {
+            return {
+                success: false,
+                message: '接收者列表不能为空',
+            };
+        }
+        if (params.userIds.length > BATCH_SEND_LIMIT) {
+            return this.batchSendInChunks(params);
+        }
+        try {
+            const result = await this.dingtalkApiClient.post('/v1.0/robot/oToMessages/batchSend', params, {
+                headers: {
+                    'x-acs-dingtalk-access-token': tokenResult.accessToken,
+                },
+            });
+            if (!result.success) {
+                return {
+                    success: false,
+                    message: result.message || '批量发送机器人消息失败',
+                    data: result.data,
+                };
+            }
+            return {
+                success: true,
+                message: '批量发送成功',
+                data: result.data,
+                successCount: params.userIds.length,
+                failCount: 0,
+            };
+        }
+        catch (error) {
+            console.error('批量发送机器人消息异常:', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : '批量发送机器人消息异常',
+                failedUserIds: params.userIds,
+            };
+        }
+    }
+    /**
+     * 分批发送机器人消息（超过20人时自动分批）
+     */
+    async batchSendInChunks(params) {
+        const { userIds, ...restParams } = params;
+        const chunks = this.chunkArray(userIds, BATCH_SEND_LIMIT);
+        const failedUserIds = [];
+        let successCount = 0;
+        let failCount = 0;
+        for (const chunk of chunks) {
+            const chunkParams = {
+                ...restParams,
+                userIds: chunk,
+            };
+            const result = await this.batchSendRobotMessage(chunkParams);
+            if (result.success) {
+                successCount += chunk.length;
+            }
+            else {
+                failCount += chunk.length;
+                failedUserIds.push(...chunk);
+            }
+        }
+        const allSuccess = failCount === 0;
+        return {
+            success: allSuccess,
+            message: allSuccess
+                ? `批量发送成功，共 ${successCount} 人`
+                : `部分发送失败，成功 ${successCount} 人，失败 ${failCount} 人`,
+            successCount,
+            failCount,
+            failedUserIds: failedUserIds.length > 0 ? failedUserIds : undefined,
+        };
+    }
+    /**
+     * 发送 Markdown 消息
+     */
+    async sendMarkdownMessage(params) {
+        const robotCode = this.getRobotCode();
+        if (!robotCode) {
+            return {
+                success: false,
+                message: '未配置环境变量 DINGTALK_ROBOT_CODE',
+            };
+        }
+        return this.batchSendRobotMessage({
+            robotCode,
+            userIds: params.userIds,
+            msgKey: 'sampleMarkdown',
+            msgParam: JSON.stringify({
+                title: params.title,
+                text: params.text,
+            }),
+        });
+    }
+    /**
+     * 通用批量发送接口
+     */
+    async sendBatchNotification(params) {
+        const robotCode = this.getRobotCode();
+        if (!robotCode) {
+            return {
+                success: false,
+                message: '未配置环境变量 DINGTALK_ROBOT_CODE',
+            };
+        }
+        return this.batchSendRobotMessage({
+            robotCode,
+            userIds: params.userIds,
+            msgKey: params.msgKey,
+            msgParam: JSON.stringify(params.msgParam),
+        });
+    }
+    /**
+     * 初始化（重新加载环境变量配置）
+     */
+    async initialize() {
+        const envConfig = (0, environment_1.getDingTalkEnvConfig)();
+        this.dingtalkApiClient = new http_client_1.HttpClient(envConfig.apiUrl || 'https://api.dingtalk.com');
+    }
+    /**
+     * 将数组分割成指定大小的块
+     */
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+}
+exports.DingTalkProvider = DingTalkProvider;
+/** 默认钉钉提供者实例 */
+exports.dingtalkProvider = new DingTalkProvider();

package/{src/abilities/index.ts → lib/abilities/index.d.ts}

@@ -1,6 +1,5 @@
 /**
  * 能力模块统一导出
  */
-
 export * from './dingtalk';
 export * from './registry';

package/lib/abilities/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * 能力模块统一导出
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dingtalk"), exports);
+__exportStar(require("./registry"), exports);

package/lib/abilities/registry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 能力注册表模块
+ */
+import { AbilityProvider } from '../types';
+/**
+ * 能力注册表配置
+ */
+export interface AbilityRegistryConfig {
+    /** 是否启用日志 */
+    enableLogging?: boolean;
+    /** 默认超时时间 */
+    defaultTimeout?: number;
+}
+/**
+ * 能力注册表
+ */
+export declare class AbilityRegistry {
+    private providers;
+    private config;
+    constructor(config?: AbilityRegistryConfig);
+    /**
+     * 注册能力提供者
+     * @param provider 能力提供者
+     */
+    register(provider: AbilityProvider): void;
+    /**
+     * 批量注册能力提供者
+     * @param providers 能力提供者数组
+     */
+    registerAll(providers: AbilityProvider[]): void;
+    /**
+     * 获取能力提供者
+     * @param name 提供者名称
+     */
+    get<T extends AbilityProvider = AbilityProvider>(name: string): T | undefined;
+    /**
+     * 检查能力提供者是否已注册
+     * @param name 提供者名称
+     */
+    has(name: string): boolean;
+    /**
+     * 获取所有已注册的提供者名称
+     */
+    getNames(): string[];
+    /**
+     * 获取所有已注册的提供者
+     */
+    getAll(): AbilityProvider[];
+    /**
+     * 注销能力提供者
+     * @param name 提供者名称
+     */
+    unregister(name: string): boolean;
+    /**
+     * 清空所有能力提供者
+     */
+    clear(): void;
+    /**
+     * 初始化所有已注册的提供者
+     */
+    initializeAll(): Promise<void>;
+    /**
+     * 销毁所有已注册的提供者
+     */
+    destroyAll(): Promise<void>;
+    private log;
+}
+/** 默认能力注册表实例 */
+export declare const defaultRegistry: AbilityRegistry;

package/lib/abilities/registry.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * 能力注册表模块
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRegistry = exports.AbilityRegistry = void 0;
+/**
+ * 能力注册表
+ */
+class AbilityRegistry {
+    constructor(config = {}) {
+        this.providers = new Map();
+        this.config = {
+            enableLogging: false,
+            defaultTimeout: 30000,
+            ...config,
+        };
+    }
+    /**
+     * 注册能力提供者
+     * @param provider 能力提供者
+     */
+    register(provider) {
+        if (this.providers.has(provider.name)) {
+            throw new Error(`Provider "${provider.name}" is already registered`);
+        }
+        this.providers.set(provider.name, provider);
+        this.log(`Registered provider: ${provider.name}`);
+    }
+    /**
+     * 批量注册能力提供者
+     * @param providers 能力提供者数组
+     */
+    registerAll(providers) {
+        for (const provider of providers) {
+            this.register(provider);
+        }
+    }
+    /**
+     * 获取能力提供者
+     * @param name 提供者名称
+     */
+    get(name) {
+        return this.providers.get(name);
+    }
+    /**
+     * 检查能力提供者是否已注册
+     * @param name 提供者名称
+     */
+    has(name) {
+        return this.providers.has(name);
+    }
+    /**
+     * 获取所有已注册的提供者名称
+     */
+    getNames() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+     * 获取所有已注册的提供者
+     */
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * 注销能力提供者
+     * @param name 提供者名称
+     */
+    unregister(name) {
+        const result = this.providers.delete(name);
+        if (result) {
+            this.log(`Unregistered provider: ${name}`);
+        }
+        return result;
+    }
+    /**
+     * 清空所有能力提供者
+     */
+    clear() {
+        this.providers.clear();
+        this.log('Cleared all providers');
+    }
+    /**
+     * 初始化所有已注册的提供者
+     */
+    async initializeAll() {
+        for (const provider of this.providers.values()) {
+            if (provider.initialize) {
+                await provider.initialize();
+            }
+        }
+    }
+    /**
+     * 销毁所有已注册的提供者
+     */
+    async destroyAll() {
+        for (const provider of this.providers.values()) {
+            if (provider.destroy) {
+                await provider.destroy();
+            }
+        }
+    }
+    log(message) {
+        if (this.config.enableLogging) {
+            console.log(`[AbilityRegistry] ${message}`);
+        }
+    }
+}
+exports.AbilityRegistry = AbilityRegistry;
+/** 默认能力注册表实例 */
+exports.defaultRegistry = new AbilityRegistry();

package/lib/core/environment.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 环境配置模块
+ */
+export interface EnvironmentConfig {
+    /** API 基础 URL */
+    apiUrl: string;
+    /** 当前环境 */
+    env: 'development' | 'production';
+    /** 应用 ID */
+    appId?: string;
+    /** 用户 ID */
+    userId?: string;
+    /** 租户 ID */
+    tenantId?: string;
+}
+/**
+ * 钉钉环境配置
+ */
+export interface DingTalkEnvConfig {
+    /** 钉钉应用 AppKey */
+    appKey?: string;
+    /** 钉钉应用 AppSecret */
+    appSecret?: string;
+    /** 钉钉机器人编码 */
+    robotCode?: string;
+    /** 钉钉 API 基础 URL */
+    apiUrl?: string;
+}
+/**
+ * 获取环境配置
+ * @returns 环境配置对象
+ */
+export declare function getEnvironmentConfig(): EnvironmentConfig;
+/**
+ * 设置环境配置
+ * @param config 部分配置
+ */
+export declare function setEnvironmentConfig(config: Partial<EnvironmentConfig>): void;
+/**
+ * 重置环境配置为默认值
+ */
+export declare function resetEnvironmentConfig(): void;
+/**
+ * 获取钉钉环境配置（从环境变量）
+ * @returns 钉钉环境配置对象
+ */
+export declare function getDingTalkEnvConfig(): DingTalkEnvConfig;

package/lib/core/environment.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDingTalkEnvConfig = exports.resetEnvironmentConfig = exports.setEnvironmentConfig = exports.getEnvironmentConfig = void 0;
+/**
+ * 默认环境配置
+ */
+const defaultConfig = {
+    apiUrl: process.env.API_URL || '',
+    env: process.env.NODE_ENV || 'development',
+    appId: process.env.APP_ID,
+    userId: process.env.USER_ID,
+    tenantId: process.env.TENANT_ID,
+};
+/** 当前环境配置 */
+let currentConfig = { ...defaultConfig };
+/**
+ * 获取环境配置
+ * @returns 环境配置对象
+ */
+function getEnvironmentConfig() {
+    return { ...currentConfig };
+}
+exports.getEnvironmentConfig = getEnvironmentConfig;
+/**
+ * 设置环境配置
+ * @param config 部分配置
+ */
+function setEnvironmentConfig(config) {
+    currentConfig = { ...currentConfig, ...config };
+}
+exports.setEnvironmentConfig = setEnvironmentConfig;
+/**
+ * 重置环境配置为默认值
+ */
+function resetEnvironmentConfig() {
+    currentConfig = { ...defaultConfig };
+}
+exports.resetEnvironmentConfig = resetEnvironmentConfig;
+/**
+ * 获取钉钉环境配置（从环境变量）
+ * @returns 钉钉环境配置对象
+ */
+function getDingTalkEnvConfig() {
+    return {
+        appKey: process.env.DINGTALK_APP_KEY,
+        appSecret: process.env.DINGTALK_APP_SECRET,
+        robotCode: process.env.DINGTALK_ROBOT_CODE,
+        apiUrl: process.env.DINGTALK_API_URL,
+    };
+}
+exports.getDingTalkEnvConfig = getDingTalkEnvConfig;

package/lib/core/http-client.d.ts

@@ -0,0 +1,16 @@
+import { BaseResponse } from "../types";
+/**
+ * HTTP 请求客户端
+ */
+export declare class HttpClient {
+    private baseUrl;
+    constructor(baseUrl: string);
+    /**
+     * 发送 POST 请求
+     */
+    post<T = any>(endpoint: string, data: any, options?: RequestInit): Promise<BaseResponse<T>>;
+    /**
+     * 发送 GET 请求
+     */
+    get<T = any>(endpoint: string, options?: RequestInit): Promise<BaseResponse<T>>;
+}