@fatalmistake02/rian 0.0.0-stage → 0.2.1

package/internal/git/git.go

@@ -0,0 +1,166 @@
+// Package git reads local repository state. Inspect never fetches the network.
+package git
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type Status struct {
+	Repository                         bool
+	Branch                             string
+	Modified, Untracked, Ahead, Behind int
+	Remote, GitHub, Commit             string
+	CommitTime                         time.Time
+	Error                              string
+}
+
+func (s Status) Dirty() bool { return s.Modified+s.Untracked > 0 }
+
+// GitHubRepo accepts SSH, HTTPS, git protocol and ssh:// remotes, but only
+// github.com. Strict owner/repo validation also makes overrides safe URLs.
+func GitHubRepo(remote string) string {
+	remote = strings.TrimSpace(remote)
+	var path string
+	if strings.HasPrefix(remote, "git@github.com:") {
+		path = strings.TrimPrefix(remote, "git@github.com:")
+	} else {
+		u, err := url.Parse(remote)
+		if err != nil || !strings.EqualFold(u.Hostname(), "github.com") {
+			return ""
+		}
+		if u.Scheme != "https" && u.Scheme != "http" && u.Scheme != "ssh" && u.Scheme != "git" {
+			return ""
+		}
+		path = strings.TrimPrefix(u.Path, "/")
+	}
+	path = strings.TrimSuffix(strings.TrimRight(path, "/"), ".git")
+	parts := strings.Split(path, "/")
+	if len(parts) != 2 || !validPart(parts[0]) || !validPart(parts[1]) {
+		return ""
+	}
+	return path
+}
+
+func validPart(part string) bool {
+	if part == "" || part == "." || part == ".." {
+		return false
+	}
+	for _, r := range part {
+		if !(r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_' || r == '.') {
+			return false
+		}
+	}
+	return true
+}
+
+func NormalizeRepo(repo string) (string, error) {
+	if repo == "" {
+		return "", nil
+	}
+	if parsed := GitHubRepo(repo); parsed != "" {
+		return parsed, nil
+	}
+	if parsed := GitHubRepo("https://github.com/" + repo); parsed != "" {
+		return parsed, nil
+	}
+	return "", fmt.Errorf("use a GitHub owner/repository or a github.com URL")
+}
+
+func Inspect(path string) Status {
+	ctx, cancel := context.WithTimeout(context.Background(), 6*time.Second)
+	defer cancel()
+	run := func(args ...string) (string, error) {
+		cmd := exec.CommandContext(ctx, "git", append([]string{"-C", path}, args...)...)
+		hideWindow(cmd)
+		output, err := cmd.Output()
+		if len(args) > 0 && args[0] == "status" {
+			return string(output), err
+		}
+		return strings.TrimSpace(string(output)), err
+	}
+	var s Status
+	if info, err := os.Stat(path); err != nil || !info.IsDir() {
+		s.Error = "This directory is no longer available"
+		return s
+	}
+	if _, err := exec.LookPath("git"); err != nil {
+		s.Error = "Git is not installed"
+		return s
+	}
+	root, err := run("rev-parse", "--is-inside-work-tree")
+	if err != nil || root != "true" {
+		return s
+	}
+	s.Repository = true
+	branch, err := run("symbolic-ref", "--quiet", "--short", "HEAD")
+	if err != nil {
+		branch, _ = run("rev-parse", "--short", "HEAD")
+		if branch != "" {
+			branch = "detached · " + branch
+		} else {
+			branch = "unborn"
+		}
+	}
+	s.Branch = branch
+	output, err := run("status", "--porcelain=v1", "-z", "--untracked-files=all")
+	if err != nil {
+		s.Error = "Unable to read Git status"
+	} else {
+		s.Modified, s.Untracked = ParsePorcelain(output)
+	}
+	s.Remote, _ = run("remote", "get-url", "origin")
+	if s.Remote == "" {
+		remotes, _ := run("remote")
+		if names := strings.Fields(remotes); len(names) > 0 {
+			s.Remote, _ = run("remote", "get-url", names[0])
+		}
+	}
+	s.GitHub = GitHubRepo(s.Remote)
+	counts, err := run("rev-list", "--left-right", "--count", "HEAD...@{upstream}")
+	if err == nil {
+		parts := strings.Fields(counts)
+		if len(parts) == 2 {
+			s.Ahead, _ = strconv.Atoi(parts[0])
+			s.Behind, _ = strconv.Atoi(parts[1])
+		}
+	}
+	commit, err := run("log", "-1", "--format=%ct%n%s")
+	if err == nil {
+		parts := strings.SplitN(commit, "\n", 2)
+		if len(parts) == 2 {
+			seconds, _ := strconv.ParseInt(parts[0], 10, 64)
+			s.CommitTime = time.Unix(seconds, 0)
+			s.Commit = parts[1]
+		}
+	}
+	if ctx.Err() != nil {
+		s.Error = "Git status timed out"
+	}
+	return s
+}
+
+func ParsePorcelain(output string) (modified, untracked int) {
+	entries := strings.Split(output, "\x00")
+	for i := 0; i < len(entries); i++ {
+		entry := entries[i]
+		if len(entry) < 3 {
+			continue
+		}
+		if entry[:2] == "??" {
+			untracked++
+		} else {
+			modified++
+			if entry[0] == 'R' || entry[0] == 'C' || entry[1] == 'R' || entry[1] == 'C' {
+				i++
+			}
+		}
+	}
+	return
+}

