@zhin.js/core 1.0.0

package/src/config.ts

@@ -0,0 +1,276 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { parse as parseToml } from 'toml';
+import { config as loadDotenv } from 'dotenv';
+import type { AppConfig,DefineConfig } from './types.js';
+
+export interface ConfigOptions {
+  configPath?: string;
+  envPath?: string;
+  envOverride?: boolean;
+}
+
+/**
+ * 支持的配置文件格式
+ */
+export type ConfigFormat = 'json' | 'yaml' | 'yml' | 'toml' | 'js' | 'ts';
+
+/**
+ * 环境变量替换正则表达式，支持默认值语法: ${VAR_NAME:-default_value}
+ */
+const ENV_VAR_REGEX = /\$\{([^}]+)\}/g;
+
+/**
+ * 替换字符串中的环境变量
+ */
+function replaceEnvVars(str: string): string {
+  return str.replace(ENV_VAR_REGEX, (match, content) => {
+    // 解析环境变量名和默认值
+    const colonIndex = content.indexOf(':-');
+    let envName: string;
+    let defaultValue: string | undefined;
+    
+    if (colonIndex !== -1) {
+      // 格式: VAR_NAME:-default_value
+      envName = content.slice(0, colonIndex);
+      defaultValue = content.slice(colonIndex + 2);
+    } else {
+      // 格式: VAR_NAME
+      envName = content;
+      defaultValue = undefined;
+    }
+    
+    const envValue = process.env[envName];
+    
+    if (envValue !== undefined) {
+      return envValue;
+    } else if (defaultValue !== undefined) {
+      return defaultValue;
+    } else {
+      console.warn(`环境变量 ${envName} 未定义，保持原值`);
+      return match;
+    }
+  });
+}
+
+/**
+ * 递归替换对象中的环境变量
+ */
+function replaceEnvVarsInObject(obj: any): any {
+  if (typeof obj === 'string') {
+    return replaceEnvVars(obj);
+  }
+  
+  if (Array.isArray(obj)) {
+    return obj.map(item => replaceEnvVarsInObject(item));
+  }
+  
+  if (obj && typeof obj === 'object') {
+    for (const [key, value] of Object.entries(obj)) {
+      obj[key] = replaceEnvVarsInObject(value);
+    }
+    return obj;
+  }
+  
+  return obj;
+}
+
+/**
+ * 根据文件扩展名解析配置文件
+ */
+async function parseConfigFile(content: string, format: ConfigFormat, filePath?: string): Promise<any> {
+  try {
+    switch (format) {
+      case 'json':
+        return JSON.parse(content);
+      case 'yaml':
+      case 'yml':
+        return parseYaml(content);
+      case 'toml':
+        return parseToml(content);
+      case 'js':
+      case 'ts':
+        if (!filePath) {
+          throw new Error('解析 JS/TS 配置文件需要提供文件路径');
+        }
+        // 使用动态导入加载 JS/TS 模块
+        const fileUrl = pathToFileURL(path.resolve(filePath)).href;
+        const module = await import(fileUrl);
+        // 支持 ES 模块的 default 导出和 CommonJS 模块
+        const result = module.default || module;
+        if(typeof result === 'function') return await result((process.env||{}) as Record<string,string>);
+        return result;
+      default:
+        throw new Error(`不支持的配置文件格式: ${format}`);
+    }
+  } catch (error) {
+    throw new Error(`解析配置文件失败: ${error}`);
+  }
+}
+
+/**
+ * 获取配置文件格式
+ */
+function getConfigFormat(filePath: string): ConfigFormat {
+  const ext = path.extname(filePath).slice(1).toLowerCase();
+  if (!['json', 'yaml', 'yml', 'toml', 'js', 'ts'].includes(ext)) {
+    throw new Error(`不支持的配置文件格式: ${ext}`);
+  }
+  return ext as ConfigFormat;
+}
+
+/**
+ * 查找配置文件
+ */
+function findConfigFile(cwd: string = process.cwd()): string | null {
+  const configNames = [
+    // 优先查找 zhin.config.* 格式
+    'zhin.config.yaml',
+    'zhin.config.yml', 
+    'zhin.config.json',
+    'zhin.config.toml',
+    'zhin.config.js',
+    'zhin.config.ts',
+    // 然后查找 config.* 格式
+    'config.yaml',
+    'config.yml',
+    'config.json',
+    'config.toml',
+    'config.js',
+    'config.ts'
+  ];
+
+  for (const name of configNames) {
+    const filePath = path.join(cwd, name);
+    if (fs.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+
+  return null;
+}
+export function defineConfig<T extends DefineConfig<AppConfig>>(config: T): T {
+  return config;
+}
+/**
+ * 加载配置文件
+ */
+export async function loadConfig(options: ConfigOptions = {}): Promise<[string,AppConfig]> {
+  const { configPath, envPath, envOverride = true } = options;
+  
+  // 加载环境变量
+  if (envPath) {
+    loadDotenv({ path: envPath, override: envOverride });
+  } else {
+    // 尝试加载默认的 .env 文件
+    const defaultEnvPath = path.join(process.cwd(), '.env');
+    if (fs.existsSync(defaultEnvPath)) {
+      loadDotenv({ path: defaultEnvPath, override: envOverride });
+    }
+  }
+
+  // 确定配置文件路径
+  let finalConfigPath: string;
+  
+  if (configPath) {
+    if (!fs.existsSync(configPath)) {
+      throw new Error(`配置文件不存在: ${configPath}`);
+    }
+    finalConfigPath = configPath;
+  } else {
+    const foundPath = findConfigFile();
+    if (!foundPath) {
+      throw new Error('未找到配置文件，支持的文件名: zhin.config.[yaml|yml|json|toml|js|ts] 或 config.[yaml|yml|json|toml|js|ts]');
+    }
+    finalConfigPath = foundPath;
+  }
+
+  // 读取并解析配置文件
+  const format = getConfigFormat(finalConfigPath);
+  let rawConfig: any;
+  
+  if (format === 'js' || format === 'ts') {
+    // JS/TS 文件不需要读取内容，直接解析
+    rawConfig = await parseConfigFile('', format, finalConfigPath);
+  } else {
+    const content = fs.readFileSync(finalConfigPath, 'utf-8');
+    rawConfig = await parseConfigFile(content, format, finalConfigPath);
+  }
+  
+  // 替换环境变量
+  const config = replaceEnvVarsInObject(rawConfig) as AppConfig;
+  
+  // 验证配置
+  validateConfig(config);
+  
+  return [finalConfigPath,config];
+}
+
+/**
+ * 验证配置文件结构
+ */
+function validateConfig(config: any): void {
+  if (!config) {
+    throw new Error('配置文件不能为空');
+  }
+  
+  if (!config.bots || !Array.isArray(config.bots)) {
+    throw new Error('配置文件必须包含 bots 数组');
+  }
+  
+  
+  for (const [index, bot] of config.bots.entries()) {
+    if (!bot.name) {
+      throw new Error(`机器人 ${index} 缺少 name 字段`);
+    }
+    
+    if (!bot.context) {
+      throw new Error(`机器人 ${bot.name} 缺少 context 字段`);
+    }
+  }
+}
+
+/**
+ * 保存配置文件
+ */
+export function saveConfig(config: AppConfig, filePath: string): void {
+  const format = getConfigFormat(filePath);
+  let content: string;
+  
+  switch (format) {
+    case 'json':
+      content = JSON.stringify(config, null, 2);
+      break;
+    case 'yaml':
+    case 'yml':
+      content = stringifyYaml(config, { indent: 2 });
+      break;
+    case 'toml':
+      // toml 库没有 stringify 方法，我们需要手动实现或使用其他库
+      throw new Error('暂不支持保存 TOML 格式的配置文件');
+    default:
+      throw new Error(`不支持的配置文件格式: ${format}`);
+  }
+  
+  fs.writeFileSync(filePath, content, 'utf-8');
+}
+
+/**
+ * 创建默认配置
+ */
+export function createDefaultConfig(format: ConfigFormat = 'yaml'): AppConfig {
+  return {
+    bots: [
+      {
+        name: 'onebot11',
+        context: 'onebot11',
+        url: '${ONEBOT_URL:-ws://localhost:8080}',
+        access_token: '${ONEBOT_ACCESS_TOKEN:-}'
+      }
+    ],
+    plugin_dirs: ['./src/plugins', 'node_modules'],
+    plugins: []
+  };
+} 

package/src/index.ts

@@ -0,0 +1,14 @@
+// ============================================================================
+// Zhin Bot Framework - HMR Edition
+// ============================================================================
+
+// 核心系统
+export type { Bot } from './bot.js';
+export { loadConfig, saveConfig, createDefaultConfig } from './config.js';
+export * from './types.js';
+export * from './config.js';
+export * from './adapter.js'
+export * from './plugin.js';
+// HMR Bot系统 (主要API)
+export * from './app.js';
+export * from '@zhin.js/hmr';

package/src/logger.ts

@@ -0,0 +1,3 @@
+import { ConsoleLogger } from "@zhin.js/hmr";
+
+export const logger = new ConsoleLogger('[Core]', process.env.NODE_ENV === 'development');

package/src/plugin.ts

@@ -0,0 +1,122 @@
+// ============================================================================
+// 插件类型定义
+// ============================================================================
+
+
+import {MaybePromise} from '@zhin.js/types'
+import { Message, BeforeSendHandler, SendOptions} from "./types";
+import {Dependency, Logger,} from "@zhin.js/hmr";
+import {App} from "./app";
+
+/** 消息中间件函数 */
+export type MessageMiddleware = (message: Message, next: () => Promise<void>) => MaybePromise<void>;
+
+/** 事件监听器函数 */
+export type EventListener<T = any> = (data: T) => void | Promise<void>;
+
+/** 定时任务配置 */
+export interface CronJob {
+    name: string;
+    schedule: string; // cron 表达式
+    handler: () => void | Promise<void>;
+    enabled?: boolean;
+}
+
+
+// ============================================================================
+// Plugin 类
+// ============================================================================
+
+/**
+ * 插件类：继承自Dependency，提供机器人特定功能
+ */
+export class Plugin extends Dependency<Plugin> {
+    middlewares: MessageMiddleware[] = [];
+    eventListeners = new Map<string, EventListener[]>();
+    cronJobs = new Map<string, CronJob>();
+
+    #logger?:Logger
+    constructor(parent: Dependency<Plugin>, name: string, filePath: string) {
+        super(parent, name, filePath);
+        this.on('message.receive',this.#handleMessage.bind(this))
+    }
+    #handleMessage(message:Message){
+        const next=async (index:number)=>{
+            if(!this.middlewares[index]) return
+            const middleware=this.middlewares[index]
+            middleware(message,()=>next(index+1))
+        }
+        next(0)
+    }
+    beforeSend(handler:BeforeSendHandler){
+        this.before('message.send',handler)
+    }
+    before(event:string,listener:(...args:any[])=>any){
+        this.on(`before-${event}`,listener)
+    }
+    /** 获取所属的App实例 */
+    get app(): App {
+        return this.parent as App;
+    }
+    get logger(): Logger {
+        if(this.#logger) return this.#logger
+        const names = [this.name];
+        let temp=this as Dependency<Plugin>
+        while(temp.parent){
+            names.unshift(temp.parent.name)
+            temp=temp.parent
+        }
+        return this.#logger=this.app.getLogger(...names)
+    }
+
+    /** 添加中间件 */
+    addMiddleware(middleware: MessageMiddleware): void {
+        this.middlewares.push(middleware);
+        this.dispatch('middleware.add',middleware)
+    }
+
+    /** 添加事件监听器 */
+    addEventListener<T = any>(event: string, listener: EventListener<T>): void {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, []);
+        }
+        this.eventListeners.get(event)!.push(listener);
+        this.dispatch('listener.add',event,listener)
+    }
+
+    /** 添加定时任务 */
+    addCronJob(job: CronJob): void {
+        this.cronJobs.set(job.name, job);
+        this.dispatch('cron-job.add',job)
+    }
+    /** 发送消息 */
+    async sendMessage(options:SendOptions): Promise<void> {
+        await this.app.sendMessage(options);
+    }
+
+    /** 销毁插件 */
+    dispose(): void {
+        // 移除所有中间件
+        for (const middleware of this.middlewares) {
+            this.dispatch('middleware.remove', middleware)
+        }
+        this.middlewares = []
+
+        // 移除所有事件监听器
+        for (const [event, listeners] of this.eventListeners) {
+            for (const listener of listeners) {
+                this.dispatch('listener.remove', event, listener)
+            }
+        }
+        this.eventListeners.clear()
+
+        // 移除所有定时任务
+        for (const [name, job] of this.cronJobs) {
+            this.dispatch('cron-job.remove', job)
+        }
+        this.cronJobs.clear()
+
+        // 调用父类的dispose方法
+        super.dispose()
+    }
+}

package/src/types-generator.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from './logger.js';
+
+/**
+ * 更新 tsconfig.json 的类型声明
+ * @param cwd 项目根目录
+ */
+export async function generateEnvTypes(cwd: string): Promise<void> {
+    try {
+        // 基础类型集合
+        const types = new Set(['@zhin.js/types']);
+        
+        // 检查 package.json 中的依赖
+        const pkgPath = path.join(cwd, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const allDeps = {
+                ...(pkg.dependencies || {}),
+                ...(pkg.devDependencies || {})
+            };
+
+            // 检查所有 @zhin.js/ 开头的包
+            for (const [name] of Object.entries(allDeps)) {
+                if (name.startsWith('@zhin.js/') || name === 'zhin.js') {
+                    try {
+                        const depPkgPath = path.join(cwd, 'node_modules', name, 'package.json');
+                        if (fs.existsSync(depPkgPath)) {
+                            const depPkg = JSON.parse(fs.readFileSync(depPkgPath, 'utf-8'));
+                            if (depPkg.types || depPkg.typings) {
+                                types.add(name);
+                            }
+                        }
+                    } catch (err) {
+                        // 如果读取失败，跳过这个包
+                        continue;
+                    }
+                }
+            }
+        }
+
+        // 更新或创建 tsconfig.json
+        const tsconfigPath = path.join(cwd, 'tsconfig.json');
+        let tsconfig:Record<string,any> = {};
+
+        // 读取现有的 tsconfig.json
+        if (fs.existsSync(tsconfigPath)) {
+            try {
+                tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf-8'));
+            } catch (err) {
+                console.error(err)
+                logger.warn('⚠️ Failed to parse tsconfig.json, creating new one');
+            }
+        }
+
+        // 确保 compilerOptions 存在
+        if (!tsconfig.compilerOptions) {
+            tsconfig.compilerOptions = {};
+        }
+
+        // 合并现有的 types
+        const existingTypes = tsconfig.compilerOptions.types || [];
+        const allTypes = new Set([...existingTypes, ...types]);
+
+        // 更新 types 字段
+        tsconfig.compilerOptions.types = Array.from(allTypes);
+
+        // 写入文件
+        fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2), 'utf-8');
+        logger.info('✅ Updated TypeScript types configuration');
+    } catch (error) {
+        logger.warn('⚠️ Failed to update TypeScript types:', error);
+    }
+}

package/src/types.ts

@@ -0,0 +1,74 @@
+import {MaybePromise}from '@zhin.js/types'
+
+export interface MessageSegment<T extends keyof Segment=keyof Segment> {
+  type: T;
+  data: Segment[T];
+}
+export interface Segment{
+  [key:string]:Record<string, any>
+  any:Record<string, any>
+}
+export type MaybeArray<T>=T|T[]
+export type SendContent=MaybeArray<string|MessageSegment>
+export interface MessageSender{
+  id: string;
+  name?: string;
+}
+export type MessageComponent<T extends object>=(props:T&{children:SendContent})=>MaybePromise<SendContent>
+export interface MessageChannel{
+  id: string;
+  type: 'group' | 'private' | 'channel';
+}
+export interface Message {
+  id: string;
+  adapter:string
+  bot:string
+  content: MessageSegment[];
+  sender: MessageSender;
+  reply(content:SendContent,quote?:boolean|string):Promise<void>
+  channel: MessageChannel;
+  timestamp: number;
+  raw: string;
+}
+
+export interface User {
+  user_id: string;
+  nickname: string;
+  card?: string;
+  role?: string;
+}
+
+export interface Group {
+  group_id: string;
+  group_name: string;
+  member_count: number;
+}
+
+export interface BotConfig {
+  name: string;
+  context: string;
+  [key: string]: any;
+}
+
+
+
+export interface AppConfig {
+  /** 机器人配置列表 */
+  bots?: BotConfig[];
+  /** 插件目录列表，默认为 ['./plugins', 'node_modules'] */
+  plugin_dirs?: string[];
+  /** 需要加载的插件列表 */
+  plugins?: string[];
+  /** 禁用的依赖列表 */
+  disable_dependencies?: string[];
+  /** 是否启用调试模式 */
+  debug?: boolean;
+}
+export type DefineConfig<T> = T | ((env:Record<string,string>)=>MaybePromise<T>);
+
+export interface SendOptions extends MessageChannel{
+  context:string
+  bot:string
+  content:SendContent
+}
+export type BeforeSendHandler=(options:SendOptions)=>MaybePromise<SendOptions|void>