@whyour/qinglong 2.19.2-2 → 2.20.0-2

package/static/build/services/dependence.js

@@ -86,23 +86,24 @@ let DependenceService = class DependenceService {
         await dependence_1.DependenceModel.destroy({ where: { id: ids } });
     }
     async dependencies({ searchValue, type, status, }, sort = [], query = {}) {
-        let condition = Object.assign(Object.assign({}, query), { type: dependence_1.DependenceTypes[type] });
+        let condition = query;
+        if (dependence_1.DependenceTypes[type]) {
+            condition.type = dependence_1.DependenceTypes[type];
+        }
         if (status) {
             condition.status = status.split(',').map(Number);
         }
         if (searchValue) {
             const encodeText = encodeURI(searchValue);
-            const reg = {
+            condition.name = {
                 [sequelize_1.Op.or]: [
                     { [sequelize_1.Op.like]: `%${searchValue}%` },
                     { [sequelize_1.Op.like]: `%${encodeText}%` },
                 ],
             };
-            condition = Object.assign(Object.assign({}, condition), { name: reg });
         }
         try {
-            const result = await this.find(condition, sort);
-            return result;
+            return await this.find(condition, sort);
         }
         catch (error) {
             throw error;

package/static/build/services/env.js

@@ -15,12 +15,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const groupBy_1 = __importDefault(require("lodash/groupBy"));
+const sequelize_1 = require("sequelize");
 const typedi_1 = require("typedi");
 const winston_1 = __importDefault(require("winston"));
 const config_1 = __importDefault(require("../config"));
 const env_1 = require("../data/env");
-const groupBy_1 = __importDefault(require("lodash/groupBy"));
-const sequelize_1 = require("sequelize");
 const utils_1 = require("../shared/utils");
 let EnvService = class EnvService {
     constructor(logger) {
@@ -128,6 +128,7 @@ let EnvService = class EnvService {
         }
         try {
             const result = await this.find(condition, [
+                ['isPinned', 'DESC'],
                 ['position', 'DESC'],
                 ['createdAt', 'ASC'],
             ]);
@@ -163,6 +164,12 @@ let EnvService = class EnvService {
         await env_1.EnvModel.update({ name }, { where: { id: ids } });
         await this.set_envs();
     }
+    async pin(ids) {
+        await env_1.EnvModel.update({ isPinned: 1 }, { where: { id: ids } });
+    }
+    async unPin(ids) {
+        await env_1.EnvModel.update({ isPinned: 0 }, { where: { id: ids } });
+    }
     async set_envs() {
         const envs = await this.envs('', {
             name: { [sequelize_1.Op.not]: null },

package/static/build/services/notify.js

@@ -454,15 +454,27 @@ let NotificationService = class NotificationService {
         }
     }
     async lark() {
-        let { larkKey } = this.params;
+        let { larkKey, larkSecret } = this.params;
         if (!larkKey.startsWith('http')) {
             larkKey = `https://open.feishu.cn/open-apis/bot/v2/hook/${larkKey}`;
         }
+        const body = {
+            msg_type: 'text',
+            content: { text: `${this.title}\n\n${this.content}` },
+        };
+        // Add signature if secret is provided
+        // Note: Feishu's signature algorithm uses timestamp+"\n"+secret as the HMAC key
+        // and signs an empty message, which differs from typical HMAC usage
+        if (larkSecret) {
+            const timestamp = Math.floor(Date.now() / 1000).toString();
+            const stringToSign = `${timestamp}\n${larkSecret}`;
+            const hmac = crypto_1.default.createHmac('sha256', stringToSign);
+            const sign = hmac.digest('base64');
+            body.timestamp = timestamp;
+            body.sign = sign;
+        }
         try {
-            const res = await http_1.httpClient.post(larkKey, Object.assign(Object.assign({}, this.gotOption), { json: {
-                    msg_type: 'text',
-                    content: { text: `${this.title}\n\n${this.content}` },
-                }, headers: { 'Content-Type': 'application/json' } }));
+            const res = await http_1.httpClient.post(larkKey, Object.assign(Object.assign({}, this.gotOption), { json: body, headers: { 'Content-Type': 'application/json' } }));
             if (res.StatusCode === 0 || res.code === 0) {
                 return true;
             }

package/static/build/services/schedule.js

@@ -87,7 +87,7 @@ let ScheduleService = class ScheduleService {
     }
     async createCronTask({ id = 0, command, name, schedule = '', runOrigin }, callbacks, runImmediately = false) {
         const _id = this.formatId(id);
-        this.logger.info('[panel][创建cron任务], 任务ID: %s, cron: %s, 任务名: %s, 执行命令: %s', _id, schedule, name, command);
+        this.logger.info('[panel][创建cron任务] 任务ID: %s, cron: %s, 任务名: %s, 执行命令: %s', _id, schedule, name, command);
         this.scheduleStacks.set(_id, node_schedule_1.default.scheduleJob(_id, schedule, async () => {
             this.runTask(command, callbacks, {
                 name,
@@ -110,7 +110,7 @@ let ScheduleService = class ScheduleService {
     async cancelCronTask({ id = 0, name }) {
         var _a;
         const _id = this.formatId(id);
-        this.logger.info('[panel][取消定时任务], 任务名: %s', name);
+        this.logger.info('[panel][取消定时任务] 任务名: %s', name);
         if (this.scheduleStacks.has(_id)) {
             (_a = this.scheduleStacks.get(_id)) === null || _a === void 0 ? void 0 : _a.cancel();
             this.scheduleStacks.delete(_id);
@@ -118,7 +118,7 @@ let ScheduleService = class ScheduleService {
     }
     async createIntervalTask({ id = 0, command, name = '', runOrigin }, schedule, runImmediately = true, callbacks) {
         const _id = this.formatId(id);
-        this.logger.info('[panel][创建interval任务], 任务ID: %s, 任务名: %s, 执行命令: %s', _id, name, command);
+        this.logger.info('[panel][创建interval任务] 任务ID: %s, 任务名: %s, 执行命令: %s', _id, name, command);
         const task = new toad_scheduler_1.Task(name, () => {
             this.runTask(command, callbacks, {
                 name,
@@ -142,7 +142,7 @@ let ScheduleService = class ScheduleService {
     }
     async cancelIntervalTask({ id = 0, name }) {
         const _id = this.formatId(id);
-        this.logger.info('[panel][取消interval任务], 任务ID: %s, 任务名: %s', _id, name);
+        this.logger.info('[panel][取消interval任务] 任务ID: %s, 任务名: %s', _id, name);
         this.intervalSchedule.removeById(_id);
     }
     formatId(id) {

package/static/build/services/sshKey.js

@@ -40,16 +40,15 @@ let SshKeyService = class SshKeyService {
             config = await promises_1.default.readFile(this.sshConfigFilePath, { encoding: 'utf-8' });
         }
         else {
-            await (0, utils_1.writeFileWithLock)(this.sshConfigFilePath, '');
+            await (0, utils_1.writeFileWithLock)(this.sshConfigFilePath, '', { mode: '600' });
         }
         if (!config.includes(this.sshConfigHeader)) {
-            await (0, utils_1.writeFileWithLock)(this.sshConfigFilePath, `${this.sshConfigHeader}\n\n${config}`);
+            await (0, utils_1.writeFileWithLock)(this.sshConfigFilePath, `${this.sshConfigHeader}\n\n${config}`, { mode: '600' });
         }
     }
     async generatePrivateKeyFile(alias, key) {
         try {
             await (0, utils_1.writeFileWithLock)(path_1.default.join(this.sshPath, alias), `${key}${os_1.default.EOL}`, {
-                encoding: 'utf8',
                 mode: '400',
             });
         }
@@ -74,7 +73,10 @@ let SshKeyService = class SshKeyService {
             ? `    ProxyCommand nc -v -x ${proxy} %h %p 2>/dev/null\n`
             : '';
         const config = `Host ${alias}\n    Hostname ${host}\n    IdentityFile ${path_1.default.join(this.sshPath, alias)}\n    StrictHostKeyChecking no\n${proxyStr}`;
-        await (0, utils_1.writeFileWithLock)(`${path_1.default.join(this.sshPath, `${alias}.config`)}`, config);
+        await (0, utils_1.writeFileWithLock)(`${path_1.default.join(this.sshPath, `${alias}.config`)}`, config, {
+            encoding: 'utf8',
+            mode: '600',
+        });
     }
     async removeSshConfig(alias) {
         try {
@@ -105,6 +107,24 @@ let SshKeyService = class SshKeyService {
             }
         }
     }
+    async addGlobalSSHKey(key, alias) {
+        await this.generatePrivateKeyFile(`~global_${alias}`, key);
+        // Create a global SSH config entry that matches all hosts
+        // This allows the key to be used for any Git repository
+        await this.generateGlobalSshConfig(`~global_${alias}`);
+    }
+    async removeGlobalSSHKey(alias) {
+        await this.removePrivateKeyFile(`~global_${alias}`);
+        await this.removeSshConfig(`~global_${alias}`);
+    }
+    async generateGlobalSshConfig(alias) {
+        // Create a config that matches all hosts, making this key globally available
+        const config = `Host *\n    IdentityFile ${path_1.default.join(this.sshPath, alias)}\n    StrictHostKeyChecking no\n`;
+        await (0, utils_1.writeFileWithLock)(`${path_1.default.join(this.sshPath, `${alias}.config`)}`, config, {
+            encoding: 'utf8',
+            mode: '600',
+        });
+    }
 };
 SshKeyService = __decorate([
     (0, typedi_1.Service)(),

package/static/build/services/subscription.js

@@ -53,6 +53,7 @@ const const_1 = require("../config/const");
 const subscription_2 = require("../config/subscription");
 const cron_1 = require("../data/cron");
 const cron_2 = __importDefault(require("./cron"));
+const logStreamManager_1 = require("../shared/logStreamManager");
 let SubscriptionService = class SubscriptionService {
     constructor(logger, scheduleService, sockService, sshKeyService, crontabService) {
         this.logger = logger;
@@ -129,7 +130,7 @@ let SubscriptionService = class SubscriptionService {
                 let beforeStr = '';
                 try {
                     if (doc.sub_before) {
-                        await promises_1.default.appendFile(absolutePath, `\n## 执行before命令...\n\n`);
+                        await logStreamManager_1.logStreamManager.write(absolutePath, `\n## 执行before命令...\n\n`);
                         beforeStr = await (0, util_1.promiseExec)(doc.sub_before);
                     }
                 }
@@ -138,7 +139,7 @@ let SubscriptionService = class SubscriptionService {
                         (error.stderr && error.stderr.toString()) || JSON.stringify(error);
                 }
                 if (beforeStr) {
-                    await promises_1.default.appendFile(absolutePath, `${beforeStr}\n`);
+                    await logStreamManager_1.logStreamManager.write(absolutePath, `${beforeStr}\n`);
                 }
             },
             onStart: async (cp, startTime) => {
@@ -153,7 +154,7 @@ let SubscriptionService = class SubscriptionService {
                 let afterStr = '';
                 try {
                     if (sub.sub_after) {
-                        await promises_1.default.appendFile(absolutePath, `\n\n## 执行after命令...\n\n`);
+                        await logStreamManager_1.logStreamManager.write(absolutePath, `\n\n## 执行after命令...\n\n`);
                         afterStr = await (0, util_1.promiseExec)(sub.sub_after);
                     }
                 }
@@ -162,9 +163,11 @@ let SubscriptionService = class SubscriptionService {
                         (error.stderr && error.stderr.toString()) || JSON.stringify(error);
                 }
                 if (afterStr) {
-                    await promises_1.default.appendFile(absolutePath, `${afterStr}\n`);
+                    await logStreamManager_1.logStreamManager.write(absolutePath, `${afterStr}\n`);
                 }
-                await promises_1.default.appendFile(absolutePath, `\n## 执行结束... ${endTime.format('YYYY-MM-DD HH:mm:ss')}  耗时 ${diff} 秒${const_1.LOG_END_SYMBOL}`);
+                await logStreamManager_1.logStreamManager.write(absolutePath, `\n## 执行结束... ${endTime.format('YYYY-MM-DD HH:mm:ss')}  耗时 ${diff} 秒${const_1.LOG_END_SYMBOL}`);
+                // Close the stream after task completion
+                await logStreamManager_1.logStreamManager.closeStream(absolutePath);
                 await subscription_1.SubscriptionModel.update({ status: subscription_1.SubscriptionStatus.idle, pid: undefined }, { where: { id: sub.id } });
                 this.sockService.sendMessage({
                     type: 'runSubscriptionEnd',
@@ -175,12 +178,12 @@ let SubscriptionService = class SubscriptionService {
             onError: async (message) => {
                 const sub = await this.getDb({ id: doc.id });
                 const absolutePath = await (0, util_1.handleLogPath)(sub.log_path);
-                await promises_1.default.appendFile(absolutePath, `\n${message}`);
+                await logStreamManager_1.logStreamManager.write(absolutePath, `\n${message}`);
             },
             onLog: async (message) => {
                 const sub = await this.getDb({ id: doc.id });
                 const absolutePath = await (0, util_1.handleLogPath)(sub.log_path);
-                await promises_1.default.appendFile(absolutePath, `\n${message}`);
+                await logStreamManager_1.logStreamManager.write(absolutePath, `\n${message}`);
             },
         };
     }
@@ -317,7 +320,7 @@ let SubscriptionService = class SubscriptionService {
                 return (await Promise.all(files.map(async (x) => ({
                     filename: x,
                     directory: relativeDir.replace(config_1.default.logPath, ''),
-                    time: (await promises_1.default.lstat(`${dir}/${x}`)).mtime.getTime(),
+                    time: (await promises_1.default.lstat(`${dir}/${x}`)).birthtimeMs,
                 })))).sort((a, b) => b.time - a.time);
             }
         }

package/static/build/services/system.js

@@ -414,6 +414,21 @@ let SystemService = class SystemService {
             return { code: 400, message: '设置时区失败' };
         }
     }
+    async updateGlobalSshKey(info) {
+        const oDoc = await this.getSystemConfig();
+        const result = await this.updateAuthDb(Object.assign(Object.assign({}, oDoc), { info: Object.assign(Object.assign({}, oDoc.info), info) }));
+        // Apply the global SSH key
+        const SshKeyService = require('./sshKey').default;
+        const Container = require('typedi').Container;
+        const sshKeyService = Container.get(SshKeyService);
+        if (info.globalSshKey) {
+            await sshKeyService.addGlobalSSHKey(info.globalSshKey, 'global');
+        }
+        else {
+            await sshKeyService.removeGlobalSSHKey('global');
+        }
+        return { code: 200, data: result };
+    }
     async cleanDependence(type) {
         if (!type || !['node', 'python3'].includes(type)) {
             return { code: 400, message: '参数错误' };

package/static/build/services/user.js

@@ -79,9 +79,17 @@ let UserService = class UserService {
                 expiresIn: config_1.default.jwt.expiresIn || expiration,
                 algorithm: 'HS384',
             });
+            const tokenInfo = {
+                value: token,
+                timestamp,
+                ip,
+                address,
+                platform: req.platform,
+            };
+            const updatedTokens = this.addTokenToList(tokens, req.platform, tokenInfo);
             await this.updateAuthInfo(content, {
                 token,
-                tokens: Object.assign(Object.assign({}, tokens), { [req.platform]: token }),
+                tokens: updatedTokens,
                 lastlogon: timestamp,
                 retries: 0,
                 lastip: ip,
@@ -146,11 +154,23 @@ let UserService = class UserService {
             }
         }
     }
-    async logout(platform) {
+    async logout(platform, tokenValue) {
+        if (!platform || !tokenValue) {
+            this.logger.warn('Invalid logout parameters - empty platform or token');
+            return;
+        }
         const authInfo = await this.getAuthInfo();
+        // Verify the token exists before attempting to remove it
+        const tokenExists = this.findTokenInList(authInfo.tokens, platform, tokenValue);
+        if (!tokenExists && authInfo.token !== tokenValue) {
+            // Token not found, but don't throw error - user may have already logged out
+            this.logger.info(`Logout attempted for non-existent token on platform: ${platform}`);
+            return;
+        }
+        const updatedTokens = this.removeTokenFromList(authInfo.tokens, platform, tokenValue);
         await this.updateAuthInfo(authInfo, {
-            token: '',
-            tokens: Object.assign(Object.assign({}, authInfo.tokens), { [platform]: '' }),
+            token: authInfo.token === tokenValue ? '' : authInfo.token,
+            tokens: updatedTokens,
         });
     }
     async getLoginLog() {
@@ -299,6 +319,65 @@ let UserService = class UserService {
             return { code: 400, message: '通知发送失败，请检查参数' };
         }
     }
+    normalizeTokens(tokens) {
+        const normalized = {};
+        for (const [platform, value] of Object.entries(tokens)) {
+            if (typeof value === 'string') {
+                // Legacy format: convert string token to TokenInfo array
+                if (value) {
+                    normalized[platform] = [
+                        {
+                            value,
+                            timestamp: Date.now(),
+                            ip: '',
+                            address: '',
+                            platform,
+                        },
+                    ];
+                }
+                else {
+                    normalized[platform] = [];
+                }
+            }
+            else {
+                // Already in new format
+                normalized[platform] = value || [];
+            }
+        }
+        return normalized;
+    }
+    addTokenToList(tokens, platform, tokenInfo, maxTokensPerPlatform = config_1.default.maxTokensPerPlatform) {
+        // Validate maxTokensPerPlatform parameter
+        if (!Number.isInteger(maxTokensPerPlatform) || maxTokensPerPlatform < 1) {
+            this.logger.warn(`Invalid maxTokensPerPlatform value: ${maxTokensPerPlatform}, using default`);
+            maxTokensPerPlatform = config_1.default.maxTokensPerPlatform;
+        }
+        const normalized = this.normalizeTokens(tokens);
+        if (!normalized[platform]) {
+            normalized[platform] = [];
+        }
+        // Add new token
+        normalized[platform].unshift(tokenInfo);
+        // Limit the number of active tokens per platform
+        if (normalized[platform].length > maxTokensPerPlatform) {
+            normalized[platform] = normalized[platform].slice(0, maxTokensPerPlatform);
+        }
+        return normalized;
+    }
+    removeTokenFromList(tokens, platform, tokenValue) {
+        const normalized = this.normalizeTokens(tokens);
+        if (normalized[platform]) {
+            normalized[platform] = normalized[platform].filter((t) => t.value !== tokenValue);
+        }
+        return normalized;
+    }
+    findTokenInList(tokens, platform, tokenValue) {
+        const normalized = this.normalizeTokens(tokens);
+        if (normalized[platform]) {
+            return normalized[platform].find((t) => t.value === tokenValue);
+        }
+        return undefined;
+    }
     async resetAuthInfo(info) {
         const { retries, twoFactorActivated, password, username } = info;
         const authInfo = await this.getAuthInfo();

package/static/build/shared/auth.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidToken = void 0;
+/**
+ * Validates if a token exists in the authentication info.
+ * Supports both legacy string tokens and new TokenInfo array format.
+ *
+ * @param authInfo - The authentication information
+ * @param headerToken - The token to validate
+ * @param platform - The platform (desktop, mobile)
+ * @returns true if the token is valid, false otherwise
+ */
+function isValidToken(authInfo, headerToken, platform) {
+    if (!authInfo || !headerToken) {
+        return false;
+    }
+    const { token = '', tokens = {} } = authInfo;
+    // Check legacy token field
+    if (headerToken === token) {
+        return true;
+    }
+    // Check platform-specific tokens (support both legacy string and new TokenInfo[] format)
+    const platformTokens = tokens[platform];
+    // Handle null/undefined platformTokens
+    if (platformTokens === null || platformTokens === undefined) {
+        return false;
+    }
+    if (typeof platformTokens === 'string') {
+        // Legacy format: single string token
+        return headerToken === platformTokens;
+    }
+    else if (Array.isArray(platformTokens)) {
+        // New format: array of TokenInfo objects
+        return platformTokens.some((t) => t && t.value === headerToken);
+    }
+    // Unexpected type - log warning and reject
+    return false;
+}
+exports.isValidToken = isValidToken;
+//# sourceMappingURL=auth.js.map

package/static/build/shared/logStreamManager.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logStreamManager = exports.LogStreamManager = void 0;
+const fs_1 = require("fs");
+const events_1 = require("events");
+/**
+ * Manages write streams for log files to improve performance by avoiding repeated file opens
+ */
+class LogStreamManager extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.streams = new Map();
+        this.pendingWrites = new Map();
+    }
+    /**
+     * Write data to a log file using a managed stream
+     * @param filePath - Absolute path to the log file
+     * @param data - Data to write to the log file
+     */
+    async write(filePath, data) {
+        // Wait for any pending writes to this file to complete
+        const pending = this.pendingWrites.get(filePath);
+        if (pending) {
+            await pending;
+        }
+        // Create a new promise for this write operation
+        const writePromise = new Promise((resolve, reject) => {
+            let stream = this.streams.get(filePath);
+            if (!stream) {
+                // Create a new write stream if one doesn't exist
+                stream = (0, fs_1.createWriteStream)(filePath, { flags: 'a' });
+                this.streams.set(filePath, stream);
+                // Handle stream errors
+                stream.on('error', (error) => {
+                    this.emit('error', { filePath, error });
+                    // Remove the stream from the map on error
+                    this.streams.delete(filePath);
+                    reject(error);
+                });
+            }
+            // Write the data
+            const canContinue = stream.write(data, 'utf8', (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+            // Handle backpressure
+            if (!canContinue) {
+                stream.once('drain', () => {
+                    // Stream is ready for more data
+                });
+            }
+        });
+        this.pendingWrites.set(filePath, writePromise);
+        try {
+            await writePromise;
+        }
+        finally {
+            this.pendingWrites.delete(filePath);
+        }
+    }
+    /**
+     * Close the stream for a specific file path
+     * @param filePath - Absolute path to the log file
+     */
+    async closeStream(filePath) {
+        // Wait for any pending writes to complete
+        const pending = this.pendingWrites.get(filePath);
+        if (pending) {
+            await pending.catch(() => {
+                // Ignore errors on pending writes during close
+            });
+        }
+        const stream = this.streams.get(filePath);
+        if (stream) {
+            return new Promise((resolve) => {
+                stream.end(() => {
+                    this.streams.delete(filePath);
+                    resolve();
+                });
+            });
+        }
+    }
+    /**
+     * Close all open streams
+     */
+    async closeAll() {
+        const closePromises = Array.from(this.streams.keys()).map((filePath) => this.closeStream(filePath));
+        await Promise.all(closePromises);
+    }
+    /**
+     * Get the number of open streams
+     */
+    getOpenStreamCount() {
+        return this.streams.size;
+    }
+}
+exports.LogStreamManager = LogStreamManager;
+// Export a singleton instance for shared use
+exports.logStreamManager = new LogStreamManager();
+//# sourceMappingURL=logStreamManager.js.map

package/static/build/shared/runCron.js

@@ -7,9 +7,32 @@ exports.runCron = void 0;
 const cross_spawn_1 = require("cross-spawn");
 const pLimit_1 = __importDefault(require("./pLimit"));
 const logger_1 = __importDefault(require("../loaders/logger"));
+const cron_1 = require("../data/cron");
+const util_1 = require("../config/util");
 function runCron(cmd, cron) {
     return pLimit_1.default.runWithCronLimit(cron, () => {
         return new Promise(async (resolve) => {
+            // Check if the cron is already running and stop it (only if multiple instances are not allowed)
+            try {
+                const existingCron = await cron_1.CrontabModel.findOne({
+                    where: { id: Number(cron.id) },
+                });
+                // Default to single instance mode (0) for backward compatibility
+                const allowSingleInstances = (existingCron === null || existingCron === void 0 ? void 0 : existingCron.allow_multiple_instances) === 0;
+                if (allowSingleInstances &&
+                    existingCron &&
+                    existingCron.pid &&
+                    (existingCron.status === cron_1.CrontabStatus.running ||
+                        existingCron.status === cron_1.CrontabStatus.queued)) {
+                    logger_1.default.info(`[schedule][停止已运行任务] 任务ID: ${cron.id}, PID: ${existingCron.pid}`);
+                    await (0, util_1.killTask)(existingCron.pid);
+                    // Update the status to idle after killing
+                    await cron_1.CrontabModel.update({ status: cron_1.CrontabStatus.idle, pid: undefined }, { where: { id: Number(cron.id) } });
+                }
+            }
+            catch (error) {
+                logger_1.default.error(`[schedule][检查已运行任务失败] 任务ID: ${cron.id}, 错误: ${error}`);
+            }
             logger_1.default.info(`[schedule][开始执行任务] 参数 ${JSON.stringify(Object.assign(Object.assign({}, cron), { command: cmd }))}`);
             const cp = (0, cross_spawn_1.spawn)(cmd, { shell: '/bin/bash' });
             cp.stderr.on('data', (data) => {

package/static/build/validation/schedule.js

@@ -5,15 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonCronSchema = exports.scheduleSchema = void 0;
 const celebrate_1 = require("celebrate");
-const cron_parser_1 = __importDefault(require("cron-parser"));
+const cron_parser_1 = require("cron-parser");
 const schedule_1 = require("../interface/schedule");
+const path_1 = __importDefault(require("path"));
+const config_1 = __importDefault(require("../config"));
 const validateSchedule = (value, helpers) => {
     if (value.startsWith(schedule_1.ScheduleType.ONCE) ||
         value.startsWith(schedule_1.ScheduleType.BOOT)) {
         return value;
     }
     try {
-        if (cron_parser_1.default.parseExpression(value).hasNext()) {
+        if (cron_parser_1.CronExpressionParser.parse(value).hasNext()) {
             return value;
         }
     }
@@ -38,5 +40,40 @@ exports.commonCronSchema = {
     extra_schedules: celebrate_1.Joi.array().optional().allow(null),
     task_before: celebrate_1.Joi.string().optional().allow('').allow(null),
     task_after: celebrate_1.Joi.string().optional().allow('').allow(null),
+    log_name: celebrate_1.Joi.string()
+        .optional()
+        .allow('')
+        .allow(null)
+        .custom((value, helpers) => {
+        if (!value)
+            return value;
+        // Check if it's an absolute path
+        if (value.startsWith('/')) {
+            // Allow /dev/null as special case
+            if (value === '/dev/null') {
+                return value;
+            }
+            // For other absolute paths, ensure they are within the safe log directory
+            const normalizedValue = path_1.default.normalize(value);
+            const normalizedLogPath = path_1.default.normalize(config_1.default.logPath);
+            if (!normalizedValue.startsWith(normalizedLogPath)) {
+                return helpers.error('string.unsafePath');
+            }
+            return value;
+        }
+        if (!/^(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?:\/)?(?:[\w.-]+\/)*[\w.-]+\/?$/.test(value)) {
+            return helpers.error('string.pattern.base');
+        }
+        if (value.length > 100) {
+            return helpers.error('string.max');
+        }
+        return value;
+    })
+        .messages({
+        'string.pattern.base': '日志名称只能包含字母、数字、下划线和连字符',
+        'string.max': '日志名称不能超过100个字符',
+        'string.unsafePath': '绝对路径必须在日志目录内或使用 /dev/null',
+    }),
+    allow_multiple_instances: celebrate_1.Joi.number().optional().valid(0, 1).allow(null),
 };
 //# sourceMappingURL=schedule.js.map