wip: fix: deploy status

toolshed/abra#478

cli/app/deploy.go

@@ -221,7 +221,14 @@ checkout as-is. Recipe commit hashes are also supported as values for
 
 		log.Debugf("set waiting timeout to %d second(s)", stack.WaitTimeout)
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, app.Name, internal.DontWaitConverge); err != nil {
+		if err := stack.RunDeploy(
+			cl,
+			deployOpts,
+			compose,
+			app.Name,
+			app.Server,
+			internal.DontWaitConverge,
+		); err != nil {
 			log.Fatal(err)
 		}
 

cli/app/logs.go

@@ -3,11 +3,6 @@ package app
 import (
 	"context"
 	"fmt"
-	"io"
-	"os"
-	"slices"
-	"sync"
-	"time"
 
 	"coopcloud.tech/abra/cli/internal"
 	appPkg "coopcloud.tech/abra/pkg/app"
@@ -15,11 +10,6 @@ import (
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
 	"coopcloud.tech/abra/pkg/upstream/stack"
-	"github.com/docker/docker/api/types"
-	containerTypes "github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/filters"
-	"github.com/docker/docker/api/types/swarm"
-	dockerClient "github.com/docker/docker/client"
 	"github.com/spf13/cobra"
 )
 
@@ -68,85 +58,26 @@ var AppLogsCommand = &cobra.Command{
 			log.Fatalf("%s is not deployed?", app.Name)
 		}
 
-		var serviceNames []string
+		// TODO
-		if len(args) == 2 {
+		// var serviceNames []string
-			serviceNames = []string{args[1]}
+		// if len(args) == 2 {
-		}
+		// 	serviceNames = []string{args[1]}
+		// }
 
-		if err = tailLogs(cl, app, serviceNames); err != nil {
+		// b, err := logs.TailLogs(
-			log.Fatal(err)
+		// 	cl,
-		}
+		// 	app,
+		// 	serviceNames,
+		// 	stdErr,
+		// 	sinceLogs,
+		// 	true,
+		// )
+		// if err != nil {
+		// 	log.Fatal(err)
+		// }
 	},
 }
 
-// tailLogs prints logs for the given app with optional service names to be
-// filtered on. It also checks if the latest task is not runnning and then
-// prints the past tasks.
-func tailLogs(cl *dockerClient.Client, app appPkg.App, serviceNames []string) error {
-	f, err := app.Filters(true, false, serviceNames...)
-	if err != nil {
-		return err
-	}
-
-	services, err := cl.ServiceList(context.Background(), types.ServiceListOptions{Filters: f})
-	if err != nil {
-		return err
-	}
-
-	var wg sync.WaitGroup
-	for _, service := range services {
-		filters := filters.NewArgs()
-		filters.Add("name", service.Spec.Name)
-		tasks, err := cl.TaskList(context.Background(), types.TaskListOptions{Filters: f})
-		if err != nil {
-			return err
-		}
-		if len(tasks) > 0 {
-			// Need to sort the tasks by the CreatedAt field in the inverse order.
-			// Otherwise they are in the reversed order and not sorted properly.
-			slices.SortFunc[[]swarm.Task](tasks, func(t1, t2 swarm.Task) int {
-				return int(t2.Meta.CreatedAt.Unix() - t1.Meta.CreatedAt.Unix())
-			})
-			lastTask := tasks[0].Status
-			if lastTask.State != swarm.TaskStateRunning {
-				for _, task := range tasks {
-					log.Errorf("[%s] %s State %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err)
-				}
-			}
-		}
-
-		// Collect the logs in a go routine, so the logs from all services are
-		// collected in parallel.
-		wg.Add(1)
-		go func(serviceID string) {
-			logs, err := cl.ServiceLogs(context.Background(), serviceID, containerTypes.LogsOptions{
-				ShowStderr: true,
-				ShowStdout: !stdErr,
-				Since:      sinceLogs,
-				Until:      "",
-				Timestamps: true,
-				Follow:     true,
-				Tail:       "20",
-				Details:    false,
-			})
-			if err != nil {
-				log.Fatal(err)
-			}
-			defer logs.Close()
-
-			_, err = io.Copy(os.Stdout, logs)
-			if err != nil && err != io.EOF {
-				log.Fatal(err)
-			}
-		}(service.ID)
-	}
-
-	// Wait for all log streams to be closed.
-	wg.Wait()
-
-	return nil
-}
-
 var (
 	stdErr    bool
 	sinceLogs string

cli/app/restart.go

@@ -9,6 +9,7 @@ import (
 	"coopcloud.tech/abra/pkg/autocomplete"
 	"coopcloud.tech/abra/pkg/client"
 	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/ui"
 	upstream "coopcloud.tech/abra/pkg/upstream/service"
 	stack "coopcloud.tech/abra/pkg/upstream/stack"
 	"github.com/spf13/cobra"
@@ -95,11 +96,20 @@ Pass "--all-services/-a" to restart all services.`,
 
 			log.Debugf("attempting to scale %s to 0", stackServiceName)
 
+			// TODO
 			if err := upstream.RunServiceScale(context.Background(), cl, stackServiceName, 0); err != nil {
 				log.Fatal(err)
 			}
 
-			if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil {
+			// TODO
+			if err := stack.WaitOnServices(
+				cmd.Context(),
+				cl,
+				// TODO
+				[]ui.ServiceMeta{{Name: stackServiceName, ID: "???"}},
+				app.Name,
+				app.Server,
+			); err != nil {
 				log.Fatal(err)
 			}
 
@@ -110,7 +120,14 @@ Pass "--all-services/-a" to restart all services.`,
 				log.Fatal(err)
 			}
 
-			if err := stack.WaitOnService(context.Background(), cl, stackServiceName, app.Name); err != nil {
+			if err := stack.WaitOnServices(
+				cmd.Context(),
+				cl,
+				// TODO
+				[]ui.ServiceMeta{{Name: stackServiceName, ID: "???"}},
+				app.Name,
+				app.Server,
+			); err != nil {
 				log.Fatal(err)
 			}
 

cli/app/rollback.go

@@ -201,7 +201,14 @@ beforehand. See "abra app backup" for more.`,
 			log.Fatal(err)
 		}
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
+		if err := stack.RunDeploy(
+			cl,
+			deployOpts,
+			compose,
+			stackName,
+			app.Server,
+			internal.DontWaitConverge,
+		); err != nil {
 			log.Fatal(err)
 		}
 

cli/app/upgrade.go

@@ -234,7 +234,14 @@ beforehand. See "abra app backup" for more.`,
 
 		log.Debugf("set waiting timeout to %d second(s)", stack.WaitTimeout)
 
-		if err := stack.RunDeploy(cl, deployOpts, compose, stackName, internal.DontWaitConverge); err != nil {
+		if err := stack.RunDeploy(
+			cl,
+			deployOpts,
+			compose,
+			stackName,
+			app.Server,
+			internal.DontWaitConverge,
+		); err != nil {
 			log.Fatal(err)
 		}
 

cli/run.go

@@ -35,6 +35,7 @@ func Run(version, commit string) {
 				config.ABRA_DIR,
 				config.SERVERS_DIR,
 				config.RECIPES_DIR,
+				config.LOGS_DIR,
 				config.VENDOR_DIR, // TODO(d1): remove > 0.9.x
 				config.BACKUP_DIR, // TODO(d1): remove > 0.9.x
 			}

cli/updater/updater.go

@@ -441,7 +441,14 @@ func upgrade(cl *dockerclient.Client, stackName, recipeName, upgradeVersion stri
 
 	log.Infof("upgrade %s (%s) to version %s", stackName, recipeName, upgradeVersion)
 
-	err = stack.RunDeploy(cl, deployOpts, compose, stackName, true)
+	err = stack.RunDeploy(
+		cl,
+		deployOpts,
+		compose,
+		stackName,
+		app.Server,
+		true,
+	)
 
 	return err
 }

go.mod

@@ -8,6 +8,7 @@ require (
 	coopcloud.tech/tagcmp v0.0.0-20230809071031-eb3e7758d4eb
 	git.coopcloud.tech/toolshed/godotenv v1.5.2-0.20250103171850-4d0ca41daa5c
 	github.com/AlecAivazis/survey/v2 v2.3.7
+	github.com/charmbracelet/bubbletea v1.2.4
 	github.com/charmbracelet/lipgloss v1.0.0
 	github.com/charmbracelet/log v0.4.0
 	github.com/distribution/reference v0.6.0
@@ -18,6 +19,7 @@ require (
 	github.com/google/go-cmp v0.6.0
 	github.com/moby/sys/signal v0.7.1
 	github.com/moby/term v0.5.2
+	github.com/muesli/reflow v0.3.0
 	github.com/pkg/errors v0.9.1
 	github.com/schollz/progressbar/v3 v3.17.1
 	golang.org/x/term v0.28.0
@@ -37,6 +39,8 @@ require (
 	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/charmbracelet/x/ansi v0.6.0 // indirect
+	github.com/charmbracelet/x/exp/golden v0.0.0-20240815200342-61de596daa2b // indirect
+	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/cloudflare/circl v1.5.0 // indirect
 	github.com/containerd/log v0.1.0 // indirect
 	github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect
@@ -48,6 +52,7 @@ require (
 	github.com/docker/go-metrics v0.0.1 // indirect
 	github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/ghodss/yaml v1.0.0 // indirect
@@ -70,6 +75,7 @@ require (
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
 	github.com/miekg/pkcs11 v1.1.1 // indirect
@@ -81,6 +87,8 @@ require (
 	github.com/moby/sys/user v0.3.0 // indirect
 	github.com/moby/sys/userns v0.1.0 // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/termenv v0.15.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect

go.sum

@@ -131,19 +131,22 @@ github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInq
 github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
 github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
 github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/charmbracelet/bubbletea v1.2.4 h1:KN8aCViA0eps9SCOThb2/XPIlea3ANJLUkv3KnQRNCE=
+github.com/charmbracelet/bubbletea v1.2.4/go.mod h1:Qr6fVQw+wX7JkWWkVyXYk/ZUQ92a6XNekLXa3rR18MM=
 github.com/charmbracelet/lipgloss v1.0.0 h1:O7VkGDvqEdGi93X+DeqsQ7PKHDgtQfF8j8/O2qFMQNg=
 github.com/charmbracelet/lipgloss v1.0.0/go.mod h1:U5fy9Z+C38obMs+T+tJqst9VGzlOYGj4ri9reL3qUlo=
 github.com/charmbracelet/log v0.4.0 h1:G9bQAcx8rWA2T3pWvx7YtPTPwgqpk7D68BX21IRW8ZM=
 github.com/charmbracelet/log v0.4.0/go.mod h1:63bXt/djrizTec0l11H20t8FDSvA4CRZJ1KH22MdptM=
 github.com/charmbracelet/x/ansi v0.6.0 h1:qOznutrb93gx9oMiGf7caF7bqqubh6YIM0SWKyA08pA=
 github.com/charmbracelet/x/ansi v0.6.0/go.mod h1:KBUFw1la39nl0dLl10l5ORDAqGXaeurTQmwyyVKse/Q=
-github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a h1:G99klV19u0QnhiizODirwVksQB91TJKV/UaTnACcG30=
+github.com/charmbracelet/x/exp/golden v0.0.0-20240815200342-61de596daa2b h1:MnAMdlwSltxJyULnrYbkZpp4k58Co7Tah3ciKhSNo0Q=
-github.com/charmbracelet/x/exp/golden v0.0.0-20240806155701-69247e0abc2a/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
+github.com/charmbracelet/x/exp/golden v0.0.0-20240815200342-61de596daa2b/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
+github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
 github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw=
 github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M=
 github.com/checkpoint-restore/go-criu/v5 v5.3.0/go.mod h1:E/eQpaFtUKGOOSEBZgmKAcn+zUUwWxqcaKZlF54wK8E=
@@ -353,6 +356,8 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
 github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
 github.com/erikstmartin/go-testdb v0.0.0-20160219214506-8d10e4a1bae5/go.mod h1:a2zkGnVExMxdzMo3M0Hi/3sEU+cWnZpSni0O6/Yb/P0=
 github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
@@ -520,7 +525,6 @@ github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1 h1:VNqngBF40hVlDloBruUehVYC3ArSgIyScOAyMRqBxRg=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.25.1/go.mod h1:RBRO7fro65R6tjKzYgLAFo0t1QEXY1Dp+i/bvpRiqiQ=
@@ -625,7 +629,10 @@ github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hd
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
 github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-shellwords v1.0.3/go.mod h1:3xCvwCdWdlDJUrvuMn7Wuy9eWs4pE8vqg+NOMyg4B2o=
@@ -673,8 +680,6 @@ github.com/moby/sys/user v0.3.0/go.mod h1:bG+tYYYJgaMtRKgEmuueC0hJEAZWwtIbZTB+85
 github.com/moby/sys/userns v0.1.0 h1:tVLXkFOxVu9A64/yh59slHVv9ahO9UIev4JZusOLG/g=
 github.com/moby/sys/userns v0.1.0/go.mod h1:IHUYgu/kao6N8YZlp9Cf444ySSvCmDlmzUcYfDHOl28=
 github.com/moby/term v0.0.0-20200312100748-672ec06f55cd/go.mod h1:DdlQx2hp0Ss5/fLikoLlEeIYiATotOjgB//nb973jeo=
-github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
-github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
 github.com/moby/term v0.5.2 h1:6qk3FJAFDs6i/q3W/pQ97SX192qKfZgGjCQqfCJkgzQ=
 github.com/moby/term v0.5.2/go.mod h1:d3djjFCrjnB+fl8NJux+EJzu0msscUP+f8it8hPkFLc=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -685,6 +690,12 @@ github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjY
 github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
 github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
 github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
+github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
 github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
 github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
 github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
@@ -802,6 +813,7 @@ github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1
 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
@@ -810,7 +822,6 @@ github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6L
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
-github.com/russross/blackfriday v1.6.0 h1:KqfZb0pUVN2lYqZUYRddxF4OR8ZMURnJIG5Y3VRLtww=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -957,8 +968,6 @@ go.opentelemetry.io/otel/sdk/metric v1.33.0/go.mod h1:dL5ykHZmm1B1nVRk9dDjChwDmt
 go.opentelemetry.io/otel/trace v1.33.0 h1:cCJuF7LRjUFso9LPnEAHJDB2pqzp+hbO8eu1qqW2d/s=
 go.opentelemetry.io/otel/trace v1.33.0/go.mod h1:uIcdVUZMpTAmz0tI1z04GoVSezK37CbGV4fr1f2nBck=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.opentelemetry.io/proto/otlp v1.4.0 h1:TA9WRvW6zMwP+Ssb6fLoUIuirti1gGbP28GcKG1jgeg=
-go.opentelemetry.io/proto/otlp v1.4.0/go.mod h1:PPBWZIP98o2ElSqI35IHfu7hIhSwvc5N38Jw8pXuGFY=
 go.opentelemetry.io/proto/otlp v1.5.0 h1:xJvq7gMzB31/d406fB8U5CBdyQGw4P399D1aQWU/3i4=
 go.opentelemetry.io/proto/otlp v1.5.0/go.mod h1:keN8WnHxOy8PG0rQZjJJ5A2ebUoafqWp0eVQ4yIXvJ4=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
@@ -985,8 +994,6 @@ golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWP
 golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
-golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
 golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
@@ -999,8 +1006,6 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/exp v0.0.0-20250103183323-7d7fa50e5329 h1:9kj3STMvgqy3YA4VQXBrN7925ICMxD5wzMRcgA30588=
-golang.org/x/exp v0.0.0-20250103183323-7d7fa50e5329/go.mod h1:qj5a5QZpwLU2NLQudwIN5koi3beDhSAlJwa67PuM98c=
 golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8 h1:yqrTHse8TCMW1M1ZCP+VAR/l0kKxwaAIqN/il7x4voA=
 golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8/go.mod h1:tujkw807nyEEAamNbDrEGzRav+ilXA7PCRAd6xsmwiU=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
@@ -1068,8 +1073,6 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b
 golang.org/x/net v0.0.0-20210825183410-e898025ed96a/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
-golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
 golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
 golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -1160,6 +1163,7 @@ golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210906170528-6f6e22806c34/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -1170,15 +1174,11 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
-golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
 golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
-golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
 golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
 golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -1198,8 +1198,6 @@ golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxb
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20200630173020-3af7569d3a1e/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg=
-golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=
 golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -1247,8 +1245,6 @@ golang.org/x/tools v0.0.0-20200916195026-c9a70fc28ce3/go.mod h1:z6u4i615ZeAfBE4X
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.28.0 h1:WuB6qZ4RPCQo5aP3WdKZS7i595EdWqWR8vqJTlwTVK8=
-golang.org/x/tools v0.28.0/go.mod h1:dcIOrVd3mfQKTgrDVQHqCPMWy6lnhfhtX3hLXYVLfRw=
 golang.org/x/tools v0.29.0 h1:Xx0h3TtM9rzQpQuR4dKLrdglAmCEN5Oi+P74JdhdzXE=
 golang.org/x/tools v0.29.0/go.mod h1:KMQVMRsVxU6nHCFXrBPhDB8XncLNLM0lIy/F14RP588=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1299,12 +1295,8 @@ google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfG
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto v0.0.0-20200527145253-8367513e4ece/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
 google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto/googleapis/api v0.0.0-20250102185135-69823020774d h1:H8tOf8XM88HvKqLTxe755haY6r1fqqzLbEnfrmLXlSA=
-google.golang.org/genproto/googleapis/api v0.0.0-20250102185135-69823020774d/go.mod h1:2v7Z7gP2ZUOGsaFyxATQSRoBnKygqVq2Cwnvom7QiqY=
 google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422 h1:GVIKPyP/kLIyVOgOnTwFOrvQaQUzOzGMCxgFUOEmm24=
 google.golang.org/genproto/googleapis/api v0.0.0-20250106144421-5f5ef82da422/go.mod h1:b6h1vNKhxaSoEI+5jc3PJUCustfli/mRab7295pY7rw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250102185135-69823020774d h1:xJJRGY7TJcvIlpSrN3K6LAWgNFUILlO+OMAqtg9aqnw=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20250102185135-69823020774d/go.mod h1:3ENsm/5D1mzDyhpzeRi1NR784I0BcofWBoSc5QqqMK4=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250106144421-5f5ef82da422 h1:3UsHvIr4Wc2aW4brOaSCmcxh9ksica6fHEr8P1XhkYw=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250106144421-5f5ef82da422/go.mod h1:3ENsm/5D1mzDyhpzeRi1NR784I0BcofWBoSc5QqqMK4=
 google.golang.org/grpc v0.0.0-20160317175043-d3ddb4469d5a/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
@@ -1341,8 +1333,6 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
-google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 google.golang.org/protobuf v1.36.2 h1:R8FeyR1/eLmkutZOM5CWghmo5itiG9z0ktFlTVLuTmU=
 google.golang.org/protobuf v1.36.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
@@ -1384,7 +1374,6 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=

pkg/config/abra.go

@@ -90,6 +90,7 @@ func (a Abra) GetAbraDir() string {
 
 func (a Abra) GetServersDir() string   { return path.Join(a.GetAbraDir(), "servers") }
 func (a Abra) GetRecipesDir() string   { return path.Join(a.GetAbraDir(), "recipes") }
+func (a Abra) GetLogsDir() string      { return path.Join(a.GetAbraDir(), "logs") }
 func (a Abra) GetVendorDir() string    { return path.Join(a.GetAbraDir(), "vendor") }
 func (a Abra) GetBackupDir() string    { return path.Join(a.GetAbraDir(), "backups") }
 func (a Abra) GetCatalogueDir() string { return path.Join(a.GetAbraDir(), "catalogue") }
@@ -100,6 +101,7 @@ var (
 	ABRA_DIR                  = config.GetAbraDir()
 	SERVERS_DIR               = config.GetServersDir()
 	RECIPES_DIR               = config.GetRecipesDir()
+	LOGS_DIR                  = config.GetLogsDir()
 	VENDOR_DIR                = config.GetVendorDir()
 	BACKUP_DIR                = config.GetBackupDir()
 	CATALOGUE_DIR             = config.GetCatalogueDir()

pkg/logs/logs.go

@@ -0,0 +1,133 @@
+package logs
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"os"
+	"os/signal"
+	"slices"
+	"sync"
+
+	"github.com/docker/docker/api/types"
+	containerTypes "github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/api/types/swarm"
+	dockerClient "github.com/docker/docker/client"
+)
+
+type TailOpts struct {
+	AppName  string
+	Services []string
+	StdErr   bool
+	Since    string
+	Buffer   *bytes.Buffer
+	ToBuffer bool
+	Filters  filters.Args
+}
+
+// TailLogs gathers logs for the given app with optional service names to be
+// filtered on. These logs can be printed to os.Stdout or gathered to a buffer.
+func TailLogs(
+	cl *dockerClient.Client,
+	opts TailOpts,
+) error {
+	sigintChannel := make(chan os.Signal, 1)
+	signal.Notify(sigintChannel, os.Interrupt)
+	defer signal.Stop(sigintChannel)
+
+	f := filters.NewArgs()
+	for _, name := range opts.Services {
+		f.Add("name", name)
+	}
+
+	services, err := cl.ServiceList(
+		context.Background(),
+		types.ServiceListOptions{Filters: f},
+	)
+	if err != nil {
+		return err
+	}
+
+	waitCh := make(chan struct{})
+
+	go func() {
+		var wg sync.WaitGroup
+		for _, service := range services {
+			f := filters.NewArgs()
+			f.Add("name", service.Spec.Name)
+
+			tasks, err := cl.TaskList(context.Background(), types.TaskListOptions{Filters: f})
+			if err != nil {
+				// TODO
+				// return nil
+			}
+
+			if len(tasks) > 0 {
+				// Need to sort the tasks by the CreatedAt field in the inverse order.
+				// Otherwise they are in the reversed order and not sorted properly.
+				slices.SortFunc[[]swarm.Task](tasks, func(t1, t2 swarm.Task) int {
+					return int(t2.Meta.CreatedAt.Unix() - t1.Meta.CreatedAt.Unix())
+				})
+				lastTask := tasks[0].Status
+				if lastTask.State != swarm.TaskStateRunning {
+					// for _, task := range tasks {
+					// TODO
+					// return fmt.Errorf("[%s] %s state %s: %s", service.Spec.Name, task.Meta.CreatedAt.Format(time.RFC3339), task.Status.State, task.Status.Err)
+					// }
+				}
+			}
+
+			// Collect the logs in a go routine, so the logs from all services are
+			// collected in parallel.
+			wg.Add(1)
+			go func(serviceID string) {
+				logs, err := cl.ServiceLogs(context.Background(), serviceID, containerTypes.LogsOptions{
+					ShowStderr: true,
+					ShowStdout: !opts.StdErr,
+					Since:      opts.Since,
+					Until:      "",
+					Timestamps: true,
+					Follow:     true,
+					Tail:       "50",  // TODO: if buf, bump it up!
+					Details:    false, // TODO: if buf, yes!
+				})
+				if err != nil {
+					// TODO
+					// log.Debugf("unable to poll logs: %s", err)
+				}
+				defer logs.Close()
+
+				if opts.ToBuffer {
+					_, err = io.Copy(opts.Buffer, logs)
+					if err != nil && err != io.EOF {
+						// TODO
+						// log.Debugf("unable to copy buffer: %s", err)
+					}
+					logs.Close()
+					return
+				}
+
+				_, err = io.Copy(os.Stdout, logs)
+				if err != nil && err != io.EOF {
+					// TODO
+					// log.Debugf("unable to copy buffer: %s", err)
+				}
+				logs.Close()
+
+			}(service.ID)
+		}
+
+		wg.Wait()
+		close(waitCh)
+	}()
+
+	select {
+	case <-waitCh:
+		return nil
+	case <-sigintChannel:
+		return nil
+	}
+
+	return nil
+}

pkg/ui/deploy.go

@@ -0,0 +1,421 @@
+package ui
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"coopcloud.tech/abra/pkg/formatter"
+	"coopcloud.tech/abra/pkg/logs"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/docker/cli/cli/command/service/progress"
+	containerTypes "github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/filters"
+	dockerClient "github.com/docker/docker/client"
+	"github.com/docker/docker/pkg/jsonmessage"
+	"github.com/muesli/reflow/wordwrap"
+)
+
+type statusMsg struct {
+	stream  stream
+	jsonMsg jsonmessage.JSONMessage
+}
+
+type healthState struct {
+	log string
+}
+
+type healthcheckMsg struct {
+	stream stream
+	state  healthState
+}
+
+type progressCompleteMsg struct {
+	stream stream
+
+	// NOTE(d1): failure scenarios are as follows
+	//           an error from ServiceProgress
+	//           a rollback
+	failed bool
+}
+
+type ServiceMeta struct {
+	Name string
+	ID   string
+}
+
+type Model struct {
+	appName string
+	cl      *dockerClient.Client
+	count   int
+	ctx     context.Context
+	err     error
+	info    string
+	timeout time.Duration
+	width   int
+
+	LogsBuffer *bytes.Buffer
+
+	Streams *[]stream
+	Failed  bool
+	Timeout bool
+}
+
+func (m Model) complete() bool {
+	if m.count == len(*m.Streams) {
+		return true
+	}
+	return false
+}
+
+type stream struct {
+	decoder           *json.Decoder
+	id                string
+	reader            *io.PipeReader
+	writer            *io.PipeWriter
+	overallStatus     string
+	rollbackStatus    string
+	verifyStatus      string
+	healthcheckStatus string
+
+	Err       error
+	ErrStatus string
+	Name      string
+}
+
+func (s stream) String() string {
+	out := fmt.Sprintf("{decoder: %v, ", s.decoder)
+	out += fmt.Sprintf("err: %v, ", s.Err)
+	out += fmt.Sprintf("id: %s, ", s.id)
+	out += fmt.Sprintf("name: %s, ", s.Name)
+	out += fmt.Sprintf("reader: %v, ", s.reader)
+	out += fmt.Sprintf("writer: %v, ", s.writer)
+	out += fmt.Sprintf("overallStatus: %s, ", s.overallStatus)
+	out += fmt.Sprintf("rollbackStatus: %s, ", s.rollbackStatus)
+	out += fmt.Sprintf("verifyStatus: %s, ", s.verifyStatus)
+	out += fmt.Sprintf("errStatus: %s, ", s.ErrStatus)
+	out += fmt.Sprintf("healthcheckStatus: %s}", s.healthcheckStatus)
+	return out
+}
+
+func (s stream) progress(m Model) tea.Msg {
+	if err := progress.ServiceProgress(m.ctx, m.cl, s.id, s.writer); err != nil {
+		s.Err = err
+		return progressCompleteMsg{
+			stream: s,
+			failed: true,
+		}
+	}
+
+	return progressCompleteMsg{stream: s}
+}
+
+func (s stream) process() tea.Msg {
+	var jsonMsg jsonmessage.JSONMessage
+
+	if err := s.decoder.Decode(&jsonMsg); err != nil {
+		if err == io.EOF {
+			// NOTE(d1): end processing messages
+			return nil
+		}
+
+		s.Err = err
+	}
+
+	return statusMsg{
+		stream:  s,
+		jsonMsg: jsonMsg,
+	}
+}
+
+func (s stream) healthcheck(m Model) tea.Msg {
+	filters := filters.NewArgs()
+	filters.Add("name", fmt.Sprintf("^%s", s.Name))
+
+	containers, err := m.cl.ContainerList(m.ctx, containerTypes.ListOptions{Filters: filters})
+	if err != nil {
+		s.Err = err
+		return healthcheckMsg{stream: s}
+	}
+
+	if len(containers) == 0 {
+		return healthcheckMsg{stream: s}
+	}
+
+	container := containers[0]
+	containerState, err := m.cl.ContainerInspect(m.ctx, container.ID)
+	if err != nil {
+		s.Err = err
+		return healthcheckMsg{stream: s}
+	}
+
+	var log string
+	if containerState.State.Health != nil {
+		if len(containerState.State.Health.Log) > 0 {
+			entry := containerState.State.Health.Log[0]
+			if entry.ExitCode < 0 {
+				log = entry.Output
+			}
+		}
+
+		return healthcheckMsg{
+			stream: s,
+			state:  healthState{log: log},
+		}
+	}
+
+	return healthcheckMsg{stream: s}
+}
+
+func DeployInitialModel(
+	ctx context.Context,
+	cl *dockerClient.Client,
+	services []ServiceMeta,
+	appName string,
+	timeout time.Duration,
+) Model {
+	var streams []stream
+	for _, service := range services {
+		r, w := io.Pipe()
+		d := json.NewDecoder(r)
+		streams = append(streams, stream{
+			Name:    service.Name,
+			id:      service.ID,
+			reader:  r,
+			writer:  w,
+			decoder: d,
+		})
+	}
+
+	infoRenderer := lipgloss.NewStyle().
+		Bold(true).
+		MaxWidth(4).
+		Foreground(lipgloss.Color("86"))
+	infoMarker := infoRenderer.Render("INFO")
+
+	var logsBuffer bytes.Buffer
+
+	return Model{
+		ctx:        ctx,
+		cl:         cl,
+		appName:    appName,
+		timeout:    timeout,
+		Streams:    &streams,
+		info:       infoMarker,
+		LogsBuffer: &logsBuffer,
+	}
+}
+
+func (m Model) Init() tea.Cmd {
+	var cmds []tea.Cmd
+
+	for _, stream := range *m.Streams {
+		cmds = append(
+			cmds,
+			[]tea.Cmd{
+				func() tea.Msg { return stream.progress(m) },
+				func() tea.Msg { return stream.process() },
+				func() tea.Msg { return stream.healthcheck(m) },
+			}...,
+		)
+	}
+
+	cmds = append(cmds, func() tea.Msg { return deployTimeout(m) })
+	cmds = append(cmds, func() tea.Msg { return m.gatherLogs() })
+
+	return tea.Batch(cmds...)
+}
+
+func (m Model) gatherLogs() tea.Msg {
+	var services []string
+	for _, s := range *m.Streams {
+		services = append(services, s.Name)
+	}
+
+	opts := logs.TailOpts{
+		AppName:  m.appName,
+		Services: services,
+		StdErr:   true,
+		Buffer:   m.LogsBuffer,
+		ToBuffer: true,
+	}
+
+	if err := logs.TailLogs(m.cl, opts); err != nil {
+		// TODO
+		// log.Debugf("gatherLogs: %s", err)
+	}
+
+	return nil
+}
+
+type timeoutMsg struct{}
+
+func deployTimeout(m Model) tea.Msg {
+	<-time.After(m.timeout)
+	return timeoutMsg{}
+}
+
+func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmds []tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c", "q":
+			return m, tea.Quit
+		}
+
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+
+	case progressCompleteMsg:
+		if msg.failed {
+			m.Failed = true
+		}
+
+		m.count += 1
+
+		if m.complete() {
+			return m, tea.Quit
+		}
+
+	case healthcheckMsg:
+		if msg.state != (healthState{}) && msg.state.log != "" {
+			msg.stream.healthcheckStatus = strings.ToLower(msg.state.log)
+
+			if msg.stream.Err != nil {
+				msg.stream.ErrStatus = msg.stream.Err.Error()
+			}
+
+			for idx, s := range *m.Streams {
+				if s.id == msg.stream.id {
+					(*m.Streams)[idx].healthcheckStatus = msg.stream.healthcheckStatus
+				}
+			}
+		}
+
+		cmds = append(
+			cmds,
+			func() tea.Msg { return msg.stream.healthcheck(m) },
+		)
+
+	case timeoutMsg:
+		m.Timeout = true
+		return m, tea.Quit
+
+	case statusMsg:
+		switch msg.jsonMsg.ID {
+		case "rollback":
+			m.Failed = true
+			msg.stream.rollbackStatus = strings.ToLower(msg.jsonMsg.Status)
+		case "overall progress":
+			msg.stream.overallStatus = strings.ToLower(msg.jsonMsg.Status)
+		case "verify":
+			msg.stream.verifyStatus = strings.ToLower(msg.jsonMsg.Status)
+		}
+
+		if msg.stream.Err != nil {
+			msg.stream.ErrStatus = msg.stream.Err.Error()
+		}
+
+		for idx, s := range *m.Streams {
+			if s.id == msg.stream.id {
+				switch msg.jsonMsg.ID {
+				case "rollback":
+					(*m.Streams)[idx].rollbackStatus = msg.stream.rollbackStatus
+				case "overall progress":
+					(*m.Streams)[idx].overallStatus = msg.stream.overallStatus
+				case "verify":
+					(*m.Streams)[idx].verifyStatus = msg.stream.verifyStatus
+				}
+			}
+		}
+
+		cmds = append(
+			cmds,
+			func() tea.Msg { return msg.stream.process() },
+		)
+	}
+
+	return m, tea.Batch(cmds...)
+}
+
+func (m Model) View() string {
+	body := strings.Builder{}
+
+	for _, stream := range *m.Streams {
+		split := strings.Split(stream.Name, "_")
+		short := split[len(split)-1]
+
+		newLineSpacing := "       "
+		for range len(short) {
+			newLineSpacing += " "
+		}
+
+		output := fmt.Sprintf("%s %s: %s",
+			m.info,
+			formatter.BoldStyle.Render(short),
+			stream.overallStatus,
+		)
+
+		if stream.verifyStatus != "" {
+			output += fmt.Sprintf(" (%s)", stream.verifyStatus)
+		}
+
+		if stream.rollbackStatus != "" {
+			output += fmt.Sprintf("\n%s%s: %s",
+				newLineSpacing,
+				formatter.BoldUnderlineStyle.Render("ROLLBACK"),
+				stream.rollbackStatus,
+			)
+		}
+
+		if stream.healthcheckStatus != "" {
+			output += fmt.Sprintf("\n%s%s: %s",
+				newLineSpacing,
+				formatter.BoldUnderlineStyle.Render("HEALTHCHECK"),
+				wrapHealthstatus(m, stream, newLineSpacing),
+			)
+		}
+
+		if stream.ErrStatus != "" {
+			output += fmt.Sprintf("\n%s%s: %s",
+				newLineSpacing,
+				formatter.BoldUnderlineStyle.Render("ERROR"),
+				stream.ErrStatus,
+			)
+		}
+
+		body.WriteString(output)
+		body.WriteString("\n")
+	}
+
+	return body.String()
+}
+
+// wrapHealthstatus wraps the health check output which is mostly quite long.
+func wrapHealthstatus(m Model, s stream, newLineSpacing string) string {
+	// NOTE(d1): the spacing here represents "HEALTCHECK: ". 20 is an arbitrary
+	//           padding chosen in the hope of not overrunning horizontal space.
+	newLineSpacingWithIndent := newLineSpacing + "             "
+	firstWrap := wordwrap.String(
+		s.healthcheckStatus,
+		((m.width - len(newLineSpacingWithIndent)) - 20),
+	)
+
+	var finalWrap string
+	for idx, line := range strings.Split(firstWrap, "\n") {
+		if idx == 0 {
+			finalWrap = line
+			continue
+		}
+		finalWrap += fmt.Sprintf("\n%s%s", newLineSpacingWithIndent, line)
+	}
+
+	return finalWrap
+}

pkg/upstream/stack/remove.go

@@ -87,7 +87,7 @@ func removeServices(
 	var hasError bool
 	sort.Slice(services, sortServiceByName(services))
 	for _, service := range services {
-		log.Infof("removing service %s", service.Spec.Name)
+		log.Debugf("removing service %s", service.Spec.Name)
 		if err := client.ServiceRemove(ctx, service.ID); err != nil {
 			hasError = true
 			log.Fatalf("failed to remove service %s: %s", service.ID, err)
@@ -103,7 +103,7 @@ func removeNetworks(
 ) bool {
 	var hasError bool
 	for _, network := range networks {
-		log.Infof("removing network %s", network.Name)
+		log.Debugf("removing network %s", network.Name)
 		if err := client.NetworkRemove(ctx, network.ID); err != nil {
 			hasError = true
 			log.Fatalf("failed to remove network %s: %s", network.ID, err)
@@ -119,7 +119,7 @@ func removeSecrets(
 ) bool {
 	var hasError bool
 	for _, secret := range secrets {
-		log.Infof("removing secret %s", secret.Spec.Name)
+		log.Debugf("removing secret %s", secret.Spec.Name)
 		if err := client.SecretRemove(ctx, secret.ID); err != nil {
 			hasError = true
 			log.Fatalf("Failed to remove secret %s: %s", secret.ID, err)
@@ -135,7 +135,7 @@ func removeConfigs(
 ) bool {
 	var hasError bool
 	for _, config := range configs {
-		log.Infof("removing config %s", config.Spec.Name)
+		log.Debugf("removing config %s", config.Spec.Name)
 		if err := client.ConfigRemove(ctx, config.ID); err != nil {
 			hasError = true
 			log.Fatalf("failed to remove config %s: %s", config.ID, err)

pkg/upstream/stack/stack.go

@@ -3,20 +3,20 @@ package stack // https://github.com/docker/cli/blob/master/cli/command/stack/swa
 import (
 	"context"
 	"fmt"
-	"io"
-	"io/ioutil"
 	"os"
-	"os/signal"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
 
 	stdlibErr "errors"
 
+	tea "github.com/charmbracelet/bubbletea"
+
 	"coopcloud.tech/abra/pkg/config"
 	"coopcloud.tech/abra/pkg/log"
+	"coopcloud.tech/abra/pkg/ui"
 	"coopcloud.tech/abra/pkg/upstream/convert"
-	"github.com/docker/cli/cli/command/service/progress"
 	"github.com/docker/cli/cli/command/stack/formatter"
 	composetypes "github.com/docker/cli/cli/compose/types"
 	"github.com/docker/docker/api/types"
@@ -176,7 +176,7 @@ func IsDeployed(ctx context.Context, cl *dockerClient.Client, stackName string)
 func pruneServices(ctx context.Context, cl *dockerClient.Client, namespace convert.Namespace, services map[string]struct{}) {
 	oldServices, err := GetStackServices(ctx, cl, namespace.Name())
 	if err != nil {
-		log.Infof("failed to list services: %s", err)
+		log.Warnf("failed to list services: %s", err)
 	}
 
 	pruneServices := []swarm.Service{}
@@ -190,7 +190,16 @@ func pruneServices(ctx context.Context, cl *dockerClient.Client, namespace conve
 }
 
 // RunDeploy is the swarm implementation of docker stack deploy
-func RunDeploy(cl *dockerClient.Client, opts Deploy, cfg *composetypes.Config, appName string, dontWait bool) error {
+func RunDeploy(
+	cl *dockerClient.Client,
+	opts Deploy,
+	cfg *composetypes.Config,
+	appName string,
+	serverName string,
+	dontWait bool,
+) error {
+	log.Info("initialising deployment")
+
 	if err := validateResolveImageFlag(&opts); err != nil {
 		return err
 	}
@@ -200,7 +209,7 @@ func RunDeploy(cl *dockerClient.Client, opts Deploy, cfg *composetypes.Config, a
 		opts.ResolveImage = ResolveImageNever
 	}
 
-	return deployCompose(context.Background(), cl, opts, cfg, appName, dontWait)
+	return deployCompose(context.Background(), cl, opts, cfg, appName, serverName, dontWait)
 }
 
 // validateResolveImageFlag validates the opts.resolveImage command line option
@@ -213,7 +222,15 @@ func validateResolveImageFlag(opts *Deploy) error {
 	}
 }
 
-func deployCompose(ctx context.Context, cl *dockerClient.Client, opts Deploy, config *composetypes.Config, appName string, dontWait bool) error {
+func deployCompose(
+	ctx context.Context,
+	cl *dockerClient.Client,
+	opts Deploy,
+	config *composetypes.Config,
+	appName string,
+	serverName string,
+	dontWait bool,
+) error {
 	namespace := convert.NewNamespace(opts.Namespace)
 
 	if opts.Prune {
@@ -254,7 +271,14 @@ func deployCompose(ctx context.Context, cl *dockerClient.Client, opts Deploy, co
 		return err
 	}
 
-	serviceIDs, err := deployServices(ctx, cl, services, namespace, opts.SendRegistryAuth, opts.ResolveImage)
+	serviceIDs, err := deployServices(
+		ctx,
+		cl,
+		services,
+		namespace,
+		opts.SendRegistryAuth,
+		opts.ResolveImage,
+	)
 	if err != nil {
 		return err
 	}
@@ -264,14 +288,16 @@ func deployCompose(ctx context.Context, cl *dockerClient.Client, opts Deploy, co
 		return nil
 	}
 
-	log.Infof("waiting for %s to deploy... please hold 🤚", appName)
+	if err := WaitOnServices(
-
+		ctx,
-	if err := waitOnServices(ctx, cl, serviceIDs, appName); err != nil {
+		cl,
+		serviceIDs,
+		appName,
+		serverName,
+	); err != nil {
 		return err
 	}
 
-	log.Infof("successfully deployed %s", appName)
-
 	return nil
 }
 
@@ -342,7 +368,7 @@ func createConfigs(ctx context.Context, cl *dockerClient.Client, configs []swarm
 			}
 		case dockerClient.IsErrNotFound(err):
 			// config does not exist, then we create a new one.
-			log.Infof("creating config %s", configSpec.Name)
+			log.Debugf("creating config %s", configSpec.Name)
 			if _, err := cl.ConfigCreate(ctx, configSpec); err != nil {
 				return errors.Wrapf(err, "failed to create config %s", configSpec.Name)
 			}
@@ -373,7 +399,7 @@ func createNetworks(ctx context.Context, cl *dockerClient.Client, namespace conv
 			createOpts.Driver = defaultNetworkDriver
 		}
 
-		log.Infof("creating network %s", name)
+		log.Debugf("creating network %s", name)
 		if _, err := cl.NetworkCreate(ctx, name, createOpts); err != nil {
 			return errors.Wrapf(err, "failed to create network %s", name)
 		}
@@ -387,10 +413,12 @@ func deployServices(
 	services map[string]swarm.ServiceSpec,
 	namespace convert.Namespace,
 	sendAuth bool,
-	resolveImage string) ([]string, error) {
+	resolveImage string) ([]ui.ServiceMeta, error) {
+	var servicesMeta []ui.ServiceMeta
+
 	existingServices, err := GetStackServices(ctx, cl, namespace.Name())
 	if err != nil {
-		return nil, err
+		return servicesMeta, err
 	}
 
 	existingServiceMap := make(map[string]swarm.Service)
@@ -398,8 +426,6 @@ func deployServices(
 		existingServiceMap[service.Spec.Name] = service
 	}
 
-	var serviceIDs []string
-
 	for internalName, serviceSpec := range services {
 		var (
 			name        = namespace.Scope(internalName)
@@ -408,7 +434,7 @@ func deployServices(
 		)
 
 		if service, exists := existingServiceMap[name]; exists {
-			log.Infof("updating %s", name)
+			log.Debugf("updating %s", name)
 
 			updateOpts := types.ServiceUpdateOptions{EncodedRegistryAuth: encodedAuth}
 
@@ -450,9 +476,12 @@ func deployServices(
 				log.Warn(warning)
 			}
 
-			serviceIDs = append(serviceIDs, service.ID)
+			servicesMeta = append(servicesMeta, ui.ServiceMeta{
+				Name: name,
+				ID:   service.ID,
+			})
 		} else {
-			log.Infof("creating %s", name)
+			log.Debugf("creating %s", name)
 
 			createOpts := types.ServiceCreateOptions{EncodedRegistryAuth: encodedAuth}
 
@@ -466,11 +495,14 @@ func deployServices(
 				return nil, errors.Wrapf(err, "failed to create %s", name)
 			}
 
-			serviceIDs = append(serviceIDs, serviceCreateResponse.ID)
+			servicesMeta = append(servicesMeta, ui.ServiceMeta{
+				Name: name,
+				ID:   serviceCreateResponse.ID,
+			})
 		}
 	}
 
-	return serviceIDs, nil
+	return servicesMeta, nil
 }
 
 func getStackNetworks(ctx context.Context, dockerclient client.APIClient, namespace string) ([]types.NetworkResource, error) {
@@ -485,69 +517,72 @@ func getStackConfigs(ctx context.Context, dockerclient client.APIClient, namespa
 	return dockerclient.ConfigList(ctx, types.ConfigListOptions{Filters: getStackFilter(namespace)})
 }
 
-func waitOnServices(ctx context.Context, cl *dockerClient.Client, serviceIDs []string, appName string) error {
+func timestamp() string {
+	ts := time.Now().UTC().Format(time.RFC3339)
+	return strings.Replace(ts, ":", "", -1) // get rid of offensive colons
+}
+
+func WaitOnServices(
+	ctx context.Context,
+	cl *dockerClient.Client,
+	services []ui.ServiceMeta,
+	appName string,
+	serverName string,
+) error {
+	log.Info("polling deployment status")
+
+	timeout := time.Duration(WaitTimeout) * time.Second
+	model := ui.DeployInitialModel(ctx, cl, services, appName, timeout)
+	tui := tea.NewProgram(model)
+
+	m, err := tui.Run()
+	if err != nil {
+		return err
+	}
+
+	deployModel := m.(ui.Model)
+
+	logsPath := filepath.Join(
+		config.LOGS_DIR,
+		serverName,
+		fmt.Sprintf("%s_%s", appName, timestamp()),
+	)
+
+	if err := os.MkdirAll(filepath.Join(config.LOGS_DIR, serverName), 0644); err != nil {
+		// TODO
+		log.Fatalf("MkdirAll: %s", err)
+	}
+
+	if deployModel.Timeout {
+		if err := os.WriteFile(logsPath, deployModel.LogsBuffer.Bytes(), 0644); err != nil {
+			// TODO
+			log.Fatalf("WriteFile: %s", err)
+		}
+		return fmt.Errorf("deployment timed out, logs in %s", logsPath)
+	}
+
+	if deployModel.Failed {
 		var errs []error
 
-	for _, serviceID := range serviceIDs {
+		for _, s := range *deployModel.Streams {
-		if err := WaitOnService(ctx, cl, serviceID, appName); err != nil {
+			if s.Err != nil {
-			errs = append(errs, fmt.Errorf("%s: %w", serviceID, err))
+				errs = append(errs, fmt.Errorf("%s: %s", s.Name, s.ErrStatus))
 			}
 		}
 
-	if len(errs) > 0 {
+		if err := os.WriteFile(logsPath, deployModel.LogsBuffer.Bytes(), 0644); err != nil {
+			// TODO
+			log.Fatalf("WriteFile: %s", err)
+		}
+
+		errs = append(errs, fmt.Errorf("deployment failed, logs in %s", logsPath))
+
 		return stdlibErr.Join(errs...)
 	}
 
 	return nil
 }
 
-// https://github.com/docker/cli/blob/master/cli/command/service/helpers.go
-// https://github.com/docker/cli/blob/master/cli/command/service/progress/progress.go
-func WaitOnService(ctx context.Context, cl *dockerClient.Client, serviceID, appName string) error {
-	errChan := make(chan error, 1)
-	pipeReader, pipeWriter := io.Pipe()
-
-	sigintChannel := make(chan os.Signal, 1)
-	signal.Notify(sigintChannel, os.Interrupt)
-	defer signal.Stop(sigintChannel)
-
-	go func() {
-		errChan <- progress.ServiceProgress(ctx, cl, serviceID, pipeWriter)
-	}()
-
-	go io.Copy(ioutil.Discard, pipeReader)
-
-	timeout := time.Duration(WaitTimeout) * time.Second
-
-	select {
-	case err := <-errChan:
-		return err
-	case <-sigintChannel:
-		return fmt.Errorf(`
-Not waiting for %s to deploy. The deployment is ongoing...
-
-If you want to stop the deployment, try:
-
-    abra app undeploy %s`, appName, appName)
-	case <-time.After(timeout):
-		return fmt.Errorf(`
-%s has not converged (%s second timeout reached).
-
-This does not necessarily mean your deployment has failed, it may just be that
-the app is taking longer to deploy based on your server resources or network
-latency.
-
-You can track latest deployment status with:
-
-    abra app ps %s
-
-And inspect the logs with:
-
-    abra app logs %s
-`, appName, timeout, appName, appName)
-	}
-}
-
 // Copypasta from https://github.com/docker/cli/blob/master/cli/command/stack/swarm/list.go
 // GetStacks lists the swarm stacks.
 func GetStacks(cl *dockerClient.Client) ([]*formatter.Stack, error) {

vendor/github.com/charmbracelet/bubbletea/.gitattributes

@@ -0,0 +1 @@
+*.golden -text

vendor/github.com/charmbracelet/bubbletea/.gitignore

@@ -0,0 +1,23 @@
+.DS_Store
+.envrc
+
+examples/fullscreen/fullscreen
+examples/help/help
+examples/http/http
+examples/list-default/list-default
+examples/list-fancy/list-fancy
+examples/list-simple/list-simple
+examples/mouse/mouse
+examples/pager/pager
+examples/progress-download/color_vortex.blend
+examples/progress-download/progress-download
+examples/simple/simple
+examples/spinner/spinner
+examples/textinput/textinput
+examples/textinputs/textinputs
+examples/views/views
+tutorials/basics/basics
+tutorials/commands/commands
+.idea
+coverage.txt
+dist/

vendor/github.com/charmbracelet/bubbletea/.golangci-soft.yml

@@ -0,0 +1,40 @@
+run:
+  tests: false
+  issues-exit-code: 0
+
+issues:
+  include:
+    - EXC0001
+    - EXC0005
+    - EXC0011
+    - EXC0012
+    - EXC0013
+
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+linters:
+  enable:
+    - exhaustive
+    - goconst
+    - godot
+    - godox
+    - mnd
+    - gomoddirectives
+    - goprintffuncname
+    - misspell
+    - nakedret
+    - nestif
+    - noctx
+    - nolintlint
+    - prealloc
+    - wrapcheck
+
+  # disable default linters, they are already enabled in .golangci.yml
+  disable:
+    - errcheck
+    - gosimple
+    - govet
+    - ineffassign
+    - staticcheck
+    - unused

vendor/github.com/charmbracelet/bubbletea/.golangci.yml

@@ -0,0 +1,28 @@
+run:
+  tests: false
+
+issues:
+  include:
+    - EXC0001
+    - EXC0005
+    - EXC0011
+    - EXC0012
+    - EXC0013
+
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+linters:
+  enable:
+    - bodyclose
+    - gofumpt
+    - goimports
+    - gosec
+    - nilerr
+    - revive
+    - rowserrcheck
+    - sqlclosecheck
+    - tparallel
+    - unconvert
+    - unparam
+    - whitespace

vendor/github.com/charmbracelet/bubbletea/.goreleaser.yml

@@ -0,0 +1,5 @@
+# yaml-language-server: $schema=https://goreleaser.com/static/schema-pro.json
+version: 2
+includes:
+  - from_url:
+      url: charmbracelet/meta/main/goreleaser-lib.yaml

vendor/github.com/charmbracelet/bubbletea/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Charmbracelet, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/charmbracelet/bubbletea/README.md

@@ -0,0 +1,393 @@
+# Bubble Tea
+
+<p>
+    <a href="https://stuff.charm.sh/bubbletea/bubbletea-4k.png"><img src="https://github.com/charmbracelet/bubbletea/assets/25087/108d4fdb-d554-4910-abed-2a5f5586a60e" width="313" alt="Bubble Tea Title Treatment"></a><br>
+    <a href="https://github.com/charmbracelet/bubbletea/releases"><img src="https://img.shields.io/github/release/charmbracelet/bubbletea.svg" alt="Latest Release"></a>
+    <a href="https://pkg.go.dev/github.com/charmbracelet/bubbletea?tab=doc"><img src="https://godoc.org/github.com/charmbracelet/bubbletea?status.svg" alt="GoDoc"></a>
+    <a href="https://github.com/charmbracelet/bubbletea/actions"><img src="https://github.com/charmbracelet/bubbletea/actions/workflows/build.yml/badge.svg" alt="Build Status"></a>
+    <a href="https://www.phorm.ai/query?projectId=a0e324b6-b706-4546-b951-6671ea60c13f"><img src="https://stuff.charm.sh/misc/phorm-badge.svg" alt="phorm.ai"></a>
+</p>
+
+The fun, functional and stateful way to build terminal apps. A Go framework
+based on [The Elm Architecture][elm]. Bubble Tea is well-suited for simple and
+complex terminal applications, either inline, full-window, or a mix of both.
+
+<p>
+    <img src="https://stuff.charm.sh/bubbletea/bubbletea-example.gif" width="100%" alt="Bubble Tea Example">
+</p>
+
+Bubble Tea is in use in production and includes a number of features and
+performance optimizations we’ve added along the way. Among those is a standard
+framerate-based renderer, a renderer for high-performance scrollable
+regions which works alongside the main renderer, and mouse support.
+
+To get started, see the tutorial below, the [examples][examples], the
+[docs][docs], the [video tutorials][youtube] and some common [resources](#libraries-we-use-with-bubble-tea).
+
+[youtube]: https://charm.sh/yt
+
+## By the way
+
+Be sure to check out [Bubbles][bubbles], a library of common UI components for Bubble Tea.
+
+<p>
+    <a href="https://github.com/charmbracelet/bubbles"><img src="https://stuff.charm.sh/bubbles/bubbles-badge.png" width="174" alt="Bubbles Badge"></a>&nbsp;&nbsp;
+    <a href="https://github.com/charmbracelet/bubbles"><img src="https://stuff.charm.sh/bubbles-examples/textinput.gif" width="400" alt="Text Input Example from Bubbles"></a>
+</p>
+
+---
+
+## Tutorial
+
+Bubble Tea is based on the functional design paradigms of [The Elm
+Architecture][elm], which happens to work nicely with Go. It's a delightful way
+to build applications.
+
+This tutorial assumes you have a working knowledge of Go.
+
+By the way, the non-annotated source code for this program is available
+[on GitHub][tut-source].
+
+[elm]: https://guide.elm-lang.org/architecture/
+[tut-source]: https://github.com/charmbracelet/bubbletea/tree/master/tutorials/basics
+
+### Enough! Let's get to it.
+
+For this tutorial, we're making a shopping list.
+
+To start we'll define our package and import some libraries. Our only external
+import will be the Bubble Tea library, which we'll call `tea` for short.
+
+```go
+package main
+
+import (
+    "fmt"
+    "os"
+
+    tea "github.com/charmbracelet/bubbletea"
+)
+```
+
+Bubble Tea programs are comprised of a **model** that describes the application
+state and three simple methods on that model:
+
+- **Init**, a function that returns an initial command for the application to run.
+- **Update**, a function that handles incoming events and updates the model accordingly.
+- **View**, a function that renders the UI based on the data in the model.
+
+### The Model
+
+So let's start by defining our model which will store our application's state.
+It can be any type, but a `struct` usually makes the most sense.
+
+```go
+type model struct {
+    choices  []string           // items on the to-do list
+    cursor   int                // which to-do list item our cursor is pointing at
+    selected map[int]struct{}   // which to-do items are selected
+}
+```
+
+### Initialization
+
+Next, we’ll define our application’s initial state. In this case, we’re defining
+a function to return our initial model, however, we could just as easily define
+the initial model as a variable elsewhere, too.
+
+```go
+func initialModel() model {
+	return model{
+		// Our to-do list is a grocery list
+		choices:  []string{"Buy carrots", "Buy celery", "Buy kohlrabi"},
+
+		// A map which indicates which choices are selected. We're using
+		// the  map like a mathematical set. The keys refer to the indexes
+		// of the `choices` slice, above.
+		selected: make(map[int]struct{}),
+	}
+}
+```
+
+Next, we define the `Init` method. `Init` can return a `Cmd` that could perform
+some initial I/O. For now, we don't need to do any I/O, so for the command,
+we'll just return `nil`, which translates to "no command."
+
+```go
+func (m model) Init() tea.Cmd {
+    // Just return `nil`, which means "no I/O right now, please."
+    return nil
+}
+```
+
+### The Update Method
+
+Next up is the update method. The update function is called when ”things
+happen.” Its job is to look at what has happened and return an updated model in
+response. It can also return a `Cmd` to make more things happen, but for now
+don't worry about that part.
+
+In our case, when a user presses the down arrow, `Update`’s job is to notice
+that the down arrow was pressed and move the cursor accordingly (or not).
+
+The “something happened” comes in the form of a `Msg`, which can be any type.
+Messages are the result of some I/O that took place, such as a keypress, timer
+tick, or a response from a server.
+
+We usually figure out which type of `Msg` we received with a type switch, but
+you could also use a type assertion.
+
+For now, we'll just deal with `tea.KeyMsg` messages, which are automatically
+sent to the update function when keys are pressed.
+
+```go
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+    switch msg := msg.(type) {
+
+    // Is it a key press?
+    case tea.KeyMsg:
+
+        // Cool, what was the actual key pressed?
+        switch msg.String() {
+
+        // These keys should exit the program.
+        case "ctrl+c", "q":
+            return m, tea.Quit
+
+        // The "up" and "k" keys move the cursor up
+        case "up", "k":
+            if m.cursor > 0 {
+                m.cursor--
+            }
+
+        // The "down" and "j" keys move the cursor down
+        case "down", "j":
+            if m.cursor < len(m.choices)-1 {
+                m.cursor++
+            }
+
+        // The "enter" key and the spacebar (a literal space) toggle
+        // the selected state for the item that the cursor is pointing at.
+        case "enter", " ":
+            _, ok := m.selected[m.cursor]
+            if ok {
+                delete(m.selected, m.cursor)
+            } else {
+                m.selected[m.cursor] = struct{}{}
+            }
+        }
+    }
+
+    // Return the updated model to the Bubble Tea runtime for processing.
+    // Note that we're not returning a command.
+    return m, nil
+}
+```
+
+You may have noticed that <kbd>ctrl+c</kbd> and <kbd>q</kbd> above return
+a `tea.Quit` command with the model. That’s a special command which instructs
+the Bubble Tea runtime to quit, exiting the program.
+
+### The View Method
+
+At last, it’s time to render our UI. Of all the methods, the view is the
+simplest. We look at the model in its current state and use it to return
+a `string`. That string is our UI!
+
+Because the view describes the entire UI of your application, you don’t have to
+worry about redrawing logic and stuff like that. Bubble Tea takes care of it
+for you.
+
+```go
+func (m model) View() string {
+    // The header
+    s := "What should we buy at the market?\n\n"
+
+    // Iterate over our choices
+    for i, choice := range m.choices {
+
+        // Is the cursor pointing at this choice?
+        cursor := " " // no cursor
+        if m.cursor == i {
+            cursor = ">" // cursor!
+        }
+
+        // Is this choice selected?
+        checked := " " // not selected
+        if _, ok := m.selected[i]; ok {
+            checked = "x" // selected!
+        }
+
+        // Render the row
+        s += fmt.Sprintf("%s [%s] %s\n", cursor, checked, choice)
+    }
+
+    // The footer
+    s += "\nPress q to quit.\n"
+
+    // Send the UI for rendering
+    return s
+}
+```
+
+### All Together Now
+
+The last step is to simply run our program. We pass our initial model to
+`tea.NewProgram` and let it rip:
+
+```go
+func main() {
+    p := tea.NewProgram(initialModel())
+    if _, err := p.Run(); err != nil {
+        fmt.Printf("Alas, there's been an error: %v", err)
+        os.Exit(1)
+    }
+}
+```
+
+## What’s Next?
+
+This tutorial covers the basics of building an interactive terminal UI, but
+in the real world you'll also need to perform I/O. To learn about that have a
+look at the [Command Tutorial][cmd]. It's pretty simple.
+
+There are also several [Bubble Tea examples][examples] available and, of course,
+there are [Go Docs][docs].
+
+[cmd]: https://github.com/charmbracelet/bubbletea/tree/master/tutorials/commands/
+[examples]: https://github.com/charmbracelet/bubbletea/tree/master/examples
+[docs]: https://pkg.go.dev/github.com/charmbracelet/bubbletea?tab=doc
+
+## Debugging
+
+### Debugging with Delve
+
+Since Bubble Tea apps assume control of stdin and stdout, you’ll need to run
+delve in headless mode and then connect to it:
+
+```bash
+# Start the debugger
+$ dlv debug --headless --api-version=2 --listen=127.0.0.1:43000 .
+API server listening at: 127.0.0.1:43000
+
+# Connect to it from another terminal
+$ dlv connect 127.0.0.1:43000
+```
+
+If you do not explicitly supply the `--listen` flag, the port used will vary
+per run, so passing this in makes the debugger easier to use from a script
+or your IDE of choice.
+
+Additionally, we pass in `--api-version=2` because delve defaults to version 1
+for backwards compatibility reasons. However, delve recommends using version 2
+for all new development and some clients may no longer work with version 1.
+For more information, see the [Delve documentation](https://github.com/go-delve/delve/tree/master/Documentation/api).
+
+### Logging Stuff
+
+You can’t really log to stdout with Bubble Tea because your TUI is busy
+occupying that! You can, however, log to a file by including something like
+the following prior to starting your Bubble Tea program:
+
+```go
+if len(os.Getenv("DEBUG")) > 0 {
+	f, err := tea.LogToFile("debug.log", "debug")
+	if err != nil {
+		fmt.Println("fatal:", err)
+		os.Exit(1)
+	}
+	defer f.Close()
+}
+```
+
+To see what’s being logged in real time, run `tail -f debug.log` while you run
+your program in another window.
+
+## Libraries we use with Bubble Tea
+
+- [Bubbles][bubbles]: Common Bubble Tea components such as text inputs, viewports, spinners and so on
+- [Lip Gloss][lipgloss]: Style, format and layout tools for terminal applications
+- [Harmonica][harmonica]: A spring animation library for smooth, natural motion
+- [BubbleZone][bubblezone]: Easy mouse event tracking for Bubble Tea components
+- [ntcharts][ntcharts]: A terminal charting library built for Bubble Tea and [Lip Gloss][lipgloss]
+- [Termenv][termenv]: Advanced ANSI styling for terminal applications
+- [Reflow][reflow]: Advanced ANSI-aware methods for working with text
+
+[bubbles]: https://github.com/charmbracelet/bubbles
+[lipgloss]: https://github.com/charmbracelet/lipgloss
+[harmonica]: https://github.com/charmbracelet/harmonica
+[bubblezone]: https://github.com/lrstanley/bubblezone
+[ntcharts]: https://github.com/NimbleMarkets/ntcharts
+[termenv]: https://github.com/muesli/termenv
+[reflow]: https://github.com/muesli/reflow
+
+## Bubble Tea in the Wild
+
+There are over 8k applications built with Bubble Tea! Here are a handful of ’em.
+
+### Staff favourites
+
+- [chezmoi](https://github.com/twpayne/chezmoi): securely manage your dotfiles across multiple machines
+- [circumflex](https://github.com/bensadeh/circumflex): read Hacker News in the terminal
+- [gh-dash](https://www.github.com/dlvhdr/gh-dash): a GitHub CLI extension for PRs and issues
+- [Tetrigo](https://github.com/Broderick-Westrope/tetrigo): Tetris in the terminal
+
+### In Industry
+
+- Microsoft Azure – [Aztify](https://github.com/Azure/aztfy): bring Microsoft Azure resources under Terraform
+- Daytona – [Daytona](https://github.com/daytonaio/daytona): open source dev environment manager
+- Truffle Security Co. – [Trufflehog](https://github.com/trufflesecurity/trufflehog): find leaked credentials
+- NVIDIA – [container-canary](https://github.com/NVIDIA/container-canary) from NVIDIA: a container validator
+- AWS – [eks-node-viewer](https://github.com/awslabs/eks-node-viewer) from AWS: a tool for visualizing dynamic node usage within an EKS cluster
+- MinIO – [mc](https://github.com/minio/mc) from Min.io: the official [MinIO](https://min.io) client
+
+### Charm stuff
+
+- [Glow](https://github.com/charmbracelet/glow): a markdown reader, browser, and online markdown stash
+- [Huh?](https://github.com/charmbracelet/huh): an interactive prompt and form toolkit
+- [Mods](https://github.com/charmbracelet/mods): AI on the CLI, built for pipelines
+- [Wishlist](https://github.com/charmbracelet/wishlist): an SSH directory (and bastion!)
+
+### There’s so much more where that came from
+
+For more applications built with Bubble Tea see [Charm & Friends][community].
+Is there something cool you made with Bubble Tea you want to share? [PRs][community] are
+welcome!
+
+## Contributing
+
+See [contributing][contribute].
+
+[contribute]: https://github.com/charmbracelet/bubbletea/contribute
+
+## Feedback
+
+We’d love to hear your thoughts on this project. Feel free to drop us a note!
+
+- [Twitter](https://twitter.com/charmcli)
+- [The Fediverse](https://mastodon.social/@charmcli)
+- [Discord](https://charm.sh/chat)
+
+## Acknowledgments
+
+Bubble Tea is based on the paradigms of [The Elm Architecture][elm] by Evan
+Czaplicki et alia and the excellent [go-tea][gotea] by TJ Holowaychuk. It’s
+inspired by the many great [_Zeichenorientierte Benutzerschnittstellen_][zb]
+of days past.
+
+[elm]: https://guide.elm-lang.org/architecture/
+[gotea]: https://github.com/tj/go-tea
+[zb]: https://de.wikipedia.org/wiki/Zeichenorientierte_Benutzerschnittstelle
+[community]: https://github.com/charm-and-friends/charm-in-the-wild
+
+## License
+
+[MIT](https://github.com/charmbracelet/bubbletea/raw/master/LICENSE)
+
+---
+
+Part of [Charm](https://charm.sh).
+
+<a href="https://charm.sh/"><img alt="The Charm logo" src="https://stuff.charm.sh/charm-badge.jpg" width="400"></a>
+
+Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة

vendor/github.com/charmbracelet/bubbletea/commands.go

@@ -0,0 +1,216 @@
+package tea
+
+import (
+	"time"
+)
+
+// Batch performs a bunch of commands concurrently with no ordering guarantees
+// about the results. Use a Batch to return several commands.
+//
+// Example:
+//
+//	    func (m model) Init() Cmd {
+//		       return tea.Batch(someCommand, someOtherCommand)
+//	    }
+func Batch(cmds ...Cmd) Cmd {
+	var validCmds []Cmd //nolint:prealloc
+	for _, c := range cmds {
+		if c == nil {
+			continue
+		}
+		validCmds = append(validCmds, c)
+	}
+	switch len(validCmds) {
+	case 0:
+		return nil
+	case 1:
+		return validCmds[0]
+	default:
+		return func() Msg {
+			return BatchMsg(validCmds)
+		}
+	}
+}
+
+// BatchMsg is a message used to perform a bunch of commands concurrently with
+// no ordering guarantees. You can send a BatchMsg with Batch.
+type BatchMsg []Cmd
+
+// Sequence runs the given commands one at a time, in order. Contrast this with
+// Batch, which runs commands concurrently.
+func Sequence(cmds ...Cmd) Cmd {
+	return func() Msg {
+		return sequenceMsg(cmds)
+	}
+}
+
+// sequenceMsg is used internally to run the given commands in order.
+type sequenceMsg []Cmd
+
+// Every is a command that ticks in sync with the system clock. So, if you
+// wanted to tick with the system clock every second, minute or hour you
+// could use this. It's also handy for having different things tick in sync.
+//
+// Because we're ticking with the system clock the tick will likely not run for
+// the entire specified duration. For example, if we're ticking for one minute
+// and the clock is at 12:34:20 then the next tick will happen at 12:35:00, 40
+// seconds later.
+//
+// To produce the command, pass a duration and a function which returns
+// a message containing the time at which the tick occurred.
+//
+//	type TickMsg time.Time
+//
+//	cmd := Every(time.Second, func(t time.Time) Msg {
+//	   return TickMsg(t)
+//	})
+//
+// Beginners' note: Every sends a single message and won't automatically
+// dispatch messages at an interval. To do that, you'll want to return another
+// Every command after receiving your tick message. For example:
+//
+//	type TickMsg time.Time
+//
+//	// Send a message every second.
+//	func tickEvery() Cmd {
+//	    return Every(time.Second, func(t time.Time) Msg {
+//	        return TickMsg(t)
+//	    })
+//	}
+//
+//	func (m model) Init() Cmd {
+//	    // Start ticking.
+//	    return tickEvery()
+//	}
+//
+//	func (m model) Update(msg Msg) (Model, Cmd) {
+//	    switch msg.(type) {
+//	    case TickMsg:
+//	        // Return your Every command again to loop.
+//	        return m, tickEvery()
+//	    }
+//	    return m, nil
+//	}
+//
+// Every is analogous to Tick in the Elm Architecture.
+func Every(duration time.Duration, fn func(time.Time) Msg) Cmd {
+	n := time.Now()
+	d := n.Truncate(duration).Add(duration).Sub(n)
+	t := time.NewTimer(d)
+	return func() Msg {
+		ts := <-t.C
+		t.Stop()
+		for len(t.C) > 0 {
+			<-t.C
+		}
+		return fn(ts)
+	}
+}
+
+// Tick produces a command at an interval independent of the system clock at
+// the given duration. That is, the timer begins precisely when invoked,
+// and runs for its entire duration.
+//
+// To produce the command, pass a duration and a function which returns
+// a message containing the time at which the tick occurred.
+//
+//	type TickMsg time.Time
+//
+//	cmd := Tick(time.Second, func(t time.Time) Msg {
+//	   return TickMsg(t)
+//	})
+//
+// Beginners' note: Tick sends a single message and won't automatically
+// dispatch messages at an interval. To do that, you'll want to return another
+// Tick command after receiving your tick message. For example:
+//
+//	type TickMsg time.Time
+//
+//	func doTick() Cmd {
+//	    return Tick(time.Second, func(t time.Time) Msg {
+//	        return TickMsg(t)
+//	    })
+//	}
+//
+//	func (m model) Init() Cmd {
+//	    // Start ticking.
+//	    return doTick()
+//	}
+//
+//	func (m model) Update(msg Msg) (Model, Cmd) {
+//	    switch msg.(type) {
+//	    case TickMsg:
+//	        // Return your Tick command again to loop.
+//	        return m, doTick()
+//	    }
+//	    return m, nil
+//	}
+func Tick(d time.Duration, fn func(time.Time) Msg) Cmd {
+	t := time.NewTimer(d)
+	return func() Msg {
+		ts := <-t.C
+		t.Stop()
+		for len(t.C) > 0 {
+			<-t.C
+		}
+		return fn(ts)
+	}
+}
+
+// Sequentially produces a command that sequentially executes the given
+// commands.
+// The Msg returned is the first non-nil message returned by a Cmd.
+//
+//	func saveStateCmd() Msg {
+//	   if err := save(); err != nil {
+//	       return errMsg{err}
+//	   }
+//	   return nil
+//	}
+//
+//	cmd := Sequentially(saveStateCmd, Quit)
+//
+// Deprecated: use Sequence instead.
+func Sequentially(cmds ...Cmd) Cmd {
+	return func() Msg {
+		for _, cmd := range cmds {
+			if cmd == nil {
+				continue
+			}
+			if msg := cmd(); msg != nil {
+				return msg
+			}
+		}
+		return nil
+	}
+}
+
+// setWindowTitleMsg is an internal message used to set the window title.
+type setWindowTitleMsg string
+
+// SetWindowTitle produces a command that sets the terminal title.
+//
+// For example:
+//
+//	func (m model) Init() Cmd {
+//	    // Set title.
+//	    return tea.SetWindowTitle("My App")
+//	}
+func SetWindowTitle(title string) Cmd {
+	return func() Msg {
+		return setWindowTitleMsg(title)
+	}
+}
+
+type windowSizeMsg struct{}
+
+// WindowSize is a command that queries the terminal for its current size. It
+// delivers the results to Update via a [WindowSizeMsg]. Keep in mind that
+// WindowSizeMsgs will automatically be delivered to Update when the [Program]
+// starts and when the window dimensions change so in many cases you will not
+// need to explicitly invoke this command.
+func WindowSize() Cmd {
+	return func() Msg {
+		return windowSizeMsg{}
+	}
+}

vendor/github.com/charmbracelet/bubbletea/exec.go

@@ -0,0 +1,129 @@
+package tea
+
+import (
+	"io"
+	"os"
+	"os/exec"
+)
+
+// execMsg is used internally to run an ExecCommand sent with Exec.
+type execMsg struct {
+	cmd ExecCommand
+	fn  ExecCallback
+}
+
+// Exec is used to perform arbitrary I/O in a blocking fashion, effectively
+// pausing the Program while execution is running and resuming it when
+// execution has completed.
+//
+// Most of the time you'll want to use ExecProcess, which runs an exec.Cmd.
+//
+// For non-interactive i/o you should use a Cmd (that is, a tea.Cmd).
+func Exec(c ExecCommand, fn ExecCallback) Cmd {
+	return func() Msg {
+		return execMsg{cmd: c, fn: fn}
+	}
+}
+
+// ExecProcess runs the given *exec.Cmd in a blocking fashion, effectively
+// pausing the Program while the command is running. After the *exec.Cmd exists
+// the Program resumes. It's useful for spawning other interactive applications
+// such as editors and shells from within a Program.
+//
+// To produce the command, pass an *exec.Cmd and a function which returns
+// a message containing the error which may have occurred when running the
+// ExecCommand.
+//
+//	type VimFinishedMsg struct { err error }
+//
+//	c := exec.Command("vim", "file.txt")
+//
+//	cmd := ExecProcess(c, func(err error) Msg {
+//	    return VimFinishedMsg{err: err}
+//	})
+//
+// Or, if you don't care about errors, you could simply:
+//
+//	cmd := ExecProcess(exec.Command("vim", "file.txt"), nil)
+//
+// For non-interactive i/o you should use a Cmd (that is, a tea.Cmd).
+func ExecProcess(c *exec.Cmd, fn ExecCallback) Cmd {
+	return Exec(wrapExecCommand(c), fn)
+}
+
+// ExecCallback is used when executing an *exec.Command to return a message
+// with an error, which may or may not be nil.
+type ExecCallback func(error) Msg
+
+// ExecCommand can be implemented to execute things in a blocking fashion in
+// the current terminal.
+type ExecCommand interface {
+	Run() error
+	SetStdin(io.Reader)
+	SetStdout(io.Writer)
+	SetStderr(io.Writer)
+}
+
+// wrapExecCommand wraps an exec.Cmd so that it satisfies the ExecCommand
+// interface so it can be used with Exec.
+func wrapExecCommand(c *exec.Cmd) ExecCommand {
+	return &osExecCommand{Cmd: c}
+}
+
+// osExecCommand is a layer over an exec.Cmd that satisfies the ExecCommand
+// interface.
+type osExecCommand struct{ *exec.Cmd }
+
+// SetStdin sets stdin on underlying exec.Cmd to the given io.Reader.
+func (c *osExecCommand) SetStdin(r io.Reader) {
+	// If unset, have the command use the same input as the terminal.
+	if c.Stdin == nil {
+		c.Stdin = r
+	}
+}
+
+// SetStdout sets stdout on underlying exec.Cmd to the given io.Writer.
+func (c *osExecCommand) SetStdout(w io.Writer) {
+	// If unset, have the command use the same output as the terminal.
+	if c.Stdout == nil {
+		c.Stdout = w
+	}
+}
+
+// SetStderr sets stderr on the underlying exec.Cmd to the given io.Writer.
+func (c *osExecCommand) SetStderr(w io.Writer) {
+	// If unset, use stderr for the command's stderr
+	if c.Stderr == nil {
+		c.Stderr = w
+	}
+}
+
+// exec runs an ExecCommand and delivers the results to the program as a Msg.
+func (p *Program) exec(c ExecCommand, fn ExecCallback) {
+	if err := p.ReleaseTerminal(); err != nil {
+		// If we can't release input, abort.
+		if fn != nil {
+			go p.Send(fn(err))
+		}
+		return
+	}
+
+	c.SetStdin(p.input)
+	c.SetStdout(p.output)
+	c.SetStderr(os.Stderr)
+
+	// Execute system command.
+	if err := c.Run(); err != nil {
+		_ = p.RestoreTerminal() // also try to restore the terminal.
+		if fn != nil {
+			go p.Send(fn(err))
+		}
+		return
+	}
+
+	// Have the program re-capture input.
+	err := p.RestoreTerminal()
+	if fn != nil {
+		go p.Send(fn(err))
+	}
+}

vendor/github.com/charmbracelet/bubbletea/focus.go

@@ -0,0 +1,9 @@
+package tea
+
+// FocusMsg represents a terminal focus message.
+// This occurs when the terminal gains focus.
+type FocusMsg struct{}
+
+// BlurMsg represents a terminal blur message.
+// This occurs when the terminal loses focus.
+type BlurMsg struct{}

vendor/github.com/charmbracelet/bubbletea/inputreader_other.go

@@ -0,0 +1,14 @@
+//go:build !windows
+// +build !windows
+
+package tea
+
+import (
+	"io"
+
+	"github.com/muesli/cancelreader"
+)
+
+func newInputReader(r io.Reader) (cancelreader.CancelReader, error) {
+	return cancelreader.NewReader(r)
+}

vendor/github.com/charmbracelet/bubbletea/inputreader_windows.go

@@ -0,0 +1,107 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"sync"
+
+	"github.com/charmbracelet/x/term"
+	"github.com/erikgeiser/coninput"
+	"github.com/muesli/cancelreader"
+	"golang.org/x/sys/windows"
+)
+
+type conInputReader struct {
+	cancelMixin
+
+	conin windows.Handle
+
+	originalMode uint32
+}
+
+var _ cancelreader.CancelReader = &conInputReader{}
+
+func newInputReader(r io.Reader) (cancelreader.CancelReader, error) {
+	fallback := func(io.Reader) (cancelreader.CancelReader, error) {
+		return cancelreader.NewReader(r)
+	}
+	if f, ok := r.(term.File); !ok || f.Fd() != os.Stdin.Fd() {
+		return fallback(r)
+	}
+
+	conin, err := coninput.NewStdinHandle()
+	if err != nil {
+		return fallback(r)
+	}
+
+	originalMode, err := prepareConsole(conin,
+		windows.ENABLE_MOUSE_INPUT,
+		windows.ENABLE_WINDOW_INPUT,
+		windows.ENABLE_EXTENDED_FLAGS,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to prepare console input: %w", err)
+	}
+
+	return &conInputReader{
+		conin:        conin,
+		originalMode: originalMode,
+	}, nil
+}
+
+// Cancel implements cancelreader.CancelReader.
+func (r *conInputReader) Cancel() bool {
+	r.setCanceled()
+
+	return windows.CancelIo(r.conin) == nil
+}
+
+// Close implements cancelreader.CancelReader.
+func (r *conInputReader) Close() error {
+	if r.originalMode != 0 {
+		err := windows.SetConsoleMode(r.conin, r.originalMode)
+		if err != nil {
+			return fmt.Errorf("reset console mode: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// Read implements cancelreader.CancelReader.
+func (*conInputReader) Read(_ []byte) (n int, err error) {
+	return 0, nil
+}
+
+func prepareConsole(input windows.Handle, modes ...uint32) (originalMode uint32, err error) {
+	err = windows.GetConsoleMode(input, &originalMode)
+	if err != nil {
+		return 0, fmt.Errorf("get console mode: %w", err)
+	}
+
+	newMode := coninput.AddInputModes(0, modes...)
+
+	err = windows.SetConsoleMode(input, newMode)
+	if err != nil {
+		return 0, fmt.Errorf("set console mode: %w", err)
+	}
+
+	return originalMode, nil
+}
+
+// cancelMixin represents a goroutine-safe cancelation status.
+type cancelMixin struct {
+	unsafeCanceled bool
+	lock           sync.Mutex
+}
+
+func (c *cancelMixin) setCanceled() {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	c.unsafeCanceled = true
+}

vendor/github.com/charmbracelet/bubbletea/key.go

@@ -0,0 +1,715 @@
+package tea
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"regexp"
+	"strings"
+	"unicode/utf8"
+)
+
+// KeyMsg contains information about a keypress. KeyMsgs are always sent to
+// the program's update function. There are a couple general patterns you could
+// use to check for keypresses:
+//
+//	// Switch on the string representation of the key (shorter)
+//	switch msg := msg.(type) {
+//	case KeyMsg:
+//	    switch msg.String() {
+//	    case "enter":
+//	        fmt.Println("you pressed enter!")
+//	    case "a":
+//	        fmt.Println("you pressed a!")
+//	    }
+//	}
+//
+//	// Switch on the key type (more foolproof)
+//	switch msg := msg.(type) {
+//	case KeyMsg:
+//	    switch msg.Type {
+//	    case KeyEnter:
+//	        fmt.Println("you pressed enter!")
+//	    case KeyRunes:
+//	        switch string(msg.Runes) {
+//	        case "a":
+//	            fmt.Println("you pressed a!")
+//	        }
+//	    }
+//	}
+//
+// Note that Key.Runes will always contain at least one character, so you can
+// always safely call Key.Runes[0]. In most cases Key.Runes will only contain
+// one character, though certain input method editors (most notably Chinese
+// IMEs) can input multiple runes at once.
+type KeyMsg Key
+
+// String returns a string representation for a key message. It's safe (and
+// encouraged) for use in key comparison.
+func (k KeyMsg) String() (str string) {
+	return Key(k).String()
+}
+
+// Key contains information about a keypress.
+type Key struct {
+	Type  KeyType
+	Runes []rune
+	Alt   bool
+	Paste bool
+}
+
+// String returns a friendly string representation for a key. It's safe (and
+// encouraged) for use in key comparison.
+//
+//	k := Key{Type: KeyEnter}
+//	fmt.Println(k)
+//	// Output: enter
+func (k Key) String() (str string) {
+	var buf strings.Builder
+	if k.Alt {
+		buf.WriteString("alt+")
+	}
+	if k.Type == KeyRunes {
+		if k.Paste {
+			// Note: bubbles/keys bindings currently do string compares to
+			// recognize shortcuts. Since pasted text should never activate
+			// shortcuts, we need to ensure that the binding code doesn't
+			// match Key events that result from pastes. We achieve this
+			// here by enclosing pastes in '[...]' so that the string
+			// comparison in Matches() fails in that case.
+			buf.WriteByte('[')
+		}
+		buf.WriteString(string(k.Runes))
+		if k.Paste {
+			buf.WriteByte(']')
+		}
+		return buf.String()
+	} else if s, ok := keyNames[k.Type]; ok {
+		buf.WriteString(s)
+		return buf.String()
+	}
+	return ""
+}
+
+// KeyType indicates the key pressed, such as KeyEnter or KeyBreak or KeyCtrlC.
+// All other keys will be type KeyRunes. To get the rune value, check the Rune
+// method on a Key struct, or use the Key.String() method:
+//
+//	k := Key{Type: KeyRunes, Runes: []rune{'a'}, Alt: true}
+//	if k.Type == KeyRunes {
+//
+//	    fmt.Println(k.Runes)
+//	    // Output: a
+//
+//	    fmt.Println(k.String())
+//	    // Output: alt+a
+//
+//	}
+type KeyType int
+
+func (k KeyType) String() (str string) {
+	if s, ok := keyNames[k]; ok {
+		return s
+	}
+	return ""
+}
+
+// Control keys. We could do this with an iota, but the values are very
+// specific, so we set the values explicitly to avoid any confusion.
+//
+// See also:
+// https://en.wikipedia.org/wiki/C0_and_C1_control_codes
+const (
+	keyNUL KeyType = 0   // null, \0
+	keySOH KeyType = 1   // start of heading
+	keySTX KeyType = 2   // start of text
+	keyETX KeyType = 3   // break, ctrl+c
+	keyEOT KeyType = 4   // end of transmission
+	keyENQ KeyType = 5   // enquiry
+	keyACK KeyType = 6   // acknowledge
+	keyBEL KeyType = 7   // bell, \a
+	keyBS  KeyType = 8   // backspace
+	keyHT  KeyType = 9   // horizontal tabulation, \t
+	keyLF  KeyType = 10  // line feed, \n
+	keyVT  KeyType = 11  // vertical tabulation \v
+	keyFF  KeyType = 12  // form feed \f
+	keyCR  KeyType = 13  // carriage return, \r
+	keySO  KeyType = 14  // shift out
+	keySI  KeyType = 15  // shift in
+	keyDLE KeyType = 16  // data link escape
+	keyDC1 KeyType = 17  // device control one
+	keyDC2 KeyType = 18  // device control two
+	keyDC3 KeyType = 19  // device control three
+	keyDC4 KeyType = 20  // device control four
+	keyNAK KeyType = 21  // negative acknowledge
+	keySYN KeyType = 22  // synchronous idle
+	keyETB KeyType = 23  // end of transmission block
+	keyCAN KeyType = 24  // cancel
+	keyEM  KeyType = 25  // end of medium
+	keySUB KeyType = 26  // substitution
+	keyESC KeyType = 27  // escape, \e
+	keyFS  KeyType = 28  // file separator
+	keyGS  KeyType = 29  // group separator
+	keyRS  KeyType = 30  // record separator
+	keyUS  KeyType = 31  // unit separator
+	keyDEL KeyType = 127 // delete. on most systems this is mapped to backspace, I hear
+)
+
+// Control key aliases.
+const (
+	KeyNull      KeyType = keyNUL
+	KeyBreak     KeyType = keyETX
+	KeyEnter     KeyType = keyCR
+	KeyBackspace KeyType = keyDEL
+	KeyTab       KeyType = keyHT
+	KeyEsc       KeyType = keyESC
+	KeyEscape    KeyType = keyESC
+
+	KeyCtrlAt           KeyType = keyNUL // ctrl+@
+	KeyCtrlA            KeyType = keySOH
+	KeyCtrlB            KeyType = keySTX
+	KeyCtrlC            KeyType = keyETX
+	KeyCtrlD            KeyType = keyEOT
+	KeyCtrlE            KeyType = keyENQ
+	KeyCtrlF            KeyType = keyACK
+	KeyCtrlG            KeyType = keyBEL
+	KeyCtrlH            KeyType = keyBS
+	KeyCtrlI            KeyType = keyHT
+	KeyCtrlJ            KeyType = keyLF
+	KeyCtrlK            KeyType = keyVT
+	KeyCtrlL            KeyType = keyFF
+	KeyCtrlM            KeyType = keyCR
+	KeyCtrlN            KeyType = keySO
+	KeyCtrlO            KeyType = keySI
+	KeyCtrlP            KeyType = keyDLE
+	KeyCtrlQ            KeyType = keyDC1
+	KeyCtrlR            KeyType = keyDC2
+	KeyCtrlS            KeyType = keyDC3
+	KeyCtrlT            KeyType = keyDC4
+	KeyCtrlU            KeyType = keyNAK
+	KeyCtrlV            KeyType = keySYN
+	KeyCtrlW            KeyType = keyETB
+	KeyCtrlX            KeyType = keyCAN
+	KeyCtrlY            KeyType = keyEM
+	KeyCtrlZ            KeyType = keySUB
+	KeyCtrlOpenBracket  KeyType = keyESC // ctrl+[
+	KeyCtrlBackslash    KeyType = keyFS  // ctrl+\
+	KeyCtrlCloseBracket KeyType = keyGS  // ctrl+]
+	KeyCtrlCaret        KeyType = keyRS  // ctrl+^
+	KeyCtrlUnderscore   KeyType = keyUS  // ctrl+_
+	KeyCtrlQuestionMark KeyType = keyDEL // ctrl+?
+)
+
+// Other keys.
+const (
+	KeyRunes KeyType = -(iota + 1)
+	KeyUp
+	KeyDown
+	KeyRight
+	KeyLeft
+	KeyShiftTab
+	KeyHome
+	KeyEnd
+	KeyPgUp
+	KeyPgDown
+	KeyCtrlPgUp
+	KeyCtrlPgDown
+	KeyDelete
+	KeyInsert
+	KeySpace
+	KeyCtrlUp
+	KeyCtrlDown
+	KeyCtrlRight
+	KeyCtrlLeft
+	KeyCtrlHome
+	KeyCtrlEnd
+	KeyShiftUp
+	KeyShiftDown
+	KeyShiftRight
+	KeyShiftLeft
+	KeyShiftHome
+	KeyShiftEnd
+	KeyCtrlShiftUp
+	KeyCtrlShiftDown
+	KeyCtrlShiftLeft
+	KeyCtrlShiftRight
+	KeyCtrlShiftHome
+	KeyCtrlShiftEnd
+	KeyF1
+	KeyF2
+	KeyF3
+	KeyF4
+	KeyF5
+	KeyF6
+	KeyF7
+	KeyF8
+	KeyF9
+	KeyF10
+	KeyF11
+	KeyF12
+	KeyF13
+	KeyF14
+	KeyF15
+	KeyF16
+	KeyF17
+	KeyF18
+	KeyF19
+	KeyF20
+)
+
+// Mappings for control keys and other special keys to friendly consts.
+var keyNames = map[KeyType]string{
+	// Control keys.
+	keyNUL: "ctrl+@", // also ctrl+` (that's ctrl+backtick)
+	keySOH: "ctrl+a",
+	keySTX: "ctrl+b",
+	keyETX: "ctrl+c",
+	keyEOT: "ctrl+d",
+	keyENQ: "ctrl+e",
+	keyACK: "ctrl+f",
+	keyBEL: "ctrl+g",
+	keyBS:  "ctrl+h",
+	keyHT:  "tab", // also ctrl+i
+	keyLF:  "ctrl+j",
+	keyVT:  "ctrl+k",
+	keyFF:  "ctrl+l",
+	keyCR:  "enter",
+	keySO:  "ctrl+n",
+	keySI:  "ctrl+o",
+	keyDLE: "ctrl+p",
+	keyDC1: "ctrl+q",
+	keyDC2: "ctrl+r",
+	keyDC3: "ctrl+s",
+	keyDC4: "ctrl+t",
+	keyNAK: "ctrl+u",
+	keySYN: "ctrl+v",
+	keyETB: "ctrl+w",
+	keyCAN: "ctrl+x",
+	keyEM:  "ctrl+y",
+	keySUB: "ctrl+z",
+	keyESC: "esc",
+	keyFS:  "ctrl+\\",
+	keyGS:  "ctrl+]",
+	keyRS:  "ctrl+^",
+	keyUS:  "ctrl+_",
+	keyDEL: "backspace",
+
+	// Other keys.
+	KeyRunes:          "runes",
+	KeyUp:             "up",
+	KeyDown:           "down",
+	KeyRight:          "right",
+	KeySpace:          " ", // for backwards compatibility
+	KeyLeft:           "left",
+	KeyShiftTab:       "shift+tab",
+	KeyHome:           "home",
+	KeyEnd:            "end",
+	KeyCtrlHome:       "ctrl+home",
+	KeyCtrlEnd:        "ctrl+end",
+	KeyShiftHome:      "shift+home",
+	KeyShiftEnd:       "shift+end",
+	KeyCtrlShiftHome:  "ctrl+shift+home",
+	KeyCtrlShiftEnd:   "ctrl+shift+end",
+	KeyPgUp:           "pgup",
+	KeyPgDown:         "pgdown",
+	KeyCtrlPgUp:       "ctrl+pgup",
+	KeyCtrlPgDown:     "ctrl+pgdown",
+	KeyDelete:         "delete",
+	KeyInsert:         "insert",
+	KeyCtrlUp:         "ctrl+up",
+	KeyCtrlDown:       "ctrl+down",
+	KeyCtrlRight:      "ctrl+right",
+	KeyCtrlLeft:       "ctrl+left",
+	KeyShiftUp:        "shift+up",
+	KeyShiftDown:      "shift+down",
+	KeyShiftRight:     "shift+right",
+	KeyShiftLeft:      "shift+left",
+	KeyCtrlShiftUp:    "ctrl+shift+up",
+	KeyCtrlShiftDown:  "ctrl+shift+down",
+	KeyCtrlShiftLeft:  "ctrl+shift+left",
+	KeyCtrlShiftRight: "ctrl+shift+right",
+	KeyF1:             "f1",
+	KeyF2:             "f2",
+	KeyF3:             "f3",
+	KeyF4:             "f4",
+	KeyF5:             "f5",
+	KeyF6:             "f6",
+	KeyF7:             "f7",
+	KeyF8:             "f8",
+	KeyF9:             "f9",
+	KeyF10:            "f10",
+	KeyF11:            "f11",
+	KeyF12:            "f12",
+	KeyF13:            "f13",
+	KeyF14:            "f14",
+	KeyF15:            "f15",
+	KeyF16:            "f16",
+	KeyF17:            "f17",
+	KeyF18:            "f18",
+	KeyF19:            "f19",
+	KeyF20:            "f20",
+}
+
+// Sequence mappings.
+var sequences = map[string]Key{
+	// Arrow keys
+	"\x1b[A":    {Type: KeyUp},
+	"\x1b[B":    {Type: KeyDown},
+	"\x1b[C":    {Type: KeyRight},
+	"\x1b[D":    {Type: KeyLeft},
+	"\x1b[1;2A": {Type: KeyShiftUp},
+	"\x1b[1;2B": {Type: KeyShiftDown},
+	"\x1b[1;2C": {Type: KeyShiftRight},
+	"\x1b[1;2D": {Type: KeyShiftLeft},
+	"\x1b[OA":   {Type: KeyShiftUp},    // DECCKM
+	"\x1b[OB":   {Type: KeyShiftDown},  // DECCKM
+	"\x1b[OC":   {Type: KeyShiftRight}, // DECCKM
+	"\x1b[OD":   {Type: KeyShiftLeft},  // DECCKM
+	"\x1b[a":    {Type: KeyShiftUp},    // urxvt
+	"\x1b[b":    {Type: KeyShiftDown},  // urxvt
+	"\x1b[c":    {Type: KeyShiftRight}, // urxvt
+	"\x1b[d":    {Type: KeyShiftLeft},  // urxvt
+	"\x1b[1;3A": {Type: KeyUp, Alt: true},
+	"\x1b[1;3B": {Type: KeyDown, Alt: true},
+	"\x1b[1;3C": {Type: KeyRight, Alt: true},
+	"\x1b[1;3D": {Type: KeyLeft, Alt: true},
+
+	"\x1b[1;4A": {Type: KeyShiftUp, Alt: true},
+	"\x1b[1;4B": {Type: KeyShiftDown, Alt: true},
+	"\x1b[1;4C": {Type: KeyShiftRight, Alt: true},
+	"\x1b[1;4D": {Type: KeyShiftLeft, Alt: true},
+
+	"\x1b[1;5A": {Type: KeyCtrlUp},
+	"\x1b[1;5B": {Type: KeyCtrlDown},
+	"\x1b[1;5C": {Type: KeyCtrlRight},
+	"\x1b[1;5D": {Type: KeyCtrlLeft},
+	"\x1b[Oa":   {Type: KeyCtrlUp, Alt: true},    // urxvt
+	"\x1b[Ob":   {Type: KeyCtrlDown, Alt: true},  // urxvt
+	"\x1b[Oc":   {Type: KeyCtrlRight, Alt: true}, // urxvt
+	"\x1b[Od":   {Type: KeyCtrlLeft, Alt: true},  // urxvt
+	"\x1b[1;6A": {Type: KeyCtrlShiftUp},
+	"\x1b[1;6B": {Type: KeyCtrlShiftDown},
+	"\x1b[1;6C": {Type: KeyCtrlShiftRight},
+	"\x1b[1;6D": {Type: KeyCtrlShiftLeft},
+	"\x1b[1;7A": {Type: KeyCtrlUp, Alt: true},
+	"\x1b[1;7B": {Type: KeyCtrlDown, Alt: true},
+	"\x1b[1;7C": {Type: KeyCtrlRight, Alt: true},
+	"\x1b[1;7D": {Type: KeyCtrlLeft, Alt: true},
+	"\x1b[1;8A": {Type: KeyCtrlShiftUp, Alt: true},
+	"\x1b[1;8B": {Type: KeyCtrlShiftDown, Alt: true},
+	"\x1b[1;8C": {Type: KeyCtrlShiftRight, Alt: true},
+	"\x1b[1;8D": {Type: KeyCtrlShiftLeft, Alt: true},
+
+	// Miscellaneous keys
+	"\x1b[Z": {Type: KeyShiftTab},
+
+	"\x1b[2~":   {Type: KeyInsert},
+	"\x1b[3;2~": {Type: KeyInsert, Alt: true},
+
+	"\x1b[3~":   {Type: KeyDelete},
+	"\x1b[3;3~": {Type: KeyDelete, Alt: true},
+
+	"\x1b[5~":   {Type: KeyPgUp},
+	"\x1b[5;3~": {Type: KeyPgUp, Alt: true},
+	"\x1b[5;5~": {Type: KeyCtrlPgUp},
+	"\x1b[5^":   {Type: KeyCtrlPgUp}, // urxvt
+	"\x1b[5;7~": {Type: KeyCtrlPgUp, Alt: true},
+
+	"\x1b[6~":   {Type: KeyPgDown},
+	"\x1b[6;3~": {Type: KeyPgDown, Alt: true},
+	"\x1b[6;5~": {Type: KeyCtrlPgDown},
+	"\x1b[6^":   {Type: KeyCtrlPgDown}, // urxvt
+	"\x1b[6;7~": {Type: KeyCtrlPgDown, Alt: true},
+
+	"\x1b[1~":   {Type: KeyHome},
+	"\x1b[H":    {Type: KeyHome},                     // xterm, lxterm
+	"\x1b[1;3H": {Type: KeyHome, Alt: true},          // xterm, lxterm
+	"\x1b[1;5H": {Type: KeyCtrlHome},                 // xterm, lxterm
+	"\x1b[1;7H": {Type: KeyCtrlHome, Alt: true},      // xterm, lxterm
+	"\x1b[1;2H": {Type: KeyShiftHome},                // xterm, lxterm
+	"\x1b[1;4H": {Type: KeyShiftHome, Alt: true},     // xterm, lxterm
+	"\x1b[1;6H": {Type: KeyCtrlShiftHome},            // xterm, lxterm
+	"\x1b[1;8H": {Type: KeyCtrlShiftHome, Alt: true}, // xterm, lxterm
+
+	"\x1b[4~":   {Type: KeyEnd},
+	"\x1b[F":    {Type: KeyEnd},                     // xterm, lxterm
+	"\x1b[1;3F": {Type: KeyEnd, Alt: true},          // xterm, lxterm
+	"\x1b[1;5F": {Type: KeyCtrlEnd},                 // xterm, lxterm
+	"\x1b[1;7F": {Type: KeyCtrlEnd, Alt: true},      // xterm, lxterm
+	"\x1b[1;2F": {Type: KeyShiftEnd},                // xterm, lxterm
+	"\x1b[1;4F": {Type: KeyShiftEnd, Alt: true},     // xterm, lxterm
+	"\x1b[1;6F": {Type: KeyCtrlShiftEnd},            // xterm, lxterm
+	"\x1b[1;8F": {Type: KeyCtrlShiftEnd, Alt: true}, // xterm, lxterm
+
+	"\x1b[7~": {Type: KeyHome},          // urxvt
+	"\x1b[7^": {Type: KeyCtrlHome},      // urxvt
+	"\x1b[7$": {Type: KeyShiftHome},     // urxvt
+	"\x1b[7@": {Type: KeyCtrlShiftHome}, // urxvt
+
+	"\x1b[8~": {Type: KeyEnd},          // urxvt
+	"\x1b[8^": {Type: KeyCtrlEnd},      // urxvt
+	"\x1b[8$": {Type: KeyShiftEnd},     // urxvt
+	"\x1b[8@": {Type: KeyCtrlShiftEnd}, // urxvt
+
+	// Function keys, Linux console
+	"\x1b[[A": {Type: KeyF1}, // linux console
+	"\x1b[[B": {Type: KeyF2}, // linux console
+	"\x1b[[C": {Type: KeyF3}, // linux console
+	"\x1b[[D": {Type: KeyF4}, // linux console
+	"\x1b[[E": {Type: KeyF5}, // linux console
+
+	// Function keys, X11
+	"\x1bOP": {Type: KeyF1}, // vt100, xterm
+	"\x1bOQ": {Type: KeyF2}, // vt100, xterm
+	"\x1bOR": {Type: KeyF3}, // vt100, xterm
+	"\x1bOS": {Type: KeyF4}, // vt100, xterm
+
+	"\x1b[1;3P": {Type: KeyF1, Alt: true}, // vt100, xterm
+	"\x1b[1;3Q": {Type: KeyF2, Alt: true}, // vt100, xterm
+	"\x1b[1;3R": {Type: KeyF3, Alt: true}, // vt100, xterm
+	"\x1b[1;3S": {Type: KeyF4, Alt: true}, // vt100, xterm
+
+	"\x1b[11~": {Type: KeyF1}, // urxvt
+	"\x1b[12~": {Type: KeyF2}, // urxvt
+	"\x1b[13~": {Type: KeyF3}, // urxvt
+	"\x1b[14~": {Type: KeyF4}, // urxvt
+
+	"\x1b[15~": {Type: KeyF5}, // vt100, xterm, also urxvt
+
+	"\x1b[15;3~": {Type: KeyF5, Alt: true}, // vt100, xterm, also urxvt
+
+	"\x1b[17~": {Type: KeyF6},  // vt100, xterm, also urxvt
+	"\x1b[18~": {Type: KeyF7},  // vt100, xterm, also urxvt
+	"\x1b[19~": {Type: KeyF8},  // vt100, xterm, also urxvt
+	"\x1b[20~": {Type: KeyF9},  // vt100, xterm, also urxvt
+	"\x1b[21~": {Type: KeyF10}, // vt100, xterm, also urxvt
+
+	"\x1b[17;3~": {Type: KeyF6, Alt: true},  // vt100, xterm
+	"\x1b[18;3~": {Type: KeyF7, Alt: true},  // vt100, xterm
+	"\x1b[19;3~": {Type: KeyF8, Alt: true},  // vt100, xterm
+	"\x1b[20;3~": {Type: KeyF9, Alt: true},  // vt100, xterm
+	"\x1b[21;3~": {Type: KeyF10, Alt: true}, // vt100, xterm
+
+	"\x1b[23~": {Type: KeyF11}, // vt100, xterm, also urxvt
+	"\x1b[24~": {Type: KeyF12}, // vt100, xterm, also urxvt
+
+	"\x1b[23;3~": {Type: KeyF11, Alt: true}, // vt100, xterm
+	"\x1b[24;3~": {Type: KeyF12, Alt: true}, // vt100, xterm
+
+	"\x1b[1;2P": {Type: KeyF13},
+	"\x1b[1;2Q": {Type: KeyF14},
+
+	"\x1b[25~": {Type: KeyF13}, // vt100, xterm, also urxvt
+	"\x1b[26~": {Type: KeyF14}, // vt100, xterm, also urxvt
+
+	"\x1b[25;3~": {Type: KeyF13, Alt: true}, // vt100, xterm
+	"\x1b[26;3~": {Type: KeyF14, Alt: true}, // vt100, xterm
+
+	"\x1b[1;2R": {Type: KeyF15},
+	"\x1b[1;2S": {Type: KeyF16},
+
+	"\x1b[28~": {Type: KeyF15}, // vt100, xterm, also urxvt
+	"\x1b[29~": {Type: KeyF16}, // vt100, xterm, also urxvt
+
+	"\x1b[28;3~": {Type: KeyF15, Alt: true}, // vt100, xterm
+	"\x1b[29;3~": {Type: KeyF16, Alt: true}, // vt100, xterm
+
+	"\x1b[15;2~": {Type: KeyF17},
+	"\x1b[17;2~": {Type: KeyF18},
+	"\x1b[18;2~": {Type: KeyF19},
+	"\x1b[19;2~": {Type: KeyF20},
+
+	"\x1b[31~": {Type: KeyF17},
+	"\x1b[32~": {Type: KeyF18},
+	"\x1b[33~": {Type: KeyF19},
+	"\x1b[34~": {Type: KeyF20},
+
+	// Powershell sequences.
+	"\x1bOA": {Type: KeyUp, Alt: false},
+	"\x1bOB": {Type: KeyDown, Alt: false},
+	"\x1bOC": {Type: KeyRight, Alt: false},
+	"\x1bOD": {Type: KeyLeft, Alt: false},
+}
+
+// unknownInputByteMsg is reported by the input reader when an invalid
+// utf-8 byte is detected on the input. Currently, it is not handled
+// further by bubbletea. However, having this event makes it possible
+// to troubleshoot invalid inputs.
+type unknownInputByteMsg byte
+
+func (u unknownInputByteMsg) String() string {
+	return fmt.Sprintf("?%#02x?", int(u))
+}
+
+// unknownCSISequenceMsg is reported by the input reader when an
+// unrecognized CSI sequence is detected on the input. Currently, it
+// is not handled further by bubbletea. However, having this event
+// makes it possible to troubleshoot invalid inputs.
+type unknownCSISequenceMsg []byte
+
+func (u unknownCSISequenceMsg) String() string {
+	return fmt.Sprintf("?CSI%+v?", []byte(u)[2:])
+}
+
+var spaceRunes = []rune{' '}
+
+// readAnsiInputs reads keypress and mouse inputs from a TTY and produces messages
+// containing information about the key or mouse events accordingly.
+func readAnsiInputs(ctx context.Context, msgs chan<- Msg, input io.Reader) error {
+	var buf [256]byte
+
+	var leftOverFromPrevIteration []byte
+loop:
+	for {
+		// Read and block.
+		numBytes, err := input.Read(buf[:])
+		if err != nil {
+			return fmt.Errorf("error reading input: %w", err)
+		}
+		b := buf[:numBytes]
+		if leftOverFromPrevIteration != nil {
+			b = append(leftOverFromPrevIteration, b...)
+		}
+
+		// If we had a short read (numBytes < len(buf)), we're sure that
+		// the end of this read is an event boundary, so there is no doubt
+		// if we are encountering the end of the buffer while parsing a message.
+		// However, if we've succeeded in filling up the buffer, there may
+		// be more data in the OS buffer ready to be read in, to complete
+		// the last message in the input. In that case, we will retry with
+		// the left over data in the next iteration.
+		canHaveMoreData := numBytes == len(buf)
+
+		var i, w int
+		for i, w = 0, 0; i < len(b); i += w {
+			var msg Msg
+			w, msg = detectOneMsg(b[i:], canHaveMoreData)
+			if w == 0 {
+				// Expecting more bytes beyond the current buffer. Try waiting
+				// for more input.
+				leftOverFromPrevIteration = make([]byte, 0, len(b[i:])+len(buf))
+				leftOverFromPrevIteration = append(leftOverFromPrevIteration, b[i:]...)
+				continue loop
+			}
+
+			select {
+			case msgs <- msg:
+			case <-ctx.Done():
+				err := ctx.Err()
+				if err != nil {
+					err = fmt.Errorf("found context error while reading input: %w", err)
+				}
+				return err
+			}
+		}
+		leftOverFromPrevIteration = nil
+	}
+}
+
+var (
+	unknownCSIRe  = regexp.MustCompile(`^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]`)
+	mouseSGRRegex = regexp.MustCompile(`(\d+);(\d+);(\d+)([Mm])`)
+)
+
+func detectOneMsg(b []byte, canHaveMoreData bool) (w int, msg Msg) {
+	// Detect mouse events.
+	// X10 mouse events have a length of 6 bytes
+	const mouseEventX10Len = 6
+	if len(b) >= mouseEventX10Len && b[0] == '\x1b' && b[1] == '[' {
+		switch b[2] {
+		case 'M':
+			return mouseEventX10Len, MouseMsg(parseX10MouseEvent(b))
+		case '<':
+			if matchIndices := mouseSGRRegex.FindSubmatchIndex(b[3:]); matchIndices != nil {
+				// SGR mouse events length is the length of the match plus the length of the escape sequence
+				mouseEventSGRLen := matchIndices[1] + 3 //nolint:gomnd
+				return mouseEventSGRLen, MouseMsg(parseSGRMouseEvent(b))
+			}
+		}
+	}
+
+	// Detect focus events.
+	var foundRF bool
+	foundRF, w, msg = detectReportFocus(b)
+	if foundRF {
+		return w, msg
+	}
+
+	// Detect bracketed paste.
+	var foundbp bool
+	foundbp, w, msg = detectBracketedPaste(b)
+	if foundbp {
+		return w, msg
+	}
+
+	// Detect escape sequence and control characters other than NUL,
+	// possibly with an escape character in front to mark the Alt
+	// modifier.
+	var foundSeq bool
+	foundSeq, w, msg = detectSequence(b)
+	if foundSeq {
+		return w, msg
+	}
+
+	// No non-NUL control character or escape sequence.
+	// If we are seeing at least an escape character, remember it for later below.
+	alt := false
+	i := 0
+	if b[0] == '\x1b' {
+		alt = true
+		i++
+	}
+
+	// Are we seeing a standalone NUL? This is not handled by detectSequence().
+	if i < len(b) && b[i] == 0 {
+		return i + 1, KeyMsg{Type: keyNUL, Alt: alt}
+	}
+
+	// Find the longest sequence of runes that are not control
+	// characters from this point.
+	var runes []rune
+	for rw := 0; i < len(b); i += rw {
+		var r rune
+		r, rw = utf8.DecodeRune(b[i:])
+		if r == utf8.RuneError || r <= rune(keyUS) || r == rune(keyDEL) || r == ' ' {
+			// Rune errors are handled below; control characters and spaces will
+			// be handled by detectSequence in the next call to detectOneMsg.
+			break
+		}
+		runes = append(runes, r)
+		if alt {
+			// We only support a single rune after an escape alt modifier.
+			i += rw
+			break
+		}
+	}
+	if i >= len(b) && canHaveMoreData {
+		// We have encountered the end of the input buffer. Alas, we can't
+		// be sure whether the data in the remainder of the buffer is
+		// complete (maybe there was a short read). Instead of sending anything
+		// dumb to the message channel, do a short read. The outer loop will
+		// handle this case by extending the buffer as necessary.
+		return 0, nil
+	}
+
+	// If we found at least one rune, we report the bunch of them as
+	// a single KeyRunes or KeySpace event.
+	if len(runes) > 0 {
+		k := Key{Type: KeyRunes, Runes: runes, Alt: alt}
+		if len(runes) == 1 && runes[0] == ' ' {
+			k.Type = KeySpace
+		}
+		return i, KeyMsg(k)
+	}
+
+	// We didn't find an escape sequence, nor a valid rune. Was this a
+	// lone escape character at the end of the input?
+	if alt && len(b) == 1 {
+		return 1, KeyMsg(Key{Type: KeyEscape})
+	}
+
+	// The character at the current position is neither an escape
+	// sequence, a valid rune start or a sole escape character. Report
+	// it as an invalid byte.
+	return 1, unknownInputByteMsg(b[0])
+}

vendor/github.com/charmbracelet/bubbletea/key_other.go

@@ -0,0 +1,13 @@
+//go:build !windows
+// +build !windows
+
+package tea
+
+import (
+	"context"
+	"io"
+)
+
+func readInputs(ctx context.Context, msgs chan<- Msg, input io.Reader) error {
+	return readAnsiInputs(ctx, msgs, input)
+}

vendor/github.com/charmbracelet/bubbletea/key_sequences.go

@@ -0,0 +1,131 @@
+package tea
+
+import (
+	"bytes"
+	"sort"
+	"unicode/utf8"
+)
+
+// extSequences is used by the map-based algorithm below. It contains
+// the sequences plus their alternatives with an escape character
+// prefixed, plus the control chars, plus the space.
+// It does not contain the NUL character, which is handled specially
+// by detectOneMsg.
+var extSequences = func() map[string]Key {
+	s := map[string]Key{}
+	for seq, key := range sequences {
+		key := key
+		s[seq] = key
+		if !key.Alt {
+			key.Alt = true
+			s["\x1b"+seq] = key
+		}
+	}
+	for i := keyNUL + 1; i <= keyDEL; i++ {
+		if i == keyESC {
+			continue
+		}
+		s[string([]byte{byte(i)})] = Key{Type: i}
+		s[string([]byte{'\x1b', byte(i)})] = Key{Type: i, Alt: true}
+		if i == keyUS {
+			i = keyDEL - 1
+		}
+	}
+	s[" "] = Key{Type: KeySpace, Runes: spaceRunes}
+	s["\x1b "] = Key{Type: KeySpace, Alt: true, Runes: spaceRunes}
+	s["\x1b\x1b"] = Key{Type: KeyEscape, Alt: true}
+	return s
+}()
+
+// seqLengths is the sizes of valid sequences, starting with the
+// largest size.
+var seqLengths = func() []int {
+	sizes := map[int]struct{}{}
+	for seq := range extSequences {
+		sizes[len(seq)] = struct{}{}
+	}
+	lsizes := make([]int, 0, len(sizes))
+	for sz := range sizes {
+		lsizes = append(lsizes, sz)
+	}
+	sort.Slice(lsizes, func(i, j int) bool { return lsizes[i] > lsizes[j] })
+	return lsizes
+}()
+
+// detectSequence uses a longest prefix match over the input
+// sequence and a hash map.
+func detectSequence(input []byte) (hasSeq bool, width int, msg Msg) {
+	seqs := extSequences
+	for _, sz := range seqLengths {
+		if sz > len(input) {
+			continue
+		}
+		prefix := input[:sz]
+		key, ok := seqs[string(prefix)]
+		if ok {
+			return true, sz, KeyMsg(key)
+		}
+	}
+	// Is this an unknown CSI sequence?
+	if loc := unknownCSIRe.FindIndex(input); loc != nil {
+		return true, loc[1], unknownCSISequenceMsg(input[:loc[1]])
+	}
+
+	return false, 0, nil
+}
+
+// detectBracketedPaste detects an input pasted while bracketed
+// paste mode was enabled.
+//
+// Note: this function is a no-op if bracketed paste was not enabled
+// on the terminal, since in that case we'd never see this
+// particular escape sequence.
+func detectBracketedPaste(input []byte) (hasBp bool, width int, msg Msg) {
+	// Detect the start sequence.
+	const bpStart = "\x1b[200~"
+	if len(input) < len(bpStart) || string(input[:len(bpStart)]) != bpStart {
+		return false, 0, nil
+	}
+
+	// Skip over the start sequence.
+	input = input[len(bpStart):]
+
+	// If we saw the start sequence, then we must have an end sequence
+	// as well. Find it.
+	const bpEnd = "\x1b[201~"
+	idx := bytes.Index(input, []byte(bpEnd))
+	inputLen := len(bpStart) + idx + len(bpEnd)
+	if idx == -1 {
+		// We have encountered the end of the input buffer without seeing
+		// the marker for the end of the bracketed paste.
+		// Tell the outer loop we have done a short read and we want more.
+		return true, 0, nil
+	}
+
+	// The paste is everything in-between.
+	paste := input[:idx]
+
+	// All there is in-between is runes, not to be interpreted further.
+	k := Key{Type: KeyRunes, Paste: true}
+	for len(paste) > 0 {
+		r, w := utf8.DecodeRune(paste)
+		if r != utf8.RuneError {
+			k.Runes = append(k.Runes, r)
+		}
+		paste = paste[w:]
+	}
+
+	return true, inputLen, KeyMsg(k)
+}
+
+// detectReportFocus detects a focus report sequence.
+// nolint: gomnd
+func detectReportFocus(input []byte) (hasRF bool, width int, msg Msg) {
+	switch {
+	case bytes.Equal(input, []byte("\x1b[I")):
+		return true, 3, FocusMsg{}
+	case bytes.Equal(input, []byte("\x1b[O")):
+		return true, 3, BlurMsg{}
+	}
+	return false, 0, nil
+}

vendor/github.com/charmbracelet/bubbletea/key_windows.go

@@ -0,0 +1,351 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"github.com/erikgeiser/coninput"
+	localereader "github.com/mattn/go-localereader"
+	"golang.org/x/sys/windows"
+)
+
+func readInputs(ctx context.Context, msgs chan<- Msg, input io.Reader) error {
+	if coninReader, ok := input.(*conInputReader); ok {
+		return readConInputs(ctx, msgs, coninReader.conin)
+	}
+
+	return readAnsiInputs(ctx, msgs, localereader.NewReader(input))
+}
+
+func readConInputs(ctx context.Context, msgsch chan<- Msg, con windows.Handle) error {
+	var ps coninput.ButtonState                 // keep track of previous mouse state
+	var ws coninput.WindowBufferSizeEventRecord // keep track of the last window size event
+	for {
+		events, err := coninput.ReadNConsoleInputs(con, 16)
+		if err != nil {
+			return fmt.Errorf("read coninput events: %w", err)
+		}
+
+		for _, event := range events {
+			var msgs []Msg
+			switch e := event.Unwrap().(type) {
+			case coninput.KeyEventRecord:
+				if !e.KeyDown || e.VirtualKeyCode == coninput.VK_SHIFT {
+					continue
+				}
+
+				for i := 0; i < int(e.RepeatCount); i++ {
+					eventKeyType := keyType(e)
+					var runes []rune
+
+					// Add the character only if the key type is an actual character and not a control sequence.
+					// This mimics the behavior in readAnsiInputs where the character is also removed.
+					// We don't need to handle KeySpace here. See the comment in keyType().
+					if eventKeyType == KeyRunes {
+						runes = []rune{e.Char}
+					}
+
+					msgs = append(msgs, KeyMsg{
+						Type:  eventKeyType,
+						Runes: runes,
+						Alt:   e.ControlKeyState.Contains(coninput.LEFT_ALT_PRESSED | coninput.RIGHT_ALT_PRESSED),
+					})
+				}
+			case coninput.WindowBufferSizeEventRecord:
+				if e != ws {
+					ws = e
+					msgs = append(msgs, WindowSizeMsg{
+						Width:  int(e.Size.X),
+						Height: int(e.Size.Y),
+					})
+				}
+			case coninput.MouseEventRecord:
+				event := mouseEvent(ps, e)
+				if event.Type != MouseUnknown {
+					msgs = append(msgs, event)
+				}
+				ps = e.ButtonState
+			case coninput.FocusEventRecord, coninput.MenuEventRecord:
+				// ignore
+			default: // unknown event
+				continue
+			}
+
+			// Send all messages to the channel
+			for _, msg := range msgs {
+				select {
+				case msgsch <- msg:
+				case <-ctx.Done():
+					err := ctx.Err()
+					if err != nil {
+						return fmt.Errorf("coninput context error: %w", err)
+					}
+					return err
+				}
+			}
+		}
+	}
+}
+
+func mouseEventButton(p, s coninput.ButtonState) (button MouseButton, action MouseAction) {
+	btn := p ^ s
+	action = MouseActionPress
+	if btn&s == 0 {
+		action = MouseActionRelease
+	}
+
+	if btn == 0 {
+		switch {
+		case s&coninput.FROM_LEFT_1ST_BUTTON_PRESSED > 0:
+			button = MouseButtonLeft
+		case s&coninput.FROM_LEFT_2ND_BUTTON_PRESSED > 0:
+			button = MouseButtonMiddle
+		case s&coninput.RIGHTMOST_BUTTON_PRESSED > 0:
+			button = MouseButtonRight
+		case s&coninput.FROM_LEFT_3RD_BUTTON_PRESSED > 0:
+			button = MouseButtonBackward
+		case s&coninput.FROM_LEFT_4TH_BUTTON_PRESSED > 0:
+			button = MouseButtonForward
+		}
+		return
+	}
+
+	switch {
+	case btn == coninput.FROM_LEFT_1ST_BUTTON_PRESSED: // left button
+		button = MouseButtonLeft
+	case btn == coninput.RIGHTMOST_BUTTON_PRESSED: // right button
+		button = MouseButtonRight
+	case btn == coninput.FROM_LEFT_2ND_BUTTON_PRESSED: // middle button
+		button = MouseButtonMiddle
+	case btn == coninput.FROM_LEFT_3RD_BUTTON_PRESSED: // unknown (possibly mouse backward)
+		button = MouseButtonBackward
+	case btn == coninput.FROM_LEFT_4TH_BUTTON_PRESSED: // unknown (possibly mouse forward)
+		button = MouseButtonForward
+	}
+
+	return button, action
+}
+
+func mouseEvent(p coninput.ButtonState, e coninput.MouseEventRecord) MouseMsg {
+	ev := MouseMsg{
+		X:     int(e.MousePositon.X),
+		Y:     int(e.MousePositon.Y),
+		Alt:   e.ControlKeyState.Contains(coninput.LEFT_ALT_PRESSED | coninput.RIGHT_ALT_PRESSED),
+		Ctrl:  e.ControlKeyState.Contains(coninput.LEFT_CTRL_PRESSED | coninput.RIGHT_CTRL_PRESSED),
+		Shift: e.ControlKeyState.Contains(coninput.SHIFT_PRESSED),
+	}
+	switch e.EventFlags {
+	case coninput.CLICK, coninput.DOUBLE_CLICK:
+		ev.Button, ev.Action = mouseEventButton(p, e.ButtonState)
+		if ev.Action == MouseActionRelease {
+			ev.Type = MouseRelease
+		}
+		switch ev.Button {
+		case MouseButtonLeft:
+			ev.Type = MouseLeft
+		case MouseButtonMiddle:
+			ev.Type = MouseMiddle
+		case MouseButtonRight:
+			ev.Type = MouseRight
+		case MouseButtonBackward:
+			ev.Type = MouseBackward
+		case MouseButtonForward:
+			ev.Type = MouseForward
+		}
+	case coninput.MOUSE_WHEELED:
+		if e.WheelDirection > 0 {
+			ev.Button = MouseButtonWheelUp
+			ev.Type = MouseWheelUp
+		} else {
+			ev.Button = MouseButtonWheelDown
+			ev.Type = MouseWheelDown
+		}
+	case coninput.MOUSE_HWHEELED:
+		if e.WheelDirection > 0 {
+			ev.Button = MouseButtonWheelRight
+			ev.Type = MouseWheelRight
+		} else {
+			ev.Button = MouseButtonWheelLeft
+			ev.Type = MouseWheelLeft
+		}
+	case coninput.MOUSE_MOVED:
+		ev.Button, _ = mouseEventButton(p, e.ButtonState)
+		ev.Action = MouseActionMotion
+		ev.Type = MouseMotion
+	}
+
+	return ev
+}
+
+func keyType(e coninput.KeyEventRecord) KeyType {
+	code := e.VirtualKeyCode
+
+	shiftPressed := e.ControlKeyState.Contains(coninput.SHIFT_PRESSED)
+	ctrlPressed := e.ControlKeyState.Contains(coninput.LEFT_CTRL_PRESSED | coninput.RIGHT_CTRL_PRESSED)
+
+	switch code {
+	case coninput.VK_RETURN:
+		return KeyEnter
+	case coninput.VK_BACK:
+		return KeyBackspace
+	case coninput.VK_TAB:
+		if shiftPressed {
+			return KeyShiftTab
+		}
+		return KeyTab
+	case coninput.VK_SPACE:
+		return KeyRunes // this could be KeySpace but on unix space also produces KeyRunes
+	case coninput.VK_ESCAPE:
+		return KeyEscape
+	case coninput.VK_UP:
+		switch {
+		case shiftPressed && ctrlPressed:
+			return KeyCtrlShiftUp
+		case shiftPressed:
+			return KeyShiftUp
+		case ctrlPressed:
+			return KeyCtrlUp
+		default:
+			return KeyUp
+		}
+	case coninput.VK_DOWN:
+		switch {
+		case shiftPressed && ctrlPressed:
+			return KeyCtrlShiftDown
+		case shiftPressed:
+			return KeyShiftDown
+		case ctrlPressed:
+			return KeyCtrlDown
+		default:
+			return KeyDown
+		}
+	case coninput.VK_RIGHT:
+		switch {
+		case shiftPressed && ctrlPressed:
+			return KeyCtrlShiftRight
+		case shiftPressed:
+			return KeyShiftRight
+		case ctrlPressed:
+			return KeyCtrlRight
+		default:
+			return KeyRight
+		}
+	case coninput.VK_LEFT:
+		switch {
+		case shiftPressed && ctrlPressed:
+			return KeyCtrlShiftLeft
+		case shiftPressed:
+			return KeyShiftLeft
+		case ctrlPressed:
+			return KeyCtrlLeft
+		default:
+			return KeyLeft
+		}
+	case coninput.VK_HOME:
+		switch {
+		case shiftPressed && ctrlPressed:
+			return KeyCtrlShiftHome
+		case shiftPressed:
+			return KeyShiftHome
+		case ctrlPressed:
+			return KeyCtrlHome
+		default:
+			return KeyHome
+		}
+	case coninput.VK_END:
+		switch {
+		case shiftPressed && ctrlPressed:
+			return KeyCtrlShiftEnd
+		case shiftPressed:
+			return KeyShiftEnd
+		case ctrlPressed:
+			return KeyCtrlEnd
+		default:
+			return KeyEnd
+		}
+	case coninput.VK_PRIOR:
+		return KeyPgUp
+	case coninput.VK_NEXT:
+		return KeyPgDown
+	case coninput.VK_DELETE:
+		return KeyDelete
+	default:
+		if e.ControlKeyState&(coninput.LEFT_CTRL_PRESSED|coninput.RIGHT_CTRL_PRESSED) == 0 {
+			return KeyRunes
+		}
+
+		switch e.Char {
+		case '@':
+			return KeyCtrlAt
+		case '\x01':
+			return KeyCtrlA
+		case '\x02':
+			return KeyCtrlB
+		case '\x03':
+			return KeyCtrlC
+		case '\x04':
+			return KeyCtrlD
+		case '\x05':
+			return KeyCtrlE
+		case '\x06':
+			return KeyCtrlF
+		case '\a':
+			return KeyCtrlG
+		case '\b':
+			return KeyCtrlH
+		case '\t':
+			return KeyCtrlI
+		case '\n':
+			return KeyCtrlJ
+		case '\v':
+			return KeyCtrlK
+		case '\f':
+			return KeyCtrlL
+		case '\r':
+			return KeyCtrlM
+		case '\x0e':
+			return KeyCtrlN
+		case '\x0f':
+			return KeyCtrlO
+		case '\x10':
+			return KeyCtrlP
+		case '\x11':
+			return KeyCtrlQ
+		case '\x12':
+			return KeyCtrlR
+		case '\x13':
+			return KeyCtrlS
+		case '\x14':
+			return KeyCtrlT
+		case '\x15':
+			return KeyCtrlU
+		case '\x16':
+			return KeyCtrlV
+		case '\x17':
+			return KeyCtrlW
+		case '\x18':
+			return KeyCtrlX
+		case '\x19':
+			return KeyCtrlY
+		case '\x1a':
+			return KeyCtrlZ
+		case '\x1b':
+			return KeyCtrlCloseBracket
+		case '\x1c':
+			return KeyCtrlBackslash
+		case '\x1f':
+			return KeyCtrlUnderscore
+		}
+
+		switch code {
+		case coninput.VK_OEM_4:
+			return KeyCtrlOpenBracket
+		}
+
+		return KeyRunes
+	}
+}

vendor/github.com/charmbracelet/bubbletea/logging.go

@@ -0,0 +1,53 @@
+package tea
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"unicode"
+)
+
+// LogToFile sets up default logging to log to a file. This is helpful as we
+// can't print to the terminal since our TUI is occupying it. If the file
+// doesn't exist it will be created.
+//
+// Don't forget to close the file when you're done with it.
+//
+//	  f, err := LogToFile("debug.log", "debug")
+//	  if err != nil {
+//			fmt.Println("fatal:", err)
+//			os.Exit(1)
+//	  }
+//	  defer f.Close()
+func LogToFile(path string, prefix string) (*os.File, error) {
+	return LogToFileWith(path, prefix, log.Default())
+}
+
+// LogOptionsSetter is an interface implemented by stdlib's log and charm's log
+// libraries.
+type LogOptionsSetter interface {
+	SetOutput(io.Writer)
+	SetPrefix(string)
+}
+
+// LogToFileWith does allows to call LogToFile with a custom LogOptionsSetter.
+func LogToFileWith(path string, prefix string, log LogOptionsSetter) (*os.File, error) {
+	f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0o600) //nolint:gomnd
+	if err != nil {
+		return nil, fmt.Errorf("error opening file for logging: %w", err)
+	}
+	log.SetOutput(f)
+
+	// Add a space after the prefix if a prefix is being specified and it
+	// doesn't already have a trailing space.
+	if len(prefix) > 0 {
+		finalChar := prefix[len(prefix)-1]
+		if !unicode.IsSpace(rune(finalChar)) {
+			prefix += " "
+		}
+	}
+	log.SetPrefix(prefix)
+
+	return f, nil
+}

vendor/github.com/charmbracelet/bubbletea/mouse.go

@@ -0,0 +1,308 @@
+package tea
+
+import "strconv"
+
+// MouseMsg contains information about a mouse event and are sent to a programs
+// update function when mouse activity occurs. Note that the mouse must first
+// be enabled in order for the mouse events to be received.
+type MouseMsg MouseEvent
+
+// String returns a string representation of a mouse event.
+func (m MouseMsg) String() string {
+	return MouseEvent(m).String()
+}
+
+// MouseEvent represents a mouse event, which could be a click, a scroll wheel
+// movement, a cursor movement, or a combination.
+type MouseEvent struct {
+	X      int
+	Y      int
+	Shift  bool
+	Alt    bool
+	Ctrl   bool
+	Action MouseAction
+	Button MouseButton
+
+	// Deprecated: Use MouseAction & MouseButton instead.
+	Type MouseEventType
+}
+
+// IsWheel returns true if the mouse event is a wheel event.
+func (m MouseEvent) IsWheel() bool {
+	return m.Button == MouseButtonWheelUp || m.Button == MouseButtonWheelDown ||
+		m.Button == MouseButtonWheelLeft || m.Button == MouseButtonWheelRight
+}
+
+// String returns a string representation of a mouse event.
+func (m MouseEvent) String() (s string) {
+	if m.Ctrl {
+		s += "ctrl+"
+	}
+	if m.Alt {
+		s += "alt+"
+	}
+	if m.Shift {
+		s += "shift+"
+	}
+
+	if m.Button == MouseButtonNone { //nolint:nestif
+		if m.Action == MouseActionMotion || m.Action == MouseActionRelease {
+			s += mouseActions[m.Action]
+		} else {
+			s += "unknown"
+		}
+	} else if m.IsWheel() {
+		s += mouseButtons[m.Button]
+	} else {
+		btn := mouseButtons[m.Button]
+		if btn != "" {
+			s += btn
+		}
+		act := mouseActions[m.Action]
+		if act != "" {
+			s += " " + act
+		}
+	}
+
+	return s
+}
+
+// MouseAction represents the action that occurred during a mouse event.
+type MouseAction int
+
+// Mouse event actions.
+const (
+	MouseActionPress MouseAction = iota
+	MouseActionRelease
+	MouseActionMotion
+)
+
+var mouseActions = map[MouseAction]string{
+	MouseActionPress:   "press",
+	MouseActionRelease: "release",
+	MouseActionMotion:  "motion",
+}
+
+// MouseButton represents the button that was pressed during a mouse event.
+type MouseButton int
+
+// Mouse event buttons
+//
+// This is based on X11 mouse button codes.
+//
+//	1 = left button
+//	2 = middle button (pressing the scroll wheel)
+//	3 = right button
+//	4 = turn scroll wheel up
+//	5 = turn scroll wheel down
+//	6 = push scroll wheel left
+//	7 = push scroll wheel right
+//	8 = 4th button (aka browser backward button)
+//	9 = 5th button (aka browser forward button)
+//	10
+//	11
+//
+// Other buttons are not supported.
+const (
+	MouseButtonNone MouseButton = iota
+	MouseButtonLeft
+	MouseButtonMiddle
+	MouseButtonRight
+	MouseButtonWheelUp
+	MouseButtonWheelDown
+	MouseButtonWheelLeft
+	MouseButtonWheelRight
+	MouseButtonBackward
+	MouseButtonForward
+	MouseButton10
+	MouseButton11
+)
+
+var mouseButtons = map[MouseButton]string{
+	MouseButtonNone:       "none",
+	MouseButtonLeft:       "left",
+	MouseButtonMiddle:     "middle",
+	MouseButtonRight:      "right",
+	MouseButtonWheelUp:    "wheel up",
+	MouseButtonWheelDown:  "wheel down",
+	MouseButtonWheelLeft:  "wheel left",
+	MouseButtonWheelRight: "wheel right",
+	MouseButtonBackward:   "backward",
+	MouseButtonForward:    "forward",
+	MouseButton10:         "button 10",
+	MouseButton11:         "button 11",
+}
+
+// MouseEventType indicates the type of mouse event occurring.
+//
+// Deprecated: Use MouseAction & MouseButton instead.
+type MouseEventType int
+
+// Mouse event types.
+//
+// Deprecated: Use MouseAction & MouseButton instead.
+const (
+	MouseUnknown MouseEventType = iota
+	MouseLeft
+	MouseRight
+	MouseMiddle
+	MouseRelease // mouse button release (X10 only)
+	MouseWheelUp
+	MouseWheelDown
+	MouseWheelLeft
+	MouseWheelRight
+	MouseBackward
+	MouseForward
+	MouseMotion
+)
+
+// Parse SGR-encoded mouse events; SGR extended mouse events. SGR mouse events
+// look like:
+//
+//	ESC [ < Cb ; Cx ; Cy (M or m)
+//
+// where:
+//
+//	Cb is the encoded button code
+//	Cx is the x-coordinate of the mouse
+//	Cy is the y-coordinate of the mouse
+//	M is for button press, m is for button release
+//
+// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Extended-coordinates
+func parseSGRMouseEvent(buf []byte) MouseEvent {
+	str := string(buf[3:])
+	matches := mouseSGRRegex.FindStringSubmatch(str)
+	if len(matches) != 5 { //nolint:gomnd
+		// Unreachable, we already checked the regex in `detectOneMsg`.
+		panic("invalid mouse event")
+	}
+
+	b, _ := strconv.Atoi(matches[1])
+	px := matches[2]
+	py := matches[3]
+	release := matches[4] == "m"
+	m := parseMouseButton(b, true)
+
+	// Wheel buttons don't have release events
+	// Motion can be reported as a release event in some terminals (Windows Terminal)
+	if m.Action != MouseActionMotion && !m.IsWheel() && release {
+		m.Action = MouseActionRelease
+		m.Type = MouseRelease
+	}
+
+	x, _ := strconv.Atoi(px)
+	y, _ := strconv.Atoi(py)
+
+	// (1,1) is the upper left. We subtract 1 to normalize it to (0,0).
+	m.X = x - 1
+	m.Y = y - 1
+
+	return m
+}
+
+const x10MouseByteOffset = 32
+
+// Parse X10-encoded mouse events; the simplest kind. The last release of X10
+// was December 1986, by the way. The original X10 mouse protocol limits the Cx
+// and Cy coordinates to 223 (=255-032).
+//
+// X10 mouse events look like:
+//
+//	ESC [M Cb Cx Cy
+//
+// See: http://www.xfree86.org/current/ctlseqs.html#Mouse%20Tracking
+func parseX10MouseEvent(buf []byte) MouseEvent {
+	v := buf[3:6]
+	m := parseMouseButton(int(v[0]), false)
+
+	// (1,1) is the upper left. We subtract 1 to normalize it to (0,0).
+	m.X = int(v[1]) - x10MouseByteOffset - 1
+	m.Y = int(v[2]) - x10MouseByteOffset - 1
+
+	return m
+}
+
+// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Extended-coordinates
+func parseMouseButton(b int, isSGR bool) MouseEvent {
+	var m MouseEvent
+	e := b
+	if !isSGR {
+		e -= x10MouseByteOffset
+	}
+
+	const (
+		bitShift  = 0b0000_0100
+		bitAlt    = 0b0000_1000
+		bitCtrl   = 0b0001_0000
+		bitMotion = 0b0010_0000
+		bitWheel  = 0b0100_0000
+		bitAdd    = 0b1000_0000 // additional buttons 8-11
+
+		bitsMask = 0b0000_0011
+	)
+
+	if e&bitAdd != 0 {
+		m.Button = MouseButtonBackward + MouseButton(e&bitsMask)
+	} else if e&bitWheel != 0 {
+		m.Button = MouseButtonWheelUp + MouseButton(e&bitsMask)
+	} else {
+		m.Button = MouseButtonLeft + MouseButton(e&bitsMask)
+		// X10 reports a button release as 0b0000_0011 (3)
+		if e&bitsMask == bitsMask {
+			m.Action = MouseActionRelease
+			m.Button = MouseButtonNone
+		}
+	}
+
+	// Motion bit doesn't get reported for wheel events.
+	if e&bitMotion != 0 && !m.IsWheel() {
+		m.Action = MouseActionMotion
+	}
+
+	// Modifiers
+	m.Alt = e&bitAlt != 0
+	m.Ctrl = e&bitCtrl != 0
+	m.Shift = e&bitShift != 0
+
+	// backward compatibility
+	switch {
+	case m.Button == MouseButtonLeft && m.Action == MouseActionPress:
+		m.Type = MouseLeft
+	case m.Button == MouseButtonMiddle && m.Action == MouseActionPress:
+		m.Type = MouseMiddle
+	case m.Button == MouseButtonRight && m.Action == MouseActionPress:
+		m.Type = MouseRight
+	case m.Button == MouseButtonNone && m.Action == MouseActionRelease:
+		m.Type = MouseRelease
+	case m.Button == MouseButtonWheelUp && m.Action == MouseActionPress:
+		m.Type = MouseWheelUp
+	case m.Button == MouseButtonWheelDown && m.Action == MouseActionPress:
+		m.Type = MouseWheelDown
+	case m.Button == MouseButtonWheelLeft && m.Action == MouseActionPress:
+		m.Type = MouseWheelLeft
+	case m.Button == MouseButtonWheelRight && m.Action == MouseActionPress:
+		m.Type = MouseWheelRight
+	case m.Button == MouseButtonBackward && m.Action == MouseActionPress:
+		m.Type = MouseBackward
+	case m.Button == MouseButtonForward && m.Action == MouseActionPress:
+		m.Type = MouseForward
+	case m.Action == MouseActionMotion:
+		m.Type = MouseMotion
+		switch m.Button { //nolint:exhaustive
+		case MouseButtonLeft:
+			m.Type = MouseLeft
+		case MouseButtonMiddle:
+			m.Type = MouseMiddle
+		case MouseButtonRight:
+			m.Type = MouseRight
+		case MouseButtonBackward:
+			m.Type = MouseBackward
+		case MouseButtonForward:
+			m.Type = MouseForward
+		}
+	default:
+		m.Type = MouseUnknown
+	}
+
+	return m
+}

vendor/github.com/charmbracelet/bubbletea/nil_renderer.go

@@ -0,0 +1,28 @@
+package tea
+
+type nilRenderer struct{}
+
+func (n nilRenderer) start()                     {}
+func (n nilRenderer) stop()                      {}
+func (n nilRenderer) kill()                      {}
+func (n nilRenderer) write(_ string)             {}
+func (n nilRenderer) repaint()                   {}
+func (n nilRenderer) clearScreen()               {}
+func (n nilRenderer) altScreen() bool            { return false }
+func (n nilRenderer) enterAltScreen()            {}
+func (n nilRenderer) exitAltScreen()             {}
+func (n nilRenderer) showCursor()                {}
+func (n nilRenderer) hideCursor()                {}
+func (n nilRenderer) enableMouseCellMotion()     {}
+func (n nilRenderer) disableMouseCellMotion()    {}
+func (n nilRenderer) enableMouseAllMotion()      {}
+func (n nilRenderer) disableMouseAllMotion()     {}
+func (n nilRenderer) enableBracketedPaste()      {}
+func (n nilRenderer) disableBracketedPaste()     {}
+func (n nilRenderer) enableMouseSGRMode()        {}
+func (n nilRenderer) disableMouseSGRMode()       {}
+func (n nilRenderer) bracketedPasteActive() bool { return false }
+func (n nilRenderer) setWindowTitle(_ string)    {}
+func (n nilRenderer) reportFocus() bool          { return false }
+func (n nilRenderer) enableReportFocus()         {}
+func (n nilRenderer) disableReportFocus()        {}

vendor/github.com/charmbracelet/bubbletea/options.go

@@ -0,0 +1,252 @@
+package tea
+
+import (
+	"context"
+	"io"
+	"sync/atomic"
+)
+
+// ProgramOption is used to set options when initializing a Program. Program can
+// accept a variable number of options.
+//
+// Example usage:
+//
+//	p := NewProgram(model, WithInput(someInput), WithOutput(someOutput))
+type ProgramOption func(*Program)
+
+// WithContext lets you specify a context in which to run the Program. This is
+// useful if you want to cancel the execution from outside. When a Program gets
+// cancelled it will exit with an error ErrProgramKilled.
+func WithContext(ctx context.Context) ProgramOption {
+	return func(p *Program) {
+		p.ctx = ctx
+	}
+}
+
+// WithOutput sets the output which, by default, is stdout. In most cases you
+// won't need to use this.
+func WithOutput(output io.Writer) ProgramOption {
+	return func(p *Program) {
+		p.output = output
+	}
+}
+
+// WithInput sets the input which, by default, is stdin. In most cases you
+// won't need to use this. To disable input entirely pass nil.
+//
+//	p := NewProgram(model, WithInput(nil))
+func WithInput(input io.Reader) ProgramOption {
+	return func(p *Program) {
+		p.input = input
+		p.inputType = customInput
+	}
+}
+
+// WithInputTTY opens a new TTY for input (or console input device on Windows).
+func WithInputTTY() ProgramOption {
+	return func(p *Program) {
+		p.inputType = ttyInput
+	}
+}
+
+// WithEnvironment sets the environment variables that the program will use.
+// This useful when the program is running in a remote session (e.g. SSH) and
+// you want to pass the environment variables from the remote session to the
+// program.
+//
+// Example:
+//
+//	var sess ssh.Session // ssh.Session is a type from the github.com/charmbracelet/ssh package
+//	pty, _, _ := sess.Pty()
+//	environ := append(sess.Environ(), "TERM="+pty.Term)
+//	p := tea.NewProgram(model, tea.WithEnvironment(environ)
+func WithEnvironment(env []string) ProgramOption {
+	return func(p *Program) {
+		p.environ = env
+	}
+}
+
+// WithoutSignalHandler disables the signal handler that Bubble Tea sets up for
+// Programs. This is useful if you want to handle signals yourself.
+func WithoutSignalHandler() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withoutSignalHandler
+	}
+}
+
+// WithoutCatchPanics disables the panic catching that Bubble Tea does by
+// default. If panic catching is disabled the terminal will be in a fairly
+// unusable state after a panic because Bubble Tea will not perform its usual
+// cleanup on exit.
+func WithoutCatchPanics() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withoutCatchPanics
+	}
+}
+
+// WithoutSignals will ignore OS signals.
+// This is mainly useful for testing.
+func WithoutSignals() ProgramOption {
+	return func(p *Program) {
+		atomic.StoreUint32(&p.ignoreSignals, 1)
+	}
+}
+
+// WithAltScreen starts the program with the alternate screen buffer enabled
+// (i.e. the program starts in full window mode). Note that the altscreen will
+// be automatically exited when the program quits.
+//
+// Example:
+//
+//	p := tea.NewProgram(Model{}, tea.WithAltScreen())
+//	if _, err := p.Run(); err != nil {
+//	    fmt.Println("Error running program:", err)
+//	    os.Exit(1)
+//	}
+//
+// To enter the altscreen once the program has already started running use the
+// EnterAltScreen command.
+func WithAltScreen() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withAltScreen
+	}
+}
+
+// WithoutBracketedPaste starts the program with bracketed paste disabled.
+func WithoutBracketedPaste() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withoutBracketedPaste
+	}
+}
+
+// WithMouseCellMotion starts the program with the mouse enabled in "cell
+// motion" mode.
+//
+// Cell motion mode enables mouse click, release, and wheel events. Mouse
+// movement events are also captured if a mouse button is pressed (i.e., drag
+// events). Cell motion mode is better supported than all motion mode.
+//
+// This will try to enable the mouse in extended mode (SGR), if that is not
+// supported by the terminal it will fall back to normal mode (X10).
+//
+// To enable mouse cell motion once the program has already started running use
+// the EnableMouseCellMotion command. To disable the mouse when the program is
+// running use the DisableMouse command.
+//
+// The mouse will be automatically disabled when the program exits.
+func WithMouseCellMotion() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withMouseCellMotion // set
+		p.startupOptions &^= withMouseAllMotion // clear
+	}
+}
+
+// WithMouseAllMotion starts the program with the mouse enabled in "all motion"
+// mode.
+//
+// EnableMouseAllMotion is a special command that enables mouse click, release,
+// wheel, and motion events, which are delivered regardless of whether a mouse
+// button is pressed, effectively enabling support for hover interactions.
+//
+// This will try to enable the mouse in extended mode (SGR), if that is not
+// supported by the terminal it will fall back to normal mode (X10).
+//
+// Many modern terminals support this, but not all. If in doubt, use
+// EnableMouseCellMotion instead.
+//
+// To enable the mouse once the program has already started running use the
+// EnableMouseAllMotion command. To disable the mouse when the program is
+// running use the DisableMouse command.
+//
+// The mouse will be automatically disabled when the program exits.
+func WithMouseAllMotion() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withMouseAllMotion   // set
+		p.startupOptions &^= withMouseCellMotion // clear
+	}
+}
+
+// WithoutRenderer disables the renderer. When this is set output and log
+// statements will be plainly sent to stdout (or another output if one is set)
+// without any rendering and redrawing logic. In other words, printing and
+// logging will behave the same way it would in a non-TUI commandline tool.
+// This can be useful if you want to use the Bubble Tea framework for a non-TUI
+// application, or to provide an additional non-TUI mode to your Bubble Tea
+// programs. For example, your program could behave like a daemon if output is
+// not a TTY.
+func WithoutRenderer() ProgramOption {
+	return func(p *Program) {
+		p.renderer = &nilRenderer{}
+	}
+}
+
+// WithANSICompressor removes redundant ANSI sequences to produce potentially
+// smaller output, at the cost of some processing overhead.
+//
+// This feature is provisional, and may be changed or removed in a future version
+// of this package.
+//
+// Deprecated: this incurs a noticable performance hit. A future release will
+// optimize ANSI automatically without the performance penalty.
+func WithANSICompressor() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withANSICompressor
+	}
+}
+
+// WithFilter supplies an event filter that will be invoked before Bubble Tea
+// processes a tea.Msg. The event filter can return any tea.Msg which will then
+// get handled by Bubble Tea instead of the original event. If the event filter
+// returns nil, the event will be ignored and Bubble Tea will not process it.
+//
+// As an example, this could be used to prevent a program from shutting down if
+// there are unsaved changes.
+//
+// Example:
+//
+//	func filter(m tea.Model, msg tea.Msg) tea.Msg {
+//		if _, ok := msg.(tea.QuitMsg); !ok {
+//			return msg
+//		}
+//
+//		model := m.(myModel)
+//		if model.hasChanges {
+//			return nil
+//		}
+//
+//		return msg
+//	}
+//
+//	p := tea.NewProgram(Model{}, tea.WithFilter(filter));
+//
+//	if _,err := p.Run(); err != nil {
+//		fmt.Println("Error running program:", err)
+//		os.Exit(1)
+//	}
+func WithFilter(filter func(Model, Msg) Msg) ProgramOption {
+	return func(p *Program) {
+		p.filter = filter
+	}
+}
+
+// WithFPS sets a custom maximum FPS at which the renderer should run. If
+// less than 1, the default value of 60 will be used. If over 120, the FPS
+// will be capped at 120.
+func WithFPS(fps int) ProgramOption {
+	return func(p *Program) {
+		p.fps = fps
+	}
+}
+
+// WithReportFocus enables reporting when the terminal gains and loses
+// focus. When this is enabled [FocusMsg] and [BlurMsg] messages will be sent
+// to your Update method.
+//
+// Note that while most terminals and multiplexers support focus reporting,
+// some do not. Also note that tmux needs to be configured to report focus
+// events.
+func WithReportFocus() ProgramOption {
+	return func(p *Program) {
+		p.startupOptions |= withReportFocus
+	}
+}

vendor/github.com/charmbracelet/bubbletea/renderer.go

@@ -0,0 +1,85 @@
+package tea
+
+// renderer is the interface for Bubble Tea renderers.
+type renderer interface {
+	// Start the renderer.
+	start()
+
+	// Stop the renderer, but render the final frame in the buffer, if any.
+	stop()
+
+	// Stop the renderer without doing any final rendering.
+	kill()
+
+	// Write a frame to the renderer. The renderer can write this data to
+	// output at its discretion.
+	write(string)
+
+	// Request a full re-render. Note that this will not trigger a render
+	// immediately. Rather, this method causes the next render to be a full
+	// repaint. Because of this, it's safe to call this method multiple times
+	// in succession.
+	repaint()
+
+	// Clears the terminal.
+	clearScreen()
+
+	// Whether or not the alternate screen buffer is enabled.
+	altScreen() bool
+	// Enable the alternate screen buffer.
+	enterAltScreen()
+	// Disable the alternate screen buffer.
+	exitAltScreen()
+
+	// Show the cursor.
+	showCursor()
+	// Hide the cursor.
+	hideCursor()
+
+	// enableMouseCellMotion enables mouse click, release, wheel and motion
+	// events if a mouse button is pressed (i.e., drag events).
+	enableMouseCellMotion()
+
+	// disableMouseCellMotion disables Mouse Cell Motion tracking.
+	disableMouseCellMotion()
+
+	// enableMouseAllMotion enables mouse click, release, wheel and motion
+	// events, regardless of whether a mouse button is pressed. Many modern
+	// terminals support this, but not all.
+	enableMouseAllMotion()
+
+	// disableMouseAllMotion disables All Motion mouse tracking.
+	disableMouseAllMotion()
+
+	// enableMouseSGRMode enables mouse extended mode (SGR).
+	enableMouseSGRMode()
+
+	// disableMouseSGRMode disables mouse extended mode (SGR).
+	disableMouseSGRMode()
+
+	// enableBracketedPaste enables bracketed paste, where characters
+	// inside the input are not interpreted when pasted as a whole.
+	enableBracketedPaste()
+
+	// disableBracketedPaste disables bracketed paste.
+	disableBracketedPaste()
+
+	// bracketedPasteActive reports whether bracketed paste mode is
+	// currently enabled.
+	bracketedPasteActive() bool
+
+	// setWindowTitle sets the terminal window title.
+	setWindowTitle(string)
+
+	// reportFocus returns whether reporting focus events is enabled.
+	reportFocus() bool
+
+	// enableReportFocus reports focus events to the program.
+	enableReportFocus()
+
+	// disableReportFocus stops reporting focus events to the program.
+	disableReportFocus()
+}
+
+// repaintMsg forces a full repaint.
+type repaintMsg struct{}

vendor/github.com/charmbracelet/bubbletea/screen.go

@@ -0,0 +1,248 @@
+package tea
+
+// WindowSizeMsg is used to report the terminal size. It's sent to Update once
+// initially and then on every terminal resize. Note that Windows does not
+// have support for reporting when resizes occur as it does not support the
+// SIGWINCH signal.
+type WindowSizeMsg struct {
+	Width  int
+	Height int
+}
+
+// ClearScreen is a special command that tells the program to clear the screen
+// before the next update. This can be used to move the cursor to the top left
+// of the screen and clear visual clutter when the alt screen is not in use.
+//
+// Note that it should never be necessary to call ClearScreen() for regular
+// redraws.
+func ClearScreen() Msg {
+	return clearScreenMsg{}
+}
+
+// clearScreenMsg is an internal message that signals to clear the screen.
+// You can send a clearScreenMsg with ClearScreen.
+type clearScreenMsg struct{}
+
+// EnterAltScreen is a special command that tells the Bubble Tea program to
+// enter the alternate screen buffer.
+//
+// Because commands run asynchronously, this command should not be used in your
+// model's Init function. To initialize your program with the altscreen enabled
+// use the WithAltScreen ProgramOption instead.
+func EnterAltScreen() Msg {
+	return enterAltScreenMsg{}
+}
+
+// enterAltScreenMsg in an internal message signals that the program should
+// enter alternate screen buffer. You can send a enterAltScreenMsg with
+// EnterAltScreen.
+type enterAltScreenMsg struct{}
+
+// ExitAltScreen is a special command that tells the Bubble Tea program to exit
+// the alternate screen buffer. This command should be used to exit the
+// alternate screen buffer while the program is running.
+//
+// Note that the alternate screen buffer will be automatically exited when the
+// program quits.
+func ExitAltScreen() Msg {
+	return exitAltScreenMsg{}
+}
+
+// exitAltScreenMsg in an internal message signals that the program should exit
+// alternate screen buffer. You can send a exitAltScreenMsg with ExitAltScreen.
+type exitAltScreenMsg struct{}
+
+// EnableMouseCellMotion is a special command that enables mouse click,
+// release, and wheel events. Mouse movement events are also captured if
+// a mouse button is pressed (i.e., drag events).
+//
+// Because commands run asynchronously, this command should not be used in your
+// model's Init function. Use the WithMouseCellMotion ProgramOption instead.
+func EnableMouseCellMotion() Msg {
+	return enableMouseCellMotionMsg{}
+}
+
+// enableMouseCellMotionMsg is a special command that signals to start
+// listening for "cell motion" type mouse events (ESC[?1002l). To send an
+// enableMouseCellMotionMsg, use the EnableMouseCellMotion command.
+type enableMouseCellMotionMsg struct{}
+
+// EnableMouseAllMotion is a special command that enables mouse click, release,
+// wheel, and motion events, which are delivered regardless of whether a mouse
+// button is pressed, effectively enabling support for hover interactions.
+//
+// Many modern terminals support this, but not all. If in doubt, use
+// EnableMouseCellMotion instead.
+//
+// Because commands run asynchronously, this command should not be used in your
+// model's Init function. Use the WithMouseAllMotion ProgramOption instead.
+func EnableMouseAllMotion() Msg {
+	return enableMouseAllMotionMsg{}
+}
+
+// enableMouseAllMotionMsg is a special command that signals to start listening
+// for "all motion" type mouse events (ESC[?1003l). To send an
+// enableMouseAllMotionMsg, use the EnableMouseAllMotion command.
+type enableMouseAllMotionMsg struct{}
+
+// DisableMouse is a special command that stops listening for mouse events.
+func DisableMouse() Msg {
+	return disableMouseMsg{}
+}
+
+// disableMouseMsg is an internal message that signals to stop listening
+// for mouse events. To send a disableMouseMsg, use the DisableMouse command.
+type disableMouseMsg struct{}
+
+// HideCursor is a special command for manually instructing Bubble Tea to hide
+// the cursor. In some rare cases, certain operations will cause the terminal
+// to show the cursor, which is normally hidden for the duration of a Bubble
+// Tea program's lifetime. You will most likely not need to use this command.
+func HideCursor() Msg {
+	return hideCursorMsg{}
+}
+
+// hideCursorMsg is an internal command used to hide the cursor. You can send
+// this message with HideCursor.
+type hideCursorMsg struct{}
+
+// ShowCursor is a special command for manually instructing Bubble Tea to show
+// the cursor.
+func ShowCursor() Msg {
+	return showCursorMsg{}
+}
+
+// showCursorMsg is an internal command used to show the cursor. You can send
+// this message with ShowCursor.
+type showCursorMsg struct{}
+
+// EnableBracketedPaste is a special command that tells the Bubble Tea program
+// to accept bracketed paste input.
+//
+// Note that bracketed paste will be automatically disabled when the
+// program quits.
+func EnableBracketedPaste() Msg {
+	return enableBracketedPasteMsg{}
+}
+
+// enableBracketedPasteMsg in an internal message signals that
+// bracketed paste should be enabled. You can send an
+// enableBracketedPasteMsg with EnableBracketedPaste.
+type enableBracketedPasteMsg struct{}
+
+// DisableBracketedPaste is a special command that tells the Bubble Tea program
+// to accept bracketed paste input.
+//
+// Note that bracketed paste will be automatically disabled when the
+// program quits.
+func DisableBracketedPaste() Msg {
+	return disableBracketedPasteMsg{}
+}
+
+// disableBracketedPasteMsg in an internal message signals that
+// bracketed paste should be disabled. You can send an
+// disableBracketedPasteMsg with DisableBracketedPaste.
+type disableBracketedPasteMsg struct{}
+
+// enableReportFocusMsg is an internal message that signals to enable focus
+// reporting. You can send an enableReportFocusMsg with EnableReportFocus.
+type enableReportFocusMsg struct{}
+
+// EnableReportFocus is a special command that tells the Bubble Tea program to
+// report focus events to the program.
+func EnableReportFocus() Msg {
+	return enableReportFocusMsg{}
+}
+
+// disableReportFocusMsg is an internal message that signals to disable focus
+// reporting. You can send an disableReportFocusMsg with DisableReportFocus.
+type disableReportFocusMsg struct{}
+
+// DisableReportFocus is a special command that tells the Bubble Tea program to
+// stop reporting focus events to the program.
+func DisableReportFocus() Msg {
+	return disableReportFocusMsg{}
+}
+
+// EnterAltScreen enters the alternate screen buffer, which consumes the entire
+// terminal window. ExitAltScreen will return the terminal to its former state.
+//
+// Deprecated: Use the WithAltScreen ProgramOption instead.
+func (p *Program) EnterAltScreen() {
+	if p.renderer != nil {
+		p.renderer.enterAltScreen()
+	} else {
+		p.startupOptions |= withAltScreen
+	}
+}
+
+// ExitAltScreen exits the alternate screen buffer.
+//
+// Deprecated: The altscreen will exited automatically when the program exits.
+func (p *Program) ExitAltScreen() {
+	if p.renderer != nil {
+		p.renderer.exitAltScreen()
+	} else {
+		p.startupOptions &^= withAltScreen
+	}
+}
+
+// EnableMouseCellMotion enables mouse click, release, wheel and motion events
+// if a mouse button is pressed (i.e., drag events).
+//
+// Deprecated: Use the WithMouseCellMotion ProgramOption instead.
+func (p *Program) EnableMouseCellMotion() {
+	if p.renderer != nil {
+		p.renderer.enableMouseCellMotion()
+	} else {
+		p.startupOptions |= withMouseCellMotion
+	}
+}
+
+// DisableMouseCellMotion disables Mouse Cell Motion tracking. This will be
+// called automatically when exiting a Bubble Tea program.
+//
+// Deprecated: The mouse will automatically be disabled when the program exits.
+func (p *Program) DisableMouseCellMotion() {
+	if p.renderer != nil {
+		p.renderer.disableMouseCellMotion()
+	} else {
+		p.startupOptions &^= withMouseCellMotion
+	}
+}
+
+// EnableMouseAllMotion enables mouse click, release, wheel and motion events,
+// regardless of whether a mouse button is pressed. Many modern terminals
+// support this, but not all.
+//
+// Deprecated: Use the WithMouseAllMotion ProgramOption instead.
+func (p *Program) EnableMouseAllMotion() {
+	if p.renderer != nil {
+		p.renderer.enableMouseAllMotion()
+	} else {
+		p.startupOptions |= withMouseAllMotion
+	}
+}
+
+// DisableMouseAllMotion disables All Motion mouse tracking. This will be
+// called automatically when exiting a Bubble Tea program.
+//
+// Deprecated: The mouse will automatically be disabled when the program exits.
+func (p *Program) DisableMouseAllMotion() {
+	if p.renderer != nil {
+		p.renderer.disableMouseAllMotion()
+	} else {
+		p.startupOptions &^= withMouseAllMotion
+	}
+}
+
+// SetWindowTitle sets the terminal window title.
+//
+// Deprecated: Use the SetWindowTitle command instead.
+func (p *Program) SetWindowTitle(title string) {
+	if p.renderer != nil {
+		p.renderer.setWindowTitle(title)
+	} else {
+		p.startupTitle = title
+	}
+}

vendor/github.com/charmbracelet/bubbletea/signals_unix.go

@@ -0,0 +1,33 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix || zos
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix zos
+
+package tea
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+// listenForResize sends messages (or errors) when the terminal resizes.
+// Argument output should be the file descriptor for the terminal; usually
+// os.Stdout.
+func (p *Program) listenForResize(done chan struct{}) {
+	sig := make(chan os.Signal, 1)
+	signal.Notify(sig, syscall.SIGWINCH)
+
+	defer func() {
+		signal.Stop(sig)
+		close(done)
+	}()
+
+	for {
+		select {
+		case <-p.ctx.Done():
+			return
+		case <-sig:
+		}
+
+		p.checkResize()
+	}
+}

vendor/github.com/charmbracelet/bubbletea/signals_windows.go

@@ -0,0 +1,10 @@
+//go:build windows
+// +build windows
+
+package tea
+
+// listenForResize is not available on windows because windows does not
+// implement syscall.SIGWINCH.
+func (p *Program) listenForResize(done chan struct{}) {
+	close(done)
+}

vendor/github.com/charmbracelet/bubbletea/standard_renderer.go

@@ -0,0 +1,782 @@
+package tea
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/charmbracelet/x/ansi"
+	"github.com/muesli/ansi/compressor"
+)
+
+const (
+	// defaultFramerate specifies the maximum interval at which we should
+	// update the view.
+	defaultFPS = 60
+	maxFPS     = 120
+)
+
+// standardRenderer is a framerate-based terminal renderer, updating the view
+// at a given framerate to avoid overloading the terminal emulator.
+//
+// In cases where very high performance is needed the renderer can be told
+// to exclude ranges of lines, allowing them to be written to directly.
+type standardRenderer struct {
+	mtx *sync.Mutex
+	out io.Writer
+
+	buf                bytes.Buffer
+	queuedMessageLines []string
+	framerate          time.Duration
+	ticker             *time.Ticker
+	done               chan struct{}
+	lastRender         string
+	lastRenderedLines  []string
+	linesRendered      int
+	altLinesRendered   int
+	useANSICompressor  bool
+	once               sync.Once
+
+	// cursor visibility state
+	cursorHidden bool
+
+	// essentially whether or not we're using the full size of the terminal
+	altScreenActive bool
+
+	// whether or not we're currently using bracketed paste
+	bpActive bool
+
+	// reportingFocus whether reporting focus events is enabled
+	reportingFocus bool
+
+	// renderer dimensions; usually the size of the window
+	width  int
+	height int
+
+	// lines explicitly set not to render
+	ignoreLines map[int]struct{}
+}
+
+// newRenderer creates a new renderer. Normally you'll want to initialize it
+// with os.Stdout as the first argument.
+func newRenderer(out io.Writer, useANSICompressor bool, fps int) renderer {
+	if fps < 1 {
+		fps = defaultFPS
+	} else if fps > maxFPS {
+		fps = maxFPS
+	}
+	r := &standardRenderer{
+		out:                out,
+		mtx:                &sync.Mutex{},
+		done:               make(chan struct{}),
+		framerate:          time.Second / time.Duration(fps),
+		useANSICompressor:  useANSICompressor,
+		queuedMessageLines: []string{},
+	}
+	if r.useANSICompressor {
+		r.out = &compressor.Writer{Forward: out}
+	}
+	return r
+}
+
+// start starts the renderer.
+func (r *standardRenderer) start() {
+	if r.ticker == nil {
+		r.ticker = time.NewTicker(r.framerate)
+	} else {
+		// If the ticker already exists, it has been stopped and we need to
+		// reset it.
+		r.ticker.Reset(r.framerate)
+	}
+
+	// Since the renderer can be restarted after a stop, we need to reset
+	// the done channel and its corresponding sync.Once.
+	r.once = sync.Once{}
+
+	go r.listen()
+}
+
+// stop permanently halts the renderer, rendering the final frame.
+func (r *standardRenderer) stop() {
+	// Stop the renderer before acquiring the mutex to avoid a deadlock.
+	r.once.Do(func() {
+		r.done <- struct{}{}
+	})
+
+	// flush locks the mutex
+	r.flush()
+
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EraseEntireLine)
+	// Move the cursor back to the beginning of the line
+	r.execute("\r")
+
+	if r.useANSICompressor {
+		if w, ok := r.out.(io.WriteCloser); ok {
+			_ = w.Close()
+		}
+	}
+}
+
+// execute writes a sequence to the terminal.
+func (r *standardRenderer) execute(seq string) {
+	_, _ = io.WriteString(r.out, seq)
+}
+
+// kill halts the renderer. The final frame will not be rendered.
+func (r *standardRenderer) kill() {
+	// Stop the renderer before acquiring the mutex to avoid a deadlock.
+	r.once.Do(func() {
+		r.done <- struct{}{}
+	})
+
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EraseEntireLine)
+	// Move the cursor back to the beginning of the line
+	r.execute("\r")
+}
+
+// listen waits for ticks on the ticker, or a signal to stop the renderer.
+func (r *standardRenderer) listen() {
+	for {
+		select {
+		case <-r.done:
+			r.ticker.Stop()
+			return
+
+		case <-r.ticker.C:
+			r.flush()
+		}
+	}
+}
+
+// flush renders the buffer.
+func (r *standardRenderer) flush() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	if r.buf.Len() == 0 || r.buf.String() == r.lastRender {
+		// Nothing to do.
+		return
+	}
+
+	// Output buffer.
+	buf := &bytes.Buffer{}
+
+	// Moving to the beginning of the section, that we rendered.
+	if r.altScreenActive {
+		buf.WriteString(ansi.HomeCursorPosition)
+	} else if r.linesRendered > 1 {
+		buf.WriteString(ansi.CursorUp(r.linesRendered - 1))
+	}
+
+	newLines := strings.Split(r.buf.String(), "\n")
+
+	// If we know the output's height, we can use it to determine how many
+	// lines we can render. We drop lines from the top of the render buffer if
+	// necessary, as we can't navigate the cursor into the terminal's scrollback
+	// buffer.
+	if r.height > 0 && len(newLines) > r.height {
+		newLines = newLines[len(newLines)-r.height:]
+	}
+
+	flushQueuedMessages := len(r.queuedMessageLines) > 0 && !r.altScreenActive
+
+	if flushQueuedMessages {
+		// Dump the lines we've queued up for printing.
+		for _, line := range r.queuedMessageLines {
+			if ansi.StringWidth(line) < r.width {
+				// We only erase the rest of the line when the line is shorter than
+				// the width of the terminal. When the cursor reaches the end of
+				// the line, any escape sequences that follow will only affect the
+				// last cell of the line.
+
+				// Removing previously rendered content at the end of line.
+				line = line + ansi.EraseLineRight
+			}
+
+			_, _ = buf.WriteString(line)
+			_, _ = buf.WriteString("\r\n")
+		}
+		// Clear the queued message lines.
+		r.queuedMessageLines = []string{}
+	}
+
+	// Paint new lines.
+	for i := 0; i < len(newLines); i++ {
+		canSkip := !flushQueuedMessages && // Queuing messages triggers repaint -> we don't have access to previous frame content.
+			len(r.lastRenderedLines) > i && r.lastRenderedLines[i] == newLines[i] // Previously rendered line is the same.
+
+		if _, ignore := r.ignoreLines[i]; ignore || canSkip {
+			// Unless this is the last line, move the cursor down.
+			if i < len(newLines)-1 {
+				buf.WriteString(ansi.CursorDown1)
+			}
+			continue
+		}
+
+		if i == 0 && r.lastRender == "" {
+			// On first render, reset the cursor to the start of the line
+			// before writing anything.
+			buf.WriteByte('\r')
+		}
+
+		line := newLines[i]
+
+		// Truncate lines wider than the width of the window to avoid
+		// wrapping, which will mess up rendering. If we don't have the
+		// width of the window this will be ignored.
+		//
+		// Note that on Windows we only get the width of the window on
+		// program initialization, so after a resize this won't perform
+		// correctly (signal SIGWINCH is not supported on Windows).
+		if r.width > 0 {
+			line = ansi.Truncate(line, r.width, "")
+		}
+
+		if ansi.StringWidth(line) < r.width {
+			// We only erase the rest of the line when the line is shorter than
+			// the width of the terminal. When the cursor reaches the end of
+			// the line, any escape sequences that follow will only affect the
+			// last cell of the line.
+
+			// Removing previously rendered content at the end of line.
+			line = line + ansi.EraseLineRight
+		}
+
+		_, _ = buf.WriteString(line)
+
+		if i < len(newLines)-1 {
+			_, _ = buf.WriteString("\r\n")
+		}
+	}
+
+	lastLinesRendered := r.linesRendered
+	if r.altScreenActive {
+		lastLinesRendered = r.altLinesRendered
+	}
+
+	// Clearing left over content from last render.
+	if lastLinesRendered > len(newLines) {
+		buf.WriteString(ansi.EraseScreenBelow)
+	}
+
+	if r.altScreenActive {
+		r.altLinesRendered = len(newLines)
+	} else {
+		r.linesRendered = len(newLines)
+	}
+
+	// Make sure the cursor is at the start of the last line to keep rendering
+	// behavior consistent.
+	if r.altScreenActive {
+		// This case fixes a bug in macOS terminal. In other terminals the
+		// other case seems to do the job regardless of whether or not we're
+		// using the full terminal window.
+		buf.WriteString(ansi.SetCursorPosition(0, len(newLines)))
+	} else {
+		buf.WriteString(ansi.CursorLeft(r.width))
+	}
+
+	_, _ = r.out.Write(buf.Bytes())
+	r.lastRender = r.buf.String()
+
+	// Save previously rendered lines for comparison in the next render. If we
+	// don't do this, we can't skip rendering lines that haven't changed.
+	// See https://github.com/charmbracelet/bubbletea/pull/1233
+	r.lastRenderedLines = newLines
+	r.buf.Reset()
+}
+
+// write writes to the internal buffer. The buffer will be outputted via the
+// ticker which calls flush().
+func (r *standardRenderer) write(s string) {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+	r.buf.Reset()
+
+	// If an empty string was passed we should clear existing output and
+	// rendering nothing. Rather than introduce additional state to manage
+	// this, we render a single space as a simple (albeit less correct)
+	// solution.
+	if s == "" {
+		s = " "
+	}
+
+	_, _ = r.buf.WriteString(s)
+}
+
+func (r *standardRenderer) repaint() {
+	r.lastRender = ""
+	r.lastRenderedLines = nil
+}
+
+func (r *standardRenderer) clearScreen() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EraseEntireScreen)
+	r.execute(ansi.HomeCursorPosition)
+
+	r.repaint()
+}
+
+func (r *standardRenderer) altScreen() bool {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	return r.altScreenActive
+}
+
+func (r *standardRenderer) enterAltScreen() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	if r.altScreenActive {
+		return
+	}
+
+	r.altScreenActive = true
+	r.execute(ansi.EnableAltScreenBuffer)
+
+	// Ensure that the terminal is cleared, even when it doesn't support
+	// alt screen (or alt screen support is disabled, like GNU screen by
+	// default).
+	//
+	// Note: we can't use r.clearScreen() here because the mutex is already
+	// locked.
+	r.execute(ansi.EraseEntireScreen)
+	r.execute(ansi.HomeCursorPosition)
+
+	// cmd.exe and other terminals keep separate cursor states for the AltScreen
+	// and the main buffer. We have to explicitly reset the cursor visibility
+	// whenever we enter AltScreen.
+	if r.cursorHidden {
+		r.execute(ansi.HideCursor)
+	} else {
+		r.execute(ansi.ShowCursor)
+	}
+
+	// Entering the alt screen resets the lines rendered count.
+	r.altLinesRendered = 0
+
+	r.repaint()
+}
+
+func (r *standardRenderer) exitAltScreen() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	if !r.altScreenActive {
+		return
+	}
+
+	r.altScreenActive = false
+	r.execute(ansi.DisableAltScreenBuffer)
+
+	// cmd.exe and other terminals keep separate cursor states for the AltScreen
+	// and the main buffer. We have to explicitly reset the cursor visibility
+	// whenever we exit AltScreen.
+	if r.cursorHidden {
+		r.execute(ansi.HideCursor)
+	} else {
+		r.execute(ansi.ShowCursor)
+	}
+
+	r.repaint()
+}
+
+func (r *standardRenderer) showCursor() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.cursorHidden = false
+	r.execute(ansi.ShowCursor)
+}
+
+func (r *standardRenderer) hideCursor() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.cursorHidden = true
+	r.execute(ansi.HideCursor)
+}
+
+func (r *standardRenderer) enableMouseCellMotion() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EnableMouseCellMotion)
+}
+
+func (r *standardRenderer) disableMouseCellMotion() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.DisableMouseCellMotion)
+}
+
+func (r *standardRenderer) enableMouseAllMotion() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EnableMouseAllMotion)
+}
+
+func (r *standardRenderer) disableMouseAllMotion() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.DisableMouseAllMotion)
+}
+
+func (r *standardRenderer) enableMouseSGRMode() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EnableMouseSgrExt)
+}
+
+func (r *standardRenderer) disableMouseSGRMode() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.DisableMouseSgrExt)
+}
+
+func (r *standardRenderer) enableBracketedPaste() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EnableBracketedPaste)
+	r.bpActive = true
+}
+
+func (r *standardRenderer) disableBracketedPaste() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.DisableBracketedPaste)
+	r.bpActive = false
+}
+
+func (r *standardRenderer) bracketedPasteActive() bool {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	return r.bpActive
+}
+
+func (r *standardRenderer) enableReportFocus() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.EnableReportFocus)
+	r.reportingFocus = true
+}
+
+func (r *standardRenderer) disableReportFocus() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	r.execute(ansi.DisableReportFocus)
+	r.reportingFocus = false
+}
+
+func (r *standardRenderer) reportFocus() bool {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	return r.reportingFocus
+}
+
+// setWindowTitle sets the terminal window title.
+func (r *standardRenderer) setWindowTitle(title string) {
+	r.execute(ansi.SetWindowTitle(title))
+}
+
+// setIgnoredLines specifies lines not to be touched by the standard Bubble Tea
+// renderer.
+func (r *standardRenderer) setIgnoredLines(from int, to int) {
+	// Lock if we're going to be clearing some lines since we don't want
+	// anything jacking our cursor.
+	if r.linesRendered > 0 {
+		r.mtx.Lock()
+		defer r.mtx.Unlock()
+	}
+
+	if r.ignoreLines == nil {
+		r.ignoreLines = make(map[int]struct{})
+	}
+	for i := from; i < to; i++ {
+		r.ignoreLines[i] = struct{}{}
+	}
+
+	// Erase ignored lines
+	if r.linesRendered > 0 {
+		buf := &bytes.Buffer{}
+
+		for i := r.linesRendered - 1; i >= 0; i-- {
+			if _, exists := r.ignoreLines[i]; exists {
+				buf.WriteString(ansi.EraseEntireLine)
+			}
+			buf.WriteString(ansi.CursorUp1)
+		}
+		buf.WriteString(ansi.SetCursorPosition(0, r.linesRendered)) // put cursor back
+		_, _ = r.out.Write(buf.Bytes())
+	}
+}
+
+// clearIgnoredLines returns control of any ignored lines to the standard
+// Bubble Tea renderer. That is, any lines previously set to be ignored can be
+// rendered to again.
+func (r *standardRenderer) clearIgnoredLines() {
+	r.ignoreLines = nil
+}
+
+// insertTop effectively scrolls up. It inserts lines at the top of a given
+// area designated to be a scrollable region, pushing everything else down.
+// This is roughly how ncurses does it.
+//
+// To call this function use command ScrollUp().
+//
+// For this to work renderer.ignoreLines must be set to ignore the scrollable
+// region since we are bypassing the normal Bubble Tea renderer here.
+//
+// Because this method relies on the terminal dimensions, it's only valid for
+// full-window applications (generally those that use the alternate screen
+// buffer).
+//
+// This method bypasses the normal rendering buffer and is philosophically
+// different than the normal way we approach rendering in Bubble Tea. It's for
+// use in high-performance rendering, such as a pager that could potentially
+// be rendering very complicated ansi. In cases where the content is simpler
+// standard Bubble Tea rendering should suffice.
+//
+// Deprecated: This option is deprecated and will be removed in a future
+// version of this package.
+func (r *standardRenderer) insertTop(lines []string, topBoundary, bottomBoundary int) {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	buf := &bytes.Buffer{}
+
+	buf.WriteString(ansi.SetScrollingRegion(topBoundary, bottomBoundary))
+	buf.WriteString(ansi.SetCursorPosition(0, topBoundary))
+	buf.WriteString(ansi.InsertLine(len(lines)))
+	_, _ = buf.WriteString(strings.Join(lines, "\r\n"))
+	buf.WriteString(ansi.SetScrollingRegion(0, r.height))
+
+	// Move cursor back to where the main rendering routine expects it to be
+	buf.WriteString(ansi.SetCursorPosition(0, r.linesRendered))
+
+	_, _ = r.out.Write(buf.Bytes())
+}
+
+// insertBottom effectively scrolls down. It inserts lines at the bottom of
+// a given area designated to be a scrollable region, pushing everything else
+// up. This is roughly how ncurses does it.
+//
+// To call this function use the command ScrollDown().
+//
+// See note in insertTop() for caveats, how this function only makes sense for
+// full-window applications, and how it differs from the normal way we do
+// rendering in Bubble Tea.
+//
+// Deprecated: This option is deprecated and will be removed in a future
+// version of this package.
+func (r *standardRenderer) insertBottom(lines []string, topBoundary, bottomBoundary int) {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+
+	buf := &bytes.Buffer{}
+
+	buf.WriteString(ansi.SetScrollingRegion(topBoundary, bottomBoundary))
+	buf.WriteString(ansi.SetCursorPosition(0, bottomBoundary))
+	_, _ = buf.WriteString("\r\n" + strings.Join(lines, "\r\n"))
+	buf.WriteString(ansi.SetScrollingRegion(0, r.height))
+
+	// Move cursor back to where the main rendering routine expects it to be
+	buf.WriteString(ansi.SetCursorPosition(0, r.linesRendered))
+
+	_, _ = r.out.Write(buf.Bytes())
+}
+
+// handleMessages handles internal messages for the renderer.
+func (r *standardRenderer) handleMessages(msg Msg) {
+	switch msg := msg.(type) {
+	case repaintMsg:
+		// Force a repaint by clearing the render cache as we slide into a
+		// render.
+		r.mtx.Lock()
+		r.repaint()
+		r.mtx.Unlock()
+
+	case WindowSizeMsg:
+		r.mtx.Lock()
+		r.width = msg.Width
+		r.height = msg.Height
+		r.repaint()
+		r.mtx.Unlock()
+
+	case clearScrollAreaMsg:
+		r.clearIgnoredLines()
+
+		// Force a repaint on the area where the scrollable stuff was in this
+		// update cycle
+		r.mtx.Lock()
+		r.repaint()
+		r.mtx.Unlock()
+
+	case syncScrollAreaMsg:
+		// Re-render scrolling area
+		r.clearIgnoredLines()
+		r.setIgnoredLines(msg.topBoundary, msg.bottomBoundary)
+		r.insertTop(msg.lines, msg.topBoundary, msg.bottomBoundary)
+
+		// Force non-scrolling stuff to repaint in this update cycle
+		r.mtx.Lock()
+		r.repaint()
+		r.mtx.Unlock()
+
+	case scrollUpMsg:
+		r.insertTop(msg.lines, msg.topBoundary, msg.bottomBoundary)
+
+	case scrollDownMsg:
+		r.insertBottom(msg.lines, msg.topBoundary, msg.bottomBoundary)
+
+	case printLineMessage:
+		if !r.altScreenActive {
+			lines := strings.Split(msg.messageBody, "\n")
+			r.mtx.Lock()
+			r.queuedMessageLines = append(r.queuedMessageLines, lines...)
+			r.repaint()
+			r.mtx.Unlock()
+		}
+	}
+}
+
+// HIGH-PERFORMANCE RENDERING STUFF
+
+type syncScrollAreaMsg struct {
+	lines          []string
+	topBoundary    int
+	bottomBoundary int
+}
+
+// SyncScrollArea performs a paint of the entire region designated to be the
+// scrollable area. This is required to initialize the scrollable region and
+// should also be called on resize (WindowSizeMsg).
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func SyncScrollArea(lines []string, topBoundary int, bottomBoundary int) Cmd {
+	return func() Msg {
+		return syncScrollAreaMsg{
+			lines:          lines,
+			topBoundary:    topBoundary,
+			bottomBoundary: bottomBoundary,
+		}
+	}
+}
+
+type clearScrollAreaMsg struct{}
+
+// ClearScrollArea deallocates the scrollable region and returns the control of
+// those lines to the main rendering routine.
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func ClearScrollArea() Msg {
+	return clearScrollAreaMsg{}
+}
+
+type scrollUpMsg struct {
+	lines          []string
+	topBoundary    int
+	bottomBoundary int
+}
+
+// ScrollUp adds lines to the top of the scrollable region, pushing existing
+// lines below down. Lines that are pushed out the scrollable region disappear
+// from view.
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func ScrollUp(newLines []string, topBoundary, bottomBoundary int) Cmd {
+	return func() Msg {
+		return scrollUpMsg{
+			lines:          newLines,
+			topBoundary:    topBoundary,
+			bottomBoundary: bottomBoundary,
+		}
+	}
+}
+
+type scrollDownMsg struct {
+	lines          []string
+	topBoundary    int
+	bottomBoundary int
+}
+
+// ScrollDown adds lines to the bottom of the scrollable region, pushing
+// existing lines above up. Lines that are pushed out of the scrollable region
+// disappear from view.
+//
+// For high-performance, scroll-based rendering only.
+//
+// Deprecated: This option will be removed in a future version of this package.
+func ScrollDown(newLines []string, topBoundary, bottomBoundary int) Cmd {
+	return func() Msg {
+		return scrollDownMsg{
+			lines:          newLines,
+			topBoundary:    topBoundary,
+			bottomBoundary: bottomBoundary,
+		}
+	}
+}
+
+type printLineMessage struct {
+	messageBody string
+}
+
+// Println prints above the Program. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Println (but similar to log.Println) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func Println(args ...interface{}) Cmd {
+	return func() Msg {
+		return printLineMessage{
+			messageBody: fmt.Sprint(args...),
+		}
+	}
+}
+
+// Printf prints above the Program. It takes a format template followed by
+// values similar to fmt.Printf. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Printf (but similar to log.Printf) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func Printf(template string, args ...interface{}) Cmd {
+	return func() Msg {
+		return printLineMessage{
+			messageBody: fmt.Sprintf(template, args...),
+		}
+	}
+}

vendor/github.com/charmbracelet/bubbletea/tea.go

@@ -0,0 +1,788 @@
+// Package tea provides a framework for building rich terminal user interfaces
+// based on the paradigms of The Elm Architecture. It's well-suited for simple
+// and complex terminal applications, either inline, full-window, or a mix of
+// both. It's been battle-tested in several large projects and is
+// production-ready.
+//
+// A tutorial is available at https://github.com/charmbracelet/bubbletea/tree/master/tutorials
+//
+// Example programs can be found at https://github.com/charmbracelet/bubbletea/tree/master/examples
+package tea
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"runtime/debug"
+	"sync"
+	"sync/atomic"
+	"syscall"
+
+	"github.com/charmbracelet/x/term"
+	"github.com/muesli/cancelreader"
+	"golang.org/x/sync/errgroup"
+)
+
+// ErrProgramKilled is returned by [Program.Run] when the program got killed.
+var ErrProgramKilled = errors.New("program was killed")
+
+// Msg contain data from the result of a IO operation. Msgs trigger the update
+// function and, henceforth, the UI.
+type Msg interface{}
+
+// Model contains the program's state as well as its core functions.
+type Model interface {
+	// Init is the first function that will be called. It returns an optional
+	// initial command. To not perform an initial command return nil.
+	Init() Cmd
+
+	// Update is called when a message is received. Use it to inspect messages
+	// and, in response, update the model and/or send a command.
+	Update(Msg) (Model, Cmd)
+
+	// View renders the program's UI, which is just a string. The view is
+	// rendered after every Update.
+	View() string
+}
+
+// Cmd is an IO operation that returns a message when it's complete. If it's
+// nil it's considered a no-op. Use it for things like HTTP requests, timers,
+// saving and loading from disk, and so on.
+//
+// Note that there's almost never a reason to use a command to send a message
+// to another part of your program. That can almost always be done in the
+// update function.
+type Cmd func() Msg
+
+type inputType int
+
+const (
+	defaultInput inputType = iota
+	ttyInput
+	customInput
+)
+
+// String implements the stringer interface for [inputType]. It is inteded to
+// be used in testing.
+func (i inputType) String() string {
+	return [...]string{
+		"default input",
+		"tty input",
+		"custom input",
+	}[i]
+}
+
+// Options to customize the program during its initialization. These are
+// generally set with ProgramOptions.
+//
+// The options here are treated as bits.
+type startupOptions int16
+
+func (s startupOptions) has(option startupOptions) bool {
+	return s&option != 0
+}
+
+const (
+	withAltScreen startupOptions = 1 << iota
+	withMouseCellMotion
+	withMouseAllMotion
+	withANSICompressor
+	withoutSignalHandler
+	// Catching panics is incredibly useful for restoring the terminal to a
+	// usable state after a panic occurs. When this is set, Bubble Tea will
+	// recover from panics, print the stack trace, and disable raw mode. This
+	// feature is on by default.
+	withoutCatchPanics
+	withoutBracketedPaste
+	withReportFocus
+)
+
+// channelHandlers manages the series of channels returned by various processes.
+// It allows us to wait for those processes to terminate before exiting the
+// program.
+type channelHandlers []chan struct{}
+
+// Adds a channel to the list of handlers. We wait for all handlers to terminate
+// gracefully on shutdown.
+func (h *channelHandlers) add(ch chan struct{}) {
+	*h = append(*h, ch)
+}
+
+// shutdown waits for all handlers to terminate.
+func (h channelHandlers) shutdown() {
+	var wg sync.WaitGroup
+	for _, ch := range h {
+		wg.Add(1)
+		go func(ch chan struct{}) {
+			<-ch
+			wg.Done()
+		}(ch)
+	}
+	wg.Wait()
+}
+
+// Program is a terminal user interface.
+type Program struct {
+	initialModel Model
+
+	// handlers is a list of channels that need to be waited on before the
+	// program can exit.
+	handlers channelHandlers
+
+	// Configuration options that will set as the program is initializing,
+	// treated as bits. These options can be set via various ProgramOptions.
+	startupOptions startupOptions
+
+	// startupTitle is the title that will be set on the terminal when the
+	// program starts.
+	startupTitle string
+
+	inputType inputType
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	msgs     chan Msg
+	errs     chan error
+	finished chan struct{}
+
+	// where to send output, this will usually be os.Stdout.
+	output io.Writer
+	// ttyOutput is null if output is not a TTY.
+	ttyOutput           term.File
+	previousOutputState *term.State
+	renderer            renderer
+
+	// the environment variables for the program, defaults to os.Environ().
+	environ []string
+
+	// where to read inputs from, this will usually be os.Stdin.
+	input io.Reader
+	// ttyInput is null if input is not a TTY.
+	ttyInput              term.File
+	previousTtyInputState *term.State
+	cancelReader          cancelreader.CancelReader
+	readLoopDone          chan struct{}
+
+	// was the altscreen active before releasing the terminal?
+	altScreenWasActive bool
+	ignoreSignals      uint32
+
+	bpWasActive bool // was the bracketed paste mode active before releasing the terminal?
+	reportFocus bool // was focus reporting active before releasing the terminal?
+
+	filter func(Model, Msg) Msg
+
+	// fps is the frames per second we should set on the renderer, if
+	// applicable,
+	fps int
+}
+
+// Quit is a special command that tells the Bubble Tea program to exit.
+func Quit() Msg {
+	return QuitMsg{}
+}
+
+// QuitMsg signals that the program should quit. You can send a QuitMsg with
+// Quit.
+type QuitMsg struct{}
+
+// Suspend is a special command that tells the Bubble Tea program to suspend.
+func Suspend() Msg {
+	return SuspendMsg{}
+}
+
+// SuspendMsg signals the program should suspend.
+// This usually happens when ctrl+z is pressed on common programs, but since
+// bubbletea puts the terminal in raw mode, we need to handle it in a
+// per-program basis.
+// You can send this message with Suspend.
+type SuspendMsg struct{}
+
+// ResumeMsg can be listen to to do something once a program is resumed back
+// from a suspend state.
+type ResumeMsg struct{}
+
+// NewProgram creates a new Program.
+func NewProgram(model Model, opts ...ProgramOption) *Program {
+	p := &Program{
+		initialModel: model,
+		msgs:         make(chan Msg),
+	}
+
+	// Apply all options to the program.
+	for _, opt := range opts {
+		opt(p)
+	}
+
+	// A context can be provided with a ProgramOption, but if none was provided
+	// we'll use the default background context.
+	if p.ctx == nil {
+		p.ctx = context.Background()
+	}
+	// Initialize context and teardown channel.
+	p.ctx, p.cancel = context.WithCancel(p.ctx)
+
+	// if no output was set, set it to stdout
+	if p.output == nil {
+		p.output = os.Stdout
+	}
+
+	// if no environment was set, set it to os.Environ()
+	if p.environ == nil {
+		p.environ = os.Environ()
+	}
+
+	return p
+}
+
+func (p *Program) handleSignals() chan struct{} {
+	ch := make(chan struct{})
+
+	// Listen for SIGINT and SIGTERM.
+	//
+	// In most cases ^C will not send an interrupt because the terminal will be
+	// in raw mode and ^C will be captured as a keystroke and sent along to
+	// Program.Update as a KeyMsg. When input is not a TTY, however, ^C will be
+	// caught here.
+	//
+	// SIGTERM is sent by unix utilities (like kill) to terminate a process.
+	go func() {
+		sig := make(chan os.Signal, 1)
+		signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
+		defer func() {
+			signal.Stop(sig)
+			close(ch)
+		}()
+
+		for {
+			select {
+			case <-p.ctx.Done():
+				return
+
+			case <-sig:
+				if atomic.LoadUint32(&p.ignoreSignals) == 0 {
+					p.msgs <- QuitMsg{}
+					return
+				}
+			}
+		}
+	}()
+
+	return ch
+}
+
+// handleResize handles terminal resize events.
+func (p *Program) handleResize() chan struct{} {
+	ch := make(chan struct{})
+
+	if p.ttyOutput != nil {
+		// Get the initial terminal size and send it to the program.
+		go p.checkResize()
+
+		// Listen for window resizes.
+		go p.listenForResize(ch)
+	} else {
+		close(ch)
+	}
+
+	return ch
+}
+
+// handleCommands runs commands in a goroutine and sends the result to the
+// program's message channel.
+func (p *Program) handleCommands(cmds chan Cmd) chan struct{} {
+	ch := make(chan struct{})
+
+	go func() {
+		defer close(ch)
+
+		for {
+			select {
+			case <-p.ctx.Done():
+				return
+
+			case cmd := <-cmds:
+				if cmd == nil {
+					continue
+				}
+
+				// Don't wait on these goroutines, otherwise the shutdown
+				// latency would get too large as a Cmd can run for some time
+				// (e.g. tick commands that sleep for half a second). It's not
+				// possible to cancel them so we'll have to leak the goroutine
+				// until Cmd returns.
+				go func() {
+					// Recover from panics.
+					if !p.startupOptions.has(withoutCatchPanics) {
+						defer p.recoverFromPanic()
+					}
+
+					msg := cmd() // this can be long.
+					p.Send(msg)
+				}()
+			}
+		}
+	}()
+
+	return ch
+}
+
+func (p *Program) disableMouse() {
+	p.renderer.disableMouseCellMotion()
+	p.renderer.disableMouseAllMotion()
+	p.renderer.disableMouseSGRMode()
+}
+
+// eventLoop is the central message loop. It receives and handles the default
+// Bubble Tea messages, update the model and triggers redraws.
+func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {
+	for {
+		select {
+		case <-p.ctx.Done():
+			return model, nil
+
+		case err := <-p.errs:
+			return model, err
+
+		case msg := <-p.msgs:
+			// Filter messages.
+			if p.filter != nil {
+				msg = p.filter(model, msg)
+			}
+			if msg == nil {
+				continue
+			}
+
+			// Handle special internal messages.
+			switch msg := msg.(type) {
+			case QuitMsg:
+				return model, nil
+
+			case SuspendMsg:
+				if suspendSupported {
+					p.suspend()
+				}
+
+			case clearScreenMsg:
+				p.renderer.clearScreen()
+
+			case enterAltScreenMsg:
+				p.renderer.enterAltScreen()
+
+			case exitAltScreenMsg:
+				p.renderer.exitAltScreen()
+
+			case enableMouseCellMotionMsg, enableMouseAllMotionMsg:
+				switch msg.(type) {
+				case enableMouseCellMotionMsg:
+					p.renderer.enableMouseCellMotion()
+				case enableMouseAllMotionMsg:
+					p.renderer.enableMouseAllMotion()
+				}
+				// mouse mode (1006) is a no-op if the terminal doesn't support it.
+				p.renderer.enableMouseSGRMode()
+
+			case disableMouseMsg:
+				p.disableMouse()
+
+			case showCursorMsg:
+				p.renderer.showCursor()
+
+			case hideCursorMsg:
+				p.renderer.hideCursor()
+
+			case enableBracketedPasteMsg:
+				p.renderer.enableBracketedPaste()
+
+			case disableBracketedPasteMsg:
+				p.renderer.disableBracketedPaste()
+
+			case enableReportFocusMsg:
+				p.renderer.enableReportFocus()
+
+			case disableReportFocusMsg:
+				p.renderer.disableReportFocus()
+
+			case execMsg:
+				// NB: this blocks.
+				p.exec(msg.cmd, msg.fn)
+
+			case BatchMsg:
+				for _, cmd := range msg {
+					cmds <- cmd
+				}
+				continue
+
+			case sequenceMsg:
+				go func() {
+					// Execute commands one at a time, in order.
+					for _, cmd := range msg {
+						if cmd == nil {
+							continue
+						}
+
+						msg := cmd()
+						if batchMsg, ok := msg.(BatchMsg); ok {
+							g, _ := errgroup.WithContext(p.ctx)
+							for _, cmd := range batchMsg {
+								cmd := cmd
+								g.Go(func() error {
+									p.Send(cmd())
+									return nil
+								})
+							}
+
+							//nolint:errcheck
+							g.Wait() // wait for all commands from batch msg to finish
+							continue
+						}
+
+						p.Send(msg)
+					}
+				}()
+
+			case setWindowTitleMsg:
+				p.SetWindowTitle(string(msg))
+
+			case windowSizeMsg:
+				go p.checkResize()
+			}
+
+			// Process internal messages for the renderer.
+			if r, ok := p.renderer.(*standardRenderer); ok {
+				r.handleMessages(msg)
+			}
+
+			var cmd Cmd
+			model, cmd = model.Update(msg) // run update
+			cmds <- cmd                    // process command (if any)
+			p.renderer.write(model.View()) // send view to renderer
+		}
+	}
+}
+
+// Run initializes the program and runs its event loops, blocking until it gets
+// terminated by either [Program.Quit], [Program.Kill], or its signal handler.
+// Returns the final model.
+func (p *Program) Run() (Model, error) {
+	p.handlers = channelHandlers{}
+	cmds := make(chan Cmd)
+	p.errs = make(chan error)
+	p.finished = make(chan struct{}, 1)
+
+	defer p.cancel()
+
+	switch p.inputType {
+	case defaultInput:
+		p.input = os.Stdin
+
+		// The user has not set a custom input, so we need to check whether or
+		// not standard input is a terminal. If it's not, we open a new TTY for
+		// input. This will allow things to "just work" in cases where data was
+		// piped in or redirected to the application.
+		//
+		// To disable input entirely pass nil to the [WithInput] program option.
+		f, isFile := p.input.(term.File)
+		if !isFile {
+			break
+		}
+		if term.IsTerminal(f.Fd()) {
+			break
+		}
+
+		f, err := openInputTTY()
+		if err != nil {
+			return p.initialModel, err
+		}
+		defer f.Close() //nolint:errcheck
+		p.input = f
+
+	case ttyInput:
+		// Open a new TTY, by request
+		f, err := openInputTTY()
+		if err != nil {
+			return p.initialModel, err
+		}
+		defer f.Close() //nolint:errcheck
+		p.input = f
+
+	case customInput:
+		// (There is nothing extra to do.)
+	}
+
+	// Handle signals.
+	if !p.startupOptions.has(withoutSignalHandler) {
+		p.handlers.add(p.handleSignals())
+	}
+
+	// Recover from panics.
+	if !p.startupOptions.has(withoutCatchPanics) {
+		defer p.recoverFromPanic()
+	}
+
+	// If no renderer is set use the standard one.
+	if p.renderer == nil {
+		p.renderer = newRenderer(p.output, p.startupOptions.has(withANSICompressor), p.fps)
+	}
+
+	// Check if output is a TTY before entering raw mode, hiding the cursor and
+	// so on.
+	if err := p.initTerminal(); err != nil {
+		return p.initialModel, err
+	}
+
+	// Honor program startup options.
+	if p.startupTitle != "" {
+		p.renderer.setWindowTitle(p.startupTitle)
+	}
+	if p.startupOptions&withAltScreen != 0 {
+		p.renderer.enterAltScreen()
+	}
+	if p.startupOptions&withoutBracketedPaste == 0 {
+		p.renderer.enableBracketedPaste()
+	}
+	if p.startupOptions&withMouseCellMotion != 0 {
+		p.renderer.enableMouseCellMotion()
+		p.renderer.enableMouseSGRMode()
+	} else if p.startupOptions&withMouseAllMotion != 0 {
+		p.renderer.enableMouseAllMotion()
+		p.renderer.enableMouseSGRMode()
+	}
+	if p.startupOptions&withReportFocus != 0 {
+		p.renderer.enableReportFocus()
+	}
+
+	// Start the renderer.
+	p.renderer.start()
+
+	// Initialize the program.
+	model := p.initialModel
+	if initCmd := model.Init(); initCmd != nil {
+		ch := make(chan struct{})
+		p.handlers.add(ch)
+
+		go func() {
+			defer close(ch)
+
+			select {
+			case cmds <- initCmd:
+			case <-p.ctx.Done():
+			}
+		}()
+	}
+
+	// Render the initial view.
+	p.renderer.write(model.View())
+
+	// Subscribe to user input.
+	if p.input != nil {
+		if err := p.initCancelReader(); err != nil {
+			return model, err
+		}
+	}
+
+	// Handle resize events.
+	p.handlers.add(p.handleResize())
+
+	// Process commands.
+	p.handlers.add(p.handleCommands(cmds))
+
+	// Run event loop, handle updates and draw.
+	model, err := p.eventLoop(model, cmds)
+	killed := p.ctx.Err() != nil
+	if killed {
+		err = fmt.Errorf("%w: %s", ErrProgramKilled, p.ctx.Err())
+	} else {
+		// Ensure we rendered the final state of the model.
+		p.renderer.write(model.View())
+	}
+
+	// Restore terminal state.
+	p.shutdown(killed)
+
+	return model, err
+}
+
+// StartReturningModel initializes the program and runs its event loops,
+// blocking until it gets terminated by either [Program.Quit], [Program.Kill],
+// or its signal handler. Returns the final model.
+//
+// Deprecated: please use [Program.Run] instead.
+func (p *Program) StartReturningModel() (Model, error) {
+	return p.Run()
+}
+
+// Start initializes the program and runs its event loops, blocking until it
+// gets terminated by either [Program.Quit], [Program.Kill], or its signal
+// handler.
+//
+// Deprecated: please use [Program.Run] instead.
+func (p *Program) Start() error {
+	_, err := p.Run()
+	return err
+}
+
+// Send sends a message to the main update function, effectively allowing
+// messages to be injected from outside the program for interoperability
+// purposes.
+//
+// If the program hasn't started yet this will be a blocking operation.
+// If the program has already been terminated this will be a no-op, so it's safe
+// to send messages after the program has exited.
+func (p *Program) Send(msg Msg) {
+	select {
+	case <-p.ctx.Done():
+	case p.msgs <- msg:
+	}
+}
+
+// Quit is a convenience function for quitting Bubble Tea programs. Use it
+// when you need to shut down a Bubble Tea program from the outside.
+//
+// If you wish to quit from within a Bubble Tea program use the Quit command.
+//
+// If the program is not running this will be a no-op, so it's safe to call
+// if the program is unstarted or has already exited.
+func (p *Program) Quit() {
+	p.Send(Quit())
+}
+
+// Kill stops the program immediately and restores the former terminal state.
+// The final render that you would normally see when quitting will be skipped.
+// [program.Run] returns a [ErrProgramKilled] error.
+func (p *Program) Kill() {
+	p.shutdown(true)
+}
+
+// Wait waits/blocks until the underlying Program finished shutting down.
+func (p *Program) Wait() {
+	<-p.finished
+}
+
+// shutdown performs operations to free up resources and restore the terminal
+// to its original state.
+func (p *Program) shutdown(kill bool) {
+	p.cancel()
+
+	// Wait for all handlers to finish.
+	p.handlers.shutdown()
+
+	// Check if the cancel reader has been setup before waiting and closing.
+	if p.cancelReader != nil {
+		// Wait for input loop to finish.
+		if p.cancelReader.Cancel() {
+			if !kill {
+				p.waitForReadLoop()
+			}
+		}
+		_ = p.cancelReader.Close()
+	}
+
+	if p.renderer != nil {
+		if kill {
+			p.renderer.kill()
+		} else {
+			p.renderer.stop()
+		}
+	}
+
+	_ = p.restoreTerminalState()
+	if !kill {
+		p.finished <- struct{}{}
+	}
+}
+
+// recoverFromPanic recovers from a panic, prints the stack trace, and restores
+// the terminal to a usable state.
+func (p *Program) recoverFromPanic() {
+	if r := recover(); r != nil {
+		p.shutdown(true)
+		fmt.Printf("Caught panic:\n\n%s\n\nRestoring terminal...\n\n", r)
+		debug.PrintStack()
+	}
+}
+
+// ReleaseTerminal restores the original terminal state and cancels the input
+// reader. You can return control to the Program with RestoreTerminal.
+func (p *Program) ReleaseTerminal() error {
+	atomic.StoreUint32(&p.ignoreSignals, 1)
+	if p.cancelReader != nil {
+		p.cancelReader.Cancel()
+	}
+
+	p.waitForReadLoop()
+
+	if p.renderer != nil {
+		p.renderer.stop()
+		p.altScreenWasActive = p.renderer.altScreen()
+		p.bpWasActive = p.renderer.bracketedPasteActive()
+		p.reportFocus = p.renderer.reportFocus()
+	}
+
+	return p.restoreTerminalState()
+}
+
+// RestoreTerminal reinitializes the Program's input reader, restores the
+// terminal to the former state when the program was running, and repaints.
+// Use it to reinitialize a Program after running ReleaseTerminal.
+func (p *Program) RestoreTerminal() error {
+	atomic.StoreUint32(&p.ignoreSignals, 0)
+
+	if err := p.initTerminal(); err != nil {
+		return err
+	}
+	if err := p.initCancelReader(); err != nil {
+		return err
+	}
+	if p.altScreenWasActive {
+		p.renderer.enterAltScreen()
+	} else {
+		// entering alt screen already causes a repaint.
+		go p.Send(repaintMsg{})
+	}
+	if p.renderer != nil {
+		p.renderer.start()
+	}
+	if p.bpWasActive {
+		p.renderer.enableBracketedPaste()
+	}
+	if p.reportFocus {
+		p.renderer.enableReportFocus()
+	}
+
+	// If the output is a terminal, it may have been resized while another
+	// process was at the foreground, in which case we may not have received
+	// SIGWINCH. Detect any size change now and propagate the new size as
+	// needed.
+	go p.checkResize()
+
+	return nil
+}
+
+// Println prints above the Program. This output is unmanaged by the program
+// and will persist across renders by the Program.
+//
+// If the altscreen is active no output will be printed.
+func (p *Program) Println(args ...interface{}) {
+	p.msgs <- printLineMessage{
+		messageBody: fmt.Sprint(args...),
+	}
+}
+
+// Printf prints above the Program. It takes a format template followed by
+// values similar to fmt.Printf. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Printf (but similar to log.Printf) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func (p *Program) Printf(template string, args ...interface{}) {
+	p.msgs <- printLineMessage{
+		messageBody: fmt.Sprintf(template, args...),
+	}
+}

vendor/github.com/charmbracelet/bubbletea/tea_init.go

@@ -0,0 +1,22 @@
+package tea
+
+import (
+	"github.com/charmbracelet/lipgloss"
+)
+
+func init() {
+	// XXX: This is a workaround to make assure that Lip Gloss and Termenv
+	// query the terminal before any Bubble Tea Program runs and acquires the
+	// terminal. Without this, Programs that use Lip Gloss/Termenv might hang
+	// while waiting for a a [termenv.OSCTimeout] while querying the terminal
+	// for its background/foreground colors.
+	//
+	// This happens because Bubble Tea acquires the terminal before termenv
+	// reads any responses.
+	//
+	// Note that this will only affect programs running on the default IO i.e.
+	// [os.Stdout] and [os.Stdin].
+	//
+	// This workaround will be removed in v2.
+	_ = lipgloss.HasDarkBackground()
+}

vendor/github.com/charmbracelet/bubbletea/tty.go

@@ -0,0 +1,136 @@
+package tea
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/charmbracelet/x/term"
+	"github.com/muesli/cancelreader"
+)
+
+func (p *Program) suspend() {
+	if err := p.ReleaseTerminal(); err != nil {
+		// If we can't release input, abort.
+		return
+	}
+
+	suspendProcess()
+
+	_ = p.RestoreTerminal()
+	go p.Send(ResumeMsg{})
+}
+
+func (p *Program) initTerminal() error {
+	if _, ok := p.renderer.(*nilRenderer); ok {
+		// No need to initialize the terminal if we're not rendering
+		return nil
+	}
+
+	if err := p.initInput(); err != nil {
+		return err
+	}
+
+	p.renderer.hideCursor()
+	return nil
+}
+
+// restoreTerminalState restores the terminal to the state prior to running the
+// Bubble Tea program.
+func (p *Program) restoreTerminalState() error {
+	if p.renderer != nil {
+		p.renderer.disableBracketedPaste()
+		p.renderer.showCursor()
+		p.disableMouse()
+
+		if p.renderer.reportFocus() {
+			p.renderer.disableReportFocus()
+		}
+
+		if p.renderer.altScreen() {
+			p.renderer.exitAltScreen()
+
+			// give the terminal a moment to catch up
+			time.Sleep(time.Millisecond * 10) //nolint:gomnd
+		}
+	}
+
+	return p.restoreInput()
+}
+
+// restoreInput restores the tty input to its original state.
+func (p *Program) restoreInput() error {
+	if p.ttyInput != nil && p.previousTtyInputState != nil {
+		if err := term.Restore(p.ttyInput.Fd(), p.previousTtyInputState); err != nil {
+			return fmt.Errorf("error restoring console: %w", err)
+		}
+	}
+	if p.ttyOutput != nil && p.previousOutputState != nil {
+		if err := term.Restore(p.ttyOutput.Fd(), p.previousOutputState); err != nil {
+			return fmt.Errorf("error restoring console: %w", err)
+		}
+	}
+	return nil
+}
+
+// initCancelReader (re)commences reading inputs.
+func (p *Program) initCancelReader() error {
+	var err error
+	p.cancelReader, err = newInputReader(p.input)
+	if err != nil {
+		return fmt.Errorf("error creating cancelreader: %w", err)
+	}
+
+	p.readLoopDone = make(chan struct{})
+	go p.readLoop()
+
+	return nil
+}
+
+func (p *Program) readLoop() {
+	defer close(p.readLoopDone)
+
+	err := readInputs(p.ctx, p.msgs, p.cancelReader)
+	if !errors.Is(err, io.EOF) && !errors.Is(err, cancelreader.ErrCanceled) {
+		select {
+		case <-p.ctx.Done():
+		case p.errs <- err:
+		}
+	}
+}
+
+// waitForReadLoop waits for the cancelReader to finish its read loop.
+func (p *Program) waitForReadLoop() {
+	select {
+	case <-p.readLoopDone:
+	case <-time.After(500 * time.Millisecond): //nolint:gomnd
+		// The read loop hangs, which means the input
+		// cancelReader's cancel function has returned true even
+		// though it was not able to cancel the read.
+	}
+}
+
+// checkResize detects the current size of the output and informs the program
+// via a WindowSizeMsg.
+func (p *Program) checkResize() {
+	if p.ttyOutput == nil {
+		// can't query window size
+		return
+	}
+
+	w, h, err := term.GetSize(p.ttyOutput.Fd())
+	if err != nil {
+		select {
+		case <-p.ctx.Done():
+		case p.errs <- err:
+		}
+
+		return
+	}
+
+	p.Send(WindowSizeMsg{
+		Width:  w,
+		Height: h,
+	})
+}

vendor/github.com/charmbracelet/bubbletea/tty_unix.go

@@ -0,0 +1,49 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix || zos
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix zos
+
+package tea
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/charmbracelet/x/term"
+)
+
+func (p *Program) initInput() (err error) {
+	// Check if input is a terminal
+	if f, ok := p.input.(term.File); ok && term.IsTerminal(f.Fd()) {
+		p.ttyInput = f
+		p.previousTtyInputState, err = term.MakeRaw(p.ttyInput.Fd())
+		if err != nil {
+			return fmt.Errorf("error entering raw mode: %w", err)
+		}
+	}
+
+	if f, ok := p.output.(term.File); ok && term.IsTerminal(f.Fd()) {
+		p.ttyOutput = f
+	}
+
+	return nil
+}
+
+func openInputTTY() (*os.File, error) {
+	f, err := os.Open("/dev/tty")
+	if err != nil {
+		return nil, fmt.Errorf("could not open a new TTY: %w", err)
+	}
+	return f, nil
+}
+
+const suspendSupported = true
+
+// Send SIGTSTP to the entire process group.
+func suspendProcess() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGCONT)
+	_ = syscall.Kill(0, syscall.SIGTSTP)
+	// blocks until a CONT happens...
+	<-c
+}

vendor/github.com/charmbracelet/bubbletea/tty_windows.go

@@ -0,0 +1,68 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/charmbracelet/x/term"
+	"golang.org/x/sys/windows"
+)
+
+func (p *Program) initInput() (err error) {
+	// Save stdin state and enable VT input
+	// We also need to enable VT
+	// input here.
+	if f, ok := p.input.(term.File); ok && term.IsTerminal(f.Fd()) {
+		p.ttyInput = f
+		p.previousTtyInputState, err = term.MakeRaw(p.ttyInput.Fd())
+		if err != nil {
+			return err
+		}
+
+		// Enable VT input
+		var mode uint32
+		if err := windows.GetConsoleMode(windows.Handle(p.ttyInput.Fd()), &mode); err != nil {
+			return fmt.Errorf("error getting console mode: %w", err)
+		}
+
+		if err := windows.SetConsoleMode(windows.Handle(p.ttyInput.Fd()), mode|windows.ENABLE_VIRTUAL_TERMINAL_INPUT); err != nil {
+			return fmt.Errorf("error setting console mode: %w", err)
+		}
+	}
+
+	// Save output screen buffer state and enable VT processing.
+	if f, ok := p.output.(term.File); ok && term.IsTerminal(f.Fd()) {
+		p.ttyOutput = f
+		p.previousOutputState, err = term.GetState(f.Fd())
+		if err != nil {
+			return err
+		}
+
+		var mode uint32
+		if err := windows.GetConsoleMode(windows.Handle(p.ttyOutput.Fd()), &mode); err != nil {
+			return fmt.Errorf("error getting console mode: %w", err)
+		}
+
+		if err := windows.SetConsoleMode(windows.Handle(p.ttyOutput.Fd()), mode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING); err != nil {
+			return fmt.Errorf("error setting console mode: %w", err)
+		}
+	}
+
+	return
+}
+
+// Open the Windows equivalent of a TTY.
+func openInputTTY() (*os.File, error) {
+	f, err := os.OpenFile("CONIN$", os.O_RDWR, 0o644)
+	if err != nil {
+		return nil, err
+	}
+	return f, nil
+}
+
+const suspendSupported = false
+
+func suspendProcess() {}

vendor/github.com/charmbracelet/x/term/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Charmbracelet, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/charmbracelet/x/term/term.go

@@ -0,0 +1,49 @@
+package term
+
+// State contains platform-specific state of a terminal.
+type State struct {
+	state
+}
+
+// IsTerminal returns whether the given file descriptor is a terminal.
+func IsTerminal(fd uintptr) bool {
+	return isTerminal(fd)
+}
+
+// MakeRaw puts the terminal connected to the given file descriptor into raw
+// mode and returns the previous state of the terminal so that it can be
+// restored.
+func MakeRaw(fd uintptr) (*State, error) {
+	return makeRaw(fd)
+}
+
+// GetState returns the current state of a terminal which may be useful to
+// restore the terminal after a signal.
+func GetState(fd uintptr) (*State, error) {
+	return getState(fd)
+}
+
+// SetState sets the given state of the terminal.
+func SetState(fd uintptr, state *State) error {
+	return setState(fd, state)
+}
+
+// Restore restores the terminal connected to the given file descriptor to a
+// previous state.
+func Restore(fd uintptr, oldState *State) error {
+	return restore(fd, oldState)
+}
+
+// GetSize returns the visible dimensions of the given terminal.
+//
+// These dimensions don't include any scrollback buffer height.
+func GetSize(fd uintptr) (width, height int, err error) {
+	return getSize(fd)
+}
+
+// ReadPassword reads a line of input from a terminal without local echo.  This
+// is commonly used for inputting passwords and other sensitive data. The slice
+// returned does not include the \n.
+func ReadPassword(fd uintptr) ([]byte, error) {
+	return readPassword(fd)
+}

vendor/github.com/charmbracelet/x/term/term_other.go

@@ -0,0 +1,39 @@
+//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !zos && !windows && !solaris && !plan9
+// +build !aix,!darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!zos,!windows,!solaris,!plan9
+
+package term
+
+import (
+	"fmt"
+	"runtime"
+)
+
+type state struct{}
+
+func isTerminal(fd uintptr) bool {
+	return false
+}
+
+func makeRaw(fd uintptr) (*State, error) {
+	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func getState(fd uintptr) (*State, error) {
+	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func restore(fd uintptr, state *State) error {
+	return fmt.Errorf("terminal: Restore not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func getSize(fd uintptr) (width, height int, err error) {
+	return 0, 0, fmt.Errorf("terminal: GetSize not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func setState(fd uintptr, state *State) error {
+	return fmt.Errorf("terminal: SetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func readPassword(fd uintptr) ([]byte, error) {
+	return nil, fmt.Errorf("terminal: ReadPassword not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+}

vendor/github.com/charmbracelet/x/term/term_unix.go

@@ -0,0 +1,96 @@
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris zos
+
+package term
+
+import (
+	"golang.org/x/sys/unix"
+)
+
+type state struct {
+	unix.Termios
+}
+
+func isTerminal(fd uintptr) bool {
+	_, err := unix.IoctlGetTermios(int(fd), ioctlReadTermios)
+	return err == nil
+}
+
+func makeRaw(fd uintptr) (*State, error) {
+	termios, err := unix.IoctlGetTermios(int(fd), ioctlReadTermios)
+	if err != nil {
+		return nil, err
+	}
+
+	oldState := State{state{Termios: *termios}}
+
+	// This attempts to replicate the behaviour documented for cfmakeraw in
+	// the termios(3) manpage.
+	termios.Iflag &^= unix.IGNBRK | unix.BRKINT | unix.PARMRK | unix.ISTRIP | unix.INLCR | unix.IGNCR | unix.ICRNL | unix.IXON
+	termios.Oflag &^= unix.OPOST
+	termios.Lflag &^= unix.ECHO | unix.ECHONL | unix.ICANON | unix.ISIG | unix.IEXTEN
+	termios.Cflag &^= unix.CSIZE | unix.PARENB
+	termios.Cflag |= unix.CS8
+	termios.Cc[unix.VMIN] = 1
+	termios.Cc[unix.VTIME] = 0
+	if err := unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios); err != nil {
+		return nil, err
+	}
+
+	return &oldState, nil
+}
+
+func setState(fd uintptr, state *State) error {
+	var termios *unix.Termios
+	if state != nil {
+		termios = &state.Termios
+	}
+	return unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios)
+}
+
+func getState(fd uintptr) (*State, error) {
+	termios, err := unix.IoctlGetTermios(int(fd), ioctlReadTermios)
+	if err != nil {
+		return nil, err
+	}
+
+	return &State{state{Termios: *termios}}, nil
+}
+
+func restore(fd uintptr, state *State) error {
+	return unix.IoctlSetTermios(int(fd), ioctlWriteTermios, &state.Termios)
+}
+
+func getSize(fd uintptr) (width, height int, err error) {
+	ws, err := unix.IoctlGetWinsize(int(fd), unix.TIOCGWINSZ)
+	if err != nil {
+		return 0, 0, err
+	}
+	return int(ws.Col), int(ws.Row), nil
+}
+
+// passwordReader is an io.Reader that reads from a specific file descriptor.
+type passwordReader int
+
+func (r passwordReader) Read(buf []byte) (int, error) {
+	return unix.Read(int(r), buf)
+}
+
+func readPassword(fd uintptr) ([]byte, error) {
+	termios, err := unix.IoctlGetTermios(int(fd), ioctlReadTermios)
+	if err != nil {
+		return nil, err
+	}
+
+	newState := *termios
+	newState.Lflag &^= unix.ECHO
+	newState.Lflag |= unix.ICANON | unix.ISIG
+	newState.Iflag |= unix.ICRNL
+	if err := unix.IoctlSetTermios(int(fd), ioctlWriteTermios, &newState); err != nil {
+		return nil, err
+	}
+
+	defer unix.IoctlSetTermios(int(fd), ioctlWriteTermios, termios)
+
+	return readPasswordLine(passwordReader(fd))
+}

vendor/github.com/charmbracelet/x/term/term_unix_bsd.go

@@ -0,0 +1,11 @@
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
+// +build darwin dragonfly freebsd netbsd openbsd
+
+package term
+
+import "golang.org/x/sys/unix"
+
+const (
+	ioctlReadTermios  = unix.TIOCGETA
+	ioctlWriteTermios = unix.TIOCSETA
+)

vendor/github.com/charmbracelet/x/term/term_unix_other.go

@@ -0,0 +1,11 @@
+//go:build aix || linux || solaris || zos
+// +build aix linux solaris zos
+
+package term
+
+import "golang.org/x/sys/unix"
+
+const (
+	ioctlReadTermios  = unix.TCGETS
+	ioctlWriteTermios = unix.TCSETS
+)

vendor/github.com/charmbracelet/x/term/term_windows.go

@@ -0,0 +1,87 @@
+//go:build windows
+// +build windows
+
+package term
+
+import (
+	"os"
+
+	"golang.org/x/sys/windows"
+)
+
+type state struct {
+	Mode uint32
+}
+
+func isTerminal(fd uintptr) bool {
+	var st uint32
+	err := windows.GetConsoleMode(windows.Handle(fd), &st)
+	return err == nil
+}
+
+func makeRaw(fd uintptr) (*State, error) {
+	var st uint32
+	if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
+		return nil, err
+	}
+	raw := st &^ (windows.ENABLE_ECHO_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT | windows.ENABLE_PROCESSED_OUTPUT)
+	raw |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
+	if err := windows.SetConsoleMode(windows.Handle(fd), raw); err != nil {
+		return nil, err
+	}
+	return &State{state{st}}, nil
+}
+
+func setState(fd uintptr, state *State) error {
+	var mode uint32
+	if state != nil {
+		mode = state.Mode
+	}
+	return windows.SetConsoleMode(windows.Handle(fd), mode)
+}
+
+func getState(fd uintptr) (*State, error) {
+	var st uint32
+	if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
+		return nil, err
+	}
+	return &State{state{st}}, nil
+}
+
+func restore(fd uintptr, state *State) error {
+	return windows.SetConsoleMode(windows.Handle(fd), state.Mode)
+}
+
+func getSize(fd uintptr) (width, height int, err error) {
+	var info windows.ConsoleScreenBufferInfo
+	if err := windows.GetConsoleScreenBufferInfo(windows.Handle(fd), &info); err != nil {
+		return 0, 0, err
+	}
+	return int(info.Window.Right - info.Window.Left + 1), int(info.Window.Bottom - info.Window.Top + 1), nil
+}
+
+func readPassword(fd uintptr) ([]byte, error) {
+	var st uint32
+	if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
+		return nil, err
+	}
+	old := st
+
+	st &^= (windows.ENABLE_ECHO_INPUT | windows.ENABLE_LINE_INPUT)
+	st |= (windows.ENABLE_PROCESSED_OUTPUT | windows.ENABLE_PROCESSED_INPUT)
+	if err := windows.SetConsoleMode(windows.Handle(fd), st); err != nil {
+		return nil, err
+	}
+
+	defer windows.SetConsoleMode(windows.Handle(fd), old)
+
+	var h windows.Handle
+	p, _ := windows.GetCurrentProcess()
+	if err := windows.DuplicateHandle(p, windows.Handle(fd), p, &h, 0, false, windows.DUPLICATE_SAME_ACCESS); err != nil {
+		return nil, err
+	}
+
+	f := os.NewFile(uintptr(h), "stdin")
+	defer f.Close()
+	return readPasswordLine(f)
+}

vendor/github.com/charmbracelet/x/term/terminal.go

@@ -0,0 +1,12 @@
+package term
+
+import (
+	"io"
+)
+
+// File represents a file that has a file descriptor and can be read from,
+// written to, and closed.
+type File interface {
+	io.ReadWriteCloser
+	Fd() uintptr
+}

vendor/github.com/charmbracelet/x/term/util.go

@@ -0,0 +1,47 @@
+package term
+
+import (
+	"io"
+	"runtime"
+)
+
+// readPasswordLine reads from reader until it finds \n or io.EOF.
+// The slice returned does not include the \n.
+// readPasswordLine also ignores any \r it finds.
+// Windows uses \r as end of line. So, on Windows, readPasswordLine
+// reads until it finds \r and ignores any \n it finds during processing.
+func readPasswordLine(reader io.Reader) ([]byte, error) {
+	var buf [1]byte
+	var ret []byte
+
+	for {
+		n, err := reader.Read(buf[:])
+		if n > 0 {
+			switch buf[0] {
+			case '\b':
+				if len(ret) > 0 {
+					ret = ret[:len(ret)-1]
+				}
+			case '\n':
+				if runtime.GOOS != "windows" {
+					return ret, nil
+				}
+				// otherwise ignore \n
+			case '\r':
+				if runtime.GOOS == "windows" {
+					return ret, nil
+				}
+				// otherwise ignore \r
+			default:
+				ret = append(ret, buf[0])
+			}
+			continue
+		}
+		if err != nil {
+			if err == io.EOF && len(ret) > 0 {
+				return ret, nil
+			}
+			return ret, err
+		}
+	}
+}

vendor/github.com/erikgeiser/coninput/.gitignore

@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/

vendor/github.com/erikgeiser/coninput/.golangci.yml

@@ -0,0 +1,24 @@
+linters:
+  enable-all: true
+  disable:
+    - golint
+    - interfacer
+    - scopelint
+    - maligned
+    - rowserrcheck
+    - funlen
+    - depguard
+    - goerr113
+    - exhaustivestruct
+    - testpackage
+    - gochecknoglobals
+    - wrapcheck
+    - forbidigo
+    - ifshort
+    - cyclop
+    - gomoddirectives
+linters-settings:
+  exhaustive:
+    default-signifies-exhaustive: true
+issues:
+  exclude-use-default: false

vendor/github.com/erikgeiser/coninput/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Erik G.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/erikgeiser/coninput/README.md

@@ -0,0 +1,2 @@
+# coninput
+Go library for input handling using Windows Console API

vendor/github.com/erikgeiser/coninput/keycodes.go

@@ -0,0 +1,205 @@
+package coninput
+
+// VirtualKeyCode holds a virtual key code (see
+// https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes).
+type VirtualKeyCode uint16
+
+const (
+	VK_LBUTTON             VirtualKeyCode = 0x01
+	VK_RBUTTON             VirtualKeyCode = 0x02
+	VK_CANCEL              VirtualKeyCode = 0x03
+	VK_MBUTTON             VirtualKeyCode = 0x04
+	VK_XBUTTON1            VirtualKeyCode = 0x05
+	VK_XBUTTON2            VirtualKeyCode = 0x06
+	VK_BACK                VirtualKeyCode = 0x08
+	VK_TAB                 VirtualKeyCode = 0x09
+	VK_CLEAR               VirtualKeyCode = 0x0C
+	VK_RETURN              VirtualKeyCode = 0x0D
+	VK_SHIFT               VirtualKeyCode = 0x10
+	VK_CONTROL             VirtualKeyCode = 0x11
+	VK_MENU                VirtualKeyCode = 0x12
+	VK_PAUSE               VirtualKeyCode = 0x13
+	VK_CAPITAL             VirtualKeyCode = 0x14
+	VK_KANA                VirtualKeyCode = 0x15
+	VK_HANGEUL             VirtualKeyCode = 0x15
+	VK_HANGUL              VirtualKeyCode = 0x15
+	VK_IME_ON              VirtualKeyCode = 0x16
+	VK_JUNJA               VirtualKeyCode = 0x17
+	VK_FINAL               VirtualKeyCode = 0x18
+	VK_HANJA               VirtualKeyCode = 0x19
+	VK_KANJI               VirtualKeyCode = 0x19
+	VK_IME_OFF             VirtualKeyCode = 0x1A
+	VK_ESCAPE              VirtualKeyCode = 0x1B
+	VK_CONVERT             VirtualKeyCode = 0x1C
+	VK_NONCONVERT          VirtualKeyCode = 0x1D
+	VK_ACCEPT              VirtualKeyCode = 0x1E
+	VK_MODECHANGE          VirtualKeyCode = 0x1F
+	VK_SPACE               VirtualKeyCode = 0x20
+	VK_PRIOR               VirtualKeyCode = 0x21
+	VK_NEXT                VirtualKeyCode = 0x22
+	VK_END                 VirtualKeyCode = 0x23
+	VK_HOME                VirtualKeyCode = 0x24
+	VK_LEFT                VirtualKeyCode = 0x25
+	VK_UP                  VirtualKeyCode = 0x26
+	VK_RIGHT               VirtualKeyCode = 0x27
+	VK_DOWN                VirtualKeyCode = 0x28
+	VK_SELECT              VirtualKeyCode = 0x29
+	VK_PRINT               VirtualKeyCode = 0x2A
+	VK_EXECUTE             VirtualKeyCode = 0x2B
+	VK_SNAPSHOT            VirtualKeyCode = 0x2C
+	VK_INSERT              VirtualKeyCode = 0x2D
+	VK_DELETE              VirtualKeyCode = 0x2E
+	VK_HELP                VirtualKeyCode = 0x2F
+	VK_0                   VirtualKeyCode = 0x30
+	VK_1                   VirtualKeyCode = 0x31
+	VK_2                   VirtualKeyCode = 0x32
+	VK_3                   VirtualKeyCode = 0x33
+	VK_4                   VirtualKeyCode = 0x34
+	VK_5                   VirtualKeyCode = 0x35
+	VK_6                   VirtualKeyCode = 0x36
+	VK_7                   VirtualKeyCode = 0x37
+	VK_8                   VirtualKeyCode = 0x38
+	VK_9                   VirtualKeyCode = 0x39
+	VK_A                   VirtualKeyCode = 0x41
+	VK_B                   VirtualKeyCode = 0x42
+	VK_C                   VirtualKeyCode = 0x43
+	VK_D                   VirtualKeyCode = 0x44
+	VK_E                   VirtualKeyCode = 0x45
+	VK_F                   VirtualKeyCode = 0x46
+	VK_G                   VirtualKeyCode = 0x47
+	VK_H                   VirtualKeyCode = 0x48
+	VK_I                   VirtualKeyCode = 0x49
+	VK_J                   VirtualKeyCode = 0x4A
+	VK_K                   VirtualKeyCode = 0x4B
+	VK_L                   VirtualKeyCode = 0x4C
+	VK_M                   VirtualKeyCode = 0x4D
+	VK_N                   VirtualKeyCode = 0x4E
+	VK_O                   VirtualKeyCode = 0x4F
+	VK_P                   VirtualKeyCode = 0x50
+	VK_Q                   VirtualKeyCode = 0x51
+	VK_R                   VirtualKeyCode = 0x52
+	VK_S                   VirtualKeyCode = 0x53
+	VK_T                   VirtualKeyCode = 0x54
+	VK_U                   VirtualKeyCode = 0x55
+	VK_V                   VirtualKeyCode = 0x56
+	VK_W                   VirtualKeyCode = 0x57
+	VK_X                   VirtualKeyCode = 0x58
+	VK_Y                   VirtualKeyCode = 0x59
+	VK_Z                   VirtualKeyCode = 0x5A
+	VK_LWIN                VirtualKeyCode = 0x5B
+	VK_RWIN                VirtualKeyCode = 0x5C
+	VK_APPS                VirtualKeyCode = 0x5D
+	VK_SLEEP               VirtualKeyCode = 0x5F
+	VK_NUMPAD0             VirtualKeyCode = 0x60
+	VK_NUMPAD1             VirtualKeyCode = 0x61
+	VK_NUMPAD2             VirtualKeyCode = 0x62
+	VK_NUMPAD3             VirtualKeyCode = 0x63
+	VK_NUMPAD4             VirtualKeyCode = 0x64
+	VK_NUMPAD5             VirtualKeyCode = 0x65
+	VK_NUMPAD6             VirtualKeyCode = 0x66
+	VK_NUMPAD7             VirtualKeyCode = 0x67
+	VK_NUMPAD8             VirtualKeyCode = 0x68
+	VK_NUMPAD9             VirtualKeyCode = 0x69
+	VK_MULTIPLY            VirtualKeyCode = 0x6A
+	VK_ADD                 VirtualKeyCode = 0x6B
+	VK_SEPARATOR           VirtualKeyCode = 0x6C
+	VK_SUBTRACT            VirtualKeyCode = 0x6D
+	VK_DECIMAL             VirtualKeyCode = 0x6E
+	VK_DIVIDE              VirtualKeyCode = 0x6F
+	VK_F1                  VirtualKeyCode = 0x70
+	VK_F2                  VirtualKeyCode = 0x71
+	VK_F3                  VirtualKeyCode = 0x72
+	VK_F4                  VirtualKeyCode = 0x73
+	VK_F5                  VirtualKeyCode = 0x74
+	VK_F6                  VirtualKeyCode = 0x75
+	VK_F7                  VirtualKeyCode = 0x76
+	VK_F8                  VirtualKeyCode = 0x77
+	VK_F9                  VirtualKeyCode = 0x78
+	VK_F10                 VirtualKeyCode = 0x79
+	VK_F11                 VirtualKeyCode = 0x7A
+	VK_F12                 VirtualKeyCode = 0x7B
+	VK_F13                 VirtualKeyCode = 0x7C
+	VK_F14                 VirtualKeyCode = 0x7D
+	VK_F15                 VirtualKeyCode = 0x7E
+	VK_F16                 VirtualKeyCode = 0x7F
+	VK_F17                 VirtualKeyCode = 0x80
+	VK_F18                 VirtualKeyCode = 0x81
+	VK_F19                 VirtualKeyCode = 0x82
+	VK_F20                 VirtualKeyCode = 0x83
+	VK_F21                 VirtualKeyCode = 0x84
+	VK_F22                 VirtualKeyCode = 0x85
+	VK_F23                 VirtualKeyCode = 0x86
+	VK_F24                 VirtualKeyCode = 0x87
+	VK_NUMLOCK             VirtualKeyCode = 0x90
+	VK_SCROLL              VirtualKeyCode = 0x91
+	VK_OEM_NEC_EQUAL       VirtualKeyCode = 0x92
+	VK_OEM_FJ_JISHO        VirtualKeyCode = 0x92
+	VK_OEM_FJ_MASSHOU      VirtualKeyCode = 0x93
+	VK_OEM_FJ_TOUROKU      VirtualKeyCode = 0x94
+	VK_OEM_FJ_LOYA         VirtualKeyCode = 0x95
+	VK_OEM_FJ_ROYA         VirtualKeyCode = 0x96
+	VK_LSHIFT              VirtualKeyCode = 0xA0
+	VK_RSHIFT              VirtualKeyCode = 0xA1
+	VK_LCONTROL            VirtualKeyCode = 0xA2
+	VK_RCONTROL            VirtualKeyCode = 0xA3
+	VK_LMENU               VirtualKeyCode = 0xA4
+	VK_RMENU               VirtualKeyCode = 0xA5
+	VK_BROWSER_BACK        VirtualKeyCode = 0xA6
+	VK_BROWSER_FORWARD     VirtualKeyCode = 0xA7
+	VK_BROWSER_REFRESH     VirtualKeyCode = 0xA8
+	VK_BROWSER_STOP        VirtualKeyCode = 0xA9
+	VK_BROWSER_SEARCH      VirtualKeyCode = 0xAA
+	VK_BROWSER_FAVORITES   VirtualKeyCode = 0xAB
+	VK_BROWSER_HOME        VirtualKeyCode = 0xAC
+	VK_VOLUME_MUTE         VirtualKeyCode = 0xAD
+	VK_VOLUME_DOWN         VirtualKeyCode = 0xAE
+	VK_VOLUME_UP           VirtualKeyCode = 0xAF
+	VK_MEDIA_NEXT_TRACK    VirtualKeyCode = 0xB0
+	VK_MEDIA_PREV_TRACK    VirtualKeyCode = 0xB1
+	VK_MEDIA_STOP          VirtualKeyCode = 0xB2
+	VK_MEDIA_PLAY_PAUSE    VirtualKeyCode = 0xB3
+	VK_LAUNCH_MAIL         VirtualKeyCode = 0xB4
+	VK_LAUNCH_MEDIA_SELECT VirtualKeyCode = 0xB5
+	VK_LAUNCH_APP1         VirtualKeyCode = 0xB6
+	VK_LAUNCH_APP2         VirtualKeyCode = 0xB7
+	VK_OEM_1               VirtualKeyCode = 0xBA
+	VK_OEM_PLUS            VirtualKeyCode = 0xBB
+	VK_OEM_COMMA           VirtualKeyCode = 0xBC
+	VK_OEM_MINUS           VirtualKeyCode = 0xBD
+	VK_OEM_PERIOD          VirtualKeyCode = 0xBE
+	VK_OEM_2               VirtualKeyCode = 0xBF
+	VK_OEM_3               VirtualKeyCode = 0xC0
+	VK_OEM_4               VirtualKeyCode = 0xDB
+	VK_OEM_5               VirtualKeyCode = 0xDC
+	VK_OEM_6               VirtualKeyCode = 0xDD
+	VK_OEM_7               VirtualKeyCode = 0xDE
+	VK_OEM_8               VirtualKeyCode = 0xDF
+	VK_OEM_AX              VirtualKeyCode = 0xE1
+	VK_OEM_102             VirtualKeyCode = 0xE2
+	VK_ICO_HELP            VirtualKeyCode = 0xE3
+	VK_ICO_00              VirtualKeyCode = 0xE4
+	VK_PROCESSKEY          VirtualKeyCode = 0xE5
+	VK_ICO_CLEAR           VirtualKeyCode = 0xE6
+	VK_OEM_RESET           VirtualKeyCode = 0xE9
+	VK_OEM_JUMP            VirtualKeyCode = 0xEA
+	VK_OEM_PA1             VirtualKeyCode = 0xEB
+	VK_OEM_PA2             VirtualKeyCode = 0xEC
+	VK_OEM_PA3             VirtualKeyCode = 0xED
+	VK_OEM_WSCTRL          VirtualKeyCode = 0xEE
+	VK_OEM_CUSEL           VirtualKeyCode = 0xEF
+	VK_OEM_ATTN            VirtualKeyCode = 0xF0
+	VK_OEM_FINISH          VirtualKeyCode = 0xF1
+	VK_OEM_COPY            VirtualKeyCode = 0xF2
+	VK_OEM_AUTO            VirtualKeyCode = 0xF3
+	VK_OEM_ENLW            VirtualKeyCode = 0xF4
+	VK_OEM_BACKTAB         VirtualKeyCode = 0xF5
+	VK_ATTN                VirtualKeyCode = 0xF6
+	VK_CRSEL               VirtualKeyCode = 0xF7
+	VK_EXSEL               VirtualKeyCode = 0xF8
+	VK_EREOF               VirtualKeyCode = 0xF9
+	VK_PLAY                VirtualKeyCode = 0xFA
+	VK_ZOOM                VirtualKeyCode = 0xFB
+	VK_NONAME              VirtualKeyCode = 0xFC
+	VK_PA1                 VirtualKeyCode = 0xFD
+	VK_OEM_CLEAR           VirtualKeyCode = 0xFE
+)

vendor/github.com/erikgeiser/coninput/mode.go

@@ -0,0 +1,82 @@
+//go:build windows
+// +build windows
+
+package coninput
+
+import (
+	"strings"
+
+	"golang.org/x/sys/windows"
+)
+
+// AddInputModes returns the given mode with one or more additional modes enabled.
+func AddInputModes(mode uint32, enableModes ...uint32) uint32 {
+	for _, enableMode := range enableModes {
+		mode |= enableMode
+	}
+
+	return mode
+}
+
+// RemoveInputModes returns the given mode with one or more additional modes disabled.
+func RemoveInputModes(mode uint32, disableModes ...uint32) uint32 {
+	for _, disableMode := range disableModes {
+		mode &^= disableMode
+	}
+
+	return mode
+}
+
+// ToggleInputModes returns the given mode with one or more additional modes toggeled.
+func ToggleInputModes(mode uint32, toggleModes ...uint32) uint32 {
+	for _, toggeMode := range toggleModes {
+		mode ^= toggeMode
+	}
+
+	return mode
+}
+
+var inputModes = []struct {
+	mode uint32
+	name string
+}{
+	{mode: windows.ENABLE_ECHO_INPUT, name: "ENABLE_ECHO_INPUT"},
+	{mode: windows.ENABLE_INSERT_MODE, name: "ENABLE_INSERT_MODE"},
+	{mode: windows.ENABLE_LINE_INPUT, name: "ENABLE_LINE_INPUT"},
+	{mode: windows.ENABLE_MOUSE_INPUT, name: "ENABLE_MOUSE_INPUT"},
+	{mode: windows.ENABLE_PROCESSED_INPUT, name: "ENABLE_PROCESSED_INPUT"},
+	{mode: windows.ENABLE_QUICK_EDIT_MODE, name: "ENABLE_QUICK_EDIT_MODE"},
+	{mode: windows.ENABLE_WINDOW_INPUT, name: "ENABLE_WINDOW_INPUT"},
+	{mode: windows.ENABLE_VIRTUAL_TERMINAL_INPUT, name: "ENABLE_VIRTUAL_TERMINAL_INPUT"},
+}
+
+// ListInputMode returnes the isolated enabled input modes as a list.
+func ListInputModes(mode uint32) []uint32 {
+	modes := []uint32{}
+
+	for _, inputMode := range inputModes {
+		if mode&inputMode.mode > 0 {
+			modes = append(modes, inputMode.mode)
+		}
+	}
+
+	return modes
+}
+
+// ListInputMode returnes the isolated enabled input mode names as a list.
+func ListInputModeNames(mode uint32) []string {
+	modes := []string{}
+
+	for _, inputMode := range inputModes {
+		if mode&inputMode.mode > 0 {
+			modes = append(modes, inputMode.name)
+		}
+	}
+
+	return modes
+}
+
+// DescribeInputMode returns a string containing the names of each enabled input mode.
+func DescribeInputMode(mode uint32) string {
+	return strings.Join(ListInputModeNames(mode), "|")
+}

vendor/github.com/erikgeiser/coninput/read.go

@@ -0,0 +1,154 @@
+//go:build windows
+// +build windows
+
+package coninput
+
+import (
+	"fmt"
+	"syscall"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+var (
+	modkernel32                       = windows.NewLazySystemDLL("kernel32.dll")
+	procReadConsoleInputW             = modkernel32.NewProc("ReadConsoleInputW")
+	procPeekConsoleInputW             = modkernel32.NewProc("PeekConsoleInputW")
+	procGetNumberOfConsoleInputEvents = modkernel32.NewProc("GetNumberOfConsoleInputEvents")
+	procFlushConsoleInputBuffer       = modkernel32.NewProc("FlushConsoleInputBuffer")
+)
+
+// NewStdinHandle is a shortcut for windows.GetStdHandle(windows.STD_INPUT_HANDLE).
+func NewStdinHandle() (windows.Handle, error) {
+	return windows.GetStdHandle(windows.STD_INPUT_HANDLE)
+}
+
+// WinReadConsoleInput is a thin wrapper around the Windows console API function
+// ReadConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/readconsoleinput). In most
+// cases it is more practical to either use ReadConsoleInput or
+// ReadNConsoleInputs.
+func WinReadConsoleInput(consoleInput windows.Handle, buffer *InputRecord,
+	length uint32, numberOfEventsRead *uint32) error {
+	r, _, e := syscall.Syscall6(procReadConsoleInputW.Addr(), 4,
+		uintptr(consoleInput), uintptr(unsafe.Pointer(buffer)), uintptr(length),
+		uintptr(unsafe.Pointer(numberOfEventsRead)), 0, 0)
+	if r == 0 {
+		return error(e)
+	}
+
+	return nil
+}
+
+// ReadNConsoleInputs is a wrapper around ReadConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/readconsoleinput) that
+// automates the event buffer allocation in oder to provide io.Reader-like
+// sematics. maxEvents must be greater than zero.
+func ReadNConsoleInputs(console windows.Handle, maxEvents uint32) ([]InputRecord, error) {
+	if maxEvents == 0 {
+		return nil, fmt.Errorf("maxEvents cannot be zero")
+	}
+
+	var inputRecords = make([]InputRecord, maxEvents)
+	n, err := ReadConsoleInput(console, inputRecords)
+
+	return inputRecords[:n], err
+}
+
+// ReadConsoleInput provides an ideomatic interface to the Windows console API
+// function ReadConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/readconsoleinput). The size
+// of inputRecords must be greater than zero.
+func ReadConsoleInput(console windows.Handle, inputRecords []InputRecord) (uint32, error) {
+	if len(inputRecords) == 0 {
+		return 0, fmt.Errorf("size of input record buffer cannot be zero")
+	}
+
+	var read uint32
+	err := WinReadConsoleInput(console, &inputRecords[0], uint32(len(inputRecords)), &read)
+
+	return read, err
+}
+
+// WinPeekConsoleInput is a thin wrapper around the Windows console API function
+// PeekConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/peekconsoleinput). In most
+// cases it is more practical to either use PeekConsoleInput or
+// PeekNConsoleInputs.
+func WinPeekConsoleInput(consoleInput windows.Handle, buffer *InputRecord,
+	length uint32, numberOfEventsRead *uint32) error {
+	r, _, e := syscall.Syscall6(procPeekConsoleInputW.Addr(), 4,
+		uintptr(consoleInput), uintptr(unsafe.Pointer(buffer)), uintptr(length),
+		uintptr(unsafe.Pointer(numberOfEventsRead)), 0, 0)
+	if r == 0 {
+		return error(e)
+	}
+
+	return nil
+
+}
+
+// PeekNConsoleInputs is a wrapper around PeekConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/peekconsoleinput) that
+// automates the event buffer allocation in oder to provide io.Reader-like
+// sematics. maxEvents must be greater than zero.
+func PeekNConsoleInputs(console windows.Handle, maxEvents uint32) ([]InputRecord, error) {
+	if maxEvents == 0 {
+		return nil, fmt.Errorf("maxEvents cannot be zero")
+	}
+
+	var inputRecords = make([]InputRecord, maxEvents)
+	n, err := PeekConsoleInput(console, inputRecords)
+
+	return inputRecords[:n], err
+}
+
+// PeekConsoleInput provides an ideomatic interface to the Windows console API
+// function PeekConsoleInput (see
+// https://docs.microsoft.com/en-us/windows/console/peekconsoleinput). The size
+// of inputRecords must be greater than zero.
+func PeekConsoleInput(console windows.Handle, inputRecords []InputRecord) (uint32, error) {
+	if len(inputRecords) == 0 {
+		return 0, fmt.Errorf("size of input record buffer cannot be zero")
+	}
+
+	var read uint32
+
+	err := WinPeekConsoleInput(console, &inputRecords[0], uint32(len(inputRecords)), &read)
+
+	return read, err
+}
+
+// WinGetNumberOfConsoleInputEvents provides an ideomatic interface to the
+// Windows console API function GetNumberOfConsoleInputEvents (see
+// https://docs.microsoft.com/en-us/windows/console/getnumberofconsoleinputevents).
+func WinGetNumberOfConsoleInputEvents(consoleInput windows.Handle, numberOfEvents *uint32) error {
+	r, _, e := syscall.Syscall6(procGetNumberOfConsoleInputEvents.Addr(), 2,
+		uintptr(consoleInput), uintptr(unsafe.Pointer(numberOfEvents)), 0,
+		0, 0, 0)
+	if r == 0 {
+		return error(e)
+	}
+
+	return nil
+}
+
+// GetNumberOfConsoleInputEvents provides an ideomatic interface to the Windows
+// console API function GetNumberOfConsoleInputEvents (see
+// https://docs.microsoft.com/en-us/windows/console/getnumberofconsoleinputevents).
+func GetNumberOfConsoleInputEvents(console windows.Handle) (uint32, error) {
+	var nEvents uint32
+	err := WinGetNumberOfConsoleInputEvents(console, &nEvents)
+
+	return nEvents, err
+}
+
+func FlushConsoleInputBuffer(consoleInput windows.Handle) error {
+	r, _, e := syscall.Syscall(procFlushConsoleInputBuffer.Addr(), 1, uintptr(consoleInput), 0, 0)
+	if r == 0 {
+		return error(e)
+	}
+
+	return nil
+}

vendor/github.com/erikgeiser/coninput/records.go

@@ -0,0 +1,486 @@
+package coninput
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const (
+	maxEventSize     = 16
+	wordPaddingBytes = 2
+)
+
+// EventType denots the type of an event
+type EventType uint16
+
+// EventUnion is the union data type that contains the data for any event.
+type EventUnion [maxEventSize]byte
+
+// InputRecord corresponds to the INPUT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+type InputRecord struct {
+	// EventType specifies the type of event that helt in Event.
+	EventType EventType
+
+	// Padding of the 16-bit EventType to a whole 32-bit dword.
+	_ [wordPaddingBytes]byte
+
+	// Event holds the actual event data. Use Unrap to access it as its
+	// respective event type.
+	Event EventUnion
+}
+
+// String implements fmt.Stringer for InputRecord.
+func (ir InputRecord) String() string {
+	return ir.Unwrap().String()
+}
+
+// Unwrap parses the event data into an EventRecord of the respective event
+// type. The data in the returned EventRecord does not contain any references to
+// the passed InputRecord.
+func (ir InputRecord) Unwrap() EventRecord {
+	switch ir.EventType {
+	case FocusEventType:
+		return FocusEventRecord{SetFocus: ir.Event[0] > 0}
+	case KeyEventType:
+		return KeyEventRecord{
+			KeyDown:         binary.LittleEndian.Uint32(ir.Event[0:4]) > 0,
+			RepeatCount:     binary.LittleEndian.Uint16(ir.Event[4:6]),
+			VirtualKeyCode:  VirtualKeyCode(binary.LittleEndian.Uint16(ir.Event[6:8])),
+			VirtualScanCode: VirtualKeyCode(binary.LittleEndian.Uint16(ir.Event[8:10])),
+			Char:            rune(binary.LittleEndian.Uint16(ir.Event[10:12])),
+			ControlKeyState: ControlKeyState(binary.LittleEndian.Uint32(ir.Event[12:16])),
+		}
+	case MouseEventType:
+		m := MouseEventRecord{
+			MousePositon: Coord{
+				X: binary.LittleEndian.Uint16(ir.Event[0:2]),
+				Y: binary.LittleEndian.Uint16(ir.Event[2:4]),
+			},
+			ButtonState:     ButtonState(binary.LittleEndian.Uint32(ir.Event[4:8])),
+			ControlKeyState: ControlKeyState(binary.LittleEndian.Uint32(ir.Event[8:12])),
+			EventFlags:      EventFlags(binary.LittleEndian.Uint32(ir.Event[12:16])),
+		}
+
+		if (m.EventFlags&MOUSE_WHEELED > 0) || (m.EventFlags&MOUSE_HWHEELED > 0) {
+			if int16(highWord(uint32(m.ButtonState))) > 0 {
+				m.WheelDirection = 1
+			} else {
+				m.WheelDirection = -1
+			}
+		}
+
+		return m
+	case WindowBufferSizeEventType:
+		return WindowBufferSizeEventRecord{
+			Size: Coord{
+				X: binary.LittleEndian.Uint16(ir.Event[0:2]),
+				Y: binary.LittleEndian.Uint16(ir.Event[2:4]),
+			},
+		}
+	case MenuEventType:
+		return MenuEventRecord{
+			CommandID: binary.LittleEndian.Uint32(ir.Event[0:4]),
+		}
+	default:
+		return &UnknownEvent{InputRecord: ir}
+	}
+}
+
+// EventRecord represents one of the following event types:
+// TypeFocusEventRecord, TypeKeyEventRecord, TypeMouseEventRecord,
+// TypeWindowBufferSizeEvent, TypeMenuEventRecord and UnknownEvent.
+type EventRecord interface {
+	Type() string
+	fmt.Stringer
+}
+
+// FocusEventType is the event type for a FocusEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const FocusEventType EventType = 0x0010
+
+// FocusEventRecord represent the FOCUS_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/focus-event-record-str).
+// These events are used internally by the Windows console API and should be
+// ignored.
+type FocusEventRecord struct {
+	// SetFocus is reserved and should not be used.
+	SetFocus bool
+}
+
+// Ensure that FocusEventRecord satisfies EventRecord interface.
+var _ EventRecord = FocusEventRecord{}
+
+// Type ensures that FocusEventRecord satisfies EventRecord interface.
+func (e FocusEventRecord) Type() string { return "FocusEvent" }
+
+// String ensures that FocusEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e FocusEventRecord) String() string { return fmt.Sprintf("%s[%v]", e.Type(), e.SetFocus) }
+
+// KeyEventType is the event type for a KeyEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const KeyEventType EventType = 0x0001
+
+// KeyEventRecord represent the KEY_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/key-event-record-str).
+type KeyEventRecord struct {
+	// KeyDown specified whether the key is pressed or released.
+	KeyDown bool
+
+	//  RepeatCount indicates that a key is being held down. For example, when a
+	//  key is held down, five events with RepeatCount equal to 1 may be
+	//  generated, one event with RepeatCount equal to 5, or multiple events
+	//  with RepeatCount greater than or equal to 1.
+	RepeatCount uint16
+
+	// VirtualKeyCode identifies the given key in a device-independent manner
+	// (see
+	// https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes).
+	VirtualKeyCode VirtualKeyCode
+
+	//  VirtualScanCode represents the device-dependent value generated by the
+	//  keyboard hardware.
+	VirtualScanCode VirtualKeyCode
+
+	// Char is the character that corresponds to the pressed key. Char can be
+	// zero for some keys.
+	Char rune
+
+	//ControlKeyState holds the state of the control keys.
+	ControlKeyState ControlKeyState
+}
+
+// Ensure that KeyEventRecord satisfies EventRecord interface.
+var _ EventRecord = KeyEventRecord{}
+
+// Type ensures that KeyEventRecord satisfies EventRecord interface.
+func (e KeyEventRecord) Type() string { return "KeyEvent" }
+
+// String ensures that KeyEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e KeyEventRecord) String() string {
+	infos := []string{}
+
+	repeat := ""
+	if e.RepeatCount > 1 {
+		repeat = "x" + strconv.Itoa(int(e.RepeatCount))
+	}
+
+	infos = append(infos, fmt.Sprintf("%q%s", e.Char, repeat))
+
+	direction := "up"
+	if e.KeyDown {
+		direction = "down"
+	}
+
+	infos = append(infos, direction)
+
+	if e.ControlKeyState != NO_CONTROL_KEY {
+		infos = append(infos, e.ControlKeyState.String())
+	}
+
+	infos = append(infos, fmt.Sprintf("KeyCode: %d", e.VirtualKeyCode))
+	infos = append(infos, fmt.Sprintf("ScanCode: %d", e.VirtualScanCode))
+
+	return fmt.Sprintf("%s[%s]", e.Type(), strings.Join(infos, ", "))
+}
+
+// MenuEventType is the event type for a MenuEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const MenuEventType EventType = 0x0008
+
+// MenuEventRecord represent the MENU_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/menu-event-record-str).
+// These events are deprecated by the Windows console API and should be ignored.
+type MenuEventRecord struct {
+	CommandID uint32
+}
+
+// Ensure that MenuEventRecord satisfies EventRecord interface.
+var _ EventRecord = MenuEventRecord{}
+
+// Type ensures that MenuEventRecord satisfies EventRecord interface.
+func (e MenuEventRecord) Type() string { return "MenuEvent" }
+
+// String ensures that MenuEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e MenuEventRecord) String() string { return fmt.Sprintf("MenuEvent[%d]", e.CommandID) }
+
+// MouseEventType is the event type for a MouseEventRecord (see
+// https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const MouseEventType EventType = 0x0002
+
+// MouseEventRecord represent the MOUSE_EVENT_RECORD structure from the Windows
+// console API (see
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type MouseEventRecord struct {
+	// MousePosition contains the location of the cursor, in terms of the
+	// console screen buffer's character-cell coordinates.
+	MousePositon Coord
+
+	// ButtonState holds the status of the mouse buttons.
+	ButtonState ButtonState
+
+	// ControlKeyState holds the state of the control keys.
+	ControlKeyState ControlKeyState
+
+	// EventFlags specify tge type of mouse event.
+	EventFlags EventFlags
+
+	// WheelDirection specified the direction in which the mouse wheel is
+	// spinning when EventFlags contains MOUSE_HWHEELED or MOUSE_WHEELED. When
+	// the event flags specify MOUSE_WHEELED it is 1 if the wheel rotated
+	// forward (away from the user) or -1 when it rotates backwards. When
+	// MOUSE_HWHEELED is specified it is 1 when the wheel rotates right and -1
+	// when it rotates left. When the EventFlags do not indicate a mouse wheel
+	// event it is 0.
+	WheelDirection int
+}
+
+// Ensure that MouseEventRecord satisfies EventRecord interface.
+var _ EventRecord = MouseEventRecord{}
+
+func (e MouseEventRecord) WheelDirectionName() string {
+	if e.EventFlags&MOUSE_WHEELED > 0 {
+		if e.WheelDirection > 0 {
+			return "Forward"
+		}
+
+		return "Backward"
+	} else if e.EventFlags&MOUSE_HWHEELED > 0 {
+		if e.WheelDirection > 0 {
+			return "Right"
+		}
+
+		return "Left"
+	}
+
+	return ""
+}
+
+// Type ensures that MouseEventRecord satisfies EventRecord interface.
+func (e MouseEventRecord) Type() string { return "MouseEvent" }
+
+// String ensures that MouseEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e MouseEventRecord) String() string {
+	infos := []string{e.MousePositon.String()}
+
+	if e.ButtonState&0xFF != 0 {
+		infos = append(infos, e.ButtonState.String())
+	}
+
+	eventDescription := e.EventFlags.String()
+
+	wheelDirection := e.WheelDirectionName()
+	if wheelDirection != "" {
+		eventDescription += "(" + wheelDirection + ")"
+	}
+
+	infos = append(infos, eventDescription)
+
+	if e.ControlKeyState != NO_CONTROL_KEY {
+		infos = append(infos, e.ControlKeyState.String())
+	}
+
+	return fmt.Sprintf("%s[%s]", e.Type(), strings.Join(infos, ", "))
+}
+
+// WindowBufferSizeEventType is the event type for a WindowBufferSizeEventRecord
+// (see https://docs.microsoft.com/en-us/windows/console/input-record-str).
+const WindowBufferSizeEventType EventType = 0x0004
+
+// WindowBufferSizeEventRecord represent the WINDOW_BUFFER_SIZE_RECORD structure
+// from the Windows console API (see
+// https://docs.microsoft.com/en-us/windows/console/window-buffer-size-record-str).
+type WindowBufferSizeEventRecord struct {
+	// Size contains the size of the console screen buffer, in character cell columns and rows.
+	Size Coord
+}
+
+// Ensure that WindowBufferSizeEventRecord satisfies EventRecord interface.
+var _ EventRecord = WindowBufferSizeEventRecord{}
+
+// Type ensures that WindowBufferSizeEventRecord satisfies EventRecord interface.
+func (e WindowBufferSizeEventRecord) Type() string { return "WindowBufferSizeEvent" }
+
+// String ensures that WindowBufferSizeEventRecord satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e WindowBufferSizeEventRecord) String() string {
+	return fmt.Sprintf("WindowBufferSizeEvent[%s]", e.Size)
+}
+
+// UnknownEvent is generated when the event type does not match one of the
+// following types: TypeFocusEventRecord, TypeKeyEventRecord,
+// TypeMouseEventRecord, TypeWindowBufferSizeEvent, TypeMenuEventRecord and
+// UnknownEvent.
+type UnknownEvent struct {
+	InputRecord
+}
+
+// Ensure that UnknownEvent satisfies EventRecord interface.
+var _ EventRecord = UnknownEvent{}
+
+// Type ensures that UnknownEvent satisfies EventRecord interface.
+func (e UnknownEvent) Type() string { return "UnknownEvent" }
+
+// String ensures that UnknownEvent satisfies EventRecord and fmt.Stringer
+// interfaces.
+func (e UnknownEvent) String() string {
+	return fmt.Sprintf("%s[Type: %d, Data: %v]", e.Type(), e.InputRecord.EventType, e.InputRecord.Event[:])
+}
+
+// Coord represent the COORD structure from the Windows
+// console API (see https://docs.microsoft.com/en-us/windows/console/coord-str).
+type Coord struct {
+	// X is the horizontal coordinate or column value. The units depend on the function call.
+	X uint16
+	// Y is the vertical coordinate or row value. The units depend on the function call.
+	Y uint16
+}
+
+// String ensures that Coord satisfies the fmt.Stringer interface.
+func (c Coord) String() string {
+	return fmt.Sprintf("(%d, %d)", c.X, c.Y)
+}
+
+// ButtonState holds the state of the mouse buttons (see
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type ButtonState uint32
+
+func (bs ButtonState) Contains(state ButtonState) bool {
+	return bs&state > 0
+}
+
+// String ensures that ButtonState satisfies the fmt.Stringer interface.
+func (bs ButtonState) String() string {
+	switch {
+	case bs&FROM_LEFT_1ST_BUTTON_PRESSED > 0:
+		return "Left"
+	case bs&FROM_LEFT_2ND_BUTTON_PRESSED > 0:
+		return "2"
+	case bs&FROM_LEFT_3RD_BUTTON_PRESSED > 0:
+		return "3"
+	case bs&FROM_LEFT_4TH_BUTTON_PRESSED > 0:
+		return "4"
+	case bs&RIGHTMOST_BUTTON_PRESSED > 0:
+		return "Right"
+	case bs&0xFF == 0:
+		return "No Button"
+	default:
+		return fmt.Sprintf("Unknown(%d)", bs)
+	}
+}
+
+func (bs ButtonState) IsReleased() bool {
+	return bs&0xff > 0
+}
+
+// Valid values for ButtonState.
+const (
+	FROM_LEFT_1ST_BUTTON_PRESSED ButtonState = 0x0001
+	RIGHTMOST_BUTTON_PRESSED     ButtonState = 0x0002
+	FROM_LEFT_2ND_BUTTON_PRESSED ButtonState = 0x0004
+	FROM_LEFT_3RD_BUTTON_PRESSED ButtonState = 0x0008
+	FROM_LEFT_4TH_BUTTON_PRESSED ButtonState = 0x0010
+)
+
+// ControlKeyState holds the state of the control keys for key and mouse events
+// (see https://docs.microsoft.com/en-us/windows/console/key-event-record-str
+// and https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type ControlKeyState uint32
+
+func (cks ControlKeyState) Contains(state ControlKeyState) bool {
+	return cks&state > 0
+}
+
+// Valid values for ControlKeyState.
+const (
+	CAPSLOCK_ON        ControlKeyState = 0x0080
+	ENHANCED_KEY       ControlKeyState = 0x0100
+	LEFT_ALT_PRESSED   ControlKeyState = 0x0002
+	LEFT_CTRL_PRESSED  ControlKeyState = 0x0008
+	NUMLOCK_ON         ControlKeyState = 0x0020
+	RIGHT_ALT_PRESSED  ControlKeyState = 0x0001
+	RIGHT_CTRL_PRESSED ControlKeyState = 0x0004
+	SCROLLLOCK_ON      ControlKeyState = 0x0040
+	SHIFT_PRESSED      ControlKeyState = 0x0010
+	NO_CONTROL_KEY     ControlKeyState = 0x0000
+)
+
+// String ensures that ControlKeyState satisfies the fmt.Stringer interface.
+func (cks ControlKeyState) String() string {
+	controlKeys := []string{}
+
+	switch {
+	case cks&CAPSLOCK_ON > 0:
+		controlKeys = append(controlKeys, "CapsLock")
+	case cks&ENHANCED_KEY > 0:
+		controlKeys = append(controlKeys, "Enhanced")
+	case cks&LEFT_ALT_PRESSED > 0:
+		controlKeys = append(controlKeys, "Alt")
+	case cks&LEFT_CTRL_PRESSED > 0:
+		controlKeys = append(controlKeys, "CTRL")
+	case cks&NUMLOCK_ON > 0:
+		controlKeys = append(controlKeys, "NumLock")
+	case cks&RIGHT_ALT_PRESSED > 0:
+		controlKeys = append(controlKeys, "RightAlt")
+	case cks&RIGHT_CTRL_PRESSED > 0:
+		controlKeys = append(controlKeys, "RightCTRL")
+	case cks&SCROLLLOCK_ON > 0:
+		controlKeys = append(controlKeys, "ScrollLock")
+	case cks&SHIFT_PRESSED > 0:
+		controlKeys = append(controlKeys, "Shift")
+	case cks == NO_CONTROL_KEY:
+	default:
+		return fmt.Sprintf("Unknown(%d)", cks)
+	}
+
+	return strings.Join(controlKeys, ",")
+}
+
+// EventFlags specifies the type of a mouse event (see
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str).
+type EventFlags uint32
+
+// String ensures that EventFlags satisfies the fmt.Stringer interface.
+func (ef EventFlags) String() string {
+	switch {
+	case ef&DOUBLE_CLICK > 0:
+		return "DoubleClick"
+	case ef&MOUSE_WHEELED > 0:
+		return "Wheeled"
+	case ef&MOUSE_MOVED > 0:
+		return "Moved"
+	case ef&MOUSE_HWHEELED > 0:
+		return "HWheeld"
+	case ef == CLICK:
+		return "Click"
+	default:
+		return fmt.Sprintf("Unknown(%d)", ef)
+	}
+}
+
+func (ef EventFlags) Contains(flag EventFlags) bool {
+	return ef&flag > 0
+}
+
+// Valid values for EventFlags.
+const (
+	CLICK          EventFlags = 0x0000
+	MOUSE_MOVED    EventFlags = 0x0001
+	DOUBLE_CLICK   EventFlags = 0x0002
+	MOUSE_WHEELED  EventFlags = 0x0004
+	MOUSE_HWHEELED EventFlags = 0x0008
+)
+
+func highWord(data uint32) uint16 {
+	return uint16((data & 0xFFFF0000) >> 16)
+}

vendor/github.com/mattn/go-localereader/README.md

@@ -0,0 +1,23 @@
+# go-localereader
+
+CodePage decoder for Windows
+
+## Usage
+
+```
+io.Copy(os.Stdout, localereader.NewAcpReader(bytes.Reader(bytesSjis)))
+```
+
+## Installation
+
+```
+$ go get github.com/mattn/go-localereader
+```
+
+## License
+
+MIT
+
+## Author
+
+Yasuhiro Matsumoto (a.k.a. mattn)

vendor/github.com/mattn/go-localereader/localereader.go

@@ -0,0 +1,19 @@
+package localereader
+
+import (
+	"bytes"
+	"io"
+)
+
+func NewReader(r io.Reader) io.Reader {
+	return newReader(r)
+}
+
+func UTF8(b []byte) ([]byte, error) {
+	var buf bytes.Buffer
+	n, err := io.Copy(&buf, newReader(bytes.NewReader(b)))
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes()[:n], nil
+}

vendor/github.com/mattn/go-localereader/localereader_unix.go

@@ -0,0 +1,11 @@
+// +build !windows
+
+package localereader
+
+import (
+	"io"
+)
+
+func newReader(r io.Reader) io.Reader {
+	return r
+}

vendor/github.com/mattn/go-localereader/localereader_windows.go

@@ -0,0 +1,85 @@
+// +build windows
+
+package localereader
+
+import (
+	"io"
+	"syscall"
+	"unicode/utf8"
+	"unsafe"
+
+	"golang.org/x/text/transform"
+)
+
+const (
+	CP_ACP               = 0
+	MB_ERR_INVALID_CHARS = 8
+)
+
+var (
+	modkernel32             = syscall.NewLazyDLL("kernel32.dll")
+	procMultiByteToWideChar = modkernel32.NewProc("MultiByteToWideChar")
+	procIsDBCSLeadByte      = modkernel32.NewProc("IsDBCSLeadByte")
+)
+
+type codepageDecoder struct {
+	transform.NopResetter
+
+	cp int
+}
+
+func (codepageDecoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	r, size := rune(0), 0
+loop:
+	for ; nSrc < len(src); nSrc += size {
+		switch c0 := src[nSrc]; {
+		case c0 < utf8.RuneSelf:
+			r, size = rune(c0), 1
+
+		default:
+			br, _, _ := procIsDBCSLeadByte.Call(uintptr(src[nSrc]))
+			if br == 0 {
+				r = rune(src[nSrc])
+				size = 1
+				break
+			}
+			if nSrc >= len(src)-1 {
+				r = rune(src[nSrc])
+				size = 1
+				break
+			}
+			n, _, _ := procMultiByteToWideChar.Call(CP_ACP, 0, uintptr(unsafe.Pointer(&src[nSrc])), uintptr(2), uintptr(0), 0)
+			if n <= 0 {
+				err = syscall.GetLastError()
+				break
+			}
+			var us [1]uint16
+			rc, _, _ := procMultiByteToWideChar.Call(CP_ACP, 0, uintptr(unsafe.Pointer(&src[nSrc])), uintptr(2), uintptr(unsafe.Pointer(&us[0])), 1)
+			if rc == 0 {
+				size = 1
+				break
+			}
+			r = rune(us[0])
+			size = 2
+		}
+		if nDst+utf8.RuneLen(r) > len(dst) {
+			err = transform.ErrShortDst
+			break loop
+		}
+		nDst += utf8.EncodeRune(dst[nDst:], r)
+	}
+	return nDst, nSrc, err
+
+}
+
+func newReader(r io.Reader) io.Reader {
+	return transform.NewReader(r, NewAcpDecoder())
+}
+
+func NewCodePageDecoder(cp int) transform.Transformer {
+	return &codepageDecoder{cp: cp}
+}
+
+func NewAcpDecoder() transform.Transformer {
+	return &codepageDecoder{cp: CP_ACP}
+}

vendor/github.com/muesli/ansi/.gitignore

@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/

vendor/github.com/muesli/ansi/.golangci.yml

@@ -0,0 +1,27 @@
+run:
+  tests: false
+
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+linters:
+  enable:
+    - bodyclose
+    - dupl
+    - exportloopref
+    - goconst
+    - godot
+    - godox
+    - goimports
+    - golint
+    - goprintffuncname
+    - gosec
+    - ifshort
+    - misspell
+    - prealloc
+    - rowserrcheck
+    - sqlclosecheck
+    - unconvert
+    - unparam
+    - whitespace

vendor/github.com/muesli/ansi/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Christian Muehlhaeuser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/muesli/ansi/README.md

@@ -0,0 +1,31 @@
+# ansi
+
+[![Latest Release](https://img.shields.io/github/release/muesli/ansi.svg)](https://github.com/muesli/ansi/releases)
+[![Build Status](https://github.com/muesli/ansi/workflows/build/badge.svg)](https://github.com/muesli/ansi/actions)
+[![Coverage Status](https://coveralls.io/repos/github/muesli/ansi/badge.svg?branch=master)](https://coveralls.io/github/muesli/ansi?branch=master)
+[![Go ReportCard](https://goreportcard.com/badge/muesli/ansi)](https://goreportcard.com/report/muesli/ansi)
+[![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](https://pkg.go.dev/github.com/muesli/ansi)
+
+Raw ANSI sequence helpers
+
+## ANSI Writer
+
+```go
+import "github.com/muesli/ansi"
+
+w := ansi.Writer{Forward: os.Stdout}
+w.Write([]byte("\x1b[31mHello, world!\x1b[0m"))
+w.Close()
+```
+
+## Compressor
+
+The ANSI compressor eliminates unnecessary/redundant ANSI sequences.
+
+```go
+import "github.com/muesli/ansi/compressor"
+
+w := compressor.Writer{Forward: os.Stdout}
+w.Write([]byte("\x1b[31mHello, world!\x1b[0m"))
+w.Close()
+```

vendor/github.com/muesli/ansi/ansi.go

@@ -0,0 +1,7 @@
+package ansi
+
+const Marker = '\x1B'
+
+func IsTerminator(c rune) bool {
+	return (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a)
+}

vendor/github.com/muesli/ansi/buffer.go

@@ -0,0 +1,40 @@
+package ansi
+
+import (
+	"bytes"
+
+	"github.com/mattn/go-runewidth"
+)
+
+// Buffer is a buffer aware of ANSI escape sequences.
+type Buffer struct {
+	bytes.Buffer
+}
+
+// PrintableRuneWidth returns the cell width of all printable runes in the
+// buffer.
+func (w Buffer) PrintableRuneWidth() int {
+	return PrintableRuneWidth(w.String())
+}
+
+// PrintableRuneWidth returns the cell width of the given string.
+func PrintableRuneWidth(s string) int {
+	var n int
+	var ansi bool
+
+	for _, c := range s {
+		if c == Marker {
+			// ANSI escape sequence
+			ansi = true
+		} else if ansi {
+			if IsTerminator(c) {
+				// ANSI sequence terminated
+				ansi = false
+			}
+		} else {
+			n += runewidth.RuneWidth(c)
+		}
+	}
+
+	return n
+}

vendor/github.com/muesli/ansi/compressor/writer.go

@@ -0,0 +1,132 @@
+package compressor
+
+import (
+	"bytes"
+	"io"
+	"unicode/utf8"
+
+	"github.com/muesli/ansi"
+)
+
+type Writer struct {
+	Forward io.Writer
+
+	ansi         bool
+	ansiseq      bytes.Buffer
+	lastseq      bytes.Buffer
+	prevlastseq  bytes.Buffer
+	resetreq     bool
+	runeBuf      []byte
+	compressed   int
+	uncompressed int
+}
+
+// Bytes is shorthand for declaring a new default compressor instance,
+// used to immediately compress a byte slice.
+func Bytes(b []byte) []byte {
+	var buf bytes.Buffer
+	f := Writer{
+		Forward: &buf,
+	}
+	_, _ = f.Write(b)
+	_ = f.Close()
+
+	return buf.Bytes()
+}
+
+// String is shorthand for declaring a new default compressor instance,
+// used to immediately compress a string.
+func String(s string) string {
+	return string(Bytes([]byte(s)))
+}
+
+// Write is used to write content to the ANSI buffer.
+func (w *Writer) Write(b []byte) (int, error) {
+	w.uncompressed += len(b)
+
+	for _, c := range string(b) {
+		if c == ansi.Marker {
+			// ANSI escape sequence
+			w.ansi = true
+			_, _ = w.ansiseq.WriteRune(c)
+		} else if w.ansi {
+			_, _ = w.ansiseq.WriteRune(c)
+			if ansi.IsTerminator(c) {
+				// ANSI sequence terminated
+				w.ansi = false
+
+				terminated := false
+				if bytes.HasSuffix(w.ansiseq.Bytes(), []byte("[0m")) {
+					// reset sequence
+					w.prevlastseq.Reset()
+					w.prevlastseq.Write(w.lastseq.Bytes())
+
+					w.lastseq.Reset()
+					terminated = true
+					w.resetreq = true
+				} else if c == 'm' {
+					// color code
+					_, _ = w.lastseq.Write(w.ansiseq.Bytes())
+				}
+
+				if !terminated {
+					// did we reset the sequence just to restore it again?
+					if bytes.Equal(w.ansiseq.Bytes(), w.prevlastseq.Bytes()) {
+						w.resetreq = false
+						w.ansiseq.Reset()
+					}
+
+					w.prevlastseq.Reset()
+
+					if w.resetreq {
+						w.ResetAnsi()
+					}
+
+					_, _ = w.Forward.Write(w.ansiseq.Bytes())
+					w.compressed += w.ansiseq.Len()
+				}
+
+				w.ansiseq.Reset()
+			}
+		} else {
+			if w.resetreq {
+				w.ResetAnsi()
+			}
+
+			_, err := w.writeRune(c)
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	return len(b), nil
+}
+
+func (w *Writer) writeRune(r rune) (int, error) {
+	if w.runeBuf == nil {
+		w.runeBuf = make([]byte, utf8.UTFMax)
+	}
+	n := utf8.EncodeRune(w.runeBuf, r)
+	w.compressed += n
+	return w.Forward.Write(w.runeBuf[:n])
+}
+
+// Close finishes the compression operation. Always call it before trying to
+// retrieve the final result.
+func (w *Writer) Close() error {
+	if w.resetreq {
+		w.ResetAnsi()
+	}
+
+	// log.Println("Written uncompressed: ", w.uncompressed)
+	// log.Println("Written compressed: ", w.compressed)
+
+	return nil
+}
+
+func (w *Writer) ResetAnsi() {
+	w.prevlastseq.Reset()
+	_, _ = w.Forward.Write([]byte("\x1b[0m"))
+	w.resetreq = false
+}

vendor/github.com/muesli/ansi/writer.go

@@ -0,0 +1,76 @@
+package ansi
+
+import (
+	"bytes"
+	"io"
+	"unicode/utf8"
+)
+
+type Writer struct {
+	Forward io.Writer
+
+	ansi       bool
+	ansiseq    bytes.Buffer
+	lastseq    bytes.Buffer
+	seqchanged bool
+	runeBuf    []byte
+}
+
+// Write is used to write content to the ANSI buffer.
+func (w *Writer) Write(b []byte) (int, error) {
+	for _, c := range string(b) {
+		if c == Marker {
+			// ANSI escape sequence
+			w.ansi = true
+			w.seqchanged = true
+			_, _ = w.ansiseq.WriteRune(c)
+		} else if w.ansi {
+			_, _ = w.ansiseq.WriteRune(c)
+			if IsTerminator(c) {
+				// ANSI sequence terminated
+				w.ansi = false
+
+				if bytes.HasSuffix(w.ansiseq.Bytes(), []byte("[0m")) {
+					// reset sequence
+					w.lastseq.Reset()
+					w.seqchanged = false
+				} else if c == 'm' {
+					// color code
+					_, _ = w.lastseq.Write(w.ansiseq.Bytes())
+				}
+
+				_, _ = w.ansiseq.WriteTo(w.Forward)
+			}
+		} else {
+			_, err := w.writeRune(c)
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	return len(b), nil
+}
+
+func (w *Writer) writeRune(r rune) (int, error) {
+	if w.runeBuf == nil {
+		w.runeBuf = make([]byte, utf8.UTFMax)
+	}
+	n := utf8.EncodeRune(w.runeBuf, r)
+	return w.Forward.Write(w.runeBuf[:n])
+}
+
+func (w *Writer) LastSequence() string {
+	return w.lastseq.String()
+}
+
+func (w *Writer) ResetAnsi() {
+	if !w.seqchanged {
+		return
+	}
+	_, _ = w.Forward.Write([]byte("\x1b[0m"))
+}
+
+func (w *Writer) RestoreAnsi() {
+	_, _ = w.Forward.Write(w.lastseq.Bytes())
+}

vendor/github.com/muesli/cancelreader/.gitignore

@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/

vendor/github.com/muesli/cancelreader/.golangci-soft.yml

@@ -0,0 +1,47 @@
+run:
+  tests: false
+
+issues:
+  include:
+    - EXC0001
+    - EXC0005
+    - EXC0011
+    - EXC0012
+    - EXC0013
+
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+linters:
+  enable:
+    # - dupl
+    - exhaustive
+    # - exhaustivestruct
+    - goconst
+    - godot
+    - godox
+    - gomnd
+    - gomoddirectives
+    - goprintffuncname
+    - ifshort
+    # - lll
+    - misspell
+    - nakedret
+    - nestif
+    - noctx
+    - nolintlint
+    - prealloc
+    - wrapcheck
+
+  # disable default linters, they are already enabled in .golangci.yml
+  disable:
+    - deadcode
+    - errcheck
+    - gosimple
+    - govet
+    - ineffassign
+    - staticcheck
+    - structcheck
+    - typecheck
+    - unused
+    - varcheck

vendor/github.com/muesli/cancelreader/.golangci.yml

@@ -0,0 +1,29 @@
+run:
+  tests: false
+
+issues:
+  include:
+    - EXC0001
+    - EXC0005
+    - EXC0011
+    - EXC0012
+    - EXC0013
+
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+linters:
+  enable:
+    - bodyclose
+    - exportloopref
+    - goimports
+    - gosec
+    - nilerr
+    - predeclared
+    - revive
+    - rowserrcheck
+    - sqlclosecheck
+    - tparallel
+    - unconvert
+    - unparam
+    - whitespace

vendor/github.com/muesli/cancelreader/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Erik Geiser and Christian Muehlhaeuser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/muesli/cancelreader/README.md

@@ -0,0 +1,64 @@
+# CancelReader
+
+[![Latest Release](https://img.shields.io/github/release/muesli/cancelreader.svg?style=for-the-badge)](https://github.com/muesli/cancelreader/releases)
+[![Go Doc](https://img.shields.io/badge/godoc-reference-blue.svg?style=for-the-badge)](https://pkg.go.dev/github.com/muesli/cancelreader)
+[![Software License](https://img.shields.io/badge/license-MIT-blue.svg?style=for-the-badge)](/LICENSE)
+[![Build Status](https://img.shields.io/github/workflow/status/muesli/cancelreader/build?style=for-the-badge)](https://github.com/muesli/cancelreader/actions)
+[![Go ReportCard](https://goreportcard.com/badge/github.com/muesli/cancelreader?style=for-the-badge)](https://goreportcard.com/report/muesli/cancelreader)
+
+A cancelable reader for Go
+
+This package is based on the fantastic work of [Erik Geiser](https://github.com/erikgeiser)
+in Charm's [Bubble Tea](https://github.com/charmbracelet/bubbletea) framework.
+
+## Usage
+
+`NewReader` returns a reader with a `Cancel` function. If the input reader is a
+`File`, the cancel function can be used to interrupt a blocking `Read` call.
+In this case, the cancel function returns true if the call was canceled
+successfully. If the input reader is not a `File`, the cancel function does
+nothing and always returns false.
+
+```go
+r, err := cancelreader.NewReader(file)
+if err != nil {
+    // handle error
+    ...
+}
+
+// cancel after five seconds
+go func() {
+    time.Sleep(5 * time.Second)
+    r.Cancel()
+}()
+
+// keep reading
+for {
+    var buf [1024]byte
+    _, err := r.Read(buf[:])
+
+    if errors.Is(err, cancelreader.ErrCanceled) {
+        fmt.Println("canceled!")
+        break
+    }
+    if err != nil {
+        // handle other errors
+        ...
+    }
+
+    // handle data
+    ...
+}
+```
+
+## Implementations
+
+- The Linux implementation is based on the epoll mechanism
+- The BSD and macOS implementation is based on the kqueue mechanism
+- The generic Unix implementation is based on the posix select syscall
+
+## Caution
+
+The Windows implementation is based on WaitForMultipleObject with overlapping
+reads from CONIN$. At this point it only supports canceling reads from
+`os.Stdin`.

vendor/github.com/muesli/cancelreader/cancelreader.go

@@ -0,0 +1,93 @@
+package cancelreader
+
+import (
+	"fmt"
+	"io"
+	"sync"
+)
+
+// ErrCanceled gets returned when trying to read from a canceled reader.
+var ErrCanceled = fmt.Errorf("read canceled")
+
+// CancelReader is a io.Reader whose Read() calls can be canceled without data
+// being consumed. The cancelReader has to be closed.
+type CancelReader interface {
+	io.ReadCloser
+
+	// Cancel cancels ongoing and future reads an returns true if it succeeded.
+	Cancel() bool
+}
+
+// File represents an input/output resource with a file descriptor.
+type File interface {
+	io.ReadWriteCloser
+
+	// Fd returns its file descriptor
+	Fd() uintptr
+
+	// Name returns its file name.
+	Name() string
+}
+
+// fallbackCancelReader implements cancelReader but does not actually support
+// cancelation during an ongoing Read() call. Thus, Cancel() always returns
+// false. However, after calling Cancel(), new Read() calls immediately return
+// errCanceled and don't consume any data anymore.
+type fallbackCancelReader struct {
+	r io.Reader
+	cancelMixin
+}
+
+// newFallbackCancelReader is a fallback for NewReader that cannot actually
+// cancel an ongoing read but will immediately return on future reads if it has
+// been canceled.
+func newFallbackCancelReader(reader io.Reader) (CancelReader, error) {
+	return &fallbackCancelReader{r: reader}, nil
+}
+
+func (r *fallbackCancelReader) Read(data []byte) (int, error) {
+	if r.isCanceled() {
+		return 0, ErrCanceled
+	}
+
+	n, err := r.r.Read(data)
+	/*
+		If the underlying reader is a blocking reader (e.g. an open connection),
+		it might happen that 1 goroutine cancels the reader while its stuck in
+		the read call waiting for something.
+		If that happens, we should still cancel the read.
+	*/
+	if r.isCanceled() {
+		return 0, ErrCanceled
+	}
+	return n, err // nolint: wrapcheck
+}
+
+func (r *fallbackCancelReader) Cancel() bool {
+	r.setCanceled()
+	return false
+}
+
+func (r *fallbackCancelReader) Close() error {
+	return nil
+}
+
+// cancelMixin represents a goroutine-safe cancelation status.
+type cancelMixin struct {
+	unsafeCanceled bool
+	lock           sync.Mutex
+}
+
+func (c *cancelMixin) isCanceled() bool {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	return c.unsafeCanceled
+}
+
+func (c *cancelMixin) setCanceled() {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	c.unsafeCanceled = true
+}

vendor/github.com/muesli/cancelreader/cancelreader_bsd.go

@@ -0,0 +1,146 @@
+//go:build darwin || freebsd || netbsd || openbsd || dragonfly
+// +build darwin freebsd netbsd openbsd dragonfly
+
+package cancelreader
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"golang.org/x/sys/unix"
+)
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File, the cancel function can be used to interrupt a blocking read call.
+// In this case, the cancel function returns true if the call was canceled
+// successfully. If the input reader is not a File, the cancel function
+// does nothing and always returns false. The BSD and macOS implementation is
+// based on the kqueue mechanism.
+func NewReader(reader io.Reader) (CancelReader, error) {
+	file, ok := reader.(File)
+	if !ok {
+		return newFallbackCancelReader(reader)
+	}
+
+	// kqueue returns instantly when polling /dev/tty so fallback to select
+	if file.Name() == "/dev/tty" {
+		return newSelectCancelReader(reader)
+	}
+
+	kQueue, err := unix.Kqueue()
+	if err != nil {
+		return nil, fmt.Errorf("create kqueue: %w", err)
+	}
+
+	r := &kqueueCancelReader{
+		file:   file,
+		kQueue: kQueue,
+	}
+
+	r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+	if err != nil {
+		_ = unix.Close(kQueue)
+		return nil, err
+	}
+
+	unix.SetKevent(&r.kQueueEvents[0], int(file.Fd()), unix.EVFILT_READ, unix.EV_ADD)
+	unix.SetKevent(&r.kQueueEvents[1], int(r.cancelSignalReader.Fd()), unix.EVFILT_READ, unix.EV_ADD)
+
+	return r, nil
+}
+
+type kqueueCancelReader struct {
+	file               File
+	cancelSignalReader File
+	cancelSignalWriter File
+	cancelMixin
+	kQueue       int
+	kQueueEvents [2]unix.Kevent_t
+}
+
+func (r *kqueueCancelReader) Read(data []byte) (int, error) {
+	if r.isCanceled() {
+		return 0, ErrCanceled
+	}
+
+	err := r.wait()
+	if err != nil {
+		if errors.Is(err, ErrCanceled) {
+			// remove signal from pipe
+			var b [1]byte
+			_, errRead := r.cancelSignalReader.Read(b[:])
+			if errRead != nil {
+				return 0, fmt.Errorf("reading cancel signal: %w", errRead)
+			}
+		}
+
+		return 0, err
+	}
+
+	return r.file.Read(data)
+}
+
+func (r *kqueueCancelReader) Cancel() bool {
+	r.setCanceled()
+
+	// send cancel signal
+	_, err := r.cancelSignalWriter.Write([]byte{'c'})
+	return err == nil
+}
+
+func (r *kqueueCancelReader) Close() error {
+	var errMsgs []string
+
+	// close kqueue
+	err := unix.Close(r.kQueue)
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing kqueue: %v", err))
+	}
+
+	// close pipe
+	err = r.cancelSignalWriter.Close()
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+	}
+
+	err = r.cancelSignalReader.Close()
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+	}
+
+	if len(errMsgs) > 0 {
+		return fmt.Errorf(strings.Join(errMsgs, ", "))
+	}
+
+	return nil
+}
+
+func (r *kqueueCancelReader) wait() error {
+	events := make([]unix.Kevent_t, 1)
+
+	for {
+		_, err := unix.Kevent(r.kQueue, r.kQueueEvents[:], events, nil)
+		if errors.Is(err, unix.EINTR) {
+			continue // try again if the syscall was interrupted
+		}
+
+		if err != nil {
+			return fmt.Errorf("kevent: %w", err)
+		}
+
+		break
+	}
+
+	ident := uint64(events[0].Ident)
+	switch ident {
+	case uint64(r.file.Fd()):
+		return nil
+	case uint64(r.cancelSignalReader.Fd()):
+		return ErrCanceled
+	}
+
+	return fmt.Errorf("unknown error")
+}

vendor/github.com/muesli/cancelreader/cancelreader_default.go

@@ -0,0 +1,12 @@
+//go:build !darwin && !windows && !linux && !solaris && !freebsd && !netbsd && !openbsd && !dragonfly
+// +build !darwin,!windows,!linux,!solaris,!freebsd,!netbsd,!openbsd,!dragonfly
+
+package cancelreader
+
+import "io"
+
+// NewReader returns a fallbackCancelReader that satisfies the CancelReader but
+// does not actually support cancellation.
+func NewReader(reader io.Reader) (CancelReader, error) {
+	return newFallbackCancelReader(reader)
+}

vendor/github.com/muesli/cancelreader/cancelreader_linux.go

@@ -0,0 +1,154 @@
+//go:build linux
+// +build linux
+
+package cancelreader
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"golang.org/x/sys/unix"
+)
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File, the cancel function can be used to interrupt a blocking read call.
+// In this case, the cancel function returns true if the call was canceled
+// successfully. If the input reader is not a File, the cancel function
+// does nothing and always returns false. The Linux implementation is based on
+// the epoll mechanism.
+func NewReader(reader io.Reader) (CancelReader, error) {
+	file, ok := reader.(File)
+	if !ok {
+		return newFallbackCancelReader(reader)
+	}
+
+	epoll, err := unix.EpollCreate1(0)
+	if err != nil {
+		return nil, fmt.Errorf("create epoll: %w", err)
+	}
+
+	r := &epollCancelReader{
+		file:  file,
+		epoll: epoll,
+	}
+
+	r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+	if err != nil {
+		_ = unix.Close(epoll)
+		return nil, err
+	}
+
+	err = unix.EpollCtl(epoll, unix.EPOLL_CTL_ADD, int(file.Fd()), &unix.EpollEvent{
+		Events: unix.EPOLLIN,
+		Fd:     int32(file.Fd()),
+	})
+	if err != nil {
+		_ = unix.Close(epoll)
+		return nil, fmt.Errorf("add reader to epoll interest list")
+	}
+
+	err = unix.EpollCtl(epoll, unix.EPOLL_CTL_ADD, int(r.cancelSignalReader.Fd()), &unix.EpollEvent{
+		Events: unix.EPOLLIN,
+		Fd:     int32(r.cancelSignalReader.Fd()),
+	})
+	if err != nil {
+		_ = unix.Close(epoll)
+		return nil, fmt.Errorf("add reader to epoll interest list")
+	}
+
+	return r, nil
+}
+
+type epollCancelReader struct {
+	file               File
+	cancelSignalReader File
+	cancelSignalWriter File
+	cancelMixin
+	epoll int
+}
+
+func (r *epollCancelReader) Read(data []byte) (int, error) {
+	if r.isCanceled() {
+		return 0, ErrCanceled
+	}
+
+	err := r.wait()
+	if err != nil {
+		if errors.Is(err, ErrCanceled) {
+			// remove signal from pipe
+			var b [1]byte
+			_, readErr := r.cancelSignalReader.Read(b[:])
+			if readErr != nil {
+				return 0, fmt.Errorf("reading cancel signal: %w", readErr)
+			}
+		}
+
+		return 0, err
+	}
+
+	return r.file.Read(data)
+}
+
+func (r *epollCancelReader) Cancel() bool {
+	r.setCanceled()
+
+	// send cancel signal
+	_, err := r.cancelSignalWriter.Write([]byte{'c'})
+	return err == nil
+}
+
+func (r *epollCancelReader) Close() error {
+	var errMsgs []string
+
+	// close kqueue
+	err := unix.Close(r.epoll)
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing epoll: %v", err))
+	}
+
+	// close pipe
+	err = r.cancelSignalWriter.Close()
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+	}
+
+	err = r.cancelSignalReader.Close()
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+	}
+
+	if len(errMsgs) > 0 {
+		return fmt.Errorf(strings.Join(errMsgs, ", "))
+	}
+
+	return nil
+}
+
+func (r *epollCancelReader) wait() error {
+	events := make([]unix.EpollEvent, 1)
+
+	for {
+		_, err := unix.EpollWait(r.epoll, events, -1)
+		if errors.Is(err, unix.EINTR) {
+			continue // try again if the syscall was interrupted
+		}
+
+		if err != nil {
+			return fmt.Errorf("kevent: %w", err)
+		}
+
+		break
+	}
+
+	switch events[0].Fd {
+	case int32(r.file.Fd()):
+		return nil
+	case int32(r.cancelSignalReader.Fd()):
+		return ErrCanceled
+	}
+
+	return fmt.Errorf("unknown error")
+}

vendor/github.com/muesli/cancelreader/cancelreader_select.go

@@ -0,0 +1,136 @@
+//go:build solaris || darwin || freebsd || netbsd || openbsd || dragonfly
+// +build solaris darwin freebsd netbsd openbsd dragonfly
+
+package cancelreader
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"golang.org/x/sys/unix"
+)
+
+// newSelectCancelReader returns a reader and a cancel function. If the input
+// reader is a File, the cancel function can be used to interrupt a
+// blocking call read call. In this case, the cancel function returns true if
+// the call was canceled successfully. If the input reader is not a File or
+// the file descriptor is 1024 or larger, the cancel function does nothing and
+// always returns false. The generic unix implementation is based on the posix
+// select syscall.
+func newSelectCancelReader(reader io.Reader) (CancelReader, error) {
+	file, ok := reader.(File)
+	if !ok || file.Fd() >= unix.FD_SETSIZE {
+		return newFallbackCancelReader(reader)
+	}
+	r := &selectCancelReader{file: file}
+
+	var err error
+
+	r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+	if err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+type selectCancelReader struct {
+	file               File
+	cancelSignalReader File
+	cancelSignalWriter File
+	cancelMixin
+}
+
+func (r *selectCancelReader) Read(data []byte) (int, error) {
+	if r.isCanceled() {
+		return 0, ErrCanceled
+	}
+
+	for {
+		err := waitForRead(r.file, r.cancelSignalReader)
+		if err != nil {
+			if errors.Is(err, unix.EINTR) {
+				continue // try again if the syscall was interrupted
+			}
+
+			if errors.Is(err, ErrCanceled) {
+				// remove signal from pipe
+				var b [1]byte
+				_, readErr := r.cancelSignalReader.Read(b[:])
+				if readErr != nil {
+					return 0, fmt.Errorf("reading cancel signal: %w", readErr)
+				}
+			}
+
+			return 0, err
+		}
+
+		return r.file.Read(data)
+	}
+}
+
+func (r *selectCancelReader) Cancel() bool {
+	r.setCanceled()
+
+	// send cancel signal
+	_, err := r.cancelSignalWriter.Write([]byte{'c'})
+	return err == nil
+}
+
+func (r *selectCancelReader) Close() error {
+	var errMsgs []string
+
+	// close pipe
+	err := r.cancelSignalWriter.Close()
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+	}
+
+	err = r.cancelSignalReader.Close()
+	if err != nil {
+		errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+	}
+
+	if len(errMsgs) > 0 {
+		return fmt.Errorf(strings.Join(errMsgs, ", "))
+	}
+
+	return nil
+}
+
+func waitForRead(reader, abort File) error {
+	readerFd := int(reader.Fd())
+	abortFd := int(abort.Fd())
+
+	maxFd := readerFd
+	if abortFd > maxFd {
+		maxFd = abortFd
+	}
+
+	// this is a limitation of the select syscall
+	if maxFd >= unix.FD_SETSIZE {
+		return fmt.Errorf("cannot select on file descriptor %d which is larger than 1024", maxFd)
+	}
+
+	fdSet := &unix.FdSet{}
+	fdSet.Set(int(reader.Fd()))
+	fdSet.Set(int(abort.Fd()))
+
+	_, err := unix.Select(maxFd+1, fdSet, nil, nil, nil)
+	if err != nil {
+		return fmt.Errorf("select: %w", err)
+	}
+
+	if fdSet.IsSet(abortFd) {
+		return ErrCanceled
+	}
+
+	if fdSet.IsSet(readerFd) {
+		return nil
+	}
+
+	return fmt.Errorf("select returned without setting a file descriptor")
+}

vendor/github.com/muesli/cancelreader/cancelreader_unix.go

@@ -0,0 +1,18 @@
+//go:build solaris
+// +build solaris
+
+package cancelreader
+
+import (
+	"io"
+)
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File, the cancel function can be used to interrupt a blocking read call.
+// In this case, the cancel function returns true if the call was canceled
+// successfully. If the input reader is not a File or the file descriptor
+// is 1024 or larger, the cancel function does nothing and always returns false.
+// The generic unix implementation is based on the posix select syscall.
+func NewReader(reader io.Reader) (CancelReader, error) {
+	return newSelectCancelReader(reader)
+}

vendor/github.com/muesli/cancelreader/cancelreader_windows.go

@@ -0,0 +1,244 @@
+//go:build windows
+// +build windows
+
+package cancelreader
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"syscall"
+	"time"
+	"unicode/utf16"
+
+	"golang.org/x/sys/windows"
+)
+
+var fileShareValidFlags uint32 = 0x00000007
+
+// NewReader returns a reader and a cancel function. If the input reader is a
+// File with the same file descriptor as os.Stdin, the cancel function can
+// be used to interrupt a blocking read call. In this case, the cancel function
+// returns true if the call was canceled successfully. If the input reader is
+// not a File with the same file descriptor as os.Stdin, the cancel
+// function does nothing and always returns false. The Windows implementation
+// is based on WaitForMultipleObject with overlapping reads from CONIN$.
+func NewReader(reader io.Reader) (CancelReader, error) {
+	if f, ok := reader.(File); !ok || f.Fd() != os.Stdin.Fd() {
+		return newFallbackCancelReader(reader)
+	}
+
+	// it is necessary to open CONIN$ (NOT windows.STD_INPUT_HANDLE) in
+	// overlapped mode to be able to use it with WaitForMultipleObjects.
+	conin, err := windows.CreateFile(
+		&(utf16.Encode([]rune("CONIN$\x00"))[0]), windows.GENERIC_READ|windows.GENERIC_WRITE,
+		fileShareValidFlags, nil, windows.OPEN_EXISTING, windows.FILE_FLAG_OVERLAPPED, 0)
+	if err != nil {
+		return nil, fmt.Errorf("open CONIN$ in overlapping mode: %w", err)
+	}
+
+	resetConsole, err := prepareConsole(conin)
+	if err != nil {
+		return nil, fmt.Errorf("prepare console: %w", err)
+	}
+
+	// flush input, otherwise it can contain events which trigger
+	// WaitForMultipleObjects but which ReadFile cannot read, resulting in an
+	// un-cancelable read
+	err = flushConsoleInputBuffer(conin)
+	if err != nil {
+		return nil, fmt.Errorf("flush console input buffer: %w", err)
+	}
+
+	cancelEvent, err := windows.CreateEvent(nil, 0, 0, nil)
+	if err != nil {
+		return nil, fmt.Errorf("create stop event: %w", err)
+	}
+
+	return &winCancelReader{
+		conin:              conin,
+		cancelEvent:        cancelEvent,
+		resetConsole:       resetConsole,
+		blockingReadSignal: make(chan struct{}, 1),
+	}, nil
+}
+
+type winCancelReader struct {
+	conin       windows.Handle
+	cancelEvent windows.Handle
+	cancelMixin
+
+	resetConsole       func() error
+	blockingReadSignal chan struct{}
+}
+
+func (r *winCancelReader) Read(data []byte) (int, error) {
+	if r.isCanceled() {
+		return 0, ErrCanceled
+	}
+
+	err := r.wait()
+	if err != nil {
+		return 0, err
+	}
+
+	if r.isCanceled() {
+		return 0, ErrCanceled
+	}
+
+	// windows.Read does not work on overlapping windows.Handles
+	return r.readAsync(data)
+}
+
+// Cancel cancels ongoing and future Read() calls and returns true if the
+// cancelation of the ongoing Read() was successful. On Windows Terminal,
+// WaitForMultipleObjects sometimes immediately returns without input being
+// available. In this case, graceful cancelation is not possible and Cancel()
+// returns false.
+func (r *winCancelReader) Cancel() bool {
+	r.setCanceled()
+
+	select {
+	case r.blockingReadSignal <- struct{}{}:
+		err := windows.SetEvent(r.cancelEvent)
+		if err != nil {
+			return false
+		}
+		<-r.blockingReadSignal
+	case <-time.After(100 * time.Millisecond):
+		// Read() hangs in a GetOverlappedResult which is likely due to
+		// WaitForMultipleObjects returning without input being available
+		// so we cannot cancel this ongoing read.
+		return false
+	}
+
+	return true
+}
+
+func (r *winCancelReader) Close() error {
+	err := windows.CloseHandle(r.cancelEvent)
+	if err != nil {
+		return fmt.Errorf("closing cancel event handle: %w", err)
+	}
+
+	err = r.resetConsole()
+	if err != nil {
+		return err
+	}
+
+	err = windows.Close(r.conin)
+	if err != nil {
+		return fmt.Errorf("closing CONIN$")
+	}
+
+	return nil
+}
+
+func (r *winCancelReader) wait() error {
+	event, err := windows.WaitForMultipleObjects([]windows.Handle{r.conin, r.cancelEvent}, false, windows.INFINITE)
+	switch {
+	case windows.WAIT_OBJECT_0 <= event && event < windows.WAIT_OBJECT_0+2:
+		if event == windows.WAIT_OBJECT_0+1 {
+			return ErrCanceled
+		}
+
+		if event == windows.WAIT_OBJECT_0 {
+			return nil
+		}
+
+		return fmt.Errorf("unexpected wait object is ready: %d", event-windows.WAIT_OBJECT_0)
+	case windows.WAIT_ABANDONED <= event && event < windows.WAIT_ABANDONED+2:
+		return fmt.Errorf("abandoned")
+	case event == uint32(windows.WAIT_TIMEOUT):
+		return fmt.Errorf("timeout")
+	case event == windows.WAIT_FAILED:
+		return fmt.Errorf("failed")
+	default:
+		return fmt.Errorf("unexpected error: %w", error(err))
+	}
+}
+
+// readAsync is necessary to read from a windows.Handle in overlapping mode.
+func (r *winCancelReader) readAsync(data []byte) (int, error) {
+	hevent, err := windows.CreateEvent(nil, 0, 0, nil)
+	if err != nil {
+		return 0, fmt.Errorf("create event: %w", err)
+	}
+
+	overlapped := windows.Overlapped{
+		HEvent: hevent,
+	}
+
+	var n uint32
+
+	err = windows.ReadFile(r.conin, data, &n, &overlapped)
+	if err != nil && err != windows.ERROR_IO_PENDING {
+		return int(n), err
+	}
+
+	r.blockingReadSignal <- struct{}{}
+	err = windows.GetOverlappedResult(r.conin, &overlapped, &n, true)
+	if err != nil {
+		return int(n), nil
+	}
+	<-r.blockingReadSignal
+
+	return int(n), nil
+}
+
+func prepareConsole(input windows.Handle) (reset func() error, err error) {
+	var originalMode uint32
+
+	err = windows.GetConsoleMode(input, &originalMode)
+	if err != nil {
+		return nil, fmt.Errorf("get console mode: %w", err)
+	}
+
+	var newMode uint32
+	newMode &^= windows.ENABLE_ECHO_INPUT
+	newMode &^= windows.ENABLE_LINE_INPUT
+	newMode &^= windows.ENABLE_MOUSE_INPUT
+	newMode &^= windows.ENABLE_WINDOW_INPUT
+	newMode &^= windows.ENABLE_PROCESSED_INPUT
+
+	newMode |= windows.ENABLE_EXTENDED_FLAGS
+	newMode |= windows.ENABLE_INSERT_MODE
+	newMode |= windows.ENABLE_QUICK_EDIT_MODE
+
+	// Enabling virtual terminal input is necessary for processing certain
+	// types of input like X10 mouse events and arrows keys with the current
+	// bytes-based input reader. It does, however, prevent cancelReader from
+	// being able to cancel input. The planned solution for this is to read
+	// Windows events in a more native fashion, rather than the current simple
+	// bytes-based input reader which works well on unix systems.
+	newMode |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
+
+	err = windows.SetConsoleMode(input, newMode)
+	if err != nil {
+		return nil, fmt.Errorf("set console mode: %w", err)
+	}
+
+	return func() error {
+		err := windows.SetConsoleMode(input, originalMode)
+		if err != nil {
+			return fmt.Errorf("reset console mode: %w", err)
+		}
+
+		return nil
+	}, nil
+}
+
+var (
+	modkernel32                 = windows.NewLazySystemDLL("kernel32.dll")
+	procFlushConsoleInputBuffer = modkernel32.NewProc("FlushConsoleInputBuffer")
+)
+
+func flushConsoleInputBuffer(consoleInput windows.Handle) error {
+	r, _, e := syscall.Syscall(procFlushConsoleInputBuffer.Addr(), 1,
+		uintptr(consoleInput), 0, 0)
+	if r == 0 {
+		return error(e)
+	}
+
+	return nil
+}

vendor/github.com/muesli/reflow/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Christian Muehlhaeuser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/muesli/reflow/ansi/ansi.go

@@ -0,0 +1,7 @@
+package ansi
+
+const Marker = '\x1B'
+
+func IsTerminator(c rune) bool {
+	return (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a)
+}

vendor/github.com/muesli/reflow/ansi/buffer.go

@@ -0,0 +1,40 @@
+package ansi
+
+import (
+	"bytes"
+
+	"github.com/mattn/go-runewidth"
+)
+
+// Buffer is a buffer aware of ANSI escape sequences.
+type Buffer struct {
+	bytes.Buffer
+}
+
+// PrintableRuneWidth returns the cell width of all printable runes in the
+// buffer.
+func (w Buffer) PrintableRuneWidth() int {
+	return PrintableRuneWidth(w.String())
+}
+
+// PrintableRuneWidth returns the cell width of the given string.
+func PrintableRuneWidth(s string) int {
+	var n int
+	var ansi bool
+
+	for _, c := range s {
+		if c == Marker {
+			// ANSI escape sequence
+			ansi = true
+		} else if ansi {
+			if IsTerminator(c) {
+				// ANSI sequence terminated
+				ansi = false
+			}
+		} else {
+			n += runewidth.RuneWidth(c)
+		}
+	}
+
+	return n
+}

vendor/github.com/muesli/reflow/ansi/writer.go

@@ -0,0 +1,76 @@
+package ansi
+
+import (
+	"bytes"
+	"io"
+	"unicode/utf8"
+)
+
+type Writer struct {
+	Forward io.Writer
+
+	ansi       bool
+	ansiseq    bytes.Buffer
+	lastseq    bytes.Buffer
+	seqchanged bool
+	runeBuf    []byte
+}
+
+// Write is used to write content to the ANSI buffer.
+func (w *Writer) Write(b []byte) (int, error) {
+	for _, c := range string(b) {
+		if c == Marker {
+			// ANSI escape sequence
+			w.ansi = true
+			w.seqchanged = true
+			_, _ = w.ansiseq.WriteRune(c)
+		} else if w.ansi {
+			_, _ = w.ansiseq.WriteRune(c)
+			if IsTerminator(c) {
+				// ANSI sequence terminated
+				w.ansi = false
+
+				if bytes.HasSuffix(w.ansiseq.Bytes(), []byte("[0m")) {
+					// reset sequence
+					w.lastseq.Reset()
+					w.seqchanged = false
+				} else if c == 'm' {
+					// color code
+					_, _ = w.lastseq.Write(w.ansiseq.Bytes())
+				}
+
+				_, _ = w.ansiseq.WriteTo(w.Forward)
+			}
+		} else {
+			_, err := w.writeRune(c)
+			if err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	return len(b), nil
+}
+
+func (w *Writer) writeRune(r rune) (int, error) {
+	if w.runeBuf == nil {
+		w.runeBuf = make([]byte, utf8.UTFMax)
+	}
+	n := utf8.EncodeRune(w.runeBuf, r)
+	return w.Forward.Write(w.runeBuf[:n])
+}
+
+func (w *Writer) LastSequence() string {
+	return w.lastseq.String()
+}
+
+func (w *Writer) ResetAnsi() {
+	if !w.seqchanged {
+		return
+	}
+	_, _ = w.Forward.Write([]byte("\x1b[0m"))
+}
+
+func (w *Writer) RestoreAnsi() {
+	_, _ = w.Forward.Write(w.lastseq.Bytes())
+}

vendor/github.com/muesli/reflow/wordwrap/wordwrap.go

@@ -0,0 +1,167 @@
+package wordwrap
+
+import (
+	"bytes"
+	"strings"
+	"unicode"
+
+	"github.com/muesli/reflow/ansi"
+)
+
+var (
+	defaultBreakpoints = []rune{'-'}
+	defaultNewline     = []rune{'\n'}
+)
+
+// WordWrap contains settings and state for customisable text reflowing with
+// support for ANSI escape sequences. This means you can style your terminal
+// output without affecting the word wrapping algorithm.
+type WordWrap struct {
+	Limit        int
+	Breakpoints  []rune
+	Newline      []rune
+	KeepNewlines bool
+
+	buf   bytes.Buffer
+	space bytes.Buffer
+	word  ansi.Buffer
+
+	lineLen int
+	ansi    bool
+}
+
+// NewWriter returns a new instance of a word-wrapping writer, initialized with
+// default settings.
+func NewWriter(limit int) *WordWrap {
+	return &WordWrap{
+		Limit:        limit,
+		Breakpoints:  defaultBreakpoints,
+		Newline:      defaultNewline,
+		KeepNewlines: true,
+	}
+}
+
+// Bytes is shorthand for declaring a new default WordWrap instance,
+// used to immediately word-wrap a byte slice.
+func Bytes(b []byte, limit int) []byte {
+	f := NewWriter(limit)
+	_, _ = f.Write(b)
+	_ = f.Close()
+
+	return f.Bytes()
+}
+
+// String is shorthand for declaring a new default WordWrap instance,
+// used to immediately word-wrap a string.
+func String(s string, limit int) string {
+	return string(Bytes([]byte(s), limit))
+}
+
+func (w *WordWrap) addSpace() {
+	w.lineLen += w.space.Len()
+	_, _ = w.buf.Write(w.space.Bytes())
+	w.space.Reset()
+}
+
+func (w *WordWrap) addWord() {
+	if w.word.Len() > 0 {
+		w.addSpace()
+		w.lineLen += w.word.PrintableRuneWidth()
+		_, _ = w.buf.Write(w.word.Bytes())
+		w.word.Reset()
+	}
+}
+
+func (w *WordWrap) addNewLine() {
+	_, _ = w.buf.WriteRune('\n')
+	w.lineLen = 0
+	w.space.Reset()
+}
+
+func inGroup(a []rune, c rune) bool {
+	for _, v := range a {
+		if v == c {
+			return true
+		}
+	}
+	return false
+}
+
+// Write is used to write more content to the word-wrap buffer.
+func (w *WordWrap) Write(b []byte) (int, error) {
+	if w.Limit == 0 {
+		return w.buf.Write(b)
+	}
+
+	s := string(b)
+	if !w.KeepNewlines {
+		s = strings.Replace(strings.TrimSpace(s), "\n", " ", -1)
+	}
+
+	for _, c := range s {
+		if c == '\x1B' {
+			// ANSI escape sequence
+			_, _ = w.word.WriteRune(c)
+			w.ansi = true
+		} else if w.ansi {
+			_, _ = w.word.WriteRune(c)
+			if (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) {
+				// ANSI sequence terminated
+				w.ansi = false
+			}
+		} else if inGroup(w.Newline, c) {
+			// end of current line
+			// see if we can add the content of the space buffer to the current line
+			if w.word.Len() == 0 {
+				if w.lineLen+w.space.Len() > w.Limit {
+					w.lineLen = 0
+				} else {
+					// preserve whitespace
+					_, _ = w.buf.Write(w.space.Bytes())
+				}
+				w.space.Reset()
+			}
+
+			w.addWord()
+			w.addNewLine()
+		} else if unicode.IsSpace(c) {
+			// end of current word
+			w.addWord()
+			_, _ = w.space.WriteRune(c)
+		} else if inGroup(w.Breakpoints, c) {
+			// valid breakpoint
+			w.addSpace()
+			w.addWord()
+			_, _ = w.buf.WriteRune(c)
+		} else {
+			// any other character
+			_, _ = w.word.WriteRune(c)
+
+			// add a line break if the current word would exceed the line's
+			// character limit
+			if w.lineLen+w.space.Len()+w.word.PrintableRuneWidth() > w.Limit &&
+				w.word.PrintableRuneWidth() < w.Limit {
+				w.addNewLine()
+			}
+		}
+	}
+
+	return len(b), nil
+}
+
+// Close will finish the word-wrap operation. Always call it before trying to
+// retrieve the final result.
+func (w *WordWrap) Close() error {
+	w.addWord()
+	return nil
+}
+
+// Bytes returns the word-wrapped result as a byte slice.
+func (w *WordWrap) Bytes() []byte {
+	return w.buf.Bytes()
+}
+
+// String returns the word-wrapped result as a string.
+func (w *WordWrap) String() string {
+	return w.buf.String()
+}

vendor/modules.txt

@@ -65,6 +65,9 @@ github.com/cenkalti/backoff/v4
 # github.com/cespare/xxhash/v2 v2.3.0
 ## explicit; go 1.11
 github.com/cespare/xxhash/v2
+# github.com/charmbracelet/bubbletea v1.2.4
+## explicit; go 1.18
+github.com/charmbracelet/bubbletea
 # github.com/charmbracelet/lipgloss v1.0.0
 ## explicit; go 1.18
 github.com/charmbracelet/lipgloss
@@ -76,6 +79,11 @@ github.com/charmbracelet/log
 ## explicit; go 1.18
 github.com/charmbracelet/x/ansi
 github.com/charmbracelet/x/ansi/parser
+# github.com/charmbracelet/x/exp/golden v0.0.0-20240815200342-61de596daa2b
+## explicit; go 1.19
+# github.com/charmbracelet/x/term v0.2.1
+## explicit; go 1.18
+github.com/charmbracelet/x/term
 # github.com/cloudflare/circl v1.5.0
 ## explicit; go 1.22.0
 github.com/cloudflare/circl/dh/x25519
@@ -243,6 +251,9 @@ github.com/emirpasic/gods/lists/arraylist
 github.com/emirpasic/gods/trees
 github.com/emirpasic/gods/trees/binaryheap
 github.com/emirpasic/gods/utils
+# github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f
+## explicit; go 1.16
+github.com/erikgeiser/coninput
 # github.com/felixge/httpsnoop v1.0.4
 ## explicit; go 1.13
 github.com/felixge/httpsnoop
@@ -393,6 +404,9 @@ github.com/mattn/go-colorable
 # github.com/mattn/go-isatty v0.0.20
 ## explicit; go 1.15
 github.com/mattn/go-isatty
+# github.com/mattn/go-localereader v0.0.1
+## explicit
+github.com/mattn/go-localereader
 # github.com/mattn/go-runewidth v0.0.16
 ## explicit; go 1.9
 github.com/mattn/go-runewidth
@@ -449,6 +463,17 @@ github.com/moby/term/windows
 # github.com/morikuni/aec v1.0.0
 ## explicit
 github.com/morikuni/aec
+# github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6
+## explicit; go 1.17
+github.com/muesli/ansi
+github.com/muesli/ansi/compressor
+# github.com/muesli/cancelreader v0.2.2
+## explicit; go 1.17
+github.com/muesli/cancelreader
+# github.com/muesli/reflow v0.3.0
+## explicit; go 1.13
+github.com/muesli/reflow/ansi
+github.com/muesli/reflow/wordwrap
 # github.com/muesli/termenv v0.15.2
 ## explicit; go 1.17
 github.com/muesli/termenv