Upload 170 files

.gitattributes

@@ -35,3 +35,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 fonts/TikTok-Bold.ttf filter=lfs diff=lfs merge=lfs -text
 gradio_demo.png filter=lfs diff=lfs merge=lfs -text
+assets/edu_note.wav filter=lfs diff=lfs merge=lfs -text
+assets/fun_fact.wav filter=lfs diff=lfs merge=lfs -text
+assets/thanks.wav filter=lfs diff=lfs merge=lfs -text

assets/edu_note.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:880362273fe0348d8e73e9cf99cbe58573ccaac1e51628e92d4a362c8199d399
+size 416444

assets/fun_fact.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:245b8db3fc90671b02baa477ce0c2d08754b225ae95a853687191ad126de562e
+size 496844

assets/thanks.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d04843d86bff241ff659cf6c6931641797411dbf3b1532eee83914058bbc5a64
+size 288044

auth/database.py

@@ -0,0 +1,88 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+from sqlalchemy.exc import OperationalError
+
+# ==========================================================
+# DATABASE URL
+# ==========================================================
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+if not DATABASE_URL:
+    raise RuntimeError(
+        "DATABASE_URL environment variable is not set"
+    )
+
+# ==========================================================
+# SUPABASE ENTERPRISE ENGINE CONFIG
+# ==========================================================
+# Optimized for:
+# - Supabase Pooler
+# - FastAPI async workload
+# - Background workers
+# - Long-running autonomous services
+
+engine = create_engine(
+    DATABASE_URL,
+
+    # --- Pool Stability ---
+    pool_pre_ping=True,      # validates dead connections
+    pool_recycle=300,        # refresh connections
+    pool_size=5,             # safe baseline
+    max_overflow=10,         # burst capacity
+
+    # --- Reliability ---
+    echo=False,
+    future=True,
+
+    # --- Supabase Requirement ---
+    connect_args={
+        "sslmode": "require",
+        "connect_timeout": 10,
+    },
+)
+
+# ==========================================================
+# SESSION FACTORY
+# ==========================================================
+SessionLocal = sessionmaker(
+    autocommit=False,
+    autoflush=False,
+    bind=engine,
+)
+
+# ==========================================================
+# BASE MODEL
+# ==========================================================
+Base = declarative_base()
+
+# ==========================================================
+# DEPENDENCY (FASTAPI)
+# ==========================================================
+def get_db():
+    """
+    FastAPI dependency injection session.
+    Ensures connection cleanup even on crash.
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+# ==========================================================
+# CONNECTION TEST (STARTUP SAFE)
+# ==========================================================
+def verify_database_connection():
+    """
+    Validates database connectivity during startup.
+    Prevents silent runtime failures.
+    """
+    try:
+        with engine.connect() as conn:
+            conn.execute("SELECT 1")
+    except OperationalError as e:
+        raise RuntimeError(
+            f"Database connection failed: {str(e)}"
+        )

auth/models.py

@@ -0,0 +1,96 @@
+import uuid
+from sqlalchemy import Column, String, Boolean, DateTime, func, Index
+from sqlalchemy.dialects.postgresql import UUID
+
+from auth.database import Base
+
+
+# =========================================================
+# USERS TABLE (CORE AUTH ENTITY)
+# =========================================================
+class User(Base):
+    __tablename__ = "users"
+
+    # -----------------------------
+    # Primary Key (UUID for Supabase compatibility)
+    # -----------------------------
+    id = Column(
+        UUID(as_uuid=True),
+        primary_key=True,
+        default=uuid.uuid4,
+        nullable=False,
+    )
+
+    # -----------------------------
+    # Identity Fields
+    # -----------------------------
+    email = Column(String(255), unique=True, nullable=False, index=True)
+    username = Column(String(100), unique=True, nullable=True, index=True)
+
+    # -----------------------------
+    # Security Fields
+    # NOTE: stores hashed password only (never plaintext)
+    # -----------------------------
+    hashed_password = Column(String(255), nullable=False)
+
+    # -----------------------------
+    # Account State
+    # -----------------------------
+    is_active = Column(Boolean, default=True, nullable=False)
+    is_verified = Column(Boolean, default=False, nullable=False)
+
+    # -----------------------------
+    # Audit Fields
+    # -----------------------------
+    created_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+
+    updated_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+
+# =========================================================
+# OPTIONAL: API KEY TABLE (FOR AUTOMATION / N8N / WORKFLOWS)
+# =========================================================
+class ApiKey(Base):
+    __tablename__ = "api_keys"
+
+    id = Column(
+        UUID(as_uuid=True),
+        primary_key=True,
+        default=uuid.uuid4,
+        nullable=False,
+    )
+
+    user_id = Column(
+        UUID(as_uuid=True),
+        nullable=False,
+        index=True,
+    )
+
+    key_hash = Column(String(255), nullable=False, unique=True)
+
+    name = Column(String(120), nullable=True)
+
+    is_active = Column(Boolean, default=True, nullable=False)
+
+    created_at = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False,
+    )
+
+
+# =========================================================
+# INDEXES (PERFORMANCE OPTIMIZATION)
+# =========================================================
+Index("idx_users_email", User.email)
+Index("idx_users_username", User.username)
+Index("idx_api_keys_user_id", ApiKey.user_id)

auth/routes.py

@@ -0,0 +1,340 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from sqlalchemy.exc import IntegrityError
+from datetime import datetime
+
+from auth.database import get_db
+from auth.models import User
+from auth.schemas import (
+    SignupSchema,
+    LoginSchema,
+    TokenSchema,
+)
+from auth.security import (
+    hash_password,
+    verify_password,
+    create_access_token,
+    decode_token,
+)
+
+router = APIRouter(
+    prefix="/api/auth",
+    tags=["Authentication"],
+)
+
+
+# =========================================================
+# SIGNUP
+# =========================================================
+
+@router.post("/signup", status_code=201)
+def signup(
+    data: SignupSchema,
+    db: Session = Depends(get_db),
+):
+
+    try:
+
+        # =================================================
+        # NORMALIZATION
+        # =================================================
+
+        email = data.email.strip().lower()
+        username = data.username.strip()
+
+        # =================================================
+        # EXISTING EMAIL CHECK
+        # =================================================
+
+        existing_email = (
+            db.query(User)
+            .filter(User.email == email)
+            .first()
+        )
+
+        if existing_email:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail="Email already registered",
+            )
+
+        # =================================================
+        # EXISTING USERNAME CHECK
+        # =================================================
+
+        existing_username = (
+            db.query(User)
+            .filter(User.username == username)
+            .first()
+        )
+
+        if existing_username:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail="Username already taken",
+            )
+
+        # =================================================
+        # HASH PASSWORD
+        # =================================================
+
+        password_hash = hash_password(data.password)
+
+        # =================================================
+        # CREATE USER
+        # =================================================
+
+        user = User(
+            email=email,
+            username=username,
+            password_hash=password_hash,
+            created_at=datetime.utcnow(),
+        )
+
+        db.add(user)
+        db.commit()
+        db.refresh(user)
+
+        # =================================================
+        # CREATE JWT
+        # =================================================
+
+        token = create_access_token(
+            {
+                "sub": str(user.id),
+                "email": user.email,
+            }
+        )
+
+        return {
+            "status": "success",
+            "message": "Account created successfully",
+            "token": token,
+            "user": {
+                "id": str(user.id),
+                "email": user.email,
+                "username": user.username,
+                "created_at": (
+                    user.created_at.isoformat()
+                    if user.created_at
+                    else None
+                ),
+            },
+        }
+
+    except HTTPException:
+        raise
+
+    except IntegrityError as e:
+
+        db.rollback()
+
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="User already exists",
+        )
+
+    except ValueError as e:
+
+        db.rollback()
+
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e),
+        )
+
+    except Exception as e:
+
+        db.rollback()
+
+        print("SIGNUP ERROR:", str(e))
+
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Signup failed: {str(e)}",
+        )
+
+
+# =========================================================
+# LOGIN
+# =========================================================
+
+@router.post("/login")
+def login(
+    data: LoginSchema,
+    db: Session = Depends(get_db),
+):
+
+    try:
+
+        email = data.email.strip().lower()
+
+        user = (
+            db.query(User)
+            .filter(User.email == email)
+            .first()
+        )
+
+        if not user:
+
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid email or password",
+            )
+
+        if not verify_password(
+            data.password,
+            user.password_hash,
+        ):
+
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid email or password",
+            )
+
+        token = create_access_token(
+            {
+                "sub": str(user.id),
+                "email": user.email,
+            }
+        )
+
+        return {
+            "status": "success",
+            "message": "Login successful",
+            "token": token,
+            "user": {
+                "id": str(user.id),
+                "email": user.email,
+                "username": user.username,
+                "created_at": (
+                    user.created_at.isoformat()
+                    if user.created_at
+                    else None
+                ),
+            },
+        }
+
+    except HTTPException:
+        raise
+
+    except Exception as e:
+
+        print("LOGIN ERROR:", str(e))
+
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Login failed: {str(e)}",
+        )
+
+
+# =========================================================
+# VERIFY TOKEN
+# =========================================================
+
+@router.post("/verify")
+def verify_token(
+    data: TokenSchema,
+):
+
+    try:
+
+        payload = decode_token(data.token)
+
+        if not payload:
+
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid token",
+            )
+
+        return {
+            "valid": True,
+            "payload": payload,
+        }
+
+    except HTTPException:
+        raise
+
+    except Exception as e:
+
+        print("VERIFY ERROR:", str(e))
+
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Token verification failed: {str(e)}",
+        )
+
+
+# =========================================================
+# REFRESH TOKEN
+# =========================================================
+
+@router.post("/refresh")
+def refresh_token(
+    data: TokenSchema,
+    db: Session = Depends(get_db),
+):
+
+    try:
+
+        payload = decode_token(data.token)
+
+        user_id = payload.get("sub")
+
+        if not user_id:
+
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid token payload",
+            )
+
+        user = (
+            db.query(User)
+            .filter(User.id == user_id)
+            .first()
+        )
+
+        if not user:
+
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="User not found",
+            )
+
+        new_token = create_access_token(
+            {
+                "sub": str(user.id),
+                "email": user.email,
+            }
+        )
+
+        return {
+            "status": "success",
+            "token": new_token,
+        }
+
+    except HTTPException:
+        raise
+
+    except Exception as e:
+
+        print("REFRESH ERROR:", str(e))
+
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Refresh failed: {str(e)}",
+        )
+
+
+# =========================================================
+# LOGOUT
+# =========================================================
+
+@router.post("/logout")
+def logout():
+
+    return {
+        "status": "success",
+        "message": "Logout successful",
+    }

auth/schemas.py

@@ -0,0 +1,59 @@
+from pydantic import BaseModel, EmailStr, Field, ConfigDict
+
+
+# =========================================================
+# BASE CONFIG (STRICT MODE → PREVENTS SILENT DATA COERCION)
+# =========================================================
+class StrictSchema(BaseModel):
+    model_config = ConfigDict(
+        strict=True,
+        extra="forbid",
+        validate_assignment=True,
+    )
+
+
+# =========================================================
+# SIGNUP SCHEMA
+# =========================================================
+class SignupSchema(StrictSchema):
+    email: EmailStr
+    username: str = Field(
+        min_length=3,
+        max_length=32,
+        pattern=r"^[a-zA-Z0-9_]+$"
+    )
+    password: str = Field(
+        min_length=8,
+        max_length=72,
+    )
+
+
+# =========================================================
+# LOGIN SCHEMA
+# =========================================================
+class LoginSchema(StrictSchema):
+    email: EmailStr
+    password: str = Field(
+        min_length=1,
+        max_length=72,
+    )
+
+
+# =========================================================
+# TOKEN REQUEST SCHEMA
+# =========================================================
+class TokenSchema(StrictSchema):
+    token: str = Field(
+        min_length=10,
+        max_length=2048
+    )
+
+
+# =========================================================
+# USER RESPONSE SCHEMA (SAFE OUTPUT MODEL)
+# =========================================================
+class UserOutSchema(StrictSchema):
+    id: int
+    email: EmailStr
+    username: str
+    created_at: str

auth/security.py

@@ -0,0 +1,137 @@
+import os
+from datetime import datetime, timedelta, timezone
+from typing import Optional, Dict, Any
+
+from jose import jwt, JWTError
+from passlib.context import CryptContext
+from fastapi import HTTPException, status, Depends
+from fastapi.security import OAuth2PasswordBearer
+
+
+# =========================================================
+# ENV CONFIG
+# =========================================================
+
+SECRET_KEY = os.getenv("SECRET_KEY")
+
+if not SECRET_KEY:
+    raise RuntimeError("SECRET_KEY environment variable missing")
+
+ALGORITHM = os.getenv("ALGORITHM", "HS256")
+
+ACCESS_TOKEN_EXPIRE_MINUTES = int(
+    os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "1440")
+)
+
+
+# =========================================================
+# PASSWORD HASHING
+# =========================================================
+# IMPORTANT:
+# pbkdf2_sha256 avoids:
+# - bcrypt crashes
+# - bcrypt native dependency issues
+# - 72-byte limits
+# - passlib backend bugs
+# =========================================================
+
+pwd_context = CryptContext(
+    schemes=["pbkdf2_sha256"],
+    deprecated="auto",
+)
+
+
+def hash_password(password: str) -> str:
+
+    if not password:
+        raise ValueError("Password required")
+
+    if len(password) < 8:
+        raise ValueError("Password too short")
+
+    return pwd_context.hash(password)
+
+
+def verify_password(
+    plain_password: str,
+    hashed_password: str,
+) -> bool:
+
+    try:
+        return pwd_context.verify(
+            plain_password,
+            hashed_password,
+        )
+    except Exception:
+        return False
+
+
+# =========================================================
+# JWT
+# =========================================================
+
+def create_access_token(
+    data: Dict[str, Any],
+    expires_delta: Optional[timedelta] = None,
+) -> str:
+
+    to_encode = data.copy()
+
+    expire = datetime.now(timezone.utc) + (
+        expires_delta
+        if expires_delta
+        else timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+
+    to_encode.update({"exp": expire})
+
+    return jwt.encode(
+        to_encode,
+        SECRET_KEY,
+        algorithm=ALGORITHM,
+    )
+
+
+def decode_token(token: str):
+
+    try:
+        return jwt.decode(
+            token,
+            SECRET_KEY,
+            algorithms=[ALGORITHM],
+        )
+
+    except JWTError:
+
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+
+# =========================================================
+# AUTH DEPENDENCY
+# =========================================================
+
+oauth2_scheme = OAuth2PasswordBearer(
+    tokenUrl="/api/auth/login"
+)
+
+
+def get_current_user(
+    token: str = Depends(oauth2_scheme)
+):
+
+    payload = decode_token(token)
+
+    user_id = payload.get("sub")
+
+    if not user_id:
+
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid authentication",
+        )
+
+    return payload

core/builders/api_builder.py

@@ -0,0 +1,142 @@
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from typing import Optional
+import tempfile
+import shutil
+import os
+
+from core.registry.loader import get_tasks
+from core.execution.executor import execute_task
+
+
+# =====================================================
+# ROUTER BUILDER
+# =====================================================
+
+def build_api_router() -> APIRouter:
+    """
+    Dynamically builds API routes from TASK REGISTRY.
+
+    Generated endpoints:
+
+        POST /execute/{task}
+        GET  /tasks
+        GET  /health
+    """
+
+    router = APIRouter(tags=["API"])
+
+    # =================================================
+    # EXECUTE TASK
+    # =================================================
+    @router.post("/execute/{task_name}")
+    async def execute(
+        task_name: str,
+        file: Optional[UploadFile] = File(None),
+        url_input: Optional[str] = Form(None),
+    ):
+        """
+        Universal execution endpoint.
+        Accepts:
+            - file upload
+            - url_input
+        """
+
+        tasks = get_tasks()
+
+        if task_name not in tasks:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Task '{task_name}' not found",
+            )
+
+        temp_path = None
+
+        try:
+            # -----------------------------------------
+            # SAVE UPLOADED FILE
+            # -----------------------------------------
+            if file:
+                suffix = os.path.splitext(file.filename)[1]
+
+                with tempfile.NamedTemporaryFile(
+                    delete=False,
+                    suffix=suffix,
+                ) as tmp:
+                    shutil.copyfileobj(file.file, tmp)
+                    temp_path = tmp.name
+
+            # -----------------------------------------
+            # BUILD INPUT PAYLOAD
+            # -----------------------------------------
+            payload = {
+                "file_path": temp_path,
+                "url_input": url_input,
+            }
+
+            # -----------------------------------------
+            # EXECUTE TASK
+            # -----------------------------------------
+            result = await execute_task(task_name, payload)
+
+            # -----------------------------------------
+            # FILE RESPONSE
+            # -----------------------------------------
+            if isinstance(result, dict) and result.get("file"):
+                output_file = result["file"]
+
+                if os.path.exists(output_file):
+                    return FileResponse(
+                        output_file,
+                        filename=os.path.basename(output_file),
+                    )
+
+            # -----------------------------------------
+            # JSON RESPONSE
+            # -----------------------------------------
+            return JSONResponse(result)
+
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=str(e),
+            )
+
+        finally:
+            # -----------------------------------------
+            # CLEANUP TEMP FILE
+            # -----------------------------------------
+            if temp_path and os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+    # =================================================
+    # TASK LIST
+    # =================================================
+    @router.get("/tasks")
+    async def list_tasks():
+        """
+        Returns registry tasks.
+        Used by UI and Docs builder.
+        """
+
+        tasks = get_tasks()
+
+        return {
+            name: {
+                "category": getattr(t, "category", "general"),
+                "description": getattr(t, "description", ""),
+            }
+            for name, t in tasks.items()
+        }
+
+    # =================================================
+    # HEALTH CHECK
+    # =================================================
+    @router.get("/health")
+    async def health():
+        return {
+            "status": "ok",
+            "tasks_loaded": len(get_tasks()),
+        }
+
+    return router

core/builders/docs_builder.py

@@ -0,0 +1,89 @@
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+from typing import Dict, Any, List
+
+from core.registry.tasks_registry import TASKS
+
+
+# =====================================================
+# INTERNAL HELPERS
+# =====================================================
+
+def _serialize_task(task) -> Dict[str, Any]:
+    """
+    Convert TaskDefinition → API-safe metadata.
+    Must NOT import task modules.
+    """
+
+    return {
+        "name": getattr(task, "name", None),
+        "description": getattr(task, "description", ""),
+        "category": getattr(task, "category", "general"),
+        "module": getattr(task, "module", None),
+        "callable": getattr(task, "callable_name", "run"),
+        "async": getattr(task, "async_task", False),
+        "enabled": getattr(task, "enabled", True),
+    }
+
+
+def _group_tasks(tasks: List[Any]) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    Groups tasks by category for UI rendering.
+    """
+
+    grouped: Dict[str, List[Dict[str, Any]]] = {}
+
+    for task in tasks:
+        category = getattr(task, "category", "general")
+        grouped.setdefault(category, []).append(_serialize_task(task))
+
+    return grouped
+
+
+# =====================================================
+# DOCS ROUTER BUILDER (V11)
+# =====================================================
+
+def build_docs_router() -> APIRouter:
+    """
+    Builds dynamic documentation endpoints.
+
+    Provides:
+        /docs/tasks      → flat task list
+        /docs/catalog    → grouped tasks
+        /docs/health     → docs status
+    """
+
+    router = APIRouter(
+        prefix="/docs",
+        tags=["Documentation"],
+    )
+
+    # -------------------------------------------------
+    # List all tasks
+    # -------------------------------------------------
+    @router.get("/tasks")
+    async def list_tasks():
+        return JSONResponse(
+            [_serialize_task(task) for task in TASKS]
+        )
+
+    # -------------------------------------------------
+    # Categorized task catalog
+    # -------------------------------------------------
+    @router.get("/catalog")
+    async def task_catalog():
+        return JSONResponse(_group_tasks(TASKS))
+
+    # -------------------------------------------------
+    # Docs health endpoint
+    # -------------------------------------------------
+    @router.get("/health")
+    async def docs_health():
+        return {
+            "status": "ok",
+            "service": "docs",
+            "tasks_registered": len(TASKS),
+        }
+
+    return router

