pressbridge 1.1.0__py3-none-any.whl

pressbridge/__init__.py

@@ -0,0 +1,3 @@
+"""PressBridge: give Claude safe, audited access to WordPress sites."""
+
+__version__ = "1.1.0"

pressbridge/__main__.py

@@ -0,0 +1,166 @@
+"""Command line entry point.
+
+    pressbridge serve --config config.yaml              # stdio (Claude Desktop / Claude Code, local)
+    pressbridge serve --config config.yaml --http       # HTTPS-ready HTTP server (Pro)
+    pressbridge check --config config.yaml              # validate config and WP-CLI access
+    pressbridge token                                   # print a new random token
+    pressbridge watch run|daemon|status|report|test-alert   # security watch (Agent)
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import secrets
+import shutil
+import sys
+
+from . import __version__
+from .config import ConfigError, load_config
+from .edition import EDITION
+
+
+def _cmd_check(cfg) -> int:
+    from . import wpcli
+
+    ok = True
+    print(f"PressBridge {__version__} ({EDITION})")
+    print(f"Data dir: {cfg.data_dir}")
+    if not shutil.which(cfg.wp_bin):
+        print(f"  ! WP-CLI '{cfg.wp_bin}' not found on PATH")
+        ok = False
+    for s in cfg.sites.values():
+        print(f"- {s.name}: root={s.root} mode={s.mode} wp={s.wp_path or 'none'} profile={s.wp_profile}")
+        if s.wp_path and shutil.which(cfg.wp_bin):
+            r = wpcli.run(cfg, s, ["core", "version"])
+            if r["exit_code"] == 0:
+                print(f"    WordPress {r['stdout'].strip()}")
+            else:
+                ok = False
+                print(f"    ! WP-CLI failed: {r['stderr'].strip()[:300]}")
+    print("OK" if ok else "Problems found")
+    return 0 if ok else 1
+
+
+def _cmd_watch(cfg, a) -> int:
+    if EDITION != "agent":
+        print("PressBridge Watch is part of PressBridge Agent (https://pressbridgesupport.github.io/pressbridge).", file=sys.stderr)
+        return 2
+    from .watch import parse_settings
+    from .watch import runner
+
+    try:
+        settings = parse_settings(cfg.watch)
+    except ConfigError as e:
+        print(f"Config error: {e}", file=sys.stderr)
+        return 2
+
+    if a.watch_cmd == "status":
+        print(runner.status(cfg, settings))
+        return 0
+    if a.watch_cmd == "report":
+        p = runner.watch_dir(cfg) / "reports" / "latest.txt"
+        print(p.read_text() if p.exists() else "No report yet. Run: pressbridge watch run")
+        return 0
+    if a.watch_cmd == "test-alert":
+        errors = runner.test_alert(settings)
+        for e in errors:
+            print(f"! {e}", file=sys.stderr)
+        if not errors:
+            print("Test alert sent.")
+        return 1 if errors else 0
+    if a.watch_cmd == "daemon":
+        try:
+            runner.daemon(cfg, settings, run_now=a.now, log=lambda m: print(m, flush=True))
+        except KeyboardInterrupt:
+            pass
+        return 0
+
+    try:
+        result = runner.run_once(cfg, settings, sites=a.site, notify=not a.no_notify,
+                                 use_claude=not a.no_claude, force_notify=a.notify_always,
+                                 save=not a.dry_run)
+    except (RuntimeError, ValueError) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 3
+    print(result.report_path.read_text() if result.report_path else "")
+    if result.notified:
+        print("Alert sent.")
+    for e in result.delivery_errors:
+        print(f"! Alert delivery failed: {e}", file=sys.stderr)
+    return result.exit_code
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="pressbridge", description="Safe WordPress access for Claude")
+    p.add_argument("--version", action="version", version=f"pressbridge {__version__} ({EDITION})")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    serve = sub.add_parser("serve", help="Run the MCP server")
+    serve.add_argument("--config", default=os.environ.get("PRESSBRIDGE_CONFIG", "/config/config.yaml"))
+    serve.add_argument("--http", action="store_true", help="Serve over HTTP instead of stdio (Pro)")
+    serve.add_argument("--port", type=int, default=int(os.environ.get("PRESSBRIDGE_PORT", "8765")))
+    serve.add_argument("--host", default=os.environ.get("PRESSBRIDGE_HOST", "0.0.0.0"),
+                       help="Interface to bind in HTTP mode (use 127.0.0.1 behind a proxy on the host network)")
+
+    check = sub.add_parser("check", help="Validate the config and WP-CLI access")
+    check.add_argument("--config", default=os.environ.get("PRESSBRIDGE_CONFIG", "/config/config.yaml"))
+
+    sub.add_parser("token", help="Generate a random bearer token")
+
+    watch = sub.add_parser("watch", help="Security watch: nightly checks and alerts (Agent edition)")
+    watch.add_argument("--config", default=os.environ.get("PRESSBRIDGE_CONFIG", "/config/config.yaml"))
+    wsub = watch.add_subparsers(dest="watch_cmd", required=True)
+    w_run = wsub.add_parser("run", help="Check all sites once now")
+    w_run.add_argument("--site", action="append", help="Only this site (repeatable)")
+    w_run.add_argument("--no-notify", action="store_true", help="Don't send alerts")
+    w_run.add_argument("--no-claude", action="store_true", help="Skip Claude's review")
+    w_run.add_argument("--notify-always", action="store_true", help="Send the report even if all is clear")
+    w_run.add_argument("--dry-run", action="store_true", help="Don't save the new baseline (compare only)")
+    w_daemon = wsub.add_parser("daemon", help="Run on the schedule, forever (for Docker or systemd)")
+    w_daemon.add_argument("--now", action="store_true", help="Also run once at start")
+    wsub.add_parser("status", help="Show the last run, the next run and each site's baseline")
+    wsub.add_parser("test-alert", help="Send a test alert to every configured channel")
+    wsub.add_parser("report", help="Print the latest report")
+
+    a = p.parse_args(argv)
+    if a.cmd == "token":
+        print(secrets.token_hex(32))
+        return 0
+
+    try:
+        cfg = load_config(a.config)
+    except ConfigError as e:
+        print(f"Config error: {e}", file=sys.stderr)
+        return 2
+
+    if a.cmd == "check":
+        return _cmd_check(cfg)
+
+    if a.cmd == "watch":
+        return _cmd_watch(cfg, a)
+
+    if a.http:
+        if EDITION == "free":
+            print("HTTP mode is a PressBridge Pro feature. Free runs over stdio.", file=sys.stderr)
+            return 2
+        import uvicorn
+
+        from .server import build_http_app
+
+        try:
+            app = build_http_app(cfg)
+        except ConfigError as e:
+            print(f"Config error: {e}", file=sys.stderr)
+            return 2
+        uvicorn.run(app, host=a.host, port=a.port, log_level="info", proxy_headers=True,
+                    forwarded_allow_ips="*")
+        return 0
+
+    from .server import build_server
+
+    build_server(cfg).run("stdio")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pressbridge/audit.py

@@ -0,0 +1,58 @@
+"""Append-only JSON Lines audit log of every tool call."""
+from __future__ import annotations
+
+import json
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+
+_lock = threading.Lock()
+_MAX_FIELD = 500
+
+
+def _shorten(value):
+    if isinstance(value, str) and len(value) > _MAX_FIELD:
+        return value[:_MAX_FIELD] + f"... [{len(value)} chars]"
+    if isinstance(value, list):
+        return [_shorten(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _shorten(v) for k, v in value.items()}
+    return value
+
+
+def record(log_path: Path, *, tool: str, site: str | None, args: dict, ok: bool, error: str | None = None,
+           result_summary: dict | None = None) -> None:
+    entry = {
+        "ts": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "tool": tool,
+        "site": site,
+        "args": _shorten(args),
+        "ok": ok,
+    }
+    if error:
+        entry["error"] = error[:_MAX_FIELD]
+    if result_summary:
+        entry["result"] = result_summary
+    line = json.dumps(entry, ensure_ascii=False)
+    with _lock:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        with log_path.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+
+
+def tail(log_path: Path, limit: int = 50, site: str | None = None) -> list[dict]:
+    if not log_path.exists():
+        return []
+    lines = log_path.read_text(encoding="utf-8").splitlines()
+    out: list[dict] = []
+    for line in reversed(lines):
+        try:
+            item = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if site and item.get("site") != site:
+            continue
+        out.append(item)
+        if len(out) >= limit:
+            break
+    return out

pressbridge/config.py

@@ -0,0 +1,208 @@
+"""Configuration loading for PressBridge.
+
+A single YAML file describes the WordPress sites the server may touch,
+what each one is allowed to do, and where audit logs and backups live.
+Secrets (bearer tokens) are pulled from environment variables so the
+config file itself can be committed safely.
+"""
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from .edition import EDITION
+
+DEFAULT_DENY = [
+    "wp-config*",
+    ".env",
+    ".env.*",
+    ".htpasswd",
+    ".git",
+    ".git/*",
+    "*.sql",
+    "*.sql.gz",
+    "*.sqlite",
+    "*.sqlite3",
+    ".ht.sqlite",
+    "*.wpress",
+    "backup*.zip",
+    "*.key",
+    "*.pem",
+    "id_rsa*",
+    "debug.log",
+]
+
+VALID_MODES = ("read", "write")
+VALID_PROFILES = ("readonly", "maintenance")
+_ENV_REF = re.compile(r"\$\{([A-Z0-9_]+)\}")
+
+
+class ConfigError(ValueError):
+    """Raised when the config file is missing or invalid."""
+
+
+@dataclass
+class Site:
+    name: str
+    root: Path
+    mode: str = "read"
+    wp_path: Path | None = None
+    wp_profile: str = "readonly"
+    wp_url: str | None = None
+    deny: list[str] = field(default_factory=lambda: list(DEFAULT_DENY))
+    max_read_bytes: int = 512_000
+    max_write_bytes: int = 2_000_000
+    watched: bool = True
+
+    @property
+    def writable(self) -> bool:
+        return self.mode == "write"
+
+
+@dataclass
+class Config:
+    sites: dict[str, Site]
+    data_dir: Path
+    wp_bin: str = "wp"
+    wp_timeout: int = 120
+    tokens: list[str] = field(default_factory=list)
+    allowed_hosts: list[str] = field(default_factory=list)
+    wp_env: list[str] = field(default_factory=list)
+    watch: dict = field(default_factory=dict)
+
+    @property
+    def audit_log(self) -> Path:
+        return self.data_dir / "audit.jsonl"
+
+    def backup_root(self, site: Site) -> Path:
+        return self.data_dir / "backups" / site.name
+
+    def trash_root(self, site: Site) -> Path:
+        return self.data_dir / "trash" / site.name
+
+    def site(self, name: str | None) -> Site:
+        if not name:
+            if len(self.sites) == 1:
+                return next(iter(self.sites.values()))
+            raise ConfigError(
+                "Several sites are configured; pass `site`. Known sites: "
+                + ", ".join(sorted(self.sites))
+            )
+        try:
+            return self.sites[name]
+        except KeyError:
+            raise ConfigError(
+                f"Unknown site '{name}'. Known sites: " + ", ".join(sorted(self.sites))
+            ) from None
+
+
+def _expand_env(value):
+    if isinstance(value, str):
+        def repl(m: re.Match) -> str:
+            # Unset variables become "", and empty tokens/hosts are dropped later.
+            # HTTP mode refuses to start without a token, so this cannot open a hole.
+            return os.environ.get(m.group(1), "")
+        return _ENV_REF.sub(repl, value)
+    if isinstance(value, list):
+        return [_expand_env(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _expand_env(v) for k, v in value.items()}
+    return value
+
+
+def _parse_site(name: str, raw: dict) -> Site:
+    if not re.fullmatch(r"[a-z0-9][a-z0-9_-]{0,62}", name):
+        raise ConfigError(f"Site name '{name}' must be lowercase letters, digits, '-' or '_'")
+    if not isinstance(raw, dict) or "root" not in raw:
+        raise ConfigError(f"Site '{name}' needs a `root` path")
+    root = Path(raw["root"]).expanduser()
+    if not root.is_absolute():
+        raise ConfigError(f"Site '{name}': root must be an absolute path")
+    if not root.is_dir():
+        raise ConfigError(f"Site '{name}': root {root} does not exist or is not a directory")
+
+    mode = raw.get("mode", "read")
+    if mode not in VALID_MODES:
+        raise ConfigError(f"Site '{name}': mode must be one of {VALID_MODES}")
+    profile = raw.get("wp_profile", "readonly")
+    if profile not in VALID_PROFILES:
+        raise ConfigError(f"Site '{name}': wp_profile must be one of {VALID_PROFILES}")
+    if profile == "maintenance" and mode != "write":
+        raise ConfigError(f"Site '{name}': wp_profile 'maintenance' requires mode 'write'")
+
+    wp_path = raw.get("wp_path")
+    wp_path = Path(wp_path) if wp_path else None
+    if wp_path is None and (root / "wp-includes").is_dir():
+        wp_path = root
+
+    deny = list(DEFAULT_DENY)
+    if raw.get("replace_default_deny"):
+        deny = []
+    deny += list(raw.get("deny", []))
+    for pattern in raw.get("allow", []):
+        if pattern in deny:
+            deny.remove(pattern)
+
+    return Site(
+        name=name,
+        root=root.resolve(),
+        mode=mode,
+        wp_path=wp_path.resolve() if wp_path else None,
+        wp_profile=profile,
+        wp_url=raw.get("wp_url"),
+        deny=deny,
+        max_read_bytes=int(raw.get("max_read_bytes", 512_000)),
+        max_write_bytes=int(raw.get("max_write_bytes", 2_000_000)),
+        watched=bool(raw.get("watch", True)),
+    )
+
+
+def load_config(path: str | Path) -> Config:
+    path = Path(path)
+    if not path.is_file():
+        raise ConfigError(f"Config file not found: {path}")
+    try:
+        raw = yaml.safe_load(path.read_text()) or {}
+    except yaml.YAMLError as e:
+        raise ConfigError(f"Config file is not valid YAML: {e}") from e
+    raw = _expand_env(raw)
+
+    sites_raw = raw.get("sites") or {}
+    if not sites_raw:
+        raise ConfigError("Config needs at least one entry under `sites`")
+    sites = {name: _parse_site(name, s) for name, s in sites_raw.items()}
+
+    if EDITION == "free":
+        if len(sites) > 1:
+            raise ConfigError(
+                "PressBridge Free supports one site. Remove the extra sites or upgrade to Pro."
+            )
+        for s in sites.values():
+            s.mode = "read"
+            s.wp_profile = "readonly"
+
+    data_dir = Path(raw.get("data_dir", "/data")).expanduser()
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    tokens = raw.get("tokens") or []
+    if isinstance(tokens, str):
+        tokens = [tokens]
+    tokens = [t for t in tokens if t]
+    for t in tokens:
+        if len(t) < 24:
+            raise ConfigError("Each token must be at least 24 characters (use `openssl rand -hex 32`)")
+
+    return Config(
+        sites=sites,
+        data_dir=data_dir.resolve(),
+        wp_bin=raw.get("wp_bin", "wp"),
+        wp_timeout=int(raw.get("wp_timeout", 120)),
+        tokens=tokens,
+        allowed_hosts=[h for h in (raw.get("allowed_hosts") or []) if h],
+        wp_env=[str(v) for v in (raw.get("wp_env") or [])],
+        watch=raw.get("watch") or {},
+    )

pressbridge/edition.py

@@ -0,0 +1 @@
+EDITION = "free"