Update forge-texture from local forge-bricks (with vendored common)

app.py

@@ -14,14 +14,25 @@ import gradio as gr
 import spaces
 from PIL import Image
 
+# Robust import for local workspace + HF Space deployment (common is vendored on push)
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+for candidate in (HERE.parent, HERE):
+    if (candidate / "common" / "manifest.py").exists():
+        sys.path.insert(0, str(candidate))
+        break
+
 try:
-    from ..common.manifest import create_manifest
-    from ..common.health import SpaceHealth
-except Exception:
-    import sys
-    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
     from common.manifest import create_manifest
     from common.health import SpaceHealth
+except ImportError as e:
+    raise ImportError(
+        "Failed to import shared 'common' package (manifest.py / health.py).\n"
+        "For local development: run ./install.sh from the forge-bricks/ root.\n"
+        "For HF Spaces: re-run scripts/push_to_hf.py so it vendors common/."
+    ) from e
 
 health = SpaceHealth()
 

common/README.md

@@ -0,0 +1,10 @@
+# forge-bricks-common
+
+Shared utilities used by all Forge Bricks:
+
+- `manifest.py` — `AssetManifest` + `create_manifest()` (lineage, provenance, commercial license flags, game-asset friendly metadata)
+- `health.py` — `SpaceHealth` background monitor (adapted from 3d-creator-suite) for robust fallback behavior when calling other HF Spaces
+
+This package is installed in editable mode when you run the root `install.sh`.
+
+It is a dependency of the individual bricks via their `pyproject.toml` workspace configuration.

common/__init__.py

@@ -0,0 +1,9 @@
+"""Common utilities for Forge Bricks (HF Gradio ZeroGPU Spaces).
+
+Reusable: manifest schema, health monitoring (adapted from 3d-creator-suite),
+asset metadata helpers, lineage tracking, local fallback support.
+"""
+from .manifest import AssetManifest, create_manifest
+from .health import SpaceHealth
+
+__all__ = ["AssetManifest", "create_manifest", "SpaceHealth"]

common/health.py

@@ -0,0 +1,74 @@
+"""SpaceHealth monitor (thread-safe periodic checks + cache).
+
+Directly adapted from 3d-creator-suite/src/cloud/health.py for robustness.
+Use inside bricks and daggr clients to avoid calling dead/sleeping providers.
+"""
+from __future__ import annotations
+import logging
+import threading
+import time
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SpaceHealth:
+    """Thread-safe health status cache for HF Spaces (or any gradio endpoint)."""
+
+    def __init__(self, check_interval: int = 120):
+        self._interval = check_interval
+        self._lock = threading.Lock()
+        self._status: dict[str, dict[str, Any]] = {}
+        self._thread: threading.Thread | None = None
+        self._running = False
+
+    def start(self, space_ids: list[str]) -> None:
+        self._running = True
+        self._thread = threading.Thread(
+            target=self._check_loop, args=(space_ids,), daemon=True
+        )
+        self._thread.start()
+        logger.info(f"Health monitor started for {len(space_ids)} targets")
+
+    def stop(self) -> None:
+        self._running = False
+        if self._thread:
+            self._thread.join(timeout=5)
+
+    def is_ok(self, space_id: str) -> Optional[bool]:
+        with self._lock:
+            return self._status.get(space_id, {}).get("ok")
+
+    def get_all(self) -> dict[str, dict[str, Any]]:
+        with self._lock:
+            return dict(self._status)
+
+    def _check_loop(self, space_ids: list[str]) -> None:
+        while self._running:
+            for sid in space_ids:
+                self._check_one(sid)
+            time.sleep(self._interval)
+
+    def _check_one(self, space_id: str) -> None:
+        try:
+            from gradio_client import Client
+            start = time.monotonic()
+            client = Client(space_id, timeout=10)
+            latency = time.monotonic() - start
+            del client
+            with self._lock:
+                self._status[space_id] = {
+                    "ok": True,
+                    "latency": round(latency, 2),
+                    "last_check": time.time(),
+                    "error": None,
+                }
+        except Exception as e:
+            with self._lock:
+                self._status[space_id] = {
+                    "ok": False,
+                    "latency": None,
+                    "last_check": time.time(),
+                    "error": str(e)[:200],
+                }
+            logger.debug(f"Health check failed for {space_id}: {e}")

common/manifest.py

@@ -0,0 +1,70 @@
+"""Asset manifest + lineage for Forge Bricks outputs.
+
+Based on patterns from daggr-pipelines packaging + aetherium-hub asset_registry + ForgeDNA descriptors.
+Every brick output includes one of these for traceability, editing lineage, license, and editor integration.
+"""
+from __future__ import annotations
+import json
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+
+@dataclass
+class AssetManifest:
+    """Standard output manifest for any generated/edited game asset brick."""
+    id: str
+    name: str
+    type: str  # e.g. "concept_image", "sprite", "model_3d", "texture_pbr", "audio_sfx", "voice_clip", "rig", "anim_clip", "shader"
+    version: int = 1
+    parent_id: Optional[str] = None  # For edits/refines (lineage)
+    source_brick: str = ""
+    prompt_or_desc: str = ""
+    params: dict[str, Any] = field(default_factory=dict)  # seed, strength, steps, voice_description, etc.
+    files: dict[str, str] = field(default_factory=dict)  # role -> path (e.g. "sprite": "xxx.png", "glb": "...")
+    metadata: dict[str, Any] = field(default_factory=dict)  # tags, lod, commercial_ok, model, timings, etc.
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    license_note: str = ""
+    commercial_ok: bool = False
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    def save(self, path: str | Path) -> None:
+        Path(path).write_text(json.dumps(self.to_dict(), indent=2))
+
+    @classmethod
+    def load(cls, path: str | Path) -> "AssetManifest":
+        data = json.loads(Path(path).read_text())
+        return cls(**data)
+
+
+def create_manifest(
+    *,
+    name: str,
+    type: str,
+    source_brick: str,
+    prompt_or_desc: str = "",
+    files: dict[str, str] | None = None,
+    params: dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
+    parent_id: str | None = None,
+    license_note: str = "Check brick README for model licenses",
+    commercial_ok: bool = False,
+) -> AssetManifest:
+    """Helper to create a properly populated manifest (used by all bricks)."""
+    mid = f"{source_brick}_{int(datetime.now(timezone.utc).timestamp() * 1000)}"
+    return AssetManifest(
+        id=mid,
+        name=name,
+        type=type,
+        source_brick=source_brick,
+        prompt_or_desc=prompt_or_desc,
+        parent_id=parent_id,
+        files=files or {},
+        params=params or {},
+        metadata=metadata or {},
+        license_note=license_note,
+        commercial_ok=commercial_ok,
+    )

common/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "forge-bricks-common"
+version = "0.1.0"
+description = "Shared utilities for Forge Bricks (manifests, health checks, etc.)"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pillow>=10.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]