vanth 1.0.0__py3-none-win_amd64.whl

vanth/__init__.py

@@ -0,0 +1,13 @@
+__all__ = ["__version__"]
+
+
+def _package_version() -> str:
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+
+        return version("vanth")
+    except PackageNotFoundError:  # source checkout, not installed
+        return "0.0.0"
+
+
+__version__ = _package_version()

vanth/__main__.py

@@ -0,0 +1,3 @@
+from .server import main
+
+main()

vanth/agent_events.py

@@ -0,0 +1,26 @@
+import json
+
+
+def agent_event(event_type: str, message: str | None = None, **data: object) -> None:
+    payload: dict[str, object] = {"type": event_type, "data": data}
+    if message is not None:
+        payload["message"] = message
+    print("AGENT_EVENT " + json.dumps(payload, separators=(",", ":")), flush=True)
+
+
+def progress(
+    current: float,
+    total: float | None = None,
+    unit: str | None = None,
+    stage: str | None = None,
+    message: str | None = None,
+) -> None:
+    data: dict[str, object] = {"current": current}
+    if total is not None:
+        data["total"] = total
+        data["percent"] = round((current / total) * 100, 2) if total else 0
+    if unit is not None:
+        data["unit"] = unit
+    if stage is not None:
+        data["stage"] = stage
+    agent_event("progress", message, **data)

vanth/agent_logger.py

@@ -0,0 +1,60 @@
+"""Loguru-based structured logging for Vanth jobs.
+
+`from vanth.agent_logger import logger` then `logger.info(...)`. Every record is
+routed to stdout as an `AGENT_EVENT` line with a `log` type, so the daemon
+persists it as a timestamped, level-aware structured event (visible in the exact
+event table) instead of a bare text line.
+
+Unlike a plain `print`, loguru gives you levels, timestamps, exception
+capture, and the option to also mirror records to a file or stderr while keeping
+the Vanth event stream clean.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from loguru import logger as _logger
+
+
+def _vanth_sink(message: Any) -> None:
+    record = message.record
+    payload = {
+        "type": "log",
+        "level": record["level"].name.lower(),
+        "message": record["message"],
+    }
+    extra = _clean_extra(dict(record.get("extra") or {}))
+    if extra:
+        payload["data"] = extra
+    exception = record.get("exception")
+    if exception is not None and exception.type is not None:
+        payload["message"] = f"{payload['message']} :: {exception.type.__name__}: {exception.value}"
+    print("AGENT_EVENT " + _json(payload), flush=True)
+
+
+def _json(payload: dict[str, Any]) -> str:
+    import json
+
+    return json.dumps(payload, separators=(",", ":"), ensure_ascii=False, default=str)
+
+
+# A module-level logger whose default sink emits AGENT_EVENT log lines. The
+# original stderr default is removed so records do not double-print.
+logger = _logger.bind(__name__="vanth")
+logger.remove()  # drop loguru's default stderr sink
+logger.add(_vanth_sink, format="{message}", level="TRACE")
+
+
+def _clean_extra(extra: dict[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in extra.items() if key != "__name__"}
+
+
+def log_with_context(level: str, message: str, **context: Any) -> None:
+    """Emit a log event with extra context carried in the event `data`."""
+    method = getattr(logger, level.lower(), logger.info)
+    method(message, **context)
+
+
+__all__ = ["logger", "log_with_context"]

vanth/cli.py

@@ -0,0 +1,273 @@
+"""Human-facing CLI for the Vanth daemon.
+
+Unlike the MCP tools (which are JSON request/response over stdio), these
+commands are meant for a person at a terminal: ``vanth status``, ``vanth
+doctor``, ``vanth restart``. They read the same daemon discovery metadata and
+speak the same authenticated loopback HTTP, but print readable output and exit
+with a meaningful status code (0 = healthy, 1 = problem, 2 = usage).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from .client import VanthClient
+from .paths import canonical_home
+
+
+def _discovery(home: Path) -> dict[str, Any] | None:
+    try:
+        payload = json.loads((home / "daemon.json").read_text(encoding="utf-8"))
+        return payload if isinstance(payload, dict) else None
+    except (OSError, ValueError):
+        return None
+
+
+def _daemon_version() -> str:
+    """Best-effort version of the installed package (not the daemon process)."""
+    try:
+        from . import __version__
+
+        return __version__
+    except Exception:
+        return "unknown"
+
+
+def _health(url: str, token: str) -> dict[str, Any] | None:
+    """Return the /health payload, or None if the daemon is unreachable."""
+    try:
+        request = urllib.request.Request(
+            url + "/health", headers={"Authorization": f"Bearer {token}"}
+        )
+        with urllib.request.urlopen(request, timeout=2) as response:
+            return json.loads(response.read().decode())
+    except Exception:
+        return None
+
+
+def _pid_alive(pid: int) -> bool:
+    """Return whether a process with the given PID is running."""
+    if not pid:
+        return False
+    if sys.platform == "win32":
+        try:
+            result = subprocess.run(
+                ["tasklist", "/FI", f"PID eq {pid}", "/NH"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+                timeout=2,
+            )
+            return str(pid) in result.stdout
+        except Exception:
+            return True  # assume alive on probe failure
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False
+
+
+def cmd_status(home: Path, *, json_out: bool = False) -> int:
+    disc = _discovery(home)
+    url = disc["url"] if disc else None
+    token_path = home / "token"
+    token = token_path.read_text(encoding="utf-8").strip() if token_path.exists() else ""
+
+    up = False
+    health = None
+    doctor = None
+    if url and token:
+        health = _health(url, token)
+        if health is not None:
+            up = True
+            try:
+                client = VanthClient(url, home)
+                doctor = client.get("/doctor")
+            except Exception:
+                doctor = None
+
+    if json_out:
+        payload = {
+            "up": up,
+            "url": url,
+            "pid": disc.get("pid") if disc else None,
+            "daemon_schema_version": disc.get("schema_version") if disc else None,
+            "started_at": disc.get("started_at") if disc else None,
+            "package_version": _daemon_version(),
+            "health": health,
+            "doctor": doctor,
+        }
+        print(json.dumps(payload, indent=2, default=str))
+        return 0 if up else 1
+
+    running = []
+    if up:
+        try:
+            client = VanthClient(url, home)
+            running = client.get("/jobs", {"status": ["running"]}).get("jobs", [])
+        except Exception:
+            running = []
+
+    print(f"vanth daemon: {'UP' if up else 'DOWN'}")
+    print(f"  home:     {home}")
+    print(f"  url:      {url or '(no daemon.json - never started)'}")
+    if disc:
+        print(f"  pid:      {disc.get('pid')}")
+        print(f"  schema:   {disc.get('schema_version')}")
+        print(f"  started:  {disc.get('started_at')}")
+    print(f"  package:  {_daemon_version()}")
+    if doctor:
+        print(f"  running jobs: {len(running)}")
+        for job in running[:10]:
+            print(f"    - {job.get('job_id')}  {job.get('name') or ''}  ({job.get('status')})")
+        print(f"  schema (db):  {doctor.get('schema_version')}")
+        counts = doctor.get("delivery_counts") or {}
+        if counts:
+            print(f"  deliveries:   {counts}")
+        if doctor.get("warnings"):
+            print("  warnings:")
+            for warning in doctor["warnings"]:
+                print(f"    - {warning.get('type')}: {warning}")
+    elif up:
+        print("  doctor:   unreachable (auth/schema problem)")
+    return 0 if up else 1
+
+
+def cmd_doctor(home: Path, *, json_out: bool = False) -> int:
+    client = VanthClient(home=home)
+    try:
+        client.ensure()
+        report = client.get("/doctor")
+    except Exception as exc:
+        print(f"vanth doctor: failed to reach daemon: {exc}")
+        return 1
+    if json_out:
+        print(json.dumps(report, indent=2, default=str))
+    else:
+        ok = report.get("ok")
+        print(f"vanth doctor: {'OK' if ok else 'PROBLEM'}")
+        print(f"  home:          {report.get('home')}")
+        print(f"  schema:        {report.get('schema_version')}")
+        print(f"  tables:        {len(report.get('tables', []))}")
+        print(f"  deliveries:    {report.get('delivery_counts')}")
+        print(f"  codex:         {'available' if report.get('codex', {}).get('available') else 'MISSING'}")
+        print(f"  opencode:      {'available' if report.get('opencode', {}).get('available') else 'MISSING'}")
+        print(f"  quick_check:   {report.get('quick_check')}")
+        print(f"  disk_free:     {_fmt_bytes(report.get('disk_free_bytes', 0))}")
+        for warning in report.get("warnings", []):
+            print(f"  WARNING:       {warning}")
+    return 0 if report.get("ok") else 1
+
+
+def _fmt_bytes(n: int) -> str:
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+        if n < 1024 or unit == "TiB":
+            return f"{n:.1f} {unit}" if unit != "B" else f"{n} B"
+        n /= 1024
+    return f"{n:.1f} TiB"
+
+
+def cmd_restart(home: Path, *, json_out: bool = False) -> int:
+    """Gracefully stop the daemon (if running) and start it again fresh.
+
+    In-flight jobs are owned by detached runner processes, so they survive the
+    daemon restart; the new daemon reconciles them on startup. This is the
+    reliable way to pick up a code/version update.
+    """
+    disc = _discovery(home)
+    url = disc["url"] if disc else None
+    token_path = home / "token"
+    token = token_path.read_text(encoding="utf-8").strip() if token_path.exists() else ""
+    was_up = bool(url and token and _health(url, token) is not None)
+    old_pid = disc.get("pid") if disc else None
+
+    if was_up:
+        # Ask the daemon to shut down gracefully.
+        try:
+            request = urllib.request.Request(
+                url + "/shutdown",
+                data=b"{}",
+                headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
+                method="POST",
+            )
+            with urllib.request.urlopen(request, timeout=5) as response:
+                response.read()
+        except urllib.error.HTTPError as exc:
+            print(f"vanth restart: warning: shutdown returned HTTP {exc.code}: {exc.read()!r}", file=sys.stderr)
+        except Exception as exc:
+            print(f"vanth restart: warning: shutdown request failed: {exc}", file=sys.stderr)
+        # Wait until the old daemon is truly gone: port closed, discovery
+        # metadata removed, and the old process (if known) has exited so the
+        # home lock is released before the new daemon starts.
+        deadline = time.monotonic() + 15
+        while time.monotonic() < deadline:
+            health_down = _health(url, token) is None
+            metadata_gone = not (home / "daemon.json").exists()
+            pid_gone = True
+            if old_pid and sys.platform == "win32":
+                pid_gone = not _pid_alive(old_pid)
+            elif old_pid:
+                pid_gone = not _pid_alive(old_pid)
+            if health_down and metadata_gone and pid_gone:
+                break
+            time.sleep(0.2)
+
+    # Start fresh and verify a new process is actually serving.
+    client = VanthClient(home=home)
+    try:
+        # The old process may still be releasing its home lock; retry briefly.
+        last_error: Exception | None = None
+        doctor = None
+        for _ in range(20):
+            try:
+                client.ensure()
+                doctor = client.get("/doctor")
+                break
+            except Exception as exc:  # noqa: BLE001 - retry transient lock races
+                last_error = exc
+                time.sleep(0.25)
+        if doctor is None:
+            raise last_error or RuntimeError("vanthd did not start")
+    except Exception as exc:
+        if json_out:
+            print(json.dumps({"ok": False, "error": str(exc)}))
+        else:
+            print(f"vanth restart: failed to start daemon: {exc}")
+        return 1
+    if json_out:
+        print(json.dumps({"ok": True, "restarted_from_running": was_up, "schema_version": doctor.get("schema_version")}))
+    else:
+        print(f"vanth restart: daemon {'restarted' if was_up else 'started'} (schema v{doctor.get('schema_version')})")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    home = canonical_home()
+    json_out = "--json" in argv
+    argv = [arg for arg in argv if arg != "--json"]
+    if not argv:
+        print(__doc__, file=sys.stderr)
+        return 2
+    command = argv[0]
+    if command == "status":
+        return cmd_status(home, json_out=json_out)
+    if command == "doctor":
+        return cmd_doctor(home, json_out=json_out)
+    if command == "restart":
+        return cmd_restart(home, json_out=json_out)
+    print(f"vanth: unknown command {command!r}", file=sys.stderr)
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

vanth/client.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import json
+import secrets
+import os
+import stat
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from .paths import canonical_home, secure_home_permissions
+
+
+def _default_daemon_url() -> str:
+    host = os.environ.get("VANTH_DAEMON_HOST", "127.0.0.1")
+    try:
+        port = int(os.environ.get("VANTH_DAEMON_PORT", "8765"))
+    except ValueError:
+        port = 8765
+    return f"http://{host}:{port}"
+
+
+def auth_token_path(home: str | os.PathLike[str] | None = None) -> str:
+    return os.fspath(canonical_home(home) / "token")
+
+
+def ensure_auth_token(home: str | os.PathLike[str] | None = None) -> str:
+    path = auth_token_path(home)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    created = False
+    try:
+        with open(path, "x", encoding="utf-8") as handle:
+            handle.write(secrets.token_urlsafe(32))
+        created = True
+    except FileExistsError:
+        pass
+    try:
+        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:
+        pass
+    if created:
+        # Newly-created token: tighten the home ACL so a broad profile-level
+        # grant (e.g. a sandbox group) cannot read it.
+        secure_home_permissions(os.path.dirname(path))
+    with open(path, encoding="utf-8") as handle:
+        token = handle.read().strip()
+    if not token:
+        raise RuntimeError("Vanth authentication token is empty")
+    return token
+
+
+class VanthClient:
+    def __init__(self, url: str | None = None, home: str | os.PathLike[str] | None = None) -> None:
+        self.home = canonical_home(home)
+        self.url = self._resolve_url(url).rstrip("/")
+        self.token = ensure_auth_token(self.home)
+
+    def _resolve_url(self, url: str | None) -> str:
+        if url:
+            return url
+        env_url = os.environ.get("VANTH_DAEMON_URL")
+        if env_url:
+            return env_url
+        discovered = self._discover_url()
+        if discovered:
+            return discovered
+        host = os.environ.get("VANTH_DAEMON_HOST", "127.0.0.1")
+        try:
+            port = int(os.environ.get("VANTH_DAEMON_PORT", "8765"))
+        except ValueError:
+            port = 8765
+        return f"http://{host}:{port}"
+
+    def _discover_url(self) -> str | None:
+        try:
+            payload = json.loads((self.home / "daemon.json").read_text(encoding="utf-8"))
+            return payload.get("url")
+        except (OSError, ValueError):
+            return None
+
+    def _ready(self) -> bool:
+        payload = self.get("/doctor")
+        return (
+            isinstance(payload, dict)
+            and payload.get("result") != "error"
+            and payload.get("schema_version") is not None
+            and Path(str(payload.get("home", ""))).expanduser().resolve() == self.home
+        )
+
+    def ensure(self) -> None:
+        try:
+            if self._ready():
+                return
+        except Exception:
+            pass
+        subprocess.Popen(
+            [sys.executable, "-m", "vanth.daemon"],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            env=os.environ.copy(),
+            creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0) if sys.platform == "win32" else 0,
+        )
+        deadline = time.monotonic() + 5
+        while time.monotonic() < deadline:
+            try:
+                if self._ready():
+                    return
+            except Exception:
+                pass
+            time.sleep(0.1)
+        raise RuntimeError("vanthd did not start")
+
+    def get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        url = self.url + path
+        if params:
+            clean = {key: value for key, value in params.items() if value is not None}
+            if clean:
+                url += "?" + urllib.parse.urlencode(clean, doseq=True)
+        try:
+            request = urllib.request.Request(url, headers={"Authorization": f"Bearer {self.token}"})
+            with urllib.request.urlopen(request, timeout=None) as response:
+                return json.loads(response.read().decode())
+        except urllib.error.HTTPError as exc:
+            return json.loads(exc.read().decode())
+
+    def post(self, path: str, payload: dict[str, Any] | None = None) -> dict[str, Any]:
+        data = json.dumps(payload or {}).encode()
+        request = urllib.request.Request(
+            self.url + path,
+            data=data,
+            headers={"Content-Type": "application/json", "Authorization": f"Bearer {self.token}"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=None) as response:
+                return json.loads(response.read().decode())
+        except urllib.error.HTTPError as exc:
+            return json.loads(exc.read().decode())

vanth/codex_bridge.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import json
+import os
+import queue
+import subprocess
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+
+class CodexBridgeError(RuntimeError):
+    pass
+
+
+def _default_codex_command() -> list[str]:
+    configured = os.environ.get("VANTH_CODEX_BIN")
+    if configured:
+        return [configured]
+    win_default = Path(r"C:\codex\codex.exe")
+    if sys.platform == "win32" and win_default.exists():
+        return [str(win_default)]
+    return ["codex"]
+
+
+def _command_argv(command: Any) -> list[str]:
+    if command is None:
+        return _default_codex_command()
+    if isinstance(command, list):
+        return [str(part) for part in command]
+    if isinstance(command, str):
+        return [command]
+    raise CodexBridgeError("codex_command must be a string path or argv list")
+
+
+def _reader(stream, out: queue.Queue[str]) -> None:
+    while True:
+        line = stream.readline()
+        if not line:
+            return
+        out.put(line.rstrip("\r\n"))
+
+
+class _CodexAppServer:
+    def __init__(self, command: Any, timeout_seconds: int) -> None:
+        argv = _command_argv(command) + ["app-server", "--listen", "stdio://", "--analytics-default-enabled"]
+        self.deadline = time.monotonic() + timeout_seconds
+        self.stdout: queue.Queue[str] = queue.Queue()
+        self.stderr: queue.Queue[str] = queue.Queue()
+        self.stderr_tail: list[str] = []
+        self.proc = subprocess.Popen(
+            argv,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+        )
+        assert self.proc.stdout is not None
+        assert self.proc.stderr is not None
+        threading.Thread(target=_reader, args=(self.proc.stdout, self.stdout), daemon=True).start()
+        threading.Thread(target=_reader, args=(self.proc.stderr, self.stderr), daemon=True).start()
+
+    def close(self) -> None:
+        if self.proc.poll() is not None:
+            return
+        self.proc.terminate()
+        try:
+            self.proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            self.proc.kill()
+            self.proc.wait(timeout=2)
+
+    def send(self, request_id: int, method: str, params: dict[str, Any]) -> None:
+        if self.proc.stdin is None:
+            raise CodexBridgeError("codex app-server stdin closed")
+        self.proc.stdin.write(json.dumps({"jsonrpc": "2.0", "id": request_id, "method": method, "params": params}) + "\n")
+        self.proc.stdin.flush()
+
+    def response(self, request_id: int) -> dict[str, Any]:
+        while True:
+            while not self.stderr.empty():
+                self.stderr_tail.append(self.stderr.get())
+                self.stderr_tail = self.stderr_tail[-5:]
+            remaining = self.deadline - time.monotonic()
+            if remaining <= 0:
+                raise CodexBridgeError(self._error("timed out waiting for codex app-server"))
+            try:
+                line = self.stdout.get(timeout=min(0.1, remaining))
+            except queue.Empty:
+                if self.proc.poll() is not None:
+                    raise CodexBridgeError(self._error(f"codex app-server exited with {self.proc.returncode}"))
+                continue
+            try:
+                message = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if message.get("id") != request_id:
+                continue
+            if "error" in message:
+                raise CodexBridgeError(self._error(message["error"].get("message", "codex app-server error")))
+            return message.get("result", {})
+
+    def _error(self, message: str) -> str:
+        if not self.stderr_tail:
+            return message
+        return f"{message}: {' | '.join(self.stderr_tail)}"
+
+
+def send_message_to_thread(
+    thread_id: str,
+    prompt: str,
+    *,
+    codex_command: Any = None,
+    timeout_seconds: int = 30,
+) -> dict[str, Any]:
+    server = _CodexAppServer(codex_command, timeout_seconds)
+    try:
+        server.send(
+            1,
+            "initialize",
+            {"clientInfo": {"name": "vanth", "version": "0"}, "capabilities": {"experimentalApi": True}},
+        )
+        server.response(1)
+        server.send(2, "thread/resume", {"threadId": thread_id, "excludeTurns": True})
+        server.response(2)
+        server.send(3, "turn/start", {"threadId": thread_id, "input": [{"type": "text", "text": prompt}]})
+        return server.response(3)
+    finally:
+        server.close()
+
+
+def send_delivery_to_codex(payload: dict[str, Any]) -> dict[str, Any]:
+    target = payload.get("target") or {}
+    thread_id = target.get("thread_id") or target.get("threadId")
+    prompt = payload.get("prompt")
+    if not isinstance(thread_id, str) or not thread_id:
+        raise CodexBridgeError("codex_thread target requires thread_id")
+    if not isinstance(prompt, str) or not prompt:
+        raise CodexBridgeError("delivery payload requires prompt")
+    return send_message_to_thread(
+        thread_id,
+        prompt,
+        codex_command=target.get("codex_command"),
+        timeout_seconds=int(target.get("timeout_seconds", 30)),
+    )
+
+
+def main() -> None:
+    payload = json.load(sys.stdin)
+    result = send_delivery_to_codex(payload)
+    print(json.dumps(result, separators=(",", ":")))