Merge pull request #502 from docker/version/endpoint

feat(api): add daemon version endpoint client and version comparison

Author: Benehiko

client/client.go

@@ -25,16 +25,19 @@ import (
 	"connectrpc.com/connect"
 
 	"github.com/docker/secrets-engine/x/api"
+	healthv1 "github.com/docker/secrets-engine/x/api/health/v1"
+	"github.com/docker/secrets-engine/x/api/health/v1/healthv1connect"
 	"github.com/docker/secrets-engine/x/api/resolver"
 	v1 "github.com/docker/secrets-engine/x/api/resolver/v1"
 	"github.com/docker/secrets-engine/x/api/resolver/v1/resolverv1connect"
 	"github.com/docker/secrets-engine/x/secrets"
 )
 
 type (
-	Envelope = secrets.Envelope
-	ID       = secrets.ID
-	Pattern  = secrets.Pattern
+	Envelope      = secrets.Envelope
+	ID            = secrets.ID
+	Pattern       = secrets.Pattern
+	DaemonVersion = api.DaemonVersion
 )
 
 var (
@@ -120,6 +123,7 @@ type config struct {
 type client struct {
 	resolverClient secrets.Resolver
 	listClient     resolverv1connect.ListServiceClient
+	versionClient  healthv1connect.VersionServiceClient
 }
 
 func (c client) GetSecrets(ctx context.Context, pattern secrets.Pattern) ([]secrets.Envelope, error) {
@@ -133,9 +137,28 @@ func (c client) GetSecrets(ctx context.Context, pattern secrets.Pattern) ([]secr
 	return envelopes, nil
 }
 
+func (c client) Version(ctx context.Context) (DaemonVersion, error) {
+	resp, err := c.versionClient.GetVersion(ctx, connect.NewRequest(healthv1.GetVersionRequest_builder{}.Build()))
+	if isDialError(err) {
+		return DaemonVersion{}, fmt.Errorf("%w: %w", ErrSecretsEngineNotAvailable, err)
+	}
+	if err != nil {
+		return DaemonVersion{}, err
+	}
+	ver, err := api.NewVersion(resp.Msg.GetVersion())
+	if err != nil {
+		return DaemonVersion{}, fmt.Errorf("parsing daemon version %q: %w", resp.Msg.GetVersion(), err)
+	}
+	return DaemonVersion{Version: ver, Date: resp.Msg.GetDate(), CommitHash: resp.Msg.GetCommitHash()}, nil
+}
+
+// Client is the interface for interacting with the secrets engine daemon.
 type Client interface {
 	secrets.Resolver
 
+	// Version returns the name and version reported by the daemon.
+	Version(ctx context.Context) (DaemonVersion, error)
+
 	ListPlugins(ctx context.Context) ([]PluginInfo, error)
 }
 
@@ -187,6 +210,7 @@ func New(options ...Option) (Client, error) {
 	return &client{
 		resolverClient: resolver.NewResolverClient(c),
 		listClient:     resolverv1connect.NewListServiceClient(c, "http://unix"),
+		versionClient:  healthv1connect.NewVersionServiceClient(c, "http://unix"),
 	}, nil
 }
 

client/client_test.go

@@ -29,12 +29,37 @@ import (
 	"google.golang.org/protobuf/proto"
 
 	"github.com/docker/secrets-engine/x/api"
+	healthv1 "github.com/docker/secrets-engine/x/api/health/v1"
+	"github.com/docker/secrets-engine/x/api/health/v1/healthv1connect"
 	resolverv1 "github.com/docker/secrets-engine/x/api/resolver/v1"
 	"github.com/docker/secrets-engine/x/api/resolver/v1/resolverv1connect"
 	"github.com/docker/secrets-engine/x/secrets"
 	"github.com/docker/secrets-engine/x/testhelper"
 )
 
+var _ healthv1connect.VersionServiceHandler = &mockVersionService{}
+
+type mockVersionService struct {
+	version    string
+	date       string
+	commitHash string
+}
+
+func (m mockVersionService) GetVersion(_ context.Context, _ *connect.Request[healthv1.GetVersionRequest]) (*connect.Response[healthv1.GetVersionResponse], error) {
+	return connect.NewResponse(healthv1.GetVersionResponse_builder{
+		Version:    proto.String(m.version),
+		Date:       proto.String(m.date),
+		CommitHash: proto.String(m.commitHash),
+	}.Build()), nil
+}
+
+func mockVersionEngine(t *testing.T, version, date, commitHash string) string {
+	t.Helper()
+	socketPath := testhelper.RandomShortSocketName()
+	muxServer(t, socketPath, []handler{wrapHandler(healthv1connect.NewVersionServiceHandler(&mockVersionService{version: version, date: date, commitHash: commitHash}))})
+	return socketPath
+}
+
 var _ resolverv1connect.ListServiceHandler = &mockPluginsList{}
 
 type mockPluginsList struct {
@@ -169,6 +194,27 @@ func Test_ListPlugins(t *testing.T) {
 	})
 }
 
+func Test_Version(t *testing.T) {
+	t.Parallel()
+	t.Run("returns version info", func(t *testing.T) {
+		socket := mockVersionEngine(t, "v1.2.3", "2026-03-26", "abc1234")
+		c, err := New(WithSocketPath(socket))
+		require.NoError(t, err)
+		dv, err := c.Version(t.Context())
+		require.NoError(t, err)
+		assert.Equal(t, "v1.2.3", dv.Version.String())
+		assert.Equal(t, "2026-03-26", dv.Date)
+		assert.Equal(t, "abc1234", dv.CommitHash)
+	})
+	t.Run("unavailable daemon", func(t *testing.T) {
+		socketPath := testhelper.RandomShortSocketName()
+		c, err := New(WithSocketPath(socketPath))
+		require.NoError(t, err)
+		_, err = c.Version(t.Context())
+		require.ErrorIs(t, err, ErrSecretsEngineNotAvailable)
+	})
+}
+
 func TestSecretsEngineUnavailable(t *testing.T) {
 	socketPath := testhelper.RandomShortSocketName()
 	client, err := New(WithSocketPath(socketPath))

scripts/copy-only-diff

@@ -21,9 +21,17 @@ if [ ! -d .git ]; then
     exit 1
 fi
 
-if ! git diff --quiet; then
+modified=$(git diff --name-only --diff-filter=d)
+untracked=$(git ls-files --others --exclude-standard)
+
+if [ -n "$modified" ] || [ -n "$untracked" ]; then
     echo "Detected modified files:"
-    git diff --name-only | xargs -I{} cp --parents {} "$1"
+    if [ -n "$modified" ]; then
+        echo "$modified" | xargs -I{} cp --parents {} "$1"
+    fi
+    if [ -n "$untracked" ]; then
+        echo "$untracked" | xargs -I{} cp --parents {} "$1"
+    fi
 else
     echo "No changes detected"
 fi

x/api/daemon.go

@@ -0,0 +1,22 @@
+// Copyright 2025-2026 Docker, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package api
+
+// DaemonVersion holds version information reported by the daemon.
+type DaemonVersion struct {
+	Version    Version
+	Date       string
+	CommitHash string
+}