cli: properly resolve composer version from local tree (#311)

Fixes #304

When running local extensions, if the extension manifest does not
contain the version (local composer extension), try to find the parent
in the tree before falling back to the embedded manifest versions. This
will allow older versions of the CLI to work properly with commands like
`boe run --local extensions/composer/waf` and properly resolve the
versions from the local tree.

cc @sjoukedv

---------

Signed-off-by: Ignasi Barrera <ignasi@tetrate.io>

Author: nacx

cli/cmd/run.go

@@ -229,8 +229,8 @@ func downloadExtensions(ctx context.Context, downloader *extensions.Downloader,
 						name, extensionSrc, err)
 				}
 				manifest.Remote = true // Mark the manifest as remote since it is from a downloaded artifact
-				// The LoadLocalmanifest resolves "parent" the versions from the embedded manifests, but here, after downloading the source
-				// we want to force the version to the ones form the downloaded artifact.
+				// Composer source artifacts contains manifests without version information (just the parent reference).
+				// We need to set the versions here.
 				manifest.Version = artifact.Manifest.Version
 				manifest.ComposerVersion = artifact.Manifest.ComposerVersion
 
@@ -330,6 +330,10 @@ func loadLocalManifests(ctx context.Context, logger *slog.Logger, downloader *ex
 			return nil, fmt.Errorf("%w from %s: %w", errFailedToLoadLocalManifest, path, err)
 		}
 
+		if err := extensions.ResolveLocalVersions(manifest); err != nil {
+			return nil, fmt.Errorf("%w from %s: %w", errFailedToLoadLocalManifest, path, err)
+		}
+
 		if build {
 			switch manifest.Type {
 			case extensions.TypeGo:

cli/internal/extensions/manifest.go

@@ -287,12 +287,57 @@ func LoadLocalManifest(path string) (*Manifest, error) {
 		return nil, err
 	}
 	m.Path = path
-	if err = resolveVersions(m, Manifests); err != nil {
-		return nil, err
-	}
 	return m, nil
 }
 
+// ResolveLocalVersions resolves version fields for a local manifest that has a parent.
+// It first tries to find the parent manifest on the local filesystem by walking up the
+// directory tree from the manifest's path. If not found locally, it falls back to the
+// embedded manifests.
+func ResolveLocalVersions(m *Manifest) error {
+	if m.Type != TypeGo || m.Parent == "" {
+		return nil
+	}
+
+	// Try to find the parent manifest on the local filesystem.
+	parent, err := findLocalParentManifest(m)
+	if err == nil {
+		return resolveVersions(m, map[string]*Manifest{parent.Name: parent})
+	}
+
+	// Fall back to the embedded manifests.
+	return resolveVersions(m, Manifests)
+}
+
+// findLocalParentManifest walks up the directory tree from the manifest's path
+// looking for a manifest.yaml whose name matches the parent field.
+func findLocalParentManifest(m *Manifest) (*Manifest, error) {
+	// Start from the directory containing the child manifest and walk up.
+	dir := filepath.Dir(m.Path)
+	for {
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			// Reached filesystem root without finding the parent.
+			return nil, fmt.Errorf("%w: %s", ErrParentManifestNotFound, m.Parent)
+		}
+		dir = parent
+
+		candidate := filepath.Join(dir, "manifest.yaml")
+		if _, err := os.Stat(candidate); err != nil {
+			continue
+		}
+
+		// Load without validation since the parent may have a different type (e.g. composer).
+		cm, err := loadManifest(os.DirFS(dir), "manifest.yaml", false)
+		if err != nil {
+			continue
+		}
+		if cm.Name == m.Parent {
+			return cm, nil
+		}
+	}
+}
+
 // ValidateManifest validates the manifest against the JSON schema.
 func ValidateManifest(manifest *Manifest) error {
 	// Convert manifest to JSON for schema validation

cli/internal/extensions/manifest_test.go

@@ -7,6 +7,7 @@ package extensions
 
 import (
 	"io/fs"
+	"os"
 	"path/filepath"
 	"testing"
 	"testing/fstest"
@@ -505,3 +506,80 @@ func TestLoadLocalManifest(t *testing.T) {
 		require.ErrorIs(t, err, ErrParseManifestFile)
 	})
 }
+
+func TestResolveLocalVersions(t *testing.T) {
+	t.Run("local-parent-found", func(t *testing.T) {
+		// Create a directory structure: parent/child/manifest.yaml
+		tmpDir := t.TempDir()
+		parentDir := tmpDir
+		childDir := filepath.Join(tmpDir, "child")
+		require.NoError(t, os.MkdirAll(childDir, 0o750))
+
+		parentManifest := `name: test-parent
+version: 9.9.9
+composerVersion: 9.9.9
+minEnvoyVersion: 1.99.0
+type: composer
+extensionSet: true
+`
+		childManifest := `name: test-child
+parent: test-parent
+categories: [Misc]
+author: Test
+description: A child extension
+longDescription: A child extension
+type: go
+tags: [test]
+license: Apache-2.0
+examples: []
+`
+		require.NoError(t, os.WriteFile(filepath.Join(parentDir, "manifest.yaml"), []byte(parentManifest), 0o600))
+		require.NoError(t, os.WriteFile(filepath.Join(childDir, "manifest.yaml"), []byte(childManifest), 0o600))
+
+		m, err := LoadLocalManifest(filepath.Join(childDir, "manifest.yaml"))
+		require.NoError(t, err)
+		require.Empty(t, m.Version)
+
+		require.NoError(t, ResolveLocalVersions(m))
+		assert.Equal(t, "9.9.9", m.Version)
+		assert.Equal(t, "9.9.9", m.ComposerVersion)
+		assert.Equal(t, "1.99.0", m.MinEnvoyVersion)
+	})
+
+	t.Run("no-local-parent-falls-back-to-embedded", func(t *testing.T) {
+		// Create a child manifest in an isolated temp dir (no parent on filesystem).
+		tmpDir := t.TempDir()
+		childManifest := `name: test-child
+parent: composer
+categories: [Misc]
+author: Test
+description: A child extension
+longDescription: A child extension
+type: go
+tags: [test]
+license: Apache-2.0
+examples: []
+`
+		require.NoError(t, os.WriteFile(filepath.Join(tmpDir, "manifest.yaml"), []byte(childManifest), 0o600))
+
+		m, err := LoadLocalManifest(filepath.Join(tmpDir, "manifest.yaml"))
+		require.NoError(t, err)
+
+		// Should fall back to embedded manifests (composer exists in embedded).
+		require.NoError(t, ResolveLocalVersions(m))
+		assert.Equal(t, Manifests["composer"].Version, m.Version)
+		assert.Equal(t, Manifests["composer"].Version, m.ComposerVersion)
+	})
+
+	t.Run("noop-for-non-go-type", func(t *testing.T) {
+		m := &Manifest{Name: "test", Type: TypeWasm, Version: "1.0.0"}
+		require.NoError(t, ResolveLocalVersions(m))
+		assert.Equal(t, "1.0.0", m.Version)
+	})
+
+	t.Run("noop-for-no-parent", func(t *testing.T) {
+		m := &Manifest{Name: "test", Type: TypeGo, Version: "1.0.0"}
+		require.NoError(t, ResolveLocalVersions(m))
+		assert.Equal(t, "1.0.0", m.Version)
+	})
+}