@zhin.js/core 1.0.38 → 1.0.40

package/src/ai/types.ts

@@ -142,6 +142,7 @@ export interface ProviderConfig {
   apiKey?: string;
   baseUrl?: string;
   defaultModel?: string;
+  models?: string[];
   timeout?: number;
   maxRetries?: number;
   headers?: Record<string, string>;

package/src/cron.ts

@@ -1,142 +1,4 @@
-import { Cron as Croner } from 'croner';
-
 /**
- * Cron 定时任务类
- * 基于 croner 实现的定时任务调度器 (无需 Luxon，内存占用更小)
+ * Re-export from @zhin.js/kernel for backward compatibility.
  */
-export class Cron {
-  private job: Croner | null = null;
-  id:string = '';
-  private callback: () => void | Promise<void>;
-  private isDisposed = false;
-  private _cronExpression: string;
-
-  /**
-   * 创建一个新的 Cron 实例
-   * @param cronExpression - Cron 表达式 (例如: '0 0 * * *' 表示每天午夜执行)
-   * @param callback - 要执行的回调函数
-   */
-  constructor(cronExpression: string, callback: () => void | Promise<void>) {
-    this.id=Math.random().toString(36).substring(2, 10);
-    try {
-      this._cronExpression = cronExpression;
-      this.callback = callback;
-      
-      // 验证 cron 表达式是否有效 (不启动)
-      const testJob = new Croner(cronExpression, { paused: true });
-      testJob.stop();
-    } catch (error) {
-      throw new Error(`Invalid cron expression "${cronExpression}": ${(error as Error).message}`);
-    }
-  }
-
-  /**
-   * 启动定时任务
-   */
-  run(): void {
-    if (this.isDisposed) {
-      throw new Error('Cannot run a disposed cron job');
-    }
-
-    if (this.job) {
-      return; // 已经在运行中
-    }
-
-    // 创建并启动任务
-    this.job = new Croner(this._cronExpression, async () => {
-      try {
-        await this.callback();
-      } catch (error) {
-        console.error(`Error executing cron callback: ${(error as Error).message}`);
-      }
-    });
-  }
-
-  /**
-   * 停止定时任务
-   */
-  stop(): void {
-    if (this.job) {
-      this.job.stop();
-      this.job = null;
-    }
-  }
-
-  /**
-   * 销毁定时任务，释放资源
-   */
-  dispose(): void {
-    this.stop();
-    this.isDisposed = true;
-  }
-
-  /**
-   * 获取下一次执行时间
-   */
-  getNextExecutionTime(): Date {
-    if (this.isDisposed) {
-      throw new Error('Cannot get next execution time for a disposed cron job');
-    }
-    
-    // 创建临时任务来获取下次执行时间
-    const tempJob = new Croner(this._cronExpression, { paused: true });
-    const nextRun = tempJob.nextRun();
-    tempJob.stop();
-    
-    if (!nextRun) {
-      throw new Error('Cannot determine next execution time');
-    }
-    
-    return nextRun;
-  }
-
-  /**
-   * 检查任务是否正在运行
-   */
-  get running(): boolean {
-    return this.job !== null;
-  }
-
-  /**
-   * 检查任务是否已被销毁
-   */
-  get disposed(): boolean {
-    return this.isDisposed;
-  }
-
-  /**
-   * 获取原始的 cron 表达式字符串
-   */
-  get cronExpression(): string {
-    return this._cronExpression;
-  }
-}
-
-//
-// Cron 表达式格式说明:
-//
-// 标准格式: "分 时 日 月 周" (5 字段)
-//
-// 字段说明:
-// - 分: 0-59
-// - 时: 0-23
-// - 日: 1-31
-// - 月: 1-12 (或 JAN-DEC)
-// - 周: 0-7 (0和7都表示周日，或 SUN-SAT)
-//
-// > croner 也支持 6 字段格式 "秒 分 时 日 月 周"，但推荐使用 5 字段格式。
-//
-// 特殊字符:
-// - 星号: 匹配任意值
-// - 问号: 用于日和周字段，表示不指定值
-// - 横线: 表示范围，如 1-5
-// - 逗号: 表示列表，如 1,3,5
-// - 斜杠: 表示步长，如 */15 表示每15分钟
-//
-// 常用示例:
-// - "0 0 * * *": 每天午夜执行
-// - "*/15 * * * *": 每15分钟执行
-// - "0 12 * * *": 每天中午12点执行
-// - "0 0 1 * *": 每月1号午夜执行
-// - "0 0 * * 0": 每周日午夜执行
-//
+export { Cron } from '@zhin.js/kernel';

package/src/errors.ts

@@ -1,70 +1,21 @@
-// ============================================================================
-// 错误处理系统
-// ============================================================================
-
 /**
- * 基础错误类，所有自定义错误都应该继承此类
+ * Re-export generic errors from @zhin.js/kernel
  */
-export class ZhinError extends Error {
-    public readonly code: string
-    public readonly timestamp: Date
-    public readonly context?: Record<string, any>
-
-    constructor(message: string, code: string = 'ZHIN_ERROR', context?: Record<string, any>) {
-        super(message)
-        this.name = this.constructor.name
-        this.code = code
-        this.timestamp = new Date()
-        this.context = context
-        
-        // 确保错误堆栈正确显示
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor)
-        }
-    }
-
-    /**
-     * 转换为JSON格式
-     */
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            code: this.code,
-            timestamp: this.timestamp.toISOString(),
-            context: this.context,
-            stack: this.stack
-        }
-    }
-
-    /**
-     * 转换为用户友好的格式
-     */
-    toUserString(): string {
-        return `[${this.code}] ${this.message}`
-    }
-}
+export {
+  ZhinError,
+  ConfigError,
+  PluginError,
+  ConnectionError,
+  ContextError,
+  ValidationError,
+  PermissionError,
+  TimeoutError,
+  ErrorManager,
+  RetryManager,
+  CircuitBreaker,
+} from '@zhin.js/kernel';
 
