Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DansiDanutz_MyWork-AI /tools /api_server.py
| #!/usr/bin/env python3 | |
| """MyWork API Server — REST interface for the mw framework. | |
| Usage: | |
| mw api [--port PORT] [--host HOST] | |
| Exposes all framework functionality via REST endpoints: | |
| GET /health — Server + framework health | |
| GET /status — Framework status (mw status) | |
| GET /projects — List all projects | |
| GET /projects/{name} — Project details | |
| POST /projects — Create new project (mw new) | |
| GET /brain/search?q= — Search knowledge vault | |
| POST /brain — Add knowledge entry | |
| GET /brain/stats — Brain statistics | |
| GET /git/log — Recent commits | |
| POST /commands/run — Run any mw command | |
| GET /doctor — Full diagnostics | |
| GET /ecosystem — Live app URLs | |
| GET /plugins — List plugins | |
| GET /env — List env vars (masked) | |
| POST /check — Run quality gate | |
| GET /metrics — Framework metrics (tests, commands, uptime) | |
| """ | |
| import http.server | |
| import json | |
| import os | |
| import subprocess | |
| import sys | |
| import time | |
| from datetime import datetime, timezone | |
| from pathlib import Path | |
| from typing import Optional | |
| from urllib.parse import parse_qs, urlparse | |
| # Try to import FastAPI; fall back to built-in HTTP server | |
| try: | |
| from fastapi import FastAPI, HTTPException, Query | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from fastapi.responses import JSONResponse | |
| import uvicorn | |
| HAS_FASTAPI = True | |
| except ImportError: | |
| HAS_FASTAPI = False | |
| def _get_framework_version() -> str: | |
| """Get version from importlib.metadata (pypi) or pyproject.toml fallback.""" | |
| try: | |
| from importlib.metadata import version as pkg_version | |
| return pkg_version("mywork-ai") | |
| except Exception: | |
| pass | |
| try: | |
| import tomllib # Python 3.11+ | |
| except ImportError: | |
| try: | |
| import tomli as tomllib | |
| except ImportError: | |
| tomllib = None | |
| if tomllib: | |
| try: | |
| with open(FRAMEWORK_ROOT / "pyproject.toml", "rb") as _f: | |
| return tomllib.load(_f).get("project", {}).get("version", "3.0.1") | |
| except Exception: | |
| pass | |
| return "3.0.1" | |
| FRAMEWORK_VERSION = _get_framework_version() | |
| # Optional API key auth — set MW_API_KEY env var to enable | |
| _MW_API_KEY = os.environ.get("MW_API_KEY", "") | |
| FRAMEWORK_ROOT = Path(__file__).parent.parent | |
| START_TIME = time.time() | |
| # Allowed mw subcommands (whitelist for security) | |
| ALLOWED_COMMANDS = { | |
| "status", "doctor", "report", "dashboard", "ecosystem", | |
| "links", "search", "projects", "brain", "lint", "check", | |
| "env", "monitor", "ci", "plugin", "test", "fix", | |
| } | |
| def run_mw(args: list[str], timeout: int = 30) -> dict: | |
| """Run an mw subcommand and capture output.""" | |
| cmd = [sys.executable, str(FRAMEWORK_ROOT / "tools" / "mw.py")] + args | |
| try: | |
| result = subprocess.run( | |
| cmd, capture_output=True, text=True, | |
| timeout=timeout, cwd=str(FRAMEWORK_ROOT), | |
| env={**os.environ, "NO_COLOR": "1", "TERM": "dumb"} | |
| ) | |
| return { | |
| "success": result.returncode == 0, | |
| "stdout": result.stdout, | |
| "stderr": result.stderr, | |
| "returncode": result.returncode, | |
| } | |
| except subprocess.TimeoutExpired: | |
| return {"success": False, "stdout": "", "stderr": "Command timed out", "returncode": -1} | |
| except Exception as e: | |
| return {"success": False, "stdout": "", "stderr": str(e), "returncode": -1} | |
| def get_projects_list() -> list[dict]: | |
| """List all projects with metadata.""" | |
| projects = [] | |
| projects_dir = FRAMEWORK_ROOT / "projects" | |
| if not projects_dir.exists(): | |
| return projects | |
| for p in sorted(projects_dir.iterdir()): | |
| if p.is_dir() and not p.name.startswith('.'): | |
| info = {"name": p.name, "path": str(p)} | |
| pkg = p / "package.json" | |
| pyproject = p / "pyproject.toml" | |
| if pkg.exists(): | |
| try: | |
| data = json.loads(pkg.read_text()) | |
| info["language"] = "node" | |
| info["version"] = data.get("version", "unknown") | |
| info["description"] = data.get("description", "") | |
| except Exception: | |
| info["language"] = "node" | |
| elif pyproject.exists(): | |
| info["language"] = "python" | |
| else: | |
| info["language"] = "unknown" | |
| info["has_git"] = (p / ".git").exists() | |
| info["has_tests"] = any( | |
| (p / d).exists() for d in ["tests", "test", "__tests__", "spec"] | |
| ) | |
| projects.append(info) | |
| return projects | |
| def get_brain_stats() -> dict: | |
| """Get brain knowledge vault statistics.""" | |
| brain_dir = FRAMEWORK_ROOT / "brain" | |
| if not brain_dir.exists(): | |
| return {"entries": 0, "categories": [], "size_kb": 0} | |
| entries = list(brain_dir.glob("**/*.md")) + list(brain_dir.glob("**/*.json")) | |
| total_size = sum(f.stat().st_size for f in entries if f.exists()) | |
| categories = sorted(set(f.parent.name for f in entries if f.parent != brain_dir)) | |
| return { | |
| "entries": len(entries), | |
| "categories": categories[:20], | |
| "size_kb": round(total_size / 1024, 1), | |
| } | |
| def search_brain(query: str, limit: int = 10) -> list[dict]: | |
| """Search brain entries.""" | |
| brain_dir = FRAMEWORK_ROOT / "brain" | |
| if not brain_dir.exists(): | |
| return [] | |
| results = [] | |
| query_lower = query.lower() | |
| for f in brain_dir.glob("**/*.md"): | |
| try: | |
| content = f.read_text() | |
| if query_lower in content.lower(): | |
| # Extract first 200 chars as snippet | |
| idx = content.lower().index(query_lower) | |
| start = max(0, idx - 50) | |
| snippet = content[start:start + 200].strip() | |
| results.append({ | |
| "file": str(f.relative_to(brain_dir)), | |
| "category": f.parent.name if f.parent != brain_dir else "root", | |
| "snippet": snippet, | |
| "size_kb": round(f.stat().st_size / 1024, 1), | |
| }) | |
| if len(results) >= limit: | |
| break | |
| except Exception: | |
| continue | |
| return results | |
| def get_git_log(limit: int = 20) -> list[dict]: | |
| """Get recent git commits.""" | |
| try: | |
| result = subprocess.run( | |
| ["git", "log", f"--max-count={limit}", | |
| "--pretty=format:%H|%h|%s|%an|%ar|%aI"], | |
| capture_output=True, text=True, | |
| cwd=str(FRAMEWORK_ROOT), timeout=5 | |
| ) | |
| commits = [] | |
| for line in result.stdout.strip().split("\n"): | |
| if "|" in line: | |
| parts = line.split("|", 5) | |
| if len(parts) >= 5: | |
| commits.append({ | |
| "hash": parts[0], "short": parts[1], | |
| "message": parts[2], "author": parts[3], | |
| "when": parts[4], | |
| "date": parts[5] if len(parts) > 5 else "", | |
| }) | |
| return commits | |
| except Exception: | |
| return [] | |
| def get_metrics() -> dict: | |
| """Gather framework metrics.""" | |
| # Count tests | |
| test_count = 0 | |
| for pattern in ["test_*.py", "*_test.py"]: | |
| for f in (FRAMEWORK_ROOT / "tools").glob(f"**/{pattern}"): | |
| try: | |
| content = f.read_text() | |
| test_count += content.count("def test_") | |
| except Exception: | |
| pass | |
| # Count mw commands | |
| mw_path = FRAMEWORK_ROOT / "tools" / "mw.py" | |
| cmd_count = 0 | |
| if mw_path.exists(): | |
| try: | |
| for line in mw_path.read_text().split("\n"): | |
| if line.strip().startswith('"') and ":" in line and "—" in line: | |
| cmd_count += 1 | |
| except Exception: | |
| pass | |
| # Count tools | |
| tools_count = len(list((FRAMEWORK_ROOT / "tools").glob("*.py"))) | |
| return { | |
| "test_count": test_count, | |
| "command_count": cmd_count, | |
| "tools_count": tools_count, | |
| "uptime_seconds": round(time.time() - START_TIME), | |
| "framework_version": FRAMEWORK_VERSION, | |
| "python_version": sys.version.split()[0], | |
| "timestamp": datetime.now(timezone.utc).isoformat(), | |
| } | |
| # ─── FastAPI App ──────────────────────────────────────────── | |
| def create_app() -> "FastAPI": | |
| """Create and configure the FastAPI application.""" | |
| app = FastAPI( | |
| title="MyWork-AI API", | |
| description="REST interface for the MyWork development framework", | |
| version=FRAMEWORK_VERSION, | |
| docs_url="/docs", | |
| redoc_url="/redoc", | |
| ) | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"], | |
| allow_credentials=True, | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| # Optional API key auth — active only if MW_API_KEY is set | |
| if _MW_API_KEY: | |
| from fastapi import Request | |
| from fastapi.responses import JSONResponse as _JSONResponse | |
| async def api_key_middleware(request: Request, call_next): | |
| if request.url.path in ("/health", "/docs", "/redoc", "/openapi.json"): | |
| return await call_next(request) | |
| key = request.headers.get("X-API-Key", "") | |
| if key != _MW_API_KEY: | |
| return _JSONResponse( | |
| status_code=403, | |
| content={"error": "Invalid or missing X-API-Key header"}, | |
| ) | |
| return await call_next(request) | |
| async def health(): | |
| """Health check endpoint.""" | |
| status_result = run_mw(["status"], timeout=10) | |
| return { | |
| "status": "healthy" if status_result["success"] else "degraded", | |
| "uptime_seconds": round(time.time() - START_TIME), | |
| "timestamp": datetime.now(timezone.utc).isoformat(), | |
| "framework": "mywork-ai", | |
| "version": FRAMEWORK_VERSION, | |
| } | |
| async def status(): | |
| """Full framework status.""" | |
| result = run_mw(["status"]) | |
| return {"output": result["stdout"], "success": result["success"]} | |
| async def list_projects(): | |
| """List all projects.""" | |
| return {"projects": get_projects_list()} | |
| async def get_project(name: str): | |
| """Get project details.""" | |
| projects = get_projects_list() | |
| for p in projects: | |
| if p["name"] == name: | |
| return p | |
| raise HTTPException(status_code=404, detail=f"Project '{name}' not found") | |
| async def create_project(name: str, template: str = "basic"): | |
| """Create a new project.""" | |
| result = run_mw(["new", name, template]) | |
| if result["success"]: | |
| return {"message": f"Project '{name}' created", "output": result["stdout"]} | |
| raise HTTPException(status_code=400, detail=result["stderr"] or result["stdout"]) | |
| async def brain_search(q: str = Query(..., min_length=1), limit: int = 10): | |
| """Search the knowledge vault.""" | |
| return {"query": q, "results": search_brain(q, limit)} | |
| async def brain_add(title: str, content: str, category: str = "general"): | |
| """Add a knowledge entry.""" | |
| result = run_mw(["brain", "add", "--title", title, "--category", category, "--content", content]) | |
| return {"success": result["success"], "output": result["stdout"]} | |
| async def brain_stats(): | |
| """Brain statistics.""" | |
| return get_brain_stats() | |
| async def git_log(limit: int = 20): | |
| """Recent git commits.""" | |
| return {"commits": get_git_log(limit)} | |
| async def run_command(command: str, args: list[str] = []): | |
| """Run an mw command (whitelisted).""" | |
| if command not in ALLOWED_COMMANDS: | |
| raise HTTPException( | |
| status_code=403, | |
| detail=f"Command '{command}' not allowed. Allowed: {sorted(ALLOWED_COMMANDS)}" | |
| ) | |
| result = run_mw([command] + args, timeout=60) | |
| return result | |
| async def doctor(): | |
| """Full system diagnostics.""" | |
| result = run_mw(["doctor"], timeout=30) | |
| return {"output": result["stdout"], "success": result["success"]} | |
| async def ecosystem(): | |
| """Live app URLs and ecosystem overview.""" | |
| result = run_mw(["ecosystem"]) | |
| return {"output": result["stdout"], "success": result["success"]} | |
| async def plugins(): | |
| """List installed plugins.""" | |
| result = run_mw(["plugin", "list"]) | |
| return {"output": result["stdout"], "success": result["success"]} | |
| async def env_list(): | |
| """List environment variables (masked).""" | |
| result = run_mw(["env", "list"]) | |
| return {"output": result["stdout"], "success": result["success"]} | |
| async def quality_check(quick: bool = False): | |
| """Run quality gate checks.""" | |
| args = ["check"] | |
| if quick: | |
| args.append("--quick") | |
| result = run_mw(args, timeout=120) | |
| return result | |
| async def metrics(): | |
| """Framework metrics.""" | |
| return get_metrics() | |
| # ─── Agent endpoints ──────────────────────────────────────────────────── | |
| async def list_agents(): | |
| """List available agent YAML/Markdown definitions.""" | |
| agents = [] | |
| search_dirs = [ | |
| FRAMEWORK_ROOT / "agents", | |
| Path.home() / ".mywork" / "agents", | |
| Path.cwd() / "agents", | |
| ] | |
| for d in search_dirs: | |
| if d.is_dir(): | |
| for p in sorted(d.glob("**/*.yaml")) + sorted(d.glob("**/*.yml")) + sorted(d.glob("**/*.md")): | |
| try: | |
| agents.append({ | |
| "name": p.stem, | |
| "path": str(p), | |
| "size_bytes": p.stat().st_size, | |
| }) | |
| except Exception: | |
| pass | |
| return {"agents": agents, "count": len(agents)} | |
| async def validate_agent(name: str): | |
| """Validate an agent YAML config by name.""" | |
| result = run_mw(["agent", "validate", name], timeout=30) | |
| return {"name": name, "valid": result["success"], "output": result["stdout"], "errors": result["stderr"]} | |
| async def run_agent_chat(name: str, message: str = "", max_turns: int = 1): | |
| """Run a single-turn interaction with an agent (non-streaming).""" | |
| if not message: | |
| raise HTTPException(status_code=400, detail="message is required") | |
| result = run_mw( | |
| ["agent", "run", name, "--message", message, "--max-turns", str(max_turns)], | |
| timeout=120, | |
| ) | |
| return { | |
| "agent": name, | |
| "input": message, | |
| "output": result["stdout"], | |
| "success": result["success"], | |
| "error": result["stderr"] if not result["success"] else None, | |
| } | |
| async def agent_info(name: str): | |
| """Get agent configuration and capabilities.""" | |
| result = run_mw(["agent", "info", name], timeout=15) | |
| return {"name": name, "output": result["stdout"], "success": result["success"]} | |
| return app | |
| # ─── Fallback: Built-in HTTP Server ──────────────────────── | |
| class SimpleAPIHandler(http.server.BaseHTTPRequestHandler): | |
| """Minimal HTTP handler when FastAPI is not available.""" | |
| def do_GET(self): | |
| """Handle HTTP GET requests for the simple API server. | |
| Routes requests to appropriate handlers based on the URL path. | |
| Supports health checks, status, projects, brain search, git log, | |
| metrics, and doctor endpoints when FastAPI is not available. | |
| Returns: | |
| JSON response with appropriate status code | |
| """ | |
| parsed = urlparse(self.path) | |
| path = parsed.path.rstrip("/") | |
| params = parse_qs(parsed.query) | |
| routes = { | |
| "/health": lambda: { | |
| "status": "healthy", | |
| "uptime_seconds": round(time.time() - START_TIME), | |
| "note": "Install fastapi+uvicorn for full API: pip install fastapi uvicorn", | |
| }, | |
| "/status": lambda: run_mw(["status"]), | |
| "/projects": lambda: {"projects": get_projects_list()}, | |
| "/brain/stats": lambda: get_brain_stats(), | |
| "/git/log": lambda: {"commits": get_git_log()}, | |
| "/metrics": lambda: get_metrics(), | |
| "/doctor": lambda: run_mw(["doctor"]), | |
| } | |
| if path in routes: | |
| data = routes[path]() | |
| 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, indent=2).encode()) | |
| elif path == "/brain/search" and "q" in params: | |
| results = search_brain(params["q"][0]) | |
| self.send_response(200) | |
| self.send_header("Content-Type", "application/json") | |
| self.end_headers() | |
| self.wfile.write(json.dumps({"results": results}, indent=2).encode()) | |
| else: | |
| self.send_response(404) | |
| self.send_header("Content-Type", "application/json") | |
| self.end_headers() | |
| endpoints = list(routes.keys()) + ["/brain/search?q="] | |
| self.wfile.write(json.dumps({ | |
| "error": "Not found", | |
| "available_endpoints": endpoints, | |
| }).encode()) | |
| def log_message(self, format, *args): | |
| """Suppress default logging.""" | |
| pass | |
| def serve(host: str = "0.0.0.0", port: int = 8420): | |
| """Start the API server.""" | |
| if HAS_FASTAPI: | |
| app = create_app() | |
| print(f"\n🚀 MyWork API Server starting...") | |
| print(f" URL: http://{host}:{port}") | |
| print(f" Docs: http://{host}:{port}/docs") | |
| print(f" Mode: FastAPI + Uvicorn\n") | |
| uvicorn.run(app, host=host, port=port, log_level="info") | |
| else: | |
| print(f"\n🚀 MyWork API Server (lite) starting...") | |
| print(f" URL: http://{host}:{port}") | |
| print(f" Note: Install fastapi+uvicorn for full API") | |
| print(f" Mode: Built-in HTTP server\n") | |
| server = http.server.HTTPServer((host, port), SimpleAPIHandler) | |
| try: | |
| server.serve_forever() | |
| except KeyboardInterrupt: | |
| print("\n⏹ Server stopped.") | |
| server.server_close() | |
| if __name__ == "__main__": | |
| import argparse | |
| parser = argparse.ArgumentParser(description="MyWork API Server") | |
| parser.add_argument("--host", default="0.0.0.0") | |
| parser.add_argument("--port", type=int, default=8420) | |
| args = parser.parse_args() | |
| serve(args.host, args.port) | |
Xet Storage Details
- Size:
- 19.7 kB
- Xet hash:
- 10c14a4f399e3620d62a5965645b84aca9ee6c0af6e8a79790fd860dbe16ea40
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.