fleet-framework 0.1.0__py3-none-any.whl

fleet/master/broadcaster.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from collections import defaultdict
+from typing import Any
+
+from fastapi import WebSocket
+
+logger = logging.getLogger(__name__)
+
+
+class Broadcaster:
+    # in-memory worker_id -> set[WebSocket]. one WS per (automation_type, worker_id).
+    # used to push ConfigChanged frames after a PATCH.
+    def __init__(self) -> None:
+        self._sockets: dict[tuple[str, str], set[WebSocket]] = defaultdict(set)
+        self._lock = asyncio.Lock()
+
+    async def attach(self, automation_type: str, worker_id: str, ws: WebSocket) -> None:
+        async with self._lock:
+            self._sockets[(automation_type, worker_id)].add(ws)
+
+    async def detach(self, automation_type: str, worker_id: str, ws: WebSocket) -> None:
+        async with self._lock:
+            self._sockets.get((automation_type, worker_id), set()).discard(ws)
+
+    async def publish(self, automation_type: str, worker_id: str, frame: dict[str, Any]) -> None:
+        payload = json.dumps(frame)
+        async with self._lock:
+            socks = list(self._sockets.get((automation_type, worker_id), set()))
+        for ws in socks:
+            try:
+                await ws.send_text(payload)
+            except Exception:
+                logger.debug("ws send failed for %s/%s", automation_type, worker_id)

fleet/master/dashboard/__init__.py

@@ -0,0 +1,4 @@
+# dashboard templates + static + router lives here.
+from fleet.master.dashboard.router import make_dashboard_router
+
+__all__ = ["make_dashboard_router"]

fleet/master/dashboard/router.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+from fleet.core.automation import get_registry
+
+_HERE = Path(__file__).parent
+
+
+def make_dashboard_router() -> APIRouter:
+    router = APIRouter()
+    templates = Jinja2Templates(directory=str(_HERE / "templates"))
+
+    @router.get("/", response_class=HTMLResponse)
+    async def index(request: Request) -> HTMLResponse:
+        reg = get_registry()
+        automations = [
+            {
+                "type": name,
+                "class": cls.__name__,
+                "kind": cls.__mro__[1].__name__,
+                "schema": cls.Config.model_json_schema(),
+            }
+            for name, cls in reg.items()
+        ]
+        return templates.TemplateResponse(
+            request, "index.html", {"automations": automations}
+        )
+
+    router.mount("/static", StaticFiles(directory=str(_HERE / "static")), name="static")
+    return router

fleet/master/dashboard/static/style.css

