pyre-cli 9.5.0 → 9.5.2

package/dist/{chunk-PV4MXTAJ.js → chunk-N4WJVF5M.js}

@@ -1,3 +1,6 @@
+import {
+  collectBlenderRenders
+} from "./chunk-25I533OF.js";
 import {
   run
 } from "./chunk-FH5WDJBF.js";
@@ -58,6 +61,25 @@ async function getSmcMetrics() {
     } catch {
     }
   }
+  if (result.temps["cpu_die"] === void 0) {
+    try {
+      const battRaw = await run("ioreg -r -n AppleSmartBattery 2>/dev/null", "");
+      if (battRaw) {
+        const virtMatch = battRaw.match(/"VirtualTemperature"\s*=\s*(\d+)/);
+        const cellMatch = battRaw.match(/"Temperature"\s*=\s*(\d+)/);
+        const rawVirt = virtMatch ? parseFloat(virtMatch[1]) : void 0;
+        const rawCell = cellMatch ? parseFloat(cellMatch[1]) : void 0;
+        const virtC = rawVirt !== void 0 ? Math.round(rawVirt / 10) / 10 : void 0;
+        const cellC = rawCell !== void 0 ? Math.round(rawCell / 10) / 10 : void 0;
+        if (virtC !== void 0 && virtC >= 15 && virtC <= 115) {
+          result.temps["cpu_die"] = virtC;
+        } else if (cellC !== void 0 && cellC >= 15 && cellC <= 115) {
+          result.temps["cpu_die"] = cellC;
+        }
+      }
+    } catch {
+    }
+  }
   if (result.temps["cpu_die"] === void 0) {
     try {
       const tz0 = (await run("cat /sys/class/thermal/thermal_zone0/temp 2>/dev/null", "")).trim();
@@ -91,6 +113,43 @@ function parseSuffix(s) {
   return s.toUpperCase() === "K" ? 1024 : s.toUpperCase() === "M" ? 1024 * 1024 : s.toUpperCase() === "G" ? 1024 * 1024 * 1024 : 1;
 }
 
+// src/monitors/dns_cache.ts
+import dns from "dns";
+var cache = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Set();
+function resolveIp(ip) {
+  let cleanIp = ip;
+  if (cleanIp.includes("]:")) {
+    cleanIp = cleanIp.substring(1, cleanIp.indexOf("]"));
+  } else if (cleanIp.includes(":") && cleanIp.split(":").length === 2) {
+    cleanIp = cleanIp.split(":")[0];
+  } else if (cleanIp.includes(":") && !cleanIp.includes("]")) {
+    const lastColon = cleanIp.lastIndexOf(":");
+    const isPort = !cleanIp.includes(":", cleanIp.indexOf(":") + 1);
+  }
+  if (cleanIp.includes(":") && cleanIp.includes(".")) {
+    const lastDot = cleanIp.lastIndexOf(".");
+    if (lastDot > cleanIp.lastIndexOf(":")) {
+      cleanIp = cleanIp.substring(0, lastDot);
+    }
+  }
+  if (cache.has(cleanIp)) return cache.get(cleanIp);
+  if (pending.has(cleanIp)) return ip;
+  if (cleanIp.startsWith("127.") || cleanIp.startsWith("192.168.") || cleanIp.startsWith("10.") || cleanIp.startsWith("172.16.") || cleanIp.startsWith("ff02:") || cleanIp === "*:*" || cleanIp === "*" || cleanIp.startsWith("fe80:")) {
+    return ip;
+  }
+  pending.add(cleanIp);
+  dns.reverse(cleanIp, (err, hostnames) => {
+    if (!err && hostnames && hostnames.length > 0) {
+      cache.set(cleanIp, hostnames[0]);
+    } else {
+      cache.set(cleanIp, cleanIp);
+    }
+    pending.delete(cleanIp);
+  });
+  return ip;
+}
+
 // src/monitors/collectors.ts
 var SP_TTL_MS = 1e4;
 var NETSTAT_TTL_MS = 1e3;
@@ -103,6 +162,7 @@ var spBatteryCache = null;
 var netstatIbCache = null;
 var routeCache = null;
 var sysctlCache = /* @__PURE__ */ new Map();
+var prevNetSample = null;
 async function cachedSysctl(key, fallback) {
   const now = Date.now();
   const hit = sysctlCache.get(key);
@@ -166,7 +226,7 @@ function estimateBatteryLife(level, state) {
   return { estimatedTimeToEmpty, dischargeRatePerHour: Math.round(dischargeRate * 10) / 10, powerWatts };
 }
 async function collectAll(opts = {}) {
-  const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks] = await Promise.all([
+  const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks, containers, blenderRenders] = await Promise.all([
     collectCpu(),
     collectGpu(opts.detailed),
     collectMemory(),
@@ -178,7 +238,9 @@ async function collectAll(opts = {}) {
     collectSystem(),
     collectPower(),
     collectPackets(),
-    collectTasks()
+    collectTasks(),
+    collectContainers(),
+    collectBlenderRenders()
   ]);
   return {
     header: {
@@ -198,9 +260,32 @@ async function collectAll(opts = {}) {
     power,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     packets,
-    tasks
+    tasks,
+    containers,
+    blenderRenders
   };
 }
+async function collectContainers() {
+  try {
+    const raw = (await run('docker stats --no-stream --format "{{.ID}}|{{.Name}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}|{{.NetIO}}|{{.BlockIO}}|{{.PIDs}}" 2>/dev/null', "")).trim();
+    if (!raw) return [];
+    return raw.split("\n").map((line) => {
+      const parts = line.split("|");
+      return {
+        id: parts[0],
+        name: parts[1],
+        cpuPercent: parseFloat(parts[2].replace("%", "")) || 0,
+        memUsage: parts[3],
+        memPercent: parseFloat(parts[4].replace("%", "")) || 0,
+        netIO: parts[5],
+        blockIO: parts[6],
+        pids: parseInt(parts[7], 10) || 0
+      };
+    });
+  } catch {
+    return [];
+  }
+}
 async function collectPower() {
   try {
     const { power } = await getSmcMetrics();
@@ -730,9 +815,148 @@ async function collectNetwork() {
         }
       }
     }
-    return { interface: iface, ip, rxBytes, txBytes, rxPackets, txPackets };
+    const now = Date.now();
+    let rxRate = 0;
+    let txRate = 0;
+    if (prevNetSample && prevNetSample.ts > 0) {
+      const dt = Math.max((now - prevNetSample.ts) / 1e3, 1e-3);
+      rxRate = Math.max(0, (rxBytes - prevNetSample.rxBytes) / dt);
+      txRate = Math.max(0, (txBytes - prevNetSample.txBytes) / dt);
+    }
+    prevNetSample = { rxBytes, txBytes, rxPackets, txPackets, ts: now };
+    const protocolStats = await getProtocolStats();
+    const connectionStates = await getConnectionStates();
+    const listeningPorts = await getListeningPorts();
+    const establishedConnections = connectionStates.established;
+    const topRemoteHosts = await getTopRemoteHosts();
+    return {
+      interface: iface,
+      ip,
+      rxBytes,
+      txBytes,
+      rxPackets,
+      txPackets,
+      rxRate,
+      txRate,
+      connections: establishedConnections,
+      protocols: protocolStats,
+      connectionStates,
+      listeningPorts,
+      establishedConnections,
+      topRemoteHosts
+    };
   } catch {
-    return { interface: "unknown", ip: "0.0.0.0", rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0 };
+    return {
+      interface: "unknown",
+      ip: "0.0.0.0",
+      rxBytes: 0,
+      txBytes: 0,
+      rxPackets: 0,
+      txPackets: 0,
+      rxRate: 0,
+      txRate: 0,
+      connections: 0,
+      protocols: { tcp: { connections: 0, rxBytes: 0, txBytes: 0 }, udp: { connections: 0, rxBytes: 0, txBytes: 0 } },
+      connectionStates: { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 },
+      listeningPorts: [],
+      establishedConnections: 0,
+      topRemoteHosts: []
+    };
+  }
+}
+async function getProtocolStats() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | awk '{print $1}' | sort | uniq -c", "");
+    const tcpConnections = (await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | wc -l", "0")).trim();
+    const udpConnections = (await run("netstat -n -p udp 2>/dev/null | tail -n +3 | wc -l", "0")).trim();
+    let tcpRxBytes = 0;
+    let tcpTxBytes = 0;
+    let udpRxBytes = 0;
+    let udpTxBytes = 0;
+    try {
+      const netstat = await cachedNetstatIb();
+      for (const line of netstat.split("\n")) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 9 && parts[0] && !parts[0].startsWith("Name")) {
+          const iface = parts[0];
+          if (iface.includes("lo")) continue;
+          const rx = parseInt(parts[5]) || 0;
+          const tx = parseInt(parts[7]) || 0;
+          tcpRxBytes += rx;
+          tcpTxBytes += tx;
+        }
+      }
+    } catch {
+    }
+    return {
+      tcp: {
+        connections: parseInt(tcpConnections) || 0,
+        rxBytes: tcpRxBytes,
+        txBytes: tcpTxBytes
+      },
+      udp: {
+        connections: parseInt(udpConnections) || 0,
+        rxBytes: udpRxBytes,
+        txBytes: udpTxBytes
+      }
+    };
+  } catch {
+    return { tcp: { connections: 0, rxBytes: 0, txBytes: 0 }, udp: { connections: 0, rxBytes: 0, txBytes: 0 } };
+  }
+}
+async function getConnectionStates() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | awk '{print $6}' | sort | uniq -c", "");
+    const lines = raw.split("\n").filter(Boolean);
+    const stats = { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+    for (const line of lines) {
+      const match = line.match(/(\d+)\s+(\S+)/);
+      if (!match) continue;
+      const count = parseInt(match[1]);
+      const state = match[2].toUpperCase();
+      if (state.includes("ESTABLISHED")) stats.established += count;
+      else if (state.includes("LISTEN")) stats.listening += count;
+      else if (state.includes("TIME_WAIT")) stats.timeWait += count;
+      else if (state.includes("CLOSE_WAIT")) stats.closeWait += count;
+      else stats.other += count;
+    }
+    return stats;
+  } catch {
+    return { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+  }
+}
+async function getListeningPorts() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | grep LISTEN | awk '{print $4}' | rev | cut -d. -f1 | rev", "");
+    const ports = raw.split("\n").map((p) => parseInt(p, 10)).filter((p) => !isNaN(p) && p > 0);
+    return [...new Set(ports)].sort((a, b) => a - b);
+  } catch {
+    return [];
+  }
+}
+async function getTopRemoteHosts() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | grep ESTABLISHED | awk '{print $5}' | rev | cut -d. -f1 | rev", "");
+    const ports = raw.split("\n").filter(Boolean);
+    const hostMap = /* @__PURE__ */ new Map();
+    for (const port of ports) {
+      const host = port.split(":")[0];
+      if (!host || host === "127.0.0.1" || host === "::1") continue;
+      const existing = hostMap.get(host) || { count: 0, bytes: 0 };
+      hostMap.set(host, { count: existing.count + 1, bytes: existing.bytes });
+    }
+    const result = [];
+    for (const [host, info] of hostMap.entries()) {
+      result.push({
+        host,
+        ip: host,
+        bytesTransferred: info.bytes,
+        connectionCount: info.count
+      });
+    }
+    return result.sort((a, b) => b.connectionCount - a.connectionCount).slice(0, 10);
+  } catch {
+    return [];
   }
 }
 async function collectProcesses(limit) {
@@ -781,29 +1005,67 @@ async function collectPackets() {
       }
     }
     let connections = 0;
