Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

20.7 KB
Raw Blame
package app

import (
	"context"
	"fmt"
	"io"
	"log/slog"
	"math/rand/v2"
	"net/url"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"sync"
	"time"

	tea "charm.land/bubbletea/v2"
	"charm.land/lipgloss/v2"
	"github.com/TNTcraftHIM/Piik/internal/app/browser"
	"github.com/TNTcraftHIM/Piik/internal/app/buildinfo"
	"github.com/TNTcraftHIM/Piik/internal/app/failure"
	"github.com/TNTcraftHIM/Piik/internal/app/launcher"
	"github.com/TNTcraftHIM/Piik/internal/diagnostics"
	"github.com/charmbracelet/colorprofile"
	"github.com/charmbracelet/x/ansi"
	"github.com/charmbracelet/x/term"
)

type consoleView struct {
	mode, state, entry, invite string
	certificate                string
	protected                  bool
	problem                    error
	browserError               error
}

type consoleLanguage string
type consoleLauncher string
type consoleFinished struct{ err error }
type consoleTick struct{}
type consoleIdleWink struct{}
type consoleOpenResult struct {
	target string
	err    error
}
type consoleDiagnostic string

func (diagnostic consoleDiagnostic) Error() string { return string(diagnostic) }

type consoleDebug struct {
	logPath string
	export  func() (string, error)
}
type consoleExportResult struct {
	path string
	err  error
}

type consoleResult struct {
	model tea.Model
	err   error
}

type consoleModel struct {
	view        consoleView
	launcher    string
	language    string
	width       int
	height      int
	colors      bool
	frame       int
	tickPending bool
	idlePending bool
	idleWink    bool
	finished    bool
	cancel      context.CancelFunc
	debug       consoleDebug
	exporting   bool
	exportPath  string
	exportError bool
	openBrowser func(string)
}

type console struct {
	mu       sync.Mutex
	machine  bool
	finished bool
	program  *tea.Program
	done     chan consoleResult
	plain    consoleModel
	opening  bool
	openURL  func(string) error
}

var consoleCopy = map[string][3]string{
	"failure.tunnel-exited":      {"Public invite disconnected before it was ready. Try again or use an existing Piik site.", "公网邀请尚未就绪就已断开,请重试或使用已有 Piik 站点。", "!"},
	"failure.tunnel-timeout":     {"Public invite did not connect in time. Try again or use an existing Piik site.", "公网邀请连接超时,请重试或使用已有 Piik 站点。", "!"},
	"failure.tunnel-unavailable": {"The public-invite helper is unavailable. Extract the complete App package again.", "公网邀请辅助程序不可用,请重新完整解压 App 程序包。", "!"},
	"failure.tunnel-start":       {"Could not start public invite. Check the details or use an existing Piik site.", "无法启动公网邀请,请查看详情或使用已有 Piik 站点。", "!"},
	"failure.tunnel-stopped":     {"Public invite stopped. Reopen App for a new link or use an existing Piik site.", "公网邀请已停止,请重开 App 获取新链接,或使用已有 Piik 站点。", "!"},
	"failure.local-port":         {"The local port is unavailable. Close the other process or choose another port.", "本地端口不可用,请关闭占用程序或更换端口。", "!"},
	"failure.local-network":      {"No suitable local invitation address. Check your network and selected address.", "没有合适的局域网邀请地址,请检查网络和所选地址。", "!"},
	"failure.configuration":      {"Could not apply App settings. Check the details.", "无法应用 App 设置,请查看详情。", "!"},
	"failure.native-control":     {"App connection service is unavailable. Reopen App and try again.", "App 连接服务不可用,请重开 App 后重试。", "!"},
	"failure.launcher":           {"App launcher is unavailable. Reopen App and try again.", "App 启动页不可用,请重开 App 后重试。", "!"},
	"failure.diagnostics":        {"Could not start diagnostics. Check the save location and permissions.", "无法开启诊断,请检查保存位置与权限。", "!"},
	"failure.local-server":       {"The local room service is unavailable. Check the details.", "本地房间服务不可用,请查看详情。", "!"},
	"local":                      {"Local network", "局域网", "□"},
	"link":                       {"Public link", "公网链接", "↗"},
	"site":                       {"Piik Site", "Piik 站点", "@"},
	"setup":                      {"App is ready", "App 已就绪", "?"},
	"starting":                   {"Starting", "正在启动", "…"},
	"ready":                      {"Ready", "已就绪", "✓"},
	"stopping":                   {"Stopping", "正在退出", "→"},
	"stopped":                    {"Stopped", "已停止", "○"},
	"failed":                     {"Could not continue", "运行失败", "!"},
	"entry":                      {"Open in browser", "打开网页", "□"},
	"launcher":                   {"App launcher", "App 启动页", "☆"},
	"invite":                     {"Site address", "站点地址", "↗"},
	"certificate":                {"Local certificate · SHA-256", "本地证书 · SHA-256", "TLS SHA-256"},
	"access":                     {"Site access", "站点准入", ""},
	"open":                       {"Open", "开放", "○"},
	"password":                   {"Password protected", "已设置密码", "*"},
	"error":                      {"Details", "详情", "!"},
	"exit":                       {"quit", "退出", "↪"},
	"openFailed":                 {"Could not open the browser; use the address above.", "无法打开浏览器,请使用上方地址。", "! ↗"},
	"log":                        {"Log", "日志", "LOG"},
	"export":                     {"Export diagnostics", "导出诊断", "ZIP"},
	"exporting":                  {"Saving diagnostics", "正在保存诊断", "ZIP ..."},
	"exported":                   {"Saved", "已保存", "ZIP +"},
	"exportFailed":               {"Could not save diagnostics", "无法保存诊断", "ZIP !"},
}

