Prepare for default agent

Signed-off-by: David Gageot <david.gageot@docker.com>

Author: dgageot

cmd/root/run.go

@@ -86,18 +86,21 @@ func (f *runExecFlags) runOrExec(ctx context.Context, out *cli.Printer, args []s
 	var rt runtime.Runtime
 	var sess *session.Session
 	var err error
-	if f.remoteAddress != "" {
-		rt, sess, err = f.createRemoteRuntimeAndSession(ctx, args[0])
+	switch {
+	case f.remoteAddress != "":
+		agentFileName = args[0]
+		rt, sess, err = f.createRemoteRuntimeAndSession(ctx, agentFileName)
 		if err != nil {
 			return err
 		}
-	} else {
+
+	default:
 		agentFileName, err = f.resolveAgentFile(ctx, out, args[0])
 		if err != nil {
 			return err
 		}
 
-		t, err := f.loadAgents(ctx, agentFileName)
+		t, err := f.loadAgentFrom(ctx, teamloader.NewFileSource(agentFileName))
 		if err != nil {
 			return err
 		}
@@ -133,8 +136,8 @@ func (f *runExecFlags) resolveAgentFile(ctx context.Context, out *cli.Printer, a
 	return agentfile.Resolve(ctx, out, agentFilename)
 }
 
-func (f *runExecFlags) loadAgents(ctx context.Context, agentFilename string) (*team.Team, error) {
-	t, err := teamloader.Load(ctx, agentFilename, f.runConfig, teamloader.WithModelOverrides(f.modelOverrides))
+func (f *runExecFlags) loadAgentFrom(ctx context.Context, source teamloader.AgentSource) (*team.Team, error) {
+	t, err := teamloader.LoadFrom(ctx, source, f.runConfig, teamloader.WithModelOverrides(f.modelOverrides))
 	if err != nil {
 		return nil, err
 	}

pkg/config/config.go

@@ -19,22 +19,26 @@ import (
 func LoadConfig(path string, fs filesystem.FS) (*latest.Config, error) {
 	data, err := fs.ReadFile(path)
 	if err != nil {
-		return nil, fmt.Errorf("reading config file: %w", err)
+		return nil, fmt.Errorf("reading config file %s: %w", path, err)
 	}
 
+	return LoadConfigBytes(data)
+}
+
+func LoadConfigBytes(data []byte) (*latest.Config, error) {
 	var raw struct {
 		Version string `yaml:"version,omitempty"`
 	}
 	if err := yaml.UnmarshalWithOptions(data, &raw); err != nil {
-		return nil, fmt.Errorf("looking for version in config file %s\n%s", path, yaml.FormatError(err, true, true))
+		return nil, fmt.Errorf("looking for version in config file\n%s", yaml.FormatError(err, true, true))
 	}
 	if raw.Version == "" {
 		raw.Version = latest.Version
 	}
 
 	oldConfig, err := parseCurrentVersion(data, raw.Version)
 	if err != nil {
-		return nil, fmt.Errorf("parsing config file %s\n%s", path, yaml.FormatError(err, true, true))
+		return nil, fmt.Errorf("parsing config file\n%s", yaml.FormatError(err, true, true))
 	}
 
 	config, err := migrateToLatestConfig(oldConfig)

pkg/teamloader/sources.go

@@ -0,0 +1,77 @@
+package teamloader
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+type AgentSource interface {
+	Name() string
+	ParentDir() string
+	Read() ([]byte, error)
+}
+
+// fileSource is used to load an agent configuration from a YAML file.
+type fileSource struct {
+	path string
+}
+
+func NewFileSource(path string) AgentSource {
+	return fileSource{
+		path: path,
+	}
+}
+
+func (a fileSource) Name() string {
+	return filepath.Base(a.path)
+}
+
+func (a fileSource) ParentDir() string {
+	return filepath.Dir(a.path)
+}
+
+func (a fileSource) Read() ([]byte, error) {
+	parentDir := a.ParentDir()
+	fs, err := os.OpenRoot(parentDir)
+	if err != nil {
+		return nil, fmt.Errorf("opening filesystem %s: %w", parentDir, err)
+	}
+
+	fileName := a.Name()
+	data, err := fs.ReadFile(fileName)
+	if err != nil {
+		return nil, fmt.Errorf("reading config file %s: %w", fileName, err)
+	}
+
+	return data, nil
+}
+
+// bytesSource is used to load an agent configuration from a []byte.
+type bytesSource struct {
+	workingDir string
+	data       []byte
+}
+
+func NewBytesSource(workingDir string, data []byte) AgentSource {
+	// TODO(dga): this is not perfect but ok for now
+	if workingDir == "" {
+		workingDir = "."
+	}
+	return bytesSource{
+		workingDir: workingDir,
+		data:       data,
+	}
+}
+
+func (a bytesSource) Name() string {
+	return ""
+}
+
+func (a bytesSource) ParentDir() string {
+	return a.workingDir
+}
+
+func (a bytesSource) Read() ([]byte, error) {
+	return a.data, nil
+}

pkg/teamloader/teamloader.go

@@ -95,7 +95,14 @@ func WithToolsetRegistry(registry *ToolsetRegistry) Opt {
 	}
 }
 
+// Load loads an agent team from the given file path.
+// Prefers LoadFrom for more control over the source.
 func Load(ctx context.Context, p string, runtimeConfig config.RuntimeConfig, opts ...Opt) (*team.Team, error) {
+	return LoadFrom(ctx, NewFileSource(p), runtimeConfig, opts...)
+}
+
+// LoadFrom loads an agent team from the given source
+func LoadFrom(ctx context.Context, source AgentSource, runtimeConfig config.RuntimeConfig, opts ...Opt) (*team.Team, error) {
 	var loadOpts loadOptions
 	loadOpts.toolsetRegistry = NewDefaultToolsetRegistry()
 
@@ -105,8 +112,8 @@ func Load(ctx context.Context, p string, runtimeConfig config.RuntimeConfig, opt
 		}
 	}
 
-	fileName := filepath.Base(p)
-	parentDir := filepath.Dir(p)
+	fileName := source.Name()
+	parentDir := source.ParentDir()
 
 	// Make env file paths absolute relative to the agent config file.
 	var err error
@@ -127,12 +134,12 @@ func Load(ctx context.Context, p string, runtimeConfig config.RuntimeConfig, opt
 	env := environment.NewMultiProvider(envFilesProviders, defaultEnvProvider)
 
 	// Load the agent's configuration
-	fs, err := os.OpenRoot(parentDir)
+	data, err := source.Read()
 	if err != nil {
-		return nil, fmt.Errorf("opening filesystem %s: %w", parentDir, err)
+		return nil, fmt.Errorf("reading config file: %w", err)
 	}
 
-	cfg, err := config.LoadConfig(fileName, fs)
+	cfg, err := config.LoadConfigBytes(data)
 	if err != nil {
 		return nil, err
 	}