core/builders/ui_builder.py

@@ -0,0 +1,107 @@
+from fastapi import APIRouter
+from fastapi.responses import HTMLResponse, FileResponse
+from pathlib import Path
+from typing import Dict, List
+
+from core.registry.tasks_registry import TASKS
+
+
+# =====================================================
+# CONFIG
+# =====================================================
+
+BASE_DIR = Path(__file__).resolve().parents[2]
+UI_DIR = BASE_DIR / "ui"
+INDEX_FILE = UI_DIR / "index.html"
+
+
+# =====================================================
+# TASK GROUPING
+# =====================================================
+
+def group_tasks() -> Dict[str, List[dict]]:
+    """
+    Converts registry → categorized UI structure.
+    """
+
+    categories: Dict[str, List[dict]] = {}
+
+    for task in TASKS:
+        if not getattr(task, "enabled", True):
+            continue
+
+        category = getattr(task, "category", "general")
+
+        categories.setdefault(category, []).append(
+            {
+                "name": task.name,
+                "description": getattr(task, "description", ""),
+            }
+        )
+
+    return categories
+
+
+# =====================================================
+# ROUTER BUILDER
+# =====================================================
+
+def build_ui_router() -> APIRouter:
+    """
+    Serves UI + dynamic UI metadata.
+
+    Endpoints:
+        /
+        /ui
+        /ui/tasks
+        /ui/health
+    """
+
+    router = APIRouter(tags=["UI"])
+
+    # -------------------------------------------------
+    # MAIN UI
+    # -------------------------------------------------
+    @router.get("/", response_class=HTMLResponse)
+    async def serve_root():
+        """
+        Serves index.html
+        """
+
+        if not INDEX_FILE.exists():
+            return HTMLResponse(
+                "<h1>Basyx UI Missing</h1>",
+                status_code=500,
+            )
+
+        return FileResponse(INDEX_FILE)
+
+    # -------------------------------------------------
+    # Explicit UI route
+    # -------------------------------------------------
+    @router.get("/ui", response_class=HTMLResponse)
+    async def serve_ui():
+        return await serve_root()
+
+    # -------------------------------------------------
+    # UI TASK CATALOG
+    # -------------------------------------------------
+    @router.get("/ui/tasks")
+    async def ui_tasks():
+        """
+        UI fetches this to build sidebar dynamically.
+        """
+        return group_tasks()
+
+    # -------------------------------------------------
+    # HEALTH
+    # -------------------------------------------------
+    @router.get("/ui/health")
+    async def ui_health():
+        return {
+            "status": "ok",
+            "ui": "active",
+            "tasks": len(TASKS),
+        }
+
+    return router