func newConsole(cancel context.CancelFunc, machine bool) *console {
	console := &console{
		machine: machine,
		openURL: browser.Open,
		plain: consoleModel{view: consoleView{state: "starting"}, language: defaultConsoleLanguage(), width: 76, cancel: cancel,
			colors: colorprofile.Detect(os.Stdout, os.Environ()) > colorprofile.ASCII},
	}
	console.plain.openBrowser = console.openBrowser
	if machine {
		return console
	}
	if term.IsTerminal(os.Stdin.Fd()) && term.IsTerminal(os.Stdout.Fd()) && os.Getenv("TERM") != "dumb" {
		console.program = tea.NewProgram(console.plain, tea.WithoutSignalHandler())
		console.done = make(chan consoleResult, 1)
		go func() {
			model, err := console.program.Run()
			console.done <- consoleResult{model: model, err: err}
			cancel()
		}()
	}
	return console
}

func (console *console) send(message tea.Msg) {
	console.mu.Lock()
	defer console.mu.Unlock()
	if console.machine || console.finished {
		return
	}
	if _, finished := message.(consoleFinished); finished {
		console.finished = true
	}
	if console.program != nil {
		console.program.Send(message)
		return
	}
	updated, _ := console.plain.Update(message)
	console.plain = updated.(consoleModel)
	fmt.Fprintln(os.Stdout, console.plain.content(false))
}

func (console *console) show(view consoleView)       { console.send(view) }
func (console *console) setLanguage(language string) { console.send(consoleLanguage(language)) }

// One OS handoff may remain pending, but never blocks App readiness or exit.
// Do not kill the handler on a timer: it may itself own the user's browser.
func (console *console) openBrowser(target string) {
	console.mu.Lock()
	if console.finished || console.opening {
		console.mu.Unlock()
		return
	}
	console.opening = true
	openURL := console.openURL
	console.mu.Unlock()
	go func() {
		err := openURL(target)
		if err != nil {
			slog.Debug("Could not open the system browser", diagnostics.Error(err))
		}
		console.send(consoleOpenResult{target: target, err: err})
		console.mu.Lock()
		console.opening = false
		console.mu.Unlock()
	}()
}

func (console *console) stop(err error) error {
	if console.program == nil {
		return nil
	}
	console.send(consoleFinished{err})
	result := <-console.done
	if model, ok := result.model.(consoleModel); ok {
		console.plain.language = model.language
	}
	return result.err
}

func (console *console) finish(err error, exportPath string) {
	if console.program == nil {
		console.send(consoleFinished{err})
		return
	}
	if exportPath != "" {
		fmt.Fprintln(os.Stderr, "Piik App:", console.plain.text("exported"), exportPath)
	}
	if err != nil {
		fmt.Fprintln(os.Stderr, "Piik App:", err)
	}
}

func (console *console) logWriter() io.Writer {
	if console.program == nil {
		return os.Stderr
	}
	return console
}

func (console *console) Write(data []byte) (int, error) {
	if text := strings.TrimSpace(string(data)); text != "" {
		console.send(consoleDiagnostic(ansi.Strip(text)))
	}
	return len(data), nil
}

func (model consoleModel) Init() tea.Cmd { return nil }

func (model consoleModel) Update(message tea.Msg) (tea.Model, tea.Cmd) {
	switch value := message.(type) {
	case consoleView:
		if model.view.state != "stopping" {
			model.view = value
		}
	case consoleLanguage:
		model.language = string(value)
	case consoleLauncher:
		model.launcher = string(value)
	case consoleDiagnostic:
		model.view.problem = value
		model.view.browserError = nil
	case consoleDebug:
		model.debug = value
	case consoleExportResult:
		model.exporting, model.exportError = false, value.err != nil
		if value.err == nil {
			model.exportPath = value.path
		}
	case tea.WindowSizeMsg:
		model.width, model.height = value.Width, value.Height
	case tea.ColorProfileMsg:
		model.colors = value.Profile > colorprofile.ASCII
	case consoleTick:
		model.tickPending = false
		model.frame++
		if model.frame >= 16 {
			model.idleWink = false
		}
	case consoleIdleWink:
		model.idlePending = false
		if model.view.state == "ready" || model.view.state == "setup" {
			model.frame, model.idleWink = 8, true
		}
	case consoleOpenResult:
		if value.target == model.view.entry && !model.finished && model.view.state != "stopping" {
			model.view.browserError = value.err
		}
	case consoleFinished:
		model.finished = true
		model.view.entry, model.view.invite, model.launcher = "", "", ""
		model.view.browserError = nil
		model.view.state, model.view.problem = "stopped", nil
		if value.err != nil {
			model.view.state, model.view.problem = "failed", value.err
		}
		return model, tea.Quit
	case tea.KeyPressMsg:
		switch value.String() {
		case "q", "ctrl+c":
			model.view = consoleView{mode: model.view.mode, state: "stopping"}
			model.launcher = ""
			model.cancel()
		case "o", "O":
			if target := model.view.entry; target != "" && model.openBrowser != nil {
				return model, func() tea.Msg { model.openBrowser(target); return nil }
			}
		case "d", "D":
			if model.debug.export != nil && !model.exporting && !model.finished && model.view.state != "stopping" {
				model.exporting, model.exportError = true, false
				return model, func() tea.Msg {
					path, err := model.debug.export()
					return consoleExportResult{path: path, err: err}
				}
			}
		}
	}
	if model.animating() && !model.tickPending {
		model.tickPending = true
		return model, tea.Tick(200*time.Millisecond, func(time.Time) tea.Msg { return consoleTick{} })
	}
	if !model.finished && !model.animating() && !model.idlePending &&
		(model.view.state == "ready" || model.view.state == "setup") {
		model.idlePending = true
		return model, tea.Tick(time.Duration(8+rand.IntN(13))*time.Second, func(time.Time) tea.Msg { return consoleIdleWink{} })
	}
	return model, nil
}

func (model consoleModel) animating() bool {
	return !model.finished && model.view.state != "stopping" &&
		(model.view.state == "starting" || model.frame < 8 || model.idleWink)
}

func (model consoleModel) text(key string) string {
	index := 0
	if model.language == "zh" {
		index = 1
	}
	if model.language == "vis" {
		return consoleVisualToken(key)
	}
	return consoleCopy[key][index]
}

func (model consoleModel) View() tea.View {
	view := tea.NewView(model.content(true))
	view.WindowTitle = "Piik App"
	view.AltScreen = true
	return view
}

func (model consoleModel) content(styled bool) string {
	width := max(12, min(model.width-2, 74))
	compact := model.height > 0 && model.height < 24
	compactDebug := compact && model.debug.logPath != ""
	visual := model.language == "vis"
	accent, muted, link, rule := lipgloss.NewStyle(), lipgloss.NewStyle(), lipgloss.NewStyle(), lipgloss.NewStyle()
	if styled {
		accent = accent.Bold(true)
		muted = muted.Faint(true)
		link = link.Underline(true)
	}
	key, stateStyle := accent, accent
	if styled && model.colors {
		// Use the terminal's palette so light and dark terminal themes both work.
		link = link.Foreground(lipgloss.Color("12"))
		key = key.Foreground(lipgloss.Color("12"))
		rule = rule.Foreground(lipgloss.Color("8"))
		switch model.view.state {
		case "ready", "setup":
			stateStyle = stateStyle.Foreground(lipgloss.Color("10"))
		case "starting", "stopping":
			stateStyle = stateStyle.Foreground(lipgloss.Color("11"))
		case "failed":
			stateStyle = stateStyle.Foreground(lipgloss.Color("9"))
		}
	}
	revision := buildinfo.Revision
	if len(revision) == 40 {
		revision = revision[:7]
	}
	var out strings.Builder
	version := buildinfo.Version()
	heading := accent.Render("Piik App") + "\n" + muted.Render(version)
	if revision != "" && revision != version {
		heading += "\n" + muted.Render(revision)
	}
	animated := styled && model.animating()
	mascot := accent.Render(consoleTV(model.frame, animated, compact || width < 34))
	if styled && model.colors && width >= 36 && !compact {
		mascot = consoleBlockTV(model.frame, animated)
	}
	fmt.Fprintln(&out, lipgloss.JoinHorizontal(lipgloss.Center, mascot, "  ", heading))
	if styled && !compact {
		fmt.Fprintln(&out, rule.Render(strings.Repeat("─", width-4)))
	} else {
		fmt.Fprintln(&out)
	}
	state := model.text(model.view.state)
	if model.view.state == "starting" && !visual {
		dots := 3
		if styled {
			dots = model.frame%3 + 1
		}
		state += strings.Repeat(".", dots)
	}
	if visual {
		// Keep visual mode one line tall; multi-line scene art side by side
		// collapses on narrow terminals and reads like missing characters.
		fmt.Fprintln(&out, lipgloss.JoinHorizontal(lipgloss.Center,
			accent.Render(consoleVisualToken(model.view.mode)), " · ",
			stateStyle.Render(consoleVisualToken(model.view.state))))
	} else {
		statusLine := stateStyle.Render(state)
		if model.view.mode != "" {
			statusLine += muted.Render("  ·  ") + model.text(model.view.mode)
		}
		fmt.Fprintln(&out, ansi.Wrap(statusLine, width-4, ""))
	}
	for _, item := range [][2]string{{"entry", model.view.entry}, {"launcher", model.launcher}, {"invite", model.view.invite}} {
		if item[1] == "" || compact && item[0] == "invite" || item[0] == "launcher" && item[1] == model.view.entry {
			continue
		}
		address := consoleAddress(item[1])
		if item[0] == "entry" {
			port := 0
			if source, err := url.Parse(item[1]); err == nil {
				port, _ = strconv.Atoi(source.Query().Get("piik-client-port"))
			}
			address = launcher.EntryURL(address, port)
		}
		style := link
		if styled {
			style = style.Hyperlink(address)
		}
		if compactDebug {
			fmt.Fprintf(&out, "\n%s\n", style.Render(address))
		} else if visual {
			label := consoleVisualToken(item[0])
			fmt.Fprintf(&out, "\n%s %s\n", label, style.Render(address))
		} else {
			fmt.Fprintf(&out, "\n%s\n%s\n", muted.Render(model.text(item[0])), style.Render(address))
		}
	}
	accessPicture := ""
	if !compact && model.view.certificate != "" {
		fmt.Fprintf(&out, "\n%s\n%s\n", muted.Render(model.text("certificate")), model.view.certificate)
	}
	if !compact && model.view.entry != "" && (model.view.mode == "local" || model.view.mode == "link") {
		access := "open"
		if model.view.protected {
			access = "password"
		}
		if visual {
			accessPicture = consoleVisualToken(access) + "   "
		} else {
			fmt.Fprintf(&out, "\n%s  %s\n", muted.Render(model.text("access")), model.text(access))
		}
	}
	problem := ""
	if model.view.problem != nil {
		problem = diagnostics.SafeText(model.view.problem.Error())
		if _, diagnostic := model.view.problem.(consoleDiagnostic); !diagnostic {
			if reason := failure.Of(model.view.problem); reason != "" {
				fmt.Fprintf(&out, "\n%s\n", ansi.Hardwrap(model.text("failure."+string(reason)), width-4, true))
			} else if model.view.state != "failed" {
				fmt.Fprintf(&out, "\n%s\n", model.text("failed"))
			}
		}
	}
	if model.view.browserError != nil {
		problem = model.text("openFailed") + "\n" + model.view.browserError.Error()
	}
	if problem != "" {
		lines := strings.Split(ansi.Hardwrap(ansi.Strip(problem), width-4, true), "\n")
		if len(lines) > 3 {
			lines = append(lines[:2], "...")
		}
		fmt.Fprintf(&out, "\n%s\n%s\n", model.text("error"), strings.Join(lines, "\n"))
	}
	if model.debug.logPath != "" {
		path, label := model.debug.logPath, "log"
		if model.exportPath != "" {
			path, label = model.exportPath, "exported"
		}
		separator := "\n"
		if compactDebug {
			separator = " "
		}
		fmt.Fprintf(&out, "\n%s%s%s\n", muted.Render(model.text(label)), separator, consoleFileLink(path, path, link, styled))
		if model.exporting {
			fmt.Fprintln(&out, model.text("exporting"))
		} else if model.exportError {
			fmt.Fprintln(&out, model.text("exportFailed"))
		}
	}
	if !model.finished {
		keys := key.Render("[q / Ctrl+C]")
		if !styled {
			keys = "Ctrl+C"
		}
		help := keys + " " + muted.Render(model.text("exit"))
		if visual {
			if model.view.entry != "" && styled {
				help = key.Render("[o]") + " ↗    " + help
			}
			help = lipgloss.JoinHorizontal(lipgloss.Center, accessPicture, help)
		} else if model.view.entry != "" && styled {
			separator := "    "
			if compact {
				separator = "\n"
			}
			help = key.Render("[o]") + " " + muted.Render(model.text("entry")) + separator + help
		}
		if model.debug.export != nil && styled {
			help = key.Render("[d]") + " " + muted.Render(model.text("export")) + "\n" + help
		}
		fmt.Fprintf(&out, "\n%s", help)
	}
	content := ansi.Hardwrap(out.String(), width-4, true)
	if !styled {
		return content
	}
	padding := 1
	if model.height > 0 && lipgloss.Height(content)+4 > model.height {
		content = strings.ReplaceAll(content, "\n\n", "\n")
		padding = 0
	}
	return lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(rule.GetForeground()).
		Padding(padding, 1).Width(width).Render(content)
}

func consoleVisualToken(key string) string {
	if entry, known := consoleCopy[key]; known {
		return entry[2]
	}
	return "?"
}

func consoleTV(frame int, animated, compact bool) string {
	phase := 0
	if animated {
		phase = frame % 8
	}
	eye := "o"
	if !animated || phase >= 4 {
		eye = "-"
	}
	if compact {
		return "  \\ /     \n [o  " + eye + "]   \n  /  \\     "
	}
	stars := [3]string{" ", " ", " "}
	if phase == 5 {
		stars[2] = "*"
	}
	if phase == 6 {
		stars[1] = "+"
	}
	if phase == 7 {
		stars[0] = "."
	}
	lines := []string{
		"     \\ /     " + stars[0] + " ",
		" .----v----.  " + stars[1] + " ",
		" | o     " + eye + " |  " + stars[2] + " ",
		" '---------'    ",
		"   /     \\      ",
	}
	return strings.Join(lines, "\n")
}

func consoleBlockTV(frame int, animated bool) string {
	phase := 0
	if animated {
		phase = frame % 8
	}
	shell := lipgloss.NewStyle().Reverse(true)
	spark := lipgloss.NewStyle().Foreground(lipgloss.Color("#f4c14d")).Faint(phase == 7)
	// Digits reveal the shell clockwise before the face; subsequent loops keep it drawn.
	rows := []string{"  2   2  ", "   2 2   ", " 0000011 ", "3sssssss1", "3sessses1", "3sssssss1", " 3222222 ", "  3   3  "}
	lines := make([]string, 0, len(rows))
	for rowIndex, row := range rows {
		var line strings.Builder
		for column, pixel := range row {
			if animated && (pixel >= '0' && pixel <= '3' && frame < int(pixel-'0') || (pixel == 's' || pixel == 'e') && frame < 3) {
				pixel = ' '
			}
			switch pixel {
			case '0', '1', '2', '3':
				line.WriteString(shell.Render("  "))
			case 's':
				line.WriteString("  ")
			case 'e':
				if column == len(row)-3 && (!animated || phase >= 4) {
					line.WriteString("\u2584\u2584")
				} else {
					line.WriteString(shell.Render("  "))
				}
			default:
				line.WriteString("  ")
			}
		}
		star := "   "
		starStyle := spark
		switch {
		case phase == 5 && rowIndex == 4:
			star = "\u2584\u2588\u2584"
		case phase == 5 && rowIndex == 5:
			star, starStyle = "\u2584 \u2584", spark.Reverse(true)
		case phase == 6 && rowIndex == 2:
			star = " \u2584 "
		case phase == 7 && rowIndex == 1:
			star = "  ."
		}
		lines = append(lines, line.String()+starStyle.Render(star))
	}
	return strings.Join(lines, "\n")
}

func consoleAddress(raw string) string {
	parsed, err := url.Parse(raw)
	if err != nil {
		return ""
	}
	parsed.User, parsed.RawQuery, parsed.Fragment, parsed.RawFragment, parsed.ForceQuery = nil, "", "", "", false
	return parsed.String()
}

func consoleFileLink(path, label string, style lipgloss.Style, styled bool) string {
	if !styled {
		return label
	}
	path = filepath.ToSlash(path)
	if !strings.HasPrefix(path, "/") {
		path = "/" + path
	}
	address := url.URL{Scheme: "file", Path: path}
	return style.Hyperlink(address.String()).Render(label)
}