agent-loop-guard-runtime 0.6.0a2__py3-none-any.whl

app/sandbox/workspace.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import difflib
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import uuid
+import zipfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from app.sandbox.policy import validate_command
+
+IGNORED_NAMES = {".git", ".agent-loop-guard", ".venv", "node_modules", "__pycache__"}
+SESSION_PATTERN = re.compile(r"^sbx_[a-f0-9]{24}$")
+
+
+def docker_available() -> tuple[bool, str]:
+    executable = shutil.which("docker")
+    if not executable:
+        return False, "Docker CLI is not installed. Install Docker in WSL2 or Docker Desktop first."
+    try:
+        result = subprocess.run(
+            [executable, "version", "--format", "{{.Server.Version}}"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return False, str(exc)
+    if result.returncode:
+        return False, result.stderr.strip() or "Docker daemon is not available."
+    return True, result.stdout.strip()
+
+
+def build_docker_command(
+    workspace: Path,
+    image: str,
+    command: list[str],
+    *,
+    network: str = "none",
+    cpus: float = 1.0,
+    memory: str = "1g",
+    pids: int = 128,
+) -> list[str]:
+    validate_command(command)
+    user = f"{os.getuid()}:{os.getgid()}" if hasattr(os, "getuid") else "1000:1000"
+    return [
+        "docker",
+        "run",
+        "--rm",
+        "--init",
+        "--user",
+        user,
+        "--network",
+        network,
+        "--cpus",
+        str(cpus),
+        "--memory",
+        memory,
+        "--pids-limit",
+        str(pids),
+        "--cap-drop",
+        "ALL",
+        "--security-opt",
+        "no-new-privileges",
+        "--read-only",
+        "--tmpfs",
+        "/tmp:rw,noexec,nosuid,size=128m",
+        "--mount",
+        f"type=bind,source={workspace.resolve()},target=/workspace",
+        "--workdir",
+        "/workspace",
+        image,
+        *command,
+    ]
+
+
+class SandboxWorkspace:
+    def __init__(self, root: Path | None = None) -> None:
+        self.root = (root or Path(".agent-loop-guard/sandboxes")).resolve()
+
+    def create(self, source: Path, image: str = "python:3.12-slim") -> dict[str, Any]:
+        available, detail = docker_available()
+        if not available:
+            raise RuntimeError(detail)
+        source = source.resolve()
+        _ensure_safe_source(source)
+        session_id = f"sbx_{uuid.uuid4().hex[:24]}"
+        session_root = self.root / session_id
+        snapshot = session_root / "snapshot"
+        workspace = session_root / "workspace"
+        session_root.mkdir(parents=True)
+        _copy_tree(source, snapshot)
+        _copy_tree(source, workspace)
+        manifest = {
+            "schema_version": "sandbox.v1",
+            "id": session_id,
+            "source": str(source),
+            "image": image,
+            "docker_version": detail,
+            "created_at": datetime.now(UTC).isoformat(),
+            "original_hashes": _file_hashes(snapshot),
+        }
+        _write_manifest(session_root, manifest)
+        return manifest
+
+    def execute(
+        self,
+        session_id: str,
+        command: list[str],
+        *,
+        timeout: float = 300,
+        network: str = "none",
+        cpus: float = 1.0,
+        memory: str = "1g",
+        pids: int = 128,
+    ) -> subprocess.CompletedProcess[str]:
+        session_root, manifest = self._load(session_id)
+        docker_command = build_docker_command(
+            session_root / "workspace",
+            str(manifest["image"]),
+            command,
+            network=network,
+            cpus=cpus,
+            memory=memory,
+            pids=pids,
+        )
+        try:
+            return subprocess.run(
+                docker_command,
+                text=True,
+                capture_output=True,
+                timeout=timeout,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as exc:
+            raise RuntimeError(f"Sandbox command timed out after {timeout:g}s") from exc
+
+    def diff(self, session_id: str) -> list[dict[str, Any]]:
+        session_root, _ = self._load(session_id)
+        snapshot = session_root / "snapshot"
+        workspace = session_root / "workspace"
+        before = _file_hashes(snapshot)
+        after = _file_hashes(workspace)
+        rows = []
+        for path in sorted(set(before) | set(after)):
+            status = "added" if path not in before else "deleted" if path not in after else "modified"
+            if before.get(path) == after.get(path):
+                continue
+            rows.append(
+                {
+                    "path": path,
+                    "status": status,
+                    "before_sha256": before.get(path),
+                    "after_sha256": after.get(path),
+                    "patch": _text_diff(snapshot / path, workspace / path, path),
+                }
+            )
+        return rows
+
+    def apply(self, session_id: str, paths: list[str] | None = None) -> list[str]:
+        session_root, manifest = self._load(session_id)
+        source = Path(str(manifest["source"])).resolve()
+        snapshot = session_root / "snapshot"
+        workspace = session_root / "workspace"
+        changes = {item["path"]: item for item in self.diff(session_id)}
+        selected = sorted(changes) if paths is None else paths
+        unknown = sorted(set(selected) - set(changes))
+        if unknown:
+            raise ValueError(f"Paths are not changed: {', '.join(unknown)}")
+        applied = []
+        for relative in selected:
+            source_path = _contained(source, relative)
+            snapshot_path = _contained(snapshot, relative)
+            workspace_path = _contained(workspace, relative)
+            expected = _hash_file(snapshot_path) if snapshot_path.is_file() else None
+            current = _hash_file(source_path) if source_path.is_file() else None
+            if current != expected:
+                raise RuntimeError(f"Source changed since sandbox creation: {relative}")
+            if workspace_path.is_symlink():
+                raise RuntimeError(f"Refusing to apply symlink: {relative}")
+            if changes[relative]["status"] == "deleted":
+                source_path.unlink(missing_ok=True)
+            else:
+                source_path.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(workspace_path, source_path)
+            applied.append(relative)
+        return applied
+
+    def discard(self, session_id: str) -> None:
+        session_root, _ = self._load(session_id)
+        shutil.rmtree(session_root)
+
+    def export(self, session_id: str, destination: Path) -> Path:
+        session_root, _ = self._load(session_id)
+        destination = destination.resolve()
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(destination, "w", zipfile.ZIP_DEFLATED) as archive:
+            archive.write(session_root / "manifest.json", "manifest.json")
+            archive.writestr("diff.json", json.dumps(self.diff(session_id), indent=2))
+            for path in (session_root / "workspace").rglob("*"):
+                if path.is_file() and not path.is_symlink():
+                    archive.write(path, Path("workspace") / path.relative_to(session_root / "workspace"))
+        return destination
+
+    def _load(self, session_id: str) -> tuple[Path, dict[str, Any]]:
+        if not SESSION_PATTERN.fullmatch(session_id):
+            raise ValueError("Invalid sandbox id")
+        session_root = (self.root / session_id).resolve()
+        if session_root.parent != self.root or not session_root.is_dir():
+            raise FileNotFoundError(f"Sandbox not found: {session_id}")
+        manifest = json.loads((session_root / "manifest.json").read_text(encoding="utf-8"))
+        return session_root, manifest
+
+
+def _ensure_safe_source(source: Path) -> None:
+    if not source.is_dir():
+        raise ValueError(f"Source directory does not exist: {source}")
+    for path in source.rglob("*"):
+        if any(part in IGNORED_NAMES for part in path.relative_to(source).parts):
+            continue
+        if path.is_symlink():
+            raise ValueError(f"Source contains a symlink; sandbox creation refused: {path}")
+
+
+def _ignore(_directory: str, names: list[str]) -> set[str]:
+    return set(names) & IGNORED_NAMES
+
+
+def _copy_tree(source: Path, destination: Path) -> None:
+    shutil.copytree(source, destination, ignore=_ignore)
+
+
+def _write_manifest(session_root: Path, manifest: dict[str, Any]) -> None:
+    (session_root / "manifest.json").write_text(
+        json.dumps(manifest, indent=2, sort_keys=True), encoding="utf-8"
+    )
+
+
+def _file_hashes(root: Path) -> dict[str, str]:
+    return {
+        path.relative_to(root).as_posix(): _hash_file(path)
+        for path in root.rglob("*")
+        if path.is_file() and not path.is_symlink()
+    }
+
+
+def _hash_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _contained(root: Path, relative: str) -> Path:
+    if Path(relative).is_absolute() or ".." in Path(relative).parts:
+        raise ValueError(f"Unsafe relative path: {relative}")
+    candidate = (root / relative).resolve()
+    try:
+        candidate.relative_to(root.resolve())
+    except ValueError as exc:
+        raise ValueError(f"Path escapes workspace: {relative}") from exc
+    return candidate
+
+
+def _text_diff(before: Path, after: Path, label: str) -> str | None:
+    try:
+        before_text = before.read_text(encoding="utf-8").splitlines(keepends=True) if before.exists() else []
+        after_text = after.read_text(encoding="utf-8").splitlines(keepends=True) if after.exists() else []
+    except (OSError, UnicodeDecodeError):
+        return None
+    return "".join(
+        difflib.unified_diff(before_text, after_text, fromfile=f"a/{label}", tofile=f"b/{label}")
+    )

app/static/styles.css

@@ -0,0 +1,327 @@
+:root {
+  color-scheme: light;
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  background: #f6f7f9;
+  color: #18202a;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  display: grid;
+  grid-template-columns: 240px 1fr;
+}
+
+a {
+  color: #0b5cad;
+  text-decoration: none;
+}
+
+.sidebar {
+  background: #101820;
+  color: #f7f9fb;
+  padding: 24px 18px;
+}
+
+.brand {
+  color: #fff;
+  display: block;
+  font-size: 19px;
+  font-weight: 700;
+  margin-bottom: 24px;
+}
+
+nav {
+  display: grid;
+  gap: 6px;
+}
+
+nav a {
+  color: #c9d3df;
+  padding: 9px 10px;
+  border-radius: 6px;
+}
+
+nav a:hover {
+  background: #1d2a36;
+  color: #fff;
+}
+
+.content {
+  padding: 28px 34px 48px;
+  min-width: 0;
+}
+
+.page-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 18px;
+}
+
+h1, h2 {
+  letter-spacing: 0;
+  margin: 0;
+}
+
+h1 {
+  font-size: 28px;
+}
+
+h2 {
+  font-size: 18px;
+  margin-bottom: 14px;
+}
+
+.muted {
+  color: #667382;
+}
+
+.metric-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+  gap: 12px;
+  margin-bottom: 18px;
+}
+
+.metric, .panel, .notice {
+  background: #fff;
+  border: 1px solid #dde3ea;
+  border-radius: 8px;
+}
+
+.metric {
+  padding: 14px 16px;
+}
+
+.metric span {
+  color: #667382;
+  display: block;
+  font-size: 13px;
+  margin-bottom: 6px;
+}
+
+.metric strong {
+  font-size: 24px;
+}
+
+.panel {
+  padding: 18px;
+  margin-bottom: 18px;
+}
+
+.notice {
+  padding: 14px 16px;
+  margin-bottom: 18px;
+  background: #eef8f2;
+  border-color: #b9dec4;
+  display: flex;
+  gap: 16px;
+  align-items: center;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  table-layout: fixed;
+}
+
+th, td {
+  border-bottom: 1px solid #e7ebf0;
+  padding: 10px 8px;
+  text-align: left;
+  vertical-align: middle;
+  overflow-wrap: anywhere;
+}
+
+th {
+  color: #596777;
+  font-size: 12px;
+  text-transform: uppercase;
+}
+
+code {
+  background: #f1f3f6;
+  border: 1px solid #dfe5eb;
+  border-radius: 5px;
+  padding: 2px 5px;
+  font-size: 12px;
+}
+
+button, .button {
+  appearance: none;
+  border: 1px solid #0c5a9e;
+  background: #0c5a9e;
+  color: #fff;
+  border-radius: 6px;
+  padding: 8px 12px;
+  font: inherit;
+  cursor: pointer;
+  display: inline-flex;
+  align-items: center;
+  min-height: 36px;
+}
+
+button.danger {
+  background: #a32929;
+  border-color: #a32929;
+}
+
+button.secondary {
+  background: #fff;
+  color: #0c5a9e;
+}
+
+.timeline {
+  display: grid;
+  gap: 8px;
+  margin-bottom: 18px;
+}
+
+.timeline-row {
+  display: grid;
+  grid-template-columns: minmax(150px, 220px) 1fr 80px;
+  gap: 10px;
+  align-items: center;
+  padding-left: calc(var(--depth) * 12px);
+}
+
+.timeline-track {
+  position: relative;
+  height: 12px;
+  border-radius: 4px;
+  background: #edf1f5;
+  overflow: hidden;
+}
+
+.timeline-bar {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  min-width: 3px;
+  background: #2d7d46;
+}
+
+.timeline-bar.status-error,
+.timeline-bar.status-blocked {
+  background: #b43b3b;
+}
+
+.approval-row {
+  display: grid;
+  grid-template-columns: minmax(260px, 1fr) 180px auto auto;
+  gap: 10px;
+  align-items: center;
+  padding: 10px 0;
+  border-bottom: 1px solid #e7ebf0;
+}
+
+.button.secondary {
+  background: #fff;
+  color: #0c5a9e;
+}
+
+input, select {
+  width: 100%;
+  min-height: 36px;
+  border: 1px solid #ccd5df;
+  border-radius: 6px;
+  padding: 7px 9px;
+  font: inherit;
+}
+
+.inline-form {
+  display: grid;
+  grid-template-columns: minmax(140px, 1fr) minmax(220px, 2fr) auto;
+  gap: 10px;
+  align-items: center;
+}
+
+.actions {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
+.form-actions {
+  display: flex;
+  justify-content: flex-end;
+  margin-top: 14px;
+}
+
+.demo-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
+  gap: 12px;
+}
+
+.demo-grid form {
+  border: 1px solid #e1e6ec;
+  border-radius: 8px;
+  padding: 14px;
+  display: grid;
+  gap: 10px;
+}
+
+.status {
+  border-radius: 999px;
+  padding: 3px 8px;
+  font-size: 12px;
+  background: #edf1f5;
+}
+
+.status-paused {
+  background: #fff0d6;
+}
+
+.status-ended {
+  background: #eceff3;
+}
+
+.status-running {
+  background: #e8f2ff;
+}
+
+.status-ok {
+  background: #e7f6eb;
+}
+
+.status-error, .status-blocked {
+  background: #fde7e7;
+}
+
+.kv th {
+  width: 220px;
+}
+
+@media (max-width: 900px) {
+  body {
+    grid-template-columns: 1fr;
+  }
+
+  .sidebar {
+    position: static;
+  }
+
+  .metric-grid {
+    grid-template-columns: repeat(2, minmax(120px, 1fr));
+  }
+
+  .page-head, .actions {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .inline-form {
+    grid-template-columns: 1fr;
+  }
+
+  .approval-row {
+    grid-template-columns: 1fr;
+  }
+}

app/templates/agents.html

@@ -0,0 +1,48 @@
+{% extends "base.html" %}
+{% block title %}Agents · Agent Loop Guard{% endblock %}
+{% block content %}
+<header class="page-head"><h1>Agents</h1></header>
+{% if created_key %}
+<section class="notice">
+  <strong>{{ created_agent.name }}</strong>
+  <code>{{ created_key }}</code>
+</section>
+{% endif %}
+<section class="panel">
+  <h2>Create Agent Key</h2>
+  <form class="inline-form" action="/agents" method="post">
+    <input name="name" placeholder="Name" required>
+    <input name="project_id" value="default">
+    <select name="protocol">
+      <option value="openai">openai</option>
+      <option value="anthropic">anthropic</option>
+    </select>
+    <button type="submit">Create</button>
+  </form>
+</section>
+<section class="panel">
+  <h2>Local Keys</h2>
+  <table>
+    <thead><tr><th>ID</th><th>Name</th><th>Project</th><th>Protocol</th><th>State</th><th></th></tr></thead>
+    <tbody>
+    {% for agent in agents %}
+      <tr>
+        <td><code>{{ agent.id }}</code></td>
+        <td>{{ agent.name }}</td>
+        <td>{{ agent.project_id }}</td>
+        <td>{{ agent.protocol }}</td>
+        <td>{% if agent.paused %}paused{% elif agent.enabled %}enabled{% else %}disabled{% endif %}</td>
+        <td>
+          {% if agent.paused %}
+          <form action="/agents/{{ agent.id }}/resume" method="post"><button type="submit">Resume</button></form>
+          {% else %}
+          <form action="/agents/{{ agent.id }}/pause" method="post"><button type="submit">Pause</button></form>
+          {% endif %}
+        </td>
+      </tr>
+    {% endfor %}
+    </tbody>
+  </table>
+</section>
+{% endblock %}
+

app/templates/base.html

@@ -0,0 +1,27 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>{% block title %}Agent Loop Guard{% endblock %}</title>
+  <link rel="stylesheet" href="/static/styles.css">
+</head>
+<body>
+  <aside class="sidebar">
+    <a class="brand" href="/">Agent Loop Guard</a>
+    <nav>
+      <a href="/">Dashboard</a>
+      <a href="/sessions">Sessions</a>
+      <a href="/replay">Replay</a>
+      <a href="/mcp">MCP Firewall</a>
+      <a href="/demo">Demo Lab</a>
+      <a href="/policies">Policies</a>
+      <a href="/agents">Agents</a>
+      <a href="/settings">Settings</a>
+    </nav>
+  </aside>
+  <main class="content">
+    {% block content %}{% endblock %}
+  </main>
+</body>
+</html>