Upload 6 files

api.py

@@ -3,10 +3,11 @@
 import json
 import shutil
 import uuid
+import zipfile
 from pathlib import Path
 from typing import Any
 
-from fastapi import FastAPI, File, Form, HTTPException, Query, UploadFile
+from fastapi import Depends, FastAPI, File, Form, Header, HTTPException, Query, UploadFile
 from fastapi.responses import FileResponse
 from pydantic import BaseModel, Field
 
@@ -16,16 +17,38 @@ from renderer.core.models import AIReelsRequest, RenderRequest, Scene
 from renderer.core.security import verify_download_token
 from renderer.core.utils import safe_filename
 from renderer.jobs import JobManager
+from renderer.platform import PlatformProcessor, supported_toolkit_tasks
 from renderer.scenes import Timeline
 from renderer import RenderEngine
 from renderer.subtitles import SubtitleEvent, SubtitleGenerator
-from renderer.templates import apply_preset, list_platform_profiles, list_presets, list_templates, platform_profile_metadata
+from renderer.templates import (
+    apply_creative_style,
+    apply_preset,
+    creative_style_metadata,
+    get_creative_style,
+    list_creative_styles,
+    list_platform_profiles,
+    list_presets,
+    list_scene_effects,
+    list_templates,
+    platform_profile_metadata,
+    scene_effect_metadata,
+)
+from renderer.transitions import TransitionBuilder
 
 settings = Settings()
 settings.ensure_dirs()
 job_manager = JobManager(settings)
 api = FastAPI(title="Basyx FFmpeg Rendering Engine", version="1.0.0")
 
+API_KEY_HEADER = "X-API-Key"
+
+
+def _verify_api_key(api_key: str | None = Header(default=None, alias=API_KEY_HEADER)) -> None:
+    configured = getattr(settings, "api_key", "")
+    if configured and api_key != configured:
+        raise HTTPException(status_code=401, detail="Invalid or missing API key")
+
 def _submission_response(job_id: str) -> dict[str, str]:
     download_url = f"/download/{job_id}"
     try:
@@ -54,6 +77,7 @@ class RenderPayload(BaseModel):
     scenes: list[ScenePayload]
     template: str = "tiktok_classic"
     preset: str | None = None
+    creative_style: str | None = None
     platform: str | None = None
     output_name: str = "render.mp4"
     voiceover: str | None = None
@@ -88,6 +112,7 @@ class AIReelsPayload(BaseModel):
     voiceover: str
     assets: list[str]
     template: str = "tiktok_classic"
+    creative_style: str | None = None
     platform: str | None = None
     output_name: str = "ai_reel.mp4"
     background_music: str | None = None
@@ -108,6 +133,8 @@ class UploadedAsset(BaseModel):
     filename: str
     path: str
     reference: str
+    kind: str = "other"
+    metadata: dict[str, Any] | None = None
 
 
 class TranscribePayload(BaseModel):
@@ -131,6 +158,74 @@ class SceneBuildPayload(BaseModel):
     assets: list[str]
     duration: float | None = None
     transition: str = "fade"
+    creative_style: str | None = None
+
+
+class IngestSourcePayload(BaseModel):
+    url: str
+    type: str | None = None
+    name: str | None = None
+
+
+class IngestPayload(BaseModel):
+    sources: list[IngestSourcePayload]
+    callback_url: str | None = None
+
+
+class AnalyzePayload(BaseModel):
+    media: str
+    transcript: str = ""
+    platform: str | None = None
+    callback_url: str | None = None
+
+
+class ClipsPayload(BaseModel):
+    media: str
+    clips: list[dict[str, Any]] | None = None
+    callback_url: str | None = None
+
+
+class ToolkitPayload(BaseModel):
+    task: str
+    input: str | None = None
+    media: str | None = None
+    output_name: str | None = None
+    params: dict[str, Any] = Field(default_factory=dict)
+    callback_url: str | None = None
+    export_target: str | None = None
+    model_config = {"extra": "allow"}
+
+
+class ThumbnailPayload(BaseModel):
+    media: str
+    text: str = ""
+    timestamp: float | None = None
+    template: str = "bold"
+    callback_url: str | None = None
+
+
+class MetadataPayload(BaseModel):
+    topic: str = ""
+    transcript: str = ""
+    platform: str | None = None
+    callback_url: str | None = None
+
+
+class PublishPayload(BaseModel):
+    media: str | None = None
+    asset: str | None = None
+    title: str | None = None
+    description: str | None = None
+    platforms: list[str] = Field(default_factory=list)
+    platform: str | None = None
+    scheduled_at: str | None = None
+    draft: bool = True
+    callback_url: str | None = None
+
+
+class ProjectPayload(BaseModel):
+    name: str
+    metadata: dict[str, Any] = Field(default_factory=dict)
 
 
 @api.get("/health")
@@ -138,9 +233,40 @@ def health() -> dict[str, str]:
     return {"status": "ok"}
 
 
+@api.get("/monitor")
+def monitor() -> dict[str, Any]:
+    return _monitor_payload()
+
+
+@api.get("/queue")
+def queue() -> dict[str, Any]:
+    return job_manager.summary()
+
+
+@api.get("/workers")
+def workers() -> dict[str, Any]:
+    return {
+        "max_workers": settings.max_workers,
+        "ffmpeg_timeout_seconds": settings.ffmpeg_timeout_seconds,
+        "whisper_device": settings.whisper_device,
+        "whisper_model_size": settings.whisper_model_size,
+        "toolkit_tasks": supported_toolkit_tasks(),
+    }
+
+
 @api.get("/presets")
-def presets() -> dict[str, list[str]]:
-    return {"presets": list_presets(), "caption_templates": list_templates(), "platforms": list_platform_profiles()}
+def presets() -> dict[str, Any]:
+    return {
+        "presets": list_presets(),
+        "caption_templates": list_templates(),
+        "platforms": list_platform_profiles(),
+        "creative_styles": list_creative_styles(),
+        "scene_effects": list_scene_effects(),
+        "transitions": TransitionBuilder().list_transitions(),
+        "creative_style_metadata": creative_style_metadata(),
+        "scene_effect_metadata": scene_effect_metadata(),
+        "toolkit_tasks": supported_toolkit_tasks(),
+    }
 
 
 @api.get("/platforms")
@@ -148,10 +274,43 @@ def platforms() -> dict[str, dict[str, Any]]:
     return {"platforms": platform_profile_metadata()}
 
 
