vibora 1.7.0 → 1.8.0

package/server/index.js

@@ -7732,6 +7732,7 @@ var systemMetrics = sqliteTable("system_metrics", {
   cpuPercent: real("cpu_percent").notNull(),
   memoryUsedBytes: integer("memory_used_bytes").notNull(),
   memoryTotalBytes: integer("memory_total_bytes").notNull(),
+  memoryCacheBytes: integer("memory_cache_bytes").notNull().default(0),
   diskUsedBytes: integer("disk_used_bytes").notNull(),
   diskTotalBytes: integer("disk_total_bytes").notNull()
 });
@@ -143455,9 +143456,47 @@ import { execSync as execSync5 } from "child_process";
 
 // server/services/metrics-collector.ts
 import os5 from "os";
+import fs7 from "fs";
 import { execSync as execSync4 } from "child_process";
 var COLLECT_INTERVAL = 5000;
 var RETENTION_HOURS = 24;
+function getMemoryInfo() {
+  const total = os5.totalmem();
+  try {
+    const meminfo = fs7.readFileSync("/proc/meminfo", "utf-8");
+    const values = {};
+    for (const line of meminfo.split(`
+`)) {
+      const match3 = line.match(/^(\w+):\s+(\d+)\s+kB/);
+      if (match3) {
+        values[match3[1]] = parseInt(match3[2], 10) * 1024;
+      }
+    }
+    const memTotal = values["MemTotal"] || total;
+    const memFree = values["MemFree"] || 0;
+    const buffers = values["Buffers"] || 0;
+    const cached = values["Cached"] || 0;
+    const sReclaimable = values["SReclaimable"] || 0;
+    const shmem = values["Shmem"] || 0;
+    let cacheBuffers = buffers + cached + sReclaimable - shmem;
+    if (cacheBuffers < 0) {
+      cacheBuffers = 0;
+    }
+    const used = memTotal - memFree - buffers - cached - sReclaimable + shmem;
+    return {
+      total: memTotal,
+      used: Math.max(used, 0),
+      cache: cacheBuffers
+    };
+  } catch {
+    const free = os5.freemem();
+    return {
+      total,
+      used: total - free,
+      cache: 0
+    };
+  }
+}
 var intervalId = null;
 var previousCpu = null;
 function getCpuSnapshot() {
@@ -143505,15 +143544,14 @@ function getDiskUsage() {
 function collectMetrics() {
   const timestamp = Math.floor(Date.now() / 1000);
   const cpuPercent = calculateCpuPercent();
-  const memoryTotal = os5.totalmem();
-  const memoryFree = os5.freemem();
-  const memoryUsed = memoryTotal - memoryFree;
+  const memory = getMemoryInfo();
   const disk = getDiskUsage();
   db.insert(systemMetrics).values({
     timestamp,
     cpuPercent,
-    memoryUsedBytes: memoryUsed,
-    memoryTotalBytes: memoryTotal,
+    memoryUsedBytes: memory.used,
+    memoryTotalBytes: memory.total,
+    memoryCacheBytes: memory.cache,
     diskUsedBytes: disk.used,
     diskTotalBytes: disk.total
   }).run();
@@ -143555,21 +143593,22 @@ function getMetrics(windowSeconds) {
     timestamp: row.timestamp,
     cpuPercent: row.cpuPercent,
     memoryUsedPercent: row.memoryTotalBytes > 0 ? row.memoryUsedBytes / row.memoryTotalBytes * 100 : 0,
+    memoryCachePercent: row.memoryTotalBytes > 0 ? row.memoryCacheBytes / row.memoryTotalBytes * 100 : 0,
     diskUsedPercent: row.diskTotalBytes > 0 ? row.diskUsedBytes / row.diskTotalBytes * 100 : 0
   }));
 }
 function getCurrentMetrics() {
-  const memoryTotal = os5.totalmem();
-  const memoryFree = os5.freemem();
-  const memoryUsed = memoryTotal - memoryFree;
+  const memory = getMemoryInfo();
   const disk = getDiskUsage();
   const latest = db.select().from(systemMetrics).orderBy(systemMetrics.timestamp).limit(1).all();
   return {
     cpu: latest.length > 0 ? latest[0].cpuPercent : 0,
     memory: {
-      total: memoryTotal,
-      used: memoryUsed,
-      usedPercent: memoryUsed / memoryTotal * 100
+      total: memory.total,
+      used: memory.used,
+      cache: memory.cache,
+      usedPercent: memory.total > 0 ? memory.used / memory.total * 100 : 0,
+      cachePercent: memory.total > 0 ? memory.cache / memory.total * 100 : 0
     },
     disk: {
       total: disk.total,
@@ -143797,6 +143836,156 @@ monitoringRoutes.post("/claude-instances/:pid/kill-pid", (c) => {
     return c.json({ error: message }, 500);
   }
 });
+monitoringRoutes.get("/top-processes", (c) => {
+  const sortBy = c.req.query("sort") || "memory";
+  const limit = parseInt(c.req.query("limit") || "10", 10);
+  try {
+    const memTotal = parseInt(readFileSync7("/proc/meminfo", "utf-8").match(/MemTotal:\s+(\d+)/)?.[1] || "0", 10) * 1024;
+    const processes = [];
+    const procDirs = readdirSync7("/proc").filter((d) => /^\d+$/.test(d));
+    for (const pidStr of procDirs) {
+      const pid = parseInt(pidStr, 10);
+      try {
+        const status = readFileSync7(`/proc/${pid}/status`, "utf-8");
+        const nameMatch = status.match(/Name:\s+(.+)/);
+        const rssMatch = status.match(/VmRSS:\s+(\d+)\s+kB/);
+        if (!nameMatch || !rssMatch)
+          continue;
+        const name = nameMatch[1].trim();
+        const memoryKB = parseInt(rssMatch[1], 10);
+        const memoryMB = memoryKB / 1024;
+        const memoryPercent = memTotal > 0 ? memoryKB * 1024 / memTotal * 100 : 0;
+        let command = "";
+        try {
+          command = readFileSync7(`/proc/${pid}/cmdline`, "utf-8").replace(/\0/g, " ").trim().slice(0, 200);
+        } catch {
+          command = name;
+        }
+        const cpuPercent = 0;
+        processes.push({
+          pid,
+          name,
+          command,
+          cpuPercent: Math.round(cpuPercent * 10) / 10,
+          memoryMB: Math.round(memoryMB * 10) / 10,
+          memoryPercent: Math.round(memoryPercent * 10) / 10
+        });
+      } catch {
+        continue;
+      }
+    }
+    if (sortBy === "cpu") {
+      processes.sort((a, b) => b.cpuPercent - a.cpuPercent);
+    } else {
+      processes.sort((a, b) => b.memoryMB - a.memoryMB);
+    }
+    return c.json(processes.slice(0, limit));
+  } catch {
+    try {
+      const sortFlag = sortBy === "cpu" ? "-pcpu" : "-rss";
+      const result = execSync5(`ps -eo pid,comm,args,%cpu,rss --sort=${sortFlag} --no-headers | head -${limit + 1}`, { encoding: "utf-8", timeout: 5000 });
+      const memTotal = parseInt(execSync5("grep MemTotal /proc/meminfo", { encoding: "utf-8" }).match(/(\d+)/)?.[1] || "0", 10) * 1024;
+      const processes = [];
+      for (const line of result.trim().split(`
+`)) {
+        const match3 = line.match(/^\s*(\d+)\s+(\S+)\s+(.+?)\s+([\d.]+)\s+(\d+)\s*$/);
+        if (match3) {
+          const memoryKB = parseInt(match3[5], 10);
+          processes.push({
+            pid: parseInt(match3[1], 10),
+            name: match3[2],
+            command: match3[3].trim().slice(0, 200),
+            cpuPercent: parseFloat(match3[4]),
+            memoryMB: Math.round(memoryKB / 1024 * 10) / 10,
+            memoryPercent: memTotal > 0 ? Math.round(memoryKB * 1024 / memTotal * 1000) / 10 : 0
+          });
+        }
+      }
+      return c.json(processes);
+    } catch (fallbackErr) {
+      const message = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+      return c.json({ error: message }, 500);
+    }
+  }
+});
+monitoringRoutes.get("/docker-stats", (c) => {
+  try {
+    let result;
+    let runtime = "docker";
+    try {
+      result = execSync5('docker stats --no-stream --format "{{json .}}"', {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      try {
+        result = execSync5('podman stats --no-stream --format "{{json .}}"', {
+          encoding: "utf-8",
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        runtime = "podman";
+      } catch {
+        return c.json({ containers: [], available: false, runtime: null });
+      }
+    }
+    const containers = [];
+    for (const line of result.trim().split(`
+`)) {
+      if (!line.trim())
+        continue;
+      try {
+        const data = JSON.parse(line);
+        const cpuStr = data.CPUPerc || "0%";
+        const cpuPercent = parseFloat(cpuStr.replace("%", "")) || 0;
+        const memUsageStr = data.MemUsage || "0B / 0B";
+        const [usedStr, limitStr] = memUsageStr.split(" / ");
+        const parseMemory = (str) => {
+          const match3 = str.match(/([\d.]+)\s*(B|KB|KiB|MB|MiB|GB|GiB)/i);
+          if (!match3)
+            return 0;
+          const value = parseFloat(match3[1]);
+          const unit = match3[2].toLowerCase();
+          switch (unit) {
+            case "b":
+              return value / (1024 * 1024);
+            case "kb":
+            case "kib":
+              return value / 1024;
+            case "mb":
+            case "mib":
+              return value;
+            case "gb":
+            case "gib":
+              return value * 1024;
+            default:
+              return value;
+          }
+        };
+        const memoryMB = parseMemory(usedStr);
+        const memoryLimit = parseMemory(limitStr);
+        const memPercStr = data.MemPerc || "0%";
+        const memoryPercent = parseFloat(memPercStr.replace("%", "")) || 0;
+        containers.push({
+          id: (data.ID || data.Id || "").slice(0, 12),
+          name: data.Name || data.Names || "unknown",
+          cpuPercent: Math.round(cpuPercent * 10) / 10,
+          memoryMB: Math.round(memoryMB * 10) / 10,
+          memoryLimit: Math.round(memoryLimit * 10) / 10,
+          memoryPercent: Math.round(memoryPercent * 10) / 10
+        });
+      } catch {
+        continue;
+      }
+    }
+    containers.sort((a, b) => b.memoryMB - a.memoryMB);
+    return c.json({ containers, available: true, runtime });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ error: message }, 500);
+  }
+});
 
 // server/app.ts
 function getDistPath() {