relay-flow 0.2.7-alpha → 0.2.9-alpha

package/cmd/relay-flow/main.go

@@ -136,6 +136,7 @@ Usage:
   relay-flow init [--force] [--task-plugin <name> --runner-plugin <name> --harness-plugin <name>]
                    [--executor-plugin <goworkflows|temporal>]
                    [--temporal-address <host:port>] [--temporal-namespace <name>]
+                   (interactive first run also authenticates and optionally registers repos)
   relay-flow task auth [task-plugin options]
   relay-flow serve [--recover] [--debug] [--background]
   relay-flow stop
@@ -168,6 +169,14 @@ Usage:
 // a TTY → three stdin lines (task, runner, harness), the documented test
 // seam and script path.
 func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
+	if err := recoverFirstRunPublication(p); err != nil {
+		fmt.Fprintln(os.Stderr, "init: "+err.Error())
+		return exitFail
+	}
+	if err := cleanupFirstRunStaging(p); err != nil {
+		fmt.Fprintln(os.Stderr, "init: "+err.Error())
+		return exitFail
+	}
 	fs := flag.NewFlagSet("init", flag.ContinueOnError)
 	taskName := fs.String("task-plugin", "", "task plugin name (non-interactive)")
 	runnerName := fs.String("runner-plugin", "", "runner plugin name (non-interactive)")
@@ -206,11 +215,17 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 		fmt.Fprintln(os.Stderr, "init: database is missing; refusing to recreate existing durable state")
 		return exitFail
 	}
-	if err := os.MkdirAll(p.Root, 0o700); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return exitFail
+	// A first interactive setup keeps the final home untouched until the
+	// selected task plugin has authenticated successfully. Scripted setup and
+	// --force retain the existing eager directory creation behavior.
+	firstRunInteractive := !*force && !configExists && !databaseExists && !flagged && interactiveInitTTY(stdin)
+	if !firstRunInteractive {
+		if err := os.MkdirAll(p.Root, 0o700); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return exitFail
+		}
+		_ = os.Chmod(p.Root, 0o700)
 	}
-	_ = os.Chmod(p.Root, 0o700)
 	var unlock func()
 	if *force {
 		unlock, err = lockForForcedInit(p.Lock)
@@ -240,9 +255,9 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 	switch {
 	case flagged:
 		names = []string{*taskName, *runnerName, *harnessName}
-	case isTTY(stdin):
+	case interactiveInitTTY(stdin):
 		var err error
-		names, err = pickPluginsInteractive()
+		names, err = interactiveInitPluginPick()
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "init: "+err.Error())
 			return exitFail
@@ -258,7 +273,7 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 			return exitFail
 		}
 	}
-	if executor == executorTemporal && isTTY(stdin) {
+	if executor == executorTemporal && interactiveInitTTY(stdin) {
 		address, namespace, err := promptTemporalSettings(*temporalAddress, *temporalNamespace)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "init: "+err.Error())
@@ -353,6 +368,19 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 	} else {
 		cfg.HarnessConfig = config.Merge(harnessDefaults, cfg.HarnessConfig)
 	}
+	var stagedAuthDir string
+	if firstRunInteractive {
+		if names[0] == "beads" {
+			fmt.Println("Beads authentication is managed by the Beads workspace and Dolt setup; relay-flow does not store task credentials.")
+		}
+		var authErr error
+		cfg, stagedAuthDir, authErr = stageFirstRunAuthentication(p, cfg, names[0], stdin)
+		if authErr != nil {
+			fmt.Fprintln(os.Stderr, "init: task auth: "+authErr.Error())
+			return exitFail
+		}
+		defer os.RemoveAll(stagedAuthDir)
+	}
 	identity := projection.ExecutorIdentity{
 		ExecutorPlugin:    executor,
 		TemporalAddress:   cfg.TemporalAddress,
@@ -373,13 +401,30 @@ func cmdInit(p paths.Paths, args []string, stdin io.Reader) int {
 			return exitFail
 		}
 	}
-	if !databaseExists {
+	if !firstRunInteractive && !databaseExists {
 		if err := projection.InitDatabaseWithIdentity(p.Database, identity); err != nil {
 			fmt.Fprintln(os.Stderr, "init: "+err.Error())
 			return exitFail
 		}
 	}
-	if err := config.SaveMachine(p.Config, cfg); err != nil {
+	if firstRunInteractive {
+		if err := commitFirstRun(p, stagedAuthDir, identity); err != nil {
+			fmt.Fprintln(os.Stderr, "init: "+err.Error())
+			return exitFail
+		}
+		register, err := interactiveInitRepoPrompt()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "init: "+err.Error())
+			return exitFail
+		}
+		if register {
+			if err := interactiveInitRepoSetup(p, stdin); err != nil {
+				fmt.Fprintln(os.Stderr, "init: "+err.Error())
+				return exitFail
+			}
+			fmt.Println("Repository setup complete. The server is running; stop it with `relay-flow stop`.")
+		}
+	} else if err := config.SaveMachine(p.Config, cfg); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return exitFail
 	}
@@ -540,53 +585,119 @@ func cmdServe(p paths.Paths, args []string) int {
 	return exitOK
 }
 
+var (
+	backgroundServeStartupTimeout = 10 * time.Second
+	backgroundServePollInterval   = 50 * time.Millisecond
+)
+
 func startBackgroundServe(p paths.Paths, recover, debug bool) error {
 	client := server.NewClient(p.Socket)
 	if serverResponding(client, 200*time.Millisecond) {
 		return fmt.Errorf("serve --background: server is already running")
 	}
-	executable, err := os.Executable()
+	deadline := time.Now().Add(backgroundServeStartupTimeout)
+	lockHeld, err := serverLockHeld(p.Lock)
 	if err != nil {
-		return fmt.Errorf("serve --background: resolve executable: %w", err)
-	}
-	childArgs := []string{"serve"}
-	if recover {
-		childArgs = append(childArgs, "--recover")
+		return fmt.Errorf("serve --background: inspect server lock: %w", err)
 	}
-	if debug {
-		childArgs = append(childArgs, "--debug")
+
+	var (
+		cmd           *exec.Cmd
+		wait          chan error
+		observedOwner = lockHeld
+		devNull       *os.File
+	)
+	if !lockHeld {
+		executable, resolveErr := os.Executable()
+		if resolveErr != nil {
+			return fmt.Errorf("serve --background: resolve executable: %w", resolveErr)
+		}
+		childArgs := []string{"serve"}
+		if recover {
+			childArgs = append(childArgs, "--recover")
+		}
+		if debug {
+			childArgs = append(childArgs, "--debug")
+		}
+		devNull, err = os.OpenFile(os.DevNull, os.O_RDWR, 0)
+		if err != nil {
+			return fmt.Errorf("serve --background: open %s: %w", os.DevNull, err)
+		}
+		defer devNull.Close()
+		cmd = exec.Command(executable, childArgs...)
+		cmd.Stdin, cmd.Stdout, cmd.Stderr = devNull, devNull, devNull
+		cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+		if err := cmd.Start(); err != nil {
+			return fmt.Errorf("serve --background: start: %w; see %s", err, p.ServerLog)
+		}
+		wait = make(chan error, 1)
+		go func() { wait <- cmd.Wait() }()
 	}
-	devNull, err := os.OpenFile(os.DevNull, os.O_RDWR, 0)
-	if err != nil {
-		return fmt.Errorf("serve --background: open %s: %w", os.DevNull, err)
-	}
-	defer devNull.Close()
-	cmd := exec.Command(executable, childArgs...)
-	cmd.Stdin, cmd.Stdout, cmd.Stderr = devNull, devNull, devNull
-	cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
-	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("serve --background: start: %w; see %s", err, p.ServerLog)
-	}
-	wait := make(chan error, 1)
-	go func() { wait <- cmd.Wait() }()
-	deadline := time.NewTimer(10 * time.Second)
-	defer deadline.Stop()
-	ticker := time.NewTicker(50 * time.Millisecond)
+
+	ticker := time.NewTicker(backgroundServePollInterval)
 	defer ticker.Stop()
 	for {
-		select {
-		case err := <-wait:
-			return fmt.Errorf("serve --background: server exited before readiness: %v; see %s", err, p.ServerLog)
-		case <-deadline.C:
-			_ = cmd.Process.Kill()
-			<-wait
+		if serverResponding(client, 200*time.Millisecond) {
+			return nil
+		}
+		if !time.Now().Before(deadline) {
+			if cmd != nil && wait != nil {
+				_ = cmd.Process.Kill()
+				<-wait
+			}
 			return fmt.Errorf("serve --background: startup timed out; see %s", p.ServerLog)
-		case <-ticker.C:
-			if serverResponding(client, 200*time.Millisecond) {
-				return nil
+		}
+		if observedOwner && wait == nil {
+			held, lockErr := serverLockHeld(p.Lock)
+			if lockErr != nil {
+				return fmt.Errorf("serve --background: inspect server lock: %w", lockErr)
+			}
+			if !held {
+				return fmt.Errorf("serve --background: server exited before readiness; see %s", p.ServerLog)
+			}
+		}
+		select {
+		case childErr := <-wait:
+			held, lockErr := serverLockHeld(p.Lock)
+			if lockErr != nil {
+				return fmt.Errorf("serve --background: inspect server lock: %w", lockErr)
 			}
+			if held {
+				// Another process acquired the lock while this child was
+				// starting. Wait for that owner instead of spawning again.
+				observedOwner = true
+				wait = nil
+				cmd = nil
+				continue
+			}
+			return fmt.Errorf("serve --background: server exited before readiness: %v; see %s", childErr, p.ServerLog)
+		case <-ticker.C:
+		}
+	}
+}
+
+func serverLockHeld(path string) (bool, error) {
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o600)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
 		}
+		return false, err
+	}
+	defer f.Close()
+	if err := f.Chmod(0o600); err != nil {
+		return false, err
+	}
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err != nil {
+		if err == syscall.EWOULDBLOCK || err == syscall.EAGAIN {
+			return true, nil
+		}
+		return false, err
+	}
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_UN); err != nil {
+		return false, err
 	}
