@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/davinci-resolve-mcp/tests/live_script_smoke.py

@@ -1,141 +0,0 @@
-"""Live Resolve smoke test for v2.5.0 script_plugin authoring.
-
-Installs a media_rules script in Workspace → Scripts → Edit, plus a scaffold
-in Utility (Lua and Python flavors), and reports that the install paths
-exist on disk. Resolve does NOT need to be restarted — the menu refreshes
-each time it's opened.
-
-Cleans up regardless of pass/fail.
-"""
-
-import os
-import subprocess
-import sys
-import time
-
-PROJECT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, PROJECT)
-
-# Stub MCP imports so we can use src.server functions without spinning up the
-# full MCP server.
-import types
-
-class _FastMCP:
-    def __init__(self, *a, **k): pass
-    def tool(self, *a, **k):
-        def deco(fn): return fn
-        return deco
-    def resource(self, *a, **k):
-        def deco(fn): return fn
-        return deco
-
-mcp_mod = types.ModuleType("mcp")
-sub = types.ModuleType("mcp.server")
-fast = types.ModuleType("mcp.server.fastmcp")
-stdio = types.ModuleType("mcp.server.stdio")
-fast.FastMCP = _FastMCP
-stdio.stdio_server = lambda *a, **k: None
-anyio = types.ModuleType("anyio")
-anyio.run = lambda f: f()
-sys.modules.setdefault("anyio", anyio)
-sys.modules.setdefault("mcp", mcp_mod)
-sys.modules.setdefault("mcp.server", sub)
-sys.modules.setdefault("mcp.server.fastmcp", fast)
-sys.modules.setdefault("mcp.server.stdio", stdio)
-
-from src.utils.platform import get_resolve_paths  # noqa: E402
-
-paths = get_resolve_paths()
-os.environ["RESOLVE_SCRIPT_API"] = paths["api_path"]
-os.environ["RESOLVE_SCRIPT_LIB"] = paths["lib_path"]
-sys.path.insert(0, paths["modules_path"])
-
-import DaVinciResolveScript as dvr_script  # noqa: E402
-from src.server import script_plugin  # noqa: E402
-
-
-SCRIPTS_TO_INSTALL = [
-    # (name, kind, category, language, options)
-    ("McpLiveRulesLua",     "media_rules", "Edit",    "lua", None),
-    ("McpLiveRulesPy",      "media_rules", "Edit",    "py",  None),
-    ("McpLiveScaffoldLua",  "scaffold",    "Utility", "lua", None),
-    ("McpLiveScaffoldPy",   "scaffold",    "Utility", "py",  None),
-]
-
-
-def main():
-    installed = []
-    print(f"=== Installing {len(SCRIPTS_TO_INSTALL)} scripts ===")
-    for name, kind, category, language, options in SCRIPTS_TO_INSTALL:
-        opts = dict(options or {})
-        opts["language"] = language
-        gen = script_plugin('template', {
-            'kind': kind, 'name': name, 'options': opts,
-        })
-        if 'error' in gen:
-            print(f"  [GEN FAIL] {name}: {gen['error']}")
-            continue
-        r = script_plugin('install', {
-            'name': name, 'source': gen['source'],
-            'category': category, 'language': language, 'overwrite': True,
-        })
-        if 'error' in r:
-            print(f"  [INSTALL FAIL] {name}: {r['error']}")
-            continue
-        installed.append((name, category, language, r['path']))
-        size = os.path.getsize(r['path'])
-        print(f"  [OK] {name:25s} → {category}/  ({language}, {size} bytes)")
-
-    print()
-    print("=== Verify scripts are visible to Resolve ===")
-    print("Scripts live at:")
-    for name, category, language, path in installed:
-        print(f"  {path}")
-    print()
-    print("Resolve picks these up without a restart. To verify:")
-    print("  1. Launch Resolve (or it can already be running)")
-    print("  2. Open any project")
-    print("  3. Check Workspace → Scripts → Edit       (should show "
-          "McpLiveRulesLua, McpLiveRulesPy)")
-    print("     and Workspace → Scripts → Utility    (should show "
-          "McpLiveScaffoldLua, McpLiveScaffoldPy)")
-    print()
-    print("Optional: open Console (Workspace → Console → Lua tab) and click any")
-    print("of the McpLive* scripts in the menu — it should run without errors")
-    print("(media_rules runs against your current project in DRY-RUN mode by")
-    print("default, scaffold just prints version info).")
-    print()
-
-    # Try to also confirm via Resolve API that the installation succeeded —
-    # but only if Resolve is already running. Do NOT auto-launch.
-    cand = dvr_script.scriptapp("Resolve")
-    if cand is not None:
-        try:
-            ver = cand.GetVersion()
-            if ver:
-                print(f"=== Resolve is running ({cand.GetVersionString()}) ===")
-                print("Files exist on disk; ready for you to inspect the menu.")
-        except Exception:
-            pass
-
-    # Cleanup prompt
-    print()
-    print("Press ENTER once you've confirmed (or just want to clean up)...")
-    try:
-        input()
-    except (KeyboardInterrupt, EOFError):
-        print()
-
-    print("=== Cleanup ===")
-    for name, category, language, path in installed:
-        r = script_plugin('remove', {
-            'name': name, 'category': category, 'language': language,
-        })
-        if r.get('success'):
-            print(f"  removed: {name}.{language}")
-        else:
-            print(f"  WARN remove failed: {name}.{language} — {r}")
-
-
-if __name__ == "__main__":
-    main()

