async-htty 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7243a9a99e7a0957ae6a2641c13597899ab85210c5f5334aefc23c9d573681f3
-  data.tar.gz: 5022a69037b5ec3100456de037dd263f28995a135222bde4e2a8a721f2c2e0a4
+  metadata.gz: f033a6514d7f18ec5f7c94b4f547ef2fa00e025eedce18d004387dde4baae5bb
+  data.tar.gz: 6d6a4cf76032a9e403c3f38f0ed4a46d1f6af61dd61ca3b712c68c93eabea6f8
 SHA512:
-  metadata.gz: 8c9bbb53d42a71efe71c714cb4c6aa743c4e0f8fbefd60e4dec918a2e21d9123627a27a3994da9be17901314f684d4f3a942a6ce7caabf8092168afc9b6a2cd1
-  data.tar.gz: b07dbf1b26da9cbd084fd7a048dc7aa7be7122f26a8190da24fb4b4bb2a2f7f472419c508f91d2797035a26e12ef516d7b693b099b7537d6e441fb4de4df44e0
+  metadata.gz: 1f027635ab2786cae7850b213eba3c37e3ac9762409d746a0d54e83d6a9366963d598843f7ccedbd729298c877181062dce7c28f20154c91a6a944cdea2430c3
+  data.tar.gz: b3bfefe4d878d7a404ffc3f3d66798f9acd5e6e17b03743849f58a281dde09a3d63c1fc85bb7918f4b8ff6a340c4335e2ddaaf1d20e882d1f270c6f953ba3f82

data/lib/async/htty/protocol/htty/server.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/http/protocol/http2/server"
+
+module Async
+	module HTTY
+		module Protocol
+			module HTTY
+				class Server < ::Async::HTTP::Protocol::HTTP2::Server
+					def receive_goaway(frame)
+						super
+
+						unless self.framer.nil?
+							self.send_goaway
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/htty/protocol/htty.rb

@@ -6,6 +6,7 @@
 require "protocol/htty"
 
 require "async/http/protocol/http2"
+require_relative "htty/server"
 
 module Async
 	module HTTY
@@ -24,7 +25,7 @@ module Async
 				def self.server(stream, settings: ::Async::HTTP::Protocol::HTTP2::SERVER_SETTINGS)
 					stream = ::Protocol::HTTY::Stream.open(stream, bootstrap: :write)
 					
-					server = ::Async::HTTP::Protocol::HTTP2::Server.new(stream)
+					server = Server.new(stream)
 					server.read_connection_preface(settings)
 					server.start_connection
 					

data/lib/async/htty/server.rb

@@ -24,9 +24,8 @@ module Async
 					block.call
 				end
 			end
-
 			
-			def self.open(app = nil, input: $stdin, output: $stdout, env: ENV, **options, &block)
+			def self.open(app = nil, input: $stdin, output: $stdout, error: $stderr, env: ENV, **options, &block)
 				app ||= block
 				server = self.new(app, **options)
 
@@ -37,13 +36,38 @@ module Async
 					$stderr.puts "HTTY is not supported by this environment, visit https://htty.dev for more information."
 					raise UnsupportedError, "HTTY is not supported by this environment"
 				end
+
+				unless input.respond_to?(:tty?) && input.tty?
+					raise UnsupportedError, "HTTY requires a TTY input stream"
+				end
+				
+				original_input = input.dup
+				original_output = output.dup
+				original_error = error.dup
+				
+				stream = ::IO::Stream::Duplex(original_input, original_output)
+				input.reopen(File::NULL)
+				output.reopen(File::NULL)
+				error.reopen(File::NULL)
 				
 				Sync do |task|
-					with_raw_terminal(input) do
-						stream = ::IO::Stream::Duplex(input, output)
+					with_raw_terminal(original_input) do
 						server.accept(stream, task: task)
 					end
 				end
+				
+			ensure
+				if original_input
+					input.reopen(original_input)
+				end
+				
+				if original_output
+					output.reopen(original_output)
+				end
+				
+				if original_error
+					error.reopen(original_error)
+				end
 			end
 			
 			def initialize(app, protocol: Protocol::HTTY)