-    try {
-      const tcpConns = (await run("netstat -an | grep ESTABLISHED | wc -l", "0", 2e3)).trim();
-      connections = parseInt(tcpConns) || 0;
-    } catch {
-      connections = 0;
-    }
-    let topProcesses = [];
     let allProcesses = [];
     try {
-      const lsof = (await run("lsof -i -n -P 2>/dev/null | tail -n +2 | awk '{print $1, $2}' | sort | uniq -c | sort -rn", "", 2e3)).trim();
-      const lsofLines = lsof.split("\n");
-      topProcesses = lsofLines.map((line) => {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length >= 3) {
-          return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
+      const nettop = (await run("nettop -L 1 -J bytes_in,bytes_out,state 2>/dev/null", "", 2e3)).trim();
+      const rows = nettop.split("\n");
+      let currentProc = null;
+      for (const row of rows) {
+        if (!row || row.startsWith(",state,")) continue;
+        const cols = row.split(",");
+        const nameCol = cols[0];
+        if (!nameCol.includes("<->")) {
+          if (currentProc) {
+            if (currentProc.connections && currentProc.connections.length > 0) {
+              allProcesses.push(currentProc);
+            }
+          }
+          const lastDot = nameCol.lastIndexOf(".");
+          let pid = 0;
+          let command = nameCol;
+          if (lastDot > 0) {
+            const possiblePid = parseInt(nameCol.substring(lastDot + 1));
+            if (!isNaN(possiblePid)) {
+              pid = possiblePid;
+              command = nameCol.substring(0, lastDot);
+            }
+          }
+          const rx = parseInt(cols[2]) || 0;
+          const tx = parseInt(cols[3]) || 0;
+          currentProc = { pid, command, rxBytes: rx, txBytes: tx, connections: [] };
+        } else {
+          if (currentProc) {
+            const state = cols[1];
+            const rx = parseInt(cols[2]) || 0;
+            const tx = parseInt(cols[3]) || 0;
+            if (state === "Established") connections++;
+            const spaceIdx = nameCol.indexOf(" ");
+            const protocol = spaceIdx > 0 ? nameCol.substring(0, spaceIdx) : "";
+            const endpoints = spaceIdx > 0 ? nameCol.substring(spaceIdx + 1) : nameCol;
+            const arrowIdx = endpoints.indexOf("<->");
+            let local = "";
+            let remote = "";
+            if (arrowIdx > 0) {
+              local = endpoints.substring(0, arrowIdx);
+              remote = endpoints.substring(arrowIdx + 3);
+              remote = resolveIp(remote);
+            } else {
+              local = endpoints;
+            }
+            currentProc.connections.push({ protocol, local, remote, state, rxBytes: rx, txBytes: tx });
+          }
         }
-        return { pid: 0, command: "", rxBytes: 0, txBytes: 0 };
-      }).filter((p) => p.pid > 0);
-      allProcesses = topProcesses;
+      }
+      if (currentProc && currentProc.connections && currentProc.connections.length > 0) {
+        allProcesses.push(currentProc);
+      }
     } catch {
-      topProcesses = [];
       allProcesses = [];
     }
