forge-cw 0.1.0

package/cw/lib/dashboard/server.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""CW Retro Dashboard — Data server.
+
+Tiny HTTP server that:
+  GET /           → serves index.html
+  GET /api/data   → returns live CW workspace data as JSON
+  GET /api/activity?after=<ts> → returns recent activity events
+  GET /api/stream → SSE stream of real-time activity events
+"""
+
+import http.server
+import json
+import os
+import glob
+import sys
+import webbrowser
+import socket
+import time
+import threading
+from pathlib import Path
+from datetime import datetime, timezone
+from urllib.parse import urlparse, parse_qs
+
+CW_HOME = os.environ.get("CW_HOME", os.path.expanduser("~/.cw"))
+DASHBOARD_DIR = os.path.dirname(os.path.abspath(__file__))
+ACTIVITY_FILE = os.path.join(CW_HOME, "activity.jsonl")
+
+# per-harness marker files that indicate a logged-in credential dir
+HARNESS_AUTH_MARKERS = {
+    "claude": [".claude.json"],
+    "codex": ["auth.json", "env"],
+    "pi": ["auth.json", "env"],
+    "opencode": ["auth.json", "env"],
+}
+
+
+def harness_dir(account_path, harness):
+    """claude keeps the flat dir unless a claude subdir exists"""
+    sub = os.path.join(account_path, "claude")
+    if harness == "claude" and not os.path.isdir(sub):
+        return account_path
+    return os.path.join(account_path, harness)
+
+
+def account_harness(account_path):
+    """the account's default harness, mirroring _account_default_harness"""
+    meta_file = os.path.join(account_path, "meta.json")
+    if os.path.isfile(meta_file):
+        try:
+            with open(meta_file) as f:
+                h = json.load(f).get("harness")
+            if h:
+                return h
+        except Exception:
+            pass
+    return "claude"
+
+
+def harness_authenticated(account_path, harness):
+    hdir = harness_dir(account_path, harness)
+    markers = HARNESS_AUTH_MARKERS.get(harness, [])
+    return any(os.path.isfile(os.path.join(hdir, m)) for m in markers)
+
+
+def collect_data():
+    data = {
+        "version": "0.1.0",
+        "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+        "accounts": [],
+        "projects": [],
+        "sessions": [],
+        "stats": {},
+        "recent_log": [],
+    }
+
+    # ── Accounts ──────────────────────────────────────────────
+    accounts_dir = os.path.join(CW_HOME, "accounts")
+    if os.path.isdir(accounts_dir):
+        for name in sorted(os.listdir(accounts_dir)):
+            acct_path = os.path.join(accounts_dir, name)
+            if not os.path.isdir(acct_path) or name.startswith("."):
+                continue
+            harness = account_harness(acct_path)
+            data["accounts"].append(
+                {
+                    "name": name,
+                    "harness": harness,
+                    "authenticated": harness_authenticated(acct_path, harness),
+                }
+            )
+
+    # ── Projects ──────────────────────────────────────────────
+    registry = os.path.join(CW_HOME, "projects.json")
+    if os.path.isfile(registry):
+        with open(registry) as f:
+            projects = json.load(f)
+        for name, info in projects.items():
+            pp = info.get("path", "")
+            claude_md = os.path.isfile(os.path.join(pp, "CLAUDE.md"))
+            agents_dir = os.path.join(pp, ".claude", "agents")
+            commands_dir = os.path.join(pp, ".claude", "commands")
+            agents = (
+                len(glob.glob(os.path.join(agents_dir, "*.md")))
+                if os.path.isdir(agents_dir)
+                else 0
+            )
+            commands = (
+                len(glob.glob(os.path.join(commands_dir, "*.md")))
+                if os.path.isdir(commands_dir)
+                else 0
+            )
+            has_mcp = False
+            settings_file = os.path.join(pp, ".claude", "settings.json")
+            if os.path.isfile(settings_file):
+                try:
+                    with open(settings_file) as sf:
+                        s = json.load(sf)
+                    if s.get("mcpServers") or s.get("mcp_servers"):
+                        has_mcp = True
+                except Exception:
+                    pass
+
+            data["projects"].append(
+                {
+                    "name": name,
+                    "account": info.get("account", ""),
+                    "path": pp,
+                    "type": info.get("type", ""),
+                    "has_claude_md": claude_md,
+                    "agents": agents,
+                    "commands": commands,
+                    "has_mcp": has_mcp,
+                    "git": os.path.isdir(os.path.join(pp, ".git")),
+                }
+            )
+
+    # ── Sessions ──────────────────────────────────────────────
+    sessions_dir = os.path.join(CW_HOME, "sessions")
+    if os.path.isdir(sessions_dir):
+        for project in sorted(os.listdir(sessions_dir)):
+            project_dir = os.path.join(sessions_dir, project)
+            if not os.path.isdir(project_dir):
+                continue
+            for session in sorted(os.listdir(project_dir)):
+                meta_file = os.path.join(project_dir, session, "session.json")
+                if os.path.isfile(meta_file):
+                    try:
+                        with open(meta_file) as f:
+                            meta = json.load(f)
+                        meta["harness"] = meta.get("harness") or "claude"
+                        meta["provider"] = meta.get("provider") or "native"
+                        data["sessions"].append(meta)
+                    except Exception:
+                        pass
+
+    # ── Recent log ────────────────────────────────────────────
+    log_file = os.path.join(CW_HOME, "sessions.log")
+    if os.path.isfile(log_file):
+        with open(log_file) as f:
+            lines = f.readlines()
+        data["recent_log"] = [l.strip() for l in lines[-30:] if l.strip()]
+
+    # ── Stats ─────────────────────────────────────────────────
+    active = [s for s in data["sessions"] if s.get("status") == "active"]
+    done = [s for s in data["sessions"] if s.get("status") == "done"]
+    tasks = [s for s in active if s.get("type") == "task"]
+    reviews = [s for s in active if s.get("type") == "review"]
+    total_opens = sum(s.get("opens", 0) for s in data["sessions"])
+
+    data["stats"] = {
+        "total_sessions": len(data["sessions"]),
+        "active_sessions": len(active),
+        "completed_sessions": len(done),
+        "active_tasks": len(tasks),
+        "active_reviews": len(reviews),
+        "total_opens": total_opens,
+        "total_projects": len(data["projects"]),
+        "total_accounts": len(data["accounts"]),
+    }
+
+    return data
+
+
+def collect_activity(after_ts=0.0, limit=100):
+    """Read recent activity events from the JSONL file."""
+    events = []
+    if not os.path.isfile(ACTIVITY_FILE):
+        return events
+
+    try:
+        with open(ACTIVITY_FILE) as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                    if entry.get("ts", 0) > after_ts:
+                        events.append(entry)
+                except Exception:
+                    continue
+    except Exception:
+        pass
+
+    # Return most recent entries
+    return events[-limit:]
+
+
+def get_live_sessions(events, window=30):
+    """Derive which sessions are 'live' (had activity in last N seconds)."""
+    now = time.time()
+    cutoff = now - window
+    live = {}
+
+    for e in events:
+        ts = e.get("ts", 0)
+        if ts < cutoff:
+            continue
+        key = e.get("project", "") + "/" + e.get("task", "")
+        if not key or key == "/":
+            key = e.get("session", "unknown")
+
+        existing = live.get(key)
+        if not existing or ts > existing["ts"]:
+            live[key] = {
+                "project": e.get("project", ""),
+                "task": e.get("task", ""),
+                "type": e.get("type", ""),
+                "account": e.get("account", ""),
+                "session": e.get("session", ""),
+                "event": e.get("event", ""),
+                "tool": e.get("tool", ""),
+                "summary": e.get("summary", ""),
+                "ts": ts,
+                "age": round(now - ts, 1),
+            }
+
+    return list(live.values())
+
+
+class DashboardHandler(http.server.SimpleHTTPRequestHandler):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, directory=DASHBOARD_DIR, **kwargs)
+
+    def do_GET(self):
+        parsed = urlparse(self.path)
+
+        if parsed.path == "/api/data":
+            self._json_response(collect_data())
+
+        elif parsed.path == "/api/activity":
+            qs = parse_qs(parsed.query)
+            after = float(qs.get("after", ["0"])[0])
+            limit = int(qs.get("limit", ["100"])[0])
+            events = collect_activity(after, limit)
+            live = get_live_sessions(events)
+            self._json_response({"events": events, "live": live})
+
+        elif parsed.path == "/api/stream":
+            self._sse_stream()
+
+        elif parsed.path == "/" or parsed.path == "/index.html":
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
+            self.send_header("Pragma", "no-cache")
+            self.end_headers()
+            html_path = os.path.join(DASHBOARD_DIR, "index.html")
+            with open(html_path, "rb") as f:
+                self.wfile.write(f.read())
+        else:
+            super().do_GET()
+
+    def _json_response(self, data):
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        self.wfile.write(json.dumps(data).encode())
+
+    def _sse_stream(self):
+        """Server-Sent Events: tail activity.jsonl and push new lines."""
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Connection", "keep-alive")
+        self.end_headers()
+
+        # Seek to end of file
+        try:
+            if os.path.isfile(ACTIVITY_FILE):
+                f = open(ACTIVITY_FILE, "r")
+                f.seek(0, 2)  # seek to end
+            else:
+                f = None
+
+            last_size = os.path.getsize(ACTIVITY_FILE) if f else 0
+
+            while True:
+                # Check if file was recreated/truncated
+                try:
+                    cur_size = os.path.getsize(ACTIVITY_FILE) if os.path.isfile(ACTIVITY_FILE) else 0
+                except OSError:
+                    cur_size = 0
+
+                if f is None and os.path.isfile(ACTIVITY_FILE):
+                    f = open(ACTIVITY_FILE, "r")
+                    f.seek(0, 2)
+                    last_size = cur_size
+                elif f and cur_size < last_size:
+                    # File was truncated/rotated, reopen
+                    f.close()
+                    f = open(ACTIVITY_FILE, "r")
+                    last_size = 0
+
+                if f:
+                    new_lines = f.readlines()
+                    last_size = cur_size
+                    for line in new_lines:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            entry = json.loads(line)
+                            # Send as SSE event
+                            payload = json.dumps(entry, ensure_ascii=False)
+                            self.wfile.write(f"data: {payload}\n\n".encode())
+                            self.wfile.flush()
+                        except Exception:
+                            continue
+
+                # Send keepalive comment every cycle
+                try:
+                    self.wfile.write(f": keepalive {time.time()}\n\n".encode())
+                    self.wfile.flush()
+                except (BrokenPipeError, ConnectionResetError):
+                    break
+
+                time.sleep(0.5)
+
+        except (BrokenPipeError, ConnectionResetError):
+            pass
+        finally:
+            if f:
+                f.close()
+
+    def log_message(self, format, *args):
+        pass
+
+
+def find_free_port(start=3737):
+    for port in range(start, start + 100):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("127.0.0.1", port))
+                return port
+            except OSError:
+                continue
+    return start
+
+
+def main():
+    port = find_free_port()
+    # Use ThreadingHTTPServer so SSE doesn't block other requests
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", port), DashboardHandler)
+    url = f"http://127.0.0.1:{port}"
+    print(f"\033[0;32m[cw]\033[0m Retro Dashboard \u2192 {url}")
+    print(f"\033[2m     Press Ctrl+C to stop\033[0m")
+    webbrowser.open(url)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print(f"\n\033[0;32m[cw]\033[0m Dashboard stopped")
+        server.server_close()
+
+
+if __name__ == "__main__":
+    main()