data/lib/async/htty/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module HTTY
-		VERSION = "0.1.0"
+		VERSION = "0.2.1"
 	end
 end

data/readme.md

@@ -14,8 +14,20 @@ Please see the [project documentation](https://socketry.github.io/async-htty/) f
 
 Please see the [project releases](https://socketry.github.io/async-htty/releases/index) for all releases.
 
+### v0.2.1
+
+  - Send a server-side GOAWAY when the HTTY client closes an HTTP/2 session, allowing terminal clients to detach cleanly.
+  - Add PTY coverage for binary request/response bodies across the full byte range.
+
+### v0.2.0
+
+  - Reopen `stdin`, `stdout`, and `stderr` to null devices to prevent output from interfering with HTTY's byte stream.
+  - Guard against non-TTY input streams, which are not supported by HTTY.
+
 ### v0.1.0
 
+  - Initial implementation.
+
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,3 +1,15 @@
 # Releases
 
+## v0.2.1
+
+  - Send a server-side GOAWAY when the HTTY client closes an HTTP/2 session, allowing terminal clients to detach cleanly.
+  - Add PTY coverage for binary request/response bodies across the full byte range.
+
+## v0.2.0
+
+  - Reopen `stdin`, `stdout`, and `stderr` to null devices to prevent output from interfering with HTTY's byte stream.
+  - Guard against non-TTY input streams, which are not supported by HTTY.
+
 ## v0.1.0
+
+  - Initial implementation.

data/test/async/htty/protocol/htty.rb

@@ -4,12 +4,48 @@
 # Copyright, 2026, by Samuel Williams.
 
 require "async"
+require "protocol/http/body/writable"
 require "protocol/http/request"
 require "protocol/http/response"
 require "protocol/http2"
+require "protocol/http2/client"
+require "protocol/http2/stream"
+require "rbconfig"
 require "async/htty"
 
+require "async/htty/pty_stream"
+
+class EchoResponseStream < Protocol::HTTP2::Stream
+	attr :response_headers
+	attr :body
+	
+	def initialize(...)
+		super
+		@response_headers = []
+		@body = +"".b
+	end
+	
+	def process_headers(frame)
+		@response_headers = super
+	end
+	
+	def process_data(frame)
+		data = super
+		@body << data.b if data
+		return data
+	end
+end
+
+class EchoClient < Protocol::HTTP2::Client
+	def create_stream(id = next_stream_id)
+		EchoResponseStream.create(self, id)
+	end
+end
+
 describe Async::HTTY::Protocol::HTTY do
+	let(:root) {File.expand_path("../../../..", __dir__)}
+	let(:ruby_load_path) {File.join(root, "lib")}
+	
 	def make_pipes
 		server_input, client_output = IO.pipe
 		client_input, server_output = IO.pipe
@@ -36,6 +72,29 @@ describe Async::HTTY::Protocol::HTTY do
 		IO::Stream::Duplex(pipes[:server_input], pipes[:server_output])
 	end
 	
+	def spawn_fixture(name)
+		environment = {
+			"HTTY" => "1",
+			"RUBYLIB" => [ruby_load_path, ENV["RUBYLIB"]].compact.join(":"),
+		}
+		executable = File.join(root, "fixtures", "async", "htty", "executables", name)
+		
+		PTY.spawn(environment, RbConfig.ruby, executable)
+	end
+	
+	def with_fixture(name)
+		input, output, pid = spawn_fixture(name)
+		input.binmode
+		output.binmode
+		
+		stream = Async::HTTY::PTYStream.new(input, output)
+		
+		yield stream
+	ensure
+		stream&.close
+		Process.wait(pid) rescue nil
+	end
+	
 	it "can carry an HTTP/2 request over HTTY bootstrap and raw transport" do
 		pipes = make_pipes
 		
@@ -60,6 +119,95 @@ describe Async::HTTY::Protocol::HTTY do
 		end
 	end
 	
+	it "round trips all byte values over a real PTY" do
+		payload = (0x00..0xff).to_a.pack("C*")
+		
+		with_fixture("echo_body.rb") do |stream|
+			Protocol::HTTY::Stream.new(stream).read_bootstrap
+			
+			framer = Protocol::HTTP2::Framer.new(stream)
+			client = EchoClient.new(framer)
+			client.send_connection_preface
+			
+			request = client.create_stream
+			request.send_headers(
+				[
+					[":method", "POST"],
+					[":path", "/echo"],
+					[":scheme", "http"],
+					[":authority", "htty.local"],
+					["content-length", payload.bytesize.to_s],
+					["content-type", "application/octet-stream"],
+				]
+			)
+			request.send_data(payload)
+			request.send_data(nil)
+			
+			until request.closed?
+				client.read_frame
+			end
+			
+			expect(request.response_headers.to_h[":status"]).to be == "200"
+			expect(request.body).to be == payload
+		ensure
+			client&.send_goaway
+			client&.close
+		end
+	end
+	
+	it "returns from accept when the client sends GOAWAY while a response body is active" do
+		pipes = make_pipes
+		body = Protocol::HTTP::Body::Writable.new
+		
+		Sync do |task|
+			request_started = Async::Notification.new
+			server_finished = Async::Notification.new
+			
+			server = Async::HTTY::Server.for do |request|
+				request_started.signal
+				Protocol::HTTP::Response[200, {}, body]
+			end
+			
+			server_task = task.async do
+				server.accept(server_stream(pipes))
+			ensure
+				server_finished.signal
+			end
+			
+			stream = Protocol::HTTY::Stream.open(client_stream(pipes), bootstrap: :read)
+			framer = Protocol::HTTP2::Framer.new(stream)
+			client = Protocol::HTTP2::Client.new(framer)
+			client.send_connection_preface
+			
+			request = client.create_stream
+			request.send_headers(
+				[[":method", "GET"], [":path", "/"], [":scheme", "http"], [":authority", "htty.local"]],
+				Protocol::HTTP2::END_STREAM
+			)
+			
+			request_started.wait
+			client.send_goaway
+			
+			task.with_timeout(1) do
+				server_finished.wait
+			end
+			
+			frame = task.with_timeout(1) do
+				loop do
+					frame = framer.read_frame(client.local_settings.maximum_frame_size)
+					break frame if frame.is_a?(Protocol::HTTP2::GoawayFrame)
+				end
+			end
+			
+			expect(frame).to be(:is_a?, Protocol::HTTP2::GoawayFrame)
+		ensure
+			body.close
+			client&.close
+			server_task&.stop
+			close_pipes(pipes)
+		end
+	end
+	
 	it "ignores terminal noise before the HTTY bootstrap" do
 		pipes = make_pipes
 		

data/test/async/htty/server.rb

@@ -3,40 +3,24 @@
 # Released under the MIT License.
 # Copyright, 2026, by Samuel Williams.
 
-require "stringio"
 require "protocol/http/middleware"
 require "async/htty"
+require "async/htty/fake_file"
 
 describe Async::HTTY::Server do
 	let(:server) {subject.new(Protocol::HTTP::Middleware::Okay)}
 	let(:env) {{"HTTY" => "1"}}
+	let(:error) {Async::HTTY::FakeFile.new}
 	
 	it "exposes the HTTY protocol by default" do
 		expect(server.protocol).to be == Async::HTTY::Protocol::HTTY
 	end
 	
 	it "switches tty input into raw mode while accepting a session" do
-		input = Object.new
-		output = StringIO.new
+		input = Async::HTTY::FakeFile.new(tty: true)
+		output = Async::HTTY::FakeFile.new
 		connection = Object.new
 		protocol = Object.new
-		input.instance_variable_set(:@raw_called, false)
-		
-		def input.tty?
-			true
-		end
-		
-		def input.raw
-			@raw_called = true
-			yield
-		end
-		
-		def input.raw_called?
-			@raw_called
-		end
-		
-		def input.timeout
-		end
 		
 		def connection.each
 		end
@@ -55,49 +39,113 @@ describe Async::HTTY::Server do
 			connection
 		end
 		
-		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, env: env, protocol: protocol)
+		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env, protocol: protocol)
 		
-		expect(input.raw_called?).to be == true
+		expect(input).to be(:raw_called?)
+		expect(input).not.to be(:raw?)
 		expect(output.string).to be == ""
 	end
 	
 	it "leaves raw mode if protocol setup fails" do
-		input = Object.new
-		output = StringIO.new
+		input = Async::HTTY::FakeFile.new(tty: true)
+		output = Async::HTTY::FakeFile.new
 		protocol = Object.new
-		input.instance_variable_set(:@raw_exited, false)
 		
-		def input.tty?
-			true
+		protocol.define_singleton_method(:server) do |_stream|
+			raise EOFError, "aborted"
 		end
 		
-		def input.raw
-			yield
-		ensure
-			@raw_exited = true
+		expect do
+			subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env, protocol: protocol)
+		end.to raise_exception(EOFError, message: be =~ /aborted/)
+		
+		expect(input).to be(:raw_exited?)
+		expect(input).not.to be(:raw?)
+	end
+	
+	it "reopens stdio streams while accepting and restores them afterwards" do
+		input = Async::HTTY::FakeFile.new("request", tty: true)
+		output = Async::HTTY::FakeFile.new
+		error = Async::HTTY::FakeFile.new("diagnostics")
+		connection = Object.new
+		protocol = Object.new
+		reopened_to_null = nil
+		duplex_input = nil
+		duplex_output = nil
+		
+		def connection.each
 		end
 		
