Initial deployment

.gitignore

@@ -0,0 +1,33 @@
+@"
+# Virtual Environment
+venv/
+.venv/
+env/
+
+# Environment Variables
+.env
+
+# Python Cache
+__pycache__/
+*.pyc
+
+# IDE
+.vscode/
+.idea/
+
+# Logs
+*.log
+
+# OS Files
+.DS_Store
+Thumbs.db
+
+# Build Files
+dist/
+build/
+*.egg-info/
+
+# Playwright Reports
+playwright-report/
+test-results/
+"@ | Out-File .gitignore

Dockerfile

@@ -0,0 +1,51 @@
+FROM python:3.12-slim
+
+# Prevent Python from buffering stdout/stderr
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies required by Playwright
+RUN apt-get update && apt-get install -y \
+    curl \
+    wget \
+    git \
+    libnss3 \
+    libatk1.0-0 \
+    libatk-bridge2.0-0 \
+    libcups2 \
+    libdrm2 \
+    libxkbcommon0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxfixes3 \
+    libxrandr2 \
+    libgbm1 \
+    libasound2 \
+    libpangocairo-1.0-0 \
+    libpango-1.0-0 \
+    libcairo2 \
+    libx11-6 \
+    libxcb1 \
+    libxext6 \
+    libx11-xcb1 \
+    libxcursor1 \
+    libxi6 \
+    libxtst6 \
+    fonts-liberation \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install Playwright browser
+RUN playwright install chromium
+
+# Copy project
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

agents/result_formatter/agent.py

@@ -0,0 +1,98 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import (
+    ChatPromptTemplate
+)
+from langchain_core.output_parsers import (
+    StrOutputParser
+)
+
+from core.config import settings
+
+
+class ResultFormatterAgent:
+
+    def __init__(self):
+
+        self.llm = ChatOpenAI(
+            api_key=settings.MISTRAL_API_KEY,
+            base_url="https://api.mistral.ai/v1",
+            model="mistral-medium-latest",
+            temperature=0.1
+        )
+
+        self.prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    """
+You are an expert data analyst.
+
+Your job is to analyze browser automation
+results and present them in a concise,
+human-friendly format.
+
+Rules:
+
+1. Focus only on information relevant
+to the user's request.
+
+2. Ignore:
+   - navigation menus
+   - headers
+   - footers
+   - ads
+   - irrelevant page text
+
+3. Summarize findings clearly.
+
+4. If products are found:
+   - list the most relevant ones
+   - mention prices if available
+
+5. If jobs are found:
+   - list job titles
+   - company names
+   - locations
+
+6. If no useful information exists,
+say so clearly.
+
+Return readable markdown.
+                    """
+                ),
+                (
+                    "user",
+                    """
+User Request:
+{user_prompt}
+
+Workflow Name:
+{workflow_name}
+
+Raw Results:
+{results}
+                    """
+                )
+            ]
+        )
+
+        self.chain = (
+            self.prompt
+            | self.llm
+            | StrOutputParser()
+        )
+
+    def format(
+        self,
+        user_prompt: str,
+        workflow_name: str,
+        results: str
+    ):
+
+        return self.chain.invoke(
+            {
+                "user_prompt": user_prompt,
+                "workflow_name": workflow_name,
+                "results": results
+            }
+        )

agents/workflow_generator/agent.py

