main.go

package main

import (
	"bufio"
	"embed"
	"flag"
	"fmt"
	"io/fs"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"strings"
	"sync"
	"syscall"
)

//go:embed tpls
var templates embed.FS

func main() {
	if len(os.Args) < 2 {
		fmt.Fprintln(os.Stderr, "usage: zen <command>")
		os.Exit(1)
	}

	switch os.Args[1] {
	case "init":
		cmdInit()
	case "procfile":
		cmdProcfile()
	default:
		fmt.Fprintf(os.Stderr, "unknown command: %s\n", os.Args[1])
		os.Exit(1)
	}
}

func cmdInit() {
	const root = "tpls/init"

	err := fs.WalkDir(templates, root, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}

		rel := strings.TrimPrefix(path, root+"/")
		if rel == path {
			return nil
		}

		if d.IsDir() {
			return os.MkdirAll(rel, 0o755)
		}

		data, err := templates.ReadFile(path)
		if err != nil {
			return err
		}

		dest := strings.TrimSuffix(rel, ".tpl")

		if _, err := os.Stat(dest); err == nil {
			fmt.Printf("\033[33m%s skipped (already exists)\033[0m\n", dest)
			return nil
		}

		if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
			return err
		}

		fmt.Println(dest)
		return os.WriteFile(dest, data, 0o644)
	})

	if err != nil {
		fmt.Fprintf(os.Stderr, "init failed: %v\n", err)
		os.Exit(1)
	}
}

var colors = []string{
	"\033[36m", // cyan
	"\033[33m", // yellow
	"\033[32m", // green
	"\033[35m", // magenta
	"\033[34m", // blue
	"\033[31m", // red
}

const colorReset = "\033[0m"

func cmdProcfile() {
	fs := flag.NewFlagSet("procfile", flag.ExitOnError)
	file := fs.String("f", "Procfile", "path to Procfile")
	fs.Parse(os.Args[2:])

	entries, err := parseProcfile(*file)
	if err != nil {
		fmt.Fprintf(os.Stderr, "error: %v\n", err)
		os.Exit(1)
	}

	if len(entries) == 0 {
		fmt.Fprintln(os.Stderr, "no services found in Procfile")
		os.Exit(1)
	}

	// find max name length for aligned output
	maxLen := 0
	for _, e := range entries {
		if len(e.name) > maxLen {
			maxLen = len(e.name)
		}
	}

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)

	var wg sync.WaitGroup
	cmds := make([]*exec.Cmd, 0, len(entries))

	for i, e := range entries {
		color := colors[i%len(colors)]
		prefix := fmt.Sprintf("%s%-*s |%s ", color, maxLen, e.name, colorReset)

		cmd := exec.Command("sh", "-c", e.command)
		cmd.Env = os.Environ()
		cmds = append(cmds, cmd)

		stdout, _ := cmd.StdoutPipe()
		stderr, _ := cmd.StderrPipe()

		if err := cmd.Start(); err != nil {
			fmt.Fprintf(os.Stderr, "%s%s failed to start: %v%s\n", color, e.name, err, colorReset)
			continue
		}

		fmt.Printf("%sstarted %s (pid %d)%s\n", color, e.name, cmd.Process.Pid, colorReset)

		wg.Add(2)
		go func() {
			defer wg.Done()
			scanner := bufio.NewScanner(stdout)
			for scanner.Scan() {
				fmt.Printf("%s%s\n", prefix, scanner.Text())
			}
		}()
		go func() {
			defer wg.Done()
			scanner := bufio.NewScanner(stderr)
			for scanner.Scan() {
				fmt.Printf("%s%s\n", prefix, scanner.Text())
			}
		}()

		wg.Add(1)
		go func(name, clr string, c *exec.Cmd) {
			defer wg.Done()
			_ = c.Wait()
			fmt.Printf("%s%s exited%s\n", clr, name, colorReset)
		}(e.name, color, cmd)
	}

	<-sig
	fmt.Println("\nshutting down...")

	for _, cmd := range cmds {
		if cmd.Process != nil {
			_ = cmd.Process.Signal(syscall.SIGTERM)
		}
	}

	wg.Wait()
}

type procEntry struct {
	name    string
	command string
}

func parseProcfile(path string) ([]procEntry, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	var entries []procEntry
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}

		name, cmd, ok := strings.Cut(line, ":")
		if !ok {
			continue
		}

		name = strings.TrimSpace(name)
		cmd = strings.TrimSpace(cmd)
		if name != "" && cmd != "" {
			entries = append(entries, procEntry{name: name, command: cmd})
		}
	}

	return entries, scanner.Err()
}