Add WebSocket transport support

.gitignore

@@ -178,3 +178,7 @@ env.bak/
 #lockfiles
 uv.lock
 poetry.lock
+tests/interop/js_libp2p/js_node/node_modules/
+tests/interop/js_libp2p/js_node/package-lock.json
+tests/interop/js_libp2p/js_node/src/node_modules/
+tests/interop/js_libp2p/js_node/src/package-lock.json

examples/transport_integration_demo.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+Demo script showing the new transport integration capabilities in py-libp2p.
+
+This script demonstrates:
+1. How to use the transport registry
+2. How to create transports dynamically based on multiaddrs
+3. How to register custom transports
+4. How the new system automatically selects the right transport
+"""
+
+import asyncio
+import logging
+from pathlib import Path
+import sys
+
+# Add the libp2p directory to the path so we can import it
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import multiaddr
+
+from libp2p.transport import (
+    create_transport,
+    create_transport_for_multiaddr,
+    get_supported_transport_protocols,
+    get_transport_registry,
+    register_transport,
+)
+from libp2p.transport.tcp.tcp import TCP
+from libp2p.transport.upgrader import TransportUpgrader
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def demo_transport_registry():
+    """Demonstrate the transport registry functionality."""
+    print("🔧 Transport Registry Demo")
+    print("=" * 50)
+
+    # Get the global registry
+    registry = get_transport_registry()
+
+    # Show supported protocols
+    supported = get_supported_transport_protocols()
+    print(f"Supported transport protocols: {supported}")
+
+    # Show registered transports
+    print("\nRegistered transports:")
+    for protocol in supported:
+        transport_class = registry.get_transport(protocol)
+        class_name = transport_class.__name__ if transport_class else "None"
+        print(f"  {protocol}: {class_name}")
+
+    print()
+
+
+def demo_transport_factory():
+    """Demonstrate the transport factory functions."""
+    print("🏭 Transport Factory Demo")
+    print("=" * 50)
+
+    # Create a dummy upgrader for WebSocket transport
+    upgrader = TransportUpgrader({}, {})
+
+    # Create transports using the factory function
+    try:
+        tcp_transport = create_transport("tcp")
+        print(f"✅ Created TCP transport: {type(tcp_transport).__name__}")
+
+        ws_transport = create_transport("ws", upgrader)
+        print(f"✅ Created WebSocket transport: {type(ws_transport).__name__}")
+
+    except Exception as e:
+        print(f"❌ Error creating transport: {e}")
+
+    print()
+
+
+def demo_multiaddr_transport_selection():
+    """Demonstrate automatic transport selection based on multiaddrs."""
+    print("🎯 Multiaddr Transport Selection Demo")
+    print("=" * 50)
+
+    # Create a dummy upgrader
+    upgrader = TransportUpgrader({}, {})
+
+    # Test different multiaddr types
+    test_addrs = [
+        "/ip4/127.0.0.1/tcp/8080",
+        "/ip4/127.0.0.1/tcp/8080/ws",
+        "/ip6/::1/tcp/8080/ws",
+        "/dns4/example.com/tcp/443/ws",
+    ]
+
+    for addr_str in test_addrs:
+        try:
+            maddr = multiaddr.Multiaddr(addr_str)
+            transport = create_transport_for_multiaddr(maddr, upgrader)
+
+            if transport:
+                print(f"✅ {addr_str} -> {type(transport).__name__}")
+            else:
+                print(f"❌ {addr_str} -> No transport found")
+
+        except Exception as e:
+            print(f"❌ {addr_str} -> Error: {e}")
+
+    print()
+
+
+def demo_custom_transport_registration():
+    """Demonstrate how to register custom transports."""
+    print("🔧 Custom Transport Registration Demo")
+    print("=" * 50)
+
+    # Show current supported protocols
+    print(f"Before registration: {get_supported_transport_protocols()}")
+
+    # Register a custom transport (using TCP as an example)
+    class CustomTCPTransport(TCP):
+        """Custom TCP transport for demonstration."""
+
+        def __init__(self):
+            super().__init__()
+            self.custom_flag = True
+
+    # Register the custom transport
+    register_transport("custom_tcp", CustomTCPTransport)
+
+    # Show updated supported protocols
+    print(f"After registration: {get_supported_transport_protocols()}")
+
+    # Test creating the custom transport
+    try:
+        custom_transport = create_transport("custom_tcp")
+        print(f"✅ Created custom transport: {type(custom_transport).__name__}")
+        # Check if it has the custom flag (type-safe way)
+        if hasattr(custom_transport, "custom_flag"):
+            flag_value = getattr(custom_transport, "custom_flag", "Not found")
+            print(f"   Custom flag: {flag_value}")
+        else:
+            print("   Custom flag: Not found")
+    except Exception as e:
+        print(f"❌ Error creating custom transport: {e}")
+
+    print()
+
+
+def demo_integration_with_libp2p():
+    """Demonstrate how the new system integrates with libp2p."""
+    print("🚀 Libp2p Integration Demo")
+    print("=" * 50)
+
+    print("The new transport system integrates seamlessly with libp2p:")
+    print()
+    print("1. ✅ Automatic transport selection based on multiaddr")
+    print("2. ✅ Support for WebSocket (/ws) protocol")
+    print("3. ✅ Fallback to TCP for backward compatibility")
+    print("4. ✅ Easy registration of new transport protocols")
+    print("5. ✅ No changes needed to existing libp2p code")
+    print()
+
+    print("Example usage in libp2p:")
+    print("  # This will automatically use WebSocket transport")
+    print("  host = new_host(listen_addrs=['/ip4/127.0.0.1/tcp/8080/ws'])")
+    print()
+    print("  # This will automatically use TCP transport")
+    print("  host = new_host(listen_addrs=['/ip4/127.0.0.1/tcp/8080'])")
+    print()
+
+    print()
+
+
+async def main():
+    """Run all demos."""
+    print("🎉 Py-libp2p Transport Integration Demo")
+    print("=" * 60)
+    print()
+
+    # Run all demos
+    demo_transport_registry()
+    demo_transport_factory()
+    demo_multiaddr_transport_selection()
+    demo_custom_transport_registration()
+    demo_integration_with_libp2p()
+
+    print("🎯 Summary of New Features:")
+    print("=" * 40)
+    print("✅ Transport Registry: Central registry for all transport implementations")
+    print("✅ Dynamic Transport Selection: Automatic selection based on multiaddr")
+    print("✅ WebSocket Support: Full /ws protocol support")
+    print("✅ Extensible Architecture: Easy to add new transport protocols")
+    print("✅ Backward Compatibility: Existing TCP code continues to work")
+    print("✅ Factory Functions: Simple API for creating transports")
+    print()
+    print("🚀 The transport system is now ready for production use!")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n👋 Demo interrupted by user")
+    except Exception as e:
+        print(f"\n❌ Demo failed with error: {e}")
+        import traceback
+
+        traceback.print_exc()