@@ -0,0 +1,198 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+
+from core.config import settings
+
+
+class WorkflowGeneratorAgent:
+
+    def __init__(self):
+
+        self.llm = ChatOpenAI(
+            api_key=settings.MISTRAL_API_KEY,
+            base_url="https://api.mistral.ai/v1",
+            model="mistral-medium-latest",
+            temperature=0.2
+        )
+
+        self.prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    """
+You are an expert browser automation workflow planner.
+
+Convert user requests into valid JSON workflows.
+
+Allowed actions:
+
+- goto
+- click
+- fill
+- wait
+- search
+- extract
+
+Rules:
+
+1. execution_type must be:
+   - instant
+   - scheduled
+
+2. If the user wants information, products,
+jobs, prices, news, search results,
+or any data from a website:
+
+Generate:
+
+goto
+search
+wait
+extract
+
+3. Default wait duration is 3 seconds.
+
+4. If the user does not specify the number
+of results to return, use extract limit = 5.
+
+5. If the user specifies a number,
+use that number as the extract limit.
+
+6. If the user mentions a website,
+generate the correct URL.
+
+7. If the request contains scheduling,
+set execution_type to scheduled.
+
+Schedule format:
+
+{{
+    "type": "daily" | "weekly" | "once",
+    "time": "HH:MM"
+}}
+
+For weekly schedules you MUST include:
+
+{{
+    "type": "weekly",
+    "day_of_week": "monday",
+    "time": "09:00"
+}}
+
+Valid values for day_of_week:
+
+- monday
+- tuesday
+- wednesday
+- thursday
+- friday
+- saturday
+- sunday
+
+Example:
+
+Request:
+Every Monday at 9 AM search Amazon for AMD laptops
+
+Output:
+
+{{
+    "workflow_name": "weekly_amd_laptops_search",
+    "execution_type": "scheduled",
+    "schedule": {{
+        "type": "weekly",
+        "day_of_week": "monday",
+        "time": "09:00"
+    }},
+    "steps": [
+        {{
+            "action": "goto",
+            "url": "https://www.amazon.com"
+        }},
+        {{
+            "action": "search",
+            "query": "AMD laptops"
+        }},
+        {{
+            "action": "wait",
+            "duration": 3
+        }},
+        {{
+            "action": "extract",
+            "limit": 5
+        }}
+    ]
+}}
+
+Request:
+Every day at 8 AM check iPhone prices
+
+Output:
+
+{{
+    "workflow_name": "daily_iphone_price_check",
+    "execution_type": "scheduled",
+    "schedule": {{
+        "type": "daily",
+        "time": "08:00"
+    }},
+    "steps": [
+        {{
+            "action": "goto",
+            "url": "https://www.amazon.com"
+        }},
+        {{
+            "action": "search",
+            "query": "iPhone"
+        }},
+        {{
+            "action": "wait",
+            "duration": 3
+        }},
+        {{
+            "action": "extract",
+            "limit": 5
+        }}
+    ]
+}}
+
+8. Create meaningful workflow names.
+
+9. Return ONLY valid JSON.
+
+10. Use "url" for goto actions.
+Never use "target" for goto actions.
+
+Output format:
+
+{{
+    "workflow_name": "",
+    "execution_type": "instant",
+    "schedule": null,
+    "steps": []
+}}
+
+Return JSON only.
+                    """
+                ),
+                ("user", "{prompt}")
+            ]
+        )
+
+        self.chain = (
+            self.prompt
+            | self.llm
+            | StrOutputParser()
+        )
+
+    def generate(
+        self,
+        prompt: str
+    ):
+
+        return self.chain.invoke(
+            {
+                "prompt": prompt
+            }
+        )

agents/workflow_generator/parser.py

@@ -0,0 +1,28 @@
+import json
+
+
+def parse_workflow(response: str):
+
+    try:
+
+        response = response.strip()
+
+        if response.startswith("```json"):
+            response = response.replace(
+                "```json",
+                ""
+            )
+
+        if response.endswith("```"):
+            response = response[:-3]
+
+        response = response.strip()
+
+        return json.loads(response)
+
+    except Exception as e:
+
+        return {
+            "error": str(e),
+            "raw_response": response
+        }

agents/workflow_validator/agent.py

@@ -0,0 +1,105 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+
+from core.config import settings
+
+
+class WorkflowValidatorAgent:
+
+    def __init__(self):
+
+        self.llm = ChatOpenAI(
+            api_key=settings.MISTRAL_API_KEY,
+            base_url="https://api.mistral.ai/v1",
+            model="mistral-medium-latest",
+            temperature=0
+        )
+
+        self.prompt = ChatPromptTemplate.from_messages(
+            [
+                (
+                    "system",
+                    """
+You are a workflow validation agent.
+
+Validate the workflow JSON.
+
+Checks:
+
+1. workflow_name exists.
+
+2. execution_type exists and is:
+   - instant
+   - scheduled
+
+3. steps exists and contains at least
+   one action.
+
+4. Allowed actions:
+
+   - goto
+   - click
+   - fill
+   - wait
+   - search
+   - extract
+
+5. If execution_type is scheduled,
+   schedule must exist.
+
+6. If action is goto,
+   url must exist.
+
+7. If action is search,
+   query must exist.
+
+8. If action is fill,
+   selector and value must exist.
+
+9. If action is click,
+   selector must exist.
+
+10. If action is wait,
+    duration must exist.
+
+11. If action is extract and limit
+    is missing, automatically set:
+
+    {{
+        "limit": 5
+    }}
+
+12. Fix minor issues if possible.
+
+Return ONLY JSON.
+
+Format:
+
+{{
+    "valid": true,
+    "message": "",
+    "workflow": {{}}
+}}
+                    """
+                ),
+                ("user", "{workflow}")
+            ]
+        )
+
+        self.chain = (
+            self.prompt
+            | self.llm
+            | JsonOutputParser()
+        )
+
+    def validate(
+        self,
+        workflow: dict
+    ):
+
+        return self.chain.invoke(
+            {
+                "workflow": workflow
+            }
+        )

