@whyour/qinglong 2.19.2-1 → 2.20.0-1

package/static/build/services/cron.js

@@ -21,7 +21,7 @@ const config_1 = __importDefault(require("../config"));
 const cron_1 = require("../data/cron");
 const child_process_1 = require("child_process");
 const promises_1 = __importDefault(require("fs/promises"));
-const cron_parser_1 = __importDefault(require("cron-parser"));
+const cron_parser_1 = require("cron-parser");
 const util_1 = require("../config/util");
 const sequelize_1 = require("sequelize");
 const path_1 = __importDefault(require("path"));
@@ -34,6 +34,7 @@ const pickBy_1 = __importDefault(require("lodash/pickBy"));
 const omit_1 = __importDefault(require("lodash/omit"));
 const utils_1 = require("../shared/utils");
 const schedule_1 = require("../interface/schedule");
+const logStreamManager_1 = require("../shared/logStreamManager");
 let CronService = class CronService {
     constructor(logger) {
         this.logger = logger;
@@ -54,9 +55,28 @@ let CronService = class CronService {
     isSpecialSchedule(schedule) {
         return this.isOnceSchedule(schedule) || this.isBootSchedule(schedule);
     }
+    async getLogName(cron) {
+        const { log_name, command, id } = cron;
+        if (log_name === '/dev/null') {
+            return log_name;
+        }
+        let uniqPath = await (0, util_1.getUniqPath)(command, `${id}`);
+        if (log_name) {
+            const normalizedLogName = log_name.startsWith('/')
+                ? log_name
+                : path_1.default.join(config_1.default.logPath, log_name);
+            if (normalizedLogName.startsWith(config_1.default.logPath)) {
+                uniqPath = log_name;
+            }
+        }
+        const logDirPath = path_1.default.resolve(config_1.default.logPath, `${uniqPath}`);
+        await promises_1.default.mkdir(logDirPath, { recursive: true });
+        return uniqPath;
+    }
     async create(payload) {
         const tab = new cron_1.Crontab(payload);
         tab.saved = false;
+        tab.log_name = await this.getLogName(tab);
         const doc = await this.insert(tab);
         if ((0, util_1.isDemoEnv)()) {
             return doc;
@@ -82,6 +102,7 @@ let CronService = class CronService {
         const doc = await this.getDb({ id: payload.id });
         const tab = new cron_1.Crontab(Object.assign(Object.assign({}, doc), payload));
         tab.saved = false;
+        tab.log_name = await this.getLogName(tab);
         const newDoc = await this.updateDb(tab);
         if (doc.isDisabled === 1 || (0, util_1.isDemoEnv)()) {
             return newDoc;
@@ -384,13 +405,14 @@ let CronService = class CronService {
     async stop(ids) {
         const docs = await cron_1.CrontabModel.findAll({ where: { id: ids } });
         for (const doc of docs) {
-            if (doc.pid) {
-                try {
-                    await (0, util_1.killTask)(doc.pid);
-                }
-                catch (error) {
-                    this.logger.error(error);
-                }
+            // Kill all running instances of this task
+            try {
+                const command = this.makeCommand(doc);
+                await (0, util_1.killAllTasks)(command);
+                this.logger.info(`[panel][停止所有运行中的任务实例] 任务ID: ${doc.id}, 命令: ${command}`);
+            }
+            catch (error) {
+                this.logger.error(`[panel][停止任务失败] 任务ID: ${doc.id}, 错误: ${error}`);
             }
         }
         await cron_1.CrontabModel.update({ status: cron_1.CrontabStatus.idle, pid: undefined }, { where: { id: ids } });
@@ -398,7 +420,6 @@ let CronService = class CronService {
     async runSingle(cronId) {
         return pLimit_1.default.manualRunWithCronLimit(() => {
             return new Promise(async (resolve) => {
-                var _a;
                 const cron = await this.getDb({ id: cronId });
                 const params = {
                     name: cron.name,
@@ -411,30 +432,32 @@ let CronService = class CronService {
                     return;
                 }
                 this.logger.info(`[panel][开始执行任务] 参数: ${JSON.stringify(params)}`);
-                let { id, command, log_path } = cron;
-                const uniqPath = await (0, util_1.getUniqPath)(command, `${id}`);
+                let { id, command, log_name } = cron;
+                const uniqPath = log_name === '/dev/null' || !log_name
+                    ? await (0, util_1.getUniqPath)(command, `${id}`)
+                    : log_name;
                 const logTime = (0, dayjs_1.default)().format('YYYY-MM-DD-HH-mm-ss-SSS');
                 const logDirPath = path_1.default.resolve(config_1.default.logPath, `${uniqPath}`);
-                if ((_a = log_path === null || log_path === void 0 ? void 0 : log_path.split('/')) === null || _a === void 0 ? void 0 : _a.every((x) => x !== uniqPath)) {
-                    await promises_1.default.mkdir(logDirPath, { recursive: true });
-                }
+                await promises_1.default.mkdir(logDirPath, { recursive: true });
                 const logPath = `${uniqPath}/${logTime}.log`;
                 const absolutePath = path_1.default.resolve(config_1.default.logPath, `${logPath}`);
                 const cp = (0, cross_spawn_1.spawn)(`real_log_path=${logPath} no_delay=true ${this.makeCommand(cron, true)}`, { shell: '/bin/bash' });
                 await cron_1.CrontabModel.update({ status: cron_1.CrontabStatus.running, pid: cp.pid, log_path: logPath }, { where: { id } });
                 cp.stdout.on('data', async (data) => {
-                    await promises_1.default.appendFile(absolutePath, data.toString());
+                    await logStreamManager_1.logStreamManager.write(absolutePath, data.toString());
                 });
                 cp.stderr.on('data', async (data) => {
                     this.logger.info('[panel][执行任务失败] 命令: %s, 错误信息: %j', command, data.toString());
-                    await promises_1.default.appendFile(absolutePath, data.toString());
+                    await logStreamManager_1.logStreamManager.write(absolutePath, data.toString());
                 });
                 cp.on('error', async (err) => {
                     this.logger.error('[panel][创建任务失败] 命令: %s, 错误信息: %j', command, err);
-                    await promises_1.default.appendFile(absolutePath, JSON.stringify(err));
+                    await logStreamManager_1.logStreamManager.write(absolutePath, JSON.stringify(err));
                 });
                 cp.on('exit', async (code) => {
                     this.logger.info('[panel][执行任务结束] 参数: %s, 退出码: %j', JSON.stringify(params), code);
+                    // Close the stream after task completion
+                    await logStreamManager_1.logStreamManager.closeStream(absolutePath);
                     await cron_1.CrontabModel.update({ status: cron_1.CrontabStatus.idle, pid: undefined }, { where: { id } });
                     resolve(Object.assign(Object.assign({}, params), { pid: cp.pid, code }));
                 });
@@ -467,6 +490,9 @@ let CronService = class CronService {
         if (!doc) {
             return '';
         }
+        if (doc.log_name === '/dev/null') {
+            return '日志设置为忽略';
+        }
         const absolutePath = path_1.default.resolve(config_1.default.logPath, `${doc.log_path}`);
         const logFileExist = doc.log_path && (await (0, util_1.fileExist)(absolutePath));
         if (logFileExist) {
@@ -476,7 +502,7 @@ let CronService = class CronService {
             return typeof doc.status === 'number' &&
                 [cron_1.CrontabStatus.queued, cron_1.CrontabStatus.running].includes(doc.status)
                 ? '运行中...'
-                : '任务空闲中';
+                : '日志不存在...';
         }
     }
     async logs(id) {
@@ -492,7 +518,7 @@ let CronService = class CronService {
             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);
         }
         else {
@@ -505,6 +531,10 @@ let CronService = class CronService {
             command = `${const_1.TASK_PREFIX}${tab.command}`;
         }
         let commandVariable = `real_time=${Boolean(realTime)} no_tee=true ID=${tab.id} `;
+        // Only include log_name if it has a truthy value to avoid passing null/undefined to shell
+        if (tab.log_name) {
+            commandVariable += `log_name=${tab.log_name} `;
+        }
         if (tab.task_before) {
             commandVariable += `task_before='${tab.task_before
                 .replace(/'/g, "'\\''")
@@ -544,7 +574,11 @@ let CronService = class CronService {
         await cron_1.CrontabModel.update({ saved: true }, { where: {} });
     }
     importCrontab() {
-        (0, child_process_1.exec)('crontab -l', (error, stdout, stderr) => {
+        (0, child_process_1.exec)('crontab -l', (error, stdout) => {
+            if (error) {
+                const errorMsg = error.message || String(error);
+                this.logger.error('[crontab] Failed to read system crontab:', errorMsg);
+            }
             const lines = stdout.split('\n');
             const namePrefix = new Date().getTime();
             lines.reverse().forEach(async (line, index) => {
@@ -554,7 +588,7 @@ let CronService = class CronService {
                 const schedule = line.replace(command, '').trim();
                 if (command &&
                     schedule &&
-                    cron_parser_1.default.parseExpression(schedule).hasNext()) {
+                    cron_parser_1.CronExpressionParser.parse(schedule).hasNext()) {
                     const name = namePrefix + '_' + index;
                     const _crontab = await cron_1.CrontabModel.findOne({
                         where: { command, schedule },

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

@@ -308,11 +308,12 @@ let SystemService = class SystemService {
             return { code: 400, message: '通知发送失败，请检查系统设置/通知配置' };
         }
     }
-    async run({ command }, callback) {
+    async run({ command, logPath }, callback) {
         if (!command.startsWith(const_1.TASK_COMMAND)) {
             command = `${const_1.TASK_COMMAND} ${command}`;
         }
-        this.scheduleService.runTask(`real_time=true ${command}`, callback, {
+        const logPathPrefix = logPath ? `real_log_path=${logPath}` : '';
+        this.scheduleService.runTask(`${logPathPrefix} real_time=true ${command}`, callback, {
             command,
             id: command.replace(/ /g, '-'),
             runOrigin: 'system',
@@ -413,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