+@api.get("/toolkit/tasks")
+def toolkit_tasks() -> dict[str, list[str]]:
+    return {"tasks": supported_toolkit_tasks()}
+
+
+@api.get("/projects")
+def list_projects() -> dict[str, list[dict[str, Any]]]:
+    projects_dir = settings.storage_dir / "projects"
+    projects_dir.mkdir(parents=True, exist_ok=True)
+    projects: list[dict[str, Any]] = []
+    for manifest in sorted(projects_dir.glob("*/project.json")):
+        try:
+            projects.append(json.loads(manifest.read_text(encoding="utf-8")))
+        except Exception:
+            continue
+    return {"projects": projects}
+
+
+@api.post("/projects", dependencies=[Depends(_verify_api_key)])
+def create_project(payload: ProjectPayload) -> dict[str, Any]:
+    slug = safe_filename(payload.name)
+    project_dir = settings.storage_dir / "projects" / slug
+    project_dir.mkdir(parents=True, exist_ok=True)
+    manifest = {
+        "name": payload.name,
+        "slug": slug,
+        "path": str(project_dir),
+        "metadata": payload.metadata,
+    }
+    (project_dir / "project.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+    return {"project": manifest}
+
+
 @api.post("/render")
 def render(payload: RenderPayload | AIReelsPayload) -> dict[str, str]:
     if isinstance(payload, AIReelsPayload):
-        job_id = job_manager.submit_ai_reels(AIReelsRequest(**payload.model_dump()))
+        job_id = job_manager.submit_ai_reels(_ai_reels_request(payload))
     else:
         job_id = job_manager.submit_render(_render_request(payload))
     return _submission_response(job_id)
@@ -160,7 +319,7 @@ def render(payload: RenderPayload | AIReelsPayload) -> dict[str, str]:
 
 @api.post("/render/ai-reels")
 def render_ai_reels(payload: AIReelsPayload) -> dict[str, str]:
-    job_id = job_manager.submit_ai_reels(AIReelsRequest(**payload.model_dump()))
+    job_id = job_manager.submit_ai_reels(_ai_reels_request(payload))
     return _submission_response(job_id)
 
 
@@ -184,7 +343,7 @@ async def render_ai_reels_upload(request_json: str = Form(...), files: list[Uplo
     uploads = await _stage_uploads(files)
     payload_data = _replace_upload_refs(json.loads(request_json), uploads)
     payload = AIReelsPayload.model_validate(payload_data)
-    job_id = job_manager.submit_ai_reels(AIReelsRequest(**payload.model_dump()))
+    job_id = job_manager.submit_ai_reels(_ai_reels_request(payload))
     return _submission_response(job_id)
 
 
@@ -192,11 +351,115 @@ async def render_ai_reels_upload(request_json: str = Form(...), files: list[Uplo
 async def upload_assets(files: list[UploadFile] = File(...)) -> dict[str, list[UploadedAsset]]:
     uploads = await _stage_uploads(files)
     assets = [
-        UploadedAsset(filename=filename, path=path, reference=f"upload://{filename}") for filename, path in uploads.items()
+        UploadedAsset(filename=filename, path=path, reference=f"upload://{filename}", kind=_asset_kind(filename)) for filename, path in uploads.items()
     ]
     return {"assets": [asset.model_dump() for asset in assets]}
 
 
+@api.post("/upload")
+async def upload(files: list[UploadFile] = File(...), expand_zip: bool = Form(default=True)) -> dict[str, list[UploadedAsset]]:
+    uploads = await _stage_uploads(files)
+    expanded: dict[str, str] = {}
+    for filename, path in uploads.items():
+        if expand_zip and filename.lower().endswith(".zip"):
+            expanded.update(_extract_zip(Path(path)))
+        else:
+            expanded[filename] = path
+    assets = [
+        UploadedAsset(filename=filename, path=path, reference=f"upload://{filename}", kind=_asset_kind(filename))
+        for filename, path in expanded.items()
+    ]
+    return {"assets": [asset.model_dump() for asset in assets]}
+
+
+@api.post("/ingest", dependencies=[Depends(_verify_api_key)])
+def ingest(payload: IngestPayload) -> dict[str, str]:
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).ingest_sources([source.model_dump() for source in payload.sources], task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/analyze", dependencies=[Depends(_verify_api_key)])
+def analyze(payload: AnalyzePayload) -> dict[str, str]:
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).analyze(
+            payload.media,
+            task_id,
+            transcript=payload.transcript,
+            platform=payload.platform,
+        ),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/clips", dependencies=[Depends(_verify_api_key)])
+def clips(payload: ClipsPayload) -> dict[str, str]:
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).clips(payload.media, task_id, payload.clips),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/thumbnail", dependencies=[Depends(_verify_api_key)])
+def thumbnail(payload: ThumbnailPayload) -> dict[str, str]:
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).thumbnail(
+            payload.media,
+            task_id,
+            text=payload.text,
+            timestamp=payload.timestamp,
+            template=payload.template,
+        ),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/metadata", dependencies=[Depends(_verify_api_key)])
+def metadata(payload: MetadataPayload) -> dict[str, str]:
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).metadata(
+            task_id,
+            topic=payload.topic,
+            transcript=payload.transcript,
+            platform=payload.platform,
+        ),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/publish", dependencies=[Depends(_verify_api_key)])
+def publish(payload: PublishPayload) -> dict[str, str]:
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).publish(payload.model_dump(), task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/toolkit", dependencies=[Depends(_verify_api_key)])
+def toolkit(payload: ToolkitPayload) -> dict[str, str]:
+    data = payload.model_dump()
+    if payload.model_extra:
+        data.update(payload.model_extra)
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).toolkit(data, task_id),
+        callback_url=payload.callback_url,
+        export_target=payload.export_target,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/edit", dependencies=[Depends(_verify_api_key)])
+def edit(payload: ToolkitPayload) -> dict[str, str]:
+    return toolkit(payload)
+
+
 @api.post("/transcribe")
 def transcribe(payload: TranscribePayload) -> dict:
     from renderer.core.ingest import AssetIngestor
