async-htty 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7243a9a99e7a0957ae6a2641c13597899ab85210c5f5334aefc23c9d573681f3
-  data.tar.gz: 5022a69037b5ec3100456de037dd263f28995a135222bde4e2a8a721f2c2e0a4
+  metadata.gz: c9d30babccdd7bf9fe410add7bb9dd2a6f7dafaa4d642bb377bf431f2aea4818
+  data.tar.gz: 8cd9da81dce5256dd99c9724491f07c94217fda9efd604f468c67b61a1b4f379
 SHA512:
-  metadata.gz: 8c9bbb53d42a71efe71c714cb4c6aa743c4e0f8fbefd60e4dec918a2e21d9123627a27a3994da9be17901314f684d4f3a942a6ce7caabf8092168afc9b6a2cd1
-  data.tar.gz: b07dbf1b26da9cbd084fd7a048dc7aa7be7122f26a8190da24fb4b4bb2a2f7f472419c508f91d2797035a26e12ef516d7b693b099b7537d6e441fb4de4df44e0
+  metadata.gz: b9a43f93f8c0a6a73e3114ea24ff950fcce09d49bd06752ca121e720ea8f566d220b41ee000514819bd1b537551e7ef74b0e191f3c6709e73a44083b0278e667
+  data.tar.gz: 0d9d94b0125c871ee18a5f95c98e45249e84b2397ef751f9c4b56b9b3175842b438630a998fd063fe0f848f75570c6a9f94b66ddc7044cdd99451173ff6c387d

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.0"
 	end
 end

data/readme.md

@@ -14,8 +14,15 @@ 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.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,10 @@
 # Releases
 
+## 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/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.0
 platform: ruby
 authors:
 - Samuel Williams