robopark 3.2.0 → 3.3.0

package/scheduler/main.py

@@ -16,13 +16,16 @@ import hmac
 import time
 import uuid
 from datetime import datetime, timedelta
+from html import escape as html_escape
+from pathlib import Path
 from typing import Any, Optional, List
+from urllib.parse import quote
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Query, Header
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
-from fastapi.responses import HTMLResponse
+from fastapi.responses import HTMLResponse, FileResponse
 from pydantic import BaseModel
 import httpx
 import aiosqlite
@@ -1740,6 +1743,60 @@ async def _select_available_server(db):
         raise HTTPException(503, "All servers at capacity")
     return server
 
+async def _claim_character_device(
+    db,
+    *,
+    character_id: str,
+    join_link_id: str,
+    requested_robot_id: str,
+    client_name: str | None,
+    now: datetime,
+):
+    """Bind whichever device opened a character link to that character.
+
+    Production calls used to demand a pre-enrolled robot, which meant a freshly
+    imaged voice/vision box could not take a call until someone ran `robopark
+    enroll` on it. Instead the link itself is the identity: the claim is keyed on
+    the join link when there is one and on the character otherwise, so opening the
+    same link from a different browser transfers the character to that device and
+    ends the previous holder's live session.
+
+    Returns (robot_id, robot_video_ref).
+    """
+    claim_key = (join_link_id or f"character:{character_id}").strip()[:120]
+    device_id = "claim_" + hashlib.sha256(claim_key.encode("utf-8")).hexdigest()[:16]
+    label = (requested_robot_id or client_name or character_id or "claimed device").strip()[:80]
+    stamp = now.isoformat()
+
+    async with db.execute("SELECT id, name FROM devices WHERE id = ?", (device_id,)) as cursor:
+        existing = await cursor.fetchone()
+
+    if existing:
+        # Same link opened again: the newest device wins. Close whatever session
+        # the previous holder still had open so two browsers cannot both drive
+        # the character, then re-point the claim at the current caller.
+        await db.execute(
+            "UPDATE sessions SET ended_at = ?, end_reason = ? WHERE robot_id = ? AND ended_at IS NULL",
+            (stamp, "claim_transferred", device_id),
+        )
+        await db.execute(
+            "UPDATE devices SET character_id = ?, name = ?, status = ?, last_heartbeat = ? WHERE id = ?",
+            (character_id, label, "claimed", stamp, device_id),
+        )
+    else:
+        await db.execute(
+            """INSERT INTO devices (id, name, character_id, status, device_role,
+                                    last_heartbeat, enrolled_at, notes)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (device_id, label, character_id, "claimed", "voice_vision", stamp, stamp,
+             f"auto-claimed via join link {claim_key}"),
+        )
+    await db.commit()
+    # No MJPEG ref: a claimed device publishes its own browser camera rather than
+    # exposing a robot-side vision server, so the page falls back to local video.
+    return device_id, None
+
+
 @app.post("/api/sessions/voice-call")
 async def create_voice_call(payload: VoiceCallRequest):
     """Create a browser voice call using a frozen character and voice stack.
@@ -1788,17 +1845,30 @@ async def create_voice_call(payload: VoiceCallRequest):
         robot_id = "operator-test"
         robot_video_ref = None
         if call_mode == "production":
-            if not requested_robot_id:
-                raise HTTPException(422, "Production calls require a registered robot")
-            async with db.execute(
-                "SELECT id, name FROM devices WHERE id = ? OR lower(name) = lower(?) ORDER BY last_heartbeat DESC LIMIT 1",
-                (requested_robot_id, requested_robot_id),
-            ) as cursor:
-                robot_device = await cursor.fetchone()
-            if not robot_device:
-                raise HTTPException(404, f"Production robot '{requested_robot_id}' is not registered")
-            robot_id = robot_device["id"]
-            robot_video_ref = robot_device["name"] or robot_device["id"]
+            # Claim-based binding. A production call no longer requires hardware to
+            # have been enrolled ahead of time: whichever device opens the character
+            # link claims that character, and holds it until another device opens the
+            # same link. An explicitly requested robot that is already registered
+            # still wins, so existing enrolled fleets behave exactly as before.
+            robot_device = None
+            if requested_robot_id:
+                async with db.execute(
+                    "SELECT id, name FROM devices WHERE id = ? OR lower(name) = lower(?) ORDER BY last_heartbeat DESC LIMIT 1",
+                    (requested_robot_id, requested_robot_id),
+                ) as cursor:
+                    robot_device = await cursor.fetchone()
+            if robot_device:
+                robot_id = robot_device["id"]
+                robot_video_ref = robot_device["name"] or robot_device["id"]
+            else:
+                robot_id, robot_video_ref = await _claim_character_device(
+                    db,
+                    character_id=character["id"],
+                    join_link_id=join_link_id,
+                    requested_robot_id=requested_robot_id,
+                    client_name=payload.client_name,
+                    now=now,
+                )
         metadata = {
             "control_center": True,
             "character_id": character["id"],
@@ -6993,6 +7063,114 @@ async def voice_client():
     </body></html>
     """
 
+# ==========================================================================
+# Operator-facing pages served directly by the scheduler.
+#
+# These used to live behind the Next frontend (Docker) and the federation mesh
+# hub, which meant a one-command deploy was impossible and the join page existed
+# in three diverging copies. The scheduler already owns the character bindings
+# and mints the ElevenLabs signed URLs, so it serves the pages too: `robopark
+# serve` alone is now enough, and joining devices need only a browser.
+# ==========================================================================
+
+STATIC_DIR = Path(__file__).resolve().parent / "static"
+
+
+@app.get("/voice-join.html", include_in_schema=False)
+async def voice_join_page():
+    """The character call page. Visitors open this; no install, no credentials."""
+    page = STATIC_DIR / "voice-join.html"
+    if not page.exists():
+        raise HTTPException(404, "voice-join.html is missing from this install")
+    return FileResponse(page, media_type="text/html; charset=utf-8")
+
+
+@app.get("/vendor/elevenlabs-client.iife.js", include_in_schema=False)
+async def elevenlabs_browser_client():
+    """Vendored ElevenLabs browser SDK, so joining devices need no npm install."""
+    asset = STATIC_DIR / "vendor" / "elevenlabs-client.iife.js"
+    if not asset.exists():
+        raise HTTPException(404, "ElevenLabs browser client is missing from this install")
+    return FileResponse(asset, media_type="application/javascript; charset=utf-8")
+
+
+def _call_link(character_id: str, agent_id: str, branch_id: str | None, mode: str) -> str:
+    query = f"character={quote(character_id)}&agent_id={quote(agent_id)}&mode={mode}"
+    if branch_id:
+        query += f"&branch_id={quote(branch_id)}"
+    return f"/voice-join.html?{query}"
+
+
+@app.get("/calls", response_class=HTMLResponse, include_in_schema=False)
+async def call_links_page():
+    """One page listing every preconfigured character call link, ready to copy.
+
+    Production links no longer depend on enrolled hardware — the first device to
+    open one claims that character — so every character with a bound ElevenLabs
+    agent gets a working production link here.
+    """
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            """SELECT id, name, elevenlabs_agent_id, elevenlabs_branch_id, default_engine
+               FROM character_presets ORDER BY name"""
+        ) as cursor:
+            characters = await cursor.fetchall()
+
+    rows = []
+    ready = 0
+    for character in characters:
+        name = html_escape(str(character["name"] or character["id"]))
+        agent_id = (character["elevenlabs_agent_id"] or "").strip()
+        if not agent_id:
+            rows.append(
+                f'<tr class="blocked"><td>{name}</td><td colspan="2">'
+                "no ElevenLabs agent bound — set one in the Control Center</td></tr>"
+            )
+            continue
+        ready += 1
+        link = _call_link(character["id"], agent_id, character["elevenlabs_branch_id"], "production")
+        test = _call_link(character["id"], agent_id, character["elevenlabs_branch_id"], "test")
+        rows.append(
+            f"<tr><td>{name}<span class=agent>{html_escape(agent_id)}</span></td>"
+            f'<td><a href="{link}">production</a>'
+            f'<button data-link="{link}">copy</button></td>'
+            f'<td><a href="{test}">test</a><button data-link="{test}">copy</button></td></tr>'
+        )
+
+    return f"""<!doctype html><html lang=en><head><meta charset=utf-8>
+<meta name=viewport content="width=device-width,initial-scale=1">
+<title>RoboPark character call links</title><style>
+body{{margin:0;padding:clamp(16px,4vw,40px);background:#0b0a07;color:#f4efe2;
+font:15px/1.5 Verdana,Geneva,sans-serif}}
+h1{{margin:0 0 4px;font:700 1.6rem Georgia,serif;color:#ffe9a8}}
+p.sub{{margin:0 0 22px;color:#a99e84;font-size:.85rem}}
+table{{width:100%;border-collapse:collapse;max-width:1000px}}
+th{{text-align:left;padding:.55rem .6rem;color:#a99e84;font:600 .7rem monospace;
+text-transform:uppercase;letter-spacing:.1em;border-bottom:1px solid #3a3222}}
+td{{padding:.7rem .6rem;border-bottom:1px solid #211d14;vertical-align:top}}
+.agent{{display:block;color:#7e755f;font:.62rem monospace;margin-top:.2rem}}
+a{{color:#f4cf72}}button{{margin-left:.5rem;border:1px solid #4a4130;border-radius:7px;
+background:#171308;color:#f4cf72;padding:.24rem .5rem;font:.68rem monospace;cursor:pointer}}
+button:hover{{background:#241d0e}}tr.blocked td{{color:#ff9d93}}
+</style></head><body>
+<h1>Character call links</h1>
+<p class=sub>{ready} of {len(characters)} characters ready ·
+production links claim the character for whichever device opens them ·
+no enrollment and no install required</p>
+<table><tr><th>Character</th><th>Production</th><th>Browser test</th></tr>
+{''.join(rows)}</table>
+<script>
+document.addEventListener('click',function(e){{
+  var b=e.target.closest('button[data-link]');if(!b)return;
+  var url=location.origin+b.getAttribute('data-link');
+  navigator.clipboard.writeText(url).then(function(){{
+    var t=b.textContent;b.textContent='copied';setTimeout(function(){{b.textContent=t}},1200);
+  }});
+}});
+</script></body></html>"""
+
+
 @app.get("/", response_class=HTMLResponse)
 async def dashboard():
     """Serve embedded dashboard"""
@@ -7009,14 +7187,15 @@ async def dashboard():
     </head>
     <body class="bg-gray-900 text-white">
         <div class="bg-amber-950 border-b border-amber-600 px-4 py-3 text-sm text-amber-100">
-            <strong>Scheduler service view.</strong> The canonical operator UI is the full standalone RoboPark Control Center on this gateway at port 47913.
-            <a id="fullControlCenterLink" class="underline ml-2" href="#">Open full Park Control Center</a>
+            <strong>RoboPark Control Center.</strong> Character call links are ready to copy &mdash; production links claim the character for whichever device opens them, so no enrollment is needed.
+            <a id="fullControlCenterLink" class="underline ml-2" href="/calls">Open character call links</a>
         </div>
         <div id="app"></div>
         <script>
-            const fullControlCenterLink = document.getElementById('fullControlCenterLink');
-            const meshHost = window.location.hostname || 'localhost';
-            fullControlCenterLink.href = `${window.location.protocol}//${meshHost}:47913/${window.location.search}#park`;
+            // The call links are served by this same process now; the old link
+            // pointed at the federation mesh hub on 47913, which is no longer
+            // required to run a deployment.
+            document.getElementById('fullControlCenterLink').href = '/calls';
             const { createApp, ref, computed, onMounted, onUnmounted } = Vue;
             
             createApp({

package/scheduler/media_lock.py

@@ -1,57 +1,57 @@
-"""Cross-process media ownership for Linux robot appliances."""
-from __future__ import annotations
-
-import os
-import sys
-import time
-from pathlib import Path
-from typing import Optional
-
-
-class MediaLock:
-    def __init__(self, kind: str, timeout: float = 5.0):
-        self.kind = kind
-        self.timeout = timeout
-        self.fd: Optional[int] = None
-
-    def acquire(self) -> "MediaLock":
-        if not sys.platform.startswith("linux"):
-            return self
-        import fcntl
-
-        lock_dir = Path("/run/lock") if os.access("/run/lock", os.W_OK) else Path("/tmp")
-        path = lock_dir / f"robopark-{self.kind}.lock"
-        self.fd = os.open(path, os.O_CREAT | os.O_RDWR, 0o660)
-        deadline = time.monotonic() + self.timeout
-        while True:
-            try:
-                fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                os.ftruncate(self.fd, 0)
-                os.write(self.fd, f"{os.getpid()}\n".encode("ascii"))
-                return self
-            except BlockingIOError:
-                if time.monotonic() >= deadline:
-                    self.release()
-                    raise TimeoutError(f"{self.kind} is owned by another RoboPark media process")
-                time.sleep(0.05)
-
-    def release(self) -> None:
-        if self.fd is None:
-            return
-        try:
-            if sys.platform.startswith("linux"):
-                import fcntl
-                fcntl.flock(self.fd, fcntl.LOCK_UN)
-        finally:
-            os.close(self.fd)
-            self.fd = None
-
-    def __enter__(self) -> "MediaLock":
-        return self.acquire()
-
-    def __exit__(self, exc_type, exc, traceback) -> None:
-        self.release()
-
-
-def media_lock(kind: str, timeout: float = 5.0) -> MediaLock:
-    return MediaLock(kind, timeout)
+"""Cross-process media ownership for Linux robot appliances."""
+from __future__ import annotations
+
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+
+class MediaLock:
+    def __init__(self, kind: str, timeout: float = 5.0):
+        self.kind = kind
+        self.timeout = timeout
+        self.fd: Optional[int] = None
+
+    def acquire(self) -> "MediaLock":
+        if not sys.platform.startswith("linux"):
+            return self
+        import fcntl
+
+        lock_dir = Path("/run/lock") if os.access("/run/lock", os.W_OK) else Path("/tmp")
+        path = lock_dir / f"robopark-{self.kind}.lock"
+        self.fd = os.open(path, os.O_CREAT | os.O_RDWR, 0o660)
+        deadline = time.monotonic() + self.timeout
+        while True:
+            try:
+                fcntl.flock(self.fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                os.ftruncate(self.fd, 0)
+                os.write(self.fd, f"{os.getpid()}\n".encode("ascii"))
+                return self
+            except BlockingIOError:
+                if time.monotonic() >= deadline:
+                    self.release()
+                    raise TimeoutError(f"{self.kind} is owned by another RoboPark media process")
+                time.sleep(0.05)
+
+    def release(self) -> None:
+        if self.fd is None:
+            return
+        try:
+            if sys.platform.startswith("linux"):
+                import fcntl
+                fcntl.flock(self.fd, fcntl.LOCK_UN)
+        finally:
+            os.close(self.fd)
+            self.fd = None
+
+    def __enter__(self) -> "MediaLock":
+        return self.acquire()
+
+    def __exit__(self, exc_type, exc, traceback) -> None:
+        self.release()
+
+
+def media_lock(kind: str, timeout: float = 5.0) -> MediaLock:
+    return MediaLock(kind, timeout)