@zhin.js/core 1.0.2 → 1.0.4

package/src/command.ts

@@ -1,7 +1,10 @@
 import {MatchResult, SegmentMatcher} from "segment-matcher";
-import {AdapterMessage, RegisteredAdapters, SendContent} from "./types.js";
+import {AdapterMessage, SendContent} from "./types.js";
+import {RegisteredAdapters} from "@zhin.js/types";
 import type {Message} from "./message.js";
 import {MaybePromise} from "@zhin.js/types";
+import { Plugin } from "./plugin.js";
+import { PluginError } from "./errors.js";
 
 /**
  * MessageCommand类：命令系统核心，基于segment-matcher实现。
@@ -9,15 +12,8 @@ import {MaybePromise} from "@zhin.js/types";
  */
 export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredAdapters> extends SegmentMatcher{
     #callbacks:MessageCommand.Callback<T>[]=[];
+    #permissions:string[]=[];
     #checkers:MessageCommand.Checker<T>[]=[]
-    /**
-     * 限定命令作用域（适配器名）
-     * @param scopes 适配器名列表
-     */
-    scope<R extends T>(...scopes:R[]):MessageCommand<R>{
-        this.#checkers.push((m)=>(scopes as string[]).includes(m.$adapter))
-        return this as MessageCommand<R>
-    }
     /**
      * 注册命令回调
      * @param callback 命令处理函数
@@ -26,12 +22,25 @@ export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredA
         this.#callbacks.push(callback)
         return this as MessageCommand<T>;
     }
+    permit(...permissions:string[]){
+        this.#permissions.push(...permissions)
+        return this as MessageCommand<T>;
+    }
     /**
      * 处理消息，自动匹配命令并执行回调
      * @param message 消息对象
+     * @param plugin 插件实例
      * @returns 命令返回内容或undefined
      */
-    async handle(message:Message<AdapterMessage<T>>):Promise<SendContent|undefined>{
+    async handle(message:Message<AdapterMessage<T>>,plugin:Plugin):Promise<SendContent|undefined>{
+        for(const permission of this.#permissions){
+            const permit=plugin.getPermit(permission)
+            if(!permit) {
+                throw new PluginError(`权限 ${permission} 不存在`,plugin.name)
+            }
+            const result=await permit.check(permission,message)
+            if(!result) return;
+        }
         for(const check of this.#checkers){
             const result=await check(message)
             if(!result) return;

package/src/jsx-dev-runtime.ts

@@ -0,0 +1,2 @@
+export * from './jsx-runtime.js'
+export {jsx as jsxDEV} from './jsx.js'

package/src/log-transport.ts

@@ -0,0 +1,163 @@
+import { LogTransport } from '@zhin.js/logger'
+import { App } from './app.js'
+
+/**
+ * 数据库日志传输器
+ * 将日志存储到数据库，并自动清理旧日志
+ */
+export class DatabaseLogTransport implements LogTransport {
+  private app: App
+  private stripAnsiRegex = /\x1b\[[0-9;]*m/g
+  private cleanupTimer?: NodeJS.Timeout
+  private maxDays: number
+  private maxRecords: number
+  private cleanupInterval: number
+
+  constructor(app: App) {
+    this.app = app
+    
+    // 从配置读取日志清理策略
+    const logConfig = app['config']?.log || {}
+    this.maxDays = logConfig.maxDays || 7 // 默认保留 7 天
+    this.maxRecords = logConfig.maxRecords || 10000 // 默认最多 10000 条
+    this.cleanupInterval = logConfig.cleanupInterval || 24 // 默认 24 小时清理一次
+    
+    // 启动定时清理
+    this.startCleanup()
+  }
+
+  /**
+   * 启动定时清理任务
+   */
+  private startCleanup(): void {
+    // 立即执行一次清理
+    this.cleanupOldLogs().catch(err => {
+      this.app.logger.error('[DatabaseLogTransport] Initial cleanup failed:', err.message)
+    })
+
+    // 设置定时任务
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupOldLogs().catch(err => {
+        this.app.logger.error('[DatabaseLogTransport] Scheduled cleanup failed:', err.message)
+      })
+    }, this.cleanupInterval * 60 * 60 * 1000) // 转换为毫秒
+  }
+
+  /**
+   * 清理旧日志
+   */
+  private async cleanupOldLogs(): Promise<void> {
+    if (!this.app.database) {
+      return
+    }
+
+    try {
+      const LogModel = this.app.database.model('SystemLog')
+      if (!LogModel) {
+        return
+      }
+
+      // 1. 按时间清理：删除超过 maxDays 天的日志
+      const cutoffDate = new Date()
+      cutoffDate.setDate(cutoffDate.getDate() - this.maxDays)
+      
+      const deletedByDate = await LogModel
+        .delete({ timestamp: { $lt: cutoffDate } })
+      
+      // 2. 按数量清理：如果日志总数超过 maxRecords，删除最旧的
+      const total = await LogModel.select()
+      const totalCount = total.length
+      
+      if (totalCount > this.maxRecords) {
+        const excessCount = totalCount - this.maxRecords
+        
+        // 查找最旧的 excessCount 条日志的 ID
+        const oldestLogs = await LogModel
+          .select('id','timestamp')
+          .orderBy('timestamp', 'ASC')
+          .limit(excessCount)
+        
+        const idsToDelete = oldestLogs.map((log: any) => log.id)
+        
+        if (idsToDelete.length > 0) {
+          await LogModel
+            .delete({ id: { $in: idsToDelete } })
+        }
+      }
+
+      this.app.logger.info(
+        `[DatabaseLogTransport] Log cleanup completed. ` +
+        `Deleted ${deletedByDate || 0} logs older than ${this.maxDays} days. ` +
+        `Current total: ${Math.max(0, totalCount - (deletedByDate || 0))} logs.`
+      )
+    } catch (error) {
+      // 静默处理错误
+      this.app.logger.error('[DatabaseLogTransport] Cleanup error:', (error as Error).message)
+    }
+  }
+
+  /**
+   * 停止清理任务
+   */
+  public stopCleanup(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer)
+      this.cleanupTimer = undefined
+    }
+  }
+
+  /**
+   * 移除 ANSI 颜色代码
+   */
+  private stripAnsi(str: string): string {
+    return str.replace(this.stripAnsiRegex, '')
+  }
+
+  write(message: string): void {
+    // 移除 ANSI 颜色代码
+    const cleanMessage = this.stripAnsi(message)
+    
+    // 解析日志消息
+    // 格式: [09-08 04:07:55.852] [INFO] [MyApp]: message
+    const logRegex = /\[[\d-]+ [\d:.]+\] \[(\w+)\] \[([^\]]+)\]: ([\s\S]+)/
+    const match = cleanMessage.match(logRegex)
+    
+    if (match) {
+      const [, level, name, msg] = match
+      const source = name.split(':')[0] // 取第一部分作为 source
+      
+      // 异步存储到数据库，不阻塞日志输出
+      this.saveToDatabase(level.toLowerCase(), name, msg.trim(), source).catch(err => {
+        // 避免日志存储失败导致应用崩溃
+        console.error('[DatabaseLogTransport] Failed to save log:', err.message)
+      })
+    }
+  }
+
+  /**
+   * 保存日志到数据库
+   */
+  private async saveToDatabase(level: string, name: string, message: string, source: string): Promise<void> {
+    if (!this.app.database) {
+      return // 没有数据库则跳过
+    }
+
+    try {
+      const LogModel = this.app.database.model('SystemLog')
+      if (!LogModel) {
+        return // 模型不存在则跳过
+      }
+
+      await LogModel.create({
+        level,
+        name,
+        message,
+        source,
+        timestamp: new Date()
+      })
+    } catch (error) {
+      // 静默处理错误，避免干扰主流程
+    }
+  }
+}
+