+	return false, nil
 }
 
 func serverResponding(client *server.Client, timeout time.Duration) bool {
@@ -798,7 +909,7 @@ func cmdRepo(c *server.Client, args []string, stdin io.Reader) int {
 }
 
 // cmdRepoRegister registers one flagged repo or multiple interactively selected
-// runner repos. Jira project is shared and component is always the repo name.
+// runner repos using registration metadata supplied by the selected task plugin.
 func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags, stdin io.Reader) int {
 	ctx := context.Background()
 	flagged := flagName != "" || flagPath != "" || len(sets) > 0
@@ -809,32 +920,28 @@ func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags,
 			fmt.Fprintln(os.Stderr, "repo register: --name and --path are required for non-interactive registration")
 			return exitUsage
 		}
-		if _, ok := sets["component"]; ok {
-			fmt.Fprintln(os.Stderr, "repo register: component is derived from --name and cannot be overridden")
-			return exitUsage
-		}
-		fields, err := c.RepoTaskFields(ctx)
+		registration, err := loadRepoRegistration(ctx, c, sets)
 		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
+			fmt.Fprintln(os.Stderr, standaloneRepoServerHint(err))
 			return exitFail
 		}
-		taskCfg, err := repoTaskConfig(fields, sets, flagName)
+		taskCfg, err := registrationTaskConfig(registration, sets, flagName)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
 			return exitUsage
 		}
 		info, err := c.RegisterRepo(ctx, repo.RegisterInput{Name: flagName, Path: flagPath, TaskConfig: taskCfg})
 		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
+			fmt.Fprintln(os.Stderr, standaloneRepoServerHint(err))
 			return exitFail
 		}
 		fmt.Println(info.Name)
 		return exitOK
 	}
 
-	fields, err := c.RepoTaskFields(ctx)
+	registration, err := c.RepoRegistrationFields(ctx, nil)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
+		fmt.Fprintln(os.Stderr, standaloneRepoServerHint(err))
 		return exitFail
 	}
 
@@ -844,48 +951,39 @@ func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags,
 	}
 	candidates, err := c.DiscoverRepos(ctx)
 	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
+		fmt.Fprintln(os.Stderr, standaloneRepoServerHint(err))
 		return exitFail
 	}
-	if len(candidates) == 0 {
-		fmt.Fprintln(os.Stderr, "repo register: runner discovered no repos")
+	registered, err := c.ListRepos(ctx)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, standaloneRepoServerHint(err))
+		return exitFail
+	}
+	candidates, selected, err := selectReposInteractive(ctx, c, candidates, registered)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "repo register: "+standaloneRepoServerHint(err).Error())
 		return exitFail
 	}
 
