delimit-cli 3.14.28 → 3.14.29

package/gateway/ai/mcp_bridge.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Delimit MCP Bridge Relay Server.
+
+Bridges HTTP requests to a local MCP server running on stdin/stdout.
+Designed for remote Claude Code sessions to proxy tool calls via SSH tunnel.
+
+Usage: python mcp_bridge.py --command "path/to/mcp-server" --port 7824
+
+Endpoints:
+    GET  /health    - Health check
+    GET  /mcp/list  - List available tools from the local MCP server
+    POST /mcp/call  - Call a tool: {"method":"tools/call","params":{"name":"...","arguments":{...}}}
+"""
+import argparse, json, logging, select, subprocess, threading
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+logger = logging.getLogger("delimit.mcp_bridge")
+
+
+class MCPSubprocessClient:
+    """Manages a local MCP server subprocess communicating via JSON-RPC over stdio."""
+
+    def __init__(self, command: str, init_timeout: float = 10.0):
+        self.command = command
+        self.init_timeout = init_timeout
+        self._proc = None
+        self._lock = threading.Lock()
+        self._request_id = 0
+
+    def start(self):
+        self._proc = subprocess.Popen(
+            self.command, shell=True,
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        )
+        init_resp = self._send_request("initialize", {
+            "protocolVersion": "2024-11-05", "capabilities": {},
+            "clientInfo": {"name": "delimit-bridge", "version": "1.0.0"},
+        })
+        if init_resp is None:
+            raise RuntimeError("MCP server did not respond to initialize")
+        self._send_notification("notifications/initialized", {})
+        logger.info("MCP server initialized: %s", init_resp.get("result", {}).get("serverInfo", {}))
+
+    def stop(self):
+        if self._proc and self._proc.poll() is None:
+            self._proc.terminate()
+            try:
+                self._proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self._proc.kill()
+
+    def list_tools(self) -> dict:
+        return self._send_request("tools/list", {})
+
+    def call_tool(self, name: str, arguments: dict) -> dict:
+        return self._send_request("tools/call", {"name": name, "arguments": arguments})
+
+    def _next_id(self) -> int:
+        self._request_id += 1
+        return self._request_id
+
+    def _send_notification(self, method: str, params: dict):
+        self._write({"jsonrpc": "2.0", "method": method, "params": params})
+
+    def _send_request(self, method: str, params: dict, timeout: float = 30.0):
+        with self._lock:
+            req_id = self._next_id()
+            self._write({"jsonrpc": "2.0", "id": req_id, "method": method, "params": params})
+            return self._read(timeout=timeout)
+
+    def _write(self, msg: dict):
+        if self._proc is None or self._proc.stdin is None:
+            raise RuntimeError("MCP subprocess not running")
+        self._proc.stdin.write((json.dumps(msg) + "\n").encode())
+        self._proc.stdin.flush()
+
+    def _read(self, timeout: float = 30.0):
+        if self._proc is None or self._proc.stdout is None:
+            return None
+        ready, _, _ = select.select([self._proc.stdout], [], [], timeout)
+        if not ready:
+            logger.warning("Timeout waiting for MCP response")
+            return None
+        line = self._proc.stdout.readline()
+        return json.loads(line.decode().strip()) if line else None
+
+
+class BridgeHandler(BaseHTTPRequestHandler):
+    """HTTP handler that proxies requests to the MCP subprocess."""
+    server_version = "DelimitMCPBridge/1.0"
+    mcp_client: MCPSubprocessClient = None
+
+    def log_message(self, fmt, *args):
+        logger.info(fmt, *args)
+
+    def _json(self, data: dict, status: int = 200):
+        body = json.dumps(data).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _body(self) -> bytes:
+        return self.rfile.read(int(self.headers.get("Content-Length", 0)))
+
+    def _mcp_result(self, resp, on_result=None):
+        """Unwrap an MCP JSON-RPC response into an HTTP response."""
+        if resp and "result" in resp:
+            self._json(on_result(resp["result"]) if on_result else {"result": resp["result"]})
+        elif resp and "error" in resp:
+            self._json({"error": resp["error"]}, 502)
+        else:
+            self._json({"error": "no_response_from_mcp_server"}, 502)
+
+    def do_GET(self):
+        if self.path == "/health":
+            self._json({"status": "ok", "server": "delimit-mcp-bridge"})
+        elif self.path == "/mcp/list":
+            try:
+                self._mcp_result(self.mcp_client.list_tools(),
+                                 on_result=lambda r: {"tools": r.get("tools", [])})
+            except Exception as exc:
+                logger.exception("list_tools failed")
+                self._json({"error": str(exc)}, 500)
+        else:
+            self._json({"error": "not_found"}, 404)
+
+    def do_POST(self):
+        if self.path != "/mcp/call":
+            self._json({"error": "not_found"}, 404)
+            return
+        try:
+            raw = self._body()
+            if not raw:
+                self._json({"error": "empty_body"}, 400); return
+            body = json.loads(raw)
+        except json.JSONDecodeError:
+            self._json({"error": "invalid_json"}, 400); return
+        params = body.get("params", {})
+        tool_name = params.get("name")
+        if not tool_name:
+            self._json({"error": "missing params.name"}, 400); return
+        try:
+            self._mcp_result(self.mcp_client.call_tool(tool_name, params.get("arguments", {})))
+        except Exception as exc:
+            logger.exception("call_tool failed")
+            self._json({"error": str(exc)}, 500)
+
+
+def create_server(command: str, port: int = 7824, init_timeout: float = 10.0):
+    """Create and return (httpd, mcp_client) without starting the serve loop."""
+    client = MCPSubprocessClient(command, init_timeout=init_timeout)
+    client.start()
+    handler = type("Handler", (BridgeHandler,), {"mcp_client": client})
+    return HTTPServer(("127.0.0.1", port), handler), client
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Delimit MCP Bridge Relay")
+    parser.add_argument("--command", required=True, help="Command to spawn the local MCP server")
+    parser.add_argument("--port", type=int, default=7824, help="Port to listen on (default 7824)")
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s")
+    logger.info("Starting MCP bridge: command=%r port=%d", args.command, args.port)
+    httpd, client = create_server(args.command, args.port)
+    try:
+        logger.info("Bridge listening on 127.0.0.1:%d", args.port)
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        logger.info("Shutting down")
+    finally:
+        httpd.server_close()
+        client.stop()
+
+
+if __name__ == "__main__":
+    main()

package/gateway/ai/release_sync.py

@@ -28,10 +28,10 @@ DEFAULT_CONFIG = {
     "urls": {
         "homepage": "https://delimit.ai",
         "docs": "https://delimit.ai/docs",
-        "github": "https://github.com/delimit-ai/delimit",
+        "github": "https://github.com/delimit-ai/delimit-mcp-server",
         "action": "https://github.com/marketplace/actions/delimit-api-governance",
         "npm": "https://www.npmjs.com/package/delimit-cli",
-        "quickstart": "https://github.com/delimit-ai/delimit-quickstart",
+        "quickstart": "https://github.com/delimit-ai/delimit-mcp-server-quickstart",
     },
 }
 

package/gateway/ai/screen_record.py

@@ -0,0 +1,374 @@
+"""
+Screen recording helpers for Delimit MCP.
+
+Two modes:
+- browser: Xvfb + Chromium + ffmpeg -> MP4
+- terminal: asciinema + agg + ffmpeg -> .cast + GIF + MP4
+
+Bonus:
+- take_screenshot: Chromium headless screenshot -> PNG
+"""
+
+import logging
+import os
+import shutil
+import signal
+import subprocess
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger("delimit.ai.screen_record")
+
+# ── Constants ────────────────────────────────────────────────────────────
+
+CHROMIUM_PATH = "/root/.cache/puppeteer/chrome/linux-146.0.7680.153/chrome-linux64/chrome"
+CONTENT_BASE = Path.home() / ".delimit" / "content"
+VIDEOS_DIR = CONTENT_BASE / "videos"
+GIFS_DIR = CONTENT_BASE / "gifs"
+CASTS_DIR = CONTENT_BASE / "casts"
+SCREENSHOTS_DIR = CONTENT_BASE / "screenshots"
+
+MAX_DURATION = 120
+DEFAULT_WIDTH = 1920
+DEFAULT_HEIGHT = 1080
+DISPLAY_NUM = 99
+
+
+def _ensure_dirs():
+    """Create output directories if they don't exist."""
+    for d in (VIDEOS_DIR, GIFS_DIR, CASTS_DIR, SCREENSHOTS_DIR):
+        d.mkdir(parents=True, exist_ok=True)
+
+
+def _check_binary(name: str) -> Optional[str]:
+    """Return path to binary or None if not found."""
+    return shutil.which(name)
+
+
+def _file_size_kb(path: Path) -> int:
+    """Return file size in KB, or 0 if missing."""
+    try:
+        return int(path.stat().st_size / 1024)
+    except (OSError, FileNotFoundError):
+        return 0
+
+
+def _kill_pid(pid: int):
+    """Kill a process, ignoring errors."""
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except (OSError, ProcessLookupError):
+        pass
+
+
+# ── Browser Recording ────────────────────────────────────────────────────
+
+def record_browser(url: str, name: str, duration: int) -> Dict[str, Any]:
+    """Record a Chromium browser session visiting a URL as 1080p MP4.
+
+    Starts Xvfb virtual display, ffmpeg screen capture, and Chromium.
+    Cleans up all processes on completion or failure.
+    """
+    # Dependency checks
+    missing = []
+    if not _check_binary("Xvfb"):
+        missing.append("Xvfb (apt install xvfb)")
+    if not _check_binary("ffmpeg"):
+        missing.append("ffmpeg (apt install ffmpeg)")
+    if not Path(CHROMIUM_PATH).exists():
+        missing.append(f"Chromium at {CHROMIUM_PATH}")
+    if missing:
+        return {
+            "recorded": False,
+            "error": "missing_dependencies",
+            "message": f"Required binaries not found: {', '.join(missing)}",
+        }
+
+    if not url:
+        return {"recorded": False, "error": "missing_url", "message": "url is required for browser mode"}
+
+    duration = min(max(1, duration), MAX_DURATION)
+    _ensure_dirs()
+
+    output_path = VIDEOS_DIR / f"{name}.mp4"
+    display = f":{DISPLAY_NUM}"
+
+    xvfb_proc = None
+    ffmpeg_proc = None
+    chrome_proc = None
+
+    try:
+        # 1. Start virtual display
+        xvfb_proc = subprocess.Popen(
+            ["Xvfb", display, "-screen", "0", f"{DEFAULT_WIDTH}x{DEFAULT_HEIGHT}x24"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        time.sleep(1)
+
+        env = os.environ.copy()
+        env["DISPLAY"] = display
+
+        # 2. Start ffmpeg recording
+        ffmpeg_proc = subprocess.Popen(
+            [
+                "ffmpeg", "-y",
+                "-video_size", f"{DEFAULT_WIDTH}x{DEFAULT_HEIGHT}",
+                "-framerate", "30",
+                "-f", "x11grab", "-i", display,
+                "-t", str(duration),
+                "-c:v", "libx264", "-preset", "ultrafast", "-crf", "23",
+                "-pix_fmt", "yuv420p",
+                str(output_path),
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            env=env,
+        )
+        time.sleep(1)
+
+        # 3. Launch Chromium
+        chrome_proc = subprocess.Popen(
+            [
+                CHROMIUM_PATH,
+                "--no-sandbox",
+                "--disable-gpu",
+                "--disable-dev-shm-usage",
+                f"--window-size={DEFAULT_WIDTH},{DEFAULT_HEIGHT}",
+                "--start-maximized",
+                url,
+            ],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            env=env,
+        )
+
+        # 4. Wait for ffmpeg to finish (it will stop after -t duration)
+        ffmpeg_proc.wait(timeout=duration + 30)
+
+        return {
+            "recorded": True,
+            "mode": "browser",
+            "files": {
+                "mp4": str(output_path),
+            },
+            "duration": duration,
+            "size_kb": _file_size_kb(output_path),
+            "url": url,
+        }
+
+    except subprocess.TimeoutExpired:
+        if ffmpeg_proc:
+            ffmpeg_proc.kill()
+        return {
+            "recorded": False,
+            "error": "timeout",
+            "message": f"Recording timed out after {duration + 30}s",
+        }
+    except Exception as e:
+        logger.error("Browser recording failed: %s", e)
+        return {
+            "recorded": False,
+            "error": "recording_failed",
+            "message": str(e),
+        }
+    finally:
+        # Always clean up processes
+        if chrome_proc and chrome_proc.poll() is None:
+            _kill_pid(chrome_proc.pid)
+        if ffmpeg_proc and ffmpeg_proc.poll() is None:
+            _kill_pid(ffmpeg_proc.pid)
+        if xvfb_proc and xvfb_proc.poll() is None:
+            _kill_pid(xvfb_proc.pid)
+
+
+# ── Terminal Recording ───────────────────────────────────────────────────
+
+def record_terminal(name: str, duration: int, script: str = "") -> Dict[str, Any]:
+    """Record a terminal session as .cast + GIF + MP4.
+
+    Uses asciinema to record, agg to convert to GIF, ffmpeg for MP4.
+    If script is provided, it runs non-interactively via asciinema rec -c.
+    """
+    missing = []
+    if not _check_binary("asciinema"):
+        missing.append("asciinema (pip install asciinema)")
+    if not _check_binary("agg"):
+        missing.append("agg (cargo install agg)")
+    if not _check_binary("ffmpeg"):
+        missing.append("ffmpeg (apt install ffmpeg)")
+    if missing:
+        return {
+            "recorded": False,
+            "error": "missing_dependencies",
+            "message": f"Required binaries not found: {', '.join(missing)}",
+        }
+
+    duration = min(max(1, duration), MAX_DURATION)
+    _ensure_dirs()
+
+    cast_path = CASTS_DIR / f"{name}.cast"
+    gif_path = GIFS_DIR / f"{name}.gif"
+    mp4_path = VIDEOS_DIR / f"{name}.mp4"
+
+    try:
+        # 1. Record with asciinema
+        asciinema_cmd = [
+            "asciinema", "rec", str(cast_path),
+            "--overwrite", "--cols", "120", "--rows", "35",
+        ]
+
+        if script:
+            # Run a command non-interactively
+            asciinema_cmd.extend(["-c", script])
+            result = subprocess.run(
+                asciinema_cmd,
+                timeout=duration + 10,
+                capture_output=True,
+                text=True,
+            )
+        else:
+            # Record idle terminal for specified duration
+            # Use a simple sleep command to fill the duration
+            asciinema_cmd.extend(["-c", f"sleep {duration}"])
+            result = subprocess.run(
+                asciinema_cmd,
+                timeout=duration + 10,
+                capture_output=True,
+                text=True,
+            )
+
+        if not cast_path.exists():
+            return {
+                "recorded": False,
+                "error": "asciinema_failed",
+                "message": f"asciinema did not produce output: {result.stderr}",
+            }
+
+        files = {"cast": str(cast_path)}
+
+        # 2. Convert to GIF via agg
+        agg_result = subprocess.run(
+            [
+                "agg", str(cast_path), str(gif_path),
+                "--font-size", "16",
+                "--theme", "monokai",
+                "--speed", "1.5",
+                "--cols", "120",
+                "--rows", "35",
+            ],
+            timeout=60,
+            capture_output=True,
+            text=True,
+        )
+        if gif_path.exists():
+            files["gif"] = str(gif_path)
+
+        # 3. Convert GIF to MP4 via ffmpeg
+        if gif_path.exists():
+            ffmpeg_result = subprocess.run(
+                [
+                    "ffmpeg", "-y", "-i", str(gif_path),
+                    "-movflags", "faststart",
+                    "-pix_fmt", "yuv420p",
+                    "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
+                    str(mp4_path),
+                ],
+                timeout=60,
+                capture_output=True,
+                text=True,
+            )
+            if mp4_path.exists():
+                files["mp4"] = str(mp4_path)
+
+        return {
+            "recorded": True,
+            "mode": "terminal",
+            "files": files,
+            "duration": duration,
+            "size_kb": _file_size_kb(mp4_path) or _file_size_kb(gif_path) or _file_size_kb(cast_path),
+        }
+
+    except subprocess.TimeoutExpired:
+        return {
+            "recorded": False,
+            "error": "timeout",
+            "message": f"Terminal recording timed out after {duration + 10}s",
+        }
+    except Exception as e:
+        logger.error("Terminal recording failed: %s", e)
+        return {
+            "recorded": False,
+            "error": "recording_failed",
+            "message": str(e),
+        }
+
+
+# ── Screenshot ───────────────────────────────────────────────────────────
+
+def take_screenshot(url: str, name: str) -> Dict[str, Any]:
+    """Take a single screenshot of a URL using headless Chromium.
+
+    Returns PNG path. Useful for audit evidence and visual regression.
+    """
+    if not Path(CHROMIUM_PATH).exists():
+        return {
+            "recorded": False,
+            "error": "missing_dependencies",
+            "message": f"Chromium not found at {CHROMIUM_PATH}",
+        }
+
+    if not url:
+        return {"recorded": False, "error": "missing_url", "message": "url is required for screenshot"}
+
+    _ensure_dirs()
+    output_path = SCREENSHOTS_DIR / f"{name}.png"
+
+    try:
+        result = subprocess.run(
+            [
+                CHROMIUM_PATH,
+                "--headless",
+                "--no-sandbox",
+                "--disable-gpu",
+                "--disable-dev-shm-usage",
+                f"--window-size={DEFAULT_WIDTH},{DEFAULT_HEIGHT}",
+                f"--screenshot={output_path}",
+                url,
+            ],
+            timeout=30,
+            capture_output=True,
+            text=True,
+        )
+
+        if output_path.exists():
+            return {
+                "recorded": True,
+                "mode": "screenshot",
+                "files": {
+                    "png": str(output_path),
+                },
+                "size_kb": _file_size_kb(output_path),
+                "url": url,
+            }
+        else:
+            return {
+                "recorded": False,
+                "error": "screenshot_failed",
+                "message": f"Chromium did not produce screenshot: {result.stderr[:500]}",
+            }
+
+    except subprocess.TimeoutExpired:
+        return {
+            "recorded": False,
+            "error": "timeout",
+            "message": "Screenshot timed out after 30s",
+        }
+    except Exception as e:
+        logger.error("Screenshot failed: %s", e)
+        return {
+            "recorded": False,
+            "error": "screenshot_failed",
+            "message": str(e),
+        }