autoforge-ai 0.1.0

package/server/routers/schedules.py

@@ -0,0 +1,356 @@
+"""
+Schedules Router
+================
+
+API endpoints for managing agent schedules.
+Provides CRUD operations for time-based schedule configuration.
+"""
+
+from contextlib import contextmanager
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Generator, Tuple
+
+from fastapi import APIRouter, HTTPException
+from sqlalchemy.orm import Session
+
+# Schedule limits to prevent resource exhaustion
+MAX_SCHEDULES_PER_PROJECT = 50
+
+from ..schemas import (
+    NextRunResponse,
+    ScheduleCreate,
+    ScheduleListResponse,
+    ScheduleResponse,
+    ScheduleUpdate,
+)
+from ..utils.project_helpers import get_project_path as _get_project_path
+from ..utils.validation import validate_project_name
+
+if TYPE_CHECKING:
+    from api.database import Schedule as ScheduleModel
+
+
+def _schedule_to_response(schedule: "ScheduleModel") -> ScheduleResponse:
+    """Convert a Schedule ORM object to a ScheduleResponse Pydantic model.
+
+    SQLAlchemy Column descriptors resolve to Python types at instance access time,
+    but mypy sees the Column[T] descriptor type. Using model_validate with
+    from_attributes handles this conversion correctly.
+    """
+    return ScheduleResponse.model_validate(schedule, from_attributes=True)
+
+router = APIRouter(
+    prefix="/api/projects/{project_name}/schedules",
+    tags=["schedules"]
+)
+
+
+@contextmanager
+def _get_db_session(project_name: str) -> Generator[Tuple[Session, Path], None, None]:
+    """Get database session for a project as a context manager.
+
+    Usage:
+        with _get_db_session(project_name) as (db, project_path):
+            # ... use db ...
+        # db is automatically closed
+    """
+    from api.database import create_database
+
+    project_name = validate_project_name(project_name)
+    project_path = _get_project_path(project_name)
+
+    if not project_path:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Project '{project_name}' not found in registry"
+        )
+
+    if not project_path.exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"Project directory not found: {project_path}"
+        )
+
+    _, SessionLocal = create_database(project_path)
+    db = SessionLocal()
+    try:
+        yield db, project_path
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
+@router.get("", response_model=ScheduleListResponse)
+async def list_schedules(project_name: str):
+    """Get all schedules for a project."""
+    from api.database import Schedule
+
+    with _get_db_session(project_name) as (db, _):
+        schedules = db.query(Schedule).filter(
+            Schedule.project_name == project_name
+        ).order_by(Schedule.start_time).all()
+
+        return ScheduleListResponse(
+            schedules=[_schedule_to_response(s) for s in schedules]
+        )
+
+
+@router.post("", response_model=ScheduleResponse, status_code=201)
+async def create_schedule(project_name: str, data: ScheduleCreate):
+    """Create a new schedule for a project."""
+    from api.database import Schedule
+
+    from ..services.scheduler_service import get_scheduler
+
+    with _get_db_session(project_name) as (db, project_path):
+        # Check schedule limit to prevent resource exhaustion
+        existing_count = db.query(Schedule).filter(
+            Schedule.project_name == project_name
+        ).count()
+
+        if existing_count >= MAX_SCHEDULES_PER_PROJECT:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Maximum schedules per project ({MAX_SCHEDULES_PER_PROJECT}) exceeded"
+            )
+
+        # Create schedule record
+        schedule = Schedule(
+            project_name=project_name,
+            start_time=data.start_time,
+            duration_minutes=data.duration_minutes,
+            days_of_week=data.days_of_week,
+            enabled=data.enabled,
+            yolo_mode=data.yolo_mode,
+            model=data.model,
+        )
+        db.add(schedule)
+        db.commit()
+        db.refresh(schedule)
+
+        # Register with APScheduler if enabled
+        if schedule.enabled:
+            import logging
+            logger = logging.getLogger(__name__)
+
+            scheduler = get_scheduler()
+            await scheduler.add_schedule(project_name, schedule, project_path)
+            logger.info(f"Registered schedule {schedule.id} with APScheduler")
+
+            # Check if we're currently within this schedule's window
+            # If so, start the agent immediately (cron won't trigger until next occurrence)
+            now = datetime.now(timezone.utc)
+            is_within = scheduler._is_within_window(schedule, now)
+            logger.info(f"Schedule {schedule.id}: is_within_window={is_within}, now={now}, start={schedule.start_time}")
+
+            if is_within:
+                # Check for manual stop override
+                from api.database import ScheduleOverride
+                override = db.query(ScheduleOverride).filter(
+                    ScheduleOverride.schedule_id == schedule.id,
+                    ScheduleOverride.override_type == "stop",
+                    ScheduleOverride.expires_at > now,
+                ).first()
+
+                logger.info(f"Schedule {schedule.id}: has_override={override is not None}")
+
+                if not override:
+                    # Start agent immediately
+                    logger.info(
+                        f"Schedule {schedule.id} is within active window, starting agent immediately"
+                    )
+                    try:
+                        await scheduler._start_agent(project_name, project_path, schedule)
+                        logger.info(f"Successfully started agent for schedule {schedule.id}")
+                    except Exception as e:
+                        logger.error(f"Failed to start agent for schedule {schedule.id}: {e}", exc_info=True)
+
+        return _schedule_to_response(schedule)
+
+
+@router.get("/next", response_model=NextRunResponse)
+async def get_next_scheduled_run(project_name: str):
+    """Calculate next scheduled run across all enabled schedules."""
+    from api.database import Schedule, ScheduleOverride
+
+    from ..services.scheduler_service import get_scheduler
+
+    with _get_db_session(project_name) as (db, _):
+        schedules = db.query(Schedule).filter(
+            Schedule.project_name == project_name,
+            Schedule.enabled == True,  # noqa: E712
+        ).all()
+
+        if not schedules:
+            return NextRunResponse(
+                has_schedules=False,
+                next_start=None,
+                next_end=None,
+                is_currently_running=False,
+                active_schedule_count=0,
+            )
+
+        now = datetime.now(timezone.utc)
+        scheduler = get_scheduler()
+
+        # Find active schedules and calculate next run
+        active_count = 0
+        next_start = None
+        latest_end = None
+
+        for schedule in schedules:
+            if scheduler._is_within_window(schedule, now):
+                # Check for manual stop override
+                override = db.query(ScheduleOverride).filter(
+                    ScheduleOverride.schedule_id == schedule.id,
+                    ScheduleOverride.override_type == "stop",
+                    ScheduleOverride.expires_at > now,
+                ).first()
+
+                if not override:
+                    # Schedule is active and not manually stopped
+                    active_count += 1
+                    # Calculate end time for this window
+                    end_time = _calculate_window_end(schedule, now)
+                    if latest_end is None or end_time > latest_end:
+                        latest_end = end_time
+                # If override exists, treat schedule as not active
+            else:
+                # Calculate next start time
+                next_schedule_start = _calculate_next_start(schedule, now)
+                if next_schedule_start and (next_start is None or next_schedule_start < next_start):
+                    next_start = next_schedule_start
+
+        return NextRunResponse(
+            has_schedules=True,
+            next_start=next_start if active_count == 0 else None,
+            next_end=latest_end,
+            is_currently_running=active_count > 0,
+            active_schedule_count=active_count,
+        )
+
+
+@router.get("/{schedule_id}", response_model=ScheduleResponse)
+async def get_schedule(project_name: str, schedule_id: int):
+    """Get a single schedule by ID."""
+    from api.database import Schedule
+
+    with _get_db_session(project_name) as (db, _):
+        schedule = db.query(Schedule).filter(
+            Schedule.id == schedule_id,
+            Schedule.project_name == project_name,
+        ).first()
+
+        if not schedule:
+            raise HTTPException(status_code=404, detail="Schedule not found")
+
+        return _schedule_to_response(schedule)
+
+
+@router.patch("/{schedule_id}", response_model=ScheduleResponse)
+async def update_schedule(
+    project_name: str,
+    schedule_id: int,
+    data: ScheduleUpdate
+):
+    """Update an existing schedule."""
+    from api.database import Schedule
+
+    from ..services.scheduler_service import get_scheduler
+
+    with _get_db_session(project_name) as (db, project_path):
+        schedule = db.query(Schedule).filter(
+            Schedule.id == schedule_id,
+            Schedule.project_name == project_name,
+        ).first()
+
+        if not schedule:
+            raise HTTPException(status_code=404, detail="Schedule not found")
+
+        was_enabled = schedule.enabled
+
+        # Update only fields that were explicitly provided
+        # This allows sending {"model": null} to clear it vs omitting the field entirely
+        update_data = data.model_dump(exclude_unset=True)
+        for field, value in update_data.items():
+            setattr(schedule, field, value)
+
+        db.commit()
+        db.refresh(schedule)
+
+        # Update APScheduler jobs
+        scheduler = get_scheduler()
+        if schedule.enabled:
+            # Re-register with updated times
+            await scheduler.add_schedule(project_name, schedule, project_path)
+        elif was_enabled:
+            # Was enabled, now disabled - remove jobs
+            scheduler.remove_schedule(schedule_id)
+
+        return _schedule_to_response(schedule)
+
+
+@router.delete("/{schedule_id}", status_code=204)
+async def delete_schedule(project_name: str, schedule_id: int):
+    """Delete a schedule."""
+    from api.database import Schedule
+
+    from ..services.scheduler_service import get_scheduler
+
+    with _get_db_session(project_name) as (db, _):
+        schedule = db.query(Schedule).filter(
+            Schedule.id == schedule_id,
+            Schedule.project_name == project_name,
+        ).first()
+
+        if not schedule:
+            raise HTTPException(status_code=404, detail="Schedule not found")
+
+        # Remove APScheduler jobs
+        scheduler = get_scheduler()
+        scheduler.remove_schedule(schedule_id)
+
+        # Delete from database
+        db.delete(schedule)
+        db.commit()
+
+
+def _calculate_window_end(schedule, now: datetime) -> datetime:
+    """Calculate when the current window ends."""
+    start_hour, start_minute = map(int, schedule.start_time.split(":"))
+
+    # Create start time for today in UTC
+    window_start = now.replace(
+        hour=start_hour, minute=start_minute, second=0, microsecond=0
+    )
+
+    # If current time is before start time, the window started yesterday
+    if now < window_start:
+        window_start = window_start - timedelta(days=1)
+
+    return window_start + timedelta(minutes=schedule.duration_minutes)
+
+
+def _calculate_next_start(schedule, now: datetime) -> datetime | None:
+    """Calculate the next start time for a schedule."""
+    start_hour, start_minute = map(int, schedule.start_time.split(":"))
+
+    # Create start time for today
+    candidate = now.replace(
+        hour=start_hour, minute=start_minute, second=0, microsecond=0
+    )
+
+    # If already past today's start time, check tomorrow
+    if candidate <= now:
+        candidate = candidate + timedelta(days=1)
+
+    # Find the next active day
+    for _ in range(7):
+        if schedule.is_active_on_day(candidate.weekday()):
+            return candidate
+        candidate = candidate + timedelta(days=1)
+
+    return None

