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

package/mcps/blender-mcp-server/scripts/demos/README.md

@@ -1,186 +0,0 @@
-# Dam-Break Demo
-
-End-to-end validation that the MCP python execution path can build a complete
-flood-through-town scene without manual Blender UI steps (beyond enabling the
-add-on). The repo now ships two variants:
-
-- `procedural_dam_break_scene.py`: stable visible flood animation for Blender 4.0.x.
-- `dam_break_scene.py`: experimental Mantaflow setup path.
-
-## Recommended Mode
-
-For Blender 4.0.x use the procedural scene. It produces visible water in the
-viewport and avoids the Mantaflow viewport crash.
-
-```bash
-python3 scripts/demos/run_dam_break.py
-```
-
-To force the older Mantaflow path:
-
-```bash
-python3 scripts/demos/run_dam_break.py --simulation mantaflow --bake
-```
-
-## What the Procedural Demo Builds
-
-| Element | Details |
-|---|---|
-| Ground plane | Street + sidewalks + barrier |
-| 6 buildings | Blockout town section around an intersection |
-| Flood animation | Procedural water mesh sequence over 120 frames |
-| Debris objects | 4 props advected by the flood field |
-| Camera | Animated cinematic overview over 120 frames |
-| Frame range | 1–120 at 24 fps |
-| Render settings | EEVEE, 1280×720 preview |
-
-## Two Ways to Run
-
-### Option A — Single script (all-in-one)
-
-Send the monolithic scene script through MCP:
-
-```json
-{
-  "tool": "blender_python_exec",
-  "args": {
-    "script_path": "/path/to/scripts/demos/procedural_dam_break_scene.py",
-    "args": {"frame_end": 120}
-  }
-}
-```
-
-Or via the bridge test helper:
-
-```bash
-python3 scripts/blender_bridge_request.py python.execute \
-  --params '{"script_path":"/path/to/scripts/demos/procedural_dam_break_scene.py","args":{"frame_end":120}}'
-```
-
-### Option B — Step-by-step bridge caller
-
-The `run_dam_break.py` script sends individual MCP commands, mixing inline
-code (for geometry) with local library scripts (sent as inline code for
-portability, so it does not depend on approved script roots inside Blender):
-
-```bash
-# Dry run — see what would be sent:
-python3 scripts/demos/run_dam_break.py --dry-run
-
-# Run against live Blender (stable procedural mode):
-python3 scripts/demos/run_dam_break.py
-
-# Run Mantaflow mode instead:
-python3 scripts/demos/run_dam_break.py --simulation mantaflow --bake --render
-```
-
-## Mantaflow Notes
-
-The Mantaflow path remains in the repo for experimentation, but Blender 4.0.x
-can crash when a visible liquid domain updates in the viewport. Use the
-procedural scene when you need a stable visible result in the live app.
-
-## After Scene Setup
-
-### Bake the fluid simulation
-
-```json
-{
-  "tool": "blender_python_exec_async",
-  "args": {
-    "code": "import bpy\nbpy.ops.fluid.bake_all()\n__result__ = {'baked': True}",
-    "timeout_seconds": 1800
-  }
-}
-```
-
-Then poll:
-
-```json
-{"tool": "blender_job_status", "args": {"job_id": "<returned job_id>"}}
-```
-
-### Render a preview still
-
-```json
-{
-  "tool": "blender_render_still",
-  "args": {"output_path": "/tmp/dam_break_preview.png"}
-}
-```
-
-## What This Validates
-
-- [x] Inline code creates geometry (ground, buildings, debris)
-- [x] Library script `frame_range.py` sets frame range
-- [x] Library script `fluid_domain.py` creates Mantaflow domain
-- [x] Library script `fluid_inflow.py` creates inflow source
-- [x] Library script `effector.py` marks objects as collision effectors
-- [x] Library script `rigid_body.py` adds active rigid bodies
-- [x] Library script `camera.py` creates and positions camera
-- [x] Library script `keyframes.py` inserts dolly animation keyframes
-- [x] Library script `collections.py` organizes scene hierarchy
-- [x] Render settings are configurable via inline code
-- [x] Async job path works for baking
-- [x] Job polling and completion work
-- [x] Render still produces output
-
-## Gaps & Follow-Up Tickets
-
-Issues discovered while building this demo that should be addressed in future
-work:
-
-### GAP-1: Live bridge scripts should avoid `bpy.ops.mesh.primitive_*`
-
-**Status:** mitigated
-
-The repo now includes `scripts/library/create_mesh.py`, and the bridge injects
-an `mcp_create_mesh(...)` helper into `python.execute` scripts. Use those
-instead of `bpy.ops.mesh.primitive_*_add` for bridge-driven blockouts,
-especially near Mantaflow setup.
-
-### GAP-2: No library script for render settings
-
-**Problem:** There is no library script for configuring render engine, samples,
-resolution, color management, or output format. The demo uses inline code.
-
-**Impact:** Render configuration is a common task that would benefit from a
-reusable, validated script.
-
-**Recommendation:** Add `scripts/library/render_settings.py` supporting engine
-selection, resolution, samples, output format, and color management.
-
-### GAP-3: No fluid bake library script
-
-**Problem:** Triggering `bpy.ops.fluid.bake_all()` requires inline code through
-the async path. There is no library wrapper.
-
-**Impact:** Minor — the inline call is simple. But a library script could add
-validation (check domain exists, check cache dir).
-
-**Recommendation:** Add `scripts/library/fluid_bake.py` that validates the
-domain setup before calling bake.
-
-### GAP-4: No viewport/OpenGL render for quick preview
-
-**Problem:** The existing render tools only support full engine renders (EEVEE
-or Cycles). There is no viewport render or OpenGL render option for sub-second
-preview captures.
-
-**Impact:** Getting visual feedback during iterative scene building requires a
-full render, which is slow even with EEVEE at low resolution.
-
-**Recommendation:** Add a `render.viewport` bridge command using
-`bpy.ops.render.opengl()` for instant viewport captures.
-
-### GAP-5: No progress callback for async jobs
-
-**Problem:** The async job system supports polling via `job.status`, but there
-is no way for the running script to report intermediate progress (e.g., "baking
-frame 45/120").
-
-**Impact:** Long bakes appear as opaque "running" status with no visibility
-into progress.
-
-**Recommendation:** Add a `__progress__` callback or namespace variable that
-scripts can update, surfaced through `job.status`.

package/mcps/blender-mcp-server/scripts/demos/dam_break_scene.py

@@ -1,276 +0,0 @@
-"""Dam-break demo scene — end-to-end Blender Python script.
-
-Run this through the MCP bridge via ``blender_python_exec`` to build a complete
-low-res fluid-through-town demo scene entirely from script.  The scene includes:
-
-* Ground plane as a street
-* Three building blockout cubes
-* Fluid domain (Mantaflow liquid, low-res)
-* Inflow source positioned as a water release
-* Collision effectors on ground and buildings
-* Two dynamic rigid-body debris objects
-* Camera with keyframed dolly animation
-* Frame range configured for 120-frame preview
-* Render settings tuned for a fast EEVEE preview
-
-After running, trigger a fluid bake via ``blender_python_exec_async``::
-
-    bpy.ops.fluid.bake_all()
-    __result__ = {"baked": True}
-
-Then render a preview via ``blender_render_still``.
-
-Args (optional overrides):
-    resolution (int): Fluid domain max resolution. Default: 32
-    frame_end (int): Last frame of the simulation. Default: 120
-    output_dir (str): Blender-relative path for caches/renders. Default: "//"
-"""
-
-import math
-
-import bpy
-
-
-def create_box_object(name, size, location):
-    if isinstance(size, (int, float)):
-        sx = sy = sz = float(size)
-    else:
-        sx, sy, sz = size
-    hx, hy, hz = sx / 2.0, sy / 2.0, sz / 2.0
-    verts = [
-        (-hx, -hy, -hz),
-        (hx, -hy, -hz),
-        (hx, hy, -hz),
-        (-hx, hy, -hz),
-        (-hx, -hy, hz),
-        (hx, -hy, hz),
-        (hx, hy, hz),
-        (-hx, hy, hz),
-    ]
-    faces = [
-        (0, 1, 2, 3),
-        (4, 5, 6, 7),
-        (0, 1, 5, 4),
-        (1, 2, 6, 5),
-        (2, 3, 7, 6),
-        (3, 0, 4, 7),
-    ]
-    mesh = bpy.data.meshes.new(f"{name}Mesh")
-    mesh.from_pydata(verts, [], faces)
-    mesh.update()
-    obj = bpy.data.objects.new(name, mesh)
-    bpy.context.scene.collection.objects.link(obj)
-    obj.location = location
-    return obj
-
-
-def create_plane_object(name, size, location):
-    half = size / 2.0
-    verts = [
-        (-half, -half, 0.0),
-        (half, -half, 0.0),
-        (half, half, 0.0),
-        (-half, half, 0.0),
-    ]
-    mesh = bpy.data.meshes.new(f"{name}Mesh")
-    mesh.from_pydata(verts, [], [(0, 1, 2, 3)])
-    mesh.update()
-    obj = bpy.data.objects.new(name, mesh)
-    bpy.context.scene.collection.objects.link(obj)
-    obj.location = location
-    return obj
-
-
-# ---------------------------------------------------------------------------
-# Parameters
-# ---------------------------------------------------------------------------
-resolution = args.get("resolution", 32)
-frame_end = args.get("frame_end", 120)
-output_dir = args.get("output_dir", "//")
-
-# ---------------------------------------------------------------------------
-# 1. Clear default scene
-# ---------------------------------------------------------------------------
-bpy.ops.object.select_all(action="SELECT")
-bpy.ops.object.delete(use_global=False)
-
-# ---------------------------------------------------------------------------
-# 2. Frame range
-# ---------------------------------------------------------------------------
-scene = bpy.context.scene
-scene.frame_start = 1
-scene.frame_end = frame_end
-scene.frame_current = 1
-scene.render.fps = 24
-
-# ---------------------------------------------------------------------------
-# 3. Ground plane (street)
-# ---------------------------------------------------------------------------
-ground = create_plane_object("Ground", 20, (0, 0, 0))
-
-# ---------------------------------------------------------------------------
-# 4. Buildings
-# ---------------------------------------------------------------------------
-buildings = [
-    {"name": "Building_A", "size": (2, 3, 4), "loc": (3, 2, 2)},
-    {"name": "Building_B", "size": (2.5, 2, 5), "loc": (-2, -1, 2.5)},
-    {"name": "Building_C", "size": (1.8, 4, 3), "loc": (1, -4, 1.5)},
-]
-
-building_names = []
-for b in buildings:
-    obj = create_box_object(b["name"], b["size"], b["loc"])
-    building_names.append(obj.name)
-
-# ---------------------------------------------------------------------------
-# 5. Debris objects (small rigid-body props)
-# ---------------------------------------------------------------------------
-debris_names = []
-debris_specs = [
-    {"name": "Debris_Crate", "loc": (2, -2, 0.4), "size": 0.8},
-    {"name": "Debris_Barrel", "loc": (-1, 1, 0.5), "size": 0.6},
-]
-for d in debris_specs:
-    obj = create_box_object(d["name"], d["size"], d["loc"])
-    debris_names.append(obj.name)
-
-# ---------------------------------------------------------------------------
-# 6. Rigid bodies on debris
-# ---------------------------------------------------------------------------
-for dname in debris_names:
-    obj = bpy.data.objects.get(dname)
-    if obj is None:
-        continue
-    bpy.context.view_layer.objects.active = obj
-    obj.select_set(True)
-    bpy.ops.rigidbody.object_add()
-    obj.rigid_body.type = "ACTIVE"
-    obj.rigid_body.mass = 5.0
-    obj.rigid_body.friction = 0.6
-    obj.rigid_body.restitution = 0.2
-    obj.rigid_body.collision_shape = "BOX"
-    obj.select_set(False)
-
-# ---------------------------------------------------------------------------
-# 7. Fluid domain
-# ---------------------------------------------------------------------------
-domain_size = 22
-domain = create_box_object("FluidDomain", domain_size, (0, 0, 5))
-dmod = domain.modifiers.new(name="Fluid", type="FLUID")
-dmod.fluid_type = "DOMAIN"
-dsettings = dmod.domain_settings
-dsettings.domain_type = "LIQUID"
-dsettings.resolution_max = resolution
-dsettings.cache_directory = output_dir + "fluid_cache"
-dsettings.use_mesh = True
-dmod.show_viewport = False
-domain.display_type = "WIRE"
-
-# ---------------------------------------------------------------------------
-# 8. Inflow source (water rushing in from +X side)
-# ---------------------------------------------------------------------------
-inflow = create_box_object("WaterInflow", 3, (8, 0, 3))
-imod = inflow.modifiers.new(name="Fluid", type="FLUID")
-imod.fluid_type = "FLOW"
-imod.show_viewport = False
-flow = imod.flow_settings
-flow.flow_type = "LIQUID"
-flow.flow_behavior = "INFLOW"
-flow.use_initial_velocity = True
-flow.velocity_normal = 0
-flow.velocity_coord = (-4, 0, 0)  # rushing toward -X
-inflow.hide_viewport = True
-inflow.hide_render = True
-
-# ---------------------------------------------------------------------------
-# 9. Collision effectors — ground + buildings
-# ---------------------------------------------------------------------------
-collider_names = ["Ground"] + building_names
-for cname in collider_names:
-    obj = bpy.data.objects.get(cname)
-    if obj is None:
-        continue
-    emod = obj.modifiers.get("Fluid") or obj.modifiers.new(name="Fluid", type="FLUID")
-    emod.fluid_type = "EFFECTOR"
-    eff = emod.effector_settings
-    eff.effector_type = "COLLISION"
-    eff.surface_distance = 0.01
-
-# ---------------------------------------------------------------------------
-# 10. Camera with dolly keyframes
-# ---------------------------------------------------------------------------
-cam_data = bpy.data.cameras.new("DamBreakCam")
-cam_obj = bpy.data.objects.new("DamBreakCam", cam_data)
-bpy.context.collection.objects.link(cam_obj)
-cam_obj.data.lens = 35
-
-scene.camera = cam_obj
-
-cam_keyframes = [
-    {"frame": 1, "location": (15, -12, 8), "rotation": (math.radians(60), 0, math.radians(50))},
-    {"frame": frame_end // 2, "location": (6, -10, 5), "rotation": (math.radians(65), 0, math.radians(30))},
-    {"frame": frame_end, "location": (0, -8, 3), "rotation": (math.radians(70), 0, math.radians(10))},
-]
-for kf in cam_keyframes:
-    cam_obj.location = kf["location"]
-    cam_obj.rotation_euler = kf["rotation"]
-    cam_obj.keyframe_insert(data_path="location", frame=kf["frame"])
-    cam_obj.keyframe_insert(data_path="rotation_euler", frame=kf["frame"])
-
-
-# ---------------------------------------------------------------------------
-# 11. Collections
-# ---------------------------------------------------------------------------
-def move_to_collection(obj_name, coll_name):
-    obj = bpy.data.objects.get(obj_name)
-    if obj is None:
-        return
-    coll = bpy.data.collections.get(coll_name)
-    if coll is None:
-        coll = bpy.data.collections.new(coll_name)
-        scene.collection.children.link(coll)
-    for c in obj.users_collection:
-        c.objects.unlink(obj)
-    coll.objects.link(obj)
-
-
-for bn in building_names:
-    move_to_collection(bn, "Buildings")
-for dn in debris_names:
-    move_to_collection(dn, "Debris")
-move_to_collection("Ground", "Environment")
-move_to_collection("FluidDomain", "Fluid")
-move_to_collection("WaterInflow", "Fluid")
-move_to_collection("DamBreakCam", "Camera")
-
-# ---------------------------------------------------------------------------
-# 12. Render settings (fast EEVEE preview)
-# ---------------------------------------------------------------------------
-scene.render.engine = "BLENDER_EEVEE"
-scene.render.resolution_x = 960
-scene.render.resolution_y = 540
-scene.render.resolution_percentage = 100
-scene.render.filepath = output_dir + "dam_break_preview"
-
-# ---------------------------------------------------------------------------
-# Result summary
-# ---------------------------------------------------------------------------
-__result__ = {
-    "scene": scene.name,
-    "frame_range": [scene.frame_start, scene.frame_end],
-    "fluid_domain": domain.name,
-    "fluid_resolution": resolution,
-    "inflow": inflow.name,
-    "colliders": collider_names,
-    "debris": debris_names,
-    "camera": cam_obj.name,
-    "camera_keyframes": len(cam_keyframes),
-    "buildings": building_names,
-    "render_engine": scene.render.engine,
-    "render_resolution": [scene.render.resolution_x, scene.render.resolution_y],
-    "next_steps": [
-        "The liquid domain stays hidden in the viewport to avoid Blender 4.0.2 view-layer update crashes.",
-        "Bake fluid: blender_python_exec_async with code 'bpy.ops.fluid.bake_all(); __result__={\"baked\":True}'",
-        "Render preview: blender_render_still with output_path '/tmp/dam_break.png'",
-    ],
-}

package/mcps/blender-mcp-server/scripts/demos/open_dam_break_gui.py

@@ -1,33 +0,0 @@
-"""Open Blender GUI with the stable procedural dam-break scene built.
-
-Run:
-    blender --factory-startup --python scripts/demos/open_dam_break_gui.py
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import bpy
-
-SCENE_SCRIPT = Path(__file__).with_name("procedural_dam_break_scene.py")
-
-
-def main() -> None:
-    args = {
-        "frame_end": 120,
-        "output_dir": "//",
-    }
-    namespace = {
-        "__name__": "__main__",
-        "args": args,
-    }
-
-    code = SCENE_SCRIPT.read_text(encoding="utf-8")
-    exec(compile(code, str(SCENE_SCRIPT), "exec"), namespace)
-    bpy.context.scene.frame_set(min(70, bpy.context.scene.frame_end))
-    print("Procedural dam-break scene ready in Blender GUI")
-
-
-if __name__ == "__main__":
-    main()