openagent-framework 0.2.1__tar.gz → 0.2.3__tar.gz

{openagent_framework-0.2.1 → openagent_framework-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openagent-framework
-Version: 0.2.1
+Version: 0.2.3
 Summary: Simplified LLM agent framework with MCP, memory, and multi-channel support
 License-Expression: MIT
 Requires-Python: >=3.11

{openagent_framework-0.2.1 → openagent_framework-0.2.3}/openagent/__init__.py

@@ -1,5 +1,5 @@
 from openagent.agent import Agent
 from openagent.config import load_config
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 __all__ = ["Agent", "load_config"]

openagent_framework-0.2.3/openagent/bootstrap.py

@@ -0,0 +1,364 @@
+"""Platform detection, environment checks and dependency installers.
+
+Powers `openagent doctor` and the extended `openagent setup` command.
+Aim: make it as easy as possible to get OpenAgent running on a fresh
+machine, across Linux / macOS / Windows, *without* pretending we can
+silently install Docker Desktop on Mac/Win (we can't, legally or
+practically).
+
+Design:
+- Every check returns a `Check` dataclass — name, status, message, fix hint.
+- Installers either succeed, raise, or return "manual-instructions" strings.
+- The caller (CLI) decides how to present the result.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import platform
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+# ── Check result dataclass ──
+
+Status = str  # "ok" | "warn" | "fail" | "skip"
+
+
+@dataclass
+class Check:
+    name: str
+    status: Status
+    message: str
+    fix_hint: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.status == "ok"
+
+
+@dataclass
+class Report:
+    checks: list[Check] = field(default_factory=list)
+
+    def add(self, chk: Check) -> None:
+        self.checks.append(chk)
+
+    @property
+    def has_failures(self) -> bool:
+        return any(c.status == "fail" for c in self.checks)
+
+    @property
+    def has_warnings(self) -> bool:
+        return any(c.status == "warn" for c in self.checks)
+
+
+# ── Platform helpers ──
+
+def current_platform() -> str:
+    system = platform.system()
+    if system == "Darwin":
+        return "macos"
+    if system == "Linux":
+        return "linux"
+    if system == "Windows":
+        return "windows"
+    return system.lower()
+
+
+def detect_linux_pkg_manager() -> str | None:
+    """Return 'apt' / 'dnf' / 'pacman' / None."""
+    for mgr in ("apt-get", "dnf", "pacman", "zypper", "apk"):
+        if shutil.which(mgr):
+            return mgr.replace("-get", "")
+    return None
+
+
+# ── Individual checks ──
+
+def check_python() -> Check:
+    v = sys.version_info
+    ver = f"{v.major}.{v.minor}.{v.micro}"
+    if v >= (3, 11):
+        return Check("python", "ok", f"Python {ver}")
+    return Check(
+        "python", "fail",
+        f"Python {ver} — OpenAgent requires 3.11+",
+        "Install Python 3.11 or newer.",
+    )
+
+
+def check_command(cmd: str, name: str | None = None) -> Check:
+    display = name or cmd
+    path = shutil.which(cmd)
+    if not path:
+        return Check(display, "warn", f"{display} not installed", f"Install {display}.")
+    try:
+        out = subprocess.run(
+            [cmd, "--version"], capture_output=True, text=True, timeout=5,
+        )
+        version_line = (out.stdout or out.stderr).strip().splitlines()[0] if (out.stdout or out.stderr) else "installed"
+        return Check(display, "ok", version_line)
+    except Exception:
+        return Check(display, "ok", f"{display} at {path}")
+
+
+def check_docker() -> Check:
+    """Check Docker CLI + daemon reachability."""
+    if not shutil.which("docker"):
+        hint = {
+            "linux": "Run: openagent setup --with-docker",
+            "macos": "Install Docker Desktop: https://docs.docker.com/desktop/install/mac-install/",
+            "windows": "Install Docker Desktop: https://docs.docker.com/desktop/install/windows-install/",
+        }.get(current_platform(), "Install Docker.")
+        return Check("docker", "warn", "docker CLI not found", hint)
+
+    try:
+        proc = subprocess.run(
+            ["docker", "info", "--format", "{{.ServerVersion}}"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if proc.returncode != 0:
+            hint = "Start the Docker daemon."
+            if current_platform() in ("macos", "windows"):
+                hint = "Launch Docker Desktop and wait for it to be ready."
+            return Check(
+                "docker", "warn",
+                "docker CLI found, but daemon is not reachable",
+                hint,
+            )
+        return Check("docker", "ok", f"Docker daemon {proc.stdout.strip()} reachable")
+    except Exception as e:
+        return Check("docker", "warn", f"docker check failed: {e}", "")
+
+
+def check_git() -> Check:
+    return check_command("git")
+
+
+def check_node() -> Check:
+    return check_command("node")
+
+
+def check_openagent_config(config_path: Path) -> Check:
+    if not config_path.exists():
+        return Check(
+            "config",
+            "warn",
+            f"no openagent.yaml at {config_path}",
+            "Create one by copying an example from docs/ or passing --config.",
+        )
+    try:
+        import yaml
+        with open(config_path) as f:
+            yaml.safe_load(f)
+        return Check("config", "ok", f"{config_path}")
+    except Exception as e:
+        return Check("config", "fail", f"invalid YAML: {e}", "Fix the syntax errors.")
+
+
+def check_memory_vault(config: dict) -> Check:
+    mem = config.get("memory", {}).get("vault_path") or "./memories"
+    p = Path(mem).expanduser()
+    if p.exists():
+        count = len(list(p.glob("*.md")))
+        return Check("memory-vault", "ok", f"{p} ({count} notes)")
+    return Check(
+        "memory-vault", "warn",
+        f"{p} does not exist yet",
+        f"Create with: mkdir -p {p}",
+    )
+
+
+def check_services_enabled(config: dict) -> list[Check]:
+    """Check each enabled service has its prerequisites met."""
+    out: list[Check] = []
+    services = config.get("services", {}) or {}
+    for name, svc_cfg in services.items():
+        if not svc_cfg or not svc_cfg.get("enabled"):
+            continue
+        if name == "obsidian_web":
+            if not svc_cfg.get("password") and not os.environ.get("OBSIDIAN_PASSWORD"):
+                out.append(Check(
+                    "service:obsidian_web", "fail",
+                    "enabled but no password set",
+                    "Set services.obsidian_web.password or OBSIDIAN_PASSWORD env var.",
+                ))
+            else:
+                out.append(Check("service:obsidian_web", "ok", "configured"))
+    return out
+
+
+# ── Doctor: run all checks ──
+
+def run_doctor(config: dict, config_path: Path) -> Report:
+    """Run the full set of checks and return a Report."""
+    rpt = Report()
+    rpt.add(check_python())
+    rpt.add(check_openagent_config(config_path))
+    rpt.add(check_memory_vault(config))
+    rpt.add(check_git())
+    rpt.add(check_node())
+    rpt.add(check_docker())
+    for c in check_services_enabled(config):
+        rpt.add(c)
+    return rpt
+
+
+# ── Installers ──
+
+def _run(cmd: list[str], check: bool = True) -> subprocess.CompletedProcess:
+    logger.info("+ %s", " ".join(cmd))
+    return subprocess.run(cmd, check=check)
+
+
+def install_docker_linux() -> str:
+    """Install Docker via the distro's package manager."""
+    mgr = detect_linux_pkg_manager()
+    if mgr is None:
+        raise RuntimeError(
+            "No supported package manager found. Install Docker manually: "
+            "https://docs.docker.com/engine/install/"
+        )
+
+    sudo = ["sudo"] if os.geteuid() != 0 else []
+
+    if mgr == "apt":
+        env = os.environ.copy()
+        env["DEBIAN_FRONTEND"] = "noninteractive"
+        subprocess.run(sudo + ["apt-get", "update", "-q"], check=True, env=env)
+        subprocess.run(sudo + ["apt-get", "install", "-y", "-q", "docker.io"], check=True, env=env)
+    elif mgr == "dnf":
+        _run(sudo + ["dnf", "install", "-y", "docker"])
+    elif mgr == "pacman":
+        _run(sudo + ["pacman", "-S", "--noconfirm", "docker"])
+    elif mgr == "zypper":
+        _run(sudo + ["zypper", "--non-interactive", "install", "docker"])
+    elif mgr == "apk":
+        _run(sudo + ["apk", "add", "docker"])
+
+    # Enable + start daemon (systemd)
+    if shutil.which("systemctl"):
+        subprocess.run(sudo + ["systemctl", "enable", "--now", "docker"], check=False)
+
+    # Add current user to docker group
+    user = os.environ.get("SUDO_USER") or os.environ.get("USER")
+    if user and user != "root":
+        subprocess.run(sudo + ["usermod", "-aG", "docker", user], check=False)
+        return (
+            f"Docker installed. User '{user}' added to the docker group — "
+            "you may need to log out and back in (or run `newgrp docker`) "
+            "before the current shell can use docker without sudo."
+        )
+    return "Docker installed and enabled."
+
+
+def install_docker_macos() -> str:
+    """Install Docker Desktop on macOS via Homebrew cask if available."""
+    if shutil.which("docker"):
+        return "Docker already installed."
+
+    if shutil.which("brew"):
+        try:
+            _run(["brew", "install", "--cask", "docker"])
+            return (
+                "Docker Desktop installed via Homebrew. "
+                "Launch the Docker app from /Applications once to accept the "
+                "terms of service and finish setup, then re-run "
+                "`openagent doctor` to verify."
+            )
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"brew install failed: {e}")
+
+    raise RuntimeError(
+        "Homebrew not found. Install it from https://brew.sh then re-run "
+        "this command, or install Docker Desktop manually from "
+        "https://docs.docker.com/desktop/install/mac-install/"
+    )
+
+
+def install_docker_windows() -> str:
+    """Install Docker Desktop on Windows via winget if available."""
+    if shutil.which("docker"):
+        return "Docker already installed."
+
+    if shutil.which("winget"):
+        try:
+            _run([
+                "winget", "install", "--silent", "--accept-source-agreements",
+                "--accept-package-agreements", "Docker.DockerDesktop",
+            ])
+            return (
+                "Docker Desktop installed via winget. A reboot is usually "
+                "required. After rebooting, launch Docker Desktop once, then "
+                "re-run `openagent doctor`."
+            )
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"winget install failed: {e}")
+
+    raise RuntimeError(
+        "winget not found. Install Docker Desktop manually from "
+        "https://docs.docker.com/desktop/install/windows-install/"
+    )
+
+
+def install_docker() -> str:
+    """Dispatch to the platform-specific installer."""
+    pf = current_platform()
+    if pf == "linux":
+        return install_docker_linux()
+    if pf == "macos":
+        return install_docker_macos()
+    if pf == "windows":
+        return install_docker_windows()
+    raise RuntimeError(f"Unsupported platform for automatic Docker install: {pf}")
+
+
+# ── Image pulling ──
+
+SERVICE_IMAGES = {
+    "obsidian_web": "lscr.io/linuxserver/obsidian:latest",
+}
+
+
+def enabled_service_images(config: dict) -> dict[str, str]:
+    out: dict[str, str] = {}
+    services = config.get("services", {}) or {}
+    for name, cfg in services.items():
+        if cfg and cfg.get("enabled") and name in SERVICE_IMAGES:
+            out[name] = SERVICE_IMAGES[name]
+    return out
+
+
+async def pull_service_images(config: dict) -> list[tuple[str, bool, str]]:
+    """Pull Docker images for every enabled aux service.
+
+    Returns a list of (service_name, success, message) tuples.
+    """
+    out: list[tuple[str, bool, str]] = []
+    if not shutil.which("docker"):
+        return out
+
+    for name, image in enabled_service_images(config).items():
+        logger.info(f"Pulling image for {name}: {image}")
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "docker", "pull", image,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            _, err = await proc.communicate()
+            if proc.returncode == 0:
+                out.append((name, True, f"pulled {image}"))
+            else:
+                out.append((name, False, f"pull failed: {err.decode(errors='replace').strip()[:200]}"))
+        except Exception as e:
+            out.append((name, False, f"pull error: {e}"))
+    return out

{openagent_framework-0.2.1 → openagent_framework-0.2.3}/openagent/cli.py

@@ -331,41 +331,152 @@ def services_cmd(ctx, action: str):
     asyncio.run(_run())
 
 
+# ── Doctor: environment checks ──
+
+_STATUS_STYLE = {
+    "ok":   "[green]✓[/green]",
+    "warn": "[yellow]![/yellow]",
+    "fail": "[red]✗[/red]",
+    "skip": "[dim]·[/dim]",
+}
+
+
+def _print_report(report) -> None:
+    from rich.table import Table as _Table
+    tbl = _Table(show_header=True, header_style="bold")
+    tbl.add_column("", width=2)
+    tbl.add_column("Check", style="cyan")
+    tbl.add_column("Status")
+    tbl.add_column("Fix", style="dim")
+    for c in report.checks:
+        icon = _STATUS_STYLE.get(c.status, "?")
+        tbl.add_row(icon, c.name, c.message, c.fix_hint or "")
+    console.print(tbl)
+
+
+@main.command("doctor")
+@click.pass_context
+def doctor_cmd(ctx):
+    """Check the environment: Python, Docker, config, enabled services."""
+    from pathlib import Path
+    from openagent.bootstrap import run_doctor, current_platform
+
+    config = ctx.obj["config"]
+    config_path = Path(ctx.obj["config_path"]).expanduser()
+
+    console.print(f"[bold]Platform:[/bold] {current_platform()}")
+    console.print()
+
+    report = run_doctor(config, config_path)
+    _print_report(report)
+
+    console.print()
+    if report.has_failures:
+        console.print("[red]Some checks failed.[/red] Fix the issues above and re-run `openagent doctor`.")
+        raise SystemExit(1)
+    if report.has_warnings:
+        console.print("[yellow]All critical checks passed, with warnings.[/yellow]")
+    else:
+        console.print("[green]All checks passed. You're good to go.[/green]")
+
+
 # ── Service management (OS-level systemd/launchd) ──
 
 @main.command("setup")
+@click.option("--with-docker", is_flag=True,
+              help="Install Docker (Linux: via apt/dnf/pacman; Mac/Win: via brew/winget).")
+@click.option("--pull-images", is_flag=True,
+              help="Pre-pull Docker images for every enabled aux service.")
+@click.option("--full", is_flag=True,
+              help="Everything: doctor, install Docker if missing, pull images, register OS service.")
+@click.option("--no-service", is_flag=True,
+              help="Skip OS service registration (systemd/launchd/Task Scheduler).")
 @click.pass_context
-def setup_cmd(ctx):
-    """Detect platform, install OpenAgent as a system service, and report status."""
-    import platform as _platform
+def setup_cmd(ctx, with_docker: bool, pull_images: bool, full: bool, no_service: bool):
+    """First-time setup: check environment, install deps, register OS service.
+
+    By default only registers OpenAgent as an OS service. Pass --full to also
+    install Docker (where automatable) and pre-pull images for the services
+    enabled in your config.
+    """
+    from pathlib import Path
+    from openagent.bootstrap import (
+        run_doctor, install_docker, pull_service_images,
+        check_docker, current_platform,
+    )
     from openagent.service import setup_service
 
-    console.print(f"[bold]Detected platform:[/bold] {_platform.system()}")
-    console.print("Installing OpenAgent as a system service...")
+    config = ctx.obj["config"]
+    config_path = Path(ctx.obj["config_path"]).expanduser()
+
+    if full:
+        with_docker = True
+        pull_images = True
+
+    console.print(f"[bold]Platform:[/bold] {current_platform()}")
     console.print()
 
-    try:
-        info = setup_service()
-        console.print(f"[green]{info['message']}[/green]")
-        console.print(f"[dim]Service file:[/dim] {info['service_file']}")
+    # 1. Doctor pass 1
+    console.print("[bold]Step 1 — environment check[/bold]")
+    report = run_doctor(config, config_path)
+    _print_report(report)
+    console.print()
+
+    # 2. Install Docker if requested and missing
+    if with_docker:
+        console.print("[bold]Step 2 — Docker[/bold]")
+        docker_chk = check_docker()
+        if docker_chk.status == "ok":
+            console.print(f"[green]Docker already OK:[/green] {docker_chk.message}")
+        else:
+            try:
+                msg = install_docker()
+                console.print(f"[green]{msg}[/green]")
+            except Exception as e:
+                console.print(f"[red]Docker install failed:[/red] {e}")
         console.print()
-        console.print("[bold]Service status:[/bold]")
-        console.print(info["status"])
+
+    # 3. Pull images for enabled services
+    if pull_images:
+        console.print("[bold]Step 3 — pulling service images[/bold]")
+        results = asyncio.run(pull_service_images(config))
+        if not results:
+            console.print("[dim]No services with pullable images are enabled.[/dim]")
+        else:
+            for name, ok, msg in results:
+                icon = "[green]✓[/green]" if ok else "[red]✗[/red]"
+                console.print(f"  {icon} {name}: {msg}")
         console.print()
-        console.print(
-            "[green]OpenAgent will now auto-start on boot "
-            "and restart on crash.[/green]"
-        )
-    except Exception as e:
-        console.print(f"[red]Setup failed: {e}[/red]")
+
+    # 4. Register OS service
+    if not no_service:
+        console.print("[bold]Step 4 — register OS service[/bold]")
+        try:
+            info = setup_service()
+            console.print(f"[green]{info['message']}[/green]")
+            console.print(f"[dim]Service file:[/dim] {info['service_file']}")
+        except Exception as e:
+            console.print(f"[red]Service registration failed:[/red] {e}")
+            raise SystemExit(1)
+        console.print()
+
+    # 5. Final re-check
+    console.print("[bold]Final check[/bold]")
+    final = run_doctor(config, config_path)
+    _print_report(final)
+    console.print()
+
+    if final.has_failures:
+        console.print("[red]Setup finished with failures.[/red] See above.")
         raise SystemExit(1)
+    console.print("[green]Setup complete.[/green]")
 
 
 @main.command("install")
 @click.pass_context
 def install_cmd(ctx):
-    """Alias for openagent setup."""
-    ctx.invoke(setup_cmd)
+    """Alias for `openagent setup --full`."""
+    ctx.invoke(setup_cmd, with_docker=True, pull_images=True, full=True, no_service=False)
 
 
 @main.command("uninstall")

{openagent_framework-0.2.1 → openagent_framework-0.2.3}/openagent/scheduler.py

@@ -69,24 +69,29 @@ class Scheduler:
                 logger.error(f"Scheduler error: {e}")
             await asyncio.sleep(CHECK_INTERVAL)
 
+    async def run_task(self, task: dict) -> None:
+        """Execute a single task. Extension point: override or monkey-patch
+        this to intercept specific tasks (e.g. auto-update, which uses a
+        direct pip subprocess instead of going through the agent)."""
+        task_name = task["name"]
+        try:
+            response = await self.agent.run(
+                message=task["prompt"],
+                user_id="scheduler",
+                session_id=f"scheduler:{task['id']}",
+            )
+            logger.info(f"Task '{task_name}' completed: {response[:100]}...")
+        except Exception as e:
+            logger.error(f"Task '{task_name}' failed: {e}")
+
     async def _check_and_run(self) -> None:
         """Check for due tasks and execute them."""
         now = time.time()
         due_tasks = await self.db.get_due_tasks(now)
 
         for task in due_tasks:
-            task_name = task["name"]
-            logger.info(f"Running scheduled task: {task_name}")
-
-            try:
-                response = await self.agent.run(
-                    message=task["prompt"],
-                    user_id="scheduler",
-                    session_id=f"scheduler:{task['id']}",
-                )
-                logger.info(f"Task '{task_name}' completed: {response[:100]}...")
-            except Exception as e:
-                logger.error(f"Task '{task_name}' failed: {e}")
+            logger.info(f"Running scheduled task: {task['name']}")
+            await self.run_task(task)
 
             # Update last_run and compute next_run
             try:
@@ -98,7 +103,7 @@ class Scheduler:
                     next_run=next_run,
                 )
             except (ValueError, KeyError) as e:
-                logger.error(f"Failed to update next_run for '{task_name}': {e}")
+                logger.error(f"Failed to update next_run for '{task['name']}': {e}")
 
     # ── Task management helpers ──
 

{openagent_framework-0.2.1 → openagent_framework-0.2.3}/openagent_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openagent-framework
-Version: 0.2.1
+Version: 0.2.3
 Summary: Simplified LLM agent framework with MCP, memory, and multi-channel support
 License-Expression: MIT
 Requires-Python: >=3.11

{openagent_framework-0.2.1 → openagent_framework-0.2.3}/openagent_framework.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ pyproject.toml
 docs/README.md
 openagent/__init__.py
 openagent/agent.py
+openagent/bootstrap.py
 openagent/cli.py
 openagent/config.py
 openagent/scheduler.py

{openagent_framework-0.2.1 → openagent_framework-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openagent-framework"
-version = "0.2.1"
+version = "0.2.3"
 description = "Simplified LLM agent framework with MCP, memory, and multi-channel support"
 readme = "docs/README.md"
 requires-python = ">=3.11"