alemonjs 2.1.86 → 2.1.88

package/bin/README.md

@@ -100,6 +100,27 @@ alemonc version update
 
 读取本地 `package.json`，查找所有 `alemonjs` 和 `@alemonjs/*` 依赖，检查并更新到最新版本。
 
+#### publish — 智能发布当前包
+
+```sh
+alemonc publish
+alemonc publish patch
+alemonc publish --dry-run
+```
+
+行为说明：
+
+- 默认会查询 git tag 历史作为版本基线
+- 不传参数时：
+  - 如果本地版本高于最新 tag，直接发布本地版本
+  - 否则自动按最新 tag `patch +1`
+- 传 `patch/minor/major/prepatch/preminor/premajor/prerelease` 时会自动递增
+- 传具体版本号时会直接以该版本发布
+- 默认先执行 `npm run build`
+- 文件选择规则直接复用 npm 机制，也就是 `package.json.files`、`.npmignore`、`.gitignore` 和 npm 默认规则
+- 最终把产物提交到 git `release` 分支，并推送对应 tag
+- 默认要求 git 工作区干净，发布成功后会自动提交源码中的 `package.json` 版本变更
+
 ---
 
 ### 项目诊断

package/bin/alemonc.js

@@ -6,6 +6,7 @@ import { versionUpdate } from './versionUpdate.js';
 import { info } from './info.js';
 import { platformAdd, platformRemove, platformList } from './platform.js';
 import { login } from './login.js';
+import { publish } from './publish.js';
 import { Command } from 'commander';
 const program = new Command();
 
@@ -74,6 +75,24 @@ program
     versionUpdate();
   });
 
+program
+  .command('publish [release]')
+  .description('智能发布当前包到 git release 仓库，支持 patch/minor/major 或直接指定版本号')
+  .option('--tag <tag>', 'git 标签通道，默认 stable 为 latest，预发布为 next')
+  .option('--preid <preid>', '预发布标识，默认 beta', 'beta')
+  .option('--branch <branch>', '发布目标分支，默认 release')
+  .option('--dry-run', '只执行检查和打包，不真正发布')
+  .option('--skip-build', '跳过构建')
+  .option('--no-git-checks', '跳过 git 干净工作区检查及发布后自动提交源码版本')
+  .action(async (release, options) => {
+    try {
+      await publish(release, options);
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
 program
   .command('info')
   .description('输出项目诊断信息')
@@ -118,4 +137,4 @@ program
     program.help();
   });
 
-program.parse(process.argv);
+program.parseAsync(process.argv);

package/bin/publish.js

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { join } from 'path';
+import os from 'os';
+import { execSync, spawnSync } from 'child_process';
+
+const RELEASE_TYPES = new Set(['patch', 'minor', 'major', 'prepatch', 'preminor', 'premajor', 'prerelease']);
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+
+function readPackageJson() {
+  const pkgPath = join(process.cwd(), 'package.json');
+
+  if (!fs.existsSync(pkgPath)) {
+    throw new Error('未找到 package.json');
+  }
+
+  return {
+    pkgPath,
+    pkg: JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+  };
+}
+
+function runCommand(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    shell: false,
+    ...options
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`命令执行失败: ${command} ${args.join(' ')}`);
+  }
+}
+
+function getCommandOutput(command) {
+  return execSync(command, {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  }).trim();
+}
+
+function hasCommand(command) {
+  const result = spawnSync(command, ['--version'], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+
+  return !result.error;
+}
+
+function isGitRepo() {
+  try {
+    return getCommandOutput('git rev-parse --is-inside-work-tree') === 'true';
+  } catch {
+    return false;
+  }
+}
+
+function ensureCleanGit() {
+  const status = getCommandOutput('git status --porcelain');
+  if (status) {
+    throw new Error('工作区存在未提交改动，请先提交或使用 --no-git-checks 跳过检查');
+  }
+}
+
+function parseVersion(version) {
+  const matched = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+  if (!matched) {
+    throw new Error(`非法版本号: ${version}`);
+  }
+
+  return {
+    major: Number(matched[1]),
+    minor: Number(matched[2]),
+    patch: Number(matched[3]),
+    prerelease: matched[4] ?? null
+  };
+}
+
+function compareVersions(a, b) {
+  const av = parseVersion(a);
+  const bv = parseVersion(b);
+
+  for (const key of ['major', 'minor', 'patch']) {
+    if (av[key] > bv[key]) return 1;
+    if (av[key] < bv[key]) return -1;
+  }
+
+  if (av.prerelease === bv.prerelease) return 0;
+  if (av.prerelease === null) return 1;
+  if (bv.prerelease === null) return -1;
+
+  return av.prerelease.localeCompare(bv.prerelease);
+}
+
+function incrementVersion(baseVersion, releaseType, preid = 'beta') {
+  const parsed = parseVersion(baseVersion);
+
+  if (releaseType === 'patch') {
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+  }
+
+  if (releaseType === 'minor') {
+    return `${parsed.major}.${parsed.minor + 1}.0`;
+  }
+
+  if (releaseType === 'major') {
+    return `${parsed.major + 1}.0.0`;
+  }
+
+  if (releaseType === 'prepatch') {
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}-${preid}.0`;
+  }
+
+  if (releaseType === 'preminor') {
+    return `${parsed.major}.${parsed.minor + 1}.0-${preid}.0`;
+  }
+
+  if (releaseType === 'premajor') {
+    return `${parsed.major + 1}.0.0-${preid}.0`;
+  }
+
+  if (releaseType === 'prerelease') {
+    if (parsed.prerelease) {
+      const next = parsed.prerelease.match(/^(.*?)(\d+)$/);
+      if (next) {
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}-${next[1]}${Number(next[2]) + 1}`;
+      }
+
+      return `${parsed.major}.${parsed.minor}.${parsed.patch}-${parsed.prerelease}.1`;
+    }
+
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}-${preid}.0`;
+  }
+
+  throw new Error(`不支持的发布类型: ${releaseType}`);
+}
+
+function resolveTargetVersion(localVersion, remoteVersion, release, preid) {
+  if (!release) {
+    if (!remoteVersion) {
+      return localVersion;
+    }
+
+    if (compareVersions(localVersion, remoteVersion) > 0) {
+      return localVersion;
+    }
+
+    return incrementVersion(remoteVersion, 'patch', preid);
+  }
+
+  if (RELEASE_TYPES.has(release)) {
+    const base = remoteVersion && compareVersions(remoteVersion, localVersion) > 0 ? remoteVersion : localVersion;
+    return incrementVersion(base, release, preid);
+  }
+
+  if (SEMVER_RE.test(release)) {
+    return release;
+  }
+
+  throw new Error(`无法识别的发布参数: ${release}`);
+}
+
+function updateVersion(pkgPath, pkg, version) {
+  pkg.version = version;
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}
+
+function getPackResult(cwd = process.cwd()) {
+  const output = execSync('npm pack --json --dry-run', {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+    maxBuffer: 20 * 1024 * 1024
+  }).trim();
+
+  const result = JSON.parse(output);
+  if (!Array.isArray(result) || result.length === 0 || !Array.isArray(result[0]?.files)) {
+    throw new Error('无法解析 npm pack 文件清单');
+  }
+
+  return result[0];
+}
+
+function copyPublishFiles(files) {
+  const stageDir = fs.mkdtempSync(join(os.tmpdir(), 'alemon-publish-'));
+
+  for (const item of files) {
+    const relativePath = item.path;
+    const sourcePath = join(process.cwd(), relativePath);
+    const targetPath = join(stageDir, relativePath);
+
+    fs.mkdirSync(join(targetPath, '..'), { recursive: true });
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+
+  return stageDir;
+}
+
+function materializePublishDir(sourceDir, files) {
+  const publishDir = fs.mkdtempSync(join(os.tmpdir(), 'alemon-release-'));
+
+  for (const item of files) {
+    const relativePath = item.path;
+    const sourcePath = join(sourceDir, relativePath);
+    const targetPath = join(publishDir, relativePath);
+
+    fs.mkdirSync(join(targetPath, '..'), { recursive: true });
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+
+  return publishDir;
+}
+
+function removeDirContents(dirPath) {
+  for (const entry of fs.readdirSync(dirPath)) {
+    if (entry === '.git') {
+      continue;
+    }
+
+    fs.rmSync(join(dirPath, entry), { recursive: true, force: true });
+  }
+}
+
+function copyDirContents(sourceDir, targetDir) {
+  for (const entry of fs.readdirSync(sourceDir)) {
+    fs.cpSync(join(sourceDir, entry), join(targetDir, entry), { recursive: true });
+  }
+}
+
+function ensureGitRepo() {
+  if (!isGitRepo()) {
+    throw new Error('当前目录不是 git 仓库，无法执行 git 发布');
+  }
+}
+
+function remoteBranchExists(branch) {
+  const result = spawnSync('git', ['ls-remote', '--exit-code', '--heads', 'origin', branch], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+
+  return result.status === 0;
+}
+
+function localBranchExists(branch) {
+  const result = spawnSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+
+  return result.status === 0;
+}
+
+function createReleaseWorktree(branch) {
+  const worktreeDir = fs.mkdtempSync(join(os.tmpdir(), 'alemon-worktree-'));
+
+  if (remoteBranchExists(branch)) {
+    runCommand('git', ['fetch', 'origin', branch]);
+    runCommand('git', ['worktree', 'add', '-B', branch, worktreeDir, `origin/${branch}`]);
+  } else if (localBranchExists(branch)) {
+    runCommand('git', ['worktree', 'add', worktreeDir, branch]);
+  } else {
+    runCommand('git', ['worktree', 'add', '-b', branch, worktreeDir]);
+  }
+
+  return worktreeDir;
+}
+
+function cleanupWorktree(worktreeDir) {
+  if (!worktreeDir) {
+    return;
+  }
+
+  spawnSync('git', ['worktree', 'remove', '--force', worktreeDir], {
+    cwd: process.cwd(),
+    stdio: 'ignore'
+  });
+  fs.rmSync(worktreeDir, { recursive: true, force: true });
+}
+
+export async function publish(release, options = {}) {
+  if (!hasCommand('git')) {
+    throw new Error('未找到 git，请先安装 git');
+  }
+
+  if (!hasCommand('npm')) {
+    throw new Error('未找到 npm，请先安装 Node.js/npm');
+  }
+
+  const { pkgPath, pkg } = readPackageJson();
+  const packageName = pkg.name;
+  const localVersion = String(pkg.version || '').trim();
+
+  if (!packageName) {
+    throw new Error('package.json 缺少 name');
+  }
+
+  if (!SEMVER_RE.test(localVersion)) {
+    throw new Error(`当前 package.json 版本号非法: ${localVersion}`);
+  }
+
+  console.log(`发布包: ${packageName}`);
+  console.log(`本地版本: ${localVersion}`);
+
+  ensureGitRepo();
+
+  const releaseBranch = options.branch || 'release';
+  const remoteVersion = getCommandOutput(`git tag --list "v*" --sort=-v:refname | head -n 1`).replace(/^v/, '');
+  if (remoteVersion) {
+    console.log(`最新 git tag: v${remoteVersion}`);
+  } else {
+    console.log('最新 git tag: 无，将按首次发布处理');
+  }
+
+  if (options.gitChecks !== false && isGitRepo()) {
+    ensureCleanGit();
+  }
+
+  const targetVersion = resolveTargetVersion(localVersion, remoteVersion, release, options.preid);
+  const distTag = options.tag || (targetVersion.includes('-') ? 'next' : 'latest');
+  const gitTagName = distTag === 'latest' ? `v${targetVersion}` : `v${targetVersion}-${distTag}`;
+  console.log(`目标版本: ${targetVersion}`);
+  console.log(`发布分支: ${releaseBranch}`);
+  console.log(`git 标签: ${gitTagName}`);
+
+  if (targetVersion !== localVersion) {
+    updateVersion(pkgPath, pkg, targetVersion);
+    console.log(`已更新 package.json 版本: ${localVersion} -> ${targetVersion}`);
+  }
+
+  let stageDir = null;
+  let publishDir = null;
+  let worktreeDir = null;
+  try {
+    if (!options.skipBuild) {
+      if (pkg.scripts?.build) {
+        console.log('执行构建...');
+        runCommand('npm', ['run', 'build']);
+      } else {
+        console.log('未定义 build 脚本，跳过构建');
+      }
+    } else {
+      console.log('已跳过构建');
+    }
+
+    const packResult = getPackResult();
+    stageDir = copyPublishFiles(packResult.files);
+
+    const filteredPackResult = getPackResult(stageDir);
+    publishDir = materializePublishDir(stageDir, filteredPackResult.files);
+
+    console.log(`发布文件数: ${filteredPackResult.files.length}`);
+
+    if (options.dryRun) {
+      console.log('dry-run 模式，不会真正推送到 git');
+      return;
+    }
+
+    console.log('准备 release worktree...');
+    worktreeDir = createReleaseWorktree(releaseBranch);
+    removeDirContents(worktreeDir);
+    copyDirContents(publishDir, worktreeDir);
+
+    runCommand('git', ['-C', worktreeDir, 'add', '-A']);
+    const hasChanges = spawnSync('git', ['-C', worktreeDir, 'diff', '--cached', '--quiet']).status !== 0;
+    if (!hasChanges) {
+      console.log('release 分支无文件变化，跳过提交');
+    } else {
+      runCommand('git', ['-C', worktreeDir, 'commit', '-m', `release: ${gitTagName}`]);
+      runCommand('git', ['-C', worktreeDir, 'push', 'origin', `HEAD:${releaseBranch}`]);
+      console.log(`已推送到分支: ${releaseBranch}`);
+    }
+
+    runCommand('git', ['tag', '-f', gitTagName]);
+    runCommand('git', ['push', 'origin', gitTagName, '--force']);
+    console.log(`发布完成: ${packageName}@${targetVersion}`);
+  } catch (error) {
+    if (targetVersion !== localVersion) {
+      updateVersion(pkgPath, pkg, localVersion);
+      console.log(`已回滚 package.json 版本到 ${localVersion}`);
+    }
+    throw error;
+  } finally {
+    if (stageDir) {
+      fs.rmSync(stageDir, { recursive: true, force: true });
+    }
+    if (publishDir) {
+      fs.rmSync(publishDir, { recursive: true, force: true });
+    }
+    cleanupWorktree(worktreeDir);
+  }
+
+  if (options.gitChecks !== false && isGitRepo()) {
+    runCommand('git', ['add', 'package.json']);
+    runCommand('git', ['commit', '-m', `release: ${gitTagName}`]);
+    console.log(`已记录源码版本变更: ${gitTagName}`);
+  }
+}

package/lib/application/define-router.js

@@ -21,5 +21,6 @@ const defineRouter = routes => {
         current: routes
     };
 };
+global.defineRouter = defineRouter;
 
 export { defineRouter, lazy, runHandler };

package/lib/application/runtime/client-runtime.d.ts

@@ -1 +1,9 @@
-export {};
+import '../define-children.js';
+import '../define-response.js';
+import '../define-middleware.js';
+import '../define-router.js';
+import '../format/message-api.js';
+import './event-response.js';
+import './event-middleware.js';
+import './event-utils.js';
+import './event-group.js';

package/lib/application/runtime/client-runtime.js

@@ -1,3 +1,12 @@
+import '../define-children.js';
+import '../define-response.js';
+import '../define-middleware.js';
+import '../define-router.js';
+import '../format/message-api.js';
+import './event-response.js';
+import './event-middleware.js';
+import './event-utils.js';
+import './event-group.js';
 import { cbpClient } from './cbp/connects/client.js';
 import 'flatted';
 import 'fs';

package/lib/application/runtime/http/routers/router.js

@@ -177,19 +177,19 @@ const dispatchAppKoaRouters = async (ctx, appName) => {
                 const beforeRouterPath = ctx.routerPath;
                 let fallthrough = false;
                 await rewriteCtxPath(ctx, rewrittenPath, async () => {
-                    await koaRouter.routes()(ctx, () => {
+                    await koaRouter.routes()(ctx, async () => {
                         fallthrough = true;
                     });
                 });
                 const afterMatched = Array.isArray(matchedContext.matched) ? matchedContext.matched.length : 0;
                 const afterMatchedRoute = ctx._matchedRoute;
                 const afterRouterPath = ctx.routerPath;
-                const handled = afterMatched > beforeMatched
-                    || afterMatchedRoute !== beforeMatchedRoute
-                    || afterRouterPath !== beforeRouterPath
-                    || ctx.status !== beforeStatus
-                    || ctx.body !== beforeBody
-                    || !fallthrough;
+                const handled = afterMatched > beforeMatched ||
+                    afterMatchedRoute !== beforeMatchedRoute ||
+                    afterRouterPath !== beforeRouterPath ||
+                    ctx.status !== beforeStatus ||
+                    ctx.body !== beforeBody ||
+                    !fallthrough;
                 if (!handled) {
                     continue;
                 }

package/lib/application/runtime/load-modules/loadChild.js

@@ -1,5 +1,5 @@
 import { dirname, join } from 'path';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { showErrorModule, getRecursiveDirFiles, createEventName } from '../../../common/utils.js';
 import { registerRuntimeApp, updateRuntimeAppStatus, ChildrenApp, clearRuntimeAppKoaRouters, setRuntimeAppKoaRouters, updateRuntimeAppCapabilities } from '../store.js';
 import { registerExpose } from '../../expose.js';
@@ -11,6 +11,50 @@ import { dispatchRuntimeStatusChange, dispatchAppDispose, dispatchAppReady } fro
 const initRequire = () => { };
 initRequire.resolve = () => '';
 const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
+const resolvePackageDir = (appName) => {
+    const resolveWithPaths = require$1.resolve;
+    const candidatePaths = resolveWithPaths?.paths?.(appName) ?? [];
+    for (const basePath of candidatePaths) {
+        const packageDir = join(basePath, appName);
+        if (existsSync(join(packageDir, 'package.json'))) {
+            return packageDir;
+        }
+    }
+    return null;
+};
+const resolvePackageEntryFromPackageJson = (packageDir) => {
+    const packageJsonPath = join(packageDir, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8')) ?? {};
+        const exportsField = pkg?.exports;
+        let entry = null;
+        if (typeof exportsField === 'string') {
+            entry = exportsField;
+        }
+        else if (exportsField && typeof exportsField === 'object') {
+            const rootExport = exportsField['.'];
+            if (typeof rootExport === 'string') {
+                entry = rootExport;
+            }
+            else if (rootExport && typeof rootExport === 'object') {
+                entry = rootExport.import ?? rootExport.default ?? rootExport.require ?? null;
+            }
+        }
+        if (!entry) {
+            entry = pkg?.module ?? pkg?.main ?? 'index.js';
+        }
+        if (typeof entry !== 'string' || !entry.trim()) {
+            return null;
+        }
+        return join(packageDir, entry);
+    }
+    catch {
+        return null;
+    }
+};
 const resolvePackageRoot = (startDir) => {
     let currentDir = startDir;
     while (currentDir && currentDir !== dirname(currentDir)) {
@@ -253,7 +297,14 @@ const loadChildrenFile = (appName) => {
         return;
     }
     try {
-        const mainPath = require$1.resolve(appName);
+        let mainPath = require$1.resolve(appName);
+        if (!existsSync(mainPath)) {
+            const packageDir = resolvePackageDir(appName);
+            const fallbackMainPath = packageDir ? resolvePackageEntryFromPackageJson(packageDir) : null;
+            if (fallbackMainPath) {
+                mainPath = fallbackMainPath;
+            }
+        }
         if (!existsSync(mainPath)) {
             updateRuntimeAppStatus(appName, 'failed', new Error('The main file does not exist,' + mainPath));
             logger.error({
@@ -274,6 +325,20 @@ const loadChildrenFile = (appName) => {
         void loadChildren(mainPath, appName);
     }
     catch (e) {
+        const packageDir = resolvePackageDir(appName);
+        const fallbackMainPath = packageDir ? resolvePackageEntryFromPackageJson(packageDir) : null;
+        if (fallbackMainPath && existsSync(fallbackMainPath)) {
+            registerRuntimeApp({
+                name: appName,
+                kind: 'plugin',
+                enabled: true,
+                status: 'discovered',
+                rootDir: dirname(fallbackMainPath),
+                mainPath: fallbackMainPath
+            });
+            void loadChildren(fallbackMainPath, appName);
+            return;
+        }
         updateRuntimeAppStatus(appName, 'failed', e);
         showErrorModule(e);
     }

package/lib/application/runtime/store.js

@@ -107,8 +107,8 @@ const registerRuntimeApp = (record) => {
         createdAt: current?.createdAt ?? now,
         updatedAt: now
     };
-    if (current?.status !== record.status) {
-        logRuntimeAppStatus(record.status === 'failed' ? 'warn' : 'debug', runtimeApps[record.name]);
+    if (current?.status !== record.status && process.env.NODE_ENV === 'development') {
+        logRuntimeAppStatus('debug', runtimeApps[record.name]);
     }
     return runtimeApps[record.name];
 };

package/lib/global.d.ts

@@ -1,4 +1,4 @@
-import type { DefineChildrenFunc, OnResponseReversalFunc, OnMiddlewareReversalFunc, OnSelectsFunc, OnDataFormatFunc, OnResponseReversalFuncBack, OnGroupFunc, OnMiddlewareReversalFuncBack, DefineResponseFunc, defineMiddlewareFunc, StoreChildrenApp, StateSubscribeMap, SubscribeKeysMap, LoggerUtils, ResponseState, StartOptions } from './types';
+import type { DefineChildrenFunc, OnResponseReversalFunc, OnMiddlewareReversalFunc, OnSelectsFunc, OnDataFormatFunc, OnResponseReversalFuncBack, OnGroupFunc, OnMiddlewareReversalFuncBack, DefineResponseFunc, defineMiddlewareFunc, DefineRouterFunc, StoreChildrenApp, StateSubscribeMap, SubscribeKeysMap, LoggerUtils, ResponseState, StartOptions } from './types';
 import { type Server } from 'ws';
 import type WebSocket from 'ws';
 import type { IncomingMessage } from 'http';
@@ -7,6 +7,9 @@ import type { RuntimeAppRecord } from './application/runtime/store.js';
 declare global {
     var __config: any;
     var __options: StartOptions;
+    var __sandbox: boolean | undefined;
+    var __client_loaded: boolean | undefined;
+    var __publicIp: string | undefined;
     var logger: LoggerUtils;
     var alemonjsCore: {
         storeState: ResponseState;
@@ -25,6 +28,7 @@ declare global {
     var chatbotServer: Server<typeof WebSocket, typeof IncomingMessage>;
     var chatbotPlatform: WebSocket;
     var chatbotClient: WebSocket;
+    var testoneClient: WebSocket | undefined;
     var onResponse: OnResponseReversalFunc;
     var OnResponse: OnResponseReversalFuncBack;
     var onMiddleware: OnMiddlewareReversalFunc;
@@ -32,6 +36,7 @@ declare global {
     var defineChildren: DefineChildrenFunc;
     var defineResponse: DefineResponseFunc;
     var defineMiddleware: defineMiddlewareFunc;
+    var defineRouter: DefineRouterFunc;
     var onSelects: OnSelectsFunc;
     var format: OnDataFormatFunc;
     var onGroup: OnGroupFunc;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.86",
+  "version": "2.1.88",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -93,4 +93,4 @@
     "url": "https://github.com/lemonade-lab/alemonjs.git"
   },
   "gitHead": "c6aa5616afe091a37610dad22fbb2d2618d943b8"
-}
+}