@hybridlabor-api/aos 4.4.0 → 4.4.2-beta.0

package/mcps/davinci-resolve-mcp/src/utils/render_deliver_live_probe.py

@@ -1,384 +0,0 @@
-#!/usr/bin/env python3
-"""Live Render / Deliver boundary probe.
-
-Creates a disposable Resolve project with generated synthetic media, probes
-render format/codec/settings/job/quick-export surfaces, writes JSON/Markdown
-evidence reports, deletes the project, and removes generated media/render
-outputs.
-"""
-
-from __future__ import annotations
-
-import json
-import platform
-import shutil
-import subprocess
-import sys
-import tempfile
-import time
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
-
-
-def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
-    if not isinstance(result, dict):
-        raise AssertionError(f"{label}: expected dict, got {result!r}")
-    if result.get("error"):
-        raise AssertionError(f"{label}: {result['error']}")
-    if "success" in result and result["success"] is not True:
-        raise AssertionError(f"{label}: expected success=True, got {result!r}")
-    return result
-
-
-def _record_tool_result(
-    recorder: ProbeRecorder,
-    category: str,
-    name: str,
-    result: Dict[str, Any],
-    *,
-    partial_on_false: bool = True,
-) -> None:
-    if not isinstance(result, dict):
-        recorder.record(category, name, "error", details={"reason": "non-dict result", "result": repr(result)})
-        return
-    if result.get("error"):
-        recorder.record(category, name, "error", details={"reason": result.get("error")}, evidence=result)
-        return
-    if "success" in result and result["success"] is not True:
-        recorder.record(
-            category,
-            name,
-            "partially_supported" if partial_on_false else "unsupported",
-            details={"reason": "success returned false"},
-            evidence=result,
-        )
-        return
-    recorder.record(category, name, "supported", evidence=result)
-
-
-def _run_ffmpeg(args: list[str]) -> None:
-    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True, timeout=120)
-
-
-def _make_synthetic_video(work_dir: Path) -> Path:
-    video = work_dir / "render_probe_source.mov"
-    _run_ffmpeg(
-        [
-            "-f",
-            "lavfi",
-            "-i",
-            "testsrc2=size=320x180:rate=24:duration=2",
-            "-f",
-            "lavfi",
-            "-i",
-            "sine=frequency=880:sample_rate=48000:duration=2",
-            "-shortest",
-            "-pix_fmt",
-            "yuv420p",
-            "-c:v",
-            "libx264",
-            "-c:a",
-            "aac",
-            "-y",
-            str(video),
-        ]
-    )
-    return video
-
-
-def _first_imported_clip(imported_items):
-    for item in imported_items or []:
-        try:
-            if item.GetUniqueId():
-                return item
-        except Exception:
-            pass
-    return None
-
-
-def _choose_render_format_codec(server) -> Dict[str, Optional[str]]:
-    formats_result = server.render("get_formats")
-    formats = formats_result.get("formats") if isinstance(formats_result, dict) else {}
-    if not isinstance(formats, dict) or not formats:
-        return {"format": None, "codec": None, "label": None}
-
-    preferred_formats = ["mp4", "QuickTime"]
-    format_names = [fmt for fmt in preferred_formats if fmt in formats]
-    format_names.extend([fmt for fmt in formats if fmt not in format_names])
-
-    for fmt in format_names:
-        codecs_result = server.render("get_codecs", {"format": fmt})
-        codecs = codecs_result.get("codecs") if isinstance(codecs_result, dict) else {}
-        if not isinstance(codecs, dict) or not codecs:
-            continue
-        preferred = []
-        for label, codec in codecs.items():
-            text = f"{label} {codec}".lower()
-            if "h.264" in text or "h264" in text:
-                preferred.insert(0, (label, codec))
-            else:
-                preferred.append((label, codec))
-        label, codec = preferred[0]
-        return {"format": fmt, "codec": codec, "label": label}
-    return {"format": None, "codec": None, "label": None}
-
-
-def _render_output_files(render_dir: Path):
-    if not render_dir.exists():
-        return []
-    return sorted(str(path) for path in render_dir.iterdir() if path.is_file())
-
-
-def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, Any]:
-    output_dir.mkdir(parents=True, exist_ok=True)
-    work_dir = Path(tempfile.mkdtemp(prefix="mcp_render_deliver_probe_"))
-    render_dir = output_dir / "renders"
-    render_dir.mkdir(parents=True, exist_ok=True)
-    project_name = f"_mcp_render_deliver_probe_{int(time.time())}"
-    timeline_name = "Render Deliver Probe Timeline"
-    preset_name = f"_mcp_render_probe_preset_{int(time.time())}"
-    recorder = ProbeRecorder()
-    created_project = False
-    delete_result: Optional[Dict[str, Any]] = None
-
-    metadata: Dict[str, Any] = {
-        "title": "Render Deliver Kernel Capability Probe",
-        "timestamp_utc": utc_timestamp(),
-        "python": sys.version,
-        "platform": platform.platform(),
-        "output_dir": str(output_dir),
-        "project_name": project_name,
-        "render_dir": str(render_dir),
-    }
-
-    try:
-        version = _require_success("resolve_control.get_version", server.resolve_control("get_version"))
-        metadata.update(
-            {
-                "product": version.get("product"),
-                "version": version.get("version"),
-                "version_string": version.get("version_string"),
-            }
-        )
-        print(f"Connected to {metadata['product']} {metadata['version_string']}")
-
-        _require_success("project_manager.create", server.project_manager("create", {"name": project_name}))
-        created_project = True
-        print(f"Created disposable project: {project_name}")
-        server.resolve_control("open_page", {"page": "edit"})
-
-        video = _make_synthetic_video(work_dir)
-        metadata["synthetic_media"] = {"video": str(video)}
-        print(f"Generated synthetic media under: {work_dir}")
-
-        resolve = server.get_resolve()
-        project = resolve.GetProjectManager().GetCurrentProject()
-        media_pool = project.GetMediaPool()
-        imported = media_pool.ImportMedia([str(video)]) or []
-        clip = _first_imported_clip(imported)
-        if not clip:
-            raise AssertionError("Failed to import synthetic render media")
-        timeline = media_pool.CreateTimelineFromClips(timeline_name, [clip])
-        if not timeline:
-            raise AssertionError("Failed to create synthetic render timeline")
-        project.SetCurrentTimeline(timeline)
-        print(f"Created timeline: {timeline_name}")
-
-        chosen = _choose_render_format_codec(server)
-        metadata["chosen_format_codec"] = chosen
-        render_settings = {
-            "TargetDir": str(render_dir),
-            "CustomName": "mcp_render_probe",
-            "SelectAllFrames": True,
-            "ExportVideo": True,
-            "ExportAudio": True,
-            "FormatWidth": 320,
-            "FormatHeight": 180,
-            "FrameRate": 24,
-            "VideoQuality": "Least",
-            "EnableUpload": False,
-        }
-        safe_settings = {key: value for key, value in render_settings.items() if key != "EnableUpload"}
-
-        _record_tool_result(recorder, "capabilities", "render_capabilities", server.render("render_capabilities"))
-        _record_tool_result(recorder, "matrix", "probe_render_matrix", server.render("probe_render_matrix"))
-        settings_snapshot = server.render("probe_render_settings")
-        _record_tool_result(recorder, "settings", "probe_render_settings", settings_snapshot)
-        if isinstance(settings_snapshot.get("settings"), dict) and settings_snapshot["settings"].get("error"):
-            recorder.record(
-                "settings",
-                "get_render_settings_readback",
-                "version_or_page_dependent",
-                details={"reason": settings_snapshot["settings"]["error"]},
-            )
-        if chosen["format"] and chosen["codec"]:
-            _record_tool_result(
-                recorder,
-                "format_codec",
-                "set_format_and_codec",
-                server.render(
-                    "set_format_and_codec",
-                    {"format": chosen["format"], "codec": chosen["codec"]},
-                ),
-            )
-            _record_tool_result(
-                recorder,
-                "format_codec",
-                "get_resolutions_chosen",
-                server.render("get_resolutions", {"format": chosen["format"], "codec": chosen["codec"]}),
-            )
-        else:
-            recorder.record("format_codec", "choose_format_codec", "unsupported", details={"reason": "No render codec available"})
-        _record_tool_result(
-            recorder,
-            "settings",
-            "validate_render_settings",
-            server.render(
-                "validate_render_settings",
-                {"settings": safe_settings, "require_temp_target": True},
-            ),
-        )
-        _record_tool_result(
-            recorder,
-            "settings",
-            "safe_set_render_settings",
-            server.render(
-                "safe_set_render_settings",
-                {"settings": safe_settings, "require_temp_target": True},
-            ),
-        )
-
-        _record_tool_result(recorder, "mode", "get_mode", server.render("get_mode"))
-        current_mode = server.render("get_mode").get("mode", 0)
-        _record_tool_result(recorder, "mode", "set_mode_restore", server.render("set_mode", {"mode": current_mode}))
-
-        _record_tool_result(recorder, "presets", "list_presets", server.render("list_presets"))
-        _record_tool_result(recorder, "presets", "save_preset", server.render("save_preset", {"name": preset_name}))
-        _record_tool_result(recorder, "presets", "delete_preset", server.render("delete_preset", {"name": preset_name}))
-
-        prepare_params = {
-            "target_dir": str(render_dir),
-            "settings": safe_settings,
-            "custom_name": "mcp_render_probe_prepare",
-            "dry_run": True,
-        }
-        if chosen["format"] and chosen["codec"]:
-            prepare_params.update({"format": chosen["format"], "codec": chosen["codec"]})
-        _record_tool_result(recorder, "jobs", "prepare_render_job_dry_run", server.render("prepare_render_job", prepare_params))
-
-        lifecycle_params = {
-            "target_dir": str(render_dir),
-            "settings": safe_settings,
-            "custom_name": "mcp_render_probe_lifecycle",
-        }
-        if chosen["format"] and chosen["codec"]:
-            lifecycle_params.update({"format": chosen["format"], "codec": chosen["codec"]})
-        _record_tool_result(
-            recorder,
-            "jobs",
-            "render_job_lifecycle_probe",
-            server.render("render_job_lifecycle_probe", lifecycle_params),
-        )
-
-        actual_params = {
-            "target_dir": str(render_dir),
-            "settings": {**safe_settings, "CustomName": "mcp_render_probe_actual"},
-            "custom_name": "mcp_render_probe_actual",
-        }
-        if chosen["format"] and chosen["codec"]:
-            actual_params.update({"format": chosen["format"], "codec": chosen["codec"]})
-        prepared = server.render("prepare_render_job", actual_params)
-        _record_tool_result(recorder, "jobs", "prepare_render_job", prepared)
-        job_id = prepared.get("job_id") if isinstance(prepared, dict) else None
-        if job_id:
-            _record_tool_result(recorder, "jobs", "get_job_status_before_start", server.render("get_job_status", {"job_id": job_id}))
-            start_result = server.render("start", {"job_ids": [job_id], "interactive": False})
-            _record_tool_result(recorder, "jobs", "start_rendering", start_result)
-            deadline = time.time() + 45
-            while time.time() < deadline:
-                rendering = server.render("is_rendering")
-                if not rendering.get("rendering"):
-                    break
-                time.sleep(1)
-            final_rendering = server.render("is_rendering")
-            if final_rendering.get("rendering"):
-                server.render("stop")
-                recorder.record(
-                    "jobs",
-                    "render_completion",
-                    "partially_supported",
-                    details={"reason": "Render exceeded 45 second probe timeout and was stopped"},
-                )
-            else:
-                files = _render_output_files(render_dir)
-                status = "supported" if files else "write_only_unverifiable"
-                recorder.record("jobs", "render_completion", status, evidence={"files": files})
-            _record_tool_result(recorder, "jobs", "get_job_status_after_start", server.render("get_job_status", {"job_id": job_id}))
-            _record_tool_result(recorder, "jobs", "delete_render_job", server.render("delete_job", {"job_id": job_id}))
-
-        quick_caps = server.render("quick_export_capabilities")
-        _record_tool_result(recorder, "quick_export", "quick_export_capabilities", quick_caps)
-        quick_presets = quick_caps.get("presets") if isinstance(quick_caps, dict) else []
-        if quick_presets:
-            preset = quick_presets[0] if isinstance(quick_presets[0], str) else quick_presets[0].get("Name")
-            _record_tool_result(
-                recorder,
-                "quick_export",
-                "safe_quick_export_dry_run",
-                server.render(
-                    "safe_quick_export",
-                    {
-                        "preset": preset,
-                        "target_dir": str(render_dir),
-                        "custom_name": "mcp_quick_export_probe",
-                        "dry_run": True,
-                    },
-                ),
-            )
-        else:
-            recorder.record("quick_export", "safe_quick_export_dry_run", "not_applicable", details={"reason": "No quick export presets"})
-
-        _record_tool_result(
-            recorder,
-            "report",
-            "export_render_boundary_report",
-            server.render("export_render_boundary_report", {"max_pairs": 20}),
-        )
-
-        if keep_open:
-            server.project_manager("save")
-            print(f"LEFT PROJECT OPEN FOR INSPECTION: {project_name}")
-            created_project = False
-
-    finally:
-        if created_project:
-            server.project_manager("save")
-            server.project_manager("close")
-            delete_result = server.project_manager("delete", {"name": project_name})
-            print(f"Deleted disposable project: {delete_result}")
-
-    report = recorder.to_report(
-        metadata,
-        {
-            "json": str(output_dir / "render-deliver-probe.json"),
-            "markdown": str(output_dir / "render-deliver-probe.md"),
-        },
-    )
-    json_path = output_dir / "render-deliver-probe.json"
-    markdown_path = output_dir / "render-deliver-probe.md"
-    json_path.write_text(json.dumps(report, indent=2, sort_keys=True), encoding="utf-8")
-    markdown_path.write_text(render_markdown_report(report), encoding="utf-8")
-    print(f"Wrote JSON report: {json_path}")
-    print(f"Wrote Markdown report: {markdown_path}")
-    print(f"Counts: {json.dumps(report['counts'], sort_keys=True)}")
-    if not keep_open:
-        shutil.rmtree(work_dir, ignore_errors=True)
-        shutil.rmtree(render_dir, ignore_errors=True)
-        print(f"Removed synthetic media directory: {work_dir}")
-        print(f"Removed render output directory: {render_dir}")
-
-    if delete_result and delete_result.get("success") is not True:
-        raise AssertionError(f"Cleanup failed for {project_name}: {delete_result!r}")
-    return report

package/mcps/davinci-resolve-mcp/src/utils/resolve_ai_governance.py

@@ -1,214 +0,0 @@
-"""Soft governance tiers for the Resolve 21 media-creating AI ops.
-
-The two media-creating ops (`remove_motion_blur`, `generate_speech`) render new
-files on Resolve's GPU/AI engine. They are already confirm-token gated, so
-governance here is intentionally **advisory**: it reads the AI-ops ledger for the
-current session and reports how the *next* run sits against a named tier's soft
-thresholds. The result is surfaced in the confirm preview and the control panel —
-it never hard-blocks (the analysis-caps layer meters Claude tokens; this is a
-different, local concern).
-
-Tiers (per session):
-
-| dimension                 | off  | lenient | standard | strict |
-|---------------------------|-----:|--------:|---------:|-------:|
-| deblur_runs               | None | 50      | 15       | 5      |
-| speech_runs               | None | 50      | 15       | 5      |
-| render_bytes (new media)  | None | 50 GB   | 10 GB    | 2 GB   |
-| render_wall_clock_ms       | None | 1 h     | 20 min   | 5 min  |
-
-`standard` is the default. Only the render ops are governed; analysis ops
-(classify / IntelliSearch / slate / transcribe) are always within-tier.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Dict, List, Optional
-
-from src.utils import resolve_ai_ledger
-
-logger = logging.getLogger("resolve-mcp.resolve-ai-governance")
-
-TIER_OFF = "off"
-TIER_LENIENT = "lenient"
-TIER_STANDARD = "standard"
-TIER_STRICT = "strict"
-DEFAULT_TIER = TIER_STANDARD
-
-_GB = 1024 ** 3
-
-# dimension -> value (None = uncapped)
-TIERS: Dict[str, Dict[str, Optional[int]]] = {
-    TIER_OFF: {
-        "deblur_runs": None, "speech_runs": None,
-        "render_bytes": None, "render_wall_clock_ms": None,
-    },
-    TIER_LENIENT: {
-        "deblur_runs": 50, "speech_runs": 50,
-        "render_bytes": 50 * _GB, "render_wall_clock_ms": 60 * 60 * 1000,
-    },
-    TIER_STANDARD: {
-        "deblur_runs": 15, "speech_runs": 15,
-        "render_bytes": 10 * _GB, "render_wall_clock_ms": 20 * 60 * 1000,
-    },
-    TIER_STRICT: {
-        "deblur_runs": 5, "speech_runs": 5,
-        "render_bytes": 2 * _GB, "render_wall_clock_ms": 5 * 60 * 1000,
-    },
-}
-
-VALID_TIERS = frozenset(TIERS)
-
-_OVERRIDE_KEYS = frozenset({"deblur_runs", "speech_runs", "render_bytes", "render_wall_clock_ms"})
-
-# Which ledger op feeds which run-count dimension.
-_OP_RUN_DIM = {
-    "remove_motion_blur": "deblur_runs",
-    "generate_speech": "speech_runs",
-}
-
-GOVERNED_OPS = frozenset(_OP_RUN_DIM)
-
-
-def list_tiers() -> Dict[str, Dict[str, Optional[int]]]:
-    return {name: dict(vals) for name, vals in TIERS.items()}
-
-
-def resolve_tier(preset: Optional[str] = None, overrides: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """Return the effective thresholds dict for `preset` with `overrides` applied.
-
-    An override value of None / "unlimited" means uncapped on that dimension.
-    """
-    name = (preset or DEFAULT_TIER).strip().lower()
-    if name not in TIERS:
-        name = DEFAULT_TIER
-    effective = dict(TIERS[name])
-    if isinstance(overrides, dict):
-        for key, val in overrides.items():
-            if key not in _OVERRIDE_KEYS:
-                continue
-            if val is None or (isinstance(val, str) and val.strip().lower() == "unlimited"):
-                effective[key] = None
-            else:
-                try:
-                    effective[key] = int(val)
-                except (TypeError, ValueError):
-                    continue
-    return {"preset": name, "thresholds": effective}
-
-
-def _render_usage(project_root: str, session_id: Optional[str]) -> Dict[str, int]:
-    """Aggregate this session's render-op usage from the ledger."""
-    summary = resolve_ai_ledger.get_summary(project_root=project_root, session_id=session_id)
-    by_op = summary.get("by_op", {})
-    deblur = by_op.get("remove_motion_blur", {})
-    speech = by_op.get("generate_speech", {})
-    render_bytes = (deblur.get("bytes_created", 0) or 0) + (speech.get("bytes_created", 0) or 0)
-    render_ms = (deblur.get("wall_clock_ms", 0) or 0) + (speech.get("wall_clock_ms", 0) or 0)
-    return {
-        "deblur_runs": deblur.get("runs", 0) or 0,
-        "speech_runs": speech.get("runs", 0) or 0,
-        "render_bytes": render_bytes,
-        "render_wall_clock_ms": render_ms,
-    }
-
-
-def check(
-    *,
-    project_root: Optional[str],
-    session_id: Optional[str],
-    op: str,
-    preset: Optional[str] = None,
-    overrides: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    """Advisory governance status for the NEXT run of `op`.
-
-    Returns {applies, exceeded, near, tier, thresholds, usage, projected, warnings}.
-    `applies` is False for non-render ops (no governance) or missing project_root.
-    `exceeded` is True if the projected run-count is over the tier's run cap, or a
-    cumulative dimension (bytes/time) is already over. `near` is True at >=80%.
-    Never blocks — purely informational.
-    """
-    resolved = resolve_tier(preset, overrides)
-    base = {
-        "applies": False,
-        "exceeded": False,
-        "near": False,
-        "tier": resolved["preset"],
-        "thresholds": resolved["thresholds"],
-        "usage": {},
-        "projected": {},
-        "warnings": [],
-    }
-    if op not in GOVERNED_OPS or not project_root:
-        return base
-    thresholds = resolved["thresholds"]
-    usage = _render_usage(project_root, session_id)
-    run_dim = _OP_RUN_DIM[op]
-    projected = dict(usage)
-    projected[run_dim] = usage[run_dim] + 1  # this run adds one
-
-    warnings: List[str] = []
-    exceeded = False
-    near = False
-
-    def _assess(dim: str, value: int, label: str, fmt) -> None:
-        nonlocal exceeded, near
-        cap = thresholds.get(dim)
-        if cap is None:
-            return
-        if value > cap:
-            exceeded = True
-            warnings.append(f"{label}: {fmt(value)} exceeds the {resolved['preset']} limit of {fmt(cap)}.")
-        elif value >= cap * 0.8:
-            near = True
-            warnings.append(f"{label}: {fmt(value)} is approaching the {resolved['preset']} limit of {fmt(cap)}.")
-
-    def _fmt_bytes(n: int) -> str:
-        if not n:
-            return "0 B"
-        units = ["B", "KB", "MB", "GB", "TB"]
-        v = float(n)
-        i = 0
-        while v >= 1024 and i < len(units) - 1:
-            v /= 1024
-            i += 1
-        return f"{v:.1f} {units[i]}"
-
-    def _fmt_min(ms: int) -> str:
-        return f"{ms / 60000:.1f} min"
-
-    _assess(run_dim, projected[run_dim], "Runs this session", str)
-    _assess("render_bytes", usage["render_bytes"], "Media created this session", _fmt_bytes)
-    _assess("render_wall_clock_ms", usage["render_wall_clock_ms"], "Render time this session", _fmt_min)
-
-    base.update({
-        "applies": True,
-        "exceeded": exceeded,
-        "near": near,
-        "usage": usage,
-        "projected": projected,
-        "warnings": warnings,
-    })
-    return base
-
-
-def status(
-    *,
-    project_root: Optional[str],
-    session_id: Optional[str],
-    preset: Optional[str] = None,
-    overrides: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    """Current session render usage vs the effective tier (for the panel/MCP)."""
-    resolved = resolve_tier(preset, overrides)
-    usage = _render_usage(project_root, session_id) if project_root else {
-        "deblur_runs": 0, "speech_runs": 0, "render_bytes": 0, "render_wall_clock_ms": 0,
-    }
-    return {
-        "tier": resolved["preset"],
-        "thresholds": resolved["thresholds"],
-        "usage": usage,
-        "tiers_available": list_tiers(),
-    }