gemini-computer-use 0.1.2 → 0.2.3

package/README.md

@@ -70,13 +70,38 @@ cd Computer-use-for-Gemini-App-Web
 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>
+   https://smart-server.online/sse?user=<your-node-name>&token=<your_secret_token>
    ```
+   Every node uses the **same shared domain** and is selected by `?user=` — there are no per-device subdomains to configure, and nothing extra to add to the TLS certificate.
 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"*
 
+### One shared domain (canonical URL contract)
+
+A node is **never** addressed by its own hostname. The gateway publishes a single
+shared domain and the node name travels as a query parameter:
+
+| Purpose | Canonical URL |
+| :--- | :--- |
+| MCP over SSE | `https://<shared-domain>/sse?user=<node-name>&token=<token>` |
+| MCP Streamable HTTP | `https://<shared-domain>/mcp?user=<node-name>&token=<token>` |
+| Reverse tunnel (agent) | `wss://<shared-domain>/ws/tunnel?user=<node-name>&token=<token>` |
+
+Why: every extra hostname would need its own DNS record *and* its own SAN in the
+TLS certificate. A node whose name is missing from the certificate fails the TLS
+handshake, and the Gemini client then reports an opaque "cannot connect to host".
+With one shared domain the certificate covers every node forever, and adding a
+node is only a registration call.
+
+- The shared domain defaults to `smart-server.online`; override it with
+  `./install.sh --domain=<shared-domain>` (node side) or `MESH_PUBLIC_URL`
+  (gateway side).
+- Legacy per-device subdomain URLs still resolve for backwards compatibility and
+  log a deprecation warning; set `MESH_LEGACY_SUBDOMAIN=0` on the gateway to
+  reject them outright.
+
 ---
 
 ## 🖥️ Deployment Modes
@@ -101,6 +126,41 @@ Automatically transfers files and configures the node on your remote server via
 
 ---
 
+## 🚢 Gateway Operations
+
+The gateway is a single host serving every node. Publish it only through the
+deploy script, so the running gateway, the served installers and the node
+bootstrap payload cannot drift apart:
+
+```bash
+MESH_GATEWAY_SSH=root@<gateway-ip> ./deploy_gateway.sh              # deploy
+MESH_GATEWAY_SSH=root@<gateway-ip> ./deploy_gateway.sh --dry-run    # preview
+MESH_GATEWAY_SSH=root@<gateway-ip> MESH_GATEWAY_SSH_PASS_FILE=~/.ssh/gw-pass \
+    ./deploy_gateway.sh                                            # password auth
+```
+It verifies every upload with an sha256 manifest on the host, takes a
+timestamped backup, installs with the right owner, restarts the service and
+finishes with a public health check. Nothing is installed if verification fails.
+
+### TLS certificate policy (one name, no per-device SANs)
+
+The certificate must cover the **shared domain only**. No device name is ever
+added to it, because a node is selected by `?user=` and never by a hostname:
+
+```bash
+# what the certificate currently covers
+sudo certbot certificates | grep -A1 'Certificate Name: smart-server.online'
+
+# canonical renewal check (staging, does not touch the live certificate)
+sudo certbot renew --dry-run --cert-name smart-server.online
+```
+Legacy per-device SANs may still be present from before this contract. They are
+harmless and keep old bookmarked URLs working; drop them from the lineage at the
+next renewal once no client uses subdomain URLs any more (see the `domains =`
+line in `/etc/letsencrypt/renewal/<name>.conf`, or re-issue with a single `-d`).
+
+---
+
 ## 🔒 Security Architecture
 
 - **Token-Gated Endpoints**: Every incoming request must contain the cryptographic token via `?token=...` or `Authorization: Bearer`.
@@ -185,10 +245,61 @@ cd Computer-use-for-Gemini-App-Web
 2. Нажмите **Добавить приложение** (Add App / Настройки ➔ MCP).
 3. Ссылка на ваш MCP-сервер **автоматически скопирована в буфер обмена** при установке — просто вставьте её (**Ctrl+V**):
    ```text
-   https://<имя-вашего-пк>.smart-server.online/sse?token=<ваш_секретный_токен>
+   https://smart-server.online/sse?user=<имя-вашего-узла>&token=<ваш_секретный_токен>
    ```
+   Все узлы используют **один общий домен**, а нужный узел выбирается параметром `?user=` — субдомены для каждого устройства не создаются, и добавлять что-либо в TLS-сертификат не нужно.
 4. Готово! Теперь Gemini может выполнять команды прямо на вашей машине.
 
+### Один общий домен (канонический формат URL)
+
+Узел **никогда** не адресуется собственным именем хоста. Шлюз публикует один
+общий домен, а имя узла передаётся параметром:
+
+| Назначение | Канонический URL |
+| :--- | :--- |
+| MCP через SSE | `https://<общий-домен>/sse?user=<имя-узла>&token=<токен>` |
+| MCP Streamable HTTP | `https://<общий-домен>/mcp?user=<имя-узла>&token=<токен>` |
+| Обратный туннель (агент) | `wss://<общий-домен>/ws/tunnel?user=<имя-узла>&token=<токен>` |
+
+Почему так: каждому дополнительному имени хоста нужна своя DNS-запись **и** свой
+SAN в TLS-сертификате. Если имени нет в сертификате, TLS-рукопожатие падает, и
+клиент Gemini показывает невнятную ошибку «не удаётся подключиться к хосту».
+С одним общим доменом сертификат покрывает все узлы сразу, а добавление узла —
+это только вызов регистрации.
+
+- Общий домен по умолчанию `smart-server.online`; переопределяется через
+  `./install.sh --domain=<общий-домен>` (на стороне узла) или `MESH_PUBLIC_URL`
+  (на стороне шлюза).
+- Старые ссылки с субдоменами устройства продолжают работать для совместимости
+  и пишут предупреждение в лог; `MESH_LEGACY_SUBDOMAIN=0` на шлюзе отключает их.
+
+---
+
+## 🚢 Эксплуатация шлюза
+
+Шлюз — один хост на все узлы. Публикуйте его только скриптом, чтобы работающий
+шлюз, отдаваемые установщики и bootstrap-код узлов не расходились:
+
+```bash
+MESH_GATEWAY_SSH=root@<ip-шлюза> ./deploy_gateway.sh            # задеплоить
+MESH_GATEWAY_SSH=root@<ip-шлюза> ./deploy_gateway.sh --dry-run  # предпросмотр
+```
+Скрипт проверяет каждую загрузку манифестом sha256 на хосте, делает бэкап с
+меткой времени, ставит файлы с нужным владельцем, перезапускает службу и
+завершает публичной проверкой здоровья. При несовпадении хэшей ничего не
+устанавливается.
+
+**Политика TLS-сертификата: только общий домен, без SAN на устройства.**
+Имена узлов в сертификат не добавляются никогда — узел выбирается `?user=`:
+
+```bash
+sudo certbot certificates | grep -A1 'Certificate Name: smart-server.online'
+sudo certbot renew --dry-run --cert-name smart-server.online   # проверка продления
+```
+Старые SAN'ы устройств могут остаться с прежнего контракта: они безвредны и
+поддерживают совместимость старых ссылок. Убрать их можно при следующем
+продлении, когда субдоменными ссылками никто не пользуется.
+
 ---
 
 ## 📄 Лицензия

package/core/agent.py

@@ -1,10 +1,26 @@
+"""core/agent.py - Antigravity Mesh tunnel node (thin transport).
+
+All tool logic lives in :mod:`core.mcp_tools`; this module only maintains the
+websocket tunnel to the gateway and forwards ``tools/call`` requests.  The
+response shape is unchanged (``stdout``/``stderr``/``exit_code`` and friends),
+so an unmodified gateway keeps working.
+
+Configuration (read once at import/startup)::
+
+    MESH_WORKSPACE    base directory for relative paths (default: cwd)
+    MESH_READ_ONLY    "1"/"true" -> mutating tools refuse to run
+    MESH_WRITE_ROOTS  pathsep-separated list of roots allowed for writes
+"""
+
 import asyncio
 import json
 import logging
 import os