package/server/routers/settings.py

@@ -0,0 +1,127 @@
+"""
+Settings Router
+===============
+
+API endpoints for global settings management.
+Settings are stored in the registry database and shared across all projects.
+"""
+
+import mimetypes
+import os
+import sys
+
+from fastapi import APIRouter
+
+from ..schemas import ModelInfo, ModelsResponse, SettingsResponse, SettingsUpdate
+from ..services.chat_constants import ROOT_DIR
+
+# Mimetype fix for Windows - must run before StaticFiles is mounted
+mimetypes.add_type("text/javascript", ".js", True)
+
+# Ensure root is on sys.path for registry import
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+from registry import (
+    AVAILABLE_MODELS,
+    DEFAULT_MODEL,
+    get_all_settings,
+    set_setting,
+)
+
+router = APIRouter(prefix="/api/settings", tags=["settings"])
+
+
+def _parse_yolo_mode(value: str | None) -> bool:
+    """Parse YOLO mode string to boolean."""
+    return (value or "false").lower() == "true"
+
+
+def _is_glm_mode() -> bool:
+    """Check if GLM API is configured via environment variables."""
+    base_url = os.getenv("ANTHROPIC_BASE_URL", "")
+    # GLM mode is when ANTHROPIC_BASE_URL is set but NOT pointing to Ollama
+    return bool(base_url) and not _is_ollama_mode()
+
+
+def _is_ollama_mode() -> bool:
+    """Check if Ollama API is configured via environment variables."""
+    base_url = os.getenv("ANTHROPIC_BASE_URL", "")
+    return "localhost:11434" in base_url or "127.0.0.1:11434" in base_url
+
+
+@router.get("/models", response_model=ModelsResponse)
+async def get_available_models():
+    """Get list of available models.
+
+    Frontend should call this to get the current list of models
+    instead of hardcoding them.
+    """
+    return ModelsResponse(
+        models=[ModelInfo(id=m["id"], name=m["name"]) for m in AVAILABLE_MODELS],
+        default=DEFAULT_MODEL,
+    )
+
+
+def _parse_int(value: str | None, default: int) -> int:
+    """Parse integer setting with default fallback."""
+    if value is None:
+        return default
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return default
+
+
+def _parse_bool(value: str | None, default: bool = False) -> bool:
+    """Parse boolean setting with default fallback."""
+    if value is None:
+        return default
+    return value.lower() == "true"
+
+
+@router.get("", response_model=SettingsResponse)
+async def get_settings():
+    """Get current global settings."""
+    all_settings = get_all_settings()
+
+    return SettingsResponse(
+        yolo_mode=_parse_yolo_mode(all_settings.get("yolo_mode")),
+        model=all_settings.get("model", DEFAULT_MODEL),
+        glm_mode=_is_glm_mode(),
+        ollama_mode=_is_ollama_mode(),
+        testing_agent_ratio=_parse_int(all_settings.get("testing_agent_ratio"), 1),
+        playwright_headless=_parse_bool(all_settings.get("playwright_headless"), default=True),
+        batch_size=_parse_int(all_settings.get("batch_size"), 3),
+    )
+
+
+@router.patch("", response_model=SettingsResponse)
+async def update_settings(update: SettingsUpdate):
+    """Update global settings."""
+    if update.yolo_mode is not None:
+        set_setting("yolo_mode", "true" if update.yolo_mode else "false")
+
+    if update.model is not None:
+        set_setting("model", update.model)
+
+    if update.testing_agent_ratio is not None:
+        set_setting("testing_agent_ratio", str(update.testing_agent_ratio))
+
+    if update.playwright_headless is not None:
+        set_setting("playwright_headless", "true" if update.playwright_headless else "false")
+
+    if update.batch_size is not None:
+        set_setting("batch_size", str(update.batch_size))
+
+    # Return updated settings
+    all_settings = get_all_settings()
+    return SettingsResponse(
+        yolo_mode=_parse_yolo_mode(all_settings.get("yolo_mode")),
+        model=all_settings.get("model", DEFAULT_MODEL),
+        glm_mode=_is_glm_mode(),
+        ollama_mode=_is_ollama_mode(),
+        testing_agent_ratio=_parse_int(all_settings.get("testing_agent_ratio"), 1),
+        playwright_headless=_parse_bool(all_settings.get("playwright_headless"), default=True),
+        batch_size=_parse_int(all_settings.get("batch_size"), 3),
+    )