alemonjs 2.1.49 → 2.1.50

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIdED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/lib/app/event-format.d.ts

@@ -0,0 +1,19 @@
+import { Events, EventKeys, EventBuilder, ReservedEventKeys, User, Guild, Channel, Message, MessageText, MessageMedia, MessageOpen, Platform } from '../types';
+export declare class FormatEvent<T extends EventKeys = EventKeys> {
+    #private;
+    private constructor();
+    static create<T extends EventKeys>(name: T): EventBuilder<T>;
+    addPlatform(params: Platform): this;
+    addGuild(params: Guild): this;
+    addChannel(params: Channel): this;
+    addUser(params: User): this;
+    addMessage(params: Message): this;
+    addText(params: MessageText): this;
+    addMedia(params: MessageMedia): this;
+    addOpen(params: MessageOpen): this;
+    add<E extends Record<string, unknown>>(fields: {
+        [K in keyof E]: K extends ReservedEventKeys ? never : E[K];
+    }): this;
+    get value(): Events[T];
+}
+export declare function wrapEvent<E extends Record<string, unknown>>(event: object): Readonly<E>;

package/lib/app/event-format.js

@@ -0,0 +1,128 @@
+class FormatEvent {
+    #data;
+    constructor(name) {
+        this.#data = { name, Timestamp: Date.now() };
+    }
+    static create(name) {
+        return new FormatEvent(name);
+    }
+    addPlatform(params) {
+        const { value, ...otherParams } = params;
+        Object.assign(this.#data, otherParams);
+        Object.defineProperty(this.#data, 'value', {
+            value,
+            enumerable: false
+        });
+        return this;
+    }
+    addGuild(params) {
+        Object.assign(this.#data, {
+            GuildId: params.GuildId,
+            SpaceId: params.SpaceId
+        });
+        return this;
+    }
+    addChannel(params) {
+        Object.assign(this.#data, {
+            ChannelId: params.ChannelId
+        });
+        return this;
+    }
+    addUser(params) {
+        Object.assign(this.#data, {
+            UserId: params.UserId,
+            UserKey: params.UserKey,
+            IsMaster: params.IsMaster,
+            IsBot: params.IsBot,
+            ...(params.UserName !== undefined && { UserName: params.UserName }),
+            ...(params.UserAvatar !== undefined && { UserAvatar: params.UserAvatar })
+        });
+        return this;
+    }
+    addMessage(params) {
+        const assign = { MessageId: params.MessageId };
+        if (params.ReplyId !== undefined) {
+            assign.ReplyId = params.ReplyId;
+        }
+        Object.assign(this.#data, assign);
+        return this;
+    }
+    addText(params) {
+        Object.assign(this.#data, {
+            MessageText: params.MessageText
+        });
+        return this;
+    }
+    addMedia(params) {
+        Object.assign(this.#data, {
+            MessageMedia: params.MessageMedia
+        });
+        return this;
+    }
+    addOpen(params) {
+        Object.assign(this.#data, {
+            OpenId: params.OpenId
+        });
+        return this;
+    }
+    add(fields) {
+        for (const key of Object.keys(fields)) {
+            this.#data[`_${key}`] = fields[key];
+        }
+        return this;
+    }
+    get value() {
+        return this.#data;
+    }
+}
+function wrapEvent(event) {
+    return new Proxy(event, {
+        get(target, prop, receiver) {
+            if (typeof prop === 'string' && !prop.startsWith('_')) {
+                const privateKey = `_${prop}`;
+                if (privateKey in target) {
+                    return Reflect.get(target, privateKey, receiver);
+                }
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+        has(target, prop) {
+            if (typeof prop === 'string' && !prop.startsWith('_')) {
+                if (`_${prop}` in target) {
+                    return true;
+                }
+            }
+            return Reflect.has(target, prop);
+        },
+        set() {
+            return false;
+        },
+        deleteProperty() {
+            return false;
+        },
+        ownKeys(target) {
+            return Reflect.ownKeys(target).map(key => {
+                if (typeof key === 'string' && key.startsWith('_')) {
+                    return key.slice(1);
+                }
+                return key;
+            });
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (typeof prop === 'string' && !prop.startsWith('_')) {
+                const privateKey = `_${prop}`;
+                const desc = Reflect.getOwnPropertyDescriptor(target, privateKey);
+                if (desc) {
+                    return { ...desc, configurable: true, writable: false };
+                }
+            }
+            const desc = Reflect.getOwnPropertyDescriptor(target, prop);
+            if (desc) {
+                return { ...desc, writable: false };
+            }
+            return desc;
+        }
+    });
+}
+
+export { FormatEvent, wrapEvent };

package/lib/app/event-utils.js

@@ -1,5 +1,5 @@
 import { getConfig } from '../core/config.js';
-import { ChildrenApp, State, StateSubscribe } from './store.js';
+import { StateSubscribe, ChildrenApp, State } from './store.js';
 import { ResultCode } from '../core/variable.js';
 
 const unChildren = (name = 'main') => {

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

@@ -10,6 +10,26 @@ import { sendAPI } from '../../cbp/processor/api.js';
 import '../message-format-old.js';
 import { getCurrentEvent } from '../hook-event-context.js';
 
+const createDeepProxy = (event, path = []) => {
+    return new Proxy((() => { }), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol') {
+                return undefined;
+            }
+            return createDeepProxy(event, [...path, String(prop)]);
+        },
+        apply(_target, _thisArg, args) {
+            return sendAPI({
+                action: 'client.api',
+                payload: {
+                    event,
+                    key: path.join('.'),
+                    params: args
+                }
+            });
+        }
+    });
+};
 function useClient(eventOrClass, _ApiClass) {
     let valueEvent;
     if (eventOrClass !== undefined && typeof eventOrClass === 'function') {
@@ -26,23 +46,7 @@ function useClient(eventOrClass, _ApiClass) {
         });
         throw new Error('Invalid event: event must be an object');
     }
