remote

Author: torrmal

anton/chat.py

@@ -443,26 +443,38 @@ async def _handle_remote(
         status = result.get("status", "")
 
     # Poll until ready — 5s intervals, 3 min max
+    # Use /resolve to get the direct IP, then poll /health on it
     if status in ("provisioning", "starting"):
         max_wait = 180
         poll_interval = 5
         start_time = time.time()
+        direct_endpoint = None
 
         with Live(Spinner("dots", text="  Waiting for instance to be ready...", style="anton.cyan"), console=console, transient=True):
             while time.time() - start_time < max_wait:
                 await asyncio.sleep(poll_interval)
                 try:
-                    req = Request(
-                        f"{endpoint}/health",
-                        headers={
-                            "Authorization": f"Bearer {api_key}",
-                            "User-Agent": "anton/1.0",
-                        },
-                    )
-                    with urlopen(req, timeout=5) as resp:
-                        health = json.loads(resp.read().decode())
-                    if health.get("status") == "ok":
-                        break
+                    # First resolve the direct IP via Cloudflare Worker
+                    if not direct_endpoint:
+                        req = Request(
+                            f"{endpoint}/resolve",
+                            headers={"Authorization": f"Bearer {api_key}", "User-Agent": "anton/1.0"},
+                        )
+                        with urlopen(req, timeout=5) as resp:
+                            resolve_data = json.loads(resp.read().decode())
+                        if resolve_data.get("status") == "running":
+                            direct_endpoint = resolve_data.get("endpoint", "")
+
+                    # Then check health directly
+                    if direct_endpoint:
+                        req = Request(
+                            f"{direct_endpoint}/health",
+                            headers={"Authorization": f"Bearer {api_key}", "User-Agent": "anton/1.0"},
+                        )
+                        with urlopen(req, timeout=5) as resp:
+                            health = json.loads(resp.read().decode())
+                        if health.get("status") == "ok":
+                            break
                 except Exception:
                     pass
             else:

anton/core/backends/remote.py

@@ -40,13 +40,42 @@ def __init__(
             cells=cells,
             workspace_path=workspace_path,
         )
-        self._endpoint = endpoint_url.rstrip("/")
+        self._cloudflare_endpoint = endpoint_url.rstrip("/")  # https://sp-xxx.4nton.ai
+        self._direct_endpoint: str | None = None  # resolved to http://IP:port
         self._api_key = api_key
 
     # ------------------------------------------------------------------
     # HTTP helpers
     # ------------------------------------------------------------------
 
+    async def _resolve_endpoint(self) -> str:
+        """Resolve the Cloudflare endpoint to a direct IP endpoint.
+
+        Calls /resolve on the Cloudflare Worker which returns the instance's
+        direct IP. Caches the result for subsequent calls.
+        """
+        if self._direct_endpoint:
+            return self._direct_endpoint
+
+        import aiohttp
+
+        url = f"{self._cloudflare_endpoint}/resolve"
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                url, headers=self._headers(), timeout=aiohttp.ClientTimeout(total=15)
+            ) as resp:
+                if resp.status >= 400:
+                    text = await resp.text()
+                    raise RuntimeError(f"Failed to resolve remote scratchpad ({resp.status}): {text}")
+                data = await resp.json()
+
+        endpoint = data.get("endpoint", "")
+        if not endpoint:
+            raise RuntimeError(f"No endpoint returned from /resolve: {data}")
+
+        self._direct_endpoint = endpoint.rstrip("/")
+        return self._direct_endpoint
+
     def _headers(self) -> dict[str, str]:
         return {
             "Authorization": f"Bearer {self._api_key}",
@@ -58,7 +87,8 @@ async def _post(self, path: str, body: dict | None = None) -> dict:
         """POST to the remote service and return parsed JSON."""
         import aiohttp
 
-        url = f"{self._endpoint}{path}"
+        endpoint = await self._resolve_endpoint()
+        url = f"{endpoint}{path}"
         async with aiohttp.ClientSession() as session:
             async with session.post(
                 url, json=body or {}, headers=self._headers(), timeout=aiohttp.ClientTimeout(total=300)
@@ -72,7 +102,8 @@ async def _get(self, path: str, params: dict | None = None) -> dict:
         """GET from the remote service and return parsed JSON."""
         import aiohttp
 
-        url = f"{self._endpoint}{path}"
+        endpoint = await self._resolve_endpoint()
+        url = f"{endpoint}{path}"
         async with aiohttp.ClientSession() as session:
             async with session.get(
                 url, params=params, headers=self._headers(), timeout=aiohttp.ClientTimeout(total=30)
@@ -86,7 +117,8 @@ async def _sse(self, path: str, body: dict) -> AsyncIterator[dict]:
         """POST to an SSE endpoint and yield parsed events."""
         import aiohttp
 
-        url = f"{self._endpoint}{path}"
+        endpoint = await self._resolve_endpoint()
+        url = f"{endpoint}{path}"
         async with aiohttp.ClientSession() as session:
             async with session.post(
                 url, json=body, headers=self._headers(), timeout=aiohttp.ClientTimeout(total=600)