agent-control-plane 0.3.0 → 0.6.0

package/tools/dashboard/issue_queue_state.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def split_key_value_text(text: str) -> list[str]:
+    return [line.strip() for line in re.split(r"(?:\r?\n|\\n)+", text) if line.strip()]
+
+
+def normalize_value(raw: str) -> str:
+    value = raw.strip()
+    if value in {"''", '""'}:
+        return ""
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
+        return value[1:-1]
+    return value
+
+
+def parse_key_value_text(text: str) -> dict[str, str]:
+    data: dict[str, str] = {}
+    for line in split_key_value_text(text):
+        if "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        data[key.strip()] = normalize_value(value)
+    return data
+
+
+def read_env_file(path: Path) -> dict[str, str]:
+    if not path.is_file():
+        return {}
+    return parse_key_value_text(path.read_text(encoding="utf-8", errors="replace"))
+
+
+def file_mtime_iso(path: Path) -> str:
+    return datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def parse_issue_queue_filename(path: Path) -> tuple[str, str]:
+    name = path.name
+    if name.endswith(".env"):
+        name = name[:-4]
+    if not name.startswith("issue-"):
+        return "", ""
+
+    payload = name[len("issue-") :]
+    if "." not in payload:
+        return payload, ""
+
+    issue_id, remainder = payload.split(".", 1)
+    remainder_parts = remainder.split(".")
+    if len(remainder_parts) >= 2:
+        return issue_id, ".".join(remainder_parts[:-1])
+    return issue_id, remainder
+
+
+def is_pending_queue_file(path: Path) -> bool:
+    return path.is_file() and path.name.startswith("issue-") and path.name.endswith(".env") and ".tmp." not in path.name
+
+
+def is_claim_queue_file(path: Path) -> bool:
+    return path.is_file() and path.name.startswith("issue-") and ".tmp." not in path.name
+
+
+def collect_queue_items(root: Path, kind: str) -> list[dict[str, Any]]:
+    if not root.is_dir():
+        return []
+
+    matcher = is_pending_queue_file if kind == "pending" else is_claim_queue_file
+    items: list[dict[str, Any]] = []
+    for path in sorted((item for item in root.iterdir() if matcher(item)), key=lambda item: item.stat().st_mtime, reverse=True):
+        env = read_env_file(path)
+        issue_id_from_name, claimer_from_name = parse_issue_queue_filename(path)
+        claim_file = env.get("CLAIM_FILE", "")
+        state_kind = env.get("STATE_KIND", "")
+        items.append(
+            {
+                "issue_id": env.get("ISSUE_ID", "") or issue_id_from_name,
+                "session": env.get("SESSION", "") or claimer_from_name,
+                "claim_file": claim_file or (str(path) if kind == "claims" else ""),
+                "queued_by": env.get("QUEUED_BY", ""),
+                "claimed_by": env.get("CLAIMED_BY", "") or claimer_from_name,
+                "state_kind": state_kind or ("claim" if kind == "claims" else "pending"),
+                "state_format_version": env.get("STATE_FORMAT_VERSION", ""),
+                "updated_at": env.get("UPDATED_AT", "") or env.get("CLAIMED_AT", "") or env.get("QUEUED_AT", "") or file_mtime_iso(path),
+                "state_file": str(path),
+            }
+        )
+    return items
+
+
+def collect_issue_queue(state_root: Path) -> dict[str, list[dict[str, Any]]]:
+    queue_root = state_root / "resident-workers" / "issue-queue"
+    return {
+        "pending": collect_queue_items(queue_root / "pending", "pending"),
+        "claims": collect_queue_items(queue_root / "claims", "claims"),
+    }

package/tools/dashboard/server.py

@@ -4,14 +4,18 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import subprocess
 from functools import partial
 from http import HTTPStatus
 from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from urllib.parse import urlparse
+from urllib.parse import urlparse, parse_qs
 
 from dashboard_snapshot import build_snapshot
 
+ROOT_DIR = Path(__file__).resolve().parents[2]
+TOOLS_BIN_DIR = ROOT_DIR / "tools" / "bin"
+
 
 DASHBOARD_DIR = Path(__file__).resolve().parent
 
@@ -31,6 +35,124 @@ class DashboardHandler(SimpleHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(encoded)
             return
+        if parsed.path == "/api/doctor":
+            query = parse_qs(parsed.query)
+            profile_id = (query.get("profile_id") or [""])[0]
+            if not profile_id:
+                self.send_response(HTTPStatus.BAD_REQUEST)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "profile_id is required"}).encode("utf-8"))
+                return
+            doctor_script = TOOLS_BIN_DIR / "flow-runtime-doctor.sh"
+            if not doctor_script.is_file():
+                self.send_response(HTTPStatus.NOT_FOUND)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "doctor script not found"}).encode("utf-8"))
+                return
+            try:
+                env = os.environ.copy()
+                env["ACP_PROJECT_ID"] = profile_id
+                output = subprocess.check_output(
+                    ["bash", str(doctor_script)],
+                    cwd=str(ROOT_DIR),
+                    env=env,
+                    text=True,
+                    stderr=subprocess.STDOUT,
+                    timeout=120,
+                )
+                payload = {"output": output}
+                encoded = json.dumps(payload).encode("utf-8")
+                self.send_response(HTTPStatus.OK)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.send_header("Content-Length", str(len(encoded)))
+                self.end_headers()
+                self.wfile.write(encoded)
+            except subprocess.TimeoutExpired:
+                self.send_response(HTTPStatus.GATEWAY_TIMEOUT)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "doctor timed out"}).encode("utf-8"))
+            except subprocess.CalledProcessError as exc:
+                payload = {"error": exc.returncode, "output": exc.output}
+                encoded = json.dumps(payload).encode("utf-8")
+                self.send_response(HTTPStatus.OK)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.send_header("Content-Length", str(len(encoded)))
+                self.end_headers()
+                self.wfile.write(encoded)
+            return
+        if parsed.path == "/api/profile/export":
+            query = parse_qs(parsed.query)
+            profile_id = (query.get("profile_id") or [""])[0]
+            if not profile_id:
+                self.send_response(HTTPStatus.BAD_REQUEST)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "profile_id is required"}).encode("utf-8"))
+                return
+            registry_root = Path(os.environ.get("ACP_PROFILE_REGISTRY_ROOT", str(Path.home() / ".agent-runtime" / "control-plane" / "profiles")))
+            profile_dir = registry_root / profile_id
+            config_file = profile_dir / "control-plane.yaml"
+            if not config_file.is_file():
+                self.send_response(HTTPStatus.NOT_FOUND)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "profile config not found"}).encode("utf-8"))
+                return
+            try:
+                config = config_file.read_text(encoding="utf-8")
+                payload = {"profile_id": profile_id, "config": config, "config_file": str(config_file)}
+                encoded = json.dumps(payload).encode("utf-8")
+                self.send_response(HTTPStatus.OK)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.send_header("Content-Length", str(len(encoded)))
+                self.end_headers()
+                self.wfile.write(encoded)
+            except Exception as exc:
+                self.send_response(HTTPStatus.INTERNAL_SERVER_ERROR)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": str(exc)}).encode("utf-8"))
+            return
+        if parsed.path == "/api/profile/import":
+            if self.command != "POST":
+                self.send_response(HTTPStatus.METHOD_NOT_ALOWED)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": "POST required"}).encode("utf-8"))
+                return
+            try:
+                content_length = int(self.headers.get("Content-Length", 0))
+                body = self.rfile.read(content_length)
+                data = json.loads(body)
+                profile_id = data.get("profile_id", "")
+                config = data.get("config", "")
+                if not profile_id or not config:
+                    self.send_response(HTTPStatus.BAD_REQUEST)
+                    self.send_header("Content-Type", "application/json")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": "profile_id and config required"}).encode("utf-8"))
+                    return
+                registry_root = Path(os.environ.get("ACP_PROFILE_REGISTRY_ROOT", str(Path.home() / ".agent-runtime" / "control-plane" / "profiles")))
+                profile_dir = registry_root / profile_id
+                config_file = profile_dir / "control-plane.yaml"
+                profile_dir.mkdir(parents=True, exist_ok=True)
+                config_file.write_text(config, encoding="utf-8")
+                payload = {"status": "ok", "profile_id": profile_id, "config_file": str(config_file)}
+                encoded = json.dumps(payload).encode("utf-8")
+                self.send_response(HTTPStatus.OK)
+                self.send_header("Content-Type", "application/json; charset=utf-8")
+                self.send_header("Content-Length", str(len(encoded)))
+                self.end_headers()
+                self.wfile.write(encoded)
+            except Exception as exc:
+                self.send_response(HTTPStatus.INTERNAL_SERVER_ERROR)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps({"error": str(exc)}).encode("utf-8"))
+            return
         return super().do_GET()
 
     def end_headers(self) -> None: