From af34b2f267dff50f1310088ebd590a92f5bca1ee Mon Sep 17 00:00:00 2001 From: Levi Neely Date: Tue, 31 Mar 2026 22:30:08 +0200 Subject: [PATCH] Add ollie/exec package: extract execute_code from anvillm-mcp Extracts execute_code into a shared ollie/exec package so anvillm-mcp and ollie's agent loop can both use it. Includes sandboxed execution, dangerous-pattern validation with per-Executor rate limiting, 9P tool reading, and pipeline construction. Co-Authored-By: Claude Sonnet 4.6 --- exec/exec.go | 391 ++++++++++++++++++++++++++++++++++++++++++++++ exec/exec_test.go | 174 +++++++++++++++++++++ exec/metrics.go | 69 ++++++++ go.mod | 17 +- go.sum | 60 +++++-- 5 files changed, 691 insertions(+), 20 deletions(-) create mode 100644 exec/exec.go create mode 100644 exec/exec_test.go create mode 100644 exec/metrics.go diff --git a/exec/exec.go b/exec/exec.go new file mode 100644 index 0000000..abe858a --- /dev/null +++ b/exec/exec.go @@ -0,0 +1,391 @@ +package exec + +import ( + "bytes" + "context" + "fmt" + "io" + "os" + "os/exec" + "path/filepath" + "regexp" + "strings" + "sync" + "time" + + "9fans.net/go/plan9/client" + "anvillm/pkg/sandbox" +) + +// ReadTool reads a named tool script from the 9P tools directory. +func ReadTool(name string) (string, error) { + if strings.Contains(name, "/") || strings.Contains(name, "..") { + return "", fmt.Errorf("invalid tool name") + } + + ns := fmt.Sprintf("/tmp/ns.%s.:0", os.Getenv("USER")) + fsys, err := client.Mount("unix", filepath.Join(ns, "anvillm")) + if err != nil { + return "", fmt.Errorf("failed to mount 9P: %v", err) + } + defer fsys.Close() + + fid, err := fsys.Open("/tools/"+name, 0) + if err != nil { + return "", fmt.Errorf("tool not found: %s", name) + } + defer fid.Close() + + var buf []byte + tmp := make([]byte, 8192) + for { + n, err := fid.Read(tmp) + if n > 0 { + buf = append(buf, tmp[:n]...) + } + if err != nil || n < len(tmp) { + break + } + } + return string(buf), nil +} + +// PipeStep is one stage in a tool pipeline. +// Exactly one of Tool or Code must be set. +type PipeStep struct { + Tool string // named tool read from 9P (trusted) + Code string // inline bash code (untrusted, validated) + Args []string +} + +// BuildPipeline constructs a single bash pipeline string from the given steps. +// Tool steps are trusted (sourced from 9P); inline code steps are validated +// individually so the combined string is always returned as trusted. +func BuildPipeline(steps []PipeStep) (string, bool, error) { + if len(steps) == 0 { + return "", false, fmt.Errorf("pipe requires at least one step") + } + validator := &Executor{} // used only for ValidateCode; fresh instance = no shared rate limit state + parts := make([]string, 0, len(steps)) + for _, step := range steps { + var code string + if step.Tool != "" { + var err error + code, err = ReadTool(step.Tool) + if err != nil { + return "", false, fmt.Errorf("pipe step %q: %v", step.Tool, err) + } + } else if step.Code != "" { + if err := validator.ValidateCode(step.Code); err != nil { + return "", false, fmt.Errorf("pipe step code: %v", err) + } + code = step.Code + } else { + return "", false, fmt.Errorf("each pipe step requires either 'tool' or 'code'") + } + if len(step.Args) > 0 { + var escaped []string + for _, arg := range step.Args { + escaped = append(escaped, "'"+strings.ReplaceAll(arg, "'", "'\\''")+"'") + } + parts = append(parts, fmt.Sprintf("( set -- %s\n%s )", strings.Join(escaped, " "), code)) + } else { + parts = append(parts, fmt.Sprintf("(\n%s\n)", code)) + } + } + return strings.Join(parts, " |\n"), true, nil +} + +// Executor runs code in a sandboxed environment. +type Executor struct { + // LogDir is the directory for execution and security event logs. + // Defaults to ~/.local/state/exec when empty. + LogDir string + + // WorkspaceBase is the parent directory for temporary execution workspaces. + // If set, each execution gets a fresh temp directory under WorkspaceBase. + // If empty, the current working directory is used directly. + WorkspaceBase string + + // rate limiting state (per-Executor) + rateLimitMu sync.Mutex + validationFailures int + lastFailure time.Time + blockedUntil time.Time +} + +// New creates a new Executor with the given log directory and workspace base. +func New(logDir, workspaceBase string) *Executor { + return &Executor{LogDir: logDir, WorkspaceBase: workspaceBase} +} + +func (e *Executor) logDir() string { + if e.LogDir != "" { + return e.LogDir + } + home, _ := os.UserHomeDir() + return filepath.Join(home, ".local", "state", "exec") +} + +var dangerousPatterns = []*regexp.Regexp{ + regexp.MustCompile(`rm\s+(-[a-z]*r[a-z]*\s+)*-[a-z]*f[a-z]*\s*/(home|var|usr|etc|boot|root|bin|sbin|lib|opt|srv)?`), // rm -rf, rm -r -f on sensitive paths + regexp.MustCompile(`rm\s+(-[a-z]*f[a-z]*\s+)*-[a-z]*r[a-z]*\s*/(home|var|usr|etc|boot|root|bin|sbin|lib|opt|srv)?`), // rm -fr, rm -f -r on sensitive paths + regexp.MustCompile(`rm\s+.*--recursive.*--force`), // rm --recursive --force + regexp.MustCompile(`rm\s+.*--force.*--recursive`), // rm --force --recursive + regexp.MustCompile(`rm\s+(-[a-z]*r[a-z]*\s+)*-[a-z]*f[a-z]*\s+\.\.?(/|$)`), // rm -rf ./ or rm -rf ../ + regexp.MustCompile(`rm\s+(-[a-z]*r[a-z]*\s+)*-[a-z]*f[a-z]*\s+~`), // rm -rf ~ (home dir) + regexp.MustCompile(`rm\s+(-[a-z]*r[a-z]*\s+)*-[a-z]*f[a-z]*\s+\*`), // rm -rf * (glob expansion) + regexp.MustCompile(`:\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&`), // fork bomb + regexp.MustCompile(`\bmkfs\b`), // filesystem format + regexp.MustCompile(`\bdd\b.*\bif=/dev/`), // dd from device + regexp.MustCompile(`>\s*/dev/sd`), // write to block device + regexp.MustCompile(`\beval\s+".*\$`), // eval with variable expansion + regexp.MustCompile(`\b(sudo|su)\s`), // privilege escalation + regexp.MustCompile(`/etc/(shadow|sudoers)`), // sensitive files (not passwd) +} + +var whitespacePattern = regexp.MustCompile(`\s+`) + +const ( + maxFailures = 5 + blockDuration = 30 * time.Second + failureWindow = 60 * time.Second +) + +func (e *Executor) checkRateLimit() error { + e.rateLimitMu.Lock() + defer e.rateLimitMu.Unlock() + + now := time.Now() + if now.Before(e.blockedUntil) { + remaining := e.blockedUntil.Sub(now).Round(time.Second) + return fmt.Errorf("rate limited: too many validation failures, blocked for %v", remaining) + } + return nil +} + +func (e *Executor) recordValidationFailure() { + e.rateLimitMu.Lock() + defer e.rateLimitMu.Unlock() + + now := time.Now() + if now.Sub(e.lastFailure) > failureWindow { + e.validationFailures = 0 + } + + e.validationFailures++ + e.lastFailure = now + + if e.validationFailures >= maxFailures { + e.blockedUntil = now.Add(blockDuration) + e.validationFailures = 0 + logSecurityEvent(e.logDir(), SecurityEvent{ + Timestamp: now, + EventType: "rate_limit_triggered", + Details: fmt.Sprintf("blocked for %v after %d failures", blockDuration, maxFailures), + }) + } +} + +// ValidateCode checks code against dangerous patterns. +func (e *Executor) ValidateCode(code string) error { + if err := e.checkRateLimit(); err != nil { + return err + } + + normalized := strings.ToLower(code) + normalized = whitespacePattern.ReplaceAllString(normalized, " ") + + for _, pattern := range dangerousPatterns { + if pattern.MatchString(normalized) { + e.recordValidationFailure() + logSecurityEvent(e.logDir(), SecurityEvent{ + Timestamp: time.Now(), + EventType: "validation_failure", + Details: fmt.Sprintf("dangerous pattern: %s", pattern.String()), + }) + return fmt.Errorf("dangerous pattern detected") + } + } + return nil +} + +// IsPermissionError returns true if err indicates a permission or missing-file error. +func IsPermissionError(err error) bool { + if err == nil { + return false + } + msg := strings.ToLower(err.Error()) + return strings.Contains(msg, "permission denied") || + strings.Contains(msg, "no such file or directory") +} + +func loadLayeredConfig(name string) (*sandbox.Config, error) { + baseCfg, err := sandbox.Load() + if err != nil { + return nil, fmt.Errorf("failed to load global config: %w", err) + } + + baseLayer := sandbox.LayeredConfig{ + Filesystem: baseCfg.Filesystem, + Network: baseCfg.Network, + Env: baseCfg.Env, + } + layers := []sandbox.LayeredConfig{baseLayer} + + if name == "" { + name = "anvilmcp" + } + sbxLayer, err := sandbox.LoadSandbox(name) + if err != nil { + return nil, fmt.Errorf("failed to load sandbox %q: %w", name, err) + } + layers = append(layers, sbxLayer) + + general := sandbox.GeneralConfig{ + BestEffort: baseCfg.General.BestEffort, + LogLevel: baseCfg.General.LogLevel, + } + advanced := sandbox.AdvancedConfig{ + LDD: baseCfg.Advanced.LDD, + AddExec: baseCfg.Advanced.AddExec, + } + + return sandbox.Merge(general, advanced, layers...), nil +} + +// Execute runs code in a sandbox and returns combined stdout+stderr. +func (e *Executor) Execute(code, language string, timeout int, sandboxName string, trusted bool) (string, error) { + start := time.Now() + + if timeout <= 0 { + timeout = 30 + } + + if !trusted { + if err := e.ValidateCode(code); err != nil { + logExecution(e.logDir(), ExecutionLog{ + Timestamp: start, + CodeHash: hashCode(code), + Language: language, + Duration: time.Since(start), + Success: false, + OutputSize: 0, + Error: err.Error(), + }) + return "", err + } + } + + cfg, err := loadLayeredConfig(sandboxName) + if err != nil { + return "", err + } + + workDir, _ := os.Getwd() + var cleanupWorkDir bool + + if e.WorkspaceBase != "" { + if err := os.MkdirAll(e.WorkspaceBase, 0700); err != nil { + return "", fmt.Errorf("failed to create workspace base: %v", err) + } + workDir, err = os.MkdirTemp(e.WorkspaceBase, "exec-*") + if err != nil { + return "", fmt.Errorf("failed to create workspace: %v", err) + } + cleanupWorkDir = true + } + + if cleanupWorkDir { + defer os.RemoveAll(workDir) + } + + ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second) + defer cancel() + + var cmd *exec.Cmd + switch language { + case "bash", "": + wrapped := sandbox.WrapCommand(cfg, []string{"bash", "-c", code}, workDir) + cmd = exec.CommandContext(ctx, wrapped[0], wrapped[1:]...) + cmd.Dir = workDir + default: + return "", fmt.Errorf("unsupported language: %s (supported: bash)", language) + } + + const maxToolOutputSize = 8000 + var outputBuf bytes.Buffer + lw := &limitedWriter{w: &outputBuf, limit: 10 * 1024 * 1024} + cmd.Stdout = lw + cmd.Stderr = lw + + err = cmd.Run() + output := outputBuf.Bytes() + + if lw.truncated { + output = append(output, []byte("\n[output truncated at 10MB]")...) + } + + duration := time.Since(start) + + execLog := ExecutionLog{ + Timestamp: start, + CodeHash: hashCode(code), + Language: language, + Duration: duration, + Success: err == nil && ctx.Err() != context.DeadlineExceeded, + OutputSize: len(output), + } + + if ctx.Err() == context.DeadlineExceeded { + execLog.Error = fmt.Sprintf("execution timeout after %d seconds", timeout) + logExecution(e.logDir(), execLog) + logSecurityEvent(e.logDir(), SecurityEvent{ + Timestamp: start, + EventType: "timeout", + Language: language, + Details: fmt.Sprintf("timeout after %d seconds", timeout), + }) + return "", fmt.Errorf("execution timeout after %d seconds", timeout) + } + if err != nil { + execLog.Error = err.Error() + logExecution(e.logDir(), execLog) + return string(output), fmt.Errorf("execution failed: %v\nOutput: %s", err, string(output)) + } + + logExecution(e.logDir(), execLog) + result := string(output) + if len(result) > maxToolOutputSize { + result = result[:maxToolOutputSize] + "\n... (output truncated)" + } + return result, nil +} + +type limitedWriter struct { + w io.Writer + written int + limit int + truncated bool +} + +func (lw *limitedWriter) Write(p []byte) (n int, err error) { + if lw.written >= lw.limit { + lw.truncated = true + return len(p), nil + } + + remaining := lw.limit - lw.written + toWrite := p + if len(p) > remaining { + toWrite = p[:remaining] + lw.truncated = true + } + + written, err := lw.w.Write(toWrite) + lw.written += written + if err != nil { + return written, err + } + return len(p), nil +} diff --git a/exec/exec_test.go b/exec/exec_test.go new file mode 100644 index 0000000..f1a50aa --- /dev/null +++ b/exec/exec_test.go @@ -0,0 +1,174 @@ +package exec + +import ( + "strings" + "testing" + "time" +) + +func newTestExecutor(t *testing.T) *Executor { + t.Helper() + return New(t.TempDir(), "") +} + +func TestValidateCode(t *testing.T) { + tests := []struct { + name string + code string + wantErr bool + }{ + {"safe code", "echo hello", false}, + {"rm -rf /", "rm -rf /", true}, + {"rm -rf / with spaces", "rm -rf /", true}, + {"rm -rf / with tabs", "rm\t-rf\t/", true}, + {"rm -rf/ no space", "rm -rf/", true}, + {"rm -fr /", "rm -fr /", true}, + {"rm -fr/ no space", "rm -fr/", true}, + {"rm -rf /home", "rm -rf /home", true}, + {"rm -rf /var", "rm -rf /var", true}, + {"rm -rf /etc", "rm -rf /etc", true}, + {"rm -rf /usr", "rm -rf /usr", true}, + {"fork bomb", ":(){ :|:& };:", true}, + {"fork bomb with spaces", ": ( ) { : | : & } ; :", true}, + {"mkfs", "mkfs.ext4 /dev/sda", true}, + {"dd from device", "dd if=/dev/zero of=/dev/sda", true}, + {"device write", "echo data > /dev/sda", true}, + {"sudo", "sudo rm file", true}, + {"su", "su - root", true}, + {"etc shadow", "cat /etc/shadow", true}, + {"safe 9p", "9p read anvillm/inbox/user", false}, + {"safe jq", "echo '{}' | jq .field", false}, + {"safe rm", "rm file.txt", false}, + {"rm -rf ./", "rm -rf ./", true}, + {"rm -rf ../", "rm -rf ../", true}, + {"rm -rf .", "rm -rf .", true}, + {"rm -r -f /", "rm -r -f /", true}, + {"rm -f -r /", "rm -f -r /", true}, + {"rm --recursive --force /", "rm --recursive --force /", true}, + {"rm --force --recursive /", "rm --force --recursive /", true}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := newTestExecutor(t).ValidateCode(tt.code) + if (err != nil) != tt.wantErr { + t.Errorf("ValidateCode() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestDangerousPatternsCompile(t *testing.T) { + if len(dangerousPatterns) == 0 { + t.Error("dangerousPatterns should not be empty") + } + for i, p := range dangerousPatterns { + if p == nil { + t.Errorf("dangerousPatterns[%d] is nil", i) + } + } +} + +func TestLimitedWriter(t *testing.T) { + tests := []struct { + name string + limit int + writes []string + wantTotal int + wantTruncated bool + }{ + { + name: "under limit", + limit: 100, + writes: []string{"hello", " ", "world"}, + wantTotal: 11, + wantTruncated: false, + }, + { + name: "at limit", + limit: 5, + writes: []string{"hello"}, + wantTotal: 5, + wantTruncated: false, + }, + { + name: "over limit", + limit: 5, + writes: []string{"hello", "world"}, + wantTotal: 5, + wantTruncated: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var buf strings.Builder + lw := &limitedWriter{w: &buf, limit: tt.limit} + + for _, write := range tt.writes { + lw.Write([]byte(write)) + } + + if lw.truncated != tt.wantTruncated { + t.Errorf("limitedWriter truncated = %v, want %v", lw.truncated, tt.wantTruncated) + } + if buf.Len() != tt.wantTotal { + t.Errorf("limitedWriter wrote %d bytes, want %d", buf.Len(), tt.wantTotal) + } + }) + } +} + +func resetExecutor(e *Executor) { + e.rateLimitMu.Lock() + defer e.rateLimitMu.Unlock() + e.validationFailures = 0 + e.lastFailure = time.Time{} + e.blockedUntil = time.Time{} +} + +func TestRateLimitCounterResetAfterWindow(t *testing.T) { + e := newTestExecutor(t) + + for range maxFailures - 1 { + e.recordValidationFailure() + } + + e.rateLimitMu.Lock() + e.lastFailure = time.Now().Add(-failureWindow - time.Second) + e.rateLimitMu.Unlock() + + e.recordValidationFailure() + + if err := e.checkRateLimit(); err != nil { + t.Errorf("expected no rate limit after window reset, got: %v", err) + } +} + +func TestRateLimitBlocksAfterMaxFailures(t *testing.T) { + e := newTestExecutor(t) + + for range maxFailures { + e.recordValidationFailure() + } + + if err := e.checkRateLimit(); err == nil { + t.Error("expected rate limit error after maxFailures") + } +} + +func TestRateLimitUnblocksAfterDuration(t *testing.T) { + e := newTestExecutor(t) + + for range maxFailures { + e.recordValidationFailure() + } + + e.rateLimitMu.Lock() + e.blockedUntil = time.Now().Add(-time.Second) + e.rateLimitMu.Unlock() + + if err := e.checkRateLimit(); err != nil { + t.Errorf("expected no rate limit after block duration, got: %v", err) + } +} diff --git a/exec/metrics.go b/exec/metrics.go new file mode 100644 index 0000000..6a9ea4a --- /dev/null +++ b/exec/metrics.go @@ -0,0 +1,69 @@ +package exec + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "os" + "path/filepath" + "time" +) + +// ExecutionLog records metadata about a code execution. +type ExecutionLog struct { + Timestamp time.Time `json:"timestamp"` + CodeHash string `json:"code_hash"` + Language string `json:"language"` + Duration time.Duration `json:"duration"` + Success bool `json:"success"` + OutputSize int `json:"output_size"` + Error string `json:"error,omitempty"` +} + +// SecurityEvent records a security-relevant event. +type SecurityEvent struct { + Timestamp time.Time `json:"timestamp"` + EventType string `json:"event_type"` + Language string `json:"language,omitempty"` + Details string `json:"details"` +} + +func hashCode(code string) string { + h := sha256.Sum256([]byte(code)) + return hex.EncodeToString(h[:]) +} + +func logExecution(logDir string, log ExecutionLog) error { + if err := os.MkdirAll(logDir, 0755); err != nil { + return err + } + f, err := os.OpenFile(filepath.Join(logDir, "executions.jsonl"), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { + return err + } + defer f.Close() + data, err := json.Marshal(log) + if err != nil { + return err + } + _, err = fmt.Fprintf(f, "%s\n", data) + return err +} + +func logSecurityEvent(logDir string, event SecurityEvent) error { + if err := os.MkdirAll(logDir, 0700); err != nil { + return err + } + f, err := os.OpenFile(filepath.Join(logDir, "security.jsonl"), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0600) + if err != nil { + return err + } + defer f.Close() + data, err := json.Marshal(event) + if err != nil { + return err + } + _, err = fmt.Fprintf(f, "%s\n", data) + return err +} diff --git a/go.mod b/go.mod index 3084851..e30dea8 100644 --- a/go.mod +++ b/go.mod @@ -1,14 +1,19 @@ module ollie -go 1.24.3 +go 1.25.6 -require github.com/chzyer/readline v1.5.1 +require ( + 9fans.net/go v0.0.7 + anvillm v0.0.0-00010101000000-000000000000 + github.com/charmbracelet/bubbles v1.0.0 + github.com/charmbracelet/bubbletea v1.3.10 +) + +replace anvillm => ../anvillm/main require ( github.com/atotto/clipboard v0.1.4 // indirect github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect - github.com/charmbracelet/bubbles v1.0.0 // indirect - github.com/charmbracelet/bubbletea v1.3.10 // indirect github.com/charmbracelet/colorprofile v0.4.1 // indirect github.com/charmbracelet/lipgloss v1.1.0 // indirect github.com/charmbracelet/x/ansi v0.11.6 // indirect @@ -25,9 +30,9 @@ require ( github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect github.com/muesli/cancelreader v0.2.2 // indirect github.com/muesli/termenv v0.16.0 // indirect - github.com/peterh/liner v1.2.2 // indirect github.com/rivo/uniseg v0.4.7 // indirect github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect golang.org/x/sys v0.41.0 // indirect - golang.org/x/text v0.3.8 // indirect + golang.org/x/text v0.33.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 5752876..1cdbbed 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,15 @@ +9fans.net/go v0.0.7 h1:H5CsYJTf99C8EYAQr+uSoEJnLP/iZU8RmDuhyk30iSM= +9fans.net/go v0.0.7/go.mod h1:Rxvbbc1e+1TyGMjAvLthGTyO97t+6JMQ6ly+Lcs9Uf0= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20201218220906-28db891af037/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ= +github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE= github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= +github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3vj1nolY= +github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E= github.com/charmbracelet/bubbles v1.0.0 h1:12J8/ak/uCZEMQ6KU7pcfwceyjLlWsDLAxB5fXonfvc= github.com/charmbracelet/bubbles v1.0.0/go.mod h1:9d/Zd5GdnauMI5ivUIVisuEm3ave1XwXtD1ckyV6r3E= github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw= @@ -16,12 +24,6 @@ github.com/charmbracelet/x/cellbuf v0.0.15 h1:ur3pZy0o6z/R7EylET877CBxaiE1Sp1GMx github.com/charmbracelet/x/cellbuf v0.0.15/go.mod h1:J1YVbR7MUuEGIFPCaaZ96KDl5NoS0DAWkskup+mOY+Q= github.com/charmbracelet/x/term v0.2.2 h1:xVRT/S2ZcKdhhOuSP4t5cLi5o+JxklsoEObBSgfgZRk= github.com/charmbracelet/x/term v0.2.2/go.mod h1:kF8CY5RddLWrsgVwpw4kAa6TESp6EB5y3uxGLeCqzAI= -github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM= -github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ= -github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI= -github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk= -github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04= -github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8= github.com/clipperhouse/displaywidth v0.9.0 h1:Qb4KOhYwRiN3viMv1v/3cTBlz3AcAZX3+y9OLhMtAtA= github.com/clipperhouse/displaywidth v0.9.0/go.mod h1:aCAAqTlh4GIVkhQnJpbL0T/WfcrJXHcj8C0yjYcjOZA= github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs= @@ -30,14 +32,13 @@ github.com/clipperhouse/uax29/v2 v2.5.0 h1:x7T0T4eTHDONxFJsL94uKNKPHrclyFI0lm7+w github.com/clipperhouse/uax29/v2 v2.5.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g= 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/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag= github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= 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.3 h1:a+kO+98RDGEfo6asOGMmpodZq4FNtnGP54yps8BzLR4= -github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw= github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs= github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= @@ -46,17 +47,48 @@ github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELU github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc= github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk= -github.com/peterh/liner v1.2.2 h1:aJ4AOodmL+JxOZZEL2u9iJf8omNRpqHc/EbrK+3mAXw= -github.com/peterh/liner v1.2.2/go.mod h1:xFwJyiKIXJZUKItq5dGHZSTBRAuG/CpeNpWLyiNRNwI= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no= github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56/go.mod h1:JhuoJpWY28nO4Vef9tZUw9qufEGTyX1+7lmHxV5q5G4= +golang.org/x/exp v0.0.0-20210405174845-4513512abef3/go.mod h1:I6l2HNBLBZEcrOoCpyKLdY2lHoRZ8lI4x60KMCQDft4= +golang.org/x/exp v0.0.0-20240205201215-2c58cdc269a3 h1:/RIbNt/Zr7rVhIkQhooTxCxFcdWLGIKnZA4IXNFSrvo= +golang.org/x/exp v0.0.0-20240205201215-2c58cdc269a3/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20201217150744-e6ae53a27f4f/go.mod h1:skQtrUTUwhdJvXM/2KKJzY8pDgNr9I/FOMqDVRPBUS4= +golang.org/x/mobile v0.0.0-20210220033013-bdb1ca9a1e08/go.mod h1:skQtrUTUwhdJvXM/2KKJzY8pDgNr9I/FOMqDVRPBUS4= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191209134235-331c550502dd/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.1-0.20200828183125-ce943fd02449/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210415045647-66c3f260301c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211117180635-dee7805ff2e1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k= golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= -golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY= -golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE= +golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200117012304-6edc0a871e69/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=