-    const client = new Proxy({}, {
-        get(_target, prop) {
-            if (typeof prop === 'symbol') {
-                return undefined;
-            }
-            return (...args) => {
-                return sendAPI({
-                    action: 'client.api',
-                    payload: {
-                        event: valueEvent,
-                        key: String(prop),
-                        params: args
-                    }
-                });
-            };
-        }
-    });
+    const client = createDeepProxy(valueEvent);
     return [client];
 }
 

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

@@ -0,0 +1,20 @@
+import { EventKeys, Events } from 'types';
+type UseEventOptions<T extends EventKeys> = {
+    selects: T | T[];
+    regular?: RegExp;
+    prefix?: string;
+    exact?: string;
+};
+type UseEventResult<T extends EventKeys> = {
+    current: Events[T];
+    value: Events[T]['value'];
+    match: {
+        selects: boolean;
+        regular: boolean;
+        prefix: boolean;
+        exact: boolean;
+    };
+};
+export declare function useEvent<T extends EventKeys>(options?: UseEventOptions<T>): readonly [UseEventResult<T>];
+export declare function useEvent<T extends EventKeys>(event?: Events[T], options?: UseEventOptions<T>): readonly [UseEventResult<T>];
+export {};

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

@@ -0,0 +1,38 @@
+import { getEventOrThrow } from './common.js';
+
+const isOptions = (v) => {
+    return typeof v === 'object' && 'selects' in v;
+};
+function useEvent(eventOrOptions, options) {
+    let eventArg;
+    let opts;
+    if (eventOrOptions && isOptions(eventOrOptions)) {
+        opts = eventOrOptions;
+    }
+    else {
+        eventArg = eventOrOptions;
+        opts = options;
+    }
+    const { selects, regular, prefix, exact } = opts ?? {};
+    const eventValue = getEventOrThrow(eventArg);
+    const { name, MessageText } = eventValue;
+    const selectsArr = Array.isArray(selects) ? selects : [selects];
+    const match = {
+        selects: selectsArr.includes(name),
+        exact: !!(exact && MessageText === exact),
+        prefix: !!(prefix && MessageText?.startsWith(prefix)),
+        regular: !!(regular && MessageText && regular.test(MessageText))
+    };
+    const r = {
+        current: { ...eventValue },
+        match
+    };
+    Object.defineProperty(r, 'value', {
+        get() {
+            return eventValue.value;
+        }
+    });
+    return [r];
+}
+
+export { useEvent };

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

@@ -13,3 +13,5 @@ export * from './reaction';
 export * from './request';
 export * from './role';
 export * from './user';
+export * from './subscribe';
+export * from './event';

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

@@ -13,3 +13,5 @@ export { useReaction } from './reaction.js';
 export { useRequest } from './request.js';
 export { useRole } from './role.js';
 export { useUser } from './user.js';
+export { useObserver, useSubscribe } from './subscribe.js';
+export { useEvent } from './event.js';

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

@@ -0,0 +1,73 @@
+import { EventCycleEnum, Current, Events, EventKeys } from '../../types';
+export declare function useSubscribe<T extends EventKeys>(selects: T | T[]): readonly [
+    {
+        create: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        mount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        unmount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        cancel: (value: {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        }) => void;
+    }
+];
+export declare function useSubscribe<T extends EventKeys>(event: Events[T] | undefined, selects: T | T[]): readonly [
+    {
+        create: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        mount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        unmount: (callback: Current<T>, keys: (keyof Events[T])[]) => {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        };
+        cancel: (value: {
+            id: string;
+            selects: T[];
+            choose: EventCycleEnum;
+        }) => void;
+    }
+];
+export declare function useObserver<T extends EventKeys>(selects: T | T[]): readonly [
+    (callback: Current<T>, keys: (keyof Events[T])[]) => {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    },
+    (value: {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    }) => void
+];
+export declare function useObserver<T extends EventKeys>(event: Events[T] | undefined, selects: T | T[]): readonly [
+    (callback: Current<T>, keys: (keyof Events[T])[]) => {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    },
+    (value: {
+        id: string;
+        selects: T[];
+        choose: EventCycleEnum;
+    }) => void
+];

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

