Upload 6 files

Dockerfile

@@ -5,7 +5,9 @@ ENV PYTHONUNBUFFERED=1 \
     EXPORTS_DIR=/app/exports \
     JOBS_DIR=/app/jobs \
     STORAGE_DIR=/app/storage \
+    AVA2LON_BASE_DIR=/app \
     BASYX_BASE_DIR=/app \
+    AVA2LON_SIGNING_SECRET=change-me-in-space-secrets \
     BASYX_SIGNING_SECRET=change-me-in-space-secrets \
     MAX_RENDER_WORKERS=1 \
     FFMPEG_TIMEOUT_SECONDS=900 \

api.py

@@ -19,6 +19,15 @@ 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.studio import (
+    ProjectStore,
+    StudioTaskProcessor,
+    add_effect,
+    add_filter,
+    add_keyframe,
+    add_transition,
+    capability_catalog,
+)
 from renderer import RenderEngine
 from renderer.subtitles import SubtitleEvent, SubtitleGenerator
 from renderer.templates import (
@@ -39,7 +48,8 @@ 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")
+project_manager = ProjectStore(settings)
+api = FastAPI(title="Ava2lon Studio AI", version="2.0.0")
 
 API_KEY_HEADER = "X-API-Key"
 
@@ -226,6 +236,124 @@ class PublishPayload(BaseModel):
 class ProjectPayload(BaseModel):
     name: str
     metadata: dict[str, Any] = Field(default_factory=dict)
+    export_settings: dict[str, Any] = Field(default_factory=dict)
+    template: dict[str, Any] | None = None
+
+
+class ProjectSavePayload(BaseModel):
+    project_id: str | None = None
+    project: dict[str, Any]
+
+
+class ProjectAssetPayload(BaseModel):
+    project_id: str
+    asset: dict[str, Any]
+
+
+class TimelineAddPayload(BaseModel):
+    project_id: str
+    track_type: str = "video"
+    track_id: str | None = None
+    item: dict[str, Any] = Field(default_factory=dict)
+
+
+class TimelineOperationPayload(BaseModel):
+    project_id: str
+    operation: str = "drag"
+    item_id: str | None = None
+    params: dict[str, Any] = Field(default_factory=dict)
+
+
+class EffectApplyPayload(BaseModel):
+    project_id: str | None = None
+    target_id: str | None = None
+    item_id: str | None = None
+    effect: str
+    params: dict[str, Any] = Field(default_factory=dict)
+    callback_url: str | None = None
+
+
+class FilterApplyPayload(BaseModel):
+    project_id: str | None = None
+    target_id: str | None = None
+    item_id: str | None = None
+    filter: str
+    params: dict[str, Any] = Field(default_factory=dict)
+    lut: str | None = None
+    callback_url: str | None = None
+
+
+class TransitionAddPayload(BaseModel):
+    project_id: str | None = None
+    from_item_id: str | None = None
+    to_item_id: str | None = None
+    target_id: str | None = None
+    transition: str
+    duration: float = Field(default=0.45, gt=0)
+    params: dict[str, Any] = Field(default_factory=dict)
+    callback_url: str | None = None
+
+
+class KeyframePayload(BaseModel):
+    project_id: str
+    target_id: str
+    property: str
+    time: float = Field(ge=0)
+    value: Any
+    easing: str = "linear"
+
+
+class GenerationPayload(BaseModel):
+    prompt: str | None = None
+    text: str | None = None
+    media: str | None = None
+    provider: str | None = None
+    callback_url: str | None = None
+    export_target: str | None = None
+    params: dict[str, Any] = Field(default_factory=dict)
+    model_config = {"extra": "allow"}
+
+
+class CaptionGeneratePayload(BaseModel):
+    media: str | None = None
+    audio: str | None = None
+    text: str | None = None
+    transcript: str | None = None
+    events: list[dict[str, Any]] | None = None
+    template: str = "capcut"
+    language: str | None = None
+    engine: str = "whisper"
+    word_timestamps: bool = True
+    emoji_insertion: bool = False
+    speaker_detection: bool = False
+    karaoke: bool = True
+    animated: bool = True
+    callback_url: str | None = None
+    model_config = {"extra": "allow"}
+
+
+class AIToolPayload(BaseModel):
+    project_id: str | None = None
+    media: str | None = None
+    transcript: str | None = None
+    text: str | None = None
+    platform: str | None = None
+    callback_url: str | None = None
+    params: dict[str, Any] = Field(default_factory=dict)
+    model_config = {"extra": "allow"}
+
+
+class ProjectRenderPayload(BaseModel):
+    output_name: str = "project_render.mp4"
+    template: str | None = None
+    preset: str | None = None
+    creative_style: str | None = None
+    platform: str | None = None
+    callback_url: str | None = None
+    export_target: str | None = None
+    preview: bool = False
+    normalize: bool = True
+    metadata: dict[str, Any] = Field(default_factory=dict)
 
 
 @api.get("/health")
@@ -279,32 +407,307 @@ def toolkit_tasks() -> dict[str, list[str]]:
     return {"tasks": supported_toolkit_tasks()}
 
 
+@api.get("/capabilities")
+def capabilities() -> dict[str, Any]:
+    catalog = capability_catalog()
+    catalog["runtime"] = {
+        "toolkit_tasks": supported_toolkit_tasks(),
+        "caption_templates": list_templates(),
+        "creative_styles": list_creative_styles(),
+        "scene_effects": list_scene_effects(),
+        "platforms": list_platform_profiles(),
+        "transitions": TransitionBuilder().list_transitions(),
+    }
+    return catalog
+
+
+@api.get("/effects")
+def effects() -> dict[str, Any]:
+    catalog = capability_catalog()
+    return {"effects": catalog["effects"], "scene_effects": scene_effect_metadata()}
+
+
+@api.get("/filters")
+def filters() -> dict[str, Any]:
+    return {"filters": capability_catalog()["filters"]}
+
+
+@api.get("/transitions")
+def transitions() -> dict[str, Any]:
+    return {"families": capability_catalog()["transitions"], "ffmpeg": TransitionBuilder().list_transitions()}
+
+
+@api.get("/templates/catalog")
+def templates_catalog() -> dict[str, Any]:
+    return {
+        "categories": capability_catalog()["templates"],
+        "caption_templates": list_templates(),
+        "render_presets": list_presets(),
+        "creative_styles": creative_style_metadata(),
+    }
+
+
 @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}
