squidbot 0.1.0__py3-none-any.whl

squidbot/daemon.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+SquidBot Daemon Manager
+
+Process supervisor for running SquidBot server and managing clients.
+"""
+
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+# PID and log files
+DATA_DIR = Path.home() / ".squidbot"
+PID_FILE = DATA_DIR / "squidbot.pid"
+LOG_FILE = DATA_DIR / "squidbot.log"
+
+# Script directory
+SCRIPT_DIR = Path(__file__).parent.absolute()
+
+
+def get_pid() -> int | None:
+    """Get the PID of the running server."""
+    if not PID_FILE.exists():
+        return None
+    try:
+        pid = int(PID_FILE.read_text().strip())
+        # Check if process is actually running
+        os.kill(pid, 0)
+        return pid
+    except (ValueError, ProcessLookupError, PermissionError):
+        # PID file exists but process is not running
+        PID_FILE.unlink(missing_ok=True)
+        return None
+
+
+def is_running() -> bool:
+    """Check if the server is running."""
+    return get_pid() is not None
+
+
+def find_squidbot_processes() -> list[tuple[int, str]]:
+    """Find all SquidBot-related Python processes (server and client only)."""
+    processes = []
+    try:
+        # Use ps to find Python processes
+        result = subprocess.run(["ps", "aux"], capture_output=True, text=True)
+
+        for line in result.stdout.split("\n"):
+            # Only look for server.py and client.py, not daemon.py
+            if "python" in line.lower() and any(
+                script in line for script in ["server.py", "client.py"]
+            ):
+                parts = line.split()
+                if len(parts) >= 2:
+                    try:
+                        pid = int(parts[1])
+                        # Don't include ourselves
+                        if pid != os.getpid():
+                            processes.append((pid, line))
+                    except ValueError:
+                        pass
+    except Exception:
+        pass
+
+    return processes
+
+
+def show_env_info():
+    """Display environment configuration to console."""
+    import os
+
+    from dotenv import load_dotenv
+
+    load_dotenv()
+
+    squid_port = int(os.environ.get("SQUID_PORT", "7777"))
+    openai_model = os.environ.get("OPENAI_MODEL", "gpt-4o")
+    heartbeat = int(os.environ.get("HEARTBEAT_INTERVAL_MINUTES", "30"))
+    telegram_token = os.environ.get("TELEGRAM_BOT_TOKEN", "")
+    openai_key = os.environ.get("OPENAI_API_KEY", "")
+
+    print("")
+    print("=" * 60)
+    print("  SquidBot Configuration")
+    print("=" * 60)
+    print(f"  Home Directory : {DATA_DIR}")
+    print(f"  Server Port    : 127.0.0.1:{squid_port}")
+    print(f"  Model          : {openai_model}")
+    print(f"  Heartbeat      : {heartbeat} minutes")
+    print("-" * 60)
+    print(f"  OPENAI_API_KEY : {'[SET]' if openai_key else '[NOT SET]'}")
+    print(f"  Telegram Bot   : {'[ENABLED]' if telegram_token else '[DISABLED]'}")
+    print("=" * 60)
+    print("")
+
+
+def start():
+    """Start the server."""
+    if is_running():
+        print(f"SquidBot server is already running (PID: {get_pid()})")
+        return False
+
+    # Ensure data directory exists
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Show environment info to console
+    show_env_info()
+
+    # Check Playwright before starting (so user sees errors immediately)
+    from .playwright_check import require_playwright_or_exit
+
+    require_playwright_or_exit()
+
+    print(f"Starting SquidBot server...")
+    print(f"Log file: {LOG_FILE}")
+
+    # Open log file
+    log_fd = open(LOG_FILE, "a")
+
+    # Start the process using module execution
+    # cwd must be parent of squidbot package (app directory)
+    process = subprocess.Popen(
+        [sys.executable, "-m", "squidbot.server"],
+        stdout=log_fd,
+        stderr=log_fd,
+        cwd=str(SCRIPT_DIR.parent),
+        start_new_session=True,  # Detach from terminal
+    )
+
+    # Write PID file
+    PID_FILE.write_text(str(process.pid))
+
+    # Wait a moment to check if it started successfully
+    time.sleep(1)
+
+    if process.poll() is None:
+        print(f"SquidBot server started (PID: {process.pid})")
+        return True
+    else:
+        print("SquidBot failed to start. Check logs:")
+        print(f"  tail -f {LOG_FILE}")
+        PID_FILE.unlink(missing_ok=True)
+        return False
+
+
+def stop():
+    """Stop the server."""
+    pid = get_pid()
+    if pid is None:
+        print("SquidBot server is not running")
+        return False
+
+    print(f"Stopping SquidBot server (PID: {pid})...")
+
+    try:
+        # Send SIGTERM for graceful shutdown
+        os.kill(pid, signal.SIGTERM)
+
+        # Wait for process to terminate
+        for _ in range(10):  # Wait up to 10 seconds
+            time.sleep(1)
+            try:
+                os.kill(pid, 0)
+            except ProcessLookupError:
+                print("SquidBot server stopped")
+                PID_FILE.unlink(missing_ok=True)
+                return True
+
+        # Force kill if still running
+        print("Process not responding, sending SIGKILL...")
+        os.kill(pid, signal.SIGKILL)
+        time.sleep(1)
+        PID_FILE.unlink(missing_ok=True)
+        print("SquidBot server forcefully terminated")
+        return True
+
+    except ProcessLookupError:
+        print("Process already terminated")
+        PID_FILE.unlink(missing_ok=True)
+        return True
+    except PermissionError:
+        print(f"Permission denied to stop process {pid}")
+        return False
+
+
+def stopall():
+    """Stop server and kill all clients."""
+    print("Stopping all SquidBot processes...")
+
+    killed = 0
+
+    # First, stop the server gracefully
+    if is_running():
+        stop()
+        killed += 1
+
+    # Find and kill any remaining processes
+    processes = find_squidbot_processes()
+
+    for pid, cmdline in processes:
+        try:
+            print(f"  Killing PID {pid}...")
+            os.kill(pid, signal.SIGTERM)
+            killed += 1
+        except (ProcessLookupError, PermissionError):
+            pass
+
+    # Wait a moment
+    if processes:
+        time.sleep(1)
+
+        # Force kill any remaining
+        for pid, cmdline in processes:
+            try:
+                os.kill(pid, 0)  # Check if still running
+                print(f"  Force killing PID {pid}...")
+                os.kill(pid, signal.SIGKILL)
+            except (ProcessLookupError, PermissionError):
+                pass
+
+    # Clean up PID file
+    PID_FILE.unlink(missing_ok=True)
+
+    print(f"Stopped {killed} process(es)")
+    return True
+
+
+def restart():
+    """Restart the server."""
+    if is_running():
+        stop()
+        time.sleep(1)
+    start()
+
+
+def status():
+    """Show server status."""
+    pid = get_pid()
+    if pid:
+        print(f"SquidBot server is running (PID: {pid})")
+        print(f"Log file: {LOG_FILE}")
+
+        # Show any client processes
+        processes = find_squidbot_processes()
+        clients = [(p, c) for p, c in processes if "client.py" in c]
+        if clients:
+            print(f"Active clients: {len(clients)}")
+
+        return True
+    else:
+        print("SquidBot server is not running")
+        return False
+
+
+def logs(follow: bool = False, lines: int = 50):
+    """Show server logs."""
+    if not LOG_FILE.exists():
+        print("No log file found")
+        return
+
+    if follow:
+        os.execvp("tail", ["tail", "-f", str(LOG_FILE)])
+    else:
+        os.execvp("tail", ["tail", "-n", str(lines), str(LOG_FILE)])
+
+
+def main():
+    """Main entry point."""
+    if len(sys.argv) < 2:
+        print("Usage: python daemon.py <command>")
+        print("")
+        print("Commands:")
+        print("  start    Start the server")
+        print("  stop     Stop the server")
+        print("  stopall  Stop server and kill all clients")
+        print("  restart  Restart the server")
+        print("  status   Show server status")
+        print("  logs     Show recent logs")
+        print("  logs -f  Follow logs in real-time")
+        sys.exit(1)
+
+    command = sys.argv[1]
+
+    if command == "start":
+        success = start()
+        sys.exit(0 if success else 1)
+    elif command == "stop":
+        success = stop()
+        sys.exit(0 if success else 1)
+    elif command == "stopall":
+        success = stopall()
+        sys.exit(0 if success else 1)
+    elif command == "restart":
+        restart()
+    elif command == "status":
+        running = status()
+        sys.exit(0 if running else 1)
+    elif command == "logs":
+        follow = "-f" in sys.argv or "--follow" in sys.argv
+        logs(follow=follow)
+    else:
+        print(f"Unknown command: {command}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

squidbot/lanes.py

@@ -0,0 +1,41 @@
+"""
+Command Lanes - Execution context categorization.
+
+Lanes categorize the context in which commands are executed,
+enabling different behaviors for different execution paths.
+"""
+
+from enum import Enum
+
+
+class CommandLane(str, Enum):
+    """Command execution lane types."""
+
+    MAIN = "main"  # Primary user interaction
+    CRON = "cron"  # Scheduled/cron jobs
+    SUBAGENT = "subagent"  # Sub-agent execution
+    NESTED = "nested"  # Nested command execution
+    WEBHOOK = "webhook"  # Webhook-triggered execution
+    PROACTIVE = "proactive"  # Proactive/autonomous messages
+
+    def __str__(self) -> str:
+        return self.value
+
+    @property
+    def is_user_initiated(self) -> bool:
+        """Whether this lane represents user-initiated actions."""
+        return self in (CommandLane.MAIN, CommandLane.NESTED)
+
+    @property
+    def is_automated(self) -> bool:
+        """Whether this lane represents automated actions."""
+        return self in (CommandLane.CRON, CommandLane.WEBHOOK, CommandLane.PROACTIVE)
+
+
+# Convenience exports
+LANE_MAIN = CommandLane.MAIN
+LANE_CRON = CommandLane.CRON
+LANE_SUBAGENT = CommandLane.SUBAGENT
+LANE_NESTED = CommandLane.NESTED
+LANE_WEBHOOK = CommandLane.WEBHOOK
+LANE_PROACTIVE = CommandLane.PROACTIVE

squidbot/main.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""
+SquidBot - Autonomous AI Agent
+
+A Telegram bot with:
+- Telegram bot interface
+- OpenAI LLM with tool calling
+- Autonomous tool chaining loop
+- Persistent memory
+- Web search
+- Browser automation (Playwright)
+- Proactive messaging (cron/heartbeat)
+"""
+
+import asyncio
+import logging
+
+from telegram import Update
+from telegram.ext import (Application, CommandHandler, ContextTypes,
+                          MessageHandler, filters)
+
+from .agent import run_agent_with_history
+from .config import TELEGRAM_BOT_TOKEN, validate_config
+from .scheduler import Scheduler
+
+# Setup logging
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+# Session storage (in-memory for simplicity)
+sessions: dict[int, list[dict]] = {}
+
+# Scheduler instance (initialized later)
+scheduler: Scheduler | None = None
+
+
+async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle /start command."""
+    await update.message.reply_text(
+        "Hello! I'm your autonomous AI assistant.\n\n"
+        "I can:\n"
+        "- Remember things you tell me\n"
+        "- Search the web for information\n"
+        "- Browse websites\n"
+        "- Set reminders and scheduled tasks\n\n"
+        "Just send me a message!"
+    )
+
+
+async def clear_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle /clear command - clear session history."""
+    chat_id = update.effective_chat.id
+    sessions[chat_id] = []
+    await update.message.reply_text("Conversation history cleared.")
+
+
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle incoming messages."""
+    chat_id = update.effective_chat.id
+    user_message = update.message.text
+
+    # Update scheduler's chat_id for proactive messages
+    global scheduler
+    if scheduler:
+        scheduler.set_chat_id(chat_id)
+
+    # Get or create session history
+    if chat_id not in sessions:
+        sessions[chat_id] = []
+
+    # Send typing indicator
+    await context.bot.send_chat_action(chat_id=chat_id, action="typing")
+
+    try:
+        # Run the agent
+        response, updated_history = await run_agent_with_history(
+            user_message, sessions[chat_id]
+        )
+        sessions[chat_id] = updated_history
+
+        # Send response (split if too long)
+        max_length = 4096
+        if len(response) <= max_length:
+            await update.message.reply_text(response)
+        else:
+            # Split into chunks
+            for i in range(0, len(response), max_length):
+                chunk = response[i : i + max_length]
+                await update.message.reply_text(chunk)
+
+        # Reload scheduler jobs in case new ones were created
+        if scheduler:
+            scheduler.reload_jobs()
+
+    except Exception as e:
+        logger.exception("Error handling message")
+        await update.message.reply_text(f"Sorry, an error occurred: {str(e)}")
+
+
+async def send_proactive_message(app: Application, chat_id: int, message: str):
+    """Send a proactive message to a chat."""
+    try:
+        await app.bot.send_message(chat_id=chat_id, text=message)
+    except Exception as e:
+        logger.error(f"Failed to send proactive message: {e}")
+
+
+def main():
+    """Main entry point."""
+    # Validate configuration
+    validate_config()
+
+    # Create application
+    app = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
+
+    # Add handlers
+    app.add_handler(CommandHandler("start", start_command))
+    app.add_handler(CommandHandler("clear", clear_command))
+    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+
+    # Setup scheduler
+    global scheduler
+
+    async def send_message(message: str):
+        """Wrapper to send messages from scheduler."""
+        # Get the most recent chat_id
+        if scheduler and scheduler.chat_id:
+            await send_proactive_message(app, scheduler.chat_id, message)
+
+    async def run_agent_for_scheduler(prompt: str) -> str:
+        """Run agent from scheduler context."""
+        response, _ = await run_agent_with_history(prompt, [])
+        return response
+
+    scheduler = Scheduler(send_message=send_message, run_agent=run_agent_for_scheduler)
+
+    # Start scheduler when bot starts
+    async def post_init(application: Application):
+        scheduler.start()
+        logger.info("Bot and scheduler started")
+
+    async def post_shutdown(application: Application):
+        scheduler.stop()
+        logger.info("Scheduler stopped")
+
+    app.post_init = post_init
+    app.post_shutdown = post_shutdown
+
+    # Run the bot
+    logger.info("Starting SquidBot...")
+    app.run_polling(allowed_updates=Update.ALL_TYPES)
+
+
+if __name__ == "__main__":
+    main()