@@ -0,0 +1,112 @@
+import { ResultCode } from '../../core/variable.js';
+import { SubscribeList } from '../store.js';
+import { SubscribeStatus } from '../config.js';
+import { getCurrentEvent } from '../hook-event-context.js';
+
+function useSubscribe(eventOrSelects, maybeSelects) {
+    const selects = (maybeSelects === undefined ? eventOrSelects : maybeSelects);
+    const event = (maybeSelects === undefined ? undefined : eventOrSelects);
+    const valueEvent = event ?? getCurrentEvent();
+    if (typeof valueEvent !== 'object' || valueEvent === null) {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'event is not object',
+            data: null
+        });
+        throw new Error('event is not object');
+    }
+    if (typeof selects !== 'string' && !Array.isArray(selects)) {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'select is not string or array',
+            data: null
+        });
+        throw new Error('select is not string or array');
+    }
+    const register = (callback, keys, choose) => {
+        const curSelects = Array.isArray(selects) ? selects : [selects];
+        const ID = Date.now().toString(36) + Math.random().toString(36).substring(2, 15);
+        if (keys.length === 0) {
+            logger.warn({
+                code: ResultCode.FailParams,
+                message: 'subscribe keys is empty',
+                data: null
+            });
+            return { selects: curSelects, choose, id: ID };
+        }
+        for (const select of curSelects) {
+            const subList = new SubscribeList(choose, select);
+            const values = {};
+            for (const key of keys) {
+                if (typeof key === 'string' && (typeof valueEvent[key] === 'string' || typeof valueEvent[key] === 'number' || typeof valueEvent[key] === 'boolean')) {
+                    values[key] = valueEvent[key];
+                }
+                else {
+                    logger.warn({
+                        code: ResultCode.FailParams,
+                        message: `Invalid key: ${key?.toString()} must be a string, number or boolean`,
+                        data: null
+                    });
+                }
+            }
+            subList.value.append({
+                choose,
+                selects: curSelects,
+                keys: values,
+                current: callback,
+                status: SubscribeStatus.active,
+                id: ID
+            });
+        }
+        return {
+            selects: curSelects,
+            choose,
+            id: ID
+        };
+    };
+    const create = (callback, keys) => {
+        return register(callback, keys, 'create');
+    };
+    const mountBefore = (callback, keys) => {
+        return register(callback, keys, 'mount');
+    };
+    const unmount = (callback, keys) => {
+        return register(callback, keys, 'unmount');
+    };
+    const cancel = (value) => {
+        const selects = value.selects;
+        const ID = value.id;
+        for (const select of selects) {
+            const subList = new SubscribeList(value.choose, select);
+            subList.value.forEach(node => {
+                if (node.data.id === ID) {
+                    node.data.status = SubscribeStatus.paused;
+                    return true;
+                }
+            });
+        }
+    };
+    const subscribe = {
+        create,
+        mount: mountBefore,
+        unmount,
+        cancel
+    };
+    return [subscribe];
+}
+function useObserver(eventOrSelects, maybeSelects) {
+    const selects = (maybeSelects === undefined ? eventOrSelects : maybeSelects);
+    const event = (maybeSelects === undefined ? undefined : eventOrSelects);
+    if (selects === undefined) {
+        logger.error({
+            code: ResultCode.FailParams,
+            message: 'select is not string or array',
+            data: null
+        });
+        throw new Error('select is not string or array');
+    }
+    const [subscribe] = useSubscribe(event, selects);
+    return [subscribe.mount, subscribe.cancel];
+}
+
+export { useObserver, useSubscribe };

package/lib/app/index.d.ts

@@ -5,6 +5,7 @@ export * from './define-platform.js';
 export * from './define-response.js';
 export * from './define-middleware.js';
 export * from './define-router.js';
+export * from './event-format.js';
 export * from './event-group.js';
 export * from './event-middleware';
 export * from './event-processor';
@@ -16,6 +17,5 @@ export * from './event-processor-subscribe.js';
 export * from './hook-use/index.js';
 export * from './hook-event-context.js';
 export * from './event-utils.js';
-export * from './hook-use-subscribe.js';
 export * from './message-api.js';
 export * from './message-format.js';

package/lib/app/index.js

@@ -6,6 +6,7 @@ export { definePlatform } from './define-platform.js';
 export { defineResponse } from './define-response.js';
 export { defineMiddleware } from './define-middleware.js';
 export { defineRouter, lazy } from './define-router.js';
+export { FormatEvent, wrapEvent } from './event-format.js';
 export { onGroup } from './event-group.js';
 export { OnMiddleware, onMiddleware } from './event-middleware.js';
 export { OnProcessor, onProcessor } from './event-processor.js';
@@ -29,9 +30,10 @@ export { useReaction } from './hook-use/reaction.js';
 export { useRequest } from './hook-use/request.js';
 export { useRole } from './hook-use/role.js';
 export { useUser } from './hook-use/user.js';
+export { useObserver, useSubscribe } from './hook-use/subscribe.js';
+export { useEvent } from './hook-use/event.js';
 export { getCurrentEvent, withEventContext } from './hook-event-context.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './event-utils.js';
-export { useObserver, useSubscribe } from './hook-use-subscribe.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';
 export { Format, FormatButtonGroup, FormatMarkDown, createEvent } from './message-format.js';
 export { Attachment, Audio, BT, Button, Image, ImageFile, ImageURL, Link, MD, Markdown, MarkdownOriginal, Mention, Text, Video } from './message-format-old.js';

package/lib/app/load_modules/load.js