@@ -236,25 +499,28 @@ def subtitles(payload: SubtitlePayload) -> FileResponse:
 
 
 @api.post("/scene-builder")
-def scene_builder(payload: SceneBuildPayload) -> dict[str, list[dict[str, Any]]]:
+def scene_builder(payload: SceneBuildPayload) -> dict[str, Any]:
     if not payload.assets:
         raise HTTPException(status_code=400, detail="At least one asset is required")
+    style = get_creative_style(payload.creative_style)
     words = payload.script.split()
-    total_duration = payload.duration or max(3.0, len(words) * 0.35)
+    total_duration = payload.duration or max(style.scene_duration * len(payload.assets), len(words) * 0.35, 3.0)
     per_scene = total_duration / len(payload.assets)
-    chunk_size = max(1, round(len(words) / len(payload.assets)))
-    captions = [" ".join(words[index : index + chunk_size]) for index in range(0, len(words), chunk_size)]
+    captions = _split_words_for_assets(words, len(payload.assets))
     scenes = [
         {
             "start": round(index * per_scene, 3),
             "duration": round(per_scene, 3),
             "media": asset,
             "caption": captions[index] if index < len(captions) else "",
-            "transition": payload.transition,
+            "transition": _style_transition(payload.transition, style.transition_sequence, index),
+            "effect": style.scene_effect_sequence[index % len(style.scene_effect_sequence)],
+            "background": "blur",
+            "layout": "fill",
         }
         for index, asset in enumerate(payload.assets)
     ]
-    return {"scenes": scenes}
+    return {"scenes": scenes, "creative_style": style.metadata_payload()}
 
 
 @api.post("/transcribe/upload")
@@ -317,7 +583,7 @@ def download(job_id: str, token: str | None = Query(default=None)) -> FileRespon
     path = Path(record.output_path)
     if not path.exists():
         raise HTTPException(status_code=404, detail="Output file is missing")
-    return FileResponse(path, media_type="video/mp4", filename=path.name)
+    return FileResponse(path, media_type=_media_type(path), filename=path.name)
 
 
 @api.post("/inspect")
@@ -329,11 +595,12 @@ def inspect_asset(path: str) -> dict:
 
 
 def _render_request(payload: RenderPayload) -> RenderRequest:
