fix: correct proxy URL construction for Astro CLI reverse proxy discovery

The routes.json hostname field already contains the full hostname
(e.g. providence.sirius.localhost), so appending .localhost again
produced invalid URLs like http://providence.sirius.localhost.localhost:6563.

Also fix existing port-scan tests to pass a nonexistent proxy_routes_path
so they don't accidentally pick up real routes.json entries on the host.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: josh-fell

astro-airflow-mcp/src/astro_airflow_mcp/__main__.py

@@ -5,56 +5,52 @@
 import os
 from pathlib import Path
 
-import yaml
-
+from astro_airflow_mcp.constants import DEFAULT_AIRFLOW_URL
 from astro_airflow_mcp.logging import configure_logging, get_logger
 from astro_airflow_mcp.server import configure, mcp
 
 logger = get_logger("main")
 
-# Default Airflow URL if no config is found
-DEFAULT_AIRFLOW_URL = "http://localhost:8080"
-
 
-def discover_airflow_url(project_dir: str | None) -> str | None:
-    """Discover Airflow URL from .astro/config.yaml in the project directory.
+def discover_airflow_url(
+    project_dir: str | None,
+    proxy_routes_path: Path | None = None,
+    proxy_global_config_path: Path | None = None,
+) -> tuple[str, bool] | None:
+    """Discover Airflow URL, checking proxy routes first then .astro/config.yaml.
 
-    Looks for the Astro CLI config file and extracts the webserver/api-server port.
-    Prefers api-server.port (Airflow 3.x) over webserver.port (Airflow 2.x).
+    Discovery priority:
+    1. Proxy routes.json match by project directory (Astro CLI reverse proxy)
+    2. .astro/config.yaml port (Airflow 3.x api-server.port, then 2.x webserver.port)
 
     Args:
         project_dir: The project directory to search in
+        proxy_routes_path: Path to proxy routes.json (for testing)
+        proxy_global_config_path: Path to global astro config (for testing)
 
     Returns:
-        The discovered Airflow URL (e.g., "http://localhost:8081"), or None if not found
+        Tuple of (url, is_proxy) if found, None otherwise
     """
     if not project_dir:
         return None
 
-    config_path = Path(project_dir) / ".astro" / "config.yaml"
-    if not config_path.exists():
-        return None
-
-    try:
-        with open(config_path) as f:
-            config = yaml.safe_load(f)
-
-        if not config:
-            return None
+    from astro_airflow_mcp.discovery.local import LocalDiscoveryBackend
 
-        # Try api-server.port first (Airflow 3.x), then webserver.port (Airflow 2.x)
-        port = None
-        if "api-server" in config and isinstance(config["api-server"], dict):
-            port = config["api-server"].get("port")
-        if port is None and "webserver" in config and isinstance(config["webserver"], dict):
-            port = config["webserver"].get("port")
+    backend = LocalDiscoveryBackend()
 
-        if port:
-            return f"http://localhost:{port}"
+    # Step 1: Check proxy routes for a matching project directory
+    proxy_url = backend.find_proxy_url_for_project(
+        project_dir,
+        routes_path=proxy_routes_path,
+        global_config_path=proxy_global_config_path,
+    )
+    if proxy_url:
+        return (proxy_url, True)
 
-    except Exception as e:
-        # Log but don't fail - we'll fall back to default
-        logger.debug("Failed to read .astro/config.yaml: %s", e)
+    # Step 2: Check .astro/config.yaml for port
+    port = backend.get_astro_project_port(project_dir=Path(project_dir))
+    if port:
+        return (f"http://localhost:{port}", False)
 
     return None
 
@@ -147,10 +143,11 @@ def main():
     airflow_url = args.airflow_url
     url_source = "explicit"
     if not airflow_url:
-        # Try auto-discovery from .astro/config.yaml
-        airflow_url = discover_airflow_url(args.airflow_project_dir)
-        if airflow_url:
-            url_source = "auto-discovered"
+        # Try auto-discovery: proxy routes → .astro/config.yaml → default
+        result = discover_airflow_url(args.airflow_project_dir)
+        if result:
+            airflow_url, is_proxy = result
+            url_source = "auto-discovered (proxy)" if is_proxy else "auto-discovered"
         else:
             airflow_url = DEFAULT_AIRFLOW_URL
             url_source = "default"

astro-airflow-mcp/src/astro_airflow_mcp/constants.py

@@ -1,5 +1,8 @@
 """Shared constants for CLI and MCP server."""
 
+import os
+from pathlib import Path
+
 # Terminal states for DAG runs (polling stops when reached)
 TERMINAL_DAG_RUN_STATES = {"success", "failed", "upstream_failed"}
 
@@ -15,3 +18,21 @@
 
 # Read-only mode environment variable
 READ_ONLY_ENV_VAR = "AF_READ_ONLY"
+
+# Astro CLI reverse proxy defaults
+DEFAULT_PROXY_PORT = 6563
+
+
+def get_astro_home() -> Path:
+    """Return the Astro CLI home directory, respecting ASTRO_HOME env var."""
+    return Path(os.environ.get("ASTRO_HOME", Path.home() / ".astro")).expanduser()
+
+
+def get_proxy_routes_path() -> Path:
+    """Return the path to the proxy routes.json file."""
+    return get_astro_home() / "proxy" / "routes.json"
+
+
+def get_astro_global_config_path() -> Path:
+    """Return the path to the global Astro CLI config.yaml."""
+    return get_astro_home() / "config.yaml"

astro-airflow-mcp/src/astro_airflow_mcp/discovery/local.py

@@ -3,13 +3,19 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import socket
 from pathlib import Path
 from typing import Any
 
 import httpx
 import yaml
 
+from astro_airflow_mcp.constants import (
+    DEFAULT_PROXY_PORT,
+    get_astro_global_config_path,
+    get_proxy_routes_path,
+)
 from astro_airflow_mcp.discovery.base import DiscoveredInstance, DiscoveryError
 
 
@@ -57,7 +63,7 @@ def is_available(self) -> bool:
         """Local discovery is always available."""
         return True
 
-    def _get_astro_project_port(self, project_dir: Path | None = None) -> int | None:
+    def get_astro_project_port(self, project_dir: Path | None = None) -> int | None:
         """Check for .astro/config.yaml and extract the configured port.
 
         Looks for:
@@ -96,35 +102,147 @@ def _get_astro_project_port(self, project_dir: Path | None = None) -> int | None
         except (OSError, yaml.YAMLError, ValueError, TypeError):
             return None
 
+    def _get_proxy_port(self, global_config_path: Path | None = None) -> int:
+        """Read the proxy port from the global Astro CLI config.
+
+        Args:
+            global_config_path: Path to ~/.astro/config.yaml (for testing)
+
+        Returns:
+            Proxy port number (default: DEFAULT_PROXY_PORT)
+        """
+        if global_config_path is None:
+            global_config_path = get_astro_global_config_path()
+
+        try:
+            with open(global_config_path) as f:
+                config = yaml.safe_load(f)
+            if (
+                config
+                and "proxy" in config
+                and isinstance(config["proxy"], dict)
+                and (port := config["proxy"].get("port")) is not None
+            ):
+                return int(port)
+        except (OSError, yaml.YAMLError, ValueError, TypeError):
+            pass
+
+        return DEFAULT_PROXY_PORT
+
+    def _read_proxy_routes(self, routes_path: Path | None = None) -> list[dict]:
+        """Read proxy routes from ~/.astro/proxy/routes.json.
+
+        Args:
+            routes_path: Path to routes.json (for testing)
+
+        Returns:
+            List of route dicts, or empty list if unavailable
+        """
+        if routes_path is None:
+            routes_path = get_proxy_routes_path()
+
+        try:
+            with open(routes_path) as f:
+                data = json.load(f)
+            if isinstance(data, list):
+                return data
+        except (OSError, json.JSONDecodeError, TypeError):
+            pass
+
+        return []
+
+    def find_proxy_url_for_project(
+        self,
+        project_dir: str,
+        routes_path: Path | None = None,
+        global_config_path: Path | None = None,
+    ) -> str | None:
+        """Find the proxy URL for a specific project directory.
+
+        Args:
+            project_dir: The project directory to match
+            routes_path: Path to routes.json (for testing)
+            global_config_path: Path to global astro config (for testing)
+
+        Returns:
+            Proxy URL if a matching route is found, None otherwise
+        """
+        routes = self._read_proxy_routes(routes_path=routes_path)
+        if not routes:
+            return None
+
+        project_path = str(Path(project_dir).resolve())
+        for route in routes:
+            if not (route_dir := route.get("projectDir")):
+                continue
+            if str(Path(route_dir).resolve()) != project_path:
+                continue
+            if not (hostname := route.get("hostname")):
+                continue
+            proxy_port = self._get_proxy_port(global_config_path=global_config_path)
+            return f"http://{hostname}:{proxy_port}"
+
+        return None
+
     def discover(
         self,
         ports: list[int] | None = None,
         hosts: list[str] | None = None,
         timeout: float | None = None,
+        proxy_routes_path: Path | None = None,
+        proxy_global_config_path: Path | None = None,
         **kwargs: Any,
     ) -> list[DiscoveredInstance]:
-        """Discover local Airflow instances by scanning ports.
+        """Discover local Airflow instances.
 
-        First checks for .astro/config.yaml in the current directory to find
-        the configured port. Falls back to scanning common ports if not found.
+        Checks proxy routes first (for Astro CLI reverse proxy), then falls
+        back to scanning ports for running Airflow instances.
 
         Args:
             ports: Ports to scan (default: check .astro/config.yaml, then common ports)
             hosts: Hosts to scan (default: localhost, 127.0.0.1)
             timeout: Connection timeout in seconds
+            proxy_routes_path: Path to proxy routes.json (for testing)
+            proxy_global_config_path: Path to global astro config (for testing)
             **kwargs: Additional options (ignored)
 
         Returns:
-            List of discovered instances
+            List of discovered instances (proxy routes first, then port-scanned)
         """
         if timeout is None:
             timeout = self.DEFAULT_HTTP_TIMEOUT
 
+        instances: list[DiscoveredInstance] = []
+
+        # Step 1: Check proxy routes (Astro CLI reverse proxy)
+        if proxy_routes := self._read_proxy_routes(routes_path=proxy_routes_path):
+            proxy_port = self._get_proxy_port(global_config_path=proxy_global_config_path)
+            for route in proxy_routes:
+                if not (hostname := route.get("hostname")):
+                    continue
+                proxy_url = f"http://{hostname}:{proxy_port}"
+                instance_name = f"{hostname}:{proxy_port}"
+                instances.append(
+                    DiscoveredInstance(
+                        name=instance_name,
+                        url=proxy_url,
+                        source=self.name,
+                        auth_token=None,
+                        metadata={
+                            "proxy": True,
+                            "project_dir": route.get("projectDir", ""),
+                            "mode": route.get("mode", ""),
+                            "backend_port": route.get("port", ""),
+                        },
+                    )
+                )
+
+        # Step 2: Port scanning
         # Build port list: check .astro/config.yaml first, then fallback to defaults
         if ports:
             scan_ports = ports
         else:
-            astro_port = self._get_astro_project_port()
+            astro_port = self.get_astro_project_port()
             if astro_port:
                 # Prioritize Astro project port, then check other common ports
                 scan_ports = [astro_port] + [p for p in self.DEFAULT_PORTS if p != astro_port]
@@ -133,7 +251,6 @@ def discover(
 
         scan_hosts = hosts if hosts else self.DEFAULT_HOSTS
 
-        instances: list[DiscoveredInstance] = []
         seen_urls: set[str] = set()
 
         for host in scan_hosts: