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

package/mcps/davinci-mcp-professional/pyproject.toml

@@ -1,115 +0,0 @@
-[project]
-name = "davinci-mcp-professional"
-dynamic = ["version"]
-description = "Model Context Protocol server for DaVinci Resolve integration"
-readme = "README.md"
-license = { file = "COPYING.md" }
-authors = [
-    { name = "Hoyt Harness", email = "hoyt.harness@gmail.com" }
-]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.14",
-]
-requires-python = ">=3.10"
-dependencies = [
-    "mcp>=1.10.0",
-    "anyio>=4.9",
-    "httpx>=0.27.1,<1.0.0",
-    "pydantic>=2.12.0",
-    "click>=8.0.0",
-    "colorama>=0.4.6",
-]
-
-[project.optional-dependencies]
-build = [
-    "pyinstaller>=6.0.0",
-]
-
-[project.scripts]
-davinci-mcp = "davinci_mcp.cli:main"
-
-[project.urls]
-Homepage = "https://github.com/Positronikal/davinci-mcp-professional"
-Repository = "https://github.com/Positronikal/davinci-mcp-professional"
-Issues = "https://github.com/Positronikal/davinci-mcp-professional/issues"
-
-[build-system]
-requires = ["hatchling", "hatch-vcs"]
-build-backend = "hatchling.build"
-
-[tool.hatch.version]
-source = "vcs"
-raw-options = { version_scheme = "no-guess-dev" }
-
-[tool.hatch.build.hooks.vcs]
-version-file = "src/davinci_mcp/_version.py"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/davinci_mcp"]
-
-[tool.uv]
-default-groups = ["dev"]
-
-[dependency-groups]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-asyncio>=0.23.0",
-    "pytest-cov>=5.0.0",
-    "mypy>=1.10.0",
-    "ruff>=0.4.0",
-    "safety>=3.0.0",
-    "bandit>=1.7.8",
-    "pip-licenses>=4.4.0",
-    "pyright>=1.1.400",
-]
-
-[tool.mypy]
-python_version = "3.10"
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = true
-check_untyped_defs = true
-
-[tool.pyright]
-pythonVersion = "3.10"
-typeCheckingMode = "basic"
-reportMissingImports = true
-reportMissingTypeStubs = false
-reportUnusedImport = true
-reportUnusedVariable = true
-reportDuplicateImport = true
-reportUntypedFunctionDecorator = false
-reportUntypedClassDecorator = false
-reportUntypedBaseClass = false
-reportUntypedNamedTuple = false
-reportPrivateUsage = false
-reportConstantRedefinition = true
-reportIncompatibleMethodOverride = true
-reportIncompatibleVariableOverride = true
-reportInconsistentConstructor = true
-exclude = [
-    "**/__pycache__",
-    "**/node_modules",
-    ".venv",
-    "build",
-    "dist",
-    "tests",
-]
-include = [
-    "src",
-]
-
-[tool.ruff]
-line-length = 88
-target-version = "py310"
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "UP", "C4", "PERF"]
-ignore = ["PERF203"]

package/mcps/davinci-mcp-professional/security_audit.py

@@ -1,379 +0,0 @@
-#!/usr/bin/env python3
-"""
-Security audit script for DaVinci MCP Professional.
-
-This script runs a comprehensive security audit including:
-- Dependency vulnerability scanning
-- Static application security testing (SAST)
-- License compliance checking
-- Code quality analysis
-- Security test execution
-"""
-
-import subprocess
-import sys
-import json
-import os
-from pathlib import Path
-from typing import Dict, List, Tuple, Optional
-
-
-class SecurityAuditor:
-    """Comprehensive security auditing tool."""
-    
-    def __init__(self, project_root: Optional[Path] = None):
-        self.project_root = project_root or Path(__file__).parent
-        self.results = {}
-        self.errors = []
-    
-    def run_command(self, cmd: List[str], description: str) -> Tuple[bool, str, str]:
-        """Run a command and capture output."""
-        try:
-            result = subprocess.run(
-                cmd, capture_output=True, text=True, cwd=self.project_root
-            )
-            return (
-                result.returncode == 0,
-                result.stdout,
-                result.stderr
-            )
-        except FileNotFoundError:
-            return False, "", f"Command not found: {cmd[0]}"
-        except Exception as e:
-            return False, "", str(e)
-    
-    def check_dependencies_safety(self) -> Dict:
-        """Check dependencies for known vulnerabilities using Safety."""
-        print("🔍 Checking dependencies with Safety...")
-        
-        success, stdout, stderr = self.run_command(
-            ["safety", "check", "--json"], 
-            "Safety vulnerability scan"
-        )
-        
-        if success:
-            try:
-                vulnerabilities = json.loads(stdout) if stdout.strip() else []
-                return {
-                    "status": "success",
-                    "vulnerabilities": vulnerabilities,
-                    "count": len(vulnerabilities)
-                }
-            except json.JSONDecodeError:
-                return {
-                    "status": "error",
-                    "error": "Failed to parse Safety output"
-                }
-        else:
-            return {
-                "status": "error", 
-                "error": stderr or "Safety check failed"
-            }
-    
-    def run_bandit_sast(self) -> Dict:
-        """Run Bandit static application security testing."""
-        print("🔍 Running Bandit SAST analysis...")
-        
-        success, stdout, stderr = self.run_command(
-            ["bandit", "-r", "src/", "-f", "json", "-o", "bandit-report.json"],
-            "Bandit SAST scan"
-        )
-        
-        # Bandit returns non-zero when issues are found, so check the output file
-        report_file = self.project_root / "bandit-report.json"
-        if report_file.exists():
-            try:
-                with open(report_file, 'r') as f:
-                    report = json.load(f)
-                
-                return {
-                    "status": "success",
-                    "results": report.get("results", []),
-                    "metrics": report.get("metrics", {}),
-                    "count": len(report.get("results", []))
-                }
-            except Exception as e:
-                return {
-                    "status": "error",
-                    "error": f"Failed to read Bandit report: {e}"
-                }
-        else:
-            return {
-                "status": "error",
-                "error": "Bandit report not generated"
-            }
-    
-    def check_license_compliance(self) -> Dict:
-        """Check license compliance."""
-        print("📄 Checking license compliance...")
-        
-        success, stdout, stderr = self.run_command(
-            ["pip-licenses", "--format=json"],
-            "License compliance check"
-        )
-        
-        if success:
-            try:
-                licenses = json.loads(stdout)
-                
-                # Check for problematic licenses
-                problematic_licenses = [
-                    "GPL", "AGPL", "LGPL", "CDDL", "EPL", "MPL"
-                ]
-                
-                issues = []
-                for package in licenses:
-                    license_name = package.get("License", "").upper()
-                    if any(prob in license_name for prob in problematic_licenses):
-                        issues.append({
-                            "package": package.get("Name"),
-                            "license": package.get("License"),
-                            "version": package.get("Version")
-                        })
-                
-                return {
-                    "status": "success",
-                    "licenses": licenses,
-                    "total_packages": len(licenses),
-                    "problematic_licenses": issues,
-                    "issues_count": len(issues)
-                }
-            except json.JSONDecodeError:
-                return {
-                    "status": "error",
-                    "error": "Failed to parse license data"
-                }
-        else:
-            return {
-                "status": "error",
-                "error": stderr or "License check failed"
-            }
-    
-    def run_security_tests(self) -> Dict:
-        """Run security-focused tests."""
-        print("🧪 Running security tests...")
-        
-        success, stdout, stderr = self.run_command(
-            ["python", "-m", "pytest", "tests/test_security.py", "-v", "--tb=short"],
-            "Security tests"
-        )
-        
-        return {
-            "status": "success" if success else "failed",
-            "output": stdout,
-            "error": stderr if not success else None
-        }
-    
-    def run_code_quality_checks(self) -> Dict:
-        """Run code quality and style checks."""
-        print("✨ Running code quality checks...")
-        
-        results = {}
-        
-        # Run Black formatter check
-        success, stdout, stderr = self.run_command(
-            ["black", "--check", "--diff", "src/"],
-            "Black formatter check"
-        )
-        results["black"] = {
-            "passed": success,
-            "output": stdout,
-            "error": stderr if not success else None
-        }
-        
-        # Run isort import sorting check
-        success, stdout, stderr = self.run_command(
-            ["isort", "--check-only", "--diff", "src/"],
-            "isort import check"
-        )
-        results["isort"] = {
-            "passed": success,
-            "output": stdout,
-            "error": stderr if not success else None
-        }
-        
-        # Run Ruff linting
-        success, stdout, stderr = self.run_command(
-            ["ruff", "check", "src/"],
-            "Ruff linting"
-        )
-        results["ruff"] = {
-            "passed": success,
-            "output": stdout,
-            "error": stderr if not success else None
-        }
-        
-        return results
-    
-    def generate_report(self) -> str:
-        """Generate a comprehensive security report."""
-        report_lines = [
-            "=" * 80,
-            "🛡️  DAVINCI MCP PROFESSIONAL SECURITY AUDIT REPORT",
-            "=" * 80,
-            ""
-        ]
-        
-        # Safety results
-        if "safety" in self.results:
-            safety = self.results["safety"]
-            report_lines.append("📦 DEPENDENCY SECURITY (Safety)")
-            report_lines.append("-" * 40)
-            if safety["status"] == "success":
-                vuln_count = safety["count"]
-                if vuln_count == 0:
-                    report_lines.append("✅ No known vulnerabilities found")
-                else:
-                    report_lines.append(f"⚠️  {vuln_count} vulnerabilities found:")
-                    for vuln in safety["vulnerabilities"][:5]:  # Show first 5
-                        pkg = vuln.get("package", "Unknown")
-                        ver = vuln.get("installed_version", "Unknown")
-                        vuln_id = vuln.get("vulnerability_id", "Unknown")
-                        report_lines.append(f"   • {pkg} {ver} - {vuln_id}")
-            else:
-                report_lines.append(f"❌ Error: {safety['error']}")
-            report_lines.append("")
-        
-        # Bandit results
-        if "bandit" in self.results:
-            bandit = self.results["bandit"]
-            report_lines.append("🔍 STATIC APPLICATION SECURITY TESTING (Bandit)")
-            report_lines.append("-" * 50)
-            if bandit["status"] == "success":
-                issue_count = bandit["count"]
-                if issue_count == 0:
-                    report_lines.append("✅ No security issues found")
-                else:
-                    report_lines.append(f"⚠️  {issue_count} security issues found:")
-                    for issue in bandit["results"][:5]:  # Show first 5
-                        test_id = issue.get("test_id", "Unknown")
-                        severity = issue.get("issue_severity", "Unknown")
-                        confidence = issue.get("issue_confidence", "Unknown")
-                        text = issue.get("issue_text", "Unknown")
-                        report_lines.append(f"   • {test_id} ({severity}/{confidence}): {text}")
-            else:
-                report_lines.append(f"❌ Error: {bandit['error']}")
-            report_lines.append("")
-        
-        # License compliance
-        if "licenses" in self.results:
-            licenses = self.results["licenses"]
-            report_lines.append("📄 LICENSE COMPLIANCE")
-            report_lines.append("-" * 20)
-            if licenses["status"] == "success":
-                total = licenses["total_packages"]
-                issues = licenses["issues_count"]
-                report_lines.append(f"📊 Total packages: {total}")
-                if issues == 0:
-                    report_lines.append("✅ No problematic licenses found")
-                else:
-                    report_lines.append(f"⚠️  {issues} potentially problematic licenses:")
-                    for issue in licenses["problematic_licenses"]:
-                        pkg = issue["package"]
-                        lic = issue["license"]
-                        report_lines.append(f"   • {pkg}: {lic}")
-            else:
-                report_lines.append(f"❌ Error: {licenses['error']}")
-            report_lines.append("")
-        
-        # Security tests
-        if "security_tests" in self.results:
-            tests = self.results["security_tests"]
-            report_lines.append("🧪 SECURITY TESTS")
-            report_lines.append("-" * 15)
-            if tests["status"] == "success":
-                report_lines.append("✅ All security tests passed")
-            else:
-                report_lines.append("❌ Some security tests failed")
-                if tests.get("error"):
-                    report_lines.append(f"Error: {tests['error']}")
-            report_lines.append("")
-        
-        # Code quality
-        if "code_quality" in self.results:
-            quality = self.results["code_quality"]
-            report_lines.append("✨ CODE QUALITY")
-            report_lines.append("-" * 13)
-            for tool, result in quality.items():
-                status = "✅" if result["passed"] else "❌"
-                report_lines.append(f"{status} {tool.capitalize()}")
-            report_lines.append("")
-        
-        # Summary
-        report_lines.extend([
-            "📊 SECURITY AUDIT SUMMARY",
-            "-" * 25,
-            f"🗓️  Audit Date: {os.environ.get('DATE', 'Unknown')}",
-            f"👤 Auditor: Security Automation Script",
-            f"📁 Project: DaVinci MCP Professional v2.2.1",
-            "",
-            "🔗 Next Steps:",
-            "1. Review and address any security vulnerabilities",
-            "2. Update dependencies with known issues", 
-            "3. Fix code quality issues",
-            "4. Re-run audit after fixes",
-            "",
-            "=" * 80
-        ])
-        
-        return "\n".join(report_lines)
-    
-    def run_full_audit(self) -> None:
-        """Run the complete security audit."""
-        print("🚀 Starting comprehensive security audit...")
-        print()
-        
-        # Run all security checks
-        self.results["safety"] = self.check_dependencies_safety()
-        self.results["bandit"] = self.run_bandit_sast()
-        self.results["licenses"] = self.check_license_compliance()
-        self.results["security_tests"] = self.run_security_tests()
-        self.results["code_quality"] = self.run_code_quality_checks()
-        
-        # Generate and save report
-        report = self.generate_report()
-        print(report)
-        
-        # Save report to file
-        report_file = self.project_root / "security-audit-report.txt"
-        with open(report_file, 'w') as f:
-            f.write(report)
-        
-        print(f"\n📄 Full report saved to: {report_file}")
-        
-        # Save JSON results for CI/CD
-        json_file = self.project_root / "security-audit-results.json"
-        with open(json_file, 'w') as f:
-            json.dump(self.results, f, indent=2)
-        
-        print(f"📊 JSON results saved to: {json_file}")
-
-
-def main():
-    """Main entry point."""
-    if len(sys.argv) > 1 and sys.argv[1] == "--help":
-        print("""
-DaVinci MCP Professional Security Auditor
-
-Usage: python security_audit.py [options]
-
-Options:
-  --help     Show this help message
-  
-This script performs a comprehensive security audit including:
-- Dependency vulnerability scanning (Safety)
-- Static application security testing (Bandit)
-- License compliance checking
-- Security test execution
-- Code quality analysis
-
-Results are saved to security-audit-report.txt and security-audit-results.json
-        """)
-        return
-    
-    auditor = SecurityAuditor()
-    auditor.run_full_audit()
-
-
-if __name__ == "__main__":
-    main()

package/mcps/davinci-mcp-professional/src/davinci_mcp/__init__.py

@@ -1,19 +0,0 @@
-"""
-DaVinci Resolve MCP Server
-
-A modern, clean implementation of a Model Context Protocol server
-for DaVinci Resolve integration.
-"""
-
-try:
-    from ._version import __version__
-except ImportError:
-    from importlib.metadata import version
-
-    __version__ = version("davinci-mcp-professional")
-__author__ = "Hoyt Harness"
-
-from .resolve_client import DaVinciResolveClient
-from .server import DaVinciMCPServer
-
-__all__ = ["DaVinciMCPServer", "DaVinciResolveClient"]

package/mcps/davinci-mcp-professional/src/davinci_mcp/cli.py

@@ -1,138 +0,0 @@
-"""
-Command line interface for DaVinci Resolve MCP Server.
-"""
-
-import asyncio
-import logging
-import os
-import sys
-
-import click
-from colorama import Fore, Style
-from colorama import init as init_colorama
-
-# Set UTF-8 encoding for Windows console only for direct output, not for stdio
-if os.name == "nt":  # Windows
-    os.environ["PYTHONIOENCODING"] = "utf-8"
-    # Only set console encoding if we're running in interactive mode
-    # Don't modify stdout/stderr if they might be used by MCP stdio
-    if hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
-        try:
-            # Store original stdout/stderr in case we need them
-            _original_stdout = sys.stdout
-            _original_stderr = sys.stderr
-        except (AttributeError, OSError):
-            pass  # Fallback to default behavior
-
-from . import __version__
-from .server import DaVinciMCPServer
-from .utils import check_resolve_installation, check_resolve_running
-
-# Initialize colorama for cross-platform colored output
-init_colorama()
-
-# Set up logging
-logging.basicConfig(
-    level=logging.INFO,
-    format=f"{Fore.CYAN}%(asctime)s{Style.RESET_ALL} - "
-    f"{Fore.YELLOW}%(name)s{Style.RESET_ALL} - "
-    f"%(levelname)s - %(message)s",
-)
-
-logger = logging.getLogger(__name__)
-
-
-def print_status(message: str, status: str = "INFO") -> None:
-    """Print a colored status message."""
-    if status == "OK":
-        click.echo(f"{Fore.GREEN}[OK]{Style.RESET_ALL} {message}")
-    elif status == "ERROR":
-        click.echo(f"{Fore.RED}[ERROR]{Style.RESET_ALL} {message}")
-    elif status == "WARNING":
-        click.echo(f"{Fore.YELLOW}[WARNING]{Style.RESET_ALL} {message}")
-    else:
-        click.echo(f"{Fore.CYAN}[INFO]{Style.RESET_ALL} {message}")
-
-
-def check_prerequisites() -> bool:
-    """Check if prerequisites are met."""
-    print_status("Checking DaVinci Resolve installation...")
-
-    installation = check_resolve_installation()
-
-    if not installation["api_path_exists"]:
-        print_status("DaVinci Resolve API path not found", "ERROR")
-        return False
-
-    if not installation["lib_path_exists"]:
-        print_status("DaVinci Resolve library not found", "ERROR")
-        return False
-
-    if not installation["modules_path_exists"]:
-        print_status("DaVinci Resolve modules path not found", "ERROR")
-        return False
-
-    print_status("DaVinci Resolve installation verified", "OK")
-
-    print_status("Checking if DaVinci Resolve is running...")
-    if not check_resolve_running():
-        print_status("DaVinci Resolve is not running", "ERROR")
-        print_status(
-            "Please start DaVinci Resolve before running the MCP server", "WARNING"
-        )
-        return False
-
-    print_status("DaVinci Resolve is running", "OK")
-    return True
-
-
-@click.command()
-@click.option("--debug", is_flag=True, help="Enable debug logging")
-@click.option("--skip-checks", is_flag=True, help="Skip prerequisite checks")
-def main(debug: bool = False, skip_checks: bool = False) -> None:
-    """Start the DaVinci Resolve MCP Server."""
-
-    if debug:
-        logging.getLogger().setLevel(logging.DEBUG)
-        logging.getLogger("davinci_mcp").setLevel(logging.DEBUG)
-        print_status("Debug logging enabled")
-
-    # Print banner
-    vi = sys.version_info
-    py_ver = f"{vi.major}.{vi.minor}.{vi.micro}"
-    click.echo(f"\n{Fore.MAGENTA}{'=' * 60}{Style.RESET_ALL}")
-    click.echo(
-        f"{Fore.MAGENTA}  DaVinci MCP Professional v{__version__}{Style.RESET_ALL}"
-    )
-    click.echo(f"{Fore.MAGENTA}  Python {py_ver}{Style.RESET_ALL}")
-    click.echo(f"{Fore.MAGENTA}{'=' * 60}{Style.RESET_ALL}\n")
-
-    # Check prerequisites unless skipped
-    if not skip_checks:
-        if not check_prerequisites():
-            print_status("Prerequisites not met. Exiting.", "ERROR")
-            sys.exit(1)
-
-        click.echo()  # Empty line for spacing
-
-    # Start the server
-    try:
-        print_status("Starting MCP server...")
-        server = DaVinciMCPServer()
-
-        asyncio.run(server.run())
-
-    except KeyboardInterrupt:
-        print_status("\nShutting down server...", "WARNING")
-        sys.exit(0)
-    except Exception as e:
-        print_status(f"Server error: {e}", "ERROR")
-        if debug:
-            import traceback
-
-            traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()