querysub 0.305.0 → 0.307.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.305.0",
+  "version": "0.307.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/deployManager/components/MachineDetailPage.tsx

@@ -68,7 +68,7 @@ export class MachineDetailPage extends qreact.Component {
                     <div className={css.vbox(4)}>
                         {Object.entries(machine.info).map(([key, value]) => (
                             <div key={key}>
-                                <span>{key}:</span> {value}
+                                <span>{key}:</span> {JSON.stringify(value)}
                             </div>
                         ))}
                     </div>

package/src/deployManager/machineApplyMainCode.ts

@@ -27,6 +27,98 @@ import path from "path";
 
 const PIPE_FILE_LINE_LIMIT = 10_000;
 
+const getMemoryInfo = measureWrap(async function getMemoryInfo(): Promise<{ value: number; max: number } | undefined> {
+    if (os.platform() === "win32") {
+        throw new Error("Windows is not supported for machine resource monitoring");
+    }
+
+    try {
+        // Linux: Use free command
+        let result = await runPromise("free -b", { quiet: true });
+        let lines = result.split("\n");
+        let memLine = lines.find(line => line.startsWith("Mem:"));
+        if (memLine) {
+            let parts = memLine.split(/\s+/);
+            let total = parseInt(parts[1]);
+            let used = parseInt(parts[2]);
+            if (total && used >= 0) {
+                return { value: used, max: total };
+            }
+        }
+    } catch (e: any) {
+        console.warn(`Error getting memory info: ${e.message}`);
+    }
+    return undefined;
+});
+
+const getCpuInfo = measureWrap(async function getCpuInfo(): Promise<{ value: number; max: number; coreCount: number } | undefined> {
+    if (os.platform() === "win32") {
+        throw new Error("Windows is not supported for machine resource monitoring");
+    }
+
+    let coreCount = os.cpus().length;
+
+    try {
+        // Linux: Get CPU usage from /proc/stat - need two readings to calculate current usage
+        let result1 = await runPromise("grep 'cpu ' /proc/stat", { quiet: true });
+        let parts1 = result1.trim().split(/\s+/);
+
+        if (parts1.length >= 8) {
+            // Wait 1 second for accurate measurement
+            await new Promise(resolve => setTimeout(resolve, 1000));
+
+            let result2 = await runPromise("grep 'cpu ' /proc/stat", { quiet: true });
+            let parts2 = result2.trim().split(/\s+/);
+
+            if (parts2.length >= 8) {
+                // Calculate differences between the two readings
+                let idle1 = parseInt(parts1[4]) + parseInt(parts1[5]); // idle + iowait
+                let total1 = parts1.slice(1, 8).reduce((sum, val) => sum + parseInt(val), 0);
+
+                let idle2 = parseInt(parts2[4]) + parseInt(parts2[5]); // idle + iowait
+                let total2 = parts2.slice(1, 8).reduce((sum, val) => sum + parseInt(val), 0);
+
+                let totalDiff = total2 - total1;
+                let idleDiff = idle2 - idle1;
+
+                if (totalDiff > 0) {
+                    let usagePercent = (totalDiff - idleDiff) / totalDiff;
+                    let coresUsed = usagePercent * coreCount;
+                    return { value: coresUsed, max: coreCount, coreCount };
+                }
+            }
+        }
+    } catch (e: any) {
+        console.warn(`Error getting CPU info: ${e.message}`);
+    }
+    return undefined;
+});
+
+const getDiskInfo = measureWrap(async function getDiskInfo(): Promise<{ value: number; max: number } | undefined> {
+    if (os.platform() === "win32") {
+        throw new Error("Windows is not supported for machine resource monitoring");
+    }
+
+    try {
+        // Linux: Get disk usage for root filesystem
+        let result = await runPromise("df -B1 /", { quiet: true });
+        let lines = result.split("\n");
+        if (lines.length >= 2) {
+            let parts = lines[1].split(/\s+/);
+            if (parts.length >= 4) {
+                let total = parseInt(parts[1]);
+                let used = parseInt(parts[2]);
+                if (total && used >= 0) {
+                    return { value: used, max: total };
+                }
+            }
+        }
+    } catch (e: any) {
+        console.warn(`Error getting disk info: ${e.message}`);
+    }
+    return undefined;
+});
+
 const getLiveMachineInfo = measureWrap(async function getLiveMachineInfo() {
     let machineInfo: MachineInfo = {
         machineId: getOwnMachineId(),
@@ -46,6 +138,38 @@ const getLiveMachineInfo = measureWrap(async function getLiveMachineInfo() {
     machineInfo.repoUrl = await getGitURLLive(".");
     machineInfo.gitRef = await getGitRefLive(".");
 
+    // Get system resource information
+    let [memoryInfo, cpuInfo, diskInfo] = await Promise.all([
+        getMemoryInfo(),
+        getCpuInfo(),
+        getDiskInfo()
+    ]);
+
+    if (memoryInfo) {
+        machineInfo.info.ram = {
+            type: "MEMORY",
+            value: memoryInfo.value,
+            max: memoryInfo.max,
+        };
+    }
+
+    if (cpuInfo) {
+        machineInfo.info.cpu = {
+            type: "CPU",
+            value: cpuInfo.value,
+            max: cpuInfo.max,
+            coreCount: cpuInfo.coreCount,
+        };
+    }
+
+    if (diskInfo) {
+        machineInfo.info.disk = {
+            type: "DISK",
+            value: diskInfo.value,
+            max: diskInfo.max,
+        };
+    }
+
     return machineInfo;
 });
 
@@ -334,19 +458,12 @@ const runScreenCommand = measureWrap(async function runScreenCommand(config: {
     let prefix = getTmuxPrefix();
     let screenName = config.screenName;
 
-    if (config.rollingWindow) {
+    if (config.rollingWindow !== undefined) {
         let screens = await getScreenState();
         let rollingObj = rollingKeepScreenAlive.get(screenName);
         if (rollingObj) {
             rollingObj.pinnedDuration = config.rollingWindow;
         }
-        // Without this check we might have only 1 service up for a long period of time. I guess even with it we can still have only 1 service up for a long period of time (if the rolling window is alive, but barely), but... idk... this seems better?
-        if (rollingObj && rollingObj.pinnedTime + rollingObj.pinnedDuration < Date.now()) {
-            console.log(red(`Rolling screen ${screenName} is finished, deleting it, it should be killed shortly`));
-            rollingKeepScreenAlive.delete(screenName);
-            rollingScreens.delete(rollingObj.rollingScreenName);
-            rollingObj = undefined;
-        }
         let existingScreen = screens.find(x => x.screenName === screenName);
         if (existingScreen && !rollingObj) {
             let nodeIdPath = os.homedir() + "/" + SERVICE_FOLDER + screenName + "/" + SERVICE_NODE_FILE_NAME;

package/src/deployManager/machineSchema.ts

@@ -43,7 +43,12 @@ export type MachineInfo = {
         lscpu
         id (fallback to whoami)
     */
-    info: Record<string, string>;
+    info: Record<string, string | {
+        type: string;
+        value: number;
+        max: number;
+        coreCount?: number;  // Optional for CPU info
+    }>;
 
     repoUrl: string;
     gitRef: string;

package/src/deployManager/spec.txt

@@ -1,12 +1,3 @@
-// updateRootDiscoveryLocation("127-0-0-1.querysubtest.com:7008")
-
-Get updateRootDiscoveryLocation called when we disconnect, and don't reconnect?
-
-
-
-1) Update everything to latest
-3) Update cyoa rolling time back to 4 hours
-
 
 9) In machine info, support an object which can show current, and max, so we can show it as a bar and the max amount for:
     RAM
@@ -20,4 +11,6 @@ Get updateRootDiscoveryLocation called when we disconnect, and don't reconnect?
     (Yes, it overlaps with node metrics, but that's okay, sometimes we want to look at machines, other times services, and the types of errors that show up in either changes).
 
 
-11) A spinning animation on the FPS display, so we can visually see when the browser locks up (because the animation will stop?)
+11) A spinning animation on the FPS display, so we can visually see when the browser locks up (because the animation will stop?)
+
+1) Update everything to latest