@yumerijs/core 3.0.0-alpha.3 → 3.0.0-alpha.6

package/dist/context.d.ts

@@ -3,6 +3,7 @@ import { Route } from './route.js';
 import { HookHandler } from './hook.js';
 import { Middleware } from './middleware.js';
 import { IRenderer } from '@yumerijs/types';
+import { SessionStorageProcessor, Storage, SessionStorageSnapshot } from './storage.js';
 export interface Components {
     [key: string]: any;
 }
@@ -71,6 +72,10 @@ export declare class Context {
     executeHook(name: string, ...args: any[]): Promise<any[]>;
     /** 获取 Core 实例 */
     getCore(): Core;
+    /**
+     * 替换 core 的 session 存储处理器或底层存储。
+     */
+    setStorage(storage: SessionStorageProcessor | Storage<SessionStorageSnapshot>): void;
     /**
      * 触发事件
      * @param event 事件名称
@@ -105,7 +110,7 @@ export declare class Context {
      * @param module 插件模块
      * @param config 插件配置
      */
-    plugin(module: Plugin, config?: any): Promise<Context>;
+    plugin(module: Plugin, config?: any): Promise<Context | undefined>;
     /**
      * 注册 i18n
      * @param content 内容（可以是嵌套对象或单个key）

package/dist/context.js

@@ -102,6 +102,12 @@ export class Context {
     getCore() {
         return this.core;
     }
+    /**
+     * 替换 core 的 session 存储处理器或底层存储。
+     */
+    setStorage(storage) {
+        this.core.setStorage(storage);
+    }
     /**
      * 触发事件
      * @param event 事件名称
@@ -139,7 +145,7 @@ export class Context {
      */
     fork(name = this.pluginname, path) {
         const ctx = new Context(this.core, name);
-        ctx.childpath = path;
+        ctx.childpath = path ?? '/';
         this.childContexts.push(ctx);
         return ctx;
     }

package/dist/core.d.ts

@@ -9,6 +9,7 @@ import { HookHandler, Hook } from './hook.js';
 import { Server as CoreServer } from './server.js';
 import { I18n } from './i18n.js';
 import { IRenderer } from '@yumerijs/types';
+import { SessionStorageProcessor, Storage, SessionStorageSnapshot } from './storage.js';
 export interface Plugin {
     apply?: (ctx: Context, config: Config) => Promise<void> | void;
     disable?: (ctx: Context) => Promise<void> | void;
@@ -55,11 +56,14 @@ export declare class Core {
     server: CoreServer;
     i18n: I18n;
     loader: any;
+    storage: SessionStorageProcessor;
     renderers: Map<string, IRenderer>;
     pluginRenderers: Map<string, string>;
     constructor(loader?: any, coreConfig?: CoreOptions, loggersetCore?: boolean, splash?: boolean);
-    checkUpdate(): Promise<void>;
+    private checkUpdate;
     addRenderer(renderer: IRenderer): void;
+    setStorage(storage: SessionStorageProcessor | Storage<SessionStorageSnapshot>): void;
+    getStorage(): SessionStorageProcessor;
     getRendererForPlugin(pluginName: string): string | undefined;
     runCore(): Promise<void>;
     getShortPluginName(pluginName: string): string;

package/dist/core.js

@@ -4,7 +4,9 @@ import { Logger } from './logger.js';
 import { Route } from './route.js';
 import { Hook } from './hook.js';
 import { Server as CoreServer } from './server.js';
+import { SessionStorageProcessor } from './storage.js';
 import * as fs from 'fs';
+import semver from 'semver';
 const version = JSON.parse(await fs.promises.readFile(new URL('../package.json', import.meta.url), 'utf-8')).version;
 function isClassPlugin(value) {
     if (typeof value !== 'function')
@@ -28,14 +30,7 @@ function mergePluginMeta(target, source) {
     return target;
 }
 export function resolvePluginModule(module, context, config) {
-    let candidate;
-    // 只有对象模块才取 default/apply
-    if (typeof module === 'object' && module !== null) {
-        candidate = module.default ?? module.apply ?? module;
-    }
-    else {
-        candidate = module;
-    }
+    const candidate = module?.default ?? module?.apply ?? module;
     let plugin;
     if (isClassPlugin(candidate)) {
         plugin = new candidate(context, config);
@@ -74,6 +69,7 @@ export class Core {
     server;
     i18n;
     loader;
+    storage = new SessionStorageProcessor();
     renderers = new Map();
     pluginRenderers = new Map(); // Stores which plugin uses which renderer
     constructor(loader, coreConfig = {}, loggersetCore = true, splash = true) {
@@ -88,15 +84,17 @@ export class Core {
     }
     async checkUpdate() {
         try {
-            const response = await fetch('https://registry.npmjs.org/yumeri/latest');
+            const response = await fetch('https://registry.npmjs.org/yumeri');
             if (!response.ok)
                 return;
-            const { version: latest } = await response.json();
-            if (latest !== version) {
+            const pkg = await response.json();
+            const currentMajor = semver.major(version);
+            const latest = Object.keys(pkg.versions)
+                .filter(v => semver.valid(v) && semver.major(v) === currentMajor)
+                .sort(semver.rcompare)[0];
+            if (latest && semver.gt(latest, version)) {
                 this.logger.info(`There is new version for Yumeri: ${version} -> ${latest}`);
             }
-            else {
-            }
         }
         catch (error) {
             this.logger.error('Error while checking updates: ', error.message);
@@ -108,6 +106,17 @@ export class Core {
         }
         this.renderers.set(renderer.name, renderer);
     }
+    setStorage(storage) {
+        if (storage instanceof SessionStorageProcessor) {
+            this.storage = storage;
+        }
+        else {
+            this.storage.setStorage(storage);
+        }
+    }
+    getStorage() {
+        return this.storage;
+    }
     getRendererForPlugin(pluginName) {
         return this.pluginRenderers.get(pluginName);
     }

package/dist/index.d.ts

@@ -12,3 +12,4 @@ export * from './context.js';
 export * from './hook.js';
 export * from './middleware.js';
 export * from './i18n.js';
+export * from './storage.js';

package/dist/index.js

@@ -12,3 +12,4 @@ export * from './context.js';
 export * from './hook.js';
 export * from './middleware.js';
 export * from './i18n.js';
+export * from './storage.js';

package/dist/route.d.ts

@@ -23,7 +23,7 @@ export declare class Route {
     private handler;
     middlewares: Middleware[];
     allowedMethods: string[];
-    ws: WebSocketServer;
+    ws: WebSocketServer | null;
     context: Context;
     private routehost;
     /**

package/dist/route.js

@@ -436,11 +436,19 @@ export class Route {
             // after finishing pattern, path must be fully consumed (no extra segments)
             if (j !== parts.length)
                 return null;
-            const result = { params, pathParams, hostParams };
+            const normalizedHostParams = {};
+            for (const [key, value] of Object.entries(hostParams)) {
+                normalizedHostParams[key] = value ?? '';
+            }
+            const result = { params, pathParams, hostParams: normalizedHostParams };
             return result;
         }
         else if (pathname.startsWith('root') && this.path == pathname) {
-            const result = { params: { pathname }, pathParams: [pathname], hostParams };
+            const normalizedHostParams = {};
+            for (const [key, value] of Object.entries(hostParams)) {
+                normalizedHostParams[key] = value ?? '';
+            }
+            const result = { params: { pathname }, pathParams: [pathname], hostParams: normalizedHostParams };
             return result;
         }
         return null;

package/dist/server.js

@@ -28,7 +28,7 @@ export class Server {
      * 创建一个新的会话对象
      */
     createSession(ip, cookies, res, req, pathname, pluginContext, extra = {}) {
-        const session = new Session(ip, cookies, this, req, res, pathname, undefined, pluginContext);
+        const session = new Session(ip, cookies, this, req, res ?? undefined, pathname, undefined, pluginContext);
         Object.assign(session.properties, extra);
         session.protocol = extra.protocol ?? 'http';
         return session;
@@ -90,9 +90,18 @@ export class Server {
             const pluginContext = route ? route.context : (rootroute ? rootroute.context : undefined);
             const session = this.createSession(ip, cookies, res, req, pathname, pluginContext, { protocol: 'http', header: req.headers });
             session._startAt = Date.now();
+            await session.loadData();
             /** 路由处理逻辑 */
             const handleRoute = async (routePath) => {
-                const matched = await this.core.executeRoute(routePath, session, queryParams);
+                let matched = false;
+                try {
+                    matched = await this.core.executeRoute(routePath, session, queryParams);
+                }
+                finally {
+                    if (matched) {
+                        await session.saveData(true);
+                    }
+                }
                 if (!matched) {
                     // 核心层不再提供静态文件服务，直接返回 404
                     res.writeHead(404, { 'Content-Type': 'text/plain' });
@@ -166,15 +175,18 @@ export class Server {
             const route = this.core.getRoute(pathname);
             const pluginContext = route ? route.context : undefined;
             const session = this.createSession(ip, cookies, null, req, pathname, pluginContext, { protocol: 'http', header: req.headers });
+            await session.loadData();
             if (route && route.ws != null) {
+                const wsServer = route.ws;
                 const matched = await this.core.executeRoute(pathname, session, queryParams);
                 if (!matched) {
                     socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
                     socket.destroy();
                 }
                 else {
-                    route.ws.handleUpgrade(req, socket, head, (ws) => {
-                        route.ws.emit('connection', ws, req, session);
+                    await session.saveData(true);
+                    wsServer.handleUpgrade(req, socket, head, (ws) => {
+                        wsServer.emit('connection', ws, req, session);
                     });
                 }
             }

package/dist/session.d.ts

@@ -12,9 +12,9 @@ type ParsedParams = Record<string, string | string[] | undefined>;
 /** 客户端对象，包含原始的 HTTP 请求和响应对象 */
 export interface Client {
     /** 原始的 Node.js HTTP 请求对象 */
-    req: IncomingMessage;
+    req?: IncomingMessage;
     /** 原始的 Node.js HTTP 响应对象 */
-    res: ServerResponse;
+    res?: ServerResponse;
     /** 经过处理后的规范化请求头 */
     headers?: Record<string, string>;
 }
@@ -90,14 +90,14 @@ declare class SessionRequest {
     /** 请求使用的协议 */
     protocol: string;
     /** 原始的 IncomingMessage 对象 */
-    raw: IncomingMessage;
+    raw?: IncomingMessage;
     constructor(data: {
         ip: string;
         cookies: Record<string, string>;
         query?: Record<string, string>;
         pathname?: string;
         headers: Record<string, string>;
-        raw: IncomingMessage;
+        raw?: IncomingMessage;
     });
 }
 /**
@@ -121,8 +121,8 @@ declare class SessionResponse {
     /** 标识该响应是否已经处理完毕 */
     handled: boolean;
     /** 原始的 ServerResponse 对象 */
-    raw: ServerResponse;
-    constructor(res: ServerResponse);
+    raw?: ServerResponse;
+    constructor(res?: ServerResponse);
 }
 /**
  * 会话对象 (Session)
@@ -137,6 +137,8 @@ export declare class Session {
     sessionid: string;
     /** 持久化的会话数据存储 */
     data: Record<string, any>;
+    private dataDirty;
+    private dataDestroyed;
     /** 供插件或中间件挂载的临时属性 */
     properties: Record<string, any>;
     /** 对核心服务器实例的引用 */
@@ -160,7 +162,7 @@ export declare class Session {
     /** 获取请求中的 Cookie 集合 */
     get cookie(): Record<string, string>;
     /** 获取 URL 查询参数 */
-    get query(): Record<string, string>;
+    get query(): Record<string, string> | undefined;
     /** 获取请求路径 */
     get pathname(): string;
     /** 获取语言列表 */
@@ -227,6 +229,10 @@ export declare class Session {
      * MD5 加密
      */
     private md5;
+    /** 从 core 存储处理器加载会话数据 */
+    loadData(): Promise<void>;
+    /** 将当前会话数据保存到 core 存储处理器 */
+    saveData(force?: boolean): Promise<void>;
     /** 设置会话数据 */
     setData(key: string, value: any): void;
     /** 删除会话数据 */

package/dist/session.js

@@ -72,6 +72,8 @@ export class Session {
     sessionid;
     /** 持久化的会话数据存储 */
     data = {};
+    dataDirty = false;
+    dataDestroyed = false;
     /** 供插件或中间件挂载的临时属性 */
     properties = {};
     /** 对核心服务器实例的引用 */
@@ -238,6 +240,8 @@ export class Session {
      */
     async parseRequestBody(client = this.client) {
         const req = client.req;
+        if (!req)
+            return {};
         return new Promise((resolve, reject) => {
             const contentType = (req.headers['content-type'] || '').toLowerCase();
             if (contentType.includes('application/json') || contentType.includes('application/x-www-form-urlencoded')) {
@@ -295,14 +299,46 @@ export class Session {
         hash.update(str);
         return hash.digest('hex');
     }
+    /** 从 core 存储处理器加载会话数据 */
+    async loadData() {
+        this.data = await this.server.core.storage.load(this.sessionid);
+        this.dataDirty = false;
+        this.dataDestroyed = false;
+    }
+    /** 将当前会话数据保存到 core 存储处理器 */
+    async saveData(force = false) {
+        if (this.dataDestroyed) {
+            await this.server.core.storage.delete(this.sessionid);
+            this.dataDirty = false;
+            return;
+        }
+        if (force || this.dataDirty) {
+            await this.server.core.storage.save(this.sessionid, this.data);
+            this.dataDirty = false;
+        }
+    }
     /** 设置会话数据 */
-    setData(key, value) { this.data[key] = value; }
+    setData(key, value) {
+        this.data[key] = value;
+        this.dataDirty = true;
+        this.dataDestroyed = false;
+    }
     /** 删除会话数据 */
-    deleteData(key) { delete this.data[key]; }
+    deleteData(key) {
+        delete this.data[key];
+        this.dataDirty = true;
+    }
     /** 清空会话数据 */
-    clearData() { this.data = {}; }
+    clearData() {
+        this.data = {};
+        this.dataDirty = true;
+    }
     /** 销毁会话 */
-    destroy() { this.clearData(); }
+    destroy() {
+        this.data = {};
+        this.dataDirty = true;
+        this.dataDestroyed = true;
+    }
     /** 设置 MIME 类型 */
     setMime(mimeType) {
         const map = {
@@ -313,10 +349,16 @@ export class Session {
         this.response.headers['Content-Type'] = map[mimeType] || mimeType;
     }
     /** 向响应流写入数据 */
-    send(data) { return this.response.raw.write(data); }
+    send(data) {
+        if (!this.response.raw)
+            throw new Error('Cannot send data without a response object.');
+        return this.response.raw.write(data);
+    }
     /** 结束响应 */
     endsession(message) {
         this.response.handled = true;
+        if (!this.response.raw)
+            throw new Error('Cannot end session without a response object.');
         return this.response.raw.end(message);
     }
     /** 获取国际化文本 */

package/dist/storage.d.ts

@@ -0,0 +1,39 @@
+export type MaybePromise<T> = T | Promise<T>;
+export interface Storage<T = any> {
+    get(key: string): MaybePromise<T | undefined | null>;
+    set(key: string, value: T): MaybePromise<void>;
+    delete(key: string): MaybePromise<void>;
+    clear?(): MaybePromise<void>;
+}
+export declare class MemoryStorage<T = any> implements Storage<T> {
+    private data;
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    delete(key: string): void;
+    clear(): void;
+}
+export interface SessionStorageSnapshot {
+    sessionid: string;
+    data: Record<string, any>;
+    createdAt: number;
+    updatedAt: number;
+    expiresAt?: number | null;
+}
+export interface SessionStorageOptions {
+    keyPrefix?: string;
+    ttl?: number;
+}
+export declare class SessionStorageProcessor {
+    private storage;
+    private keyPrefix;
+    private ttl?;
+    constructor(storage?: Storage<SessionStorageSnapshot>, options?: SessionStorageOptions);
+    setStorage(storage: Storage<SessionStorageSnapshot>): void;
+    getStorage(): Storage<SessionStorageSnapshot>;
+    load(sessionid: string): Promise<Record<string, any>>;
+    save(sessionid: string, data: Record<string, any>): Promise<void>;
+    delete(sessionid: string): Promise<void>;
+    clear(): Promise<void>;
+    private getKey;
+    private isExpired;
+}

package/dist/storage.js

@@ -0,0 +1,69 @@
+export class MemoryStorage {
+    data = new Map();
+    get(key) {
+        return this.data.get(key);
+    }
+    set(key, value) {
+        this.data.set(key, value);
+    }
+    delete(key) {
+        this.data.delete(key);
+    }
+    clear() {
+        this.data.clear();
+    }
+}
+export class SessionStorageProcessor {
+    storage;
+    keyPrefix;
+    ttl;
+    constructor(storage = new MemoryStorage(), options = {}) {
+        this.storage = storage;
+        this.keyPrefix = options.keyPrefix ?? 'session:';
+        this.ttl = options.ttl;
+    }
+    setStorage(storage) {
+        this.storage = storage;
+    }
+    getStorage() {
+        return this.storage;
+    }
+    async load(sessionid) {
+        const snapshot = await this.storage.get(this.getKey(sessionid));
+        if (!snapshot)
+            return {};
+        if (this.isExpired(snapshot)) {
+            await this.delete(sessionid);
+            return {};
+        }
+        return { ...(snapshot.data || {}) };
+    }
+    async save(sessionid, data) {
+        const key = this.getKey(sessionid);
+        const now = Date.now();
+        const current = await this.storage.get(key);
+        const createdAt = current && !this.isExpired(current) ? current.createdAt : now;
+        const snapshot = {
+            sessionid,
+            data: { ...(data || {}) },
+            createdAt,
+            updatedAt: now,
+            expiresAt: this.ttl ? now + this.ttl : null,
+        };
+        await this.storage.set(key, snapshot);
+    }
+    async delete(sessionid) {
+        await this.storage.delete(this.getKey(sessionid));
+    }
+    async clear() {
+        if (this.storage.clear) {
+            await this.storage.clear();
+        }
+    }
+    getKey(sessionid) {
+        return `${this.keyPrefix}${sessionid}`;
+    }
+    isExpired(snapshot) {
+        return typeof snapshot.expiresAt === 'number' && snapshot.expiresAt > 0 && snapshot.expiresAt <= Date.now();
+    }
+}

package/package.json

@@ -1,46 +1,48 @@
-{
-  "name": "@yumerijs/core",
-  "version": "3.0.0-alpha.3",
-  "description": "Core module for yumeri",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "yarn build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yumerijs/yumeri.git"
-  },
-  "keywords": [
-    "yumeri",
-    "API"
-  ],
-  "author": "WindyPear-Team,FireGuo",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/yumerijs/yumeri/issues"
-  },
-  "homepage": "https://github.com/yumerijs/yumeri#readme",
-  "devDependencies": {
-    "@types/formidable": "^3",
-    "@types/js-yaml": "^4.0.9",
-    "@types/mime-types": "^3",
-    "@types/node": "^22.13.10",
-    "@types/ws": "^8",
-    "typescript": "^5.8.2"
-  },
-  "dependencies": {
-    "chokidar": "^4.0.3",
-    "formidable": "^3.5.4",
-    "js-yaml": "^4.1.0",
-    "mime-types": "^3.0.1",
-    "picocolors": "^1.1.1",
-    "ws": "^8.18.3"
-  },
-  "packageManager": "yarn@4.9.1"
-}
+{
+  "name": "@yumerijs/core",
+  "version": "3.0.0-alpha.6",
+  "description": "Core module for yumeri",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "yarn build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yumerijs/yumeri.git"
+  },
+  "keywords": [
+    "yumeri",
+    "API"
+  ],
+  "author": "WindyPear-Team,FireGuo",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/yumerijs/yumeri/issues"
+  },
+  "homepage": "https://github.com/yumerijs/yumeri#readme",
+  "devDependencies": {
+    "@types/formidable": "^3",
+    "@types/js-yaml": "^4.0.9",
+    "@types/mime-types": "^3",
+    "@types/node": "^22.13.10",
+    "@types/semver": "^7",
+    "@types/ws": "^8",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "formidable": "^3.5.4",
+    "js-yaml": "^4.1.0",
+    "mime-types": "^3.0.1",
+    "picocolors": "^1.1.1",
+    "semver": "^7.8.4",
+    "ws": "^8.18.3"
+  },
+  "packageManager": "yarn@4.9.1"
+}

package/dist/command.d.ts

@@ -1,144 +0,0 @@
-/**
- * @time: 2025/08/14 09:48
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
-import { Core } from './core';
-import { Session } from './session';
-import { Middleware } from './middleware';
-/**
- * 命令处理函数接口
- * @param session 会话对象
- * @param args 其他参数
- * @returns Promise<any>
- */
-interface ActionFn {
-    (session: any, ...args: any[]): Promise<any>;
-}
-/**
- * 支持的协议类型
- * @enum {string}
- */
-export declare enum ProtocolType {
-    /** HTTP 协议 */
-    HTTP = "http",
-    /** WebSocket 协议 */
-    WS = "ws",
-    /** 所有协议 */
-    ALL = "all"
-}
-/**
- * 支持的 HTTP 方法
- * @enum {string}
- */
-export declare enum HttpMethod {
-    /** GET 请求方法 */
-    GET = "get",
-    /** POST 请求方法 */
-    POST = "post",
-    /** PUT 请求方法 */
-    PUT = "put",
-    /** DELETE 请求方法 */
-    DELETE = "delete",
-    /** PATCH 请求方法 */
-    PATCH = "patch",
-    /** HEAD 请求方法 */
-    HEAD = "head",
-    /** OPTIONS 请求方法 */
-    OPTIONS = "options",
-    /** 所有 HTTP 方法 */
-    ALL = "all"
-}
-/**
- * 命令类，用于注册和执行命令
- */
-/**
- * @deprecated Use Route instead.
- */
-export declare class Command {
-    /** 命令名称 */
-    name: string;
-    /** 命令处理函数 */
-    actionFn: ActionFn | null;
-    /** WebSocket 连接处理函数 */
-    connectFn: ActionFn | null;
-    /** WebSocket 关闭处理函数 */
-    closeFn: ActionFn | null;
-    /** 核心实例 */
-    core: Core;
-    /** 命令特定的中间件数组 */
-    middlewares: Middleware[];
-    /** 支持的协议类型，默认为所有协议 */
-    protocol: ProtocolType;
-    /** 支持的 HTTP 方法，默认为所有方法 */
-    httpMethods: HttpMethod[];
-    /**
-     * 创建命令实例
-     * @param core 核心实例
-     * @param name 命令名称
-     */
-    constructor(core: Core, name: string);
-    /**
-     * 注册命令处理函数
-     * @param fn 处理函数
-     * @returns this 支持链式调用
-     */
-    action(fn: ActionFn): this;
-    /**
-     * 注册 WebSocket 关闭处理函数
-     * @param fn 处理函数
-     * @returns this 支持链式调用
-     */
-    close(fn: ActionFn): this;
-    /**
-     * 注册 WebSocket 连接处理函数
-     * @param fn 处理函数
-     * @returns this 支持链式调用
-     */
-    connect(fn: ActionFn): this;
-    /**
-     * 设置命令支持的协议类型
-     * @param protocol 协议类型
-     * @returns this 支持链式调用
-     */
-    setProtocol(protocol: ProtocolType): this;
-    /**
-     * 设置命令支持的 HTTP 方法
-     * @param methods 单个 HTTP 方法或 HTTP 方法数组
-     * @returns this 支持链式调用
-     */
-    setHttpMethods(methods: HttpMethod | HttpMethod[]): this;
-    /**
-     * 检查命令是否支持指定的协议类型
-     * @param protocol 协议类型
-     * @returns 是否支持
-     */
-    supportsProtocol(protocol: ProtocolType): boolean;
-    /**
-     * 检查命令是否支持指定的 HTTP 方法
-     * @param method HTTP 方法
-     * @returns 是否支持
-     */
-    supportsHttpMethod(method: string): boolean;
-    /**
-     * 注册命令特定的中间件
-     * @param middleware 中间件函数
-     * @returns this 支持链式调用
-     */
-    use(middleware: Middleware): this;
-    /**
-     * 执行命令，包括中间件链和处理函数
-     * @param session 会话对象
-     * @param args 其他参数
-     * @returns 处理后的会话对象
-     */
-    execute(session: any, ...args: any[]): Promise<Session | null>;
-    /**
-     * 执行命令处理函数（不包含中间件）
-     * @param session 会话对象
-     * @param args 其他参数
-     * @returns 处理后的会话对象
-     */
-    executeHandler(session: any, ...args: any[]): Promise<Session | null>;
-}
-export {};

package/dist/command.js

@@ -1,181 +0,0 @@
-"use strict";
-/**
- * @time: 2025/08/14 09:48
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Command = exports.HttpMethod = exports.ProtocolType = void 0;
-/**
- * 支持的协议类型
- * @enum {string}
- */
-var ProtocolType;
-(function (ProtocolType) {
-    /** HTTP 协议 */
-    ProtocolType["HTTP"] = "http";
-    /** WebSocket 协议 */
-    ProtocolType["WS"] = "ws";
-    /** 所有协议 */
-    ProtocolType["ALL"] = "all";
-})(ProtocolType || (exports.ProtocolType = ProtocolType = {}));
-/**
- * 支持的 HTTP 方法
- * @enum {string}
- */
-var HttpMethod;
-(function (HttpMethod) {
-    /** GET 请求方法 */
-    HttpMethod["GET"] = "get";
-    /** POST 请求方法 */
-    HttpMethod["POST"] = "post";
-    /** PUT 请求方法 */
-    HttpMethod["PUT"] = "put";
-    /** DELETE 请求方法 */
-    HttpMethod["DELETE"] = "delete";
-    /** PATCH 请求方法 */
-    HttpMethod["PATCH"] = "patch";
-    /** HEAD 请求方法 */
-    HttpMethod["HEAD"] = "head";
-    /** OPTIONS 请求方法 */
-    HttpMethod["OPTIONS"] = "options";
-    /** 所有 HTTP 方法 */
-    HttpMethod["ALL"] = "all";
-})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
-/**
- * 命令类，用于注册和执行命令
- */
-/**
- * @deprecated Use Route instead.
- */
-class Command {
-    /** 命令名称 */
-    name;
-    /** 命令处理函数 */
-    actionFn = null;
-    /** WebSocket 连接处理函数 */
-    connectFn = null;
-    /** WebSocket 关闭处理函数 */
-    closeFn = null;
-    /** 核心实例 */
-    core;
-    /** 命令特定的中间件数组 */
-    middlewares = [];
-    /** 支持的协议类型，默认为所有协议 */
-    protocol = ProtocolType.ALL;
-    /** 支持的 HTTP 方法，默认为所有方法 */
-    httpMethods = [HttpMethod.ALL];
-    /**
-     * 创建命令实例
-     * @param core 核心实例
-     * @param name 命令名称
-     */
-    constructor(core, name) {
-        this.core = core;
-        this.name = name;
-    }
-    /**
-     * 注册命令处理函数
-     * @param fn 处理函数
-     * @returns this 支持链式调用
-     */
-    action(fn) {
-        this.actionFn = fn;
-        return this;
-    }
-    /**
-     * 注册 WebSocket 关闭处理函数
-     * @param fn 处理函数
-     * @returns this 支持链式调用
-     */
-    close(fn) {
-        this.closeFn = fn;
-        return this;
-    }
-    /**
-     * 注册 WebSocket 连接处理函数
-     * @param fn 处理函数
-     * @returns this 支持链式调用
-     */
-    connect(fn) {
-        this.connectFn = fn;
-        return this;
-    }
-    /**
-     * 设置命令支持的协议类型
-     * @param protocol 协议类型
-     * @returns this 支持链式调用
-     */
-    setProtocol(protocol) {
-        this.protocol = protocol;
-        return this;
-    }
-    /**
-     * 设置命令支持的 HTTP 方法
-     * @param methods 单个 HTTP 方法或 HTTP 方法数组
-     * @returns this 支持链式调用
-     */
-    setHttpMethods(methods) {
-        if (Array.isArray(methods)) {
-            this.httpMethods = methods;
-        }
-        else {
-            this.httpMethods = [methods];
-        }
-        return this;
-    }
-    /**
-     * 检查命令是否支持指定的协议类型
-     * @param protocol 协议类型
-     * @returns 是否支持
-     */
-    supportsProtocol(protocol) {
-        return this.protocol === ProtocolType.ALL || this.protocol === protocol;
-    }
-    /**
-     * 检查命令是否支持指定的 HTTP 方法
-     * @param method HTTP 方法
-     * @returns 是否支持
-     */
-    supportsHttpMethod(method) {
-        const lowerMethod = method.toLowerCase();
-        return this.httpMethods.includes(HttpMethod.ALL) ||
-            this.httpMethods.some(m => m.toLowerCase() === lowerMethod);
-    }
-    /**
-     * 注册命令特定的中间件
-     * @param middleware 中间件函数
-     * @returns this 支持链式调用
-     */
-    use(middleware) {
-        this.middlewares.push(middleware);
-        return this;
-    }
-    /**
-     * 执行命令，包括中间件链和处理函数
-     * @param session 会话对象
-     * @param args 其他参数
-     * @returns 处理后的会话对象
-     */
-    async execute(session, ...args) {
-        if (this.actionFn) {
-            await this.actionFn(session, ...args);
-            return session;
-        }
-        return null;
-    }
-    /**
-     * 执行命令处理函数（不包含中间件）
-     * @param session 会话对象
-     * @param args 其他参数
-     * @returns 处理后的会话对象
-     */
-    async executeHandler(session, ...args) {
-        if (this.actionFn) {
-            await this.actionFn(session, ...args);
-            return session;
-        }
-        return null;
-    }
-}
-exports.Command = Command;

package/dist/platform.d.ts

@@ -1,164 +0,0 @@
-/**
- * @time: 2025/08/14 09:48
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
-import { Session } from './session';
-import { Core } from './core';
-import { ConfigSchema } from './config';
-/**
- * Platform 基类
- * 作为平台接入的基础类，提供标准化的接口和通用能力
- * 各平台实现类需继承此类并实现所有抽象方法
- */
-export declare abstract class Platform {
-    protected status: 'idle' | 'starting' | 'running' | 'stopping' | 'error';
-    protected errorMessage: string | null;
-    protected config: Record<string, any>;
-    protected instanceId: string;
-    protected eventListeners: Record<string, Array<(...args: any[]) => void>>;
-    /**
-     * 构造函数
-     * @param config 平台配置
-     */
-    constructor(config?: Record<string, any>);
-    /**
-     * 生成平台实例ID
-     * @returns 实例ID字符串
-     */
-    protected generateInstanceId(): string;
-    /**
-     * 向客户端发送消息
-     * @param session 会话对象
-     * @param data 要发送的数据
-     * @returns 发送结果
-     */
-    abstract sendMessage(session: Session, data: any): any;
-    /**
-     * 结束会话
-     * @param session 会话对象
-     * @param message 结束消息
-     * @returns 结束结果
-     */
-    abstract terminationSession(session: Session, message: any): any;
-    /**
-     * 获取平台名称
-     * @returns 平台名称
-     */
-    abstract getPlatformName(): string;
-    /**
-     * 获取平台版本号
-     * @returns 平台版本号
-     */
-    abstract getPlatformVersionCode(): string;
-    /**
-     * 获取平台ID
-     * @returns 平台ID
-     */
-    abstract getPlatformId(): string;
-    /**
-     * 获取平台状态
-     * @returns 平台状态对象
-     */
-    abstract getPlatformStatus(): Record<string, any>;
-    /**
-     * 启动平台
-     * @param core Core实例
-     * @returns 启动结果
-     */
-    abstract startPlatform(core?: Core): Promise<any>;
-    /**
-     * 停止平台
-     * @returns 停止结果
-     */
-    abstract stopPlatform(): Promise<void>;
-    /**
-     * 重启平台
-     * @param core Core实例
-     * @returns 重启结果
-     */
-    restartPlatform(core?: Core): Promise<any>;
-    /**
-     * 设置平台配置
-     * @param key 配置键
-     * @param value 配置值
-     */
-    setConfig(key: string, value: any): void;
-    /**
-     * 获取平台配置
-     * @param key 配置键
-     * @param defaultValue 默认值
-     * @returns 配置值
-     */
-    getConfig<T>(key: string, defaultValue?: T): T;
-    /**
-     * 获取平台实例ID
-     * @returns 实例ID
-     */
-    getInstanceId(): string;
-    /**
-     * 获取当前平台状态
-     * @returns 状态字符串
-     */
-    getStatus(): 'idle' | 'starting' | 'running' | 'stopping' | 'error';
-    /**
-     * 获取错误信息
-     * @returns 错误信息
-     */
-    getErrorMessage(): string | null;
-    /**
-     * 添加平台事件监听器
-     * @param event 事件名称
-     * @param listener 监听器函数
-     */
-    on(event: string, listener: (...args: any[]) => void): void;
-    /**
-     * 移除平台事件监听器
-     * @param event 事件名称
-     * @param listener 监听器函数
-     */
-    off(event: string, listener: (...args: any[]) => void): void;
-    /**
-     * 触发平台事件
-     * @param event 事件名称
-     * @param args 事件参数
-     */
-    protected emit(event: string, ...args: any[]): void;
-    /**
-     * 创建会话
-     * @param ip 客户端IP
-     * @param cookie Cookie对象
-     * @param query 查询参数
-     * @returns 会话对象
-     */
-    createSession(ip: string, cookie: Record<string, string>, query?: Record<string, string>): Session;
-    /**
-     * 处理会话数据
-     * @param session 会话对象
-     * @param data 会话数据
-     * @returns 处理结果
-     */
-    processSessionData(session: Session, data: any): any;
-    /**
-     * 验证会话
-     * @param session 会话对象
-     * @returns 验证结果
-     */
-    validateSession(session: Session): boolean;
-    /**
-     * 获取平台支持的MIME类型
-     * @returns MIME类型数组
-     */
-    getSupportedMimeTypes(): string[];
-    /**
-     * 获取平台元数据
-     * @returns 平台元数据
-     */
-    getMetadata(): Record<string, any>;
-    /**
-     * 获取平台配置模式
-     * 子类可以覆盖此方法提供自定义配置模式
-     * @returns 配置模式对象
-     */
-    static getConfigSchema(): Record<string, ConfigSchema>;
-}

package/dist/platform.js

@@ -1,199 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Platform = void 0;
-/**
- * @time: 2025/08/14 09:48
- * @author: FireGuo
- * WindyPear-Team All right reserved
- **/
-const session_1 = require("./session");
-/**
- * Platform 基类
- * 作为平台接入的基础类，提供标准化的接口和通用能力
- * 各平台实现类需继承此类并实现所有抽象方法
- */
-class Platform {
-    // 平台状态
-    status = 'idle';
-    // 平台错误信息
-    errorMessage = null;
-    // 平台配置
-    config = {};
-    // 平台实例ID
-    instanceId = '';
-    // 平台事件监听器
-    eventListeners = {};
-    /**
-     * 构造函数
-     * @param config 平台配置
-     */
-    constructor(config) {
-        if (config) {
-            this.config = { ...config };
-        }
-        this.instanceId = this.generateInstanceId();
-    }
-    /**
-     * 生成平台实例ID
-     * @returns 实例ID字符串
-     */
-    generateInstanceId() {
-        return `${this.getPlatformId()}-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
-    }
-    /**
-     * 重启平台
-     * @param core Core实例
-     * @returns 重启结果
-     */
-    async restartPlatform(core) {
-        await this.stopPlatform();
-        return this.startPlatform(core);
-    }
-    /**
-     * 设置平台配置
-     * @param key 配置键
-     * @param value 配置值
-     */
-    setConfig(key, value) {
-        this.config[key] = value;
-    }
-    /**
-     * 获取平台配置
-     * @param key 配置键
-     * @param defaultValue 默认值
-     * @returns 配置值
-     */
-    getConfig(key, defaultValue) {
-        return (this.config[key] !== undefined) ? this.config[key] : defaultValue;
-    }
-    /**
-     * 获取平台实例ID
-     * @returns 实例ID
-     */
-    getInstanceId() {
-        return this.instanceId;
-    }
-    /**
-     * 获取当前平台状态
-     * @returns 状态字符串
-     */
-    getStatus() {
-        return this.status;
-    }
-    /**
-     * 获取错误信息
-     * @returns 错误信息
-     */
-    getErrorMessage() {
-        return this.errorMessage;
-    }
-    /**
-     * 添加平台事件监听器
-     * @param event 事件名称
-     * @param listener 监听器函数
-     */
-    on(event, listener) {
-        if (!this.eventListeners[event]) {
-            this.eventListeners[event] = [];
-        }
-        this.eventListeners[event].push(listener);
-    }
-    /**
-     * 移除平台事件监听器
-     * @param event 事件名称
-     * @param listener 监听器函数
-     */
-    off(event, listener) {
-        if (!this.eventListeners[event]) {
-            return;
-        }
-        this.eventListeners[event] = this.eventListeners[event].filter(l => l !== listener);
-    }
-    /**
-     * 触发平台事件
-     * @param event 事件名称
-     * @param args 事件参数
-     */
-    emit(event, ...args) {
-        if (!this.eventListeners[event]) {
-            return;
-        }
-        for (const listener of this.eventListeners[event]) {
-            try {
-                listener(...args);
-            }
-            catch (error) {
-                console.error(`Error in platform event listener for "${event}":`, error);
-            }
-        }
-    }
-    /**
-     * 创建会话
-     * @param ip 客户端IP
-     * @param cookie Cookie对象
-     * @param query 查询参数
-     * @returns 会话对象
-     */
-    createSession(ip, cookie, query) {
-        return new session_1.Session(ip, cookie, this, query);
-    }
-    /**
-     * 处理会话数据
-     * @param session 会话对象
-     * @param data 会话数据
-     * @returns 处理结果
-     */
-    processSessionData(session, data) {
-        // 默认实现，子类可覆盖
-        return data;
-    }
-    /**
-     * 验证会话
-     * @param session 会话对象
-     * @returns 验证结果
-     */
-    validateSession(session) {
-        // 默认实现，子类可覆盖
-        return true;
-    }
-    /**
-     * 获取平台支持的MIME类型
-     * @returns MIME类型数组
-     */
-    getSupportedMimeTypes() {
-        // 默认实现，子类可覆盖
-        return [
-            'text/plain',
-            'text/html',
-            'application/json',
-            'application/xml',
-            'image/png',
-            'image/jpeg',
-            'application/pdf'
-        ];
-    }
-    /**
-     * 获取平台元数据
-     * @returns 平台元数据
-     */
-    getMetadata() {
-        return {
-            id: this.getPlatformId(),
-            name: this.getPlatformName(),
-            version: this.getPlatformVersionCode(),
-            status: this.getStatus(),
-            instanceId: this.getInstanceId(),
-            supportedMimeTypes: this.getSupportedMimeTypes(),
-            ...this.getPlatformStatus()
-        };
-    }
-    /**
-     * 获取平台配置模式
-     * 子类可以覆盖此方法提供自定义配置模式
-     * @returns 配置模式对象
-     */
-    static getConfigSchema() {
-        return {};
-    }
-}
-exports.Platform = Platform;