package/mcps/davinci-resolve-mcp/tests/live_sync_event_validation.py

@@ -1,165 +0,0 @@
-"""Live validation for sync-event detection and confirmed marker writes.
-
-Creates a disposable Resolve project, imports synthetic audio with a 2-pop and
-slate clap, verifies source-safe detection, verifies marker writes are refused
-without confirmation, then confirms Media Pool item marker creation.
-
-Run with:
-  venv/bin/python tests/live_sync_event_validation.py
-"""
-
-from __future__ import annotations
-
-import asyncio
-import math
-import os
-import shutil
-import struct
-import sys
-import tempfile
-import time
-import wave
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-HERE = Path(__file__).resolve().parent
-ROOT = HERE.parent
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-
-def _ok(label: str, condition: bool, detail: Any = None) -> bool:
-    status = "PASS" if condition else "FAIL"
-    suffix = f" — {detail}" if detail is not None else ""
-    print(f"  [{status}] {label}{suffix}")
-    return condition
-
-
-def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
-    if not isinstance(result, dict) or result.get("success") is not True:
-        raise AssertionError(f"{label} failed: {result!r}")
-    print(f"  [PASS] {label}")
-    return result
-
-
-def _write_sync_fixture(path: Path, sample_rate: int = 16000) -> None:
-    duration_seconds = 6.0
-    samples = [0.0] * int(sample_rate * duration_seconds)
-
-    pop_start = int(2.0 * sample_rate)
-    pop_length = int((1.0 / 24.0) * sample_rate)
-    for index in range(pop_length):
-        samples[pop_start + index] = 0.75 * math.sin(2.0 * math.pi * 1000.0 * (index / sample_rate))
-
-    clap_start = int(4.0 * sample_rate)
-    samples[clap_start] = 0.95
-    samples[clap_start + 1] = -0.85
-    samples[clap_start + 3] = 0.55
-
-    with wave.open(str(path), "wb") as handle:
-        handle.setnchannels(1)
-        handle.setsampwidth(2)
-        handle.setframerate(sample_rate)
-        frames = bytearray()
-        for sample in samples:
-            clipped = max(-1.0, min(1.0, sample))
-            frames.extend(struct.pack("<h", int(clipped * 32767)))
-        handle.writeframes(bytes(frames))
-
-
-def _cleanup_project(server, project_name: str) -> Dict[str, Any]:
-    resolve = server.get_resolve()
-    if not resolve:
-        return {"success": False, "error": "Resolve unavailable during cleanup"}
-    pm = resolve.GetProjectManager()
-    project = pm.GetCurrentProject()
-    if project:
-        try:
-            pm.CloseProject(project)
-        except Exception:
-            pass
-    return {"success": bool(pm.DeleteProject(project_name))}
-
-
-async def main_async() -> int:
-    import src.server as server
-
-    print("=" * 72)
-    print("Sync event live validation")
-    print("=" * 72)
-
-    version = server.resolve_control("get_version")
-    if "error" in version:
-        print(f"FATAL: {version['error']}")
-        return 2
-    print(f"Connected to {version.get('product')} {version.get('version_string')}")
-
-    project_name = f"_mcp_sync_event_validation_{int(time.time())}"
-    work_dir = Path(tempfile.mkdtemp(prefix="mcp_sync_event_validation_"))
-    created_project = False
-    try:
-        _require_success("project_manager.create", server.project_manager("create", {"name": project_name}))
-        created_project = True
-        print(f"Created disposable project: {project_name}")
-
-        source = work_dir / "sync_event_fixture.wav"
-        _write_sync_fixture(source)
-        print(f"Generated synthetic audio under: {work_dir}")
-
-        imported = server.media_pool("import_media", {"paths": [str(source)]})
-        if imported.get("imported") != 1:
-            raise AssertionError(f"media_pool.import_media failed: {imported!r}")
-        print("  [PASS] media_pool.import_media")
-
-        clips = server.folder("get_clips").get("clips") or []
-        clip_ids: List[str] = [clip.get("id") for clip in clips if clip.get("name") == source.name and clip.get("id")]
-        if len(clip_ids) != 1:
-            raise AssertionError(f"expected imported clip id, got {clips!r}")
-        clip_id = clip_ids[0]
-        print("  [PASS] folder.get_clips returned imported clip id")
-
-        detection = await server.media_analysis(
-            "detect_sync_events",
-            {
-                "target": {"type": "clip", "clip_id": clip_id},
-                "fps": 24,
-                "scan_start_seconds": 6,
-                "scan_tail_seconds": 0,
-            },
-        )
-        _require_success("media_analysis.detect_sync_events", detection)
-        events = (detection.get("files") or [{}])[0].get("events") or []
-        suggestions = (detection.get("files") or [{}])[0].get("marker_suggestions") or []
-        checks = [
-            _ok("detected a 2-pop", any(event.get("type") == "two_pop" for event in events), events),
-            _ok("detected a slate clap", any(event.get("type") == "slate_clap" for event in events), events),
-            _ok("returned marker suggestions", bool(suggestions), suggestions),
-            _ok("marker suggestions require confirmation", all(s.get("requires_confirmation") for s in suggestions), suggestions),
-        ]
-
-        preview = await server.media_analysis("add_sync_event_markers", {"detection": detection})
-        checks.append(_ok("marker write refused without confirmation", preview.get("confirmation_required") is True, preview))
-
-        applied = await server.media_analysis("add_sync_event_markers", {"detection": detection, "confirm": True})
-        _require_success("media_analysis.add_sync_event_markers confirmed", applied)
-        markers = server.media_pool_item_markers("get_all", {"clip_id": clip_id}).get("markers") or {}
-        checks.extend([
-            _ok("confirmed marker write added markers", applied.get("added", 0) >= 1, applied),
-            _ok("media pool clip has markers", bool(markers), markers),
-        ])
-        return 0 if all(checks) else 1
-    except Exception as exc:
-        print(f"FATAL: {exc}")
-        return 2
-    finally:
-        if created_project:
-            cleanup = _cleanup_project(server, project_name)
-            print(f"Cleanup project: {cleanup!r}")
-        shutil.rmtree(work_dir, ignore_errors=True)
-        print(f"Removed synthetic media directory: {work_dir}")
-
-
-if __name__ == "__main__":
-    raise SystemExit(asyncio.run(main_async()))
-

