todo: handled ls command in multiselect.py (#622)

libp2p/host/basic_host.py

@@ -195,6 +195,29 @@ class BasicHost(IHost):
         net_stream.set_protocol(selected_protocol)
         return net_stream
 
+    async def send_command(self, peer_id: ID, command: str) -> list[str]:
+        """
+        Send a multistream-select command to the specified peer and return
+        the response.
+
+        :param peer_id: peer_id that host is connecting
+        :param command: supported multistream-select command (e.g., "ls)
+        :raise StreamFailure: If the stream cannot be opened or negotiation fails
+        :return: list of strings representing the response from peer.
+        """
+        new_stream = await self._network.new_stream(peer_id)
+
+        try:
+            response = await self.multiselect_client.query_multistream_command(
+                MultiselectCommunicator(new_stream), command
+            )
+        except MultiselectClientError as error:
+            logger.debug("fail to open a stream to peer %s, error=%s", peer_id, error)
+            await new_stream.reset()
+            raise StreamFailure(f"failed to open a stream to peer {peer_id}") from error
+
+        return response
+
     async def connect(self, peer_info: PeerInfo) -> None:
         """
         Ensure there is a connection between this host and the peer

libp2p/protocol_muxer/multiselect.py

@@ -60,8 +60,14 @@ class Multiselect(IMultiselectMuxer):
                 raise MultiselectError() from error
 
             if command == "ls":
-                # TODO: handle ls command
-                pass
+                supported_protocols = list(self.handlers.keys())
+                response = "\n".join(supported_protocols) + "\n"
+
+                try:
+                    await communicator.write(response)
+                except MultiselectCommunicatorError as error:
+                    raise MultiselectError() from error
+
             else:
                 protocol = TProtocol(command)
                 if protocol in self.handlers:

libp2p/protocol_muxer/multiselect_client.py

@@ -70,6 +70,36 @@ class MultiselectClient(IMultiselectClient):
 
         raise MultiselectClientError("protocols not supported")
 
+    async def query_multistream_command(
+        self, communicator: IMultiselectCommunicator, command: str
+    ) -> list[str]:
+        """
+        Send a multistream-select command over the given communicator and return
+        parsed response.
+
+        :param communicator: communicator to use to communicate with counterparty
+        :param command: supported multistream-select command(e.g., ls)
+        :raise MultiselectClientError: If the communicator fails to process data.
+        :return: list of strings representing the response from peer.
+        """
+        await self.handshake(communicator)
+
+        if command == "ls":
+            try:
+                await communicator.write("ls")
+            except MultiselectCommunicatorError as error:
+                raise MultiselectClientError() from error
+        else:
+            raise ValueError("Command not supported")
+
+        try:
+            response = await communicator.read()
+            response_list = response.strip().splitlines()
+        except MultiselectCommunicatorError as error:
+            raise MultiselectClientError() from error
+
+        return response_list
+
     async def try_select(
         self, communicator: IMultiselectCommunicator, protocol: TProtocol
     ) -> TProtocol: