pytty 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdb07fa81c4837ef64e8bffa9abaed4abdb6b99caeff476a7d4b11b2b36be8f1
-  data.tar.gz: 979f05736d9f1ab607edf33371c6a3f1ffadcdd60ca05c8d6d57af2a401e1808
+  metadata.gz: ac7cf59162fd0dccf371c30835205439e1e5886e1205046a7e8bfeba356ec66d
+  data.tar.gz: 91514548de9aee6be4f3f4ae8fdf1cad590ca4af1696b50dcd94075747bd5569
 SHA512:
-  metadata.gz: 691018ead4ca0970d5ba99006e2931aa7da6b6d116adf6e2d041282c22d24f67985a0eb581659d82bb991c8f64e22b31f9bee6733b02de4fb54ca70187f0f791
-  data.tar.gz: 5c9c8a5cbea5e16a36332b3aab35f02472322b474d075bf923dd671c6d56f49a78677c6d77370f77eb80388ae1cfa0ffb8148232178433b201cd4e3da010e625
+  metadata.gz: 932b0d858592fc7674e29735b6fc97e0244e0348a8c0cc944008bf10c137085aba44fa52ea9cfed2d92d161f549eef8243817363193d9d100bbc435a8bfec8eb
+  data.tar.gz: b467fead672a215988f55b57225f6ba2167e3ca8aae23d3849f4bb69b056159ed3d5cd505e579909d78995bf40ff2ef434c0ced8fdb0cdb1988d39b9d58add12

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pytty (0.4.1)
+    pytty (0.5.0)
       async-websocket
       clamp (~> 1.3)
       falcon
@@ -10,18 +10,18 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    async (1.13.0)
+    async (1.14.0)
       nio4r (~> 2.3)
       timers (~> 4.1)
     async-container (0.8.1)
       async (~> 1.0)
       async-io (~> 1.4)
-    async-http (0.37.7)
-      async (~> 1.6)
-      async-io (~> 1.16)
+    async-http (0.37.9)
+      async (~> 1.14)
+      async-io (~> 1.18)
       http-protocol (~> 0.10)
-    async-io (1.17.2)
-      async (~> 1.3)
+    async-io (1.18.1)
+      async (~> 1.14)
     async-websocket (0.6.1)
       async-io
       websocket-driver (~> 0.7.0)

data/README.md

@@ -1,3 +1,3 @@
 # pytty
 
-Process Yield TTY
+Process Yield TTY

data/lib/pytty/client/api.rb

@@ -3,4 +3,9 @@ require_relative "api/yield"
 require_relative "api/attach"
 require_relative "api/spawn"
 require_relative "api/stdout"
+require_relative "api/stderr"
+require_relative "api/status"
+
 require_relative "api/signal"
+require_relative "api/rm"
+require_relative "api/port"

data/lib/pytty/client/api/attach.rb

@@ -15,10 +15,9 @@ module Pytty
             # }.to_json
             # response = internet.post("#{Pytty::Client.host_url}/v1/stdin/#{id}", headers, [stdin_body])
 
-            if interactive
-              $stdin.raw!
-              $stdin.echo = false
-            end
+            $stdin.raw!
+            $stdin.echo = false
+
             async_stdin = Async::IO::Stream.new(
               Async::IO::Generic.new($stdin)
             )
@@ -60,14 +59,26 @@ module Pytty
 
             response = internet.post("#{Pytty::Client.host_url}/v1/attach/#{id}", headers, [body])
             response.body.each do |c|
-              print c
+              stream = if c[0] == "1"
+                $stdout
+              else
+                $stderr
+              end
+
+              case c[1..-1]
+              when "\n"
+                stream.print "#{c}\r"
+              else
+                stream.print c[1..-1]
+              end
             end
           rescue Async::Wrapper::Cancelled => ex
             p ["rescued", ex]
           ensure
             stdin_task.stop
-
             internet.close
+            `stty sane`
+            #$stdout.print "\r" #stdin.raw!
           end
         end
       end

data/lib/pytty/client/api/port.rb

@@ -0,0 +1,21 @@
+module Pytty
+  module Client
+    module Api
+      class Port
+        def self.run(id:, from:, to:)
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+          body = {
+            from: from,
+            to: to
+          }.to_json
+
+          response = internet.post("#{Pytty::Client.host_url}/v1/port/#{id}", headers, [body])
+          [response, JSON.parse(response.body.read)]
+        ensure
+          internet.close
+        end
+      end
+    end
+  end
+end

data/lib/pytty/client/api/rm.rb

@@ -0,0 +1,18 @@
+module Pytty
+  module Client
+    module Api
+      class Rm
+        def self.run(id:)
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+          body = {}.to_json
+
+          response = internet.post("#{Pytty::Client.host_url}/v1/rm/#{id}", headers, [body])
+          [response, JSON.parse(response.body.read)]
+        ensure
+          internet.close
+        end
+      end
+    end
+  end
+end

data/lib/pytty/client/api/status.rb

@@ -0,0 +1,19 @@
+module Pytty
+  module Client
+    module Api
+      class Status
+        def self.run(id:)
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+          body = {
+          }.to_json
+
+          response = internet.post("#{Pytty::Client.host_url}/v1/status/#{id}", headers, [body])
+          [response, response.read]
+        ensure
+          internet.close
+        end
+      end
+    end
+  end
+end

data/lib/pytty/client/api/stderr.rb

@@ -0,0 +1,19 @@
+module Pytty
+  module Client
+    module Api
+      class Stderr
+        def self.run(id:)
+          internet = Async::HTTP::Internet.new
+          headers = [['accept', 'application/json']]
+          body = {
+          }.to_json
+
+          response = internet.post("#{Pytty::Client.host_url}/v1/stderr/#{id}", headers, [body])
+          [response, response.body]
+        ensure
+          internet.close
+        end
+      end
+    end
+  end
+end

data/lib/pytty/client/api/stdout.rb

@@ -9,7 +9,7 @@ module Pytty
           }.to_json
 
           response = internet.post("#{Pytty::Client.host_url}/v1/stdout/#{id}", headers, [body])
-          puts response.read
+          [response, response.body]
         ensure
           internet.close
         end

data/lib/pytty/client/cli.rb

@@ -11,6 +11,9 @@ require_relative "cli/rm_command"
 require_relative "cli/signal_command"
 require_relative "cli/attach_command"
 require_relative "cli/stdout_command"
+require_relative "cli/stderr_command"
+require_relative "cli/status_command"
+require_relative "cli/port_command"
 
 require_relative "cli/run_command"
 

data/lib/pytty/client/cli/port_command.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class PortCommand < Clamp::Command
+        parameter "ID", "id"
+        parameter "PORTS", "ports"
+
+        def execute
+          Async.run do
+            from,to = ports.split(":")
+            Pytty::Client::Api::Port.run id: id, from: from, to: to
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/pytty/client/cli/rm_command.rb

@@ -24,12 +24,9 @@ module Pytty
           end
 
           Async.run do
-            internet = Async::HTTP::Internet.new
-            headers = [['accept', 'application/json']]
-            body = {}.to_json
-
             for id in ids do
-              response = internet.post("#{Pytty::Client.host_url}/v1/rm/#{id}", headers, [body])
+              response, body = Pytty::Client::Api::Rm.run id: id
+
               if response.status == 200
                 puts id
               else
@@ -37,8 +34,6 @@ module Pytty
                 exit 1
               end
             end
-          ensure
-            internet.close
           end
         end
       end

data/lib/pytty/client/cli/root_command.rb

@@ -20,6 +20,9 @@ module Pytty
         subcommand ["signal"], "signal", SignalCommand
         subcommand ["attach"], "attach", AttachCommand
         subcommand ["stdout"], "stdout", StdoutCommand
+        subcommand ["stderr"], "stderr", StderrCommand
+        subcommand ["status"], "status", StatusCommand
+        subcommand ["port"], "port", PortCommand
 
         def self.run
           super
@@ -31,4 +34,3 @@ module Pytty
     end
   end
 end
-

data/lib/pytty/client/cli/run_command.rb

