codepp 0.0.437__py3-none-any.whl

code_puppy/scheduler/daemon.py

@@ -0,0 +1,280 @@
+"""Scheduler daemon for Code Puppy.
+
+Runs as a background process, checking for and executing scheduled tasks.
+Uses pure Python timing (no external scheduler dependencies).
+"""
+
+import atexit
+import os
+import re
+import signal
+import sys
+import tempfile
+import time
+from datetime import datetime, timedelta
+from typing import Optional
+
+from code_puppy.scheduler.config import (
+    SCHEDULER_PID_FILE,
+    ScheduledTask,
+    load_tasks,
+)
+from code_puppy.scheduler.executor import execute_task
+
+# Global flag for graceful shutdown
+_shutdown_requested = False
+
+
+def parse_interval(interval_str: str) -> Optional[timedelta]:
+    """Parse interval string like '30m', '1h', '2d' into timedelta."""
+    match = re.match(r"^(\d+)([smhd])$", interval_str.lower())
+    if not match:
+        return None
+
+    value = int(match.group(1))
+    unit = match.group(2)
+
+    if unit == "s":
+        return timedelta(seconds=value)
+    elif unit == "m":
+        return timedelta(minutes=value)
+    elif unit == "h":
+        return timedelta(hours=value)
+    elif unit == "d":
+        return timedelta(days=value)
+    return None
+
+
+def should_run_task(task: ScheduledTask, now: datetime) -> bool:
+    """Determine if a task should run now based on its schedule."""
+    if not task.enabled:
+        return False
+
+    if task.schedule_type == "interval":
+        interval = parse_interval(task.schedule_value)
+        if not interval:
+            return False
+
+        if not task.last_run:
+            return True  # Never run before
+
+        last_run = datetime.fromisoformat(task.last_run)
+        return (now - last_run) >= interval
+
+    elif task.schedule_type == "hourly":
+        if not task.last_run:
+            return True
+        last_run = datetime.fromisoformat(task.last_run)
+        return (now - last_run) >= timedelta(hours=1)
+
+    elif task.schedule_type == "daily":
+        if not task.last_run:
+            return True
+        last_run = datetime.fromisoformat(task.last_run)
+        return (now - last_run) >= timedelta(days=1)
+
+    elif task.schedule_type == "cron":
+        # Cron expressions not yet supported - would need croniter library
+        # Log warning so users know why task isn't running
+        print(
+            f"[Scheduler] Warning: Cron schedules not yet supported, skipping: {task.name}"
+        )
+        return False
+
+    return False
+
+
+def run_scheduler_loop(check_interval: int = 60):
+    """Main scheduler loop. Checks tasks every `check_interval` seconds."""
+    global _shutdown_requested
+
+    print(f"[Scheduler] Starting daemon (PID: {os.getpid()})")
+    print(f"[Scheduler] Check interval: {check_interval}s")
+
+    while not _shutdown_requested:
+        try:
+            tasks = load_tasks()
+            now = datetime.now()
+
+            for task in tasks:
+                if _shutdown_requested:
+                    break
+
+                if should_run_task(task, now):
+                    print(f"[Scheduler] Running task: {task.name} ({task.id})")
+                    success, exit_code, error = execute_task(task)
+                    if success:
+                        print(f"[Scheduler] Task completed: {task.name}")
+                    else:
+                        print(f"[Scheduler] Task failed: {task.name} - {error}")
+
+            # Sleep in small increments to allow graceful shutdown
+            for _ in range(check_interval):
+                if _shutdown_requested:
+                    break
+                time.sleep(1)
+
+        except Exception as e:
+            print(f"[Scheduler] Error in loop: {e}")
+            time.sleep(10)  # Wait before retrying
+
+    print("[Scheduler] Daemon stopped")
+
+
+def write_pid_file():
+    """Write the current PID to the PID file atomically.
+
+    Writes to a temp file first, then atomically replaces the PID file.
+    This prevents corruption if a crash occurs mid-write.
+    """
+    pid_dir = os.path.dirname(SCHEDULER_PID_FILE)
+    os.makedirs(pid_dir, exist_ok=True)
+    fd, tmp_path = tempfile.mkstemp(dir=pid_dir, prefix=".pid_tmp_")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(str(os.getpid()))
+        os.replace(tmp_path, SCHEDULER_PID_FILE)
+    except BaseException:
+        try:
+            os.remove(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def remove_pid_file():
+    """Remove the PID file."""
+    try:
+        if os.path.exists(SCHEDULER_PID_FILE):
+            os.remove(SCHEDULER_PID_FILE)
+    except OSError:
+        pass
+
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals."""
+    global _shutdown_requested
+    print(f"\n[Scheduler] Received signal {signum}, shutting down...")
+    _shutdown_requested = True
+
+
+def start_daemon(foreground: bool = False):
+    """Start the scheduler daemon.
+
+    Args:
+        foreground: If True, run in foreground. If False, daemonize.
+    """
+    global _shutdown_requested
+    _shutdown_requested = False
+
+    # Set up signal handlers
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Write PID file and register cleanup
+    write_pid_file()
+    atexit.register(remove_pid_file)
+
+    # Run the scheduler loop
+    run_scheduler_loop()
+
+
+def get_daemon_pid() -> Optional[int]:
+    """Get the PID of the running daemon, or None if not running."""
+    if not os.path.exists(SCHEDULER_PID_FILE):
+        return None
+
+    try:
+        with open(SCHEDULER_PID_FILE, "r") as f:
+            content = f.read().strip()
+        if not content:
+            remove_pid_file()
+            return None
+        pid = int(content)
+
+        # Check if process is actually running
+        if sys.platform == "win32":
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            handle = kernel32.OpenProcess(
+                0x1000, False, pid
+            )  # PROCESS_QUERY_LIMITED_INFORMATION
+            if handle:
+                kernel32.CloseHandle(handle)
+                return pid
+            return None
+        else:
+            os.kill(pid, 0)  # Doesn't kill, just checks if process exists
+            return pid
+    except (ValueError, ProcessLookupError, PermissionError, OSError):
+        # PID file exists but process is not running - stale PID file
+        remove_pid_file()
+        return None
+
+
+def start_daemon_background() -> bool:
+    """Start the scheduler daemon in the background.
+
+    Returns:
+        True if daemon started successfully, False otherwise.
+    """
+    import subprocess
+    import time
+
+    # NOTE: There is an inherent TOCTOU race between checking if the daemon
+    # is running and starting a new one. Full mitigation would require file
+    # locking (e.g., fcntl.flock). We mitigate by re-checking after start.
+    pid = get_daemon_pid()
+    if pid:
+        return True  # Already running
+
+    cmd = [sys.executable, "-m", "code_puppy.scheduler"]
+
+    if sys.platform == "win32":
+        subprocess.Popen(
+            cmd,
+            creationflags=subprocess.CREATE_NO_WINDOW,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    else:
+        subprocess.Popen(
+            cmd,
+            start_new_session=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    time.sleep(1)
+    # Re-check to confirm daemon actually started (also catches race where
+    # another process started the daemon between our check and Popen).
+    return get_daemon_pid() is not None
+
+
+def stop_daemon() -> bool:
+    """Stop the running daemon. Returns True if stopped successfully."""
+    pid = get_daemon_pid()
+    if not pid:
+        return False
+
+    try:
+        if sys.platform == "win32":
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            handle = kernel32.OpenProcess(1, False, pid)  # PROCESS_TERMINATE
+            kernel32.TerminateProcess(handle, 0)
+            kernel32.CloseHandle(handle)
+        else:
+            os.kill(pid, signal.SIGTERM)
+
+        # Wait for process to stop
+        for _ in range(10):
+            time.sleep(0.5)
+            if not get_daemon_pid():
+                return True
+
+        return False
+    except Exception:
+        return False

code_puppy/scheduler/executor.py

@@ -0,0 +1,155 @@
+"""Task executor for the Code Puppy scheduler.
+
+Handles executing scheduled tasks by invoking code-puppy CLI
+with the configured prompt, model, and agent.
+"""
+
+import os
+import subprocess
+import sys
+from datetime import datetime
+from typing import Tuple
+
+from code_puppy.scheduler.config import (
+    SCHEDULER_LOG_DIR,
+    ScheduledTask,
+    update_task,
+)
+
+
+def get_code_puppy_command() -> str:
+    """Get the path to the code-puppy executable."""
+    # Try to find code-puppy in the same environment as this script
+    if sys.platform == "win32":
+        # On Windows, look for code-puppy.exe or use python -m
+        return "code-puppy"
+    else:
+        # On Unix, code-puppy should be in PATH if installed
+        return "code-puppy"
+
+
+def execute_task(task: ScheduledTask) -> Tuple[bool, int, str]:
+    """Execute a scheduled task.
+
+    Args:
+        task: The ScheduledTask to execute
+
+    Returns:
+        Tuple of (success: bool, exit_code: int, error_message: str)
+    """
+    # Ensure log directory exists
+    os.makedirs(SCHEDULER_LOG_DIR, mode=0o700, exist_ok=True)
+
+    # Build the command
+    cmd = [get_code_puppy_command()]
+
+    # Add prompt
+    cmd.extend(["-p", task.prompt])
+
+    # Add model if specified
+    if task.model:
+        cmd.extend(["--model", task.model])
+
+    # Add agent if specified
+    if task.agent:
+        cmd.extend(["--agent", task.agent])
+
+    # Determine working directory
+    working_dir = task.working_directory
+    if working_dir == "." or not working_dir:
+        working_dir = os.getcwd()
+    working_dir = os.path.expanduser(working_dir)
+
+    # Validate working directory exists
+    if not os.path.isdir(working_dir):
+        error_msg = f"Working directory not found: {working_dir}"
+        task.last_status = "failed"
+        task.last_exit_code = -1
+        update_task(task)
+        return (False, -1, error_msg)
+
+    # Ensure log file path
+    log_file = task.log_file
+    if not log_file:
+        log_file = os.path.join(SCHEDULER_LOG_DIR, f"{task.id}.log")
+    log_file = os.path.expanduser(log_file)
+
+    # Ensure log file directory exists
+    os.makedirs(os.path.dirname(log_file), exist_ok=True)
+
+    # Update task status to running
+    task.last_status = "running"
+    task.last_run = datetime.now().isoformat()
+    update_task(task)
+
+    try:
+        # Open log file for appending
+        with open(log_file, "a") as log_f:
+            # Write header
+            log_f.write(f"\n{'=' * 60}\n")
+            log_f.write(f"Task: {task.name} ({task.id})\n")
+            log_f.write(f"Started: {datetime.now().isoformat()}\n")
+            log_f.write(f"Command: {' '.join(cmd)}\n")
+            log_f.write(f"Working Dir: {working_dir}\n")
+            log_f.write(f"{'=' * 60}\n\n")
+            log_f.flush()
+
+            # Execute the command
+            process = subprocess.Popen(
+                cmd,
+                cwd=working_dir,
+                stdout=log_f,
+                stderr=subprocess.STDOUT,
+                shell=False,
+                env=os.environ.copy(),
+            )
+
+            # Wait for completion
+            exit_code = process.wait()
+
+            # Write footer
+            log_f.write(f"\n{'=' * 60}\n")
+            log_f.write(f"Finished: {datetime.now().isoformat()}\n")
+            log_f.write(f"Exit Code: {exit_code}\n")
+            log_f.write(f"{'=' * 60}\n")
+
+        # Update task status
+        task.last_status = "success" if exit_code == 0 else "failed"
+        task.last_exit_code = exit_code
+        update_task(task)
+
+        return (exit_code == 0, exit_code, "")
+
+    except FileNotFoundError as e:
+        error_msg = f"code-puppy not found: {e}"
+        task.last_status = "failed"
+        task.last_exit_code = -1
+        update_task(task)
+        return (False, -1, error_msg)
+
+    except Exception as e:
+        error_msg = f"Execution error: {e}"
+        task.last_status = "failed"
+        task.last_exit_code = -1
+        update_task(task)
+        return (False, -1, error_msg)
+
+
+def run_task_by_id(task_id: str) -> Tuple[bool, str]:
+    """Run a task immediately by its ID.
+
+    Returns:
+        Tuple of (success: bool, message: str)
+    """
+    from code_puppy.scheduler.config import get_task
+
+    task = get_task(task_id)
+    if not task:
+        return (False, f"Task not found: {task_id}")
+
+    success, exit_code, error = execute_task(task)
+
+    if success:
+        return (True, f"Task '{task.name}' completed successfully")
+    else:
+        return (False, f"Task '{task.name}' failed (exit code: {exit_code}): {error}")

code_puppy/scheduler/platform.py

@@ -0,0 +1,19 @@
+"""Platform abstraction for daemon management.
+
+Provides a unified interface for daemon operations across Windows, Linux, and macOS.
+"""
+
+import sys
+
+if sys.platform == "win32":
+    from code_puppy.scheduler.platform_win import (
+        is_process_running,
+        terminate_process,
+    )
+else:
+    from code_puppy.scheduler.platform_unix import (
+        is_process_running,
+        terminate_process,
+    )
+
+__all__ = ["is_process_running", "terminate_process"]

code_puppy/scheduler/platform_unix.py

@@ -0,0 +1,22 @@
+"""Unix/macOS platform support for scheduler daemon."""
+
+import os
+import signal
+
+
+def is_process_running(pid: int) -> bool:
+    """Check if a process with the given PID is running."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False
+
+
+def terminate_process(pid: int) -> bool:
+    """Terminate a process by PID."""
+    try:
+        os.kill(pid, signal.SIGTERM)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False

code_puppy/scheduler/platform_win.py

@@ -0,0 +1,32 @@
+"""Windows platform support for scheduler daemon."""
+
+import ctypes
+
+
+def is_process_running(pid: int) -> bool:
+    """Check if a process with the given PID is running."""
+    try:
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.OpenProcess(
+            0x1000, False, pid
+        )  # PROCESS_QUERY_LIMITED_INFORMATION
+        if handle:
+            kernel32.CloseHandle(handle)
+            return True
+        return False
+    except Exception:
+        return False
+
+
+def terminate_process(pid: int) -> bool:
+    """Terminate a process by PID."""
+    try:
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.OpenProcess(1, False, pid)  # PROCESS_TERMINATE
+        if handle:
+            kernel32.TerminateProcess(handle, 0)
+            kernel32.CloseHandle(handle)
+            return True
+        return False
+    except Exception:
+        return False