negotium 0.6.8 → 0.6.9

package/dist/main.js

@@ -3674,7 +3674,7 @@ var exports_version = {};
 __export(exports_version, {
   NEGOTIUM_VERSION: () => NEGOTIUM_VERSION
 });
-var NEGOTIUM_VERSION = "0.6.8";
+var NEGOTIUM_VERSION = "0.6.9";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn as spawn2 } from "child_process";
@@ -25107,7 +25107,7 @@ __export(exports_system_health, {
   createSystemHealthMcpServer: () => createSystemHealthMcpServer
 });
 import { execFile as execFile2 } from "child_process";
-import { cpus, freemem, loadavg, totalmem } from "os";
+import { cpus, loadavg } from "os";
 import { promisify as promisify2 } from "util";
 import { McpServer as McpServer4 } from "@modelcontextprotocol/sdk/server/mcp.js";
 function fmtBytes(bytes) {
@@ -25119,13 +25119,58 @@ async function shell(command, args) {
   return stdout.trim();
 }
 async function getMemoryPressure() {
+  let level = "unknown";
   try {
-    const level = await shell("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"]);
-    return level === "4" ? "critical" : level === "2" ? "warning" : "normal";
+    const l = await shell("sysctl", ["-n", "kern.memorystatus_vm_pressure_level"]);
+    level = l === "4" ? "critical" : l === "2" ? "warning" : "normal";
+  } catch {}
+  let freePct = null;
+  try {
+    const out = await shell("memory_pressure", []);
+    const m = out.match(/System-wide memory free percentage:\s*(\d+)%/);
+    if (m)
+      freePct = Number(m[1]);
+  } catch {}
+  return { level, freePct };
+}
+async function getTotalMemBytes() {
+  try {
+    return Number(await shell("sysctl", ["-n", "hw.memsize"]));
   } catch {
-    return "unknown";
+    return 0;
   }
 }
