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

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

@@ -1,244 +0,0 @@
-"""Resolve 21 AI-ops ledger.
-
-Records each Resolve-local AI scripting op (audio classification, IntelliSearch,
-slate analysis, motion-deblur, speech generation). These run on Resolve's own
-GPU/AI engine and do NOT consume the Claude-side analysis token budget tracked
-in `analysis_caps`, so they get their own ledger.
-
-The value of the ledger is mostly the **wall-clock + file/byte accounting** for
-the two media-creating ops (`remove_motion_blur`, `generate_speech`). For the
-bool-returning analysis ops, an invocation counter + duration is what is
-reliable (some may queue work asynchronously inside Resolve, so the recorded
-duration is the script-call duration, not necessarily the engine completion).
-
-Persistence reuses `timeline_brain_db` (table `resolve_ai_op_usage`, schema v7).
-Every write is best-effort: a ledger failure must never block or corrupt the
-underlying Resolve op.
-"""
-
-from __future__ import annotations
-
-import logging
-import time
-from typing import Any, Dict, List, Optional
-
-from src.utils import actor_identity, timeline_brain_db
-
-logger = logging.getLogger("resolve-mcp.resolve-ai-ledger")
-
-OP_CLASS_ANALYSIS = "analysis"
-OP_CLASS_RENDER = "render"  # produces a new media file
-
-# op name -> (op_class, extra_required or None). The op names match the
-# consolidated-server action names.
-OP_META: Dict[str, Dict[str, Optional[str]]] = {
-    "perform_audio_classification": {"op_class": OP_CLASS_ANALYSIS, "extra_required": None},
-    "clear_audio_classification": {"op_class": OP_CLASS_ANALYSIS, "extra_required": None},
-    "analyze_for_intellisearch": {"op_class": OP_CLASS_ANALYSIS, "extra_required": "AI IntelliSearch"},
-    "analyze_for_slate": {"op_class": OP_CLASS_ANALYSIS, "extra_required": "AI Slate ID"},
-    "remove_motion_blur": {"op_class": OP_CLASS_RENDER, "extra_required": None},
-    "generate_speech": {"op_class": OP_CLASS_RENDER, "extra_required": "AI Speech Generator"},
-}
-
-
-def op_meta(op: str) -> Dict[str, Optional[str]]:
-    return OP_META.get(op, {"op_class": OP_CLASS_ANALYSIS, "extra_required": None})
-
-
-def _iso(when: Optional[float] = None) -> str:
-    return time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(when if when is not None else time.time()))
-
-
-def _day_bucket(when: Optional[float] = None) -> str:
-    return time.strftime("%Y-%m-%d", time.gmtime(when if when is not None else time.time()))
-
-
-def record_op(
-    *,
-    project_root: str,
-    op: str,
-    clip_id: Optional[str] = None,
-    session_id: Optional[str] = None,
-    success: bool = False,
-    wall_clock_ms: int = 0,
-    output_path: Optional[str] = None,
-    output_bytes: Optional[int] = None,
-    error: Optional[str] = None,
-    actor: Optional[str] = None,
-) -> Optional[int]:
-    """Persist one ledger row. Returns the row id, or None on any failure.
-
-    Best-effort: never raises. Callers run this after the Resolve op so a ledger
-    problem cannot affect the op itself.
-    """
-    if not project_root:
-        return None
-    meta = op_meta(op)
-    now = time.time()
-    try:
-        with timeline_brain_db.transaction(project_root) as txn:
-            cursor = txn.execute(
-                """
-                INSERT INTO resolve_ai_op_usage(
-                    op, op_class, clip_id, session_id, success, wall_clock_ms,
-                    output_path, output_bytes, extra_required, error,
-                    occurred_at, day_bucket, actor
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    op, meta["op_class"], clip_id, session_id, 1 if success else 0,
-                    int(wall_clock_ms), output_path,
-                    int(output_bytes) if output_bytes is not None else None,
-                    meta["extra_required"], error,
-                    _iso(now), _day_bucket(now),
-                    actor or actor_identity.actor_string(),
-                ),
-            )
-            return cursor.lastrowid
-    except Exception as exc:  # pragma: no cover - defensive
-        logger.debug("resolve_ai_ledger.record_op failed: %s", exc)
-        return None
-
-
-class timed:
-    """Context manager that times a Resolve AI op and records it on exit.
-
-    Usage:
-        with resolve_ai_ledger.timed(project_root, "analyze_for_slate", clip_id=cid) as rec:
-            ok = bool(clip.AnalyzeForSlate(color))
-            rec.success = ok
-        # row written automatically; exceptions are recorded then re-raised.
-
-    For media-creating ops, set rec.output_path / rec.output_bytes before exit.
-    All recording is best-effort and never masks the op's own exception.
-    """
-
-    def __init__(
-        self,
-        project_root: Optional[str],
-        op: str,
-        *,
-        clip_id: Optional[str] = None,
-        session_id: Optional[str] = None,
-    ) -> None:
-        self.project_root = project_root
-        self.op = op
-        self.clip_id = clip_id
-        self.session_id = session_id
-        self.success: bool = False
-        self.output_path: Optional[str] = None
-        self.output_bytes: Optional[int] = None
-        self.error: Optional[str] = None
-        self.row_id: Optional[int] = None
-        self._start: float = 0.0
-
-    def __enter__(self) -> "timed":
-        self._start = time.time()
-        return self
-
-    def __exit__(self, exc_type, exc, tb) -> bool:
-        wall_clock_ms = int((time.time() - self._start) * 1000)
-        if exc is not None and self.error is None:
-            self.error = f"{exc_type.__name__}: {exc}" if exc_type else str(exc)
-        if self.project_root:
-            self.row_id = record_op(
-                project_root=self.project_root,
-                op=self.op,
-                clip_id=self.clip_id,
-                session_id=self.session_id,
-                success=self.success,
-                wall_clock_ms=wall_clock_ms,
-                output_path=self.output_path,
-                output_bytes=self.output_bytes,
-                error=self.error,
-            )
-        return False  # never suppress the op's own exception
-
-
-def get_usage(
-    *,
-    project_root: str,
-    session_id: Optional[str] = None,
-    op: Optional[str] = None,
-    limit: int = 100,
-) -> List[Dict[str, Any]]:
-    """Return recent ledger rows, newest first."""
-    if not project_root:
-        return []
-    clauses: List[str] = []
-    args: List[Any] = []
-    if session_id:
-        clauses.append("session_id = ?")
-        args.append(session_id)
-    if op:
-        clauses.append("op = ?")
-        args.append(op)
-    where = (" WHERE " + " AND ".join(clauses)) if clauses else ""
-    try:
-        conn = timeline_brain_db.connect(project_root)
-        rows = conn.execute(
-            f"""
-            SELECT op, op_class, clip_id, session_id, success, wall_clock_ms,
-                   output_path, output_bytes, extra_required, error, occurred_at, actor
-            FROM resolve_ai_op_usage{where}
-            ORDER BY id DESC LIMIT ?
-            """,
-            (*args, int(limit)),
-        ).fetchall()
-    except Exception as exc:  # pragma: no cover - defensive
-        logger.debug("resolve_ai_ledger.get_usage failed: %s", exc)
-        return []
-    return [dict(r) for r in rows]
-
-
-def get_summary(*, project_root: str, session_id: Optional[str] = None) -> Dict[str, Any]:
-    """Aggregate ledger rows into per-op and overall totals.
-
-    Returns counts, successes, total wall-clock, and total files/bytes created
-    (the latter meaningful only for render-class ops).
-    """
-    empty = {"by_op": {}, "totals": {"runs": 0, "successes": 0, "failures": 0,
-                                      "wall_clock_ms": 0, "files_created": 0, "bytes_created": 0}}
-    if not project_root:
-        return empty
-    clause = " WHERE session_id = ?" if session_id else ""
-    args = (session_id,) if session_id else ()
-    try:
-        conn = timeline_brain_db.connect(project_root)
-        rows = conn.execute(
-            f"""
-            SELECT op, op_class, success, wall_clock_ms, output_path, output_bytes
-            FROM resolve_ai_op_usage{clause}
-            """,
-            args,
-        ).fetchall()
-    except Exception as exc:  # pragma: no cover - defensive
-        logger.debug("resolve_ai_ledger.get_summary failed: %s", exc)
-        return empty
-
-    by_op: Dict[str, Dict[str, Any]] = {}
-    totals = {"runs": 0, "successes": 0, "failures": 0, "wall_clock_ms": 0,
-              "files_created": 0, "bytes_created": 0}
-    for r in rows:
-        op = r["op"]
-        bucket = by_op.setdefault(op, {
-            "op_class": r["op_class"], "runs": 0, "successes": 0, "failures": 0,
-            "wall_clock_ms": 0, "files_created": 0, "bytes_created": 0,
-        })
-        bucket["runs"] += 1
-        totals["runs"] += 1
-        if r["success"]:
-            bucket["successes"] += 1
-            totals["successes"] += 1
-        else:
-            bucket["failures"] += 1
-            totals["failures"] += 1
-        bucket["wall_clock_ms"] += r["wall_clock_ms"] or 0
-        totals["wall_clock_ms"] += r["wall_clock_ms"] or 0
-        if r["output_path"]:
-            bucket["files_created"] += 1
-            totals["files_created"] += 1
-        if r["output_bytes"]:
-            bucket["bytes_created"] += r["output_bytes"]
-            totals["bytes_created"] += r["output_bytes"]
-    return {"by_op": by_op, "totals": totals}

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

@@ -1,171 +0,0 @@
-"""Cross-process visibility for long synchronous DaVinci Resolve operations.
-
-The Resolve scripting bridge executes one call at a time. Most calls return in
-milliseconds, but a handful block for seconds-to-minutes (timeline export and
-import, scene-cut detection, subtitle generation, audio transcription). A
-second tool call issued during one of those — from another thread of this
-server, or from the other instance when stdio and networked servers share one
-Resolve — simply hangs inside fusionscript with no feedback.
-
-This module gives those long operations a name and a presence that every
-instance can see, so the Resolve preflight can wait briefly and then return a
-structured "busy" answer instead of hanging:
-
-    with long_resolve_op("timeline.export"):
-        tl.Export(...)
-
-    op = wait_until_free(timeout_seconds=5.0)   # None when free
-    if op:
-        ... return a RESOLVE_BUSY error naming op["label"] ...
-
-Registration is advisory and best-effort: a sidecar JSON file in the temp dir
-(same approach as page_lock) carries {label, pid, thread, started_at}. Records
-are ignored when their pid is dead or they exceed MAX_OP_AGE_SECONDS, so a
-crashed operation can never wedge the server. The registering thread is exempt
-from its own gate — long operations call Resolve helpers internally.
-"""
-from __future__ import annotations
-
-import json
-import os
-import tempfile
-import threading
-import time
-from contextlib import contextmanager
-from typing import Any, Dict, Optional
-
-_SIDECAR = os.path.join(tempfile.gettempdir(), "davinci_resolve_mcp_busy.json")
-# A long op that has run this long is presumed crashed/leaked and ignored.
-MAX_OP_AGE_SECONDS = 2 * 60 * 60
-# Default time a preflight will wait for the bridge to free up before
-# returning a busy error.
-DEFAULT_WAIT_SECONDS = 5.0
-_POLL_SECONDS = 0.25
-
-_lock = threading.Lock()
-_local_owner: Optional[int] = None  # thread ident of the in-process registrant
-
-
-def _pid_alive(pid: int) -> bool:
-    try:
-        os.kill(pid, 0)
-        return True
-    except ProcessLookupError:
-        return False
-    except PermissionError:
-        return True
-    except OSError:
-        return False
-
-
-def _read_record() -> Optional[Dict[str, Any]]:
-    try:
-        with open(_SIDECAR, "r", encoding="utf-8") as handle:
-            record = json.load(handle)
-    except (OSError, json.JSONDecodeError):
-        return None
-    if not isinstance(record, dict) or not record.get("label"):
-        return None
-    started_at = record.get("started_at")
-    if not isinstance(started_at, (int, float)):
-        return None
-    if time.time() - started_at > MAX_OP_AGE_SECONDS:
-        return None
-    pid = record.get("pid")
-    if not isinstance(pid, int) or not _pid_alive(pid):
-        return None
-    return record
-
-
-def _write_record(record: Dict[str, Any]) -> None:
-    tmp_path = f"{_SIDECAR}.tmp-{os.getpid()}-{threading.get_ident()}"
-    try:
-        with open(tmp_path, "w", encoding="utf-8") as handle:
-            json.dump(record, handle)
-        os.replace(tmp_path, _SIDECAR)
-    except OSError:
-        pass
-    finally:
-        try:
-            os.remove(tmp_path)
-        except OSError:
-            pass
-
-
-def _clear_record() -> None:
-    record = None
-    try:
-        with open(_SIDECAR, "r", encoding="utf-8") as handle:
-            record = json.load(handle)
-    except (OSError, json.JSONDecodeError):
-        pass
-    # Only the owning process removes the sidecar; never clobber another
-    # instance's registration.
-    if isinstance(record, dict) and record.get("pid") == os.getpid():
-        try:
-            os.remove(_SIDECAR)
-        except OSError:
-            pass
-
-
-def current_long_op() -> Optional[Dict[str, Any]]:
-    """The active long operation visible across instances, or None."""
-    record = _read_record()
-    if record is None:
-        return None
-    return {
-        "label": record.get("label"),
-        "pid": record.get("pid"),
-        "same_process": record.get("pid") == os.getpid(),
-        "started_at": record.get("started_at"),
-        "age_seconds": round(max(0.0, time.time() - float(record.get("started_at", 0.0))), 1),
-    }
-
-
-@contextmanager
-def long_resolve_op(label: str):
-    """Register a long synchronous Resolve call for its duration."""
-    global _local_owner
-    ident = threading.get_ident()
-    with _lock:
-        nested = _local_owner is not None
-        if not nested:
-            _local_owner = ident
-    if not nested:
-        _write_record({
-            "label": str(label),
-            "pid": os.getpid(),
-            "thread": ident,
-            "started_at": time.time(),
-        })
-    try:
-        yield
-    finally:
-        if not nested:
-            with _lock:
-                _local_owner = None
-            _clear_record()
-
-
-def wait_until_free(timeout_seconds: Optional[float] = None) -> Optional[Dict[str, Any]]:
-    """Wait briefly for any long op to finish.
-
-    Returns None when the bridge is free (or becomes free within the timeout),
-    otherwise the still-running operation's info. The thread that registered
-    the current in-process op is never gated by it. timeout_seconds defaults
-    to DEFAULT_WAIT_SECONDS, read at call time so callers/tests can tune it.
-    """
-    if timeout_seconds is None:
-        timeout_seconds = DEFAULT_WAIT_SECONDS
-    deadline = time.monotonic() + max(0.0, float(timeout_seconds))
-    while True:
-        op = current_long_op()
-        if op is None:
-            return None
-        if op["same_process"]:
-            record = _read_record() or {}
-            if record.get("thread") == threading.get_ident():
-                return None
-        if time.monotonic() >= deadline:
-            return op
-        time.sleep(_POLL_SECONDS)

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

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-"""
-DaVinci Resolve Connection Utilities
-"""
-
-import os
-import logging
-from .platform import get_platform, get_resolve_paths, setup_environment
-
-logger = logging.getLogger("davinci-resolve-mcp.connection")
-
-def initialize_resolve():
-    """Initialize connection to DaVinci Resolve application."""
-    try:
-        # Import the DaVinci Resolve scripting module
-        import DaVinciResolveScript as dvr_script
-        
-        # Get the resolve object
-        resolve = dvr_script.scriptapp("Resolve")
-        
-        if resolve is None:
-            logger.error("Failed to get Resolve object. Is DaVinci Resolve running?")
-            return None
-        
-        logger.info(f"Connected to DaVinci Resolve: {resolve.GetProductName()} {resolve.GetVersionString()}")
-        return resolve
-    
-    except ImportError:
-        platform_name = get_platform()
-        paths = get_resolve_paths()
-        
-        logger.error("Failed to import DaVinciResolveScript. Check environment variables.")
-        logger.error("RESOLVE_SCRIPT_API, RESOLVE_SCRIPT_LIB, and PYTHONPATH must be set correctly.")
-        
-        if platform_name == 'darwin':
-            logger.error("On macOS, typically:")
-            logger.error(f'export RESOLVE_SCRIPT_API="{paths["api_path"]}"')
-            logger.error(f'export RESOLVE_SCRIPT_LIB="{paths["lib_path"]}"')
-            logger.error(f'export PYTHONPATH="$PYTHONPATH:{paths["modules_path"]}"')
-        elif platform_name == 'windows':
-            logger.error("On Windows, typically:")
-            logger.error(f'set RESOLVE_SCRIPT_API={paths["api_path"]}')
-            logger.error(f'set RESOLVE_SCRIPT_LIB={paths["lib_path"]}')
-            logger.error(f'set PYTHONPATH=%PYTHONPATH%;{paths["modules_path"]}')
-        elif platform_name == 'linux':
-            logger.error("On Linux, typically:")
-            logger.error(f'export RESOLVE_SCRIPT_API="{paths["api_path"]}"')
-            logger.error(f'export RESOLVE_SCRIPT_LIB="{paths["lib_path"]}"')
-            logger.error(f'export PYTHONPATH="$PYTHONPATH:{paths["modules_path"]}"')
-        
-        return None
-    
-    except Exception as e:
-        logger.error(f"Unexpected error initializing Resolve: {str(e)}")
-        return None
-
-def check_environment_variables():
-    """Check if the required environment variables are set."""
-    resolve_script_api = os.environ.get("RESOLVE_SCRIPT_API")
-    resolve_script_lib = os.environ.get("RESOLVE_SCRIPT_LIB")
-    
-    missing_vars = []
-    if not resolve_script_api:
-        missing_vars.append("RESOLVE_SCRIPT_API")
-    if not resolve_script_lib:
-        missing_vars.append("RESOLVE_SCRIPT_LIB")
-    
-    return {
-        "all_set": len(missing_vars) == 0,
-        "missing": missing_vars,
-        "resolve_script_api": resolve_script_api,
-        "resolve_script_lib": resolve_script_lib
-    }
-
-def set_default_environment_variables():
-    """Set the default environment variables based on platform."""
-    return setup_environment()