-/**
- * 配置相关错误
- */
-export class ConfigError extends ZhinError {
-    constructor(message: string, context?: Record<string, any>) {
-        super(message, 'CONFIG_ERROR', context)
-    }
-}
-
-/**
- * 插件相关错误
- */
-export class PluginError extends ZhinError {
-    public readonly pluginName: string
-
-    constructor(message: string, pluginName: string, context?: Record<string, any>) {
-        super(message, 'PLUGIN_ERROR', { ...context, pluginName })
-        this.pluginName = pluginName
-    }
-}
+import { ZhinError } from '@zhin.js/kernel';
 
 /**
  * 适配器相关错误
@@ -80,18 +31,6 @@ export class AdapterError extends ZhinError {
     }
 }
 
-/**
- * 连接相关错误
- */
-export class ConnectionError extends ZhinError {
-    public readonly retryable: boolean
-
-    constructor(message: string, retryable: boolean = true, context?: Record<string, any>) {
-        super(message, 'CONNECTION_ERROR', { ...context, retryable })
-        this.retryable = retryable
-    }
-}
-
 /**
  * 消息处理错误
  */
@@ -105,261 +44,3 @@ export class MessageError extends ZhinError {
         this.channelId = channelId
     }
 }
-
-/**
- * 上下文相关错误
- */
-export class ContextError extends ZhinError {
-    public readonly contextName: string
-
-    constructor(message: string, contextName: string, context?: Record<string, any>) {
-        super(message, 'CONTEXT_ERROR', { ...context, contextName })
-        this.contextName = contextName
-    }
-}
-
-/**
- * 验证错误
- */
-export class ValidationError extends ZhinError {
-    public readonly field?: string
-    public readonly value?: any
-
-    constructor(message: string, field?: string, value?: any, context?: Record<string, any>) {
-        super(message, 'VALIDATION_ERROR', { ...context, field, value })
-        this.field = field
-        this.value = value
-    }
-}
-
-/**
- * 权限错误
- */
-export class PermissionError extends ZhinError {
-    public readonly userId?: string
-    public readonly requiredPermission?: string
-
-    constructor(message: string, userId?: string, requiredPermission?: string, context?: Record<string, any>) {
-        super(message, 'PERMISSION_ERROR', { ...context, userId, requiredPermission })
-        this.userId = userId
-        this.requiredPermission = requiredPermission
-    }
-}
-
-/**
- * 超时错误
- */
-export class TimeoutError extends ZhinError {
-    public readonly timeoutMs: number
-
-    constructor(message: string, timeoutMs: number, context?: Record<string, any>) {
-        super(message, 'TIMEOUT_ERROR', { ...context, timeoutMs })
-        this.timeoutMs = timeoutMs
-    }
-}
-
-/**
- * 错误处理器接口
- */
-export interface ErrorHandler {
-    (error: Error, context?: Record<string, any>): void | Promise<void>
-}
-
-/**
- * 错误管理器
- */
-export class ErrorManager {
-    private handlers: Map<string, ErrorHandler[]> = new Map()
-    private globalHandlers: ErrorHandler[] = []
-
-    /**
-     * 注册错误处理器
-     */
-    register(errorType: string, handler: ErrorHandler): void {
-        if (!this.handlers.has(errorType)) {
-            this.handlers.set(errorType, [])
-        }
-        this.handlers.get(errorType)!.push(handler)
-    }
-
-    /**
-     * 注册全局错误处理器
-     */
-    registerGlobal(handler: ErrorHandler): void {
-        this.globalHandlers.push(handler)
-    }
-
-    /**
-     * 处理错误
-     */
-    async handle(error: Error, context?: Record<string, any>): Promise<void> {
-        // 首先调用全局处理器
-        for (const handler of this.globalHandlers) {
-            try {
-                await handler(error, context)
-            } catch (handlerError) {
-                // console.error 已替换为注释
-            }
-        }
-
-        // 然后调用特定类型的处理器
-        const errorType = error.constructor.name
-        const handlers = this.handlers.get(errorType) || []
-        
-        for (const handler of handlers) {
-            try {
-                await handler(error, context)
-            } catch (handlerError) {
-                // console.error 已替换为注释
-            }
-        }
-    }
-
-    /**
-     * 移除错误处理器
-     */
-    unregister(errorType: string, handler: ErrorHandler): boolean {
-        const handlers = this.handlers.get(errorType)
-        if (handlers) {
-            const index = handlers.indexOf(handler)
-            if (index !== -1) {
-                handlers.splice(index, 1)
-                return true
-            }
-        }
-        return false
-    }
-
-    /**
-     * 清理所有处理器
-     */
-    clear(): void {
-        this.handlers.clear()
-        this.globalHandlers.length = 0
-    }
-}
-
-/**
- * 错误重试工具
- */
-export class RetryManager {
-    /**
-     * 执行重试逻辑
-     */
-    static async retry<T>(
-        fn: () => Promise<T>,
-        options: {
-            maxRetries?: number
-            delay?: number
-            exponentialBackoff?: boolean
-            retryCondition?: (error: Error) => boolean
-        } = {}
-    ): Promise<T> {
-        const {
-            maxRetries = 3,
-            delay = 1000,
-            exponentialBackoff = true,
-            retryCondition = () => true
-        } = options
-
-        let lastError: Error
-        
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                return await fn()
-            } catch (error) {
-                lastError = error as Error
-                
-                // 如果是最后一次尝试或不满足重试条件，直接抛出错误
-                if (attempt === maxRetries || !retryCondition(lastError)) {
-                    throw lastError
-                }
-                
-                // 计算延迟时间
-                const currentDelay = exponentialBackoff 
-                    ? delay * Math.pow(2, attempt)
-                    : delay
-                
-                // 等待后重试
-                await new Promise(resolve => setTimeout(resolve, currentDelay))
-            }
-        }
-        
-        throw lastError!
-    }
-}
-
-/**
- * 断路器模式实现
- */
-export class CircuitBreaker {
-    private failures: number = 0
-    private lastFailureTime: number = 0
-    private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED'
-
-    constructor(
-        private failureThreshold: number = 5,
-        private timeoutMs: number = 60000,
-        private monitoringPeriodMs: number = 10000
-    ) {}
-
-    /**
-     * 执行受保护的操作
-     */
-    async execute<T>(fn: () => Promise<T>): Promise<T> {
-        if (this.state === 'OPEN') {
-            if (Date.now() - this.lastFailureTime > this.timeoutMs) {
-                this.state = 'HALF_OPEN'
-            } else {
-                throw new Error('Circuit breaker is OPEN')
-            }
-        }
-
-        try {
-            const result = await fn()
-            this.onSuccess()
-            return result
-        } catch (error) {
-            this.onFailure()
-            throw error
-        }
-    }
-
-    private onSuccess(): void {
-        this.failures = 0
-        this.state = 'CLOSED'
-    }
-
-    private onFailure(): void {
-        this.failures++
-        this.lastFailureTime = Date.now()
-        
-        if (this.failures >= this.failureThreshold) {
-            this.state = 'OPEN'
-        }
-    }
-
-    /**
-     * 获取断路器状态
-     */
-    getState(): 'CLOSED' | 'OPEN' | 'HALF_OPEN' {
-        return this.state
-    }
-
-    /**
-     * 重置断路器
-     */
-    reset(): void {
-        this.failures = 0
-        this.lastFailureTime = 0
-        this.state = 'CLOSED'
-    }
-}
-
-// 默认错误管理器实例
-export const errorManager = new ErrorManager()
-
-// 默认错误处理器
-errorManager.registerGlobal((error, context) => {
-    // Default error handler - logs to console
-})

package/src/feature.ts

@@ -1,156 +1,7 @@
-import type { Plugin } from "./plugin.js";
 /**
- * Feature 抽象基类
- * 所有可追踪、可序列化的插件功能（命令、组件、定时任务、中间件等）的基类。
- * Feature 替换原来的 Context 接口，用于 provide/inject 机制。
+ * Re-export from @zhin.js/kernel for backward compatibility.
+ * Core's Plugin class implements PluginLike, so the Feature's
+ * mounted(plugin: PluginLike) signature is compatible.
  */
-
-/**
- * Feature 序列化后的 JSON 格式，用于 HTTP API 返回给前端
- */
-export interface FeatureJSON {
-  name: string;
-  icon: string;
-  desc: string;
-  count: number;
-  items: any[];
-}
-
-/**
- * Feature 变更事件监听器类型
- */
-export type FeatureListener<T> = (item: T, pluginName: string) => void;
-
-/**
- * Feature<T> 抽象类
- * - name / icon / desc: 自描述元数据
- * - items: 全局 item 列表
- * - pluginItems: 按插件名分组的 item 列表
- * - toJSON: 控制 HTTP API 返回的数据格式
- * - extensions: 提供给 Plugin.prototype 的扩展方法（如 addCommand）
- * - mounted / dispose: 可选生命周期钩子
- * - on('add' | 'remove'): 变更事件通知
- */
-export abstract class Feature<T = any> {
-  abstract readonly name: string;
-  abstract readonly icon: string;
-  abstract readonly desc: string;
-
-  /** 全局 item 列表 */
-  readonly items: T[] = [];
-
-  /** 按插件名分组的 item 列表 */
-  protected pluginItems = new Map<string, T[]>();
-
-  /** 事件监听器 */
-  #listeners = new Map<string, Set<FeatureListener<T>>>();
-
-  /**
-   * 监听变更事件
-   * @param event 'add' | 'remove'
-   * @param listener 回调函数
-   * @returns 取消监听的函数
-   */
-  on(event: 'add' | 'remove', listener: FeatureListener<T>): () => void {
-    if (!this.#listeners.has(event)) {
-      this.#listeners.set(event, new Set());
-    }
-    this.#listeners.get(event)!.add(listener);
-    return () => { this.#listeners.get(event)?.delete(listener); };
-  }
-
-  /** 触发事件 */
-  protected emit(event: 'add' | 'remove', item: T, pluginName: string): void {
-    const listeners = this.#listeners.get(event);
-    if (!listeners) return;
-    for (const listener of listeners) {
-      try { listener(item, pluginName); } catch { /* 防止监听器异常影响主流程 */ }
-    }
-  }
-
-  /**
-   * 添加 item，同时记录所属插件
-   * @returns dispose 函数，用于移除该 item
-   */
-  add(item: T, pluginName: string): () => void {
-    this.items.push(item);
-    if (!this.pluginItems.has(pluginName)) {
-      this.pluginItems.set(pluginName, []);
-    }
-    this.pluginItems.get(pluginName)!.push(item);
-    this.emit('add', item, pluginName);
-    return () => this.remove(item, pluginName);
-  }
-
-  /**
-   * 移除 item
-   */
-  remove(item: T, pluginName?: string): boolean {
-    const idx = this.items.indexOf(item);
-    if (idx !== -1) {
-      this.items.splice(idx, 1);
-      const resolvedPluginName = pluginName ?? this.#findPluginName(item);
-      for (const [, items] of this.pluginItems) {
-        const i = items.indexOf(item);
-        if (i !== -1) items.splice(i, 1);
-      }
-      this.emit('remove', item, resolvedPluginName ?? '');
-      return true;
-    }
-    return false;
-  }
-
-  /** 反查 item 所属的 pluginName */
-  #findPluginName(item: T): string | undefined {
-    for (const [name, items] of this.pluginItems) {
-      if (items.includes(item)) return name;
-    }
-    return undefined;
-  }
-
-  /**
-   * 获取指定插件注册的 item 列表
-   */
-  getByPlugin(pluginName: string): T[] {
-    return this.pluginItems.get(pluginName) || [];
-  }
-
-  /**
-   * 全局 item 数量
-   */
-  get count(): number {
-    return this.items.length;
-  }
-
-  /**
-   * 指定插件的 item 数量
-   */
-  countByPlugin(pluginName: string): number {
-    return this.getByPlugin(pluginName).length;
-  }
-
-  /**
-   * 序列化为 JSON（用于 HTTP API）
-   * @param pluginName 如果提供，则只返回该插件的 item；否则返回全部
-   */
-  abstract toJSON(pluginName?: string): FeatureJSON;
-
-  /**
-   * 提供给 Plugin.prototype 的扩展方法
-   * 子类重写此 getter 以注册扩展（如 addCommand）
-   */
-  get extensions(): Record<string, Function> {
-    return {};
-  }
-
-  /**
-   * 生命周期: 服务挂载时调用
-   * @param plugin 宿主插件（通常是 root plugin）
-   */
-  mounted?(plugin: Plugin): void | Promise<void>;
-
-  /**
-   * 生命周期: 服务销毁时调用
-   */
-  dispose?(): void;
-}
+export { Feature } from '@zhin.js/kernel';
+export type { FeatureJSON, FeatureListener } from '@zhin.js/kernel';

package/src/index.ts

@@ -39,4 +39,6 @@ export * from './scheduler/index.js'
 export * from '@zhin.js/database'
 export * from '@zhin.js/logger'
 // 只导出 Schema 类，避免与 utils.js 的 isEmpty 冲突
-export { Schema } from '@zhin.js/schema'
+export { Schema } from '@zhin.js/schema'
+// Re-export PluginLike from kernel (generic plugin interface)
+export type { PluginLike } from '@zhin.js/kernel'