uv-suite 0.28.0 → 0.30.0

package/watchtower/app/routers/ingest.py

@@ -0,0 +1,102 @@
+"""Ingest router: hooks and `uvs` POST here. Writes events/sessions/approvals
+and emits a NOTIFY so connected dashboards update without polling."""
+import asyncpg
+from fastapi import APIRouter, Depends, Request
+
+from app import db
+from app.models import ApprovalIn, SessionRegister, StateUpdate
+
+router = APIRouter()
+
+
+@router.post("/events")
+async def ingest_event(req: Request, con: asyncpg.Connection = Depends(db.db)) -> dict:
+    body = await req.json()
+
+    sid = body.get("uvs_session_id") or body.get("session_id")
+    event_type = body.get("event_type", "Unknown")
+    tool_name = body.get("tool_name")
+    command = body.get("command")
+    cwd = body.get("cwd")
+
+    name = body.get("session_name") or body.get("name")
+    kind = body.get("session_kind") or body.get("kind")
+    purpose = body.get("session_purpose") or body.get("purpose")
+    priority = body.get("session_priority") or body.get("priority")
+    persona = body.get("persona")
+
+    await con.execute(
+        """INSERT INTO events (session_id, event_type, tool_name, command, payload)
+           VALUES ($1, $2, $3, $4, $5)""",
+        sid, event_type, tool_name, command, body,
+    )
+
+    if sid:
+        await con.execute(
+            """INSERT INTO sessions (id, name, kind, purpose, priority, persona, cwd)
+               VALUES ($1, $2, $3, $4, $5, $6, $7)
+               ON CONFLICT (id) DO UPDATE SET
+                 name     = COALESCE($2, sessions.name),
+                 kind     = COALESCE($3, sessions.kind),
+                 purpose  = COALESCE($4, sessions.purpose),
+                 priority = COALESCE($5, sessions.priority),
+                 persona  = COALESCE($6, sessions.persona),
+                 cwd      = COALESCE($7, sessions.cwd)""",
+            sid, name, kind, purpose, priority, persona, cwd,
+        )
+
+    await db.notify(con, {"type": "event", "session_id": sid, "event_type": event_type})
+    return {"ok": True}
+
+
+@router.post("/sessions/register")
+async def register_session(s: SessionRegister, con: asyncpg.Connection = Depends(db.db)) -> dict:
+    await con.execute(
+        """INSERT INTO sessions (id, name, persona, cwd, worktree, branch, pid, tmux_target, state)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'active')
+           ON CONFLICT (id) DO UPDATE SET
+             name        = COALESCE($2, sessions.name),
+             persona     = COALESCE($3, sessions.persona),
+             cwd         = COALESCE($4, sessions.cwd),
+             worktree    = COALESCE($5, sessions.worktree),
+             branch      = COALESCE($6, sessions.branch),
+             pid         = COALESCE($7, sessions.pid),
+             tmux_target = COALESCE($8, sessions.tmux_target),
+             state       = 'active'""",
+        s.id, s.name, s.persona, s.cwd, s.worktree, s.branch, s.pid, s.tmux_target,
+    )
+    await db.notify(con, {"type": "session", "session_id": s.id})
+    return {"ok": True}
+
+
+@router.post("/approvals")
+async def create_approval(a: ApprovalIn, con: asyncpg.Connection = Depends(db.db)) -> dict:
+    row = await con.fetchrow(
+        """INSERT INTO approvals (session_id, tool_name, command, request, status)
+           VALUES ($1, $2, $3, $4, 'pending')
+           RETURNING id""",
+        a.session_id, a.tool_name, a.command, a.request,
+    )
+    await con.execute(
+        "UPDATE sessions SET state = 'awaiting_human' WHERE id = $1", a.session_id
+    )
+    await db.notify(con, {
+        "type": "approval",
+        "id": row["id"],
+        "session_id": a.session_id,
+        "tool_name": a.tool_name,
+        "command": a.command,
+    })
+    return {"ok": True, "id": row["id"]}
+
+
+@router.post("/sessions/{id}/state")
+async def update_state(id: str, s: StateUpdate, con: asyncpg.Connection = Depends(db.db)) -> dict:
+    if s.state == "terminated":
+        await con.execute(
+            "UPDATE sessions SET state = $2, ended_at = now() WHERE id = $1", id, s.state
+        )
+    else:
+        await con.execute("UPDATE sessions SET state = $2 WHERE id = $1", id, s.state)
+    await db.notify(con, {"type": "session", "session_id": id, "state": s.state})
+    return {"ok": True}

package/watchtower/app/routers/query.py