package/internal/git/git_test.go

@@ -0,0 +1,73 @@
+package git
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func TestGitHubRepo(t *testing.T) {
+	for _, remote := range []string{"git@github.com:FatalMistake02/Cardly.git", "https://github.com/FatalMistake02/Cardly.git", "ssh://git@github.com/FatalMistake02/Cardly.git", "git://github.com/FatalMistake02/Cardly", "https://github.com/FatalMistake02/Cardly/"} {
+		if actual := GitHubRepo(remote); actual != "FatalMistake02/Cardly" {
+			t.Errorf("%q → %q", remote, actual)
+		}
+	}
+	for _, remote := range []string{"", "git@gitlab.com:owner/repo.git", "https://github.com.evil.test/a/b", "https://github.com/a/b/tree/main", "https://evil.test/github.com/a/b", "https://github.com/a/../b", "file:///a/b", "https://github.com/a/b%20x", "https://github.com/a/.."} {
+		if actual := GitHubRepo(remote); actual != "" {
+			t.Errorf("accepted %q as %q", remote, actual)
+		}
+	}
+	if actual, err := NormalizeRepo("owner/repo"); err != nil || actual != "owner/repo" {
+		t.Fatalf("override: %q %v", actual, err)
+	}
+}
+
+func TestPorcelainRenamesAndWhitespace(t *testing.T) {
+	modified, untracked := ParsePorcelain(" M file with spaces\x00R  new name\x00old name\x00?? new file\x00 D deleted\x00")
+	if modified != 3 || untracked != 1 {
+		t.Fatalf("got modified %d, untracked %d", modified, untracked)
+	}
+}
+
+func TestInspectRepository(t *testing.T) {
+	if _, err := exec.LookPath("git"); err != nil {
+		t.Skip("git unavailable")
+	}
+	dir := t.TempDir()
+	run := func(args ...string) {
+		t.Helper()
+		cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
+		if data, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git %v: %s %v", args, data, err)
+		}
+	}
+	run("init", "-b", "main")
+	run("config", "user.name", "Rian Test")
+	run("config", "user.email", "rian@example.test")
+	run("config", "commit.gpgsign", "false")
+	if status := Inspect(dir); !status.Repository || status.Branch != "main" {
+		t.Fatalf("unborn branch: %+v", status)
+	}
+	file := filepath.Join(dir, "file.txt")
+	if err := os.WriteFile(file, []byte("first"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	run("add", "--", "file.txt")
+	run("commit", "-m", "Initial project")
+	run("remote", "add", "origin", "git@github.com:owner/repo.git")
+	if err := os.WriteFile(file, []byte("changed"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "new.txt"), []byte("new"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	s := Inspect(dir)
+	if !s.Repository || s.Branch != "main" || s.Modified != 1 || s.Untracked != 1 || s.GitHub != "owner/repo" || s.Commit != "Initial project" || s.CommitTime.IsZero() || !s.Dirty() {
+		t.Fatalf("unexpected status: %+v", s)
+	}
+	run("checkout", "--detach")
+	if s = Inspect(dir); s.Branch == "main" || s.Branch == "" {
+		t.Fatalf("detached status: %+v", s)
+	}
+}

package/internal/git/window_unix.go

@@ -0,0 +1,7 @@
+//go:build !windows
+
+package git
+
+import "os/exec"
+
+func hideWindow(cmd *exec.Cmd) {}

package/internal/git/window_windows.go

@@ -0,0 +1,8 @@
+package git
+
+import (
+	"os/exec"
+	"syscall"
+)
+
+func hideWindow(cmd *exec.Cmd) { cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true} }

package/internal/process/platform_unix.go

@@ -0,0 +1,19 @@
+//go:build !windows
+
+package process
+
+import (
+	"errors"
+	"os/exec"
+	"syscall"
+)
+
+func prepare(cmd *exec.Cmd) { cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} }
+
+func stopTree(cmd *exec.Cmd) error {
+	err := syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+	if errors.Is(err, syscall.ESRCH) {
+		return nil
+	}
+	return err
+}

package/internal/process/platform_windows.go

@@ -0,0 +1,25 @@
+package process
+
+import (
+	"fmt"
+	"os/exec"
+	"strconv"
+	"syscall"
+)
+
+func prepare(cmd *exec.Cmd) {
+	if cmd.SysProcAttr == nil {
+		cmd.SysProcAttr = &syscall.SysProcAttr{}
+	}
+	cmd.SysProcAttr.HideWindow = true
+	cmd.SysProcAttr.CreationFlags |= 0x00000200
+}
+
+func stopTree(cmd *exec.Cmd) error {
+	kill := exec.Command("taskkill.exe", "/PID", strconv.Itoa(cmd.Process.Pid), "/T", "/F")
+	kill.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
+	if output, err := kill.CombinedOutput(); err != nil {
+		return fmt.Errorf("could not stop process tree: %s (%w)", output, err)
+	}
+	return nil
+}

package/internal/process/process.go

@@ -0,0 +1,172 @@
+// Package process owns project processes and bounded, concurrent output buffers.
+package process
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"sync"
+	"time"
+
+	"rian/internal/tools"
+)
+
+const outputLimit = 96 * 1024
+
+type Snapshot struct {
+	Command        string
+	PID            int
+	Started, Ended time.Time
+	Running        bool
+	Stopped        bool
+	Output         string
+	Error          string
+}
+
+type session struct {
+	mu     sync.Mutex
+	cmd    *exec.Cmd
+	state  Snapshot
+	buffer []byte
+	done   chan struct{}
+}
+
+func (s *session) Write(data []byte) (int, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	n := len(data)
+	if n >= outputLimit {
+		s.buffer = append(s.buffer[:0], data[n-outputLimit:]...)
+	} else {
+		if len(s.buffer)+n > outputLimit {
+			s.buffer = s.buffer[len(s.buffer)+n-outputLimit:]
+		}
+		s.buffer = append(s.buffer, data...)
+	}
+	return n, nil
+}
+
+func (s *session) snapshot() Snapshot {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	state := s.state
+	state.Output = string(s.buffer)
+	return state
+}
+
+type Manager struct {
+	mu       sync.Mutex
+	startMu  sync.Mutex
+	sessions map[string]*session
+	closed   bool
+}
+
+func New() *Manager { return &Manager{sessions: map[string]*session{}} }
+
+func (m *Manager) Start(id, path, command string) (Snapshot, error) {
+	if info, err := os.Stat(path); err != nil || !info.IsDir() {
+		return Snapshot{}, fmt.Errorf("this directory is no longer available: %s", path)
+	}
+	return m.StartCommand(id, command, tools.Shell(path, command))
+}
+
+func (m *Manager) StartCommand(id, label string, cmd *exec.Cmd) (Snapshot, error) {
+	// Launch/shutdown serialize separately from the map lock. Screen snapshots
+	// never wait for an OS process launch (which can be slow on Windows).
+	m.startMu.Lock()
+	defer m.startMu.Unlock()
+	m.mu.Lock()
+	closed, existing := m.closed, m.sessions[id]
+	m.mu.Unlock()
+	if closed {
+		return Snapshot{}, fmt.Errorf("process manager is shutting down")
+	}
+	if existing != nil && existing.snapshot().Running {
+		return existing.snapshot(), fmt.Errorf("a command is already running for this project; stop it first")
+	}
+	s := &session{cmd: cmd, state: Snapshot{Command: label, Started: time.Now()}, done: make(chan struct{})}
+	cmd.Stdout, cmd.Stderr = s, s
+	prepare(cmd)
+	if err := cmd.Start(); err != nil {
+		return Snapshot{}, fmt.Errorf("could not start command: %w", err)
+	}
+	s.state.PID, s.state.Running = cmd.Process.Pid, true
+	m.mu.Lock()
+	m.sessions[id] = s
+	m.mu.Unlock()
+	go func() {
+		err := cmd.Wait()
+		s.mu.Lock()
+		s.state.Running, s.state.Ended = false, time.Now()
+		if err != nil && !s.state.Stopped {
+			s.state.Error = err.Error()
+		}
+		s.mu.Unlock()
+		close(s.done)
+	}()
+	return s.snapshot(), nil
+}
+
+func (m *Manager) Snapshot(id string) Snapshot {
+	m.mu.Lock()
+	s := m.sessions[id]
+	m.mu.Unlock()
+	if s == nil {
+		return Snapshot{}
+	}
+	return s.snapshot()
+}
+
+func (m *Manager) Stop(id string) error {
+	m.mu.Lock()
+	s := m.sessions[id]
+	m.mu.Unlock()
+	if s == nil || !s.snapshot().Running {
+		return nil
+	}
+	s.mu.Lock()
+	s.state.Stopped = true
+	s.mu.Unlock()
+	if err := stopTree(s.cmd); err != nil {
+		s.mu.Lock()
+		s.state.Stopped = false
+		s.mu.Unlock()
+		return err
+	}
+	select {
+	case <-s.done:
+		return nil
+	case <-time.After(4 * time.Second):
+		return fmt.Errorf("process did not exit after stop")
+	}
+}
+
+func (m *Manager) Active() int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	n := 0
+	for _, s := range m.sessions {
+		if s.snapshot().Running {
+			n++
+		}
+	}
+	return n
+}
+
+func (m *Manager) Close() {
+	m.startMu.Lock()
+	m.mu.Lock()
+	m.closed = true
+	ids := make([]string, 0, len(m.sessions))
+	for id := range m.sessions {
+		ids = append(ids, id)
+	}
+	m.mu.Unlock()
+	m.startMu.Unlock()
+	var wg sync.WaitGroup
+	for _, id := range ids {
+		wg.Add(1)
+		go func(id string) { defer wg.Done(); _ = m.Stop(id) }(id)
+	}
+	wg.Wait()
+}