package/mcps/davinci-resolve-mcp/tests/live_timeline_conform_validation.py

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-"""Run the live Timeline Conform / Interchange kernel probe."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-import tempfile
-import types
-from pathlib import Path
-
-
-def _install_mcp_stubs() -> None:
-    class FastMCP:
-        def __init__(self, *args, **kwargs):
-            pass
-
-        def tool(self, *args, **kwargs):
-            def decorate(func):
-                return func
-
-            return decorate
-
-        def resource(self, *args, **kwargs):
-            def decorate(func):
-                return func
-
-            return decorate
-
-    def stdio_server(*args, **kwargs):
-        raise RuntimeError("stdio_server is not used by the live timeline conform probe")
-
-    anyio = types.ModuleType("anyio")
-    anyio.run = lambda func: func()
-
-    mcp = types.ModuleType("mcp")
-    server = types.ModuleType("mcp.server")
-    fastmcp = types.ModuleType("mcp.server.fastmcp")
-    stdio = types.ModuleType("mcp.server.stdio")
-
-    fastmcp.FastMCP = FastMCP
-    stdio.stdio_server = stdio_server
-
-    sys.modules.setdefault("anyio", anyio)
-    sys.modules.setdefault("mcp", mcp)
-    sys.modules.setdefault("mcp.server", server)
-    sys.modules.setdefault("mcp.server.fastmcp", fastmcp)
-    sys.modules.setdefault("mcp.server.stdio", stdio)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--output-dir", type=Path, default=None)
-    parser.add_argument("--keep-open", action="store_true")
-    args = parser.parse_args()
-
-    _install_mcp_stubs()
-    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-    original_argv = sys.argv[:]
-    sys.argv = [sys.argv[0]]
-    try:
-        import src.server as server  # noqa: WPS433
-    finally:
-        sys.argv = original_argv
-
-    from src.utils.timeline_conform_live_probe import run_probe  # noqa: WPS433
-
-    output_dir = args.output_dir or Path(tempfile.mkdtemp(prefix="timeline-conform-probe-report_"))
-    report = run_probe(server, output_dir, keep_open=args.keep_open)
-    if report["counts"].get("error", 0):
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/mcps/davinci-resolve-mcp/tests/live_v233_validation.py

@@ -1,282 +0,0 @@
-"""Live validation harness for v2.3.3 granular-layer changes.
-
-Imports the granular tool functions directly and calls them against a live
-DaVinci Resolve. Reports pass/fail for each new or changed tool.
-
-Run with: venv/bin/python tests/live_v233_validation.py
-
-Tools validated:
-  - granular.media_pool.append_to_timeline (both clip_ids and clip_infos forms)
-  - granular.media_pool.auto_sync_audio (with audio sync settings dict)
-  - granular.media_pool.import_media (clip_infos image-sequence form)
-  - granular.timeline.timeline_create_compound_clip (with info dict)
-  - granular.project.rename_color_group
-  - granular.project.render_with_quick_export (params dict accepted)
-  - granular.project.create_cloud_project_tool (skipped — needs cloud account)
-  - granular.project.load_cloud_project_tool (skipped — needs cloud account)
-
-Skips: cloud project tools, anything that needs network/cloud account.
-Runs against the currently-open Resolve project (creates a disposable
-project for isolation).
-"""
-
-import os
-import subprocess
-import sys
-import tempfile
-import time
-
-# Ensure src/ is on the path
-HERE = os.path.dirname(os.path.abspath(__file__))
-ROOT = os.path.dirname(HERE)
-if ROOT not in sys.path:
-    sys.path.insert(0, ROOT)
-
-
-def make_synthetic_media(work_dir):
-    """Generate a few synthetic .mov files via ffmpeg. Returns list of paths."""
-    paths = []
-    for i, color in enumerate(("red", "blue", "green"), start=1):
-        path = os.path.join(work_dir, f"v233_synthetic_{color}.mov")
-        subprocess.run([
-            "ffmpeg", "-hide_banner", "-loglevel", "error",
-            "-f", "lavfi", "-i", f"color=c={color}:s=320x240:d=2:r=24",
-            "-y", path,
-        ], check=True)
-        paths.append(path)
-    # Image sequence for clip_infos image-sequence test
-    seq_dir = os.path.join(work_dir, "seq")
-    os.makedirs(seq_dir, exist_ok=True)
-    for i in range(1, 4):
-        path = os.path.join(seq_dir, f"frame_{i:03d}.png")
-        subprocess.run([
-            "ffmpeg", "-hide_banner", "-loglevel", "error",
-            "-f", "lavfi", "-i", "color=c=red:s=160x120:d=1:r=24",
-            "-frames:v", "1", "-y", path,
-        ], check=True)
-    return paths, os.path.join(seq_dir, "frame_%03d.png")
-
-
-def report(name, ok, detail=""):
-    status = "PASS" if ok else "FAIL"
-    line = f"  [{status}] {name}"
-    if detail:
-        line += f" — {detail}"
-    print(line)
-    return ok
-
-
-def main():
-    # Late imports so the script can also be syntax-checked without Resolve
-    from src.granular.common import get_resolve, _get_mp, _find_clip_by_id  # noqa: F401
-    from src.granular import media_pool as gmp
-    from src.granular import timeline as gtl
-    from src.granular import project as gprj
-
-    print("=" * 70)
-    print("v2.3.3 live validation harness")
-    print("=" * 70)
-
-    r = get_resolve()
-    if r is None:
-        print("FATAL: cannot connect to DaVinci Resolve. Is it running?")
-        return 2
-    print(f"Connected to Resolve {'.'.join(str(x) for x in r.GetVersion()[:4])}")
-
-    pm = r.GetProjectManager()
-    project_name = f"v233_validation_{int(time.time())}"
-    if not pm.CreateProject(project_name):
-        print(f"FATAL: failed to create disposable project '{project_name}'")
-        return 2
-    print(f"Created disposable project: {project_name}")
-
-    work_dir = tempfile.mkdtemp(prefix="v233_validation_")
-    print(f"Synthetic media in: {work_dir}")
-
-    try:
-        clip_paths, seq_path = make_synthetic_media(work_dir)
-
-        # Import the synthetic clips via the documented direct API
-        proj = pm.GetCurrentProject()
-        mp = proj.GetMediaPool()
-        imported = mp.ImportMedia(clip_paths)
-        if not imported or len(imported) != 3:
-            print("FATAL: failed to import synthetic media")
-            return 2
-        clip_a, clip_b, clip_c = imported
-        clip_a_id = clip_a.GetUniqueId()
-        clip_b_id = clip_b.GetUniqueId()
-        print(f"Imported 3 clips. Sample id: {clip_a_id}")
-
-        # Create a timeline to append into
-        tl = mp.CreateEmptyTimeline("v233_test_timeline")
-        if not tl:
-            print("FATAL: failed to create timeline")
-            return 2
-
-        results = []
-
-        # ─── append_to_timeline (granular) — simple form ───
-        out = gmp.append_to_timeline(clip_ids=[clip_a_id])
-        results.append(report(
-            "granular.append_to_timeline (simple clip_ids)",
-            out.get("success") is True and out.get("count") == 1,
-            f"got {out!r}",
-        ))
-
-        # ─── append_to_timeline (granular) — positioned form ───
-        out = gmp.append_to_timeline(clip_infos=[{
-            "clip_id": clip_b_id, "start_frame": 0, "end_frame": 23,
-            "record_frame": 100, "track_index": 1,
-        }])
-        results.append(report(
-            "granular.append_to_timeline (positioned clip_infos)",
-            out.get("success") is True
-                and out.get("count") == 1
-                and isinstance(out.get("items"), list)
-                and out["items"][0].get("timeline_item_id"),
-            f"items={out.get('items')}",
-        ))
-
-        # ─── append_to_timeline (granular) — failure path ───
-        out = gmp.append_to_timeline(clip_infos=[{"clip_id": clip_b_id, "start_frame": 0}])
-        results.append(report(
-            "granular.append_to_timeline failure path returns clean error",
-            "error" in out,
-            f"got {out!r}",
-        ))
-
-        # ─── auto_sync_audio (granular) ───
-        out = gmp.auto_sync_audio(
-            clip_ids=[clip_a_id, clip_b_id],
-            sync_mode="timecode",
-            retain_video_metadata=True,
-        )
-        # Resolve may legitimately return False if clips have no audio to sync;
-        # we just want the call to not crash and to forward the dict.
-        results.append(report(
-            "granular.auto_sync_audio (settings dict mapping)",
-            isinstance(out, dict) and "success" in out,
-            f"got {out!r}",
-        ))
-
-        # ─── auto_sync_audio failure path ───
-        out = gmp.auto_sync_audio(clip_ids=[clip_a_id], sync_mode="zerocross")
-        results.append(report(
-            "granular.auto_sync_audio rejects invalid sync_mode",
-            "error" in out and "Unknown sync_mode" in out["error"],
-            f"got {out!r}",
-        ))
-
-        # ─── import_media (granular) — image sequence ───
-        out = gmp.import_media(clip_infos=[{
-            "FilePath": seq_path, "StartIndex": 1, "EndIndex": 3,
-        }])
-        results.append(report(
-            "granular.import_media (image-sequence clip_infos)",
-            out.get("success") is True and out.get("imported") == 1,
-            f"got {out!r}",
-        ))
-
-        # ─── timeline_create_compound_clip (granular) — with info dict ───
-        # Need a fresh timeline item to compound; use the one we appended.
-        # Set current timeline so granular tools can find it.
-        proj.SetCurrentTimeline(tl)
-        items_on_track = tl.GetItemListInTrack("video", 1) or []
-        if items_on_track:
-            target_id = items_on_track[0].GetUniqueId()
-            out = gtl.timeline_create_compound_clip(
-                clip_ids=[target_id], track_type="video", track_index=1,
-                name="v233_compound_test", start_timecode="01:00:00:00",
-            )
-            # Compound creation requires multiple selected items, so this may
-            # return success=False even when the dict is forwarded correctly.
-            # Verify forwarding by checking shape, not necessarily success=True.
-            results.append(report(
-                "granular.timeline_create_compound_clip (info dict accepted)",
-                isinstance(out, dict) and ("success" in out or "error" in out),
-                f"got {out!r}",
-            ))
-        else:
-            results.append(report(
-                "granular.timeline_create_compound_clip (info dict accepted)",
-                False, "no items to compound",
-            ))
-
-        # ─── rename_color_group (granular) ───
-        # Create a color group, then rename it.
-        cg = proj.AddColorGroup("v233_group_initial")
-        if cg:
-            out = gprj.rename_color_group(group_name="v233_group_initial",
-                                          new_name="v233_group_renamed")
-            results.append(report(
-                "granular.rename_color_group",
-                out.get("success") is True,
-                f"got {out!r}",
-            ))
-            # Cleanup color group
-            proj.DeleteColorGroup(cg)
-        else:
-            results.append(report(
-                "granular.rename_color_group",
-                False, "failed to create test color group",
-            ))
-
-        # ─── render_with_quick_export (granular) — verify dict forwarding ───
-        # Don't actually start a render; just verify the call shape forwards
-        # the params dict. We use an obviously-bogus preset name so Resolve
-        # rejects it without rendering, but the dict path is still exercised.
-        out = gprj.render_with_quick_export(
-            preset_name="__v233_nonexistent_preset__",
-            target_dir=work_dir,
-            custom_name="v233_test",
-            video_quality=0,
-            enable_upload=False,
-        )
-        results.append(report(
-            "granular.render_with_quick_export (params dict accepted)",
-            isinstance(out, dict) and "preset_name" in out,
-            f"got {out!r}",
-        ))
-
-        # ─── compound: get_items_in_track — verifies deprecated→supported fix ───
-        # Already on the loaded MCP server, but we can directly verify the
-        # call itself returns items via GetItemListInTrack.
-        items = tl.GetItemListInTrack("video", 1)
-        results.append(report(
-            "compound: GetItemListInTrack (replaces deprecated GetItemsInTrack)",
-            items is not None,
-            f"got {len(items) if items else 0} items",
-        ))
-
-        # ─── Summary ───
-        print()
-        print("=" * 70)
-        passed = sum(1 for r in results if r)
-        total = len(results)
-        print(f"v2.3.3 live validation: {passed}/{total} passed")
-        print("=" * 70)
-        return 0 if passed == total else 1
-
-    finally:
-        # Cleanup: switch to a different project, then delete the disposable
-        try:
-            projects = pm.GetProjectListInCurrentFolder() or []
-            other = next((p for p in projects if p != project_name), None)
-            if other:
-                pm.LoadProject(other)
-            pm.DeleteProject(project_name)
-            print(f"Cleaned up disposable project: {project_name}")
-        except Exception as exc:
-            print(f"WARN: cleanup failed (delete '{project_name}' manually): {exc}")
-        # Cleanup temp media
-        try:
-            import shutil
-            shutil.rmtree(work_dir)
-            print(f"Cleaned up temp media: {work_dir}")
-        except Exception as exc:
-            print(f"WARN: temp media cleanup failed: {exc}")
-
-
-if __name__ == "__main__":
-    sys.exit(main())