jsir 2.3.2 → 2.3.4

package/cmd/oaa.js

@@ -11,7 +11,7 @@ const {
     createConsole, setTips, delTips,
     getEditor, errorStr, getConfigDir,
     getFullPath, parseUniqueName, toUniqueName, isJsirFileName, toJsirFileName,
-    getAlias, wrapperJsirText, eia
+    getAlias, wrapperJsirText, eia, getKeyTips, getValTips, getRoomsDir
 } = $lib;
 const _args = process.argv.slice(2).map(trim);
 const evalCode = require('../deps/evalCode')
@@ -28,6 +28,7 @@ const _libDataDir = getLibDataDir()
 const _fileWatcherMap = {}
 const _types = setting.fileType
 const console = createConsole();
+const room = require('../deps/room');
 
 let lastFilterArg = '';
 let _cmdMapFile = setting.name + 'CmdMap.json'
@@ -345,28 +346,7 @@ function initRl(callback, promptStr, hidden) {
 }
 
 function getTipStr(showKey = false) {
-    let items = [];
-    for (let key of Object.keys(setting.tips)) {
-        let val = setting.tips[key].map(i => {
-            let item = trim(i)
-            if (item.indexOf(',') !== -1) {
-                item = `[${item}]`;
-            }
-            return item;
-        }).join("|");
-        key = trim(key)
-
-        let item
-        if (!showKey && vl(val)) {
-            item = val;
-        } else if (vl(key)) {
-            item = key
-        }
-        if (item) {
-            items.push(item)
-        }
-    }
-    let tips = items.join(',')
+    let tips = showKey ? getKeyTips().join(","):getValTips().join(",")
     if (!showKey && !_isTipsDoneShowKey && tips.length > 64) {
         return '...'
     }
@@ -380,6 +360,10 @@ function closeRl() {
 }
 
 function _nextLine(callback, promptStr, hidden, resolve, end, isText) {
+    if (!setting.enableNextLine) {
+        console.$log(warnStr("[warn]"), "NextLine Disabled");
+        return
+    }
     end = trim(end)
     if (!_haveWrapperInput) {
         return
@@ -1345,6 +1329,7 @@ const keywordDef = {
     quit: {
         comment: 'Exit',
         exeFn: (args) => {
+            room.offRoom();
             delTips();
             console.log(infoStr("Bye!"));
             _noAppendNextLine = true;
@@ -1417,6 +1402,44 @@ const keywordDef = {
             }
         },
         short: 'D'
+    },
+    room: {
+        comment: 'manage room',
+        exeFn: async (args) => {
+            let results = [];
+            await room.syncSetting();
+            for (let i = 0; i < setting.rooms.length; i++) {
+                let room = setting.rooms[i]
+                results.push({
+                    mid: i,
+                    name: (room.local ? "*":" ") + room.name,
+                    node: room.selfNode,
+                    active: room.active,
+                })
+                for (let key of Object.keys(room.jsirs)) {
+                    let jsir = room.jsirs[key]
+                    results.push({
+                        mid: i,
+                        name: (room.local ? "*":"") + room.name,
+                        node: room.selfNode,
+                        active: room.active,
+                        pid: (process.pid === jsir.pid ? "*":" ") + jsir.pid,
+                        space: jsir.space,
+                        running: jsir.active,
+                        port: jsir.port,
+                        back: jsir.back,
+                        busy: jsir.busy,
+                        tips: Object.keys(jsir.tips).map(i => i + ': ' + jsir.tips[i]).join('\n')
+                    });
+                }
+            }
+            if (results.length > 0) {
+                console.nable(results)
+            } else {
+                console.warn("no items")
+            }
+        },
+        short: 'm'
     }
 }
 
@@ -2085,20 +2108,9 @@ async function evalText($text = '', $cmdName = '', $args = []) {
         $homeDir, $lib, _cmdMap);
 }
 
-function clearFileLock() {
-    for (let file of Object.keys(fileLockMap)) {
-        fp.rmdir(file)
-        delete setting.fileLock[file]
-    }
-}
-
 function sigExit() {
-    if (!setting.sigExit) {
-        return;
-    }
     if (_noAppendNextLine) {
         delTips();
-        clearFileLock();
         process.exit(0);
     } else {
         nextLine();
@@ -2107,15 +2119,12 @@ function sigExit() {
 
 process.on('uncaughtException',function(err){
     console.$error('uncaughtException', err)
-    _noAppendNextLine || nextLine()
 })
 process.on('unhandledRejection',function(err){
     console.$error('unhandledRejection', err)
-    _noAppendNextLine || nextLine()
 })
 process.on('rejectionHandled',function(err){
     console.$error('rejectionHandled', err)
-    _noAppendNextLine || nextLine()
 })
 process.on('SIGINT', sigExit);
 process.on('SIGTERM', sigExit);
@@ -2124,6 +2133,7 @@ process.on('beforeExit', function () {
         delTips();
     } else {
         nextLine();
+        room.onRoom()
     }
 });
 

package/deps/room.js

@@ -0,0 +1,339 @@
+const os = require('os');
+const {fileJson, fileLock, vl, createConsole, getKeyTips, getValTips,
+    getRoomsDir, e, regEach} = require('./util');
+const server = require('../deps/server')
+const roomDataFile = "jsirRoom.json"
+const roomsDirLockKey = "RW_" + getRoomsDir();
+const syncRoomsLockKey = "SyncRooms_" + getRoomsDir();
+const enrichRoomInfoLockKey = "ENRICH_" + roomDataFile
+const console = createConsole();
+const net = require("net");
+const setting = require('../deps/setting')
+const fp = require('fs').promises
+const http = require('http');
+let tailscalePath = os.platform() === 'darwin' ?
+    '/Applications/Tailscale.app/Contents/MacOS/Tailscale':'tailscale';
+
+function isPidAlive(pid) {
+    try {
+        process.kill(Number(pid), 0); // 信号 0 不会实际发送，但会检查进程是否存在
+        return true; // PID 存在
+    } catch (err) {
+        if (err.code === 'ESRCH') {
+            return false; // 进程不存在
+        }
+        console.$error(`check isPidAlive ${pid} failed`, err)
+        return false;
+    }
+}
+
+function onRoom() {
+    if (!setting.roomTid[0]) {
+        try {
+            server.setRoute("post", "/", (req, res) => setting.selfRoom)
+            server.setRoute("get", "/", (req, res) => setting.selfRoom)
+        } catch (e) {
+            console.$error("initRoute failed", e)
+        }
+        _onRoom();
+    }
+}
+
+function _onRoom() {
+    setting.roomTid[0] = setTimeout(async () => {
+        try {
+            await initRoom();
+        } catch (e) {
+            console.$error('initRoom', e)
+        }
+        if (setting.roomTid[0]) {
+            _onRoom();
+        }
+    }, 3000)
+}
+
+function offRoom() {
+    if (setting.roomTid[0]) {
+        clearTimeout(setting.roomTid[0])
+        setting.roomTid[0] = null
+        if (setting.server) {
+            setting.server.close(() => {
+                console.$log('Existing server shut down.');
+            });
+        }
+    }
+}
+
+function getSelfIP(nodes) {
+    let ips = getLocalIPs().ipv4;
+    ips = ips.filter(i => nodes.indexOf(i) !== -1);
+    return ips[0]
+}
+
+async function getTailscaleNodes() {
+    console.$log("getNodes")
+    let resp = await e(`${tailscalePath} status`);
+    let nodes = []
+    regEach(resp, /^(\d+\.\d+\.\d+\.\d+)\s+/mg, arr => {
+        nodes.push(arr[1])
+    });
+    return [...new Set(nodes)];
+}
+
+async function enrichRoomInfo() {
+    let nodes = await getTailscaleNodes();
+    let ip = getSelfIP(nodes)
+    await fileJson(roomDataFile, async room => {
+        // 设置roomName
+        let name = os.hostname();
+        if (!vl(room.name) || room.name !== name) {
+            room.name = name;
+            console.$log("set roomName", name)
+        }
+        room.selfNode = ip;
+        room.nodes = nodes;
+        room.lastUpdateTime = Date.now()
+        console.$log("init room", room.name)
+    })
+}
+
+async function syncRooms() {
+    console.$log('syncRooms')
+    let roomsDir = getRoomsDir();
+    let room = await fileJson(roomDataFile)
+
+    let syncRooms = []
+    for (let node of room.nodes) {
+        if (node === room.selfNode) {
+            continue
+        }
+        try {
+            let respBody = await reqNode(node, "get", "/");
+            syncRooms.push(JSON.parse(respBody))
+        } catch (e) {
+            console.$log(`sync ${node} failed`, e);
+        }
+    }
+    await fileLock(roomsDirLockKey, async () => {
+        for (let syncRoom of syncRooms) {
+            if (syncRoom.selfNode) {
+                await fp.writeFile(syncRoom.selfNode, JSON.stringify(syncRoom, null, 2))
+            }
+        }
+    })
+
+    // 清理 roomsDir
+    let files = await fp.readdir(roomsDir)
+    let nodes = room.nodes;
+    for (let file of files) {
+        if (nodes.indexOf(file) === -1) {
+            try {
+                await fp.unlink(roomsDir + '/' + file)
+            } catch (e) {
+                console.$error(e);
+            }
+        }
+    }
+}
+
+async function syncSetting() {
+    let room = await fileJson(roomDataFile)
+    await fileLock(roomsDirLockKey, async () => await _syncSetting(room));
+}
+
+async function _syncSetting(room) {
+    setting.selfRoom = room;
+    setting.selfRoom.local = true;
+    let roomDir = getRoomsDir();
+    let rooms = []
+    let files = await fp.readdir(roomDir);
+    for (let node of setting.selfRoom.nodes) {
+        if (files.indexOf(node) !== -1) {
+            let resp = String(await fp.readFile(roomDir + '/' + node));
+            let room = JSON.parse(resp);
+            if (room.selfNode !== setting.selfRoom.selfNode) {
+                rooms.push(room)
+            }
+        } else {
+            rooms.push({
+                selfNode: node,
+                jsirs: []
+            })
+        }
+    }
+    setting.rooms = [setting.selfRoom, ...rooms]
+        .map(room => {
+            room.active = Date.now() - (room.lastUpdateTime || 0) <= 18000;
+            Object.entries(room.jsirs).forEach(([key, jsir]) =>
+                jsir.active = Date.now() - (jsir.lastUpdateTime || 0) <= 6000)
+            return room;
+        });
+}
+
+async function initRoom() {
+    let roomUpdateTouchTime = false;
+    await fileJson(roomDataFile, async room => {
+        await initRoomJsir(room)
+        if (!vl(room.lastUpdateTime) || (Date.now() - room.lastUpdateTime) > 9000) {
+            roomUpdateTouchTime = true;
+        }
+    })
+
+    if (roomUpdateTouchTime) {
+        await fileLock(enrichRoomInfoLockKey, enrichRoomInfo, false)
+        await fileLock(syncRoomsLockKey, syncRooms, false);
+    }
+
+    await syncSetting();
+}
+
+async function getEventLoopDelay() {
+    const start = process.hrtime.bigint();
+    const delay = 1; // 用于测量的短暂延迟（单位：毫秒）
+    const timeoutPromise = new Promise(resolve => setTimeout(resolve, delay));
+    return await timeoutPromise.then(() => {
+        const end = process.hrtime.bigint();
+        return Number(Math.max(Number(end - start) / 1e4 - (delay * 1e2), 0).toFixed(0)); // 避免负值
+    });
+}
+
+async function initRoomJsir(room) {
+    room.jsirs = Object.fromEntries(
+        Object.entries(room.jsirs || {}).filter(([pid]) => isPidAlive(pid))
+    );
+    room.jsirs[process.pid] = {
+        pid: process.pid,
+        space: setting.defaultSpace,
+        tips: getKeyTips().reduce((obj, key, index) => {
+            obj[key] = getValTips()[index];
+            return obj;
+        }, {}),
+        busy: await getEventLoopDelay(),
+        back: isRunningInBackground(),
+        lastUpdateTime: Date.now(),
+        port: setting.server.address().port
+    }
+    console.$log("init jsir", process.pid)
+}
+
+function isRunningInBackground() {
+    return !(process.stdout.isTTY && process.stdin.isTTY);
+}
+
+/**
+ * 获取本机所有内网 IP
+ * @returns {{ ipv4: string[], ipv6: string[] }}
+ */
+function getLocalIPs() {
+    const networkInterfaces = os.networkInterfaces();
+
+    const result = {
+        ipv4: [],
+        ipv6: []
+    };
+
+    for (const interfaceName of Object.keys(networkInterfaces)) {
+        for (const netInfo of networkInterfaces[interfaceName]) {
+            const { family, address, internal } = netInfo;
+
+            // 只关心非回环地址
+            if (!internal) {
+                if (family === 'IPv4') {
+                    result.ipv4.push(address);
+                } else if (family === 'IPv6') {
+                    result.ipv6.push(address);
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+async function sshEnables(ips) {
+    // 检查开放 22 端口的 IP
+    const sshEnabledIPs = [];
+    const portCheckPromises = ips.map((ip) =>
+        checkPortOpen(ip, 22).then((isOpen) => {
+            if (isOpen) {
+                sshEnabledIPs.push(ip);
+            }
+        })
+    );
+
+    await Promise.all(portCheckPromises);
+    return sshEnabledIPs;
+}
+
+/**
+ * 检查指定 IP 的指定端口是否开放
+ * @param {string} ip - 目标 IP 地址
+ * @param {number} port - 目标端口
+ * @returns {Promise<boolean>} - 是否开放
+ */
+function checkPortOpen(ip, port) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        socket.setTimeout(1000); // 设置超时时间
+
+        socket
+            .connect(port, ip, () => {
+                socket.destroy(); // 成功连接后关闭 socket
+                resolve(true);
+            })
+            .on("error", () => {
+                socket.destroy(); // 遇到错误时关闭 socket
+                resolve(false);
+            })
+            .on("timeout", () => {
+                socket.destroy(); // 超时时关闭 socket
+                resolve(false);
+            });
+    });
+}
+
+async function reqNode(node, method, url) {
+    let port = 52108;
+    let room = setting.rooms.filter(i => i.selfNode === node)[0]
+    if (room) {
+        let activeJsir = Object.values(room.jsirs)
+            .filter(i => i.active).sort((a,b) => a.busy - b.busy);
+        if (activeJsir.length > 0) {
+            port = activeJsir[0].port;
+        }
+    }
+    let opt = {
+        hostname: node,
+        port: port, // HTTP 默认端口
+        path: url,
+        method: method.toUpperCase(),
+    };
+    console.$log('reqRoom', JSON.stringify(opt))
+    return await new Promise((resolve, reject) => {
+        const req = http.request(opt, (res) => {
+            let data = '';
+            // 数据块接收
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            // 响应结束
+            res.on('end', () => {
+                resolve(data)
+            });
+        });
+
+        // 错误处理
+        req.on('error', (e) => {
+            reject(e)
+        });
+
+        // 结束请求
+        req.end();
+    })
+}
+
+module.exports = {
+    onRoom,
+    offRoom,
+    syncSetting
+}

package/deps/server.js

@@ -0,0 +1,110 @@
+const http = require('http');
+const {createConsole, vl} = require('./util');
+const console = createConsole();
+const setting = require('../deps/setting')
+
+// 尝试监听的端口
+const preferredPort = 52108;
+
+// 路由存储
+const routes = {};
+
+// 创建一个 HTTP 服务
+function createServer(port) {
+    const server = http.createServer(async (req, res) => {
+        const method = req.method.toLowerCase();
+        const url = req.url;
+
+        // 查找对应的路由处理函数
+        const routeKey = `${method} ${url}`;
+        if (routes[routeKey]) {
+            await routes[routeKey](req, res);
+        } else {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not Found\n');
+        }
+    });
+
+    server.listen(port, () => {
+        const address = server.address();
+        console.$log(`Server listening on port ${address.port}`);
+    });
+
+    server.on('error', (err) => {
+        console.$error(`Error occurred: ${err.message}`);
+    });
+
+    return server;
+}
+
+// 尝试启动服务的逻辑
+function startServer() {
+    if (!setting.server) {
+        try {
+            setting.server = createServer(preferredPort);
+        } catch (e) {
+            console.$error("startServer failed", e)
+            setting.server = createServer(0);
+        }
+    }
+}
+
+// 设置路由的方法
+function setRoute(method, url, fn, handler = jsonHandle) {
+    startServer();
+
+    const routeKey = `${method.toLowerCase()} ${url}`;
+    if (handler) {
+        routes[routeKey] = async (req, res) => {
+            await handler(req, res, fn)
+        };
+    } else {
+        routes[routeKey] = fn;
+    }
+    console.$log(`AddRoute: ${method.toUpperCase()} ${url} ${handler ? handler.constructor.name:''}`);
+    return setting.server;
+}
+
+function delRoute(method, url) {
+    const routeKey = `${method.toLowerCase()} ${url}`;
+    delete routes[routeKey];
+    console.$log(`DelRoute: ${method.toUpperCase()} ${url}`);
+}
+
+function jsonHandle(req, res, fn) {
+    let body = '';
+
+    // 监听请求数据
+    req.on('data', chunk => {
+        body += chunk;
+    });
+
+    req.on('end', async () => {
+        try {
+            // 解析 JSON 请求体
+            const requestData = body ? JSON.parse(body):{};
+
+            // 创建响应 JSON 数据
+            let responseData = {};
+            let result = await fn(requestData, responseData);
+            if (vl(result)) {
+                responseData = result;
+            }
+
+            // 设置响应头
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            // 返回 JSON 响应
+            res.end(JSON.stringify(responseData));
+        } catch (error) {
+            // 错误处理：如果 JSON 解析失败
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Invalid JSON format' }));
+        }
+    });
+}
+
+module.exports = {
+    setRoute,
+    delRoute,
+    jsonHandle
+};

package/deps/setting.js

@@ -18,10 +18,13 @@ module.exports = {
     initKey,
     fileKey,
     defaultType,
-    sigExit: true,
     packages: {},
-    fileLock: {},
     tips: {},
     defaultSpace: 'local',
-    workspaceMap: {}
+    workspaceMap: {},
+    enableNextLine: true,
+    roomTid: [],
+    selfRoom: {},
+    rooms: [],
+    server: null
 }

package/deps/util.js

@@ -23,6 +23,8 @@ let lockDir;
 let logDir;
 let tempDir;
 let configDir;
+let roomsDir;
+let dataDir;
 
 class SyncQueue {
     constructor() {
@@ -708,7 +710,7 @@ function getInitName(fileName) {
 }
 
 function dataFile(fileName, fn, fmt, defaultObj = {}, returnStr = false) {
-    let dataDir = getLibDataDir() + "/data"
+    let dataDir = getDataDir()
     fileName = trim(fileName)
     let path
     if (fileName.startsWith("/")) {
@@ -758,11 +760,11 @@ async function fileExist(path) {
     }
 }
 
-async function fileJson(key, fn, fmt = true) {
+async function fileJson(key, fn = null, fmt = true, safeMs = 49000) {
     `
     多进程安全文件读写
     `
-    let dataDir = getLibDataDir() + "/data"
+    let dataDir = getDataDir()
     let fileName = trim(key)
     let path = dataDir + "/" + fileName;
     let homeDir = setting.workspaceMap[setting.defaultSpace]
@@ -789,7 +791,7 @@ async function fileJson(key, fn, fmt = true) {
             result = val
         }
         await fp.writeFile(path, prefixStr + JSON.stringify(result, null, fmt ? 2:null))
-    });
+    }, true, safeMs);
     return result;
 }
 
@@ -901,6 +903,24 @@ function getConfigDir() {
     return configDir;
 }
 
+function getRoomsDir() {
+    if (roomsDir) {
+        return roomsDir
+    }
+    roomsDir = getLibDataDir() + '/rooms';
+    mkdir(roomsDir);
+    return roomsDir;
+}
+
+function getDataDir() {
+    if (dataDir) {
+        return dataDir
+    }
+    dataDir = getLibDataDir() + '/data';
+    mkdir(dataDir);
+    return dataDir;
+}
+
 function getAlias(aliasMap, key) {
     key = trim(key)
     if (!key) {
@@ -1037,7 +1057,7 @@ function getLockDir() {
     return lockDir;
 }
 
-function getLockFile(key) {
+function getLockKeyDir(key) {
     if (!key) {
         throw "invalid args"
     }
@@ -1046,36 +1066,110 @@ function getLockFile(key) {
     return lockDir + "/" + key;
 }
 
-async function _fileLock(key, fn) {
+/**
+ * 从目录中读取过期时间戳
+ * @param {string} lockDir - 锁目录路径
+ * @returns {Promise<number | null>} 如果目录下存在过期时间戳文件，则返回其数值；否则返回 null
+ */
+async function readExpireTimestamp(lockDir) {
+    try {
+        const files = await fp.readdir(lockDir);
+        // 假设我们只会创建一个文件，其文件名包含过期时间，如 `expire-1672531200000`
+        const expireFile = files.find(name => name.startsWith('expire-'));
+        if (!expireFile) {
+            return null;
+        }
+        const timestamp = parseInt(expireFile.replace('expire-', ''), 10);
+        return isNaN(timestamp) ? null : timestamp;
+    } catch (err) {
+        // 读取目录出错（可能不存在？）直接返回 null
+        return null;
+    }
+}
+
+async function _fileLock(key, fn, expireMs = 49000) {
     `
     文件锁，返回true/false,
     如果没锁住则不执行fn
     `
-    if (!key || !fn) {
-        throw new Error('invalid args')
+    if (!key || typeof fn !== 'function') {
+        throw new Error('invalid arguments');
     }
-    let file = getLockFile(key)
+
+    let lockKeyDir = getLockKeyDir(key)
+    const now = Date.now();
+    const expireAt = expireMs > 0 ? now + expireMs : 0;
+
+    // 1. 尝试判断锁目录是否已存在
+    let lockExists = false;
     try {
-        await fp.mkdir(file);
-    } catch (e) {
+        await fp.access(lockKeyDir);  // 若存在则不抛错
+        lockExists = true;
+    } catch (_) {
+        // 不存在时会抛ENOENT错误，说明还没有锁
+        lockExists = false;
+    }
+
+    if (lockExists) {
+        // 目录存在时，读取文件名中的过期时间戳
+        const storedExpireAt = await readExpireTimestamp(lockKeyDir);
+        if (storedExpireAt === null) {
+            // 理论上不会出现没有“expire-xxxx”文件的情况，除非中途被手动改动
+            // 可以选择强制删除目录，或者直接返回 false
+            return false;
+        }
+        if (storedExpireAt === 0) {
+            // 说明当时设置的是永不过期
+            return false;
+        }
+        if (storedExpireAt > now) {
+            // 说明锁尚未过期
+            return false;
+        }
+        // 如果过期了，则清理原目录，以便重新加锁
+        try {
+            await fp.rm(lockKeyDir, { recursive: true, force: true });
+        } catch (err) {
+            // 删除失败，可能是权限问题；这里直接返回 false 或者抛错
+            return false;
+        }
+    }
+
+    // 2. 创建锁目录
+    try {
+        await fp.mkdir(lockKeyDir, { recursive: false });
+    } catch (err) {
+        // 如果 mkdir 依旧失败，说明在这段时间里又被别人抢先创建了
+        return false;
+    }
+
+    // 3. 在锁目录下创建一个文件，文件名带“过期时间戳”
+    //    expireAt === 0 表示永不过期
+    const expireFilename = `expire-${expireAt}`;
+    const expireFilePath = path.join(lockKeyDir, expireFilename);
+    try {
+        await fp.writeFile(expireFilePath, '');
+    } catch (err) {
+        // 无法写文件就释放锁并抛错
+        try {
+            await fp.rm(lockKeyDir, { recursive: true, force: true });
+        } catch (_) {}
         return false;
     }
-    let fileLockMap = setting.fileLock;
-    fileLockMap[file] = true;
+
+    // 4. 成功加锁后执行 fn
     try {
         await fn();
         return true;
-    } catch (e) {
-        throw e;
     } finally {
+        // 5. 执行完毕后，手动释放锁目录（也可选择保留到过期自动失效，但一般都建议主动释放）
         try {
-            await fp.rmdir(file)
-            delete fileLockMap[file]
-        } catch (_){}
+            await fp.rm(lockKeyDir, { recursive: true, force: true });
+        } catch (_) {}
     }
 }
 
-async function fileLock(key, fn, wait = true) {
+async function fileLock(key, fn, wait = true, expireMs = 49000) {
     `
     文件锁, 默认一直等待，直到加锁成功执行fn
     wait = false, 加锁失败则不执行fn
@@ -1083,13 +1177,13 @@ async function fileLock(key, fn, wait = true) {
     `
     if (wait) {
         while (true) {
-            if (await _fileLock(key, fn)) {
+            if (await _fileLock(key, fn, expireMs)) {
                 break;
             }
-            await sleep(49);
+            await sleep(9);
         }
     } else {
-        await _fileLock(key, fn);
+        await _fileLock(key, fn, expireMs);
     }
 }
 
@@ -1395,17 +1489,17 @@ async function eia(cmd, args = [], shell = false) {
     `
     当前进程不会卡住，输入输出由cmd进程持有
     `
-    setting.sigExit = false;
+    setting.enableNextLine = false;
     let child = spawn(cmd, args, {stdio:"inherit", shell});
     return new Promise((resolve, reject) => {
         // 监听子进程的关闭事件
         child.on('close', (code) => {
-            setting.sigExit = true;
+            setting.enableNextLine = true;
             resolve(code);
         });
         // 可选：监听子进程的错误事件
         child.on('error', (err) => {
-            setting.sigExit = true;
+            setting.enableNextLine = true;
             reject(err)
         });
     })
@@ -1863,6 +1957,29 @@ end tell
     }
 }
 
+function getKeyTips() {
+    let items = [];
+    for (let key of Object.keys(setting.tips)) {
+        items.push(trim(key))
+    }
+    return items
+}
+
+function getValTips() {
+    let items = [];
+    for (let key of Object.keys(setting.tips)) {
+        let val = setting.tips[key].map(i => {
+            let item = trim(i)
+            if (item.indexOf(',') !== -1) {
+                item = `[${item}]`;
+            }
+            return item;
+        }).join("|");
+        items.push(val)
+    }
+    return items
+}
+
 module.exports = {
     wrapperJsirText,
     run,
@@ -1963,5 +2080,9 @@ module.exports = {
     createDirs,
     getTempDir,
     terminalRun,
-    eia
+    eia,
+    getKeyTips,
+    getValTips,
+    getRoomsDir,
+    getDataDir
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsir",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "JavaScript Script Management Tool",
   "main": "index.js",
   "scripts": {