+    return {"projects": project_manager.list()}
 
 
 @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}
+    project = project_manager.create(payload.name, metadata=payload.metadata, template=payload.template)
+    if payload.export_settings:
+        project["export_settings"].update(payload.export_settings)
+        project = project_manager.save(project["id"], project)
+    return {"project": project}
+
+
+@api.post("/project/create", dependencies=[Depends(_verify_api_key)])
+def project_create(payload: ProjectPayload) -> dict[str, Any]:
+    return create_project(payload)
+
+
+@api.get("/project/{project_id}")
+def project_get(project_id: str) -> dict[str, Any]:
+    try:
+        return {"project": project_manager.get(project_id)}
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="Project not found") from exc
+
+
+@api.post("/project/save", dependencies=[Depends(_verify_api_key)])
+def project_save(payload: ProjectSavePayload) -> dict[str, Any]:
+    project_id = payload.project_id or str(payload.project.get("id") or safe_filename(payload.project.get("name", "project")))
+    return {"project": project_manager.save(project_id, payload.project)}
+
+
+@api.post("/project/assets/add", dependencies=[Depends(_verify_api_key)])
+def project_asset_add(payload: ProjectAssetPayload) -> dict[str, Any]:
+    try:
+        return {"project": project_manager.add_asset(payload.project_id, payload.asset)}
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="Project not found") from exc
+
+
+@api.post("/timeline/add", dependencies=[Depends(_verify_api_key)])
+def timeline_add(payload: TimelineAddPayload) -> dict[str, Any]:
+    try:
+        project = project_manager.add_to_timeline(payload.project_id, payload.item, payload.track_type, payload.track_id)
+        return {"project": project}
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="Project not found") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+@api.post("/timeline/operation", dependencies=[Depends(_verify_api_key)])
+def timeline_operation(payload: TimelineOperationPayload) -> dict[str, Any]:
+    try:
+        project = project_manager.timeline_operation(payload.project_id, payload.operation, payload.item_id, payload.params)
+        return {"project": project}
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="Timeline item or project not found") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+@api.post("/timeline/split", dependencies=[Depends(_verify_api_key)])
+def timeline_split(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "split"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/trim", dependencies=[Depends(_verify_api_key)])
+def timeline_trim(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "trim"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/ripple-delete", dependencies=[Depends(_verify_api_key)])
+def timeline_ripple_delete(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "ripple_delete"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/insert", dependencies=[Depends(_verify_api_key)])
+def timeline_insert(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "insert"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/replace", dependencies=[Depends(_verify_api_key)])
+def timeline_replace(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "replace"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/group", dependencies=[Depends(_verify_api_key)])
+def timeline_group(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "group"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/lock", dependencies=[Depends(_verify_api_key)])
+def timeline_lock(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "lock"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/hide", dependencies=[Depends(_verify_api_key)])
+def timeline_hide(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "hide"
+    return timeline_operation(payload)
+
+
+@api.post("/timeline/duplicate", dependencies=[Depends(_verify_api_key)])
+def timeline_duplicate(payload: TimelineOperationPayload) -> dict[str, Any]:
+    payload.operation = "duplicate"
+    return timeline_operation(payload)
+
+
+@api.post("/effect/apply", dependencies=[Depends(_verify_api_key)])
+def effect_apply(payload: EffectApplyPayload) -> dict[str, Any]:
+    target_id = payload.target_id or payload.item_id
+    if payload.project_id and target_id:
+        try:
+            project = project_manager.get(payload.project_id)
+            record = add_effect(project, target_id, payload.effect, payload.params)
+            project = project_manager.save(payload.project_id, project)
+            return {"effect": record, "project": project}
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail="Project or target item not found") from exc
+    data = {"task": payload.effect, "input": target_id, "params": payload.params, "callback_url": payload.callback_url}
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).ai_tool("auto_edit", data, task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/filter/apply", dependencies=[Depends(_verify_api_key)])
+def filter_apply(payload: FilterApplyPayload) -> dict[str, Any]:
+    target_id = payload.target_id or payload.item_id
+    params = dict(payload.params)
+    if payload.lut:
+        params["lut"] = payload.lut
+    if payload.project_id and target_id:
+        try:
+            project = project_manager.get(payload.project_id)
+            record = add_filter(project, target_id, payload.filter, params)
+            project = project_manager.save(payload.project_id, project)
+            return {"filter": record, "project": project}
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail="Project or target item not found") from exc
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).ai_tool("auto_color_match", payload.model_dump(), task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/transition/add", dependencies=[Depends(_verify_api_key)])
+def transition_add(payload: TransitionAddPayload) -> dict[str, Any]:
+    if payload.project_id and payload.from_item_id and payload.to_item_id:
+        try:
+            project = project_manager.get(payload.project_id)
+            record = add_transition(project, payload.from_item_id, payload.to_item_id, payload.transition, payload.duration)
+            project = project_manager.save(payload.project_id, project)
+            return {"transition": record, "project": project}
+        except KeyError as exc:
+            raise HTTPException(status_code=404, detail="Project not found") from exc
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).ai_tool("auto_edit", payload.model_dump(), task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/keyframe/add", dependencies=[Depends(_verify_api_key)])
+def keyframe_add(payload: KeyframePayload) -> dict[str, Any]:
+    try:
+        project = project_manager.get(payload.project_id)
+        record = add_keyframe(project, payload.target_id, payload.property, payload.time, payload.value, payload.easing)
+        project = project_manager.save(payload.project_id, project)
+        return {"keyframe": record, "project": project}
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="Project or target item not found") from exc
+
+
+@api.post("/caption/generate", dependencies=[Depends(_verify_api_key)])
+def caption_generate(payload: CaptionGeneratePayload) -> dict[str, str]:
+    data = payload.model_dump()
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).caption_generate(data, task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/music/generate", dependencies=[Depends(_verify_api_key)])
+def music_generate(payload: GenerationPayload) -> dict[str, str]:
+    data = _generation_data(payload)
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).music_generate(data, task_id),
+        callback_url=payload.callback_url,
+        export_target=payload.export_target,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/voice/generate", dependencies=[Depends(_verify_api_key)])
+def voice_generate(payload: GenerationPayload) -> dict[str, str]:
+    data = _generation_data(payload)
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).voice_generate(data, task_id),
+        callback_url=payload.callback_url,
+        export_target=payload.export_target,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/image/generate", dependencies=[Depends(_verify_api_key)])
+def image_generate(payload: GenerationPayload) -> dict[str, str]:
+    data = _generation_data(payload)
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).image_generate(data, task_id),
+        callback_url=payload.callback_url,
+        export_target=payload.export_target,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/video/generate", dependencies=[Depends(_verify_api_key)])
+def video_generate(payload: GenerationPayload) -> dict[str, str]:
+    data = _generation_data(payload)
+    job_id = job_manager.submit_task(
+        lambda task_id, log: StudioTaskProcessor(settings, log=log).video_generate(data, task_id),
+        callback_url=payload.callback_url,
+        export_target=payload.export_target,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/ai/{tool}", dependencies=[Depends(_verify_api_key)])
+def ai_tool(tool: str, payload: AIToolPayload) -> 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: StudioTaskProcessor(settings, log=log).ai_tool(tool, data, task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
+
+
+@api.post("/assistant/{tool}", dependencies=[Depends(_verify_api_key)])
+def assistant_tool(tool: str, payload: AIToolPayload) -> 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: StudioTaskProcessor(settings, log=log).assistant_tool(tool, data, task_id),
+        callback_url=payload.callback_url,
+    )
+    return _submission_response(job_id)
 
 
 @api.post("/render")
@@ -329,6 +732,24 @@ def render_batch(payload: BatchPayload) -> dict[str, list[str]]:
     return {"job_ids": job_ids}
 
 
+@api.post("/automation/batch", dependencies=[Depends(_verify_api_key)])
+def automation_batch(payload: BatchPayload) -> dict[str, list[str]]:
+    return render_batch(payload)
+
+
+@api.post("/project/{project_id}/render", dependencies=[Depends(_verify_api_key)])
+def project_render(project_id: str, payload: ProjectRenderPayload) -> dict[str, str]:
+    try:
+        project = project_manager.get(project_id)
+        request = _project_render_request(project, payload)
+        job_id = job_manager.submit_render(request)
+        return _submission_response(job_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail="Project not found") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
 @api.post("/render/upload")
 async def render_upload(request_json: str = Form(...), files: list[UploadFile] = File(default=[])) -> dict[str, str]:
     uploads = await _stage_uploads(files)
@@ -419,6 +840,11 @@ def thumbnail(payload: ThumbnailPayload) -> dict[str, str]:
     return _submission_response(job_id)
 
 
+@api.post("/thumbnail/create", dependencies=[Depends(_verify_api_key)])
+def thumbnail_create(payload: ThumbnailPayload) -> dict[str, str]:
+    return thumbnail(payload)
+
+
 @api.post("/metadata", dependencies=[Depends(_verify_api_key)])
 def metadata(payload: MetadataPayload) -> dict[str, str]:
     job_id = job_manager.submit_task(
@@ -549,6 +975,11 @@ async def transcribe_upload(
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
 
+@api.get("/status")
+def status_query(job_id: str = Query(...)) -> dict:
+    return status(job_id)
+
+
 @api.get("/status/{job_id}")
 def status(job_id: str) -> dict:
     try:
@@ -570,6 +1001,11 @@ def cleanup(older_than_seconds: int | None = None) -> dict[str, int]:
     return job_manager.cleanup(older_than_seconds)
 
 
+@api.get("/download")
+def download_query(job_id: str = Query(...), token: str | None = Query(default=None)) -> FileResponse:
+    return download(job_id, token)
+
+
 @api.get("/download/{job_id}")
 def download(job_id: str, token: str | None = Query(default=None)) -> FileResponse:
     try:
@@ -633,11 +1069,86 @@ def _render_request(payload: RenderPayload) -> RenderRequest:
     return request
 
 
+def _project_render_request(project: dict[str, Any], payload: ProjectRenderPayload) -> RenderRequest:
+    scenes: list[dict[str, Any]] = []
+    for tracks in project.get("timeline", {}).get("tracks", {}).values():
+        for track in tracks:
+            if track.get("hidden") or track.get("type") not in {"video", "overlay"}:
+                continue
+            for item in track.get("items", []):
+                if item.get("hidden"):
+                    continue
+                media = _item_media(project, item)
+                if not media:
+                    continue
+                scenes.append(
+                    {
+                        "start": float(item.get("start", 0.0)),
+                        "duration": float(item.get("duration", 1.0)),
+                        "media": media,
+                        "caption": item.get("caption") or item.get("text") or "",
+                        "transition": item.get("transition", "fade"),
+                        "background": item.get("background", "blur"),
+                        "layout": item.get("layout", "fill"),
+                        "effect": _first_named(item.get("effects")),
+                    }
+                )
+    if not scenes:
+        raise ValueError("Project has no renderable video or overlay timeline items")
+    export_settings = project.get("export_settings", {})
+    data = {
+        "scenes": sorted(scenes, key=lambda scene: scene["start"]),
+        "template": payload.template or export_settings.get("template", "tiktok_classic"),
+        "preset": payload.preset,
+        "creative_style": payload.creative_style or project.get("metadata", {}).get("creative_style"),
+        "platform": payload.platform or export_settings.get("platform"),
+        "output_name": payload.output_name,
+        "callback_url": payload.callback_url,
+        "export_target": payload.export_target,
+        "preview": payload.preview,
+        "normalize": payload.normalize,
+        "metadata": project.get("metadata", {}) | payload.metadata | {"project_id": project.get("id"), "project_name": project.get("name")},
+    }
+    return _render_request(RenderPayload.model_validate(data))
+
+
 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())
 
 
+def _generation_data(payload: GenerationPayload) -> dict[str, Any]:
+    data = payload.model_dump()
+    if payload.model_extra:
+        data.update(payload.model_extra)
+    params = data.pop("params", {}) or {}
+    if isinstance(params, dict):
+        data.update(params)
+    return data
+
+
+def _item_media(project: dict[str, Any], item: dict[str, Any]) -> str | None:
+    direct = item.get("media") or item.get("path") or item.get("source")
+    if direct:
+        return str(direct)
+    asset_id = item.get("asset_id")
+    if not asset_id:
+        return None
+    for asset in project.get("assets", []):
+        if asset.get("id") == asset_id:
+            return str(asset.get("path") or asset.get("url") or asset.get("source") or "")
+    return None
+
+
+def _first_named(records: Any) -> str | None:
+    if not isinstance(records, list) or not records:
+        return None
+    first = records[0]
+    if isinstance(first, dict):
+        return first.get("effect") or first.get("name")
+    return str(first)
+
+
 async def _stage_uploads(files: list[UploadFile]) -> dict[str, str]:
     upload_dir = settings.temp_dir / "uploads" / uuid.uuid4().hex
     staged: dict[str, str] = {}

app.py

@@ -7,20 +7,91 @@ from typing import Any
 import gradio as gr
 import uvicorn
 
-from api import api, job_manager, settings
+from api import api, job_manager, project_manager, settings
 from renderer import RenderEngine
 from renderer.core.models import AIReelsRequest
 from renderer.scenes import Timeline
+from renderer.studio import capability_catalog
 from renderer.templates import apply_creative_style, apply_preset, list_creative_styles, list_platform_profiles, list_templates
 
 
 def create_dashboard() -> gr.Blocks:
-    with gr.Blocks(title="Basyx FFmpeg Rendering Engine") as dashboard:
+    with gr.Blocks(title="Ava2lon Studio AI") as dashboard:
         gr.Markdown(
-            "# Basyx FFmpeg Rendering Engine\n"
-            "CPU-first rendering backend for reels, shorts, audiograms, captions, slideshows, and batch jobs."
+            "# Ava2lon Studio AI\n"
+            "CPU-first CapCut-class video automation studio with REST API parity, async jobs, webhooks, and project JSON."
         )
-        with gr.Tab("Render"):
+        with gr.Tab("Projects"):
+            project_name = gr.Textbox(label="Project name", value="Untitled Ava2lon Project")
+            project_metadata = gr.Textbox(label="Metadata JSON", lines=5, value=json.dumps({"platform": "tiktok"}, indent=2))
+            project_create = gr.Button("Create Project", variant="primary")
+            project_list = gr.Button("Refresh Projects")
+            project_output = gr.JSON(label="Projects")
+            project_create.click(fn=_create_project, inputs=[project_name, project_metadata], outputs=project_output)
+            project_list.click(fn=_list_projects, outputs=project_output)
+
+        with gr.Tab("Assets"):
+            gr.Markdown("Use `/upload` or `/assets/upload` for multipart assets, then attach them to a project with `/project/assets/add`.")
+            asset_project_id = gr.Textbox(label="Project ID")
+            asset_json = gr.Textbox(label="Asset JSON", lines=6, value=json.dumps({"path": "clip.mp4", "kind": "video"}, indent=2))
+            asset_button = gr.Button("Attach Asset", variant="primary")
+            asset_output = gr.JSON(label="Project")
+            asset_button.click(fn=_add_project_asset, inputs=[asset_project_id, asset_json], outputs=asset_output)
+
+        with gr.Tab("Timeline"):
+            timeline_project_id = gr.Textbox(label="Project ID")
+            timeline_track_type = gr.Dropdown(choices=["video", "audio", "text", "overlay", "sticker", "subtitle"], value="video", label="Track type")
+            timeline_item = gr.Textbox(
+                label="Timeline item JSON",
+                lines=8,
+                value=json.dumps({"media": "clip.mp4", "start": 0, "duration": 5, "caption": "Hook"}, indent=2),
+            )
+            timeline_add_button = gr.Button("Add To Timeline", variant="primary")
+            timeline_output = gr.JSON(label="Project")
+            timeline_add_button.click(fn=_timeline_add, inputs=[timeline_project_id, timeline_track_type, timeline_item], outputs=timeline_output)
+
+            timeline_operation_json = gr.Textbox(
+                label="Operation JSON",
+                lines=8,
+                value=json.dumps({"operation": "split", "item_id": "clip_123", "params": {"offset": 2.5}}, indent=2),
+            )
+            timeline_operation_button = gr.Button("Apply Operation")
+            timeline_operation_button.click(fn=_timeline_operation, inputs=[timeline_project_id, timeline_operation_json], outputs=timeline_output)
+
+        with gr.Tab("Templates"):
+            template_button = gr.Button("Load Template Catalog")
+            template_output = gr.JSON(label="Templates")
+            template_button.click(fn=lambda: _catalog_section("templates"), outputs=template_output)
+
+        with gr.Tab("Effects"):
+            effect_button = gr.Button("Load Effect Catalog")
+            effect_output = gr.JSON(label="Effects")
+            effect_button.click(fn=lambda: _catalog_section("effects"), outputs=effect_output)
+
+        with gr.Tab("Filters"):
+            filter_button = gr.Button("Load Filter Catalog")
+            filter_output = gr.JSON(label="Filters")
+            filter_button.click(fn=lambda: _catalog_section("filters"), outputs=filter_output)
+
+        with gr.Tab("Captions"):
+            caption_text = gr.Textbox(label="Caption source text", lines=6)
+            caption_button = gr.Button("Submit Caption Job", variant="primary")
+            caption_output = gr.JSON(label="Caption Job")
+            caption_button.click(fn=_submit_caption_generation, inputs=caption_text, outputs=caption_output)
+
+        with gr.Tab("Audio"):
+            audio_button = gr.Button("Load Audio Catalog")
+            audio_output = gr.JSON(label="Audio")
+            audio_button.click(fn=lambda: {"audio": capability_catalog()["audio"], "music": capability_catalog()["music_generator"]}, outputs=audio_output)
+
+        with gr.Tab("AI Tools"):
+            ai_tool = gr.Dropdown(choices=capability_catalog()["ai_editing"], value="auto_viral_score", label="AI tool")
+            ai_payload = gr.Textbox(label="AI payload JSON", lines=8, value=json.dumps({"platform": "tiktok", "text": "A strong opening hook"}, indent=2))
+            ai_button = gr.Button("Submit AI Tool", variant="primary")
+            ai_output = gr.JSON(label="AI Job")
+            ai_button.click(fn=_submit_ai_tool, inputs=[ai_tool, ai_payload], outputs=ai_output)
+
+        with gr.Tab("Rendering"):
             render_json = gr.Textbox(
                 label="Render JSON",
                 lines=14,
@@ -123,6 +194,11 @@ def create_dashboard() -> gr.Blocks:
             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("Settings"):
+            settings_button = gr.Button("Load Settings")
+            settings_output = gr.JSON(label="Settings")
+            settings_button.click(fn=_settings_payload, outputs=settings_output)
+
         with gr.Tab("Queue Monitor"):
             queue_button = gr.Button("Refresh Queue")
             queue_output = gr.JSON(label="Queue")
@@ -138,6 +214,55 @@ def _submit_render_json(payload: str) -> dict[str, Any]:
     return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
 
 
+def _create_project(name: str, metadata_json: str) -> dict[str, Any]:
+    metadata = json.loads(metadata_json or "{}")
+    return {"project": project_manager.create(name, metadata=metadata)}
+
+
+def _list_projects() -> dict[str, Any]:
+    return {"projects": project_manager.list()}
+
+
+def _add_project_asset(project_id: str, asset_json: str) -> dict[str, Any]:
+    return {"project": project_manager.add_asset(project_id, json.loads(asset_json or "{}"))}
+
+
+def _timeline_add(project_id: str, track_type: str, item_json: str) -> dict[str, Any]:
+    return {"project": project_manager.add_to_timeline(project_id, json.loads(item_json or "{}"), track_type=track_type)}
+
+
+def _timeline_operation(project_id: str, operation_json: str) -> dict[str, Any]:
+    data = json.loads(operation_json or "{}")
+    return {
+        "project": project_manager.timeline_operation(
+            project_id,
+            data.get("operation", "drag"),
+            item_id=data.get("item_id"),
+            params=data.get("params", {}),
+        )
+    }
+
+
+def _catalog_section(section: str) -> dict[str, Any]:
+    catalog = capability_catalog()
+    return {section: catalog.get(section)}
+
+
+def _submit_caption_generation(text: str) -> dict[str, Any]:
+    from renderer.studio import StudioTaskProcessor
+
+    job_id = job_manager.submit_task(lambda task_id, log: StudioTaskProcessor(settings, log=log).caption_generate({"text": text}, task_id))
+    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
+
+
+def _submit_ai_tool(tool: str, payload: str) -> dict[str, Any]:
+    from renderer.studio import StudioTaskProcessor
+
+    data = json.loads(payload or "{}")
+    job_id = job_manager.submit_task(lambda task_id, log: StudioTaskProcessor(settings, log=log).ai_tool(tool, data, task_id))
+    return {"job_id": job_id, "status": f"/status/{job_id}", "download": f"/download/{job_id}"}
+
+
 def _submit_batch_json(payload: str) -> dict[str, Any]:
     data = json.loads(payload)
     requests = [Timeline.request_from_payload(apply_creative_style(apply_preset(job))) for job in data.get("jobs", [])]
@@ -230,6 +355,20 @@ def _queue_status() -> dict[str, Any]:
     return job_manager.summary()
 
 
+def _settings_payload() -> dict[str, Any]:
+    return {
+        "product": "Ava2lon Studio AI",
+        "base_dir": str(settings.base_dir),
+        "temp_dir": str(settings.temp_dir),
+        "exports_dir": str(settings.exports_dir),
+        "storage_dir": str(settings.storage_dir),
+        "max_workers": settings.max_workers,
+        "whisper_model_size": settings.whisper_model_size,
+        "whisper_device": settings.whisper_device,
+        "capabilities": capability_catalog()["principles"],
+    }
+
+
 app = gr.mount_gradio_app(api, create_dashboard(), path="/dashboard")
 
 

requirements.txt

@@ -1,6 +1,7 @@
 fastapi>=0.115.0
 uvicorn[standard]>=0.30.0
 gradio>=5.0.0
+huggingface_hub<1.0
 pydantic>=2.7.0
 python-multipart>=0.0.9
 psutil>=5.9.8