Method _execute_command

relay/server.py:653–736

Execute a command on a Unity instance

(
        self,
        request_id: str,
        instance_id: str | None,
        command: str,
        params: dict[str, Any],
        timeout_ms: int,
    )

            ).to_dict()

    async def _execute_command(
        self,
        request_id: str,
        instance_id: str | None,
        command: str,
        params: dict[str, Any],
        timeout_ms: int,
    ) -> dict[str, Any]:
        """Execute a command on a Unity instance"""
        result = await self._wait_for_instance(request_id, instance_id)
        if isinstance(result, dict):
            return result
        instance = result

        if instance.capabilities and command not in instance.capabilities:
            return ErrorMessage.from_code(
                request_id,
                ErrorCode.CAPABILITY_NOT_SUPPORTED,
                f"Command '{command}' not supported by instance. Available: {', '.join(instance.capabilities)}",
            ).to_dict()

        if instance.status == InstanceStatus.BUSY:
            return await self._enqueue_command(request_id, instance, command, params, timeout_ms)

        # Send command to Unity
        cmd_msg = CommandMessage(
            id=request_id,
            command=command,
            params=params,
            timeout_ms=timeout_ms,
        )

        # Create future for response
        future: asyncio.Future[dict[str, Any]] = asyncio.Future()
        self._pending_commands[request_id] = future
        logger.info(f"Registered pending command: {request_id}")

        # Set instance to BUSY
        instance.set_status(InstanceStatus.BUSY)

        try:
            await write_frame(instance.writer, cmd_msg.to_dict())

            # Wait for response
            result = await asyncio.wait_for(
                future,
                timeout=timeout_ms / 1000,
            )

            # Convert COMMAND_RESULT to RESPONSE
            return ResponseMessage(
                id=request_id,
                success=result.get("success", False),
                data=result.get("data"),
                error=result.get("error"),
                relay_version=self._relay_version,
                bridge_version=instance.bridge_version,
            ).to_dict()