-		def input.raw_exited?
-			@raw_exited
+		def connection.closed?
+			false
 		end
 		
-		def input.timeout
+		def connection.send_goaway
+		end
+		
+		def connection.close
 		end
 		
 		protocol.define_singleton_method(:server) do |stream|
+			reopened_to_null = [input.reopened_to_null?, output.reopened_to_null?, error.reopened_to_null?]
+			duplex_input = stream.io.input
+			duplex_output = stream.io.output
+			
+			stream.write("response", flush: true)
+			
+			connection
+		end
+		
+		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env, protocol: protocol)
+		
+		expect(reopened_to_null).to be == [true, true, true]
+		expect(duplex_input).not.to be == input
+		expect(duplex_output).not.to be == output
+		expect(duplex_input.string).to be == "request"
+		
+		expect(input).not.to be(:reopened_to_null?)
+		expect(output).not.to be(:reopened_to_null?)
+		expect(error).not.to be(:reopened_to_null?)
+		
+		expect(input.reopen_events).to be == [:null, :file]
+		expect(output.reopen_events).to be == [:null, :file]
+		expect(error.reopen_events).to be == [:null, :file]
+		
+		expect(input.string).to be == "request"
+		expect(output.string).to be == "response"
+		expect(error.string).to be == "diagnostics"
+	end
+	
+	it "restores stdio streams if protocol setup fails" do
+		input = Async::HTTY::FakeFile.new("request", tty: true)
+		output = Async::HTTY::FakeFile.new("response")
+		error = Async::HTTY::FakeFile.new("diagnostics")
+		protocol = Object.new
+		
+		protocol.define_singleton_method(:server) do |_stream|
 			raise EOFError, "aborted"
 		end
 		
 		expect do
-			subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, env: env, protocol: protocol)
+			subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env, protocol: protocol)
 		end.to raise_exception(EOFError, message: be =~ /aborted/)
 		
-		expect(input.raw_exited?).to be == true
+		expect(input).not.to be(:reopened_to_null?)
+		expect(output).not.to be(:reopened_to_null?)
+		expect(error).not.to be(:reopened_to_null?)
+		
+		expect(input.reopen_events).to be == [:null, :file]
+		expect(output.reopen_events).to be == [:null, :file]
+		expect(error.reopen_events).to be == [:null, :file]
+		
+		expect(input.string).to be == "request"
+		expect(output.string).to be == "response"
+		expect(error.string).to be == "diagnostics"
 	end
 	
 	it "sends command-side GOAWAY before closing the connection" do