package/src/message.ts

@@ -28,7 +28,7 @@ export interface MessageBase {
     $bot:string
     $content: MessageElement[];
     $sender: MessageSender;
-    $reply(content:SendContent,quote?:boolean|string):Promise<void>
+    $reply(content:SendContent,quote?:boolean|string):Promise<string>
     $channel: MessageChannel;
     $timestamp: number;
     $raw: string;

package/src/models/system-log.ts

@@ -0,0 +1,20 @@
+import { Schema } from '@zhin.js/database'
+
+export interface SystemLog {
+  id?: number
+  level: string
+  name: string
+  message: string
+  source: string
+  timestamp: Date
+}
+
+export const SystemLogSchema:Schema<SystemLog>={
+  id: { type: 'integer', autoIncrement: true, primary: true },
+  level: { type: 'text', nullable: false },
+  name: { type: 'text', nullable: false },
+  message: { type: 'text', nullable: false },
+  source: { type: 'text', nullable: false },
+  timestamp: { type: 'date', nullable: false }
+}
+

package/src/models/user.ts

@@ -0,0 +1,15 @@
+import { Schema } from '@zhin.js/database'
+export interface User{
+    id:string
+    name?:string
+    password?:string
+    third_part:string[];
+    permissions?:string[]
+}
+export const UserSchema:Schema<User>={
+    id:{type:"text",nullable:false},
+    name:{type:'text',nullable:true},
+    password:{type:'text',nullable:true},
+    third_part:{type:'json',default:[]},
+    permissions:{type:'json',default:[]}
+}

package/src/permissions.ts

@@ -0,0 +1,62 @@
+import { MaybePromise } from "@zhin.js/types";
+import { RegisteredAdapter } from "./types.js";
+import { Message } from "./message.js";
+import { AdapterMessage } from "./types.js";
+import { App } from "./app.js";
+export type PermissionItem<T extends RegisteredAdapter = RegisteredAdapter> = {
+    name: string | RegExp
+    check: PermissionChecker<T>
+}
+export type PermissionChecker<T extends RegisteredAdapter = RegisteredAdapter> = (name: string, message: Message<AdapterMessage<T>>) => MaybePromise<boolean>
+export class Permissions extends Array<PermissionItem>{
+    constructor(private readonly app: App) {
+        super();
+        this.add(Permissions.define(/^adapter\([^)]+\)$/, (name, message) => {
+            return message.$adapter === name.replace(/^adapter\(([^)]+)\)$/, '$1');
+        }));
+        this.add(Permissions.define(/^group\([^)]+\)$/, (name, message) => {
+            const match=name.match(/^group\(([^)]+)\)$/);
+            if(!match) return false;
+            const id=match[1];
+            if(message.$channel.type !== 'group') return false;
+            if(id===''||id==='*') return true;
+            return message.$channel.id === id;
+        }));
+        this.add(Permissions.define(/^private\([^)]+\)$/, (name, message) => {
+            const match=name.match(/^private\(([^)]+)\)$/);
+            if(!match) return false;
+            const id=match[1];
+            if(message.$channel.type !== 'private') return false;
+            if(id===''||id==='*') return true;
+            return message.$channel.id === id;
+        }));
+        this.add(Permissions.define(/^channel\([^)]+\)$/, (name, message) => {
+            const match=name.match(/^channel\(([^)]+)\)$/);
+            if(!match) return false;
+            const id=match[1];
+            if(message.$channel.type !== 'channel') return false;
+            if(id===''||id==='*') return true;
+            return message.$channel.id === id;
+        }));
+        this.add(Permissions.define(/^user\([^)]+\)$/,(name,message)=>{
+            const match=name.match(/^channel\(([^)]+)\)$/);
+            if(!match) return false;
+            const id=match[1];
+            return message.$sender.id===id;
+        }))
+    }
+    add(permission: PermissionItem) {
+        this.push(permission);
+    }
+    get(name: string): PermissionItem | undefined {
+        return this.app.dependencyList.reduce((result,dep)=>{
+            result.push(...dep.permissions)
+            return result;
+        },[...this]).find(p => new RegExp(p.name).test(name));
+    }
+}
+export namespace Permissions{
+    export function define<T extends RegisteredAdapter = RegisteredAdapter>(name: string | RegExp, check: PermissionChecker<T>): PermissionItem<T> {
+        return { name, check };
+    }
+}

package/src/plugin.ts

@@ -5,6 +5,7 @@
 
 import {MaybePromise} from '@zhin.js/types'
 import {AdapterMessage, BeforeSendHandler, RegisteredAdapter, SendOptions} from "./types.js";
+import { PermissionItem,PermissionChecker } from './permissions.js';
 import {Message} from './message.js'
 import {Dependency, Logger,} from "@zhin.js/hmr";
 import {App} from "./app";
@@ -29,8 +30,9 @@ export type MessageMiddleware<P extends RegisteredAdapter=RegisteredAdapter> = (
  * 支持命令注册、中间件、组件、定时任务、模型等。
  */
 export class Plugin extends Dependency<Plugin> {
-    middlewares: MessageMiddleware<any>[] = [];
+    middlewares: MessageMiddleware<RegisteredAdapter>[] = [];
     components: Map<string, Component<any>> = new Map();
+    permissions: PermissionItem<RegisteredAdapter>[]=[];
     schemas: Map<string,Schema<any>>=new Map();
     commands:MessageCommand[]=[];
     crons:Cron[]=[];
@@ -48,7 +50,7 @@ export class Plugin extends Dependency<Plugin> {
         // 注册命令处理为默认中间件
         this.addMiddleware(async (message,next)=>{
             for(const command of this.commands){
-                const result=await command.handle(message);
+                const result=await command.handle(message,this);
                 if(result) message.$reply(result);
             }
             return next()
@@ -90,20 +92,26 @@ export class Plugin extends Dependency<Plugin> {
             try {
                 await message.$reply('抱歉，处理您的消息时出现了错误。')
             } catch (replyError) {
-                // 静默处理回复错误，避免错误循环
-                // console.error 已替换为注释
             }
         }
     }
+    addPermit<T extends RegisteredAdapter>(name:string|RegExp,check:PermissionChecker<T>){
+        this.permissions.push({name,check});
+        return this;
+    }
+    getPermit<T extends RegisteredAdapter>(name:string):PermissionItem<T>|undefined{
+        return this.app.permissions.get(name);
+    }
     cron(cronExpression:string,callback:()=>void){
         const cronJob = new Cron(cronExpression,callback);
         this.crons.push(cronJob);
         return this;
     }
     async #runMiddlewares(message: Message, index: number): Promise<void> {
-        if (index >= this.middlewares.length) return
+        const middlewareList=[...this.app.middlewares,...this.middlewares]
+        if (index >= middlewareList.length) return
         
-        const middleware = this.middlewares[index]
+        const middleware = middlewareList[index]
         
         try {
             await middleware(message, () => this.#runMiddlewares(message, index + 1))
@@ -178,6 +186,20 @@ export class Plugin extends Dependency<Plugin> {
             throw messageError
         }
     }
+    recallMessage(adapter:string,bot:string,id:string){
+        try{
+            this.app.recallMessage(adapter,bot,id)
+        }catch(error){
+            const messageError = new MessageError(
+                `撤回消息失败: ${(error as Error).message}`,
+                id,
+                undefined,
+                { originalError: error }
+            )
+            errorManager.handle(messageError)
+            throw messageError
+        }
+    }
 
     /** 销毁插件 */
     dispose(): void {

package/src/prompt.ts

@@ -27,8 +27,8 @@ export class Prompt<P extends RegisteredAdapter> {
      * @param config 提问配置
      */
     private prompt<T = any>(config: Prompt.Config<T>) {
-        return new Promise<T>((resolve, reject) => {
-            this.event.$reply(config.tips);
+        return new Promise<T>(async (resolve, reject) => {
+            const id = await this.event.$reply(config.tips);
             this.middleware(
                 input => {
                     if (input instanceof Error) {
@@ -37,6 +37,7 @@ export class Prompt<P extends RegisteredAdapter> {
                         else reject(input);
                         return;
                     }
+                    this.plugin.recallMessage(this.event.$adapter,this.event.$bot,id);
                     resolve(config.format(input));
                 },
                 config.timeout,

package/src/types.ts

@@ -1,21 +1,10 @@
-import {MaybePromise}from '@zhin.js/types'
-import {MessageChannel} from "./message.js";
+import {MaybePromise,RegisteredAdapters}from '@zhin.js/types'
+import {MessageChannel,Message} from "./message.js";
 import {Adapter} from "./adapter.js";
 import {Bot,BotConfig} from "./bot.js";
 import { Databases,Registry } from "@zhin.js/database";
 import { MessageComponent } from "./message.js";
 
-/**
- * 类型定义文件：包含适配器、消息、数据库、配置等核心类型声明。
- * 协作者可通过本文件了解各主要数据结构的用途与关系。
- */
-declare module '@zhin.js/types'{
-  interface GlobalContext extends RegisteredAdapters{}
-}
-/**
- * 所有已注册适配器的类型映射（key为适配器名，value为Adapter实例）
- */
-export interface RegisteredAdapters extends Record<string, Adapter>{}
 /**
  * 数据库配置类型，支持多种数据库驱动
  */
@@ -68,6 +57,7 @@ export type SendContent=MaybeArray<string|MessageElement>
 export interface MessageSender{
   id: string;
   name?: string;
+  permissions?:string[]
 }
 /**
  * 通用字典类型
@@ -109,6 +99,15 @@ export interface AppConfig {
   disable_dependencies?: string[];
   /** 是否启用调试模式 */
   debug?: boolean;
+  /** 日志配置 */
+  log?: {
+    /** 最大日志保留天数，默认 7 天 */
+    maxDays?: number;
+    /** 最大日志条数，默认 10000 条 */
+    maxRecords?: number;
+    /** 自动清理间隔（小时），默认 24 小时 */
+    cleanupInterval?: number;
+  };
 }
 /**
  * defineConfig辅助类型，支持函数式/对象式配置