menus.go

package main

import (
	"fmt"
	"math"
	"runtime"
	"strings"
	"time"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/neuralinkcorp/tsui/clipboard"
	"github.com/neuralinkcorp/tsui/libts"
	"github.com/neuralinkcorp/tsui/ui"
	"tailscale.com/ipn"
	"tailscale.com/ipn/ipnstate"
	"tailscale.com/types/opt"
	"tailscale.com/types/preftype"
)

func buildNetworkDevicesSubmenuSection(title string, peers []*ipnstate.PeerStatus) []ui.SubmenuItem {
	items := []ui.SubmenuItem{
		&ui.TitleSubmenuItem{Label: title},
	}

	if len(peers) == 0 {
		items = append(items, &ui.DividerSubmenuItem{})
	} else {
		for _, peer := range peers {
			peerName := libts.PeerName(peer)

			// Normalize the capitalization of the OS, because some are capitalized but some aren't.
			osName := peer.OS
			switch osName {
			case "android":
				osName = "Android"
			case "windows":
				osName = "Windows"
			case "linux":
				osName = "Linux"
			}

			items = append(items, &ui.LabeledSubmenuItem{
				Label:           peerName,
				AdditionalLabel: osName,
				ChildSubmenu:    buildMachineDetailsSubmenu(peer),
				OnActivate: func() tea.Msg {
					err := clipboard.WriteString(peer.TailscaleIPs[0].String())
					if err != nil {
						return errorMsg(err)
					}
					return successMsg(fmt.Sprintf("Copied IP address of %s.", peerName))
				},
				IsDim: false,
			})
		}
	}

	return items
}

func buildMachineDetailsSubmenu(peer *ipnstate.PeerStatus) *ui.Submenu {
	peerName := libts.PeerName(peer)
	items := []ui.SubmenuItem{
		&ui.TitleSubmenuItem{Label: "Machine Details"},
	}

	addCopyItem := func(label string, value string) {
		if value == "" {
			return
		}

		items = append(items, &ui.LabeledSubmenuItem{
			Label:           label,
			AdditionalLabel: value,
			OnActivate: func() tea.Msg {
				err := clipboard.WriteString(value)
				if err != nil {
					return errorMsg(err)
				}
				return successMsg(fmt.Sprintf("Copied %s of %s.", strings.ToLower(label), peerName))
			},
		})
	}

	addInfoItem := func(label string, value string) {
		if value == "" {
			return
		}

		items = append(items, &ui.LabeledSubmenuItem{
			Label:           label,
			AdditionalLabel: value,
			IsDim:           true,
			OnActivate: func() tea.Msg {
				err := clipboard.WriteString(value)
				if err != nil {
					return errorMsg(err)
				}
				return successMsg(fmt.Sprintf("Copied %s of %s.", strings.ToLower(label), peerName))
			},
		})
	}

	fullDomain := trimTrailingDot(peer.DNSName)
	addCopyItem("Short Domain", peerName)
	addCopyItem("Full Domain", fullDomain)

	for _, addr := range peer.TailscaleIPs {
		label := "Tailscale IPv6"
		if addr.Is4() {
			label = "Tailscale IPv4"
		}
		addCopyItem(label, addr.String())
	}

	items = append(items, &ui.SpacerSubmenuItem{}, &ui.TitleSubmenuItem{Label: "Details"})
	addInfoItem("OS Hostname", peer.HostName)
	addInfoItem("OS", peer.OS)
	addCopyItem("ID", string(peer.ID))
	addCopyItem("Node Key", peer.PublicKey.String())

	status := "Offline"
	if peer.Online {
		status = "Connected"
	} else if !peer.LastSeen.IsZero() {
		status = fmt.Sprintf("Last seen %s ago", ui.FormatDuration(time.Since(peer.LastSeen)))
	}
	addInfoItem("Status", status)

	if !peer.Created.IsZero() {
		addInfoItem("Created", peer.Created.Format(time.RFC822))
	}
	if peer.KeyExpiry != nil {
		keyExpiry := "Expired"
		if duration := time.Until(*peer.KeyExpiry); duration > 0 {
			keyExpiry = ui.FormatDuration(duration)
		}
		addInfoItem("Key Expiry", keyExpiry)
	}
	if peer.ExitNodeOption {
		addInfoItem("Exit Node", "Yes")
	}
	if peer.Relay != "" {
		addInfoItem("Relay", peer.Relay)
	}

	if len(peer.Addrs) > 0 || peer.CurAddr != "" {
		items = append(items, &ui.SpacerSubmenuItem{}, &ui.TitleSubmenuItem{Label: "Endpoints"})
		addInfoItem("Current", peer.CurAddr)
		for _, addr := range peer.Addrs {
			addInfoItem("Endpoint", addr)
		}
	}

	submenu := &ui.Submenu{}
	submenu.SetItems(items)
	return submenu
}

