alemonjs 2.1.56 → 2.1.57

package/lib/app/api/schedule.d.ts

@@ -0,0 +1,17 @@
+import { ScheduleCallback, CronExpression } from '../../types/schedule';
+export declare const setInterval: (callback: ScheduleCallback, ms: number) => string;
+export declare const setTimeout: (callback: ScheduleCallback, ms: number) => string;
+export declare const setCron: (expression: CronExpression, callback: ScheduleCallback) => string;
+export declare const clearInterval: (id: import("../..").ScheduleId) => boolean;
+export declare const clearTimeout: (id: import("../..").ScheduleId) => boolean;
+export declare const pauseSchedule: (id: import("../..").ScheduleId) => boolean;
+export declare const resumeSchedule: (id: import("../..").ScheduleId) => boolean;
+export declare const listSchedule: (appName?: string) => Array<{
+    id: import("../..").ScheduleId;
+    type: import("../..").ScheduleItem["type"];
+    status: import("../..").ScheduleStatus;
+    ms?: number;
+    cron?: string;
+    appName?: string;
+    createdAt: number;
+}>;

package/lib/app/api/schedule.js

@@ -0,0 +1,12 @@
+import { scheduleCancel, scheduleList, schedulePause, scheduleResume, scheduleCron, scheduleInterval, scheduleTimeout } from '../schedule-store.js';
+
+const setInterval = (callback, ms) => scheduleInterval(callback, ms);
+const setTimeout = (callback, ms) => scheduleTimeout(callback, ms);
+const setCron = (expression, callback) => scheduleCron(expression, callback);
+const clearInterval = scheduleCancel;
+const clearTimeout = scheduleCancel;
+const pauseSchedule = schedulePause;
+const resumeSchedule = scheduleResume;
+const listSchedule = scheduleList;
+
+export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout };

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

