gemini-computer-use 0.1.2

package/core/policies.py

@@ -0,0 +1,99 @@
+import os
+import re
+from typing import List, Optional, Callable, Any, Awaitable
+from google.antigravity import types
+from google.antigravity.hooks import policy
+from google.antigravity.hooks.policy import Policy, Decision
+
+ALLOWED_WORKSPACES = [
+    "/root/agy-gdrive-runner",
+    "/home/lev/MyProjects/antigravity-mesh",
+]
+
+SAFE_COMMAND_PREFIXES = [
+    "git status",
+    "git log",
+    "git diff",
+    "systemctl status",
+    "uptime",
+    "ls",
+    "ps",
+    "cat",
+    "echo",
+    "whoami",
+    "uname",
+    "df",
+    "free",
+]
+
+DESTRUCTIVE_COMMAND_PATTERNS = [
+    re.compile(r"\breboot\b"),
+    re.compile(r"\bshutdown\b"),
+    re.compile(r"\bsystemctl\s+(stop|disable|mask|restart)\b"),
+    re.compile(r"\brm\s+"),
+    re.compile(r"\bpkill\b"),
+    re.compile(r"\bkill\s+-9\b"),
+    re.compile(r"\bmkfs\b"),
+    re.compile(r"\bdd\s+"),
+]
+
+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("/") + "/"):
+            return True
+    return False
+
+def _extract_command(args: dict) -> str:
+    if not isinstance(args, dict):
+        return ""
+    return str(args.get("command") or args.get("CommandLine") or "").strip()
+
+def is_safe_command(args: dict) -> bool:
+    cmd = _extract_command(args)
+    if not cmd:
+        return False
+    return any(cmd.startswith(prefix) for prefix in SAFE_COMMAND_PREFIXES)
+
+def is_destructive_command(args: dict) -> bool:
+    cmd = _extract_command(args)
+    if not cmd:
+        return False
+    return any(pat.search(cmd) for pat in DESTRUCTIVE_COMMAND_PATTERNS)
+
+async def default_deny_handler(tool_call: types.ToolCall) -> bool:
+    return False
+
+def get_mesh_policies(
+    allowed_workspaces: Optional[List[str]] = None,
+    ask_user_handler: Optional[Callable[[types.ToolCall], Awaitable[bool]]] = None,
+) -> List[Policy]:
+    handler = ask_user_handler or default_deny_handler
+    policies: List[Policy] = []
+
+    # 1. Ask user for destructive commands
+    policies.append(
+        policy.ask_user(
+            "run_command",
+            when=is_destructive_command,
+            handler=handler,
+            name="confirm_destructive",
+        )
+    )
+
+    # 2. Allow safe commands without confirmation
+    policies.append(
+        policy.allow(
+            "run_command",
+            when=is_safe_command,
+            name="allow_safe_commands",
+        )
+    )
+
+    return policies
+
+async def evaluate_policies(policies: List[Policy], tool_call: types.ToolCall) -> types.HookResult:
+    hook = policy._PolicyDecideHook(policies)
+    return await hook.run(None, tool_call)

package/core/schemas.py

@@ -0,0 +1,49 @@
+from datetime import datetime, timezone
+from typing import List, Optional
+from pydantic import BaseModel, Field, field_validator
+
+class NodeVitals(BaseModel):
+    hostname: str
+    ip: str
+    is_online: bool
+    cpu_load_1m: float
+    ram_used_mb: int
+    ram_total_mb: int
+    ram_usage_pct: float
+    disk_free_gb: float
+    disk_total_gb: float
+    uptime: str
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+    @field_validator("ram_usage_pct")
+    @classmethod
+    def validate_ram_usage_pct(cls, v: float) -> float:
+        if not (0.0 <= v <= 100.0):
+            raise ValueError(f"ram_usage_pct must be between 0.0 and 100.0, got {v}")
+        return v
+
+class ToolExecutionResult(BaseModel):
+    command: str
+    target_node: str
+    exit_code: int
+    duration_seconds: float
+    stdout: str
+    stderr: Optional[str] = None
+    is_error: bool
+    error_summary: Optional[str] = None
+
+class MeshHealthSnapshot(BaseModel):
+    overall_healthy: bool
+    healthy_node_count: int
+    total_node_count: int
+    nodes: List[NodeVitals]
+    warnings: List[str] = Field(default_factory=list)
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+class TaskDispatchPlan(BaseModel):
+    task_id: str
+    title: str
+    target_nodes: List[str]
+    ordered_steps: List[str]
+    rollback_steps: List[str]
+    dry_run_verified: bool = False

package/core/server.py

@@ -0,0 +1,69 @@
+import os
+import shutil
+import socket
+from datetime import datetime, timezone
+from core.schemas import NodeVitals
+
+def get_coordinator_vitals() -> NodeVitals:
+    hostname = socket.gethostname()
+    ip = "127.0.0.1"
+    try:
+        load = os.getloadavg()[0]
+    except Exception:
+        load = 0.0
+
+    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
+
+    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
+
+    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
+
+    return NodeVitals(
+        hostname=hostname,
+        ip=ip,
+        is_online=True,
+        cpu_load_1m=round(load, 2),
+        ram_used_mb=used_mb,
+        ram_total_mb=total_mb,
+        ram_usage_pct=usage_pct,
+        disk_free_gb=free_disk_gb,
+        disk_total_gb=total_disk_gb,
+        uptime=uptime_str,
+        timestamp=datetime.now(timezone.utc),
+    )

package/core/subagents.py

@@ -0,0 +1,55 @@
+from typing import List
+from google.antigravity import types
+
+coordinator_worker = types.SubagentConfig(
+    name="coordinator_worker",
+    description="Autonomous worker for coordinator tasks, executing shell commands and modifying files.",
+    capabilities=types.SubagentCapabilities(
+        agent_behavior=types.AgentBehavior.AUTONOMOUS,
+        enabled_tools=[
+            types.BuiltinTools.RUN_COMMAND,
+            types.BuiltinTools.VIEW_FILE,
+            types.BuiltinTools.EDIT_FILE,
+            types.BuiltinTools.CREATE_FILE,
+            types.BuiltinTools.SEARCH_DIR,
+            types.BuiltinTools.FIND_FILE,
+            types.BuiltinTools.LIST_DIR,
+        ],
+    ),
+)
+
+remote_node_worker = types.SubagentConfig(
+    name="remote_node_worker",
+    description="Autonomous worker for dispatching commands and collecting vitals on remote mesh nodes.",
+    capabilities=types.SubagentCapabilities(
+        agent_behavior=types.AgentBehavior.AUTONOMOUS,
+        enabled_tools=[
+            types.BuiltinTools.RUN_COMMAND,
+            types.BuiltinTools.VIEW_FILE,
+        ],
+    ),
+)
+
+code_researcher = types.SubagentConfig(
+    name="code_researcher",
+    description="Read-only research worker for exploring codebase, search, and reading files.",
+    capabilities=types.SubagentCapabilities(
+        agent_behavior=types.AgentBehavior.AUTONOMOUS,
+        enabled_tools=[
+            types.BuiltinTools.VIEW_FILE,
+            types.BuiltinTools.SEARCH_DIR,
+            types.BuiltinTools.FIND_FILE,
+            types.BuiltinTools.LIST_DIR,
+        ],
+    ),
+)
+
+def get_mesh_subagents() -> List[types.SubagentConfig]:
+    return [coordinator_worker, remote_node_worker, code_researcher]
+
+def get_root_capabilities_config() -> types.CapabilitiesConfig:
+    return types.CapabilitiesConfig(
+        enable_subagents=True,
+        max_subagent_depth=2,
+        allowed_subagents=["coordinator_worker", "remote_node_worker", "code_researcher"],
+    )

package/core/triggers.py

@@ -0,0 +1,70 @@
+import json
+import logging
+from typing import Callable, Awaitable, List, Optional, Sequence
+from google.antigravity.triggers import (
+    Trigger,
+    TriggerContext,
+    FileChange,
+    FileChangeKind,
+    every,
+    on_file_change,
+)
+from core.schemas import NodeVitals
+
+logger = logging.getLogger(__name__)
+
+async def default_vitals_fetcher() -> List[NodeVitals]:
+    """Default local fetcher when no custom fetcher is provided."""
+    return []
+
+async def check_mesh_health(
+    ctx: TriggerContext,
+    vitals_fetcher: Optional[Callable[[], Awaitable[List[NodeVitals]]]] = None,
+) -> None:
+    fetcher = vitals_fetcher or default_vitals_fetcher
+    try:
+        nodes = await fetcher()
+    except Exception as e:
+        logger.error(f"Error fetching vitals in watchdog: {e}")
+        await ctx.send(f"[WATCHDOG ALERT] Failed to collect mesh vitals: {e}")
+        return
+
+    for node in nodes:
+        if not node.is_online:
+            await ctx.send(
+                f"[WATCHDOG ALERT] Node '{node.hostname}' ({node.ip}) is offline! Check mesh tunnel and host status."
+            )
+        elif node.ram_usage_pct > 90.0:
+            await ctx.send(
+                f"[WATCHDOG ALERT] Node '{node.hostname}' exceeded critical memory threshold ({node.ram_usage_pct:.1f}%). Diagnostic required."
+            )
+        elif node.cpu_load_1m > 10.0:
+            await ctx.send(
+                f"[WATCHDOG ALERT] Node '{node.hostname}' high load average: {node.cpu_load_1m}."
+            )
+
+async def handle_config_file_change(
+    ctx: TriggerContext,
+    changes: Sequence[FileChange],
+    reload_callback: Optional[Callable[[Sequence[FileChange]], Awaitable[None]]] = None,
+) -> None:
+    if reload_callback:
+        await reload_callback(changes)
+    
+    paths_str = ", ".join([str(c.path) for c in changes])
+    await ctx.send(f"[CONFIG RELOAD] Config reloaded due to change in {paths_str}")
+
+def create_mesh_watchdog_trigger(
+    interval_seconds: float = 60.0,
+    vitals_fetcher: Optional[Callable[[], Awaitable[List[NodeVitals]]]] = None,
+) -> Trigger:
+    return every(interval_seconds, lambda ctx: check_mesh_health(ctx, vitals_fetcher))
+
+def create_config_trigger(
+    path: str = "server_facts.json",
+    reload_callback: Optional[Callable[[Sequence[FileChange]], Awaitable[None]]] = None,
+) -> Trigger:
+    return on_file_change(
+        path,
+        lambda ctx, changes: handle_config_file_change(ctx, changes, reload_callback),
+    )

package/core/vitals.py

@@ -0,0 +1,117 @@
+import os
+import platform
+import shutil
+import socket
+import subprocess
+from typing import Dict, Any
+
+def get_host_vitals() -> Dict[str, Any]:
+    hostname = socket.gethostname()
+    system = platform.system()  # 'Linux', 'Darwin', 'Windows'
+
+    # CPU load average (Unix)
+    cpu_load = {"1m": 0.0, "5m": 0.0, "15m": 0.0}
+    try:
+        if hasattr(os, "getloadavg"):
+            load = os.getloadavg()
+            cpu_load = {
+                "1m": round(load[0], 2),
+                "5m": round(load[1], 2),
+                "15m": round(load[2], 2),
+            }
+    except Exception:
+        pass
+
+    # RAM metrics
+    total_mb = 0.0
+    free_mb = 0.0
+
+    if system == "Linux":
+        total_kb, avail_kb = 0, 0
+        try:
+            with open("/proc/meminfo", "r") as f:
+                for line in f:
+                    parts = line.split(":")
+                    key = parts[0].strip()
+                    if key == "MemTotal":
+                        total_kb = int(parts[1].split()[0])
+                    elif key == "MemAvailable":
+                        avail_kb = int(parts[1].split()[0])
+        except Exception:
+            pass
+        total_mb = round(total_kb / 1024, 1)
+        free_mb = round(avail_kb / 1024, 1)
+    elif system == "Darwin":
+        # macOS
+        try:
+            mem_bytes = int(subprocess.check_output(["sysctl", "-n", "hw.memsize"], text=True).strip())
+            total_mb = round(mem_bytes / (1024**2), 1)
+            vm = subprocess.check_output(["vm_stat"], text=True)
+            page_size = 4096
+            free_pages = 0
+            for line in vm.splitlines():
+                if "page size of" in line:
+                    page_size = int(line.split()[-2])
+                elif "Pages free:" in line or "Pages speculative:" in line:
+                    free_pages += int(line.split()[-1].replace(".", ""))
+            free_mb = round((free_pages * page_size) / (1024**2), 1)
+        except Exception:
+            pass
+    elif system == "Windows":
+        try:
+            import ctypes
+            class MEMORYSTATUSEX(ctypes.Structure):
+                _fields_ = [
+                    ("dwLength", ctypes.c_ulong),
+                    ("dwMemoryLoad", ctypes.c_ulong),
+                    ("ullTotalPhys", ctypes.c_ulonglong),
+                    ("ullAvailPhys", ctypes.c_ulonglong),
+                    ("ullTotalPageFile", ctypes.c_ulonglong),
+                    ("ullAvailPageFile", ctypes.c_ulonglong),
+                    ("ullTotalVirtual", ctypes.c_ulonglong),
+                    ("ullAvailVirtual", ctypes.c_ulonglong),
+                    ("sullAvailExtendedVirtual", ctypes.c_ulonglong),
+                ]
+            stat = MEMORYSTATUSEX()
+            stat.dwLength = ctypes.sizeof(MEMORYSTATUSEX)
+            ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(stat))
+            total_mb = round(stat.ullTotalPhys / (1024**2), 1)
+            free_mb = round(stat.ullAvailPhys / (1024**2), 1)
+        except Exception:
+            pass
+
+    used_mb = max(0.0, round(total_mb - free_mb, 1))
+    used_ram_pct = round((used_mb / total_mb) * 100.0, 1) if total_mb > 0 else 0.0
+
+    ram = {
+        "total_mb": total_mb,
+        "used_mb": used_mb,
+        "free_mb": free_mb,
+        "used_pct": used_ram_pct,
+    }
+
+    # Disk metrics
+    root_path = "C:\\" if system == "Windows" else "/"
+    try:
+        du = shutil.disk_usage(root_path)
+        total_gb = round(du.total / (1024**3), 2)
+        used_gb = round(du.used / (1024**3), 2)
+        free_gb = round(du.free / (1024**3), 2)
+        used_disk_pct = round((du.used / du.total) * 100.0, 1) if du.total > 0 else 0.0
+    except Exception:
+        total_gb, used_gb, free_gb, used_disk_pct = 0.0, 0.0, 0.0, 0.0
+
+    disk = {
+        "total_gb": total_gb,
+        "used_gb": used_gb,
+        "free_gb": free_gb,
+        "used_pct": used_disk_pct,
+    }
+
+    return {
+        "hostname": hostname,
+        "os": system,
+        "cpu_load": cpu_load,
+        "ram": ram,
+        "disk": disk,
+    }