// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v3.21.12
// source: agent.proto

package pb

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type StartProcessRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Cmd           string                 `protobuf:"bytes,1,opt,name=cmd,proto3" json:"cmd,omitempty"`
	Args          []string               `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
	Env           map[string]string      `protobuf:"bytes,3,rep,name=env,proto3" json:"env,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Cwd           string                 `protobuf:"bytes,4,opt,name=cwd,proto3" json:"cwd,omitempty"`
	Content       string                 `protobuf:"bytes,5,opt,name=content,proto3" json:"content,omitempty"`
	Background    bool                   `protobuf:"varint,6,opt,name=background,proto3" json:"background,omitempty"`
	Tag           string                 `protobuf:"bytes,7,opt,name=tag,proto3" json:"tag,omitempty"`
	Pty           *PTY                   `protobuf:"bytes,8,opt,name=pty,proto3" json:"pty,omitempty"`
	Stdin         []byte                 `protobuf:"bytes,9,opt,name=stdin,proto3" json:"stdin,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StartProcessRequest) Reset() {
	*x = StartProcessRequest{}
	mi := &file_agent_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StartProcessRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StartProcessRequest) ProtoMessage() {}

func (x *StartProcessRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StartProcessRequest.ProtoReflect.Descriptor instead.
func (*StartProcessRequest) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{0}
}

func (x *StartProcessRequest) GetCmd() string {
	if x != nil {
		return x.Cmd
	}
	return ""
}

func (x *StartProcessRequest) GetArgs() []string {
	if x != nil {
		return x.Args
	}
	return nil
}

func (x *StartProcessRequest) GetEnv() map[string]string {
	if x != nil {
		return x.Env
	}
	return nil
}

func (x *StartProcessRequest) GetCwd() string {
	if x != nil {
		return x.Cwd
	}
	return ""
}

func (x *StartProcessRequest) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

func (x *StartProcessRequest) GetBackground() bool {
	if x != nil {
		return x.Background
	}
	return false
}

func (x *StartProcessRequest) GetTag() string {
	if x != nil {
		return x.Tag
	}
	return ""
}

func (x *StartProcessRequest) GetPty() *PTY {
	if x != nil {
		return x.Pty
	}
	return nil
}

func (x *StartProcessRequest) GetStdin() []byte {
	if x != nil {
		return x.Stdin
	}
	return nil
}

type ProcessConfig struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Cmd           string                 `protobuf:"bytes,1,opt,name=cmd,proto3" json:"cmd,omitempty"`
	Args          []string               `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
	Env           map[string]string      `protobuf:"bytes,3,rep,name=env,proto3" json:"env,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Cwd           string                 `protobuf:"bytes,4,opt,name=cwd,proto3" json:"cwd,omitempty"`
	Pty           *PTY                   `protobuf:"bytes,5,opt,name=pty,proto3" json:"pty,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessConfig) Reset() {
	*x = ProcessConfig{}
	mi := &file_agent_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessConfig) ProtoMessage() {}

func (x *ProcessConfig) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessConfig.ProtoReflect.Descriptor instead.
func (*ProcessConfig) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{1}
}

func (x *ProcessConfig) GetCmd() string {
	if x != nil {
		return x.Cmd
	}
	return ""
}

func (x *ProcessConfig) GetArgs() []string {
	if x != nil {
		return x.Args
	}
	return nil
}

func (x *ProcessConfig) GetEnv() map[string]string {
	if x != nil {
		return x.Env
	}
	return nil
}

func (x *ProcessConfig) GetCwd() string {
	if x != nil {
		return x.Cwd
	}
	return ""
}

func (x *ProcessConfig) GetPty() *PTY {
	if x != nil {
		return x.Pty
	}
	return nil
}

type PTY struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Cols          uint32                 `protobuf:"varint,1,opt,name=cols,proto3" json:"cols,omitempty"`
	Rows          uint32                 `protobuf:"varint,2,opt,name=rows,proto3" json:"rows,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PTY) Reset() {
	*x = PTY{}
	mi := &file_agent_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PTY) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PTY) ProtoMessage() {}

func (x *PTY) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PTY.ProtoReflect.Descriptor instead.
func (*PTY) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{2}
}

func (x *PTY) GetCols() uint32 {
	if x != nil {
		return x.Cols
	}
	return 0
}

func (x *PTY) GetRows() uint32 {
	if x != nil {
		return x.Rows
	}
	return 0
}

type ProcessInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pid           int32                  `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
	Tag           string                 `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"`
	Config        *ProcessConfig         `protobuf:"bytes,3,opt,name=config,proto3" json:"config,omitempty"`
	Running       bool                   `protobuf:"varint,4,opt,name=running,proto3" json:"running,omitempty"`
	StartedAt     string                 `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
	ExitCode      int32                  `protobuf:"varint,6,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	FinishedAt    string                 `protobuf:"bytes,7,opt,name=finished_at,json=finishedAt,proto3" json:"finished_at,omitempty"`
	Stdout        string                 `protobuf:"bytes,8,opt,name=stdout,proto3" json:"stdout,omitempty"`
	Stderr        string                 `protobuf:"bytes,9,opt,name=stderr,proto3" json:"stderr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessInfo) Reset() {
	*x = ProcessInfo{}
	mi := &file_agent_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessInfo) ProtoMessage() {}

func (x *ProcessInfo) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessInfo.ProtoReflect.Descriptor instead.
func (*ProcessInfo) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{3}
}

func (x *ProcessInfo) GetPid() int32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *ProcessInfo) GetTag() string {
	if x != nil {
		return x.Tag
	}
	return ""
}

func (x *ProcessInfo) GetConfig() *ProcessConfig {
	if x != nil {
		return x.Config
	}
	return nil
}

func (x *ProcessInfo) GetRunning() bool {
	if x != nil {
		return x.Running
	}
	return false
}

func (x *ProcessInfo) GetStartedAt() string {
	if x != nil {
		return x.StartedAt
	}
	return ""
}

func (x *ProcessInfo) GetExitCode() int32 {
	if x != nil {
		return x.ExitCode
	}
	return 0
}

func (x *ProcessInfo) GetFinishedAt() string {
	if x != nil {
		return x.FinishedAt
	}
	return ""
}

func (x *ProcessInfo) GetStdout() string {
	if x != nil {
		return x.Stdout
	}
	return ""
}

func (x *ProcessInfo) GetStderr() string {
	if x != nil {
		return x.Stderr
	}
	return ""
}

type ProcessSelector struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pid           int32                  `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
	Tag           string                 `protobuf:"bytes,2,opt,name=tag,proto3" json:"tag,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessSelector) Reset() {
	*x = ProcessSelector{}
	mi := &file_agent_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessSelector) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessSelector) ProtoMessage() {}

func (x *ProcessSelector) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessSelector.ProtoReflect.Descriptor instead.
func (*ProcessSelector) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{4}
}

func (x *ProcessSelector) GetPid() int32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *ProcessSelector) GetTag() string {
	if x != nil {
		return x.Tag
	}
	return ""
}

type ProcessEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Event:
	//
	//	*ProcessEvent_Start
	//	*ProcessEvent_Data
	//	*ProcessEvent_End
	//	*ProcessEvent_Keepalive
	Event         isProcessEvent_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessEvent) Reset() {
	*x = ProcessEvent{}
	mi := &file_agent_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessEvent) ProtoMessage() {}

func (x *ProcessEvent) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessEvent.ProtoReflect.Descriptor instead.
func (*ProcessEvent) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{5}
}

func (x *ProcessEvent) GetEvent() isProcessEvent_Event {
	if x != nil {
		return x.Event
	}
	return nil
}

func (x *ProcessEvent) GetStart() *ProcessStartEvent {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_Start); ok {
			return x.Start
		}
	}
	return nil
}

func (x *ProcessEvent) GetData() *ProcessDataEvent {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *ProcessEvent) GetEnd() *ProcessEndEvent {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_End); ok {
			return x.End
		}
	}
	return nil
}

func (x *ProcessEvent) GetKeepalive() *ProcessKeepAlive {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_Keepalive); ok {
			return x.Keepalive
		}
	}
	return nil
}

type isProcessEvent_Event interface {
	isProcessEvent_Event()
}

type ProcessEvent_Start struct {
	Start *ProcessStartEvent `protobuf:"bytes,1,opt,name=start,proto3,oneof"`
}

type ProcessEvent_Data struct {
	Data *ProcessDataEvent `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
}

type ProcessEvent_End struct {
	End *ProcessEndEvent `protobuf:"bytes,3,opt,name=end,proto3,oneof"`
}

type ProcessEvent_Keepalive struct {
	Keepalive *ProcessKeepAlive `protobuf:"bytes,4,opt,name=keepalive,proto3,oneof"`
}

func (*ProcessEvent_Start) isProcessEvent_Event() {}

func (*ProcessEvent_Data) isProcessEvent_Event() {}

func (*ProcessEvent_End) isProcessEvent_Event() {}

func (*ProcessEvent_Keepalive) isProcessEvent_Event() {}

type ProcessStartEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pid           int32                  `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessStartEvent) Reset() {
	*x = ProcessStartEvent{}
	mi := &file_agent_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessStartEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessStartEvent) ProtoMessage() {}

func (x *ProcessStartEvent) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessStartEvent.ProtoReflect.Descriptor instead.
func (*ProcessStartEvent) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{6}
}

func (x *ProcessStartEvent) GetPid() int32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

type ProcessDataEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Output:
	//
	//	*ProcessDataEvent_Stdout
	//	*ProcessDataEvent_Stderr
	//	*ProcessDataEvent_Pty
	Output        isProcessDataEvent_Output `protobuf_oneof:"output"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessDataEvent) Reset() {
	*x = ProcessDataEvent{}
	mi := &file_agent_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessDataEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessDataEvent) ProtoMessage() {}

func (x *ProcessDataEvent) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessDataEvent.ProtoReflect.Descriptor instead.
func (*ProcessDataEvent) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{7}
}

func (x *ProcessDataEvent) GetOutput() isProcessDataEvent_Output {
	if x != nil {
		return x.Output
	}
	return nil
}

func (x *ProcessDataEvent) GetStdout() []byte {
	if x != nil {
		if x, ok := x.Output.(*ProcessDataEvent_Stdout); ok {
			return x.Stdout
		}
	}
	return nil
}

func (x *ProcessDataEvent) GetStderr() []byte {
	if x != nil {
		if x, ok := x.Output.(*ProcessDataEvent_Stderr); ok {
			return x.Stderr
		}
	}
	return nil
}

func (x *ProcessDataEvent) GetPty() []byte {
	if x != nil {
		if x, ok := x.Output.(*ProcessDataEvent_Pty); ok {
			return x.Pty
		}
	}
	return nil
}

type isProcessDataEvent_Output interface {
	isProcessDataEvent_Output()
}

type ProcessDataEvent_Stdout struct {
	Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"`
}

type ProcessDataEvent_Stderr struct {
	Stderr []byte `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"`
}

type ProcessDataEvent_Pty struct {
	Pty []byte `protobuf:"bytes,3,opt,name=pty,proto3,oneof"`
}

func (*ProcessDataEvent_Stdout) isProcessDataEvent_Output() {}

func (*ProcessDataEvent_Stderr) isProcessDataEvent_Output() {}

func (*ProcessDataEvent_Pty) isProcessDataEvent_Output() {}

type ProcessEndEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExitCode      int32                  `protobuf:"varint,1,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	Exited        bool                   `protobuf:"varint,2,opt,name=exited,proto3" json:"exited,omitempty"`
	Status        string                 `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	Error         string                 `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessEndEvent) Reset() {
	*x = ProcessEndEvent{}
	mi := &file_agent_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessEndEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessEndEvent) ProtoMessage() {}

func (x *ProcessEndEvent) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessEndEvent.ProtoReflect.Descriptor instead.
func (*ProcessEndEvent) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{8}
}

func (x *ProcessEndEvent) GetExitCode() int32 {
	if x != nil {
		return x.ExitCode
	}
	return 0
}

func (x *ProcessEndEvent) GetExited() bool {
	if x != nil {
		return x.Exited
	}
	return false
}

func (x *ProcessEndEvent) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

func (x *ProcessEndEvent) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

type ProcessKeepAlive struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessKeepAlive) Reset() {
	*x = ProcessKeepAlive{}
	mi := &file_agent_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ProcessKeepAlive) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ProcessKeepAlive) ProtoMessage() {}

func (x *ProcessKeepAlive) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ProcessKeepAlive.ProtoReflect.Descriptor instead.
func (*ProcessKeepAlive) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{9}
}

type ConnectProcessRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConnectProcessRequest) Reset() {
	*x = ConnectProcessRequest{}
	mi := &file_agent_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ConnectProcessRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ConnectProcessRequest) ProtoMessage() {}

func (x *ConnectProcessRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ConnectProcessRequest.ProtoReflect.Descriptor instead.
func (*ConnectProcessRequest) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{10}
}

func (x *ConnectProcessRequest) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

type ListProcessesRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListProcessesRequest) Reset() {
	*x = ListProcessesRequest{}
	mi := &file_agent_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ListProcessesRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ListProcessesRequest) ProtoMessage() {}

func (x *ListProcessesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListProcessesRequest.ProtoReflect.Descriptor instead.
func (*ListProcessesRequest) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{11}
}

type ListProcessesResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Processes     []*ProcessInfo         `protobuf:"bytes,1,rep,name=processes,proto3" json:"processes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListProcessesResponse) Reset() {
	*x = ListProcessesResponse{}
	mi := &file_agent_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ListProcessesResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ListProcessesResponse) ProtoMessage() {}

func (x *ListProcessesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListProcessesResponse.ProtoReflect.Descriptor instead.
func (*ListProcessesResponse) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{12}
}

func (x *ListProcessesResponse) GetProcesses() []*ProcessInfo {
	if x != nil {
		return x.Processes
	}
	return nil
}

type SendSignalRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	Signal        int32                  `protobuf:"varint,2,opt,name=signal,proto3" json:"signal,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SendSignalRequest) Reset() {
	*x = SendSignalRequest{}
	mi := &file_agent_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SendSignalRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SendSignalRequest) ProtoMessage() {}

func (x *SendSignalRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SendSignalRequest.ProtoReflect.Descriptor instead.
func (*SendSignalRequest) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{13}
}

func (x *SendSignalRequest) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

func (x *SendSignalRequest) GetSignal() int32 {
	if x != nil {
		return x.Signal
	}
	return 0
}

type SendSignalResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SendSignalResponse) Reset() {
	*x = SendSignalResponse{}
	mi := &file_agent_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SendSignalResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SendSignalResponse) ProtoMessage() {}

func (x *SendSignalResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SendSignalResponse.ProtoReflect.Descriptor instead.
func (*SendSignalResponse) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{14}
}

type FileChunk struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Filepath      string                 `protobuf:"bytes,1,opt,name=filepath,proto3" json:"filepath,omitempty"`
	Content       []byte                 `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FileChunk) Reset() {
	*x = FileChunk{}
	mi := &file_agent_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FileChunk) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FileChunk) ProtoMessage() {}

func (x *FileChunk) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FileChunk.ProtoReflect.Descriptor instead.
func (*FileChunk) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{15}
}

func (x *FileChunk) GetFilepath() string {
	if x != nil {
		return x.Filepath
	}
	return ""
}

func (x *FileChunk) GetContent() []byte {
	if x != nil {
		return x.Content
	}
	return nil
}

type PostFilesResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	UploadedCount int32                  `protobuf:"varint,1,opt,name=uploaded_count,json=uploadedCount,proto3" json:"uploaded_count,omitempty"`
	// Deprecated: Marked as deprecated in agent.proto.
	Error         string       `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	Entries       []*WriteInfo `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PostFilesResponse) Reset() {
	*x = PostFilesResponse{}
	mi := &file_agent_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *PostFilesResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*PostFilesResponse) ProtoMessage() {}

func (x *PostFilesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use PostFilesResponse.ProtoReflect.Descriptor instead.
func (*PostFilesResponse) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{16}
}

func (x *PostFilesResponse) GetUploadedCount() int32 {
	if x != nil {
		return x.UploadedCount
	}
	return 0
}

// Deprecated: Marked as deprecated in agent.proto.
func (x *PostFilesResponse) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

func (x *PostFilesResponse) GetEntries() []*WriteInfo {
	if x != nil {
		return x.Entries
	}
	return nil
}

type WriteInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Path          string                 `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Type          string                 `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WriteInfo) Reset() {
	*x = WriteInfo{}
	mi := &file_agent_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WriteInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WriteInfo) ProtoMessage() {}

func (x *WriteInfo) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WriteInfo.ProtoReflect.Descriptor instead.
func (*WriteInfo) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{17}
}

func (x *WriteInfo) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *WriteInfo) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *WriteInfo) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

type GetFileRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Filepath      string                 `protobuf:"bytes,1,opt,name=filepath,proto3" json:"filepath,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetFileRequest) Reset() {
	*x = GetFileRequest{}
	mi := &file_agent_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *GetFileRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*GetFileRequest) ProtoMessage() {}

func (x *GetFileRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use GetFileRequest.ProtoReflect.Descriptor instead.
func (*GetFileRequest) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{18}
}

func (x *GetFileRequest) GetFilepath() string {
	if x != nil {
		return x.Filepath
	}
	return ""
}

type FileEntry struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Path          string                 `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	Type          string                 `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
	Size          int64                  `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"`
	Permissions   string                 `protobuf:"bytes,5,opt,name=permissions,proto3" json:"permissions,omitempty"`
	ModifiedTime  string                 `protobuf:"bytes,6,opt,name=modified_time,json=modifiedTime,proto3" json:"modified_time,omitempty"`
	Metadata      map[string]string      `protobuf:"bytes,7,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	IsDirectory   bool                   `protobuf:"varint,8,opt,name=is_directory,json=isDirectory,proto3" json:"is_directory,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *FileEntry) Reset() {
	*x = FileEntry{}
	mi := &file_agent_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *FileEntry) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*FileEntry) ProtoMessage() {}

func (x *FileEntry) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use FileEntry.ProtoReflect.Descriptor instead.
func (*FileEntry) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{19}
}

func (x *FileEntry) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *FileEntry) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *FileEntry) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *FileEntry) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *FileEntry) GetPermissions() string {
	if x != nil {
		return x.Permissions
	}
	return ""
}

func (x *FileEntry) GetModifiedTime() string {
	if x != nil {
		return x.ModifiedTime
	}
	return ""
}

func (x *FileEntry) GetMetadata() map[string]string {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *FileEntry) GetIsDirectory() bool {
	if x != nil {
		return x.IsDirectory
	}
	return false
}

type ListFilesRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Path          string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Depth         int32                  `protobuf:"varint,2,opt,name=depth,proto3" json:"depth,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListFilesRequest) Reset() {
	*x = ListFilesRequest{}
	mi := &file_agent_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ListFilesRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ListFilesRequest) ProtoMessage() {}

func (x *ListFilesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListFilesRequest.ProtoReflect.Descriptor instead.
func (*ListFilesRequest) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{20}
}

func (x *ListFilesRequest) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *ListFilesRequest) GetDepth() int32 {
	if x != nil {
		return x.Depth
	}
	return 0
}

type ListFilesResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entries       []*FileEntry           `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ListFilesResponse) Reset() {
	*x = ListFilesResponse{}
	mi := &file_agent_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ListFilesResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ListFilesResponse) ProtoMessage() {}

func (x *ListFilesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ListFilesResponse.ProtoReflect.Descriptor instead.
func (*ListFilesResponse) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{21}
}

func (x *ListFilesResponse) GetEntries() []*FileEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

type SearchFilesRequest struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Path            string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Pattern         string                 `protobuf:"bytes,2,opt,name=pattern,proto3" json:"pattern,omitempty"`
	ExcludePatterns []string               `protobuf:"bytes,3,rep,name=exclude_patterns,json=excludePatterns,proto3" json:"exclude_patterns,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *SearchFilesRequest) Reset() {
	*x = SearchFilesRequest{}
	mi := &file_agent_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SearchFilesRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SearchFilesRequest) ProtoMessage() {}

func (x *SearchFilesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SearchFilesRequest.ProtoReflect.Descriptor instead.
func (*SearchFilesRequest) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{22}
}

func (x *SearchFilesRequest) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *SearchFilesRequest) GetPattern() string {
	if x != nil {
		return x.Pattern
	}
	return ""
}

func (x *SearchFilesRequest) GetExcludePatterns() []string {
	if x != nil {
		return x.ExcludePatterns
	}
	return nil
}

type SearchFilesResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Entries       []*FileEntry           `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SearchFilesResponse) Reset() {
	*x = SearchFilesResponse{}
	mi := &file_agent_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *SearchFilesResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*SearchFilesResponse) ProtoMessage() {}

func (x *SearchFilesResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_proto_msgTypes[23]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use SearchFilesResponse.ProtoReflect.Descriptor instead.
func (*SearchFilesResponse) Descriptor() ([]byte, []int) {
	return file_agent_proto_rawDescGZIP(), []int{23}
}

func (x *SearchFilesResponse) GetEntries() []*FileEntry {
	if x != nil {
		return x.Entries
	}
	return nil
}

var File_agent_proto protoreflect.FileDescriptor

const file_agent_proto_rawDesc = "" +
	"\n" +
	"\vagent.proto\x12\x02pb\"\xb6\x02\n" +
	"\x13StartProcessRequest\x12\x10\n" +
	"\x03cmd\x18\x01 \x01(\tR\x03cmd\x12\x12\n" +
	"\x04args\x18\x02 \x03(\tR\x04args\x122\n" +
	"\x03env\x18\x03 \x03(\v2 .pb.StartProcessRequest.EnvEntryR\x03env\x12\x10\n" +
	"\x03cwd\x18\x04 \x01(\tR\x03cwd\x12\x18\n" +
	"\acontent\x18\x05 \x01(\tR\acontent\x12\x1e\n" +
	"\n" +
	"background\x18\x06 \x01(\bR\n" +
	"background\x12\x10\n" +
	"\x03tag\x18\a \x01(\tR\x03tag\x12\x19\n" +
	"\x03pty\x18\b \x01(\v2\a.pb.PTYR\x03pty\x12\x14\n" +
	"\x05stdin\x18\t \x01(\fR\x05stdin\x1a6\n" +
	"\bEnvEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xc8\x01\n" +
	"\rProcessConfig\x12\x10\n" +
	"\x03cmd\x18\x01 \x01(\tR\x03cmd\x12\x12\n" +
	"\x04args\x18\x02 \x03(\tR\x04args\x12,\n" +
	"\x03env\x18\x03 \x03(\v2\x1a.pb.ProcessConfig.EnvEntryR\x03env\x12\x10\n" +
	"\x03cwd\x18\x04 \x01(\tR\x03cwd\x12\x19\n" +
	"\x03pty\x18\x05 \x01(\v2\a.pb.PTYR\x03pty\x1a6\n" +
	"\bEnvEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"-\n" +
	"\x03PTY\x12\x12\n" +
	"\x04cols\x18\x01 \x01(\rR\x04cols\x12\x12\n" +
	"\x04rows\x18\x02 \x01(\rR\x04rows\"\x83\x02\n" +
	"\vProcessInfo\x12\x10\n" +
	"\x03pid\x18\x01 \x01(\x05R\x03pid\x12\x10\n" +
	"\x03tag\x18\x02 \x01(\tR\x03tag\x12)\n" +
	"\x06config\x18\x03 \x01(\v2\x11.pb.ProcessConfigR\x06config\x12\x18\n" +
	"\arunning\x18\x04 \x01(\bR\arunning\x12\x1d\n" +
	"\n" +
	"started_at\x18\x05 \x01(\tR\tstartedAt\x12\x1b\n" +
	"\texit_code\x18\x06 \x01(\x05R\bexitCode\x12\x1f\n" +
	"\vfinished_at\x18\a \x01(\tR\n" +
	"finishedAt\x12\x16\n" +
	"\x06stdout\x18\b \x01(\tR\x06stdout\x12\x16\n" +
	"\x06stderr\x18\t \x01(\tR\x06stderr\"5\n" +
	"\x0fProcessSelector\x12\x10\n" +
	"\x03pid\x18\x01 \x01(\x05R\x03pid\x12\x10\n" +
	"\x03tag\x18\x02 \x01(\tR\x03tag\"\xd1\x01\n" +
	"\fProcessEvent\x12-\n" +
	"\x05start\x18\x01 \x01(\v2\x15.pb.ProcessStartEventH\x00R\x05start\x12*\n" +
	"\x04data\x18\x02 \x01(\v2\x14.pb.ProcessDataEventH\x00R\x04data\x12'\n" +
	"\x03end\x18\x03 \x01(\v2\x13.pb.ProcessEndEventH\x00R\x03end\x124\n" +
	"\tkeepalive\x18\x04 \x01(\v2\x14.pb.ProcessKeepAliveH\x00R\tkeepaliveB\a\n" +
	"\x05event\"%\n" +
	"\x11ProcessStartEvent\x12\x10\n" +
	"\x03pid\x18\x01 \x01(\x05R\x03pid\"d\n" +
	"\x10ProcessDataEvent\x12\x18\n" +
	"\x06stdout\x18\x01 \x01(\fH\x00R\x06stdout\x12\x18\n" +
	"\x06stderr\x18\x02 \x01(\fH\x00R\x06stderr\x12\x12\n" +
	"\x03pty\x18\x03 \x01(\fH\x00R\x03ptyB\b\n" +
	"\x06output\"t\n" +
	"\x0fProcessEndEvent\x12\x1b\n" +
	"\texit_code\x18\x01 \x01(\x05R\bexitCode\x12\x16\n" +
	"\x06exited\x18\x02 \x01(\bR\x06exited\x12\x16\n" +
	"\x06status\x18\x03 \x01(\tR\x06status\x12\x14\n" +
	"\x05error\x18\x04 \x01(\tR\x05error\"\x12\n" +
	"\x10ProcessKeepAlive\"F\n" +
	"\x15ConnectProcessRequest\x12-\n" +
	"\aprocess\x18\x01 \x01(\v2\x13.pb.ProcessSelectorR\aprocess\"\x16\n" +
	"\x14ListProcessesRequest\"F\n" +
	"\x15ListProcessesResponse\x12-\n" +
	"\tprocesses\x18\x01 \x03(\v2\x0f.pb.ProcessInfoR\tprocesses\"Z\n" +
	"\x11SendSignalRequest\x12-\n" +
	"\aprocess\x18\x01 \x01(\v2\x13.pb.ProcessSelectorR\aprocess\x12\x16\n" +
	"\x06signal\x18\x02 \x01(\x05R\x06signal\"\x14\n" +
	"\x12SendSignalResponse\"A\n" +
	"\tFileChunk\x12\x1a\n" +
	"\bfilepath\x18\x01 \x01(\tR\bfilepath\x12\x18\n" +
	"\acontent\x18\x02 \x01(\fR\acontent\"}\n" +
	"\x11PostFilesResponse\x12%\n" +
	"\x0euploaded_count\x18\x01 \x01(\x05R\ruploadedCount\x12\x18\n" +
	"\x05error\x18\x02 \x01(\tB\x02\x18\x01R\x05error\x12'\n" +
	"\aentries\x18\x03 \x03(\v2\r.pb.WriteInfoR\aentries\"G\n" +
	"\tWriteInfo\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" +
	"\x04path\x18\x02 \x01(\tR\x04path\x12\x12\n" +
	"\x04type\x18\x03 \x01(\tR\x04type\",\n" +
	"\x0eGetFileRequest\x12\x1a\n" +
	"\bfilepath\x18\x01 \x01(\tR\bfilepath\"\xbb\x02\n" +
	"\tFileEntry\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n" +
	"\x04path\x18\x02 \x01(\tR\x04path\x12\x12\n" +
	"\x04type\x18\x03 \x01(\tR\x04type\x12\x12\n" +
	"\x04size\x18\x04 \x01(\x03R\x04size\x12 \n" +
	"\vpermissions\x18\x05 \x01(\tR\vpermissions\x12#\n" +
	"\rmodified_time\x18\x06 \x01(\tR\fmodifiedTime\x127\n" +
	"\bmetadata\x18\a \x03(\v2\x1b.pb.FileEntry.MetadataEntryR\bmetadata\x12!\n" +
	"\fis_directory\x18\b \x01(\bR\visDirectory\x1a;\n" +
	"\rMetadataEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"<\n" +
	"\x10ListFilesRequest\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12\x14\n" +
	"\x05depth\x18\x02 \x01(\x05R\x05depth\"<\n" +
	"\x11ListFilesResponse\x12'\n" +
	"\aentries\x18\x01 \x03(\v2\r.pb.FileEntryR\aentries\"m\n" +
	"\x12SearchFilesRequest\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12\x18\n" +
	"\apattern\x18\x02 \x01(\tR\apattern\x12)\n" +
	"\x10exclude_patterns\x18\x03 \x03(\tR\x0fexcludePatterns\">\n" +
	"\x13SearchFilesResponse\x12'\n" +
	"\aentries\x18\x01 \x03(\v2\r.pb.FileEntryR\aentries2\x81\x02\n" +
	"\x0eProcessService\x12;\n" +
	"\fStartProcess\x12\x17.pb.StartProcessRequest\x1a\x10.pb.ProcessEvent0\x01\x128\n" +
	"\aConnect\x12\x19.pb.ConnectProcessRequest\x1a\x10.pb.ProcessEvent0\x01\x12;\n" +
	"\x04List\x12\x18.pb.ListProcessesRequest\x1a\x19.pb.ListProcessesResponse\x12;\n" +
	"\n" +
	"SendSignal\x12\x15.pb.SendSignalRequest\x1a\x16.pb.SendSignalResponse2\xf7\x01\n" +
	"\vFileService\x128\n" +
	"\x0ePostFileStream\x12\r.pb.FileChunk\x1a\x15.pb.PostFilesResponse(\x01\x124\n" +
	"\rGetFileStream\x12\x12.pb.GetFileRequest\x1a\r.pb.FileChunk0\x01\x128\n" +
	"\tListFiles\x12\x14.pb.ListFilesRequest\x1a\x15.pb.ListFilesResponse\x12>\n" +
	"\vSearchFiles\x12\x16.pb.SearchFilesRequest\x1a\x17.pb.SearchFilesResponseB,Z*github.com/openeuler/Conch/api/go_proto;pbb\x06proto3"

var (
	file_agent_proto_rawDescOnce sync.Once
	file_agent_proto_rawDescData []byte
)

func file_agent_proto_rawDescGZIP() []byte {
	file_agent_proto_rawDescOnce.Do(func() {
		file_agent_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_agent_proto_rawDesc), len(file_agent_proto_rawDesc)))
	})
	return file_agent_proto_rawDescData
}

var file_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 27)
var file_agent_proto_goTypes = []any{
	(*StartProcessRequest)(nil),   // 0: pb.StartProcessRequest
	(*ProcessConfig)(nil),         // 1: pb.ProcessConfig
	(*PTY)(nil),                   // 2: pb.PTY
	(*ProcessInfo)(nil),           // 3: pb.ProcessInfo
	(*ProcessSelector)(nil),       // 4: pb.ProcessSelector
	(*ProcessEvent)(nil),          // 5: pb.ProcessEvent
	(*ProcessStartEvent)(nil),     // 6: pb.ProcessStartEvent
	(*ProcessDataEvent)(nil),      // 7: pb.ProcessDataEvent
	(*ProcessEndEvent)(nil),       // 8: pb.ProcessEndEvent
	(*ProcessKeepAlive)(nil),      // 9: pb.ProcessKeepAlive
	(*ConnectProcessRequest)(nil), // 10: pb.ConnectProcessRequest
	(*ListProcessesRequest)(nil),  // 11: pb.ListProcessesRequest
	(*ListProcessesResponse)(nil), // 12: pb.ListProcessesResponse
	(*SendSignalRequest)(nil),     // 13: pb.SendSignalRequest
	(*SendSignalResponse)(nil),    // 14: pb.SendSignalResponse
	(*FileChunk)(nil),             // 15: pb.FileChunk
	(*PostFilesResponse)(nil),     // 16: pb.PostFilesResponse
	(*WriteInfo)(nil),             // 17: pb.WriteInfo
	(*GetFileRequest)(nil),        // 18: pb.GetFileRequest
	(*FileEntry)(nil),             // 19: pb.FileEntry
	(*ListFilesRequest)(nil),      // 20: pb.ListFilesRequest
	(*ListFilesResponse)(nil),     // 21: pb.ListFilesResponse
	(*SearchFilesRequest)(nil),    // 22: pb.SearchFilesRequest
	(*SearchFilesResponse)(nil),   // 23: pb.SearchFilesResponse
	nil,                           // 24: pb.StartProcessRequest.EnvEntry
	nil,                           // 25: pb.ProcessConfig.EnvEntry
	nil,                           // 26: pb.FileEntry.MetadataEntry
}
var file_agent_proto_depIdxs = []int32{
	24, // 0: pb.StartProcessRequest.env:type_name -> pb.StartProcessRequest.EnvEntry
	2,  // 1: pb.StartProcessRequest.pty:type_name -> pb.PTY
	25, // 2: pb.ProcessConfig.env:type_name -> pb.ProcessConfig.EnvEntry
	2,  // 3: pb.ProcessConfig.pty:type_name -> pb.PTY
	1,  // 4: pb.ProcessInfo.config:type_name -> pb.ProcessConfig
	6,  // 5: pb.ProcessEvent.start:type_name -> pb.ProcessStartEvent
	7,  // 6: pb.ProcessEvent.data:type_name -> pb.ProcessDataEvent
	8,  // 7: pb.ProcessEvent.end:type_name -> pb.ProcessEndEvent
	9,  // 8: pb.ProcessEvent.keepalive:type_name -> pb.ProcessKeepAlive
	4,  // 9: pb.ConnectProcessRequest.process:type_name -> pb.ProcessSelector
	3,  // 10: pb.ListProcessesResponse.processes:type_name -> pb.ProcessInfo
	4,  // 11: pb.SendSignalRequest.process:type_name -> pb.ProcessSelector
	17, // 12: pb.PostFilesResponse.entries:type_name -> pb.WriteInfo
	26, // 13: pb.FileEntry.metadata:type_name -> pb.FileEntry.MetadataEntry
	19, // 14: pb.ListFilesResponse.entries:type_name -> pb.FileEntry
	19, // 15: pb.SearchFilesResponse.entries:type_name -> pb.FileEntry
	0,  // 16: pb.ProcessService.StartProcess:input_type -> pb.StartProcessRequest
	10, // 17: pb.ProcessService.Connect:input_type -> pb.ConnectProcessRequest
	11, // 18: pb.ProcessService.List:input_type -> pb.ListProcessesRequest
	13, // 19: pb.ProcessService.SendSignal:input_type -> pb.SendSignalRequest
	15, // 20: pb.FileService.PostFileStream:input_type -> pb.FileChunk
	18, // 21: pb.FileService.GetFileStream:input_type -> pb.GetFileRequest
	20, // 22: pb.FileService.ListFiles:input_type -> pb.ListFilesRequest
	22, // 23: pb.FileService.SearchFiles:input_type -> pb.SearchFilesRequest
	5,  // 24: pb.ProcessService.StartProcess:output_type -> pb.ProcessEvent
	5,  // 25: pb.ProcessService.Connect:output_type -> pb.ProcessEvent
	12, // 26: pb.ProcessService.List:output_type -> pb.ListProcessesResponse
	14, // 27: pb.ProcessService.SendSignal:output_type -> pb.SendSignalResponse
	16, // 28: pb.FileService.PostFileStream:output_type -> pb.PostFilesResponse
	15, // 29: pb.FileService.GetFileStream:output_type -> pb.FileChunk
	21, // 30: pb.FileService.ListFiles:output_type -> pb.ListFilesResponse
	23, // 31: pb.FileService.SearchFiles:output_type -> pb.SearchFilesResponse
	24, // [24:32] is the sub-list for method output_type
	16, // [16:24] is the sub-list for method input_type
	16, // [16:16] is the sub-list for extension type_name
	16, // [16:16] is the sub-list for extension extendee
	0,  // [0:16] is the sub-list for field type_name
}

func init() { file_agent_proto_init() }
func file_agent_proto_init() {
	if File_agent_proto != nil {
		return
	}
	file_agent_proto_msgTypes[5].OneofWrappers = []any{
		(*ProcessEvent_Start)(nil),
		(*ProcessEvent_Data)(nil),
		(*ProcessEvent_End)(nil),
		(*ProcessEvent_Keepalive)(nil),
	}
	file_agent_proto_msgTypes[7].OneofWrappers = []any{
		(*ProcessDataEvent_Stdout)(nil),
		(*ProcessDataEvent_Stderr)(nil),
		(*ProcessDataEvent_Pty)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_agent_proto_rawDesc), len(file_agent_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   27,
			NumExtensions: 0,
			NumServices:   2,
		},
		GoTypes:           file_agent_proto_goTypes,
		DependencyIndexes: file_agent_proto_depIdxs,
		MessageInfos:      file_agent_proto_msgTypes,
	}.Build()
	File_agent_proto = out.File
	file_agent_proto_goTypes = nil
	file_agent_proto_depIdxs = nil
}