Serve Crello corpus aafdb0e86816 from the mounted bucket

Dockerfile

@@ -10,10 +10,10 @@ RUN apt-get update && apt-get install -y --no-install-recommends libegl1 libgl1
 
 # Dependencies first, for layer caching.
 COPY pyproject.toml uv.lock ./
-RUN uv sync --frozen --no-dev --no-install-project 
+RUN uv sync --frozen --no-dev --extra daytona --no-install-project
 
 COPY . .
-RUN uv sync --frozen --no-dev  \
+RUN uv sync --frozen --no-dev --extra daytona \
  && .venv/bin/python -m playwright install --with-deps chromium \
  && rm -rf /var/lib/apt/lists/*
 

realapps/__init__.py

@@ -112,3 +112,30 @@ def _up(url: str) -> bool:
         return e.code < 500
     except Exception:  # noqa: BLE001
         return False
+
+
+_AVAILABLE: dict = {}
+
+
+def available() -> tuple[bool, str]:
+    """Whether this server can run real apps, and if not, why (cached for 30 s; cheap enough for every page load).
+
+    On Daytona that needs the SDK and a key; locally, the Penpot and desktop endpoints must answer."""
+    import time
+
+    if _AVAILABLE and time.time() - _AVAILABLE["at"] < 30:
+        return _AVAILABLE["ok"], _AVAILABLE["why"]
+    if os.environ.get("DESIGN_CANVAS_APPS", "").lower() == "daytona":
+        try:
+            import daytona  # noqa: F401
+        except ImportError:
+            ok, why = False, "the daytona package is not installed (install the `daytona` extra)"
+        else:
+            ok, why = (bool(os.environ.get("DAYTONA_API_KEY")), "DAYTONA_API_KEY is not set")
+    else:
+        st = status(check=True)
+        down = [e["url"] for e in st["endpoints"] if not e.get("up")]
+        ok, why = not down, ("real apps run locally here and nothing answers at " + ", ".join(down) +
+                             "; run them (realapps/) or set DESIGN_CANVAS_APPS=daytona")
+    _AVAILABLE.update(at=time.time(), ok=ok, why="" if ok else why)
+    return ok, _AVAILABLE["why"]

realapps/daytona.py

@@ -9,7 +9,8 @@ URL, and the env's browser may reach that app and nothing else (server/gui.py):
     penpot    one Docker-in-Docker sandbox running realapps/penpot/docker-compose.yaml, shared by all Penpot
               episodes; Penpot's public URI is the sandbox's preview URL, which is stable for the sandbox's lifetime
 
-Sandboxes carry the labels {"project": "design-canvas", "role": ...} and outlive the server: the next server reuses
+Sandboxes carry the labels {"project": "design-canvas", "role": ...} (plus "pool" when DESIGN_CANVAS_DAYTONA_POOL
+names a separate pool) and outlive the server: the next server of the same pool reuses
 them (starting stopped ones). While an episode runs (up to DESIGN_CANVAS_DAYTONA_MAX_EPISODE_MIN, default 120) the
 server keeps its sandbox awake; idle ones stop by themselves after DESIGN_CANVAS_DAYTONA_AUTO_STOP minutes (default
 15) and are started again when needed.
@@ -43,6 +44,17 @@ from .penpot.backend import PenpotBackend
 
 HERE = Path(__file__).parent
 PROJECT = {"project": "design-canvas"}
+
+
+def _pool() -> str | None:
+    """DESIGN_CANVAS_DAYTONA_POOL names a separate pool (e.g. "space" for the public Space): its sandboxes carry
+    that name as a label, so two servers on different machines never take each other's desktops. Unset = the
+    default pool, the sandboxes with no pool label."""
+    return os.environ.get("DESIGN_CANVAS_DAYTONA_POOL") or None
+
+
+def _labels(**extra) -> dict:
+    return {**PROJECT, **({"pool": _pool()} if _pool() else {}), **extra}
 PENPOT_PORT, AGENT_PORT = 9011, 5005
 HOME = "/home/user"  # the desktop image's user (realapps/desktop/Dockerfile)
 
@@ -86,9 +98,10 @@ class DaytonaApps:
     def sandboxes(self, role: str | None = None) -> list:
         from daytona import ListSandboxesQuery
 
-        labels = {**PROJECT, **({"role": role} if role else {})}
+        labels = _labels(**({"role": role} if role else {}))
         return [s for s in self.d.list(ListSandboxesQuery(labels=labels))
-                if str(s.state).split(".")[-1].lower() not in ("destroyed", "destroying", "error")]
+                if s.labels.get("pool") == _pool()  # a label query also matches other pools' sandboxes
+                and str(s.state).split(".")[-1].lower() not in ("destroyed", "destroying", "error")]
 
     def _state(self, sb) -> str:
         sb.refresh_data()
@@ -167,7 +180,7 @@ class DaytonaApps:
 
         def create(_):
             return self.d.create(CreateSandboxFromSnapshotParams(
-                snapshot=snap, labels={**PROJECT, "role": "desktop", "snapshot": snap},
+                snapshot=snap, labels=_labels(role="desktop", snapshot=snap),
                 auto_stop_interval=_auto_stop(), public=False), timeout=600)
 
         with ThreadPoolExecutor(max_workers=8) as pool:
@@ -210,7 +223,7 @@ class DaytonaApps:
 
         sbs = self.sandboxes("penpot")
         sb = sbs[0] if sbs else self.d.create(CreateSandboxFromImageParams(
-            image="docker:28.3.3-dind", labels={**PROJECT, "role": "penpot"},
+            image="docker:28.3.3-dind", labels=_labels(role="penpot"),
             resources=Resources(cpu=2, memory=4, disk=10), auto_stop_interval=_auto_stop(), public=False),
             timeout=600)
         self.prepare_penpot(sb)

scripts/deploy_space.py

@@ -36,6 +36,9 @@ def main(argv=None) -> int:
     ap.add_argument("--max-envs", type=int, default=32, help="concurrent environment sessions per worker")
     ap.add_argument("--workers", type=int, default=4, help="server processes behind the Space's one URL")
     ap.add_argument("--reward", default="3", help="DESIGN_CANVAS_REWARD (3 = reward v3, as the evals use)")
+    ap.add_argument("--daytona-desktops", type=int, default=0,
+                    help="run the real apps on Daytona with this many desktops (0 = no real apps); the key and URL "
+                         "are copied from DAYTONA_API_KEY / DAYTONA_API_URL into the Space's secrets")
     ap.add_argument("--transport", choices=["http", "mount"], default="http",
                     help="read designs over HTTP (default) or from the bucket mounted at /corpus; the mount returned "
                          "I/O errors under the workers' random reads (2026-10-05)")
@@ -82,8 +85,20 @@ def main(argv=None) -> int:
                        "DESIGN_CANVAS_PUBLIC_URL": f"https://{args.space.replace('/', '-').lower()}.hf.space"}.items():
         if key not in current or current[key].value != value:
             api.add_space_variable(args.space, key, value)
+    if args.daytona_desktops > 0:  # the Space's own pool, so it never takes a local server's desktops
+        import os
+
+        for key, value in {"DESIGN_CANVAS_APPS": "daytona", "DESIGN_CANVAS_DAYTONA_POOL": "space",
+                           "DESIGN_CANVAS_DAYTONA_DESKTOPS": str(args.daytona_desktops)}.items():
+            if key not in current or current[key].value != value:
+                api.add_space_variable(args.space, key, value)
+        for key in ("DAYTONA_API_KEY", "DAYTONA_API_URL"):
+            if os.environ.get(key):
+                api.add_space_secret(args.space, key, os.environ[key])
+    elif "DESIGN_CANVAS_APPS" in current:
+        api.delete_space_variable(args.space, "DESIGN_CANVAS_APPS")
     print(json.dumps({"space": args.space, "commit": commit.oid, "snapshot_id": manifest["snapshot_id"],
-                      "bucket": bucket, "transport": args.transport,
+                      "bucket": bucket, "transport": args.transport, "daytona_desktops": args.daytona_desktops,
                       "url": f"https://huggingface.co/spaces/{args.space}"}, indent=2))
     return 0
 

server/environment.py

@@ -201,7 +201,11 @@ class DesignCanvasEnvironment(MCPEnvironment):
             # A seeded reset also fixes where the file window opens and how it lists files.
             f"&fs={rng.randrange(1 << 30)}" if seed is not None else "")
         if skin in REAL_SKINS:  # a real app behind the same interface: its own editor, set up per episode
-            from ..realapps import READY, get_backend
+            from ..realapps import READY, available, get_backend
+
+            ok, why = available()
+            if not ok:
+                raise RuntimeError(f"{REAL_SKINS[skin][0]} is not available on this server: {why}")
 
             backend = get_backend(skin, fonts_dir=self.pack.root / "fonts")
             gt = self.pack.gt_doc(task)

server/gradio_ui.py

@@ -27,6 +27,7 @@ try:
     from ..core import expert
     from ..core.pack import TaskPack
     from ..core.score import CONFIGS
+    from ..realapps import available as apps_available
     from ..realapps import status as apps_status
     from .environment import DesignCanvasEnvironment
     from .episodes import REAL_SKINS, SKIN_INFO, STORE
@@ -34,6 +35,7 @@ except ImportError:
     from core import expert
     from core.pack import TaskPack
     from core.score import CONFIGS
+    from realapps import available as apps_available
     from realapps import status as apps_status
     from server.environment import DesignCanvasEnvironment
     from server.episodes import REAL_SKINS, SKIN_INFO, STORE
@@ -43,8 +45,13 @@ SKIN_CHOICES = SIM_CHOICES + [(f"{name} (real app)", sid) for sid, (name, _) in
 
 
 def skin_choices(surface: str) -> list:
-    """The editors a surface can use: real apps only work on computer use (the env rejects them elsewhere)."""
-    return SKIN_CHOICES if surface == "gui" else SIM_CHOICES
+    """The editors a surface can use: real apps only on computer use (the env rejects them elsewhere), and marked
+    when this server cannot reach them."""
+    if surface != "gui":
+        return SIM_CHOICES
+    ok, _ = apps_available()
+    return SIM_CHOICES + [(f"{name} (real app{'' if ok else ', not set up here'})", sid)
+                          for sid, (name, _) in REAL_SKINS.items()]
 MODE_CHOICES = [("Recreate from reference", "reference"), ("Build from brief", "description")]
 SURFACE_CHOICES = [("Tool calls", "tools"), ("HTML", "html"), ("Computer use", "gui")]
 CLICK_CHOICES = [("Click", "left_click"), ("Double-click", "double_click"), ("Right-click", "right_click")]
@@ -186,6 +193,8 @@ def build_ui(pack: TaskPack) -> gr.Blocks:
         real = skin in REAL_SKINS
         if real and surface != "gui":
             raise gr.Error(f"{REAL_SKINS[skin][0]} is a real app: it runs on Computer use only.")
+        if real and not apps_available()[0]:
+            raise gr.Error(f"{REAL_SKINS[skin][0]} is not available on this server: {apps_available()[1]}")
         if real:
             progress(0, desc=f"Opening {REAL_SKINS[skin][0]} (a real app: the first one can take a minute)")
         env, obs = pg.start(split, index, mode, surface, skin, previous)