gemini-computer-use 0.2.3 → 0.4.1

package/core/version.py

@@ -0,0 +1,31 @@
+"""core/version.py - the ONE place this node's version is declared.
+
+Every other place that needs the node version asks this module:
+
+* ``core/updater.py`` compares it against the newest GitHub release;
+* ``core/mcp_tools.py`` reports it from ``mesh_status`` and ``mesh_update``;
+* ``build-installer-exe.ps1`` refuses to build when ``package.json`` disagrees
+  with it, so the npm package and the Python node can never ship as two
+  different versions;
+* ``tests/test_version_single_source.py`` pins that agreement.
+
+The repository deliberately keeps no second literal: a version that lives in two
+files is a version that eventually disagrees with itself, and an updater that
+compares the wrong number either reinstalls forever or never updates at all.
+
+Format: ``MAJOR.MINOR.PATCH``, optionally followed by a pre-release suffix
+(``0.3.0-rc.1``). The suffix never changes the meaning of the three numbers; a
+pre-release is older than the release it precedes, which is what
+``core.updater.is_newer`` implements.
+"""
+
+#: The node version. Keep it in sync with ``package.json`` (the build enforces it).
+__version__ = "0.4.1"
+
+#: The repository that publishes the releases this node updates itself from.
+#: Declared here as well so a checkout says where it came from; ``package.json``
+#: carries the same slug under ``repository.url`` and a test pins the agreement.
+REPO_SLUG = "LevRa7/Computer-use-for-Gemini-App-Web"
+
+#: Anchored pattern for the only accepted spelling, used by the single-source test.
+VERSION_PATTERN = r"^\d+\.\d+\.\d+(?:-[0-9A-Za-z.\-]+)?$"

package/core/vitals.py

@@ -3,11 +3,70 @@ import platform
 import shutil
 import socket
 import subprocess
+import time
 from typing import Dict, Any
 
+
+def _windows_cpu_usage_pct(sample_seconds: float = 0.1) -> float:
+    """Measured CPU utilisation on Windows.
+
+    Windows has no load average, so ``os.getloadavg`` does not exist and the
+    previous code reported a hardcoded 0.0. ``GetSystemTimes`` gives idle and
+    total processor time, and their delta over a short sample is the utilisation
+    every other Windows tool reports.
+    """
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        class FILETIME(ctypes.Structure):
+            _fields_ = [
+                ("dwLowDateTime", wintypes.DWORD),
+                ("dwHighDateTime", wintypes.DWORD),
+            ]
+
+        def as_int(value: "FILETIME") -> int:
+            return (value.dwHighDateTime << 32) | value.dwLowDateTime
+
+        kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+
+        def sample():
+            idle_c, kernel_c, user_c = FILETIME(), FILETIME(), FILETIME()
+            ok = kernel32.GetSystemTimes(
+                ctypes.byref(idle_c), ctypes.byref(kernel_c), ctypes.byref(user_c)
+            )
+            if not ok:
+                return None
+            return as_int(idle_c), as_int(kernel_c), as_int(user_c)
+
+        first = sample()
+        if first is None:
+            return 0.0
+        time.sleep(sample_seconds)
+        second = sample()
+        if second is None:
+            return 0.0
+
+        idle_delta = second[0] - first[0]
+        total_delta = (second[1] - first[1]) + (second[2] - first[2])
+        if total_delta <= 0:
+            return 0.0
+        usage = 100.0 * (total_delta - idle_delta) / total_delta
+        return round(max(0.0, min(100.0, usage)), 1)
+    except Exception:
+        return 0.0
+
+
 def get_host_vitals() -> Dict[str, Any]:
     hostname = socket.gethostname()
-    system = platform.system()  # 'Linux', 'Darwin', 'Windows'
+    system = platform.system()  # 'Linux', 'Darwin', 'Windows' - and 'Android' on a phone
+
+    # Python on Android (Termux, 3.13+) answers platform.system() == "Android", not
+    # "Linux", although it is Linux underneath and /proc is right there. Without this
+    # a phone reported "0 MB of RAM" - verified on an OPPO PHY110 running Android 16
+    # with Python 3.14, where the memory block came back as 0.0/0.0 MB. The file is
+    # the honest signal, so it decides.
+    linux_like = system == "Linux" or os.path.isfile("/proc/meminfo")
 
     # CPU load average (Unix)
     cpu_load = {"1m": 0.0, "5m": 0.0, "15m": 0.0}
@@ -19,6 +78,11 @@ def get_host_vitals() -> Dict[str, Any]:
                 "5m": round(load[1], 2),
                 "15m": round(load[2], 2),
             }
+        elif system == "Windows":
+            # No load average exists there: report the measured utilisation in all
+            # three slots so no consumer reads a fabricated zero.
+            usage = _windows_cpu_usage_pct()
+            cpu_load = {"1m": usage, "5m": usage, "15m": usage}
     except Exception:
         pass
 
@@ -26,7 +90,7 @@ def get_host_vitals() -> Dict[str, Any]:
     total_mb = 0.0
     free_mb = 0.0
 
-    if system == "Linux":
+    if linux_like:
         total_kb, avail_kb = 0, 0
         try:
             with open("/proc/meminfo", "r") as f: