infinicode 2.8.108 → 2.8.113

package/packages/robopark/scheduler/main.py

@@ -219,9 +219,11 @@ class DeviceEnrollRequest(BaseModel):
 
 class DeviceBootstrapRequest(BaseModel):
     name: str
+    character_id: Optional[str] = None
     lan_ip: Optional[str] = None
     tailscale_ip: Optional[str] = None
     livekit_url: Optional[str] = None
+    motor_server_url: Optional[str] = None
 
 class DeviceEnrollResponse(BaseModel):
     device_id: str
@@ -235,6 +237,7 @@ class DeviceHeartbeat(BaseModel):
     production_mode: Optional[bool] = None
     device_inventory: Optional[dict] = None
     livekit_url: Optional[str] = None
+    motor_server_url: Optional[str] = None
 
 class PipelineEventPayload(BaseModel):
     stage: str
@@ -2982,25 +2985,25 @@ async def bootstrap_device(
             await db.execute(
                 """UPDATE devices SET token_hash = ?, status = 'enrolled',
                    lan_ip = COALESCE(?, lan_ip), tailscale_ip = COALESCE(?, tailscale_ip),
-                   livekit_url = COALESCE(?, livekit_url),
+                   livekit_url = COALESCE(?, livekit_url), motor_server_url = COALESCE(?, motor_server_url),
+                   character_id = COALESCE(?, character_id),
                    enrolled_at = COALESCE(enrolled_at, ?) WHERE id = ?""",
-                (new_hash, payload.lan_ip, payload.tailscale_ip, payload.livekit_url, now, device_id),
+                (new_hash, payload.lan_ip, payload.tailscale_ip, payload.livekit_url,
+                 payload.motor_server_url, payload.character_id, now, device_id),
             )
         else:
             device_id = f"dev_{secrets.token_hex(4)}"
             await db.execute(
                 """INSERT INTO devices
-                   (id, name, lan_ip, tailscale_ip, livekit_url, token_hash, status, enrolled_at, created_at)
-                   VALUES (?, ?, ?, ?, ?, ?, 'enrolled', ?, ?)""",
-                (device_id, name, payload.lan_ip, payload.tailscale_ip, payload.livekit_url, new_hash, now, now),
+                   (id, name, lan_ip, tailscale_ip, livekit_url, motor_server_url, character_id, token_hash, status, enrolled_at, created_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'enrolled', ?, ?)""",
+                (device_id, name, payload.lan_ip, payload.tailscale_ip, payload.livekit_url,
+                 payload.motor_server_url, payload.character_id, new_hash, now, now),
             )
         await db.execute(
             "INSERT OR IGNORE INTO robots (id, name, status) VALUES (?, ?, 'idle')",
             (device_id, name),
         )
-    for field in ("motor_registry", "motor_sequences"):
-        if field in fields:
-            fields[field] = json.dumps(fields[field], separators=(",", ":"))
         await db.execute("UPDATE robots SET name = ? WHERE id = ?", (name, device_id))
         await db.commit()
 
@@ -3165,7 +3168,8 @@ async def device_heartbeat(device_id: str, payload: DeviceHeartbeat,
                    lan_ip = COALESCE(?, lan_ip),
                    last_seen_ip = COALESCE(?, last_seen_ip),
                    device_inventory = COALESCE(?, device_inventory),
-                   livekit_url = COALESCE(?, livekit_url)
+                   livekit_url = COALESCE(?, livekit_url),
+                   motor_server_url = COALESCE(?, motor_server_url)
                WHERE id = ?""",
             (
                 payload.status or "online",
@@ -3174,6 +3178,7 @@ async def device_heartbeat(device_id: str, payload: DeviceHeartbeat,
                 payload.ip,
                 json.dumps(payload.device_inventory) if payload.device_inventory is not None else None,
                 payload.livekit_url,
+                payload.motor_server_url,
                 device_id,
             ),
         ) as cur:
@@ -3738,6 +3743,49 @@ async def device_supervisor_output(device_id: str, payload: dict, authorization:
             session_id=result_payload.get("session_id"), source="robot_supervisor",
             details={"request_id": request_id, "duration_ms": result_payload.get("duration_ms")},
         ))
+    if kind == "motor_discover" and ok and isinstance(result_payload.get("registry"), list):
+        device = await _resolve_device_by_id_or_name(device_id)
+        model = _device_row_to_model(device)
+        discovered_ids = {
+            str(item.get("id")) for item in result_payload["registry"] if isinstance(item, dict)
+        }
+        reconciled_sequences = []
+        for sequence in model.motor_sequences:
+            clean_steps = [
+                step for step in (sequence.get("steps") or [])
+                if str(step.get("motor_id")) in discovered_ids
+            ]
+            reconciled_sequences.append({**sequence, "steps": clean_steps})
+        registry, sequences, greeting = _sanitize_motor_profile(MotorProfilePayload(
+            registry=result_payload["registry"],
+            sequences=reconciled_sequences,
+            greeting_sequence_id=model.greeting_motor_sequence_id,
+        ))
+        result_payload.update({
+            "registry": registry,
+            "sequences": sequences,
+            "greeting_sequence_id": greeting,
+            "persisted": True,
+        })
+        async with aiosqlite.connect(DB_PATH) as db:
+            await db.execute(
+                "UPDATE devices SET motor_registry=?, motor_sequences=?, greeting_motor_sequence_id=? WHERE id=?",
+                (json.dumps(registry), json.dumps(sequences), greeting, device_id),
+            )
+            await db.execute(
+                "UPDATE shell_requests SET result_payload=? WHERE id=?",
+                (json.dumps(result_payload), request_id),
+            )
+            await db.commit()
+        character_id = await _sync_character_motor_sequences(device_id, sequences)
+        result_payload["character_id"] = character_id
+        result_payload["allowed_motor_sequences"] = [
+            item["id"] for item in sequences if item.get("steps")
+        ]
+        await _log_history(
+            "motor", "device", device_id, "registry_discovered", "robot_supervisor",
+            f"motors={len(registry)}",
+        )
     return {"status": "ok"}
 
 
@@ -4030,19 +4078,44 @@ def _sanitize_motor_profile(payload: MotorProfilePayload) -> tuple[list, list, O
             raise HTTPException(422, f"Invalid or duplicate sequence id: {sequence_id!r}")
         sequence_ids.add(sequence_id)
         steps = []
+        total_duration_ms = 0
         for step in (raw.get("steps") or [])[:40]:
             motor_id = str(step.get("motor_id") or "")
             if motor_id not in ids:
                 raise HTTPException(422, f"Sequence {sequence_id} references unknown motor {motor_id}")
             motor = next(item for item in registry if item["id"] == motor_id)
             duration = max(50, min(motor["max_duration_ms"], int(step.get("duration_ms", 500))))
-            steps.append({"motor_id": motor_id, "delay_ms": max(0, min(30000, int(step.get("delay_ms", 0)))), "duration_ms": duration})
+            delay = max(0, min(30000, int(step.get("delay_ms", 0))))
+            total_duration_ms += delay + duration
+            if total_duration_ms > 60000:
+                raise HTTPException(422, f"Sequence {sequence_id} exceeds the 60 second safety limit")
+            steps.append({"motor_id": motor_id, "delay_ms": delay, "duration_ms": duration})
         sequences.append({"id": sequence_id, "name": str(raw.get("name") or sequence_id)[:80], "steps": steps})
     greeting = payload.greeting_sequence_id or None
     if greeting and greeting not in sequence_ids:
         raise HTTPException(422, "Greeting sequence does not exist")
     return registry, sequences, greeting
 
+async def _sync_character_motor_sequences(device_id: str, sequences: list) -> Optional[str]:
+    """Point the assigned character at this robot's validated sequence IDs."""
+    sequence_ids = [str(item["id"]) for item in sequences if item.get("id") and item.get("steps")]
+    async with aiosqlite.connect(DB_PATH) as db:
+        db.row_factory = aiosqlite.Row
+        async with db.execute(
+            "SELECT COALESCE(rvc.character_preset_id, d.character_id) AS character_id "
+            "FROM devices d LEFT JOIN robot_voice_configs rvc ON rvc.robot_id=d.id WHERE d.id=?",
+            (device_id,),
+        ) as cursor:
+            row = await cursor.fetchone()
+        character_id = row["character_id"] if row else None
+        if character_id:
+            await db.execute(
+                "UPDATE character_presets SET motors=?, updated_at=? WHERE id=?",
+                (json.dumps(sequence_ids), datetime.utcnow().isoformat(), character_id),
+            )
+            await db.commit()
+    return character_id
+
 @app.get("/api/robots/{robot_id}/motor-profile")
 async def robot_motor_profile(robot_id: str):
     device = await _resolve_device_by_id_or_name(robot_id)
@@ -4059,8 +4132,11 @@ async def save_robot_motor_profile(robot_id: str, payload: MotorProfilePayload):
         await db.execute("UPDATE devices SET motor_registry=?, motor_sequences=?, greeting_motor_sequence_id=? WHERE id=?",
                          (json.dumps(registry), json.dumps(sequences), greeting, device["id"]))
         await db.commit()
+    character_id = await _sync_character_motor_sequences(device["id"], sequences)
     await _log_history("motor", "device", device["id"], "profile_saved", "operator", f"motors={len(registry)}, sequences={len(sequences)}")
-    return {"status": "ok", "robot_id": device["id"], "registry": registry, "sequences": sequences, "greeting_sequence_id": greeting}
+    return {"status": "ok", "robot_id": device["id"], "registry": registry, "sequences": sequences,
+            "greeting_sequence_id": greeting, "character_id": character_id,
+            "allowed_motor_sequences": [item["id"] for item in sequences if item.get("steps")]}
 
 async def _queue_motor_sequence(device_id: str, sequence_id: str, session_id: Optional[str] = None) -> dict:
     device = await _resolve_device_by_id_or_name(device_id)
@@ -4068,6 +4144,8 @@ async def _queue_motor_sequence(device_id: str, sequence_id: str, session_id: Op
     sequence = next((item for item in model.motor_sequences if item.get("id") == sequence_id), None)
     if not sequence:
         raise HTTPException(404, "Motor sequence not found")
+    if not sequence.get("steps"):
+        raise HTTPException(409, "Motor sequence has no steps")
     if not model.motor_server_url:
         raise HTTPException(409, "Robot has no motor_server_url")
     request_id = await _queue_shell_request_async(model.id, "motor_sequence", "motor_server", {
@@ -4130,8 +4208,45 @@ async def run_room_motor_sequence(
             session = await cursor.fetchone()
     if not session:
         raise HTTPException(404, "No active session bound to this room")
+    if agent_authorized and not fleet_authorized:
+        async with aiosqlite.connect(DB_PATH) as db:
+            db.row_factory = aiosqlite.Row
+            async with db.execute(
+                "SELECT COALESCE(rvc.character_preset_id, d.character_id) AS character_id "
+                "FROM devices d LEFT JOIN robot_voice_configs rvc ON rvc.robot_id=d.id WHERE d.id=?",
+                (session["robot_id"],),
+            ) as cursor:
+                character_row = await cursor.fetchone()
+            character_id = character_row["character_id"] if character_row else None
+            allowed = []
+            if character_id:
+                async with db.execute("SELECT motors FROM character_presets WHERE id=?", (character_id,)) as cursor:
+                    preset = await cursor.fetchone()
+                if preset and preset["motors"]:
+                    try:
+                        allowed = [str(item) for item in json.loads(preset["motors"]) if isinstance(item, str)]
+                    except Exception:
+                        allowed = []
+        if sequence_id not in allowed:
+            raise HTTPException(
+                403,
+                f"Character {character_id or 'unassigned'} is not allowed to run motor sequence {sequence_id}",
+            )
     return await _queue_motor_sequence(session["robot_id"], sequence_id, session["id"])
 
+@app.post("/api/robots/{robot_id}/motors/stop")
+async def stop_robot_motors(robot_id: str):
+    device = await _resolve_device_by_id_or_name(robot_id)
+    model = _device_row_to_model(device)
+    if not model.motor_server_url:
+        raise HTTPException(409, "Robot has no motor_server_url")
+    request_id = await _queue_shell_request_async(model.id, "motor_sequence", "motor_server", {
+        "motor_server_url": model.motor_server_url,
+        "stop_all": True,
+    })
+    await _log_history("motor", "device", model.id, "emergency_stop_queued", "operator", request_id)
+    return {"queued": True, "request_id": request_id, "device_id": model.id}
+
 @app.post("/api/robots/{robot_id}/motors/{motor_id}/test")
 async def test_robot_motor(robot_id: str, motor_id: str, duration_ms: int = 300):
     device = await _resolve_device_by_id_or_name(robot_id)
@@ -4425,13 +4540,14 @@ class VoiceStackCreate(BaseModel):
     wake_word_timeout: float = 3.0
 
 # Effective configuration returned to the ROBOVOICE agent for a given room/robot.
-class RobotVoiceConfig(BaseModel):
+class RobotVoiceConfig(BaseModel):
     character_id: Optional[str] = None
     character_name: Optional[str] = None
     system_prompt: Optional[str] = None
     voice_stack_id: Optional[str] = None
     voice_stack: Optional[VoiceStack] = None
-    greeting_phrases: List[str] = []
+    greeting_phrases: List[str] = []
+    allowed_motor_sequences: List[str] = []
 
 def _load_robovoice_settings() -> dict:
     """Read the ROBOVOICE settings file. Returns {} if missing/invalid."""
@@ -4612,8 +4728,9 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
 
         # Determine character preset + name
         character_id = None
-        character_name = None
-        system_prompt = None
+        character_name = None
+        system_prompt = None
+        allowed_motor_sequences = []
         async with db.execute(
             "SELECT character_preset_id FROM robot_voice_configs WHERE robot_id = ?", (canonical_id,)
         ) as c:
@@ -4630,12 +4747,19 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
                     character_id = row["character_id"]
         if character_id:
             async with db.execute(
-                "SELECT name, description, system_prompt FROM character_presets WHERE id = ?", (character_id,)
+                "SELECT name, description, system_prompt, motors FROM character_presets WHERE id = ?", (character_id,)
             ) as c:
                 row = await c.fetchone()
                 if row:
-                    character_name = row["name"]
-                    system_prompt = row["system_prompt"]
+                    character_name = row["name"]
+                    system_prompt = row["system_prompt"]
+                    try:
+                        allowed_motor_sequences = [
+                            str(item) for item in _json.loads(row["motors"] or "[]")
+                            if isinstance(item, str)
+                        ]
+                    except Exception:
+                        allowed_motor_sequences = []
             if not character_name:
                 async with db.execute(
                     "SELECT name FROM robots WHERE id = ? UNION ALL SELECT name FROM devices WHERE id = ?",
@@ -4663,8 +4787,9 @@ async def _resolve_robot_voice_config(robot_id: str) -> RobotVoiceConfig:
             character_name=character_name,
             system_prompt=system_prompt,
             voice_stack_id=voice_stack.id if voice_stack else None,
-            voice_stack=voice_stack,
+            voice_stack=voice_stack,
             greeting_phrases=greeting_phrases,
+            allowed_motor_sequences=allowed_motor_sequences,
         )
 
 async def _resolve_session_voice_config(session_row) -> RobotVoiceConfig:

package/packages/robopark/scheduler/robot_supervisor.py

@@ -59,7 +59,24 @@ BACKOFF_BASE_SECONDS = 2.0
 BACKOFF_MAX_SECONDS = 60.0
 LOG_ROTATE_BYTES = 5 * 1024 * 1024  # rotate a service's log past 5MB
 POLL_INTERVAL_SECONDS = 2.0
-STATUS_REPORT_INTERVAL_SECONDS = 10.0
+STATUS_REPORT_INTERVAL_SECONDS = 10.0
+
+
+def _scheduler_headers(token: str) -> dict[str, str]:
+    """Authenticate the enrolled device and, when present, the mesh proxy."""
+    headers = {"Authorization": f"Bearer {token}"}
+    mesh_token = os.getenv("ROBOPARK_MESH_TOKEN", "").strip()
+    if mesh_token:
+        headers["X-RoboPark-Mesh-Token"] = mesh_token
+    return headers
+
+
+def _motor_headers() -> dict[str, str]:
+    token = (
+        os.getenv("ROBOPARK_MOTOR_TOKEN", "").strip()
+        or os.getenv("ROBOPARK_MESH_TOKEN", "").strip()
+    )
+    return {"X-RoboPark-Motor-Token": token} if token else {}
 
 
 def _load_robopark_identity() -> Optional[tuple[str, str, str]]:
@@ -97,7 +114,7 @@ def _report_status(states: "list[ServiceState]", identity: tuple[str, str, str])
     payload = {"services": [s.status_dict() for s in states]}
     url = f"{scheduler_url.rstrip('/')}/api/devices/{device_id}/supervisor-status"
     try:
-        resp = httpx.post(url, json=payload, headers={"Authorization": f"Bearer {token}"}, timeout=5.0)
+        resp = httpx.post(url, json=payload, headers=_scheduler_headers(token), timeout=5.0)
         resp.raise_for_status()
         return resp.json().get("commands", [])
     except Exception as e:
@@ -398,7 +415,7 @@ def _post_supervisor_output(identity, kind: str, service: Optional[str], payload
     url = f"{scheduler_url.rstrip('/')}/api/devices/{device_id}/supervisor-output"
     body = {"kind": kind, "service": service, "payload": payload, "request_id": request_id}
     try:
-        httpx.post(url, json=body, headers={"Authorization": f"Bearer {token}"}, timeout=5.0)
+        httpx.post(url, json=body, headers=_scheduler_headers(token), timeout=5.0)
     except Exception as e:
         logger.debug(f"supervisor-output POST failed: {e}")
 
@@ -445,7 +462,7 @@ def _discover_motor_registry(params: dict) -> dict:
     if not (base.startswith("http://127.0.0.1:") or base.startswith("http://localhost:")):
         return {"ok": False, "error": "motor server must be robot-local"}
     try:
-        with httpx.Client(timeout=5.0) as client:
+        with httpx.Client(timeout=5.0, headers=_motor_headers()) as client:
             response = client.get(f"{base}/list-motors")
             response.raise_for_status()
             raw_motors = response.json().get("motors", [])
@@ -487,7 +504,11 @@ def _run_motor_sequence(params: dict) -> dict:
     completed = []
     gpio_log = []
     try:
-        with httpx.Client(timeout=8.0) as client:
+        with httpx.Client(timeout=8.0, headers=_motor_headers()) as client:
+            if params.get("stop_all"):
+                response = client.post(f"{base}/stop-motors", json={})
+                response.raise_for_status()
+                return {"ok": True, "stopped": True, "sequence_id": "emergency-stop"}
             existing = client.get(f"{base}/list-motors").json().get("motors", [])
             existing_names = {str(item.get("name")) for item in existing}
             for motor_id, motor in registry.items():
@@ -556,7 +577,7 @@ def _run_motor_sequence(params: dict) -> dict:
                 completed.append({"motor_id": motor_id, "gpio": int(motor["gpio"]), "duration_ms": duration_ms})
     except Exception as exc:
         try:
-            httpx.post(f"{base}/stop-motors", json={}, timeout=3.0)
+            httpx.post(f"{base}/stop-motors", json={}, headers=_motor_headers(), timeout=3.0)
         except Exception:
             pass
         return {"ok": False, "error": f"{type(exc).__name__}: {exc}", "completed_steps": completed,
@@ -1095,12 +1116,17 @@ def _speaker_roundtrip_test(params: dict) -> dict:
     }
 
 
-def run(config_path: Path) -> None:
-    global _CURRENT_LOG_DIR
-    services, log_dir = _load_config(config_path)
+def run(config_path: Path, commands_only: bool = False) -> None:
+    global _CURRENT_LOG_DIR
+    if commands_only:
+        # Unified robot-runtime already owns preview, vision, audio and motors.
+        # Do not require a legacy supervisor config or launch duplicate owners.
+        services, log_dir = [], LOG_DIR
+    else:
+        services, log_dir = _load_config(config_path)
     _CURRENT_LOG_DIR = log_dir
     enabled = [s for s in services if s.enabled]
-    if not enabled:
+    if not enabled and not commands_only:
         raise SystemExit(f"No enabled services in {config_path} — nothing to supervise.")
 
     states = [ServiceState(spec=s) for s in enabled]
@@ -1116,7 +1142,10 @@ def run(config_path: Path) -> None:
     signal.signal(signal.SIGINT, _on_signal)
     signal.signal(signal.SIGTERM, _on_signal)
 
-    logger.info(f"supervising {len(states)} service(s): {', '.join(s.spec.name for s in states)}")
+    if commands_only:
+        logger.info("command-only supervisor active; waiting for scheduler requests")
+    else:
+        logger.info(f"supervising {len(states)} service(s): {', '.join(s.spec.name for s in states)}")
 
     last_status_report_at = 0.0
     try:
@@ -1157,7 +1186,7 @@ def run(config_path: Path) -> None:
                             _execute_command(target, cmd.get("action", "restart"))
                         elif kind == "supervisor_action":
                             logger.warning(f"remote command for unknown service {cmd.get('service_name')!r} ignored")
-                        elif kind in ("shell_run", "tail_logs", "speaker_test", "motor_sequence"):
+                        elif kind in ("shell_run", "tail_logs", "speaker_test", "motor_discover", "motor_sequence"):
                             # run on a background thread so we don't block
                             # the 2s poll loop on a slow command
                             import threading
@@ -1181,9 +1210,11 @@ def main() -> None:
     sys.stderr.reconfigure(line_buffering=True)
     logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG_FILE, help="path to supervisor.json")
-    args = parser.parse_args()
-    run(args.config)
+    parser.add_argument("--config", type=Path, default=DEFAULT_CONFIG_FILE, help="path to supervisor.json")
+    parser.add_argument("--commands-only", action="store_true",
+                        help="consume remote commands without launching duplicate robot services")
+    args = parser.parse_args()
+    run(args.config, commands_only=args.commands_only)
 
 
 if __name__ == "__main__":

package/packages/robopark/vision/motor_server.py

@@ -1,30 +1,50 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from typing import Optional, List
 import time
 import threading
-import json
+import json
 import os
+import hmac
 
 try:
     import lgpio
 except ImportError:
     lgpio = None
 
-app = FastAPI(title="Motor Control API", version="1.0.0")
-
-# CORS Configuration - Allow all origins for cross-origin requests
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins
-    allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods (GET, POST, PUT, DELETE, OPTIONS)
-    allow_headers=["*"],  # Allows all headers
-)
+app = FastAPI(title="Motor Control API", version="1.1.0")
+
+MOTOR_API_TOKEN = (
+    os.getenv("ROBOPARK_MOTOR_TOKEN", "").strip()
+    or os.getenv("ROBOPARK_MESH_TOKEN", "").strip()
+)
+
+
+@app.middleware("http")
+async def require_motor_token(request: Request, call_next):
+    """Keep actuation private even if an operator accidentally changes the bind host."""
+    if MOTOR_API_TOKEN and request.url.path not in {"/", "/status"}:
+        supplied = request.headers.get("x-robopark-motor-token", "").strip()
+        if not supplied or not hmac.compare_digest(supplied, MOTOR_API_TOKEN):
+            return JSONResponse(status_code=401, content={"detail": "Invalid or missing motor token"})
+    return await call_next(request)
+
+# The dashboard never calls this service directly; robot-local services do.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://127.0.0.1", "http://localhost"],
+    allow_credentials=False,
+    allow_methods=["GET", "POST", "PUT", "DELETE"],
+    allow_headers=["content-type", "x-robopark-motor-token"],
+)
 
 # Storage file
-MOTORS_FILE = "motors.json"
+MOTORS_FILE = os.getenv(
+    "ROBOPARK_MOTORS_FILE",
+    os.path.expanduser("~/.robopark/motors.json"),
+)
 
 # In-memory storage
 motors = {}
@@ -63,11 +83,16 @@ def load_motors():
         print(f"[ERROR] Failed to load motors: {e}")
         motors = {}
 
-def save_motors():
+def save_motors():
     """Save motors to motors.json file"""
     try:
-        with open(MOTORS_FILE, 'w') as f:
-            json.dump(motors, f, indent=2)
+        os.makedirs(os.path.dirname(os.path.abspath(MOTORS_FILE)), exist_ok=True)
+        temporary = f"{MOTORS_FILE}.tmp"
+        with open(temporary, 'w') as f:
+            json.dump(motors, f, indent=2)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(temporary, MOTORS_FILE)
         print(f"[SAVE] Motors saved to {MOTORS_FILE}")
     except Exception as e:
         print(f"[ERROR] Failed to save motors: {e}")
@@ -167,8 +192,9 @@ def shutdown_gpio() -> None:
 @app.get("/")
 async def root():
     return {
-        "message": "Motor Control API",
-        "version": "1.0.0",
+        "message": "Motor Control API",
+        "version": "1.1.0",
+        "authentication": "token" if MOTOR_API_TOKEN else "localhost-only",
         "endpoints": ["/status", "/test", "/add-motor", "/trigger-motor", "/list-motors", "/stop-motors"]
     }