lnlink-server 1.1.2 → 1.1.3

package/dist/index.js

@@ -122,6 +122,15 @@ var require_linkLogger = __commonJS({
       }
       // Cache for logger instances to avoid creating multiple instances with the same logType
       static instances = /* @__PURE__ */ new Map();
+      // Silent mode flag - when true, all logging is suppressed (used during graceful shutdown)
+      static silentMode = false;
+      /**
+       * Set silent mode to suppress all logging (used during graceful shutdown)
+       * @param {boolean} value - Whether to enable silent mode
+       */
+      static setSilentMode(value) {
+        _Logger.silentMode = value;
+      }
       constructor(logType) {
         if (_Logger.instances.has(logType)) {
           return _Logger.instances.get(logType);
@@ -131,21 +140,27 @@ var require_linkLogger = __commonJS({
         _Logger.instances.set(logType, this);
       }
       debug(message, ...args) {
+        if (_Logger.silentMode) return;
         this.logger.debug({ msg: message }, ...args);
       }
       info(message, ...args) {
+        if (_Logger.silentMode) return;
         this.logger.info({ msg: message }, ...args);
       }
       warn(message, ...args) {
+        if (_Logger.silentMode) return;
         this.logger.warn({ msg: message }, ...args);
       }
       error(message, ...args) {
+        if (_Logger.silentMode) return;
         this.logger.error({ msg: message }, ...args);
       }
       fatal(message, ...args) {
+        if (_Logger.silentMode) return;
         this.logger.fatal({ msg: message }, ...args);
       }
       logWithData(level, message, data) {
+        if (_Logger.silentMode) return;
         this.logger[level]({ ...data, msg: message });
       }
     };
@@ -2720,7 +2735,6 @@ var require_getConfig = __commonJS({
         "LINK_DEBUG",
         "LINK_ENABLE_TOR",
         "LINK_NODE_ENV",
-        "LINK_AUTO_ASSIGN_PORTS",
         "LINK_HTTPS_PROXY",
         "LINK_DATABASE_URL",
         "LINK_REPORT_BASE_URL",
@@ -2885,9 +2899,7 @@ var require_getConfig = __commonJS({
           combinedConfig.LINK_TOR_SOCKS_PORT = combinedConfig.LINK_TOR_SOCKS_PORT || 9050;
           combinedConfig.LINK_TOR_CONTROL_PORT = combinedConfig.LINK_TOR_CONTROL_PORT || 9051;
           try {
-            if (processConfig.LINK_AUTO_ASSIGN_PORTS !== "false") {
-              combinedConfig = await assignAvailablePorts(combinedConfig);
-            }
+            combinedConfig = await assignAvailablePorts(combinedConfig);
           } catch (portError) {
             console.warn(
               "Port assignment failed, using default ports:",
@@ -5577,7 +5589,6 @@ var require_processManager = __commonJS({
   "business/service/nodeManage/processManager.js"(exports2, module2) {
     var { spawn } = require("node:child_process");
     var findProcess = require("find-process").default;
-    var { getLightningService } = require_common();
     var { getConfig: getConfig2 } = require_getConfig();
     var Logger = require_linkLogger();
     var { sleep } = require_timeUtils();
@@ -5587,6 +5598,11 @@ var require_processManager = __commonJS({
       return config.LINK_EXTERNAL_NODES === "true" || config.LINK_EXTERNAL_NODES === true;
     }
     __name(isExternalNodesMode, "isExternalNodesMode");
+    function shouldDetach() {
+      const config = getConfig2();
+      return config.LINK_NODE_ENV !== "app";
+    }
+    __name(shouldDetach, "shouldDetach");
     function terminateProcess(pid, force = false) {
       const logger2 = new Logger("processManager");
       try {
@@ -5601,9 +5617,19 @@ var require_processManager = __commonJS({
     }
     __name(terminateProcess, "terminateProcess");
     var serviceState = {
-      services: null
+      services: null,
       // Will be initialized when needed
+      isShuttingDown: false
+      // Flag to suppress async logs during shutdown
     };
+    function setShuttingDown(value) {
+      serviceState.isShuttingDown = value;
+    }
+    __name(setShuttingDown, "setShuttingDown");
+    function isShuttingDown() {
+      return serviceState.isShuttingDown;
+    }
+    __name(isShuttingDown, "isShuttingDown");
     function initializeServices() {
       if (!serviceState.services) {
         serviceState.services = getServiceConfig();
@@ -5654,7 +5680,8 @@ var require_processManager = __commonJS({
           }
         }, "settleReject");
         const proc = spawn(service.command, args, {
-          stdio: "pipe"
+          stdio: "pipe",
+          detached: shouldDetach()
         });
         setServiceProcess("litd", proc);
         timeoutId = setTimeout(() => {
@@ -5664,7 +5691,9 @@ var require_processManager = __commonJS({
           }
         }, LITD_STARTUP_TIMEOUT);
         proc.once("exit", (code, signal) => {
-          logger2.info(`litd process exited with code ${code ?? "null"}, signal ${signal ?? "null"}`);
+          if (!isShuttingDown()) {
+            logger2.info(`litd process exited with code ${code ?? "null"}, signal ${signal ?? "null"}`);
+          }
           const currentService = getService("litd");
           if (currentService?.process === proc) {
             setServiceProcess("litd", null);
@@ -5727,7 +5756,8 @@ var require_processManager = __commonJS({
         }, "settleReject");
         logger2.info(`Tor config: ${JSON.stringify(args, null, 2)}`);
         const proc = spawn(service.command, args, {
-          stdio: "pipe"
+          stdio: "pipe",
+          detached: shouldDetach()
         });
         setServiceProcess("tor", proc);
         timeoutId = setTimeout(() => {
@@ -5737,7 +5767,9 @@ var require_processManager = __commonJS({
           }
         }, TOR_STARTUP_TIMEOUT);
         proc.once("exit", (code, signal) => {
-          logger2.info(`tor process exited with code ${code ?? "null"}, signal ${signal ?? "null"}`);
+          if (!isShuttingDown()) {
+            logger2.info(`tor process exited with code ${code ?? "null"}, signal ${signal ?? "null"}`);
+          }
           const currentService = getService("tor");
           if (currentService?.process === proc) {
             setServiceProcess("tor", null);
@@ -5805,7 +5837,8 @@ var require_processManager = __commonJS({
           }
         }, "settleReject");
         const proc = spawn(service.command, args, {
-          stdio: "pipe"
+          stdio: "pipe",
+          detached: shouldDetach()
         });
         setServiceProcess("rgb", proc);
         timeoutId = setTimeout(() => {
@@ -5815,7 +5848,9 @@ var require_processManager = __commonJS({
           }
         }, RGB_STARTUP_TIMEOUT);
         proc.once("exit", (code, signal) => {
-          logger2.info(`rgb process exited with code ${code ?? "null"}, signal ${signal ?? "null"}`);
+          if (!isShuttingDown()) {
+            logger2.info(`rgb process exited with code ${code ?? "null"}, signal ${signal ?? "null"}`);
+          }
           const currentService = getService("rgb");
           if (currentService?.process === proc) {
             setServiceProcess("rgb", null);
@@ -5923,35 +5958,12 @@ var require_processManager = __commonJS({
       const trackedProcess = initialService.process;
       const processAlive = trackedProcess && !trackedProcess.killed && trackedProcess.exitCode === null;
       if (processAlive) {
-        try {
-          logger2.info("Attempting graceful shutdown via RPC...");
-          const lightningService = getLightningService();
-          await lightningService.stopDaemon();
-          logger2.info("LND daemon stopped gracefully via RPC");
-          let waitCount = 0;
-          const maxWait = 10;
-          while (waitCount < maxWait) {
-            const currentProcess = getService("litd")?.process ?? trackedProcess;
-            if (!currentProcess || currentProcess.killed || currentProcess.exitCode !== null) {
-              setServiceProcess("litd", null);
-              return true;
-            }
-            await sleep(1e3);
-            waitCount++;
-          }
-          logger2.warn("Process did not exit after RPC shutdown, proceeding with fallback...");
-        } catch (error) {
-          logger2.warn(`RPC shutdown failed: ${error.message}, falling back to process termination`);
-        }
-      } else {
-        logger2.info("litd process already exited, skipping RPC shutdown");
-        setServiceProcess("litd", null);
-      }
-      const fallbackService = getService("litd") ?? initialService;
-      if (fallbackService.process) {
-        return await killProcess(fallbackService.process, "litd");
+        logger2.info("Stopping litd via SIGTERM...");
+        return await killProcess(trackedProcess, "litd", 5e3);
       }
-      return await findAndKillProcess(fallbackService.command, "litd");
+      logger2.info("litd process already exited, cleaning up...");
+      setServiceProcess("litd", null);
+      return await findAndKillProcess(initialService.command, "litd");
     }
     __name(stopLitdService, "stopLitdService");
     async function stopTorService() {
@@ -6007,32 +6019,12 @@ var require_processManager = __commonJS({
       if (!service) {
         throw new Error("rgb service not found");
       }
-      try {
-        logger2.info("Attempting graceful shutdown of RGB via SIGTERM...");
-        const processList = await findProcess("name", "rgb-lightning-node");
-        if (processList.length > 0) {
-          processList.forEach((p) => terminateProcess(p.pid, false));
-          await sleep(2e3);
-          setServiceProcess("rgb", null);
-          const remaining = await findProcess("name", "rgb-lightning-node");
-          if (remaining.length === 0) {
-            logger2.info("RGB stopped gracefully");
-            return true;
-          }
-          logger2.warn(`${remaining.length} RGB process(es) still running after SIGTERM, force killing...`);
-          remaining.forEach((p) => terminateProcess(p.pid, true));
-          setServiceProcess("rgb", null);
-          return true;
-        }
-        logger2.info("No RGB processes found via find-process, trying tracked process...");
-      } catch (error) {
-        logger2.warn(`RGB graceful shutdown failed: ${error.message}, falling back to process termination`);
-      }
       if (service.process) {
-        return await killProcess(service.process, "rgb");
-      } else {
-        return await findAndKillProcess("rgb-lightning-node", "rgb");
+        logger2.info("Stopping RGB via tracked process...");
+        return await killProcess(service.process, "rgb", 5e3);
       }
+      logger2.info("No tracked RGB process, falling back to system scan...");
+      return await findAndKillProcess("rgb-lightning-node", "rgb");
     }
     __name(stopRgbService, "stopRgbService");
     async function stopService(name) {
@@ -6079,13 +6071,24 @@ var require_processManager = __commonJS({
       };
     }
     __name(getServicesState, "getServicesState");
+    function getServicePids() {
+      const services = initializeServices();
+      return {
+        litd: services.litd?.process?.pid || null,
+        tor: services.tor?.process?.pid || null,
+        rgb: services.rgb?.process?.pid || null
+      };
+    }
+    __name(getServicePids, "getServicePids");
     module2.exports = {
       startService,
       stopService,
       stopLitdService,
       stopTorService,
       stopRgbService,
-      getServicesState
+      getServicesState,
+      getServicePids,
+      setShuttingDown
     };
   }
 });
@@ -6202,21 +6205,11 @@ var require_node = __commonJS({
           tag: TASKS.EnableRGBNode
         });
       }
-      const unlockPromise = rgbClient.node.unlockNode(unlockNodeParams);
-      const timeoutMs = 3e4;
-      let timeoutId;
-      const timeoutPromise = new Promise((resolve) => {
-        timeoutId = setTimeout(async () => {
-          const status = await getNodeState();
-          resolve({
-            message: "Request submitted, current node status:",
-            status
-          });
-        }, timeoutMs);
-      });
-      const result = await Promise.race([unlockPromise, timeoutPromise]);
-      clearTimeout(timeoutId);
-      return result || true;
+      rgbClient.node.unlockNode(unlockNodeParams).then(() => {
+      }).catch((err) => console.error("[rgb] unlockNode background error:", err.message));
+      const linkCache = require_linkCache();
+      linkCache.set("rgbState", 3);
+      return { state: 3, message: "Unlock submitted, syncing..." };
     }
     __name(unlockNode, "unlockNode");
     async function backupNode({ password }) {
@@ -6276,6 +6269,7 @@ var require_statusChecker = __commonJS({
     var { getNodeState } = require_node();
     var { getServiceConfig } = require_config2();
     var { getServicesState } = require_processManager();
+    var normalizePath = /* @__PURE__ */ __name((s) => s ? s.replace(/\\/g, "/") : "", "normalizePath");
     function isExternalNodesMode() {
       const config = getConfig2();
       return config.LINK_EXTERNAL_NODES === "true" || config.LINK_EXTERNAL_NODES === true;
@@ -6313,10 +6307,26 @@ var require_statusChecker = __commonJS({
           }
           return ServiceStatus.STOPPED;
         }
+        const { LINK_DATA_PATH } = getConfig2();
         const processList = await findProcess("name", "litd");
+        if (!LINK_DATA_PATH) {
+          if (processList.length > 0) {
+            logger2.warn("LINK_DATA_PATH not set, cannot filter litd by ownership. Returning RUNNING based on process name match.");
+            return ServiceStatus.RUNNING;
+          }
+          return ServiceStatus.STOPPED;
+        }
+        const lnlinkLitdDataDir = `${LINK_DATA_PATH}/.litd`;
         if (processList.length > 0) {
-          logger2.info(`Found litd process(es): ${processList.map((p) => p.pid).join(", ")}`);
-          return ServiceStatus.RUNNING;
+          const targetDir = normalizePath(lnlinkLitdDataDir);
+          const lnlinkLitdProcess = processList.find((p) => p.cmd && normalizePath(p.cmd).includes(targetDir));
+          if (lnlinkLitdProcess) {
+            logger2.info(`Found lnlink litd process: PID ${lnlinkLitdProcess.pid}`);
+            return ServiceStatus.RUNNING;
+          } else {
+            logger2.debug(`Found ${processList.length} litd process(es), but none belong to lnlink (data dir: ${lnlinkLitdDataDir})`);
+            return ServiceStatus.STOPPED;
+          }
         }
         return ServiceStatus.STOPPED;
       } catch (error) {
@@ -6341,10 +6351,26 @@ var require_statusChecker = __commonJS({
           }
           return ServiceStatus.STOPPED;
         }
+        const { LINK_DATA_PATH } = getConfig2();
         const processList = await findProcess("name", "rgb-lightning-node");
+        if (!LINK_DATA_PATH) {
+          if (processList.length > 0) {
+            logger2.warn("LINK_DATA_PATH not set, cannot filter RGB by ownership. Returning RUNNING based on process name match.");
+            return ServiceStatus.RUNNING;
+          }
+          return ServiceStatus.STOPPED;
+        }
+        const lnlinkRgbDataDir = `${LINK_DATA_PATH}/.rgb`;
         if (processList.length > 0) {
-          logger2.info(`Found rgb-lightning-node process(es): ${processList.map((p) => p.pid).join(", ")}`);
-          return ServiceStatus.RUNNING;
+          const targetDir = normalizePath(lnlinkRgbDataDir);
+          const lnlinkRgbProcess = processList.find((p) => p.cmd && normalizePath(p.cmd).includes(targetDir));
+          if (lnlinkRgbProcess) {
+            logger2.info(`Found lnlink RGB process: PID ${lnlinkRgbProcess.pid}`);
+            return ServiceStatus.RUNNING;
+          } else {
+            logger2.debug(`Found ${processList.length} rgb-lightning-node process(es), but none belong to lnlink (data dir: ${lnlinkRgbDataDir})`);
+            return ServiceStatus.STOPPED;
+          }
         }
         return ServiceStatus.STOPPED;
       } catch (error) {
@@ -6383,12 +6409,25 @@ var require_statusChecker = __commonJS({
       }
     }
     __name(checkProcess, "checkProcess");
-    function getTerminalStatus(filter = "") {
-      const services = getServiceConfig();
+    var terminalStatusCache = {
+      data: null,
+      timestamp: 0,
+      TTL_MS: 5e3
+      // 5 seconds cache
+    };
+    async function getTerminalStatus(filter = "") {
       const logger2 = new Logger("statusChecker");
+      if (!filter && terminalStatusCache.data) {
+        const age = Date.now() - terminalStatusCache.timestamp;
+        if (age < terminalStatusCache.TTL_MS) {
+          logger2.debug(`getTerminalStatus: returning cached result (age: ${age}ms)`);
+          return [...terminalStatusCache.data];
+        }
+      }
+      const services = getServiceConfig();
       const shouldInclude = /* @__PURE__ */ __name((name) => name !== "rgb" && (!filter || name.includes(filter)), "shouldInclude");
       const filteredServices = Object.keys(services).filter(shouldInclude);
-      return Promise.all(
+      const result = await Promise.all(
         filteredServices.map(async (name) => {
           try {
             const state = await checkProcess(name);
@@ -6403,8 +6442,18 @@ var require_statusChecker = __commonJS({
           }
         })
       );
+      if (!filter) {
+        terminalStatusCache.data = result;
+        terminalStatusCache.timestamp = Date.now();
+      }
+      return result;
     }
     __name(getTerminalStatus, "getTerminalStatus");
+    function invalidateTerminalStatusCache() {
+      terminalStatusCache.data = null;
+      terminalStatusCache.timestamp = 0;
+    }
+    __name(invalidateTerminalStatusCache, "invalidateTerminalStatusCache");
     async function getRGBStatus() {
       const logger2 = new Logger("statusChecker");
       try {
@@ -6461,6 +6510,7 @@ var require_statusChecker = __commonJS({
       checkProcess,
       getRGBStatus,
       getTerminalStatus,
+      invalidateTerminalStatusCache,
       isServiceRunning,
       waitForServiceStatus
     };
@@ -6486,6 +6536,7 @@ var require_nodeManage = __commonJS({
     var { startService, stopService } = require_processManager();
     var {
       getTerminalStatus,
+      invalidateTerminalStatusCache,
       isServiceRunning,
       getRGBStatus,
       ServiceStatus
@@ -6546,22 +6597,30 @@ var require_nodeManage = __commonJS({
       return { matched: false, statuses: lastStatuses };
     }
     __name(waitForRgbStatus, "waitForRgbStatus");
+    var isStartingTerminal = false;
+    var isStartingRGB = false;
     async function startTerminal({ waitForRunning = true } = {}) {
       const logger2 = new Logger("litdService");
-      const { LINK_ENABLE_TOR } = getConfig2();
-      const isStartTor = LINK_ENABLE_TOR === "true" || LINK_ENABLE_TOR === true;
-      logger2.info("Starting terminal services...");
-      const startStatus = await getTerminalStatus();
-      const litdStatus = startStatus.find((item) => item.service_name === "litd");
-      const torStatus = startStatus.find((item) => item.service_name === "tor");
-      logger2.info(`Current status - Litd: ${litdStatus?.status}, Tor: ${torStatus?.status}`);
-      let torSucceeded = !isStartTor;
+      if (isStartingTerminal) {
+        logger2.warn("Terminal start already in progress, returning current status");
+        return await getTerminalStatus();
+      }
+      isStartingTerminal = true;
       try {
+        const { LINK_ENABLE_TOR } = getConfig2();
+        const isStartTor = LINK_ENABLE_TOR === "true" || LINK_ENABLE_TOR === true;
+        logger2.info("Starting terminal services...");
+        const startStatus = await getTerminalStatus();
+        const litdStatus = startStatus.find((item) => item.service_name === "litd");
+        const torStatus = startStatus.find((item) => item.service_name === "tor");
+        logger2.info(`Current status - Litd: ${litdStatus?.status}, Tor: ${torStatus?.status}`);
+        let torSucceeded = !isStartTor;
         if (isStartTor && torStatus?.status === ServiceStatus.STOPPED) {
           logger2.info("Starting Tor service...");
           try {
             const torArgs = buildTorArgs();
             await startService("tor", torArgs);
+            invalidateTerminalStatusCache();
             torSucceeded = true;
             logger2.info("Tor service started successfully");
           } catch (torError) {
@@ -6579,6 +6638,7 @@ var require_nodeManage = __commonJS({
           logger2.info(`Starting Litd service (Tor: ${useTor})...`);
           const litdArgs = buildLitdArgs(useTor);
           await startService("litd", litdArgs);
+          invalidateTerminalStatusCache();
           logger2.info("Litd service started successfully");
         }
         const endStatus = await getTerminalStatus();
@@ -6600,6 +6660,8 @@ var require_nodeManage = __commonJS({
       } catch (error) {
         logger2.error(`Failed to start terminal services: ${error.message}`);
         throw error;
+      } finally {
+        isStartingTerminal = false;
       }
     }
     __name(startTerminal, "startTerminal");
@@ -6613,6 +6675,7 @@ var require_nodeManage = __commonJS({
       logger2.info("Stopping terminal services...");
       try {
         const stopRet = await stopService("litd");
+        invalidateTerminalStatusCache();
         if (!stopRet) {
           logger2.warn("stopService returned a falsy result");
           return false;
@@ -6706,6 +6769,11 @@ var require_nodeManage = __commonJS({
     async function startRGB(args = {}) {
       const { waitForRunning = true, lnlinkUser } = args;
       const logger2 = new Logger("rgbService");
+      if (isStartingRGB) {
+        logger2.warn("RGB start already in progress, returning current status");
+        return await getRGBStatus();
+      }
+      isStartingRGB = true;
       logger2.info("Starting RGB service...");
       try {
         const startStatus = await getRGBStatus();
@@ -6740,6 +6808,8 @@ var require_nodeManage = __commonJS({
       } catch (error) {
         logger2.error(`Failed to start RGB service: ${error.message}`);
         throw error;
+      } finally {
+        isStartingRGB = false;
       }
     }
     __name(startRGB, "startRGB");
@@ -6848,24 +6918,6 @@ var require_nodeManage = __commonJS({
       }
     }
     __name(updateNodeName, "updateNodeName");
-    if (globalThis.addCleanupFunction) {
-      const logger2 = new Logger("nodeManage");
-      globalThis.addCleanupFunction(async () => {
-        logger2.info("Cleaning up node processes...");
-        try {
-          for (const name of ["litd", "tor", "rgb"]) {
-            try {
-              await stopService(name);
-              logger2.info(`${name} process stopped`);
-            } catch (err) {
-              logger2.warn(`Failed to stop ${name}: ${err.message}`);
-            }
-          }
-        } catch (error) {
-          logger2.error(`Error during node cleanup: ${error.message}`);
-        }
-      });
-    }
     module2.exports = {
       // Terminal (Litd + Tor) management
       startTerminal,
@@ -7127,7 +7179,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "lnlink-server",
-      version: "1.1.2",
+      version: "1.1.3",
       private: false,
       main: "dist/index.js",
       files: [
@@ -7137,13 +7189,13 @@ var require_package = __commonJS({
       ],
       scripts: {
         build: "node build.js && node build.js --mode development --external all --entry electron",
-        "start:bin": "dotenv -e .env.bin -- node scripts/start-bin.js",
+        "start:bin": "node scripts/start-bin.js",
         "start:docker:dev": "dotenv -e .env.dev -- docker compose -f ./docker-compose.dev.yml up --build",
         "start:dev": 'dotenv -e .env.dev -- sh -c "prisma generate && (prisma migrate dev --name auto_update || prisma db push) && clinic heapprof -- node ./app.js"',
         "start:regtest": "docker compose --env-file ./.env.regtest -f ./docker-compose-lnlink.yml up --build",
         "start:testnet": "docker compose --env-file ./.env.testnet -f ./docker-compose-lnlink.yml up --build",
         "start:mainnet": "docker compose --env-file ./.env.mainnet -f ./docker-compose-lnlink.yml up --build",
-        "start:bin:dist": "dotenv -e .env.bin -- node scripts/start-bin.js --dist",
+        "start:bin:dist": "node scripts/start-bin.js --dist",
         lint: "eslint .",
         "lint:fix": "eslint . --fix",
         "lint:staged": "lint-staged",
@@ -7462,13 +7514,9 @@ var require_lndService = __commonJS({
         LINK_NODE_ADDR,
         LINK_LND_PEER_LISTEN_PORT
       } = getConfig2();
-      const currentWalletState = await getWalletState(true);
-      const terminalStatus = await getTerminalStatus();
-      const linkStatusObj = {};
-      terminalStatus.forEach((item) => {
-        linkStatusObj[item.service_name] = item.status;
-      });
       const logger2 = new Logger("lnd");
+      const version = packageJSON.version;
+      const currentWalletState = await getWalletState(true);
       const timeoutMs = 15e3;
       const fallbackCombineInfo = linkCache.get("combineNodeInfo") || {};
       let timeoutId;
@@ -7481,16 +7529,34 @@ var require_lndService = __commonJS({
           });
         }, timeoutMs);
       });
-      const result = await Promise.race([
-        combineNodeInfoAsync(currentWalletState).then((data2) => ({ fromCache: false, data: data2 })),
-        timeoutPromise
-      ]);
-      clearTimeout(timeoutId);
-      const combineInfo = result.data || {};
-      const version = packageJSON.version;
-      const taprootAssetsEnabled = await checkTprEnabled().catch(() => false);
-      const readOnlyAccount = await getLnlinkUser({
-        account_type: ACCOUNT_TYPE.READ_ONLY
+      let results;
+      try {
+        results = await Promise.allSettled([
+          Promise.race([
+            combineNodeInfoAsync(currentWalletState).then((data2) => ({ fromCache: false, data: data2 })),
+            timeoutPromise
+          ]),
+          getTerminalStatus(),
+          checkTprEnabled(),
+          getLnlinkUser({ account_type: ACCOUNT_TYPE.READ_ONLY })
+        ]);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      const [combineSettled, terminalSettled, tprSettled, userSettled] = results;
+      const combineInfo = combineSettled.value?.data || {};
+      const terminalStatus = terminalSettled.status === "fulfilled" ? terminalSettled.value : [];
+      const taprootAssetsEnabled = tprSettled.status === "fulfilled" ? tprSettled.value : false;
+      const readOnlyAccount = userSettled.status === "fulfilled" ? userSettled.value : null;
+      if (terminalSettled.status === "rejected") {
+        logger2.warn(`getNodeInfo: getTerminalStatus failed: ${terminalSettled.reason?.message}`);
+      }
+      if (userSettled.status === "rejected") {
+        logger2.warn(`getNodeInfo: getLnlinkUser failed: ${userSettled.reason?.message}`);
+      }
+      const linkStatusObj = {};
+      terminalStatus.forEach((item) => {
+        linkStatusObj[item.service_name] = item.status;
       });
       const uri = combineInfo?.uris?.[0];
       const data = {
@@ -7722,6 +7788,9 @@ var require_lndService = __commonJS({
     async function combineNodeInfoAsync(walletState) {
       let retInfo = {};
       const logger2 = new Logger("lnd");
+      const CACHE_KEY = "combineNodeInfo";
+      const CACHE_TTL_KEY = "combineNodeInfo_ts";
+      const CACHE_TTL_MS = 5e3;
       try {
         const { isMacaroonDecrypted } = getCacheMacaroon();
         let state = walletState;
@@ -7730,18 +7799,33 @@ var require_lndService = __commonJS({
             state = WALLET_STATE_CODE.LOCKED;
           }
         }
+        const cachedInfo = linkCache.get(CACHE_KEY);
+        const cacheTimestamp = linkCache.get(CACHE_TTL_KEY);
+        if (cachedInfo && cacheTimestamp && cachedInfo.state === state) {
+          const age = Date.now() - cacheTimestamp;
+          if (age < CACHE_TTL_MS) {
+            logger2.debug(`combineNodeInfoAsync: returning cached result (age: ${age}ms)`);
+            return cachedInfo;
+          }
+        }
         if (state >= WALLET_STATE_CODE.RPC_ACTIVE && isMacaroonDecrypted && state !== WALLET_STATE_CODE.WAITING_TO_START) {
           const lightningService = getLightningService();
-          const { settings } = await getMainLnlinkConfig();
           const ret = await Promise.allSettled([
+            getMainLnlinkConfig(),
             lightningService.getInfo(),
             lightningService.walletBalance(),
             lightningService.listPeers({})
           ]);
-          const [infoResult, balanceResult, peersResult] = ret;
-          const nodeInfo = infoResult.value;
-          const balance = balanceResult.value;
-          const retListpeers = peersResult.value;
+          const [configResult, infoResult, balanceResult, peersResult] = ret;
+          let settings = null;
+          if (configResult.status === "fulfilled") {
+            settings = configResult.value?.settings;
+          } else {
+            logger2.warn(`combineNodeInfoAsync: getMainLnlinkConfig failed: ${configResult.reason?.message}`);
+          }
+          const nodeInfo = infoResult.status === "fulfilled" ? infoResult.value : null;
+          const balance = balanceResult.status === "fulfilled" ? balanceResult.value : null;
+          const retListpeers = peersResult.status === "fulfilled" ? peersResult.value : null;
           const peers = retListpeers?.peers || [];
           const mapPeers = peers.map((peer) => {
             const isLnfiPeer = peer.pub_key === settings?.officialLndPeer;
@@ -7771,7 +7855,8 @@ var require_lndService = __commonJS({
           ...retInfo,
           state
         };
-        linkCache.set("combineNodeInfo", retInfo);
+        linkCache.set(CACHE_KEY, retInfo);
+        linkCache.set(CACHE_TTL_KEY, Date.now());
         return retInfo;
       } catch (e) {
         logger2.warn(`LND lndService combineNodeInfoAsync peer combineNodeInfo warn--->${e.message}`);
@@ -8291,6 +8376,15 @@ var require_lndService = __commonJS({
         }
         logger2.info("Stopping litd before config reload (to free ports)...");
         await stopTerminal({ lnlinkUser, waitForStopped: true });
+        if (!enableTor && torRunning) {
+          logger2.info("Stopping Tor service (was running standalone)...");
+          try {
+            await stopService("tor");
+            logger2.info("Tor service stopped successfully");
+          } catch (torError) {
+            logger2.warn(`Failed to stop Tor service: ${torError.message}`);
+          }
+        }
         logger2.info("Reloading config after services stopped...");
         await reloadConfig();
         logger2.info("Starting litd with new Tor configuration...");
@@ -11908,12 +12002,17 @@ var require_info = __commonJS({
         LINK_RGB_LDK_PEER_LISTENING_PORT
       } = getConfig2();
       const logger2 = new Logger("rgb");
-      let statusEntries = [];
-      try {
-        statusEntries = await getRGBStatus();
-      } catch (error) {
-        logger2.warn(`getCombinedNodeInfo - getRGBStatus failed: ${error.message}`);
+      const [statusResult, readOnlyAccountResult] = await Promise.allSettled([
+        getRGBStatus(),
+        getLnlinkUser({ account_type: ACCOUNT_TYPE.READ_ONLY })
+      ]);
+      let statusEntries = {};
+      if (statusResult.status === "fulfilled") {
+        statusEntries = statusResult.value;
+      } else {
+        logger2.warn(`getCombinedNodeInfo - getRGBStatus failed: ${statusResult.reason?.message}`);
       }
+      const readOnlyAccount = readOnlyAccountResult.status === "fulfilled" ? readOnlyAccountResult.value : null;
       const serviceRunning = statusEntries.status === ServiceStatus.RUNNING;
       let nodeInfo = null;
       let balance = {
@@ -11945,7 +12044,8 @@ var require_info = __commonJS({
           ] = await Promise.allSettled([
             rgbClient.node.getNodeInfo(),
             rgbClient.onchain.getBtcBalance({
-              skip_sync: false
+              skip_sync: true
+              // Skip sync for faster response
             }),
             rgbClient.lightning.listPeers({})
           ]);
@@ -11964,14 +12064,11 @@ var require_info = __commonJS({
           } else {
             logger2.warn(`getCombinedNodeInfo - listPeers failed: ${peersResult.reason?.message || peersResult.reason}`);
           }
-          rgbClient.rgb.refreshTransfers({ skip_sync: false }).catch((error) => {
+          rgbClient.rgb.refreshTransfers({ skip_sync: true }).catch((error) => {
             logger2.warn(`getCombinedNodeInfo - refreshTransfers failed: ${error.message}`);
           });
         }
       }
-      const readOnlyAccount = await getLnlinkUser({
-        account_type: ACCOUNT_TYPE.READ_ONLY
-      });
       const data = {
         pubkey: nodeInfo?.pubkey ?? null,
         host: `${LINK_RGB_HOST}:${LINK_RGB_LDK_PEER_LISTENING_PORT}`,
@@ -19001,17 +19098,6 @@ var require_job = __commonJS({
       logger2.info("Job system graceful shutdown completed");
     }
     __name(gracefulShutdown, "gracefulShutdown");
-    process.on("SIGINT", gracefulShutdown);
-    process.on("SIGTERM", gracefulShutdown);
-    process.on("uncaughtException", (error) => {
-      const logger2 = new Logger("job_uncaught");
-      logger2.error(`Uncaught exception: ${error.message}`);
-      gracefulShutdown();
-    });
-    process.on("unhandledRejection", (reason, promise) => {
-      const logger2 = new Logger("job_unhandled");
-      logger2.error(`Unhandled rejection at: ${promise}, reason: ${reason}`);
-    });
     module2.exports = {
       initJobSystem,
       startJobSystem,
@@ -19511,20 +19597,25 @@ var LnLink = class extends EventEmitter {
    */
   async stop() {
     try {
-      try {
-        const { stopService } = require_processManager();
-        for (const name of ["rgb", "litd", "tor"]) {
+      const { stopService, setShuttingDown } = require_processManager();
+      setShuttingDown(true);
+      console.info("Stopping LN-Link (jobs + rgb + litd + tor)...");
+      await Promise.allSettled([
+        // Job system shutdown (cron tasks, state monitoring)
+        (async () => {
+          const { gracefulShutdown: shutdownJobs } = require_job();
+          await shutdownJobs();
+        })().catch((err) => console.warn(`Job system shutdown failed: ${err.message}`)),
+        // Stop all child processes in parallel
+        ...["rgb", "litd", "tor"].map(async (name) => {
           try {
-            console.info(`Stopping ${name} process...`);
             await stopService(name);
-            console.info(`${name} process stopped`);
+            console.info(`${name} stopped`);
           } catch (err) {
             console.warn(`Failed to stop ${name}: ${err.message}`);
           }
-        }
-      } catch (err) {
-        console.warn(`Child process cleanup failed: ${err.message}`);
-      }
+        })
+      ]);
       if (this.server) {
         await new Promise((resolve) => {
           this.server.close(() => {
@@ -19564,6 +19655,14 @@ var LnLink = class extends EventEmitter {
       port: this.isRunning ? this.options.httpPort : null
     };
   }
+  /**
+   * Get PIDs of all managed child processes (litd, tor, rgb)
+   * @returns {{ litd: number|null, tor: number|null, rgb: number|null }}
+   */
+  getServicePids() {
+    const { getServicePids } = require_processManager();
+    return getServicePids();
+  }
   /**
    * Get configuration
    */