alemonjs 2.1.76 → 2.1.78

package/lib/app/event-processor.js

@@ -112,18 +112,18 @@ const onProcessor = (name, event, data) => {
             const masterId = value?.master_id;
             const masterKey = value?.master_key;
             if (event['UserId'] && matchIn(masterId, event['UserId'])) {
-                event['isMaster'] = true;
+                event['IsMaster'] = true;
             }
             else if (event['UserKey'] && matchIn(masterKey, event['UserKey'])) {
-                event['isMaster'] = true;
+                event['IsMaster'] = true;
             }
             const botId = value?.bot_id;
             const botKey = value?.bot_key;
             if (event['UserId'] && matchIn(botId, event['UserId'])) {
-                event['isBot'] = true;
+                event['IsBot'] = true;
             }
             else if (event['UserKey'] && matchIn(botKey, event['UserKey'])) {
-                event['isBot'] = true;
+                event['IsBot'] = true;
             }
             const Now = Date.now();
             const EVENT_INTERVAL = value?.processor?.repeated_event_time ?? processorRepeatedEventTime;

package/lib/app/hook-event-context.d.ts

@@ -1,3 +1,4 @@
+import { Result } from '../core';
 import { EventKeys, Events } from '../types';
 export type EventTraceReason = 'filtered' | 'completed' | 'consumed' | 'error';
 export declare const withEventContext: <T extends EventKeys, R>(event: Events[T], next: (...args: boolean[]) => void, runner: () => R) => R;
@@ -5,3 +6,7 @@ export declare const withProcessorTrace: <T extends EventKeys, R>(select: T, eve
 export declare const getCurrentEvent: <T extends EventKeys>() => Events[T] | undefined;
 export declare const getCurrentNext: () => ((...args: boolean[]) => void) | undefined;
 export declare const finishCurrentTrace: (reason: EventTraceReason) => void;
+export declare const markEventSendAttempt: <T extends EventKeys>(event?: Events[T]) => void;
+export declare const markEventSendSuccess: <T extends EventKeys>(event?: Events[T]) => void;
+export declare const markEventSendFailure: <T extends EventKeys>(error: unknown, event?: Events[T]) => void;
+export declare const recordEventSendResults: <T extends EventKeys>(results: Result[], event?: Events[T]) => void;

package/lib/app/hook-event-context.js

@@ -93,5 +93,43 @@ const getCurrentNext = () => {
 const finishCurrentTrace = (reason) => {
     eventStore.getStore()?.trace?.finish(reason);
 };
+const getTargetEvent = (event) => {
+    return event ?? eventStore.getStore()?.event;
+};
+const markEventSendAttempt = (event) => {
+    const target = getTargetEvent(event);
+    if (!target) {
+        return;
+    }
+    target._has_send_attempt = true;
+};
+const markEventSendSuccess = (event) => {
+    const target = getTargetEvent(event);
+    if (!target) {
+        return;
+    }
+    target._has_send_attempt = true;
+    target._has_send_success = true;
+    target._last_send_error = null;
+};
+const markEventSendFailure = (error, event) => {
+    const target = getTargetEvent(event);
+    if (!target) {
+        return;
+    }
+    target._has_send_attempt = true;
+    target._last_send_error = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown send error';
+};
+const recordEventSendResults = (results, event) => {
+    markEventSendAttempt(event);
+    if (Array.isArray(results) && results.some(item => item?.code === ResultCode.Ok)) {
+        markEventSendSuccess(event);
+        return;
+    }
+    const firstError = Array.isArray(results) ? results.find(item => item?.code !== ResultCode.Ok)?.message : null;
+    if (firstError) {
+        markEventSendFailure(firstError, event);
+    }
+};
 
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, withEventContext, withProcessorTrace };
+export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace };

package/lib/app/hook-use/common.d.ts

@@ -5,9 +5,9 @@ import { createResult, Result } from '../../core/utils';
 import { sendAction } from '../../cbp/processor/actions';
 import { sendAPI } from '../../cbp/processor/api';
 import { Format } from '../message-format';
-import { getCurrentEvent, getCurrentNext } from '../hook-event-context';
+import { getCurrentEvent, getCurrentNext, recordEventSendResults, markEventSendAttempt, markEventSendFailure } from '../hook-event-context';
 export type { DataEnums, EventKeys, Events, User, GuildInfo, ChannelInfo, MemberInfo, RoleInfo, PaginationParams, PaginatedResult, Result };
-export { ResultCode, ChildrenApp, createResult, sendAction, sendAPI, Format, getCurrentEvent, getCurrentNext };
+export { ResultCode, ChildrenApp, createResult, sendAction, sendAPI, Format, getCurrentEvent, getCurrentNext, recordEventSendResults, markEventSendAttempt, markEventSendFailure };
 export type Options = {
     UserId?: string;
     UserKey?: string;

package/lib/app/hook-use/common.js

@@ -5,7 +5,7 @@ export { sendAction } from '../../cbp/processor/actions.js';
 export { sendAPI } from '../../cbp/processor/api.js';
 export { Format } from '../message-format.js';
 import { getCurrentEvent } from '../hook-event-context.js';
-export { getCurrentNext } from '../hook-event-context.js';
+export { getCurrentNext, markEventSendAttempt, markEventSendFailure, recordEventSendResults } from '../hook-event-context.js';
 
 const getEventOrThrow = (event) => {
     const currentEvent = event ?? getCurrentEvent();

package/lib/app/hook-use/message.js

@@ -3,6 +3,7 @@ import { createResult } from '../../core/utils.js';
 import { ResultCode } from '../../core/variable.js';
 import { sendAction } from '../../cbp/processor/actions.js';
 import { Format } from '../message-format.js';
+import { markEventSendAttempt, recordEventSendResults, markEventSendFailure } from '../hook-event-context.js';
 
 const useMessage = (event) => {
     const valueEvent = getEventOrThrow(event);
@@ -16,17 +17,26 @@ const useMessage = (event) => {
         if (!val || val.length === 0) {
             return [createResult(ResultCode.FailParams, 'Invalid val: val must be a non-empty array', null)];
         }
-        const result = await sendAction({
-            action: 'message.send',
-            payload: {
-                event: valueEvent,
-                params: {
-                    format: val,
-                    replyId
+        markEventSendAttempt(valueEvent);
+        try {
+            const result = await sendAction({
+                action: 'message.send',
+                payload: {
+                    event: valueEvent,
+                    params: {
+                        format: val,
+                        replyId
+                    }
                 }
-            }
-        });
-        return Array.isArray(result) ? result : [result];
+            });
+            const results = Array.isArray(result) ? result : [result];
+            recordEventSendResults(results, valueEvent);
+            return results;
+        }
+        catch (error) {
+            markEventSendFailure(error, valueEvent);
+            throw error;
+        }
     };
     const lightweight = {
         send(params) {

package/lib/app/index.js

@@ -34,7 +34,7 @@ export { useUser } from './hook-use/user.js';
 export { useObserver, useSubscribe } from './hook-use/subscribe.js';
 export { createEvent, useEvent } from './hook-use/event.js';
 export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './api/schedule.js';
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, withEventContext, withProcessorTrace } from './hook-event-context.js';
+export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './hook-event-context.js';
 export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir } from './schedule-store.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './event-utils.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';

package/lib/app/message-api.js

@@ -4,6 +4,7 @@ import 'fs';
 import 'path';
 import 'yaml';
 import { createResult } from '../core/utils.js';
+import { markEventSendAttempt, recordEventSendResults, markEventSendFailure } from './hook-event-context.js';
 
 const format = (...data) => {
     if (!data || data.length === 0) {
@@ -31,16 +32,25 @@ class MessageDirect {
             });
             throw new Error('Invalid SpaceId: SpaceId must be a string');
         }
-        return await sendAction({
-            action: 'message.send.channel',
-            payload: {
-                ChannelId: params.SpaceId,
-                params: {
-                    format: Array.isArray(params.format) ? params.format : params.format.value,
-                    replyId: params?.replyId
+        markEventSendAttempt();
+        try {
+            const results = await sendAction({
+                action: 'message.send.channel',
+                payload: {
+                    ChannelId: params.SpaceId,
+                    params: {
+                        format: Array.isArray(params.format) ? params.format : params.format.value,
+                        replyId: params?.replyId
+                    }
                 }
-            }
-        });
+            });
+            recordEventSendResults(results, undefined);
+            return results;
+        }
+        catch (error) {
+            markEventSendFailure(error);
+            throw error;
+        }
     }
     async sendToUser(params) {
         if (!params.OpenID || typeof params.OpenID !== 'string') {
@@ -51,15 +61,24 @@ class MessageDirect {
             });
             throw new Error('Invalid OpenID: OpenID must be a string');
         }
-        return await sendAction({
-            action: 'message.send.user',
-            payload: {
-                UserId: params.OpenID,
-                params: {
-                    format: Array.isArray(params.format) ? params.format : params.format.value
+        markEventSendAttempt();
+        try {
+            const results = await sendAction({
+                action: 'message.send.user',
+                payload: {
+                    UserId: params.OpenID,
+                    params: {
+                        format: Array.isArray(params.format) ? params.format : params.format.value
+                    }
                 }
-            }
-        });
+            });
+            recordEventSendResults(results, undefined);
+            return results;
+        }
+        catch (error) {
+            markEventSendFailure(error);
+            throw error;
+        }
     }
 }
 const sendToChannel = (SpaceId, data) => {

package/lib/app/router/dsl.js

@@ -72,6 +72,13 @@ function getImporterLabel(importer, index) {
 function formatRouteDescription(description) {
     return typeof description === 'string' && description.trim() ? description.trim() : undefined;
 }
+function formatArgReference(arg, displayIndex) {
+    const name = typeof arg.name === 'string' ? arg.name.trim() : '';
+    if (name) {
+        return `参数「${name}」`;
+    }
+    return `第${displayIndex}个参数`;
+}
 function formatArgRuleHint(arg, displayIndex) {
     const rules = arg.rules ?? [];
     const parts = [];
@@ -105,7 +112,7 @@ function formatArgRuleHint(arg, displayIndex) {
         parts.push(`最大 ${typeRule.max}`);
     }
     const suffix = arg.description ? `，${arg.description}` : '';
-    return `参数${displayIndex} \`${arg.name}\`：${parts.join('，')}${suffix}`;
+    return `${formatArgReference(arg, displayIndex)}：${parts.join('，')}${suffix}`;
 }
 function buildSchemaHints(schema) {
     const args = schema?.args ?? [];

package/lib/app/router/fallback.js

@@ -21,11 +21,15 @@ function levenshteinDistance(a, b) {
 function normalizeForCompare(text) {
     return text.replace(/^([!！/#＃])\s*/, '').trim();
 }
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 function shouldCheckCandidate(messageText, candidate) {
     if (!messageText || !candidate) {
         return false;
     }
-    return messageText.startsWith(candidate);
+    const candidatePattern = new RegExp(`^${escapeRegExp(candidate)}(?:\\s|$)`);
+    return candidatePattern.test(messageText);
 }
 function getAdaptiveMaxDistance(input) {
     if (input.length <= 2) {

package/lib/app/router/validator.js

@@ -20,6 +20,24 @@ function getMaxArgs(schema) {
     }
     return args.length > 0 ? args.length : undefined;
 }
+function getMissingRequiredArg(rawArgs, schema) {
+    const args = schema?.args ?? [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const requiredRule = getRequiredRule(arg);
+        if (!requiredRule) {
+            continue;
+        }
+        const rawValue = arg.rules?.some(rule => rule.type === 'rest') ? rawArgs.slice(index).join(' ').trim() : rawArgs[index];
+        if (rawValue === undefined || rawValue === '') {
+            return {
+                arg,
+                displayIndex: index + 1
+            };
+        }
+    }
+    return null;
+}
 function parseRange(rawValue, rule) {
     const separators = rule.separators ?? ['-', '－'];
     const separator = separators.find(item => rawValue.includes(item));
@@ -34,8 +52,15 @@ function parseRange(rawValue, rule) {
     }
     return { start, end };
 }
+function formatArgReference(argName, displayIndex) {
+    const name = String(argName ?? '').trim();
+    if (name) {
+        return `参数「${name}」`;
+    }
+    return `第${displayIndex}个参数`;
+}
 function validateTypedRule(rawValue, rule, context, usage) {
-    const messagePrefix = `参数${context.displayIndex}`;
+    const messagePrefix = formatArgReference(context.argName, context.displayIndex);
     const normalizedValue = rule.normalizeMap?.[rawValue] ?? rawValue;
     if (rule.pattern) {
         rule.pattern.lastIndex = 0;
@@ -226,9 +251,11 @@ function validateRouteArgsForCommand(commandPath, rawArgs, schema) {
     const maxArgs = getMaxArgs(schema);
     const usage = schema?.usage;
     if (rawArgs.length < minArgs) {
+        const missingRequiredArg = getMissingRequiredArg(rawArgs, schema);
         return {
             valid: false,
-            error: schema?.messages?.tooFewArgs ?? `至少需要 ${minArgs} 个参数`,
+            error: schema?.messages?.tooFewArgs ??
+                (missingRequiredArg ? `${formatArgReference(missingRequiredArg.arg.name, missingRequiredArg.displayIndex)}是必填的` : `至少需要 ${minArgs} 个参数`),
             usage
         };
     }
@@ -252,7 +279,7 @@ function validateRouteArgsForCommand(commandPath, rawArgs, schema) {
                 if (requiredRule) {
                     return {
                         valid: false,
-                        error: requiredRule.message ?? `参数${displayIndex}是必填的`,
+                        error: requiredRule.message ?? `${formatArgReference(arg.name, displayIndex)}是必填的`,
                         usage
                     };
                 }
@@ -282,7 +309,7 @@ function validateRouteArgsForCommand(commandPath, rawArgs, schema) {
             if (requiredRule) {
                 return {
                     valid: false,
-                    error: requiredRule.message ?? `参数${displayIndex}是必填的`,
+                    error: requiredRule.message ?? `${formatArgReference(arg.name, displayIndex)}是必填的`,
                     usage
                 };
             }

package/lib/index.js

@@ -41,7 +41,7 @@ export { useUser } from './app/hook-use/user.js';
 export { useObserver, useSubscribe } from './app/hook-use/subscribe.js';
 export { createEvent, useEvent } from './app/hook-use/event.js';
 export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './app/api/schedule.js';
-export { finishCurrentTrace, getCurrentEvent, getCurrentNext, withEventContext, withProcessorTrace } from './app/hook-event-context.js';
+export { finishCurrentTrace, getCurrentEvent, getCurrentNext, markEventSendAttempt, markEventSendFailure, markEventSendSuccess, recordEventSendResults, withEventContext, withProcessorTrace } from './app/hook-event-context.js';
 export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir } from './app/schedule-store.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './app/event-utils.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './app/message-api.js';

package/lib/types/event/base/expansion.d.ts

@@ -1,3 +1,6 @@
 export type Expansion = {
+    _has_send_attempt?: boolean;
+    _has_send_success?: boolean;
+    _last_send_error?: string | null;
     [key: string]: any;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.76",
+  "version": "2.1.78",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",