@@ -11,8 +11,10 @@ module Pytty
         parameter "CMD ...", "command"
         option ["-i","--interactive"], :flag, "interactive"
         option ["-t","--tty"], :flag, "tty"
+
         option ["-d","--detach"], :flag, "detach"
         option ["--name"], "name", "name"
+        option ["--rm"], :flag, "rm"
 
         def execute
           Async.run do |task|
@@ -22,16 +24,23 @@ module Pytty
               exit 1
             end
             process_yield = Pytty::Client::ProcessYield.from_json body
-            unless detach?
+
+            attach_task = unless detach?
               task.async do
                 process_yield.attach interactive: interactive?
+                process_yield.rm
               end
             end
 
-            process_yield.spawn tty: tty?, interactive: interactive?
-
-            if detach?
-              puts process_yield.id
+            response, body = process_yield.spawn tty: tty?, interactive: interactive?
+            if response.status == 200
+              if detach?
+                puts process_yield.id
+              end
+            else
+              puts body
+              attach_task.stop
+              print "\r" unless detach?
             end
           end
         end

data/lib/pytty/client/cli/status_command.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pytty
+  module Client
+    module Cli
+      class StatusCommand < Clamp::Command
+        parameter "ID ...", "id"
+
+        def execute
+          Async.run do
+            for id in id_list do
+              response, body = Pytty::Client::Api::Status.run id: id
+              if response.status == 200
+                puts body
+              else
+                puts body
+                exit 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/pytty/client/cli/stderr_command.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'async'
+require 'async/http'
+require 'async/http/internet'
+require 'json'
+
+module Pytty
+  module Client
+    module Cli
+      class StderrCommand < Clamp::Command
+        parameter "ID", "id"
+
+        def execute
+          Async.run do
+            response, body = Pytty::Client::Api::Stderr.run id: id
+            if response.status == 200
+              puts body.read
+            else
+              puts body.read
+              exit 1
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/pytty/client/cli/stdout_command.rb

@@ -12,7 +12,13 @@ module Pytty
 
         def execute
           Async.run do
-            Pytty::Client::Api::Stdout.run id: id
+            response, body = Pytty::Client::Api::Stdout.run id: id
+            if response.status == 200
+              puts body.read
+            else
+              puts body.read
+              exit 1
+            end
           end
         end
       end

data/lib/pytty/client/process_yield.rb

@@ -20,9 +20,11 @@ module Pytty
           status: json.fetch("status")
         })
       end
+
       def running?
         !@pid.nil?
       end
+
       def to_s
         fields = []
         fields << @id
@@ -32,6 +34,10 @@ module Pytty
         fields.join("\t")
       end
 
+      def rm
+        Pytty::Client::Api::Rm.run id: @id
+      end
+
       def spawn(tty:, interactive:)
         Pytty::Client::Api::Spawn.run id: @id, tty: tty, interactive: interactive
       end

data/lib/pytty/daemon/api/router.rb

@@ -15,20 +15,29 @@ module Pytty
           end
 
           resp = case params["component"]
-          when "stdout"
+          when "stdout","stderr"
             process_yield = Pytty::Daemon.yields[params["id"]]
             return [404, {'content-type' => 'text/html; charset=utf-8'}, ["does not exist"]] unless process_yield
 
-            body = Async::HTTP::Body::Writable.new
+            stream_path = if params["component"] == "stdout"
+              process_yield.stdout_path
+            else
+              process_yield.stderr_path
+            end
+
+            stream = Async::IO::Stream.new(
+              File.open stream_path, "r"
+            )
 
+            body = Async::HTTP::Body::Writable.new
             begin
-              our_stdout = process_yield.stdout.dup
-              while c = our_stdout.read
+              while c = stream.read
                 body.write c
               end
             rescue Exception => ex
-              p ex
+              p "read", ex
             ensure
+              stream.close if stream
               body.close
             end
 
@@ -37,17 +46,25 @@ module Pytty
             process_yield = Pytty::Daemon.yields[params["id"]]
             return [404, {'content-type' => 'text/html; charset=utf-8'}, ["does not exist"]] unless process_yield
 
-            puts "got attach: #{req.object_id}"
             body = Async::HTTP::Body::Writable.new
 
-            Async::Task.current.async do |task|
+            stderr_done = Async::Task.current.async do |task|
+              notification = process_yield.add_stderr body
+              notification.wait
+            end
+
+            stdout_done = Async::Task.current.async do |task|
               notification = process_yield.add_stdout body
               notification.wait
-            rescue Exception => ex
-              puts "----"
-              p ["attach", ex]
+            end
+
+            Async::Task.current.async do |task|
+              stderr_done.wait
+              p ["stderr done"]
+              stdout_done.wait
+              p ["stderr done"]
             ensure
-              puts "closing attach: #{req.object_id}"
+              p ["closing attach:", req.object_id]
               body.close
             end
 
@@ -55,7 +72,7 @@ module Pytty
           when "ps","yield"
             status, output = Pytty::Daemon::Components::Handler.handle component: params["component"], params: body
             [status, {"Content-Type" => "application/json"}, [output.to_json]]
-          when "spawn","rm","signal","stdin"
+          when "spawn","rm","signal","stdin","status","port"
             status, output = Pytty::Daemon::Components::YieldHandler.handle component: params["component"], id: params["id"], params: body
             [status, {"Content-Type" => "application/json"}, [output.to_json]]
           when "ws"
@@ -74,4 +91,4 @@ module Pytty
       end
     end
   end
-end
+end

data/lib/pytty/daemon/components/yield_handler.rb

@@ -9,10 +9,48 @@ module Pytty
           return [404, "not found"] unless process_yield
 
           return case component
+          when "port"
+            endpoint = Async::IO::Endpoint.tcp('0.0.0.0', params["from"].to_i)
+            endpoint.accept do |client|
+              process_yield.spawn unless process_yield.running?
+              p ["port accept", client.object_id]
+              upstream = Async::IO::Endpoint.tcp('0.0.0.0', params["to"].to_i)
+              peer = nil
+              upstream.connect do |peer|
+                Async::Task.current.async do |task|
+                  while rata = peer.read(1)
+                    client.write rata
+                  end
+                  client.close
+                end
+
+                while data = client.read(2)
+                  p data
+                  peer.write(data)
+                end
+              end
+            rescue Errno::ECONNREFUSED
+              sleep 0.1
+              p ["port upstream retry"]
+              retry
+            # rescue Async::Wrapper::Cancelled
+            #   # ???
+            rescue Exception => ex
+              p ["accex", ex]
+            ensure
+              peer.close
+              client.close
+            end
+
+            [200, "ok"]
           when "stdin"
             process_yield.stdin.enqueue params["c"]
 
             [200, "ok"]
+          when "status"
+            return [500, "still running"] if process_yield.running?
+
+            [200, process_yield.status]
           when "signal"
             return [500, "not running"] unless process_yield.running?
 
@@ -21,8 +59,7 @@ module Pytty
             [200, "ok"]
           when "spawn"
             return [500, "already running"] if process_yield.running?
-
-            if process_yield.spawn
+            if process_yield.spawn tty: params["tty"], interactive: params["interactive"]
               Pytty::Daemon.dump
             else
               return [500, "could not spawn"]
@@ -31,6 +68,8 @@ module Pytty
             [200, "ok"]
           when "rm"
             process_yield.signal("KILL") if process_yield.running?
+            process_yield.cleanup
+
             Pytty::Daemon.yields.delete process_yield.id
             Pytty::Daemon.dump
 
@@ -43,4 +82,3 @@ module Pytty
     end
   end
 end
-

data/lib/pytty/daemon/process_yield.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "securerandom"
 require "pty"
+require "open3"
 
 module Pytty
   module Daemon
@@ -13,12 +14,17 @@ module Pytty
         @status = nil
         @id = id || SecureRandom.uuid
 
-        @stdout = nil
         @stdouts = {}
+        @stderrs = {}
+
+        @stdout_path = File.join Pytty::Daemon.pytty_path, "#{@id}.stdout"
+        @stderr_path = File.join Pytty::Daemon.pytty_path, "#{@id}.stderr"
+
         @stdin = Async::Queue.new
       end
 
-      attr_reader :id, :cmd, :pid, :status, :stdout
+      attr_reader :id, :cmd, :pid, :status
+      attr_reader :stdout_path, :stderr_path
       attr_accessor :stdin
 
       def add_stdout(stdout)
@@ -26,8 +32,14 @@ module Pytty
         @stdouts[notification] = stdout
         notification
       end
+      def add_stderr(stderr)
+        notification = Async::Notification.new
+        @stderrs[notification] = stderr
+        notification
+      end
 
       def running?
+        # test by killing?
         !@pid.nil?
       end
 
@@ -42,86 +54,172 @@ module Pytty
         }.to_json
       end
 
-      def spawn
-        return false if running?
+      def cleanup
         @status = nil
 
-        executable, args = @cmd
-        # @env.merge!({
-        #   "TERM" => "xterm"
-        # })
+        File.unlink @stdout_path if File.exist? @stdout_path
+        File.unlink @stderr_path if File.exist? @stderr_path
+      end
+
+      def spawn(tty: false, interactive: false)
+        return false if running?
+        cleanup
 
-        stdout_path = File.join(Pytty::Daemon.pytty_path, @id)
-        File.unlink stdout_path if File.exist? stdout_path
         stdout_appender = Async::IO::Stream.new(
-          File.open stdout_path, "a"
+          File.open @stdout_path, "a"
         )
-        @stdout = Async::IO::Stream.new(
-          File.open stdout_path, "r"
+        stderr_appender = Async::IO::Stream.new(
+          File.open @stderr_path, "a"
         )
+
+        executable, *args = @cmd
+        # @env.merge!({
+        #   "TERM" => "xterm"
+        # })
+
         Async::Task.current.async do |task|
-          real_stdout, real_stdin, pid = PTY.spawn @env, executable, *args
-          @pid = pid
+          real_stdout, real_stdin, real_stderr, @pid, wait_thr  = begin
+            if tty
+              stderr_reader, stderr_writer = IO.pipe
+              p ["spawn", "PTY"]
+              #TODO: if bash is started, no prompt is written in stderr or stdout
+              p_stdout, p_stdin, pid = PTY.spawn @env, executable, *args, err: stderr_writer
+
+              [p_stdout, p_stdin, stderr_reader, pid]
+            else
+              p_stdin, p_stdout, p_stderr, p_wait_thr = Open3.popen3 @env, executable, *args, {}
+              [p_stdout, p_stdin, p_stderr, p_wait_thr.pid, p_wait_thr]
+            end
+          rescue Errno::ENOENT => ex
+            raise unless ex.message == "No such file or directory - #{executable}"
+          end
+
+          next unless @pid  #command failed to spawn
+
           async_stdout = Async::IO::Generic.new real_stdout
           async_stdin = Async::IO::Generic.new real_stdin
+          async_stderr = Async::IO::Generic.new real_stderr
 
-          task_stdin_writer = task.async do |subtask|
-            while c = @stdin.dequeue do
-              async_stdin.write c
+          task_stdin_writer = if interactive
+            task.async do |subtask|
+              p ["task_stdin_writer", "started"]
+              while c = @stdin.dequeue do
+                async_stdin.write c
+              end
+            rescue Async::Stop => ex
+              puts "async_stdin#write Async::Stop"
+            rescue Exception => ex
+              puts "async_stdin#write: #{ex.inspect}"
+            ensure
+              async_stdin.close
+              p ["async_stdin", "closed"]
             end
-          rescue Async::Stop => ex
+          else
+            nil
+          end
+
+          task_stderr_writer = task.async do
+            p ["task_stderr_writer", "started"]
+            while c = async_stderr.read(1) do
+              stderr_appender.write c
+              stderr_appender.flush
+
+              @stderrs.each do |notification, stderr|
+                begin
+                  stderr.write "2#{c}"
+                rescue Async::HTTP::Body::Writable::Closed
+                  puts "signaling error"
+                  notification.signal
+                  @stderrs.delete notification
+                rescue => ex
+                  raise ex
+                end
+              end
+            end
+            p ["task_stderr_writer", "async_stderr has no more read"]
           rescue Exception => ex
-            puts "async_stdin.write: #{ex.inspect}"
+            p ["async_stderr ex:", ex]
+          ensure
+            stderr_appender.flush
+            stderr_appender.close
+            puts "stderr_appender closed"
+            async_stderr.close
+            puts "async_stderr closed"
           end
 
-          task_stdout_writer = task.async do |subtask|
+          task_stdout_writer = task.async do
+            p ["task_stdout_writer", "started"]
+
             while c = async_stdout.read(1)
               stdout_appender.write c
               stdout_appender.flush
 
               @stdouts.each do |notification, stdout|
                 begin
-                  stdout.write c
+                  stdout.write "1#{c}"
                 rescue Errno::EPIPE, Errno::EPROTOTYPE => ex
                   notification.signal
                   @stdouts.delete notification
                 end
               end
             end
+            p ["task_stdout_writer", "stopped"]
           rescue Async::Stop
             signal "kill"
           rescue Exception => ex
-            p ["async_stdout.read", ex]
+            p ["async_stdout", ex]
           ensure
-            task_stdin_writer.stop
-            Process.wait(@pid)
-            @status = if $?.exitstatus
-              $?.exitstatus
+            process_status = if wait_thr
+              wait_thr.value
             else
-              Signal.signame $?.termsig
+              begin
+                Process.wait(@pid)
+                $?
+              rescue Errno::ECHILD => ex
+                raise ex unless ex.message == "No child processes"
+                puts "NO CHILD PROCESS"
+                nil
+              end
+            end
+
+            @status = if process_status && process_status.exitstatus
+              process_status.exitstatus
+            else
+              Signal.signame process_status.termsig
             end
-            puts "exited #{@id} with status: #{@status}"
 
+            puts "exited #{@id} with status: #{@status}"
             @pid = nil
-            stdout_appender.close
+            task_stdin_writer.stop if task_stdin_writer
 
             @stdouts.each do |notification, stdout|
               notification.signal
               @stdouts.delete notification
             end
+            @stderrs.each do |notification, stderr|
+              notification.signal
+              @stdouts.delete notification
+            end
             Pytty::Daemon.dump
           end
-        end.wait
-
-        puts "spawned #{id}"
-        return true
+        end
+
+        if @pid
+          p ["spawned", id]
+          return true
+        else
+          p ["failed to spawn"]
+          @status = 127
+          return false
+        end
       end
 
       def signal(sig)
         return unless @pid
         Process.kill(sig.upcase, @pid)
+      rescue Errno::ESRCH => ex
+        raise ex unless ex.message == "No such process"
       end
     end
   end
 end
-

data/lib/pytty/version.rb

@@ -1,3 +1,3 @@
 module Pytty
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pytty
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Matti Paksula
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-14 00:00:00.000000000 Z
+date: 2019-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -190,19 +190,26 @@ files:
 - lib/pytty/client.rb
 - lib/pytty/client/api.rb
 - lib/pytty/client/api/attach.rb
+- lib/pytty/client/api/port.rb
 - lib/pytty/client/api/ps.rb
+- lib/pytty/client/api/rm.rb
 - lib/pytty/client/api/signal.rb
 - lib/pytty/client/api/spawn.rb
+- lib/pytty/client/api/status.rb
+- lib/pytty/client/api/stderr.rb
 - lib/pytty/client/api/stdout.rb
 - lib/pytty/client/api/yield.rb
 - lib/pytty/client/cli.rb
 - lib/pytty/client/cli/attach_command.rb
+- lib/pytty/client/cli/port_command.rb
 - lib/pytty/client/cli/ps_command.rb
 - lib/pytty/client/cli/rm_command.rb
 - lib/pytty/client/cli/root_command.rb
 - lib/pytty/client/cli/run_command.rb
 - lib/pytty/client/cli/signal_command.rb
 - lib/pytty/client/cli/spawn_command.rb
+- lib/pytty/client/cli/status_command.rb
+- lib/pytty/client/cli/stderr_command.rb
 - lib/pytty/client/cli/stdout_command.rb
 - lib/pytty/client/cli/stream_command.rb
 - lib/pytty/client/cli/yield_command.rb