diff --git a/api/services/shim/shim.pb.go b/api/services/shim/shim.pb.go
index d034825be..667e0e862 100644
--- a/api/services/shim/shim.pb.go
+++ b/api/services/shim/shim.pb.go
@@ -178,6 +178,10 @@ type StateResponse struct {
 	Pid       uint32                          `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"`
 	Status    containerd_v1_types1.Status     `protobuf:"varint,4,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"`
 	Processes []*containerd_v1_types1.Process `protobuf:"bytes,5,rep,name=processes" json:"processes,omitempty"`
+	Stdin     string                          `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"`
+	Stdout    string                          `protobuf:"bytes,7,opt,name=stdout,proto3" json:"stdout,omitempty"`
+	Stderr    string                          `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"`
+	Terminal  bool                            `protobuf:"varint,9,opt,name=terminal,proto3" json:"terminal,omitempty"`
 }
 
 func (m *StateResponse) Reset()                    { *m = StateResponse{} }
@@ -1229,6 +1233,34 @@ func (m *StateResponse) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
+	if len(m.Stdin) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdin)))
+		i += copy(dAtA[i:], m.Stdin)
+	}
+	if len(m.Stdout) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(len(m.Stdout)))
+		i += copy(dAtA[i:], m.Stdout)
+	}
+	if len(m.Stderr) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintShim(dAtA, i, uint64(len(m.Stderr)))
+		i += copy(dAtA[i:], m.Stderr)
+	}
+	if m.Terminal {
+		dAtA[i] = 0x48
+		i++
+		if m.Terminal {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
 	return i, nil
 }
 
@@ -1702,6 +1734,21 @@ func (m *StateResponse) Size() (n int) {
 			n += 1 + l + sovShim(uint64(l))
 		}
 	}
+	l = len(m.Stdin)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	l = len(m.Stdout)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	l = len(m.Stderr)
+	if l > 0 {
+		n += 1 + l + sovShim(uint64(l))
+	}
+	if m.Terminal {
+		n += 2
+	}
 	return n
 }
 
@@ -1949,6 +1996,10 @@ func (this *StateResponse) String() string {
 		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
 		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
 		`Processes:` + strings.Replace(fmt.Sprintf("%v", this.Processes), "Process", "containerd_v1_types1.Process", 1) + `,`,
+		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
+		`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
+		`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
+		`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -3425,6 +3476,113 @@ func (m *StateResponse) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stdin = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stdout = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthShim
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stderr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowShim
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Terminal = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipShim(dAtA[iNdEx:])
@@ -4251,76 +4409,77 @@ func init() {
 }
 
 var fileDescriptorShim = []byte{
-	// 1136 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xcb, 0x72, 0xe3, 0x44,
-	0x17, 0x1e, 0xd9, 0x8e, 0x63, 0x1f, 0x8f, 0x9d, 0xa4, 0x2b, 0x95, 0xd2, 0x38, 0xff, 0xef, 0x04,
-	0x55, 0x4d, 0x8d, 0x93, 0x01, 0x19, 0x32, 0xbb, 0x29, 0x58, 0xe4, 0x46, 0x31, 0x10, 0xc0, 0xd5,
-	0x09, 0x2b, 0xaa, 0x70, 0x29, 0x72, 0xc7, 0x6e, 0x22, 0xab, 0x85, 0xba, 0x9d, 0x49, 0x76, 0x3c,
-	0x00, 0x0b, 0xb6, 0x3c, 0x09, 0x7b, 0x56, 0x59, 0xb2, 0x83, 0xd5, 0xc0, 0xe4, 0x49, 0xa8, 0xbe,
-	0x48, 0xb2, 0x93, 0xc8, 0x4e, 0x36, 0xaa, 0x3e, 0xa7, 0xbf, 0x3e, 0x7d, 0xae, 0x5f, 0x0b, 0x3e,
-	0x1b, 0x50, 0x31, 0x1c, 0x9f, 0xba, 0x3e, 0x1b, 0x75, 0x7c, 0x16, 0x0a, 0x8f, 0x86, 0x24, 0xee,
-	0x4f, 0x2e, 0xbd, 0x88, 0x76, 0x38, 0x89, 0x2f, 0xa8, 0x4f, 0x78, 0x87, 0x0f, 0xe9, 0x48, 0x7d,
-	0xdc, 0x28, 0x66, 0x82, 0xa1, 0xf5, 0x0c, 0xe8, 0x5e, 0x7c, 0xe2, 0x26, 0x38, 0x57, 0x42, 0x9a,
-	0xcf, 0x06, 0x8c, 0x0d, 0x02, 0xd2, 0x51, 0xd0, 0xd3, 0xf1, 0x59, 0xc7, 0x0b, 0xaf, 0xf4, 0xb9,
-	0xe6, 0xfa, 0xed, 0x2d, 0x32, 0x8a, 0x44, 0xb2, 0xb9, 0x3a, 0x60, 0x03, 0xa6, 0x96, 0x1d, 0xb9,
-	0x32, 0xda, 0x4f, 0x1f, 0xe4, 0xa9, 0xb8, 0x8a, 0x08, 0xef, 0x8c, 0xd8, 0x38, 0x14, 0xfa, 0x6b,
-	0x4e, 0xbf, 0x7e, 0xc4, 0x69, 0xe1, 0xf1, 0x73, 0xf5, 0x31, 0x67, 0x37, 0x6e, 0x3b, 0x2b, 0xe8,
-	0x88, 0x70, 0xe1, 0x8d, 0x22, 0x0d, 0x70, 0xfe, 0x2a, 0x40, 0x7d, 0x3f, 0x26, 0x9e, 0x20, 0x98,
-	0xfc, 0x34, 0x26, 0x5c, 0xa0, 0x35, 0x28, 0xd0, 0xbe, 0x6d, 0x6d, 0x5a, 0xed, 0xea, 0x5e, 0xf9,
-	0xe6, 0xdd, 0x46, 0xe1, 0xcd, 0x01, 0x2e, 0xd0, 0x3e, 0x5a, 0x83, 0xf2, 0xe9, 0x38, 0xec, 0x07,
-	0xc4, 0x2e, 0xc8, 0x3d, 0x6c, 0x24, 0x64, 0xc3, 0x62, 0x3c, 0x0e, 0xa5, 0x5d, 0xbb, 0xa8, 0x36,
-	0x12, 0x11, 0x3d, 0x83, 0x4a, 0xc8, 0x7a, 0x11, 0xbd, 0x60, 0xc2, 0x2e, 0x6d, 0x5a, 0xed, 0x0a,
-	0x5e, 0x0c, 0x59, 0x57, 0x8a, 0xa8, 0x09, 0x15, 0x41, 0xe2, 0x11, 0x0d, 0xbd, 0xc0, 0x5e, 0x50,
-	0x5b, 0xa9, 0x8c, 0x56, 0x61, 0x81, 0x8b, 0x3e, 0x0d, 0xed, 0xb2, 0x32, 0xa7, 0x05, 0x79, 0x3d,
-	0x17, 0x7d, 0x36, 0x16, 0xf6, 0xa2, 0xbe, 0x5e, 0x4b, 0x46, 0x4f, 0xe2, 0xd8, 0xae, 0xa4, 0x7a,
-	0x12, 0xc7, 0x68, 0x07, 0xca, 0x31, 0x63, 0xe2, 0x8c, 0xdb, 0xd5, 0xcd, 0x62, 0xbb, 0xb6, 0xd3,
-	0x74, 0xa7, 0xeb, 0xad, 0xf2, 0xe5, 0x7e, 0x2d, 0xf3, 0x8c, 0x0d, 0x12, 0xb5, 0x00, 0xfc, 0x21,
-	0xf1, 0xcf, 0x23, 0x46, 0x43, 0x61, 0x83, 0xb2, 0x37, 0xa1, 0x41, 0x2f, 0x61, 0x25, 0xf2, 0x62,
-	0x12, 0x8a, 0xde, 0x04, 0xac, 0xa6, 0x60, 0xcb, 0x7a, 0x63, 0x3f, 0xd5, 0x3b, 0x0e, 0x34, 0x92,
-	0xc4, 0xf2, 0x88, 0x85, 0x9c, 0xa0, 0x65, 0x28, 0x46, 0x26, 0xb5, 0x75, 0x2c, 0x97, 0x4e, 0x03,
-	0x9e, 0x1e, 0x0b, 0x2f, 0x16, 0x26, 0xf7, 0xce, 0x07, 0x50, 0x3f, 0x20, 0x01, 0xc9, 0x8a, 0x71,
-	0xf7, 0x88, 0x80, 0x46, 0x02, 0x31, 0x66, 0x37, 0xa0, 0x46, 0x2e, 0xa9, 0xe8, 0x71, 0xe1, 0x89,
-	0x31, 0x37, 0x58, 0x90, 0xaa, 0x63, 0xa5, 0x41, 0xbb, 0x50, 0x95, 0x12, 0xe9, 0xf7, 0x3c, 0xa1,
-	0x8a, 0x27, 0xb3, 0xa1, 0x1b, 0xc3, 0x4d, 0x1a, 0xc3, 0x3d, 0x49, 0x1a, 0x63, 0xaf, 0x72, 0xfd,
-	0x6e, 0xe3, 0xc9, 0xaf, 0xff, 0x6c, 0x58, 0xb8, 0xa2, 0x8f, 0xed, 0x0a, 0xe7, 0x37, 0x0b, 0x6a,
-	0x87, 0x97, 0xc4, 0x4f, 0xfc, 0x9a, 0xac, 0x9f, 0x95, 0x57, 0xbf, 0xc2, 0xfd, 0xf5, 0x2b, 0xe6,
-	0xd4, 0xaf, 0x34, 0x55, 0xbf, 0x36, 0x94, 0x78, 0x44, 0x7c, 0xd5, 0x1d, 0xb5, 0x9d, 0xd5, 0x3b,
-	0xfe, 0xee, 0x86, 0x57, 0x58, 0x21, 0x9c, 0x03, 0x28, 0xe3, 0x80, 0x8e, 0xa8, 0x40, 0x08, 0x4a,
-	0xb2, 0xac, 0xba, 0x79, 0xb1, 0x5a, 0x4b, 0xdd, 0xd0, 0x8b, 0xfb, 0xca, 0x99, 0x12, 0x56, 0x6b,
-	0xa9, 0xe3, 0xec, 0x4c, 0x7b, 0x52, 0xc2, 0x6a, 0xed, 0x6c, 0xc2, 0x53, 0x1d, 0x60, 0x6e, 0xb1,
-	0x8e, 0x00, 0xba, 0xe2, 0x2a, 0xb7, 0x32, 0x32, 0xee, 0xb7, 0xb4, 0x2f, 0x86, 0xea, 0xaa, 0x3a,
-	0xd6, 0x82, 0x8c, 0x6f, 0x48, 0xe8, 0x60, 0xa8, 0x6f, 0xab, 0x63, 0x23, 0x39, 0x4b, 0x50, 0x3f,
-	0xbc, 0x20, 0xa1, 0xe0, 0x49, 0xed, 0x75, 0x2f, 0xa4, 0xa5, 0x77, 0xfe, 0xb0, 0xa0, 0x6e, 0x14,
-	0xc6, 0xa5, 0xc7, 0x4e, 0xa6, 0x71, 0xb1, 0x98, 0xb9, 0xf8, 0x4a, 0x26, 0x5b, 0x75, 0x89, 0x4c,
-	0x76, 0x63, 0x67, 0xfd, 0xde, 0xa1, 0xd0, 0x6d, 0x83, 0x0d, 0x14, 0xbd, 0x86, 0x6a, 0x14, 0x33,
-	0x9f, 0x70, 0x4e, 0xb8, 0xbd, 0xa0, 0x86, 0xe9, 0x7f, 0xf7, 0x9e, 0xeb, 0x6a, 0x14, 0xce, 0xe0,
-	0x32, 0xa8, 0xae, 0x37, 0xe6, 0x69, 0x50, 0x4b, 0x50, 0xc7, 0x84, 0x8f, 0x47, 0xa9, 0xa2, 0x2e,
-	0xfb, 0x8a, 0xa6, 0x03, 0xf0, 0x06, 0x6a, 0x5f, 0xd1, 0x20, 0xc8, 0xb8, 0xa8, 0xcc, 0xe9, 0x20,
-	0x69, 0xb2, 0x3a, 0x36, 0x92, 0x8c, 0xcc, 0x0b, 0x02, 0x15, 0x6e, 0x05, 0xcb, 0xe5, 0xdd, 0x58,
-	0x9d, 0xe7, 0xb0, 0xb2, 0x1f, 0x30, 0x4e, 0x8e, 0x65, 0xfb, 0xe5, 0xcf, 0xd3, 0x36, 0x2c, 0x77,
-	0x13, 0x77, 0xe7, 0x50, 0xa0, 0xf3, 0x2d, 0xac, 0x4c, 0x60, 0x4d, 0x55, 0xa6, 0xd2, 0x63, 0x3d,
-	0x2e, 0x3d, 0xbf, 0x14, 0x60, 0x25, 0xa3, 0x8c, 0xe4, 0x7a, 0x04, 0x25, 0x39, 0x78, 0x66, 0xb0,
-	0xd4, 0x1a, 0xad, 0x43, 0xd5, 0x0b, 0x02, 0xf6, 0xb6, 0x27, 0xfc, 0xc8, 0xc4, 0x5d, 0x51, 0x8a,
-	0x13, 0x3f, 0x42, 0x1f, 0x02, 0xd2, 0x9b, 0xe3, 0x90, 0x5e, 0xf6, 0x38, 0xf3, 0xcf, 0x89, 0xe0,
-	0x2a, 0x17, 0x15, 0xbc, 0xac, 0x76, 0xbe, 0x0b, 0xe9, 0xe5, 0xb1, 0xd6, 0xa3, 0xe7, 0xd0, 0x30,
-	0xa6, 0x92, 0x09, 0xd6, 0xe4, 0x5c, 0xd7, 0xf6, 0x92, 0x31, 0xfe, 0x3f, 0xc0, 0x19, 0x0d, 0x48,
-	0x2f, 0x60, 0xfe, 0x39, 0x37, 0x24, 0x5d, 0x95, 0x9a, 0x23, 0xa9, 0x40, 0x5b, 0xb0, 0xac, 0x1e,
-	0xbe, 0x5e, 0xe8, 0x8d, 0x08, 0x8f, 0x3c, 0x9f, 0x70, 0xbb, 0xbc, 0x59, 0x6c, 0x57, 0xf1, 0x92,
-	0xd2, 0x7f, 0x93, 0xaa, 0xd1, 0x0b, 0x58, 0xca, 0xf8, 0xb2, 0x17, 0x79, 0x62, 0x68, 0x38, 0xbc,
-	0x91, 0xa9, 0xbb, 0x9e, 0x18, 0xee, 0xfc, 0x5e, 0x85, 0xd2, 0xf1, 0x90, 0x8e, 0x90, 0x07, 0x65,
-	0xcd, 0x9d, 0x68, 0xdb, 0x9d, 0xf1, 0x4c, 0xbb, 0x53, 0x2f, 0x57, 0xf3, 0xe5, 0x83, 0xb0, 0xa6,
-	0x6c, 0x5f, 0xc2, 0x82, 0xa2, 0x5e, 0xb4, 0x35, 0xf3, 0xd4, 0x24, 0x3d, 0x37, 0xd7, 0xee, 0xb0,
-	0xd0, 0xa1, 0x0c, 0x55, 0xba, 0xab, 0x39, 0x79, 0x8e, 0xbb, 0x53, 0xdc, 0x3e, 0xc7, 0xdd, 0x5b,
-	0x24, 0xff, 0x83, 0x72, 0x57, 0x90, 0xf9, 0xee, 0x66, 0x17, 0x6c, 0x3f, 0x04, 0x6a, 0xec, 0xff,
-	0x08, 0xd5, 0xb4, 0xb5, 0xd1, 0x47, 0x33, 0x0f, 0xde, 0x1e, 0x97, 0xa6, 0xfb, 0x50, 0x78, 0x96,
-	0x7a, 0x45, 0x0a, 0x73, 0x62, 0x99, 0x24, 0x8e, 0xdc, 0xd4, 0x1f, 0x41, 0x59, 0x13, 0xca, 0x9c,
-	0xd4, 0x4f, 0xb1, 0x4e, 0xae, 0xb5, 0x13, 0x80, 0x6c, 0x1c, 0xd1, 0xec, 0xb8, 0xee, 0xcc, 0x6d,
-	0xae, 0xd5, 0x2f, 0xa0, 0x24, 0x39, 0x0e, 0xb5, 0x67, 0xda, 0x9b, 0xa0, 0xc1, 0x5c, 0x4b, 0x18,
-	0xca, 0xfa, 0xd1, 0x98, 0x13, 0xed, 0xd4, 0xcb, 0xd2, 0xbc, 0xff, 0xd7, 0x47, 0x61, 0x3e, 0xb6,
-	0xa4, 0x77, 0x92, 0x72, 0xe7, 0x78, 0x37, 0xc1, 0xca, 0xb9, 0xde, 0x7d, 0x2f, 0xe3, 0x24, 0xfe,
-	0xdc, 0x38, 0xd3, 0xdf, 0x88, 0xe6, 0xd6, 0x03, 0x90, 0xa6, 0x69, 0x3e, 0x87, 0x62, 0x57, 0x5c,
-	0xa1, 0x17, 0xb3, 0x5b, 0x26, 0x7d, 0x9f, 0x67, 0x96, 0x38, 0x7d, 0x16, 0xe6, 0x95, 0xf8, 0xf6,
-	0xfb, 0x91, 0x67, 0x75, 0xcf, 0xbe, 0x7e, 0xdf, 0x7a, 0xf2, 0xf7, 0xfb, 0xd6, 0x93, 0x9f, 0x6f,
-	0x5a, 0xd6, 0xf5, 0x4d, 0xcb, 0xfa, 0xf3, 0xa6, 0x65, 0xfd, 0x7b, 0xd3, 0xb2, 0x4e, 0xcb, 0x0a,
-	0xf9, 0xea, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x81, 0x12, 0xdb, 0xb6, 0xae, 0x0c, 0x00, 0x00,
+	// 1149 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4f, 0x6f, 0xe3, 0x44,
+	0x14, 0x5f, 0x27, 0x69, 0x36, 0x79, 0xd9, 0xa4, 0xed, 0xa8, 0xaa, 0xbc, 0x29, 0xa4, 0xc5, 0xd2,
+	0x6a, 0xd3, 0x2e, 0x38, 0xd0, 0xbd, 0xad, 0xe0, 0xd0, 0x7f, 0x88, 0x85, 0x02, 0xd1, 0xb4, 0x9c,
+	0x90, 0x88, 0x5c, 0x67, 0x9a, 0x0c, 0x75, 0x3c, 0xc6, 0x33, 0xe9, 0xb6, 0x37, 0x3e, 0x00, 0x07,
+	0xae, 0xdc, 0xf9, 0x0e, 0x7c, 0x85, 0x1e, 0xb9, 0xc1, 0x69, 0x61, 0xfb, 0x49, 0xd0, 0xfc, 0xb1,
+	0x9d, 0xb4, 0x75, 0xd2, 0x4a, 0x5c, 0xac, 0x99, 0x37, 0xbf, 0x79, 0xf3, 0xde, 0xfb, 0xbd, 0x3f,
+	0x86, 0xcf, 0x06, 0x54, 0x0c, 0xc7, 0x27, 0xae, 0xcf, 0x46, 0x1d, 0x9f, 0x85, 0xc2, 0xa3, 0x21,
+	0x89, 0xfb, 0x93, 0x4b, 0x2f, 0xa2, 0x1d, 0x4e, 0xe2, 0x73, 0xea, 0x13, 0xde, 0xe1, 0x43, 0x3a,
+	0x52, 0x1f, 0x37, 0x8a, 0x99, 0x60, 0x68, 0x2d, 0x03, 0xba, 0xe7, 0x9f, 0xb8, 0x09, 0xce, 0x95,
+	0x90, 0xe6, 0xd3, 0x01, 0x63, 0x83, 0x80, 0x74, 0x14, 0xf4, 0x64, 0x7c, 0xda, 0xf1, 0xc2, 0x4b,
+	0x7d, 0xaf, 0xb9, 0x76, 0xf3, 0x88, 0x8c, 0x22, 0x91, 0x1c, 0xae, 0x0c, 0xd8, 0x80, 0xa9, 0x65,
+	0x47, 0xae, 0x8c, 0xf4, 0xd3, 0x7b, 0x59, 0x2a, 0x2e, 0x23, 0xc2, 0x3b, 0x23, 0x36, 0x0e, 0x85,
+	0xfe, 0x9a, 0xdb, 0xaf, 0x1e, 0x70, 0x5b, 0x78, 0xfc, 0x4c, 0x7d, 0xcc, 0xdd, 0xf5, 0x9b, 0xc6,
+	0x0a, 0x3a, 0x22, 0x5c, 0x78, 0xa3, 0x48, 0x03, 0x9c, 0xbf, 0x0a, 0x50, 0xdf, 0x8b, 0x89, 0x27,
+	0x08, 0x26, 0x3f, 0x8d, 0x09, 0x17, 0x68, 0x15, 0x0a, 0xb4, 0x6f, 0x5b, 0x1b, 0x56, 0xbb, 0xba,
+	0x5b, 0xbe, 0x7e, 0xbb, 0x5e, 0x78, 0xbd, 0x8f, 0x0b, 0xb4, 0x8f, 0x56, 0xa1, 0x7c, 0x32, 0x0e,
+	0xfb, 0x01, 0xb1, 0x0b, 0xf2, 0x0c, 0x9b, 0x1d, 0xb2, 0xe1, 0x71, 0x3c, 0x0e, 0xa5, 0x5e, 0xbb,
+	0xa8, 0x0e, 0x92, 0x2d, 0x7a, 0x0a, 0x95, 0x90, 0xf5, 0x22, 0x7a, 0xce, 0x84, 0x5d, 0xda, 0xb0,
+	0xda, 0x15, 0xfc, 0x38, 0x64, 0x5d, 0xb9, 0x45, 0x4d, 0xa8, 0x08, 0x12, 0x8f, 0x68, 0xe8, 0x05,
+	0xf6, 0x82, 0x3a, 0x4a, 0xf7, 0x68, 0x05, 0x16, 0xb8, 0xe8, 0xd3, 0xd0, 0x2e, 0x2b, 0x75, 0x7a,
+	0x23, 0x9f, 0xe7, 0xa2, 0xcf, 0xc6, 0xc2, 0x7e, 0xac, 0x9f, 0xd7, 0x3b, 0x23, 0x27, 0x71, 0x6c,
+	0x57, 0x52, 0x39, 0x89, 0x63, 0xb4, 0x0d, 0xe5, 0x98, 0x31, 0x71, 0xca, 0xed, 0xea, 0x46, 0xb1,
+	0x5d, 0xdb, 0x6e, 0xba, 0xd3, 0x7c, 0xab, 0x78, 0xb9, 0x5f, 0xcb, 0x38, 0x63, 0x83, 0x44, 0x2d,
+	0x00, 0x7f, 0x48, 0xfc, 0xb3, 0x88, 0xd1, 0x50, 0xd8, 0xa0, 0xf4, 0x4d, 0x48, 0xd0, 0x0b, 0x58,
+	0x8e, 0xbc, 0x98, 0x84, 0xa2, 0x37, 0x01, 0xab, 0x29, 0xd8, 0x92, 0x3e, 0xd8, 0x4b, 0xe5, 0x8e,
+	0x03, 0x8d, 0x24, 0xb0, 0x3c, 0x62, 0x21, 0x27, 0x68, 0x09, 0x8a, 0x91, 0x09, 0x6d, 0x1d, 0xcb,
+	0xa5, 0xd3, 0x80, 0x27, 0x47, 0xc2, 0x8b, 0x85, 0x89, 0xbd, 0xf3, 0x01, 0xd4, 0xf7, 0x49, 0x40,
+	0x32, 0x32, 0x6e, 0x5f, 0x11, 0xd0, 0x48, 0x20, 0x46, 0xed, 0x3a, 0xd4, 0xc8, 0x05, 0x15, 0x3d,
+	0x2e, 0x3c, 0x31, 0xe6, 0x06, 0x0b, 0x52, 0x74, 0xa4, 0x24, 0x68, 0x07, 0xaa, 0x72, 0x47, 0xfa,
+	0x3d, 0x4f, 0x28, 0xf2, 0x64, 0x34, 0x74, 0x62, 0xb8, 0x49, 0x62, 0xb8, 0xc7, 0x49, 0x62, 0xec,
+	0x56, 0xae, 0xde, 0xae, 0x3f, 0xfa, 0xf5, 0x9f, 0x75, 0x0b, 0x57, 0xf4, 0xb5, 0x1d, 0xe1, 0xfc,
+	0x66, 0x41, 0xed, 0xe0, 0x82, 0xf8, 0x89, 0x5d, 0x93, 0xfc, 0x59, 0x79, 0xfc, 0x15, 0xee, 0xe6,
+	0xaf, 0x98, 0xc3, 0x5f, 0x69, 0x8a, 0xbf, 0x36, 0x94, 0x78, 0x44, 0x7c, 0x95, 0x1d, 0xb5, 0xed,
+	0x95, 0x5b, 0xf6, 0xee, 0x84, 0x97, 0x58, 0x21, 0x9c, 0x7d, 0x28, 0xe3, 0x80, 0x8e, 0xa8, 0x40,
+	0x08, 0x4a, 0x92, 0x56, 0x9d, 0xbc, 0x58, 0xad, 0xa5, 0x6c, 0xe8, 0xc5, 0x7d, 0x65, 0x4c, 0x09,
+	0xab, 0xb5, 0x94, 0x71, 0x76, 0xaa, 0x2d, 0x29, 0x61, 0xb5, 0x76, 0x36, 0xe0, 0x89, 0x76, 0x30,
+	0x97, 0xac, 0x43, 0x80, 0xae, 0xb8, 0xcc, 0x65, 0x46, 0xfa, 0xfd, 0x86, 0xf6, 0xc5, 0x50, 0x3d,
+	0x55, 0xc7, 0x7a, 0x23, 0xfd, 0x1b, 0x12, 0x3a, 0x18, 0xea, 0xd7, 0xea, 0xd8, 0xec, 0x9c, 0x45,
+	0xa8, 0x1f, 0x9c, 0x93, 0x50, 0xf0, 0x84, 0x7b, 0x9d, 0x0b, 0x29, 0xf5, 0xce, 0xef, 0x05, 0xa8,
+	0x1b, 0x81, 0x31, 0xe9, 0xa1, 0x95, 0x69, 0x4c, 0x2c, 0x66, 0x26, 0xbe, 0x94, 0xc1, 0x56, 0x59,
+	0x22, 0x83, 0xdd, 0xd8, 0x5e, 0xbb, 0xb3, 0x28, 0x74, 0xda, 0x60, 0x03, 0x45, 0xaf, 0xa0, 0x1a,
+	0xc5, 0xcc, 0x27, 0x9c, 0x13, 0x6e, 0x2f, 0xa8, 0x62, 0x7a, 0xef, 0xce, 0x7b, 0x5d, 0x8d, 0xc2,
+	0x19, 0xfc, 0x7f, 0xaa, 0xe5, 0xc9, 0x6c, 0xab, 0x4e, 0x67, 0x9b, 0x0c, 0x5b, 0xd7, 0x1b, 0xf3,
+	0x34, 0x6c, 0x8b, 0x50, 0xc7, 0x84, 0x8f, 0x47, 0xa9, 0xa0, 0x2e, 0x33, 0x97, 0xa6, 0x25, 0xf6,
+	0x1a, 0x6a, 0x5f, 0xd1, 0x20, 0xc8, 0xba, 0x5d, 0x99, 0xd3, 0x41, 0x92, 0xc6, 0x75, 0x6c, 0x76,
+	0x32, 0x76, 0x5e, 0x10, 0xa8, 0x80, 0x56, 0xb0, 0x5c, 0xde, 0x8e, 0xa6, 0xf3, 0x0c, 0x96, 0xf7,
+	0x02, 0xc6, 0xc9, 0x91, 0x74, 0x2a, 0xbf, 0x62, 0xb7, 0x60, 0xa9, 0x9b, 0x04, 0x64, 0x4e, 0x93,
+	0x75, 0xbe, 0x85, 0xe5, 0x09, 0xac, 0xe1, 0x7d, 0x8a, 0x00, 0xeb, 0x41, 0x04, 0x38, 0xbf, 0x14,
+	0x60, 0x39, 0x6b, 0x4a, 0xc9, 0xf3, 0x08, 0x4a, 0xb2, 0xb4, 0x4d, 0xe9, 0xaa, 0x35, 0x5a, 0x83,
+	0xaa, 0x17, 0x04, 0xec, 0x4d, 0x4f, 0xf8, 0x91, 0xf1, 0xbb, 0xa2, 0x04, 0xc7, 0x7e, 0x84, 0x3e,
+	0x04, 0xa4, 0x0f, 0xc7, 0x21, 0xbd, 0xe8, 0x71, 0xe6, 0x9f, 0x11, 0xc1, 0x55, 0x2c, 0x2a, 0x78,
+	0x49, 0x9d, 0x7c, 0x17, 0xd2, 0x8b, 0x23, 0x2d, 0x47, 0xcf, 0xa0, 0x61, 0x54, 0x25, 0xac, 0xe9,
+	0xf6, 0x5f, 0xd7, 0xfa, 0x92, 0x46, 0xf1, 0x3e, 0xc0, 0x29, 0x0d, 0x48, 0x2f, 0x60, 0xfe, 0x19,
+	0x37, 0x63, 0xa0, 0x2a, 0x25, 0x87, 0x52, 0x80, 0x36, 0x61, 0x49, 0x8d, 0xd6, 0x5e, 0xe8, 0x8d,
+	0x08, 0x8f, 0x3c, 0x9f, 0x70, 0xbb, 0xbc, 0x51, 0x6c, 0x57, 0xf1, 0xa2, 0x92, 0x7f, 0x93, 0x8a,
+	0xd1, 0x73, 0x58, 0xcc, 0x3a, 0x72, 0x2f, 0xf2, 0xc4, 0xd0, 0x64, 0x56, 0x23, 0x13, 0x77, 0x3d,
+	0x31, 0xdc, 0xfe, 0xa3, 0x0a, 0xa5, 0xa3, 0x21, 0x1d, 0x21, 0x0f, 0xca, 0xba, 0x3b, 0xa3, 0x2d,
+	0x77, 0xc6, 0x8f, 0x80, 0x3b, 0x35, 0x1b, 0x9b, 0x2f, 0xee, 0x85, 0x35, 0xb4, 0x7d, 0x09, 0x0b,
+	0xaa, 0xb9, 0xa3, 0xcd, 0x99, 0xb7, 0x26, 0x07, 0x40, 0x73, 0xf5, 0x56, 0x9f, 0x3b, 0x90, 0xae,
+	0x4a, 0x73, 0x75, 0xd7, 0x9f, 0x63, 0xee, 0xd4, 0xf4, 0x98, 0x63, 0xee, 0x8d, 0x31, 0xf2, 0x83,
+	0x32, 0x57, 0x90, 0xf9, 0xe6, 0x66, 0x0f, 0x6c, 0xdd, 0x07, 0x6a, 0xf4, 0xff, 0x08, 0xd5, 0x34,
+	0xb5, 0xd1, 0x47, 0x33, 0x2f, 0xde, 0x2c, 0x97, 0xa6, 0x7b, 0x5f, 0x78, 0x16, 0x7a, 0xd5, 0x14,
+	0xe6, 0xf8, 0x32, 0xd9, 0x38, 0x72, 0x43, 0x7f, 0x08, 0x65, 0xdd, 0x50, 0xe6, 0x84, 0x7e, 0xaa,
+	0xeb, 0xe4, 0x6a, 0x3b, 0x06, 0xc8, 0xca, 0x11, 0xcd, 0xf6, 0xeb, 0x56, 0xdd, 0xe6, 0x6a, 0xfd,
+	0x02, 0x4a, 0xb2, 0xc7, 0xa1, 0xf6, 0x4c, 0x7d, 0x13, 0x6d, 0x30, 0x57, 0x13, 0x86, 0xb2, 0x1e,
+	0x4b, 0x73, 0xbc, 0x9d, 0x9a, 0x5d, 0xcd, 0xbb, 0x7f, 0xae, 0x14, 0xe6, 0x63, 0x4b, 0x5a, 0x27,
+	0x5b, 0xee, 0x1c, 0xeb, 0x26, 0xba, 0x72, 0xae, 0x75, 0xdf, 0x4b, 0x3f, 0x89, 0x3f, 0xd7, 0xcf,
+	0xf4, 0x47, 0xa5, 0xb9, 0x79, 0x0f, 0xa4, 0x49, 0x9a, 0xcf, 0xa1, 0xd8, 0x15, 0x97, 0xe8, 0xf9,
+	0xec, 0x94, 0x49, 0xff, 0x00, 0x66, 0x52, 0x9c, 0x8e, 0x85, 0x79, 0x14, 0xdf, 0x9c, 0x1f, 0x79,
+	0x5a, 0x77, 0xed, 0xab, 0x77, 0xad, 0x47, 0x7f, 0xbf, 0x6b, 0x3d, 0xfa, 0xf9, 0xba, 0x65, 0x5d,
+	0x5d, 0xb7, 0xac, 0x3f, 0xaf, 0x5b, 0xd6, 0xbf, 0xd7, 0x2d, 0xeb, 0xa4, 0xac, 0x90, 0x2f, 0xff,
+	0x0b, 0x00, 0x00, 0xff, 0xff, 0xa8, 0x64, 0xea, 0xc1, 0x10, 0x0d, 0x00, 0x00,
 }
diff --git a/api/services/shim/shim.proto b/api/services/shim/shim.proto
index 94f859dfd..b6aefba20 100644
--- a/api/services/shim/shim.proto
+++ b/api/services/shim/shim.proto
@@ -97,6 +97,10 @@ message StateResponse {
 	uint32 pid = 3;
 	containerd.v1.types.Status status = 4;
 	repeated containerd.v1.types.Process processes = 5;
+	string stdin = 6;
+	string stdout = 7;
+	string stderr = 8;
+	bool terminal = 9;
 }
 
 message PauseRequest {
diff --git a/api/types/task/task.pb.go b/api/types/task/task.pb.go
index cb8775ef4..be43ffd57 100644
--- a/api/types/task/task.pb.go
+++ b/api/types/task/task.pb.go
@@ -113,6 +113,10 @@ type Task struct {
 	Pid         uint32                `protobuf:"varint,3,opt,name=pid,proto3" json:"pid,omitempty"`
 	Status      Status                `protobuf:"varint,4,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"`
 	Spec        *google_protobuf1.Any `protobuf:"bytes,5,opt,name=spec" json:"spec,omitempty"`
+	Stdin       string                `protobuf:"bytes,6,opt,name=stdin,proto3" json:"stdin,omitempty"`
+	Stdout      string                `protobuf:"bytes,7,opt,name=stdout,proto3" json:"stdout,omitempty"`
+	Stderr      string                `protobuf:"bytes,8,opt,name=stderr,proto3" json:"stderr,omitempty"`
+	Terminal    bool                  `protobuf:"varint,9,opt,name=terminal,proto3" json:"terminal,omitempty"`
 }
 
 func (m *Task) Reset()                    { *m = Task{} }
@@ -129,6 +133,9 @@ type Process struct {
 	ExitStatus  uint32                `protobuf:"varint,7,opt,name=exit_status,json=exitStatus,proto3" json:"exit_status,omitempty"`
 	Status      Status                `protobuf:"varint,8,opt,name=status,proto3,enum=containerd.v1.types.Status" json:"status,omitempty"`
 	RuntimeData *google_protobuf1.Any `protobuf:"bytes,9,opt,name=runtime_data,json=runtimeData" json:"runtime_data,omitempty"`
+	Stdin       string                `protobuf:"bytes,10,opt,name=stdin,proto3" json:"stdin,omitempty"`
+	Stdout      string                `protobuf:"bytes,11,opt,name=stdout,proto3" json:"stdout,omitempty"`
+	Stderr      string                `protobuf:"bytes,12,opt,name=stderr,proto3" json:"stderr,omitempty"`
 }
 
 func (m *Process) Reset()                    { *m = Process{} }
@@ -212,6 +219,34 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n1
 	}
+	if len(m.Stdin) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.Stdin)))
+		i += copy(dAtA[i:], m.Stdin)
+	}
+	if len(m.Stdout) > 0 {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.Stdout)))
+		i += copy(dAtA[i:], m.Stdout)
+	}
+	if len(m.Stderr) > 0 {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.Stderr)))
+		i += copy(dAtA[i:], m.Stderr)
+	}
+	if m.Terminal {
+		dAtA[i] = 0x48
+		i++
+		if m.Terminal {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
 	return i, nil
 }
 
@@ -311,6 +346,24 @@ func (m *Process) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i += n3
 	}
+	if len(m.Stdin) > 0 {
+		dAtA[i] = 0x52
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.Stdin)))
+		i += copy(dAtA[i:], m.Stdin)
+	}
+	if len(m.Stdout) > 0 {
+		dAtA[i] = 0x5a
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.Stdout)))
+		i += copy(dAtA[i:], m.Stdout)
+	}
+	if len(m.Stderr) > 0 {
+		dAtA[i] = 0x62
+		i++
+		i = encodeVarintTask(dAtA, i, uint64(len(m.Stderr)))
+		i += copy(dAtA[i:], m.Stderr)
+	}
 	return i, nil
 }
 
@@ -454,6 +507,21 @@ func (m *Task) Size() (n int) {
 		l = m.Spec.Size()
 		n += 1 + l + sovTask(uint64(l))
 	}
+	l = len(m.Stdin)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
+	l = len(m.Stdout)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
+	l = len(m.Stderr)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
+	if m.Terminal {
+		n += 2
+	}
 	return n
 }
 
@@ -496,6 +564,18 @@ func (m *Process) Size() (n int) {
 		l = m.RuntimeData.Size()
 		n += 1 + l + sovTask(uint64(l))
 	}
+	l = len(m.Stdin)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
+	l = len(m.Stdout)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
+	l = len(m.Stderr)
+	if l > 0 {
+		n += 1 + l + sovTask(uint64(l))
+	}
 	return n
 }
 
@@ -562,6 +642,10 @@ func (this *Task) String() string {
 		`Pid:` + fmt.Sprintf("%v", this.Pid) + `,`,
 		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
 		`Spec:` + strings.Replace(fmt.Sprintf("%v", this.Spec), "Any", "google_protobuf1.Any", 1) + `,`,
+		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
+		`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
+		`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
+		`Terminal:` + fmt.Sprintf("%v", this.Terminal) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -580,6 +664,9 @@ func (this *Process) String() string {
 		`ExitStatus:` + fmt.Sprintf("%v", this.ExitStatus) + `,`,
 		`Status:` + fmt.Sprintf("%v", this.Status) + `,`,
 		`RuntimeData:` + strings.Replace(fmt.Sprintf("%v", this.RuntimeData), "Any", "google_protobuf1.Any", 1) + `,`,
+		`Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`,
+		`Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`,
+		`Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`,
 		`}`,
 	}, "")
 	return s
@@ -776,6 +863,113 @@ func (m *Task) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stdin = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stdout = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stderr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Terminal", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Terminal = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTask(dAtA[iNdEx:])
@@ -1056,6 +1250,93 @@ func (m *Process) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 10:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stdin", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stdin = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stdout = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 12:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTask
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTask
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Stderr = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTask(dAtA[iNdEx:])
@@ -1503,50 +1784,54 @@ func init() {
 }
 
 var fileDescriptorTask = []byte{
-	// 718 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xbf, 0x6f, 0xf3, 0x44,
-	0x18, 0xce, 0x39, 0xce, 0xaf, 0x4b, 0x93, 0xcf, 0x1c, 0x9f, 0x90, 0xbf, 0x80, 0x1c, 0x2b, 0x42,
-	0x22, 0x42, 0xc2, 0x11, 0xe9, 0x00, 0x62, 0x4b, 0x63, 0xab, 0x8a, 0x10, 0x49, 0xb8, 0x38, 0xa2,
-	0x5b, 0x74, 0xcd, 0x1d, 0xe6, 0xd4, 0xc6, 0xb6, 0xec, 0x73, 0x4b, 0x36, 0x46, 0xd4, 0x89, 0x7f,
-	0xa0, 0x0b, 0xb0, 0xb2, 0x32, 0xb0, 0xb2, 0x74, 0x64, 0x64, 0x2a, 0x34, 0x7f, 0x09, 0xf2, 0xd9,
-	0xf9, 0xa1, 0x36, 0x20, 0x16, 0xeb, 0xbd, 0xf7, 0x79, 0xee, 0xbd, 0xe7, 0x79, 0xee, 0x0c, 0x3f,
-	0xf3, 0xb8, 0xf8, 0x26, 0xb9, 0xb4, 0x96, 0xc1, 0xaa, 0xb7, 0x0c, 0x7c, 0x41, 0xb8, 0xcf, 0x22,
-	0x7a, 0x58, 0x92, 0x90, 0xf7, 0xc4, 0x3a, 0x64, 0x71, 0x4f, 0x90, 0xf8, 0x4a, 0x7e, 0xac, 0x30,
-	0x0a, 0x44, 0x80, 0xde, 0xde, 0xb3, 0xac, 0x9b, 0x8f, 0x2d, 0x49, 0x6a, 0xbd, 0xf6, 0x02, 0x2f,
-	0x90, 0x78, 0x2f, 0xad, 0x32, 0x6a, 0xeb, 0x8d, 0x17, 0x04, 0xde, 0x35, 0xeb, 0xc9, 0xd5, 0x65,
-	0xf2, 0x75, 0x8f, 0xf8, 0xeb, 0x1c, 0x6a, 0x3f, 0x87, 0x04, 0x5f, 0xb1, 0x58, 0x90, 0x55, 0x98,
-	0x11, 0x3a, 0xbf, 0x03, 0xa8, 0xba, 0x24, 0xbe, 0x42, 0xef, 0x40, 0x85, 0x53, 0x1d, 0x98, 0xa0,
-	0x5b, 0x3b, 0x2b, 0x6f, 0x1e, 0xdb, 0xca, 0xc8, 0xc6, 0x0a, 0xa7, 0xa8, 0x0f, 0x4f, 0x76, 0x4a,
-	0x16, 0x9c, 0xea, 0x8a, 0x64, 0xbc, 0xda, 0x3c, 0xb6, 0xeb, 0xc3, 0x6d, 0x7f, 0x64, 0xe3, 0xfa,
-	0x8e, 0x34, 0xa2, 0x48, 0x83, 0xc5, 0x90, 0x53, 0xbd, 0x68, 0x82, 0x6e, 0x03, 0xa7, 0x25, 0x3a,
-	0x85, 0xe5, 0x58, 0x10, 0x91, 0xc4, 0xba, 0x6a, 0x82, 0x6e, 0xb3, 0xff, 0xae, 0x75, 0xc4, 0x9e,
-	0x35, 0x93, 0x14, 0x9c, 0x53, 0x51, 0x17, 0xaa, 0x71, 0xc8, 0x96, 0x7a, 0xc9, 0x04, 0xdd, 0x7a,
-	0xff, 0xb5, 0x95, 0x79, 0xb1, 0xb6, 0x5e, 0xac, 0x81, 0xbf, 0xc6, 0x92, 0xd1, 0xf9, 0x45, 0x81,
-	0x95, 0x69, 0x14, 0x2c, 0x59, 0x1c, 0x6f, 0x0f, 0x07, 0xfb, 0xc3, 0x11, 0x54, 0x49, 0xe4, 0xc5,
-	0xba, 0x62, 0x16, 0xbb, 0x35, 0x2c, 0xeb, 0x94, 0xc5, 0xfc, 0x1b, 0xbd, 0x28, 0x5b, 0x69, 0x89,
-	0x3e, 0x82, 0x6a, 0x12, 0xb3, 0x48, 0x0a, 0xac, 0xf7, 0xdf, 0x1c, 0x15, 0x38, 0x8f, 0x59, 0x84,
-	0x25, 0x2d, 0x1d, 0xb0, 0xbc, 0xa5, 0x52, 0x5b, 0x0d, 0xa7, 0x25, 0x6a, 0xc1, 0xaa, 0x60, 0xd1,
-	0x8a, 0xfb, 0xe4, 0x5a, 0x2f, 0x9b, 0xa0, 0x5b, 0xc5, 0xbb, 0x35, 0x6a, 0xc3, 0x3a, 0xfb, 0x96,
-	0x8b, 0x45, 0x1e, 0x42, 0x45, 0x8a, 0x83, 0x69, 0x2b, 0xf3, 0x7c, 0x10, 0x50, 0xf5, 0xff, 0x07,
-	0xf4, 0x09, 0x3c, 0x89, 0x12, 0x3f, 0xbd, 0xd2, 0x05, 0x25, 0x82, 0xe8, 0xb5, 0xff, 0x08, 0xaa,
-	0x9e, 0x33, 0x6d, 0x22, 0x48, 0x67, 0x06, 0xd5, 0x79, 0x6e, 0x22, 0xd9, 0x67, 0x95, 0x70, 0x79,
-	0x75, 0x5e, 0x7e, 0xcb, 0x0d, 0x9c, 0x96, 0xe8, 0x03, 0xf8, 0x8a, 0x50, 0xca, 0x05, 0x0f, 0x7c,
-	0x72, 0xbd, 0xf0, 0x38, 0x8d, 0x65, 0x6a, 0x0d, 0xdc, 0xdc, 0xb7, 0xcf, 0x39, 0x8d, 0x3b, 0x3f,
-	0x2a, 0xb0, 0xe4, 0xdc, 0x30, 0x5f, 0xfc, 0xeb, 0x5b, 0xfa, 0x14, 0xaa, 0xa9, 0x0f, 0x39, 0xbd,
-	0xd9, 0x7f, 0xff, 0xa8, 0x45, 0x39, 0x21, 0xfb, 0xba, 0xeb, 0x90, 0x61, 0xb9, 0xe3, 0xc8, 0x8b,
-	0x7a, 0x96, 0xa8, 0xfa, 0x22, 0xd1, 0x01, 0xac, 0xa5, 0x2b, 0x46, 0x17, 0x44, 0xe4, 0x4f, 0xa8,
-	0xf5, 0x22, 0x19, 0x77, 0xfb, 0x3b, 0x9c, 0x55, 0x1f, 0x1e, 0xdb, 0x85, 0x1f, 0xfe, 0x6a, 0x03,
-	0x5c, 0xcd, 0xb6, 0x0d, 0x44, 0xe7, 0x4b, 0x58, 0xdb, 0x09, 0x41, 0x55, 0xa8, 0x3a, 0x17, 0x23,
-	0x57, 0x2b, 0xa0, 0x0a, 0x2c, 0x4e, 0x26, 0x5f, 0x68, 0x00, 0x41, 0x58, 0x1e, 0x62, 0x67, 0xe0,
-	0x3a, 0x9a, 0x82, 0x6a, 0xb0, 0x34, 0x73, 0x07, 0xd8, 0xd5, 0x8a, 0xa8, 0x09, 0xa1, 0x73, 0xe1,
-	0x0c, 0x17, 0x03, 0xdb, 0x76, 0x6c, 0x4d, 0x4d, 0x69, 0xd3, 0xc1, 0x7c, 0xe6, 0xd8, 0x5a, 0xe9,
-	0xc3, 0x5f, 0x01, 0x2c, 0xe7, 0x02, 0x0d, 0x58, 0x99, 0x8f, 0x3f, 0x1f, 0x4f, 0xbe, 0x1a, 0x6b,
-	0x85, 0xd6, 0x5b, 0x77, 0xf7, 0x66, 0x23, 0x03, 0xe6, 0xfe, 0x95, 0x1f, 0xdc, 0xfa, 0x29, 0x9e,
-	0x4d, 0xb7, 0x35, 0x70, 0x88, 0x0f, 0x23, 0x46, 0x04, 0xa3, 0x29, 0x8e, 0xe7, 0xe3, 0xf1, 0x68,
-	0x7c, 0xae, 0x29, 0x87, 0x38, 0x4e, 0x7c, 0x9f, 0xfb, 0x5e, 0x8a, 0xcf, 0xdc, 0xc9, 0x74, 0xea,
-	0xd8, 0x5a, 0xf1, 0x10, 0x9f, 0x89, 0x20, 0x0c, 0x19, 0x45, 0xef, 0xed, 0x64, 0xa9, 0x2d, 0xed,
-	0xee, 0xde, 0x3c, 0xc9, 0xe0, 0x29, 0x49, 0x62, 0x46, 0x5b, 0xcd, 0xef, 0x7f, 0x32, 0x0a, 0xbf,
-	0xfd, 0x6c, 0xe4, 0x6a, 0xcf, 0xf4, 0x87, 0x27, 0xa3, 0xf0, 0xe7, 0x93, 0x51, 0xf8, 0x6e, 0x63,
-	0x80, 0x87, 0x8d, 0x01, 0xfe, 0xd8, 0x18, 0xe0, 0xef, 0x8d, 0x01, 0x2e, 0xcb, 0x32, 0xcd, 0xd3,
-	0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x51, 0xea, 0x99, 0x62, 0xee, 0x04, 0x00, 0x00,
+	// 775 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x4d, 0x6f, 0xe3, 0x44,
+	0x18, 0x8e, 0x1d, 0xe7, 0x6b, 0xd2, 0x66, 0xcd, 0x50, 0xad, 0xbc, 0x01, 0x39, 0x56, 0x84, 0x44,
+	0x84, 0x84, 0x23, 0xb2, 0x07, 0x10, 0xb7, 0xb4, 0xb6, 0x56, 0x11, 0x22, 0x0d, 0x13, 0x47, 0xec,
+	0x2d, 0x9a, 0x66, 0x06, 0x33, 0x6a, 0x3b, 0xb6, 0x3c, 0xe3, 0x2e, 0xbd, 0x71, 0x44, 0x7b, 0xe2,
+	0x0f, 0xec, 0x85, 0x8f, 0xbf, 0xc0, 0x81, 0x5f, 0xd0, 0x23, 0x47, 0x4e, 0x85, 0xcd, 0x5f, 0xe0,
+	0x0f, 0xa0, 0x19, 0xbb, 0x49, 0x76, 0x9b, 0x4a, 0x7b, 0xb1, 0xde, 0x79, 0x9f, 0x67, 0x26, 0xcf,
+	0xfb, 0x3c, 0x6f, 0xc0, 0x97, 0x31, 0x93, 0xdf, 0xe7, 0x67, 0xfe, 0x2a, 0xb9, 0x1c, 0xae, 0x12,
+	0x2e, 0x31, 0xe3, 0x34, 0x23, 0xbb, 0x25, 0x4e, 0xd9, 0x50, 0x5e, 0xa7, 0x54, 0x0c, 0x25, 0x16,
+	0xe7, 0xfa, 0xe3, 0xa7, 0x59, 0x22, 0x13, 0xf8, 0xfe, 0x96, 0xe5, 0x5f, 0x7d, 0xe6, 0x6b, 0x52,
+	0xf7, 0x28, 0x4e, 0xe2, 0x44, 0xe3, 0x43, 0x55, 0x15, 0xd4, 0xee, 0x93, 0x38, 0x49, 0xe2, 0x0b,
+	0x3a, 0xd4, 0xa7, 0xb3, 0xfc, 0xbb, 0x21, 0xe6, 0xd7, 0x25, 0xd4, 0x7b, 0x1b, 0x92, 0xec, 0x92,
+	0x0a, 0x89, 0x2f, 0xd3, 0x82, 0xd0, 0xff, 0xdd, 0x04, 0x56, 0x84, 0xc5, 0x39, 0x7c, 0x0c, 0x4c,
+	0x46, 0x1c, 0xc3, 0x33, 0x06, 0xad, 0xe3, 0xfa, 0xfa, 0xb6, 0x67, 0x4e, 0x02, 0x64, 0x32, 0x02,
+	0x47, 0xe0, 0x60, 0xa3, 0x64, 0xc9, 0x88, 0x63, 0x6a, 0xc6, 0xa3, 0xf5, 0x6d, 0xaf, 0x7d, 0x72,
+	0xd7, 0x9f, 0x04, 0xa8, 0xbd, 0x21, 0x4d, 0x08, 0xb4, 0x41, 0x35, 0x65, 0xc4, 0xa9, 0x7a, 0xc6,
+	0xe0, 0x10, 0xa9, 0x12, 0x3e, 0x05, 0x75, 0x21, 0xb1, 0xcc, 0x85, 0x63, 0x79, 0xc6, 0xa0, 0x33,
+	0xfa, 0xc0, 0xdf, 0x33, 0x9e, 0x3f, 0xd7, 0x14, 0x54, 0x52, 0xe1, 0x00, 0x58, 0x22, 0xa5, 0x2b,
+	0xa7, 0xe6, 0x19, 0x83, 0xf6, 0xe8, 0xc8, 0x2f, 0x66, 0xf1, 0xef, 0x66, 0xf1, 0xc7, 0xfc, 0x1a,
+	0x69, 0x06, 0x3c, 0x02, 0x35, 0x21, 0x09, 0xe3, 0x4e, 0x5d, 0xa9, 0x43, 0xc5, 0x01, 0x3e, 0x56,
+	0x3f, 0x4a, 0x92, 0x5c, 0x3a, 0x0d, 0xdd, 0x2e, 0x4f, 0x65, 0x9f, 0x66, 0x99, 0xd3, 0xdc, 0xf4,
+	0x69, 0x96, 0xc1, 0x2e, 0x68, 0x4a, 0x9a, 0x5d, 0x32, 0x8e, 0x2f, 0x9c, 0x96, 0x67, 0x0c, 0x9a,
+	0x68, 0x73, 0xee, 0xff, 0x67, 0x82, 0xc6, 0x2c, 0x4b, 0x56, 0x54, 0x88, 0xbb, 0xf1, 0x8c, 0xed,
+	0x78, 0x10, 0x58, 0x38, 0x8b, 0x85, 0x63, 0x7a, 0xd5, 0x41, 0x0b, 0xe9, 0x5a, 0xb1, 0x28, 0xbf,
+	0x72, 0xaa, 0xba, 0xa5, 0x4a, 0xf8, 0x29, 0xb0, 0x72, 0x41, 0x33, 0x6d, 0x41, 0x7b, 0xf4, 0x64,
+	0xaf, 0x05, 0x0b, 0x41, 0x33, 0xa4, 0x69, 0xea, 0x81, 0xd5, 0x0b, 0xa2, 0xa7, 0x6f, 0x21, 0x55,
+	0xbe, 0x21, 0xb0, 0xfe, 0xa6, 0x40, 0xd8, 0x03, 0x6d, 0xfa, 0x03, 0x93, 0xcb, 0xd2, 0xe6, 0x86,
+	0x16, 0x07, 0x54, 0xab, 0x70, 0x75, 0x27, 0x82, 0xe6, 0xbb, 0x47, 0xf0, 0x39, 0x38, 0xc8, 0x72,
+	0xae, 0x96, 0x66, 0x49, 0xb0, 0xc4, 0xda, 0x96, 0x87, 0xa2, 0x68, 0x97, 0xcc, 0x00, 0x4b, 0xbc,
+	0x4d, 0x04, 0xec, 0x4f, 0xa4, 0xfd, 0x40, 0x22, 0x07, 0xbb, 0x89, 0xf4, 0xe7, 0xc0, 0x5a, 0x94,
+	0x56, 0xe4, 0x5b, 0xc7, 0x73, 0xa6, 0x57, 0x2c, 0x2e, 0xb7, 0xf1, 0x10, 0xa9, 0x12, 0x7e, 0x0c,
+	0x1e, 0x61, 0x42, 0x98, 0x64, 0x09, 0xc7, 0x17, 0xcb, 0x98, 0x11, 0xa1, 0xbd, 0x3f, 0x44, 0x9d,
+	0x6d, 0xfb, 0x19, 0x23, 0xa2, 0xff, 0x8b, 0x09, 0x6a, 0xe1, 0x15, 0xe5, 0xf2, 0xc1, 0x9d, 0xff,
+	0x02, 0x58, 0xca, 0x0d, 0xfd, 0x7a, 0x67, 0xf4, 0xd1, 0x5e, 0xa3, 0xf4, 0x0b, 0xc5, 0x37, 0xba,
+	0x4e, 0x29, 0xd2, 0x37, 0xf6, 0x6c, 0xfe, 0x5b, 0xb9, 0x58, 0xf7, 0x72, 0x19, 0x83, 0x96, 0x3a,
+	0x51, 0xb2, 0xc4, 0xb2, 0x5c, 0xf5, 0xee, 0x3d, 0x7f, 0xa3, 0xbb, 0xbf, 0xed, 0x71, 0xf3, 0xe6,
+	0xb6, 0x57, 0xf9, 0xf9, 0x9f, 0x9e, 0x81, 0x9a, 0xc5, 0xb5, 0xb1, 0xec, 0x7f, 0x03, 0x5a, 0x1b,
+	0x21, 0xb0, 0x09, 0xac, 0xf0, 0xf9, 0x24, 0xb2, 0x2b, 0xb0, 0x01, 0xaa, 0xa7, 0xa7, 0x5f, 0xdb,
+	0x06, 0x04, 0xa0, 0x7e, 0x82, 0xc2, 0x71, 0x14, 0xda, 0x26, 0x6c, 0x81, 0xda, 0x3c, 0x1a, 0xa3,
+	0xc8, 0xae, 0xc2, 0x0e, 0x00, 0xe1, 0xf3, 0xf0, 0x64, 0x39, 0x0e, 0x82, 0x30, 0xb0, 0x2d, 0x45,
+	0x9b, 0x8d, 0x17, 0xf3, 0x30, 0xb0, 0x6b, 0x9f, 0xfc, 0x61, 0x80, 0x7a, 0x29, 0xd0, 0x05, 0x8d,
+	0xc5, 0xf4, 0xab, 0xe9, 0xe9, 0xb7, 0x53, 0xbb, 0xd2, 0x7d, 0xef, 0xe5, 0x2b, 0xef, 0xb0, 0x00,
+	0x16, 0xfc, 0x9c, 0x27, 0x2f, 0xb8, 0xc2, 0x8b, 0xd7, 0x03, 0xdb, 0xd8, 0xc5, 0x4f, 0x32, 0x8a,
+	0x25, 0x25, 0x0a, 0x47, 0x8b, 0xe9, 0x74, 0x32, 0x7d, 0x66, 0x9b, 0xbb, 0x38, 0xca, 0x39, 0x67,
+	0x3c, 0x56, 0xf8, 0x3c, 0x3a, 0x9d, 0xcd, 0xc2, 0xc0, 0xae, 0xee, 0xe2, 0x73, 0x99, 0xa4, 0x29,
+	0x25, 0xf0, 0xc3, 0x8d, 0x2c, 0xab, 0x6b, 0xbf, 0x7c, 0xe5, 0x1d, 0x14, 0xf0, 0x0c, 0xe7, 0x82,
+	0x92, 0x6e, 0xe7, 0xa7, 0x5f, 0xdd, 0xca, 0x9f, 0xbf, 0xb9, 0xa5, 0xda, 0x63, 0xe7, 0xe6, 0xb5,
+	0x5b, 0xf9, 0xfb, 0xb5, 0x5b, 0xf9, 0x71, 0xed, 0x1a, 0x37, 0x6b, 0xd7, 0xf8, 0x6b, 0xed, 0x1a,
+	0xff, 0xae, 0x5d, 0xe3, 0xac, 0xae, 0xdd, 0x7c, 0xfa, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x48,
+	0xcc, 0xfd, 0x9a, 0x96, 0x05, 0x00, 0x00,
 }
diff --git a/api/types/task/task.proto b/api/types/task/task.proto
index cce329f8e..e7563200e 100644
--- a/api/types/task/task.proto
+++ b/api/types/task/task.proto
@@ -23,6 +23,10 @@ message Task {
 	uint32 pid = 3;
 	Status status = 4;
 	google.protobuf.Any spec = 5;
+	string stdin = 6;
+	string stdout = 7;
+	string stderr = 8;
+	bool terminal = 9;
 }
 
 message Process {
@@ -35,6 +39,9 @@ message Process {
 	uint32 exit_status = 7;
 	Status status = 8;
 	google.protobuf.Any runtime_data = 9;
+	string stdin = 10;
+	string stdout = 11;
+	string stderr = 12;
 }
 
 message User {
diff --git a/container.go b/container.go
index 1deec2602..71c408228 100644
--- a/container.go
+++ b/container.go
@@ -3,6 +3,7 @@ package containerd
 import (
 	"context"
 	"encoding/json"
+	"path/filepath"
 
 	"github.com/containerd/containerd/api/services/containers"
 	"github.com/containerd/containerd/api/services/execution"
@@ -16,7 +17,7 @@ type Container interface {
 	NewTask(context.Context, IOCreation) (Task, error)
 	Spec() (*specs.Spec, error)
 	Task() Task
-	LoadTask(context.Context, IOCreation) (Task, error)
+	LoadTask(context.Context, IOAttach) (Task, error)
 }
 
 func containerFromProto(client *Client, c containers.Container) *container {
@@ -110,17 +111,28 @@ func (c *container) NewTask(ctx context.Context, ioCreate IOCreation) (Task, err
 	return t, nil
 }
 
-func (c *container) LoadTask(ctx context.Context, ioCreate IOCreation) (Task, error) {
-	i, err := ioCreate()
-	if err != nil {
-		return nil, err
-	}
+func (c *container) LoadTask(ctx context.Context, ioAttach IOAttach) (Task, error) {
 	response, err := c.client.TaskService().Info(ctx, &execution.InfoRequest{
 		ContainerID: c.c.ID,
 	})
 	if err != nil {
 		return nil, err
 	}
+	// get the existing fifo paths from the task information stored by the daemon
+	paths := &FifoSet{
+		Dir: getFifoDir([]string{
+			response.Task.Stdin,
+			response.Task.Stdout,
+			response.Task.Stderr,
+		}),
+		In:  response.Task.Stdin,
+		Out: response.Task.Stdout,
+		Err: response.Task.Stderr,
+	}
+	i, err := ioAttach(paths)
+	if err != nil {
+		return nil, err
+	}
 	t := &task{
 		client:      c.client,
 		io:          i,
@@ -130,3 +142,14 @@ func (c *container) LoadTask(ctx context.Context, ioCreate IOCreation) (Task, er
 	c.task = t
 	return t, nil
 }
+
+// getFifoDir looks for any non-empty path for a stdio fifo
+// and returns the dir for where it is located
+func getFifoDir(paths []string) string {
+	for _, p := range paths {
+		if p != "" {
+			return filepath.Dir(p)
+		}
+	}
+	return ""
+}
diff --git a/container_test.go b/container_test.go
index f2e791072..644334ad9 100644
--- a/container_test.go
+++ b/container_test.go
@@ -502,13 +502,7 @@ func TestContainerAttach(t *testing.T) {
 		wg.Done()
 	}()
 
-	// TODO: return fifo information from shim based on task/process
-	dir, err := ioutil.TempDir("", "attach")
-	if err != nil {
-		t.Error(err)
-		return
-	}
-	task, err := container.NewTask(ctx, WithIO(r, ow, ioutil.Discard, dir))
+	task, err := container.NewTask(ctx, NewIO(r, ow, ioutil.Discard))
 	if err != nil {
 		t.Error(err)
 		return
@@ -546,7 +540,7 @@ func TestContainerAttach(t *testing.T) {
 		t.Error(err)
 		return
 	}
-	if task, err = container.LoadTask(ctx, WithIO(r, ow, ioutil.Discard, dir)); err != nil {
+	if task, err = container.LoadTask(ctx, WithAttach(r, ow, ioutil.Discard)); err != nil {
 		t.Error(err)
 		return
 	}
diff --git a/io.go b/io.go
index e8c9f817c..a1b22e3b6 100644
--- a/io.go
+++ b/io.go
@@ -1,6 +1,7 @@
 package containerd
 
 import (
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -26,6 +27,8 @@ func (i *IO) Close() error {
 
 type IOCreation func() (*IO, error)
 
+type IOAttach func(*FifoSet) (*IO, error)
+
 func NewIO(stdin io.Reader, stdout, stderr io.Writer) IOCreation {
 	return func() (*IO, error) {
 		paths, err := NewFifos()
@@ -52,11 +55,10 @@ func NewIO(stdin io.Reader, stdout, stderr io.Writer) IOCreation {
 	}
 }
 
-func WithIO(stdin io.Reader, stdout, stderr io.Writer, dir string) IOCreation {
-	return func() (*IO, error) {
-		paths, err := WithFifos(dir)
-		if err != nil {
-			return nil, err
+func WithAttach(stdin io.Reader, stdout, stderr io.Writer) IOAttach {
+	return func(paths *FifoSet) (*IO, error) {
+		if paths == nil {
+			return nil, fmt.Errorf("cannot attach to existing fifos")
 		}
 		i := &IO{
 			Terminal: false,
@@ -121,19 +123,6 @@ func NewFifos() (*FifoSet, error) {
 	}, nil
 }
 
-// WithFifos returns existing or creates new fifos inside an existing dir
-func WithFifos(dir string) (*FifoSet, error) {
-	if err := os.MkdirAll(dir, 0700); err != nil {
-		return nil, err
-	}
-	return &FifoSet{
-		Dir: dir,
-		In:  filepath.Join(dir, "stdin"),
-		Out: filepath.Join(dir, "stdout"),
-		Err: filepath.Join(dir, "stderr"),
-	}, nil
-}
-
 type FifoSet struct {
 	// Dir is the directory holding the task fifos
 	Dir          string
diff --git a/linux/shim/exec.go b/linux/shim/exec.go
index 72703677b..39e2b3aeb 100644
--- a/linux/shim/exec.go
+++ b/linux/shim/exec.go
@@ -35,12 +35,21 @@ type execProcess struct {
 	stdin   io.Closer
 
 	parent *initProcess
+
+	stdinPath  string
+	stdoutPath string
+	stderrPath string
+	terminal   bool
 }
 
 func newExecProcess(context context.Context, path string, r *shimapi.ExecRequest, parent *initProcess, id int) (process, error) {
 	e := &execProcess{
-		id:     id,
-		parent: parent,
+		id:         id,
+		parent:     parent,
+		stdinPath:  r.Stdin,
+		stdoutPath: r.Stdout,
+		stderrPath: r.Stderr,
+		terminal:   r.Terminal,
 	}
 	var (
 		err     error
diff --git a/linux/shim/init.go b/linux/shim/init.go
index 0bf538a71..1f8ed3047 100644
--- a/linux/shim/init.go
+++ b/linux/shim/init.go
@@ -30,7 +30,8 @@ type initProcess struct {
 	// the right order when invoked in separate go routines.
 	// This is the case within the shim implementation as it makes use of
 	// the reaper interface.
-	mu      sync.Mutex
+	mu sync.Mutex
+
 	id      string
 	bundle  string
 	console console.Console
@@ -41,6 +42,11 @@ type initProcess struct {
 	pid     int
 	closers []io.Closer
 	stdin   io.Closer
+
+	stdinPath  string
+	stdoutPath string
+	stderrPath string
+	terminal   bool
 }
 
 func newInitProcess(context context.Context, path string, r *shimapi.CreateRequest) (*initProcess, error) {
@@ -61,9 +67,13 @@ func newInitProcess(context context.Context, path string, r *shimapi.CreateReque
 		PdeathSignal: syscall.SIGKILL,
 	}
 	p := &initProcess{
-		id:     r.ID,
-		bundle: r.Bundle,
-		runc:   runtime,
+		id:         r.ID,
+		bundle:     r.Bundle,
+		runc:       runtime,
+		stdinPath:  r.Stdin,
+		stdoutPath: r.Stdout,
+		stderrPath: r.Stderr,
+		terminal:   r.Terminal,
 	}
 	var (
 		err    error
diff --git a/linux/shim/service.go b/linux/shim/service.go
index cb03d23fb..3983f6f7a 100644
--- a/linux/shim/service.go
+++ b/linux/shim/service.go
@@ -192,6 +192,9 @@ func (s *Service) State(ctx context.Context, r *shimapi.StateRequest) (*shimapi.
 		Pid:       uint32(s.initProcess.Pid()),
 		Status:    status,
 		Processes: []*task.Process{},
+		Stdin:     s.initProcess.stdinPath,
+		Stdout:    s.initProcess.stdoutPath,
+		Stderr:    s.initProcess.stderrPath,
 	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -203,10 +206,16 @@ func (s *Service) State(ctx context.Context, r *shimapi.StateRequest) (*shimapi.
 			}
 			status = task.StatusStopped
 		}
-		o.Processes = append(o.Processes, &task.Process{
+		pp := &task.Process{
 			Pid:    uint32(p.Pid()),
 			Status: status,
-		})
+		}
+		if ep, ok := p.(*execProcess); ok {
+			pp.Stdin = ep.stdinPath
+			pp.Stdout = ep.stdoutPath
+			pp.Stderr = ep.stderrPath
+		}
+		o.Processes = append(o.Processes, pp)
 	}
 	return o, nil
 }
@@ -270,7 +279,6 @@ func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*
 	if err != nil {
 		return nil, err
 	}
-
 	ps := []*task.Process{}
 	for _, pid := range pids {
 		ps = append(ps, &task.Process{
@@ -280,9 +288,7 @@ func (s *Service) Processes(ctx context.Context, r *shimapi.ProcessesRequest) (*
 	resp := &shimapi.ProcessesResponse{
 		Processes: ps,
 	}
-
 	return resp, nil
-
 }
 
 func (s *Service) CloseStdin(ctx context.Context, r *shimapi.CloseStdinRequest) (*google_protobuf.Empty, error) {
diff --git a/linux/task.go b/linux/task.go
index dd0de51f6..1a04033a4 100644
--- a/linux/task.go
+++ b/linux/task.go
@@ -12,19 +12,6 @@ import (
 	specs "github.com/opencontainers/runtime-spec/specs-go"
 )
 
-type State struct {
-	pid    uint32
-	status plugin.Status
-}
-
-func (s State) Pid() uint32 {
-	return s.pid
-}
-
-func (s State) Status() plugin.Status {
-	return s.status
-}
-
 type Task struct {
 	containerID string
 	spec        []byte
@@ -56,7 +43,7 @@ func (c *Task) Start(ctx context.Context) error {
 func (c *Task) State(ctx context.Context) (plugin.State, error) {
 	response, err := c.shim.State(ctx, &shim.StateRequest{})
 	if err != nil {
-		return nil, err
+		return plugin.State{}, err
 	}
 	var status plugin.Status
 	switch response.Status {
@@ -70,9 +57,13 @@ func (c *Task) State(ctx context.Context) (plugin.State, error) {
 		status = plugin.PausedStatus
 		// TODO: containerd.DeletedStatus
 	}
-	return &State{
-		pid:    response.Pid,
-		status: status,
+	return plugin.State{
+		Pid:      response.Pid,
+		Status:   status,
+		Stdin:    response.Stdin,
+		Stdout:   response.Stdout,
+		Stderr:   response.Stderr,
+		Terminal: response.Terminal,
 	}, nil
 }
 
@@ -181,8 +172,8 @@ func (p *Process) State(ctx context.Context) (plugin.State, error) {
 	// use the container status for the status of the process
 	state, err := p.c.State(ctx)
 	if err != nil {
-		return nil, err
+		return state, err
 	}
-	state.(*State).pid = uint32(p.pid)
+	state.Pid = uint32(p.pid)
 	return state, nil
 }
diff --git a/metrics/cgroups/cgroups.go b/metrics/cgroups/cgroups.go
index ab3009893..1fb3ea373 100644
--- a/metrics/cgroups/cgroups.go
+++ b/metrics/cgroups/cgroups.go
@@ -51,7 +51,7 @@ func (m *cgroupsMonitor) Monitor(c plugin.Task) error {
 	if err != nil {
 		return err
 	}
-	cg, err := cgroups.Load(cgroups.V1, cgroups.PidPath(int(state.Pid())))
+	cg, err := cgroups.Load(cgroups.V1, cgroups.PidPath(int(state.Pid)))
 	if err != nil {
 		return err
 	}
diff --git a/plugin/container.go b/plugin/container.go
index 2d2145a5a..5c013623c 100644
--- a/plugin/container.go
+++ b/plugin/container.go
@@ -71,9 +71,13 @@ const (
 	PausedStatus
 )
 
-type State interface {
+type State struct {
 	// Status is the current status of the container
-	Status() Status
+	Status Status
 	// Pid is the main process id for the container
-	Pid() uint32
+	Pid      uint32
+	Stdin    string
+	Stdout   string
+	Stderr   string
+	Terminal bool
 }
diff --git a/services/execution/service.go b/services/execution/service.go
index e944dd412..dacad40de 100644
--- a/services/execution/service.go
+++ b/services/execution/service.go
@@ -164,7 +164,7 @@ func (s *Service) Create(ctx context.Context, r *api.CreateRequest) (*api.Create
 	}
 	return &api.CreateResponse{
 		ContainerID: r.ContainerID,
-		Pid:         state.Pid(),
+		Pid:         state.Pid,
 	}, nil
 }
 
@@ -208,7 +208,7 @@ func taskFromContainerd(ctx context.Context, c plugin.Task) (*task.Task, error)
 	}
 
 	var status task.Status
-	switch state.Status() {
+	switch state.Status {
 	case plugin.CreatedStatus:
 		status = task.StatusCreated
 	case plugin.RunningStatus:
@@ -218,17 +218,21 @@ func taskFromContainerd(ctx context.Context, c plugin.Task) (*task.Task, error)
 	case plugin.PausedStatus:
 		status = task.StatusPaused
 	default:
-		log.G(ctx).WithField("status", state.Status()).Warn("unknown status")
+		log.G(ctx).WithField("status", state.Status).Warn("unknown status")
 	}
 	return &task.Task{
 		ID:          c.Info().ID,
 		ContainerID: c.Info().ContainerID,
-		Pid:         state.Pid(),
+		Pid:         state.Pid,
 		Status:      status,
 		Spec: &protobuf.Any{
 			TypeUrl: specs.Version,
 			Value:   c.Info().Spec,
 		},
+		Stdin:    state.Stdin,
+		Stdout:   state.Stdout,
+		Stderr:   state.Stderr,
+		Terminal: state.Terminal,
 	}, nil
 }
 
@@ -359,7 +363,7 @@ func (s *Service) Exec(ctx context.Context, r *api.ExecRequest) (*api.ExecRespon
 		return nil, err
 	}
 	return &api.ExecResponse{
-		Pid: state.Pid(),
+		Pid: state.Pid,
 	}, nil
 }
 
diff --git a/windows/container.go b/windows/container.go
index 0afed30e0..06232e73c 100644
--- a/windows/container.go
+++ b/windows/container.go
@@ -116,7 +116,10 @@ func (c *container) Resume(ctx context.Context) error {
 }
 
 func (c *container) State(ctx context.Context) (plugin.State, error) {
-	return c, nil
+	return plugin.State{
+		Pid:    c.Pid(),
+		Status: c.Status(),
+	}, nil
 }
 
 func (c *container) Kill(ctx context.Context, signal uint32, pid uint32, all bool) error {
diff --git a/windows/process.go b/windows/process.go
index 438eea56d..adf9b7a8d 100644
--- a/windows/process.go
+++ b/windows/process.go
@@ -15,7 +15,10 @@ type process struct {
 }
 
 func (p *process) State(ctx context.Context) (plugin.State, error) {
-	return p, nil
+	return plugin.State{
+		Pid:    p.Pid(),
+		Status: p.Status(),
+	}, nil
 }
 
 func (p *process) Kill(ctx context.Context, sig uint32, all bool) error {