Read & write JSON-RPC frames as bytes; require binary streams

[ramfjord]

PR: Read & write JSON-RPC frames as bytes; require binary streams

Branch: ramfjord:fix/byte-counted-content-length-binary → cxxxr:master

The bug

Content-Length in JSON-RPC's HTTP-style framing is bytes (LSP makes
this explicit). The previous read-message used
(make-string LENGTH) + read-sequence on a character stream — that
reads LENGTH characters. For pure-ASCII bodies the two are identical;
for any multi-byte UTF-8 in the body, the reader takes too few bytes
from the stream. The leftover bytes corrupt the next message's header
parse and the read loop hangs. write-message had the symmetric
character-vs-byte mismatch in Content-Length.

I hit this building a swank-backed LSP server: every Lisp source file
with a single em-dash in a comment desynced the wire after didOpen,
hanging gd and K until the LSP was restarted. Same root cause
would bite any LSP-shaped consumer of jsonrpc/transport/stdio.

The TCP transport never had this bug because it already operated on a
binary socket-stream and had its own byte-aware read-headers inline.
This PR consolidates around that working pattern.

The change (3 commits)

Three commits, each independently green and reviewable.

1. Read & write JSON-RPC frames as bytes; require binary streams

The actual bug fix.

• request-response.lisp: read-headers, read-message, and
  write-message now operate on binary streams. Headers decode as
  ASCII (LSP headers are pure ASCII); body decodes as UTF-8 via
  trivial-utf-8.
• transport/tcp.lisp: socket-stream is already binary, so the shared
  read-message / write-message are exactly what tcp needs. tcp's
  bespoke inline header parser (~70 lines) and body-reading deleted.
• transport/stdio.lisp: :input / :output now default to binary
  stdio streams via sb-sys:make-fd-stream. Non-SBCL implementations
  must pass binary streams explicitly (errors helpfully on missing
  initform).
• transport/local-domain-socket.lisp: noted that
  socket-make-stream there still defaults to a character stream.
  ASCII bodies behave as before; multi-byte safety needs
  :element-type '(unsigned-byte 8) at the call site (left as
  follow-up since this transport wasn't exercised in my report).

2. Hoist 1-line transport methods to defaults on the generic

Pure cleanup, no behavior change. stdio, tcp, and local-domain-socket
all had identical 1-line send-message-using-transport methods and
near-identical receive-message-using-transport methods. Move both
to default :method clauses on the generic in
transport/interface.lisp. Websocket keeps its own methods (different
framing). Three transports now inherit the default; -19 LoC.

3. Use flexi-streams to wrap the binary stream as bivalent

flexi-streams provides a stream wrap exposing both character and
binary I/O over one buffered binary stream. With it, read-message
creates one wrap and uses it for both: read-line for ASCII headers,
read-sequence of bytes for the UTF-8 body. The byte-loop helper and
custom eof condition go away; stdlib end-of-file replaces them.

Adds flexi-streams as a direct dep — widely used across the CL
ecosystem (drakma, hunchentoot, websocket-driver) but not currently a
transitive dep of jsonrpc.

Tests

tests/request-response.lisp gains read-message-test with three
cases (each frames bytes inline via flexi-streams —
make-in-memory-input-stream + a local flet for the
Content-Length:-prefixed wire format):

• ASCII body parses (regression guard).
• Multi-byte UTF-8 body parses with byte-counted Content-Length.
• Two back-to-back messages where the first has multi-byte content —
  the second's method comes through intact (proves no desync).

tests/transport/stdio.lisp updated to pass binary fd-streams in the
existing pipe-based stdio-server test.

All 4 upstream test suites pass on every commit:
request-response, tcp-server, stdio-server, websocket-server.

Stats

• 7 files changed, +92 / -141 (net -49 LoC)
• One new direct dep: flexi-streams (commit 3).

Happy to split things differently or rework anything — let me know
what you'd prefer.

[ramfjord]

The TL;DR on this is that it fixes a bug for UTF characters (specifics can be found in the individual test additions), by relying a bit more directly on the flexi-stream library which is already a dependency here