@hybridlabor-api/aos 4.4.1 → 4.4.2-beta.1

package/mcps/blender-mcp-server/addon/models.py

@@ -1,223 +0,0 @@
-"""Small standard-library validators for bridge command parameters.
-
-Blender add-ons run inside Blender's bundled Python, so they cannot assume
-third-party packages are installed. These classes intentionally expose the
-tiny validation API used by the command handler:
-``model_validate(params).model_dump(exclude_none=True)``.
-"""
-
-from __future__ import annotations
-
-from copy import deepcopy
-from typing import Any
-
-MISSING = object()
-
-
-class BridgeParams:
-    fields: dict[str, dict[str, Any]] = {}
-
-    def __init__(self, values: dict[str, Any]):
-        self._values = values
-
-    @classmethod
-    def model_validate(cls, params: dict | None):
-        if params is None:
-            params = {}
-        if not isinstance(params, dict):
-            raise ValueError(f"{cls.__name__} parameters must be an object")
-
-        values: dict[str, Any] = {}
-        for name, spec in cls.fields.items():
-            value = params.get(name, MISSING)
-            if value is MISSING:
-                if spec.get("required", False):
-                    raise ValueError(f"Missing required parameter: {name}")
-                if "default_factory" in spec:
-                    value = spec["default_factory"]()
-                elif "default" in spec:
-                    value = deepcopy(spec["default"])
-                else:
-                    value = None
-            values[name] = cls._validate_field(name, value, spec)
-
-        return cls(values)
-
-    @staticmethod
-    def _validate_field(name: str, value: Any, spec: dict[str, Any]) -> Any:
-        if value is None:
-            if spec.get("allow_none", False):
-                return None
-            raise ValueError(f"Parameter '{name}' is required")
-
-        expected = spec.get("type")
-        if expected == "str" and not isinstance(value, str):
-            raise ValueError(f"Parameter '{name}' must be a string")
-        if expected == "bool" and not isinstance(value, bool):
-            raise ValueError(f"Parameter '{name}' must be a boolean")
-        if expected == "dict" and not isinstance(value, dict):
-            raise ValueError(f"Parameter '{name}' must be an object")
-        if expected == "int" and (not isinstance(value, int) or isinstance(value, bool)):
-            raise ValueError(f"Parameter '{name}' must be an integer")
-        if expected == "float":
-            if not isinstance(value, (int, float)) or isinstance(value, bool):
-                raise ValueError(f"Parameter '{name}' must be a number")
-            value = float(value)
-        if expected == "number_list":
-            if not isinstance(value, list):
-                raise ValueError(f"Parameter '{name}' must be a list")
-            min_length = spec.get("min_length")
-            max_length = spec.get("max_length")
-            if min_length is not None and len(value) < min_length:
-                raise ValueError(f"Parameter '{name}' must have at least {min_length} items")
-            if max_length is not None and len(value) > max_length:
-                raise ValueError(f"Parameter '{name}' must have at most {max_length} items")
-            if any(not isinstance(item, (int, float)) or isinstance(item, bool) for item in value):
-                raise ValueError(f"Parameter '{name}' must contain only numbers")
-            value = [float(item) for item in value]
-
-        if spec.get("gt") is not None and value <= spec["gt"]:
-            raise ValueError(f"Parameter '{name}' must be greater than {spec['gt']}")
-        return value
-
-    def model_dump(self, exclude_none: bool = False) -> dict[str, Any]:
-        if exclude_none:
-            return {key: value for key, value in self._values.items() if value is not None}
-        return dict(self._values)
-
-
-def field(
-    field_type: str,
-    default: Any = None,
-    *,
-    required: bool = False,
-    allow_none: bool = False,
-    default_factory=None,
-    min_length: int | None = None,
-    max_length: int | None = None,
-    gt: float | int | None = None,
-) -> dict[str, Any]:
-    spec = {
-        "type": field_type,
-        "required": required,
-        "allow_none": allow_none,
-        "min_length": min_length,
-        "max_length": max_length,
-        "gt": gt,
-    }
-    if default_factory is not None:
-        spec["default_factory"] = default_factory
-    elif required:
-        pass
-    else:
-        spec["default"] = default
-    return spec
-
-
-class SceneListObjectsParams(BridgeParams):
-    fields = {"type": field("str", allow_none=True)}
-
-
-class ObjectGetTransformParams(BridgeParams):
-    fields = {"name": field("str", required=True)}
-
-
-class ObjectGetHierarchyParams(BridgeParams):
-    fields = {"name": field("str", allow_none=True)}
-
-
-class ObjectCreateMeshParams(BridgeParams):
-    fields = {
-        "type": field("str", "cube"),
-        "name": field("str", allow_none=True),
-        "location": field("number_list", default_factory=lambda: [0, 0, 0], min_length=3, max_length=3),
-        "size": field("float", 2.0, gt=0),
-    }
-
-
-class ObjectDeleteParams(BridgeParams):
-    fields = {"name": field("str", required=True)}
-
-
-class ObjectTranslateParams(BridgeParams):
-    fields = {
-        "name": field("str", required=True),
-        "location": field("number_list", allow_none=True, min_length=3, max_length=3),
-        "offset": field("number_list", allow_none=True, min_length=3, max_length=3),
-    }
-
-
-class ObjectRotateParams(BridgeParams):
-    fields = {
-        "name": field("str", required=True),
-        "rotation": field("number_list", default_factory=lambda: [0, 0, 0], min_length=3, max_length=3),
-        "degrees": field("bool", True),
-    }
-
-
-class ObjectScaleParams(BridgeParams):
-    fields = {
-        "name": field("str", required=True),
-        "scale": field("number_list", default_factory=lambda: [1, 1, 1], min_length=3, max_length=3),
-    }
-
-
-class ObjectDuplicateParams(BridgeParams):
-    fields = {"name": field("str", required=True), "new_name": field("str", allow_none=True)}
-
-
-class MaterialCreateParams(BridgeParams):
-    fields = {
-        "name": field("str", required=True),
-        "color": field("number_list", allow_none=True, min_length=3, max_length=3),
-    }
-
-
-class MaterialAssignParams(BridgeParams):
-    fields = {"object": field("str", required=True), "material": field("str", required=True)}
-
-
-class MaterialSetColorParams(BridgeParams):
-    fields = {
-        "material": field("str", required=True),
-        "color": field("number_list", required=True, min_length=3, max_length=3),
-    }
-
-
-class MaterialSetTextureParams(BridgeParams):
-    fields = {"material": field("str", required=True), "path": field("str", required=True)}
-
-
-class RenderStillParams(BridgeParams):
-    fields = {
-        "output_path": field("str", "//render.png"),
-        "resolution_x": field("int", allow_none=True, gt=0),
-        "resolution_y": field("int", allow_none=True, gt=0),
-        "engine": field("str", allow_none=True),
-    }
-
-
-class RenderAnimationParams(BridgeParams):
-    fields = {
-        "output_path": field("str", "//render_"),
-        "frame_start": field("int", allow_none=True),
-        "frame_end": field("int", allow_none=True),
-        "engine": field("str", allow_none=True),
-    }
-
-
-class ExportFileParams(BridgeParams):
-    fields = {"filepath": field("str", required=True)}
-
-
-class PythonExecuteParams(BridgeParams):
-    fields = {
-        "code": field("str", allow_none=True),
-        "script_path": field("str", allow_none=True),
-        "args": field("dict", allow_none=True),
-        "timeout_seconds": field("float", allow_none=True, gt=0),
-    }
-
-
-class JobIdParams(BridgeParams):
-    fields = {"job_id": field("str", required=True)}

package/mcps/blender-mcp-server/pyproject.toml

@@ -1,120 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "blender-mcp-server"
-version = "0.1.3"
-description = "MCP server for controlling Blender via AI assistants"
-readme = "README.md"
-license = "MIT"
-requires-python = ">=3.10"
-authors = [
-    { name = "Adam Djellouli", email = "adam@djellouli.com" },
-]
-keywords = ["blender", "mcp", "model-context-protocol", "ai", "claude", "3d"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Topic :: Multimedia :: Graphics :: 3D Modeling",
-    "Topic :: Software Development :: Libraries",
-]
-dependencies = [
-    "mcp>=1.0.0,<2.0.0",
-    "pydantic>=2.0",
-]
-
-[project.urls]
-Homepage = "https://github.com/djeada/blender-mcp-server"
-Repository = "https://github.com/djeada/blender-mcp-server"
-Issues = "https://github.com/djeada/blender-mcp-server/issues"
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=7.0",
-    "pytest-asyncio>=0.21",
-    "pytest-cov>=6.0",
-    "ruff>=0.11",
-    "mypy>=1.15",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/blender_mcp_server"]
-
-[tool.hatch.build.targets.sdist]
-include = [
-    "src/",
-    "addon/",
-    "docs/",
-    "tests/",
-    "LICENSE",
-    "README.md",
-    "pyproject.toml",
-]
-
-[project.scripts]
-blender-mcp-server = "blender_mcp_server:main"
-
-[tool.pytest.ini_options]
-asyncio_mode = "strict"
-addopts = "--cov=blender_mcp_server --cov-report=term-missing --cov-report=xml:coverage.xml"
-
-[tool.coverage.run]
-source = ["src/blender_mcp_server"]
-
-[tool.coverage.report]
-fail_under = 50
-show_missing = true
-exclude_lines = [
-    "pragma: no cover",
-    "if __name__ == .__main__.",
-    "if TYPE_CHECKING:",
-]
-
-[tool.ruff]
-target-version = "py310"
-line-length = 120
-
-[tool.ruff.lint]
-select = [
-    "E",     # pycodestyle errors
-    "W",     # pycodestyle warnings
-    "F",     # pyflakes
-    "I",     # isort
-    "N",     # pep8-naming
-    "UP",    # pyupgrade
-    "B",     # flake8-bugbear
-    "SIM",   # flake8-simplify
-    "TCH",   # flake8-type-checking
-]
-ignore = [
-    "E501",  # line too long (handled by formatter)
-    "SIM108", # ternary operator
-]
-
-[tool.ruff.lint.per-file-ignores]
-"addon/__init__.py" = ["E402", "N801", "N818"]
-"scripts/*.py" = ["E402"]
-"scripts/library/*.py" = ["F821"]
-"scripts/demos/*.py" = ["F821"]
-
-[tool.ruff.lint.isort]
-known-first-party = ["blender_mcp_server"]
-
-[tool.mypy]
-python_version = "3.10"
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = false
-check_untyped_defs = true
-ignore_missing_imports = true
-
-[[tool.mypy.overrides]]
-module = "addon.*"
-ignore_errors = true

package/mcps/blender-mcp-server/scripts/blender_bridge_request.py

@@ -1,71 +0,0 @@
-#!/usr/bin/env python3
-"""Send a single JSON command to the Blender MCP add-on TCP bridge."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import socket
-import sys
-import uuid
-from typing import Any
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Send a JSON command to the Blender add-on bridge on localhost.")
-    parser.add_argument(
-        "command",
-        help="Bridge command, for example: scene.get_info or object.create_mesh",
-    )
-    parser.add_argument(
-        "--params",
-        default="{}",
-        help='JSON object string for command parameters, for example: \'{"name":"Cube"}\'',
-    )
-    parser.add_argument("--host", default="127.0.0.1", help="Bridge host")
-    parser.add_argument("--port", type=int, default=9876, help="Bridge port")
-    parser.add_argument("--timeout", type=float, default=10.0, help="Socket timeout in seconds")
-    return parser.parse_args()
-
-
-def send_request(host: str, port: int, command: str, params: dict[str, Any], timeout: float) -> dict[str, Any]:
-    request = {
-        "id": str(uuid.uuid4()),
-        "command": command,
-        "params": params,
-    }
-    with socket.create_connection((host, port), timeout=timeout) as sock:
-        sock.sendall((json.dumps(request) + "\n").encode("utf-8"))
-        buffer = b""
-        while b"\n" not in buffer:
-            chunk = sock.recv(65536)
-            if not chunk:
-                raise ConnectionError("Connection closed before a full response arrived")
-            buffer += chunk
-    line = buffer.split(b"\n", 1)[0]
-    return json.loads(line.decode("utf-8"))
-
-
-def main() -> int:
-    args = parse_args()
-    try:
-        params = json.loads(args.params)
-    except json.JSONDecodeError as exc:
-        print(f"Invalid --params JSON: {exc}", file=sys.stderr)
-        return 2
-    if not isinstance(params, dict):
-        print("--params must decode to a JSON object", file=sys.stderr)
-        return 2
-
-    try:
-        response = send_request(args.host, args.port, args.command, params, args.timeout)
-    except OSError as exc:
-        print(f"Bridge request failed: {exc}", file=sys.stderr)
-        return 1
-
-    print(json.dumps(response, indent=2))
-    return 0 if response.get("success") else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/mcps/blender-mcp-server/scripts/blender_create_test_cube.py

@@ -1,49 +0,0 @@
-#!/usr/bin/env python3
-"""Create a simple test cube through the Blender MCP add-on TCP bridge."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import pathlib
-import sys
-
-SCRIPT_DIR = pathlib.Path(__file__).resolve().parent
-sys.path.insert(0, str(SCRIPT_DIR))
-
-from blender_bridge_request import send_request
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Create a test cube through the Blender add-on bridge.")
-    parser.add_argument("--name", default="TestCube", help="Name for the new object")
-    parser.add_argument("--x", type=float, default=0.0, help="X location")
-    parser.add_argument("--y", type=float, default=0.0, help="Y location")
-    parser.add_argument("--z", type=float, default=1.0, help="Z location")
-    parser.add_argument("--size", type=float, default=2.0, help="Cube size")
-    parser.add_argument("--host", default="127.0.0.1", help="Bridge host")
-    parser.add_argument("--port", type=int, default=9876, help="Bridge port")
-    parser.add_argument("--timeout", type=float, default=10.0, help="Socket timeout in seconds")
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    params = {
-        "type": "cube",
-        "name": args.name,
-        "location": [args.x, args.y, args.z],
-        "size": args.size,
-    }
-    try:
-        response = send_request(args.host, args.port, "object.create_mesh", params, args.timeout)
-    except OSError as exc:
-        print(f"Bridge request failed: {exc}", file=sys.stderr)
-        return 1
-
-    print(json.dumps(response, indent=2))
-    return 0 if response.get("success") else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/mcps/blender-mcp-server/scripts/blender_scene_info.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-"""Fetch current scene info from the Blender MCP add-on TCP bridge."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import pathlib
-import sys
-
-SCRIPT_DIR = pathlib.Path(__file__).resolve().parent
-sys.path.insert(0, str(SCRIPT_DIR))
-
-from blender_bridge_request import send_request
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Fetch scene.get_info from the Blender add-on bridge.")
-    parser.add_argument("--host", default="127.0.0.1", help="Bridge host")
-    parser.add_argument("--port", type=int, default=9876, help="Bridge port")
-    parser.add_argument("--timeout", type=float, default=10.0, help="Socket timeout in seconds")
-    return parser.parse_args()
-
-
-def main() -> int:
-    args = parse_args()
-    try:
-        response = send_request(args.host, args.port, "scene.get_info", {}, args.timeout)
-    except OSError as exc:
-        print(f"Bridge request failed: {exc}", file=sys.stderr)
-        return 1
-
-    print(json.dumps(response, indent=2))
-    return 0 if response.get("success") else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/mcps/blender-mcp-server/scripts/build_addon_zip.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
-DIST_DIR="${REPO_ROOT}/dist"
-ADDON_DIR="${DIST_DIR}/blender_mcp_bridge"
-ZIP_PATH="${DIST_DIR}/blender_mcp_bridge.zip"
-
-if ! command -v zip >/dev/null 2>&1; then
-    echo "error: zip is not available" >&2
-    exit 1
-fi
-
-mkdir -p "${DIST_DIR}"
-rm -rf "${ADDON_DIR}"
-rm -f "${ZIP_PATH}"
-
-mkdir -p "${ADDON_DIR}"
-cp "${REPO_ROOT}/addon/__init__.py" "${ADDON_DIR}/__init__.py"
-cp "${REPO_ROOT}/addon/models.py" "${ADDON_DIR}/models.py"
-
-(
-    cd "${DIST_DIR}"
-    zip -rq "$(basename "${ZIP_PATH}")" "$(basename "${ADDON_DIR}")"
-)
-
-echo "Created ${ZIP_PATH}"