@@ -1,6 +1,7 @@
 import { GuildInfo, Result, User } from './common';
 export declare const useMe: () => readonly [{
     info: () => Promise<Result<User | null>>;
+    isMentionMe: () => Result<boolean>;
     guilds: () => Promise<Result<GuildInfo[]>>;
     threads: () => Promise<Result<User | null>>;
     friends: () => Promise<Result<User | null>>;

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

@@ -28,6 +28,14 @@ const useMe = () => {
             return createResult(ResultCode.Fail, 'Failed to get bot information', null);
         }
     };
+    const isMentionMe = () => {
+        try {
+            return createResult(ResultCode.Warn, 'No bot information found', false);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get bot information', false);
+        }
+    };
     const guilds = async () => {
         try {
             const results = await sendAction({
@@ -80,6 +88,7 @@ const useMe = () => {
     };
     const control = {
         info,
+        isMentionMe,
         guilds,
         threads,
         friends

package/lib/app/index.d.ts

@@ -16,7 +16,9 @@ export * from './event-processor-event.js';
 export * from './event-processor-middleware.js';
 export * from './event-processor-subscribe.js';
 export * from './hook-use/index.js';
+export * from './api/schedule.js';
 export * from './hook-event-context.js';
+export * from './schedule-store.js';
 export * from './event-utils.js';
 export * from './message-api.js';
 export * from './message-format.js';

package/lib/app/index.js

@@ -33,7 +33,9 @@ export { useRole } from './hook-use/role.js';
 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 { getCurrentEvent, getCurrentNext, withEventContext } 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';
 export { Format, FormatButtonGroup, FormatMarkDown } from './message-format.js';

package/lib/app/load_modules/loadChild.js

@@ -4,6 +4,7 @@ import { showErrorModule, getRecursiveDirFiles, createEventName } from '../../co
 import { ChildrenApp } from '../store.js';
 import { registerExpose } from '../expose.js';
 import { ResultCode, fileSuffixMiddleware } from '../../core/variable.js';
+import { registerAppDir, scheduleCancelByApp, unregisterAppDir } from '../schedule-store.js';
 import module$1 from 'module';
 
 const initRequire = () => { };
@@ -20,6 +21,7 @@ const loadChildren = async (mainPath, appName) => {
     }
     const mainDir = dirname(mainPath);
     const App = new ChildrenApp(appName);
+    registerAppDir(appName, mainDir);
     try {
         const moduleApp = await import(`file://${mainPath}`);
         if (!moduleApp?.default) {
@@ -44,6 +46,8 @@ const loadChildren = async (mainPath, appName) => {
         App.pushCycle(app);
         const unMounted = async (e) => {
             showErrorModule(e);
+            scheduleCancelByApp(appName);
+            unregisterAppDir(appName);
             App.un();
             try {
                 if (app?.unMounted) {

package/lib/app/schedule-store.d.ts

@@ -0,0 +1,20 @@
+import { ScheduleId, ScheduleItem, ScheduleStatus, ScheduleCallback, CronExpression } from '../types/schedule';
+export declare const registerAppDir: (appName: string, mainDir: string) => void;
+export declare const unregisterAppDir: (appName: string) => void;
+export declare const scheduleInterval: (callback: ScheduleCallback, ms: number, appName?: string) => ScheduleId;
+export declare const scheduleTimeout: (callback: ScheduleCallback, ms: number, appName?: string) => ScheduleId;
+export declare const scheduleCron: (expression: CronExpression, callback: ScheduleCallback, appName?: string) => ScheduleId;
+export declare const schedulePause: (id: ScheduleId) => boolean;
+export declare const scheduleResume: (id: ScheduleId) => boolean;
+export declare const scheduleCancel: (id: ScheduleId) => boolean;
+export declare const scheduleCancelByApp: (appName: string) => number;
+export declare const scheduleCancelAll: () => number;
+export declare const scheduleList: (appName?: string) => Array<{
+    id: ScheduleId;
+    type: ScheduleItem["type"];
+    status: ScheduleStatus;
+    ms?: number;
+    cron?: string;
+    appName?: string;
+    createdAt: number;
+}>;

package/lib/app/schedule-store.js

@@ -0,0 +1,230 @@
+import { ResultCode } from '../core/variable.js';
+import { CronJob } from 'cron';
+
+const scheduleMap = new Map();
+const appDirMap = new Map();
+const registerAppDir = (appName, mainDir) => {
+    appDirMap.set(appName, mainDir);
+};
+const unregisterAppDir = (appName) => {
+    appDirMap.delete(appName);
+};
+const extractCallerPaths = () => {
+    const stack = new Error().stack;
+    if (!stack) {
+        return [];
+    }
+    const paths = [];
+    const lineRegex = /(?:file:\/\/|\(|\s)(\/[^):]+)/g;
+    let m;
+    while ((m = lineRegex.exec(stack)) !== null) {
+        paths.push(m[1]);
+    }
+    return paths;
+};
+const resolveAppName = () => {
+    const callerPaths = extractCallerPaths();
+    for (const filePath of callerPaths) {
+        for (const [name, dir] of appDirMap) {
+            if (filePath.startsWith(dir)) {
+                return name;
+            }
+        }
+    }
+    return 'main';
+};
+const generateId = () => {
+    return Date.now().toString(36) + Math.random().toString(36).substring(2, 15);
+};
+const safeInvoke = (callback, id, type) => {
+    try {
+        const result = callback();
+        if (result instanceof Promise) {
+            result.catch(err => {
+                logger.error({
+                    code: ResultCode.Fail,
+                    message: `Schedule ${type} error [${id}]: ${err?.message ?? err}`,
+                    data: null
+                });
+            });
+        }
+    }
+    catch (err) {
+        logger.error({
+            code: ResultCode.Fail,
+            message: `Schedule ${type} error [${id}]: ${err?.message ?? err}`,
+            data: null
+        });
+    }
+};
+const scheduleInterval = (callback, ms, appName) => {
+    if (ms <= 0) {
+        throw new Error('Interval ms must be greater than 0');
+    }
+    const resolvedApp = appName ?? resolveAppName();
+    const id = generateId();
+    const timer = setInterval(() => {
+        safeInvoke(callback, id, 'interval');
+    }, ms);
+    const item = {
+        id,
+        type: 'interval',
+        status: 'active',
+        callback,
+        ms,
+        _timer: timer,
+        appName: resolvedApp,
+        createdAt: Date.now()
+    };
+    scheduleMap.set(id, item);
+    return id;
+};
+const scheduleTimeout = (callback, ms, appName) => {
+    if (ms < 0) {
+        throw new Error('Timeout ms must be >= 0');
+    }
+    const resolvedApp = appName ?? resolveAppName();
+    const id = generateId();
+    const timer = setTimeout(() => {
+        safeInvoke(callback, id, 'timeout');
+        const item = scheduleMap.get(id);
+        if (item) {
+            item.status = 'stopped';
+            item._timer = null;
+        }
+        scheduleMap.delete(id);
+    }, ms);
+    const item = {
+        id,
+        type: 'timeout',
+        status: 'active',
+        callback,
+        ms,
+        _timer: timer,
+        appName: resolvedApp,
+        createdAt: Date.now()
+    };
+    scheduleMap.set(id, item);
+    return id;
+};
+const scheduleCron = (expression, callback, appName) => {
+    const resolvedApp = appName ?? resolveAppName();
+    const id = generateId();
+    const job = CronJob.from({
+        cronTime: expression,
+        onTick: () => {
+            safeInvoke(callback, id, 'cron');
+        },
+        start: true
+    });
+    const item = {
+        id,
+        type: 'cron',
+        status: 'active',
+        callback,
+        cron: expression,
+        _timer: job,
+        appName: resolvedApp,
+        createdAt: Date.now()
+    };
+    scheduleMap.set(id, item);
+    return id;
+};
+const clearTimer = (item) => {
+    if (item._timer === null || item._timer === undefined) {
+        return;
+    }
+    if (item.type === 'cron') {
+        void item._timer.stop();
+    }
+    else if (item.type === 'interval') {
+        clearInterval(item._timer);
+    }
+    else {
+        clearTimeout(item._timer);
+    }
+    item._timer = null;
+};
+const schedulePause = (id) => {
+    const item = scheduleMap.get(id);
+    if (item?.status !== 'active') {
+        return false;
+    }
+    clearTimer(item);
+    item.status = 'paused';
+    return true;
+};
+const scheduleResume = (id) => {
+    const item = scheduleMap.get(id);
+    if (item?.status !== 'paused') {
+        return false;
+    }
+    if (item.type === 'interval' && item.ms) {
+        item._timer = setInterval(() => {
+            safeInvoke(item.callback, id, 'interval');
+        }, item.ms);
+        item.status = 'active';
+        return true;
+    }
+    if (item.type === 'cron' && item.cron) {
+        const job = CronJob.from({
+            cronTime: item.cron,
+            onTick: () => {
+                safeInvoke(item.callback, id, 'cron');
+            },
+            start: true
+        });
+        item._timer = job;
+        item.status = 'active';
+        return true;
+    }
+    return false;
+};
+const scheduleCancel = (id) => {
+    const item = scheduleMap.get(id);
+    if (!item) {
+        return false;
+    }
+    clearTimer(item);
+    item.status = 'stopped';
+    scheduleMap.delete(id);
+    return true;
+};
+const scheduleCancelByApp = (appName) => {
+    let count = 0;
+    for (const [id, item] of scheduleMap) {
+        if (item.appName === appName) {
+            scheduleCancel(id);
+            count++;
+        }
+    }
+    return count;
+};
+const scheduleCancelAll = () => {
+    let count = 0;
+    for (const [id] of scheduleMap) {
+        scheduleCancel(id);
+        count++;
+    }
+    return count;
+};
+const scheduleList = (appName) => {
+    const result = [];
+    for (const [, item] of scheduleMap) {
+        if (appName && item.appName !== appName) {
+            continue;
+        }
+        result.push({
+            id: item.id,
+            type: item.type,
+            status: item.status,
+            ms: item.ms,
+            cron: item.cron,
+            appName: item.appName,
+            createdAt: item.createdAt
+        });
+    }
+    return result;
+};
+
+export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir };

package/lib/cbp/connects/client.js

@@ -17,6 +17,7 @@ import '../../app/hook-event-context.js';
 import { apiResolves, apiTimeouts, actionResolves, actionTimeouts, FULL_RECEIVE_HEADER } from '../processor/config.js';
 import { setDirectSend } from '../processor/transport.js';
 import '../../app/message-format-old.js';
+import 'cron';
 import '../../app/event-utils.js';
 import '../../app/message-api.js';
 import { createWSConnector } from './base.js';

package/lib/client.js

@@ -28,6 +28,7 @@ import './app/event-processor.js';
 import './app/event-response.js';
 import './app/hook-event-context.js';
 import './app/message-format-old.js';
+import 'cron';
 import './app/event-utils.js';
 import './app/message-api.js';
 import './process/platform.js';

package/lib/index.js

@@ -40,7 +40,9 @@ 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 { createEvent, useEvent } from './app/hook-use/event.js';
+export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './app/api/schedule.js';
 export { getCurrentEvent, getCurrentNext, withEventContext } 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';
 export { Format, FormatButtonGroup, FormatMarkDown } from './app/message-format.js';

package/lib/types/index.d.ts

@@ -25,6 +25,7 @@ export * from './state/index';
 export * from './store/res';
 export * from './expose/index';
 export * from './subscribe';
+export * from './schedule';
 export * from './standard';
 export * from './actions';
 export * from './apis';

package/lib/types/schedule/index.d.ts

@@ -0,0 +1,23 @@
+export type ScheduleId = string;
+export type ScheduleType = 'interval' | 'timeout' | 'cron';
+export type ScheduleStatus = 'active' | 'paused' | 'stopped';
+export type CronExpression = string;
+export type ScheduleCallback = () => void | Promise<void>;
+export interface ScheduleItem {
+    id: ScheduleId;
+    type: ScheduleType;
+    status: ScheduleStatus;
+    callback: ScheduleCallback;
+    ms?: number;
+    cron?: CronExpression;
+    _timer?: any;
+    appName?: string;
+    createdAt: number;
+}
+export type ScheduleMap = Map<ScheduleId, ScheduleItem>;
+export interface ScheduleTools {
+    setInterval: (callback: ScheduleCallback, ms: number) => ScheduleId;
+    setTimeout: (callback: ScheduleCallback, ms: number) => ScheduleId;
+    setCron: (expression: CronExpression, callback: ScheduleCallback) => ScheduleId;
+    cancel: (id: ScheduleId) => boolean;
+}

package/lib/types/schedule/index.js

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.56",
+  "version": "2.1.57",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "axios": "^1.14.0",
     "chalk": "^5.6.2",
     "commander": "^13.1.0",
+    "cron": "^4.4.0",
     "file-type": "21.0.0",
     "flatted": "^3.3.3",
     "koa": "^3.0.1",