-	selected := []int{}
-	options := make([]huh.Option[int], len(candidates))
-	for i, cand := range candidates {
-		options[i] = huh.NewOption(cand.Name+"  ("+cand.Path+")", i)
-	}
-	pickField := repoMultiSelect(options, &selected)
-	pick := huh.NewForm(huh.NewGroup(pickField))
-	if err := pick.Run(); err != nil {
+	shared := kvFlags{}
+	if err := promptRepoRegistration(registration, shared); err != nil {
 		fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
 		return exitFail
 	}
-
-	sharedFields := registrationSharedFields(fields)
-	values := make([]string, len(sharedFields))
-	inputs := make([]huh.Field, len(sharedFields))
-	for i, field := range sharedFields {
-		title := field
-		if field == "project" {
-			title = "Jira project"
-		}
-		inputs[i] = huh.NewInput().Title(title).Value(&values[i])
-	}
-	if len(inputs) > 0 {
-		if err := huh.NewForm(huh.NewGroup(inputs...)).Run(); err != nil {
+	if len(shared) > 0 {
+		dependent, err := c.RepoRegistrationFields(ctx, flatRegistrationValues(shared))
+		if err != nil {
+			fmt.Fprintln(os.Stderr, standaloneRepoServerHint(err))
+			return exitFail
+		}
+		registration = mergeRegistration(registration, dependent)
+		if err := promptRepoRegistration(registration, shared); err != nil {
 			fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
 			return exitFail
 		}
 	}
-	shared := kvFlags{}
-	for i, field := range sharedFields {
-		shared[field] = values[i]
-	}
-	if err := registerSelectedRepos(ctx, c, candidates, selected, fields, shared); err != nil {
-		fmt.Fprintln(os.Stderr, "repo register: "+err.Error())
+	if err := registerSelectedReposDynamic(ctx, c, candidates, selected, registration, shared); err != nil {
+		fmt.Fprintln(os.Stderr, "repo register: "+standaloneRepoServerHint(err).Error())
 		return exitFail
 	}
 	return exitOK
@@ -894,6 +992,8 @@ func cmdRepoRegister(c *server.Client, flagName, flagPath string, sets kvFlags,
 func repoMultiSelect(options []huh.Option[int], selected *[]int) *huh.MultiSelect[int] {
 	return huh.NewMultiSelect[int]().
 		Title("Select repositories").
+		Description("Press / to filter repositories; select [+] Add repository to add a runner resource.").
+		Filterable(true).
 		Options(options...).
 		Value(selected).
 		Validate(func(values []int) error {
@@ -904,67 +1004,6 @@ func repoMultiSelect(options []huh.Option[int], selected *[]int) *huh.MultiSelec
 		})
 }
 
-func registrationSharedFields(fields []string) []string {
-	shared := make([]string, 0, len(fields))
-	for _, field := range fields {
-		if field != "component" {
-			shared = append(shared, field)
-		}
-	}
-	return shared
-}
-
-func repoTaskConfig(fields []string, supplied kvFlags, repoName string) (config.RawValues, error) {
-	required := map[string]bool{}
-	for _, field := range fields {
-		required[field] = true
-	}
-	values := config.RawValues{}
-	for key, value := range supplied {
-		if !required[key] {
-			return nil, fmt.Errorf("unknown task key %q (required keys: %s)", key, strings.Join(fields, ", "))
-		}
-		if value == "" {
-			return nil, fmt.Errorf("task key %q requires a non-empty value", key)
-		}
-		values[key] = value
-	}
-	if required["component"] {
-		values["component"] = repoName
-	}
-	var missing []string
-	for _, field := range fields {
-		if _, ok := values[field]; !ok {
-			missing = append(missing, field)
-		}
-	}
-	if len(missing) > 0 {
-		return nil, fmt.Errorf("missing required task keys: %s (pass --set %s=<value>)",
-			strings.Join(missing, ", "), missing[0])
-	}
-	return values, nil
-}
-
-func registerSelectedRepos(ctx context.Context, c *server.Client, candidates []runner.RepoCandidate, selected []int, fields []string, shared kvFlags) error {
-	for _, index := range selected {
-		candidate := candidates[index]
-		taskCfg, err := repoTaskConfig(fields, shared, candidate.Name)
-		if err != nil {
-			return fmt.Errorf("%s: %w", candidate.Name, err)
-		}
-		info, err := c.RegisterRepo(ctx, repo.RegisterInput{
-			Name:       candidate.Name,
-			Path:       candidate.Path,
-			TaskConfig: taskCfg,
-		})
-		if err != nil {
-			return fmt.Errorf("%s: %w", candidate.Name, err)
-		}
-		fmt.Println(info.Name)
-	}
-	return nil
-}
-
 // kvFlags collects repeated key=value flags (registration task config).
 // Parse rejects malformed pairs, empty keys/values, and duplicates.
 type kvFlags map[string]string