First ability to build itself.

.gitignore

@@ -31,5 +31,5 @@ config.toml
 public
 *.idx
 *.sqlite3
-./ttarpit
+ttarpit
-./tester
+tester

.ttarpit.json

@@ -1,26 +1,11 @@
 {
+  "Includes": [
+    "^.*.go$"
+  ],
   "Processes": {
     "tester1": {
-      "Command": "tester",
+      "Command": "make",
-      "Args": ["-count", "100", "-id", "1"]
+      "Args": ["build"]
-    }
-  },
-  "Processes": {
-    "tester2": {
-      "Command": "tester",
-      "Args": ["-count", "100", "-id", "2"]
-    }
-  },
-  "Processes": {
-    "tester3": {
-      "Command": "tester",
-      "Args": ["-count", "100", "-id", "3"]
-    }
-  },
-  "Processes": {
-    "tester4": {
-      "Command": "tester",
-      "Args": ["-count", "100", "-id", "4"]
     }
   }
 }

config/settings.go

@@ -11,13 +11,14 @@ import (
 type Process struct {
   Command string
   Args []string
-  Ready chan string
   ExecCmd *exec.Cmd
 }
 
 type config struct {
   Processes map[string]Process
+  Includes []string
   ConfigPath string
+  BuildRunning bool
 }
 
 var Settings config

main.go

@@ -6,6 +6,9 @@ import (
   "log"
   "io"
   "os"
+  "time"
+  "slices"
+  "regexp"
   "io/fs"
   "path/filepath"
   "errors"
@@ -13,7 +16,6 @@ import (
   "github.com/fsnotify/fsnotify"
 )
 
-
 func LaunchLogger(in io.Reader, out io.Writer, err error) {
   if err != nil { log.Fatal(err) }
 
@@ -25,7 +27,6 @@ func LaunchLogger(in io.Reader, out io.Writer, err error) {
 }
 
 func LaunchProcess(proc *config.Process) {
-  for {
   proc.ExecCmd = exec.Command(proc.Command, proc.Args...)
   if errors.Is(proc.ExecCmd.Err, exec.ErrDot) {
     proc.ExecCmd.Err = nil
@@ -47,21 +48,46 @@ func LaunchProcess(proc *config.Process) {
   fmt.Println("WAITING for", proc.Command)
 
   fmt.Println("SENDING READY on channel")
-    proc.Ready<- "ready"
+
+  fmt.Println("SENT READY")
   proc.ExecCmd.Wait()
   fmt.Println("PROCESS", proc.Command, "EXITED")
+}
+
+func MatchesPath(fp string) bool {
+  fp = filepath.ToSlash(fp)
+
+  is_included := slices.ContainsFunc(config.Settings.Includes, func (reg string) bool {
+    matches, err := regexp.MatchString(reg, fp)
+
+    if err != nil {
+      log.Panic("invalid excludes regex", reg, "error: ", err)
     }
+
+    return matches
+  })
+
+  return is_included
 }
 
 func RunBuild() {
+  if !config.Settings.BuildRunning {
+    config.Settings.BuildRunning = true
+    defer func(){config.Settings.BuildRunning = false}()
+
     fmt.Println("CONFIG:", config.Settings.ConfigPath)
     fmt.Println("COMMANDs:", config.Settings.Processes)
 
     for name, proc := range config.Settings.Processes {
       fmt.Println("PROCESS:", name)
 
-    proc.Ready = make(chan string)
       LaunchProcess(&proc)
+      fmt.Println("=================== PROCESS EXIT")
+    }
+
+    time.Sleep(1000 * time.Millisecond)
+  } else {
+    fmt.Println("!!!! BUILD SKIP, already running")
   }
 }
 
@@ -103,12 +129,15 @@ func WatchDir() {
 
         if event.Has(fsnotify.Create) {
           log.Println("---> CREATE", event.Name)
-          // ADD DIR
+          AddWatchDir(watcher, event.Name)
+        } else if event.Has(fsnotify.Write) {
+          // check if match then do thing
+          if MatchesPath(event.Name) {
+            go RunBuild()
+          }
         } else {
           log.Println("event:", event)
         }
-        // check if match then do thing
-        go RunBuild()
       case err, ok := <-watcher.Errors:
         if !ok {
           return

tools/cmd/tester/main.go

@@ -13,7 +13,7 @@ func Worker(name string, count int, done chan<- int, stop <-chan int) {
   for i := 0; i < count; i++ {
     select {
     case <-stop:
-      fmt.Println("Worker stopped:", name)
+      fmt.Println("TESTER Worker stopped:", name)
       done<- 1
       return
     default:
@@ -44,28 +44,26 @@ func Supervisor(id int, count int) {
 
         select {
         case <-workerDone:
-          fmt.Println("Supervisor: Worker Done")
+          fmt.Println("TESTER Supervisor: Worker Done")
           time.Sleep(500 * time.Millisecond)
         case <-stop:
-          fmt.Println("Supervisor: Stop")
+          fmt.Println("TESTER Supervisor: Stop")
           return
         }
       }
     }()
   }
 
-  /*
   go func() {
     // test shutdown
     time.Sleep(10000 * time.Millisecond)
+    fmt.Println("TESTER FORCE STOP!")
     close(stop)
   }()
-  */
 
   wg.Wait()
 }
 
-
 func main() {
   count := flag.Int("count", 10, "Seconds to wait")