@chen0825/aiapp-ability 0.1.0

package/src/abilities/dingtalk/index.ts

@@ -0,0 +1,311 @@
+/**
+ * 钉钉能力模块
+ */
+
+import { HttpClient } from '../../core/http-client';
+import { getDingTalkEnvConfig } from '../../core/environment';
+import {
+  BatchSendRobotMsgRequest,
+  BatchSendResponse,
+  RobotMsgKey,
+  GetAccessTokenResponse,
+} from '../../types/dingtalk';
+import { AbilityProvider } from '../../types';
+
+/** 钉钉API批量发送限制：每次最多20人 */
+const BATCH_SEND_LIMIT = 20;
+
+/**
+ * 简化的 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 class DingTalkProvider implements AbilityProvider {
+  public readonly name = 'dingtalk';
+  public readonly version = '1.0.0';
+
+  private dingtalkApiClient: HttpClient;
+
+  constructor() {
+    const envConfig = getDingTalkEnvConfig();
+    this.dingtalkApiClient = new HttpClient(envConfig.apiUrl);
+  }
+
+  /**
+   * 获取 appKey
+   */
+  private getAppKey(): string | undefined {
+    return getDingTalkEnvConfig().appKey;
+  }
+
+  /**
+   * 获取 appSecret
+   */
+  private getAppSecret(): string | undefined {
+    return getDingTalkEnvConfig().appSecret;
+  }
+
+  /**
+   * 获取机器人编码
+   */
+  private getRobotCode(): string | undefined {
+    return getDingTalkEnvConfig().robotCode;
+  }
+
+  /**
+   * 获取 API 基础 URL
+   */
+  private getApiUrl(): string {
+    return getDingTalkEnvConfig().apiUrl;
+  }
+
+  /**
+   * 获取企业内部应用的 accessToken（每次调用都重新获取）
+   */
+  async getAccessToken(): Promise<{ success: boolean; accessToken?: string; message?: string }> {
+    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: GetAccessTokenResponse = 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<T extends RobotMsgKey>(
+    params: BatchSendRobotMsgRequest<T>,
+  ): Promise<BatchSendResponse> {
+    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<any>(
+        '/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人时自动分批）
+   */
+  private async batchSendInChunks<T extends RobotMsgKey>(
+    params: BatchSendRobotMsgRequest<T>,
+  ): Promise<BatchSendResponse> {
+    const { userIds, ...restParams } = params;
+    const chunks = this.chunkArray(userIds, BATCH_SEND_LIMIT);
+    const failedUserIds: string[] = [];
+    let successCount = 0;
+    let failCount = 0;
+
+    for (const chunk of chunks) {
+      const chunkParams: BatchSendRobotMsgRequest<T> = {
+        ...restParams,
+        userIds: chunk,
+      } as BatchSendRobotMsgRequest<T>;
+
+      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: MarkdownNotificationParams): Promise<BatchSendResponse> {
+    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<T extends RobotMsgKey>(
+    params: BatchNotificationParams<T>,
+  ): Promise<BatchSendResponse> {
+    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(): Promise<void> {
+    const envConfig = getDingTalkEnvConfig();
+    this.dingtalkApiClient = new HttpClient(envConfig.apiUrl);
+  }
+
+  /**
+   * 将数组分割成指定大小的块
+   */
+  private chunkArray<T>(array: T[], size: number): T[][] {
+    const chunks: T[][] = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+}
+
+/** 默认钉钉提供者实例 */
+export const dingtalkProvider = new DingTalkProvider();

package/src/abilities/index.ts

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

package/src/abilities/registry.ts

@@ -0,0 +1,134 @@
+/**
+ * 能力注册表模块
+ */
+
+import { AbilityProvider } from '../types';
+
+/**
+ * 能力注册表配置
+ */
+export interface AbilityRegistryConfig {
+  /** 是否启用日志 */
+  enableLogging?: boolean;
+  /** 默认超时时间 */
+  defaultTimeout?: number;
+}
+
+/**
+ * 能力注册表
+ */
+export class AbilityRegistry {
+  private providers: Map<string, AbilityProvider> = new Map();
+  private config: AbilityRegistryConfig;
+
+  constructor(config: AbilityRegistryConfig = {}) {
+    this.config = {
+      enableLogging: false,
+      defaultTimeout: 30000,
+      ...config,
+    };
+  }
+
+  /**
+   * 注册能力提供者
+   * @param provider 能力提供者
+   */
+  register(provider: AbilityProvider): void {
+    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: AbilityProvider[]): void {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+
+  /**
+   * 获取能力提供者
+   * @param name 提供者名称
+   */
+  get<T extends AbilityProvider = AbilityProvider>(name: string): T | undefined {
+    return this.providers.get(name) as T | undefined;
+  }
+
+  /**
+   * 检查能力提供者是否已注册
+   * @param name 提供者名称
+   */
+  has(name: string): boolean {
+    return this.providers.has(name);
+  }
+
+  /**
+   * 获取所有已注册的提供者名称
+   */
+  getNames(): string[] {
+    return Array.from(this.providers.keys());
+  }
+
+  /**
+   * 获取所有已注册的提供者
+   */
+  getAll(): AbilityProvider[] {
+    return Array.from(this.providers.values());
+  }
+
+  /**
+   * 注销能力提供者
+   * @param name 提供者名称
+   */
+  unregister(name: string): boolean {
+    const result = this.providers.delete(name);
+    if (result) {
+      this.log(`Unregistered provider: ${name}`);
+    }
+    return result;
+  }
+
+  /**
+   * 清空所有能力提供者
+   */
+  clear(): void {
+    this.providers.clear();
+    this.log('Cleared all providers');
+  }
+
+  /**
+   * 初始化所有已注册的提供者
+   */
+  async initializeAll(): Promise<void> {
+    for (const provider of this.providers.values()) {
+      if (provider.initialize) {
+        await provider.initialize();
+      }
+    }
+  }
+
+  /**
+   * 销毁所有已注册的提供者
+   */
+  async destroyAll(): Promise<void> {
+    for (const provider of this.providers.values()) {
+      if (provider.destroy) {
+        await provider.destroy();
+      }
+    }
+  }
+
+  private log(message: string): void {
+    if (this.config.enableLogging) {
+      console.log(`[AbilityRegistry] ${message}`);
+    }
+  }
+}
+
+/** 默认能力注册表实例 */
+export const defaultRegistry = new AbilityRegistry();

package/src/core/environment.ts

@@ -0,0 +1,79 @@
+/**
+ * 环境配置模块
+ */
+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;
+}
+
+/**
+ * 默认环境配置
+ */
+const defaultConfig: EnvironmentConfig = {
+  apiUrl: process.env.API_URL || '',
+  env: (process.env.NODE_ENV as 'development' | 'production') || 'development',
+  appId: process.env.APP_ID,
+  userId: process.env.USER_ID,
+  tenantId: process.env.TENANT_ID,
+};
+
+/** 当前环境配置 */
+let currentConfig: EnvironmentConfig = { ...defaultConfig };
+
+/**
+ * 获取环境配置
+ * @returns 环境配置对象
+ */
+export function getEnvironmentConfig(): EnvironmentConfig {
+  return { ...currentConfig };
+}
+
+/**
+ * 设置环境配置
+ * @param config 部分配置
+ */
+export function setEnvironmentConfig(config: Partial<EnvironmentConfig>): void {
+  currentConfig = { ...currentConfig, ...config };
+}
+
+/**
+ * 重置环境配置为默认值
+ */
+export function resetEnvironmentConfig(): void {
+  currentConfig = { ...defaultConfig };
+}
+
+/**
+ * 获取钉钉环境配置（从环境变量）
+ * @returns 钉钉环境配置对象
+ */
+export function getDingTalkEnvConfig(): DingTalkEnvConfig {
+  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,
+  };
+}

package/src/core/http-client.ts

@@ -0,0 +1,88 @@
+import { BaseResponse } from "../types";
+
+/**
+ * HTTP 请求客户端
+ */
+export class HttpClient {
+  private baseUrl: string;
+
+  constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+
+  /**
+   * 发送 POST 请求
+   */
+  async post<T = any>(
+    endpoint: string,
+    data: any,
+    options?: RequestInit,
+  ): Promise<BaseResponse<T>> {
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers,
+        },
+        body: JSON.stringify(data),
+        ...options,
+      });
+
+      if (!response.ok) {
+        return {
+          success: false,
+          message: "请求异常",
+          data: undefined,
+        };
+      }
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      console.error("HTTP请求失败：", error);
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "请求失败",
+        data: undefined,
+      };
+    }
+  }
+
+  /**
+   * 发送 GET 请求
+   */
+  async get<T = any>(
+    endpoint: string,
+    options?: RequestInit,
+  ): Promise<BaseResponse<T>> {
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers,
+        },
+        ...options,
+      });
+
+      if (!response.ok) {
+        return {
+          success: false,
+          message: "请求异常",
+          data: undefined,
+        };
+      }
+
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      console.error("HTTP请求失败：", error);
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "请求失败",
+        data: undefined,
+      };
+    }
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,6 @@
+/**
+ * 核心模块统一导出
+ */
+
+export * from './http-client';
+export * from './environment';

package/src/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @ali/aiapp-ability
+ * AI应用能力包
+ */
+
+// 导出类型
+export * from './types';
+
+// 导出核心模块
+export * from './core';
+
+// 导出能力模块
+export * from './abilities';
+
+export default function main() {
+  return 'Write your own legend...';
+}