relay-flow 0.3.7-alpha → 0.3.9-alpha

package/internal/task/beads/beads_test.go

@@ -16,6 +16,21 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/task/beads/bdcli"
 )
 
+func TestBeadsLocalFactoryDoesNotProbeMissingWorkspace(t *testing.T) {
+	missing := filepath.Join(t.TempDir(), "not-yet-available")
+	sys, err := task.NewLocal(context.Background(), "beads", task.RepoSpec{
+		Name:       "payments",
+		Path:       t.TempDir(),
+		RepoConfig: config.RawValues{"beadsDir": missing},
+	})
+	if err != nil {
+		t.Fatalf("NewLocal returned error for a missing remote workspace: %v", err)
+	}
+	if sys == nil {
+		t.Fatal("NewLocal returned nil task system")
+	}
+}
+
 func TestBeadsFactoryIsRegisteredWithBeadsDirRequirement(t *testing.T) {
 	if !hasString(task.Names(), "beads") {
 		t.Fatalf("task plugins = %v, want beads", task.Names())

package/internal/task/factory.go

@@ -44,7 +44,13 @@ type Factory struct {
 	Auth                 func(context.Context, []string, io.Reader) error
 	DefaultConfig        func() config.RawValues
 	ValidateTextConfig   func(config.RawValues) error
-	New                  func(context.Context, RepoSpec) (System, error)
+	// New constructs a fully validated repo-bound system. It is used by repo
+	// registration, where connectivity must be confirmed immediately.
+	New func(context.Context, RepoSpec) (System, error)
+	// NewLocal constructs only the local adapter state needed for startup. It
+	// must not probe remote services; submission-time validation owns those
+	// checks. Factories without a local constructor retain the old behavior.
+	NewLocal func(context.Context, RepoSpec) (System, error)
 }
 
 var (
@@ -72,16 +78,49 @@ func lookup(name string) (Factory, error) {
 	return f, nil
 }
 
-// New constructs the repo-bound task System for the named plugin.
+// New constructs the repo-bound task System for the named plugin and runs
+// the adapter's immediate connectivity checks.
 func New(ctx context.Context, name string, spec RepoSpec) (System, error) {
 	f, err := lookup(name)
 	if err != nil {
 		return nil, err
 	}
 	spec.RootConfig = config.Merge(defaultConfig(f), spec.RootConfig)
+	if f.New == nil {
+		return nil, fmt.Errorf("task plugin %q has no constructor", name)
+	}
 	return f.New(ctx, spec)
 }
 
+// ValidateLocal reports whether a task plugin provides the local constructor
+// required by normal startup. This is a machine-wide plugin configuration
+// check, not a repo-specific health result.
+func ValidateLocal(name string) error {
+	f, err := lookup(name)
+	if err != nil {
+		return err
+	}
+	if f.NewLocal == nil {
+		return fmt.Errorf("task plugin %q has no local constructor", name)
+	}
+	return nil
+}
+
+// NewLocal constructs the repo-bound task state without remote probes. Every
+// startup-capable task plugin must explicitly provide this seam; falling back
+// to New would silently reintroduce startup connectivity checks.
+func NewLocal(ctx context.Context, name string, spec RepoSpec) (System, error) {
+	f, err := lookup(name)
+	if err != nil {
+		return nil, err
+	}
+	spec.RootConfig = config.Merge(defaultConfig(f), spec.RootConfig)
+	if f.NewLocal == nil {
+		return nil, fmt.Errorf("task plugin %q has no local constructor", name)
+	}
+	return f.NewLocal(ctx, spec)
+}
+
 // Defaults returns a fresh copy of the selected task plugin's root config
 // defaults for relay-flow init.
 func Defaults(name string) (config.RawValues, error) {

package/internal/task/jira/jira.go

@@ -267,31 +267,49 @@ func init() {
 			}
 			return strings.Join([]string{creds.Site, proj, comp}, "/"), nil
 		},
-		Auth: auth,
-		New: func(ctx context.Context, spec task.RepoSpec) (task.System, error) {
-			merged := config.Merge(spec.RootConfig, spec.RepoConfig)
-			var cfg Config
-			if err := config.DecodeStrict(merged, &cfg); err != nil {
-				return nil, fmt.Errorf("jira repo %q config: %w", spec.Name, err)
-			}
-			creds, err := loadCredentialsDefault()
-			if err != nil {
-				return nil, fmt.Errorf("jira credentials: %w", err)
-			}
-			client, err := sharedClient(creds.Site, creds.Email, creds.Token)
-			if err != nil {
-				return nil, err
-			}
-			sys, err := newSystem(ctx, client, spec)
-			if err != nil {
-				return nil, err
-			}
-			sys.currentUser = strings.TrimSpace(creds.Email)
-			return sys, nil
-		},
+		Auth:     auth,
+		New:      newSystemFromCredentials,
+		NewLocal: newSystemLocal,
 	})
 }
 
+func newSystemFromCredentials(ctx context.Context, spec task.RepoSpec) (task.System, error) {
+	creds, err := loadCredentialsDefault()
+	if err != nil {
+		return nil, fmt.Errorf("jira credentials: %w", err)
+	}
+	client, err := sharedClient(creds.Site, creds.Email, creds.Token)
+	if err != nil {
+		return nil, err
+	}
+	sys, err := newSystem(ctx, client, spec)
+	if err != nil {
+		return nil, err
+	}
+	sys.currentUser = strings.TrimSpace(creds.Email)
+	return sys, nil
+}
+
+// newSystemLocal builds a Jira client and typed adapter state without making
+// assignee or status requests. Those remote checks run only while submitting
+// a candidate workflow.
+func newSystemLocal(ctx context.Context, spec task.RepoSpec) (task.System, error) {
+	creds, err := loadCredentialsDefault()
+	if err != nil {
+		return nil, fmt.Errorf("jira credentials: %w", err)
+	}
+	client, err := sharedClient(creds.Site, creds.Email, creds.Token)
+	if err != nil {
+		return nil, err
+	}
+	sys, err := newSystemWithValidation(ctx, client, spec, false)
+	if err != nil {
+		return nil, err
+	}
+	sys.currentUser = strings.TrimSpace(creds.Email)
+	return sys, nil
+}
+
 func sharedClient(site, email, token string) (*jirarest.HTTPClient, error) {
 	key := strings.TrimRight(site, "/") + "\x00" + email
 	clientsMu.Lock()
@@ -321,6 +339,10 @@ type system struct {
 }
 
 func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*system, error) {
+	return newSystemWithValidation(ctx, cli, spec, true)
+}
+
+func newSystemWithValidation(ctx context.Context, cli jirarest.Client, spec task.RepoSpec, remoteValidation bool) (*system, error) {
 	if spec.Name == "" {
 		return nil, fmt.Errorf("jira: repo name is required")
 	}
@@ -338,7 +360,7 @@ func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*s
 	if err := validateTemplates(cfg.Templates); err != nil {
 		return nil, fmt.Errorf("jira repo %q taskConfig.templates: %w", spec.Name, err)
 	}
-	if cfg.Assignee != "" {
+	if remoteValidation && cfg.Assignee != "" {
 		if err := cli.ValidateAssignee(ctx, cfg.Project, cfg.Assignee); err != nil {
 			return nil, fmt.Errorf("jira repo %q assignee %q: %w", spec.Name, cfg.Assignee, err)
 		}
@@ -349,11 +371,13 @@ func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*s
 		base:      merged,
 		effective: cfg,
 	}
-	if err := s.validateTransition(ctx, "repo config", cfg.Project, cfg.Transition); err != nil {
-		return nil, fmt.Errorf("jira repo %q: %w", spec.Name, err)
-	}
-	if err := validateStatusDefaults(ctx, cli, "repo config", cfg.Project, cfg.StatusDefaults); err != nil {
-		return nil, fmt.Errorf("jira repo %q: %w", spec.Name, err)
+	if remoteValidation {
+		if err := s.validateTransition(ctx, "repo config", cfg.Project, cfg.Transition); err != nil {
+			return nil, fmt.Errorf("jira repo %q: %w", spec.Name, err)
+		}
+		if err := validateStatusDefaults(ctx, cli, "repo config", cfg.Project, cfg.StatusDefaults); err != nil {
+			return nil, fmt.Errorf("jira repo %q: %w", spec.Name, err)
+		}
 	}
 	// project/component are required repo keys enforced at registration. Do not
 	// probe conventional lifecycle names here: repository registration stores

package/internal/workflow/service.go

@@ -40,6 +40,11 @@ type Service struct {
 	// task system before storage. The composition root supplies this callback;
 	// keeping it here avoids widening RepoLookup beyond its documented query.
 	ValidateTaskConfig func(context.Context, *Workflow) error
+	// ValidateSubmission performs the workflow-scoped runner, task-system,
+	// harness, and other environment checks that must happen before the
+	// definition is persisted. Startup intentionally does not repeat these
+	// expensive checks for an accepted workflow.
+	ValidateSubmission func(context.Context, *Workflow) error
 }
 
 func NewService(store *Store, active ActiveRuns, repos RepoLookup) *Service {
@@ -89,12 +94,41 @@ func (s *Service) Submit(ctx context.Context, yamlBytes []byte) (*Workflow, erro
 	if active {
 		return nil, fmt.Errorf("workflow %q has active runs; replacement is rejected", wf.Name)
 	}
+	if s.ValidateSubmission != nil {
+		if err := s.ValidateSubmission(ctx, wf); err != nil {
+			return nil, err
+		}
+	}
+	previousFiles, err := s.store.snapshot(wf.Name)
+	if err != nil {
+		return nil, err
+	}
+	previous, hadPrevious := s.reg.Get(wf.Name)
+	wf.MarkHealthy()
 	if err := s.store.Put(wf.Name, yamlBytes); err != nil {
 		return nil, err
 	}
 	s.reg.Replace(wf)
 	if s.Rebind != nil {
 		if err := s.Rebind(); err != nil {
+			// A binding failure is part of submission failure: restore both the
+			// durable pair and the registry entry before returning.
+			restoreErr := s.store.restorePair(wf.Name, previousFiles)
+			if hadPrevious {
+				s.reg.Replace(previous)
+			} else {
+				s.reg.Remove(wf.Name)
+			}
+			if rebindErr := s.Rebind(); rebindErr != nil {
+				if restoreErr == nil {
+					restoreErr = rebindErr
+				} else {
+					restoreErr = fmt.Errorf("restore bindings: %v; restore files: %w", rebindErr, restoreErr)
+				}
+			}
+			if restoreErr != nil {
+				return nil, fmt.Errorf("rebind workflows for %q: %w (rollback failed: %v)", wf.Name, err, restoreErr)
+			}
 			return nil, fmt.Errorf("rebind workflows for %q: %w", wf.Name, err)
 		}
 	}
@@ -115,12 +149,31 @@ func (s *Service) Remove(ctx context.Context, name string) error {
 	if active {
 		return fmt.Errorf("workflow %q has active runs; removal is rejected", name)
 	}
+	previousFiles, err := s.store.snapshot(name)
+	if err != nil {
+		return err
+	}
+	previous, hadPrevious := s.reg.Get(name)
 	if err := s.store.Remove(name); err != nil {
 		return err
 	}
 	s.reg.Remove(name)
 	if s.Rebind != nil {
 		if err := s.Rebind(); err != nil {
+			restoreErr := s.store.restorePair(name, previousFiles)
+			if hadPrevious {
+				s.reg.Replace(previous)
+			}
+			if rebindErr := s.Rebind(); rebindErr != nil {
+				if restoreErr == nil {
+					restoreErr = rebindErr
+				} else {
+					restoreErr = fmt.Errorf("restore bindings: %v; restore files: %w", rebindErr, restoreErr)
+				}
+			}
+			if restoreErr != nil {
+				return fmt.Errorf("rebind workflows after removing %q: %w (rollback failed: %v)", name, err, restoreErr)
+			}
 			return fmt.Errorf("rebind workflows after removing %q: %w", name, err)
 		}
 	}