@zhin.js/core 1.0.50 → 1.0.52

package/tests/dispatcher.test.ts

@@ -2,8 +2,14 @@
  * MessageDispatcher 测试
  */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createMessageDispatcher, type MessageDispatcherService, type RouteResult } from '../src/built/dispatcher.js';
+import { EventEmitter } from 'node:events';
+import {
+  createMessageDispatcher,
+  type MessageDispatcherService,
+} from '../src/built/dispatcher.js';
 import type { Message } from '../src/message.js';
+import type { Plugin } from '../src/plugin.js';
+import type { BeforeSendHandler } from '../src/types.js';
 
 function makeMessage(text: string, overrides: Partial<Message<any>> = {}): Message<any> {
   return {
@@ -21,6 +27,42 @@ function makeMessage(text: string, overrides: Partial<Message<any>> = {}): Messa
   } as any;
 }
 
+function makeRootWithCommand(
+  handleImpl?: (msg: Message<any>, root: Plugin) => Promise<string | void>,
+) {
+  const handle = handleImpl ?? vi.fn(async () => 'cmd-ok');
+  const cmdService = {
+    items: [{ pattern: '/help ping' }],
+    handle,
+  };
+  const root = new EventEmitter() as unknown as Plugin;
+  (root as any).inject = (name: string) => {
+    if (name === 'command') return cmdService;
+    return undefined;
+  };
+  (root as any).root = root;
+  return root;
+}
+
+/** 模拟 $reply → adapter.sendMessage → renderSendMessage（before.sendMessage） */
+function wireMessageReplyThroughBeforeSend(msg: Message<any>, root: EventEmitter) {
+  msg.$reply = vi.fn(async (content: any) => {
+    let options = {
+      content,
+      bot: msg.$bot,
+      id: msg.$channel.id,
+      type: msg.$channel.type,
+      context: 'test',
+    };
+    const fns = root.listeners('before.sendMessage') as BeforeSendHandler[];
+    for (const fn of fns) {
+      const r = await fn(options);
+      if (r) options = r;
+    }
+    return 'mock-msg-id';
+  });
+}
+
 describe('createMessageDispatcher', () => {
   let context: ReturnType<typeof createMessageDispatcher>;
   let service: MessageDispatcherService;
@@ -40,6 +82,10 @@ describe('createMessageDispatcher', () => {
     expect(typeof context.value.setAITriggerMatcher).toBe('function');
     expect(typeof context.value.setAIHandler).toBe('function');
     expect(typeof context.value.hasAIHandler).toBe('function');
+    expect(typeof context.value.addOutboundPolish).toBe('function');
+    expect(typeof context.value.replyWithPolish).toBe('function');
+    expect(typeof service.matchCommand).toBe('function');
+    expect(typeof service.matchAI).toBe('function');
   });
 
   describe('Guardrail', () => {
@@ -98,7 +144,7 @@ describe('createMessageDispatcher', () => {
     it('AI 触发时应调用 handler', async () => {
       const handler = vi.fn();
       service.setAIHandler(handler);
-      service.setAITriggerMatcher((msg) => ({
+      service.setAITriggerMatcher(() => ({
         triggered: true,
         content: 'processed content',
       }));
@@ -121,20 +167,118 @@ describe('createMessageDispatcher', () => {
     });
   });
 
-  describe('Command Matcher', () => {
-    it('自定义命令匹配器应优先', async () => {
+  describe('Command Matcher (exclusive)', () => {
+    it('自定义命令匹配器应优先并阻断 AI（互斥模式）', async () => {
+      const exclusiveCtx = createMessageDispatcher({ dualRoute: { mode: 'exclusive' } });
+      const d = exclusiveCtx.value;
+      const aiHandler = vi.fn();
+      d.setAIHandler(aiHandler);
+      d.setAITriggerMatcher(() => ({ triggered: true, content: '' }));
+      d.setCommandMatcher((text) => text.startsWith('/'));
+
+      const msg = makeMessage('/help');
+      await d.dispatch(msg);
+
+      expect(aiHandler).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('双轨 dual 模式', () => {
+    it('同时命中指令与 AI 时应各执行一次（默认 command-first）', async () => {
+      const root = makeRootWithCommand();
+      const fakePlugin = { root } as Plugin;
+      context.mounted(fakePlugin);
+
       const aiHandler = vi.fn();
       service.setAIHandler(aiHandler);
-      service.setAITriggerMatcher(() => ({ triggered: true, content: '' }));
+      service.setAITriggerMatcher(() => ({ triggered: true, content: 'hi' }));
+      service.setDualRouteConfig({ mode: 'dual', order: 'command-first', allowDualReply: true });
+
+      const msg = makeMessage('/help');
+      wireMessageReplyThroughBeforeSend(msg, root as unknown as EventEmitter);
+      await service.dispatch(msg);
 
-      // 设置命令匹配器：以 / 开头视为命令
-      service.setCommandMatcher((text) => text.startsWith('/'));
+      const cmd = root.inject('command') as any;
+      expect(cmd.handle).toHaveBeenCalled();
+      expect(aiHandler).toHaveBeenCalledWith(msg, 'hi');
+      expect(msg.$reply).toHaveBeenCalledWith('cmd-ok');
+    });
+
+    it('ai-first 时应先 AI 后指令', async () => {
+      const order: string[] = [];
+      const root = makeRootWithCommand(async () => {
+        order.push('cmd');
+        return 'c';
+      });
+      const fakePlugin = { root } as Plugin;
+      context.mounted(fakePlugin);
+
+      service.setAIHandler(async () => {
+        order.push('ai');
+      });
+      service.setAITriggerMatcher(() => ({ triggered: true, content: 'x' }));
+      service.setDualRouteConfig({ mode: 'dual', order: 'ai-first', allowDualReply: true });
 
       const msg = makeMessage('/help');
+      wireMessageReplyThroughBeforeSend(msg, root as unknown as EventEmitter);
+      await service.dispatch(msg);
+
+      expect(order).toEqual(['ai', 'cmd']);
+    });
+
+    it('allowDualReply false 且 command-first 时仅执行指令', async () => {
+      const root = makeRootWithCommand();
+      const fakePlugin = { root } as Plugin;
+      context.mounted(fakePlugin);
+
+      const aiHandler = vi.fn();
+      service.setAIHandler(aiHandler);
+      service.setAITriggerMatcher(() => ({ triggered: true, content: 'x' }));
+      service.setDualRouteConfig({ mode: 'dual', order: 'command-first', allowDualReply: false });
+
+      const msg = makeMessage('/help');
+      wireMessageReplyThroughBeforeSend(msg, root as unknown as EventEmitter);
       await service.dispatch(msg);
 
-      // 命令路径不应触发 AI
       expect(aiHandler).not.toHaveBeenCalled();
+      expect(msg.$reply).toHaveBeenCalled();
+    });
+  });
+
+  describe('出站润色', () => {
+    it('replyWithPolish 应经 before.sendMessage 链式润色再发出（$reply 入参仍为原文）', async () => {
+      const root = new EventEmitter() as unknown as Plugin;
+      (root as any).inject = () => undefined;
+      (root as any).root = root;
+      context.mounted({ root } as Plugin);
+
+      const p1 = vi.fn(async (ctx: any) => `[1]${ctx.content}`);
+      const p2 = vi.fn(async (ctx: any) => `${ctx.content}[2]`);
+      service.addOutboundPolish(p1);
+      service.addOutboundPolish(p2);
+
+      const msg = makeMessage('x');
+      wireMessageReplyThroughBeforeSend(msg, root as unknown as EventEmitter);
+      await service.replyWithPolish(msg, 'ai', 'hello');
+
+      expect(p1).toHaveBeenCalled();
+      expect(p2).toHaveBeenCalled();
+      expect(msg.$reply).toHaveBeenCalledWith('hello');
+    });
+
+    it('指令路径应经过润色', async () => {
+      const root = makeRootWithCommand(async () => 'out');
+      const fakePlugin = { root } as Plugin;
+      context.mounted(fakePlugin);
+
+      service.addOutboundPolish(async (ctx) => `<<${ctx.content}>>`);
+      service.setDualRouteConfig({ mode: 'exclusive' });
+
+      const msg = makeMessage('/help');
+      wireMessageReplyThroughBeforeSend(msg, root as unknown as EventEmitter);
+      await service.dispatch(msg);
+
+      expect(msg.$reply).toHaveBeenCalledWith('out');
     });
   });
 
@@ -142,5 +286,8 @@ describe('createMessageDispatcher', () => {
     it('应提供 addGuardrail 扩展', () => {
       expect(typeof context.extensions.addGuardrail).toBe('function');
     });
+    it('应提供 addOutboundPolish 扩展', () => {
+      expect(typeof context.extensions.addOutboundPolish).toBe('function');
+    });
   });
 });

package/tests/redos-protection.test.ts

@@ -72,12 +72,13 @@ describe('ReDoS Protection Tests', () => {
     });
 
     it('should reject extremely large templates', () => {
-      // 测试超大模板
-      const hugeTemplate = '<tag>content</tag>'.repeat(10000);
-      
+      // segment.from 在 utils 中限制单段模板长度 > 400_000（见 MAX_TEMPLATE_LENGTH）
+      const chunk = '<tag>content</tag>';
+      const hugeTemplate = chunk.repeat(Math.ceil(400_001 / chunk.length));
+
       expect(() => {
         segment.from(hugeTemplate);
-      }).toThrow('Template too large');
+      }).toThrow(/Template too large/);
     });
 
     it('should handle nested tags without exponential backtracking', () => {