@matt82198/aesop 0.1.0-beta.5 → 0.1.0

package/tools/ci_merge_wait.py

@@ -75,7 +75,26 @@ def get_pr_status(pr_number):
 
 def check_ci_status(status_rollup):
     """
-    Analyze status check rollup.
+    Analyze status check rollup from gh pr view --json statusCheckRollup.
+    Handles both CheckRun (status + conclusion) and StatusContext (state) entries.
+
+    CheckRun classification:
+      - status=COMPLETED + conclusion in (FAILURE, CANCELLED, TIMED_OUT, ACTION_REQUIRED, STARTUP_FAILURE) = FAILURE
+      - status=COMPLETED + conclusion in (NEUTRAL, SKIPPED) or None/empty = SUCCESS (non-blocking per GitHub)
+      - status in (QUEUED, IN_PROGRESS) = PENDING
+      - status not recognized = PENDING (fail-closed)
+
+    StatusContext classification:
+      - state='success' = SUCCESS
+      - state in ('failure', 'error') = FAILURE
+      - state='pending' = PENDING
+      - state in ('neutral', 'skipped') = SUCCESS (non-blocking advisory checks)
+      - state not recognized = PENDING (fail-closed)
+
+    Unrecognized check shapes (no status/state field) = PENDING (fail-closed).
+
+    GitHub semantics: NEUTRAL and SKIPPED conclusions/states are non-blocking and do not prevent merge.
+
     Returns: ("pending", None), ("success", None), or ("failure", check_name)
     """
     if not status_rollup:
@@ -87,11 +106,53 @@ def check_ci_status(status_rollup):
     failed_checks = []
 
     for check in status_rollup:
-        status = check.get("status", "").upper()
-        if status == "PENDING":
-            pending_checks.append(check.get("name", "unknown"))
-        elif status == "FAILURE":
-            failed_checks.append(check.get("name", "unknown"))
+        check_name = check.get("name", "unknown")
+        check_status = None
+
+        # Determine check classification (CheckRun or StatusContext or unrecognized)
+        if "status" in check:
+            # CheckRun entry (has 'status' field)
+            status = check.get("status", "").upper()
+            conclusion = check.get("conclusion", "")
+
+            if status == "COMPLETED":
+                # Check conclusion for failure indicators
+                if conclusion and conclusion.upper() in ("FAILURE", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE"):
+                    check_status = "failure"
+                else:
+                    # COMPLETED with no/empty conclusion or other conclusion = success
+                    check_status = "success"
+            elif status in ("QUEUED", "IN_PROGRESS"):
+                check_status = "pending"
+            else:
+                # Unrecognized status value (fail-closed)
+                check_status = "pending"
+
+        elif "state" in check:
+            # StatusContext entry (has 'state' field)
+            state = check.get("state", "").lower()
+            if state == "success":
+                check_status = "success"
+            elif state in ("failure", "error"):
+                check_status = "failure"
+            elif state == "pending":
+                check_status = "pending"
+            elif state in ("neutral", "skipped"):
+                # Non-blocking advisory or skipped checks (GitHub semantics)
+                check_status = "success"
+            else:
+                # Unrecognized state value (fail-closed)
+                check_status = "pending"
+
+        else:
+            # Unrecognized shape (no status or state field) - fail-closed
+            check_status = "pending"
+
+        # Collect check status
+        if check_status == "failure":
+            failed_checks.append(check_name)
+        elif check_status == "pending":
+            pending_checks.append(check_name)
 
     # Determine overall status
     if failed_checks:
@@ -124,54 +185,174 @@ def merge_pr(pr_number, merge_method, dry_run=False):
 
 def run_self_test():
     """
-    Run self-test with mocked CI status checks.
-    No network calls; verifies the merge guard logic.
+    Run self-test with real GitHub API payload structures.
+    No network calls; verifies the merge guard logic with CheckRun and StatusContext payloads.
     Returns True if all tests pass, False otherwise.
     """
-    print("Running self-test with mocked CI statuses...")
+    print("Running self-test with real GitHub API payloads...")
 
-    # Mock status rollup: all checks SUCCESS
-    success_rollup = [
-        {"name": "test-unit", "status": "SUCCESS"},
-        {"name": "test-integration", "status": "SUCCESS"},
-        {"name": "lint", "status": "SUCCESS"},
+    # Test 1: CheckRun success case (COMPLETED with no conclusion)
+    checkrun_success = [
+        {"name": "test-unit", "status": "COMPLETED", "conclusion": None},
+        {"name": "test-integration", "status": "COMPLETED", "conclusion": ""},
+        {"name": "lint", "status": "COMPLETED", "conclusion": None},
     ]
-
-    # Test 1: success case
-    ci_status, failed_check = check_ci_status(success_rollup)
+    ci_status, failed_check = check_ci_status(checkrun_success)
     if ci_status != "success":
-        print(f"FAIL: Expected 'success', got '{ci_status}'")
+        print(f"FAIL: Expected 'success' for CheckRun COMPLETED, got '{ci_status}'")
         return False
-    print("[OK] success case: merge guard permits merge")
+    print("[OK] CheckRun success case (COMPLETED + no conclusion)")
 
-    # Test 2: pending case
-    pending_rollup = [
-        {"name": "test-unit", "status": "PENDING"},
-        {"name": "test-integration", "status": "SUCCESS"},
+    # Test 2: CheckRun in-progress case (should be pending)
+    checkrun_pending = [
+        {"name": "test-unit", "status": "IN_PROGRESS", "conclusion": None},
+        {"name": "test-integration", "status": "COMPLETED", "conclusion": None},
     ]
-    ci_status, failed_check = check_ci_status(pending_rollup)
+    ci_status, failed_check = check_ci_status(checkrun_pending)
     if ci_status != "pending":
-        print(f"FAIL: Expected 'pending', got '{ci_status}'")
+        print(f"FAIL: Expected 'pending' for IN_PROGRESS, got '{ci_status}'")
         return False
-    print("[OK] pending case: merge guard blocks merge (structurally unreachable)")
+    print("[OK] CheckRun pending case (IN_PROGRESS)")
 
-    # Test 3: failure case
-    failure_rollup = [
-        {"name": "test-unit", "status": "FAILURE"},
-        {"name": "test-integration", "status": "SUCCESS"},
+    # Test 3: CheckRun failure case (COMPLETED with FAILURE conclusion)
+    checkrun_failure = [
+        {"name": "test-unit", "status": "COMPLETED", "conclusion": "FAILURE"},
+        {"name": "test-integration", "status": "COMPLETED", "conclusion": None},
     ]
-    ci_status, failed_check = check_ci_status(failure_rollup)
+    ci_status, failed_check = check_ci_status(checkrun_failure)
     if ci_status != "failure" or failed_check != "test-unit":
         print(f"FAIL: Expected 'failure' with 'test-unit', got '{ci_status}' / '{failed_check}'")
         return False
-    print("[OK] failure case: merge guard blocks merge (structurally unreachable)")
+    print("[OK] CheckRun failure case (COMPLETED + FAILURE)")
 
-    # Test 4: no checks (treat as success)
+    # Test 4: StatusContext success case (state=success)
+    statuscontext_success = [
+        {"name": "continuous-integration/travis-ci/push", "state": "success"},
+    ]
+    ci_status, failed_check = check_ci_status(statuscontext_success)
+    if ci_status != "success":
+        print(f"FAIL: Expected 'success' for StatusContext state=success, got '{ci_status}'")
+        return False
+    print("[OK] StatusContext success case (state=success)")
+
+    # Test 5: StatusContext failure case (state=failure)
+    statuscontext_failure = [
+        {"name": "continuous-integration/travis-ci/push", "state": "failure"},
+    ]
+    ci_status, failed_check = check_ci_status(statuscontext_failure)
+    if ci_status != "failure" or failed_check != "continuous-integration/travis-ci/push":
+        print(f"FAIL: Expected 'failure' with StatusContext, got '{ci_status}' / '{failed_check}'")
+        return False
+    print("[OK] StatusContext failure case (state=failure)")
+
+    # Test 6: StatusContext pending case (state=pending)
+    statuscontext_pending = [
+        {"name": "continuous-integration/travis-ci/push", "state": "pending"},
+    ]
+    ci_status, failed_check = check_ci_status(statuscontext_pending)
+    if ci_status != "pending":
+        print(f"FAIL: Expected 'pending' for StatusContext state=pending, got '{ci_status}'")
+        return False
+    print("[OK] StatusContext pending case (state=pending)")
+
+    # Test 7: Mixed CheckRun and StatusContext (all success)
+    mixed_success = [
+        {"name": "test-unit", "status": "COMPLETED", "conclusion": None},
+        {"name": "travis-ci", "state": "success"},
+    ]
+    ci_status, _ = check_ci_status(mixed_success)
+    if ci_status != "success":
+        print(f"FAIL: Expected 'success' for mixed payloads, got '{ci_status}'")
+        return False
+    print("[OK] Mixed CheckRun + StatusContext success case")
+
+    # Test 8: Mixed payloads with pending (should block merge)
+    mixed_pending = [
+        {"name": "test-unit", "status": "COMPLETED", "conclusion": None},
+        {"name": "lint", "status": "QUEUED", "conclusion": None},
+    ]
+    ci_status, _ = check_ci_status(mixed_pending)
+    if ci_status != "pending":
+        print(f"FAIL: Expected 'pending' for QUEUED check, got '{ci_status}'")
+        return False
+    print("[OK] Mixed payloads with QUEUED (pending)")
+
+    # Test 9: No checks (treat as success)
     ci_status, _ = check_ci_status([])
     if ci_status != "success":
         print(f"FAIL: Expected 'success' for no checks, got '{ci_status}'")
         return False
-    print("[OK] no-checks case: treated as success")
+    print("[OK] No-checks case: treated as success")
+
+    # Test 10: Unrecognized shape (fail-closed: should not succeed)
+    unrecognized = [
+        {"name": "mystery-check"},
+    ]
+    ci_status, _ = check_ci_status(unrecognized)
+    if ci_status == "success":
+        print(f"FAIL: Expected not 'success' for unrecognized shape, got '{ci_status}'")
+        return False
+    print("[OK] Unrecognized check shape (fail-closed)")
+
+    # Test 11: CheckRun cancelled (counts as failure)
+    cancelled_check = [
+        {"name": "test-unit", "status": "COMPLETED", "conclusion": "CANCELLED"},
+    ]
+    ci_status, _ = check_ci_status(cancelled_check)
+    if ci_status != "failure":
+        print(f"FAIL: Expected 'failure' for CANCELLED, got '{ci_status}'")
+        return False
+    print("[OK] CheckRun CANCELLED (failure)")
+
+    # Test 12: CheckRun neutral conclusion (non-blocking advisory, should be success)
+    neutral_check = [
+        {"name": "advisory-lint", "status": "COMPLETED", "conclusion": "NEUTRAL"},
+    ]
+    ci_status, _ = check_ci_status(neutral_check)
+    if ci_status != "success":
+        print(f"FAIL: Expected 'success' for NEUTRAL conclusion, got '{ci_status}'")
+        return False
+    print("[OK] CheckRun NEUTRAL conclusion (success, non-blocking)")
+
+    # Test 13: CheckRun skipped conclusion (non-blocking, should be success)
+    skipped_check = [
+        {"name": "optional-test", "status": "COMPLETED", "conclusion": "SKIPPED"},
+    ]
+    ci_status, _ = check_ci_status(skipped_check)
+    if ci_status != "success":
+        print(f"FAIL: Expected 'success' for SKIPPED conclusion, got '{ci_status}'")
+        return False
+    print("[OK] CheckRun SKIPPED conclusion (success, non-blocking)")
+
+    # Test 14: StatusContext neutral state (non-blocking advisory, should be success)
+    neutral_state = [
+        {"name": "advisory-check", "state": "neutral"},
+    ]
+    ci_status, _ = check_ci_status(neutral_state)
+    if ci_status != "success":
+        print(f"FAIL: Expected 'success' for StatusContext state=neutral, got '{ci_status}'")
+        return False
+    print("[OK] StatusContext neutral state (success, non-blocking)")
+
+    # Test 15: StatusContext skipped state (non-blocking, should be success)
+    skipped_state = [
+        {"name": "optional-check", "state": "skipped"},
+    ]
+    ci_status, _ = check_ci_status(skipped_state)
+    if ci_status != "success":
+        print(f"FAIL: Expected 'success' for StatusContext state=skipped, got '{ci_status}'")
+        return False
+    print("[OK] StatusContext skipped state (success, non-blocking)")
+
+    # Test 16: Fabricated unknown state (fail-closed to pending)
+    unknown_state = [
+        {"name": "mystery-state", "state": "fabricated_unknown_state"},
+    ]
+    ci_status, _ = check_ci_status(unknown_state)
+    if ci_status != "pending":
+        print(f"FAIL: Expected 'pending' for unknown state, got '{ci_status}'")
+        return False
+    print("[OK] Fabricated unknown state (pending, fail-closed)")
 
     print("\nAll self-tests passed!")
     return True

package/tools/common.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Common utilities shared across tools.
+
+Functions:
+  get_state_dir() -> Path
+    Resolve state directory from AESOP_STATE_ROOT env var or default to ./state
+
+  check_heartbeat_staleness(hb_file, threshold_s) -> (is_stale, age_s, info)
+    Check if a heartbeat file is stale and return staleness, age, and descriptive info
+"""
+
+import os
+import time
+from pathlib import Path
+
+
+def get_state_dir():
+    """Resolve state directory from env var or current working directory.
+
+    Returns:
+        Path: Directory path for state files. Either from AESOP_STATE_ROOT env var
+              or defaults to ./state relative to cwd.
+    """
+    if os.environ.get("AESOP_STATE_ROOT"):
+        return Path(os.environ["AESOP_STATE_ROOT"])
+    # Default to ./state (relative to cwd)
+    return Path.cwd() / "state"
+
+
+def check_heartbeat_staleness(hb_file, threshold_s):
+    """Check if a heartbeat file is stale.
+
+    Args:
+        hb_file: Path to heartbeat file (contains epoch timestamp as first line)
+        threshold_s: Staleness threshold in seconds; age >= threshold is stale
+
+    Returns:
+        Tuple of (is_stale, age_s, info):
+          is_stale (bool): True if file missing, unreadable, or age >= threshold_s
+          age_s (int): Age in seconds (0 if file missing/unreadable)
+          info (str or None): Descriptive message if stale/missing, None if fresh
+    """
+    if not hb_file.exists():
+        return True, 0, "Heartbeat file missing"
+
+    try:
+        content = hb_file.read_text(encoding="utf-8").strip()
+        if not content:
+            return True, 0, "Heartbeat file empty"
+
+        timestamp = int(content)
+    except (ValueError, IOError):
+        return True, 0, "Heartbeat file unreadable"
+
+    age_seconds = int(time.time()) - timestamp
+    age_seconds = max(0, age_seconds)  # Never negative
+
+    if age_seconds >= threshold_s:
+        return True, age_seconds, f"Heartbeat stale ({age_seconds}s >= {threshold_s}s)"
+
+    return False, age_seconds, None

package/tools/cost_ceiling.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Cost ceiling guard — trips tools/halt.py's kill switch when fleet spend
+(tokens) meets or exceeds a configured ceiling.
+
+Why: wave-26 critique — autonomy expanded to self-merging portfolio PRs on
+green with no ceiling/cap/limit/abort anywhere in the harness. This is the cap.
+
+Configuration (aesop.config.json):
+  "limits": {
+    "max_wave_tokens": null,   # null = disabled (opt-in)
+    "max_daily_tokens": null
+  }
+
+Spend source: an explicit --spent/spent= figure always wins. Otherwise spend
+is read from the cost ledger (tools/fleet_ledger.py's OUTCOMES-LEDGER.md under
+the resolved state dir): sum of tokens_in + tokens_out across all ledger rows.
+Missing/unreadable ledger -> spend of 0 (never trips on a ledger that doesn't
+exist yet).
+
+API:
+  check(spent=None, period="wave", config=None, state_dir=None, trip=True) -> dict
+    Returns {"period", "ceiling", "spent", "exceeded", "tripped"}.
+    When exceeded and trip=True, calls tools/halt.py's halt() with a reason
+    describing the breach, and "tripped" is True. When ceiling is None
+    (unconfigured), exceeded is always False and nothing is ever tripped.
+
+CLI:
+  python tools/cost_ceiling.py --check --spent N [--period wave|daily]
+    Exit 0 if not exceeded (or ceiling unconfigured), exit 1 if exceeded
+    (and thus tripped, unless already halted).
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from datetime import datetime, timezone
+
+try:
+    import halt
+    import fleet_ledger
+except ImportError:
+    from tools import halt
+    from tools import fleet_ledger
+
+
+def load_config():
+    """Load aesop.config.json from current directory, return dict (or {} if absent/bad)."""
+    config_file = Path("aesop.config.json")
+    if not config_file.exists():
+        return {}
+    try:
+        with open(config_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"[cost_ceiling] Failed to load config: {e}", file=sys.stderr)
+        return {}
+
+
+def get_ceiling(config, period):
+    """Extract the configured ceiling for `period` ('wave' or 'daily'), or None."""
+    limits = config.get("limits", {}) if isinstance(config, dict) else {}
+    if not isinstance(limits, dict):
+        return None
+    key = f"max_{period}_tokens"
+    value = limits.get(key)
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def read_ledger_total_tokens(state_dir, period="wave"):
+    """Sum tokens_in + tokens_out from OUTCOMES-LEDGER.md.
+
+    Args:
+        state_dir: path to state directory
+        period: "wave" (all rows) or "daily" (today's rows only, filtered by UTC date)
+
+    Returns 0 if the ledger doesn't exist or is unreadable/empty.
+    Uses fleet_ledger.py's shared parser (single source of truth).
+    """
+    # Set the state root temporarily so fleet_ledger can find the ledger
+    import os
+    old_state_root = os.environ.get("AESOP_STATE_ROOT")
+    try:
+        os.environ["AESOP_STATE_ROOT"] = str(state_dir)
+        rows = fleet_ledger.parse_ledger_rows()
+    finally:
+        if old_state_root is not None:
+            os.environ["AESOP_STATE_ROOT"] = old_state_root
+        else:
+            os.environ.pop("AESOP_STATE_ROOT", None)
+
+    if not rows:
+        return 0
+
+    total = 0
+
+    if period == "daily":
+        # Filter to today's UTC date only
+        today_utc = datetime.now(timezone.utc).date()
+        for row in rows:
+            # Extract date from ISO timestamp (format: YYYY-MM-DDTHH:MM:SSZ or similar)
+            try:
+                iso_ts = row['iso_ts']
+                # Parse the date part (first 10 characters: YYYY-MM-DD)
+                row_date = datetime.fromisoformat(iso_ts.replace('Z', '+00:00')).date()
+                if row_date == today_utc:
+                    total += row['tokens_in'] + row['tokens_out']
+            except (ValueError, IndexError, KeyError):
+                # Skip malformed timestamps
+                continue
+    else:
+        # period == "wave": sum all rows
+        for row in rows:
+            total += row['tokens_in'] + row['tokens_out']
+
+    return total
+
+
+def check(spent=None, period="wave", config=None, state_dir=None, trip=True):
+    """Check spend against the configured ceiling for `period`.
+
+    Returns a dict: {"period", "ceiling", "spent", "exceeded", "tripped"}.
+    """
+    if config is None:
+        config = load_config()
+    if state_dir is None:
+        state_dir = halt.resolve_state_dir(config=config)
+    state_dir = Path(state_dir)
+
+    ceiling = get_ceiling(config, period)
+
+    if spent is None:
+        spent = read_ledger_total_tokens(state_dir, period=period)
+    spent = int(spent)
+
+    exceeded = ceiling is not None and spent >= ceiling
+    tripped = False
+
+    if exceeded and trip:
+        reason = (
+            f"cost ceiling exceeded: {period} spend {spent} tokens >= "
+            f"ceiling {ceiling} tokens"
+        )
+        halt.halt(reason, state_dir=state_dir)
+        tripped = True
+
+    return {
+        "period": period,
+        "ceiling": ceiling,
+        "spent": spent,
+        "exceeded": exceeded,
+        "tripped": tripped,
+    }
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description="Cost ceiling guard for the fleet kill switch.")
+    parser.add_argument("--check", action="store_true", help="Run the ceiling check (required).")
+    parser.add_argument("--spent", type=int, default=None, help="Explicit spend figure in tokens; defaults to ledger total.")
+    parser.add_argument("--period", choices=("wave", "daily"), default="wave", help="Which ceiling to check against (default: wave).")
+    args = parser.parse_args(argv)
+
+    if not args.check:
+        parser.print_usage(sys.stderr)
+        return 2
+
+    result = check(spent=args.spent, period=args.period)
+
+    if result["ceiling"] is None:
+        print(f"[cost_ceiling] no {args.period} ceiling configured — skipping (spent={result['spent']})")
+        return 0
+
+    if result["exceeded"]:
+        print(
+            f"[cost_ceiling] EXCEEDED: {args.period} spend {result['spent']} >= "
+            f"ceiling {result['ceiling']} — HALT tripped"
+        )
+        return 1
+
+    print(f"[cost_ceiling] ok: {args.period} spend {result['spent']} < ceiling {result['ceiling']}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/dash.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+/**
+ * Aesop dash — Launch the web dashboard
+ *
+ * Spawns python ui/serve.py with the configured port.
+ * Honors PORT environment variable, aesop.config.json dashboard.port, or defaults to 8770.
+ * Prints the dashboard URL before launching.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, spawnSync } = require('child_process');
+
+const CURRENT_DIR = process.cwd();
+
+// Resolve Python interpreter portably (prefer python3, fallback to python)
+function resolvePythonInterpreter() {
+  if (spawnSync('python3', ['--version'], { stdio: 'ignore' }).error === undefined) {
+    return 'python3';
+  }
+  if (spawnSync('python', ['--version'], { stdio: 'ignore' }).error === undefined) {
+    return 'python';
+  }
+  return null;
+}
+
+function loadConfig() {
+  const configPath = path.join(CURRENT_DIR, 'aesop.config.json');
+  try {
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch (e) {
+    return null;
+  }
+}
+
+(async function main() {
+  try {
+    // Verify dashboard script exists
+    const dashScript = path.join(CURRENT_DIR, 'ui', 'serve.py');
+    if (!fs.existsSync(dashScript)) {
+      console.error(`Error: dashboard script not found at ${dashScript}`);
+      console.error('Are you running this from the aesop root directory?');
+      process.exitCode = 1;
+      return;
+    }
+
+    // Determine port: env var > config > default
+    let port = 8770;
+
+    if (process.env.PORT) {
+      const envPort = parseInt(process.env.PORT, 10);
+      if (!isNaN(envPort) && envPort > 0 && envPort < 65536) {
+        port = envPort;
+      }
+    } else {
+      const config = loadConfig();
+      if (config && config.dashboard && config.dashboard.port) {
+        const configPort = parseInt(config.dashboard.port, 10);
+        if (!isNaN(configPort) && configPort > 0 && configPort < 65536) {
+          port = configPort;
+        }
+      }
+    }
+
+    console.log(`Launching aesop dashboard on http://localhost:${port}\n`);
+
+    // Resolve Python interpreter
+    const pythonExe = resolvePythonInterpreter();
+    if (!pythonExe) {
+      console.error('Error: python3 or python not found on PATH');
+      console.error('Please install Python 3 to run the dashboard');
+      process.exitCode = 1;
+      return;
+    }
+
+    // Spawn the dashboard script with PORT env var set
+    const proc = spawn(pythonExe, [dashScript], {
+      cwd: CURRENT_DIR,
+      stdio: 'inherit',
+      env: { ...process.env, PORT: port.toString() },
+      shell: process.platform === 'win32'
+    });
+
+    // Exit with the dashboard process's exit code
+    proc.on('exit', (code) => {
+      process.exitCode = code || 0;
+    });
+
+    proc.on('error', (err) => {
+      console.error(`Error spawning dashboard: ${err.message}`);
+      process.exitCode = 1;
+    });
+  } catch (err) {
+    console.error(`Error launching dashboard: ${err.message}`);
+    process.exitCode = 1;
+  }
+})();