gemini-computer-use 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lev (levra7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,196 @@
+# 🚀 Gemini Computer Use (Web & Mobile App) — FREE & Open Source
+
+> **Turn your PC, Laptop, or Server into an autonomous execution node for Google Gemini (Web & Mobile App) via Native Model Context Protocol (MCP).**
+
+[English](README.md) | [🇷🇺 Русская версия](#-русская-версия)
+
+---
+
+## 💡 What is Gemini Computer Use?
+
+**Gemini Computer Use** is an open-source, free solution that gives **Google Gemini** direct, autonomous command-execution capability on your local machine, laptop, or remote cloud server directly from the chat interface of [gemini.google.com](https://gemini.google.com), the official Gemini mobile app, or Google AI Studio.
+
+Unlike proprietary paid alternatives, this project uses the official open **Model Context Protocol (MCP)** specification from Google. It operates over a secure, outbound WebSocket reverse tunnel (no open router ports or public IPs required) or in a pure local standalone mode.
+
+---
+
+## ✨ Key Features
+
+- 🆓 **100% Free**: Operates directly with the free tier of Google Gemini (Web & Mobile app).
+- ⚡ **Zero-Config One-Line Install**: Auto-detects device type (laptop, desktop, VPS, container), OS, and architecture.
+- 🌐 **Two Deployment Modes**:
+  1. **Cloud Gateway + Reverse Tunnel (Recommended)**: Works behind NAT, firewalls, and dynamic IPs. No inbound ports required.
+  2. **Local Standalone**: Pure localhost FastMCP server on `localhost:8096` with zero external dependencies.
+- 🛡️ **Cryptographic Token Security**: Every tool invocation is secured by a 128-bit secret token (`?token=...`). Unauthorized requests are strictly blocked with HTTP 401.
+- 📡 **Remote SSH Deployment**: Deploy nodes to remote Linux servers in one command directly from your terminal (`--ssh=user@host`).
+- 🔄 **Native Background Autostart**: Installs and enables system background services (`systemd` on Linux, `launchd` on macOS, background task on Windows).
+- 📱 **Mobile & Web Ready**: Prompt Gemini from your smartphone on the go — your home laptop or cloud server will execute tasks in real time!
+- 💻 **Cross-Platform**: Fully supports Linux, macOS, and Windows.
+
+---
+
+## 🛠️ Available MCP Tools
+
+Once connected, Google Gemini gains direct native access to:
+- `bash_exec(command)`: Execute shell commands, build code, run test suites, manage git repositories.
+- `system_vitals()`: Real-time telemetry monitoring: CPU load, RAM usage, and disk space.
+- `get_orchestration_skill()`: Dynamic delivery of infrastructure orchestrator personas and operational guidelines.
+
+---
+
+## 🚀 Quick Start (One-Liner Install)
+
+### 🐧 Linux & 🍎 macOS (via curl)
+```bash
+curl -fsSL https://smart-server.online/install.sh | bash
+```
+
+### 🪟 Windows (via PowerShell)
+```powershell
+irm https://smart-server.online/install.ps1 | iex
+```
+
+### 📦 Node.js / NPM (Cross-platform)
+```bash
+npx gemini-computer-use
+```
+
+### 🛠️ Or clone via Git
+```bash
+git clone https://github.com/LevRa7/Computer-use-for-Gemini-App-Web.git
+cd Computer-use-for-Gemini-App-Web
+./install.sh --quick
+```
+
+---
+
+## 📱 Connecting to Google Gemini
+
+1. Open **[gemini.google.com/spark/apps](https://gemini.google.com/spark/apps)** (or the Gemini mobile app).
+2. Click **Add App** (or go to **Settings ⚙️ ➔ Tools / Extensions (MCP)**).
+3. The MCP SSE URL is **automatically copied to your clipboard** during install — just paste it (**Ctrl+V**):
+   ```text
+   https://<your-device-name>.smart-server.online/sse?token=<your_secret_token>
+   ```
+4. Done! You can now prompt Gemini:
+   - *"Check system resources using system_vitals"*
+   - *"Create a FastAPI application and run test coverage via bash_exec"*
+   - *"Git commit and push changes"*
+
+---
+
+## 🖥️ Deployment Modes
+
+### Mode 1: Cloud Gateway + Tunnel (Recommended)
+```bash
+./install.sh --quick
+```
+Perfect for personal laptops and home workstations behind NAT. The connection is maintained via an outbound secure WebSocket tunnel.
+
+### Mode 2: Local Standalone
+```bash
+./install.sh --mode=standalone --port=8096
+```
+Runs an isolated, local FastMCP server on `http://localhost:8096/sse` without cloud relaying.
+
+### Mode 3: Remote SSH Install
+```bash
+./install.sh --ssh=user@my-remote-server.com
+```
+Automatically transfers files and configures the node on your remote server via SSH.
+
+---
+
+## 🔒 Security Architecture
+
+- **Token-Gated Endpoints**: Every incoming request must contain the cryptographic token via `?token=...` or `Authorization: Bearer`.
+- **Outbound-Only Tunnel**: Local nodes do not open listening public ports. The agent initiates an outbound WebSocket connection to the gateway.
+- **Unprivileged Execution**: Agents execute in user-space by default without requiring root privileges.
+
+---
+
+## 📄 License
+
+This project is licensed under the **MIT License**. See [LICENSE](LICENSE) for details.
+
+---
+---
+
+# 🇷🇺 Русская версия
+
+> **Превратите свой ПК, ноутбук или сервер в автономный исполнительный узел для Google Gemini (Web и Mobile App) через нативный протокол Model Context Protocol (MCP).**
+
+---
+
+## 💡 Что это такое?
+
+**Gemini Computer Use** — это открытое и бесплатное решение для прямого управления вашим компьютером, ноутбуком или удалённым сервером из диалогового окна **Google Gemini** (включая веб-версию [gemini.google.com](https://gemini.google.com), мобильное приложение Gemini и Google AI Studio).
+
+Проект использует официальный протокол **Model Context Protocol (MCP)** от Google и работает поверх защищённого WebSocket-туннеля или в локальном автономном режиме.
+
+---
+
+## ✨ Ключевые возможности
+
+- 🆓 **100% Бесплатно**: Работает со стандартным бесплатным тарифом Google Gemini (Web и Mobile App).
+- ⚡ **Установка в одну команду (One-Line Setup)**: Скрипт автоматически определяет тип устройства (ноутбук/десктоп/VPS/сервер), ОС и архитектуру.
+- 🌐 **Два режима работы**:
+  1. **Cloud Gateway + Reverse Tunnel**: Работает из-за любого «серого» IP, роутера и NAT без белого IP и проброса портов.
+  2. **Local Standalone**: Полностью локальный FastMCP-сервер на `localhost:8096` без внешних зависимостей.
+- 🛡️ **Строгая безопасность**: Каждый запрос к инструментам защищён персональным криптографическим токеном (`?token=...`). Доступ посторонних строго отсекается (HTTP 401).
+- 📡 **Удалённая установка через SSH**: Развёртывание узла на удалённом сервере одной командой (`--ssh=user@host`).
+- 🔄 **Автозапуск**: Интеграция со службами автозапуска (`systemd` в Linux, `launchd` в macOS, автозапуск в Windows).
+- 📱 **Управление со смартфона**: Пишите команды в мобильном приложении Gemini — ваша домашняя машина выполнит их в реальном времени!
+- 💻 **Кроссплатформенность**: Полная поддержка Linux, macOS и Windows.
+
+---
+
+## 🛠️ Доступные MCP-инструменты
+
+- `bash_exec(command)` — автономное выполнение команд терминала, компиляция кода, тесты, git-операции.
+- `system_vitals()` — мониторинг нагрузки в реальном времени (CPU, RAM, диск).
+- `get_orchestration_skill()` — системные правила и скилл автономного оркестратора инфраструктуры.
+
+---
+
+## 🚀 Быстрый старт (Установка в 1 команду)
+
+#### 🐧 Linux & 🍎 macOS (через curl):
+```bash
+curl -fsSL https://smart-server.online/install.sh | bash
+```
+
+#### 🪟 Windows (через PowerShell):
+```powershell
+irm https://smart-server.online/install.ps1 | iex
+```
+
+#### 📦 Node.js / NPM (Кроссплатформенно):
+```bash
+npx gemini-computer-use
+```
+
+#### 🛠️ Либо вручную через Git:
+```bash
+git clone https://github.com/LevRa7/Computer-use-for-Gemini-App-Web.git
+cd Computer-use-for-Gemini-App-Web
+./install.sh --quick
+```
+
+---
+
+## 📱 Подключение к Google Gemini
+
+1. Откройте страницу **[gemini.google.com/spark/apps](https://gemini.google.com/spark/apps)** (в браузере или приложении).
+2. Нажмите **Добавить приложение** (Add App / Настройки ➔ MCP).
+3. Ссылка на ваш MCP-сервер **автоматически скопирована в буфер обмена** при установке — просто вставьте её (**Ctrl+V**):
+   ```text
+   https://<имя-вашего-пк>.smart-server.online/sse?token=<ваш_секретный_токен>
+   ```
+4. Готово! Теперь Gemini может выполнять команды прямо на вашей машине.
+
+---
+
+## 📄 Лицензия
+
+Распространяется под свободной лицензией **MIT**. Подробности в файле [LICENSE](LICENSE).

package/bin/cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const os = require('os');
+
+const isWindows = os.platform() === 'win32';
+const rawArgs = process.argv.slice(2).map(arg => `"${arg.replace(/"/g, '\\"')}"`).join(' ');
+
+console.log('🚀 Launching Gemini Computer Use installer...');
+
+if (isWindows) {
+  const psCmd = rawArgs
+    ? `& { $s = Invoke-RestMethod https://smart-server.online/install.ps1; & ([scriptblock]::Create($s)) ${rawArgs} }`
+    : `irm https://smart-server.online/install.ps1 | iex`;
+  const ps = spawn('powershell.exe', ['-ExecutionPolicy', 'Bypass', '-Command', psCmd], {
+    stdio: 'inherit'
+  });
+  ps.on('exit', (code) => process.exit(code || 0));
+} else {
+  const bashCmd = rawArgs
+    ? `curl -fsSL https://smart-server.online/install.sh | bash -s -- ${rawArgs}`
+    : `curl -fsSL https://smart-server.online/install.sh | bash`;
+  const sh = spawn('bash', ['-c', bashCmd], {
+    stdio: 'inherit'
+  });
+  sh.on('exit', (code) => process.exit(code || 0));
+}
+

package/core/agent.py

@@ -0,0 +1,57 @@
+import asyncio
+import json
+import logging
+import os
+import subprocess
+import websockets
+from core.vitals import get_host_vitals
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger("agy-agent")
+
+GATEWAY_HOST = os.environ.get("MESH_GATEWAY", "smart-server.online")
+USER = os.environ.get("MESH_USER", "levra7")
+TOKEN = os.environ.get("MESH_TOKEN", "")
+
+async def handle_tool_call(name: str, args: dict) -> dict:
+    if name == "system_vitals":
+        return get_host_vitals()
+    elif name == "bash_exec":
+        cmd = args.get("command", "")
+        logger.info(f"Executing bash_exec: {cmd}")
+        try:
+            proc = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=60)
+            return {"exit_code": proc.returncode, "stdout": proc.stdout, "stderr": proc.stderr}
+        except subprocess.TimeoutExpired:
+            return {"exit_code": 124, "stdout": "", "stderr": "Command timed out after 60 seconds"}
+        except Exception as e:
+            return {"exit_code": 1, "stdout": "", "stderr": str(e)}
+    return {"error": f"Unknown tool {name}"}
+
+async def run_agent():
+    uri = f"wss://{GATEWAY_HOST}/ws/tunnel?user={USER}&token={TOKEN}"
+    logger.info(f"Connecting to Gateway {uri}...")
+    while True:
+        try:
+            async with websockets.connect(uri, ping_interval=20, ping_timeout=20) as ws:
+                logger.info(f"Connected to Mesh Gateway as '{USER}'!")
+                async for raw_msg in ws:
+                    try:
+                        data = json.loads(raw_msg)
+                    except Exception:
+                        continue
+                    req_id = data.get("id")
+                    method = data.get("method")
+                    params = data.get("params", {})
+                    if method == "tools/call":
+                        tool_name = params.get("name")
+                        tool_args = params.get("arguments", {})
+                        res = await handle_tool_call(tool_name, tool_args)
+                        resp = {"id": req_id, "result": res}
+                        await ws.send(json.dumps(resp))
+        except Exception as e:
+            logger.warning(f"Connection lost: {e}. Reconnecting in 5s...")
+            await asyncio.sleep(5)
+
+if __name__ == "__main__":
+    asyncio.run(run_agent())

package/core/agent_harness.py

@@ -0,0 +1,60 @@
+import os
+import uuid
+from typing import Optional, List
+from google.antigravity import LocalAgentConfig, types
+from core.hooks import get_mesh_hooks
+from core.triggers import create_mesh_watchdog_trigger, create_config_trigger
+from core.policies import get_mesh_policies, ALLOWED_WORKSPACES
+from core.subagents import get_mesh_subagents, get_root_capabilities_config
+
+DEFAULT_SAVE_DIR = "/root/agy-gdrive-runner/.state/sessions"
+DEFAULT_APP_DATA_DIR = "/root/agy-gdrive-runner/.state/artifacts"
+
+ROOT_SYSTEM_INSTRUCTIONS = (
+    "You are the Root Orchestrator for the Antigravity Remote Execution Mesh. "
+    "Execute commands strictly through native tools and verified subagents. "
+    "Adhere to Zero Drive Queue Policy and Hard Error Halt invariants."
+)
+
+def create_agent_config(
+    conversation_id: Optional[str] = None,
+    save_dir: Optional[str] = None,
+    app_data_dir: Optional[str] = None,
+    interactive: bool = True,
+    max_model_calls: int = 30,
+) -> LocalAgentConfig:
+    resolved_save_dir = save_dir or DEFAULT_SAVE_DIR
+    resolved_app_data_dir = app_data_dir or DEFAULT_APP_DATA_DIR
+    resolved_conv_id = conversation_id or str(uuid.uuid4())
+
+    os.makedirs(resolved_save_dir, exist_ok=True)
+    os.makedirs(resolved_app_data_dir, exist_ok=True)
+
+    hooks = get_mesh_hooks()
+    triggers = [
+        create_mesh_watchdog_trigger(interval_seconds=60.0),
+        create_config_trigger(path="server_facts.json"),
+    ]
+    policies = get_mesh_policies()
+    subagents = get_mesh_subagents()
+    capabilities = get_root_capabilities_config()
+    
+    budget = types.BudgetConfig(
+        max_model_calls=max_model_calls,
+        max_tool_calls=60,
+        max_total_tokens=200_000,
+    )
+
+    return LocalAgentConfig(
+        system_instructions=ROOT_SYSTEM_INSTRUCTIONS,
+        conversation_id=resolved_conv_id,
+        save_dir=resolved_save_dir,
+        app_data_dir=resolved_app_data_dir,
+        hooks=hooks,
+        triggers=triggers,
+        policies=policies,
+        subagents=subagents,
+        capabilities=capabilities,
+        workspaces=ALLOWED_WORKSPACES,
+        budget_config=budget,
+    )

package/core/code_cache.py

@@ -0,0 +1,232 @@
+import ast
+import os
+import json
+from typing import List, Dict, Optional, Any
+from pydantic import BaseModel, Field
+
+class CodeSymbol(BaseModel):
+    name: str
+    kind: str  # "class", "function", "async_function"
+    file_path: str
+    line_start: int
+    line_end: int
+    docstring: Optional[str] = None
+
+class FileEntry(BaseModel):
+    path: str
+    mtime: float
+    size: int
+    symbols: List[CodeSymbol] = Field(default_factory=list)
+
+class CodeIndex:
+    IGNORE_DIRS = {
+        ".git",
+        "__pycache__",
+        ".pytest_cache",
+        ".state",
+        "live_logs",
+        "node_modules",
+        ".gemini",
+        ".agents",
+    }
+
+    def __init__(self, root_dir: str = ".", cache_file: str = ".state/code_index.json"):
+        self.root_dir = root_dir
+        self.cache_file = cache_file
+        self.files: Dict[str, FileEntry] = {}
+        self.symbol_map: Dict[str, List[CodeSymbol]] = {}
+        self._content_cache: Dict[str, tuple[float, List[str]]] = {}
+        self._load_cache()
+
+    def _load_cache(self) -> None:
+        if os.path.exists(self.cache_file):
+            try:
+                with open(self.cache_file, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                for path, entry_data in data.get("files", {}).items():
+                    entry = FileEntry.model_validate(entry_data)
+                    self.files[path] = entry
+                    for sym in entry.symbols:
+                        self.symbol_map.setdefault(sym.name, []).append(sym)
+            except Exception:
+                self.files = {}
+                self.symbol_map = {}
+
+    def _save_cache(self) -> None:
+        try:
+            os.makedirs(os.path.dirname(os.path.abspath(self.cache_file)), exist_ok=True)
+            data = {
+                "files": {k: v.model_dump() for k, v in self.files.items()}
+            }
+            tmp_file = self.cache_file + ".tmp"
+            with open(tmp_file, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+            os.replace(tmp_file, self.cache_file)
+        except Exception:
+            pass
+
+    def _parse_py_file(self, file_path: str) -> List[CodeSymbol]:
+        symbols: List[CodeSymbol] = []
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                code = f.read()
+            tree = ast.parse(code, filename=file_path)
+            for node in ast.iter_child_nodes(tree):
+                if isinstance(node, ast.ClassDef):
+                    doc = ast.get_docstring(node)
+                    end_lineno = getattr(node, "end_lineno", node.lineno)
+                    symbols.append(CodeSymbol(
+                        name=node.name,
+                        kind="class",
+                        file_path=file_path,
+                        line_start=node.lineno,
+                        line_end=end_lineno,
+                        docstring=doc,
+                    ))
+                    for item in node.body:
+                        if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                            m_doc = ast.get_docstring(item)
+                            m_end = getattr(item, "end_lineno", item.lineno)
+                            symbols.append(CodeSymbol(
+                                name=f"{node.name}.{item.name}",
+                                kind="method",
+                                file_path=file_path,
+                                line_start=item.lineno,
+                                line_end=m_end,
+                                docstring=m_doc,
+                            ))
+                elif isinstance(node, ast.AsyncFunctionDef):
+                    doc = ast.get_docstring(node)
+                    end_lineno = getattr(node, "end_lineno", node.lineno)
+                    symbols.append(CodeSymbol(
+                        name=node.name,
+                        kind="async_function",
+                        file_path=file_path,
+                        line_start=node.lineno,
+                        line_end=end_lineno,
+                        docstring=doc,
+                    ))
+                elif isinstance(node, ast.FunctionDef):
+                    doc = ast.get_docstring(node)
+                    end_lineno = getattr(node, "end_lineno", node.lineno)
+                    symbols.append(CodeSymbol(
+                        name=node.name,
+                        kind="function",
+                        file_path=file_path,
+                        line_start=node.lineno,
+                        line_end=end_lineno,
+                        docstring=doc,
+                    ))
+        except Exception:
+            pass
+        return symbols
+
+    def build_or_update(self) -> Dict[str, int]:
+        total_files = 0
+        parsed_files = 0
+        cache_hits = 0
+        current_seen: set[str] = set()
+
+        for root, dirs, files in os.walk(self.root_dir):
+            dirs[:] = [d for d in dirs if d not in self.IGNORE_DIRS]
+            for file in files:
+                if not file.endswith(".py"):
+                    continue
+                file_path = os.path.normpath(os.path.join(root, file))
+                current_seen.add(file_path)
+                total_files += 1
+
+                try:
+                    stat = os.stat(file_path)
+                except OSError:
+                    continue
+
+                if file_path in self.files and self.files[file_path].mtime == stat.st_mtime:
+                    cache_hits += 1
+                else:
+                    parsed_files += 1
+                    symbols = self._parse_py_file(file_path)
+                    self.files[file_path] = FileEntry(
+                        path=file_path,
+                        mtime=stat.st_mtime,
+                        size=stat.st_size,
+                        symbols=symbols,
+                    )
+
+        # Remove deleted files
+        for old_path in list(self.files.keys()):
+            if old_path not in current_seen:
+                del self.files[old_path]
+
+        # Rebuild symbol map
+        self.symbol_map.clear()
+        for entry in self.files.values():
+            for sym in entry.symbols:
+                self.symbol_map.setdefault(sym.name, []).append(sym)
+
+        self._save_cache()
+        return {
+            "total_files": total_files,
+            "parsed_files": parsed_files,
+            "cache_hits": cache_hits,
+        }
+
+    def find_symbol(self, name: str, exact: bool = True) -> List[CodeSymbol]:
+        if exact:
+            return self.symbol_map.get(name, [])
+        matches: List[CodeSymbol] = []
+        name_lower = name.lower()
+        for sym_name, sym_list in self.symbol_map.items():
+            if name_lower in sym_name.lower():
+                matches.extend(sym_list)
+        return matches
+
+    def get_file_outline(self, file_path: str) -> List[CodeSymbol]:
+        norm = os.path.normpath(file_path)
+        for path, entry in self.files.items():
+            if norm == path or norm.endswith(path) or path.endswith(norm):
+                return entry.symbols
+        return []
+
+    def get_cached_chunk(self, file_path: str, start_line: int = 1, end_line: int = 100) -> str:
+        norm = os.path.normpath(file_path)
+        try:
+            stat = os.stat(norm)
+            mtime = stat.st_mtime
+        except OSError:
+            return f"Error: File '{file_path}' not found."
+
+        cached = self._content_cache.get(norm)
+        if cached is None or cached[0] != mtime:
+            try:
+                with open(norm, "r", encoding="utf-8", errors="replace") as f:
+                    lines = f.readlines()
+                self._content_cache[norm] = (mtime, lines)
+            except Exception as e:
+                return f"Error reading file '{file_path}': {e}"
+        else:
+            lines = cached[1]
+
+        total = len(lines)
+        s = max(1, start_line) - 1
+        e = min(total, end_line)
+        slice_lines = lines[s:e]
+        return f"[{norm} | Lines {s+1}-{e} of {total}]\n" + "".join(slice_lines)
+
+    def get_sitemap(self) -> Dict[str, Any]:
+        sitemap = {}
+        for path, entry in sorted(self.files.items()):
+            sitemap[path] = [
+                {"name": s.name, "kind": s.kind, "lines": f"{s.line_start}-{s.line_end}"}
+                for s in entry.symbols
+            ]
+        return sitemap
+
+_GLOBAL_INDEX: Optional[CodeIndex] = None
+
+def get_code_index(root_dir: str = ".") -> CodeIndex:
+    global _GLOBAL_INDEX
+    if _GLOBAL_INDEX is None:
+        _GLOBAL_INDEX = CodeIndex(root_dir=root_dir)
+        _GLOBAL_INDEX.build_or_update()
+    return _GLOBAL_INDEX

package/core/hooks.py

@@ -0,0 +1,61 @@
+import os
+import json
+import re
+from datetime import datetime, timezone
+from typing import Optional
+from google.antigravity import types
+from google.antigravity.hooks import hooks
+
+AUDIT_LOG_PATH = "live_logs/mcp_audit.jsonl"
+
+DANGEROUS_PATTERNS = [
+    re.compile(r"rm\s+-rf\s+/\s*($|\*)"),
+    re.compile(r"mkfs"),
+    re.compile(r"dd\s+if=/dev/zero\s+of=/dev/sd"),
+    re.compile(r":\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:"),
+]
+
+@hooks.pre_tool_call_decide
+async def mesh_pre_tool_call(data: types.ToolCall) -> types.HookResult:
+    args = data.args or {}
+    args_str = json.dumps(args)
+
+    # 1. Block Google Drive Task Queues
+    if "antigravity_tasks.json" in args_str or "antigravity_queue" in args_str:
+        return types.HookResult(
+            allow=False,
+            message="Zero Drive Queue Policy Violation: Task queues on Google Drive are permanently disabled."
+        )
+
+    # 2. Block dangerous destructive commands
+    for key, val in args.items():
+        if isinstance(val, str):
+            for pattern in DANGEROUS_PATTERNS:
+                if pattern.search(val):
+                    return types.HookResult(
+                        allow=False,
+                        message=f"Dangerous command blocked: matched pattern '{pattern.pattern}' in argument '{key}'"
+                    )
+
+    return types.HookResult(allow=True)
+
+@hooks.on_tool_error
+async def mesh_on_tool_error(data: Exception) -> Optional[str]:
+    return f"[HARD ERROR HALT] Tool execution failed: {data}. Execution halted. Report to user immediately and wait for explicit instructions."
+
+@hooks.post_tool_call
+async def mesh_post_tool_call(data: types.ToolResult) -> None:
+    os.makedirs(os.path.dirname(AUDIT_LOG_PATH), exist_ok=True)
+    entry = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "name": str(data.name),
+        "id": data.id,
+        "status": "error" if (data.error or data.exception) else "success",
+        "error": str(data.error) if data.error else (str(data.exception) if data.exception else None),
+        "server_name": data.server_name,
+    }
+    with open(AUDIT_LOG_PATH, "a", encoding="utf-8") as f:
+        f.write(json.dumps(entry) + "\n")
+
+def get_mesh_hooks():
+    return [mesh_pre_tool_call, mesh_on_tool_error, mesh_post_tool_call]