gemini-computer-use 0.2.4 → 0.4.1

package/core/policies.py

@@ -5,12 +5,27 @@ from google.antigravity import types
 from google.antigravity.hooks import policy
 from google.antigravity.hooks.policy import Policy, Decision
 
+def _platform_root(posix_root: str) -> str:
+    """Express a documented deployment root for the host running this node.
+
+    ``/root/...`` is an absolute path on Linux but only drive-relative on Windows,
+    where the SDK refuses it outright ("app_data_dir must be an absolute path") and
+    ``os.makedirs`` would scatter a ``\\root\\...`` tree beside the drive root. The
+    POSIX path is kept unchanged on POSIX hosts, so deployed services do not move.
+    """
+    if os.name != "nt":
+        return posix_root
+    leaf = posix_root.rstrip("/").rsplit("/", 1)[-1]
+    return os.path.join(os.path.expanduser("~"), leaf)
+
+
 # Workspace roots are read from the environment ONLY -- never hardcode a personal
 # home directory. Point MESH_COORDINATOR_WORKSPACE / MESH_WORKSPACE at the real
-# deployment paths in the service environment.
+# deployment paths in the service environment. The documented defaults are the
+# Linux deployment paths; on Windows the same roots live under the user profile.
 ALLOWED_WORKSPACES = [
-    os.environ.get("MESH_COORDINATOR_WORKSPACE", "/root/agy-gdrive-runner"),
-    os.environ.get("MESH_WORKSPACE", "/root/antigravity-mesh"),
+    os.environ.get("MESH_COORDINATOR_WORKSPACE") or _platform_root("/root/agy-gdrive-runner"),
+    os.environ.get("MESH_WORKSPACE") or _platform_root("/root/antigravity-mesh"),
 ]
 
 SAFE_COMMAND_PREFIXES = [
@@ -40,12 +55,27 @@ DESTRUCTIVE_COMMAND_PATTERNS = [
     re.compile(r"\bdd\s+"),
 ]
 
+def _is_within(path: str, root: str) -> bool:
+    """True when *path* is *root* itself or lives inside it.
+
+    The comparison has to use the platform separator: ``root + "/"`` never
+    matches a normpath'ed Windows path, so every file inside an allowed workspace
+    was rejected there and the policy could not be satisfied at all.
+    """
+    if path == root:
+        return True
+    root = root.rstrip("/\\")
+    for sep in {os.sep, "/", "\\"}:
+        if path.startswith(root + sep):
+            return True
+    return False
+
+
 def validate_workspace_path(path: str, allowed_workspaces: Optional[List[str]] = None) -> bool:
     workspaces = allowed_workspaces or ALLOWED_WORKSPACES
     abs_path = os.path.abspath(path)
     for ws in workspaces:
-        ws_abs = os.path.abspath(ws)
-        if abs_path == ws_abs or abs_path.startswith(ws_abs.rstrip("/") + "/"):
+        if _is_within(abs_path, os.path.abspath(ws)):
             return True
     return False
 

package/core/server.py

@@ -169,47 +169,72 @@ def get_coordinator_vitals() -> "NodeVitals":
     except Exception:
         load = 0.0
 
+    # ``/proc/meminfo`` and ``/proc/uptime`` are Linux-only. Ask the shared
+    # cross-platform collector first (core.vitals knows the Windows and macOS
+    # paths), and keep the inline /proc parsing as the last resort.
+    native: Optional[Dict[str, Any]] = None
+    if _core_get_host_vitals is not None:
+        try:
+            candidate = _core_get_host_vitals()
+            if isinstance(candidate, dict):
+                native = candidate
+        except Exception:
+            native = None
+
     total_mb = 1
     used_mb = 0
-    try:
-        with open("/proc/meminfo", "r") as f:
-            lines = f.readlines()
-        mem = {}
-        for line in lines:
-            parts = line.split(":")
-            if len(parts) == 2:
-                k = parts[0].strip()
-                v = parts[1].strip().split()[0]
-                if k in ["MemTotal", "MemAvailable"]:
-                    mem[k] = int(v) // 1024
-        if "MemTotal" in mem and "MemAvailable" in mem:
-            total_mb = mem["MemTotal"]
-            avail_mb = mem["MemAvailable"]
-            used_mb = max(0, total_mb - avail_mb)
-    except Exception:
-        pass
+    if native:
+        ram = native.get("ram") or {}
+        try:
+            total_mb = int(ram.get("total_mb") or 0) or 1
+            used_mb = max(0, int(ram.get("used_mb") or 0))
+        except (TypeError, ValueError):
+            total_mb, used_mb = 1, 0
+    else:
+        try:
+            with open("/proc/meminfo", "r") as f:
+                lines = f.readlines()
+            mem = {}
+            for line in lines:
+                parts = line.split(":")
+                if len(parts) == 2:
+                    k = parts[0].strip()
+                    v = parts[1].strip().split()[0]
+                    if k in ["MemTotal", "MemAvailable"]:
+                        mem[k] = int(v) // 1024
+            if "MemTotal" in mem and "MemAvailable" in mem:
+                total_mb = mem["MemTotal"]
+                avail_mb = mem["MemAvailable"]
+                used_mb = max(0, total_mb - avail_mb)
+        except Exception:
+            pass
 
     usage_pct = round((used_mb / total_mb) * 100.0, 2) if total_mb > 0 else 0.0
     usage_pct = min(100.0, max(0.0, usage_pct))
 
     total_disk_gb = 1.0
     free_disk_gb = 0.0
-    try:
-        d = shutil.disk_usage("/")
-        total_disk_gb = round(d.total / (1024 ** 3), 2)
-        free_disk_gb = round(d.free / (1024 ** 3), 2)
-    except Exception:
-        pass
+    if native:
+        disk = native.get("disk") or {}
+        try:
+            total_disk_gb = float(disk.get("total_gb") or 0.0) or 1.0
+            free_disk_gb = max(0.0, float(disk.get("free_gb") or 0.0))
+        except (TypeError, ValueError):
+            total_disk_gb, free_disk_gb = 1.0, 0.0
+    else:
+        try:
+            d = shutil.disk_usage("C:\\" if platform.system() == "Windows" else "/")
+            total_disk_gb = round(d.total / (1024 ** 3), 2)
+            free_disk_gb = round(d.free / (1024 ** 3), 2)
+        except Exception:
+            pass
 
     uptime_str = "unknown"
-    try:
-        with open("/proc/uptime", "r") as f:
-            up_secs = float(f.read().split()[0])
-            hours = int(up_secs // 3600)
-            mins = int((up_secs % 3600) // 60)
-            uptime_str = f"{hours}h {mins}m"
-    except Exception:
-        pass
+    uptime_seconds = mcp_tools.host_uptime_seconds()
+    if uptime_seconds is not None:
+        hours = int(uptime_seconds // 3600)
+        mins = int((uptime_seconds % 3600) // 60)
+        uptime_str = f"{hours}h {mins}m"
 
     fields = dict(
         hostname=hostname,
@@ -299,6 +324,9 @@ _REQUIRED_ARGS: Dict[str, Tuple[str, ...]] = {
     "run_job": ("command",),
     "job_output": ("job_id",),
     "job_kill": ("job_id",),
+    "share_file": ("path",),
+    "serve_dir": ("path",),
+    "unshare": ("name",),
 }
 
 
@@ -440,7 +468,16 @@ class AntigravityMeshServer(object):
                         "resources": {"subscribe": False, "listChanged": False},
                     },
                     "serverInfo": {"name": self.name, "version": self.version},
-                    "instructions": "Standalone Local Antigravity Mesh Server.",
+                    # Short on purpose: the tool descriptions carry the detail. The
+                    # one thing worth saying up front is where the device branch
+                    # lives, because a phone node (Termux) is exactly the case where
+                    # a model otherwise hand-writes termux-* commands through
+                    # bash_exec instead of using the typed tools.
+                    "instructions": ("Standalone Local Antigravity Mesh Server. "
+                                     "For the device this node runs on - battery, signal, "
+                                     "time, sensors, cameras, microphones, notifications, "
+                                     "torch, volume - use device_info / device_control; "
+                                     "device_capture and device_messages ask the user first."),
                 },
             }
 
@@ -613,6 +650,15 @@ def configure_tools_from_env() -> None:
         write_roots=os.environ.get("MESH_WRITE_ROOTS") or None,
         jobs_dir=os.environ.get("MESH_JOBS_DIR") or None,
         max_output_chars=os.environ.get("MESH_MAX_OUTPUT_CHARS"),
+        # Public shares. ``public_url`` is deliberately NOT passed: the public
+        # domain is resolved by core/domain.py (MESH_PUBLIC_URL, domain.env, then
+        # the one default), and pinning it here to the environment variable alone
+        # would bypass the domain file.
+        web_dir=os.environ.get("MESH_WEB_DIR") or None,
+        mesh_user=os.environ.get("MESH_USER") or None,
+        max_share_bytes=os.environ.get("MESH_WEB_MAX_BYTES"),
+        max_shares=os.environ.get("MESH_WEB_MAX_SHARES"),
+        web_listing=os.environ.get("MESH_WEB_LISTING"),
     )