-    payload = RenderPayload.model_validate(apply_preset(payload.model_dump()))
+    payload = RenderPayload.model_validate(apply_creative_style(apply_preset(payload.model_dump(exclude_unset=True))))
     request = RenderRequest(
         scenes=[Scene(**scene.model_dump()) for scene in payload.scenes],
         template=payload.template,
         preset=payload.preset,
+        creative_style=payload.creative_style,
         platform=payload.platform,
         output_name=payload.output_name,
         voiceover=payload.voiceover,
@@ -366,12 +633,19 @@ def _render_request(payload: RenderPayload) -> RenderRequest:
     return request
 
 
+def _ai_reels_request(payload: AIReelsPayload) -> AIReelsRequest:
+    payload = AIReelsPayload.model_validate(apply_creative_style(apply_preset(payload.model_dump(exclude_unset=True))))
+    return AIReelsRequest(**payload.model_dump())
+
+
 async def _stage_uploads(files: list[UploadFile]) -> dict[str, str]:
     upload_dir = settings.temp_dir / "uploads" / uuid.uuid4().hex
     staged: dict[str, str] = {}
     total_bytes = 0
     for upload in files:
         filename = safe_filename(upload.filename or f"asset_{len(staged)}")
+        if not _allowed_upload(filename):
+            raise HTTPException(status_code=415, detail=f"Unsupported asset type: {filename}")
         target = upload_dir / filename
         target.parent.mkdir(parents=True, exist_ok=True)
         with target.open("wb") as output:
@@ -388,6 +662,112 @@ async def _stage_uploads(files: list[UploadFile]) -> dict[str, str]:
     return staged
 
 
+def _monitor_payload() -> dict[str, Any]:
+    disk = shutil.disk_usage(settings.base_dir)
+    return {
+        "health": "ok",
+        "queue": job_manager.summary(),
+        "workers": {
+            "max_workers": settings.max_workers,
+            "ffmpeg_timeout_seconds": settings.ffmpeg_timeout_seconds,
+            "whisper_model_size": settings.whisper_model_size,
+            "whisper_device": settings.whisper_device,
+        },
+        "disk": {
+            "total_bytes": disk.total,
+            "used_bytes": disk.used,
+            "free_bytes": disk.free,
+        },
+        "directories": {
+            "temp": str(settings.temp_dir),
+            "exports": str(settings.exports_dir),
+            "jobs": str(settings.jobs_dir),
+            "storage": str(settings.storage_dir),
+        },
+    }
+
+
+def _extract_zip(path: Path) -> dict[str, str]:
+    output_dir = settings.temp_dir / "uploads" / f"zip_{uuid.uuid4().hex}"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    extracted: dict[str, str] = {}
+    with zipfile.ZipFile(path) as archive:
+        for member in archive.infolist():
+            if member.is_dir():
+                continue
+            name = safe_filename(Path(member.filename).name)
+            if not _allowed_upload(name):
+                continue
+            target = output_dir / name
+            resolved = target.resolve()
+            if output_dir.resolve() not in resolved.parents and resolved != output_dir.resolve():
+                raise HTTPException(status_code=400, detail="Unsafe ZIP member path")
+            with archive.open(member) as source, target.open("wb") as destination:
+                shutil.copyfileobj(source, destination)
+            extracted[name] = str(target)
+    return extracted
+
+
+def _asset_kind(filename: str) -> str:
+    suffix = Path(filename).suffix.lower()
+    if suffix in {".mp4", ".mov", ".m4v", ".webm", ".mkv", ".avi", ".gif"}:
+        return "video"
+    if suffix in {".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"}:
+        return "audio"
+    if suffix in {".jpg", ".jpeg", ".png", ".webp", ".avif"}:
+        return "image"
+    if suffix in {".srt", ".ass", ".vtt"}:
+        return "subtitle"
+    return "other"
+
+
+def _allowed_upload(filename: str) -> bool:
+    suffix = Path(filename).suffix.lower()
+    return suffix in {
+        ".mp4",
+        ".mov",
+        ".m4v",
+        ".webm",
+        ".mkv",
+        ".avi",
+        ".gif",
+        ".mp3",
+        ".wav",
+        ".m4a",
+        ".aac",
+        ".flac",
+        ".ogg",
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".webp",
+        ".avif",
+        ".srt",
+        ".ass",
+        ".vtt",
+        ".zip",
+    }
+
+
+def _media_type(path: Path) -> str:
+    suffix = path.suffix.lower()
+    if suffix == ".json":
+        return "application/json"
+    if suffix == ".zip":
+        return "application/zip"
+    if suffix == ".jpg" or suffix == ".jpeg":
+        return "image/jpeg"
+    if suffix == ".png":
+        return "image/png"
+    if suffix == ".gif":
+        return "image/gif"
+    if suffix == ".mp3":
+        return "audio/mpeg"
+    if suffix in {".srt", ".vtt", ".ass"}:
+        return "text/plain"
+    return "video/mp4"
+
+
 def _replace_upload_refs(value: Any, uploads: dict[str, str]) -> Any:
     if isinstance(value, dict):
         return {key: _replace_upload_refs(item, uploads) for key, item in value.items()}
@@ -399,3 +779,25 @@ def _replace_upload_refs(value: Any, uploads: dict[str, str]) -> Any:
             raise HTTPException(status_code=400, detail=f"Missing uploaded file for reference: upload://{name}")
         return uploads[name]
     return value
+
+
+def _split_words_for_assets(words: list[str], count: int) -> list[str]:
+    if count <= 0:
+        return []
+    if not words:
+        return [""] * count
+    base, remainder = divmod(len(words), count)
+    captions: list[str] = []
+    cursor = 0
+    for index in range(count):
+        size = base + (1 if index < remainder else 0)
+        size = max(1, size)
+        captions.append(" ".join(words[cursor : cursor + size]))
+        cursor += size
+    return captions
+
+
+def _style_transition(requested: str, sequence: tuple[str, ...], index: int) -> str:
+    if requested and requested != "fade":
+        return requested
+    return sequence[index % len(sequence)] if sequence else "fade"

app.py

@@ -11,7 +11,7 @@ from api import api, job_manager, settings
 from renderer import RenderEngine
 from renderer.core.models import AIReelsRequest
 from renderer.scenes import Timeline
-from renderer.templates import apply_preset, list_platform_profiles, list_templates
+from renderer.templates import apply_creative_style, apply_preset, list_creative_styles, list_platform_profiles, list_templates
 
 
 def create_dashboard() -> gr.Blocks:
@@ -36,11 +36,12 @@ def create_dashboard() -> gr.Blocks:
             voiceover = gr.File(label="Voiceover", file_types=["audio"], type="filepath")
             assets = gr.File(label="Assets", file_count="multiple", type="filepath")
             template = gr.Dropdown(choices=list_templates(), value="tiktok_classic", label="Caption Template")
+            creative_style = gr.Dropdown(choices=list_creative_styles(), value="viral_shorts", label="Creative Style")
             platform = gr.Dropdown(choices=list_platform_profiles(), value="tiktok", label="Platform")
             music = gr.File(label="Background Music", file_types=["audio"], type="filepath")
             ai_button = gr.Button("Submit AI Reel", variant="primary")
             ai_output = gr.JSON(label="Submission")
-            ai_button.click(fn=_submit_ai_reel, inputs=[script, voiceover, assets, template, platform, music], outputs=ai_output)
+            ai_button.click(fn=_submit_ai_reel, inputs=[script, voiceover, assets, template, creative_style, platform, music], outputs=ai_output)
 
         with gr.Tab("Batch Render"):
             batch_json = gr.Textbox(label="Batch JSON", lines=14, value=json.dumps({"jobs": []}, indent=2))
@@ -88,11 +89,50 @@ def create_dashboard() -> gr.Blocks:
             inspect_output = gr.JSON(label="Metadata")
             inspect_button.click(fn=_inspect_asset, inputs=asset_path, outputs=inspect_output)
 
+        with gr.Tab("AI Analysis"):
+            analysis_media = gr.Textbox(label="Media URL or path")
+            analysis_transcript = gr.Textbox(label="Transcript", lines=5)
+            analysis_platform = gr.Dropdown(choices=list_platform_profiles(), value="tiktok", label="Target Platform")
+            analysis_button = gr.Button("Submit Analysis", variant="primary")
+            analysis_output = gr.JSON(label="Analysis Job")
+            analysis_button.click(
+                fn=_submit_analysis,
+                inputs=[analysis_media, analysis_transcript, analysis_platform],
+                outputs=analysis_output,
+            )
+
+        with gr.Tab("Clip Generator"):
+            clip_media = gr.Textbox(label="Media URL or path")
+            clip_json = gr.Textbox(label="Clip JSON", lines=6, value=json.dumps([{"start": 0, "end": 8}], indent=2))
+            clip_button = gr.Button("Generate Clips", variant="primary")
+            clip_output = gr.JSON(label="Clip Job")
+            clip_button.click(fn=_submit_clips, inputs=[clip_media, clip_json], outputs=clip_output)
+
+        with gr.Tab("Metadata"):
+            metadata_topic = gr.Textbox(label="Topic or transcript", lines=5)
+            metadata_platform = gr.Dropdown(choices=list_platform_profiles(), value="tiktok", label="Platform")
+            metadata_button = gr.Button("Generate Metadata", variant="primary")
+            metadata_output = gr.JSON(label="Metadata Job")
+            metadata_button.click(fn=_submit_metadata, inputs=[metadata_topic, metadata_platform], outputs=metadata_output)
+
+        with gr.Tab("Publishing"):
+            publish_media = gr.Textbox(label="Media URL or rendered output path")
+            publish_title = gr.Textbox(label="Title")
+            publish_platforms = gr.Textbox(label="Platforms", value="youtube,tiktok,instagram")
+            publish_button = gr.Button("Create Publish Draft", variant="primary")
+            publish_output = gr.JSON(label="Publish Job")
+            publish_button.click(fn=_submit_publish, inputs=[publish_media, publish_title, publish_platforms], outputs=publish_output)
+
+        with gr.Tab("Queue Monitor"):
+            queue_button = gr.Button("Refresh Queue")
+            queue_output = gr.JSON(label="Queue")
+            queue_button.click(fn=_queue_status, outputs=queue_output)
+
     return dashboard
 
 
 def _submit_render_json(payload: str) -> dict[str, Any]:
-    data = apply_preset(json.loads(payload))
+    data = apply_creative_style(apply_preset(json.loads(payload)))
     request = Timeline.request_from_payload(data)
     job_id = job_manager.submit_render(request)
     return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
@@ -100,16 +140,25 @@ def _submit_render_json(payload: str) -> dict[str, Any]:
 
 def _submit_batch_json(payload: str) -> dict[str, Any]:
     data = json.loads(payload)
-    requests = [Timeline.request_from_payload(apply_preset(job)) for job in data.get("jobs", [])]
+    requests = [Timeline.request_from_payload(apply_creative_style(apply_preset(job))) for job in data.get("jobs", [])]
     return {"job_ids": job_manager.submit_batch(requests)}
 
 
-def _submit_ai_reel(script: str, voiceover: str, assets: list[str], template: str, platform: str, music: str | None) -> dict[str, Any]:
+def _submit_ai_reel(
+    script: str,
+    voiceover: str,
+    assets: list[str],
+    template: str,
+    creative_style: str,
+    platform: str,
+    music: str | None,
+) -> dict[str, Any]:
     request = AIReelsRequest(
         script=script,
         voiceover=voiceover,
         assets=assets or [],
         template=template,
+        creative_style=creative_style,
         platform=platform,
         background_music=music,
     )
@@ -145,6 +194,42 @@ def _transcribe_file(path: str, model_size: str, language: str) -> dict[str, Any
     )
 
 
+def _submit_analysis(media: str, transcript: str, platform: str) -> dict[str, Any]:
+    from renderer.platform import PlatformProcessor
+
+    job_id = job_manager.submit_task(
+        lambda task_id, log: PlatformProcessor(settings, log=log).analyze(media, task_id, transcript=transcript, platform=platform)
+    )
+    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
+
+
+def _submit_clips(media: str, clips_json: str) -> dict[str, Any]:
+    from renderer.platform import PlatformProcessor
+
+    clips = json.loads(clips_json)
+    job_id = job_manager.submit_task(lambda task_id, log: PlatformProcessor(settings, log=log).clips(media, task_id, clips))
+    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
+
+
+def _submit_metadata(topic: str, platform: str) -> dict[str, Any]:
+    from renderer.platform import PlatformProcessor
+
+    job_id = job_manager.submit_task(lambda task_id, log: PlatformProcessor(settings, log=log).metadata(task_id, topic=topic, platform=platform))
+    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
+
+
+def _submit_publish(media: str, title: str, platforms: str) -> dict[str, Any]:
+    from renderer.platform import PlatformProcessor
+
+    payload = {"media": media, "title": title, "platforms": [item.strip() for item in platforms.split(",") if item.strip()], "draft": True}
+    job_id = job_manager.submit_task(lambda task_id, log: PlatformProcessor(settings, log=log).publish(payload, task_id))
+    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
+
+
+def _queue_status() -> dict[str, Any]:
+    return job_manager.summary()
+
+
 app = gr.mount_gradio_app(api, create_dashboard(), path="/dashboard")