core/execution/context.py

@@ -0,0 +1,155 @@
+"""
+V11 Execution Context
+---------------------
+
+Central runtime object passed into every task.
+
+Responsibilities:
+- Hold inputs
+- Share memory between tasks
+- Store outputs
+- Track execution metadata
+- Provide filesystem helpers
+- Provide logging helpers
+"""
+
+from __future__ import annotations
+
+import os
+import uuid
+import tempfile
+from typing import Any, Dict, Optional
+
+
+# =========================================================
+# Context Object
+# =========================================================
+
+class ExecutionContext:
+    """
+    Standard runtime context used by ALL tasks.
+
+    Every task receives:
+        async def run(ctx: ExecutionContext)
+    """
+
+    # -----------------------------------------------------
+    # INIT
+    # -----------------------------------------------------
+    def __init__(
+        self,
+        task_name: str,
+        inputs: Optional[Dict[str, Any]] = None,
+        workspace: Optional[str] = None,
+    ):
+
+        self.task_name = task_name
+        self.job_id = str(uuid.uuid4())
+
+        self.inputs: Dict[str, Any] = inputs or {}
+        self.outputs: Dict[str, Any] = {}
+        self.memory: Dict[str, Any] = {}
+
+        self.status: str = "created"
+        self.error: Optional[str] = None
+
+        self.workspace = workspace or self._create_workspace()
+
+    # -----------------------------------------------------
+    # WORKSPACE
+    # -----------------------------------------------------
+    def _create_workspace(self) -> str:
+        path = tempfile.mkdtemp(prefix="basyx_job_")
+        return path
+
+    def path(self, filename: str) -> str:
+        """
+        Safe workspace path helper
+        """
+        return os.path.join(self.workspace, filename)
+
+    # -----------------------------------------------------
+    # INPUT HELPERS
+    # -----------------------------------------------------
+    def get(self, key: str, default=None):
+        return self.inputs.get(key, default)
+
+    def require(self, key: str):
+        if key not in self.inputs:
+            raise ValueError(f"Missing required input: {key}")
+        return self.inputs[key]
+
+    # -----------------------------------------------------
+    # OUTPUT HELPERS
+    # -----------------------------------------------------
+    def set_output(self, key: str, value: Any):
+        self.outputs[key] = value
+
+    def result(self) -> Dict[str, Any]:
+        return {
+            "job_id": self.job_id,
+            "task": self.task_name,
+            "status": self.status,
+            "outputs": self.outputs,
+            "error": self.error,
+        }
+
+    # -----------------------------------------------------
+    # MEMORY (cross-task sharing)
+    # -----------------------------------------------------
+    def remember(self, key: str, value: Any):
+        """
+        Save value for downstream tasks.
+        """
+        self.memory[key] = value
+
+    def recall(self, key: str, default=None):
+        return self.memory.get(key, default)
+
+    # -----------------------------------------------------
+    # STATUS MANAGEMENT
+    # -----------------------------------------------------
+    def mark_running(self):
+        self.status = "running"
+
+    def mark_complete(self):
+        self.status = "completed"
+
+    def mark_failed(self, error: Exception | str):
+        self.status = "failed"
+        self.error = str(error)
+
+    # -----------------------------------------------------
+    # LOGGING
+    # -----------------------------------------------------
+    def log(self, message: str):
+        print(f"[{self.task_name} | {self.job_id}] {message}")
+
+    # -----------------------------------------------------
+    # SERIALIZATION
+    # -----------------------------------------------------
+    def to_dict(self):
+        return {
+            "job_id": self.job_id,
+            "task_name": self.task_name,
+            "inputs": self.inputs,
+            "outputs": self.outputs,
+            "memory": self.memory,
+            "status": self.status,
+            "error": self.error,
+            "workspace": self.workspace,
+        }
+
+
+# =========================================================
+# Context Factory
+# =========================================================
+
+def create_context(task_name: str, inputs: Dict[str, Any]) -> ExecutionContext:
+    """
+    Standardized factory used by executor.
+    """
+    return ExecutionContext(
+        task_name=task_name,
+        inputs=inputs,
+    )

core/execution/executor.py

@@ -0,0 +1,166 @@
+"""
+BASYX V11 EXECUTOR
+------------------
+
+Central task execution engine.
+
+Responsibilities:
+- Load task from registry
+- Create execution context
+- Execute task safely
+- Capture outputs
+- Handle failures
+- Support chaining
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from typing import Dict, Any, List
+
+from core.execution.context import create_context, ExecutionContext
+from core.registry.loader import get_task_map
+
+
+# =========================================================
+# TASK CACHE
+# =========================================================
+
+TASK_MAP = get_task_map()
+
+
+# =========================================================
+# INTERNAL EXECUTION
+# =========================================================
+
+async def _run_task(
+    task_name: str,
+    inputs: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Execute a single task safely.
+    """
+
+    if task_name not in TASK_MAP:
+        raise ValueError(f"Unknown task: {task_name}")
+
+    task = TASK_MAP[task_name]
+
+    ctx: ExecutionContext = create_context(
+        task_name=task_name,
+        inputs=inputs,
+    )
+
+    ctx.mark_running()
+    ctx.log("Starting task")
+
+    try:
+
+        # ---------------------------------------------
+        # Execute task
+        # ---------------------------------------------
+        result = task.run
+
+        if inspect.iscoroutinefunction(result):
+            await result(ctx)
+        else:
+            await asyncio.to_thread(result, ctx)
+
+        ctx.mark_complete()
+        ctx.log("Task completed")
+
+    except Exception as e:
+        ctx.mark_failed(e)
+        ctx.log(f"Task failed: {e}")
+
+    return ctx.result()
+
+
+# =========================================================
+# PUBLIC EXECUTOR
+# =========================================================
+
+async def execute_task(
+    task_name: str,
+    inputs: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Main entrypoint used by API + UI.
+    """
+
+    return await _run_task(task_name, inputs)
+
+
+# =========================================================
+# PIPELINE EXECUTION (CHAINED TASKS)
+# =========================================================
+
+async def execute_pipeline(
+    tasks: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """
+    Execute tasks sequentially.
+
+    Example:
+    [
+        {"task": "transcribe", "inputs": {...}},
+        {"task": "subtitles"},
+        {"task": "render"}
+    ]
+    """
+
+    results = []
+    shared_memory = {}
+
+    for step in tasks:
+
+        name = step["task"]
+        inputs = step.get("inputs", {})
+
+        # Inject memory from previous step
+        inputs["memory"] = shared_memory
+
+        result = await _run_task(name, inputs)
+
+        results.append(result)
+
+        if result["status"] != "completed":
+            break
+
+        # propagate outputs
+        shared_memory.update(result.get("outputs", {}))
+
+    return results
+
+
+# =========================================================
+# PARALLEL EXECUTION
+# =========================================================
+
+async def execute_parallel(
+    tasks: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """
+    Run multiple tasks concurrently.
+    """
+
+    coroutines = [
+        _run_task(t["task"], t.get("inputs", {}))
+        for t in tasks
+    ]
+
+    return await asyncio.gather(*coroutines)
+
+
+# =========================================================
+# REGISTRY HOT RELOAD (DEV MODE)
+# =========================================================
+
+def reload_tasks():
+    """
+    Reload registry without restarting server.
+    Useful during development.
+    """
+    global TASK_MAP
+    TASK_MAP = get_task_map()

core/registry/loader.py

@@ -0,0 +1,45 @@
+from core.registry.tasks_registry import TASKS
+
+
+# ------------------------------------------------
+# Return categorized tasks (UI Builder uses this)
+# ------------------------------------------------
+def get_tasks():
+    return TASKS
+
+
+# ------------------------------------------------
+# Flatten tasks across categories
+# ------------------------------------------------
+def get_all_tasks():
+
+    tasks = []
+
+    for category, items in TASKS.items():
+        for task in items:
+            task_copy = dict(task)
+            task_copy["category"] = category
+            tasks.append(task_copy)
+
+    return tasks
+
+
+# ------------------------------------------------
+# Execution map
+# id -> callable
+# ------------------------------------------------
+def get_task_map():
+
+    task_map = {}
+
+    for category, items in TASKS.items():
+        for task in items:
+
+            if "handler" not in task:
+                raise RuntimeError(
+                    f"Task '{task['id']}' missing handler"
+                )
+
+            task_map[task["id"]] = task["handler"]
+
+    return task_map

core/registry/task_model.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel, Field
+from typing import Callable, Dict, Any
+
+
+class TaskDefinition(BaseModel):
+    name: str
+    category: str
+    description: str
+
+    handler: Callable
+
+    inputs: Dict[str, str] = Field(default_factory=dict)
+    outputs: Dict[str, str] = Field(default_factory=dict)
+
+    ui_schema: Dict[str, Any] = Field(default_factory=dict)
+
+    autonomous: bool = True
+
+    class Config:
+        arbitrary_types_allowed = True

core/registry/tasks_registry.py

@@ -0,0 +1,198 @@
+"""
+BASYX V11 — Dynamic Task Registry
+---------------------------------
+
+Single Source Of Truth for:
+
+• UI generation
+• API routes
+• Executor routing
+• Documentation builder
+• Autonomous Brain planning
+"""
+
+# =========================================================
+# ANALYSIS TASKS
+# =========================================================
+
+from publisher.tasks.transcribe import run as transcribe
+from publisher.tasks.subtitles import run as subtitles
+from publisher.tasks.highlights import run as highlights
+from publisher.tasks.viral_score import run as viral_score
+from publisher.tasks.strategy import run as strategy
+
+
+# =========================================================
+# RENDER TASKS
+# =========================================================
+
+from publisher.tasks.render import run as render
+from publisher.tasks.generate_thumbnail import run as generate_thumbnail
+from publisher.tasks.generate_metadata import run as generate_metadata
+
+
+# =========================================================
+# PUBLISH TASKS
+# =========================================================
+
+from publisher.tasks.publish_tiktok import run as publish_tiktok
+from publisher.tasks.publish_youtube import run as publish_youtube
+from publisher.tasks.publish_instagram import run as publish_instagram
+
+
+# =========================================================
+# SYSTEM TASKS
+# =========================================================
+
+from publisher.tasks.batch_runner import run as batch_runner
+from publisher.tasks.autonomous_mode import run as autonomous_mode
+
+
+# =========================================================
+# TASK REGISTRY
+# =========================================================
+
+TASKS = {
+
+    # -----------------------------------------------------
+    # ANALYSIS
+    # -----------------------------------------------------
+    "analysis": [
+
+        {
+            "id": "transcribe",
+            "name": "Transcribe",
+            "description": "Generate transcript from video/audio",
+            "inputs": ["file", "url_input"],
+            "output": "json",
+            "handler": transcribe,
+        },
+
+        {
+            "id": "subtitles",
+            "name": "Subtitles",
+            "description": "Generate SRT subtitles",
+            "inputs": ["file", "url_input"],
+            "output": "file",
+            "handler": subtitles,
+        },
+
+        {
+            "id": "highlights",
+            "name": "Highlights",
+            "description": "Detect viral highlight segments",
+            "inputs": ["file"],
+            "output": "json",
+            "handler": highlights,
+        },
+
+        {
+            "id": "viral-score",
+            "name": "Viral Score",
+            "description": "AI virality prediction",
+            "inputs": ["file"],
+            "output": "json",
+            "handler": viral_score,
+        },
+
+        {
+            "id": "strategy",
+            "name": "Strategy",
+            "description": "Content strategy generation",
+            "inputs": ["file"],
+            "output": "json",
+            "handler": strategy,
+        },
+    ],
+
+    # -----------------------------------------------------
+    # RENDER
+    # -----------------------------------------------------
+    "render": [
+
+        {
+            "id": "render",
+            "name": "Render Video",
+            "description": "Render final short-form video",
+            "inputs": ["file", "url_input"],
+            "output": "video",
+            "video_output": True,
+            "handler": render,
+        },
+
+        {
+            "id": "generate-thumbnail",
+            "name": "Thumbnail",
+            "description": "Generate AI thumbnail",
+            "inputs": ["file"],
+            "output": "image",
+            "handler": generate_thumbnail,
+        },
+
+        {
+            "id": "generate-metadata",
+            "name": "Metadata",
+            "description": "Generate captions, hashtags, titles",
+            "inputs": ["file"],
+            "output": "json",
+            "handler": generate_metadata,
+        },
+    ],
+
+    # -----------------------------------------------------
+    # PUBLISH
+    # -----------------------------------------------------
+    "publish": [
+
+        {
+            "id": "publish-tiktok",
+            "name": "Publish TikTok",
+            "description": "Upload video to TikTok",
+            "inputs": ["file"],
+            "output": "json",
+            "handler": publish_tiktok,
+        },
+
+        {
+            "id": "publish-youtube",
+            "name": "Publish YouTube",
+            "description": "Upload YouTube Short",
+            "inputs": ["file"],
+            "output": "json",
+            "handler": publish_youtube,
+        },
+
+        {
+            "id": "publish-instagram",
+            "name": "Publish Instagram",
+            "description": "Upload Instagram Reel",
+            "inputs": ["file"],
+            "output": "json",
+            "handler": publish_instagram,
+        },
+    ],
+
+    # -----------------------------------------------------
+    # SYSTEM
+    # -----------------------------------------------------
+    "system": [
+
+        {
+            "id": "batch",
+            "name": "Batch Processor",
+            "description": "Execute batch pipeline",
+            "inputs": [],
+            "output": "json",
+            "handler": batch_runner,
+        },
+
+        {
+            "id": "autonomous",
+            "name": "Autonomous Mode",
+            "description": "Start autonomous AI publisher",
+            "inputs": [],
+            "output": "json",
+            "handler": autonomous_mode,
+        },
+    ],
+}

fonts/TikTok-Bold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e7b158d73db62c81c219602a5aef762aa0f40defa31d0e5dc72a2221b6d59fa
+size 131

ingestion/__init__.py

@@ -0,0 +1 @@
+# Initialize package

ingestion/base64_loader.py

@@ -0,0 +1,19 @@
+import base64
+import tempfile
+
+
+def decode_base64(data):
+
+    header, encoded = data.split(",", 1)
+
+    binary = base64.b64decode(encoded)
+
+    tmp = tempfile.NamedTemporaryFile(
+        delete=False,
+        suffix=".mp4"
+    )
+
+    tmp.write(binary)
+    tmp.close()
+
+    return tmp.name

ingestion/classifiers.py

@@ -0,0 +1,29 @@
+import os
+from urllib.parse import urlparse
+
+def classify_source(source: str):
+
+    if not source:
+        raise Exception("Empty source")
+
+    if os.path.exists(source):
+        return "local"
+
+    if source.endswith(".mp4"):
+        return "direct"
+
+    domain = urlparse(source).netloc.lower()
+
+    if "youtube" in domain or "youtu.be" in domain:
+        return "youtube"
+
+    if "tiktok" in domain:
+        return "tiktok"
+
+    if "instagram" in domain:
+        return "instagram"
+
+    if "facebook" in domain:
+        return "facebook"
+
+    return "unknown"

ingestion/cookies/youtube.txt

@@ -0,0 +1,210 @@
+[
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.949858,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "__Secure-3PSID",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "g.a0005ggHIKZHTs9zoAq0BBIjMwWabLARvs6GknU_-0exEvU5DGUwqAzR62E1h_wa5LLS12PspgACgYKAdASARYSFQHGX2MijjE-c2eX18fNOAWSCVLwmBoVAUF8yKq04Fen2HnSxnxT5K2Fpd4j0076"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1809905181.409847,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SIDCC",
+        "path": "/",
+        "sameSite": null,
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "AKEyXzUpR9UA-g9qoHyFYOWJ1CGoWZ5tgVDYm4bEHntfZ5iN6z6RVL8K33zjjp4slMle6hPdIw"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.948968,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SID",
+        "path": "/",
+        "sameSite": null,
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "g.a0005ggHIKZHTs9zoAq0BBIjMwWabLARvs6GknU_-0exEvU5DGUwA_FG-6Wg9ggcFsmCVhmjswACgYKAcMSARYSFQHGX2Mi4I_6gfKzdtxZN4ZX_kshjxoVAUF8yKqpv1_RfX_zFLUrl3TCcBZg0076"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1809905178.393538,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "__Secure-1PSIDTS",
+        "path": "/",
+        "sameSite": null,
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "sidts-CjUBhkeRd5PWbJP13KNRyvfxmZVpHrCLWiB90qS5dK1VtBZHEqYG_idUO7UYEmnajmrCqhVkWxAA"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.947697,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "SAPISID",
+        "path": "/",
+        "sameSite": null,
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "KqRpYGBu4XUSI9Dm/AZQgHuYmw_rieK8yf"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1809905181.410137,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "__Secure-1PSIDCC",
+        "path": "/",
+        "sameSite": null,
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "AKEyXzWZL0sioZ0UszpeTFyWSxRW5lbbqZGrHkU8PxHlV-jCSWbkudpG9_cQRuSIw4qB_qoxPw"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.947169,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "SSID",
+        "path": "/",
+        "sameSite": null,
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "A4IKjzFxcSCTwJsHj"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.948117,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "__Secure-1PAPISID",
+        "path": "/",
+        "sameSite": null,
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "KqRpYGBu4XUSI9Dm/AZQgHuYmw_rieK8yf"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.949424,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "__Secure-1PSID",
+        "path": "/",
+        "sameSite": null,
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "g.a0005ggHIKZHTs9zoAq0BBIjMwWabLARvs6GknU_-0exEvU5DGUwDX3_lEm4gf-uTFeESekcrQACgYKAd0SARYSFQHGX2MiwxRcpnYfY1bFNKTsueE3oxoVAUF8yKr-LKssrIr-F9tOdzCc1xo70076"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.948542,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "__Secure-3PAPISID",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "KqRpYGBu4XUSI9Dm/AZQgHuYmw_rieK8yf"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1809905181.410357,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "__Secure-3PSIDCC",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "AKEyXzWCPVCW7k3dwkKSsjV05nT9K7hC-wPUt49b_JuXW45TFu08ti7lfQsXqgfeDezseQCbZA"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1809905178.39415,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "__Secure-3PSIDTS",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "sidts-CjUBhkeRd5PWbJP13KNRyvfxmZVpHrCLWiB90qS5dK1VtBZHEqYG_idUO7UYEmnajmrCqhVkWxAA"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.947412,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "APISID",
+        "path": "/",
+        "sameSite": null,
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "36o598sqGfxJDffW/AyB1SJrxHZGXJ3xdj"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1802677401.946773,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "HSID",
+        "path": "/",
+        "sameSite": null,
+        "secure": false,
+        "session": false,
+        "storeId": null,
+        "value": "AhAjQv9yddkNo7Ro3"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1812929163.824495,
+        "hostOnly": false,
+        "httpOnly": true,
+        "name": "LOGIN_INFO",
+        "path": "/",
+        "sameSite": "no_restriction",
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "AFmmF2swRgIhAMcn3H8l0bXlZVgci9p5SvScepya1xAObUTRdJgGH5qqAiEAnQveY5dETRyStRQqDag0lUXHcTbRJkvDQ2Ge8GiDSBk:QUQ3MjNmd3IweGRfR3VIeVRCUGRiVHlkM1RxUXZjM1JnNUZCc0Nvd3lYV1l6UlpCdVVLdHR2cVgwU0UxUFloMkkwVlhXdWtMalQyMHZIVkc5eTFDU3dGSnQ1QWk5Z0N6XzZOTzVuRThBZHF3VkZsVlNpdmZ0TWExTk5jLUVxelhRQVF4M1p3RTRYSnU2dV9LQ0VoTllEcUNhZnBER3o2SW5R"
+    },
+    {
+        "domain": ".youtube.com",
+        "expirationDate": 1812929169.133873,
+        "hostOnly": false,
+        "httpOnly": false,
+        "name": "PREF",
+        "path": "/",
+        "sameSite": null,
+        "secure": true,
+        "session": false,
+        "storeId": null,
+        "value": "f6=40000000&tz=Africa.Lagos"
+    }
+]

ingestion/downloader.py

@@ -0,0 +1,18 @@
+import requests
+import tempfile
+
+
+def download_file(url):
+
+    r = requests.get(url, stream=True, timeout=120)
+
+    r.raise_for_status()
+
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
+
+    for chunk in r.iter_content(1024 * 1024):
+        tmp.write(chunk)
+
+    tmp.close()
+
+    return tmp.name

ingestion/normalizer.py

@@ -0,0 +1,24 @@
+import subprocess
+import uuid
+import os
+
+def normalize_video(path):
+
+    output = f"jobs/norm_{uuid.uuid4()}.mp4"
+
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i", path,
+        "-vf", "scale=1080:-2",
+        "-c:v", "libx264",
+        "-preset", "veryfast",
+        "-crf", "23",
+        "-c:a", "aac",
+        "-movflags", "+faststart",
+        output,
+    ]
+
+    subprocess.run(cmd, check=True)
+
+    return output

ingestion/resolver.py

@@ -0,0 +1,127 @@
+import os
+import uuid
+import requests
+from pathlib import Path
+from typing import Optional, Union
+from fastapi import UploadFile
+
+# ==============================
+# STORAGE CONFIG
+# ==============================
+
+BASE_DIR = Path(__file__).resolve().parents[1]
+UPLOAD_DIR = str(BASE_DIR / "jobs" / "uploads")
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+CHUNK_SIZE = 1024 * 1024  # 1MB streaming for large media
+
+
+# ==============================
+# CORE RESOLVER
+# ==============================
+
+def resolve_input(
+    source: Optional[str] = None,
+    upload: Optional[UploadFile] = None,
+    raw_bytes: Optional[bytes] = None
+) -> str:
+    """
+    Universal ingestion layer for all pipeline systems.
+
+    Supports:
+    - UploadFile (FastAPI / Gradio)
+    - URL download (http/https)
+    - Local filesystem path
+    - Raw bytes input (future automation nodes)
+    """
+
+    # ----------------------------------------
+    # CASE 1: UploadFile (Gradio / FastAPI)
+    # ----------------------------------------
+    if upload is not None:
+        filename = f"{uuid.uuid4()}_{upload.filename or 'upload.mp4'}"
+        path = os.path.join(UPLOAD_DIR, filename)
+
+        with open(path, "wb") as f:
+            while True:
+                chunk = upload.file.read(CHUNK_SIZE)
+                if not chunk:
+                    break
+                f.write(chunk)
+
+        return path
+
+    # ----------------------------------------
+    # CASE 2: Raw bytes (automation / webhook)
+    # ----------------------------------------
+    if raw_bytes is not None:
+        filename = f"{uuid.uuid4()}.mp4"
+        path = os.path.join(UPLOAD_DIR, filename)
+
+        with open(path, "wb") as f:
+            f.write(raw_bytes)
+
+        return path
+
+    # ----------------------------------------
+    # CASE 3: URL input (YouTube, TikTok, direct mp4)
+    # ----------------------------------------
+    if source and source.startswith(("http://", "https://")):
+
+        filename = f"{uuid.uuid4()}.mp4"
+        path = os.path.join(UPLOAD_DIR, filename)
+
+        headers = {
+            "User-Agent": "Mozilla/5.0 (compatible; BasyxBot/1.0)"
+        }
+
+        with requests.get(source, stream=True, headers=headers, timeout=60) as r:
+            r.raise_for_status()
+
+            with open(path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
+                    if chunk:
+                        f.write(chunk)
+
+        return path
+
+    # ----------------------------------------
+    # CASE 4: Local file path
+    # ----------------------------------------
+    if source and os.path.exists(source):
+        return source
+
+    # ----------------------------------------
+    # INVALID INPUT HANDLING
+    # ----------------------------------------
+    raise ValueError(
+        "resolve_input failed: no valid source, upload, or raw_bytes provided"
+    )
+
+
+# ==============================
+# OPTIONAL HELPERS (V11 READY)
+# ==============================
+
+def detect_input_type(source: str) -> str:
+    """
+    Lightweight classifier for routing decisions upstream.
+    """
+
+    if source.startswith(("http://", "https://")):
+        return "url"
+
+    if os.path.exists(source):
+        return "file"
+
+    return "unknown"
+
+
+def normalize_source(source: str) -> str:
+    """
+    Cleans input strings for downstream consistency.
+    """
+    if not source:
+        return source
+
+    return source.strip()

ingestion/social.py

@@ -0,0 +1,21 @@
+import tempfile
+import yt_dlp
+
+
+def download_social(url):
+
+    output = tempfile.NamedTemporaryFile(
+        delete=False,
+        suffix=".mp4"
+    ).name
+
+    ydl_opts = {
+        "outtmpl": output,
+        "format": "mp4",
+        "quiet": True
+    }
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([url])
+
+    return output

models/__init__.py

@@ -0,0 +1,2 @@
+from .kokoro import Kokoro
+from .tokenizer import Tokenizer

models/kokoro.py

@@ -0,0 +1,125 @@
+import torch
+import numpy as np
+import onnxruntime as ort
+
+TOKEN_LIMIT = 510
+SAMPLE_RATE = 24_000
+
+
+class Kokoro:
+    def __init__(self, model_path: str, style_vector_path: str, tokenizer, lang: str = 'en-us') -> None:
+        """
+        Initializes the ONNXInference class.
+
+        Args:
+            model_path (str): Path to the ONNX model file.
+            style_vector_path (str): Path to the style vector file.
+            lang (str): Language code for the tokenizer.
+        """
+        self.sess = ort.InferenceSession(model_path)
+        self.style_vector_path = style_vector_path
+        self.tokenizer = tokenizer
+        self.lang = lang
+
+    def preprocess(self, text):
+        """
+        Converts input text to tokenized numerical IDs and loads the style vector.
+
+        Args:
+            text (str): Input text to preprocess.
+
+        Returns:
+            tuple: Tokenized input and corresponding style vector.
+        """
+        # Convert text to phonemes and tokenize
+        phonemes = self.tokenizer.phonemize(text, lang=self.lang)
+        tokenized_phonemes = self.tokenizer.tokenize(phonemes)
+
+        if not tokenized_phonemes:
+            raise ValueError("No tokens found after tokenization")
+
+        style_vector = torch.load(self.style_vector_path, weights_only=True)
+
+        if len(tokenized_phonemes) > TOKEN_LIMIT:
+            token_chunks = self.split_into_chunks(tokenized_phonemes)
+
+            tokens_list = []
+            styles_list = []
+
+            for chunk in token_chunks:
+                token_chunk = [[0, *chunk, 0]]
+                style_chunk = style_vector[len(chunk)].numpy()
+
+                tokens_list.append(token_chunk)
+                styles_list.append(style_chunk)
+
+            return tokens_list, styles_list
+
+        style_vector = style_vector[len(tokenized_phonemes)].numpy()
+        tokenized_phonemes = [[0, *tokenized_phonemes, 0]]
+
+        return tokenized_phonemes, style_vector
+
+    @staticmethod
+    def split_into_chunks(tokens):
+        """
+        Splits a list of tokens into chunks of size TOKEN_LIMIT.
+
+        Args:
+            tokens (list): List of tokens to split.
+
+        Returns:
+            list: List of token chunks.
+        """
+        tokens_chunks = []
+        for i in range(0, len(tokens), TOKEN_LIMIT):
+            tokens_chunks.append(tokens[i:i+TOKEN_LIMIT])
+        return tokens_chunks
+
+    def infer(self, tokens, style_vector, speed=1.0):
+        """
+        Runs inference using the ONNX model.
+
+        Args:
+            tokens (list): Tokenized input for the model.
+            style_vector (numpy.ndarray): Style vector for the model.
+            speed (float): Speed parameter for inference.
+
+        Returns:
+            numpy.ndarray: Generated audio data.
+        """
+        # Perform inference
+        audio = self.sess.run(
+            None,
+            {
+                'tokens': tokens,
+                'style': style_vector,
+                'speed': np.array([speed], dtype=np.float32),
+            }
+        )[0]
+        return audio
+
+    def generate_audio(self, text,  speed=1.0):
+        """
+        Full pipeline: preprocess, infer, and save the generated audio.
+
+        Args:
+            text (str): Input text to generate audio from.
+            speed (float): Speed parameter for inference.
+        """
+        # Preprocess text
+        tokenized_data, styles_data = self.preprocess(text)
+
+        audio_segments = []
+        if len(tokenized_data) > 1:  # list of token chunks
+            for token_chunk, style_chunk in zip(tokenized_data, styles_data):
+                audio = self.infer(token_chunk, style_chunk, speed=speed)
+                audio_segments.append(audio)
+        else:  # single token less than input limit
+            # Run inference
+            audio = self.infer(tokenized_data, styles_data, speed=speed)
+            audio_segments.append(audio)
+
+        full_audio = np.concatenate(audio_segments)
+
+        return full_audio, SAMPLE_RATE

models/tokenizer.py

@@ -0,0 +1,238 @@
+import re
+from phonemizer import backend
+from typing import List
+
+
+class Tokenizer:
+    def __init__(self):
+        self.VOCAB = self._get_vocab()
+        self.phonemizers = {
+            'en-us': backend.EspeakBackend(language='en-us', preserve_punctuation=True, with_stress=True),
+            'en-gb': backend.EspeakBackend(language='en-gb', preserve_punctuation=True, with_stress=True),
+        }
+
+    @staticmethod
+    def _get_vocab():
+        """
+        Generates a mapping of symbols to integer indices for tokenization.
+
+        Returns:
+            dict: A dictionary where keys are symbols and values are unique integer indices.
+        """
+        # Define the symbols
+        _pad = "$"
+        _punctuation = ';:,.!?¡¿—…"«»“” '
+        _letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+        _letters_ipa = (
+            "ɑɐɒæɓʙβɔɕçɗɖðʤəɘɚɛɜɝɞɟʄɡɠɢʛɦɧħɥʜɨɪʝɭɬɫɮʟɱɯɰŋɳɲɴøɵɸθœɶʘɹɺɾɻʀʁɽʂʃʈʧʉʊʋⱱʌɣɤʍχʎʏʑʐʒʔʡʕʢǀǁǂǃˈˌːˑʼʴʰʱʲʷˠˤ˞↓↑→↗↘'̩'ᵻ"
+        )
+        symbols = [_pad] + list(_punctuation) + list(_letters) + list(_letters_ipa)
+
+        # Create a dictionary mapping each symbol to its index
+        return {symbol: index for index, symbol in enumerate(symbols)}
+
+    @staticmethod
+    def split_num(num: re.Match) -> str:
+        """
+        Processes numeric strings, formatting them as time, years, or other representations.
+
+        Args:
+            num (re.Match): A regex match object representing the numeric string.
+
+        Returns:
+            str: A formatted string based on the numeric input.
+        """
+        num = num.group()
+
+        # Handle time (e.g., "12:30")
+        if ':' in num:
+            hours, minutes = map(int, num.split(':'))
+            if minutes == 0:
+                return f"{hours} o'clock"
+            elif minutes < 10:
+                return f'{hours} oh {minutes}'
+            return f'{hours} {minutes}'
+
+        # Handle years or general numeric cases
+        year = int(num[:4])
+        if year < 1100 or year % 1000 < 10:
+            return num
+
+        left, right = num[:2], int(num[2:4])
+        suffix = 's' if num.endswith('s') else ''
+
+        # Format years
+        if 100 <= year % 1000 <= 999:
+            if right == 0:
+                return f'{left} hundred{suffix}'
+            elif right < 10:
+                return f'{left} oh {right}{suffix}'
+        return f'{left} {right}{suffix}'
+
+    @staticmethod
+    def flip_money(match: re.Match) -> str:
+        """
+        Converts monetary values to a textual representation.
+
+        Args:
+            m (re.Match): A regex match object representing the monetary value.
+
+        Returns:
+            str: A formatted string describing the monetary value.
+        """
+        m = m.group()
+        currency = 'dollar' if m[0] == '$' else 'pound'
+
+        # Handle whole amounts (e.g., "$10", "£20")
+        if '.' not in m:
+            singular = '' if m[1:] == '1' else 's'
+            return f'{m[1:]} {currency}{singular}'
+
+        # Handle amounts with decimals (e.g., "$10.50", "£5.25")
+        whole, cents = m[1:].split('.')
+        singular = '' if whole == '1' else 's'
+        cents = int(cents.ljust(2, '0'))  # Ensure 2 decimal places
+        coins = f"cent{'' if cents == 1 else 's'}" if m[0] == '$' else ('penny' if cents == 1 else 'pence')
+        return f'{whole} {currency}{singular} and {cents} {coins}'
+
+    @staticmethod
+    def point_num(match):
+        whole, fractional = match.group().split('.')
+        return ' point '.join([whole, ' '.join(fractional)])
+
+    def normalize_text(self, text: str) -> str:
+        """
+        Normalizes input text by replacing special characters, punctuation, and applying custom transformations.
+
+        Args:
+            text (str): Input text to normalize.
+
+        Returns:
+            str: Normalized text.
+        """
+        # Replace specific characters with standardized versions
+        replacements = {
+            chr(8216): "'",  # Left single quotation mark
+            chr(8217): "'",  # Right single quotation mark
+            '«': chr(8220),  # Left double angle quotation mark to left double quotation mark
+            '»': chr(8221),  # Right double angle quotation mark to right double quotation mark
+            chr(8220): '"',  # Left double quotation mark
+            chr(8221): '"',  # Right double quotation mark
+            '(': '«',        # Replace parentheses with angle quotation marks
+            ')': '»'
+        }
+        for old, new in replacements.items():
+            text = text.replace(old, new)
+
+        # Replace punctuation and add spaces
+        punctuation_replacements = {
+            '、': ',',
+            '。': '.',
+            '！': '!',
+            '，': ',',
+            '：': ':',
+            '；': ';',
+            '？': '?',
+        }
+        for old, new in punctuation_replacements.items():
+            text = text.replace(old, new + ' ')
+
+        # Apply regex-based replacements
+        text = re.sub(r'[^\S\n]', ' ', text)
+        text = re.sub(r'  +', ' ', text)
+        text = re.sub(r'(?<=\n) +(?=\n)', '', text)
+
+        # Expand abbreviations and handle special cases
+        abbreviation_patterns = [
+            (r'\bD[Rr]\.(?= [A-Z])', 'Doctor'),
+            (r'\b(?:Mr\.|MR\.(?= [A-Z]))', 'Mister'),
+            (r'\b(?:Ms\.|MS\.(?= [A-Z]))', 'Miss'),
+            (r'\b(?:Mrs\.|MRS\.(?= [A-Z]))', 'Mrs'),
+            (r'\betc\.(?! [A-Z])', 'etc'),
+            (r'(?i)\b(y)eah?\b', r"\1e'a"),
+        ]
+        for pattern, replacement in abbreviation_patterns:
+            text = re.sub(pattern, replacement, text)
+
+        # Handle numbers and monetary values
+        text = re.sub(r'\d*\.\d+|\b\d{4}s?\b|(?<!:)\b(?:[1-9]|1[0-2]):[0-5]\d\b(?!:)', self.split_num, text)
+        text = re.sub(r'(?<=\d),(?=\d)', '', text)  # Remove commas from numbers
+        text = re.sub(
+            r'(?i)[$£]\d+(?:\.\d+)?(?: hundred| thousand| (?:[bm]|tr)illion)*\b|[$£]\d+\.\d\d?\b',
+            self.flip_money,
+            text
+        )
+        text = re.sub(r'\d*\.\d+', self.point_num, text)
+        text = re.sub(r'(?<=\d)-(?=\d)', ' to ', text)
+
+        # Handle possessives and specific letter cases
+        text = re.sub(r'(?<=\d)S', ' S', text)
+        text = re.sub(r"(?<=[BCDFGHJ-NP-TV-Z])'?s\b", "'S", text)
+        text = re.sub(r"(?<=X')S\b", 's', text)
+
+        # Handle abbreviations with dots
+        text = re.sub(r'(?:[A-Za-z]\.){2,} [a-z]', lambda m: m.group().replace('.', '-'), text)
+        text = re.sub(r'(?i)(?<=[A-Z])\.(?=[A-Z])', '-', text)
+
+        return text.strip()
+
+    def tokenize(self, phonemes: str) -> List[int]:
+        """
+        Tokenizes a given string into a list of indices based on VOCAB.
+
+        Args:
+            text (str): Input string to tokenize.
+
+        Returns:
+            list: A list of integer indices corresponding to the characters in the input string.
+        """
+        return [self.VOCAB[x] for x in phonemes if x in self.VOCAB]
+
+    def phonemize(self, text: str, lang: str = 'en-us', normalize: bool = True) -> str:
+        """
+        Converts text to phonemes using the specified language phonemizer and applies normalization.
+
+        Args:
+            text (str): Input text to be phonemized.
+            lang (str): Language identifier ('en-us' or 'en-gb') for selecting the phonemizer.
+            normalize (bool): Whether to normalize the text before phonemization.
+
+        Returns:
+            str: A processed string of phonemes.
+        """
+        # Normalize text if required
+        if normalize:
+            text = self.normalize_text(text)
+
+        # Generate phonemes using the specified phonemizer
+        if lang not in self.phonemizers:
+            print(f"Language '{lang}' not supported. Defaulting to 'en-us'.")
+            lang = 'en-us'
+
+        phonemes = self.phonemizers[lang].phonemize([text])
+        phonemes = phonemes[0] if phonemes else ''
+
+        # Apply custom phoneme replacements
+        replacements = {
+            'kəkˈoːɹoʊ': 'kˈoʊkəɹoʊ',
+            'kəkˈɔːɹəʊ': 'kˈəʊkəɹəʊ',
+            'ʲ': 'j',
+            'r': 'ɹ',
+            'x': 'k',
+            'ɬ': 'l',
+        }
+        for old, new in replacements.items():
+            phonemes = phonemes.replace(old, new)
+
+        # Apply regex-based replacements
+        phonemes = re.sub(r'(?<=[a-zɹː])(?=hˈʌndɹɪd)', ' ', phonemes)
+        phonemes = re.sub(r' z(?=[;:,.!?¡¿—…"«»“” ]|$)', 'z', phonemes)
+
+        # Additional language-specific rules
+        if lang == 'a':
+            phonemes = re.sub(r'(?<=nˈaɪn)ti(?!ː)', 'di', phonemes)
+
+        # Filter out characters not in VOCAB
+        phonemes = ''.join(filter(lambda p: p in self.VOCAB, phonemes))
+
+        return phonemes.strip()

publisher/__init__.py

@@ -0,0 +1 @@
+# Publisher package

publisher/account_manager.py

@@ -0,0 +1,38 @@
+# publisher/account_manager.py
+
+from publisher.oauth.storage import load_tokens
+
+SUPPORTED = [
+    "youtube",
+    "tiktok",
+    "meta"
+]
+
+
+def connected_accounts(user_id):
+
+    accounts = []
+
+    for p in SUPPORTED:
+        token = load_tokens(user_id, p)
+        if token:
+            accounts.append({
+                "platform": p,
+                "token": token
+            })
+
+    return accounts
+
+
+def choose_platforms(strategy, accounts):
+
+    if strategy == "all":
+        return accounts
+
+    if strategy == "short_video":
+        return [
+            a for a in accounts
+            if a["platform"] in ["youtube", "tiktok", "meta"]
+        ]
+
+    return accounts[:1]

publisher/ai/gemini_client.py

@@ -0,0 +1,83 @@
+import os
+import time
+import random
+import logging
+
+logger = logging.getLogger("gemini-client")
+
+# =========================
+# MODEL POOL (Gemini 3 Era)
+# =========================
+
+PRIMARY_MODELS = [
+    "gemini-3.1-pro",
+    "gemini-3.1-flash",
+]
+
+FALLBACK_MODELS = [
+    "gemini-2.5-flash",
+    "gemini-3.1-flash-lite",
+]
+
+# =========================
+# SIMPLE QUOTA TRACKER
+# =========================
+_model_fail_count = {
+    "gemini-3.1-pro": 0,
+    "gemini-3.1-flash": 0,
+}
+
+
+MAX_FAILS = 3
+
+
+# =========================
+# CORE MODEL RESOLVER
+# =========================
+
+def _pick_model():
+    """
+    Select best available model with fallback logic.
+    """
+    for m in PRIMARY_MODELS:
+        if _model_fail_count.get(m, 0) < MAX_FAILS:
+            return m
+
+    return random.choice(FALLBACK_MODELS)
+
+
+# =========================
+# MAIN CLIENT INTERFACE
+# =========================
+
+def get_model():
+    """
+    Public entrypoint used by publisher_ai.
+    Returns active Gemini model name.
+    """
+    model = _pick_model()
+    logger.info(f"[Gemini] Selected model: {model}")
+    return model
+
+
+def safe_generate(prompt: str, client_callable):
+    """
+    Wrapper for Gemini calls with automatic fallback.
+    """
+
+    last_error = None
+
+    for _ in range(3):
+        model = _pick_model()
+
+        try:
+            result = client_callable(model, prompt)
+            return result
+
+        except Exception as e:
+            last_error = e
+            _model_fail_count[model] = _model_fail_count.get(model, 0) + 1
+            logger.warning(f"[Gemini FAIL] {model}: {str(e)}")
+            time.sleep(0.5)
+
+    raise RuntimeError(f"All Gemini models failed: {last_error}")

publisher/bulk.py

@@ -0,0 +1,187 @@
+"""
+bulk.py
+V9 Autonomous Publisher Engine
+
+Purpose:
+--------
+Handles BULK publishing across multiple platforms.
+
+Supports:
+- TikTok
+- Reels (Instagram)
+- YouTube Shorts
+- Facebook
+- Any future platform adapter
+
+Design:
+-------
+Input -> Normalize -> Dispatch -> Execute -> Collect Results
+
+Production Features:
+--------------------
+✔ async concurrency
+✔ retry system
+✔ per-platform isolation
+✔ failure tolerance
+✔ structured logging
+✔ scheduler-compatible
+✔ autonomous engine ready
+"""
+
+import asyncio
+import traceback
+from typing import Dict, List, Any
+
+# Platform adapters
+from publisher.platforms.tiktok import publish_tiktok
+from publisher.platforms.reels import publish_reels
+from publisher.platforms.shorts import publish_shorts
+from publisher.platforms.facebook import publish_facebook
+
+
+# =====================================================
+# PLATFORM REGISTRY
+# =====================================================
+
+PLATFORM_MAP = {
+    "tiktok": publish_tiktok,
+    "reels": publish_reels,
+    "shorts": publish_shorts,
+    "facebook": publish_facebook,
+}
+
+
+# =====================================================
+# CONFIG
+# =====================================================
+
+MAX_CONCURRENT_POSTS = 5
+MAX_RETRIES = 2
+
+
+# =====================================================
+# HELPERS
+# =====================================================
+
+async def execute_with_retry(func, payload: Dict, retries=MAX_RETRIES):
+    """
+    Safe execution wrapper with retries.
+    """
+
+    attempt = 0
+
+    while attempt <= retries:
+        try:
+            result = await func(payload)
+            return {
+                "status": "success",
+                "result": result,
+            }
+
+        except Exception as e:
+            attempt += 1
+
+            if attempt > retries:
+                return {
+                    "status": "failed",
+                    "error": str(e),
+                    "trace": traceback.format_exc(),
+                }
+
+            await asyncio.sleep(2)
+
+
+# =====================================================
+# SINGLE JOB EXECUTOR
+# =====================================================
+
+async def process_job(job: Dict[str, Any]):
+    """
+    Expected job format:
+
+    {
+        "platform": "tiktok",
+        "video_url": "...",
+        "caption": "...",
+        "hashtags": [],
+        "thumbnail": "...",
+        "schedule_time": optional
+    }
+    """
+
+    platform = job.get("platform")
+
+    if platform not in PLATFORM_MAP:
+        return {
+            "status": "failed",
+            "error": f"Unsupported platform: {platform}",
+        }
+
+    publisher = PLATFORM_MAP[platform]
+
+    return await execute_with_retry(publisher, job)
+
+
+# =====================================================
+# BULK ENGINE
+# =====================================================
+
+async def bulk_publish(jobs: List[Dict[str, Any]]):
+    """
+    Main bulk execution engine.
+    """
+
+    semaphore = asyncio.Semaphore(MAX_CONCURRENT_POSTS)
+
+    results = []
+
+    async def limited_job(job):
+        async with semaphore:
+            return await process_job(job)
+
+    tasks = [limited_job(job) for job in jobs]
+
+    completed = await asyncio.gather(*tasks, return_exceptions=False)
+
+    results.extend(completed)
+
+    return summarize_results(results)
+
+
+# =====================================================
+# SUMMARY
+# =====================================================
+
+def summarize_results(results: List[Dict]):
+    success = sum(1 for r in results if r["status"] == "success")
+    failed = len(results) - success
+
+    return {
+        "status": "completed",
+        "total_jobs": len(results),
+        "successful": success,
+        "failed": failed,
+        "results": results,
+    }
+
+
+# =====================================================
+# FASTAPI ENTRYPOINT
+# =====================================================
+
+async def execute(payload: Dict):
+    """
+    Universal endpoint handler
+
+    POST /execute/bulk_publish
+    """
+
+    jobs = payload.get("jobs")
+
+    if not jobs:
+        return {
+            "status": "error",
+            "message": "No jobs provided",
+        }
+
+    return await bulk_publish(jobs)

publisher/hashtags.py

@@ -0,0 +1,19 @@
+from publisher.ai.gemini_client import get_model
+
+
+def generate_hashtags(video_path: str):
+
+    model = get_model()
+
+    prompt = """
+    Generate 20 viral hashtags for short-form content.
+    Return comma-separated only.
+    """
+
+    res = model.generate_content(prompt)
+
+    tags = res.text.replace("\n", "").strip()
+
+    return {
+        "hashtags": tags
+    }

publisher/metadata_engine.py

@@ -0,0 +1,24 @@
+from publisher.ai.gemini_client import get_model
+
+
+def generate_metadata(video_path: str):
+
+    model = get_model()
+
+    prompt = f"""
+    Generate viral short-form video metadata.
+
+    Return JSON:
+    title
+    description
+    hook
+    audience
+    """
+
+    response = model.generate_content(prompt)
+
+    text = response.text.strip()
+
+    return {
+        "metadata": text
+    }

publisher/models.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+
+class PublishPayload(BaseModel):
+
+    video_path: str
+
+    title: str
+    description: str
+
+    hashtags: List[str]
+
+    thumbnail: Optional[str] = None
+    schedule_time: Optional[int] = None
+
+    platforms: List[str]

publisher/oauth/providers/google.py

@@ -0,0 +1,52 @@
+# publisher/oauth/providers/google.py
+
+import httpx
+import os
+from ..storage import save_tokens
+
+CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID")
+CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET")
+
+REDIRECT_URI = "https://your-domain.com/oauth/callback/google"
+
+AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth"
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+
+
+def authorization_url(state):
+
+    scope = (
+        "https://www.googleapis.com/auth/youtube.upload "
+        "https://www.googleapis.com/auth/userinfo.profile"
+    )
+
+    return (
+        f"{AUTH_URL}"
+        f"?client_id={CLIENT_ID}"
+        f"&redirect_uri={REDIRECT_URI}"
+        f"&response_type=code"
+        f"&scope={scope}"
+        f"&access_type=offline"
+        f"&state={state}"
+    )
+
+
+async def exchange_code(code):
+
+    async with httpx.AsyncClient() as client:
+        r = await client.post(
+            TOKEN_URL,
+            data={
+                "code": code,
+                "client_id": CLIENT_ID,
+                "client_secret": CLIENT_SECRET,
+                "redirect_uri": REDIRECT_URI,
+                "grant_type": "authorization_code",
+            },
+        )
+
+    return r.json()
+
+
+def store(user_id, tokens):
+    save_tokens(user_id, "google", tokens)

publisher/oauth/providers/meta.py

@@ -0,0 +1,42 @@
+# publisher/oauth/providers/meta.py
+
+import httpx
+import os
+from ..storage import save_tokens
+
+APP_ID = os.getenv("META_APP_ID")
+APP_SECRET = os.getenv("META_APP_SECRET")
+
+REDIRECT_URI = "https://your-domain.com/oauth/callback/meta"
+
+
+def authorization_url(state):
+
+    return (
+        "https://www.facebook.com/v19.0/dialog/oauth"
+        f"?client_id={APP_ID}"
+        f"&redirect_uri={REDIRECT_URI}"
+        "&scope=pages_manage_posts,pages_read_engagement,"
+        "instagram_content_publish"
+        f"&state={state}"
+    )
+
+
+async def exchange_code(code):
+
+    async with httpx.AsyncClient() as client:
+        r = await client.get(
+            "https://graph.facebook.com/v19.0/oauth/access_token",
+            params={
+                "client_id": APP_ID,
+                "redirect_uri": REDIRECT_URI,
+                "client_secret": APP_SECRET,
+                "code": code,
+            },
+        )
+
+    return r.json()
+
+
+def store(user_id, tokens):
+    save_tokens(user_id, "meta", tokens)

publisher/oauth/providers/tiktok.py

@@ -0,0 +1,45 @@
+# publisher/oauth/providers/tiktok.py
+
+import httpx
+import os
+from ..storage import save_tokens
+
+CLIENT_KEY = os.getenv("TIKTOK_CLIENT_KEY")
+CLIENT_SECRET = os.getenv("TIKTOK_CLIENT_SECRET")
+
+REDIRECT_URI = "https://your-domain.com/oauth/callback/tiktok"
+
+
+def authorization_url(state):
+
+    scope = "user.info.basic,video.upload"
+
+    return (
+        "https://www.tiktok.com/v2/auth/authorize/"
+        f"?client_key={CLIENT_KEY}"
+        f"&response_type=code"
+        f"&scope={scope}"
+        f"&redirect_uri={REDIRECT_URI}"
+        f"&state={state}"
+    )
+
+
+async def exchange_code(code):
+
+    async with httpx.AsyncClient() as client:
+        r = await client.post(
+            "https://open.tiktokapis.com/v2/oauth/token/",
+            data={
+                "client_key": CLIENT_KEY,
+                "client_secret": CLIENT_SECRET,
+                "code": code,
+                "grant_type": "authorization_code",
+                "redirect_uri": REDIRECT_URI,
+            },
+        )
+
+    return r.json()
+
+
+def store(user_id, tokens):
+    save_tokens(user_id, "tiktok", tokens)

publisher/oauth/providers/youtube.py

@@ -0,0 +1,8 @@
+# publisher/oauth/providers/youtube.py
+
+from .google import authorization_url, exchange_code
+from ..storage import save_tokens
+
+
+def store(user_id, tokens):
+    save_tokens(user_id, "youtube", tokens)

publisher/oauth/router.py

@@ -0,0 +1,47 @@
+# publisher/oauth/router.py
+
+from fastapi import APIRouter, Request
+from fastapi.responses import RedirectResponse
+
+from .sessions import create_session, get_user
+from .providers import google, meta, tiktok, youtube
+
+router = APIRouter()
+
+PROVIDERS = {
+    "google": google,
+    "meta": meta,
+    "tiktok": tiktok,
+    "youtube": youtube
+}
+
+
+@router.get("/connect/{provider}")
+async def connect(provider: str, user_id: str):
+
+    if provider not in PROVIDERS:
+        return {"error": "provider not supported"}
+
+    state = create_session(user_id)
+
+    url = PROVIDERS[provider].authorization_url(state)
+
+    return RedirectResponse(url)
+
+
+@router.get("/callback/{provider}")
+async def callback(provider: str, request: Request):
+
+    if provider not in PROVIDERS:
+        return {"error": "provider not supported"}
+
+    state = request.query_params.get("state")
+    code = request.query_params.get("code")
+
+    user_id = get_user(state)
+
+    tokens = await PROVIDERS[provider].exchange_code(code)
+
+    PROVIDERS[provider].store(user_id, tokens)
+
+    return {"status": f"{provider} connected"}

publisher/oauth/sessions.py

@@ -0,0 +1,29 @@
+# publisher/oauth/sessions.py
+
+import secrets
+import time
+
+_sessions = {}
+
+
+def create_session(user_id):
+    state = secrets.token_urlsafe(32)
+    _sessions[state] = {
+        "user_id": user_id,
+        "created": time.time()
+    }
+    return state
+
+
+def get_user(state):
+    session = _sessions.get(state)
+    if not session:
+        return None
+    return session["user_id"]
+
+
+def cleanup(expiry=600):
+    now = time.time()
+    for k in list(_sessions.keys()):
+        if now - _sessions[k]["created"] > expiry:
+            del _sessions[k]

publisher/oauth/storage.py

@@ -0,0 +1,44 @@
+# publisher/oauth/storage.py
+
+import os
+import json
+from pathlib import Path
+from cryptography.fernet import Fernet
+
+STORAGE_DIR = Path("oauth_tokens")
+STORAGE_DIR.mkdir(exist_ok=True)
+
+KEY_PATH = STORAGE_DIR / "secret.key"
+
+
+def load_key():
+    if not KEY_PATH.exists():
+        key = Fernet.generate_key()
+        KEY_PATH.write_bytes(key)
+    return KEY_PATH.read_bytes()
+
+
+fernet = Fernet(load_key())
+
+
+def _file(user_id, provider):
+    return STORAGE_DIR / f"{user_id}_{provider}.json"
+
+
+def save_tokens(user_id: str, provider: str, data: dict):
+    encrypted = fernet.encrypt(json.dumps(data).encode())
+    _file(user_id, provider).write_bytes(encrypted)
+
+
+def load_tokens(user_id: str, provider: str):
+    f = _file(user_id, provider)
+    if not f.exists():
+        return None
+    decrypted = fernet.decrypt(f.read_bytes())
+    return json.loads(decrypted.decode())
+
+
+def delete_tokens(user_id: str, provider: str):
+    f = _file(user_id, provider)
+    if f.exists():
+        f.unlink()

publisher/platform_dispatcher.py

@@ -0,0 +1,48 @@
+from importlib import import_module
+import logging
+
+logger = logging.getLogger("platform-dispatcher")
+
+
+def _safe_import(module_path, fn_name):
+    try:
+        module = import_module(module_path)
+        return getattr(module, fn_name)
+    except Exception as e:
+        logger.warning(f"[Dispatcher] Missing {module_path}: {str(e)}")
+        return None
+
+
+# lazy-loaded publishers (prevents boot crash)
+
+def dispatch_publish(video_path=None, payload=None, variants=None):
+
+    payload = payload or {}
+    results = {}
+
+    youtube = _safe_import("publisher.platforms.youtube", "publish_youtube")
+    tiktok = _safe_import("publisher.platforms.tiktok", "publish_tiktok")
+    reels = _safe_import("publisher.platforms.reels", "publish_reels")
+    shorts = _safe_import("publisher.platforms.shorts", "publish_shorts")
+    facebook = _safe_import("publisher.platforms.facebook", "publish_facebook")
+
+    async def run():
+
+        if youtube:
+            results["youtube"] = await youtube({"video_path": video_path, **payload})
+
+        if tiktok:
+            results["tiktok"] = await tiktok({"video_path": video_path, **payload})
+
+        if reels:
+            results["reels"] = await reels({"video_path": video_path, **payload})
+
+        if shorts:
+            results["shorts"] = await shorts({"video_path": video_path, **payload})
+
+        if facebook:
+            results["facebook"] = await facebook({"video_path": video_path, **payload})
+
+        return results
+
+    return run()

publisher/platforms/__init__.py

@@ -0,0 +1 @@
+# Platforms package

publisher/platforms/auth.py

@@ -0,0 +1,38 @@
+import os
+
+# =========================
+# SIMPLE ENV AUTH LOADER
+# =========================
+
+def load_env_var(key: str, default=None):
+    """
+    Safe environment variable loader.
+    Works without python-dotenv dependency.
+    """
+    return os.environ.get(key, default)
+
+
+def get_token(platform: str):
+    """
+    Returns stored token for platform.
+    No external dependency version.
+    """
+
+    key_map = {
+        "tiktok": "TIKTOK_TOKEN",
+        "youtube": "YOUTUBE_TOKEN",
+        "facebook": "FACEBOOK_TOKEN",
+        "reels": "META_TOKEN",
+    }
+
+    env_key = key_map.get(platform)
+
+    if not env_key:
+        raise ValueError(f"Unsupported platform: {platform}")
+
+    token = load_env_var(env_key)
+
+    if not token:
+        raise ValueError(f"Missing token for {platform} ({env_key})")
+
+    return token

publisher/platforms/base.py

@@ -0,0 +1,15 @@
+import os
+
+def validate_payload(payload):
+
+    if "video_path" not in payload:
+        raise Exception("video_path required")
+
+    if not os.path.exists(payload["video_path"]):
+        raise Exception("Video missing")
+
+    payload.setdefault("caption", "")
+    payload.setdefault("hashtags", [])
+    payload.setdefault("thumbnail", None)
+
+    return payload

publisher/platforms/errors.py

@@ -0,0 +1,14 @@
+class PublisherError(Exception):
+    pass
+
+
+class PlatformAuthError(PublisherError):
+    pass
+
+
+class PlatformUploadError(PublisherError):
+    pass
+
+
+class PlatformRateLimit(PublisherError):
+    pass

publisher/platforms/facebook.py

@@ -0,0 +1,28 @@
+# publisher/platforms/facebook.py
+
+import httpx
+from .auth import get_token
+from .base import validate_payload
+
+
+async def publish_facebook(payload):
+
+    payload = validate_payload(payload)
+
+    page_id = get_token("FACEBOOK_PAGE_ID")
+    token = get_token("META_ACCESS_TOKEN")
+
+    async with httpx.AsyncClient(timeout=600) as client:
+
+        with open(payload["video_path"], "rb") as f:
+
+            res = await client.post(
+                f"https://graph-video.facebook.com/{page_id}/videos",
+                data={
+                    "description": payload["caption"],
+                    "access_token": token,
+                },
+                files={"source": f},
+            )
+
+    return {"platform": "facebook", "status": "published"}

publisher/platforms/http.py

@@ -0,0 +1,38 @@
+import httpx
+import asyncio
+
+
+async def request(
+    method,
+    url,
+    headers=None,
+    data=None,
+    json=None,
+    files=None,
+    retries=3,
+):
+
+    for attempt in range(retries):
+
+        try:
+            async with httpx.AsyncClient(timeout=120) as client:
+
+                r = await client.request(
+                    method,
+                    url,
+                    headers=headers,
+                    data=data,
+                    json=json,
+                    files=files,
+                )
+
+                r.raise_for_status()
+
+                return r.json()
+
+        except Exception as e:
+
+            if attempt == retries - 1:
+                raise
+
+            await asyncio.sleep(2 ** attempt)