@@ -0,0 +1,84 @@
+"""Query router: read-only endpoints the dashboard polls/loads."""
+import os
+
+import asyncpg
+from fastapi import APIRouter, Depends, HTTPException
+
+from app import db
+
+router = APIRouter()
+
+
+@router.get("/sessions")
+async def list_sessions(con: asyncpg.Connection = Depends(db.db)) -> list[dict]:
+    rows = await con.fetch(
+        """SELECT s.*,
+                  (SELECT count(*) FROM events e
+                     WHERE e.session_id = s.id AND e.tool_name IS NOT NULL) AS tool_calls,
+                  (SELECT max(e.created_at) FROM events e
+                     WHERE e.session_id = s.id) AS last_event_at
+             FROM sessions s
+            ORDER BY COALESCE(
+              (SELECT max(e.created_at) FROM events e WHERE e.session_id = s.id),
+              s.started_at) DESC"""
+    )
+    return [dict(r) for r in rows]
+
+
+@router.get("/sessions/{id}")
+async def get_session(id: str, con: asyncpg.Connection = Depends(db.db)) -> dict:
+    row = await con.fetchrow("SELECT * FROM sessions WHERE id = $1", id)
+    if row is None:
+        raise HTTPException(status_code=404, detail="session not found")
+    return dict(row)
+
+
+@router.get("/sessions/{id}/events")
+async def get_session_events(
+    id: str, limit: int = 100, con: asyncpg.Connection = Depends(db.db)
+) -> list[dict]:
+    rows = await con.fetch(
+        """SELECT * FROM events
+            WHERE session_id = $1
+            ORDER BY created_at DESC
+            LIMIT $2""",
+        id, limit,
+    )
+    return [dict(r) for r in rows]
+
+
+@router.get("/sessions/{id}/artifacts")
+async def get_session_artifacts(
+    id: str, con: asyncpg.Connection = Depends(db.db)
+) -> list[dict]:
+    row = await con.fetchrow("SELECT cwd FROM sessions WHERE id = $1", id)
+    if row is None:
+        raise HTTPException(status_code=404, detail="session not found")
+
+    cwd = row["cwd"]
+    if not cwd:
+        return []
+
+    base = os.path.join(cwd, "uv-out", "sessions", id)
+    if not os.path.isdir(base):
+        return []
+
+    artifacts = []
+    for dirpath, _dirnames, filenames in os.walk(base):
+        for fn in filenames:
+            full = os.path.join(dirpath, fn)
+            artifacts.append({
+                "path": os.path.relpath(full, base),
+                "size": os.path.getsize(full),
+            })
+    return artifacts
+
+
+@router.get("/approvals")
+async def list_approvals(
+    status: str = "pending", con: asyncpg.Connection = Depends(db.db)
+) -> list[dict]:
+    rows = await con.fetch(
+        "SELECT * FROM approvals WHERE status = $1 ORDER BY created_at DESC", status
+    )
+    return [dict(r) for r in rows]

package/watchtower/app/routers/stream.py

@@ -0,0 +1,30 @@
+"""Stream router: a single WebSocket the dashboard connects to for live updates.
+NOTIFY payloads land on the broadcaster (see app/db.py) and fan out here."""
+import asyncio
+import json
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+from app import db
+
+router = APIRouter()
+
+
+@router.websocket("/live")
+async def live(ws: WebSocket) -> None:
+    await ws.accept()
+
+    async with db.pool.acquire() as con:
+        rows = await con.fetch("SELECT * FROM sessions ORDER BY started_at DESC")
+    snapshot = {"type": "snapshot", "sessions": [dict(r) for r in rows]}
+    await ws.send_text(json.dumps(snapshot, default=str))
+
+    q = db.broadcaster.subscribe()
+    try:
+        while True:
+            payload = await q.get()
+            await ws.send_text(payload)
+    except (WebSocketDisconnect, asyncio.CancelledError):
+        pass
+    finally:
+        db.broadcaster.unsubscribe(q)

package/watchtower/app/services/checkpoint.py

@@ -0,0 +1,107 @@
+"""Out-of-band session checkpoints.
+
+Writes a markdown checkpoint from the session's recent events + git state.
+No live session is required — everything is read from Postgres and the cwd's
+git repo, so we can checkpoint a session we don't own (e.g. before closing it).
+"""
+import os
+import subprocess
+from datetime import datetime, timezone
+
+from app import db
+
+
+def _git(cwd: str, *args: str) -> str:
+    """Best-effort `git -C <cwd> <args>`; empty string on any failure."""
+    try:
+        proc = subprocess.run(
+            ["git", "-C", cwd, *args],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        return proc.stdout.strip() if proc.returncode == 0 else ""
+    except (OSError, subprocess.SubprocessError):
+        return ""
+
+
+def _git_state(cwd: str) -> str:
+    branch = _git(cwd, "branch", "--show-current") or "(unknown)"
+    status = _git(cwd, "status", "--short") or "(clean)"
+    log = _git(cwd, "log", "--oneline", "-5") or "(no commits)"
+    return (
+        f"- Branch: `{branch}`\n\n"
+        f"Working tree:\n```\n{status}\n```\n\n"
+        f"Recent commits:\n```\n{log}\n```\n"
+    )
+
+
+def _render(session: dict, events: list, git_state: str, created: str) -> str:
+    sid = session["id"]
+    name = session.get("name") or sid
+
+    lines = []
+    for e in events:
+        ts = e["created_at"].isoformat() if e["created_at"] else ""
+        bits = [e["event_type"] or "Event"]
+        if e["tool_name"]:
+            bits.append(e["tool_name"])
+        if e["command"]:
+            bits.append(f"`{e['command']}`")
+        lines.append(f"- {ts} — {' '.join(bits)}")
+    activity = "\n".join(lines) if lines else "_No recorded events._"
+
+    return f"""---
+session: {sid}
+created: {created}
+source: watchtower
+---
+
+# Checkpoint: {name}
+
+## What's in progress
+
+<!-- TODO: optional semantic summary via `claude -p --model haiku`.
+     v1 is mechanical (events + git). Do not depend on `claude` being present. -->
+_Mechanical checkpoint — see recent activity and git state below._
+
+## Recent activity
+
+{activity}
+
+## Git state
+
+{git_state}
+"""
+
+
+async def write_checkpoint(session: dict) -> str:
+    sid = session["id"]
+    cwd = session.get("cwd") or os.getcwd()
+
+    rows = await db.pool.fetch(
+        """SELECT event_type, tool_name, command, created_at
+             FROM events
+            WHERE session_id = $1
+         ORDER BY created_at DESC
+            LIMIT 50""",
+        sid,
+    )
+    events = [dict(r) for r in rows]
+
+    now = datetime.now(timezone.utc)
+    created = now.isoformat()
+    git_state = _git_state(cwd)
+    content = _render(session, events, git_state, created)
+
+    out_dir = os.path.join(cwd, "uv-out", "sessions", sid, "checkpoints")
+    os.makedirs(out_dir, exist_ok=True)
+    fname = f"manual-{now.strftime('%Y-%m-%d-%H%M')}.md"
+    path = os.path.join(out_dir, fname)
+
+    with open(path, "w") as f:
+        f.write(content)
+    with open(os.path.join(out_dir, "latest.md"), "w") as f:
+        f.write(content)
+
+    return os.path.abspath(path)

package/watchtower/app/services/tmux.py

@@ -0,0 +1,54 @@
+"""Thin wrappers over `tmux -L uvs`.
+
+We use a dedicated tmux socket (`-L uvs`) so Watchtower-spawned sessions never
+clash with the user's own tmux server. Functions are synchronous subprocess
+calls — invoke them from async code via `asyncio.to_thread`.
+"""
+import shutil
+import subprocess
+
+SOCKET = "uvs"
+
+
+def _tmux(*args: str) -> tuple[bool, str]:
+    """Run `tmux -L uvs <args>`; return (ok, combined output)."""
+    if not has_tmux():
+        return False, "tmux not found on PATH"
+    proc = subprocess.run(
+        ["tmux", "-L", SOCKET, *args],
+        capture_output=True,
+        text=True,
+    )
+    out = (proc.stdout or "") + (proc.stderr or "")
+    return proc.returncode == 0, out.strip()
+
+
+def has_tmux() -> bool:
+    return shutil.which("tmux") is not None
+
+
+def spawn(session_id: str, command: str, cwd: str) -> str:
+    """Start a detached session named `uvs_<id>`; return its target."""
+    target = f"uvs_{session_id}"
+    ok, out = _tmux("new-session", "-d", "-s", target, "-c", cwd, command)
+    if not ok:
+        raise RuntimeError(f"tmux new-session failed: {out}")
+    return target
+
+
+def send_keys(target: str, keys: str, enter: bool = True) -> tuple[bool, str]:
+    args = ["send-keys", "-t", target, keys]
+    if enter:
+        args.append("Enter")
+    return _tmux(*args)
+
+
+def capture_pane(target: str) -> str:
+    ok, out = _tmux("capture-pane", "-t", target, "-p")
+    if not ok:
+        raise RuntimeError(f"tmux capture-pane failed: {out}")
+    return out
+
+
+def kill_session(target: str) -> tuple[bool, str]:
+    return _tmux("kill-session", "-t", target)

package/watchtower/docker-compose.yml

@@ -0,0 +1,22 @@
+services:
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: watchtower
+      POSTGRES_PASSWORD: watchtower
+      POSTGRES_DB: watchtower
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U watchtower"]
+      interval: 3s
+      timeout: 3s
+      retries: 10
+
+  app:
+    build: .
+    environment:
+      DATABASE_URL: postgresql://watchtower:watchtower@db:5432/watchtower
+    ports:
+      - "4200:4200"   # control API binds localhost only — see app routers
+    depends_on:
+      db:
+        condition: service_healthy