@@ -0,0 +1,97 @@
+:root {
+  --bg: #0f0f10;
+  --fg: #e5e5e5;
+  --muted: #8a8a8a;
+  --accent: #f7931a;
+  --line: #2a2a2a;
+  --panel: #181819;
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0; padding: 2rem;
+  background: var(--bg); color: var(--fg);
+  font: 14px/1.5 -apple-system, ui-sans-serif, system-ui, sans-serif;
+}
+header { margin-bottom: 1.5rem; }
+h1 { margin: 0; font-size: 1.3rem; color: var(--accent); }
+.muted { color: var(--muted); }
+.tabs { display: flex; gap: 0.25rem; border-bottom: 1px solid var(--line); margin-bottom: 1rem; }
+.tab {
+  background: transparent; color: var(--muted);
+  border: 0; border-bottom: 2px solid transparent;
+  padding: 0.5rem 1rem; cursor: pointer; font: inherit;
+}
+.tab:hover { color: var(--fg); }
+.tab.active { color: var(--accent); border-bottom-color: var(--accent); }
+.pane { padding: 1rem 0; }
+h2 { font-size: 1rem; margin: 0 0 1rem 0; }
+h3 { font-size: 0.85rem; color: var(--muted); margin: 1.5rem 0 0.5rem; text-transform: uppercase; letter-spacing: 0.05em; }
+table { width: 100%; border-collapse: collapse; }
+th, td { text-align: left; padding: 0.5rem; border-bottom: 1px solid var(--line); font-variant-numeric: tabular-nums; }
+th { color: var(--muted); font-weight: 500; font-size: 0.8rem; text-transform: uppercase; }
+pre.schema { background: var(--panel); padding: 1rem; border-radius: 6px; overflow: auto; font-size: 12px; }
+
+.graph-wrap {
+  background: var(--panel); padding: 1rem; border-radius: 6px;
+  overflow: auto; max-height: 75vh;
+}
+.graph-wrap svg { max-width: 100%; height: auto; }
+.submit-form { background: var(--panel); padding: 1rem; border-radius: 6px; }
+.task-form .fields {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(220px, 1fr));
+  gap: 0.5rem 1rem;
+  margin-bottom: 0.75rem;
+}
+.task-form label {
+  display: flex; flex-direction: column;
+  font-size: 0.8rem; color: var(--muted);
+  gap: 0.25rem;
+}
+.task-form label.bool { flex-direction: row; align-items: center; }
+.task-form input[type="text"],
+.task-form input[type="number"],
+.task-form select,
+.task-form textarea {
+  background: var(--bg); color: var(--fg);
+  border: 1px solid var(--line); border-radius: 4px;
+  padding: 0.4rem 0.5rem; font: inherit;
+}
+.task-form input:focus, .task-form select:focus, .task-form textarea:focus {
+  outline: none; border-color: var(--accent);
+}
+.task-form button {
+  background: var(--accent); color: #111;
+  border: 0; border-radius: 4px; padding: 0.5rem 1rem;
+  font-weight: 600; cursor: pointer;
+}
+.task-form button:hover { filter: brightness(1.1); }
+.task-form .submit-result {
+  margin-top: 0.75rem; padding: 0.5rem;
+  background: var(--bg); border-radius: 4px; font-size: 12px;
+  min-height: 1.2em; white-space: pre-wrap;
+}
+.task-form details.advanced { margin: 0.5rem 0; }
+.task-form details.advanced summary {
+  cursor: pointer; color: var(--muted); font-size: 0.8rem;
+  padding: 0.25rem 0;
+}
+
+.inspector { background: var(--panel); padding: 0.75rem; border-radius: 6px; }
+.inspector button {
+  background: transparent; color: var(--muted);
+  border: 1px solid var(--line); border-radius: 4px;
+  padding: 0.25rem 0.6rem; font: inherit; cursor: pointer;
+  margin-right: 0.4rem;
+}
+.inspector button:hover { color: var(--fg); border-color: var(--accent); }
+.inspector button.danger { color: #ff7070; }
+.inspector button.danger:hover { border-color: #ff7070; }
+.inspector pre {
+  margin: 0.5rem 0 0; padding: 0.5rem;
+  background: var(--bg); border-radius: 4px; font-size: 12px;
+  max-height: 240px; overflow: auto; white-space: pre-wrap;
+}
+.pool-card { padding: 0.5rem 0; border-bottom: 1px solid var(--line); }
+.pool-card:last-child { border-bottom: 0; }
+.pool-card strong { color: var(--fg); margin-right: 0.5rem; }

fleet/master/dashboard/templates/index.html

@@ -0,0 +1,372 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>fleet</title>
+  <link rel="stylesheet" href="/static/style.css" />
+</head>
+<body>
+  <header>
+    <h1>fleet</h1>
+    <p class="muted">
+      {{ automations|length }} automation{{ '' if automations|length == 1 else 's' }} installed
+    </p>
+  </header>
+
+  <nav class="tabs" id="tabs">
+    <button class="tab" data-type="__graph">graph</button>
+    {% for a in automations %}
+      <button class="tab" data-type="{{ a.type }}">{{ a.type }}</button>
+    {% endfor %}
+  </nav>
+
+  <main id="panes">
+    <section class="pane" data-type="__graph" hidden>
+      <h2>contracts <span class="muted">(catalog DAG)</span></h2>
+      <div class="graph-wrap"><div id="graph" class="mermaid">loading…</div></div>
+    </section>
+    {% for a in automations %}
+      <section class="pane" data-type="{{ a.type }}" hidden>
+        <h2>{{ a.type }} <span class="muted">({{ a.kind }})</span></h2>
+        <div class="workers" id="workers-{{ a.type }}">loading…</div>
+
+        <h3>submit task</h3>
+        <div class="submit-form" id="submit-{{ a.type }}">
+          <p class="muted">loading schema…</p>
+        </div>
+
+        <h3>queue</h3>
+        <div class="inspector" id="queue-{{ a.type }}">
+          <button class="refresh">refresh</button>
+          <pre class="muted">loading…</pre>
+        </div>
+
+        <h3>dead-letter queue</h3>
+        <div class="inspector" id="dlq-{{ a.type }}">
+          <button class="refresh">refresh</button>
+          <button class="danger">drain</button>
+          <pre class="muted">loading…</pre>
+        </div>
+
+        <h3>pools</h3>
+        <div class="inspector" id="pools-{{ a.type }}">loading…</div>
+
+        <h3>config schema</h3>
+        <pre class="schema">{{ a.schema | tojson(indent=2) }}</pre>
+      </section>
+    {% endfor %}
+  </main>
+
+  <script type="module">
+    import mermaid from "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";
+    mermaid.initialize({ startOnLoad: false, theme: "dark", securityLevel: "strict" });
+    window.__mermaid = mermaid;
+  </script>
+  <script>
+    const ADMIN_TOKEN = localStorage.getItem('admin_token') || prompt('admin token:');
+    if (ADMIN_TOKEN) localStorage.setItem('admin_token', ADMIN_TOKEN);
+    const AUTH = { 'Authorization': 'Bearer ' + ADMIN_TOKEN };
+
+    const loadedForms = new Set();
+    let graphLoaded = false;
+
+    document.querySelectorAll('.tab').forEach(btn => {
+      btn.addEventListener('click', () => {
+        document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+        btn.classList.add('active');
+        document.querySelectorAll('.pane').forEach(p => p.hidden = true);
+        const t = btn.dataset.type;
+        document.querySelector(`.pane[data-type="${t}"]`).hidden = false;
+        if (t === '__graph') {
+          if (!graphLoaded) { loadGraph(); graphLoaded = true; }
+          return;
+        }
+        loadWorkers(t);
+        if (!loadedForms.has(t)) {
+          loadSubmitForm(t);
+          wireInspectors(t);
+          loadInspectors(t);
+          loadedForms.add(t);
+        }
+      });
+    });
+    document.querySelector('.tab')?.click();
+
+    function wireInspectors(type) {
+      const qBox = document.getElementById('queue-' + type);
+      const dlqBox = document.getElementById('dlq-' + type);
+      qBox.querySelector('.refresh').addEventListener('click', () => loadQueue(type));
+      dlqBox.querySelector('.refresh').addEventListener('click', () => loadDlq(type));
+      dlqBox.querySelector('.danger').addEventListener('click', async () => {
+        if (!confirm(`drain DLQ for ${type}?`)) return;
+        const r = await fetch(`/api/v1/automations/${type}/dead`, {
+          method: 'DELETE', headers: AUTH,
+        });
+        const data = await r.json().catch(() => ({}));
+        alert(`[${r.status}] ${JSON.stringify(data)}`);
+        loadDlq(type);
+      });
+    }
+
+    async function loadInspectors(type) {
+      await Promise.all([loadQueue(type), loadDlq(type), loadPools(type)]);
+    }
+
+    async function loadQueue(type) {
+      const out = document.querySelector('#queue-' + CSS.escape(type) + ' pre');
+      try {
+        const r = await fetch(`/api/v1/automations/${type}/queue?n=20`, { headers: AUTH });
+        const d = await r.json();
+        out.textContent = `length: ${d.length}\n${JSON.stringify(d.items, null, 2)}`;
+      } catch (e) { out.textContent = 'error: ' + e.message; }
+    }
+
+    async function loadDlq(type) {
+      const out = document.querySelector('#dlq-' + CSS.escape(type) + ' pre');
+      try {
+        const r = await fetch(`/api/v1/automations/${type}/dead?n=20`, { headers: AUTH });
+        const d = await r.json();
+        out.textContent = `length: ${d.length}\n${JSON.stringify(d.items, null, 2)}`;
+      } catch (e) { out.textContent = 'error: ' + e.message; }
+    }
+
+    async function loadPools(type) {
+      const root = document.getElementById('pools-' + type);
+      try {
+        const r = await fetch(`/api/v1/catalog/${type}`, { headers: AUTH });
+        if (!r.ok) { root.textContent = 'catalog http ' + r.status; return; }
+        const doc = await r.json();
+        const names = Object.keys(doc.pools || {});
+        if (!names.length) { root.innerHTML = '<p class="muted">this automation declares no pools.</p>'; return; }
+        root.innerHTML = names.map(p => `
+          <div class="pool-card" data-pool="${p}">
+            <strong>${p}</strong>
+            <button class="refresh">refresh</button>
+            <pre class="muted">loading…</pre>
+          </div>
+        `).join('');
+        for (const p of names) {
+          const card = root.querySelector(`.pool-card[data-pool="${p}"]`);
+          card.querySelector('.refresh').addEventListener('click', () => loadPool(p, card));
+          loadPool(p, card);
+        }
+      } catch (e) { root.textContent = 'error: ' + e.message; }
+    }
+
+    async function loadPool(name, card) {
+      const out = card.querySelector('pre');
+      try {
+        const r = await fetch(`/api/v1/pools/${encodeURIComponent(name)}?n=20`, { headers: AUTH });
+        const d = await r.json();
+        out.textContent = `size: ${d.size}\n${JSON.stringify(d.items, null, 2)}`;
+      } catch (e) { out.textContent = 'error: ' + e.message; }
+    }
+
+    async function loadGraph() {
+      const el = document.getElementById('graph');
+      try {
+        const r = await fetch('/api/v1/catalog', { headers: AUTH });
+        if (!r.ok) { el.textContent = 'catalog http ' + r.status; return; }
+        const doc = await r.json();
+        const src = buildMermaid(doc);
+        const waitMermaid = () => new Promise(res => {
+          if (window.__mermaid) return res(window.__mermaid);
+          const iv = setInterval(() => {
+            if (window.__mermaid) { clearInterval(iv); res(window.__mermaid); }
+          }, 50);
+        });
+        const mermaid = await waitMermaid();
+        const { svg } = await mermaid.render('graph-svg', src);
+        el.innerHTML = svg;
+      } catch (e) {
+        el.textContent = 'error: ' + e.message;
+      }
+    }
+
+    function safeId(s) { return s.replace(/[^a-zA-Z0-9_]/g, '_'); }
+
+    function buildMermaid(catalog) {
+      const lines = ['flowchart LR'];
+      const automations = Object.entries(catalog);
+      if (!automations.length) return 'flowchart LR\n  empty[no automations installed]';
+      const pools = new Set();
+      for (const [type, doc] of automations) {
+        const a = `A_${safeId(type)}`;
+        lines.push(`  ${a}[["${type}<br/>(${doc.kind})"]]`);
+        if (doc.queue) {
+          const q = `Q_${safeId(doc.queue.name)}`;
+          lines.push(`  ${q}[/"queue: ${doc.queue.name}"/]`);
+          lines.push(`  ${q} -->|consume| ${a}`);
+        }
+        if (doc.stream) {
+          const s = `S_${safeId(doc.stream.name)}`;
+          lines.push(`  ${s}[("stream: ${doc.stream.name}")]`);
+          lines.push(`  ${a} -->|publish| ${s}`);
+        }
+        for (const poolName of Object.keys(doc.pools || {})) {
+          const p = `P_${safeId(poolName)}`;
+          if (!pools.has(poolName)) {
+            lines.push(`  ${p}{{"pool: ${poolName}"}}`);
+            pools.add(poolName);
+          }
+          lines.push(`  ${a} <-->|claim/put| ${p}`);
+        }
+      }
+      lines.push('  classDef auto fill:#f7931a,stroke:#f7931a,color:#111;');
+      for (const [type] of automations) {
+        lines.push(`  class A_${safeId(type)} auto;`);
+      }
+      return lines.join('\n');
+    }
+
+    async function loadWorkers(type) {
+      const el = document.getElementById('workers-' + type);
+      try {
+        const r = await fetch(`/api/v1/automations/${type}/workers`, { headers: AUTH });
+        if (!r.ok) { el.textContent = 'http ' + r.status; return; }
+        const ws = await r.json();
+        if (!ws.length) { el.textContent = 'no workers connected.'; return; }
+        el.innerHTML = '<table><thead><tr><th>worker</th><th>state</th><th>gen</th><th>slots</th><th>last seen</th></tr></thead><tbody>' +
+          ws.map(w => `<tr>
+            <td>${w.worker_id}</td>
+            <td>${w.state}</td>
+            <td>${w.config_gen}</td>
+            <td>${(w.current_stats||{}).slots ?? '-'}</td>
+            <td>${w.last_seen ? new Date(w.last_seen*1000).toLocaleTimeString() : '-'}</td>
+          </tr>`).join('') + '</tbody></table>';
+      } catch (e) {
+        el.textContent = 'error: ' + e.message;
+      }
+    }
+    setInterval(() => {
+      const active = document.querySelector('.pane:not([hidden])');
+      if (active) loadWorkers(active.dataset.type);
+    }, 5000);
+
+    async function loadSubmitForm(type) {
+      const root = document.getElementById('submit-' + type);
+      try {
+        const r = await fetch(`/api/v1/catalog/${type}`, { headers: AUTH });
+        if (!r.ok) { root.textContent = 'catalog http ' + r.status; return; }
+        const doc = await r.json();
+        if (!doc.queue || !doc.queue.payload) {
+          root.innerHTML = '<p class="muted">this automation does not accept tasks (no TaskPayload declared).</p>';
+          return;
+        }
+        renderForm(root, type, doc.queue.payload);
+      } catch (e) {
+        root.textContent = 'error: ' + e.message;
+      }
+    }
+
+    function renderForm(root, type, schema) {
+      const props = schema.properties || {};
+      const required = new Set(schema.required || []);
+      const refs = schema.$defs || schema.definitions || {};
+      const fields = [];
+      for (const [name, prop] of Object.entries(props)) {
+        fields.push(renderField(name, prop, required.has(name), refs));
+      }
+      root.innerHTML = `
+        <form class="task-form" data-type="${type}">
+          <div class="fields">${fields.join('')}</div>
+          <details class="advanced">
+            <summary>options</summary>
+            <div class="fields">
+              <label>priority <input type="number" name="__priority" value="0"/></label>
+              <label>max_attempts <input type="number" name="__max_attempts" placeholder="auto"/></label>
+              <label>ttl_seconds <input type="number" name="__ttl_seconds" placeholder="none"/></label>
+              <label>idempotency_key <input type="text" name="__idempotency_key" placeholder="optional"/></label>
+            </div>
+          </details>
+          <button type="submit">submit</button>
+          <pre class="submit-result muted"></pre>
+        </form>
+      `;
+      root.querySelector('form').addEventListener('submit', (ev) => {
+        ev.preventDefault();
+        onSubmit(root.querySelector('form'), props);
+      });
+    }
+
+    function renderField(name, prop, required, refs) {
+      const resolved = resolveRef(prop, refs);
+      const label = `${name}${required ? ' *' : ''}`;
+      const ph = resolved.description || resolved.title || '';
+      const inputType = inputTypeFor(resolved);
+      if (inputType === 'json') {
+        const def = resolved.default !== undefined ? JSON.stringify(resolved.default) : '';
+        return `<label>${label}<textarea name="${name}" placeholder='${ph}' data-shape="json" rows="3">${def}</textarea></label>`;
+      }
+      if (inputType === 'checkbox') {
+        const checked = resolved.default === true ? 'checked' : '';
+        return `<label class="bool"><input type="checkbox" name="${name}" data-shape="bool" ${checked}/> ${label}</label>`;
+      }
+      if (resolved.enum) {
+        const opts = resolved.enum.map(v => `<option value='${JSON.stringify(v)}'>${v}</option>`).join('');
+        return `<label>${label}<select name="${name}" data-shape="enum">${opts}</select></label>`;
+      }
+      const def = resolved.default !== undefined ? String(resolved.default) : '';
+      return `<label>${label}<input type="${inputType}" name="${name}" placeholder="${ph}" value="${def}" data-shape="${resolved.type || 'string'}"/></label>`;
+    }
+
+    function resolveRef(prop, refs) {
+      if (prop && prop['$ref']) {
+        const key = prop['$ref'].replace(/^#\/(?:\$defs|definitions)\//, '');
+        return refs[key] || prop;
+      }
+      return prop || {};
+    }
+
+    function inputTypeFor(p) {
+      const t = p.type;
+      if (t === 'integer' || t === 'number') return 'number';
+      if (t === 'boolean') return 'checkbox';
+      if (t === 'array' || t === 'object') return 'json';
+      return 'text';
+    }
+
+    async function onSubmit(form, props) {
+      const out = form.querySelector('.submit-result');
+      const payload = {};
+      const opts = {};
+      for (const el of form.querySelectorAll('[name]')) {
+        const name = el.name;
+        if (name.startsWith('__')) {
+          const raw = el.value.trim();
+          if (raw === '') continue;
+          opts[name.slice(2)] = ['priority','max_attempts','ttl_seconds'].includes(name.slice(2))
+            ? parseInt(raw, 10) : raw;
+          continue;
+        }
+        const shape = el.dataset.shape;
+        if (shape === 'bool') { payload[name] = el.checked; continue; }
+        const raw = el.value;
+        if (raw === '' && !(props[name] && props[name].default === '')) continue;
+        if (shape === 'json' || shape === 'enum') {
+          try { payload[name] = JSON.parse(raw); }
+          catch { out.textContent = `field ${name}: invalid JSON`; return; }
+        } else if (shape === 'integer' || shape === 'number') {
+          payload[name] = Number(raw);
+        } else {
+          payload[name] = raw;
+        }
+      }
+      const body = { payload, ...opts };
+      out.textContent = 'submitting…';
+      try {
+        const r = await fetch(`/api/v1/automations/${form.dataset.type}/tasks`, {
+          method: 'POST',
+          headers: { ...AUTH, 'content-type': 'application/json' },
+          body: JSON.stringify(body),
+        });
+        const data = await r.json().catch(() => ({}));
+        out.textContent = `[${r.status}] ${JSON.stringify(data, null, 2)}`;
+      } catch (e) {
+        out.textContent = 'error: ' + e.message;
+      }
+    }
+  </script>
+</body>
+</html>