api/auth_routes.py

@@ -0,0 +1,107 @@
+from fastapi import APIRouter
+from fastapi import Depends
+from fastapi import HTTPException
+
+from sqlalchemy.orm import Session
+
+from core.database import get_db
+from core.security import create_access_token
+from core.deps import get_current_user
+from models.user import User
+from services.auth_service import (
+    get_user_by_email,
+    create_user,
+    authenticate_user
+)
+
+from schemas.auth_schema import (
+    RegisterRequest,
+    LoginRequest,
+    TokenResponse
+)
+
+# All authentication related APIs will have /auth prefix
+router = APIRouter(
+    prefix="/auth",
+    tags=["Authentication"]
+)
+
+
+# Register a new user
+@router.post("/register")
+def register(
+    payload: RegisterRequest,
+    db: Session = Depends(get_db)
+):
+    # Check if email is already registered
+    existing_user = get_user_by_email(
+        db,
+        payload.email
+    )
+
+    if existing_user:
+        raise HTTPException(
+            status_code=400,
+            detail="Email already registered"
+        )
+
+    # Create user after hashing the password
+    user = create_user(
+        db,
+        payload.name,
+        payload.email,
+        payload.password
+    )
+
+    return {
+        "message": "User registered",
+        "user_id": user.id
+    }
+
+
+# Login user and generate JWT access token
+@router.post(
+    "/login",
+    response_model=TokenResponse
+)
+def login(
+    payload: LoginRequest,
+    db: Session = Depends(get_db)
+):
+    # Verify email and password
+    user = authenticate_user(
+        db,
+        payload.email,
+        payload.password
+    )
+
+    if not user:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid credentials"
+        )
+
+    # Store user information inside JWT payload
+    token = create_access_token(
+        {
+            "sub": str(user.id),
+            "email": user.email
+        }
+    )
+
+    return {
+        "access_token": token,
+        "token_type": "bearer"
+    }
+
+
+# Returns details of the currently logged-in user
+@router.get("/me")
+def get_me(
+    current_user: User = Depends(get_current_user)
+):
+    return {
+        "id": current_user.id,
+        "name": current_user.name,
+        "email": current_user.email
+    }

api/execution_routes.py

@@ -0,0 +1,159 @@
+from fastapi import (
+    APIRouter,
+    Depends,
+    HTTPException
+)
+
+from sqlalchemy.orm import Session
+
+from core.database import get_db
+from core.deps import get_current_user
+
+from services.execution_service import (
+    ExecutionService
+)
+
+from models.workflow import Workflow
+from models.workflow_run import WorkflowRun
+
+
+router = APIRouter(
+    prefix="/executions",
+    tags=["Executions"]
+)
+
+execution_service = ExecutionService()
+
+
+# RUN WORKFLOW
+
+@router.post("/run/{workflow_id}")
+async def run_workflow(
+    workflow_id: int,
+    db: Session = Depends(get_db),
+    current_user = Depends(
+        get_current_user
+    )
+):
+
+    return await execution_service.run_workflow(
+        workflow_id,
+        current_user.id,
+        db
+    )
+
+
+# GET ALL EXECUTIONS OF CURRENT USER
+
+@router.get("/history")
+def get_execution_history(
+    db: Session = Depends(get_db),
+    current_user = Depends(
+        get_current_user
+    )
+):
+
+    runs = (
+        db.query(
+            WorkflowRun
+        )
+        .join(
+            Workflow,
+            Workflow.id ==
+            WorkflowRun.workflow_id
+        )
+        .filter(
+            Workflow.user_id ==
+            current_user.id
+        )
+        .order_by(
+            WorkflowRun.started_at.desc()
+        )
+        .all()
+    )
+
+    return runs
+
+
+# GET EXECUTION HISTORY OF A WORKFLOW
+
+@router.get(
+    "/workflow/{workflow_id}"
+)
+def get_workflow_runs(
+    workflow_id: int,
+    db: Session = Depends(get_db),
+    current_user = Depends(
+        get_current_user
+    )
+):
+
+    workflow = db.query(
+        Workflow
+    ).filter(
+        Workflow.id == workflow_id,
+        Workflow.user_id ==
+        current_user.id
+    ).first()
+
+    if not workflow:
+
+        raise HTTPException(
+            status_code=404,
+            detail="Workflow not found"
+        )
+
+    runs = (
+        db.query(
+            WorkflowRun
+        )
+        .filter(
+            WorkflowRun.workflow_id ==
+            workflow_id
+        )
+        .order_by(
+            WorkflowRun.started_at.desc()
+        )
+        .all()
+    )
+
+    return runs
+
+
+# GET SINGLE EXECUTION
+
+@router.get("/{run_id}")
+def get_execution(
+    run_id: int,
+    db: Session = Depends(get_db),
+    current_user = Depends(
+        get_current_user
+    )
+):
+
+    run = (
+        db.query(
+            WorkflowRun
+        )
+        .join(
+            Workflow,
+            Workflow.id ==
+            WorkflowRun.workflow_id
+        )
+        .filter(
+            WorkflowRun.id ==
+            run_id,
+            Workflow.user_id ==
+            current_user.id
+        )
+        .first()
+    )
+
+    if not run:
+
+        raise HTTPException(
+            status_code=404,
+            detail="Execution not found"
+        )
+
+    return run

api/workflow_routes.py

@@ -0,0 +1,145 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from core.database import get_db
+from core.deps import get_current_user
+
+from models.workflow import Workflow
+from models.user import User
+from models.workflow_schedule import WorkflowSchedule
+from models.workflow_run import WorkflowRun
+from models.execution_log import ExecutionLog
+
+from schemas.workflow_schema import WorkflowRequest
+
+from services.workflow_service import WorkflowService
+
+
+router = APIRouter(
+    prefix="/workflows",
+    tags=["Workflows"]
+)
+
+workflow_service = WorkflowService()
+
+
+# CREATE WORKFLOW
+
+@router.post("/")
+def create_workflow(
+    request: WorkflowRequest,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+
+    return workflow_service.create_workflow(
+        prompt=request.prompt,
+        user_id=current_user.id,
+        db=db
+    )
+
+
+# GET ALL WORKFLOWS (USER ONLY)
+
+@router.get("")
+def get_workflows(
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+
+    workflows = db.query(
+        Workflow
+    ).filter(
+        Workflow.user_id == current_user.id
+    ).all()
+
+    return workflows
+
+
+# GET SINGLE WORKFLOW
+
+@router.get("/{workflow_id}")
+def get_workflow(
+    workflow_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+
+    workflow = db.query(
+        Workflow
+    ).filter(
+        Workflow.id == workflow_id,
+        Workflow.user_id == current_user.id
+    ).first()
+
+    if not workflow:
+
+        raise HTTPException(
+            status_code=404,
+            detail="Workflow not found"
+        )
+
+    return workflow
+
+
+# DELETE WORKFLOW
+
+@router.delete("/{workflow_id}")
+def delete_workflow(
+    workflow_id: int,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+
+    workflow = db.query(
+        Workflow
+    ).filter(
+        Workflow.id == workflow_id,
+        Workflow.user_id == current_user.id
+    ).first()
+
+    if not workflow:
+
+        raise HTTPException(
+            status_code=404,
+            detail="Workflow not found"
+        )
+
+    # Fetch all runs for this workflow
+    runs = db.query(
+        WorkflowRun
+    ).filter(
+        WorkflowRun.workflow_id == workflow.id
+    ).all()
+
+    # Delete execution logs first
+    for run in runs:
+
+        db.query(
+            ExecutionLog
+        ).filter(
+            ExecutionLog.run_id == run.id
+        ).delete()
+
+    # Delete workflow runs
+    db.query(
+        WorkflowRun
+    ).filter(
+        WorkflowRun.workflow_id == workflow.id
+    ).delete()
+
+    # Delete workflow schedules
+    db.query(
+        WorkflowSchedule
+    ).filter(
+        WorkflowSchedule.workflow_id == workflow.id
+    ).delete()
+
+    # Delete workflow
+    db.delete(workflow)
+
+    db.commit()
+
+    return {
+        "message": "Workflow deleted"
+    }

browser/playwright_client.py

@@ -0,0 +1,30 @@
+from playwright.async_api import (
+    async_playwright
+)
+
+
+class PlaywrightClient:
+
+    async def get_page(self):
+
+        # Start the Playwright engine
+        playwright = await (
+            async_playwright().start()
+        )
+
+        # Launch a headless Chromium browser
+        browser = await (
+            playwright.chromium.launch(
+                headless=True
+            )
+        )
+
+        # Open a new browser tab
+        page = await browser.new_page()
+
+        # Return all objects so they can be used and closed later
+        return (
+            playwright,
+            browser,
+            page
+        )

browser/test_playwright.py

@@ -0,0 +1,28 @@
+import asyncio
+from playwright.async_api import async_playwright
+
+
+async def main():
+
+    playwright = await async_playwright().start()
+
+    browser = await playwright.chromium.launch(
+        headless=False
+    )
+
+    page = await browser.new_page()
+
+    await page.goto(
+        "https://google.com"
+    )
+
+    await page.wait_for_timeout(
+        5000
+    )
+
+    await browser.close()
+
+    await playwright.stop()
+
+
+asyncio.run(main())

core/config.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+class Settings(BaseSettings):
+    DATABASE_URL: str
+    SECRET_KEY: str
+    ALGORITHM: str
+    ACCESS_TOKEN_EXPIRE_MINUTES: int
+    MISTRAL_API_KEY: str
+
+    APP_NAME: str = "TaskWeaver"
+
+    model_config = SettingsConfigDict(
+        env_file=BASE_DIR / ".env",
+        extra="ignore"
+    )
+
+settings = Settings()
+
+print("Loaded successfully")

core/database.py

@@ -0,0 +1,27 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+from core.config import settings
+
+engine = create_engine(
+    settings.DATABASE_URL,
+    pool_pre_ping=True
+)
+
+SessionLocal = sessionmaker(
+    autocommit=False,
+    autoflush=False,
+    bind=engine
+)
+
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+
+    try:
+        yield db
+    finally:
+        db.close()

core/deps.py

@@ -0,0 +1,50 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+from jose import jwt, JWTError
+
+from sqlalchemy.orm import Session
+
+from core.config import settings
+from core.database import get_db
+from models.user import User
+
+security = HTTPBearer()
+
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    db: Session = Depends(get_db)
+):
+    token = credentials.credentials
+
+    try:
+        payload = jwt.decode(
+            token,
+            settings.SECRET_KEY,
+            algorithms=[settings.ALGORITHM]
+        )
+
+        user_id: str = payload.get("sub")
+
+        if user_id is None:
+            raise HTTPException(
+                status_code=401,
+                detail="Invalid token"
+            )
+
+    except JWTError:
+        raise HTTPException(
+            status_code=401,
+            detail="Token is invalid or expired"
+        )
+
+    user = db.query(User).filter(User.id == int(user_id)).first()
+
+    if not user:
+        raise HTTPException(
+            status_code=404,
+            detail="User not found"
+        )
+
+    return user

core/security.py

@@ -0,0 +1,42 @@
+from datetime import datetime, timedelta
+
+from jose import jwt
+from passlib.context import CryptContext
+
+from core.config import settings
+
+
+pwd_context = CryptContext(
+    schemes=["bcrypt"],
+    deprecated="auto"
+)
+
+
+def hash_password(password: str) -> str:
+    return pwd_context.hash(password)
+
+
+def verify_password(
+    plain_password: str,
+    hashed_password: str
+) -> bool:
+    return pwd_context.verify(
+        plain_password,
+        hashed_password
+    )
+
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+
+    expire = datetime.utcnow() + timedelta(
+        minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
+    )
+
+    to_encode.update({"exp": expire})
+
+    return jwt.encode(
+        to_encode,
+        settings.SECRET_KEY,
+        algorithm=settings.ALGORITHM
+    )

executor/action_registry.py

@@ -0,0 +1 @@
+ACTION_REGISTRY = {}

executor/actions/click_action.py

@@ -0,0 +1,24 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+"""{
+    "action": "click",
+    "selector": "#submit"
+}"""
+
+async def execute(
+    page,
+    step
+):
+
+    await page.click(
+        step["selector"]
+    )
+
+    return {
+        "action": "click",
+        "status": "success"
+    }
+
+
+ACTION_REGISTRY["click"] = execute

executor/actions/extract_action.py

@@ -0,0 +1,27 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+
+
+async def execute(
+    page,
+    step
+):
+
+    body_text = await page.locator(
+        "body"
+    ).inner_text()
+
+    max_chars = step.get(
+        "max_chars",
+        12000
+    )
+
+    return {
+        "action": "extract",
+        "status": "success",
+        "data": body_text[:max_chars]
+    }
+
+
+ACTION_REGISTRY["extract"] = execute

executor/actions/fill_action.py

@@ -0,0 +1,26 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+"""{
+    "action": "fill",
+    "selector": "#email",
+    "value": "abc@test.com"
+}"""
+
+async def execute(
+    page,
+    step
+):
+
+    await page.fill(
+        step["selector"],
+        step["value"]
+    )
+
+    return {
+        "action": "fill",
+        "status": "success"
+    }
+
+
+ACTION_REGISTRY["fill"] = execute

executor/actions/goto_action.py

@@ -0,0 +1,21 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+
+
+async def execute(
+    page,
+    step
+):
+
+    url = step.get("url") or step.get("target")
+
+    await page.goto(url)
+
+    return {
+        "action": "goto",
+        "status": "success"
+    }
+
+
+ACTION_REGISTRY["goto"] = execute

executor/actions/save_results_action.py

@@ -0,0 +1,21 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+
+
+async def execute(
+    page,
+    step
+):
+
+    print(
+        "SAVE RESULTS"
+    )
+
+    return {
+        "action": "save_results",
+        "status": "success"
+    }
+
+
+ACTION_REGISTRY["save_results"] = execute

executor/actions/search_action.py

@@ -0,0 +1,31 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+
+
+async def execute(
+    page,
+    step
+):
+
+    query = step["query"]
+
+    search_box = page.locator(
+        "input[type='search'], input[type='text']"
+    ).first
+
+    await search_box.fill(
+        query
+    )
+
+    await page.keyboard.press(
+        "Enter"
+    )
+
+    return {
+        "action": "search",
+        "status": "success"
+    }
+
+
+ACTION_REGISTRY["search"] = execute

executor/actions/wait_action.py

@@ -0,0 +1,21 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+
+
+async def execute(
+    page,
+    step
+):
+
+    await page.wait_for_timeout(
+        step["duration"] * 1000
+    )
+
+    return {
+        "action": "wait",
+        "status": "success"
+    }
+
+
+ACTION_REGISTRY["wait"] = execute

executor/executor.py

@@ -0,0 +1,127 @@
+from executor.action_registry import (
+    ACTION_REGISTRY
+)
+
+# Importing action modules automatically registers them
+# into ACTION_REGISTRY during module initialization.
+import executor.actions.goto_action
+import executor.actions.click_action
+import executor.actions.fill_action
+import executor.actions.wait_action
+import executor.actions.extract_action
+import executor.actions.save_results_action
+import executor.actions.search_action
+
+from models.execution_log import (
+    ExecutionLog
+)
+
+
+class WorkflowExecutor:
+
+    async def execute(
+        self,
+        page,
+        workflow,
+        db=None,
+        run_id=None
+    ):
+
+        # Store results returned by each workflow step
+        results = []
+
+        # Execute workflow steps one by one in the defined order
+        for index, step in enumerate(
+            workflow["steps"],
+            start=1
+        ):
+
+            action = step["action"]
+
+            print(
+                "ACTION_REGISTRY =",
+                ACTION_REGISTRY
+            )
+
+            print(
+                "ACTION =",
+                action
+            )
+
+            # Find the function corresponding to this action
+            handler = ACTION_REGISTRY.get(
+                action
+            )
+
+            if not handler:
+
+                # Log failure if action is unsupported
+                if db and run_id:
+
+                    db.add(
+                        ExecutionLog(
+                            run_id=run_id,
+                            step_number=index,
+                            action=action,
+                            status="failed",
+                            message=f"Unknown action: {action}"
+                        )
+                    )
+
+                    db.commit()
+
+                raise Exception(
+                    f"Unknown action: {action}"
+                )
+
+            try:
+
+                # Execute the Playwright action
+                result = await handler(
+                    page,
+                    step
+                )
+
+                results.append(
+                    result
+                )
+
+                # Store successful execution log
+                if db and run_id:
+
+                    db.add(
+                        ExecutionLog(
+                            run_id=run_id,
+                            step_number=index,
+                            action=action,
+                            status=result.get(
+                                "status",
+                                "success"
+                            ),
+                            message=f"{action} executed successfully"
+                        )
+                    )
+
+                    db.commit()
+
+            except Exception as e:
+
+                # Log step failure before stopping workflow execution
+                if db and run_id:
+
+                    db.add(
+                        ExecutionLog(
+                            run_id=run_id,
+                            step_number=index,
+                            action=action,
+                            status="failed",
+                            message=str(e)
+                        )
+                    )
+
+                    db.commit()
+
+                raise e
+
+        # Return results collected from all workflow steps
+        return results

main.py

@@ -0,0 +1,68 @@
+import asyncio
+
+# Required for Playwright on Windows
+asyncio.set_event_loop_policy(
+    asyncio.WindowsProactorEventLoopPolicy()
+)
+
+from fastapi import FastAPI
+
+from core.database import Base, engine
+
+# Import models before creating tables
+from models.user import User
+from models.workflow import Workflow
+from models.workflow_run import WorkflowRun
+from models.execution_log import ExecutionLog
+from models.workflow_schedule import WorkflowSchedule
+
+# Import API routes
+from api.workflow_routes import router as workflow_router
+from api.auth_routes import router as auth_router
+from api.execution_routes import (
+    router as execution_router
+)
+
+from fastapi.middleware.cors import (
+    CORSMiddleware
+)
+
+from middleware.request_timer import (
+    request_timer
+)
+
+from scheduler.scheduler import start_scheduler
+
+# Create FastAPI application
+app = FastAPI(
+    title="TaskWeaver",
+    version="1.0.0"
+)
+
+# Register request timing middleware
+app.middleware("http")(
+    request_timer
+)
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+# Register all API routes
+app.include_router(auth_router)
+app.include_router(workflow_router)
+app.include_router(execution_router)
+
+# Start scheduler when the server starts
+@app.on_event("startup")
+def startup_event():
+    start_scheduler()
+
+# Root endpoint
+@app.get("/")
+def root():
+    return {"message": "TaskWeaver API Running"}
+
+# Health check endpoint
+@app.get("/health")
+def health():
+    return {"status": "healthy"}

middleware/request_timer.py

@@ -0,0 +1,33 @@
+import time
+
+from fastapi import Request
+
+
+async def request_timer(
+    request: Request,
+    call_next
+):
+
+    start_time = time.perf_counter()
+
+    response = await call_next(
+        request
+    )
+
+    process_time = (
+        time.perf_counter()
+        - start_time
+    )
+
+    response.headers[
+        "X-Process-Time"
+    ] = f"{process_time:.4f}"
+
+    print(
+        f"[{request.method}] "
+        f"{request.url.path} "
+        f"completed in "
+        f"{process_time:.4f}s"
+    )
+
+    return response

models/execution_log.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Text,
+    ForeignKey,
+    DateTime
+)
+
+from core.database import Base
+
+
+class ExecutionLog(Base):
+    __tablename__ = "execution_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    run_id = Column(
+        Integer,
+        ForeignKey("workflow_runs.id"),
+        nullable=False
+    )
+
+    step_number = Column(Integer)
+
+    action = Column(String(100))
+
+    status = Column(String(50))
+
+    message = Column(Text)
+
+    created_at = Column(
+        DateTime,
+        default=datetime.utcnow
+    )

models/user.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from sqlalchemy import Column, Integer, String, DateTime
+
+from core.database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    name = Column(String(100), nullable=False)
+
+    email = Column(String(255), unique=True, nullable=False)
+
+    password_hash = Column(String(255), nullable=False)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    updated_at = Column(
+        DateTime,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow
+    )

models/workflow.py

@@ -0,0 +1,38 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Text,
+    ForeignKey,
+    DateTime
+)
+
+from core.database import Base
+
+
+class Workflow(Base):
+    __tablename__ = "workflows"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    user_id = Column(
+        Integer,
+        ForeignKey("users.id"),
+        nullable=False
+    )
+
+    name = Column(String(255), nullable=False)
+
+    prompt = Column(Text, nullable=False)
+
+    workflow_json = Column(Text)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    updated_at = Column(
+        DateTime,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow
+    )

models/workflow_run.py

@@ -0,0 +1,45 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Text,
+    ForeignKey,
+    DateTime,
+    Float
+)
+
+from core.database import Base
+
+
+class WorkflowRun(Base):
+    __tablename__ = "workflow_runs"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    workflow_id = Column(
+        Integer,
+        ForeignKey("workflows.id"),
+        nullable=False
+    )
+
+    status = Column(
+        String(50),
+        default="pending"
+    )
+
+    started_at = Column(DateTime)
+
+    completed_at = Column(DateTime)
+
+    duration = Column(Float)
+
+    result_json = Column(Text)
+
+    error_message = Column(Text)
+
+    created_at = Column(
+        DateTime,
+        default=datetime.utcnow
+    )

models/workflow_schedule.py

@@ -0,0 +1,49 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    Boolean,
+    ForeignKey,
+    DateTime
+)
+
+from core.database import Base
+
+
+class WorkflowSchedule(Base):
+    __tablename__ = "workflow_schedules"
+
+    id = Column(Integer, primary_key=True, index=True)
+
+    workflow_id = Column(
+        Integer,
+        ForeignKey("workflows.id"),
+        nullable=False
+    )
+
+    schedule_type = Column(
+        String(50),
+        nullable=False
+    )
+
+    run_time = Column(
+        String(10)
+    )
+
+    day_of_week = Column(
+        String(20)
+    )
+
+    is_active = Column(
+        Boolean,
+        default=True
+    )
+
+    next_run_at = Column(DateTime)
+
+    created_at = Column(
+        DateTime,
+        default=datetime.utcnow
+    )

requirements.txt

@@ -0,0 +1,25 @@
+fastapi==0.116.1
+uvicorn[standard]==0.35.0
+
+sqlalchemy==2.0.43
+psycopg2-binary==2.9.10
+
+python-dotenv==1.1.1
+
+python-jose[cryptography]==3.5.0
+passlib[bcrypt]==1.7.4
+bcrypt==4.1.2
+
+
+pydantic==2.11.7
+pydantic-settings==2.10.1
+
+mistralai==1.9.10
+
+playwright==1.54.0
+
+apscheduler==3.11.0
+
+loguru==0.7.3
+email-validator
+

scheduler/poller.py

@@ -0,0 +1,110 @@
+from datetime import datetime, timedelta
+
+from core.database import SessionLocal
+
+from models.workflow_schedule import WorkflowSchedule
+
+from scheduler.queue import execution_queue
+
+
+def calculate_next_run(schedule):
+
+    now = datetime.utcnow()
+
+    hour, minute = map(
+        int,
+        schedule.run_time.split(":")
+    )
+
+    if schedule.schedule_type == "daily":
+
+        next_run = now.replace(
+            hour=hour,
+            minute=minute,
+            second=0,
+            microsecond=0
+        )
+
+        if next_run <= now:
+            next_run += timedelta(days=1)
+
+        return next_run
+
+    if schedule.schedule_type == "weekly":
+
+        days = {
+            "monday": 0,
+            "tuesday": 1,
+            "wednesday": 2,
+            "thursday": 3,
+            "friday": 4,
+            "saturday": 5,
+            "sunday": 6
+        }
+
+        target_day = days[
+            schedule.day_of_week.lower()
+        ]
+
+        current_day = now.weekday()
+
+        days_ahead = (
+            target_day - current_day
+        ) % 7
+
+        next_run = now.replace(
+            hour=hour,
+            minute=minute,
+            second=0,
+            microsecond=0
+        ) + timedelta(
+            days=days_ahead
+        )
+
+        if next_run <= now:
+            next_run += timedelta(days=7)
+
+        return next_run
+
+    return None
+
+
+def check_due_workflows():
+
+    db = SessionLocal()
+
+    try:
+
+        schedules = db.query(
+            WorkflowSchedule
+        ).filter(
+            WorkflowSchedule.is_active == True,
+            WorkflowSchedule.next_run_at <= datetime.utcnow()
+        ).all()
+
+        print(
+            f"Found {len(schedules)} due schedules"
+        )
+
+        for schedule in schedules:
+
+            execution_queue.put(
+                schedule.workflow_id
+            )
+
+            print(
+                f"Queued workflow {schedule.workflow_id}"
+            )
+
+            # move schedule forward immediately
+            schedule.next_run_at = (
+                calculate_next_run(
+                    schedule
+                )
+            )
+
+        db.commit()
+
+    finally:
+
+        db.close()

scheduler/queue.py

@@ -0,0 +1,3 @@
+from queue import Queue
+
+execution_queue = Queue()

scheduler/scheduler.py

@@ -0,0 +1,29 @@
+from apscheduler.schedulers.background import (
+    BackgroundScheduler
+)
+
+from scheduler.poller import (
+    check_due_workflows
+)
+from scheduler.worker import (
+    start_worker
+)
+scheduler = BackgroundScheduler()
+
+
+def start_scheduler():
+
+    if not scheduler.running:
+        start_worker()
+
+        scheduler.add_job(
+            check_due_workflows,
+            "interval",
+            minutes=5
+        )
+        
+        scheduler.start()
+
+        print(
+            "Scheduler started"
+        )

scheduler/worker.py

@@ -0,0 +1,60 @@
+import threading
+import asyncio
+
+from core.database import SessionLocal
+
+from scheduler.queue import (
+    execution_queue
+)
+
+from services.execution_service import (
+    ExecutionService
+)
+
+
+def worker():
+
+    print("Worker started")
+
+    while True:
+
+        workflow_id = execution_queue.get()
+
+        print(
+            f"Executing workflow {workflow_id}"
+        )
+
+        db = SessionLocal()
+
+        try:
+
+            service = ExecutionService()
+
+            asyncio.run(
+                service.run_scheduled_workflow(
+                    workflow_id,
+                    db
+                )
+            )
+
+        except Exception as e:
+
+            print(
+                f"Worker error: {e}"
+            )
+
+        finally:
+
+            db.close()
+
+        execution_queue.task_done()
+
+
+def start_worker():
+
+    thread = threading.Thread(
+        target=worker,
+        daemon=True
+    )
+
+    thread.start()