func trimTrailingDot(s string) string {
	if len(s) > 0 && s[len(s)-1] == '.' {
		return s[:len(s)-1]
	}
	return s
}

// Update all of the menu UIs from the current state.
func (m *model) updateMenus() {
	if m.state.BackendState == ipn.Running {
		// Update the device info submenu.
		{
			submenuItems := []ui.SubmenuItem{
				&ui.TitleSubmenuItem{Label: "Name"},
				&ui.LabeledSubmenuItem{
					Label: trimTrailingDot(m.state.Self.DNSName),
					OnActivate: func() tea.Msg {
						err := clipboard.WriteString(trimTrailingDot(m.state.Self.DNSName))
						if err != nil {
							return errorMsg(err)
						}
						return successMsg("Copied full domain to clipboard.")
					},
				},
				&ui.SpacerSubmenuItem{},
				&ui.TitleSubmenuItem{Label: "IPs"},
			}

			for _, addr := range m.state.Self.TailscaleIPs {
				submenuItems = append(submenuItems, &ui.LabeledSubmenuItem{
					Label: addr.String(),
					OnActivate: func() tea.Msg {
						err := clipboard.WriteString(addr.String())
						if err != nil {
							return errorMsg(err)
						}

						var versionName string
						if addr.Is4() {
							versionName = "IPv4"
						} else {
							versionName = "IPv6"
						}

						return successMsg(fmt.Sprintf("Copied %s address to clipboard.", versionName))
					},
				})
			}

			submenuItems = append(submenuItems,
				&ui.SpacerSubmenuItem{},
				&ui.TitleSubmenuItem{Label: "Debug Info"},
				&ui.LabeledSubmenuItem{
					Label: fmt.Sprintf("ID: %s", m.state.Self.ID),
					OnActivate: func() tea.Msg {
						err := clipboard.WriteString(string(m.state.Self.ID))
						if err != nil {
							return errorMsg(err)
						}
						return successMsg("Copied Tailscale node ID to clipboard.")
					},
				},
				&ui.LabeledSubmenuItem{
					Label: m.state.Self.PublicKey.String(),
					OnActivate: func() tea.Msg {
						err := clipboard.WriteString(m.state.Self.PublicKey.String())
						if err != nil {
							return errorMsg(err)
						}
						return successMsg("Copied node key to clipboard.")
					},
				},
			)

			if m.state.LockKey != nil {
				statusText := "Online"
				if m.state.IsLockedOut {
					statusText = "Locked Out"
				}

				submenuItems = append(submenuItems,
					&ui.SpacerSubmenuItem{},
					&ui.TitleSubmenuItem{Label: "Tailnet Lock: " + statusText},
					&ui.LabeledSubmenuItem{
						Label: m.state.LockKey.CLIString(),
						OnActivate: func() tea.Msg {
							err := clipboard.WriteString(m.state.LockKey.CLIString())
							if err != nil {
								return errorMsg(err)
							}
							return successMsg("Copied tailnet lock key to clipboard.")
						},
					},
				)
			}

			submenuItems = append(submenuItems,
				&ui.SpacerSubmenuItem{},
				&ui.LabeledSubmenuItem{
					Label:   "[Disconnect from Tailscale]",
					Variant: ui.SubmenuItemVariantAccent,
					OnActivate: func() tea.Msg {
						err := libts.Down(ctx)
						if err != nil {
							return errorMsg(err)
						}
						return tipMsg("You can also simply press . to disconnect.")
					},
				},
			)

			m.deviceInfo.Submenu.SetItems(submenuItems)
		}

		// Update the exit node submenu.
		{
			exitNodeItems := make([]ui.SubmenuItem, 2+len(m.state.ExitNodes))
			exitNodeItems[0] = &ui.ToggleableSubmenuItem{
				LabeledSubmenuItem: ui.LabeledSubmenuItem{
					Label: "None",
					OnActivate: func() tea.Msg {
						err := libts.SetExitNode(ctx, nil)
						if err != nil {
							return errorMsg(err)
						}
						return updateState()
					},
				},
				IsActive: m.state.CurrentExitNode == nil,
			}
			exitNodeItems[1] = &ui.DividerSubmenuItem{}
			for i, exitNode := range m.state.ExitNodes {
				// Offset for the "None" item and the divider.
				i += 2

				pingLabel := "???"
				if !exitNode.Online {
					pingLabel = "Offline"
				} else if m.pings[exitNode.ID] != nil {
					pingLabel = fmt.Sprintf("%dms", int(math.Round(m.pings[exitNode.ID].LatencySeconds*1000)))
				}

				exitNodeItems[i] = &ui.ToggleableSubmenuItem{
					LabeledSubmenuItem: ui.LabeledSubmenuItem{
						Label:           libts.PeerName(exitNode),
						AdditionalLabel: pingLabel,
						OnActivate: func() tea.Msg {
							err := libts.SetExitNode(ctx, exitNode)
							if err != nil {
								return errorMsg(err)
							}
							return updateState()
						},
						IsDim: !exitNode.Online,
					},
					IsActive: m.state.CurrentExitNode != nil && exitNode.ID == *m.state.CurrentExitNode,
				}
			}

			m.exitNodes.AdditionalLabel = m.state.CurrentExitNodeName
			m.exitNodes.Submenu.SetItems(exitNodeItems)
		}

		// Update the network devices submenu.
		{
			networkNodes := make([]ui.SubmenuItem, 0)

			networkNodes = append(networkNodes,
				buildNetworkDevicesSubmenuSection("My Devices", m.state.MyNodes)...)
			networkNodes = append(networkNodes,
				&ui.SpacerSubmenuItem{})
			networkNodes = append(networkNodes,
				buildNetworkDevicesSubmenuSection("Tagged Devices", m.state.TaggedNodes)...)

			for _, key := range m.state.OwnedNodeKeys {
				if key == "" {
					key = "<none>"
				}

				networkNodes = append(networkNodes,
					&ui.SpacerSubmenuItem{})
				networkNodes = append(networkNodes,
					buildNetworkDevicesSubmenuSection(key, m.state.OwnedNodes[key])...)
			}

			lenSum := len(m.state.MyNodes) + len(m.state.TaggedNodes)
			for _, value := range m.state.OwnedNodes {
				lenSum += len(value)
			}

			m.networkDevices.AdditionalLabel = fmt.Sprintf("%d visible", lenSum)
			m.networkDevices.Submenu.SetItems(networkNodes)
		}

		// Update the settings submenu.
		{
			exitNode := "No"
			if m.state.Prefs.AdvertisesExitNode() {
				exitNode = "Exit Node"
			}

			accountTitle := "Account"
			reauthenticateButtonLabel := "[Reauthenticate]"
			if m.state.Self.KeyExpiry != nil {
				reauthenticateButtonLabel = "[Reauthenticate Now]"

				duration := time.Until(*m.state.Self.KeyExpiry)
				accountTitle += " - Key Expires in " + ui.FormatDuration(duration)
			}

			submenuItems := []ui.SubmenuItem{
				&ui.TitleSubmenuItem{Label: "General"},

				ui.NewYesNoSettingsSubmenuItem("Allow Incoming Connections",
					!m.state.Prefs.ShieldsUp,
					func(newValue bool) tea.Msg {
						return editPrefs(&ipn.MaskedPrefs{
							Prefs: ipn.Prefs{
								ShieldsUp: !newValue,
							},
							ShieldsUpSet: true,
						})
					},
				),

				ui.NewYesNoSettingsSubmenuItem("Use Subnet Routes",
					m.state.Prefs.RouteAll,
					func(newValue bool) tea.Msg {
						return editPrefs(&ipn.MaskedPrefs{
							Prefs: ipn.Prefs{
								RouteAll: newValue,
							},
							RouteAllSet: true,
						})
					},
				),

				ui.NewYesNoSettingsSubmenuItem("Use DNS Settings",
					m.state.Prefs.CorpDNS,
					func(newValue bool) tea.Msg {
						return editPrefs(&ipn.MaskedPrefs{
							Prefs: ipn.Prefs{
								CorpDNS: newValue,
							},
							CorpDNSSet: true,
						})
					},
				),

				&ui.SpacerSubmenuItem{},
				&ui.TitleSubmenuItem{Label: "Exit Nodes"},

				ui.NewYesNoSettingsSubmenuItem("Enable Local Network Access",
					m.state.Prefs.ExitNodeAllowLANAccess,
					func(newValue bool) tea.Msg {
						return editPrefs(&ipn.MaskedPrefs{
							Prefs: ipn.Prefs{
								ExitNodeAllowLANAccess: newValue,
							},
							ExitNodeAllowLANAccessSet: true,
						})
					},
				),

				ui.NewSettingsSubmenuItem("Advertise Exit Node",
					[]string{"Exit Node", "No"},
					exitNode,
					func(newLabel string) tea.Msg {
						var prefs ipn.Prefs
						prefs.SetAdvertiseExitNode(newLabel == "Exit Node")
						return editPrefs(&ipn.MaskedPrefs{
							Prefs:              prefs,
							AdvertiseRoutesSet: true,
						})
					},
				),

				&ui.SpacerSubmenuItem{},
				&ui.TitleSubmenuItem{Label: accountTitle},

				&ui.LabeledSubmenuItem{
					Label: reauthenticateButtonLabel,
					// Reauthenticating is basically the same as the first-time login flow.
					OnActivate: startLoginInteractive,
				},

				&ui.LabeledSubmenuItem{
					Label:   "[Log Out]",
					Variant: ui.SubmenuItemVariantDanger,
					OnActivate: func() tea.Msg {
						err := libts.Logout(ctx)
						if err != nil {
							return errorMsg(err)
						}
						return successMsg("Logged out.")
					},
				},
			}

			// On Linux, show the advanced Linux settings.
			if runtime.GOOS == "linux" {
				var netfilterMode string
				switch m.state.Prefs.NetfilterMode {
				case preftype.NetfilterOn:
					netfilterMode = "On"
				case preftype.NetfilterNoDivert:
					netfilterMode = "No Divert"
				case preftype.NetfilterOff:
					netfilterMode = "Off"
				}

				noStatefulFiltering, _ := m.state.Prefs.NoStatefulFiltering.Get()

				submenuItems = append(submenuItems,
					&ui.SpacerSubmenuItem{},
					&ui.TitleSubmenuItem{Label: "Advanced - Linux"},

					ui.NewSettingsSubmenuItem("NetFilter Mode",
						[]string{"On", "No Divert", "Off"},
						netfilterMode,
						func(newLabel string) tea.Msg {
							var netfilterMode preftype.NetfilterMode
							switch newLabel {
							case "On":
								netfilterMode = preftype.NetfilterOn
							case "No Divert":
								netfilterMode = preftype.NetfilterNoDivert
							case "Off":
								netfilterMode = preftype.NetfilterOff
							}

							return editPrefs(&ipn.MaskedPrefs{
								Prefs: ipn.Prefs{
									NetfilterMode: netfilterMode,
								},
								NetfilterModeSet: true,
							})
						},
					),

					ui.NewYesNoSettingsSubmenuItem("Enable Stateful Filtering",
						!noStatefulFiltering,
						func(newValue bool) tea.Msg {
							return editPrefs(&ipn.MaskedPrefs{
								Prefs: ipn.Prefs{
									NoStatefulFiltering: opt.NewBool(!newValue),
								},
								NoStatefulFilteringSet: true,
							})
						},
					),
				)
			}

			m.settings.Submenu.SetItems(submenuItems)
		}

		// Make sure the menu items are visible.
		m.menu.SetItems([]*ui.AppmenuItem{
			m.deviceInfo,
			m.exitNodes,
			m.networkDevices,
			m.settings,
		})
	} else {
		// Hide the menu items if not connected.
		// I mean, they won't be visible anyway, but extra safety is always nice!
		m.menu.SetItems([]*ui.AppmenuItem{})
	}
}