diff --git a/apps/artemis/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/artemis/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100755
index af1af5a..0000000
--- a/apps/artemis/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<!--
-  ~ Copyright 2015 Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/cfm/nbi/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/cfm/nbi/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index fcd66a0..0000000
--- a/apps/cfm/nbi/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,88 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.cfm.cli.CfmMdAddCommand"/>
-            <completers>
-                <ref component-id="mdNameTypeCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <ref component-id="mdLevelCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cfm.cli.CfmMdDeleteCommand"/>
-            <completers>
-                <ref component-id="mdNameCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cfm.cli.CfmMdListMdCommand"/>
-            <completers>
-                <ref component-id="mdNameCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cfm.cli.CfmMaAddCommand"/>
-            <completers>
-                <ref component-id="mdNameCompleter"/>
-                <ref component-id="maNameTypeCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <ref component-id="maCcmIntervalCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <ref component-id="compTagTypeCompleter"/>
-                <ref component-id="compMhfCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cfm.cli.CfmMaDeleteCommand"/>
-            <completers>
-                <ref component-id="maNameCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cfm.cli.CfmMepListCommand"/>
-            <completers>
-                <ref component-id="mepIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cfm.cli.CfmMepListDeviceCommand"/>
-            <completers>
-                <ref component-id="mepDeviceIdCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="placeholderCompleter" class="org.onosproject.cli.PlaceholderCompleter"/>
-    <bean id="mdNameTypeCompleter" class="org.onosproject.cfm.cli.completer.CfmMdNameTypeCompleter"/>
-    <bean id="maNameTypeCompleter" class="org.onosproject.cfm.cli.completer.CfmMaNameTypeCompleter"/>
-    <bean id="mdNameCompleter" class="org.onosproject.cfm.cli.completer.CfmMdNameCompleter"/>
-    <bean id="maNameCompleter" class="org.onosproject.cfm.cli.completer.CfmMaNameCompleter"/>
-    <bean id="mdLevelCompleter" class="org.onosproject.cfm.cli.completer.CfmMdLevelCompleter"/>
-    <bean id="maCcmIntervalCompleter" class="org.onosproject.cfm.cli.completer.CfmMaCcmIntervalCompleter"/>
-    <bean id="compTagTypeCompleter" class="org.onosproject.cfm.cli.completer.CfmCompTagTypeCompleter"/>
-    <bean id="compMhfCompleter" class="org.onosproject.cfm.cli.completer.CfmCompMhfCompleter"/>
-    <bean id="mepIdCompleter" class="org.onosproject.cfm.cli.completer.CfmMepIdCompleter"/>
-    <bean id="mepDeviceIdCompleter" class="org.onosproject.cfm.cli.completer.CfmDeviceIdCompleter"/>
-
-</blueprint>
-
-
diff --git a/apps/cpman/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/cpman/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 592b69e..0000000
--- a/apps/cpman/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.cpman.cli.ControlMetricsStatsListCommand"/>
-            <completers>
-                <ref component-id="nodeIdCompleter"/>
-                <ref component-id="controlResourceTypeCompleter"/>
-                <ref component-id="resourceNameCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="nodeIdCompleter" class="org.onosproject.cli.NodeIdCompleter"/>
-    <bean id="controlResourceTypeCompleter" class="org.onosproject.cpman.cli.ControlResourceTypeCompleter"/>
-    <bean id="resourceNameCompleter" class="org.onosproject.cpman.cli.ResourceNameCompleter"/>
-</blueprint>
\ No newline at end of file
diff --git a/apps/dhcp/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/dhcp/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index e93d2a2..0000000
--- a/apps/dhcp/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.dhcp.cli.DhcpListAllMappings"/>
-        </command>
-        <command>
-            <action class="org.onosproject.dhcp.cli.DhcpLeaseDetails"/>
-        </command>
-        <command>
-            <action class="org.onosproject.dhcp.cli.DhcpSetStaticMapping"/>
-            <completers>
-                <ref component-id="macIDCompleter"/>
-                <ref component-id="freeIPCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.dhcp.cli.DhcpRemoveStaticMapping"/>
-            <completers>
-                <ref component-id="macIDCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="macIDCompleter" class="org.onosproject.dhcp.cli.MacIdCompleter"/>
-    <bean id="freeIPCompleter" class="org.onosproject.dhcp.cli.FreeIpCompleter"/>
-
-</blueprint>
\ No newline at end of file
diff --git a/apps/dhcprelay/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/dhcprelay/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index c0a4b6f..0000000
--- a/apps/dhcprelay/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<!--
-  ~ Copyright 2014-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.dhcprelay.cli.DhcpRelayCommand"/>
-            <completers>
-                <ref component-id="dhcpRelayCounterCompleter"/>
-                <ref component-id="dhcpRelayResetCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.dhcprelay.cli.DhcpFpmRoutesCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.dhcprelay.cli.DhcpFpmAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.dhcprelay.cli.DhcpFpmDeleteCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.dhcprelay.cli.DhcpRelayAggCountersCommand"/>
-            <completers>
-                <ref component-id="dhcpRelayResetCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-    <bean id="dhcpRelayCounterCompleter" class="org.onosproject.dhcprelay.cli.DhcpRelayCounterCompleter"/>
-    <bean id="dhcpRelayResetCompleter" class="org.onosproject.dhcprelay.cli.DhcpRelayResetCompleter"/>
-</blueprint>
diff --git a/apps/events/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/events/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 2a6a46e..0000000
--- a/apps/events/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.events.EventsCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/evpnopenflow/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/evpnopenflow/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index fcc09bf..0000000
--- a/apps/evpnopenflow/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.evpnopenflow.rsc.cli.EvpnPublicRouteListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.evpnopenflow.rsc.cli.EvpnPrivateRouteListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.evpnopenflow.rsc.cli.VpnPortListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.evpnopenflow.rsc.cli.VpnInstListCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/faultmanagement/fmcli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/faultmanagement/fmcli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index f9aad59..0000000
--- a/apps/faultmanagement/fmcli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,61 +0,0 @@
-<!--
-~ Copyright 2015-present Open Networking Foundation
-~
-~ 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.
--->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.faultmanagement.alarms.cli.GetAllAlarms"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.faultmanagement.alarms.cli.GetAllAlarmsCounts"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.faultmanagement.alarms.cli.CreateAlarm"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="alarmSeverityCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.faultmanagement.alarms.cli.UpdateAlarm"/>
-            <completers>
-                <ref component-id="alarmIdCompleter"/>
-                <ref component-id="alarmFieldCompleter"/>
-                <ref component-id="alarmFieldValueCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.faultmanagement.alarms.cli.RemoveAlarm"/>
-            <completers>
-                <ref component-id="alarmIdCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-    <bean id="alarmIdCompleter" class="org.onosproject.faultmanagement.alarms.cli.completer.AlarmIdCompleter"/>
-    <bean id="alarmSeverityCompleter" class="org.onosproject.faultmanagement.alarms.cli.completer.AlarmSeverityCompleter"/>
-    <bean id="alarmFieldCompleter" class="org.onosproject.faultmanagement.alarms.cli.completer.AlarmFieldCompleter"/>
-    <bean id="alarmFieldValueCompleter" class="org.onosproject.faultmanagement.alarms.cli.completer.AlarmFieldValueCompleter"/>
-
-</blueprint>
diff --git a/apps/flowanalyzer/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/flowanalyzer/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index d14ebbe..0000000
--- a/apps/flowanalyzer/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.flowanalyzer.FlowAnalysisCommand"/>
-        </command>
-
-    </command-bundle>
-</blueprint>
diff --git a/apps/fwd/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/fwd/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 482b04b..0000000
--- a/apps/fwd/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<!--
-+  ~ Copyright 2017-present Open Networking Foundation
-+  ~
-+  ~ 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.
-+  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.fwd.ReactiveForwardingCommand"/>
-            <completers>
-            <ref component-id="MacAddressCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-    <bean id="MacAddressCompleter" class="org.onosproject.fwd.MacAddressCompleter"/>
-</blueprint>
-
diff --git a/apps/gluon/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/gluon/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 82809d2..0000000
--- a/apps/gluon/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-  <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    <command>
-      <action class="org.onosproject.gluon.rsc.cli.GluonServerCommand"/>
-    </command>
-
-    <command>
-      <action class="org.onosproject.gluon.rsc.cli.GluonServerListCommand"/>
-    </command>
-  </command-bundle>
-</blueprint>
diff --git a/apps/imr/api/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/imr/api/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index fdddc88..0000000
--- a/apps/imr/api/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.imr.cli.StartMonitorCommand"/>
-            <completers>
-                <ref component-id="applicationIdCompleter"/>
-                <ref component-id="applicationNameCompleter"/>
-                <ref component-id="intentKeyImrCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.imr.cli.StopMonitorCommand"/>
-            <completers>
-                <ref component-id="applicationIdCompleter"/>
-                <ref component-id="applicationNameCompleter"/>
-                <ref component-id="intentKeyImrCompleter"/>
-            </completers>
-        </command>
-
-    </command-bundle>
-
-    <bean id="applicationIdCompleter" class="org.onosproject.imr.cli.ApplicationIdImrCompleter"/>
-    <bean id="applicationNameCompleter" class="org.onosproject.imr.cli.ApplicationNameImrCompleter"/>
-    <bean id="intentKeyImrCompleter" class="org.onosproject.imr.cli.IntentKeyImrCompleter"/>
-
-</blueprint>
diff --git a/apps/intentsync/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/intentsync/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 9564379..0000000
--- a/apps/intentsync/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-  <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    <command>
-      <action class="org.onosproject.intentsync.cli.PrimaryChangeCommand"/>
-    </command>
-  </command-bundle>
-</blueprint>
diff --git a/apps/layout/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/layout/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 6562fd5..0000000
--- a/apps/layout/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.layout.AutoLayoutCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
\ No newline at end of file
diff --git a/apps/mappingmanagement/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/mappingmanagement/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index bcf44d8..0000000
--- a/apps/mappingmanagement/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<!--
-~ Copyright 2017-present Open Networking Foundation
-~
-~ 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.
--->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.mapping.cli.MappingsListCommand"/>
-            <completers>
-                <ref component-id="mappingStoreTypeCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="deviceIdCompleter"
-          class="org.onosproject.cli.net.DeviceIdCompleter"/>
-    <bean id="mappingStoreTypeCompleter"
-          class="org.onosproject.mapping.cli.MappingStoreTypeCompleter"/>
-
-</blueprint>
\ No newline at end of file
diff --git a/apps/mcast/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/mcast/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 7bf0fcb..0000000
--- a/apps/mcast/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,59 +0,0 @@
-<!--
-~ Copyright 2018-present Open Networking Foundation
-~
-~ 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.
--->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.mcast.cli.McastHostJoinCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-                <entry key="-srcs" value-ref="hostIdCompleter"/>
-                <entry key="-sinks" value-ref="hostIdCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.mcast.cli.McastShowHostCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.mcast.cli.McastSinkDeleteCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-                <entry key="-cps" value-ref="connectpointCompleter"/>
-                <entry key="-s" value-ref="hostIdCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.mcast.cli.McastSourceDeleteCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-                <entry key="-src" value-ref="hostIdCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.mcast.cli.McastRoutesListCommand"/>
-        </command>
-    </command-bundle>
-
-    <bean id="hostIdCompleter" class="org.onosproject.cli.net.HostIdCompleter"/>
-    <bean id="connectpointCompleter" class="org.onosproject.cli.net.ConnectPointCompleter"/>
-    <bean id="mcastGroupCompleter" class="org.onosproject.mcast.cli.McastGroupCompleter"/>
-
-
-</blueprint>
diff --git a/apps/metrics/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/metrics/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 0b03a74..0000000
--- a/apps/metrics/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.metrics.intent.cli.IntentEventsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.metrics.intent.cli.IntentEventsMetricsCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.metrics.topology.cli.TopologyEventsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.metrics.topology.cli.TopologyEventsMetricsCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/network-troubleshoot/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/network-troubleshoot/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 4d1c429..0000000
--- a/apps/network-troubleshoot/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.fnl.cli.TsAllAnomalies" />
-        </command>
-        <command>
-            <action class="org.onosproject.fnl.cli.TsCheckLoop" />
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/newoptical/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/newoptical/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 6fdf112..0000000
--- a/apps/newoptical/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,47 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.newoptical.cli.AddOpticalConnectivityCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="connectPointCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.newoptical.cli.RemoveOpticalConnectivityCommand"/>
-            <completers>
-                <ref component-id="opticalConnectivityIdCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.newoptical.cli.ListOpticalConnectivityCommand"/>
-        </command>
-
-    </command-bundle>
-
-    <!-- TODO complete only applicable ports -->
-    <bean id="connectPointCompleter" class="org.onosproject.cli.net.ConnectPointCompleter"/>
-
-    <bean id="opticalConnectivityIdCompleter" class="org.onosproject.newoptical.cli.OpticalConnectivityIdCompleter"/>
-
-</blueprint>
diff --git a/apps/nodemetrics/mgr/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/nodemetrics/mgr/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 8bb1d69..0000000
--- a/apps/nodemetrics/mgr/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<!--
-  ~ /*
-  ~  * Copyright 2017-present Open Networking Foundation
-  ~  *
-  ~  * 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.
-  ~  */
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.nodemetrics.cli.ShowNodeCpuUsageCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.nodemetrics.cli.ShowNodeDiskUsageCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.nodemetrics.cli.ShowNodeMemoryCommand"/>
-        </command>
-    </command-bundle>
-
-
-</blueprint>
\ No newline at end of file
diff --git a/apps/odtn/service/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/odtn/service/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 953a71e..0000000
--- a/apps/odtn/service/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,47 +0,0 @@
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.odtn.cli.impl.OdtnManualTestCommand"/>
-            <completers>
-                <ref component-id="modeCompleter"/>
-                <null/>
-            </completers>
-            <optional-completers>
-                <entry key="--deviceId" value-ref="deviceIdCompleter"/>
-                <entry key="--cltPortNo" value-ref="portNumberCompleter"/>
-                <entry key="--linePortNo" value-ref="portNumberCompleter"/>
-            </optional-completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.odtn.cli.impl.OdtnDcsModelCheckCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.odtn.cli.impl.OdtnTapiHandlersTestCommand"/>
-        </command>
-
-    </command-bundle>
-
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-    <bean id="portNumberCompleter" class="org.onosproject.cli.net.PortNumberCompleter"/>
-    <bean id="modeCompleter" class="org.onosproject.odtn.cli.impl.ModeCompleter"/>
-
-</blueprint>
\ No newline at end of file
diff --git a/apps/ofagent/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/ofagent/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 8e4c23e..0000000
--- a/apps/ofagent/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<!--
-~ Copyright 2017-present Open Networking Foundation
-~
-~ 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.
--->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFAgentListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFAgentCreateCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFAgentRemoveCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFAgentStartCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFAgentStopCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFAgentAddControllerCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFAgentDeleteControllerCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ofagent.cli.OFSwitchListCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/openstacknetworking/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/openstacknetworking/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index f21a250..0000000
--- a/apps/openstacknetworking/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,122 +0,0 @@
-<!--
-~ Copyright 2017-present Open Networking Foundation
-~
-~ 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.
--->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackNetworkListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackSubnetListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackPortListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackDirectPortListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackRouterListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackFloatingIpListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackPurgeStateCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackSyncStateCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackSecurityGroupListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackPurgeRulesCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackSyncRulesCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.ExternalPeerRouterListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.UpdateExternalPeerRouterCommand"/>
-            <completers>
-                <ref component-id="ipAddressCompleter"/>
-                <ref component-id="macAddressCompleter"/>
-                <ref component-id="vlanIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.UpdateExternalPeerRouterVlanCommand"/>
-            <completers>
-                <ref component-id="ipAddressCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.DeleteExternalPeerRouterCommand" />
-            <completers>
-                <ref component-id="ipAddressCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackConfigArpModeCommand" />
-            <completers>
-                <ref component-id="arpModeCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackAddAclCommand" />
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackRemoveAclCommand" />
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.InstancePortListCommand" />
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.PurgeInstancePortsCommand" />
-            <completers>
-                <ref component-id="instancePortIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackResetPortsCommand" />
-            <completers>
-                <ref component-id="instancePortIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackDirectPortAddCommand" />
-            <completers>
-                <ref component-id="directPortCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknetworking.cli.OpenstackFlowTraceCommand" />
-            <completers>
-                <ref component-id="instanceIpAddressCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="ipAddressCompleter" class="org.onosproject.openstacknetworking.cli.IpAddressCompleter"/>
-    <bean id="directPortCompleter" class="org.onosproject.openstacknetworking.cli.DirectPortListCompleter"/>
-    <bean id="macAddressCompleter" class="org.onosproject.openstacknetworking.cli.MacAddressCompleter"/>
-    <bean id="vlanIdCompleter" class="org.onosproject.openstacknetworking.cli.VlanIdCompleter"/>
-    <bean id="arpModeCompleter" class="org.onosproject.openstacknetworking.cli.ArpModeCompleter"/>
-    <bean id="instancePortIdCompleter" class="org.onosproject.openstacknetworking.cli.InstancePortIdCompleter"/>
-    <bean id="instanceIpAddressCompleter" class="org.onosproject.openstacknetworking.cli.InstanceIpAddressCompleter"/>
-</blueprint>
diff --git a/apps/openstacknetworkingui/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/openstacknetworkingui/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index cebe471..0000000
--- a/apps/openstacknetworkingui/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<!--
-~ Copyright 2017-present Open Networking Foundation
-~
-~ 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.
--->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    </command-bundle>
-</blueprint>
diff --git a/apps/openstacknode/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/openstacknode/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 19ec8e0..0000000
--- a/apps/openstacknode/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.openstacknode.cli.OpenstackNodeListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknode.cli.OpenstackNodeCheckCommand"/>
-            <completers>
-                <ref component-id="hostnameCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacknode.cli.OpenstackNodeInitCommand"/>
-            <completers>
-                <ref component-id="hostnameCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="hostnameCompleter" class="org.onosproject.openstacknode.cli.OpenstackHostnameCompleter"/>
-
-</blueprint>
diff --git a/apps/openstacktroubleshoot/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/openstacktroubleshoot/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 791a58d..0000000
--- a/apps/openstacktroubleshoot/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<!--
-~ Copyright 2018-present Open Networking Foundation
-~
-~ 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.
--->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.openstacktroubleshoot.cli.OpenstackEastWestProbeCommand"/>
-            <completers>
-                <ref component-id="activeVmIpCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacktroubleshoot.cli.OpenstackNorthSouthProbeCommand"/>
-            <completers>
-                <ref component-id="activeFloatingIpCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.openstacktroubleshoot.cli.ResetMastershipCommand"/>
-        </command>
-    </command-bundle>
-
-    <bean id="activeVmIpCompleter" class="org.onosproject.openstacktroubleshoot.cli.ActiveVmIpCompleter"/>
-    <bean id="activeFloatingIpCompleter" class="org.onosproject.openstacktroubleshoot.cli.ActiveFloatingIpCompleter"/>
-</blueprint>
diff --git a/apps/openstackvtap/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/openstackvtap/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 7fd8ccf..0000000
--- a/apps/openstackvtap/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,54 +0,0 @@
-<!--
-+  ~ Copyright 2018-present Open Networking Foundation
-+  ~
-+  ~ 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.
-+  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.openstackvtap.cli.OpenstackVtapAddCommand" />
-            <completers>
-                <ref component-id="vmIpCompleter"/>
-                <ref component-id="vmIpCompleter"/>
-                <ref component-id="protocolTypeCompleter"/>
-                <null/>
-                <null/>
-                <ref component-id="vtapTypeCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.openstackvtap.cli.OpenstackVtapListCommand" />
-            <completers>
-                <ref component-id="vtapTypeCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.openstackvtap.cli.OpenstackVtapDeleteCommand" />
-            <completers>
-                <ref component-id="vtapIdCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.openstackvtap.cli.OpenstackVtapNetworkListCommand" />
-        </command>
-    </command-bundle>
-
-    <bean id="vtapTypeCompleter" class="org.onosproject.openstackvtap.cli.VtapTypeCompleter"/>
-    <bean id="protocolTypeCompleter" class="org.onosproject.openstackvtap.cli.ProtocolTypeCompleter"/>
-    <bean id="vmIpCompleter" class="org.onosproject.openstackvtap.cli.VmIpCompleter"/>
-    <bean id="vtapIdCompleter" class="org.onosproject.openstackvtap.cli.VtapIdCompleter"/>
-
-</blueprint>
diff --git a/apps/optical-model/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/optical-model/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index ab597d8..0000000
--- a/apps/optical-model/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.net.optical.cli.AddOpticalIntentCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="connectPointCompleter"/>
-            </completers>
-            <optional-completers>
-                <entry key="-a" value-ref="allAppNameCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.net.optical.cli.OpticalPortsListCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="connectPointCompleter" class="org.onosproject.cli.net.ConnectPointCompleter"/>
-    <bean id="allAppNameCompleter" class="org.onosproject.cli.app.AllApplicationNamesCompleter"/>
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-
-</blueprint>
\ No newline at end of file
diff --git a/apps/pce/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/pce/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 75f0893..0000000
--- a/apps/pce/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,37 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-  <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    <command>
-      <action class="org.onosproject.pce.cli.PceQueryPathCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.pce.cli.PceSetupPathCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.pce.cli.PceUpdatePathCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.pce.cli.PceDeletePathCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.pce.cli.PceQueryLoadBalancingPathCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.pce.cli.PceDeleteLoadBalancingPathCommand"/>
-    </command>
-  </command-bundle>
-</blueprint>
diff --git a/apps/pim/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/pim/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 9e71abb..0000000
--- a/apps/pim/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.pim.cli.PimInterfacesListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.pim.cli.PimNeighborsListCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/route-service/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/route-service/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index a020c3b..0000000
--- a/apps/route-service/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<!--
-  ~ Copyright 2014-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.routeservice.cli.RoutesListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.routeservice.cli.RouteAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.routeservice.cli.RouteRemoveCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.routeservice.cli.RouteStoreCommand"/>
-        </command>
-
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/routeradvertisement/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/routeradvertisement/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 4e8b59e..0000000
--- a/apps/routeradvertisement/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.ra.cli.GlobalPrefixesListCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
-
diff --git a/apps/routing/common/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/routing/common/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 1692a1d..0000000
--- a/apps/routing/common/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-  <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    <command>
-      <action class="org.onosproject.routing.cli.BgpNeighborsListCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.routing.cli.BgpRoutesListCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.routing.cli.BgpSpeakersListCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.routing.cli.AddSpeakerCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.routing.cli.RemoveSpeakerCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.routing.cli.AddPeerCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.routing.cli.RemovePeerCommand"/>
-    </command>
-  </command-bundle>
-</blueprint>
diff --git a/apps/routing/fpm/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/routing/fpm/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index a227f6f..0000000
--- a/apps/routing/fpm/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-  <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    <command>
-      <action class="org.onosproject.routing.fpm.cli.FpmConnectionsList"/>
-    </command>
-    <command>
-      <action class="org.onosproject.routing.fpm.cli.FpmPushRoutesCommand"/>
-    </command>
-  </command-bundle>
-</blueprint>
diff --git a/apps/scalablegateway/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/scalablegateway/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index d7ce04d..0000000
--- a/apps/scalablegateway/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,29 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.scalablegateway.cli.ScalableGatewayListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.scalablegateway.cli.ScalableGatewayAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.scalablegateway.cli.ScalableGatewayDeleteCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/sdnip/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/sdnip/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index cdebd85..0000000
--- a/apps/sdnip/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,31 +0,0 @@
-<!--
-  ~ Copyright 2014-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.sdnip.cli.SdnIpCommand"/>
-            <completers>
-                <ref component-id="sdnIpCommandCompleter"/>
-                <ref component-id="sdnIpEncapCompleter"/>
-                <null/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="sdnIpCommandCompleter" class="org.onosproject.sdnip.cli.completer.SdnIpCommandCompleter"/>
-    <bean id="sdnIpEncapCompleter" class="org.onosproject.sdnip.cli.completer.SdnIpEncapCompleter"/>
-</blueprint>
\ No newline at end of file
diff --git a/apps/segmentrouting/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/segmentrouting/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index f61569a..0000000
--- a/apps/segmentrouting/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,152 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <!-- XXX revisit when we formally add policies
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.TunnelListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.PolicyListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.PolicyAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.PolicyRemoveCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.TunnelAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.TunnelRemoveCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.RerouteNetworkCommand"/>
-        </command>
-        -->
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.DeviceSubnetListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.EcmpGraphCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.NextDstCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.NextVlanCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.NextPortCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.PseudowireNextListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.XconnectNextListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.InvalidateNextCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.ShouldProgramCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.VerifyGroupsCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.PseudowireListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.PseudowireRemoveCommand"/>
-            <completers>
-                <ref component-id="pseudowireIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.PseudowireAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.LinkStateCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.McastNextListCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.McastRoleListCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-                <entry key="-src" value-ref="connectpointCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.McastTreeListCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-                <entry key="-src" value-ref="connectpointCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.McastLeaderListCommand"/>
-            <optional-completers>
-                <entry key="-gAddr" value-ref="mcastGroupCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.XconnectListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.XconnectAddCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.XconnectRemoveCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.segmentrouting.cli.BlackHoleCommand"/>
-        </command>
-    </command-bundle>
-
-    <bean id="nullCompleter" class="org.apache.karaf.shell.console.completer.NullCompleter"/>
-    <bean id="placeholderCompleter" class="org.onosproject.cli.PlaceholderCompleter"/>
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-    <bean id="portNumberCompleter" class="org.onosproject.cli.net.PortNumberCompleter"/>
-    <bean id="pseudowireIdCompleter" class="org.onosproject.segmentrouting.cli.PseudowireIdCompleter"/>
-    <bean id="mcastGroupCompleter" class="org.onosproject.mcast.cli.McastGroupCompleter"/>
-    <bean id="connectpointCompleter" class="org.onosproject.cli.net.ConnectPointCompleter"/>
-
-</blueprint>
-
-
diff --git a/apps/simplefabric/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/simplefabric/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 2aad546..0000000
--- a/apps/simplefabric/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.simplefabric.cli.SimpleFabricCommand"/>
-            <completers>
-                <ref component-id="SimpleFabricCommandCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
- 
-    <bean id="SimpleFabricCommandCompleter" class="org.onosproject.simplefabric.cli.SimpleFabricCommandCompleter"/>
-</blueprint>
diff --git a/apps/t3/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/t3/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 48df042..0000000
--- a/apps/t3/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,47 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.t3.cli.TroubleshootTraceCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.t3.cli.TroubleshootSimpleTraceCommand"/>
-            <completers>
-                <ref component-id="hostIdCompleter"/>
-            </completers>
-            <optional-completers>
-                <entry key="-et" value-ref="ethTypeCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.t3.cli.TroubleshootPingAllCommand"/>
-            <optional-completers>
-                <entry key="-et" value-ref="ethTypeCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.t3.cli.TroubleshootMcastCommand"/>
-        </command>
-    </command-bundle>
-
-    <bean id="hostIdCompleter" class="org.onosproject.cli.net.HostIdCompleter"/>
-    <bean id="ethTypeCompleter" class="org.onosproject.cli.net.EthTypeCompleter"/>
-
-</blueprint>
-
-
diff --git a/apps/test/cluster-ha/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/test/cluster-ha/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 55cd87f..0000000
--- a/apps/test/cluster-ha/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.clusterha.cli.ClusterHATestCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/test/distributed-primitives/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/test/distributed-primitives/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index eeeab33..0000000
--- a/apps/test/distributed-primitives/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,63 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.CounterTestIncrementCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.SetTestAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.SetTestGetCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.SetTestRemoveCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.TransactionalMapTestGetCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.TransactionalMapTestPutCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.CounterTestCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.WorkQueueTestCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.ConsistentMapTestCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.DocumentTreeTestCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.EventuallyConsistentMapTestCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.AtomicValueTestCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.LeaderElectorTestCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.distributedprimitives.cli.DistributedLockTestCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/test/election/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/test/election/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 1d2a9ae..0000000
--- a/apps/test/election/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.election.cli.ElectionTestLeaderCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.election.cli.ElectionTestRunCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.election.cli.ElectionTestWithdrawCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/test/intent-perf/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/test/intent-perf/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 4fd80c7..0000000
--- a/apps/test/intent-perf/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.intentperf.IntentPerfListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.intentperf.IntentPerfStartCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.intentperf.IntentPerfStopCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/test/primitive-perf/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/test/primitive-perf/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 78b15ad..0000000
--- a/apps/test/primitive-perf/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.primitiveperf.PrimitivePerfListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.primitiveperf.PrimitivePerfStartCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.primitiveperf.PrimitivePerfStopCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/test/proxy/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/test/proxy/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 9519234..0000000
--- a/apps/test/proxy/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,22 +0,0 @@
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.proxytest.ProxyTestCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/test/route-scale/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/test/route-scale/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 0c9dbc5..0000000
--- a/apps/test/route-scale/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,27 +0,0 @@
-<!--
-  ~ Copyright 2018-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.routescale.CreateRoutes"/>
-        </command>
-        <command>
-            <action class="org.onosproject.routescale.CreateFlows"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/apps/virtualbng/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/virtualbng/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 33704fe..0000000
--- a/apps/virtualbng/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.virtualbng.cli.MappingListCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/apps/vpls/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/vpls/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index b61850c..0000000
--- a/apps/vpls/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<!--
-  ~ Copyright 2014-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.vpls.cli.VplsCommand"/>
-            <completers>
-                <ref component-id="vplsCommandCompleter"/>
-                <ref component-id="vplsNameCompleter"/>
-                <ref component-id="vplsOptArgCompleter"/>
-                <ref component-id="nullCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="vplsCommandCompleter" class="org.onosproject.vpls.cli.completer.VplsCommandCompleter"/>
-    <bean id="vplsNameCompleter" class="org.onosproject.vpls.cli.completer.VplsNameCompleter"/>
-    <bean id="vplsOptArgCompleter" class="org.onosproject.vpls.cli.completer.VplsOptArgCompleter"/>
-    <bean id="nullCompleter" class="org.apache.karaf.shell.console.completer.NullCompleter"/>
-</blueprint>
\ No newline at end of file
diff --git a/apps/vtn/vtnmgr/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/vtn/vtnmgr/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 98a44ce..0000000
--- a/apps/vtn/vtnmgr/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,23 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-  <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    <command>
-      <action class="org.onosproject.vtn.cli.VtnCommand"/>
-    </command>
-  </command-bundle>
-</blueprint>
diff --git a/apps/vtn/vtnrsc/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/vtn/vtnrsc/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 70d6898..0000000
--- a/apps/vtn/vtnrsc/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,92 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-  <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-    <command>
-      <action class="org.onosproject.vtnrsc.cli.network.TenantNetworkCreateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.network.TenantNetworkQueryCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.network.TenantNetworkRemoveCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.network.TenantNetworkUpdateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.subnet.SubnetCreateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.subnet.SubnetQueryCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.subnet.SubnetRemoveCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.subnet.SubnetUpdateCommand"/>
-    </command>
-      <command>
-      <action class="org.onosproject.vtnrsc.cli.virtualport.VirtualPortCreateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.virtualport.VirtualPortQueryCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.virtualport.VirtualPortRemoveCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.virtualport.VirtualPortUpdateCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.vtnrsc.cli.virtualport.VirtualPortExGwUpdateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpCreateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpQueryCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpRemoveCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.floatingip.FloatingIpUpdateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.router.RouterCreateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.router.RouterQueryCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.router.RouterRemoveCommand"/>
-    </command>
-    <command>
-      <action class="org.onosproject.vtnrsc.cli.router.RouterUpdateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.routerinterface.RouterInterfaceCreateCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.routerinterface.RouterInterfaceRemoveCommand"/>
-    </command>
-     <command>
-      <action class="org.onosproject.vtnrsc.cli.routerinterface.RouterInterfaceQueryCommand"/>
-    </command>
-  </command-bundle>
-</blueprint>
diff --git a/apps/workflow/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/workflow/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index cee835a..0000000
--- a/apps/workflow/app/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-	<command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-		<command>
-			<action class="org.onosproject.workflow.cli.WorkFlowStoreCommand"></action>
-		</command>
-		<command>
-			<action class="org.onosproject.workflow.cli.WorkplaceStoreCommand"></action>
-		</command>
-		<command>
-			<action class="org.onosproject.workflow.cli.WorkFlowCommand"></action>
-		</command>
-		<command>
-			<action class="org.onosproject.workflow.cli.WorkFlowEventMapCommand"></action>
-		</command>
-		<command>
-			<action class="org.onosproject.workflow.cli.WorkFlowTestCommand"></action>
-		</command>
-	</command-bundle>
-</blueprint>
diff --git a/apps/yang/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/apps/yang/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index d5e1711..0000000
--- a/apps/yang/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.yang.impl.YangModelsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.yang.impl.YangCompileCommand"/>
-        </command>
-    </command-bundle>
-</blueprint>
diff --git a/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index e67a8fb..0000000
--- a/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,1014 +0,0 @@
-<!--
-  ~ Copyright 2014-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.cli.MarkCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.PrettyJson"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.PrettyXml"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.SummaryCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.IssuCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.security.ReviewCommand"/>
-            <completers>
-                <ref component-id="reviewAppNameCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.FlowObjectiveNextListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.FlowObjectivePendingNextCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.FlowObjectiveQueueListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.FlowObjectiveQueueClearCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.FlowObjectiveCompositionCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.app.ApplicationsListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.app.ApplicationCommand"/>
-            <completers>
-                <ref component-id="appCommandCompleter"/>
-                <ref component-id="appNameCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.cfg.ComponentConfigCommand"/>
-            <completers>
-                <ref component-id="cfgCommandCompleter"/>
-                <ref component-id="componentNameCompleter"/>
-                <ref component-id="componentPropertyNameCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.cfg.NetworkConfigRegistryCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.cfg.NetworkConfigCommand"/>
-            <completers>
-                <ref component-id="subjectClassKeyCompleter"/>
-                <ref component-id="subjectKeyCompleter"/>
-                <ref component-id="configKeyCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.MetricsListCommand"/>
-            <completers>
-                <ref component-id="metricNameCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.NodesListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.StorageNodesListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.RolesCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.MastersListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.BalanceMastersCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.app.ApplicationIdListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.McastShowCommand"/>
-            <completers>
-                <ref component-id="mcastGroupCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.McastRoutesListCommand"/>
-            <completers>
-                <ref component-id="mcastGroupCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.McastJoinCommand"/>
-            <completers>
-                <ref component-id="placeholderCompleter"/>
-                <ref component-id="mcastGroupCompleter"/>
-                <ref component-id="connectPointCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.McastDeleteCommand"/>
-            <completers>
-                <ref component-id="placeholderCompleter"/>
-                <ref component-id="mcastGroupCompleter"/>
-                <ref component-id="connectPointCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.DriverProvidersListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DriversListCommand"/>
-            <completers>
-                <ref component-id="driverNameCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.DevicesListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DevicePortsListCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DevicePortStateCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <ref component-id="portStateCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceControllersCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceSetControllersCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceRemoveCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceInterfaceAddCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceInterfaceRemoveCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceInterfacesListCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.MeterAddCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.MeterRemoveCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.MetersListCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceRoleCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="nodeIdCompleter"/>
-                <ref component-id="roleCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.AnnotateDeviceCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="annotationKeysCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.AnnotatePortCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="annotationKeysCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.AnnotateLinkCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="peerConnectPointCompleter"/>
-                <ref component-id="annotationKeysCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.LinksListCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <null/> <!-- no more arguments -->
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.EdgePortsListCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.TopologyCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.PathListCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-                <null/> <!-- no more arguments -->
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.IntentsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.IntentsDiagnosisCommand"/>
-            <completers>
-                <ref component-id="intentKeyCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.IntentListCompilers"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.IntentListInstallers"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.IntentRemoveCommand"/>
-            <completers>
-                <ref component-id="appIdWithIntentNameCompleter"/>
-                <ref component-id="intentKeyCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.IntentPurgeCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.AddHostToHostIntentCommand"/>
-            <completers>
-                <ref component-id="hostIdCompleter"/>
-                <ref component-id="hostIdCompleter"/>
-            </completers>
-            <optional-completers>
-                <entry key="-t" value-ref="ethTypeCompleter"/>
-                <entry key="--ipProto" value-ref="ipProtocolCompleter"/>
-                <entry key="--icmp6Type" value-ref="Icmp6TypeCompleter"/>
-                <entry key="--icmp6Code" value-ref="Icmp6CodeCompleter"/>
-                <entry key="--extHdr" value-ref="ExtHeaderCompleter"/>
-                <entry key="-a" value-ref="allAppNameCompleter"/>
-                <entry key="-e" value-ref="encapTypeCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.AddPointToPointIntentCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="connectPointCompleter"/>
-                <null/> <!-- no more argument -->
-            </completers>
-            <optional-completers>
-                <entry key="-t" value-ref="ethTypeCompleter"/>
-                <entry key="--ipProto" value-ref="ipProtocolCompleter"/>
-                <entry key="--icmp6Type" value-ref="Icmp6TypeCompleter"/>
-                <entry key="--icmp6Code" value-ref="Icmp6CodeCompleter"/>
-                <entry key="--extHdr" value-ref="ExtHeaderCompleter"/>
-                <entry key="-a" value-ref="allAppNameCompleter"/>
-                <entry key="-e" value-ref="encapTypeCompleter"/>
-                <entry key="-r" value-ref="nullCompleter"/> <!-- option has no argument -->
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.GetStatisticsCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.GetFlowStatisticsCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.AddMultiPointToSinglePointIntentCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-            </completers>
-            <optional-completers>
-                <entry key="-t" value-ref="ethTypeCompleter"/>
-                <entry key="--ipProto" value-ref="ipProtocolCompleter"/>
-                <entry key="--icmp6Type" value-ref="Icmp6TypeCompleter"/>
-                <entry key="--icmp6Code" value-ref="Icmp6CodeCompleter"/>
-                <entry key="--extHdr" value-ref="ExtHeaderCompleter"/>
-                <entry key="-a" value-ref="allAppNameCompleter"/>
-                <entry key="-e" value-ref="encapTypeCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.AddSinglePointToMultiPointIntentCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-            </completers>
-            <optional-completers>
-                <entry key="-t" value-ref="ethTypeCompleter"/>
-                <entry key="--ipProto" value-ref="ipProtocolCompleter"/>
-                <entry key="--icmp6Type" value-ref="Icmp6TypeCompleter"/>
-                <entry key="--icmp6Code" value-ref="Icmp6CodeCompleter"/>
-                <entry key="--extHdr" value-ref="ExtHeaderCompleter"/>
-                <entry key="-a" value-ref="allAppNameCompleter"/>
-                <entry key="-e" value-ref="encapTypeCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.IntentPushTestCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="nullCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.IntentCycleCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="nullCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.RandomIntentCommand"/>
-            <completers>
-                <ref component-id="nullCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.ResourcesCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.AllocationsCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TestAllocateResource"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.TestProtectionEndpointIntentCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.AddProtectedTransportIntentCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.ClustersListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.PartitionsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.MapsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.CountersListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.QueuesListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TransactionsCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.CounterCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.ClusterDevicesCommand"/>
-            <completers>
-                <ref component-id="clusterIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.ClusterLinksCommand"/>
-            <completers>
-                <ref component-id="clusterIdCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.HostsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.HostRemoveCommand"/>
-            <completers>
-                <ref component-id="hostIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.InterfacesListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.InterfaceAddCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter" />
-                <ref component-id="placeholderCompleter" />
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.InterfaceRemoveCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="interfaceNameCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.GroupsListCommand"/>
-            <completers>
-                <ref component-id="groupStatusCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-            <optional-completers>
-                <entry key="-t" value-ref="groupTypeCompleter"/>
-            </optional-completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.DevicePortStatsCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.PortQueryVlansCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.TableStatisticsCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.FlowsListCommand"/>
-            <completers>
-                <ref component-id="flowRuleStatusCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.PacketRequestsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.PacketProcessorsListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.NeighbourHandlersListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.AddTestFlowsCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.LeaderCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.WipeOutCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.GlobalLabelCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.LabelResourceCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.GlobalLabelPoolCreateCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.LabelPoolCreateCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.GlobalLabelPoolDestroyCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.LabelPoolDestroyCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.GlobalLabelReleaseCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.LabelReleaseCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.GlobalLabelApplyCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.LabelApplyCommand"/>
-        </command>
-        <!-- tunnel commands -->
-        <command>
-            <action class="org.onosproject.cli.net.TunnelBorrowCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TunnelReturnCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TunnelQueryCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TunnelQuerySubscriptionCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TunnelCreateCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TunnelRemoveCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.TunnelUpdateCommand"/>
-        </command>
-        <!-- device key commands -->
-        <command>
-            <action class="org.onosproject.cli.net.DeviceKeyListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceKeyAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DeviceKeyRemoveCommand"/>
-        </command>
-
-        <!--region commands -->
-        <command>
-            <action class="org.onosproject.cli.net.RegionListCommand"/>
-            <completers>
-                <ref component-id="regionIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.RegionAddCommand"/>
-            <completers>
-                <null/>
-                <null/>
-                <ref component-id="regionTypeCompleter"/>
-                <ref component-id="nodeIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.RegionUpdateCommand"/>
-            <completers>
-                <ref component-id="regionIdCompleter"/>
-                <null/>
-                <ref component-id="regionTypeCompleter"/>
-                <ref component-id="nodeIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.RegionRemoveCommand"/>
-            <completers>
-                <ref component-id="regionIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.RegionAddDevicesCommand"/>
-            <completers>
-                <ref component-id="regionIdCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.RegionRemoveDevicesCommand"/>
-            <completers>
-                <ref component-id="regionIdCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.RegionAddPeerLocCommand"/>
-            <completers>
-                <ref component-id="regionIdCompleter"/>
-            </completers>
-        </command>
-
-        <!-- UI Layout commands -->
-        <command>
-            <action class="org.onosproject.cli.net.LayoutListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.LayoutAddCommand"/>
-        </command>
-        <!--TODO: add this + completers
-        <command>
-            <action class="org.onosproject.cli.net.LayoutRemoveCommand"/>
-        </command>
-        -->
-
-        <command>
-            <action class="org.onosproject.cli.net.PipeconfCommand"/>
-        </command>
-
-        <!--virtual network commands -->
-        <command>
-            <action class="org.onosproject.cli.net.vnet.TenantListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.TenantAddCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.TenantRemoveCommand"/>
-            <completers>
-                <ref component-id="tenantCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualNetworkListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualNetworkCreateCommand"/>
-            <completers>
-                <ref component-id="tenantCompleter"/>
-                <ref component-id="nullCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualNetworkRemoveCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualDeviceListCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualDeviceCreateCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualDeviceRemoveCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="nullCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualLinkListCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualLinkCreateCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="virtualPortCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="virtualPortCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualLinkRemoveCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="virtualPortCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="virtualPortCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualPortListCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualPortCreateCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="nullCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualPortBindCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="virtualPortCompleter"/>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualPortStateCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="virtualPortCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualPortRemoveCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="virtualPortCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualHostListCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualHostCreateCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualHostRemoveCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="virtualHostCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualNetworkIntentCreateCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualNetworkIntentRemoveCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualFlowsListCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <ref component-id="flowRuleStatusCompleter"/>
-                <ref component-id="virtualDeviceCompleter"/>
-                <ref component-id="placeholderCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualNetworkPacketRequestCommand"/>
-            <optional-completers>
-                <entry key="-t" value-ref="ethTypeCompleter"/>
-                <entry key="--ipProto" value-ref="ipProtocolCompleter"/>
-                <entry key="--icmp6Type" value-ref="Icmp6TypeCompleter"/>
-                <entry key="--icmp6Code" value-ref="Icmp6CodeCompleter"/>
-                <entry key="--extHdr" value-ref="ExtHeaderCompleter"/>
-            </optional-completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.vnet.VirtualNetworkBalanceMastersCommand"/>
-            <completers>
-                <ref component-id="virtualNetworkCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.cli.net.DpisListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.IntentDetailsCommand"/>
-            <optional-completers>
-                <entry key="--id" value-ref="intentIdCompleter"/>
-            </optional-completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.net.ConfigureLinkCommand"/>
-            <completers>
-                <ref component-id="connectPointCompleter"/>
-                <ref component-id="peerConnectPointCompleter"/>
-                <null/>
-            </completers>
-            <optional-completers>
-                <entry key="--type" value-ref="linkTypeCompleter"/>
-            </optional-completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.cli.MembershipsListCommand"/>
-        </command>
-
-        <!--Domain command-->
-        <command>
-            <action class="org.onosproject.cli.net.GetDomainsCommand"/>
-        </command>
-
-    </command-bundle>
-
-    <bean id="reviewAppNameCompleter" class="org.onosproject.cli.security.ReviewApplicationNameCompleter"/>
-    <bean id="appCommandCompleter" class="org.onosproject.cli.app.ApplicationCommandCompleter"/>
-    <bean id="appNameCompleter" class="org.onosproject.cli.app.ApplicationNameCompleter"/>
-    <bean id="allAppNameCompleter" class="org.onosproject.cli.app.AllApplicationNamesCompleter"/>
-    <bean id="appIdWithIntentNameCompleter" class="org.onosproject.cli.app.ApplicationIdWithIntentNameCompleter"/>
-    <bean id="cfgCommandCompleter" class="org.onosproject.cli.cfg.ComponentConfigCommandCompleter"/>
-    <bean id="componentNameCompleter" class="org.onosproject.cli.cfg.ComponentNameCompleter"/>
-    <bean id="componentPropertyNameCompleter" class="org.onosproject.cli.cfg.ComponentPropertyNameCompleter"/>
-    <bean id="nodeIdCompleter" class="org.onosproject.cli.NodeIdCompleter"/>
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-    <bean id="portNumberCompleter" class="org.onosproject.cli.net.PortNumberCompleter"/>
-    <bean id="numericPortNumberCompleter" class="org.onosproject.cli.net.completer.NumericPortNumberCompleter" />
-    <bean id="portStateCompleter" class="org.onosproject.cli.net.PortStateCompleter"/>
-    <bean id="clusterIdCompleter" class="org.onosproject.cli.net.ClusterIdCompleter"/>
-    <bean id="roleCompleter" class="org.onosproject.cli.net.RoleCompleter"/>
-    <bean id="hostIdCompleter" class="org.onosproject.cli.net.HostIdCompleter"/>
-    <bean id="intentKeyCompleter" class="org.onosproject.cli.net.IntentKeyCompleter"/>
-    <bean id="intentIdCompleter" class="org.onosproject.cli.net.completer.IntentIdCompleter"/>
-    <bean id="flowRuleStatusCompleter" class="org.onosproject.cli.net.FlowRuleStatusCompleter"/>
-    <bean id="groupStatusCompleter" class="org.onosproject.cli.net.GroupStatusCompleter" />
-    <bean id="groupTypeCompleter" class="org.onosproject.cli.net.GroupTypeCompleter" />
-    <bean id="connectPointCompleter" class="org.onosproject.cli.net.ConnectPointCompleter"/>
-    <bean id="nullCompleter" class="org.apache.karaf.shell.console.completer.NullCompleter"/>
-    <bean id="ethTypeCompleter" class="org.onosproject.cli.net.EthTypeCompleter"/>
-    <bean id="ipProtocolCompleter" class="org.onosproject.cli.net.IpProtocolCompleter"/>
-    <bean id="driverNameCompleter" class="org.onosproject.cli.net.DriverNameCompleter"/>
-    <bean id="Icmp6TypeCompleter" class="org.onosproject.cli.net.Icmp6TypeCompleter"/>
-    <bean id="Icmp6CodeCompleter" class="org.onosproject.cli.net.Icmp6CodeCompleter"/>
-    <bean id="ExtHeaderCompleter" class="org.onosproject.cli.net.ExtHeaderCompleter"/>
-
-    <bean id="startStopCompleter" class="org.onosproject.cli.StartStopCompleter"/>
-    <bean id="metricNameCompleter" class="org.onosproject.cli.MetricNameCompleter"/>
-    <bean id="upDownCompleter" class="org.onosproject.cli.UpDownCompleter"/>
-    <bean id="encapTypeCompleter" class="org.onosproject.cli.net.EncapTypeCompleter"/>
-
-    <bean id="placeholderCompleter" class="org.onosproject.cli.PlaceholderCompleter"/>
-
-    <bean id="subjectClassKeyCompleter" class="org.onosproject.cli.cfg.SubjectClassKeyCompleter"/>
-    <bean id="subjectKeyCompleter" class="org.onosproject.cli.cfg.SubjectKeyCompleter"/>
-    <bean id="configKeyCompleter" class="org.onosproject.cli.cfg.ConfigKeyCompleter"/>
-
-    <bean id="regionIdCompleter" class="org.onosproject.cli.net.RegionIdCompleter"/>
-    <bean id="regionTypeCompleter" class="org.onosproject.cli.net.RegionTypeCompleter"/>
-
-    <bean id="annotationKeysCompleter" class="org.onosproject.cli.net.completer.AnnotationKeysCompleter"/>
-
-    <bean id="peerConnectPointCompleter" class="org.onosproject.cli.net.completer.PeerConnectPointCompleter"/>
-
-    <bean id="interfaceNameCompleter" class="org.onosproject.cli.net.completer.InterfaceNameCompleter"/>
-
-    <bean id="linkTypeCompleter" class="org.onosproject.cli.net.completer.LinkTypeCompleter"/>
-
-    <bean id="tenantCompleter" class="org.onosproject.cli.net.vnet.TenantCompleter"/>
-    <bean id="virtualNetworkCompleter" class="org.onosproject.cli.net.vnet.VirtualNetworkCompleter"/>
-    <bean id="virtualDeviceCompleter" class="org.onosproject.cli.net.vnet.VirtualDeviceCompleter"/>
-    <bean id="virtualPortCompleter" class="org.onosproject.cli.net.vnet.VirtualPortCompleter"/>
-    <bean id="virtualHostCompleter" class="org.onosproject.cli.net.vnet.VirtualHostCompleter"/>
-
-    <bean id="domainIdCompleter" class="org.onosproject.cli.net.DomainIdCompleter" />
-
-    <bean id="mcastGroupCompleter" class="org.onosproject.cli.net.McastGroupCompleter"/>
-
-</blueprint>
diff --git a/drivers/fujitsu/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/drivers/fujitsu/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 9355ad6..0000000
--- a/drivers/fujitsu/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,107 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <!--volt commands -->
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltGetPonLinksCommand"/>
-        <completers>
-            <ref component-id="deviceIdCompleter"/>
-        </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltSetPonLinkCommand"/>
-        <completers>
-            <ref component-id="deviceIdCompleter"/>
-        </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltGetOnusCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltSetOnuCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltGetOnuStatsCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltEthLoopbackCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltRebootOnuCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltGetAlertFilterCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltSetAlertFilterCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltSubscribeCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltOndemandFwdlCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltGetAllCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltGetNniLinksCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.drivers.fujitsu.cli.VoltSetNniLinkCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-            </completers>
-        </command>
-    </command-bundle>
-
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-</blueprint>
diff --git a/protocols/netconf/ctl/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/protocols/netconf/ctl/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 019014e..0000000
--- a/protocols/netconf/ctl/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,58 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.netconf.cli.impl.NetconfSubscriptionTestCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.netconf.cli.impl.NetconfGetConfigCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="targetConfigurationsCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.netconf.cli.impl.NetconfGetCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-        <command>
-            <action class="org.onosproject.netconf.cli.impl.NetconfRpcTestCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-    </command-bundle>
-
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-    <bean id="targetConfigurationsCompleter" class="org.onosproject.netconf.cli.impl.completers.DatastoreIdCompleter"/>
-
-</blueprint>
diff --git a/providers/bgp/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/providers/bgp/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 6695a01..0000000
--- a/providers/bgp/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,15 +0,0 @@
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.bgp.cli.BgpConfiguration"/>
-        </command>
-        <command>
-            <action class="org.onosproject.bgp.cli.BgpLocalRibDisplay"/>
-        </command>
-        <command>
-            <action class="org.onosproject.bgp.cli.BgpExceptions"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/providers/isis/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/providers/isis/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index d8fcd0c..0000000
--- a/providers/isis/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.isis.cli.ApplicationIsisCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
\ No newline at end of file
diff --git a/providers/lldp/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/providers/lldp/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 504945c..0000000
--- a/providers/lldp/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<!--
-  ~ Copyright 2017-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.provider.lldp.cli.ConfigLinkDiscoveryCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="portNumberCompleter"/>
-                <null/>
-            </completers>
-        </command>
-
-    </command-bundle>
-
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-    <bean id="portNumberCompleter" class="org.onosproject.cli.net.PortNumberCompleter"/>
-
-</blueprint>
diff --git a/providers/null/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/providers/null/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 7be09e8..0000000
--- a/providers/null/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,65 +0,0 @@
-<!--
-  ~ Copyright 2015-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.provider.nil.cli.NullControlCommand"/>
-            <completers>
-                <ref component-id="startStopCompleter"/>
-                <ref component-id="topoShapeCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.provider.nil.cli.NullLinkCommand"/>
-            <completers>
-                <ref component-id="linkSrcCompleter"/>
-                <ref component-id="linkDstCompleter"/>
-                <ref component-id="upDownCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.provider.nil.cli.NullDeviceCommand"/>
-            <completers>
-                <ref component-id="deviceIdCompleter"/>
-                <ref component-id="upDownCompleter"/>
-                <null/>
-            </completers>
-        </command>
-        <command>
-            <action class="org.onosproject.provider.nil.cli.CreateNullDevice"/>
-        </command>
-        <command>
-            <action class="org.onosproject.provider.nil.cli.CreateNullLink"/>
-        </command>
-        <command>
-            <action class="org.onosproject.provider.nil.cli.CreateNullHost"/>
-        </command>
-        <command>
-            <action class="org.onosproject.provider.nil.cli.CreateNullHosts"/>
-        </command>
-    </command-bundle>
-
-    <bean id="startStopCompleter" class="org.onosproject.cli.StartStopCompleter"/>
-    <bean id="upDownCompleter" class="org.onosproject.cli.UpDownCompleter"/>
-    <bean id="topoShapeCompleter" class="org.onosproject.provider.nil.cli.TopologyShapeCompleter"/>
-    <bean id="linkSrcCompleter" class="org.onosproject.cli.net.LinkSrcCompleter"/>
-    <bean id="linkDstCompleter" class="org.onosproject.cli.net.LinkDstCompleter"/>
-    <bean id="deviceIdCompleter" class="org.onosproject.cli.net.DeviceIdCompleter"/>
-
-</blueprint>
diff --git a/providers/ospf/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/providers/ospf/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 0fe17d2..0000000
--- a/providers/ospf/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.ospf.cli.ApplicationOspfCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/providers/pcep/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/providers/pcep/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index aef97fd..0000000
--- a/providers/pcep/cli/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-
-        <command>
-            <action class="org.onosproject.pcep.cli.PcepSessionCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/tools/package/archetypes/cli/src/main/resources/archetype-resources/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/tools/package/archetypes/cli/src/main/resources/archetype-resources/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 874f89e..0000000
--- a/tools/package/archetypes/cli/src/main/resources/archetype-resources/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<!--
-  ~ Copyright ${year}-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="${package}.AppCommand"/>
-        </command>
-    </command-bundle>
-
-</blueprint>
diff --git a/web/gui/src/main/resources/OSGI-INF/blueprint/shell-config.xml b/web/gui/src/main/resources/OSGI-INF/blueprint/shell-config.xml
deleted file mode 100644
index 19abddd..0000000
--- a/web/gui/src/main/resources/OSGI-INF/blueprint/shell-config.xml
+++ /dev/null
@@ -1,53 +0,0 @@
-<!--
-  ~ Copyright 2016-present Open Networking Foundation
-  ~
-  ~ 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.
-  -->
-
-<blueprint xmlns="http://www.osgi.org/xmlns/blueprint/v1.0.0">
-
-    <command-bundle xmlns="http://karaf.apache.org/xmlns/shell/v1.1.0">
-        <command>
-            <action class="org.onosproject.ui.impl.cli.UiViewListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.ui.impl.cli.UiPreferencesListCommand"/>
-        </command>
-
-        <command>
-            <action class="org.onosproject.ui.impl.topo.cli.UiCacheMembersCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ui.impl.topo.cli.UiCacheRegionsCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ui.impl.topo.cli.UiCacheDevicesCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ui.impl.topo.cli.UiCacheHostsCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ui.impl.topo.cli.UiCacheLinksCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ui.impl.topo.cli.UiGeoMapListCommand"/>
-        </command>
-        <command>
-            <action class="org.onosproject.ui.impl.topo.cli.UiClearMetaCommand"/>
-        </command>
-    </command-bundle>
-
-    <!--<bean id="macIDCompleter" class="org.onosproject.dhcp.cli.MacIdCompleter"/>-->
-
-</blueprint>
\ No newline at end of file
