`HELLO 3` command support

[unendingblue]

I'm facing a roadblock with Tile38's handling of the HELLO command when using Bun's Redis client - Bun only supports RESP3 and always sends a HELLO 3 command when connections open, which Tile38 currently rejects.

tile38/internal/server/server.go

Lines 1116 to 1132 in 5b8ce58

	if cmd == "hello" {
	// Not Supporting RESP3+, returns an ERR instead.
	ot := msg.OutputType
	if len(msg.Args) > 1 && (msg.Args[1] >= "0" &&
	msg.Args[1] <= "9") && s.opts.ClientOutput == "json" &&
	ot == JSON && msg.ConnType == RESP {
	// Here we are making sure that we ignoring the '-o json' flag, if
	// used, otherwise the connection will fail for some redis clients
	// like "github.com/redis/go-redis/v9" are overly strict and expect
	// a map type or an error as the result of the HELLO command.
	msg.OutputType = RESP
	msg.StrictRESP = true
	}
	err := writeErr("unknown command '" + msg.Args[0] + "'")
	msg.OutputType = ot
	return err
	}

Since I'm always using OUTPUT json, it would be really helpful if Tile38 supported a way to answer to HELLO 3 without actually performing any changes to the wire protocol (since in both cases responses are a bulk string). Maybe an arg like --withHello3?

To test this out I had Claude write up a patch to handle HELLO + AUTH and it seems to work reliably with JSON output - I haven't tested RESP output yet.

[tidwall]

What would the response need to be in order for the HELLO 3 to work, but without having to supporting RESP3? My understanding is that if Tile38 says it's RESP3 then the client may make RESP3 requests, which in turn cause potential protocol errors unless Tile38 adopts the RESP3 protocol.

Is the bun client required? What about https://github.com/iwpnd/tile38-ts, https://github.com/phulst/node-tile38, or https://github.com/redis/ioredis?

[unendingblue]

For HELLO 3 the minimal response would have to be a map with the below format (documentation here). It could also support an AUTH subcommand, but this is not neccessary (can call AUTH later)

> HELLO 3
1# "server" => "redis"
2# "version" => "6.0.0"
3# "proto" => (integer) 3
4# "id" => (integer) 10
5# "mode" => "standalone"
6# "role" => "master"
7# "modules" => (empty array)

RESP3 is a superset of RESP2 (data types here), so Tile38's responses are still valid even when the negotiated protocol is RESP3. When the output is set to JSON, the Tile38 server responds in bulk strings ($ data type) which is valid in both protocols.

tile38/internal/server/server.go

Lines 1041 to 1048 in 5b8ce58

	case RESP:
	var err error
	if msg.OutputType == JSON {
	_, err = fmt.Fprintf(client, "$%d\r\n%s\r\n", len(res), res)
	} else {
	_, err = io.WriteString(client, res)
	}
	return err

And I'm assuming non-JSON output (default RESP) will still also work (haven't tried it, but I don't see why they wouldn't).

Redis clients send their commands as bulk string arrays in both RESP2 and RESP3, so they are also parsed correctly by Tile38 with no changes required. The RESP3 data types are for server responses only.

As for the motivation behind this request, it's because of performance. I'm working on an application where every saved CPU cycle counts due to high throughput, and while ioredis works great, using Bun's client is preferred.

For reference, this is what Claude cooked up.

package server

import (
	"fmt"
	"strconv"

	"github.com/tidwall/tile38/core"
)

// handleHello implements the Redis HELLO command for RESP3 protocol negotiation.
// This allows clients that require RESP3 (such as Bun's Redis client) to
// connect and communicate with Tile38.
//
// The command accepts: HELLO [protover [AUTH username password] [SETNAME clientname]]
//
// When protover is 2 or 3, Tile38 responds with a RESP map containing server
// metadata. The actual wire format of subsequent responses does not change
// because Tile38's JSON output mode wraps everything in bulk strings, which
// are identical in RESP2 and RESP3.
func (s *Server) handleHello(client *Client, msg *Message, writeOutput func(string) error) error {
	protoVersion := 2 // default to RESP2

	args := msg.Args
	i := 1

	// Parse optional protover argument
	if i < len(args) {
		v, err := strconv.Atoi(args[i])
		if err == nil {
			if v < 2 || v > 3 {
				return writeOutput(marshalRESP2Error("NOPROTO unsupported protocol version"))
			}
			protoVersion = v
			i++
		}
	}

	// Parse optional AUTH and SETNAME arguments
	for i < len(args) {
		switch {
		case eqFold(args[i], "AUTH"):
			// AUTH username password
			// Tile38 only has a single password (no usernames), so we accept
			// both AUTH <password> and AUTH <username> <password> forms.
			// In the two-arg form, we ignore the username and use the password.
			i++
			if i >= len(args) {
				return writeOutput(marshalRESP2Error("ERR syntax error"))
			}
			password := args[i]
			i++
			// Check if the next arg is another sub-command keyword. If not,
			// it's the password in the AUTH <username> <password> form.
			if i < len(args) && !eqFold(args[i], "SETNAME") {
				password = args[i]
				i++
			}
			if reqPass := s.config.requirePass(); reqPass != "" {
				if password != reqPass {
					return writeOutput(marshalRESP2Error("WRONGPASS invalid username-password pair or user is disabled."))
				}
				client.authd = true
			}

		case eqFold(args[i], "SETNAME"):
			i++
			if i >= len(args) {
				return writeOutput(marshalRESP2Error("ERR syntax error"))
			}
			client.mu.Lock()
			client.name = args[i]
			client.mu.Unlock()
			i++

		default:
			return writeOutput(marshalRESP2Error("ERR syntax error"))
		}
	}

	// Mark protocol version on the client
	client.resp3 = protoVersion == 3

	// Build the HELLO response as a RESP map.
	// Use RESP3 map format if proto 3 was requested, otherwise RESP2 array.
	role := "master"

	if protoVersion == 3 {
		return writeOutput(marshalRESP3HelloMap(
			"tile38", core.Version, protoVersion, client.id, "standalone", role,
		))
	}
	return writeOutput(marshalRESP2HelloArray(
		"tile38", core.Version, protoVersion, client.id, "standalone", role,
	))
}

// eqFold is a simple ASCII case-insensitive comparison.
func eqFold(a, b string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := 0; i < len(a); i++ {
		ca, cb := a[i], b[i]
		if ca >= 'A' && ca <= 'Z' {
			ca += 32
		}
		if cb >= 'A' && cb <= 'Z' {
			cb += 32
		}
		if ca != cb {
			return false
		}
	}
	return true
}

// marshalRESP3HelloMap builds a raw RESP3 map response for the HELLO command.
// Format: %<count>\r\n followed by key-value pairs.
func marshalRESP3HelloMap(serverName, version string, proto, clientID int, mode, role string) string {
	// 7 key-value pairs: server, version, proto, id, mode, role, modules
	return fmt.Sprintf("%%7\r\n"+
		"$6\r\nserver\r\n$%d\r\n%s\r\n"+ // server
		"$7\r\nversion\r\n$%d\r\n%s\r\n"+ // version
		"$5\r\nproto\r\n:%d\r\n"+ // proto
		"$2\r\nid\r\n:%d\r\n"+ // id
		"$4\r\nmode\r\n$%d\r\n%s\r\n"+ // mode
		"$4\r\nrole\r\n$%d\r\n%s\r\n"+ // role
		"$7\r\nmodules\r\n*0\r\n", // modules (empty array)
		len(serverName), serverName,
		len(version), version,
		proto,
		clientID,
		len(mode), mode,
		len(role), role,
	)
}

// marshalRESP2HelloArray builds a RESP2 array response for HELLO with proto 2.
// This is an array of alternating key-value pairs, matching Redis behavior.
func marshalRESP2HelloArray(serverName, version string, proto, clientID int, mode, role string) string {
	// 14 elements (7 key-value pairs as flat array)
	return fmt.Sprintf("*14\r\n"+
		"$6\r\nserver\r\n$%d\r\n%s\r\n"+ // server
		"$7\r\nversion\r\n$%d\r\n%s\r\n"+ // version
		"$5\r\nproto\r\n:%d\r\n"+ // proto
		"$2\r\nid\r\n:%d\r\n"+ // id
		"$4\r\nmode\r\n$%d\r\n%s\r\n"+ // mode
		"$4\r\nrole\r\n$%d\r\n%s\r\n"+ // role
		"$7\r\nmodules\r\n*0\r\n", // modules (empty array)
		len(serverName), serverName,
		len(version), version,
		proto,
		clientID,
		len(mode), mode,
		len(role), role,
	)
}

// marshalRESP2Error builds a RESP2 error response.
func marshalRESP2Error(msg string) string {
	return fmt.Sprintf("-%s\r\n", msg)
}

[unendingblue]

Hey @tidwall, have you had a chance to consider this? I've been running with a mock HELLO 3 command for a while now and haven't noticed anything misbehaving.