clawview 0.1.0__py3-none-any.whl

clawview/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running with python -m clawview."""
+
+from clawview.app import main
+
+main()

clawview/app.py

@@ -0,0 +1,140 @@
+"""ClawView – real-time Claude Code session dashboard."""
+
+import argparse
+import asyncio
+import os
+from pathlib import Path
+
+import uvicorn
+from fastapi import FastAPI, Request, WebSocket
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from clawview.sessions import (
+    enrich_session_detail,
+    find_session_file,
+    load_memory_files,
+    load_skill_content,
+    parse_session_detail,
+)
+from clawview.ws import (
+    session_detail_websocket,
+    session_insights_websocket,
+    session_memory_websocket,
+    websocket_endpoint,
+)
+
+# Static files bundled inside the package (src/clawview/web/)
+_DIST_DIR = Path(__file__).resolve().parent / "web"
+
+app = FastAPI(title="ClawView")
+
+
+def _setup_static_files() -> None:
+    """Mount static file serving if the dist directory exists."""
+    if not _DIST_DIR.is_dir():
+        return
+
+    # Serve /assets/ directly for hashed JS/CSS bundles
+    assets_dir = _DIST_DIR / "assets"
+    if assets_dir.is_dir():
+        app.mount("/assets", StaticFiles(directory=str(assets_dir)), name="assets")
+
+
+_setup_static_files()
+
+
+@app.websocket("/ws")
+async def ws_route(ws: WebSocket) -> None:
+    await websocket_endpoint(ws)
+
+
+@app.websocket("/ws/sessions/{session_id}")
+async def ws_session_detail_route(ws: WebSocket, session_id: str) -> None:
+    await session_detail_websocket(ws, session_id)
+
+
+@app.websocket("/ws/sessions/{session_id}/memory")
+async def ws_session_memory_route(ws: WebSocket, session_id: str) -> None:
+    await session_memory_websocket(ws, session_id)
+
+
+@app.websocket("/ws/insights/{session_id}")
+async def ws_insights_route(ws: WebSocket, session_id: str) -> None:
+    await session_insights_websocket(ws, session_id)
+
+
+@app.get("/api/sessions/{session_id}")
+async def get_session_detail(session_id: str) -> JSONResponse:
+    """Return full session detail for a given session ID."""
+    fpath = await asyncio.to_thread(find_session_file, session_id)
+    if fpath is None:
+        return JSONResponse(
+            status_code=404,
+            content={"error": f"Session {session_id} not found"},
+        )
+
+    detail = await asyncio.to_thread(parse_session_detail, fpath)
+    if detail is None:
+        return JSONResponse(
+            status_code=500,
+            content={"error": f"Failed to parse session {session_id}"},
+        )
+
+    await asyncio.to_thread(enrich_session_detail, detail, fpath)
+
+    return JSONResponse(
+        content=detail.model_dump(by_alias=True, mode="json"),
+    )
+
+
+@app.get("/api/sessions/{session_id}/memory")
+async def get_session_memory(session_id: str) -> JSONResponse:
+    """Return memory files for the project that owns the given session."""
+    files = await asyncio.to_thread(load_memory_files, session_id)
+    return JSONResponse(
+        content=[f.model_dump(by_alias=True) for f in files],
+    )
+
+
+@app.get("/api/sessions/{session_id}/skills/{skill_name:path}")
+async def get_skill_content(session_id: str, skill_name: str) -> JSONResponse:
+    """Return the content of a skill file by name."""
+    result = await asyncio.to_thread(load_skill_content, session_id, skill_name)
+    if result is None:
+        return JSONResponse(
+            status_code=404,
+            content={"error": f"Skill '{skill_name}' not found"},
+        )
+    return JSONResponse(content={
+        "name": skill_name,
+        "content": result["content"],
+        "source": result["source"],
+        "path": result["path"],
+    })
+
+
+@app.get("/{full_path:path}")
+async def spa_fallback(request: Request, full_path: str) -> FileResponse:
+    """Serve static files or fall back to index.html for SPA routing."""
+    # Try to serve the exact file first (favicon.svg, icons.svg, etc.)
+    file_path = _DIST_DIR / full_path
+    if full_path and file_path.is_file():
+        return FileResponse(str(file_path))
+
+    # Fall back to index.html for all other paths (SPA routing)
+    return FileResponse(
+        str(_DIST_DIR / "index.html"),
+        headers={
+            "Cache-Control": "no-cache, no-store, must-revalidate",
+            "Pragma": "no-cache",
+            "Expires": "0",
+        },
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="ClawView dashboard server")
+    parser.add_argument("--port", type=int, default=3333)
+    args = parser.parse_args()
+    uvicorn.run(app, host="0.0.0.0", port=args.port)

clawview/ide.py

@@ -0,0 +1,144 @@
+"""IDE / terminal detection — reads ~/.claude/ide/*.lock and inspects process ancestry."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Known terminal emulators: lowercased substring -> display name.
+_KNOWN_TERMINALS: dict[str, str] = {
+    "ghostty": "Ghostty",
+    "iterm2": "iTerm2",
+    "iterm": "iTerm2",
+    "alacritty": "Alacritty",
+    "kitty": "Kitty",
+    "wezterm": "WezTerm",
+    "hyper": "Hyper",
+    "warp": "Warp",
+    "terminal.app": "Terminal",
+    "apple_terminal": "Terminal",
+    "windowsterminal": "Windows Terminal",
+    "terminal": "Terminal",
+}
+
+
+def _is_pid_alive(pid: int) -> bool:
+    """Check whether a process with the given PID is still running."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def _build_process_table() -> tuple[dict[int, int], dict[int, str]]:
+    """Return (pid_to_ppid, pid_to_comm) maps from ``ps``."""
+    pid_to_ppid: dict[int, int] = {}
+    pid_to_comm: dict[int, str] = {}
+    try:
+        result = subprocess.run(
+            ["ps", "-o", "pid=,ppid=,comm=", "-ax"],
+            capture_output=True, text=True, timeout=5,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return pid_to_ppid, pid_to_comm
+
+    for line in result.stdout.splitlines():
+        parts = line.split(None, 2)
+        if len(parts) >= 2:
+            try:
+                pid = int(parts[0])
+                ppid = int(parts[1])
+            except ValueError:
+                continue
+            pid_to_ppid[pid] = ppid
+            if len(parts) == 3:
+                pid_to_comm[pid] = parts[2]
+
+    return pid_to_ppid, pid_to_comm
+
+
+def _get_ancestor_pids(pid: int, pid_to_ppid: dict[int, int]) -> list[int]:
+    """Return ancestor PIDs for *pid* (excluding pid 0/1), ordered from nearest to farthest."""
+    ancestors: list[int] = []
+    seen: set[int] = set()
+    current = pid
+    while current in pid_to_ppid:
+        parent = pid_to_ppid[current]
+        if parent <= 1 or parent in seen:
+            break
+        ancestors.append(parent)
+        seen.add(parent)
+        current = parent
+    return ancestors
+
+
+def load_ide_pid_map(ide_dir: str) -> dict[int, str]:
+    """Read all .lock files in *ide_dir* and return ``{ide_pid: ide_name}``.
+
+    Lock files whose PID is no longer running are skipped (stale).
+    """
+    result: dict[int, str] = {}
+
+    ide_path = Path(ide_dir)
+    if not ide_path.is_dir():
+        return result
+
+    for entry in ide_path.iterdir():
+        if entry.is_dir() or entry.suffix != ".lock":
+            continue
+
+        try:
+            data = json.loads(entry.read_text())
+        except (OSError, json.JSONDecodeError) as exc:
+            logger.warning("Skipping malformed lock file %s: %s", entry, exc)
+            continue
+
+        ide_name: str = data.get("ideName", "")
+        if not ide_name:
+            continue
+
+        pid = data.get("pid")
+        if not isinstance(pid, int):
+            continue
+
+        if not _is_pid_alive(pid):
+            logger.debug("Skipping stale lock file %s (pid %d not running)", entry.name, pid)
+            continue
+
+        result[pid] = ide_name
+
+    return result
+
+
+def resolve_client_for_pid(session_pid: int, ide_pid_map: dict[int, str]) -> str:
+    """Return the client name for *session_pid*.
+
+    First checks if the session is a descendant of a known IDE PID.
+    If not, walks the ancestor process names looking for a known terminal emulator.
+    Returns ``""`` if nothing matches.
+    """
+    pid_to_ppid, pid_to_comm = _build_process_table()
+    ancestors = _get_ancestor_pids(session_pid, pid_to_ppid)
+
+    # Check IDE ancestry first.
+    for ancestor_pid in ancestors:
+        if ancestor_pid in ide_pid_map:
+            return ide_pid_map[ancestor_pid]
+
+    # Fallback: detect terminal emulator from ancestor command names.
+    for ancestor_pid in ancestors:
+        comm = pid_to_comm.get(ancestor_pid, "")
+        if not comm:
+            continue
+        comm_lower = comm.lower()
+        for key, name in _KNOWN_TERMINALS.items():
+            if key in comm_lower:
+                return name
+
+    return ""