package/internal/process/process_test.go

@@ -0,0 +1,137 @@
+package process
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func helperCommand(t *testing.T, mode, dir string) *exec.Cmd {
+	t.Helper()
+	exe, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command(exe, "-test.run=^TestProcessHelper$")
+	cmd.Env = append(os.Environ(), "RIAN_TEST_HELPER="+mode, "RIAN_TEST_HELPER_DIR="+dir)
+	cmd.Dir = dir
+	return cmd
+}
+
+func TestProcessHelper(t *testing.T) {
+	mode := os.Getenv("RIAN_TEST_HELPER")
+	if mode == "" {
+		return
+	}
+	switch mode {
+	case "output":
+		fmt.Fprintln(os.Stdout, "hello from stdout")
+		fmt.Fprintln(os.Stderr, "hello from stderr")
+	case "long":
+		fmt.Fprintln(os.Stdout, "ready")
+		time.Sleep(time.Minute)
+	case "tree":
+		exe, _ := os.Executable()
+		child := exec.Command(exe, "-test.run=^TestProcessHelper$")
+		child.Env = append(os.Environ(), "RIAN_TEST_HELPER=child")
+		if err := child.Start(); err != nil {
+			fmt.Fprintln(os.Stdout, err)
+			os.Exit(2)
+		}
+		os.WriteFile(filepath.Join(os.Getenv("RIAN_TEST_HELPER_DIR"), "child.pid"), []byte(fmt.Sprint(child.Process.Pid)), 0600)
+		fmt.Fprintln(os.Stdout, "ready")
+		time.Sleep(time.Minute)
+	case "child":
+		file, err := os.OpenFile(filepath.Join(os.Getenv("RIAN_TEST_HELPER_DIR"), "child.log"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0600)
+		if err != nil {
+			os.Exit(3)
+		}
+		defer file.Close()
+		for range 1000 {
+			file.WriteString(".")
+			file.Sync()
+			time.Sleep(20 * time.Millisecond)
+		}
+	}
+	os.Exit(0)
+}
+
+func until(t *testing.T, condition func() bool) {
+	t.Helper()
+	deadline := time.Now().Add(5 * time.Second)
+	for time.Now().Before(deadline) {
+		if condition() {
+			return
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+	t.Fatal("process state did not arrive")
+}
+
+func TestCaptureAndOneProcessPerProject(t *testing.T) {
+	manager := New()
+	defer manager.Close()
+	dir := t.TempDir()
+	if _, err := manager.StartCommand("p", "helper output", helperCommand(t, "output", dir)); err != nil {
+		t.Fatal(err)
+	}
+	until(t, func() bool { return !manager.Snapshot("p").Running })
+	s := manager.Snapshot("p")
+	if !strings.Contains(s.Output, "stdout") || !strings.Contains(s.Output, "stderr") || s.PID == 0 || s.Started.IsZero() || s.Ended.IsZero() {
+		t.Fatalf("missing process information: %+v", s)
+	}
+	if _, err := manager.StartCommand("p", "long", helperCommand(t, "long", dir)); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := manager.StartCommand("p", "duplicate", helperCommand(t, "long", dir)); err == nil {
+		t.Fatal("a second process for one project was accepted")
+	}
+	if err := manager.Stop("p"); err != nil {
+		t.Fatal(err)
+	}
+	if s = manager.Snapshot("p"); s.Running || !s.Stopped || s.Error != "" {
+		t.Fatalf("stop failed: %+v", s)
+	}
+}
+
+func TestStopIncludesChildProcess(t *testing.T) {
+	manager := New()
+	defer manager.Close()
+	dir := t.TempDir()
+	if _, err := manager.StartCommand("tree", "tree", helperCommand(t, "tree", dir)); err != nil {
+		t.Fatal(err)
+	}
+	file := filepath.Join(dir, "child.log")
+	until(t, func() bool { info, err := os.Stat(file); return err == nil && info.Size() > 0 })
+	if err := manager.Stop("tree"); err != nil {
+		t.Fatal(err)
+	}
+	before, _ := os.Stat(file)
+	time.Sleep(200 * time.Millisecond)
+	after, _ := os.Stat(file)
+	if before.Size() != after.Size() {
+		t.Fatal("a descendant process kept running after stop")
+	}
+}
+
+func TestOutputIsBounded(t *testing.T) {
+	s := &session{}
+	s.Write([]byte(strings.Repeat("a", outputLimit*2)))
+	s.Write([]byte("tail"))
+	state := s.snapshot()
+	if len(state.Output) != outputLimit || !strings.HasSuffix(state.Output, "tail") {
+		t.Fatal("recent output was not bounded correctly")
+	}
+}
+
+func TestShutdownRejectsLateStarts(t *testing.T) {
+	manager := New()
+	manager.Close()
+	if _, err := manager.StartCommand("late", "late", helperCommand(t, "long", t.TempDir())); err == nil {
+		t.Fatal("a process started after shutdown")
+	}
+}