@@ -8,7 +8,7 @@ const loadApps = () => {
     const cfg = getConfig();
     const apps = Array.isArray(cfg.value?.apps) ? cfg.value.apps : Object.keys(cfg.value?.apps ?? {}).filter(Boolean);
     const uniqueApps = Array.from(new Set(apps));
-    void Promise.all(uniqueApps.map(app => loadChildrenFile(app)));
+    uniqueApps.forEach(app => void loadChildrenFile(app));
 };
 const run = (input) => {
     if (!input) {

package/lib/app/load_modules/loadChild.js

@@ -3,11 +3,11 @@ import { existsSync } from 'fs';
 import { showErrorModule, getRecursiveDirFiles, createEventName } from '../../core/utils.js';
 import { ChildrenApp } from '../store.js';
 import { ResultCode, fileSuffixMiddleware } from '../../core/variable.js';
-import module from 'module';
+import module$1 from 'module';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
-const require = module?.createRequire?.(import.meta.url) ?? initRequire;
+const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
 const loadChildren = async (mainPath, appName) => {
     if (!mainPath || typeof mainPath !== 'string') {
         logger.error({
@@ -168,7 +168,7 @@ const loadChildrenFile = (appName) => {
         return;
     }
     try {
-        const mainPath = require.resolve(appName);
+        const mainPath = require$1.resolve(appName);
         if (!existsSync(mainPath)) {
             logger.error({
                 code: ResultCode.FailParams,

package/lib/app/message-api.d.ts

@@ -7,12 +7,12 @@ export declare class MessageDirect {
     static create(): MessageDirect;
     sendToChannel(params: {
         SpaceId: string;
-        format: Format;
+        format: Format | DataEnums[];
         replyId?: string;
     }): Promise<Result[]>;
     sendToUser(params: {
         OpenID: string;
-        format: Format;
+        format: Format | DataEnums[];
     }): Promise<Result[]>;
 }
 export declare const sendToChannel: (SpaceId: string, data: DataEnums[]) => Promise<Result[]>;

package/lib/app/message-api.js

@@ -36,7 +36,7 @@ class MessageDirect {
             payload: {
                 ChannelId: params.SpaceId,
                 params: {
-                    format: params.format.value,
+                    format: Array.isArray(params.format) ? params.format : params.format.value,
                     replyId: params?.replyId
                 }
             }
@@ -56,49 +56,17 @@ class MessageDirect {
             payload: {
                 UserId: params.OpenID,
                 params: {
-                    format: params.format.value
+                    format: Array.isArray(params.format) ? params.format : params.format.value
                 }
             }
         });
     }
 }
-const sendToChannel = async (SpaceId, data) => {
-    if (!SpaceId || typeof SpaceId !== 'string') {
-        logger.error({
-            code: ResultCode.FailParams,
-            message: 'Invalid SpaceId: SpaceId must be a string',
-            data: null
-        });
-        throw new Error('Invalid SpaceId: SpaceId must be a string');
-    }
-    return await sendAction({
-        action: 'message.send.channel',
-        payload: {
-            ChannelId: SpaceId,
-            params: {
-                format: data
-            }
-        }
-    });
+const sendToChannel = (SpaceId, data) => {
+    return MessageDirect.create().sendToChannel({ SpaceId, format: data, replyId: undefined });
 };
-const sendToUser = async (OpenID, data) => {
-    if (!OpenID || typeof OpenID !== 'string') {
-        logger.error({
-            code: ResultCode.FailParams,
-            message: 'Invalid OpenID: OpenID must be a string',
-            data: null
-        });
-        throw new Error('Invalid OpenID: OpenID must be a string');
-    }
-    return await sendAction({
-        action: 'message.send.user',
-        payload: {
-            UserId: OpenID,
-            params: {
-                format: data
-            }
-        }
-    });
+const sendToUser = (OpenID, data) => {
+    return MessageDirect.create().sendToUser({ OpenID, format: data });
 };
 const getMessageIntent = async () => {
     const results = await sendAction({

package/lib/cbp/connects/platform.js

@@ -185,7 +185,7 @@ const cbpPlatform = (url, options = {
     };
     const currentURL = createCurrentURL() || `ws://localhost:${process.env.port || 17117}`;
     const send = (data) => {
-        if (global.chatbotPlatform && global.chatbotPlatform.readyState === WebSocket.OPEN) {
+        if (global.chatbotPlatform?.readyState === WebSocket.OPEN) {
             data.DeviceId = deviceId;
             data.CreateAt = Date.now();
             global.chatbotPlatform.send(flattedJSON.stringify(sanitizeForSerialization(data)));
@@ -194,7 +194,7 @@ const cbpPlatform = (url, options = {
     const actionReplys = [];
     const apiReplys = [];
     const replyAction = (data, payload) => {
-        if (global.chatbotPlatform && global.chatbotPlatform.readyState === WebSocket.OPEN) {
+        if (global.chatbotPlatform?.readyState === WebSocket.OPEN) {
             global.chatbotPlatform.send(flattedJSON.stringify({
                 action: data.action,
                 payload: payload,
@@ -204,7 +204,7 @@ const cbpPlatform = (url, options = {
         }
     };
     const replyApi = (data, payload) => {
-        if (global.chatbotPlatform && global.chatbotPlatform.readyState === WebSocket.OPEN) {
+        if (global.chatbotPlatform?.readyState === WebSocket.OPEN) {
             global.chatbotPlatform.send(flattedJSON.stringify({
                 action: data.action,
                 apiId: data.apiId,

package/lib/cbp/server/main.js

@@ -15,7 +15,7 @@ import { getClientChild } from '../../process/ipc-bridge.js';
 const routeMessageToDevice = (DeviceId, message) => {
     if (childrenClient.has(DeviceId)) {
         const clientWs = childrenClient.get(DeviceId);
-        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+        if (clientWs?.readyState === WebSocket.OPEN) {
             clientWs.send(message);
         }
         else {
@@ -24,7 +24,7 @@ const routeMessageToDevice = (DeviceId, message) => {
     }
     else if (fullClient.has(DeviceId)) {
         const clientWs = fullClient.get(DeviceId);
-        if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+        if (clientWs?.readyState === WebSocket.OPEN) {
             clientWs.send(message);
         }
         else {
@@ -90,7 +90,7 @@ const handleEvent = (message, ID) => {
         });
         if (bindId) {
             const clientWs = childrenClient.get(bindId);
-            if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+            if (clientWs?.readyState === WebSocket.OPEN) {
                 bindChannelToClient(ID, bindId);
                 clientWs.send(message);
             }
@@ -118,7 +118,7 @@ const handleEvent = (message, ID) => {
         return;
     }
     const clientWs = childrenClient.get(bindId);
-    if (!clientWs || clientWs.readyState !== WebSocket.OPEN) {
+    if (clientWs?.readyState !== WebSocket.OPEN) {
         childrenClient.delete(bindId);
         reBind();
         return;
@@ -129,7 +129,7 @@ const setChildrenClient = (originId, ws) => {
     childrenClient.set(originId, ws);
     ws.on('message', (message) => {
         if (global.__sandbox) {
-            if (global.testoneClient && global.testoneClient.readyState === WebSocket.OPEN) {
+            if (global.testoneClient?.readyState === WebSocket.OPEN) {
                 global.testoneClient.send(message.toString());
             }
             return;
@@ -166,7 +166,7 @@ const setFullClient = (originId, ws) => {
     fullClient.set(originId, ws);
     ws.on('message', (message) => {
         if (global.__sandbox) {
-            if (global.testoneClient && global.testoneClient.readyState === WebSocket.OPEN) {
+            if (global.testoneClient?.readyState === WebSocket.OPEN) {
                 global.testoneClient.send(message.toString());
             }
             return;

package/lib/core/utils.js

@@ -1,13 +1,13 @@
 import { createHash as createHash$1 } from 'node:crypto';
 import fs__default, { existsSync, readdirSync } from 'fs';
 import path__default, { join } from 'path';
-import { fileSuffixResponse, ResultCode } from './variable.js';
-import module from 'module';
+import { ResultCode, fileSuffixResponse } from './variable.js';
+import module$1 from 'module';
 import { getConfigValue } from './config.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
-const require = module?.createRequire?.(import.meta.url) ?? initRequire;
+const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
 const createHash = (str, options = {}) => {
     const { length = 11, algorithm = 'sha256' } = options;
     const hash = createHash$1(algorithm).update(str).digest('hex');
@@ -117,7 +117,7 @@ const showErrorModule = (e) => {
     });
 };
 const sanitizeForSerialization = (data) => {
-    const flatted = require('flatted');
+    const flatted = require$1('flatted');
     return flatted.parse(flatted.stringify(data));
 };
 const createExports = (packageJson) => {
@@ -133,7 +133,7 @@ const createExports = (packageJson) => {
 const getInputExportPath = (input) => {
     const packageJsonPath = path__default.join(input ?? process.cwd(), 'package.json');
     if (fs__default.existsSync(packageJsonPath)) {
-        const packageJson = require(packageJsonPath);
+        const packageJson = require$1(packageJsonPath);
         const main = packageJson?.main || createExports(packageJson);
         if (main) {
             return main;

package/lib/index.js

@@ -13,6 +13,7 @@ export { definePlatform } from './app/define-platform.js';
 export { defineResponse } from './app/define-response.js';
 export { defineMiddleware } from './app/define-middleware.js';
 export { defineRouter, lazy } from './app/define-router.js';
+export { FormatEvent, wrapEvent } from './app/event-format.js';
 export { onGroup } from './app/event-group.js';
 export { OnMiddleware, onMiddleware } from './app/event-middleware.js';
 export { OnProcessor, onProcessor } from './app/event-processor.js';
@@ -36,9 +37,10 @@ export { useReaction } from './app/hook-use/reaction.js';
 export { useRequest } from './app/hook-use/request.js';
 export { useRole } from './app/hook-use/role.js';
 export { useUser } from './app/hook-use/user.js';
+export { useObserver, useSubscribe } from './app/hook-use/subscribe.js';
+export { useEvent } from './app/hook-use/event.js';
 export { getCurrentEvent, withEventContext } from './app/hook-event-context.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './app/event-utils.js';
-export { useObserver, useSubscribe } from './app/hook-use-subscribe.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './app/message-api.js';
 export { Format, FormatButtonGroup, FormatMarkDown, createEvent } from './app/message-format.js';
 export { start } from './main.js';

package/lib/process/module.js

@@ -2,12 +2,12 @@ import childProcess from 'child_process';
 import { ResultCode } from '../core/variable.js';
 import { getConfigValue } from '../core/config.js';
 import '../core/utils.js';
-import module from 'module';
+import module$1 from 'module';
 import { setClientChild, forwardFromClient } from './ipc-bridge.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
-const require = module?.createRequire?.(import.meta.url) ?? initRequire;
+const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
 function startModuleAdapter() {
     const values = getConfigValue();
     const pro = values?.process ?? {};
@@ -17,7 +17,7 @@ function startModuleAdapter() {
         FORK_TIMEOUT: pro?.fork_timeout ?? 6000
     };
     try {
-        modulePath = require.resolve('../client.js');
+        modulePath = require$1.resolve('../client.js');
     }
     catch (error) {
         logger?.warn?.({

package/lib/process/platform.js

@@ -2,12 +2,12 @@ import childProcess from 'child_process';
 import { ResultCode } from '../core/variable.js';
 import { getConfigValue } from '../core/config.js';
 import '../core/utils.js';
-import module from 'module';
+import module$1 from 'module';
 import { setPlatformChild, forwardFromPlatform } from './ipc-bridge.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
-const require = module?.createRequire?.(import.meta.url) ?? initRequire;
+const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
 function startPlatformAdapterWithFallback() {
     const values = getConfigValue();
     const pro = values?.process ?? {};
@@ -29,7 +29,7 @@ function startPlatformAdapterWithFallback() {
     let isForkFailed = false;
     let imported = false;
     try {
-        modulePath = require.resolve(platformPath);
+        modulePath = require$1.resolve(platformPath);
     }
     catch {
         logger?.warn?.({

package/lib/server/routers/router.js

@@ -3,16 +3,16 @@ import fs__default, { existsSync } from 'fs';
 import path__default, { join, dirname } from 'path';
 import mime from 'mime-types';
 import hello from './hello.html.js';
-import { getModuelFile, formatPath } from './utils.js';
+import { safePath, getModuelFile, formatPath, isValidPackageName } from './utils.js';
 import { collectMiddlewares, runMiddlewares } from './middleware.js';
 import { ResultCode } from '../../core/variable.js';
 import 'yaml';
 import '../../core/utils.js';
-import module from 'module';
+import module$1 from 'module';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
-const require = module?.createRequire?.(import.meta.url) ?? initRequire;
+const require$1 = module$1?.createRequire?.(import.meta.url) ?? initRequire;
 const mainDirMap = new Map();
 const router = new KoaRouter({
     prefix: '/'
@@ -55,7 +55,17 @@ router.all('app/{*path}', async (ctx) => {
         }
         const mainDir = dirname(mainPath);
         try {
-            const dir = join(mainDir, 'route', ctx.path?.replace(apiPath, '/api') || '');
+            const routeBase = join(mainDir, 'route');
+            const dir = safePath(routeBase, ctx.path?.replace(apiPath, '/api') || '');
+            if (!dir) {
+                ctx.status = 403;
+                ctx.body = {
+                    code: 403,
+                    message: '非法路径',
+                    data: null
+                };
+                return;
+            }
             if (existsSync(dir) && fs__default.statSync(dir).isFile()) {
                 ctx.status = 404;
                 ctx.body = {
@@ -102,7 +112,7 @@ router.all('app/{*path}', async (ctx) => {
     let root = '';
     const resourcePath = formatPath(ctx.params?.path);
     try {
-        const pkg = require(path__default.join(rootPath, 'package.json')) ?? {};
+        const pkg = require$1(path__default.join(rootPath, 'package.json')) ?? {};
         root = pkg.alemonjs?.web?.root ?? '';
     }
     catch (err) {
@@ -114,7 +124,17 @@ router.all('app/{*path}', async (ctx) => {
         };
         return;
     }
-    const fullPath = root ? path__default.join(rootPath, root, resourcePath) : path__default.join(rootPath, resourcePath);
+    const webRoot = root ? path__default.join(rootPath, root) : rootPath;
+    const fullPath = safePath(webRoot, resourcePath);
+    if (!fullPath) {
+        ctx.status = 403;
+        ctx.body = {
+            code: 403,
+            message: '非法路径',
+            data: null
+        };
+        return;
+    }
     try {
         const file = await fs__default.promises.readFile(fullPath);
         const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
@@ -146,11 +166,20 @@ router.all('app', ctx => {
 });
 router.all('apps/:app/{*path}', async (ctx) => {
     const appName = ctx.params.app;
+    if (!isValidPackageName(appName)) {
+        ctx.status = 400;
+        ctx.body = {
+            code: 400,
+            message: '无效的应用名称',
+            data: null
+        };
+        return;
+    }
     const apiPath = `/apps/${appName}/api`;
     if (ctx.path.startsWith(apiPath)) {
         try {
             if (!mainDirMap.has(appName)) {
-                const mainPath = require.resolve(appName);
+                const mainPath = require$1.resolve(appName);
                 if (!existsSync(mainPath)) {
                     ctx.status = 400;
                     ctx.body = {
@@ -163,7 +192,17 @@ router.all('apps/:app/{*path}', async (ctx) => {
                 const mainDir = dirname(mainPath);
                 mainDirMap.set(appName, mainDir);
             }
-            const dir = join(mainDirMap.get(appName), 'route', ctx.path?.replace(apiPath, '/api') || '');
+            const routeBase = join(mainDirMap.get(appName), 'route');
+            const dir = safePath(routeBase, ctx.path?.replace(apiPath, '/api') || '');
+            if (!dir) {
+                ctx.status = 403;
+                ctx.body = {
+                    code: 403,
+                    message: '非法路径',
+                    data: null
+                };
+                return;
+            }
             if (existsSync(dir) && fs__default.statSync(dir).isFile()) {
                 ctx.status = 404;
                 ctx.body = {
@@ -215,7 +254,7 @@ router.all('apps/:app/{*path}', async (ctx) => {
     const resourcePath = formatPath(ctx.params?.path);
     let root = '';
     try {
-        const pkg = require(`${appName}/package`) ?? {};
+        const pkg = require$1(`${appName}/package`) ?? {};
         root = pkg?.alemonjs?.web?.root ?? '';
     }
     catch (err) {
@@ -227,7 +266,17 @@ router.all('apps/:app/{*path}', async (ctx) => {
         };
         return;
     }
-    const fullPath = root ? path__default.join(rootPath, root, resourcePath) : path__default.join(rootPath, resourcePath);
+    const webRoot = root ? path__default.join(rootPath, root) : rootPath;
+    const fullPath = safePath(webRoot, resourcePath);
+    if (!fullPath) {
+        ctx.status = 403;
+        ctx.body = {
+            code: 403,
+            message: '非法路径',
+            data: null
+        };
+        return;
+    }
     try {
         const file = await fs__default.promises.readFile(fullPath);
         const mimeType = mime.lookup(fullPath) || 'application/octet-stream';

package/lib/server/routers/utils.d.ts

@@ -1,2 +1,4 @@
+export declare const safePath: (root: string, untrusted: string) => string | null;
+export declare const isValidPackageName: (name: string) => boolean;
 export declare const getModuelFile: (dir: string) => string;
 export declare const formatPath: (path: string) => string;

package/lib/server/routers/utils.js

@@ -1,5 +1,16 @@
 import fs__default, { existsSync } from 'fs';
+import path__default from 'path';
 
+const safePath = (root, untrusted) => {
+    const resolved = path__default.resolve(root, untrusted);
+    if (resolved !== root && !resolved.startsWith(root + path__default.sep)) {
+        return null;
+    }
+    return resolved;
+};
+const isValidPackageName = (name) => {
+    return /^(?:@[a-z0-9\-~][a-z0-9\-._~]*\/)?[a-z0-9\-~][a-z0-9\-._~]*$/.test(name);
+};
 const getModuelFile = (dir) => {
     const dirMap = {
         '.js': `${dir}.js`,
@@ -36,4 +47,4 @@ const formatPath = (path) => {
     return path;
 };
 
-export { formatPath, getModuelFile };
+export { formatPath, getModuelFile, isValidPackageName, safePath };

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

@@ -1,4 +1,4 @@
-export type platform = {
+export type Platform = {
     Platform: string;
     value: any;
     BotId?: string;

package/lib/types/event/builder.d.ts

@@ -0,0 +1,36 @@
+import { Guild, Channel } from './base/guild';
+import { Message, MessageText, MessageMedia, MessageOpen } from './base/message';
+import { Platform } from './base/platform';
+import { User } from './base/user';
+import { AutoFields } from './base/auto';
+import { EventKeys, Events } from './map';
+export type ReservedEventKeys = keyof Guild | keyof Channel | keyof User | keyof Message | keyof MessageText | keyof MessageMedia | keyof MessageOpen | keyof Platform | keyof AutoFields | 'name' | 'Timestamp';
+type GuildMethods<T extends EventKeys> = Events[T] extends Guild ? {
+    addGuild(params: Guild): EventBuilder<T>;
+} : Record<string, never>;
+type ChannelMethods<T extends EventKeys> = Events[T] extends Channel ? {
+    addChannel(params: Channel): EventBuilder<T>;
+} : Record<string, never>;
+type UserMethods<T extends EventKeys> = Events[T] extends User ? {
+    addUser(params: User): EventBuilder<T>;
+} : Record<string, never>;
+type MessageMethods<T extends EventKeys> = Events[T] extends Message ? {
+    addMessage(params: Message): EventBuilder<T>;
+} : Record<string, never>;
+type TextMethods<T extends EventKeys> = Events[T] extends MessageText ? {
+    addText(params: MessageText): EventBuilder<T>;
+} : Record<string, never>;
+type MediaMethods<T extends EventKeys> = Events[T] extends MessageMedia ? {
+    addMedia(params: MessageMedia): EventBuilder<T>;
+} : Record<string, never>;
+type OpenMethods<T extends EventKeys> = Events[T] extends MessageOpen ? {
+    addOpen(params: MessageOpen): EventBuilder<T>;
+} : Record<string, never>;
+export type EventBuilder<T extends EventKeys> = {
+    addPlatform(params: Platform): EventBuilder<T>;
+    add<E extends Record<string, unknown>>(fields: {
+        [K in keyof E]: K extends ReservedEventKeys ? never : E[K];
+    }): EventBuilder<T>;
+    readonly value: Events[T];
+} & GuildMethods<T> & ChannelMethods<T> & UserMethods<T> & MessageMethods<T> & TextMethods<T> & MediaMethods<T> & OpenMethods<T>;
+export {};

package/lib/types/event/builder.js

@@ -0,0 +1 @@
+

package/lib/types/event/channel/index.d.ts

@@ -1,13 +1,13 @@
 import { Guild, Channel } from '../base/guild';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { Message } from '../base/message';
 import { Expansion } from '../base/expansion';
-export type PublicEventChannelCreate = platform & Guild & Channel & Message & {
+export type PublicEventChannelCreate = Platform & Guild & Channel & Message & {
     name: 'channel.create';
 } & Expansion;
-export type PublicEventChannelDelete = platform & Guild & Channel & Message & {
+export type PublicEventChannelDelete = Platform & Guild & Channel & Message & {
     name: 'channel.delete';
 } & Expansion;
-export type PublicEventChannelUpdate = platform & Guild & Channel & Message & {
+export type PublicEventChannelUpdate = Platform & Guild & Channel & Message & {
     name: 'channel.update';
 } & Expansion;

package/lib/types/event/guild/index.d.ts

@@ -1,14 +1,14 @@
 import { Expansion } from '../base/expansion';
 import { Channel, Guild } from '../base/guild';
 import { Message } from '../base/message';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { User } from '../base/user';
-export type PublicEventGuildJoin = platform & Guild & Channel & Message & User & {
+export type PublicEventGuildJoin = Platform & Guild & Channel & Message & User & {
     name: 'guild.join';
 } & Expansion;
-export type PublicEventGuildExit = platform & Guild & Channel & Message & User & {
+export type PublicEventGuildExit = Platform & Guild & Channel & Message & User & {
     name: 'guild.exit';
 } & Expansion;
-export type PublicEventGuildUpdate = platform & Guild & Channel & Message & {
+export type PublicEventGuildUpdate = Platform & Guild & Channel & Message & {
     name: 'guild.update';
 } & Expansion;

package/lib/types/event/interaction/index.d.ts

@@ -1,11 +1,11 @@
 import { Guild, Channel } from '../base/guild';
 import { Message, MessageOpen, MessageText } from '../base/message';
 import { User } from '../base/user';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { Expansion } from '../base/expansion';
-export type PrivateEventInteractionCreate = MessageText & MessageOpen & platform & Message & User & {
+export type PrivateEventInteractionCreate = MessageText & MessageOpen & Platform & Message & User & {
     name: 'private.interaction.create';
 } & Expansion;
-export type PublicEventInteractionCreate = MessageText & MessageOpen & platform & Guild & Channel & Message & User & {
+export type PublicEventInteractionCreate = MessageText & MessageOpen & Platform & Guild & Channel & Message & User & {
     name: 'interaction.create';
 } & Expansion;

package/lib/types/event/member/index.d.ts

@@ -1,20 +1,20 @@
 import { Guild, Channel } from '../base/guild';
 import { Message } from '../base/message';
 import { User } from '../base/user';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { Expansion } from '../base/expansion';
-export type PublicEventMemberAdd = platform & Guild & Channel & Message & User & {
+export type PublicEventMemberAdd = Platform & Guild & Channel & Message & User & {
     name: 'member.add';
 } & Expansion;
-export type PublicEventMemberRemove = platform & Guild & Channel & Message & User & {
+export type PublicEventMemberRemove = Platform & Guild & Channel & Message & User & {
     name: 'member.remove';
 } & Expansion;
-export type PublicEventMemberBan = platform & Guild & Channel & Message & User & {
+export type PublicEventMemberBan = Platform & Guild & Channel & Message & User & {
     name: 'member.ban';
 } & Expansion;
-export type PublicEventMemberUnban = platform & Guild & Channel & Message & User & {
+export type PublicEventMemberUnban = Platform & Guild & Channel & Message & User & {
     name: 'member.unban';
 } & Expansion;
-export type PublicEventMemberUpdate = platform & Guild & Channel & Message & User & {
+export type PublicEventMemberUpdate = Platform & Guild & Channel & Message & User & {
     name: 'member.update';
 } & Expansion;

package/lib/types/event/message/message.d.ts

@@ -1,23 +1,23 @@
 import { Guild, Channel } from '../base/guild';
 import { Message, MessageMedia, MessageOpen, MessageText } from '../base/message';
 import { User } from '../base/user';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { Expansion } from '../base/expansion';
-export type PublicEventMessageCreate = MessageText & MessageMedia & MessageOpen & platform & Guild & Channel & Message & User & {
+export type PublicEventMessageCreate = MessageText & MessageMedia & MessageOpen & Platform & Guild & Channel & Message & User & {
     name: 'message.create';
 } & Expansion;
-export type PublicEventMessageUpdate = platform & Guild & Channel & Message & User & {
+export type PublicEventMessageUpdate = Platform & Guild & Channel & Message & User & {
     name: 'message.update';
 } & Expansion;
-export type PublicEventMessageDelete = platform & Guild & Channel & Message & {
+export type PublicEventMessageDelete = Platform & Guild & Channel & Message & {
     name: 'message.delete';
 } & Expansion;
-export type PublicEventMessageReactionAdd = platform & Guild & Channel & Message & {
+export type PublicEventMessageReactionAdd = Platform & Guild & Channel & Message & {
     name: 'message.reaction.add';
 } & Expansion;
-export type PublicEventMessageReactionRemove = platform & Guild & Channel & Message & {
+export type PublicEventMessageReactionRemove = Platform & Guild & Channel & Message & {
     name: 'message.reaction.remove';
 } & Expansion;
-export type PublicEventMessagePin = platform & Guild & Channel & Message & {
+export type PublicEventMessagePin = Platform & Guild & Channel & Message & {
     name: 'message.pin';
 } & Expansion;

package/lib/types/event/message/private.message.d.ts

@@ -1,13 +1,13 @@
 import { Expansion } from '../base/expansion';
 import { Message, MessageMedia, MessageOpen, MessageText } from '../base/message';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { User } from '../base/user';
-export type PrivateEventMessageCreate = MessageText & MessageMedia & MessageOpen & platform & Message & User & {
+export type PrivateEventMessageCreate = MessageText & MessageMedia & MessageOpen & Platform & Message & User & {
     name: 'private.message.create';
 } & Expansion;
-export type PrivateEventMessageUpdate = platform & Message & User & {
+export type PrivateEventMessageUpdate = Platform & Message & User & {
     name: 'private.message.update';
 } & Expansion;
-export type PrivateEventMessageDelete = platform & Message & {
+export type PrivateEventMessageDelete = Platform & Message & {
     name: 'private.message.delete';
 } & Expansion;

package/lib/types/event/notice/index.d.ts

@@ -1,11 +1,11 @@
 import { Guild, Channel } from '../base/guild';
 import { Message } from '../base/message';
 import { User } from '../base/user';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { Expansion } from '../base/expansion';
-export type PublicEventNoticeCreate = platform & Guild & Channel & Message & User & {
+export type PublicEventNoticeCreate = Platform & Guild & Channel & Message & User & {
     name: 'notice.create';
 } & Expansion;
-export type PrivateEventNoticeCreate = platform & Message & User & {
+export type PrivateEventNoticeCreate = Platform & Message & User & {
     name: 'private.notice.create';
 } & Expansion;

package/lib/types/event/request/index.d.ts

@@ -1,13 +1,13 @@
 import { Expansion } from '../base/expansion';
 import { Message } from '../base/message';
-import { platform } from '../base/platform';
+import { Platform } from '../base/platform';
 import { User } from '../base/user';
-export type PrivateEventRequestFriendAdd = platform & Message & User & {
+export type PrivateEventRequestFriendAdd = Platform & Message & User & {
     name: 'private.friend.add';
 } & Expansion;
-export type PrivateEventRequestGuildAdd = platform & Message & User & {
+export type PrivateEventRequestGuildAdd = Platform & Message & User & {
     name: 'private.guild.add';
 } & Expansion;
-export type PrivateEventRequestFriendRemove = platform & Message & User & {
+export type PrivateEventRequestFriendRemove = Platform & Message & User & {
     name: 'private.friend.remove';
 } & Expansion;

package/lib/types/index.d.ts

@@ -16,6 +16,7 @@ export * from './event/request/index';
 export * from './event/actions';
 export * from './event/index';
 export * from './event/map';
+export * from './event/builder';
 export * from './logger/index';
 export * from './client/index';
 export * from './message/index';

package/lib/utils.js

@@ -1,4 +1,4 @@
-import { writeFile, existsSync, createReadStream } from 'fs';
+import { existsSync, createReadStream, writeFile } from 'fs';
 import axios from 'axios';
 import { toDataURL } from 'qrcode';
 import { isReadable, Readable } from 'node:stream';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.49",
+  "version": "2.1.50",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -69,5 +69,5 @@
     "type": "git",
     "url": "https://github.com/lemonade-lab/alemonjs.git"
   },
-  "gitHead": "c6aa5616afe091a37610dad22fbb2d2618d943b8"
-}
+  "gitHead": "41d135f9d54dda92785d1bec929db4afcf4a3f25"
+}