+    const topProcesses = [...allProcesses].sort((a, b) => b.rxBytes + b.txBytes - (a.rxBytes + a.txBytes));
+    const protocolStats = await getProtocolStats();
+    const connectionStates = await getConnectionStates();
+    const listeningPorts = await getListeningPorts();
     return {
       totalPackets: totalRxPackets + totalTxPackets,
       rxPackets: totalRxPackets,
@@ -813,7 +1075,10 @@ async function collectPackets() {
       connections,
       topProcesses,
       interfaces: ifaceStats,
-      allProcesses
+      allProcesses,
+      protocolStats,
+      connectionStates,
+      listeningPorts
     };
   } catch {
     return null;
@@ -902,6 +1167,7 @@ async function getTimeMachineStatus() {
 
 export {
   collectAll,
+  collectContainers,
   collectPower,
   collectGpu,
   collectCpu,

package/dist/{collectors-VYUH3UWY.js → collectors-JB4OGUEF.js}

@@ -1,6 +1,7 @@
 import {
   collectAll,
   collectBattery,
+  collectContainers,
   collectCpu,
   collectDisk,
   collectGpu,
@@ -13,11 +14,13 @@ import {
   collectThermal,
   getDisplayInfo,
   getTimeMachineStatus
-} from "./chunk-PV4MXTAJ.js";
+} from "./chunk-N4WJVF5M.js";
+import "./chunk-25I533OF.js";
 import "./chunk-FH5WDJBF.js";
 export {
   collectAll,
   collectBattery,
+  collectContainers,
   collectCpu,
   collectDisk,
   collectGpu,

package/dist/{config-4ZLF4HTS.js → config-KS5ZZ3VN.js}

@@ -8,7 +8,7 @@ import {
   readConfig,
   saveProfile,
   writeConfig
-} from "./chunk-RVGKEJXT.js";
+} from "./chunk-CXL4GYGQ.js";
 export {
   CONFIG_FILE,
   DEFAULT_CONFIG,

package/dist/{doctor-L6FZYA7F.js → doctor-UV7TWIHX.js}

@@ -1,7 +1,7 @@
 import {
   CONFIG_FILE,
   readConfig
-} from "./chunk-RVGKEJXT.js";
+} from "./chunk-CXL4GYGQ.js";
 import {
   run
 } from "./chunk-FH5WDJBF.js";