loki-mode 7.55.0 → 7.57.0

package/dashboard/server.py

@@ -11,6 +11,7 @@ import json
 import logging
 import os
 import subprocess
+import threading
 import time
 from collections import defaultdict
 from dataclasses import asdict
@@ -7599,18 +7600,397 @@ def _reconcile_app_runner_liveness(state):
     return state
 
 
+# =============================================================================
+# Docker-compose app-runner discovery
+#
+# When the autonomous agent brings up a docker-compose stack itself (rather than
+# via autonomy/app-runner.sh), no .loki/app-runner/state.json is written, so the
+# status endpoint reports "not_initialized" / "stopped" even though the app is
+# genuinely running. The discovery helper below inspects the live compose stack
+# for the project directory and synthesizes an equivalent status so the dashboard
+# App Runner panel surfaces the running app and its URL.
+#
+# Safety contract (all mandatory):
+#   - Every docker subprocess.run has an explicit timeout; total work is bounded.
+#   - On ANY error (TimeoutExpired/OSError/SubprocessError/parse failure) the
+#     helper returns None and the caller falls back to its prior behavior. The
+#     handler never raises and never blocks the event loop (it is offloaded via
+#     asyncio.to_thread / run_in_threadpool).
+#   - A short TTL cache prevents the 3s/5s dashboard pollers from spawning
+#     repeated docker invocations.
+#   - A URL is never fabricated for a non-running or non-published container.
+# =============================================================================
+
+# Common host ports a web service typically publishes, in precedence order.
+# Mirrors autonomy/app-runner.sh _identify_compose_web_service (COMMON list).
+_COMPOSE_COMMON_WEB_PORTS = ["3000", "8000", "8080", "5000", "4200", "5173", "80"]
+
+# Per-docker-call timeout (seconds). Several calls run in sequence; keep each
+# tight so total discovery stays bounded well under the poller interval.
+_COMPOSE_DISCOVERY_CMD_TIMEOUT = 3
+
+# TTL (seconds) for the discovery result cache, keyed by resolved project dir.
+# The dashboard polls every 3-5s; a 2.5s TTL collapses a burst of concurrent
+# pollers onto a single docker probe without making the status feel stale.
+_COMPOSE_DISCOVERY_TTL_SECONDS = 2.5
+
+# Cache: {project_dir_str: (expiry_epoch, result_or_None)}. Module-level so it
+# survives across requests. Guarded by a lock because to_thread runs the sync
+# helper on worker threads that can overlap.
+_compose_discovery_cache: dict[str, tuple[float, Optional[dict]]] = {}
+_compose_discovery_lock = threading.Lock()
+
+
+def _parse_docker_json(raw):
+    """Parse docker --format json output into a list of dicts, defensively.
+
+    Docker emits either a single JSON array or newline-delimited JSON (one
+    object per line), and the shape has varied across docker/compose versions.
+    Try a whole-blob parse first; if that fails or does not yield a list, fall
+    back to parsing each non-empty line individually. Returns a list of dicts
+    (possibly empty). Never raises.
+    """
+    raw = (raw or "").strip()
+    if not raw:
+        return []
+    try:
+        parsed = json.loads(raw)
+        if isinstance(parsed, list):
+            return [x for x in parsed if isinstance(x, dict)]
+        if isinstance(parsed, dict):
+            return [parsed]
+    except (ValueError, TypeError):
+        pass
+    items = []
+    for line in raw.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+        except (ValueError, TypeError):
+            continue
+        if isinstance(obj, dict):
+            items.append(obj)
+    return items
+
+
+def _run_docker_json(args, cwd=None):
+    """Run a docker command and return parsed JSON rows, or None on any failure.
+
+    args is the argument list AFTER `docker` (e.g. ["compose", "ps", ...]). Uses
+    an explicit per-call timeout and a list argv (no shell). A non-zero exit,
+    timeout, missing docker binary, or unparseable output all yield None so the
+    caller fails open.
+    """
+    try:
+        proc = subprocess.run(
+            ["docker", *args],
+            capture_output=True,
+            text=True,
+            timeout=_COMPOSE_DISCOVERY_CMD_TIMEOUT,
+            cwd=str(cwd) if cwd else None,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if proc.returncode != 0:
+        return None
+    return _parse_docker_json(proc.stdout)
+
+
+def _compose_published_ports(container):
+    """Host ports actually published by a running compose container (compose ps).
+
+    `docker compose ps --format json` exposes published ports under the
+    "Publishers" list, each like {"PublishedPort": 3000, "TargetPort": 3000,
+    "Protocol": "tcp", "URL": "0.0.0.0"}. A PublishedPort of 0 means the port is
+    exposed but not published to the host, so it is filtered out. Returns a list
+    of host port strings, preserving order. Never raises.
+    """
+    out = []
+    pubs = container.get("Publishers")
+    if not isinstance(pubs, list):
+        return out
+    for p in pubs:
+        if not isinstance(p, dict):
+            continue
+        port = p.get("PublishedPort")
+        try:
+            port = int(port)
+        except (TypeError, ValueError):
+            continue
+        if port > 0:
+            out.append(str(port))
+    return out
+
+
+def _compose_service_labels(svc):
+    """Normalize a compose-config service's labels into a dict. Never raises."""
+    labels = svc.get("labels") or {}
+    if isinstance(labels, dict):
+        return labels
+    if isinstance(labels, list):
+        normalized = {}
+        for item in labels:
+            if isinstance(item, str) and "=" in item:
+                k, v = item.split("=", 1)
+                normalized[k] = v
+        return normalized
+    return {}
+
+
+def _identify_compose_web_service(config_services, running_by_service):
+    """Pick the primary web service and its published host port.
+
+    Mirrors the precedence in autonomy/app-runner.sh:431-481:
+      (1) service labelled loki.primary=true
+      (2) service named web/app
+      (3) service publishing a common web port (3000/8000/8080/5000/4200/5173/80)
+      (4) first service with any published port
+    Declared names/labels come from `docker compose config`; the actual runtime
+    published port comes from the matching RUNNING container (compose ps), since
+    only running, published containers can yield a real URL. Returns
+    (service_name, port_str) or (None, None). Never raises.
+
+    config_services: dict {service_name: service_config_dict} (may be empty).
+    running_by_service: dict {service_name: [published_port_str, ...]} for
+        currently-running containers with at least one published host port.
+    """
+    if not running_by_service:
+        return (None, None)
+
+    # (1) label loki.primary=true (declared in compose config)
+    for name, svc in (config_services or {}).items():
+        if not isinstance(svc, dict):
+            continue
+        labels = _compose_service_labels(svc)
+        if str(labels.get("loki.primary", "")).lower() == "true":
+            ports = running_by_service.get(name)
+            if ports:
+                return (name, ports[0])
+
+    # (2) service named web/app
+    for cand in ("web", "app"):
+        ports = running_by_service.get(cand)
+        if ports:
+            return (cand, ports[0])
+
+    # (3) service publishing a common web port
+    for cp in _COMPOSE_COMMON_WEB_PORTS:
+        for name, ports in running_by_service.items():
+            if cp in ports:
+                return (name, cp)
+
+    # (4) first running service with any published port. Sort for determinism.
+    for name in sorted(running_by_service.keys()):
+        ports = running_by_service[name]
+        if ports:
+            return (name, ports[0])
+
+    return (None, None)
+
+
+def _container_health_state(container):
+    """Classify a running compose container into 'running' | 'starting' | None.
+
+    Reads the container State + Health fields from `docker compose ps`:
+      - State exited/dead/paused/removing -> None (no live URL to surface)
+      - State running + Health healthy or empty (no healthcheck) -> 'running'
+      - State running + Health unhealthy/starting -> 'starting' (still surface
+        the URL: e.g. a Next.js app whose home renders but whose '/' healthcheck
+        fails is reachable and should show as starting, not hidden)
+      - State created/restarting -> 'starting'
+    Returns the status string or None. Never raises.
+    """
+    state = str(container.get("State", "")).lower()
+    health = str(container.get("Health", "")).lower()
+    if state in ("exited", "dead", "paused", "removing"):
+        return None
+    if state == "running":
+        if health in ("", "healthy"):
+            return "running"
+        # unhealthy or starting healthcheck: reachable, treat as starting.
+        return "starting"
+    if state in ("created", "restarting"):
+        return "starting"
+    # Unknown/other states: do not fabricate a running URL.
+    return None
+
+
+def _discover_compose_app_runner_state():
+    """Discover a running docker-compose stack for the active project, or None.
+
+    Returns a synthesized app-runner state dict (source=="discovered") when the
+    project directory hosts a compose file AND a primary web service is running
+    with a published host port. Returns None in every other case (no compose
+    file, docker absent, nothing running, no published web port, only
+    dead/exited containers, or any error). Synchronous and self-contained; the
+    caller offloads it onto a worker thread. Never raises.
+    """
+    try:
+        project_dir = _get_loki_dir().parent.resolve()
+    except Exception:
+        return None
+    cache_key = str(project_dir)
+
+    now = time.monotonic()
+    with _compose_discovery_lock:
+        cached = _compose_discovery_cache.get(cache_key)
+        if cached is not None and cached[0] > now:
+            return cached[1]
+
+    result = _discover_compose_app_runner_state_uncached(project_dir)
+
+    with _compose_discovery_lock:
+        _compose_discovery_cache[cache_key] = (
+            time.monotonic() + _COMPOSE_DISCOVERY_TTL_SECONDS,
+            result,
+        )
+    return result
+
+
+def _discover_compose_app_runner_state_uncached(project_dir):
+    """Uncached body of _discover_compose_app_runner_state. Never raises."""
+    try:
+        # Step A: a compose file must exist in the project dir, else this is a
+        # single-process app and discovery does not apply.
+        compose_names = (
+            "docker-compose.yml", "docker-compose.yaml",
+            "compose.yml", "compose.yaml",
+        )
+        if not any((project_dir / n).is_file() for n in compose_names):
+            return None
+
+        # Step C: running containers for THIS project's compose stack, with the
+        # runtime published ports. Run from the project dir so compose resolves
+        # the right project. (Step B project matching is implicitly handled by
+        # running compose from project_dir; we keep ls/ps from this dir.)
+        ps_rows = _run_docker_json(
+            ["compose", "ps", "--format", "json"], cwd=project_dir
+        )
+        if ps_rows is None:
+            # docker absent / timeout / error -> fail open.
+            return None
+        if not ps_rows:
+            # No containers for this compose project (not up). Nothing to show.
+            return None
+
+        # Map running, published services to their host ports. Track health and
+        # the raw container for the primary so we can classify it precisely.
+        running_by_service = {}
+        container_by_service = {}
+        for c in ps_rows:
+            service = c.get("Service") or c.get("Name")
+            if not service:
+                continue
+            ports = _compose_published_ports(c)
+            if ports:
+                running_by_service.setdefault(service, [])
+                for p in ports:
+                    if p not in running_by_service[service]:
+                        running_by_service[service].append(p)
+                container_by_service.setdefault(service, c)
+        if not running_by_service:
+            # Stack is up but nothing publishes a host port: no surfaceable URL.
+            return None
+
+        # Step D: declared service config (names/labels) for precedence. Best
+        # effort: if config is unavailable we still proceed with ps data alone.
+        config_rows = _run_docker_json(
+            ["compose", "config", "--format", "json"], cwd=project_dir
+        )
+        config_services = {}
+        if config_rows:
+            cfg = config_rows[0]
+            svcs = cfg.get("services")
+            if isinstance(svcs, dict):
+                config_services = svcs
+
+        primary_service, port = _identify_compose_web_service(
+            config_services, running_by_service
+        )
+        if not primary_service or not port:
+            return None
+
+        # Step E health classification, from the primary's running container.
+        primary_container = container_by_service.get(primary_service)
+        if not isinstance(primary_container, dict):
+            return None
+        health_status = _container_health_state(primary_container)
+        if health_status is None:
+            # exited/dead/paused/unknown -> do not fabricate a URL.
+            return None
+
+        # Step B (best effort): record the compose project name for the panel.
+        compose_project = (
+            primary_container.get("Project")
+            or "".join(ch for ch in project_dir.name.lower() if ch.isalnum())
+        )
+
+        health_text = str(primary_container.get("Health", "")).lower()
+        health_ok = health_text in ("", "healthy")
+
+        # Step F: synthesize the state dict using the SAME field names the UI and
+        # app-runner.sh state.json use (status/url/port/method/last_health), plus
+        # discovery-provenance fields the panel safely ignores.
+        return {
+            "status": health_status,
+            "url": "http://localhost:{}".format(port),
+            "port": int(port),
+            "method": "docker compose (detected)",
+            "primary_service": primary_service,
+            "compose_project": compose_project,
+            "source": "discovered",
+            "externally_managed": True,
+            "last_health": {"ok": health_ok},
+        }
+    except Exception:
+        # Fail open on anything unexpected; never break the status endpoint.
+        return None
+
+
 @app.get("/api/app-runner/status")
 async def get_app_runner_status():
-    """Get app runner current status (with dead-run liveness reconciliation)."""
+    """Get app runner current status (with dead-run liveness reconciliation).
+
+    Resolution order:
+      1. state.json present AND reconciles to running/starting -> return it (an
+         app-runner.sh-managed run is authoritative).
+      2. state.json missing OR reconciles to stopped/stale -> attempt
+         docker-compose discovery for stacks the autonomous agent launched
+         itself; if a running stack is found, return the synthesized state
+         (bypassing pid-based liveness reconciliation, which is meaningless for
+         externally-launched containers).
+      3. otherwise return the existing (possibly reconciled / not_initialized)
+         result.
+    Discovery runs on a worker thread so its bounded docker calls never block
+    the event loop.
+    """
     loki_dir = _get_loki_dir()
     state_file = loki_dir / "app-runner" / "state.json"
+
     if not state_file.exists():
+        discovered = await asyncio.to_thread(_discover_compose_app_runner_state)
+        if discovered is not None:
+            return discovered
         return {"status": "not_initialized"}
+
     try:
         state = json.loads(state_file.read_text())
     except (json.JSONDecodeError, OSError):
         return {"status": "error"}
-    return _reconcile_app_runner_liveness(state)
+
+    reconciled = _reconcile_app_runner_liveness(state)
+    if isinstance(reconciled, dict) and reconciled.get("status") in ("running", "starting"):
+        # An app-runner.sh-managed run that is still live is authoritative.
+        return reconciled
+
+    # State is missing-live (stopped/stale/other): the agent may have brought up
+    # a compose stack outside app-runner.sh. Prefer a live discovered stack.
+    discovered = await asyncio.to_thread(_discover_compose_app_runner_state)
+    if discovered is not None:
+        return discovered
+    return reconciled
 
 
 def _get_log_redactor():