diff --git a/provider/internal/mockcli_test.go b/provider/internal/mockcli_test.go
new file mode 100644
index 0000000..4293b99
--- /dev/null
+++ b/provider/internal/mockcli_test.go
@@ -0,0 +1,737 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: cli.go
+//
+// Generated by this command:
+//
+//	mockgen -typed -package internal -source cli.go -destination mockcli_test.go --self_package github.com/pulumi/pulumi-docker-build/provider/internal
+//
+// Package internal is a generated GoMock package.
+package internal
+
+import (
+	io "io"
+	reflect "reflect"
+
+	command "github.com/docker/cli/cli/command"
+	configfile "github.com/docker/cli/cli/config/configfile"
+	docker "github.com/docker/cli/cli/context/docker"
+	store "github.com/docker/cli/cli/context/store"
+	store0 "github.com/docker/cli/cli/manifest/store"
+	client "github.com/docker/cli/cli/registry/client"
+	streams "github.com/docker/cli/cli/streams"
+	trust "github.com/docker/cli/cli/trust"
+	client0 "github.com/docker/docker/client"
+	client1 "github.com/theupdateframework/notary/client"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockCli is a mock of Cli interface.
+type MockCli struct {
+	ctrl     *gomock.Controller
+	recorder *MockCliMockRecorder
+}
+
+// MockCliMockRecorder is the mock recorder for MockCli.
+type MockCliMockRecorder struct {
+	mock *MockCli
+}
+
+// NewMockCli creates a new mock instance.
+func NewMockCli(ctrl *gomock.Controller) *MockCli {
+	mock := &MockCli{ctrl: ctrl}
+	mock.recorder = &MockCliMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCli) EXPECT() *MockCliMockRecorder {
+	return m.recorder
+}
+
+// Apply mocks base method.
+func (m *MockCli) Apply(ops ...command.CLIOption) error {
+	m.ctrl.T.Helper()
+	varargs := []any{}
+	for _, a := range ops {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Apply", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Apply indicates an expected call of Apply.
+func (mr *MockCliMockRecorder) Apply(ops ...any) *CliApplyCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Apply", reflect.TypeOf((*MockCli)(nil).Apply), ops...)
+	return &CliApplyCall{Call: call}
+}
+
+// CliApplyCall wrap *gomock.Call
+type CliApplyCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliApplyCall) Return(arg0 error) *CliApplyCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliApplyCall) Do(f func(...command.CLIOption) error) *CliApplyCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliApplyCall) DoAndReturn(f func(...command.CLIOption) error) *CliApplyCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// BuildKitEnabled mocks base method.
+func (m *MockCli) BuildKitEnabled() (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BuildKitEnabled")
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BuildKitEnabled indicates an expected call of BuildKitEnabled.
+func (mr *MockCliMockRecorder) BuildKitEnabled() *CliBuildKitEnabledCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildKitEnabled", reflect.TypeOf((*MockCli)(nil).BuildKitEnabled))
+	return &CliBuildKitEnabledCall{Call: call}
+}
+
+// CliBuildKitEnabledCall wrap *gomock.Call
+type CliBuildKitEnabledCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliBuildKitEnabledCall) Return(arg0 bool, arg1 error) *CliBuildKitEnabledCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliBuildKitEnabledCall) Do(f func() (bool, error)) *CliBuildKitEnabledCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliBuildKitEnabledCall) DoAndReturn(f func() (bool, error)) *CliBuildKitEnabledCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Client mocks base method.
+func (m *MockCli) Client() client0.APIClient {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Client")
+	ret0, _ := ret[0].(client0.APIClient)
+	return ret0
+}
+
+// Client indicates an expected call of Client.
+func (mr *MockCliMockRecorder) Client() *CliClientCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Client", reflect.TypeOf((*MockCli)(nil).Client))
+	return &CliClientCall{Call: call}
+}
+
+// CliClientCall wrap *gomock.Call
+type CliClientCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliClientCall) Return(arg0 client0.APIClient) *CliClientCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliClientCall) Do(f func() client0.APIClient) *CliClientCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliClientCall) DoAndReturn(f func() client0.APIClient) *CliClientCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// ConfigFile mocks base method.
+func (m *MockCli) ConfigFile() *configfile.ConfigFile {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConfigFile")
+	ret0, _ := ret[0].(*configfile.ConfigFile)
+	return ret0
+}
+
+// ConfigFile indicates an expected call of ConfigFile.
+func (mr *MockCliMockRecorder) ConfigFile() *CliConfigFileCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigFile", reflect.TypeOf((*MockCli)(nil).ConfigFile))
+	return &CliConfigFileCall{Call: call}
+}
+
+// CliConfigFileCall wrap *gomock.Call
+type CliConfigFileCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliConfigFileCall) Return(arg0 *configfile.ConfigFile) *CliConfigFileCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliConfigFileCall) Do(f func() *configfile.ConfigFile) *CliConfigFileCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliConfigFileCall) DoAndReturn(f func() *configfile.ConfigFile) *CliConfigFileCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// ContentTrustEnabled mocks base method.
+func (m *MockCli) ContentTrustEnabled() bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContentTrustEnabled")
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// ContentTrustEnabled indicates an expected call of ContentTrustEnabled.
+func (mr *MockCliMockRecorder) ContentTrustEnabled() *CliContentTrustEnabledCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContentTrustEnabled", reflect.TypeOf((*MockCli)(nil).ContentTrustEnabled))
+	return &CliContentTrustEnabledCall{Call: call}
+}
+
+// CliContentTrustEnabledCall wrap *gomock.Call
+type CliContentTrustEnabledCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliContentTrustEnabledCall) Return(arg0 bool) *CliContentTrustEnabledCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliContentTrustEnabledCall) Do(f func() bool) *CliContentTrustEnabledCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliContentTrustEnabledCall) DoAndReturn(f func() bool) *CliContentTrustEnabledCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// ContextStore mocks base method.
+func (m *MockCli) ContextStore() store.Store {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ContextStore")
+	ret0, _ := ret[0].(store.Store)
+	return ret0
+}
+
+// ContextStore indicates an expected call of ContextStore.
+func (mr *MockCliMockRecorder) ContextStore() *CliContextStoreCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContextStore", reflect.TypeOf((*MockCli)(nil).ContextStore))
+	return &CliContextStoreCall{Call: call}
+}
+
+// CliContextStoreCall wrap *gomock.Call
+type CliContextStoreCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliContextStoreCall) Return(arg0 store.Store) *CliContextStoreCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliContextStoreCall) Do(f func() store.Store) *CliContextStoreCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliContextStoreCall) DoAndReturn(f func() store.Store) *CliContextStoreCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// CurrentContext mocks base method.
+func (m *MockCli) CurrentContext() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CurrentContext")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// CurrentContext indicates an expected call of CurrentContext.
+func (mr *MockCliMockRecorder) CurrentContext() *CliCurrentContextCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentContext", reflect.TypeOf((*MockCli)(nil).CurrentContext))
+	return &CliCurrentContextCall{Call: call}
+}
+
+// CliCurrentContextCall wrap *gomock.Call
+type CliCurrentContextCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliCurrentContextCall) Return(arg0 string) *CliCurrentContextCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliCurrentContextCall) Do(f func() string) *CliCurrentContextCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliCurrentContextCall) DoAndReturn(f func() string) *CliCurrentContextCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// CurrentVersion mocks base method.
+func (m *MockCli) CurrentVersion() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CurrentVersion")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// CurrentVersion indicates an expected call of CurrentVersion.
+func (mr *MockCliMockRecorder) CurrentVersion() *CliCurrentVersionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentVersion", reflect.TypeOf((*MockCli)(nil).CurrentVersion))
+	return &CliCurrentVersionCall{Call: call}
+}
+
+// CliCurrentVersionCall wrap *gomock.Call
+type CliCurrentVersionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliCurrentVersionCall) Return(arg0 string) *CliCurrentVersionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliCurrentVersionCall) Do(f func() string) *CliCurrentVersionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliCurrentVersionCall) DoAndReturn(f func() string) *CliCurrentVersionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// DefaultVersion mocks base method.
+func (m *MockCli) DefaultVersion() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DefaultVersion")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// DefaultVersion indicates an expected call of DefaultVersion.
+func (mr *MockCliMockRecorder) DefaultVersion() *CliDefaultVersionCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultVersion", reflect.TypeOf((*MockCli)(nil).DefaultVersion))
+	return &CliDefaultVersionCall{Call: call}
+}
+
+// CliDefaultVersionCall wrap *gomock.Call
+type CliDefaultVersionCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliDefaultVersionCall) Return(arg0 string) *CliDefaultVersionCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliDefaultVersionCall) Do(f func() string) *CliDefaultVersionCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliDefaultVersionCall) DoAndReturn(f func() string) *CliDefaultVersionCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// DockerEndpoint mocks base method.
+func (m *MockCli) DockerEndpoint() docker.Endpoint {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DockerEndpoint")
+	ret0, _ := ret[0].(docker.Endpoint)
+	return ret0
+}
+
+// DockerEndpoint indicates an expected call of DockerEndpoint.
+func (mr *MockCliMockRecorder) DockerEndpoint() *CliDockerEndpointCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DockerEndpoint", reflect.TypeOf((*MockCli)(nil).DockerEndpoint))
+	return &CliDockerEndpointCall{Call: call}
+}
+
+// CliDockerEndpointCall wrap *gomock.Call
+type CliDockerEndpointCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliDockerEndpointCall) Return(arg0 docker.Endpoint) *CliDockerEndpointCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliDockerEndpointCall) Do(f func() docker.Endpoint) *CliDockerEndpointCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliDockerEndpointCall) DoAndReturn(f func() docker.Endpoint) *CliDockerEndpointCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Err mocks base method.
+func (m *MockCli) Err() io.Writer {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Err")
+	ret0, _ := ret[0].(io.Writer)
+	return ret0
+}
+
+// Err indicates an expected call of Err.
+func (mr *MockCliMockRecorder) Err() *CliErrCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Err", reflect.TypeOf((*MockCli)(nil).Err))
+	return &CliErrCall{Call: call}
+}
+
+// CliErrCall wrap *gomock.Call
+type CliErrCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliErrCall) Return(arg0 io.Writer) *CliErrCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliErrCall) Do(f func() io.Writer) *CliErrCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliErrCall) DoAndReturn(f func() io.Writer) *CliErrCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// In mocks base method.
+func (m *MockCli) In() *streams.In {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "In")
+	ret0, _ := ret[0].(*streams.In)
+	return ret0
+}
+
+// In indicates an expected call of In.
+func (mr *MockCliMockRecorder) In() *CliInCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "In", reflect.TypeOf((*MockCli)(nil).In))
+	return &CliInCall{Call: call}
+}
+
+// CliInCall wrap *gomock.Call
+type CliInCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliInCall) Return(arg0 *streams.In) *CliInCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliInCall) Do(f func() *streams.In) *CliInCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliInCall) DoAndReturn(f func() *streams.In) *CliInCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// ManifestStore mocks base method.
+func (m *MockCli) ManifestStore() store0.Store {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ManifestStore")
+	ret0, _ := ret[0].(store0.Store)
+	return ret0
+}
+
+// ManifestStore indicates an expected call of ManifestStore.
+func (mr *MockCliMockRecorder) ManifestStore() *CliManifestStoreCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManifestStore", reflect.TypeOf((*MockCli)(nil).ManifestStore))
+	return &CliManifestStoreCall{Call: call}
+}
+
+// CliManifestStoreCall wrap *gomock.Call
+type CliManifestStoreCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliManifestStoreCall) Return(arg0 store0.Store) *CliManifestStoreCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliManifestStoreCall) Do(f func() store0.Store) *CliManifestStoreCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliManifestStoreCall) DoAndReturn(f func() store0.Store) *CliManifestStoreCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// NotaryClient mocks base method.
+func (m *MockCli) NotaryClient(imgRefAndAuth trust.ImageRefAndAuth, actions []string) (client1.Repository, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NotaryClient", imgRefAndAuth, actions)
+	ret0, _ := ret[0].(client1.Repository)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NotaryClient indicates an expected call of NotaryClient.
+func (mr *MockCliMockRecorder) NotaryClient(imgRefAndAuth, actions any) *CliNotaryClientCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotaryClient", reflect.TypeOf((*MockCli)(nil).NotaryClient), imgRefAndAuth, actions)
+	return &CliNotaryClientCall{Call: call}
+}
+
+// CliNotaryClientCall wrap *gomock.Call
+type CliNotaryClientCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliNotaryClientCall) Return(arg0 client1.Repository, arg1 error) *CliNotaryClientCall {
+	c.Call = c.Call.Return(arg0, arg1)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliNotaryClientCall) Do(f func(trust.ImageRefAndAuth, []string) (client1.Repository, error)) *CliNotaryClientCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliNotaryClientCall) DoAndReturn(f func(trust.ImageRefAndAuth, []string) (client1.Repository, error)) *CliNotaryClientCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// Out mocks base method.
+func (m *MockCli) Out() *streams.Out {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Out")
+	ret0, _ := ret[0].(*streams.Out)
+	return ret0
+}
+
+// Out indicates an expected call of Out.
+func (mr *MockCliMockRecorder) Out() *CliOutCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Out", reflect.TypeOf((*MockCli)(nil).Out))
+	return &CliOutCall{Call: call}
+}
+
+// CliOutCall wrap *gomock.Call
+type CliOutCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliOutCall) Return(arg0 *streams.Out) *CliOutCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliOutCall) Do(f func() *streams.Out) *CliOutCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliOutCall) DoAndReturn(f func() *streams.Out) *CliOutCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// RegistryClient mocks base method.
+func (m *MockCli) RegistryClient(arg0 bool) client.RegistryClient {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RegistryClient", arg0)
+	ret0, _ := ret[0].(client.RegistryClient)
+	return ret0
+}
+
+// RegistryClient indicates an expected call of RegistryClient.
+func (mr *MockCliMockRecorder) RegistryClient(arg0 any) *CliRegistryClientCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegistryClient", reflect.TypeOf((*MockCli)(nil).RegistryClient), arg0)
+	return &CliRegistryClientCall{Call: call}
+}
+
+// CliRegistryClientCall wrap *gomock.Call
+type CliRegistryClientCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliRegistryClientCall) Return(arg0 client.RegistryClient) *CliRegistryClientCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliRegistryClientCall) Do(f func(bool) client.RegistryClient) *CliRegistryClientCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliRegistryClientCall) DoAndReturn(f func(bool) client.RegistryClient) *CliRegistryClientCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// ServerInfo mocks base method.
+func (m *MockCli) ServerInfo() command.ServerInfo {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ServerInfo")
+	ret0, _ := ret[0].(command.ServerInfo)
+	return ret0
+}
+
+// ServerInfo indicates an expected call of ServerInfo.
+func (mr *MockCliMockRecorder) ServerInfo() *CliServerInfoCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerInfo", reflect.TypeOf((*MockCli)(nil).ServerInfo))
+	return &CliServerInfoCall{Call: call}
+}
+
+// CliServerInfoCall wrap *gomock.Call
+type CliServerInfoCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliServerInfoCall) Return(arg0 command.ServerInfo) *CliServerInfoCall {
+	c.Call = c.Call.Return(arg0)
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliServerInfoCall) Do(f func() command.ServerInfo) *CliServerInfoCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliServerInfoCall) DoAndReturn(f func() command.ServerInfo) *CliServerInfoCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}
+
+// SetIn mocks base method.
+func (m *MockCli) SetIn(in *streams.In) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "SetIn", in)
+}
+
+// SetIn indicates an expected call of SetIn.
+func (mr *MockCliMockRecorder) SetIn(in any) *CliSetInCall {
+	mr.mock.ctrl.T.Helper()
+	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIn", reflect.TypeOf((*MockCli)(nil).SetIn), in)
+	return &CliSetInCall{Call: call}
+}
+
+// CliSetInCall wrap *gomock.Call
+type CliSetInCall struct {
+	*gomock.Call
+}
+
+// Return rewrite *gomock.Call.Return
+func (c *CliSetInCall) Return() *CliSetInCall {
+	c.Call = c.Call.Return()
+	return c
+}
+
+// Do rewrite *gomock.Call.Do
+func (c *CliSetInCall) Do(f func(*streams.In)) *CliSetInCall {
+	c.Call = c.Call.Do(f)
+	return c
+}
+
+// DoAndReturn rewrite *gomock.Call.DoAndReturn
+func (c *CliSetInCall) DoAndReturn(f func(*streams.In)) *CliSetInCall {
+	c.Call = c.Call.DoAndReturn(f)
+	return c
+}