agent-control-plane 0.4.9 → 0.6.0

package/tools/dashboard/app.js

@@ -72,6 +72,35 @@ function relativeTime(input) {
   return seconds >= 0 ? `${absolute}s ago` : `in ${absolute}s`;
 }
 
+function formatDuration(seconds) {
+  if (!seconds && seconds !== 0) return "n/a";
+  const absSeconds = Math.abs(seconds);
+  const parts = [];
+  const units = [
+    [86400, "d"],
+    [3600, "h"],
+    [60, "m"],
+    [1, "s"],
+  ];
+  for (const [unitSeconds, label] of units) {
+    if (absSeconds >= unitSeconds) {
+      const amount = Math.floor(absSeconds / unitSeconds);
+      parts.push(`${amount}${label}`);
+      seconds -= amount * unitSeconds;
+    }
+  }
+  return parts.slice(0, 2).join(" ") || "0s";
+}
+
+function timeRemaining(isoString) {
+  if (!isoString) return "n/a";
+  const next = new Date(isoString);
+  if (Number.isNaN(next.getTime())) return isoString;
+  const diffSeconds = Math.round((next.getTime() - Date.now()) / 1000);
+  if (diffSeconds <= 0) return "ready now";
+  return formatDuration(diffSeconds);
+}
+
 function statusClass(status) {
   if (!status) return "";
   return status.replace(/[^a-zA-Z0-9_-]/g, "-");
@@ -129,6 +158,8 @@ function renderOverview(snapshot) {
     ["Pending GitHub Writes", totals.pendingGithubWrites],
     ["Alerts", totals.alerts],
     ["Queued Issues", totals.queue],
+    ["Retries", totals.retries || 0],
+    ["Blockers", totals.blockers || 0],
   ]
     .map(
       ([label, value]) => `
@@ -256,6 +287,23 @@ function renderProfile(profile) {
     )
     .join("");
 
+  const runsFilterState = window._acpRunsFilter || { search: "", status: "all" };
+  window._acpRunsFilter = runsFilterState;
+
+  const filteredRuns = profile.runs.filter((row) => {
+    if (runsFilterState.status !== "all" && row.status !== runsFilterState.status) return false;
+    if (runsFilterState.search) {
+      const q = runsFilterState.search.toLowerCase();
+      return (
+        (row.session || "").toLowerCase().includes(q) ||
+        (row.coding_worker || "").toLowerCase().includes(q) ||
+        (row.task_kind || "").toLowerCase().includes(q) ||
+        (row.task_id || "").toLowerCase().includes(q)
+      );
+    }
+    return true;
+  });
+
   const runsTable = renderTable(
     [
       { label: "Session", render: (row) => `<div class="mono">${row.session}</div>` },
@@ -266,10 +314,26 @@ function renderProfile(profile) {
       { label: "Result", render: renderResult },
       { label: "Updated", render: (row) => row.updated_at ? `${relativeTime(row.updated_at)}<div class="muted">${row.updated_at}</div>` : "n/a" },
     ],
-    profile.runs,
+    filteredRuns,
     "No active run directories for this profile.",
   );
 
+  const historyFilterState = window._acpHistoryFilter || { search: "", result: "all" };
+  window._acpHistoryFilter = historyFilterState;
+
+  const filteredHistory = (profile.recent_history || []).filter((row) => {
+    if (historyFilterState.result !== "all" && row.result_kind !== historyFilterState.result) return false;
+    if (historyFilterState.search) {
+      const q = historyFilterState.search.toLowerCase();
+      return (
+        (row.session || "").toLowerCase().includes(q) ||
+        (row.coding_worker || "").toLowerCase().includes(q) ||
+        (row.task_kind || "").toLowerCase().includes(q)
+      );
+    }
+    return true;
+  });
+
   const recentHistoryTable = renderTable(
     [
       { label: "Session", render: (row) => `<div class="mono">${row.session}</div>` },
@@ -279,7 +343,7 @@ function renderProfile(profile) {
       { label: "Result", render: renderResult },
       { label: "Updated", render: (row) => row.updated_at ? `${relativeTime(row.updated_at)}<div class="muted">${row.updated_at}</div>` : "n/a" },
     ],
-    profile.recent_history || [],
+    filteredHistory,
     "No recently archived runs.",
   );
 
@@ -305,6 +369,7 @@ function renderProfile(profile) {
       { label: "Reason", render: (row) => row.last_reason || "n/a" },
       { label: "Attempts", key: "attempts" },
       { label: "Next attempt", render: (row) => row.next_attempt_at ? `${relativeTime(row.next_attempt_at)}<div class="muted">${row.next_attempt_at}</div>` : "n/a" },
+      { label: "Time Remaining", render: (row) => row.next_attempt_at ? timeRemaining(row.next_attempt_at) : "n/a" },
     ],
     profile.issue_retries || [],
     "No issue retries recorded.",
@@ -317,6 +382,7 @@ function renderProfile(profile) {
       { label: "Reason", render: (row) => row.last_reason || "n/a" },
       { label: "Attempts", key: "attempts" },
       { label: "Next attempt", render: (row) => row.next_attempt_at ? `${relativeTime(row.next_attempt_at)}<div class="muted">${row.next_attempt_at}</div>` : "n/a" },
+      { label: "Time Remaining", render: (row) => row.next_attempt_at ? timeRemaining(row.next_attempt_at) : "n/a" },
     ],
     profile.pr_retries || [],
     "No PR retries recorded.",
@@ -344,6 +410,7 @@ function renderProfile(profile) {
       { label: "Reason", render: (row) => row.last_reason || "n/a" },
       { label: "Attempts", key: "attempts" },
       { label: "Next attempt", render: (row) => row.next_attempt_at ? `${relativeTime(row.next_attempt_at)}<div class="muted">${row.next_attempt_at}</div>` : "n/a" },
+      { label: "Time Remaining", render: (row) => row.next_attempt_at ? timeRemaining(row.next_attempt_at) : "n/a" },
     ],
     profile.provider_cooldowns,
     "No provider cooldowns recorded.",
@@ -354,6 +421,7 @@ function renderProfile(profile) {
       { label: "Issue", key: "issue_id" },
       { label: "Interval", render: (row) => `${row.interval_seconds}s` },
       { label: "Next due", render: (row) => row.next_due_at ? `${relativeTime(row.next_due_at)}<div class="muted">${row.next_due_at}</div>` : "n/a" },
+      { label: "Time Remaining", render: (row) => row.next_due_at ? timeRemaining(row.next_due_at) : "n/a" },
       { label: "Last started", render: (row) => row.last_started_at ? `${relativeTime(row.last_started_at)}<div class="muted">${row.last_started_at}</div>` : "n/a" },
     ],
     profile.scheduled_issues,
@@ -413,6 +481,28 @@ function renderProfile(profile) {
       `
       : "";
 
+  const runsFilterBar = `
+    <div class="filter-bar">
+      <input type="text" class="filter-search" placeholder="Search runs..." value="${runsFilterState.search}"
+        oninput="window._acpRunsFilter.search=this.value; rerenderAll();" />
+      <button class="filter-btn ${runsFilterState.status === 'all' ? 'active' : ''}" onclick="window._acpRunsFilter.status='all'; rerenderAll();">All</button>
+      <button class="filter-btn ${runsFilterState.status === 'RUNNING' ? 'active' : ''}" onclick="window._acpRunsFilter.status='RUNNING'; rerenderAll();">Running</button>
+      <button class="filter-btn ${runsFilterState.status === 'SUCCEEDED' ? 'active' : ''}" onclick="window._acpRunsFilter.status='SUCCEEDED'; rerenderAll();">Completed</button>
+      <button class="filter-btn ${runsFilterState.status === 'FAILED' ? 'active' : ''}" onclick="window._acpRunsFilter.status='FAILED'; rerenderAll();">Failed</button>
+    </div>
+  `;
+
+  const historyFilterBar = `
+    <div class="filter-bar">
+      <input type="text" class="filter-search" placeholder="Search history..." value="${historyFilterState.search}"
+        oninput="window._acpHistoryFilter.search=this.value; rerenderAll();" />
+      <button class="filter-btn ${historyFilterState.result === 'all' ? 'active' : ''}" onclick="window._acpHistoryFilter.result='all'; rerenderAll();">All</button>
+      <button class="filter-btn ${historyFilterState.result === 'implemented' ? 'active' : ''}" onclick="window._acpHistoryFilter.result='implemented'; rerenderAll();">Implemented</button>
+      <button class="filter-btn ${historyFilterState.result === 'reported' ? 'active' : ''}" onclick="window._acpHistoryFilter.result='reported'; rerenderAll();">Reported</button>
+      <button class="filter-btn ${historyFilterState.result === 'blocked' ? 'active' : ''}" onclick="window._acpHistoryFilter.result='blocked'; rerenderAll();">Blocked</button>
+    </div>
+  `;
+
   return `
     <article class="profile">
       <header class="profile-header">
@@ -435,11 +525,13 @@ function renderProfile(profile) {
         <section class="panel">
           <h3>Active Runs</h3>
           <p class="panel-subtitle">Lifecycle shows technical session completion. Result shows what the run achieved: implemented, reported, or blocked.</p>
+          ${runsFilterBar}
           ${runsTable}
         </section>
         <section class="panel">
           <h3>Recent Completed Runs</h3>
           <p class="panel-subtitle">Recently archived runs so they do not disappear from the dashboard immediately after completion.</p>
+          ${historyFilterBar}
           ${recentHistoryTable}
         </section>
         <section class="panel">
@@ -460,6 +552,18 @@ function renderProfile(profile) {
           <h3>Resident Worker Metadata</h3>
           ${workerTable}
         </section>
+        <section class="panel">
+          <h3>Troubleshooting</h3>
+          <p class="panel-subtitle">Run diagnostics or debugging tools against this live profile.</p>
+          <div class="action-bar">
+            <button class="action-btn" onclick="runDoctor('${profile.id}')">Run Doctor</button>
+            <button class="action-btn" onclick="exportProfile('${profile.id}')">Export Profile</button>
+            <button class="action-btn" onclick="document.getElementById('import-file-${profile.id}').click()">Import Profile</button>
+            <input type="file" id="import-file-${profile.id}" style="display:none" accept=".json" onchange="importProfile('${profile.id}', this)">
+            <span id="doctor-status-${profile.id}"></span>
+          </div>
+          <pre id="doctor-output-${profile.id}" class="doctor-output" style="display:none;"></pre>
+        </section>
         <section class="panel half">
           <h3>Provider Cooldowns</h3>
           ${cooldownTable}
@@ -523,9 +627,8 @@ async function loadSnapshot() {
       throw new Error(`Snapshot request failed with ${response.status}`);
     }
     const snapshot = await response.json();
-    generatedAtNode.textContent = `Snapshot: ${snapshot.generated_at}`;
-    renderOverview(snapshot);
-    profilesNode.innerHTML = snapshot.profiles.map(renderProfile).join("");
+    window._acpSnapshot = snapshot;
+    renderFromSnapshot(snapshot);
     await maybeNotifyAlerts(snapshot);
   } catch (error) {
     generatedAtNode.textContent = `Snapshot load failed: ${error.message}`;
@@ -535,6 +638,96 @@ async function loadSnapshot() {
   }
 }
 
+function renderFromSnapshot(snapshot) {
+  generatedAtNode.textContent = `Snapshot: ${snapshot.generated_at}`;
+  renderOverview(snapshot);
+  profilesNode.innerHTML = snapshot.profiles.map(renderProfile).join("");
+}
+
+function rerenderAll() {
+  const snapshot = window._acpSnapshot;
+  if (!snapshot) return;
+  renderFromSnapshot(snapshot);
+}
+
+async function runDoctor(profileId) {
+  const statusEl = document.getElementById(`doctor-status-${profileId}`);
+  const outputEl = document.getElementById(`doctor-output-${profileId}`);
+  if (statusEl) statusEl.textContent = "Running...";
+  if (outputEl) {
+    outputEl.style.display = "none";
+    outputEl.textContent = "";
+  }
+  try {
+    const response = await fetch(`/api/doctor?profile_id=${encodeURIComponent(profileId)}`, { cache: "no-store" });
+    const data = await response.json();
+    if (statusEl) statusEl.textContent = response.ok ? "Done" : `Error: ${data.error || response.status}`;
+    if (outputEl) {
+      outputEl.style.display = "block";
+      outputEl.textContent = data.output || data.error || "No output";
+    }
+  } catch (error) {
+    if (statusEl) statusEl.textContent = `Error: ${error.message}`;
+  }
+}
+
+async function exportProfile(profileId) {
+  try {
+    const response = await fetch(`/api/profile/export?profile_id=${encodeURIComponent(profileId)}`, { cache: "no-store" });
+    if (!response.ok) {
+      const data = await response.json();
+      alert(`Export failed: ${data.error || response.status}`);
+      return;
+    }
+    const data = await response.json();
+    const blob = new Blob([JSON.stringify(data, null, 2)], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `acp-profile-${profileId}.json`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  } catch (error) {
+    alert(`Export failed: ${error.message}`);
+  }
+}
+
+async function importProfile(profileId, inputEl) {
+  const file = inputEl.files[0];
+  if (!file) return;
+  
+  try {
+    const text = await file.text();
+    const data = JSON.parse(text);
+    
+    if (!data.profile_id || !data.config) {
+      alert("Invalid profile file: missing profile_id or config");
+      return;
+    }
+    
+    const response = await fetch("/api/profile/import", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    });
+    
+    const result = await response.json();
+    if (response.ok) {
+      alert(`Profile ${profileId} imported successfully!`);
+      // Refresh the page to show imported profile
+      setTimeout(() => window.location.reload(), 1000);
+    } else {
+      alert(`Import failed: ${result.error || response.status}`);
+    }
+  } catch (error) {
+    alert(`Import failed: ${error.message}`);
+  } finally {
+    inputEl.value = "";
+  }
+}
+
 refreshButton.addEventListener("click", () => {
   void loadSnapshot();
 });

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: