squidbot 0.1.0__py3-none-any.whl

squidbot/playwright_check.py

@@ -0,0 +1,233 @@
+"""Playwright browser check module.
+
+Verifies that Playwright and Chromium browser are properly installed
+and working before server startup.
+"""
+
+import asyncio
+import logging
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+class PlaywrightCheckError(Exception):
+    """Error raised when Playwright check fails."""
+
+    pass
+
+
+async def check_playwright_installation() -> tuple[bool, str]:
+    """
+    Check if Playwright is installed and Chromium browser is available.
+
+    Returns:
+        tuple[bool, str]: (success, message)
+    """
+    try:
+        from playwright.async_api import async_playwright
+    except ImportError as e:
+        return False, f"Playwright not installed: {e}\nRun: pip install playwright"
+
+    playwright = None
+    browser = None
+    try:
+        playwright = await async_playwright().start()
+
+        # Try to launch Chromium
+        browser = await playwright.chromium.launch(headless=True)
+
+        # Create a test page and verify it works
+        page = await browser.new_page()
+        await page.goto("about:blank")
+        title = await page.title()
+        await page.close()
+
+        return True, "Playwright and Chromium browser are working correctly"
+
+    except Exception as e:
+        error_msg = str(e)
+
+        # Check for common error patterns
+        if "Executable doesn't exist" in error_msg or "browserType.launch" in error_msg:
+            return False, (
+                f"Chromium browser not installed for Playwright.\n"
+                f"Run: playwright install chromium\n"
+                f"Or for all browsers: playwright install\n"
+                f"Error: {error_msg}"
+            )
+        elif "PLAYWRIGHT_BROWSERS_PATH" in error_msg:
+            return False, (
+                f"Playwright browser path issue.\n"
+                f"Run: playwright install chromium\n"
+                f"Error: {error_msg}"
+            )
+        else:
+            return False, f"Playwright check failed: {error_msg}"
+
+    finally:
+        if browser:
+            await browser.close()
+        if playwright:
+            await playwright.stop()
+
+
+async def check_web_browsing() -> tuple[bool, str]:
+    """
+    Test that web browsing actually works by fetching a simple page.
+
+    Returns:
+        tuple[bool, str]: (success, message)
+    """
+    try:
+        from playwright.async_api import async_playwright
+    except ImportError:
+        return False, "Playwright not installed"
+
+    playwright = None
+    browser = None
+    try:
+        playwright = await async_playwright().start()
+        browser = await playwright.chromium.launch(headless=True)
+        page = await browser.new_page()
+
+        # Try to navigate to a simple, reliable URL
+        # Use example.com as it's specifically designed for testing
+        response = await page.goto("https://example.com", timeout=30000)
+
+        if response is None:
+            return False, "No response received from test page"
+
+        if response.status != 200:
+            return False, f"Test page returned status {response.status}"
+
+        # Verify we got actual content
+        title = await page.title()
+        if not title:
+            return False, "Could not read page title"
+
+        text = await page.inner_text("body")
+        if not text or len(text) < 10:
+            return False, "Could not read page content"
+
+        await page.close()
+
+        return True, f"Web browsing verified (loaded: example.com, title: {title})"
+
+    except Exception as e:
+        error_msg = str(e)
+        if "net::ERR_" in error_msg:
+            return False, f"Network error - check internet connection: {error_msg}"
+        elif "Timeout" in error_msg:
+            return False, f"Timeout while loading test page: {error_msg}"
+        else:
+            return False, f"Web browsing test failed: {error_msg}"
+
+    finally:
+        if browser:
+            await browser.close()
+        if playwright:
+            await playwright.stop()
+
+
+async def run_startup_checks(skip_web_test: bool = False) -> tuple[bool, list[str]]:
+    """
+    Run all Playwright startup checks.
+
+    Args:
+        skip_web_test: If True, skip the web browsing test (useful for offline mode)
+
+    Returns:
+        tuple[bool, list[str]]: (all_passed, list of messages)
+    """
+    messages = []
+    all_passed = True
+
+    # Check 1: Playwright installation
+    logger.info("Checking Playwright installation...")
+    success, msg = await check_playwright_installation()
+    messages.append(f"[{'OK' if success else 'FAIL'}] Playwright: {msg}")
+    if not success:
+        all_passed = False
+        return all_passed, messages
+
+    # Check 2: Web browsing (optional)
+    if not skip_web_test:
+        logger.info("Checking web browsing capability...")
+        success, msg = await check_web_browsing()
+        messages.append(f"[{'OK' if success else 'FAIL'}] Web browsing: {msg}")
+        if not success:
+            all_passed = False
+    else:
+        messages.append("[SKIP] Web browsing test skipped")
+
+    return all_passed, messages
+
+
+def check_playwright_sync() -> tuple[bool, list[str]]:
+    """
+    Synchronous wrapper for startup checks.
+
+    Returns:
+        tuple[bool, list[str]]: (all_passed, list of messages)
+    """
+    return asyncio.run(run_startup_checks())
+
+
+def require_playwright_or_exit(skip_web_test: bool = False):
+    """
+    Check Playwright and exit with error if not working.
+
+    This function should be called at server/daemon startup.
+    It will print error messages and exit(1) if Playwright is not properly configured.
+
+    Args:
+        skip_web_test: If True, skip the web browsing test
+    """
+    print("\n=== Playwright Browser Check ===")
+
+    try:
+        all_passed, messages = asyncio.run(run_startup_checks(skip_web_test))
+    except KeyboardInterrupt:
+        print("\nCheck cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nUnexpected error during Playwright check: {e}")
+        print("\nPlease ensure Playwright is installed:")
+        print("  pip install playwright")
+        print("  playwright install chromium")
+        sys.exit(1)
+
+    for msg in messages:
+        print(msg)
+
+    if not all_passed:
+        print("\n" + "=" * 50)
+        print("PLAYWRIGHT CHECK FAILED")
+        print("=" * 50)
+        print("\nSquidBot requires a working Playwright browser for web browsing.")
+        print("\nTo fix this, run the following commands:")
+        print("  pip install playwright")
+        print("  playwright install chromium")
+        print("\nIf you're using Poetry:")
+        print("  poetry add playwright")
+        print("  poetry run playwright install chromium")
+        print("\nServer will not start until browser is properly configured.")
+        print("=" * 50 + "\n")
+        sys.exit(1)
+
+    print("=== All checks passed ===\n")
+    return True
+
+
+if __name__ == "__main__":
+    """Run checks directly for testing."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Check Playwright installation")
+    parser.add_argument(
+        "--skip-web", action="store_true", help="Skip web browsing test"
+    )
+    args = parser.parse_args()
+
+    require_playwright_or_exit(skip_web_test=args.skip_web)

squidbot/plugins/__init__.py

@@ -0,0 +1,47 @@
+"""
+SquidBot Plugin System
+
+Provides a modular plugin architecture for extending SquidBot functionality.
+"""
+
+from .base import Plugin, PluginApi, PluginManifest
+from .hooks import AfterToolCallEvent  # Event types; Global instances
+from .hooks import (AgentEndEvent, BeforeAgentStartEvent,
+                    BeforeAgentStartResult, BeforeToolCallEvent,
+                    BeforeToolCallResult, HookContext, HookName, HookRegistry,
+                    HookRunner, MessageReceivedEvent, MessageSendingEvent,
+                    MessageSendingResult, MessageSentEvent, SessionEndEvent,
+                    SessionStartEvent, get_hook_registry, get_hook_runner)
+from .loader import (PluginRegistry, get_registry, load_builtin_plugins,
+                     load_external_plugins)
+
+__all__ = [
+    # Base
+    "Plugin",
+    "PluginApi",
+    "PluginManifest",
+    # Hooks
+    "HookName",
+    "HookContext",
+    "HookRegistry",
+    "HookRunner",
+    "BeforeAgentStartEvent",
+    "BeforeAgentStartResult",
+    "AgentEndEvent",
+    "MessageReceivedEvent",
+    "MessageSendingEvent",
+    "MessageSendingResult",
+    "MessageSentEvent",
+    "BeforeToolCallEvent",
+    "BeforeToolCallResult",
+    "AfterToolCallEvent",
+    "SessionStartEvent",
+    "SessionEndEvent",
+    "get_hook_registry",
+    "get_hook_runner",
+    # Loader
+    "PluginRegistry",
+    "get_registry",
+    "load_builtin_plugins",
+    "load_external_plugins",
+]

squidbot/plugins/base.py

@@ -0,0 +1,96 @@
+"""
+Plugin Base Classes
+
+Defines the plugin interface and base classes for SquidBot plugins.
+Inspired by OpenClaw's plugin architecture.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Awaitable, Callable
+
+from ..tools.base import Tool
+
+if TYPE_CHECKING:
+    from .hooks import HookName, HookRegistry
+
+
+@dataclass
+class PluginManifest:
+    """Plugin metadata and configuration."""
+
+    id: str
+    name: str
+    description: str
+    version: str = "1.0.0"
+    author: str = ""
+    config_schema: dict = field(default_factory=dict)
+
+
+class PluginApi:
+    """API provided to plugins for registration."""
+
+    def __init__(self, plugin_id: str, hook_registry: "HookRegistry"):
+        self._plugin_id = plugin_id
+        self._hook_registry = hook_registry
+
+    def on(
+        self,
+        hook_name: "HookName",
+        handler: Callable[..., Awaitable[Any] | Any],
+        priority: int = 0,
+    ) -> None:
+        """Register a hook handler.
+
+        Args:
+            hook_name: The hook to listen for
+            handler: Async or sync function(event, context) -> result
+            priority: Higher priority handlers run first (default: 0)
+        """
+        self._hook_registry.register(
+            plugin_id=self._plugin_id,
+            hook_name=hook_name,
+            handler=handler,
+            priority=priority,
+        )
+
+
+class Plugin(ABC):
+    """Base class for all plugins."""
+
+    @property
+    @abstractmethod
+    def manifest(self) -> PluginManifest:
+        """Return plugin manifest with metadata."""
+        pass
+
+    @abstractmethod
+    def get_tools(self) -> list[Tool]:
+        """Return list of tools provided by this plugin."""
+        pass
+
+    def register_hooks(self, api: PluginApi) -> None:
+        """Register hooks using the plugin API. Override to add hooks.
+
+        Example:
+            def register_hooks(self, api: PluginApi) -> None:
+                api.on(HookName.BEFORE_TOOL_CALL, self.on_before_tool, priority=10)
+                api.on(HookName.AFTER_TOOL_CALL, self.on_after_tool)
+        """
+        pass
+
+    def activate(self) -> None:
+        """Called when plugin is activated. Override for initialization."""
+        pass
+
+    def deactivate(self) -> None:
+        """Called when plugin is deactivated. Override for cleanup."""
+        pass
+
+    def validate_config(self, config: dict) -> tuple[bool, str | None]:
+        """Validate plugin configuration. Returns (is_valid, error_message)."""
+        return True, None
+
+    def get_config_defaults(self) -> dict[str, Any]:
+        """Return default configuration values."""
+        return {}