package/cw/lib/dashboard/start.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# ── CW Retro Dashboard Launcher ──────────────────────────────
+# Usage: bash lib/dashboard/start.sh
+# Or via cw: cw arcade
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+G='\033[0;32m' C='\033[0;36m' DIM='\033[2m' NC='\033[0m'
+
+echo -e "${G}[cw]${NC} ${C}Launching CW Station...${NC}"
+echo -e "${DIM}     Retro Arcade Dashboard${NC}"
+echo ""
+
+python3 "$SCRIPT_DIR/server.py"

package/cw/lib/harnesses/claude.sh

@@ -0,0 +1,92 @@
+# claude code driver
+# no custom_provider: the Anthropic-compatible endpoint path is not built, CW_PROVIDER is never read
+claude_supports() {
+    local cap
+    for cap in resume_by_name continue_last non_interactive_prompt interactive_prompt \
+               mcp hooks skip_permissions agent_teams plugins \
+               model_flag statusline instructions_file skills slash_commands; do
+        [[ "$1" == "$cap" ]] && return 0
+    done
+    return 1
+}
+
+claude_config_env() {
+    printf 'CLAUDE_CONFIG_DIR=%s\n' "$CW_HARNESS_DIR"
+}
+
+claude_session_ref() {
+    printf '%s' ""
+}
+
+# builds argv for a plugin subcommand without spawning it
+claude_plugin() {
+    local op="${1:-}" plugin="${2:-}"
+    _claude_base_env
+    case "$op" in
+        list) HARNESS_ARGV=(claude plugin list) ;;
+        add)  HARNESS_ARGV=(claude plugin add "$plugin") ;;
+        *)    return 1 ;;
+    esac
+    return 0
+}
+
+# builds the common prefix shared by launch and resume
+_claude_base_argv() {
+    HARNESS_ARGV=(claude)
+    local f
+    for f in $CW_EXTRA_FLAGS; do HARNESS_ARGV+=("$f"); done
+    [[ -n "$CW_MODEL" ]] && HARNESS_ARGV+=(--model "$CW_MODEL")
+    return 0
+}
+
+_claude_base_env() {
+    HARNESS_ENV=("CLAUDE_CONFIG_DIR=$CW_HARNESS_DIR")
+    [[ -n "${CW_TEAM_ENV:-}" ]] && HARNESS_ENV+=("$CW_TEAM_ENV")
+    return 0
+}
+
+claude_launch() {
+    _claude_base_env
+    if [[ -n "${CW_PASSTHRU_ARGV+x}" ]]; then
+        HARNESS_ARGV=(claude ${CW_PASSTHRU_ARGV[@]+"${CW_PASSTHRU_ARGV[@]}"})
+        return 0
+    fi
+    _claude_base_argv
+    [[ -n "$CW_SESSION_NAME" ]] && HARNESS_ARGV+=(--name "$CW_SESSION_NAME")
+    [[ -n "$CW_PROMPT" ]] && HARNESS_ARGV+=("$CW_PROMPT")
+    return 0
+}
+
+# three attempts: resume by name, continue last, start named
+claude_resume() {
+    local attempt="$1"
+    _claude_base_env
+    _claude_base_argv
+    case "$attempt" in
+        1) HARNESS_ARGV+=(--resume "$CW_SESSION_NAME") ;;
+        2) HARNESS_ARGV+=(--continue) ;;
+        3) HARNESS_ARGV+=(--name "$CW_SESSION_NAME") ;;
+        *) return 1 ;;
+    esac
+    [[ -n "$CW_PROMPT" ]] && HARNESS_ARGV+=("$CW_PROMPT")
+    return 0
+}
+
+claude_doctor() {
+    local status detail="null"
+    if ! command -v claude >/dev/null 2>&1; then
+        status="not_installed"; detail='"claude not found on PATH"'
+    elif [[ -f "$CW_HARNESS_DIR/.claude.json" ]]; then
+        status="connected"
+    else
+        status="not_logged_in"
+    fi
+    printf '{"harness":"claude","status":"%s","detail":%s}\n' "$status" "$detail"
+}
+
+# unverified: no confirmed --no-browser/device-code flag or api-key import path for claude
+claude_login() {
+    HARNESS_ENV=("CLAUDE_CONFIG_DIR=$CW_HARNESS_DIR")
+    HARNESS_ARGV=(claude /login)
+    return 0
+}