"""Antigravity Web Studio: Split-Screen Agent Chat, Sandbox Explorer & Live App Preview. A zero-dependency local web UI (`ThreadingHTTPServer` + Server-Sent Events) for interacting with a remote Antigravity Managed Agent and its Linux cloud sandbox. Features: - Real-Time SSE Chat Stream: Watch live agent steps (thoughts, Google Search queries, shell commands, tool calls) and streaming responses. - Remote `/workspace` File Explorer: Automatically lists files created inside the remote Linux container after every turn; inspect source code or download files. - Live Preview Canvas (Iframe Proxy): Any `.html` or `.svg` file created in `/workspace` is proxied directly from the remote sandbox (`/sandbox//workspace/...`) and rendered live side-by-side with your chat. - 1-Click Sandbox Forking (`from_environment`): Clone the current container filesystem into a new independent sandbox branch at any point and switch between branches. Usage: export GEMINI_API_KEY="..." # Start Web Studio on http://127.0.0.1:8080 and open in browser uv run python web_studio.py --open # Start with Gemini 4 Argon selected by default or attach to an existing sandbox uv run python web_studio.py --argon --env-id --port 8080 """ from __future__ import annotations import argparse from http import HTTPStatus from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer import json import mimetypes from pathlib import Path import sys import threading import time from typing import Any from urllib.parse import parse_qs, unquote, urlparse import warnings import webbrowser from google import genai from google.genai import errors try: from google.genai._gaos.lib import compat_errors API_ERRORS: tuple[type[Exception], ...] = ( errors.APIError, compat_errors.GeminiNextGenAPIClientError, ) except ImportError: API_ERRORS = (errors.APIError,) warnings.filterwarnings("ignore", message=".*usage is experimental.*") DEFAULT_AGENT = "antigravity-preview-09-2026" DEFAULT_MODEL = "gemini-3.8-flash" ARGON_MODEL = "gemini-4-argon" class StudioState: """Thread-safe state manager for sandboxes and conversation history per environment.""" def __init__( self, client: genai.Client, *, default_model: str | None = None, initial_env_id: str | None = None, keep_env: bool = False, ) -> None: self.client = client self.model: str | None = default_model self.current_env_id: str | None = initial_env_id self.keep_env = keep_env self.lock = threading.Lock() # Maps environment_id -> last interaction_id for stateful multi-turn continuity self.last_interaction_by_env: dict[str, str] = {} # Maps environment_id -> human label (e.g. "Sandbox #1", "Fork #2 (from a1b2c3)") self.env_labels: dict[str, str] = {} self.created_env_ids: set[str] = set() if initial_env_id: self.env_labels[initial_env_id] = f"Attached ({initial_env_id[:8]})" def register_env(self, env_id: str, label: str | None = None, created: bool = True) -> None: with self.lock: self.current_env_id = env_id if created: self.created_env_ids.add(env_id) if env_id not in self.env_labels: idx = len(self.env_labels) + 1 self.env_labels[env_id] = label or f"Sandbox #{idx} ({env_id[:8]})" def to_status_dict(self) -> dict[str, Any]: with self.lock: return { "agent": DEFAULT_AGENT, "model": self.model or DEFAULT_MODEL, "current_env_id": self.current_env_id, "previous_interaction_id": ( self.last_interaction_by_env.get(self.current_env_id) if self.current_env_id else None ), "environments": [ {"id": eid, "label": lbl} for eid, lbl in self.env_labels.items() ], } def cleanup(self) -> None: if self.keep_env or not self.created_env_ids: return for eid in list(self.created_env_ids): try: self.client.environments.delete(id=eid) print(f"🧹 Deleted sandbox: {eid}") except API_ERRORS: pass def summarize_one_line(text: str, max_len: int = 100) -> str: lines = [line.strip().strip("*#").strip() for line in text.strip().splitlines() if line.strip()] if not lines: return "" combined = " β€” ".join(lines) if len(lines) > 1 else lines[0] combined = " ".join(combined.split()) if len(combined) > max_len: return combined[: max_len - 3].rstrip() + "..." return combined def extract_step_summary(step: Any) -> dict[str, str] | None: """Convert an SSE step.start object into a structured step badge event.""" if not step: return None step_type = getattr(step, "type", "") args = getattr(step, "arguments", None) if step_type == "thought": return {"kind": "thought", "tag": "PLAN", "detail": "Planning next action..."} if step_type == "google_search_call": queries = getattr(args, "queries", "") if args else "" return { "kind": "search", "tag": "SEARCH", "detail": summarize_one_line(str(queries), max_len=90) or "Google Search", } if step_type == "code_execution_call": cmd = getattr(args, "command", getattr(args, "code", "")) if args else "" return { "kind": "exec", "tag": "EXEC", "detail": summarize_one_line(str(cmd), max_len=90) or "Shell execution", } if step_type == "function_call": fn_name = getattr(step, "name", "") or "tool" detail = fn_name if args: for key in ("TargetFile", "AbsolutePath", "path", "CommandLine", "command", "query", "Url"): val = args.get(key) if isinstance(args, dict) else getattr(args, key, None) if val: detail = f"{fn_name} ({summarize_one_line(str(val), max_len=60)})" break return {"kind": "tool", "tag": "TOOL", "detail": detail} return None def list_sandbox_files(client: genai.Client, env_id: str) -> list[dict[str, Any]]: """Return all files under `/workspace` in the given remote sandbox.""" if not env_id: return [] try: resp = client.environments.files.list( environment=env_id, path="workspace", recursive=True, ) raw_files = getattr(resp, "files", None) or [] items: list[dict[str, Any]] = [] for f in raw_files: ftype = str(getattr(f, "type", "FILE")).upper() fpath = getattr(f, "path", getattr(f, "name", "")) or "" if ftype == "DIRECTORY" or not fpath: continue rel_path = fpath.removeprefix("workspace/").lstrip("/") if not rel_path or rel_path.startswith("."): continue size_bytes = getattr(f, "size_bytes", None) ext = Path(rel_path).suffix.lower() items.append( { "path": fpath if fpath.startswith("workspace/") else f"workspace/{rel_path}", "name": rel_path, "size_bytes": int(size_bytes) if size_bytes is not None else None, "is_previewable": ext in (".html", ".htm", ".svg"), } ) items.sort(key=lambda x: (not x["is_previewable"], x["name"])) return items except Exception: return [] def download_sandbox_bytes(client: genai.Client, env_id: str, remote_path: str) -> tuple[bytes, str] | None: """Download raw bytes from a remote sandbox path and guess its MIME type.""" clean = remote_path.lstrip("/") candidates = [clean] if not clean.startswith("workspace/"): candidates.insert(0, f"workspace/{clean}") for candidate in candidates: try: data = client.environments.files.download(environment=env_id, path=candidate) mime, _ = mimetypes.guess_type(candidate) if not mime: if candidate.endswith((".py", ".md", ".txt", ".json", ".sh", ".toml", ".yaml", ".yml")): mime = "text/plain; charset=utf-8" else: mime = "application/octet-stream" elif mime.startswith("text/") or mime in ("application/javascript", "application/json"): mime = f"{mime}; charset=utf-8" return data, mime except Exception: continue return None STUDIO_HTML = """ Antigravity Web Studio
ANTIGRAVITY WEB STUDIO NO SANDBOX
AGENT INTERACTION STREAM 0 TOKENS
Remote Linux Sandbox + Live App Canvas
Every prompt executes inside an isolated Google Cloud Linux container. Ask the agent to build web apps, run Python benchmarks, or synthesize research into /workspace/app.htmlβ€”it will render live in the right-hand canvas.
IDLE
/WORKSPACE FILES
No files in /workspace yet.
LIVE ARTIFACT CANVAS
When the agent creates files in /workspace (such as app.html or report.html), they will appear in the file explorer and render live here.
""" def make_handler(state: StudioState): """Create the HTTP request handler bound to the current StudioState.""" class StudioHandler(BaseHTTPRequestHandler): def log_message(self, fmt: str, *args: Any) -> None: # Keep terminal logs clean return def _send_json(self, payload: dict[str, Any], status: int = HTTPStatus.OK) -> None: raw = json.dumps(payload).encode("utf-8") self.send_response(status) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(raw))) self.end_headers() self.wfile.write(raw) def _read_json(self) -> dict[str, Any]: length = int(self.headers.get("Content-Length", "0")) if length <= 0: return {} return json.loads(self.rfile.read(length).decode("utf-8")) def do_GET(self) -> None: parsed = urlparse(self.path) path = parsed.path if path == "/": raw = STUDIO_HTML.encode("utf-8") self.send_response(HTTPStatus.OK) self.send_header("Content-Type", "text/html; charset=utf-8") self.send_header("Content-Length", str(len(raw))) self.end_headers() self.wfile.write(raw) return if path == "/api/status": self._send_json(state.to_status_dict()) return if path == "/api/files": qs = parse_qs(parsed.query) env_id = (qs.get("env_id") or [state.current_env_id])[0] or "" files = list_sandbox_files(state.client, env_id) self._send_json({"env_id": env_id, "files": files}) return if path.startswith("/sandbox/"): # Format: /sandbox// parts = path.removeprefix("/sandbox/").split("/", 1) if len(parts) == 2: env_id = unquote(parts[0]) remote_path = unquote(parts[1]) downloaded = download_sandbox_bytes(state.client, env_id, remote_path) if downloaded is not None: data, mime = downloaded self.send_response(HTTPStatus.OK) self.send_header("Content-Type", mime) self.send_header("Content-Length", str(len(data))) self.end_headers() self.wfile.write(data) return self.send_error(HTTPStatus.NOT_FOUND, "File not found in remote sandbox") return self.send_error(HTTPStatus.NOT_FOUND) def do_POST(self) -> None: parsed = urlparse(self.path) path = parsed.path if path == "/api/model": body = self._read_json() state.model = body.get("model") or DEFAULT_MODEL self._send_json(state.to_status_dict()) return if path == "/api/new": with state.lock: state.current_env_id = None self._send_json(state.to_status_dict()) return if path == "/api/switch": body = self._read_json() target = body.get("env_id") if target: state.register_env(target, created=False) self._send_json(state.to_status_dict()) return if path == "/api/fork": body = self._read_json() source_env = body.get("env_id") or state.current_env_id if not source_env: self._send_json({"error": "No active sandbox to fork"}, status=HTTPStatus.BAD_REQUEST) return try: fork_env = state.client.environments.create(from_environment=source_env) fork_id = getattr(fork_env, "id", None) if not fork_id: raise RuntimeError("No environment id returned") label = f"Fork ({fork_id[:8]} ← {source_env[:6]})" state.register_env(fork_id, label=label, created=True) print(f"🌿 Forked sandbox {source_env} -> {fork_id}") self._send_json({"fork_env_id": fork_id, "status": state.to_status_dict()}) except Exception as exc: self._send_json({"error": str(exc)}, status=HTTPStatus.INTERNAL_SERVER_ERROR) return if path == "/api/chat": body = self._read_json() prompt = (body.get("prompt") or "").strip() target_env = body.get("env_id") or state.current_env_id or "remote" self.send_response(HTTPStatus.OK) self.send_header("Content-Type", "text/event-stream; charset=utf-8") self.send_header("Cache-Control", "no-cache") self.send_header("Connection", "close") self.end_headers() self.close_connection = True def send_sse(event_dict: dict[str, Any]) -> None: msg = f"data: {json.dumps(event_dict)}\n\n".encode("utf-8") self.wfile.write(msg) self.wfile.flush() t0 = time.monotonic() kwargs: dict[str, Any] = { "agent": DEFAULT_AGENT, "input": prompt, "environment": target_env, "stream": True, } if state.model and state.model != DEFAULT_MODEL: kwargs["agent_config"] = {"type": "antigravity", "model": state.model} prev_id = ( state.last_interaction_by_env.get(target_env) if target_env != "remote" else None ) if prev_id: kwargs["previous_interaction_id"] = prev_id try: try: events = state.client.interactions.create(**kwargs) except API_ERRORS as api_exc: if target_env != "remote" and ("404" in str(api_exc) or "not_found" in str(api_exc).lower()): with state.lock: state.env_labels.pop(target_env, None) state.last_interaction_by_env.pop(target_env, None) if state.current_env_id == target_env: state.current_env_id = None target_env = "remote" kwargs["environment"] = "remote" kwargs.pop("previous_interaction_id", None) send_sse( { "type": "step", "kind": "tool", "tag": "SANDBOX", "detail": "Previous sandbox expired or deleted β€” provisioning a fresh sandbox...", } ) events = state.client.interactions.create(**kwargs) else: raise resolved_env: str | None = None if target_env == "remote" else target_env interaction_id: str | None = None tokens = 0 for event in events: etype = getattr(event, "event_type", "") if etype == "interaction.created": inter = getattr(event, "interaction", None) if inter: interaction_id = getattr(inter, "id", interaction_id) resolved_env = getattr(inter, "environment_id", resolved_env) if resolved_env: state.register_env(resolved_env, created=(target_env == "remote")) send_sse( { "type": "env_ready", "env_id": resolved_env, "status": state.to_status_dict(), } ) elif etype == "step.start": badge = extract_step_summary(getattr(event, "step", None)) if badge: send_sse({"type": "step", **badge}) elif etype == "step.delta": delta = getattr(event, "delta", None) dtype = getattr(delta, "type", "") if dtype == "text": text = getattr(delta, "text", "") if text: send_sse({"type": "text", "text": text}) elif dtype == "thought_summary": content = getattr(delta, "content", None) ttext = getattr(content, "text", "") if content else "" if ttext: send_sse( { "type": "thought", "text": summarize_one_line(ttext, max_len=95), } ) elif etype == "step.stop": usage = getattr(event, "usage", None) if usage and getattr(usage, "total_tokens", None): tokens = int(usage.total_tokens) elif etype == "interaction.completed": inter = getattr(event, "interaction", None) if inter: interaction_id = getattr(inter, "id", interaction_id) resolved_env = getattr(inter, "environment_id", resolved_env) usage = getattr(inter, "usage", None) if usage and getattr(usage, "total_tokens", None): tokens = int(usage.total_tokens) if resolved_env: state.register_env(resolved_env, created=(target_env == "remote")) if interaction_id: state.last_interaction_by_env[resolved_env] = interaction_id elapsed_s = round(time.monotonic() - t0, 1) print( f"[{elapsed_s:5.1f}s] βœ“ Turn complete in {resolved_env} " f"(tokens: {tokens:,})" ) send_sse( { "type": "done", "env_id": resolved_env, "interaction_id": interaction_id, "tokens": tokens, "elapsed_s": elapsed_s, "status": state.to_status_dict(), } ) break elif etype == "error": err = getattr(event, "error", None) send_sse({"type": "error", "message": str(getattr(err, "message", err))}) break except Exception as exc: send_sse({"type": "error", "message": str(exc)}) return self.send_error(HTTPStatus.NOT_FOUND) return StudioHandler def parse_args(argv: list[str] | None = None) -> argparse.Namespace: parser = argparse.ArgumentParser( description="Launch Antigravity Web Studio (split-screen chat, sandbox file browser, and live preview)." ) parser.add_argument( "--host", type=str, default="127.0.0.1", help="Host interface to bind (default: 127.0.0.1).", ) parser.add_argument( "-p", "--port", type=int, default=8080, help="Local port for the Web Studio server (default: 8080).", ) model_group = parser.add_mutually_exclusive_group() model_group.add_argument( "--model", type=str, default=None, help="Initial Gemini model (e.g., gemini-3.8-flash, gemini-4-argon).", ) model_group.add_argument( "--argon", action="store_true", help=f"Start with Gemini 4 Argon ({ARGON_MODEL}).", ) parser.add_argument( "--env-id", type=str, default=None, help="Attach to an existing remote sandbox environment ID on startup.", ) parser.add_argument( "--open", action="store_true", help="Automatically open the Web Studio URL in your default browser.", ) parser.add_argument( "--keep-env", action="store_true", help="Preserve created sandboxes when shutting down the server.", ) return parser.parse_args(argv) def main(argv: list[str] | None = None) -> int: args = parse_args(argv) model_name = ARGON_MODEL if args.argon else (args.model or DEFAULT_MODEL) client = genai.Client() state = StudioState( client, default_model=model_name, initial_env_id=args.env_id, keep_env=args.keep_env, ) server = ThreadingHTTPServer((args.host, args.port), make_handler(state)) url = f"http://{args.host}:{args.port}" print(f"πŸš€ Antigravity Web Studio running at: {url}") print(f" Default Model: {model_name}") if args.env_id: print(f" Attached Sandbox: {args.env_id}") print(" Press Ctrl+C to stop the server.\n") if args.open: threading.Timer(0.4, lambda: webbrowser.open(url)).start() try: server.serve_forever() except KeyboardInterrupt: print("\nShutting down Antigravity Web Studio...") finally: server.server_close() state.cleanup() return 0 if __name__ == "__main__": sys.exit(main())