browser/platform/dto/control.go

package dto

import (
	"time"

	"browser.local/platform/domain"
)

type RunCapabilityReport struct {
	Capabilities []string `json:"capabilities"`
	Fingerprint  string   `json:"fingerprint"`
}

type RunControlHelloRequest struct {
	RegistrationToken string                           `json:"registrationToken"`
	RunEndpointID     string                           `json:"runEndpointId"`
	ServerInstanceID  string                           `json:"serverInstanceId,omitempty"`
	PluginID          string                           `json:"pluginId,omitempty"`
	ComponentKind     domain.DistributionComponentKind `json:"componentKind,omitempty"`
	ComponentKey      string                           `json:"componentKey,omitempty"`
	KeyGeneration     int                              `json:"keyGeneration,omitempty"`
	DisplayName       string                           `json:"displayName"`
	Version           string                           `json:"version"`
	Status            domain.RunEndpointStatus         `json:"status"`
	Platform          string                           `json:"platform,omitempty"`
	Architecture      string                           `json:"architecture,omitempty"`
	UpdateJobID       string                           `json:"updateJobId,omitempty"`
	UpdateOutcome     string                           `json:"updateOutcome,omitempty"`
	CapabilityReport  RunCapabilityReport              `json:"capabilityReport"`
	Capacity          RunCapacityResponse              `json:"capacity"`
}

type RunControlHelloResponse struct {
	Accepted                 bool      `json:"accepted"`
	RunEndpointID            string    `json:"runEndpointId"`
	SessionToken             string    `json:"sessionToken"`
	ServerTime               time.Time `json:"serverTime"`
	HeartbeatIntervalSeconds int       `json:"heartbeatIntervalSeconds"`
	SessionExpiresAt         time.Time `json:"sessionExpiresAt"`
	FeatureFlags             []string  `json:"featureFlags,omitempty"`
}

type RunControlHeartbeatRequest struct {
	RunEndpointID         string                   `json:"runEndpointId"`
	SessionToken          string                   `json:"sessionToken"`
	Version               string                   `json:"version"`
	Status                domain.RunEndpointStatus `json:"status"`
	CapabilityFingerprint string                   `json:"capabilityFingerprint"`
	Capacity              RunCapacityResponse      `json:"capacity"`
}

type RunControlHeartbeatResponse struct {
	Accepted             bool      `json:"accepted"`
	RunEndpointID        string    `json:"runEndpointId"`
	NextHeartbeatSeconds int       `json:"nextHeartbeatSeconds"`
	RefreshCapabilities  bool      `json:"refreshCapabilities"`
	ServerTime           time.Time `json:"serverTime"`
}

type RunControlStreamRequest struct {
	RunEndpointID string `json:"runEndpointId"`
	SessionToken  string `json:"sessionToken"`
	LastEventSeq  uint64 `json:"lastEventSeq,omitempty"`
}

type RunControlEventResponse struct {
	RunEndpointID string    `json:"runEndpointId"`
	Sequence      uint64    `json:"sequence"`
	Type          string    `json:"type"`
	ServerTime    time.Time `json:"serverTime"`
	RetrySeconds  int       `json:"retrySeconds,omitempty"`
}

type RunLifecycleReportRequest struct {
	RunEndpointID    string                    `json:"runEndpointId"`
	SessionToken     string                    `json:"sessionToken"`
	ServerInstanceID string                    `json:"serverInstanceId"`
	Capability       string                    `json:"capability"`
	State            domain.JobState           `json:"state"`
	Progress         JobProgressBody           `json:"progress"`
	Message          string                    `json:"message,omitempty"`
	ErrorCode        string                    `json:"errorCode,omitempty"`
	ManagedProcessID string                    `json:"managedProcessId,omitempty"`
	ObservationSeq   uint64                    `json:"observationSeq,omitempty"`
	ObservedAt       time.Time                 `json:"observedAt,omitempty"`
	ExecutionResult  RunJobExecutionResultBody `json:"executionResult,omitempty"`
}

type RunLifecycleReportResponse struct {
	Accepted         bool                       `json:"accepted"`
	RunEndpointID    string                     `json:"runEndpointId"`
	ServerInstanceID string                     `json:"serverInstanceId"`
	ProjectedState   domain.ServerInstanceState `json:"projectedState,omitempty"`
	ServerTime       time.Time                  `json:"serverTime"`
}

func (request RunControlHelloRequest) ToDomain() domain.RunControlHello {
	return domain.RunControlHello{
		RegistrationToken: request.RegistrationToken,
		RunEndpointID:     request.RunEndpointID,
		ServerInstanceID:  request.ServerInstanceID,
		PluginID:          request.PluginID,
		ComponentKind:     request.ComponentKind,
		ComponentKey:      request.ComponentKey,
		KeyGeneration:     request.KeyGeneration,
		DisplayName:       request.DisplayName,
		Version:           request.Version,
		Status:            request.Status,
		Platform:          request.Platform,
		Architecture:      request.Architecture,
		UpdateJobID:       request.UpdateJobID,
		UpdateOutcome:     request.UpdateOutcome,
		CapabilityReport: domain.RunCapabilityReport{
			Capabilities: domain.CopyStringSlice(request.CapabilityReport.Capabilities),
			Fingerprint:  request.CapabilityReport.Fingerprint,
		},
		Capacity: capacityToDomain(request.Capacity),
	}
}

func (request RunControlHeartbeatRequest) ToDomain() domain.RunControlHeartbeat {
	return domain.RunControlHeartbeat{
		RunEndpointID:         request.RunEndpointID,
		SessionToken:          request.SessionToken,
		Version:               request.Version,
		Status:                request.Status,
		CapabilityFingerprint: request.CapabilityFingerprint,
		Capacity:              capacityToDomain(request.Capacity),
	}
}

func (request RunControlStreamRequest) ToDomain() domain.RunControlStreamRequest {
	return domain.RunControlStreamRequest{RunEndpointID: request.RunEndpointID, SessionToken: request.SessionToken, LastEventSeq: request.LastEventSeq}
}

func (request RunLifecycleReportRequest) ToDomain() domain.RunLifecycleReport {
	return domain.RunLifecycleReport{
		RunEndpointID:    request.RunEndpointID,
		SessionToken:     request.SessionToken,
		ServerInstanceID: request.ServerInstanceID,
		Capability:       request.Capability,
		State:            request.State,
		Progress:         progressReportToDomain(request.Progress),
		Message:          request.Message,
		ErrorCode:        request.ErrorCode,
		ManagedProcessID: request.ManagedProcessID,
		ObservationSeq:   request.ObservationSeq,
		ObservedAt:       request.ObservedAt,
		ExecutionResult:  domain.JobExecutionResult{Kind: request.ExecutionResult.Kind, ProcessState: request.ExecutionResult.ProcessState, ExitClassification: request.ExecutionResult.ExitClassification, ExitCode: request.ExecutionResult.ExitCode, Version: request.ExecutionResult.Version, Checksum: request.ExecutionResult.Checksum, SizeBytes: request.ExecutionResult.SizeBytes, Summary: request.ExecutionResult.Summary, Content: request.ExecutionResult.Content, ServerDeploymentEvidence: serverDeploymentEvidenceToDomain(request.ExecutionResult.ServerDeploymentEvidence), DeploymentReceipt: deploymentReceiptToDomain(request.ExecutionResult.DeploymentReceipt)},
	}
}

func RunControlHelloFromDomain(result domain.RunControlHelloResult) RunControlHelloResponse {
	result = domain.CopyRunControlHelloResult(result)
	return RunControlHelloResponse{
		Accepted:                 result.Accepted,
		RunEndpointID:            result.RunEndpointID,
		SessionToken:             result.SessionToken,
		ServerTime:               result.ServerTime,
		HeartbeatIntervalSeconds: result.HeartbeatIntervalSeconds,
		SessionExpiresAt:         result.SessionExpiresAt,
		FeatureFlags:             result.FeatureFlags,
	}
}

func RunControlHeartbeatFromDomain(result domain.RunControlHeartbeatResult) RunControlHeartbeatResponse {
	return RunControlHeartbeatResponse{
		Accepted:             result.Accepted,
		RunEndpointID:        result.RunEndpointID,
		NextHeartbeatSeconds: result.NextHeartbeatSeconds,
		RefreshCapabilities:  result.RefreshCapabilities,
		ServerTime:           result.ServerTime,
	}
}

func RunControlEventFromDomain(event domain.RunControlEvent) RunControlEventResponse {
	return RunControlEventResponse{RunEndpointID: event.RunEndpointID, Sequence: event.Sequence, Type: event.Type, ServerTime: event.ServerTime, RetrySeconds: event.RetrySeconds}
}

func RunLifecycleReportFromDomain(result domain.RunLifecycleReportResult) RunLifecycleReportResponse {
	result = domain.CopyRunLifecycleReportResult(result)
	return RunLifecycleReportResponse{Accepted: result.Accepted, RunEndpointID: result.RunEndpointID, ServerInstanceID: result.ServerInstanceID, ProjectedState: result.ProjectedState, ServerTime: result.ServerTime}
}