+async function getVmStatMemory() {
+  const [out, totalFromSysctl] = await Promise.all([shell("vm_stat", []), getTotalMemBytes()]);
+  const extract = (label) => {
+    const m = out.match(new RegExp(`${label.replace(/\s/g, "\\s")}:\\s+(\\d+)`));
+    return m ? Number(m[1]) : 0;
+  };
+  const pageSize = Number(out.match(/page size of (\d+) bytes/)?.[1]) || 16384;
+  const pagesFree = extract("Pages free");
+  const pagesActive = extract("Pages active");
+  const pagesInactive = extract("Pages inactive");
+  const pagesSpeculative = extract("Pages speculative");
+  const pagesWired = extract("Pages wired down");
+  const pagesPurgeable = extract("Pages purgeable");
+  const pagesCompressor = extract("Pages occupied by compressor");
+  const activeBytes = pagesActive * pageSize;
+  const wiredBytes = pagesWired * pageSize;
+  const usedBytes = activeBytes + wiredBytes;
+  const cacheBytes = (pagesInactive + pagesSpeculative + pagesPurgeable) * pageSize;
+  const compressorBytes = pagesCompressor * pageSize;
+  const totalBytes = totalFromSysctl || (pagesFree + pagesActive + pagesInactive + pagesSpeculative + pagesWired + pagesPurgeable + pagesCompressor) * pageSize;
+  const availableBytes = Math.max(0, totalBytes - usedBytes);
+  return {
+    usedBytes,
+    cacheBytes,
+    compressorBytes,
+    availableBytes,
+    totalBytes,
+    activeBytes,
+    wiredBytes
+  };
+}
 async function getSwapUsage() {
   try {
     const output = await shell("sysctl", ["vm.swapusage"]);
@@ -25182,23 +25227,30 @@ function createSystemHealthMcpServer(host2 = defaultSystemHealthMcpHost) {
   server.tool("get_system_health", [
     "\uC2DC\uC2A4\uD15C \uC0C1\uD0DC\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4.",
     "- CPU \uBD80\uD558 (load average 1/5/15\uBD84)",
-    "- \uBA54\uBAA8\uB9AC \uC0AC\uC6A9\uB7C9 + \uC555\uB825 (normal/warning/critical)",
+    "- \uBA54\uBAA8\uB9AC: \uC571 \uC2E4\uC0AC\uC6A9(active+wired) / \uD30C\uC77C\uCE90\uC2DC(\uBC18\uD658\uAC00\uB2A5) / available / \uC555\uB825(free%\xB7level)",
     "- \uC2A4\uC651 \uC0AC\uC6A9\uB7C9",
     "- \uB514\uC2A4\uD06C \uC0AC\uC6A9\uB960 (/)",
     "- \uC5F4 \uC0C1\uD0DC (thermal)",
-    "- \uD504\uB85C\uC138\uC2A4 \uC218"
+    "- \uD504\uB85C\uC138\uC2A4 \uC218",
+    "",
+    "\u26A0\uFE0F Chromium/playwright \uB4F1 \uBB34\uAC70\uC6B4 \uD504\uB85C\uC138\uC2A4 \uC2E4\uD589 \uAC00\uB2A5 \uC5EC\uBD80\uB294 '\uBA54\uBAA8\uB9AC \uC0AC\uC6A9%'\uAC00 \uC544\uB2C8\uB77C",
+    "   \uBA54\uBAA8\uB9AC \uC555\uB825 \uB808\uBCA8(normal/warning/critical) + available GB \uB85C \uD310\uB2E8\uD560 \uAC83.",
+    "   (\uD30C\uC77C \uCE90\uC2DC\uB294 \uC555\uBC15 \uC2DC \uC989\uC2DC \uBC18\uD658\uB418\uBBC0\uB85C used%\uC5D0 \uAC81\uBA39\uC9C0 \uB9D0 \uAC83)"
   ].join(`
 `), {}, async () => {
     const snapshot = await host2.readSystemHealth();
-    const used = snapshot.memoryTotal - snapshot.memoryFree;
-    const memoryPercent = (used / snapshot.memoryTotal * 100).toFixed(1);
+    const { memory } = snapshot;
+    const usedPct = memory.totalBytes > 0 ? (memory.usedBytes / memory.totalBytes * 100).toFixed(1) : "0.0";
     const [load1, load5, load15] = snapshot.cpuLoad;
+    const pressureStr = snapshot.memoryPressure.freePct !== null ? `${snapshot.memoryPressure.level} (free ${snapshot.memoryPressure.freePct}%)` : snapshot.memoryPressure.level;
     return mcpOk([
       "\uC2DC\uC2A4\uD15C \uC0C1\uD0DC",
       "",
       `CPU \uBD80\uD558:      ${load1.toFixed(2)} / ${load5.toFixed(2)} / ${load15.toFixed(2)}  (1/5/15\uBD84, \uCF54\uC5B4 ${snapshot.cpuCount}\uAC1C)`,
-      `\uBA54\uBAA8\uB9AC:        ${fmtBytes(used)} / ${fmtBytes(snapshot.memoryTotal)} (${memoryPercent}%)  \uC5EC\uC720: ${fmtBytes(snapshot.memoryFree)}`,
-      `\uBA54\uBAA8\uB9AC \uC555\uB825:   ${snapshot.memoryPressure}`,
+      `\uBA54\uBAA8\uB9AC \uC2E4\uC0AC\uC6A9: ${fmtBytes(memory.usedBytes)} / ${fmtBytes(memory.totalBytes)} (${usedPct}%)  available: ${fmtBytes(memory.availableBytes)}`,
+      `  (active ${fmtBytes(memory.activeBytes)} + wired ${fmtBytes(memory.wiredBytes)})`,
+      `\uD30C\uC77C \uCE90\uC2DC:     ${fmtBytes(memory.cacheBytes)} (\uC555\uBC15 \uC2DC \uBC18\uD658 \uAC00\uB2A5)  |  \uC555\uCD95 ${fmtBytes(memory.compressorBytes)}`,
+      `\uBA54\uBAA8\uB9AC \uC555\uB825:   ${pressureStr}`,
       `\uC2A4\uC651:          ${snapshot.swap}`,
       `\uB514\uC2A4\uD06C(/):     ${snapshot.disk}`,
       `\uC5F4 \uC0C1\uD0DC:       ${snapshot.thermal}`,
@@ -25214,19 +25266,19 @@ var init_system_health = __esm(() => {
   execFileAsync2 = promisify2(execFile2);
   defaultSystemHealthMcpHost = {
     async readSystemHealth() {
-      const [memoryPressure, swap, thermal, disk, processCount] = await Promise.all([
+      const [memoryPressure, swap, thermal, disk, processCount, memory] = await Promise.all([
         getMemoryPressure(),
         getSwapUsage(),
         getThermal(),
         getDisk(),
-        getProcessCount()
+        getProcessCount(),
+        getVmStatMemory()
       ]);
       const load = loadavg();
       return {
         cpuLoad: [load[0] ?? 0, load[1] ?? 0, load[2] ?? 0],
         cpuCount: cpus().length,
-        memoryTotal: totalmem(),
-        memoryFree: freemem(),
+        memory,
         memoryPressure,
         swap,
         disk,
@@ -46742,7 +46794,7 @@ var init_gateway_forward = __esm(async () => {
 
 // ../../adapters/otium/src/peer-server.ts
 import { statfsSync } from "fs";
-import { cpus as cpus2, freemem as freemem2, loadavg as loadavg2, totalmem as totalmem2 } from "os";
+import { cpus as cpus2, freemem, loadavg as loadavg2, totalmem } from "os";
 function jsonError2(error2, status) {
   return Response.json({ ok: false, error: error2 }, { status });
 }
@@ -46842,8 +46894,8 @@ function localHealth() {
     uptimeSeconds: process.uptime(),
     cpu: { cores: cpus2().length, loadAverage: loadavg2() },
     memory: {
-      totalBytes: totalmem2(),
-      freeBytes: freemem2(),
+      totalBytes: totalmem(),
+      freeBytes: freemem(),
       processRssBytes: memory.rss,
       processHeapUsedBytes: memory.heapUsed
     },
@@ -48752,4 +48804,4 @@ switch (command) {
   }
 }
 
-//# debugId=13376A79B7F9FD5464756E2164756E21
+//# debugId=4A0B3AF545043CDF64756E2164756E21