@zhin.js/core 1.0.16 → 1.0.18

package/src/adapter.ts

@@ -1,92 +1,143 @@
-import {Bot} from "./bot.js";
-import {Plugin} from "./plugin.js";
+import { Bot } from "./bot.js";
+import { Plugin } from "./plugin.js";
+import { EventEmitter } from "events";
+import { Message } from "./message.js";
+import { BeforeSendHandler, SendOptions } from "./types.js";
+import { segment } from "./utils.js";
 /**
  * Adapter类：适配器抽象，管理多平台Bot实例。
  * 负责根据配置启动/关闭各平台机器人，统一异常处理。
  */
-export class Adapter<R extends Bot=Bot>{
-    /** 当前适配器下所有Bot实例，key为bot名称 */
-    public bots:Map<string,R>=new Map<string, R>()
-    #botFactory:Adapter.BotFactory<R>
-    /**
-     * 构造函数
-     * @param name 适配器名称（如 'process'、'qq' 等）
-     * @param botFactory Bot工厂函数或构造器
-     */
-    constructor(public name:string,botFactory:Adapter.BotFactory<R>) {
-        this.#botFactory=botFactory
-    }
-    createBot(config: Adapter.Config<R>) {
-        const bot=Adapter.isBotConstructor(this.#botFactory)?
-            new this.#botFactory(config)
-            :this.#botFactory(config)
-        return bot
-    }
-    /**
-     * 启动适配器，自动根据配置创建并连接所有Bot
-     * @param plugin 所属插件实例
-     */
-    async mounted(plugin:Plugin){
-        const configs=plugin.app.config.bots?.filter(c=>c.context===this.name)
-        if(!configs?.length) return plugin.logger.warn(`no bot config for adapter ${this.name} found`)
-        try {
-            for(const config of configs){
-                let bot: R
-                if (Adapter.isBotConstructor(this.#botFactory)) {
-                    bot = new this.#botFactory(config) as R
-                } else {
-                    bot = this.#botFactory(config) as R
-                }
-                try {
-                    await bot.$connect()
-                    plugin.logger.info(`bot ${config.name} of adapter ${this.name} connected`)
-                    this.bots.set(config.name,bot)
-                } catch (error) {
-                    // 如果连接失败，确保错误正确传播
-                    throw error
-                }
-            }
+export abstract class Adapter<R extends Bot = Bot> extends EventEmitter<Adapter.Lifecycle> {
+  /** 当前适配器下所有Bot实例，key为bot名称 */
+  public bots: Map<string, R> = new Map<string, R>();
+  /**
+   * 构造函数
+   * @param name 适配器名称（如 'process'、'qq' 等）
+   * @param botFactory Bot工厂函数或构造器
+   */
+  constructor(
+    public plugin: Plugin,
+    public name: keyof Plugin.Contexts,
+    public config: Adapter.BotConfig<R>[]
+  ) {
+    super();
+    this.on('call.recallMessage', async(bot_id, id) => {
+      const bot = this.bots.get(bot_id);
+      if(!bot) throw new Error(`Bot ${bot_id} not found`);
+      this.logger.info(`${bot_id} recall ${id}`);
+      await bot.$recallMessage(id);
+    })
+    this.on('call.sendMessage', async (bot_id:string,options:SendOptions) => {
+      const fns=this.plugin.root.listeners('before.sendMessage') as BeforeSendHandler[];
+      for(const fn of fns){
+        const result=await fn(options);
+        if(result) options=result;
+      }
+      const bot = this.bots.get(bot_id);
+      if(!bot) throw new Error(`Bot ${bot_id} not found`);
+      this.logger.info(`${bot_id} send ${options.type}(${options.id}):${segment.raw(options.content)}`);
+      return await bot.$sendMessage(options);
+    });
+    this.on('message.receive', (message) => {
+      this.logger.info(`${message.$bot} recv ${message.$channel.type}(${message.$channel.id}):${segment.raw(message.$content)}`);
+      this.plugin?.middleware(message, async ()=>{});
+    });
+  }
+  abstract createBot(config: Adapter.BotConfig<R>): R;
+  get logger() {
+    if(!this.plugin) throw new Error("Adapter is not associated with any plugin");
+    return this.plugin.logger;
+  }
+  binding(plugin: Plugin) {
+    this.plugin = plugin;
+  }
+  async start() {
+    this.plugin.root.adapters.push(this.name);
+    if (!this.config?.length) return;
 
-            plugin.logger.info(`adapter ${this.name} mounted`)
-        } catch (error) {
-            // 确保错误正确传播
-            throw error
-        }
+    for (const config of this.config) {
+      const bot = this.createBot(config);
+      await bot.$connect();
+      this.logger.debug(`bot ${bot.$id} of adapter ${this.name} connected`);
+      this.bots.set(bot.$id, bot);
     }
-    /**
-     * 停止适配器，断开并移除所有Bot实例
-     * @param plugin 所属插件实例
-     */
-    async dispose(plugin:Plugin){
+    this.logger.debug(`adapter ${this.name} started`);
+  }
+  /**
+   * 停止适配器，断开并移除所有Bot实例
+   * @param plugin 所属插件实例
+   */
+  async stop() {
+    try {
+      for (const [id, bot] of this.bots) {
         try {
-            for(const [name,bot] of this.bots){
-                try {
-                    await bot.$disconnect()
-                    plugin.logger.info(`bot ${name} of adapter ${this.name} disconnected`)
-                    this.bots.delete(name)
-                } catch (error) {
-                    // 如果断开连接失败，确保错误正确传播
-                    throw error
-                }
-            }
-            plugin.logger.info(`adapter ${this.name} stopped`)
+          await bot.$disconnect();
+          this.logger.debug(`bot ${id} of adapter ${this.name} disconnected`);
         } catch (error) {
-            // 确保错误正确传播
-            throw error
+          // 如果断开连接失败，确保错误正确传播
+          throw error;
         }
+      }
+      // 清理 bots Map
+      this.bots.clear();
+      
+      // 从 adapters 数组中移除
+      const idx = this.plugin.root.adapters.indexOf(this.name);
+      if (idx !== -1) {
+        this.plugin.root.adapters.splice(idx, 1);
+      }
+      
+      // 移除所有事件监听器
+      this.removeAllListeners();
+      
+      this.logger.info(`adapter ${this.name} stopped`);
+    } catch (error) {
+      // 确保错误正确传播
+      throw error;
     }
+  }
 }
+export interface Adapters {}
 export namespace Adapter {
-    export type BotBotConstructor<T extends Bot>=T extends Bot<infer F,infer S> ? {
-        new(config:S):T
-    }: {
-        new(config:Bot.Config):T
-    }
-    export function isBotConstructor<T extends Bot>(fn: BotFactory<T>): fn is BotBotConstructor<T> {
-        return fn.prototype &&
-            fn.prototype.constructor === fn
-    }
-    export type BotCreator<T extends Bot>=T extends Bot<infer F,infer S> ? (config: S) => T : (config: Bot.Config) => T
-    export type BotFactory<T extends Bot> = BotBotConstructor<T>|BotCreator<T>
-    export type Config<T extends Bot>=T extends Bot<infer F,infer S>?S:Bot.Config
-}
+  export type Factory<R extends Adapter = Adapter> = {
+    new (
+    plugin: Plugin,
+    name: string,
+    config: Adapter.BotConfig<Adapter.InferBot<R>>[]
+  ):R
+  };
+  export interface Lifecycle {
+    'message.receive': [Message];
+    'message.private.receive': [Message];
+    'message.group.receive': [Message];
+    'message.channel.receive': [Message];
+    'call.recallMessage': [string, string];
+    'call.sendMessage': [string, SendOptions];
+  }
+  /**
+   * 适配器工厂注册表
+   * 灵感来源于 zhinjs/next 的 Adapter.Registry
+   */
+  export const Registry = new Map<string, Factory>();
+  export type InferBot<R extends Adapter=Adapter> = R extends Adapter<infer T>
+    ? T
+    : never;
+  export type BotConfig<T extends Bot> = T extends Bot<infer R> ? R : never;
+  export type BotMessage<T extends Bot> = T extends Bot<infer _L, infer R>
+    ? R
+    : never;
+  /**
+   * 注册适配器工厂
+   *
+   * @param name 适配器名称
+   * @param factory 适配器工厂函数
+   * @example
+   * ```typescript
+   * Adapter.register('icqq', IcqqAdapter);
+   * ```
+   */
+  export function register(name: string, factory: Factory) {
+    Registry.set(name, factory);
+  }
+}

package/src/bot.ts

@@ -1,18 +1,20 @@
 import type { SendOptions } from "./types.js";
 import { Message } from "./message.js";
+import { Adapter, Adapters } from "./adapter.js";
 /**
  * Bot接口：所有平台机器人需实现的统一接口。
  * 负责消息格式化、连接、断开、消息发送等。
  * @template M 消息类型
  * @template T 配置类型
  */
-export interface Bot<M extends object = {}, T extends Bot.Config = Bot.Config> {
+export interface Bot<Config extends object= {},Event extends object = {}> {
+  $id:string
   /** 机器人配置 */
-  $config: T;
+  $config: Config;
   /** 是否已连接 */
-  $connected?: boolean;
+  $connected: boolean;
   /** 格式化平台消息为标准Message结构 */
-  $formatMessage(message: M): Message<M>;
+  $formatMessage(event: Event): Message<Event>;
   /** 连接机器人 */
   $connect(): Promise<void>;
   /** 断开机器人 */
@@ -23,12 +25,5 @@ export interface Bot<M extends object = {}, T extends Bot.Config = Bot.Config> {
   $sendMessage(options: SendOptions): Promise<string>;
 }
 export namespace Bot {
-  /**
-   * Bot配置类型，所有平台机器人通用
-   */
-  export interface Config {
-    context: string;
-    name: string;
-    [key: string]: any;
-  }
-}
+  export type Config =Adapter.BotConfig<Adapters[keyof Adapters]>
+}

package/src/built/adapter-process.ts

@@ -0,0 +1,77 @@
+import { Adapter, Plugin, Bot, SendContent, SendOptions, MessageBase, Message, segment } from "@zhin.js/core";
+export class ProcessBot implements Bot<{},{content:string,ts:number}>{
+    $id=`${process.pid}`;
+    get logger() {
+        return this.adapter.logger;
+    }
+    $connected=false;
+    constructor(public adapter: ProcessAdapter, public $config={}) {
+        this.$listenInput=this.$listenInput.bind(this);
+    }
+    $listenInput:(data:Buffer<ArrayBufferLike>)=>void=function (this:ProcessBot,data){
+        const content = data.toString().trim();
+        if (content) {
+            this.adapter.emit('message.receive', this.$formatMessage({content,ts:Date.now()}));
+        }
+    }
+    async connect() {
+    }
+    async disconnect() {
+    }
+    $formatMessage(event: {content:string,ts:number}): Message<{content:string,ts:number}> {
+        const base:MessageBase={
+            $id: `${event.ts}`,
+            $adapter: 'process',
+            $bot: `${process.pid}`,
+            $sender: {
+                id: `${process.pid}`,
+                name: process.title,
+            },
+            $channel: {
+                id: `${process.pid}`,
+                type: 'private',
+            },
+            $content: [{type:'text',data:{text:event.content}}],
+            $raw: event.content,
+            $timestamp: event.ts,
+            $recall: async () => {
+                await this.$recallMessage(base.$id)
+            },
+            $reply: async (content: SendContent) => {
+                return await this.$sendMessage({
+                    context: 'process',
+                    bot: base.$bot,
+                    content,
+                    id: base.$id,
+                    type: base.$channel.type,
+                });
+            },
+        }
+        return Message.from(event, base);
+    }
+    async $recallMessage(id: string) {
+    }
+    async $sendMessage(options: SendOptions) {
+        return `${Date.now()}`;
+    }
+    async $connect(): Promise<void> {
+        process.stdin.on('data', this.$listenInput);
+        this.$connected = true;
+    }
+    async $disconnect() {
+        process.stdin.removeListener('data', this.$listenInput);
+    }
+}
+export class ProcessAdapter extends Adapter<ProcessBot>{
+    constructor(plugin: Plugin) {
+        super(plugin, 'process', [{}]);
+    }
+    createBot(): ProcessBot {
+        return new ProcessBot(this);
+    }
+}
+declare module '@zhin.js/core'{
+    interface RegisteredAdapters{
+        process:ProcessAdapter
+    }
+}

package/src/built/command.ts

@@ -0,0 +1,102 @@
+/**
+ * Command Context
+ * 管理所有插件注册的命令
+ */
+import { MessageCommand } from "../command.js";
+import { Message } from "../message.js";
+import { Context, Plugin, getPlugin } from "../plugin.js";
+import type { RegisteredAdapter, AdapterMessage } from "../types.js";
+
+/**
+ * CommandContext 扩展方法类型
+ */
+export interface CommandContextExtensions {
+  /** 添加命令 */
+  addCommand<T extends RegisteredAdapter>(command: MessageCommand<T>): () => void;
+}
+
+// 扩展 Plugin 接口
+declare module "../plugin.js" {
+  namespace Plugin {
+    interface Extensions extends CommandContextExtensions {}
+    interface Contexts {
+      command: CommandService;
+    }
+  }
+}
+
+/**
+ * 命令服务数据
+ */
+export interface CommandService {
+  /** 命令列表（保持顺序） */
+  readonly items: MessageCommand<RegisteredAdapter>[];
+  /** 按 pattern 索引 */
+  readonly byName: Map<string, MessageCommand<RegisteredAdapter>>;
+  /** 添加命令 */
+  add(command: MessageCommand<RegisteredAdapter>, pluginName: string): () => void;
+  /** 移除命令 */
+  remove(command: MessageCommand<RegisteredAdapter>): boolean;
+  /** 按名称获取 */
+  get(pattern: string): MessageCommand<RegisteredAdapter> | undefined;
+  /** 处理消息 */
+  handle(message: Message<AdapterMessage<RegisteredAdapter>>, plugin: Plugin): Promise<any>;
+}
+
+/**
+ * 创建命令 Context
+ */
+export function createCommandService(): Context<'command', CommandContextExtensions> {
+  const items: MessageCommand<RegisteredAdapter>[] = [];
+  const byName = new Map<string, MessageCommand<RegisteredAdapter>>();
+  const pluginMap = new Map<MessageCommand<RegisteredAdapter>, string>();
+  
+  const value: CommandService = {
+    items,
+    byName,
+    
+    add(command, pluginName) {
+      items.push(command);
+      byName.set(command.pattern, command);
+      pluginMap.set(command, pluginName);
+      return () => value.remove(command);
+    },
+    
+    remove(command) {
+      const index = items.indexOf(command);
+      if (index !== -1) {
+        items.splice(index, 1);
+        byName.delete(command.pattern);
+        pluginMap.delete(command);
+        return true;
+      }
+      return false;
+    },
+    
+    get(pattern) {
+      return byName.get(pattern);
+    },
+    
+    async handle(message, plugin) {
+      for (const command of items) {
+        const result = await command.handle(message, plugin);
+        if (result) return result;
+      }
+      return null;
+    }
+  };
+  
+  return {
+    name: 'command',
+    description: '命令服务',
+    value,
+    extensions: {
+      addCommand<T extends RegisteredAdapter>(command: MessageCommand<T>) {
+        const plugin = getPlugin();
+        const dispose = value.add(command as MessageCommand<RegisteredAdapter>, plugin.name);
+        plugin.onDispose(dispose);
+        return dispose;
+      }
+    }
+  };
+}

package/src/built/component.ts

@@ -0,0 +1,111 @@
+/**
+ * Component Context
+ * 管理所有插件注册的组件
+ */
+import { Component, renderComponents } from "../component.js";
+import { SendOptions, MaybePromise } from "../types.js";
+import { Context, Plugin, getPlugin } from "../plugin.js";
+
+type Listener = (options: SendOptions) => MaybePromise<SendOptions>;
+
+/**
+ * ComponentContext 扩展方法类型
+ */
+export interface ComponentContextExtensions {
+  /** 添加组件 */
+  addComponent<T extends Component<any>>(component: T): () => void;
+}
+
+// 扩展 Plugin 接口
+declare module "../plugin.js" {
+  namespace Plugin {
+    interface Extensions extends ComponentContextExtensions {}
+    interface Contexts {
+      component: ComponentService;
+    }
+  }
+}
+
+/**
+ * 组件服务数据
+ */
+export interface ComponentService {
+  /** 按名称索引 */
+  readonly byName: Map<string, Component<any>>;
+  /** 添加组件 */
+  add(component: Component<any>, pluginName: string): () => void;
+  /** 获取所有组件名称 */
+  getAllNames(): string[];
+  /** 移除组件 */
+  remove(component: Component<any>): boolean;
+  /** 按名称获取 */
+  get(name: string): Component<any> | undefined;
+}
+
+/**
+ * 创建组件 Context
+ */
+export function createComponentService(): Context<'component', ComponentContextExtensions> {
+  const byName = new Map<string, Component<any>>();
+  const pluginMap = new Map<Component<any>, string>();
+  let listener: Listener | undefined;
+  let rootPlugin: Plugin | undefined;
+  
+  const value: ComponentService = {
+    byName,
+    
+    add(component, pluginName) {
+      byName.set(component.name, component);
+      pluginMap.set(component, pluginName);
+      return () => value.remove(component);
+    },
+    getAllNames() {
+      return Array.from(byName.keys());
+    },
+    remove(component) {
+      if (byName.has(component.name)) {
+        byName.delete(component.name);
+        pluginMap.delete(component);
+        return true;
+      }
+      return false;
+    },
+    
+    get(name) {
+      return byName.get(name);
+    }
+  };
+  
+  return {
+    name: 'component',
+    description: '组件服务',
+    value,
+    
+    mounted(plugin: Plugin) {
+      rootPlugin = plugin;
+      // 创建消息渲染监听器
+      listener = (options: SendOptions) => {
+        return renderComponents(byName, options);
+      };
+      plugin.root.on('before.sendMessage', listener);
+      return value;
+    },
+    
+    dispose() {
+      if (listener && rootPlugin) {
+        rootPlugin.root.off('before.sendMessage', listener);
+        listener = undefined;
+      }
+    },
+    
+    extensions: {
+      addComponent<T extends Component<any>>(component: T) {
+        const plugin = getPlugin();
+        const dispose = value.add(component, plugin.name);
+        plugin.onDispose(dispose);
+        return dispose;
+      }
+    }
+  };
+}
+

package/src/built/config.ts

@@ -0,0 +1,126 @@
+import path from "node:path";
+import fs from "node:fs";
+import { stringify as stringifyYaml,parse as parseYaml } from "yaml";
+import { Schema } from "@zhin.js/schema";
+export class ConfigLoader<T extends object>{
+    #data: T;
+    get data(): T {
+        return this.#proxy(this.#data,this);
+    }
+    get raw(): T {
+        return this.#data;
+    }
+    get extension() {
+        return path.extname(this.filename).toLowerCase();
+    }
+    constructor(public filename: string, public initial:T, public schema?: Schema<T>) {
+        this.#data = this.initial;
+    }
+    #proxy<R extends object>(data: R, loader: ConfigLoader<T>) {
+        return new Proxy(data, {
+            get(target, prop, receiver) {
+                const result= Reflect.get(target, prop, receiver);
+                if(result instanceof Object && result!==null) return loader.#proxy(result,loader);
+                if(typeof result==='string') {
+                    if(result.startsWith('\\${') && result.endsWith('}')) return result.slice(1);
+                    if(/^\$\{(.*)\}$/.test(result)){
+                        const content = result.slice(2, -1);
+                        const [key, ...rest] = content.split(':');
+                        const defaultValue = rest.length > 0 ? rest.join(':') : undefined;
+                        return process.env[key] ?? defaultValue ?? (loader.initial as any)[key] ?? result;
+                    }
+                }
+                return result;
+            },
+            set(target, prop, value, receiver) {
+                const result= Reflect.set(target, prop, value, receiver);
+                loader.save(loader.filename);
+                return result;
+            },
+            deleteProperty(target, prop) {
+                const result= Reflect.deleteProperty(target, prop);
+                loader.save(loader.filename);
+                return result;
+            }
+        });
+    }
+    load() {
+        const fullPath=path.resolve(process.cwd(), this.filename);
+        if (!fs.existsSync(fullPath)) {
+            this.save(fullPath);
+        }
+        const content = fs.readFileSync(fullPath, "utf-8");
+        let rawConfig: any;
+        switch (this.extension) {
+            case ".json":
+                rawConfig = JSON.parse(content);
+                break;
+            case ".yaml":
+            case ".yml":
+                rawConfig = parseYaml(content);
+                break;
+        }
+        if(this.schema){
+            this.#data = this.schema(rawConfig || this.initial) as T;
+        }else{
+            this.#data = rawConfig as T;
+        }
+    }
+    save(fullPath: string) {
+        switch (this.extension) {
+            case ".json":
+                fs.writeFileSync(fullPath, JSON.stringify(this.#data, null, 2));
+                break;
+            case ".yaml":
+            case ".yml":
+                fs.writeFileSync(fullPath, stringifyYaml(this.#data));
+                break;
+        }
+    }
+}
+export namespace ConfigLoader{
+    export const supportedExtensions = [".json", ".yaml", ".yml"];
+    export function load<T extends object>(filename: string, initial?:T, schema?: Schema<T>) {
+        const result = new ConfigLoader<T>(filename, initial??{} as T, schema);
+        result.load();
+        return result;
+    }
+}
+export class ConfigService{
+    configs: Map<string, ConfigLoader<any>> = new Map();
+    constructor() {
+    }
+    load<T extends object>(filename: string, initial?:Partial<T>, schema?: Schema<T>) {
+        const ext = path.extname(filename).toLowerCase();
+        if (!ConfigLoader.supportedExtensions.includes(ext)) {
+            throw new Error(`不支持的配置文件格式: ${ext}`);
+        }
+        const config = ConfigLoader.load(filename, initial as T, schema);
+        this.configs.set(filename, config);
+        return config;
+    }
+    get<T extends object>(filename: string, initial?:Partial<T>, schema?: Schema<T>): T {
+        if(!this.configs.has(filename)) this.load(filename, initial, schema);
+        const config = this.configs.get(filename);
+        if(!config) throw new Error(`配置文件 ${filename} 未加载`);
+        return config.data as T;
+    }
+    getRaw<T extends object>(filename: string, initial?:Partial<T>, schema?: Schema<T>): T {
+        if(!this.configs.has(filename)) this.load(filename, initial, schema);
+        const config = this.configs.get(filename);
+        if(!config) throw new Error(`配置文件 ${filename} 未加载`);
+        return config.raw as T;
+    }
+    /**
+     * 更新配置文件内容
+     * @param filename 配置文件名
+     * @param data 新的配置数据
+     */
+    set<T extends object>(filename: string, data: T): void {
+        const config = this.configs.get(filename);
+        if(!config) throw new Error(`配置文件 ${filename} 未加载`);
+        // 直接更新内部数据（会触发 Proxy 的 set 拦截器并自动保存）
+        Object.assign(config.raw, data);
+        config.save(path.resolve(process.cwd(), filename));
+    }
+}