-import subprocess
+import random
+
 import websockets
-from core.vitals import get_host_vitals
+
+from core import mcp_tools
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
 logger = logging.getLogger("agy-agent")
@@ -13,28 +29,53 @@ GATEWAY_HOST = os.environ.get("MESH_GATEWAY", "smart-server.online")
 USER = os.environ.get("MESH_USER", "levra7")
 TOKEN = os.environ.get("MESH_TOKEN", "")
 
+
+def _env_flag(name: str) -> bool:
+    return str(os.environ.get(name, "")).strip().lower() in ("1", "true", "yes", "on")
+
+
+def configure_from_env() -> None:
+    """Apply MESH_* environment configuration to the shared tool module."""
+    write_roots = os.environ.get("MESH_WRITE_ROOTS") or None
+    jobs_dir = os.environ.get("MESH_JOBS_DIR") or None
+    max_chars = os.environ.get("MESH_MAX_OUTPUT_CHARS")
+    mcp_tools.configure(
+        workspace=os.environ.get("MESH_WORKSPACE") or os.getcwd(),
+        read_only=_env_flag("MESH_READ_ONLY"),
+        write_roots=write_roots,
+        jobs_dir=jobs_dir,
+        max_output_chars=max_chars,
+    )
+
+
+# Configure as soon as the node module is imported so external callers (tests,
+# harnesses) observe the environment-driven settings.
+configure_from_env()
+
+
 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}"}
+    """Forward one tool call to the shared implementation in a worker thread."""
+    logger.info("Executing %s", name)
+    return await asyncio.to_thread(mcp_tools.call_tool, name, args or {})
+
 
 async def run_agent():
+    """Stay connected to the gateway, healing every kind of link failure.
+
+    A dropped websocket is retried with exponential backoff plus jitter: a short
+    first retry restores a flapping link quickly, while the growing cap stops a
+    hammering loop when the network is genuinely down. The backoff resets after a
+    healthy connection, so a long-lived session is not penalised.
+    """
     uri = f"wss://{GATEWAY_HOST}/ws/tunnel?user={USER}&token={TOKEN}"
     logger.info(f"Connecting to Gateway {uri}...")
+    backoff = 1.0
     while True:
         try:
-            async with websockets.connect(uri, ping_interval=20, ping_timeout=20) as ws:
+            async with websockets.connect(uri, ping_interval=10, ping_timeout=10,
+                                            close_timeout=5) as ws:
                 logger.info(f"Connected to Mesh Gateway as '{USER}'!")
+                backoff = 1.0                      # healthy again
                 async for raw_msg in ws:
                     try:
                         data = json.loads(raw_msg)
@@ -46,12 +87,20 @@ async def run_agent():
                     if method == "tools/call":
                         tool_name = params.get("name")
                         tool_args = params.get("arguments", {})
-                        res = await handle_tool_call(tool_name, tool_args)
+                        try:
+                            res = await handle_tool_call(tool_name, tool_args)
+                        except Exception as tool_exc:
+                            # A tool must never take the tunnel down with it.
+                            logger.warning(f"Tool {tool_name} failed: {tool_exc}")
+                            res = {"error": f"{type(tool_exc).__name__}: {tool_exc}"}
                         resp = {"id": req_id, "result": res}
-                        await ws.send(json.dumps(resp))
+                        await ws.send(json.dumps(resp, ensure_ascii=False))
         except Exception as e:
-            logger.warning(f"Connection lost: {e}. Reconnecting in 5s...")
-            await asyncio.sleep(5)
+            delay = min(backoff, 15.0) + random.uniform(0, 0.5)
+            logger.warning(f"Connection lost: {e}. Reconnecting in {delay:.1f}s...")
+            await asyncio.sleep(delay)
+            backoff = min(backoff * 2, 15.0)
+
 
 if __name__ == "__main__":
     asyncio.run(run_agent())