package cliui

import (

"fmt"

"io"

"sort"

"strconv"

"strings"

"github.com/google/uuid"

"github.com/jedib0t/go-pretty/v6/table"

"golang.org/x/mod/semver"

"github.com/coder/coder/v2/coderd/database/dbtime"

"github.com/coder/coder/v2/coderd/util/slice"

"github.com/coder/coder/v2/codersdk"

"github.com/coder/pretty"

)

var (

pipeMid = "├"

pipeEnd = "└"

)

type WorkspaceResourcesOptions struct {

WorkspaceName string

HideAgentState bool

HideAccess bool

Title string

ServerVersion string

ListeningPorts map[uuid.UUID]codersdk.WorkspaceAgentListeningPortsResponse

Devcontainers map[uuid.UUID]codersdk.WorkspaceAgentListContainersResponse

ShowDetails bool

}

// WorkspaceResources displays the connection status and tree-view of provided resources.

// ┌────────────────────────────────────────────────────────────────────────────┐

// │ RESOURCE STATUS ACCESS │

// ├────────────────────────────────────────────────────────────────────────────┤

// │ google_compute_disk.root │

// ├────────────────────────────────────────────────────────────────────────────┤

// │ google_compute_instance.dev │

// │ └─ dev (linux, amd64) ⦾ connecting [10s] coder ssh dev.dev │

// ├────────────────────────────────────────────────────────────────────────────┤

// │ kubernetes_pod.dev │

// │ ├─ go (linux, amd64) ⦿ connected coder ssh dev.go │

// │ └─ postgres (linux, amd64) ⦾ disconnected [4s] coder ssh dev.postgres │

// └────────────────────────────────────────────────────────────────────────────┘

func WorkspaceResources(writer io.Writer, resources []codersdk.WorkspaceResource, options WorkspaceResourcesOptions) error {

// Sort resources by type for consistent output.

sort.Slice(resources, func(i, j int) bool {

return resources[i].Type < resources[j].Type

})

tableWriter := table.NewWriter()

if options.Title != "" {

tableWriter.SetTitle(options.Title)

}

tableWriter.SetStyle(table.StyleLight)

tableWriter.Style().Options.SeparateColumns = false

row := table.Row{"Resource"}

if !options.HideAgentState {

row = append(row, "Status")

row = append(row, "Health")

row = append(row, "Version")

}

if !options.HideAccess {

row = append(row, "Access")

}

tableWriter.AppendHeader(row)

totalAgents := 0

for _, resource := range resources {

for _, agent := range resource.Agents {

if !agent.ParentID.Valid {

totalAgents++

}

}

}

for _, resource := range resources {

if resource.Type == "random_string" {

// Hide resources that aren't substantial to a user!

// This is an unfortunate case, and we should allow

// callers to hide resources eventually.

continue

}

resourceAddress := resource.Type + "." + resource.Name

// Sort agents by name for consistent output.

sort.Slice(resource.Agents, func(i, j int) bool {

return resource.Agents[i].Name < resource.Agents[j].Name

})

// Display a line for the resource.

tableWriter.AppendRow(table.Row{

Bold(resourceAddress),

"",

"",

"",

})

// Display all agents associated with the resource.

agents := slice.Filter(resource.Agents, func(agent codersdk.WorkspaceAgent) bool {

return !agent.ParentID.Valid

})

for index, agent := range agents {

tableWriter.AppendRow(renderAgentRow(agent, index, totalAgents, options))

for _, row := range renderListeningPorts(options, agent.ID, index, totalAgents) {

tableWriter.AppendRow(row)

}

for _, row := range renderDevcontainers(resources, options, agent.ID, index, totalAgents) {

tableWriter.AppendRow(row)

}

}

tableWriter.AppendSeparator()

}

_, err := fmt.Fprintln(writer, tableWriter.Render())

return err

}

func renderAgentRow(agent codersdk.WorkspaceAgent, index, totalAgents int, options WorkspaceResourcesOptions) table.Row {

row := table.Row{

// These tree from a resource!

fmt.Sprintf("%s─ %s (%s, %s)", renderPipe(index, totalAgents), agent.Name, agent.OperatingSystem, agent.Architecture),

}

if !options.HideAgentState {

var agentStatus, agentHealth, agentVersion string

if !options.HideAgentState {

agentStatus = renderAgentStatus(agent)

agentHealth = renderAgentHealth(agent)

agentVersion = renderAgentVersion(agent.Version, options.ServerVersion)

}

row = append(row, agentStatus, agentHealth, agentVersion)

}

if !options.HideAccess {

sshCommand := "coder ssh " + options.WorkspaceName

if totalAgents > 1 || len(options.Devcontainers) > 0 {

sshCommand += "." + agent.Name

}

sshCommand = pretty.Sprint(DefaultStyles.Code, sshCommand)

row = append(row, sshCommand)

}

return row

}

func renderListeningPorts(wro WorkspaceResourcesOptions, agentID uuid.UUID, idx, total int) []table.Row {

var rows []table.Row

if wro.ListeningPorts == nil {

return []table.Row{}

}

lp, ok := wro.ListeningPorts[agentID]

if !ok || len(lp.Ports) == 0 {

return []table.Row{}

}

rows = append(rows, table.Row{

fmt.Sprintf(" %s─ Open Ports", renderPipe(idx, total)),

})

for idx, port := range lp.Ports {

rows = append(rows, renderPortRow(port, idx, len(lp.Ports)))

}

return rows

}

func renderPortRow(port codersdk.WorkspaceAgentListeningPort, idx, total int) table.Row {

var sb strings.Builder

_, _ = sb.WriteString(" ")

_, _ = sb.WriteString(renderPipe(idx, total))

_, _ = sb.WriteString("─ ")

_, _ = sb.WriteString(pretty.Sprintf(DefaultStyles.Code, "%5d/%s", port.Port, port.Network))

if port.ProcessName != "" {

_, _ = sb.WriteString(pretty.Sprintf(DefaultStyles.Keyword, " [%s]", port.ProcessName))

}

return table.Row{sb.String()}

}

func renderDevcontainers(resources []codersdk.WorkspaceResource, wro WorkspaceResourcesOptions, agentID uuid.UUID, index, totalAgents int) []table.Row {

var rows []table.Row

if wro.Devcontainers == nil {

return []table.Row{}

}

dc, ok := wro.Devcontainers[agentID]

if !ok || len(dc.Devcontainers) == 0 {

return []table.Row{}

}

rows = append(rows, table.Row{

fmt.Sprintf(" %s─ %s", renderPipe(index, totalAgents), "Devcontainers"),

})

for idx, devcontainer := range dc.Devcontainers {

rows = append(rows, renderDevcontainerRow(resources, devcontainer, idx, len(dc.Devcontainers), wro)...)

}

return rows

}

func renderDevcontainerRow(resources []codersdk.WorkspaceResource, devcontainer codersdk.WorkspaceAgentDevcontainer, index, total int, wro WorkspaceResourcesOptions) []table.Row {

var rows []table.Row

// If the devcontainer is running and has an associated agent, we want to

// display the agent's details. Otherwise, we just display the devcontainer

// name and status.

var subAgent *codersdk.WorkspaceAgent

displayName := devcontainer.Name

if devcontainer.Agent != nil && devcontainer.Status == codersdk.WorkspaceAgentDevcontainerStatusRunning {

for _, resource := range resources {

if agent, found := slice.Find(resource.Agents, func(agent codersdk.WorkspaceAgent) bool {

return agent.ID == devcontainer.Agent.ID

}); found {

subAgent = &agent

break

}

}

if subAgent != nil {

displayName = subAgent.Name

displayName += fmt.Sprintf(" (%s, %s)", subAgent.OperatingSystem, subAgent.Architecture)

}

}

if devcontainer.Container != nil {

displayName += " " + pretty.Sprint(DefaultStyles.Keyword, "["+devcontainer.Container.FriendlyName+"]")

}

// Build the main row.

row := table.Row{

fmt.Sprintf(" %s─ %s", renderPipe(index, total), displayName),

}

// Add status, health, and version columns.

if !wro.HideAgentState {

if subAgent != nil {

row = append(row, renderAgentStatus(*subAgent))

row = append(row, renderAgentHealth(*subAgent))

row = append(row, renderAgentVersion(subAgent.Version, wro.ServerVersion))

} else {

row = append(row, renderDevcontainerStatus(devcontainer.Status))

row = append(row, "") // No health for devcontainer without agent.

row = append(row, "") // No version for devcontainer without agent.

}

}

// Add access column.

if !wro.HideAccess {

if subAgent != nil {

accessString := fmt.Sprintf("coder ssh %s.%s", wro.WorkspaceName, subAgent.Name)

row = append(row, pretty.Sprint(DefaultStyles.Code, accessString))

} else {

row = append(row, "") // No access for devcontainers without agent.

}

}

rows = append(rows, row)

// Add error message if present.

if errorMessage := devcontainer.Error; errorMessage != "" {

// Cap error message length for display.

if !wro.ShowDetails && len(errorMessage) > 80 {

errorMessage = errorMessage[:79] + "…"

}

errorRow := table.Row{

" × " + pretty.Sprint(DefaultStyles.Error, errorMessage),

"",

"",

"",

}

if !wro.HideAccess {

errorRow = append(errorRow, "")

}

rows = append(rows, errorRow)

}

// Add listening ports for the devcontainer agent.

if subAgent != nil {

portRows := renderListeningPorts(wro, subAgent.ID, index, total)

for _, portRow := range portRows {

// Adjust indentation for ports under devcontainer agent.

if len(portRow) > 0 {

if str, ok := portRow[0].(string); ok {

portRow[0] = " " + str // Add extra indentation.

}

}

rows = append(rows, portRow)

}

}

return rows

}

func renderDevcontainerStatus(status codersdk.WorkspaceAgentDevcontainerStatus) string {

switch status {

case codersdk.WorkspaceAgentDevcontainerStatusRunning:

return pretty.Sprint(DefaultStyles.Keyword, "▶ running")

case codersdk.WorkspaceAgentDevcontainerStatusStopped:

return pretty.Sprint(DefaultStyles.Placeholder, "⏹ stopped")

case codersdk.WorkspaceAgentDevcontainerStatusStarting:

return pretty.Sprint(DefaultStyles.Warn, "⧗ starting")

case codersdk.WorkspaceAgentDevcontainerStatusError:

return pretty.Sprint(DefaultStyles.Error, "✘ error")

default:

return pretty.Sprint(DefaultStyles.Placeholder, "○ "+string(status))

}

}

func renderAgentStatus(agent codersdk.WorkspaceAgent) string {

switch agent.Status {

case codersdk.WorkspaceAgentConnecting:

since := dbtime.Now().Sub(agent.CreatedAt)

return pretty.Sprint(DefaultStyles.Warn, "⦾ connecting") + " " +

pretty.Sprint(DefaultStyles.Placeholder, "["+strconv.Itoa(int(since.Seconds()))+"s]")

case codersdk.WorkspaceAgentDisconnected:

since := dbtime.Now().Sub(*agent.DisconnectedAt)

return pretty.Sprint(DefaultStyles.Error, "⦾ disconnected") + " " +

pretty.Sprint(DefaultStyles.Placeholder, "["+strconv.Itoa(int(since.Seconds()))+"s]")

case codersdk.WorkspaceAgentTimeout:

since := dbtime.Now().Sub(agent.CreatedAt)

return fmt.Sprintf(

"%s %s",

pretty.Sprint(DefaultStyles.Warn, "⦾ timeout"),

pretty.Sprint(DefaultStyles.Placeholder, "["+strconv.Itoa(int(since.Seconds()))+"s]"),

)

case codersdk.WorkspaceAgentConnected:

return pretty.Sprint(DefaultStyles.Keyword, "⦿ connected")

default:

return pretty.Sprint(DefaultStyles.Warn, "○ unknown")

}

}

func renderAgentHealth(agent codersdk.WorkspaceAgent) string {

if agent.Health.Healthy {

return pretty.Sprint(DefaultStyles.Keyword, "✔ healthy")

}

return pretty.Sprint(DefaultStyles.Error, "✘ "+agent.Health.Reason)

}

func renderAgentVersion(agentVersion, serverVersion string) string {

if agentVersion == "" {

agentVersion = "(unknown)"

}

if !semver.IsValid(serverVersion) || !semver.IsValid(agentVersion) {

return pretty.Sprint(DefaultStyles.Placeholder, agentVersion)

}

outdated := semver.Compare(agentVersion, serverVersion) < 0

if outdated {

return pretty.Sprint(DefaultStyles.Warn, agentVersion+" (outdated)")

}

return pretty.Sprint(DefaultStyles.Keyword, agentVersion)

}

func renderPipe(idx, total int) string {

if idx == total-1 {

return pipeEnd

}

return pipeMid

}