@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,35 +0,0 @@
-"""Test helpers for the structured error envelope landed in A1.
-
-The legacy shape was `{"error": "<prose>"}`. The new shape is
-`{"error": {"message": str, "code": str, "category": str,
-            "retryable": bool, "remediation": str?}}`.
-
-These helpers let tests assert against the new shape without each test
-needing to know the full structure.
-"""
-from __future__ import annotations
-from typing import Any, Dict
-
-
-def err_message(result: Dict[str, Any]) -> str:
-    """Return the human-readable message from a result error, whatever the shape."""
-    err = result.get("error") if isinstance(result, dict) else None
-    if isinstance(err, dict):
-        return str(err.get("message", ""))
-    if isinstance(err, str):
-        return err
-    return ""
-
-
-def err_code(result: Dict[str, Any]) -> str:
-    err = result.get("error") if isinstance(result, dict) else None
-    return str(err.get("code", "")) if isinstance(err, dict) else ""
-
-
-def err_category(result: Dict[str, Any]) -> str:
-    err = result.get("error") if isinstance(result, dict) else None
-    return str(err.get("category", "")) if isinstance(err, dict) else ""
-
-
-def is_err(result: Dict[str, Any]) -> bool:
-    return isinstance(result, dict) and "error" in result and bool(result["error"])

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

@@ -1,270 +0,0 @@
-#!/usr/bin/env python3
-"""
-DaVinci Resolve MCP Server Benchmark
------------------------------------
-This script benchmarks the MCP server's performance and responsiveness.
-It measures:
-- Connection time
-- Response time for various operations
-- Stability under load
-- Memory usage
-
-Usage:
-    python benchmark_server.py [--iterations=N] [--delay=SECONDS]
-
-Requirements:
-    - DaVinci Resolve must be running with a project open
-    - DaVinci Resolve MCP Server must be running
-    - requests, psutil modules (pip install requests psutil)
-"""
-
-import os
-import sys
-import time
-import json
-import argparse
-import statistics
-import requests
-import logging
-import psutil
-from typing import Dict, Any, List, Tuple, Optional
-from datetime import datetime
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler(f"mcp_benchmark_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger(__name__)
-
-# Server configuration
-SERVER_URL = "http://localhost:8000/api"
-
-def send_request(tool_name: str, params: Dict[str, Any]) -> Tuple[Dict[str, Any], float]:
-    """Send a request to the MCP server and measure response time."""
-    try:
-        payload = {
-            "tool": tool_name,
-            "params": params
-        }
-        start_time = time.time()
-        response = requests.post(SERVER_URL, json=payload)
-        end_time = time.time()
-        response_time = end_time - start_time
-        
-        response.raise_for_status()
-        return response.json(), response_time
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Request error: {e}")
-        return {"success": False, "error": str(e)}, time.time() - start_time
-
-def measure_system_resources() -> Dict[str, float]:
-    """Measure system resources used by the server process."""
-    resources = {}
-    
-    try:
-        # Find the server process
-        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-            if proc.info['cmdline'] and any('resolve_mcp_server.py' in cmd for cmd in proc.info['cmdline'] if cmd):
-                # Get memory usage
-                process = psutil.Process(proc.info['pid'])
-                mem_info = process.memory_info()
-                resources['memory_mb'] = mem_info.rss / (1024 * 1024)  # Convert to MB
-                resources['cpu_percent'] = process.cpu_percent(interval=0.5)
-                resources['threads'] = process.num_threads()
-                resources['connections'] = len(process.connections())
-                break
-    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess) as e:
-        logger.error(f"Error measuring system resources: {e}")
-    
-    return resources
-
-def benchmark_operation(operation_name: str, tool_name: str, params: Dict[str, Any], 
-                      iterations: int = 10, delay: float = 0.5) -> Dict[str, Any]:
-    """Benchmark a specific operation."""
-    logger.info(f"Benchmarking {operation_name}...")
-    
-    response_times = []
-    success_count = 0
-    error_count = 0
-    error_messages = []
-    
-    for i in range(iterations):
-        logger.info(f"  Iteration {i+1}/{iterations}")
-        result, response_time = send_request(tool_name, params)
-        
-        response_times.append(response_time)
-        
-        if "error" not in result or not result["error"]:
-            success_count += 1
-        else:
-            error_count += 1
-            error_message = str(result.get("error", "Unknown error"))
-            error_messages.append(error_message)
-            logger.warning(f"  Error: {error_message}")
-        
-        if i < iterations - 1:  # Don't delay after the last iteration
-            time.sleep(delay)
-    
-    # Calculate statistics
-    stats = {
-        "min_time": min(response_times),
-        "max_time": max(response_times),
-        "avg_time": statistics.mean(response_times),
-        "median_time": statistics.median(response_times),
-        "std_dev": statistics.stdev(response_times) if len(response_times) > 1 else 0,
-        "success_rate": success_count / iterations,
-        "error_rate": error_count / iterations,
-        "error_messages": error_messages[:5]  # Limit to first 5 errors
-    }
-    
-    # Log results
-    logger.info(f"Results for {operation_name}:")
-    logger.info(f"  Success rate: {stats['success_rate'] * 100:.1f}%")
-    logger.info(f"  Avg response time: {stats['avg_time'] * 1000:.2f}ms")
-    logger.info(f"  Min/Max: {stats['min_time'] * 1000:.2f}ms / {stats['max_time'] * 1000:.2f}ms")
-    
-    return stats
-
-def run_benchmarks(iterations: int = 10, delay: float = 0.5) -> Dict[str, Any]:
-    """Run benchmarks for various operations."""
-    benchmark_results = {}
-    
-    # Measure system resources at start
-    initial_resources = measure_system_resources()
-    benchmark_results["initial_resources"] = initial_resources
-    
-    # Define operations to benchmark
-    operations = [
-        {
-            "name": "Get Current Page",
-            "tool": "mcp_davinci_resolve_switch_page",
-            "params": {"page": "media"}
-        },
-        {
-            "name": "Switch to Edit Page",
-            "tool": "mcp_davinci_resolve_switch_page",
-            "params": {"page": "edit"}
-        },
-        {
-            "name": "List Timelines",
-            "tool": "mcp_davinci_resolve_list_timelines_tool",
-            "params": {"random_string": "benchmark"}
-        },
-        {
-            "name": "Project Settings - Integer",
-            "tool": "mcp_davinci_resolve_set_project_setting",
-            "params": {"setting_name": "timelineFrameRate", "setting_value": 24}
-        },
-        {
-            "name": "Project Settings - String",
-            "tool": "mcp_davinci_resolve_set_project_setting",
-            "params": {"setting_name": "timelineFrameRate", "setting_value": "24"}
-        },
-        {
-            "name": "Clear Render Queue",
-            "tool": "mcp_davinci_resolve_clear_render_queue",
-            "params": {"random_string": "benchmark"}
-        }
-    ]
-    
-    # Run benchmarks for each operation
-    for op in operations:
-        benchmark_results[op["name"]] = benchmark_operation(
-            op["name"], op["tool"], op["params"], iterations, delay
-        )
-    
-    # Measure system resources at end
-    final_resources = measure_system_resources()
-    benchmark_results["final_resources"] = final_resources
-    
-    # Calculate resource usage difference
-    resource_diff = {}
-    for key in initial_resources:
-        if key in final_resources:
-            resource_diff[key] = final_resources[key] - initial_resources[key]
-    
-    benchmark_results["resource_change"] = resource_diff
-    
-    return benchmark_results
-
-def print_summary(results: Dict[str, Any]) -> None:
-    """Print a summary of benchmark results."""
-    logger.info("\n" + "=" * 50)
-    logger.info("BENCHMARK SUMMARY")
-    logger.info("=" * 50)
-    
-    # Calculate overall statistics
-    response_times = []
-    success_rates = []
-    
-    for key, value in results.items():
-        if key not in ["initial_resources", "final_resources", "resource_change"] and isinstance(value, dict):
-            if "avg_time" in value:
-                response_times.append(value["avg_time"])
-            if "success_rate" in value:
-                success_rates.append(value["success_rate"])
-    
-    # Overall stats
-    if response_times:
-        logger.info(f"Overall average response time: {statistics.mean(response_times) * 1000:.2f}ms")
-    if success_rates:
-        logger.info(f"Overall success rate: {statistics.mean(success_rates) * 100:.1f}%")
-    
-    # Operation ranking by speed
-    operation_times = []
-    for key, value in results.items():
-        if key not in ["initial_resources", "final_resources", "resource_change"] and isinstance(value, dict):
-            if "avg_time" in value:
-                operation_times.append((key, value["avg_time"]))
-    
-    if operation_times:
-        logger.info("\nOperations ranked by speed (fastest first):")
-        for op, time in sorted(operation_times, key=lambda x: x[1]):
-            logger.info(f"  {op}: {time * 1000:.2f}ms")
-    
-    # Resource usage
-    if "resource_change" in results and results["resource_change"]:
-        logger.info("\nResource usage change during benchmark:")
-        for key, value in results["resource_change"].items():
-            if key == "memory_mb":
-                logger.info(f"  Memory: {value:.2f}MB")
-            elif key == "cpu_percent":
-                logger.info(f"  CPU: {value:.1f}%")
-            else:
-                logger.info(f"  {key}: {value}")
-    
-    logger.info("=" * 50)
-
-def main() -> None:
-    """Run the benchmark suite."""
-    parser = argparse.ArgumentParser(description="Benchmark the DaVinci Resolve MCP Server")
-    parser.add_argument("--iterations", type=int, default=10,
-                        help="Number of iterations for each benchmark (default: 10)")
-    parser.add_argument("--delay", type=float, default=0.5,
-                        help="Delay between benchmark iterations in seconds (default: 0.5)")
-    args = parser.parse_args()
-    
-    logger.info("Starting DaVinci Resolve MCP Server Benchmark")
-    logger.info("=" * 50)
-    logger.info(f"Iterations: {args.iterations}, Delay: {args.delay}s")
-    
-    # Run benchmarks
-    results = run_benchmarks(args.iterations, args.delay)
-    
-    # Print summary
-    print_summary(results)
-    
-    # Save results to file
-    result_file = f"benchmark_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-    with open(result_file, 'w') as f:
-        json.dump(results, f, indent=2)
-    
-    logger.info(f"Benchmark results saved to {result_file}")
-
-if __name__ == "__main__":
-    main() 

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

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-"""
-DaVinci Resolve Test Timeline Generator
----------------------------------------
-This script creates a test timeline with sample media for testing the MCP server.
-It generates colored test frames as clips if no media is available.
-
-Usage:
-    python create_test_timeline.py
-
-Requirements:
-    - DaVinci Resolve must be running
-    - requests module (pip install requests)
-"""
-
-import os
-import sys
-import time
-import requests
-import logging
-import tempfile
-import subprocess
-from typing import Dict, Any, List, Optional
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger(__name__)
-
-# Server configuration
-SERVER_URL = "http://localhost:8000/api"
-
-def send_request(tool_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
-    """Send a request to the MCP server."""
-    try:
-        payload = {
-            "tool": tool_name,
-            "params": params
-        }
-        response = requests.post(SERVER_URL, json=payload)
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Request error: {e}")
-        return {"success": False, "error": str(e)}
-
-def create_test_media() -> List[str]:
-    """Create test media files for import."""
-    logger.info("Creating test media files...")
-    
-    media_files = []
-    temp_dir = tempfile.gettempdir()
-    
-    try:
-        # Create three colored test frames using ffmpeg if available
-        colors = ["red", "green", "blue"]
-        
-        for color in colors:
-            output_file = os.path.join(temp_dir, f"test_{color}.mp4")
-            
-            # Check if ffmpeg is available
-            try:
-                # Create a 5-second test video with the specified color
-                cmd = [
-                    "ffmpeg", "-y", "-f", "lavfi", "-i", f"color=c={color}:s=1280x720:r=30:d=5",
-                    "-c:v", "libx264", "-pix_fmt", "yuv420p", output_file
-                ]
-                subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                media_files.append(output_file)
-                logger.info(f"Created {color} test media: {output_file}")
-            except (subprocess.SubprocessError, FileNotFoundError) as e:
-                logger.error(f"Failed to create test media: {e}")
-                # Try an alternative method if ffmpeg fails
-                break
-    except Exception as e:
-        logger.error(f"Error creating test media: {e}")
-    
-    if not media_files:
-        logger.warning("Could not create test media. The timeline will be empty.")
-    
-    return media_files
-
-def setup_test_project() -> bool:
-    """Create a test project."""
-    logger.info("Setting up test project...")
-    
-    # Create a new project
-    result = send_request("mcp_davinci_resolve_create_project", {"name": "MCP_Test_Project"})
-    
-    if "error" in result and result["error"]:
-        logger.error(f"Failed to create project: {result['error']}")
-        
-        # Try opening the project if it already exists
-        open_result = send_request("mcp_davinci_resolve_open_project", {"name": "MCP_Test_Project"})
-        if "error" in open_result and open_result["error"]:
-            logger.error(f"Failed to open existing project: {open_result['error']}")
-            return False
-        else:
-            logger.info("Opened existing test project")
-    else:
-        logger.info("Created new test project")
-    
-    # Set project settings
-    send_request("mcp_davinci_resolve_set_project_setting", 
-                {"setting_name": "timelineFrameRate", "setting_value": 30})
-    
-    return True
-
-def create_test_timeline() -> bool:
-    """Create a test timeline with imported media."""
-    logger.info("Creating test timeline...")
-    
-    # Create timeline
-    result = send_request("mcp_davinci_resolve_create_timeline", {"name": "MCP_Test_Timeline"})
-    
-    if "error" in result and result["error"]:
-        logger.error(f"Failed to create timeline: {result['error']}")
-        return False
-    
-    logger.info("Created test timeline")
-    
-    # Set as current timeline
-    send_request("mcp_davinci_resolve_set_current_timeline", {"name": "MCP_Test_Timeline"})
-    
-    # Create and import test media
-    media_files = create_test_media()
-    
-    # Import media files
-    for media_file in media_files:
-        import_result = send_request("mcp_davinci_resolve_import_media", 
-                                    {"file_path": media_file})
-        
-        if "error" not in import_result or not import_result["error"]:
-            logger.info(f"Imported media: {media_file}")
-            
-            # Add to timeline (after short delay to ensure media is processed)
-            time.sleep(1)
-            clip_name = os.path.basename(media_file)
-            add_result = send_request("mcp_davinci_resolve_add_clip_to_timeline", 
-                                     {"clip_name": clip_name, "timeline_name": "MCP_Test_Timeline"})
-            
-            if "error" not in add_result or not add_result["error"]:
-                logger.info(f"Added clip to timeline: {clip_name}")
-            else:
-                logger.warning(f"Failed to add clip to timeline: {add_result.get('error', 'Unknown error')}")
-        else:
-            logger.warning(f"Failed to import media: {import_result.get('error', 'Unknown error')}")
-    
-    return True
-
-def main() -> None:
-    """Run the test timeline creation process."""
-    logger.info("Starting DaVinci Resolve test timeline setup")
-    logger.info("=" * 50)
-    
-    # Set up test project
-    if not setup_test_project():
-        logger.error("Failed to set up test project. Exiting.")
-        sys.exit(1)
-    
-    # Create test timeline with media
-    if not create_test_timeline():
-        logger.error("Failed to create test timeline. Exiting.")
-        sys.exit(1)
-    
-    logger.info("=" * 50)
-    logger.info("Test timeline setup complete!")
-    logger.info("You can now use this timeline to test the MCP server features.")
-    logger.info("=" * 50)
-
-if __name__ == "__main__":
-    main()