-		input = StringIO.new
-		output = StringIO.new
+		input = Async::HTTY::FakeFile.new(tty: true)
+		output = Async::HTTY::FakeFile.new
 		connection = Object.new
 		protocol = Object.new
 		events = []
@@ -121,14 +169,14 @@ describe Async::HTTY::Server do
 			connection
 		end
 		
-		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, env: env, protocol: protocol)
+		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env, protocol: protocol)
 		
 		expect(events).to be == [:goaway, :close]
 	end
 	
 	it "opens a server with default stdio-style arguments" do
-		input = StringIO.new
-		output = StringIO.new
+		input = Async::HTTY::FakeFile.new(tty: true)
+		output = Async::HTTY::FakeFile.new
 		accepted = false
 		
 		server = Object.new
@@ -148,7 +196,7 @@ describe Async::HTTY::Server do
 			server
 		end
 		
-		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, env: env, protocol: protocol)
+		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env, protocol: protocol)
 		
 		expect(accepted).to be == true
 		expect(output.string).to be == ""
@@ -156,11 +204,23 @@ describe Async::HTTY::Server do
 	
 	it "raises a typed error when HTTY is disabled" do
 		expect do
-			subject.open(Protocol::HTTP::Middleware::Okay, input: StringIO.new, output: StringIO.new, env: {"HTTY" => "0"})
+			subject.open(Protocol::HTTP::Middleware::Okay, input: Async::HTTY::FakeFile.new, output: Async::HTTY::FakeFile.new, error: error, env: {"HTTY" => "0"})
 		end.to raise_exception(Async::HTTY::DisabledError, message: be =~ /disabled/)
 		
 		expect(Async::HTTY::DisabledError).to be < Async::HTTY::UnsupportedError
 	end
+
+	it "raises a typed error when stdin is not a tty" do
+		input = Async::HTTY::FakeFile.new
+		output = Async::HTTY::FakeFile.new
+
+		expect do
+			subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env)
+		end.to raise_exception(Async::HTTY::UnsupportedError, message: be =~ /TTY input/)
+
+		expect(input.reopen_events).to be == []
+		expect(output.reopen_events).to be == []
+	end
 	
 	it "prints help and raises a typed error when HTTY is not advertised" do
 		error_output = StringIO.new
@@ -170,7 +230,7 @@ describe Async::HTTY::Server do
 			$stderr = error_output
 			
 			expect do
-				subject.open(Protocol::HTTP::Middleware::Okay, input: StringIO.new, output: StringIO.new, env: {})
+				subject.open(Protocol::HTTP::Middleware::Okay, input: Async::HTTY::FakeFile.new, output: Async::HTTY::FakeFile.new, env: {})
 			end.to raise_exception(Async::HTTY::UnsupportedError, message: be =~ /not supported/)
 		ensure
 			$stderr = original_stderr
@@ -180,8 +240,8 @@ describe Async::HTTY::Server do
 	end
 
 	it "opens a server within its own async context when no task is provided" do
-		input = StringIO.new
-		output = StringIO.new
+		input = Async::HTTY::FakeFile.new(tty: true)
+		output = Async::HTTY::FakeFile.new
 		accepted = false
 
 		server = Object.new
@@ -201,7 +261,7 @@ describe Async::HTTY::Server do
 			server
 		end
 
-		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, env: env, protocol: protocol)
+		subject.open(Protocol::HTTP::Middleware::Okay, input: input, output: output, error: error, env: env, protocol: protocol)
 
 		expect(accepted).to be == true
 	end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-htty
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -105,6 +105,7 @@ files:
 - lib/async/htty/error.rb
 - lib/async/htty/protocol.rb
 - lib/async/htty/protocol/htty.rb
+- lib/async/htty/protocol/htty/server.rb
 - lib/async/htty/server.rb
 - lib/async/htty/version.rb
 - license.md