Add protocol version and warnings to hello and welcome packets

Co-authored-by: erikdubbelboer <522870+erikdubbelboer@users.noreply.github.com>

Author: Copilot

internal/signaling/peer.go

@@ -226,11 +226,37 @@ func (p *Peer) HandleHelloPacket(ctx context.Context, packet HelloPacket) error
 		}
 	}
 
-	err := p.Send(ctx, WelcomePacket{
-		Type:   "welcome",
-		ID:     p.ID,
-		Secret: p.Secret,
-	})
+	// Prepare warnings based on client version or other conditions
+	var warnings []string
+	
+	// Example: warn about deprecated features or compatibility issues
+	// This demonstrates how to use the warnings field in the future
+	if packet.Version != "" {
+		// Example logic for version-based warnings
+		// In a real scenario, you might parse semantic versions and compare properly
+		// For now, just demonstrate the capability without complex version parsing
+		_ = packet.Version // acknowledge we're using the version field
+	}
+	
+	// Future examples of when warnings might be added:
+	// - Protocol version mismatches
+	// - Deprecated game features
+	// - Server maintenance notifications
+	// - Feature flags that might affect client behavior
+
+	welcomePacket := WelcomePacket{
+		Type:            "welcome",
+		ID:              p.ID,
+		Secret:          p.Secret,
+		ProtocolVersion: ProtocolVersion,
+	}
+	
+	// Only include warnings if there are any
+	if len(warnings) > 0 {
+		welcomePacket.Warnings = warnings
+	}
+
+	err := p.Send(ctx, welcomePacket)
 	if err != nil {
 		return err
 	}

internal/signaling/protocol-notes.md

@@ -5,7 +5,7 @@
 => `{"type": "hello", "game": "GameUUID", "id?": "previousPeerID", "lobby?": "previousLobby"}`
 
 ## Server responds with:
-<= `{"type": "welcome", "id": "newPeerID"}`
+<= `{"type": "welcome", "id": "newPeerID", "secret": "peerSecret", "protocolVersion": "1.0.0", "warnings?": ["optional warning messages"]}`
 
 ## Then the connection idles until client calls create() or join('lobby')
 

internal/signaling/types.go

@@ -8,6 +8,10 @@ import (
 	"github.com/poki/netlib/internal/signaling/stores"
 )
 
+// ProtocolVersion defines the current protocol version
+// This should be incremented when backwards incompatible changes are made
+const ProtocolVersion = "1.0.0"
+
 type PingPacket struct {
 	Type string `json:"type"`
 }
@@ -24,8 +28,10 @@ type HelloPacket struct {
 type WelcomePacket struct {
 	Type string `json:"type"`
 
-	ID     string `json:"id"`
-	Secret string `json:"secret"`
+	ID              string   `json:"id"`
+	Secret          string   `json:"secret"`
+	ProtocolVersion string   `json:"protocolVersion"`
+	Warnings        []string `json:"warnings,omitempty"`
 }
 
 type ListPacket struct {

internal/signaling/welcome_test.go

@@ -0,0 +1,119 @@
+package signaling
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestWelcomePacketStructure(t *testing.T) {
+	// Test that WelcomePacket includes protocol version
+	packet := WelcomePacket{
+		Type:            "welcome",
+		ID:              "test-id",
+		Secret:          "test-secret",
+		ProtocolVersion: ProtocolVersion,
+		Warnings:        []string{"test warning"},
+	}
+
+	// Marshal to JSON to verify the structure
+	data, err := json.Marshal(packet)
+	if err != nil {
+		t.Fatalf("Failed to marshal WelcomePacket: %v", err)
+	}
+
+	// Unmarshal back to verify structure
+	var unmarshaled WelcomePacket
+	err = json.Unmarshal(data, &unmarshaled)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal WelcomePacket: %v", err)
+	}
+
+	// Verify all fields are preserved
+	if unmarshaled.Type != "welcome" {
+		t.Errorf("Expected Type 'welcome', got %s", unmarshaled.Type)
+	}
+	if unmarshaled.ID != "test-id" {
+		t.Errorf("Expected ID 'test-id', got %s", unmarshaled.ID)
+	}
+	if unmarshaled.Secret != "test-secret" {
+		t.Errorf("Expected Secret 'test-secret', got %s", unmarshaled.Secret)
+	}
+	if unmarshaled.ProtocolVersion != ProtocolVersion {
+		t.Errorf("Expected ProtocolVersion %s, got %s", ProtocolVersion, unmarshaled.ProtocolVersion)
+	}
+	if len(unmarshaled.Warnings) != 1 || unmarshaled.Warnings[0] != "test warning" {
+		t.Errorf("Expected Warnings ['test warning'], got %v", unmarshaled.Warnings)
+	}
+}
+
+func TestWelcomePacketWithoutWarnings(t *testing.T) {
+	// Test that warnings field is omitted when empty
+	packet := WelcomePacket{
+		Type:            "welcome",
+		ID:              "test-id",
+		Secret:          "test-secret",
+		ProtocolVersion: ProtocolVersion,
+	}
+
+	// Marshal to JSON
+	data, err := json.Marshal(packet)
+	if err != nil {
+		t.Fatalf("Failed to marshal WelcomePacket: %v", err)
+	}
+
+	// Verify warnings field is not in JSON when empty
+	var jsonMap map[string]interface{}
+	err = json.Unmarshal(data, &jsonMap)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal to map: %v", err)
+	}
+
+	if _, hasWarnings := jsonMap["warnings"]; hasWarnings {
+		t.Errorf("Warnings field should be omitted when empty, but was present in JSON: %s", string(data))
+	}
+
+	// Verify protocol version is always present
+	if _, hasProtocolVersion := jsonMap["protocolVersion"]; !hasProtocolVersion {
+		t.Errorf("ProtocolVersion field should always be present in JSON: %s", string(data))
+	}
+}
+
+func TestProtocolVersionConstant(t *testing.T) {
+	// Verify protocol version is defined and not empty
+	if ProtocolVersion == "" {
+		t.Error("ProtocolVersion constant should not be empty")
+	}
+
+	// Verify it follows semver-like pattern (basic check)
+	if len(ProtocolVersion) < 5 { // At minimum "1.0.0"
+		t.Errorf("ProtocolVersion should be a proper version string, got: %s", ProtocolVersion)
+	}
+}
+
+func TestWelcomePacketWarningsExample(t *testing.T) {
+	// Test how warnings could be used in practice
+	packet := WelcomePacket{
+		Type:            "welcome",
+		ID:              "test-id",
+		Secret:          "test-secret",
+		ProtocolVersion: ProtocolVersion,
+		Warnings:        []string{"Example warning: This feature will be deprecated in version 2.0.0"},
+	}
+
+	// Marshal to JSON
+	data, err := json.Marshal(packet)
+	if err != nil {
+		t.Fatalf("Failed to marshal WelcomePacket with warnings: %v", err)
+	}
+
+	// Verify the JSON contains the warning
+	jsonStr := string(data)
+	if !strings.Contains(jsonStr, "Example warning") {
+		t.Errorf("Expected JSON to contain warning message, got: %s", jsonStr)
+	}
+
+	if !strings.Contains(jsonStr, "protocolVersion") {
+		t.Errorf("Expected JSON to contain protocolVersion, got: %s", jsonStr)
+	}
+}

lib/types.ts

@@ -82,6 +82,8 @@ export interface WelcomePacket extends Base {
   type: 'welcome'
   id: string
   secret: string
+  protocolVersion: string
+  warnings?: string[]
 }
 
 export interface ListPacket extends Base {