diff --git a/onoscli b/onoscli
new file mode 100755
index 0000000..127ec95
--- /dev/null
+++ b/onoscli
@@ -0,0 +1,698 @@
+#! /usr/bin/env python
+# -*- Mode: python; py-indent-offset: 4; tab-width: 8; indent-tabs-mode: t; -*-
+
+"""
+onoscli : ONOS-specific Command Line Interface
+
+Usage:
+    # Running the CLI in interactive mode:
+    $ ./onoscli
+
+    # Running multiple CLI commands in batch mode
+    $ cat commands.txt | ./onoscli
+
+    # Running a single command from the system command-line
+    $ ./onoscli -c show switch all
+
+    # Run the following command for additional help
+    $ ./onoscli -h
+"""
+
+#
+# INSTALLATION NOTES: MUST install Python cmd2 module. E.g., on Ubuntu:
+#    sudo apt-get install python-cmd2
+# On older Ubuntu installations (e.g., Ubuntu-12.04), install also:
+#    sudo apt-get install python-pyparsing
+#
+
+#
+# ADDING A NEW CLI COMMAND:
+#  1. Add the appropriate Command entry (or entries) inside array
+#     OnosCli.init_commands.
+#     See the comments for init_commands for details.
+#  2. Add the appropriate callback (inside class OnosCli) for the CLI command
+#
+#
+
+import sys
+import argparse
+import json
+from optparse import make_option
+import urllib2
+from urllib2 import URLError, HTTPError
+import cmd2
+from cmd2 import Cmd
+from cmd2 import options
+
+
+class Command():
+    "Command node. A hierarchy of nodes are organized in a command tree."
+
+    def __init__(self, name, help, callback=None, add_parser_args=None):
+	"""name: a string with the full command name
+	   help: the help string for the command
+           callback: the method to be called if the command is executed
+	   add_parser_args: the parser arguments to add to the command: a dictionary of argparse arguments"""
+	# Normalize the name by removing extra spaces
+	self.split_name = name.split()	# List of the words in the name
+	self.name = ' '.join(self.split_name)	# Normalized name
+	self.last_subname = self.split_name[-1]	# Last word in the name
+	self.parent_name = ' '.join(self.split_name[:-1]) # Name of parent command
+	self.help = help		# THe help string
+	self.callback = callback	# The command callback
+	self.add_parser_args = add_parser_args	# Parser arguments to add
+	self.parent = None		# The parent Command
+	self.children = []		# The children Command entries
+
+
+class OnosCli(Cmd):
+    "The main ONOS CLI class"
+
+    # Setup generic CLI fields
+    intro = "Welcome to the ONOS CLI. Type help or ? to list commands.\n"
+    prompt = "(onos) "
+    settable = Cmd.settable + "prompt CLI prompt"
+
+    # Setup ONOS-specific fields
+    onos_ip = "127.0.0.1"
+    settable = settable + "onos_ip ONOS IP address"
+    onos_port = 8080
+    settable = settable + "onos_port ONOS REST port number"
+    output_format = "json"	# Valid values: json, text
+    settable = settable + "output_format The output format: `text` or `json`"
+
+    # Collection of commands sorted by the level in the CLI command hierarchy
+    commands = []
+    # Commands, parsers and subparsers keyed by the command name
+    commands_dict = {}
+    parsers_dict = {}
+    subparsers_dict = {}
+
+    def __init__(self):
+	Cmd.__init__(self)
+
+	#
+	# An array of the ONOS-specific CLI commands.
+	# Each entry is a Command instance, and must have at least
+	# two arguments:
+	#  * Command name as typed on the CLI. E.g.:
+	#    "show intent"
+	#  * Command help description. E.g.:
+	#    "Show intents"
+	#
+	# Executable commands should have a third Command argument, which is
+	# the name of the method to be called when the command is executed.
+	# The method will be called with the (argparse) parsed arguments
+	# for that command.
+	#
+	# If an executable command takes arguments, those should be described
+	# in the Command's fourth argument. It is a list of pairs:
+	#   [
+	#    ("--argument-name1", dict(...)),
+	#    ("--argument-name2", dict(...)),
+	#    ...
+	#   ]
+	# where the first entry in the pair is the argument name, and the
+	# second entry in the pair is a dictionary with argparse-specific
+	# description of the argument.
+	#
+	init_commands = [
+	    Command("delete", "Delete command"),
+	    #
+	    Command("delete intent",
+		    """Delete high-level intents
+    Usage:
+      delete intent --intent-id INTENT_ID  Delete a high-level intent
+      delete intent --all                  Delete all high-level intents
+    Arguments:
+      --intent-id INTENT_ID    The Intent ID (an integer)
+      --all                    Delete all high-level intents""",
+		    self.delete_intent,
+		    [
+		    ("--intent-id", dict(required=False, type=int)),
+		    ("--all", dict(required=False, action='store_true'))
+		    ]
+		    ),
+	    #
+	    Command("set", "Set command"),
+	    #
+	    Command("set intent",
+		    """Set a high-level intent
+    Usage:
+      set intent <ARGS>
+    Arguments:
+      --intent-id INTENT_ID     The Intent ID (an integer) (REQUIRED)
+      --src-dpid SRC_DPID       Source Switch DPID (REQUIRED)
+      --src-port SRC_PORT       Source Switch Port (REQUIRED)
+      --dst-dpid DST_DPID       Destination Switch DPID (REQUIRED)
+      --dst-port DST_PORT       Destination Switch Port (REQUIRED)
+      --match-src-mac MATCH_SRC_MAC Matching Source MAC Address (REQUIRED)
+      --match-dst-mac MATCH_DST_MAC Matching Destination MAC Address (REQUIRED)""",
+		    self.set_intent,
+		    [
+		    ("--intent-id", dict(required=True, type=int)),
+		    ("--src-dpid", dict(required=True)),
+		    ("--src-port", dict(required=True, type=int)),
+		    ("--dst-dpid", dict(required=True)),
+		    ("--dst-port", dict(required=True, type=int)),
+		    ("--match-src-mac", dict(required=True)),
+		    ("--match-dst-mac", dict(required=True))
+		    ]),
+	    #
+	    Command("show", "Show command"),
+	    #
+	    Command("show device", "Show devices"),
+	    #
+	    Command("show device all", "Show all devices", self.show_device_all),
+	    #
+	    Command("show intent", "Show intents"),
+	    #
+	    Command("show intent high",
+		    """Show all high-level intents
+  show intent high --intent-id INTENT_ID    Show a high-level intent""",
+		    self.show_intent_high,
+		    [
+		    ("--intent-id", dict(required=False, type=int))
+		    ]
+		    ),
+	    #
+	    Command("show intent low",
+		    """Show all low-level intents
+  show intent low  --intent-id INTENT_ID    Show a low-level intent""",
+		    self.show_intent_low,
+		    [
+		    ("--intent-id", dict(required=False))
+		    ]
+		    ),
+	    #
+	    Command("show link", "Show links"),
+	    #
+	    Command("show link all", "Show all links", self.show_link_all),
+	    #
+	    Command("show path", "Show a path"),
+	    #
+	    Command("show path shortest",
+		    """Show a shortest path
+    Usage:
+      show path shortest --src-dpid SRC_DPID --dst-dpid DST_DPID
+    Arguments:
+      --src-dpid SRC_DPID       Source Switch DPID
+      --dst-dpid DST_DPID       Destination Switch DPID""",
+		    self.show_path_shortest,
+		    [
+		    ("--src-dpid", dict(required=True)),
+		    ("--dst-dpid", dict(required=True))
+		    ]),
+	    #
+	    Command("show switch", "Show switches"),
+	    #
+	    Command("show switch all", "Show all switches", self.show_switch_all)
+	]
+
+	# Sort the commands by the level in the CLI command hierarchy
+	self.commands = sorted(init_commands, key = lambda c: len(c.name.split()))
+
+	# Create a dictionary with all commands: name -> Command
+	for c in self.commands:
+	    self.commands_dict[c.name] = c
+
+	# Create a tree with all commands
+	for c in self.commands:
+	    if c.parent_name:
+		pc = self.commands_dict[c.parent_name]
+		pc.children.append(c)
+		c.parent = pc
+
+	# Create the parsers and the sub-parsers
+	for c in self.commands:
+	    # Add a parser
+	    parser = None
+	    if c.parent is None:
+		# Add a top-level parser
+		parser = argparse.ArgumentParser(description=c.help,
+						 prog=c.name,
+						 add_help=False)
+	    else:
+		# Add a parser from the parent's subparser
+		parent_subparser = self.subparsers_dict[c.parent_name]
+		parser = parent_subparser.add_parser(c.last_subname,
+						     help=c.help,
+						     add_help=False)
+	    self.parsers_dict[c.name] = parser
+	    # Add a sub-parser
+	    if c.children:
+		subparser = parser.add_subparsers(help=c.help)
+		self.subparsers_dict[c.name] = subparser
+	    # Setup the callback
+	    if c.callback is not None:
+		parser.set_defaults(func=c.callback)
+	    # Init the argument parser
+	    if c.add_parser_args is not None:
+		for a in c.add_parser_args:
+		    (p1, p2) = a
+		    parser.add_argument(p1, **p2)
+
+    def delete_intent(self, args):
+	"CLI command callback: delete intent"
+
+	url = ""
+	if args.all:
+	    # Delete all intents
+	    url = "http://%s:%s/wm/onos/intent/high" % (self.onos_ip, self.onos_port)
+	else:
+	    if args.intent_id is None:
+		print "*** Unknown syntax:"
+		self.help_delete()
+		return;
+	    # Delete an intent
+	    url = "http://%s:%s/wm/onos/intent/high/%s" % (self.onos_ip, self.onos_port, args.intent_id)
+
+	result = delete_json(url)
+	# NOTE: No need to print the response
+	# if len(result) != 0:
+	#     self.print_json_result(result)
+
+    def set_intent(self, args):
+	"CLI command callback: set intent"
+
+	intents = []
+	oper = {}
+	# Create the POST payload
+	oper['intentId'] = args.intent_id
+	oper['intentType'] = 'CONSTRAINED_SHORTEST_PATH'	# XXX: Hardcoded
+	oper['staticPath'] = False		# XXX: Hardcoded
+	oper['srcSwitchDpid'] = args.src_dpid
+	oper['srcSwitchPort'] = args.src_port
+	oper['dstSwitchDpid'] = args.dst_dpid
+	oper['dstSwitchPort'] = args.dst_port
+	oper['matchSrcMac'] = args.match_src_mac
+	oper['matchDstMac'] = args.match_dst_mac
+	intents.append(oper)
+
+	url = "http://%s:%s/wm/onos/intent/high" % (self.onos_ip, self.onos_port)
+	result = post_json(url, intents)
+	# NOTE: No need to print the response
+	# if len(result) != 0:
+	#     self.print_json_result(result)
+
+    def show_device_all(self, args):
+	"CLI command callback: show device all"
+
+	url = "http://%s:%s/wm/onos/topology/devices/json" % (self.onos_ip, self.onos_port)
+	result = get_json(url)
+	self.print_json_result(result)
+
+    def show_intent_high(self, args):
+	"CLI command callback: show intent high"
+
+	if args.intent_id is None:
+	    # Show all intents
+	    url = "http://%s:%s/wm/onos/intent/high" % (self.onos_ip, self.onos_port)
+	else:
+	    # Show a single intent
+	    url = "http://%s:%s/wm/onos/intent/high/%s" % (self.onos_ip, self.onos_port, args.intent_id)
+
+	result = get_json(url)
+	self.print_json_result(result)
+
+    def show_intent_low(self, args):
+	"CLI command callback: show intent low"
+
+	if args.intent_id is None:
+	    # Show all intents
+	    url = "http://%s:%s/wm/onos/intent/low" % (self.onos_ip, self.onos_port)
+	else:
+	    # Show a single intent
+	    url = "http://%s:%s/wm/onos/intent/low/%s" % (self.onos_ip, self.onos_port, args.intent_id)
+
+	result = get_json(url)
+	self.print_json_result(result)
+
+    def show_link_all(self, args):
+	"CLI command callback: show link all"
+
+	url = "http://%s:%s/wm/onos/topology/links/json" % (self.onos_ip, self.onos_port)
+	result = get_json(url)
+	#
+	if (self.output_format == "json"):
+	    self.print_json_result(result)
+	else:
+	    # NOTE: The code below is for demo purpose only how to
+	    # decode and print the links in text format. It will be
+	    # reimplemented in the future.
+	    links = result
+	    print "# src_dpid src_port -> dst_dpid dst_port"
+	    for v in sorted(links, key=lambda x: x['src-switch']):
+		if v.has_key('dst-switch'):
+		    dst_dpid = str(v['dst-switch'])
+		if v.has_key('src-switch'):
+		    src_dpid = str(v['src-switch'])
+		if v.has_key('src-port'):
+		    src_port = str(v['src-port'])
+		if v.has_key('dst-port'):
+		    dst_port = str(v['dst-port'])
+		self.print_result("%s %s -> %s %s" % (src_dpid, src_port, dst_dpid, dst_port))
+
+    def show_path_shortest(self, args):
+	"CLI command callback: show path shortest"
+
+	url = "http://%s:%s/wm/onos/intent/path/switch/%s/shortest-path/%s" % (self.onos_ip, self.onos_port, args.src_dpid, args.dst_dpid)
+	result = get_json(url)
+	#
+	self.print_json_result(result)
+
+    def show_switch_all(self, args):
+	"CLI command callback: show switch all"
+
+	url = "http://%s:%s/wm/onos/topology/switches/json" % (self.onos_ip, self.onos_port)
+	result = get_json(url)
+	#
+	self.print_json_result(result)
+
+    #
+    # Implement "delete" top-level command
+    #
+    def do_delete(self, arg):
+        "Top-level 'delete' command"
+	self.impl_do_command('delete', arg)
+    def complete_delete(self, text, line, begidx, endidx):
+	"Completion of top-level 'delete' command"
+	return self.impl_complete_command('delete', text, line, begidx, endidx)
+    def help_delete(self):
+	"Help for top-level 'delete' command"
+	self.impl_help_command('delete')
+
+    #
+    # Implement "set" top-level command
+    #
+    def do_set(self, arg):
+        "Top-level 'set' command"
+	self.impl_do_command('set', arg)
+    def complete_set(self, text, line, begidx, endidx):
+	"Completion of top-level 'set' command"
+	return self.impl_complete_command('set', text, line, begidx, endidx)
+    def help_set(self):
+	"Help for top-level 'set' command"
+	self.impl_help_command('set')
+
+    #
+    # Implement "show" top-level command
+    #
+    def do_show(self, arg):
+        "Top-level 'show' command"
+	self.impl_do_command('show', arg)
+    def complete_show(self, text, line, begidx, endidx):
+	"Completion of top-level 'show' command"
+	return self.impl_complete_command('show', text, line, begidx, endidx)
+    def help_show(self):
+	"Help for top-level 'show' command"
+	self.impl_help_command('show')
+
+    #
+    # Implement the "do_something" top-level command execution
+    #
+    def impl_do_command(self, root_name, arg):
+	"Implementation of top-level 'do_something' command execution"
+	parser = self.parsers_dict[root_name]
+	parsed_args = parser.parse_args(arg.split())
+	parsed_args.func(parsed_args)
+
+    #
+    # Implement the "complete_something" top-level command completion
+    #
+    def impl_complete_command(self, root_name, text, line, begidx, endidx):
+	"Implementation of top-level 'complete_something' command completion"
+	root_command = self.commands_dict[root_name]
+	subtree_commands = self.collect_subtree_commands(root_command)
+
+	#
+	# Loop through the commands and add their portion
+	# of the sub-name to the list of completions.
+	#
+	# NOTE: We add a command only if it has a callback.
+	#
+	completions = []
+	for c in subtree_commands:
+	    if c.callback is None:
+		continue
+	    name = c.split_name[len(root_command.split_name):]
+	    completions.append(' '.join(name))
+
+	mline = line.partition(" ")[2]
+	offs = len(mline) - len(text)
+	return [s[offs:] for s in completions if s.startswith(mline)]
+
+    #
+    # Implement the "help_something" top-level command help
+    #
+    def impl_help_command(self, root_name):
+	"Implementation of top-level 'help_something' command help"
+	root_command = self.commands_dict[root_name]
+	subtree_commands = self.collect_subtree_commands(root_command)
+
+	#
+	# Loop through the commands and print the help for each command.
+	# NOTE: We add a command only if it has a callback.
+	#
+	print "Help for the `%s` command:" % (root_name)
+	for c in subtree_commands:
+	    if c.callback is None:
+		continue
+	    print "  {0:30}{1:30}".format(c.name, c.help)
+	    # if c.init_arg_parser is not None:
+	    # 	parser = self.parsers_dict[c.name]
+	    # 	parser.print_help()
+
+    #
+    # Traverse (breadth-first) a subtree and return all nodes except the
+    # root node.
+    #
+    def collect_subtree_commands(self, root_command):
+	"""Collect a subtree of commands.
+           Traverses (breadth-first) a subtree of commands and returns
+           all nodes except the root node."""
+
+	commands = []
+	subtree_commands = []
+	commands.append(root_command)
+	# Use breadth-first to traverse the subtree
+	while commands:
+	    pc = commands.pop(0)
+	    for c in pc.children:
+		commands.append(c)
+		subtree_commands.append(c)
+	return subtree_commands
+
+    def log_debug(self, msg):
+	"""Log debug information.
+	msg: the message to log
+	Use the following CLI commands to enable/disable debugging:
+	  paramset debug true
+	  paramset debug false
+	"""
+	if self.debug:
+	    print "%s" % (msg)
+
+    def print_json_result(self, json_result):
+	"""Print JSON result."""
+	if len(json_result) == 0:
+	    return
+	result = json.dumps(json_result, indent=4)
+	self.print_result(result)
+
+    def print_result(self, result):
+	"""Print parsed result."""
+	print "%s" % (result)
+
+    #
+    # Implementation of the "paramshow" CLI command.
+    #
+    # NOTE: The do_paramshow implementation below is copied from
+    # the cmd2.do_show() implementation
+    #
+    @options([make_option('-l', '--long', action="store_true",
+                 help="describe function of parameter")])
+    def do_paramshow(self, arg, opts):
+        '''Shows value of a parameter.'''
+        param = arg.strip().lower()
+        result = {}
+        maxlen = 0
+        for p in self.settable:
+            if (not param) or p.startswith(param):
+                result[p] = '%s: %s' % (p, str(getattr(self, p)))
+                maxlen = max(maxlen, len(result[p]))
+        if result:
+            for p in sorted(result):
+                if opts.long:
+                    self.poutput('%s # %s' % (result[p].ljust(maxlen), self.settable[p]))
+                else:
+                    self.poutput(result[p])
+        else:
+            raise NotImplementedError("Parameter '%s' not supported (type 'show' for list of parameters)." % param)
+
+    #
+    # Implementation of the "paramset" CLI command.
+    #
+    #
+    # NOTE: The do_paramset implementation below is copied from
+    # the cmd2.do_set() implementation (with minor modifications).
+    #
+    def do_paramset(self, arg):
+        '''
+        Sets a cmd2 parameter.  Accepts abbreviated parameter names so long
+        as there is no ambiguity.  Call without arguments for a list of
+        settable parameters with their values.'''
+
+	class NotSettableError(Exception):
+	    pass
+
+        try:
+            statement, paramName, val = arg.parsed.raw.split(None, 2)
+            val = val.strip()
+            paramName = paramName.strip().lower()
+            if paramName not in self.settable:
+                hits = [p for p in self.settable if p.startswith(paramName)]
+                if len(hits) == 1:
+                    paramName = hits[0]
+                else:
+                    return self.do_paramshow(paramName)
+            currentVal = getattr(self, paramName)
+            if (val[0] == val[-1]) and val[0] in ("'", '"'):
+                val = val[1:-1]
+            else:
+                val = cmd2.cast(currentVal, val)
+            setattr(self, paramName, val)
+            self.stdout.write('%s - was: %s\nnow: %s\n' % (paramName, currentVal, val))
+            if currentVal != val:
+                try:
+                    onchange_hook = getattr(self, '_onchange_%s' % paramName)
+                    onchange_hook(old=currentVal, new=val)
+                except AttributeError:
+                    pass
+        except (ValueError, AttributeError, NotSettableError) as exc:
+            self.do_paramshow(arg)
+
+
+def get_json(url):
+    """Make a REST GET call and return the JSON result
+       url: the URL to call"""
+
+    parsed_result = ""
+    try:
+	response = urllib2.urlopen(url)
+	result = response.read()
+	response.close()
+	parsed_result = json.loads(result)
+    except HTTPError as exc:
+	print "ERROR:"
+	print "  REST GET URL: %s" % url
+	# NOTE: exc.fp contains the object with the response payload
+	error_payload = json.loads(exc.fp.read())
+	print "  REST Error Code: %s" % (error_payload['code'])
+	print "  REST Error Summary: %s" % (error_payload['summary'])
+	print "  REST Error Description: %s" % (error_payload['formattedDescription'])
+	print "  HTTP Error Code: %s" % exc.code
+	print "  HTTP Error Reason: %s" % exc.reason
+    except URLError as exc:
+	print "ERROR:"
+	print "  REST GET URL: %s" % url
+	print "  URL Error Reason: %s" % exc.reason
+    return parsed_result
+
+def post_json(url, data):
+    """Make a REST POST call and return the JSON result
+       url: the URL to call
+       data: the data to POST"""
+
+    parsed_result = ""
+    data_json = json.dumps(data)
+    try:
+	request = urllib2.Request(url, data_json)
+	request.add_header("Content-Type", "application/json")
+	response = urllib2.urlopen(request)
+	result = response.read()
+	response.close()
+	if len(result) != 0:
+	    parsed_result = json.loads(result)
+    except HTTPError as exc:
+	print "ERROR:"
+	print "  REST POST URL: %s" % url
+	# NOTE: exc.fp contains the object with the response payload
+	error_payload = json.loads(exc.fp.read())
+	print "  REST Error Code: %s" % (error_payload['code'])
+	print "  REST Error Summary: %s" % (error_payload['summary'])
+	print "  REST Error Description: %s" % (error_payload['formattedDescription'])
+	print "  HTTP Error Code: %s" % exc.code
+	print "  HTTP Error Reason: %s" % exc.reason
+    except URLError as exc:
+	print "ERROR:"
+	print "  REST POST URL: %s" % url
+	print "  URL Error Reason: %s" % exc.reason
+    return parsed_result
+
+def delete_json(url):
+    """Make a REST DELETE call and return the JSON result
+       url: the URL to call"""
+
+    parsed_result = ""
+    try:
+	request = urllib2.Request(url)
+	request.get_method = lambda: 'DELETE'
+	response = urllib2.urlopen(request)
+	result = response.read()
+	response.close()
+	if len(result) != 0:
+	    parsed_result = json.loads(result)
+    except HTTPError as exc:
+	print "ERROR:"
+	print "  REST DELETE URL: %s" % url
+	# NOTE: exc.fp contains the object with the response payload
+	error_payload = json.loads(exc.fp.read())
+	print "  REST Error Code: %s" % (error_payload['code'])
+	print "  REST Error Summary: %s" % (error_payload['summary'])
+	print "  REST Error Description: %s" % (error_payload['formattedDescription'])
+	print "  HTTP Error Code: %s" % exc.code
+	print "  HTTP Error Reason: %s" % exc.reason
+    except URLError as exc:
+	print "ERROR:"
+	print "  REST DELETE URL: %s" % url
+	print "  URL Error Reason: %s" % exc.reason
+    return parsed_result
+
+if __name__ == '__main__':
+    onosCli = OnosCli()
+
+    # Setup the parser
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c', '--command', nargs=argparse.REMAINDER,
+			help="Run arguments to the end of the line as a CLI command")
+    parser.add_argument('--onos-ip',
+			help="Set the ONOS IP address (for REST calls)")
+    parser.add_argument('--onos-port',
+			help="Set the ONOS port number (for REST calls)")
+    parser.add_argument('-t', '--test', nargs='+',
+			help="Test against transcript(s) in FILE (wildcards OK)")
+
+    # Parse the arguments
+    parsed_args = parser.parse_args()
+    if parsed_args.onos_ip:
+	onosCli.onos_ip = parsed_args.onos_ip
+    if parsed_args.onos_port:
+	onosCli.onos_port = parsed_args.onos_port
+    #
+    # NOTE: We have to reset the command-line options so the Cmd2 parser
+    # doesn't process them again.
+    #
+    sys.argv = [sys.argv[0]]
+
+    # Run the CLI as appropriate
+    if parsed_args.test:
+	# Run CLI Transcript Tests
+	onosCli.runTranscriptTests(parsed_args.test)
+    elif  parsed_args.command:
+	# Run arguments as a CLI command
+	command_line = ' '.join(parsed_args.command)
+	onosCli.onecmd(command_line)
+    else:
+	# Run interactive CLI
+	onosCli.cmdloop()