--- a/MANIFEST.in	Mon Apr 02 08:56:24 2018 +0200
+++ b/MANIFEST.in	Mon Apr 02 19:44:50 2018 +0200
@@ -7,6 +7,6 @@
 include src/sat.*
 include misc
 include frontends/src/jp/jp frontends/src/primitivus/primitivus
-include src/bridge/bridge_constructor/mediawiki_template.tpl
+include src/bridge/bridge_constructor
 global-exclude *.un~
 prune src/bridge/bridge_constructor/generated

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/sat	Mon Apr 02 19:44:50 2018 +0200
@@ -0,0 +1,107 @@
+#!/bin/sh
+
+DEBUG=""
+DAEMON=""
+PYTHON="python2"
+TWISTD="$(which twistd)"
+
+kill_process() {
+    # $1 is the file containing the PID to kill, $2 is the process name
+    if [ -f $1 ]; then
+        PID=`cat $1`
+        if ps -p $PID > /dev/null; then
+            printf  "Terminating $2... "
+            kill $PID
+            while ps -p $PID > /dev/null; do
+                sleep 0.2
+            done
+            printf "OK\n"
+        else
+            echo "No running process of ID $PID... removing PID file"
+            rm -f $1
+        fi
+    else
+        echo "$2 is probably not running (PID file doesn't exist)"
+    fi
+}
+
+#We use python to parse config files
+eval `"$PYTHON" << PYTHONEND
+from sat.core.constants import Const as C
+from sat.memory.memory import fixLocalDir
+from ConfigParser import SafeConfigParser
+from os.path import expanduser, join
+import sys
+import codecs
+import locale
+
+sys.stdout = codecs.getwriter(locale.getpreferredencoding())(sys.stdout)
+
+fixLocalDir()  # XXX: tmp update code, will be removed in the future
+
+config = SafeConfigParser(defaults=C.DEFAULT_CONFIG)
+try:
+    config.read(C.CONFIG_FILES)
+except:
+    print ("echo \"/!\\ Can't read main config ! Please check the syntax\";")
+    print ("exit 1")
+    sys.exit()
+
+env=[]
+env.append("PID_DIR='%s'" % join(expanduser(config.get('DEFAULT', 'pid_dir')),''))
+env.append("LOG_DIR='%s'" % join(expanduser(config.get('DEFAULT', 'log_dir')),''))
+env.append("APP_NAME='%s'" % C.APP_NAME)
+env.append("APP_NAME_FILE='%s'" % C.APP_NAME_FILE)
+print ";".join(env)
+PYTHONEND
+`
+APP_NAME="$APP_NAME"
+PID_FILE="$PID_DIR$APP_NAME_FILE.pid"
+LOG_FILE="$LOG_DIR$APP_NAME_FILE.log"
+RUNNING_MSG="$APP_NAME is running"
+NOT_RUNNING_MSG="$APP_NAME is *NOT* running"
+
+# if there is one argument which is "stop", then we kill SaT
+if [ $# -eq 1 ];then
+    if [ $1 = "stop" ];then
+        kill_process $PID_FILE "$APP_NAME"
+        exit 0
+    elif [ $1 = "debug" ];then
+        echo "Launching $APP_NAME in debug mode"
+        DEBUG="--debug"
+    elif [ $1 = "fg" ];then
+        echo "Launching $APP_NAME in foreground mode"
+        DAEMON="n"
+    elif [ $1 = "status" ];then
+		if [ -f $PID_FILE ]; then
+			PID=`cat $PID_FILE`
+			ps -p$PID 2>&1 > /dev/null
+			if [ $? = 0  ];then
+				echo "$RUNNING_MSG (pid: $PID)"
+				exit 0
+			else
+				echo "$NOT_RUNNING_MSG, but a pid file is present (bad exit ?): $PID_FILE"
+				exit 2
+			fi
+		else
+			echo "$NOT_RUNNING_MSG"
+			exit 1
+		fi
+	else
+		echo "bad argument, please use one of (stop, debug, fg, status) or no argument"
+		exit 1
+    fi
+fi
+
+MAIN_OPTIONS="-${DAEMON}o"
+
+#Don't change the next lines
+AUTO_OPTIONS=""
+ADDITIONAL_OPTIONS="--pidfile $PID_FILE --logfile $LOG_FILE $AUTO_OPTIONS $DEBUG"
+
+log_dir=`dirname "$LOG_FILE"`
+if [ ! -d $log_dir ] ; then
+    mkdir $log_dir
+fi
+
+exec $PYTHON $TWISTD $MAIN_OPTIONS $ADDITIONAL_OPTIONS $APP_NAME_FILE

--- a/frontends/src/bridge/bridge_frontend.py	Mon Apr 02 08:56:24 2018 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-#!/usr/bin/env python2
-#-*- coding: utf-8 -*-
-
-# SAT communication bridge
-# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-class BridgeException(Exception):
-    """An exception which has been raised from the backend and arrived to the frontend."""
-
-    def __init__(self, name, message='', condition=''):
-        """
-
-        @param name (str): full exception class name (with module)
-        @param message (str): error message
-        @param condition (str) : error condition
-        """
-        Exception.__init__(self)
-        self.fullname = unicode(name)
-        self.message = unicode(message)
-        self.condition = unicode(condition) if condition else ''
-        self.module, dummy, self.classname = unicode(self.fullname).rpartition('.')
-
-    def __str__(self):
-        message = (': %s' % self.message) if self.message else ''
-        return self.classname + message
-
-    def __eq__(self, other):
-        return self.classname == other

--- a/frontends/src/bridge/dbus_bridge.py	Mon Apr 02 08:56:24 2018 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,732 +0,0 @@
-#!/usr/bin/env python2
-#-*- coding: utf-8 -*-
-
-# SAT communication bridge
-# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-from sat.core.i18n import _
-from bridge_frontend import BridgeException
-import dbus
-from sat.core.log import getLogger
-log = getLogger(__name__)
-from sat.core.exceptions import BridgeExceptionNoService, BridgeInitError
-
-from dbus.mainloop.glib import DBusGMainLoop
-DBusGMainLoop(set_as_default=True)
-
-import ast
-
-const_INT_PREFIX = "org.goffi.SAT"  # Interface prefix
-const_ERROR_PREFIX = const_INT_PREFIX + ".error"
-const_OBJ_PATH = '/org/goffi/SAT/bridge'
-const_CORE_SUFFIX = ".core"
-const_PLUGIN_SUFFIX = ".plugin"
-const_TIMEOUT = 120
-
-
-def dbus_to_bridge_exception(dbus_e):
-    """Convert a DBusException to a BridgeException.
-
-    @param dbus_e (DBusException)
-    @return: BridgeException
-    """
-    full_name = dbus_e.get_dbus_name()
-    if full_name.startswith(const_ERROR_PREFIX):
-        name = dbus_e.get_dbus_name()[len(const_ERROR_PREFIX) + 1:]
-    else:
-        name = full_name
-    # XXX: dbus_e.args doesn't contain the original DBusException args, but we
-    # receive its serialized form in dbus_e.args[0]. From that we can rebuild
-    # the original arguments list thanks to ast.literal_eval (secure eval).
-    message = dbus_e.get_dbus_message()  # similar to dbus_e.args[0]
-    try:
-        message, condition = ast.literal_eval(message)
-    except (SyntaxError, ValueError, TypeError):
-        condition = ''
-    return BridgeException(name, message, condition)
-
-
-class Bridge(object):
-
-    def bridgeConnect(self, callback, errback):
-        try:
-            self.sessions_bus = dbus.SessionBus()
-            self.db_object = self.sessions_bus.get_object(const_INT_PREFIX,
-                                                          const_OBJ_PATH)
-            self.db_core_iface = dbus.Interface(self.db_object,
-                                                dbus_interface=const_INT_PREFIX + const_CORE_SUFFIX)
-            self.db_plugin_iface = dbus.Interface(self.db_object,
-                                                  dbus_interface=const_INT_PREFIX + const_PLUGIN_SUFFIX)
-        except dbus.exceptions.DBusException, e:
-            if e._dbus_error_name in ('org.freedesktop.DBus.Error.ServiceUnknown',
-                                      'org.freedesktop.DBus.Error.Spawn.ExecFailed'):
-                errback(BridgeExceptionNoService())
-            elif e._dbus_error_name == 'org.freedesktop.DBus.Error.NotSupported':
-                log.error(_(u"D-Bus is not launched, please see README to see instructions on how to launch it"))
-                errback(BridgeInitError)
-            else:
-                errback(e)
-        callback()
-        #props = self.db_core_iface.getProperties()
-
-    def register_signal(self, functionName, handler, iface="core"):
-        if iface == "core":
-            self.db_core_iface.connect_to_signal(functionName, handler)
-        elif iface == "plugin":
-            self.db_plugin_iface.connect_to_signal(functionName, handler)
-        else:
-            log.error(_('Unknown interface'))
-
-    def __getattribute__(self, name):
-        """ usual __getattribute__ if the method exists, else try to find a plugin method """
-        try:
-            return object.__getattribute__(self, name)
-        except AttributeError:
-            # The attribute is not found, we try the plugin proxy to find the requested method
-
-            def getPluginMethod(*args, **kwargs):
-                # We first check if we have an async call. We detect this in two ways:
-                #   - if we have the 'callback' and 'errback' keyword arguments
-                #   - or if the last two arguments are callable
-
-                async = False
-                args = list(args)
-
-                if kwargs:
-                    if 'callback' in kwargs:
-                        async = True
-                        _callback = kwargs.pop('callback')
-                        _errback = kwargs.pop('errback', lambda failure: log.error(unicode(failure)))
-                    try:
-                        args.append(kwargs.pop('profile'))
-                    except KeyError:
-                        try:
-                            args.append(kwargs.pop('profile_key'))
-                        except KeyError:
-                            pass
-                    # at this point, kwargs should be empty
-                    if kwargs:
-                        log.warnings(u"unexpected keyword arguments, they will be ignored: {}".format(kwargs))
-                elif len(args) >= 2 and callable(args[-1]) and callable(args[-2]):
-                    async = True
-                    _errback = args.pop()
-                    _callback = args.pop()
-
-                method = getattr(self.db_plugin_iface, name)
-
-                if async:
-                    kwargs['timeout'] = const_TIMEOUT
-                    kwargs['reply_handler'] = _callback
-                    kwargs['error_handler'] = lambda err: _errback(dbus_to_bridge_exception(err))
-
-                return method(*args, **kwargs)
-
-            return getPluginMethod
-
-    def actionsGet(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.actionsGet(profile_key, **kwargs)
-
-    def addContact(self, entity_jid, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.addContact(entity_jid, profile_key, **kwargs)
-
-    def asyncDeleteProfile(self, profile, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.asyncDeleteProfile(profile, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def asyncGetParamA(self, name, category, attribute="value", security_limit=-1, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return unicode(self.db_core_iface.asyncGetParamA(name, category, attribute, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
-
-    def asyncGetParamsValuesFromCategory(self, category, security_limit=-1, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.asyncGetParamsValuesFromCategory(category, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def connect(self, profile_key="@DEFAULT@", password='', options={}, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.connect(profile_key, password, options, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def delContact(self, entity_jid, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.delContact(entity_jid, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def discoFindByFeatures(self, namespaces, identities, bare_jid=False, service=True, roster=True, own_jid=True, profile_key=u"@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.discoFindByFeatures(namespaces, identities, bare_jid, service, roster, own_jid, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def discoInfos(self, entity_jid, node=u'', use_cache=True, profile_key=u"@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.discoInfos(entity_jid, node, use_cache, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def discoItems(self, entity_jid, node=u'', use_cache=True, profile_key=u"@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.discoItems(entity_jid, node, use_cache, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def disconnect(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.disconnect(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def getConfig(self, section, name, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return unicode(self.db_core_iface.getConfig(section, name, **kwargs))
-
-    def getContacts(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.getContacts(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def getContactsFromGroup(self, group, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.getContactsFromGroup(group, profile_key, **kwargs)
-
-    def getEntitiesData(self, jids, keys, profile, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.getEntitiesData(jids, keys, profile, **kwargs)
-
-    def getEntityData(self, jid, keys, profile, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.getEntityData(jid, keys, profile, **kwargs)
-
-    def getFeatures(self, profile_key, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.getFeatures(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def getMainResource(self, contact_jid, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return unicode(self.db_core_iface.getMainResource(contact_jid, profile_key, **kwargs))
-
-    def getParamA(self, name, category, attribute="value", profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return unicode(self.db_core_iface.getParamA(name, category, attribute, profile_key, **kwargs))
-
-    def getParamsCategories(self, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.getParamsCategories(**kwargs)
-
-    def getParamsUI(self, security_limit=-1, app='', profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return unicode(self.db_core_iface.getParamsUI(security_limit, app, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler))
-
-    def getPresenceStatuses(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.getPresenceStatuses(profile_key, **kwargs)
-
-    def getReady(self, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.getReady(timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def getVersion(self, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return unicode(self.db_core_iface.getVersion(**kwargs))
-
-    def getWaitingSub(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.getWaitingSub(profile_key, **kwargs)
-
-    def historyGet(self, from_jid, to_jid, limit, between=True, filters='', profile="@NONE@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.historyGet(from_jid, to_jid, limit, between, filters, profile, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def isConnected(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.isConnected(profile_key, **kwargs)
-
-    def launchAction(self, callback_id, data, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.launchAction(callback_id, data, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def loadParamsTemplate(self, filename, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.loadParamsTemplate(filename, **kwargs)
-
-    def menuHelpGet(self, menu_id, language, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return unicode(self.db_core_iface.menuHelpGet(menu_id, language, **kwargs))
-
-    def menuLaunch(self, menu_type, path, data, security_limit, profile_key, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.menuLaunch(menu_type, path, data, security_limit, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def menusGet(self, language, security_limit, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.menusGet(language, security_limit, **kwargs)
-
-    def messageSend(self, to_jid, message, subject={}, mess_type="auto", extra={}, profile_key="@NONE@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.messageSend(to_jid, message, subject, mess_type, extra, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def namespacesGet(self, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.namespacesGet(**kwargs)
-
-    def paramsRegisterApp(self, xml, security_limit=-1, app='', callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.paramsRegisterApp(xml, security_limit, app, **kwargs)
-
-    def profileCreate(self, profile, password='', component='', callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.profileCreate(profile, password, component, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def profileIsSessionStarted(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.profileIsSessionStarted(profile_key, **kwargs)
-
-    def profileNameGet(self, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return unicode(self.db_core_iface.profileNameGet(profile_key, **kwargs))
-
-    def profileSetDefault(self, profile, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.profileSetDefault(profile, **kwargs)
-
-    def profileStartSession(self, password='', profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.profileStartSession(password, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def profilesListGet(self, clients=True, components=False, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.profilesListGet(clients, components, **kwargs)
-
-    def progressGet(self, id, profile, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.progressGet(id, profile, **kwargs)
-
-    def progressGetAll(self, profile, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.progressGetAll(profile, **kwargs)
-
-    def progressGetAllMetadata(self, profile, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.progressGetAllMetadata(profile, **kwargs)
-
-    def saveParamsTemplate(self, filename, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.saveParamsTemplate(filename, **kwargs)
-
-    def sessionInfosGet(self, profile_key, callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.sessionInfosGet(profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)
-
-    def setParam(self, name, value, category, security_limit=-1, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.setParam(name, value, category, security_limit, profile_key, **kwargs)
-
-    def setPresence(self, to_jid='', show='', statuses={}, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.setPresence(to_jid, show, statuses, profile_key, **kwargs)
-
-    def subscription(self, sub_type, entity, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        kwargs={}
-        if callback is not None:
-            kwargs['timeout'] = const_TIMEOUT
-            kwargs['reply_handler'] = callback
-            kwargs['error_handler'] = error_handler
-        return self.db_core_iface.subscription(sub_type, entity, profile_key, **kwargs)
-
-    def updateContact(self, entity_jid, name, groups, profile_key="@DEFAULT@", callback=None, errback=None):
-        if callback is None:
-            error_handler = None
-        else:
-            if errback is None:
-                errback = log.error
-            error_handler = lambda err:errback(dbus_to_bridge_exception(err))
-        return self.db_core_iface.updateContact(entity_jid, name, groups, profile_key, timeout=const_TIMEOUT, reply_handler=callback, error_handler=error_handler)

--- a/frontends/src/jp/arg_tools.py	Mon Apr 02 08:56:24 2018 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,98 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-
-# jp: a SàT command line tool
-# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-from sat.core.i18n import _
-from sat.core import exceptions
-
-
-def escape(arg, smart=True):
-    """format arg with quotes
-
-    @param smart(bool): if True, only escape if needed
-    """
-    if smart and not ' ' in arg and not '"' in arg:
-        return arg
-    return u'"' + arg.replace(u'"',u'\\"') + u'"'
-
-
-def get_cmd_choices(cmd=None, parser=None):
-    try:
-        choices = parser._subparsers._group_actions[0].choices
-        return choices[cmd] if cmd is not None else choices
-    except (KeyError, AttributeError):
-        raise exceptions.NotFound
-
-
-def get_use_args(host, args, use, verbose=False, parser=None):
-    """format args for argparse parser with values prefilled
-
-    @param host(JP): jp instance
-    @param args(list(str)): arguments to use
-    @param use(dict[str, str]): arguments to fill if found in parser
-    @param verbose(bool): if True a message will be displayed when argument is used or not
-    @param parser(argparse.ArgumentParser): parser to use
-    @return (tuple[list[str],list[str]]): 2 args lists:
-        - parser args, i.e. given args corresponding to parsers
-        - use args, i.e. generated args from use
-    """
-    # FIXME: positional args are not handled correclty
-    #        if there is more that one, the position is not corrected
-    if parser is None:
-        parser = host.parser
-
-    # we check not optional args to see if there
-    # is a corresonding parser
-    # else USE args would not work correctly (only for current parser)
-    parser_args = []
-    for arg in args:
-        if arg.startswith('-'):
-            break
-        try:
-            parser = get_cmd_choices(arg, parser)
-        except exceptions.NotFound:
-            break
-        parser_args.append(arg)
-
-    # post_args are remaning given args,
-    # without the ones corresponding to parsers
-    post_args = args[len(parser_args):]
-
-    opt_args = []
-    pos_args = []
-    actions = {a.dest: a for a in parser._actions}
-    for arg, value in use.iteritems():
-        try:
-            if arg == u'item' and not u'item' in actions:
-                # small hack when --item is appended to a --items list
-                arg = u'items'
-            action = actions[arg]
-        except KeyError:
-            if verbose:
-                host.disp(_(u'ignoring {name}={value}, not corresponding to any argument (in USE)').format(
-                    name=arg,
-                    value=escape(value)))
-        else:
-            if verbose:
-                host.disp(_(u'arg {name}={value} (in USE)').format(name=arg, value=escape(value)))
-            if not action.option_strings:
-                pos_args.append(value)
-            else:
-                opt_args.append(action.option_strings[0])
-                opt_args.append(value)
-    return parser_args, opt_args + pos_args + post_args

--- a/frontends/src/jp/base.py	Mon Apr 02 08:56:24 2018 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1084 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-
-# jp: a SAT command line tool
-# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-from sat.core.i18n import _
-
-### logging ###
-import logging as log
-log.basicConfig(level=log.DEBUG,
-                format='%(message)s')
-###
-
-import sys
-import locale
-import os.path
-import argparse
-from glob import iglob
-from importlib import import_module
-from sat_frontends.tools.jid import JID
-from sat.tools import config
-from sat.tools.common import dynamic_import
-from sat.tools.common import uri
-from sat.core import exceptions
-import sat_frontends.jp
-from sat_frontends.jp.constants import Const as C
-from sat_frontends.tools import misc
-import xml.etree.ElementTree as ET  # FIXME: used temporarily to manage XMLUI
-import shlex
-from collections import OrderedDict
-
-## bridge handling
-# we get bridge name from conf and initialise the right class accordingly
-main_config = config.parseMainConf()
-bridge_name = config.getConfig(main_config, '', 'bridge', 'dbus')
-
-
-# TODO: move loops handling in a separated module
-if 'dbus' in bridge_name:
-    from gi.repository import GLib
-
-
-    class JPLoop(object):
-
-        def __init__(self):
-            self.loop = GLib.MainLoop()
-
-        def run(self):
-            self.loop.run()
-
-        def quit(self):
-            self.loop.quit()
-
-        def call_later(self, delay, callback, *args):
-            """call a callback repeatedly
-
-            @param delay(int): delay between calls in ms
-            @param callback(callable): method to call
-                if the callback return True, the call will continue
-                else the calls will stop
-            @param *args: args of the callbac
-            """
-            GLib.timeout_add(delay, callback, *args)
-
-else:
-    print u"can't start jp: only D-Bus bridge is currently handled"
-    sys.exit(C.EXIT_ERROR)
-    # FIXME: twisted loop can be used when jp can handle fully async bridges
-    # from twisted.internet import reactor
-
-    # class JPLoop(object):
-
-    #     def run(self):
-    #         reactor.run()
-
-    #     def quit(self):
-    #         reactor.stop()
-
-    #     def _timeout_cb(self, args, callback, delay):
-    #         ret = callback(*args)
-    #         if ret:
-    #             reactor.callLater(delay, self._timeout_cb, args, callback, delay)
-
-    #     def call_later(self, delay, callback, *args):
-    #         delay = float(delay) / 1000
-    #         reactor.callLater(delay, self._timeout_cb, args, callback, delay)
-
-if bridge_name == "embedded":
-    from sat.core import sat_main
-    sat = sat_main.SAT()
-
-if sys.version_info < (2, 7, 3):
-    # XXX: shlex.split only handle unicode since python 2.7.3
-    # this is a workaround for older versions
-    old_split = shlex.split
-    new_split = (lambda s, *a, **kw: [t.decode('utf-8') for t in old_split(s.encode('utf-8'), *a, **kw)]
-        if isinstance(s, unicode) else old_split(s, *a, **kw))
-    shlex.split = new_split
-
-try:
-    import progressbar
-except ImportError:
-    msg = (_(u'ProgressBar not available, please download it at http://pypi.python.org/pypi/progressbar\n') +
-           _(u'Progress bar deactivated\n--\n'))
-    print >>sys.stderr,msg.encode('utf-8')
-    progressbar=None
-
-#consts
-PROG_NAME = u"jp"
-DESCRIPTION = """This software is a command line tool for XMPP.
-Get the latest version at """ + C.APP_URL
-
-COPYLEFT = u"""Copyright (C) 2009-2018 Jérôme Poisson, Adrien Cossa
-This program comes with ABSOLUTELY NO WARRANTY;
-This is free software, and you are welcome to redistribute it under certain conditions.
-"""
-
-PROGRESS_DELAY = 10 # the progression will be checked every PROGRESS_DELAY ms
-
-
-def unicode_decoder(arg):
-    # Needed to have unicode strings from arguments
-    return arg.decode(locale.getpreferredencoding())
-
-
-class Jp(object):
-    """
-    This class can be use to establish a connection with the
-    bridge. Moreover, it should manage a main loop.
-
-    To use it, you mainly have to redefine the method run to perform
-    specify what kind of operation you want to perform.
-
-    """
-    def __init__(self):
-        """
-
-        @attribute quit_on_progress_end (bool): set to False if you manage yourself exiting,
-            or if you want the user to stop by himself
-        @attribute progress_success(callable): method to call when progress just started
-            by default display a message
-        @attribute progress_success(callable): method to call when progress is successfully finished
-            by default display a message
-        @attribute progress_failure(callable): method to call when progress failed
-            by default display a message
-        """
-        # FIXME: need_loop should be removed, everything must be async in bridge so
-        #        loop will always be needed
-        bridge_module = dynamic_import.bridge(bridge_name, 'sat_frontends.bridge')
-        if bridge_module is None:
-            log.error(u"Can't import {} bridge".format(bridge_name))
-            sys.exit(1)
-
-        self.bridge = bridge_module.Bridge()
-        self.bridge.bridgeConnect(callback=self._bridgeCb, errback=self._bridgeEb)
-
-    def _bridgeCb(self):
-        self.parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
-                                              description=DESCRIPTION)
-        self._make_parents()
-        self.add_parser_options()
-        self.subparsers = self.parser.add_subparsers(title=_(u'Available commands'), dest='subparser_name')
-        self._auto_loop = False # when loop is used for internal reasons
-        self._need_loop = False
-
-        # progress attributes
-        self._progress_id = None # TODO: manage several progress ids
-        self.quit_on_progress_end = True
-
-        # outputs
-        self._outputs = {}
-        for type_ in C.OUTPUT_TYPES:
-            self._outputs[type_] = OrderedDict()
-        self.default_output = {}
-
-    def _bridgeEb(self, failure):
-        if isinstance(failure, exceptions.BridgeExceptionNoService):
-            print(_(u"Can't connect to SàT backend, are you sure it's launched ?"))
-        elif isinstance(failure, exceptions.BridgeInitError):
-            print(_(u"Can't init bridge"))
-        else:
-            print(_(u"Error while initialising bridge: {}".format(failure)))
-        sys.exit(C.EXIT_BRIDGE_ERROR)
-
-    @property
-    def version(self):
-        return self.bridge.getVersion()
-
-    @property
-    def progress_id(self):
-        return self._progress_id
-
-    @progress_id.setter
-    def progress_id(self, value):
-        self._progress_id = value
-        self.replayCache('progress_ids_cache')
-
-    @property
-    def watch_progress(self):
-        try:
-            self.pbar
-        except AttributeError:
-            return False
-        else:
-            return True
-
-    @watch_progress.setter
-    def watch_progress(self, watch_progress):
-        if watch_progress:
-            self.pbar = None
-
-    @property
-    def verbosity(self):
-        try:
-            return self.args.verbose
-        except AttributeError:
-            return 0
-
-    def replayCache(self, cache_attribute):
-        """Replay cached signals
-
-        @param cache_attribute(str): name of the attribute containing the cache
-            if the attribute doesn't exist, there is no cache and the call is ignored
-            else the cache must be a list of tuples containing the replay callback as first item,
-            then the arguments to use
-        """
-        try:
-            cache = getattr(self, cache_attribute)
-        except AttributeError:
-            pass
-        else:
-            for cache_data in cache:
-                cache_data[0](*cache_data[1:])
-
-    def disp(self, msg, verbosity=0, error=False, no_lf=False):
-        """Print a message to user
-
-        @param msg(unicode): message to print
-        @param verbosity(int): minimal verbosity to display the message
-        @param error(bool): if True, print to stderr instead of stdout
-        @param no_lf(bool): if True, do not emit line feed at the end of line
-        """
-        if self.verbosity >= verbosity:
-            if error:
-                if no_lf:
-                    print >>sys.stderr,msg.encode('utf-8'),
-                else:
-                    print >>sys.stderr,msg.encode('utf-8')
-            else:
-                if no_lf:
-                    print msg.encode('utf-8'),
-                else:
-                    print msg.encode('utf-8')
-
-    def output(self, type_, name, extra_outputs, data):
-        if name in extra_outputs:
-            extra_outputs[name](data)
-        else:
-            self._outputs[type_][name]['callback'](data)
-
-    def addOnQuitCallback(self, callback, *args, **kwargs):
-        """Add a callback which will be called on quit command
-
-        @param callback(callback): method to call
-        """
-        try:
-            callbacks_list = self._onQuitCallbacks
-        except AttributeError:
-            callbacks_list = self._onQuitCallbacks = []
-        finally:
-            callbacks_list.append((callback, args, kwargs))
-
-    def getOutputChoices(self, output_type):
-        """Return valid output filters for output_type
-
-        @param output_type: True for default,
-            else can be any registered type
-        """
-        return self._outputs[output_type].keys()
-
-    def _make_parents(self):
-        self.parents = {}
-
-        # we have a special case here as the start-session option is present only if connection is not needed,
-        # so we create two similar parents, one with the option, the other one without it
-        for parent_name in ('profile', 'profile_session'):
-            parent = self.parents[parent_name] = argparse.ArgumentParser(add_help=False)
-            parent.add_argument("-p", "--profile", action="store", type=str, default='@DEFAULT@', help=_("Use PROFILE profile key (default: %(default)s)"))
-            parent.add_argument("--pwd", action="store", type=unicode_decoder, default='', metavar='PASSWORD', help=_("Password used to connect profile, if necessary"))
-
-        profile_parent, profile_session_parent = self.parents['profile'], self.parents['profile_session']
-
-        connect_short, connect_long, connect_action, connect_help = "-c", "--connect", "store_true", _(u"Connect the profile before doing anything else")
-        profile_parent.add_argument(connect_short, connect_long, action=connect_action, help=connect_help)
-
-        profile_session_connect_group = profile_session_parent.add_mutually_exclusive_group()
-        profile_session_connect_group.add_argument(connect_short, connect_long, action=connect_action, help=connect_help)
-        profile_session_connect_group.add_argument("--start-session", action="store_true", help=_("Start a profile session without connecting"))
-
-        progress_parent = self.parents['progress'] = argparse.ArgumentParser(add_help=False)
-        if progressbar:
-            progress_parent.add_argument("-P", "--progress", action="store_true", help=_("Show progress bar"))
-
-        verbose_parent = self.parents['verbose'] = argparse.ArgumentParser(add_help=False)
-        verbose_parent.add_argument('--verbose', '-v', action='count', default=0, help=_(u"Add a verbosity level (can be used multiple times)"))
-
-        draft_parent = self.parents['draft'] = argparse.ArgumentParser(add_help=False)
-        draft_group = draft_parent.add_argument_group(_('draft handling'))
-        draft_group.add_argument("-D", "--current", action="store_true", help=_(u"load current draft"))
-        draft_group.add_argument("-F", "--draft-path", type=unicode_decoder, help=_(u"path to a draft file to retrieve"))
-
-
-    def make_pubsub_group(self, flags, defaults):
-        """generate pubsub options according to flags
-
-        @param flags(iterable[unicode]): see [CommandBase.__init__]
-        @param defaults(dict[unicode, unicode]): help text for default value
-            key can be "service" or "node"
-            value will be set in " (DEFAULT: {value})", or can be None to remove DEFAULT
-        @return (ArgumentParser): parser to add
-        """
-        flags = misc.FlagsHandler(flags)
-        parent = argparse.ArgumentParser(add_help=False)
-        pubsub_group = parent.add_argument_group('pubsub')
-        pubsub_group.add_argument("-u", "--pubsub-url", type=unicode_decoder,
-                                  help=_(u"Pubsub URL (xmpp or http)"))
-
-        service_help = _(u"JID of the PubSub service")
-        if not flags.service:
-            default = defaults.pop(u'service', _(u'PEP service'))
-            if default is not None:
-                service_help += _(u" (DEFAULT: {default})".format(default=default))
-        pubsub_group.add_argument("-s", "--service", type=unicode_decoder, default=u'',
-                                  help=service_help)
-
-        node_help = _(u"node to request")
-        if not flags.node:
-            default = defaults.pop(u'node', _(u'standard node'))
-            if default is not None:
-                node_help += _(u" (DEFAULT: {default})".format(default=default))
-        pubsub_group.add_argument("-n", "--node", type=unicode_decoder, default=u'', help=node_help)
-
-        if flags.single_item:
-            item_help = (u"item to retrieve")
-            if not flags.item:
-                default = defaults.pop(u'item', _(u'last item'))
-                if default is not None:
-                    item_help += _(u" (DEFAULT: {default})".format(default=default))
-            pubsub_group.add_argument("-i", "--item", type=unicode_decoder, help=item_help)
-            pubsub_group.add_argument("-L", "--last-item", action='store_true', help=_(u'retrieve last item'))
-        elif flags.multi_items:
-            # mutiple items
-            pubsub_group.add_argument("-i", "--item", type=unicode_decoder, action='append', dest='items', default=[], help=_(u"items to retrieve (DEFAULT: all)"))
-            if not flags.no_max:
-                pubsub_group.add_argument("-m", "--max", type=int, default=10,
-                    help=_(u"maximum number of items to get ({no_limit} to get all items)".format(no_limit=C.NO_LIMIT)))
-
-        if flags:
-            raise exceptions.InternalError('unknowns flags: {flags}'.format(flags=u', '.join(flags)))
-        if defaults:
-            raise exceptions.InternalError('unused defaults: {defaults}'.format(defaults=defaults))
-
-        return parent
-
-    def add_parser_options(self):
-        self.parser.add_argument('--version', action='version', version=("%(name)s %(version)s %(copyleft)s" % {'name': PROG_NAME, 'version': self.version, 'copyleft': COPYLEFT}))
-
-    def register_output(self, type_, name, callback, description="", default=False):
-        if type_ not in C.OUTPUT_TYPES:
-            log.error(u"Invalid output type {}".format(type_))
-            return
-        self._outputs[type_][name] = {'callback': callback,
-                                      'description': description
-                                     }
-        if default:
-            if type_ in self.default_output:
-                self.disp(_(u'there is already a default output for {}, ignoring new one').format(type_))
-            else:
-                self.default_output[type_] = name
-
-
-    def parse_output_options(self):
-        options = self.command.args.output_opts
-        options_dict = {}
-        for option in options:
-            try:
-                key, value = option.split(u'=', 1)
-            except ValueError:
-                key, value = option, None
-            options_dict[key.strip()] = value.strip() if value is not None else None
-        return options_dict
-
-    def check_output_options(self, accepted_set, options):
-        if not accepted_set.issuperset(options):
-            self.disp(u"The following output options are invalid: {invalid_options}".format(
-                invalid_options = u', '.join(set(options).difference(accepted_set))),
-                error=True)
-            self.quit(C.EXIT_BAD_ARG)
-
-    def import_plugins(self):
-        """Automaticaly import commands and outputs in jp
-
-        looks from modules names cmd_*.py in jp path and import them
-        """
-        path = os.path.dirname(sat_frontends.jp.__file__)
-        # XXX: outputs must be imported before commands as they are used for arguments
-        for type_, pattern in ((C.PLUGIN_OUTPUT, 'output_*.py'), (C.PLUGIN_CMD, 'cmd_*.py')):
-            modules = (os.path.splitext(module)[0] for module in map(os.path.basename, iglob(os.path.join(path, pattern))))
-            for module_name in modules:
-                module_path = "sat_frontends.jp." + module_name
-                try:
-                    module = import_module(module_path)
-                    self.import_plugin_module(module, type_)
-                except ImportError as e:
-                    self.disp(_(u"Can't import {module_path} plugin, ignoring it: {msg}".format(
-                    module_path = module_path,
-                    msg = e)), error=True)
-                except exceptions.CancelError:
-                    continue
-                except exceptions.MissingModule as e:
-                    self.disp(_(u"Missing module for plugin {name}: {missing}".format(
-                        name = module_path,
-                        missing = e)), error=True)
-
-
-    def import_plugin_module(self, module, type_):
-        """add commands or outpus from a module to jp
-
-        @param module: module containing commands or outputs
-        @param type_(str): one of C_PLUGIN_*
-        """
-        try:
-            class_names =  getattr(module, '__{}__'.format(type_))
-        except AttributeError:
-            log.disp(_(u"Invalid plugin module [{type}] {module}").format(type=type_, module=module), error=True)
-            raise ImportError
-        else:
-            for class_name in class_names:
-                cls = getattr(module, class_name)
-                cls(self)
-
-    def get_xmpp_uri_from_http(self, http_url):
-        """parse HTML page at http(s) URL, and looks for xmpp: uri"""
-        if http_url.startswith('https'):
-            scheme = u'https'
-        elif http_url.startswith('http'):
-            scheme = u'http'
-        else:
-            raise exceptions.InternalError(u'An HTTP scheme is expected in this method')
-        self.disp(u"{scheme} URL found, trying to find associated xmpp: URI".format(scheme=scheme.upper()),1)
-        # HTTP URL, we try to find xmpp: links
-        try:
-            from lxml import etree
-        except ImportError:
-            self.disp(u"lxml module must be installed to use http(s) scheme, please install it with \"pip install lxml\"", error=True)
-            self.host.quit(1)
-        import urllib2
-        parser = etree.HTMLParser()
-        try:
-            root = etree.parse(urllib2.urlopen(http_url), parser)
-        except etree.XMLSyntaxError as e:
-            self.disp(_(u"Can't parse HTML page : {msg}").format(msg=e))
-            links = []
-        else:
-            links = root.xpath("//link[@rel='alternate' and starts-with(@href, 'xmpp:')]")
-        if not links:
-            self.disp(u'Could not find alternate "xmpp:" URI, can\'t find associated XMPP PubSub node/item', error=True)
-            self.host.quit(1)
-        xmpp_uri = links[0].get('href')
-        return xmpp_uri
-
-    def parse_pubsub_args(self):
-        if self.args.pubsub_url is not None:
-            url = self.args.pubsub_url
-
-            if url.startswith('http'):
-                # http(s) URL, we try to retrieve xmpp one from there
-                url = self.get_xmpp_uri_from_http(url)
-
-            try:
-                uri_data = uri.parseXMPPUri(url)
-            except ValueError:
-                self.parser.error(_(u'invalid XMPP URL: {url}').format(url=url))
-            else:
-                if uri_data[u'type'] == 'pubsub':
-                    # URL is alright, we only set data not already set by other options
-                    if not self.args.service:
-                        self.args.service = uri_data[u'path']
-                    if not self.args.node:
-                        self.args.node = uri_data[u'node']
-                    uri_item = uri_data.get(u'item')
-                    if uri_item:
-                        # there is an item in URI
-                        # we use it only if item is not already set
-                        # and item_last is not used either
-                        try:
-                            item = self.args.item
-                        except AttributeError:
-                            if not self.args.items:
-                                self.args.items = [uri_item]
-                        else:
-                            if not item:
-                                try:
-                                    item_last = self.args.item_last
-                                except AttributeError:
-                                    item_last = False
-                                if not item_last:
-                                    self.args.item = uri_item
-                else:
-                    self.parser.error(_(u'XMPP URL is not a pubsub one: {url}').format(url=url))
-        flags = self.args._cmd._pubsub_flags
-        # we check required arguments here instead of using add_arguments' required option
-        # because the required argument can be set in URL
-        if C.SERVICE in flags and not self.args.service:
-            self.parser.error(_(u"argument -s/--service is required"))
-        if C.NODE in flags and not self.args.node:
-            self.parser.error(_(u"argument -n/--node is required"))
-        if C.ITEM in flags and not self.args.item:
-            self.parser.error(_(u"argument -i/--item is required"))
-
-        # FIXME: mutually groups can't be nested in a group and don't support title
-        #        so we check conflict here. This may be fixed in Python 3, to be checked
-        try:
-            if self.args.item and self.args.item_last:
-                self.parser.error(_(u"--item and --item-last can't be used at the same time"))
-        except AttributeError:
-            pass
-
-    def run(self, args=None, namespace=None):
-        self.args = self.parser.parse_args(args, namespace=None)
-        if self.args._cmd._use_pubsub:
-            self.parse_pubsub_args()
-        try:
-            self.args._cmd.run()
-            if self._need_loop or self._auto_loop:
-                self._start_loop()
-        except KeyboardInterrupt:
-            log.info(_("User interruption: good bye"))
-
-    def _start_loop(self):
-        self.loop = JPLoop()
-        self.loop.run()
-
-    def stop_loop(self):
-        try:
-            self.loop.quit()
-        except AttributeError:
-            pass
-
-    def confirmOrQuit(self, message, cancel_message=_(u"action cancelled by user")):
-        """Request user to confirm action, and quit if he doesn't"""
-
-        res = raw_input("{} (y/N)? ".format(message))
-        if res not in ("y", "Y"):
-            self.disp(cancel_message)
-            self.quit(C.EXIT_USER_CANCELLED)
-
-    def quitFromSignal(self, errcode=0):
-        """Same as self.quit, but from a signal handler
-
-        /!\: return must be used after calling this method !
-        """
-        assert self._need_loop
-        # XXX: python-dbus will show a traceback if we exit in a signal handler
-        # so we use this little timeout trick to avoid it
-        self.loop.call_later(0, self.quit, errcode)
-
-    def quit(self, errcode=0):
-        # first the onQuitCallbacks
-        try:
-            callbacks_list = self._onQuitCallbacks
-        except AttributeError:
-            pass
-        else:
-            for callback, args, kwargs in callbacks_list:
-                callback(*args, **kwargs)
-
-        self.stop_loop()
-        sys.exit(errcode)
-
-    def check_jids(self, jids):
-        """Check jids validity, transform roster name to corresponding jids
-
-        @param profile: profile name
-        @param jids: list of jids
-        @return: List of jids
-
-        """
-        names2jid = {}
-        nodes2jid = {}
-
-        for contact in self.bridge.getContacts(self.profile):
-            jid_s, attr, groups = contact
-            _jid = JID(jid_s)
-            try:
-                names2jid[attr["name"].lower()] = jid_s
-            except KeyError:
-                pass
-
-            if _jid.node:
-                nodes2jid[_jid.node.lower()] = jid_s
-
-        def expand_jid(jid):
-            _jid = jid.lower()
-            if _jid in names2jid:
-                expanded = names2jid[_jid]
-            elif _jid in nodes2jid:
-                expanded = nodes2jid[_jid]
-            else:
-                expanded = jid
-            return expanded.decode('utf-8')
-
-        def check(jid):
-            if not jid.is_valid:
-                log.error (_("%s is not a valid JID !"), jid)
-                self.quit(1)
-
-        dest_jids=[]
-        try:
-            for i in range(len(jids)):
-                dest_jids.append(expand_jid(jids[i]))
-                check(dest_jids[i])
-        except AttributeError:
-            pass
-
-        return dest_jids
-
-    def connect_profile(self, callback):
-        """ Check if the profile is connected and do it if requested
-
-        @param callback: method to call when profile is connected
-        @exit: - 1 when profile is not connected and --connect is not set
-               - 1 when the profile doesn't exists
-               - 1 when there is a connection error
-        """
-        # FIXME: need better exit codes
-
-        def cant_connect(failure):
-            log.error(_(u"Can't connect profile: {reason}").format(reason=failure))
-            self.quit(1)
-
-        def cant_start_session(failure):
-            log.error(_(u"Can't start {profile}'s session: {reason}").format(profile=self.profile, reason=failure))
-            self.quit(1)
-
-        self.profile = self.bridge.profileNameGet(self.args.profile)
-
-        if not self.profile:
-            log.error(_("The profile [{profile}] doesn't exist").format(profile=self.args.profile))
-            self.quit(1)
-
-        try:
-            start_session = self.args.start_session
-        except AttributeError:
-            pass
-        else:
-            if start_session:
-                self.bridge.profileStartSession(self.args.pwd, self.profile, lambda dummy: callback(), cant_start_session)
-                self._auto_loop = True
-                return
-            elif not self.bridge.profileIsSessionStarted(self.profile):
-                if not self.args.connect:
-                    log.error(_(u"Session for [{profile}] is not started, please start it before using jp, or use either --start-session or --connect option").format(profile=self.profile))
-                    self.quit(1)
-            else:
-                callback()
-                return
-
-
-        if not hasattr(self.args, 'connect'):
-            # a profile can be present without connect option (e.g. on profile creation/deletion)
-            return
-        elif self.args.connect is True:  # if connection is asked, we connect the profile
-            self.bridge.connect(self.profile, self.args.pwd, {}, lambda dummy: callback(), cant_connect)
-            self._auto_loop = True
-            return
-        else:
-            if not self.bridge.isConnected(self.profile):
-                log.error(_(u"Profile [{profile}] is not connected, please connect it before using jp, or use --connect option").format(profile=self.profile))
-                self.quit(1)
-
-        callback()
-
-    def get_full_jid(self, param_jid):
-        """Return the full jid if possible (add main resource when find a bare jid)"""
-        _jid = JID(param_jid)
-        if not _jid.resource:
-            #if the resource is not given, we try to add the main resource
-            main_resource = self.bridge.getMainResource(param_jid, self.profile)
-            if main_resource:
-                return "%s/%s" % (_jid.bare, main_resource)
-        return param_jid
-
-
-class CommandBase(object):
-
-    def __init__(self, host, name, use_profile=True, use_output=False, extra_outputs=None,
-                       need_connect=None, help=None, **kwargs):
-        """Initialise CommandBase
-
-        @param host: Jp instance
-        @param name(unicode): name of the new command
-        @param use_profile(bool): if True, add profile selection/connection commands
-        @param use_output(bool, unicode): if not False, add --output option
-        @param extra_outputs(dict): list of command specific outputs:
-            key is output name ("default" to use as main output)
-            value is a callable which will format the output (data will be used as only argument)
-            if a key already exists with normal outputs, the extra one will be used
-        @param need_connect(bool, None): True if profile connection is needed
-            False else (profile session must still be started)
-            None to set auto value (i.e. True if use_profile is set)
-            Can't be set if use_profile is False
-        @param help(unicode): help message to display
-        @param **kwargs: args passed to ArgumentParser
-            use_* are handled directly, they can be:
-            - use_progress(bool): if True, add progress bar activation option
-                progress* signals will be handled
-            - use_verbose(bool): if True, add verbosity option
-            - use_pubsub(bool): if True, add pubsub options
-                mandatory arguments are controlled by pubsub_req
-            - use_draft(bool): if True, add draft handling options
-            ** other arguments **
-            - pubsub_flags(iterable[unicode]): tuple of flags to set pubsub options, can be:
-                C.SERVICE: service is required
-                C.NODE: node is required
-                C.SINGLE_ITEM: only one item is allowed
-        @attribute need_loop(bool): to set by commands when loop is needed
-        """
-        self.need_loop = False # to be set by commands when loop is needed
-        try: # If we have subcommands, host is a CommandBase and we need to use host.host
-            self.host = host.host
-        except AttributeError:
-            self.host = host
-
-        # --profile option
-        parents = kwargs.setdefault('parents', set())
-        if use_profile:
-            #self.host.parents['profile'] is an ArgumentParser with profile connection arguments
-            if need_connect is None:
-                need_connect = True
-            parents.add(self.host.parents['profile' if need_connect else 'profile_session'])
-        else:
-            assert need_connect is None
-        self.need_connect = need_connect
-        # from this point, self.need_connect is None if connection is not needed at all
-        # False if session starting is needed, and True if full connection is needed
-
-        # --output option
-        if use_output:
-            if extra_outputs is None:
-                extra_outputs = {}
-            self.extra_outputs = extra_outputs
-            if use_output == True:
-                use_output = C.OUTPUT_TEXT
-            assert use_output in C.OUTPUT_TYPES
-            self._output_type = use_output
-            output_parent = argparse.ArgumentParser(add_help=False)
-            choices = set(self.host.getOutputChoices(use_output))
-            choices.update(extra_outputs)
-            if not choices:
-                raise exceptions.InternalError("No choice found for {} output type".format(use_output))
-            try:
-                default = self.host.default_output[use_output]
-            except KeyError:
-                if u'default' in choices:
-                    default = u'default'
-                elif u'simple' in choices:
-                    default = u'simple'
-                else:
-                    default = list(choices)[0]
-            output_parent.add_argument('--output', '-O', choices=sorted(choices), default=default, help=_(u"select output format (default: {})".format(default)))
-            output_parent.add_argument('--output-option', '--oo', type=unicode_decoder, action="append", dest='output_opts', default=[], help=_(u"output specific option"))
-            parents.add(output_parent)
-        else:
-            assert extra_outputs is None
-
-        self._use_pubsub = kwargs.pop('use_pubsub', False)
-        if self._use_pubsub:
-            flags = kwargs.pop('pubsub_flags', [])
-            defaults = kwargs.pop('pubsub_defaults', {})
-            parents.add(self.host.make_pubsub_group(flags, defaults))
-            self._pubsub_flags = flags
-
-        # other common options
-        use_opts = {k:v for k,v in kwargs.iteritems() if k.startswith('use_')}
-        for param, do_use in use_opts.iteritems():
-            opt=param[4:] # if param is use_verbose, opt is verbose
-            if opt not in self.host.parents:
-                raise exceptions.InternalError(u"Unknown parent option {}".format(opt))
-            del kwargs[param]
-            if do_use:
-                parents.add(self.host.parents[opt])
-
-        self.parser = host.subparsers.add_parser(name, help=help, **kwargs)
-        if hasattr(self, "subcommands"):
-            self.subparsers = self.parser.add_subparsers()
-        else:
-            self.parser.set_defaults(_cmd=self)
-        self.add_parser_options()
-
-    @property
-    def args(self):
-        return self.host.args
-
-    @property
-    def profile(self):
-        return self.host.profile
-
-    @property
-    def verbosity(self):
-        return self.host.verbosity
-
-    @property
-    def progress_id(self):
-        return self.host.progress_id
-
-    @progress_id.setter
-    def progress_id(self, value):
-        self.host.progress_id = value
-
-    def progressStartedHandler(self, uid, metadata, profile):
-        if profile != self.profile:
-            return
-        if self.progress_id is None:
-            # the progress started message can be received before the id
-            # so we keep progressStarted signals in cache to replay they
-            # when the progress_id is received
-            cache_data = (self.progressStartedHandler, uid, metadata, profile)
-            try:
-                self.host.progress_ids_cache.append(cache_data)
-            except AttributeError:
-                self.host.progress_ids_cache = [cache_data]
-        else:
-            if self.host.watch_progress and uid == self.progress_id:
-                self.onProgressStarted(metadata)
-                self.host.loop.call_later(PROGRESS_DELAY, self.progressUpdate)
-
-    def progressFinishedHandler(self, uid, metadata, profile):
-        if profile != self.profile:
-            return
-        if uid == self.progress_id:
-            try:
-                self.host.pbar.finish()
-            except AttributeError:
-                pass
-            self.onProgressFinished(metadata)
-            if self.host.quit_on_progress_end:
-                self.host.quitFromSignal()
-
-    def progressErrorHandler(self, uid, message, profile):
-        if profile != self.profile:
-            return
-        if uid == self.progress_id:
-            if self.args.progress:
-                self.disp('') # progress is not finished, so we skip a line
-            if self.host.quit_on_progress_end:
-                self.onProgressError(message)
-                self.host.quitFromSignal(1)
-
-    def progressUpdate(self):
-        """This method is continualy called to update the progress bar"""
-        data = self.host.bridge.progressGet(self.progress_id, self.profile)
-        if data:
-            try:
-                size = data['size']
-            except KeyError:
-                self.disp(_(u"file size is not known, we can't show a progress bar"), 1, error=True)
-                return False
-            if self.host.pbar is None:
-                #first answer, we must construct the bar
-                self.host.pbar = progressbar.ProgressBar(max_value=int(size),
-                                                         widgets=[_(u"Progress: "),progressbar.Percentage(),
-                                                         " ",
-                                                         progressbar.Bar(),
-                                                         " ",
-                                                         progressbar.FileTransferSpeed(),
-                                                         " ",
-                                                         progressbar.ETA()])
-                self.host.pbar.start()
-
-            self.host.pbar.update(int(data['position']))
-
-        elif self.host.pbar is not None:
-            return False
-
-        self.onProgressUpdate(data)
-
-        return True
-
-    def onProgressStarted(self, metadata):
-        """Called when progress has just started
-
-        can be overidden by a command
-        @param metadata(dict): metadata as sent by bridge.progressStarted
-        """
-        self.disp(_(u"Operation started"), 2)
-
-    def onProgressUpdate(self, metadata):
-        """Method called on each progress updata
-
-        can be overidden by a command to handle progress metadata
-        @para metadata(dict): metadata as returned by bridge.progressGet
-        """
-        pass
-
-    def onProgressFinished(self, metadata):
-        """Called when progress has just finished
-
-        can be overidden by a command
-        @param metadata(dict): metadata as sent by bridge.progressFinished
-        """
-        self.disp(_(u"Operation successfully finished"), 2)
-
-    def onProgressError(self, error_msg):
-        """Called when a progress failed
-
-        @param error_msg(unicode): error message as sent by bridge.progressError
-        """
-        self.disp(_(u"Error while doing operation: {}").format(error_msg), error=True)
-
-    def disp(self, msg, verbosity=0, error=False, no_lf=False):
-        return self.host.disp(msg, verbosity, error, no_lf)
-
-    def output(self, data):
-        try:
-            output_type = self._output_type
-        except AttributeError:
-            raise exceptions.InternalError(_(u'trying to use output when use_output has not been set'))
-        return self.host.output(output_type, self.args.output, self.extra_outputs, data)
-
-    def exitCb(self, msg=None):
-        """generic callback for success
-
-        optionally print a message, and quit
-        msg(None, unicode): if not None, print this message
-        """
-        if msg is not None:
-            self.disp(msg)
-        self.host.quit(C.EXIT_OK)
-
-    def errback(self, failure_, msg=None, exit_code=C.EXIT_ERROR):
-        """generic callback for errbacks
-
-        display failure_ then quit with generic error
-        @param failure_: arguments returned by errback
-        @param msg(unicode, None): message template
-            use {} if you want to display failure message
-        @param exit_code(int): shell exit code
-        """
-        if msg is None:
-            msg = _(u"error: {}")
-        self.disp(msg.format(failure_), error=True)
-        self.host.quit(exit_code)
-
-    def add_parser_options(self):
-        try:
-            subcommands = self.subcommands
-        except AttributeError:
-            # We don't have subcommands, the class need to implements add_parser_options
-            raise NotImplementedError
-
-        # now we add subcommands to ourself
-        for cls in subcommands:
-            cls(self)
-
-    def run(self):
-        """this method is called when a command is actually run
-
-        It set stuff like progression callbacks and profile connection
-        You should not overide this method: you should call self.start instead
-        """
-        # we keep a reference to run command, it may be useful e.g. for outputs
-        self.host.command = self
-        # host._need_loop is set here from our current value and not before
-        # as the need_loop decision must be taken only by then running command
-        self.host._need_loop = self.need_loop
-
-        try:
-            show_progress = self.args.progress
-        except AttributeError:
-            # the command doesn't use progress bar
-            pass
-        else:
-            if show_progress:
-                self.host.watch_progress = True
-            # we need to register the following signal even if we don't display the progress bar
-            self.host.bridge.register_signal("progressStarted", self.progressStartedHandler)
-            self.host.bridge.register_signal("progressFinished", self.progressFinishedHandler)
-            self.host.bridge.register_signal("progressError", self.progressErrorHandler)
-
-        if self.need_connect is not None:
-             self.host.connect_profile(self.connected)
-        else:
-            self.start()
-
-    def connected(self):
-        """this method is called when profile is connected (or session is started)
-
-        this method is only called when use_profile is True
-        most of time you should override self.start instead of this method, but if loop
-        if not always needed depending on your arguments, you may override this method,
-        but don't forget to call the parent one (i.e. this one) after self.need_loop is set
-        """
-        if not self.need_loop:
-            self.host.stop_loop()
-        self.start()
-
-    def start(self):
-        """This is the starting point of the command, this method should be overriden
-
-        at this point, profile are connected if needed
-        """
-        pass
-
-
-class CommandAnswering(CommandBase):
-    """Specialised commands which answer to specific actions
-
-    to manage action_types answer,
-    """
-    action_callbacks = {} # XXX: set managed action types in a dict here:
-                          # key is the action_type, value is the callable
-                          # which will manage the answer. profile filtering is
-                          # already managed when callback is called
-
-    def __init__(self, *args, **kwargs):
-        super(CommandAnswering, self).__init__(*args, **kwargs)
-        self.need_loop = True
-
-    def onActionNew(self, action_data, action_id, security_limit, profile):
-        if profile != self.profile:
-            return
-        try:
-            action_type = action_data['meta_type']
-        except KeyError:
-            try:
-                xml_ui = action_data["xmlui"]
-            except KeyError:
-                pass
-            else:
-                self.onXMLUI(xml_ui)
-        else:
-            try:
-                callback = self.action_callbacks[action_type]
-            except KeyError:
-                pass
-            else:
-                callback(action_data, action_id, security_limit, profile)
-
-    def onXMLUI(self, xml_ui):
-        """Display a dialog received from the backend.
-
-        @param xml_ui (unicode): dialog XML representation
-        """
-        # FIXME: we temporarily use ElementTree, but a real XMLUI managing module
-        #        should be available in the future
-        # TODO: XMLUI module
-        ui = ET.fromstring(xml_ui.encode('utf-8'))
-        dialog = ui.find("dialog")
-        if dialog is not None:
-            self.disp(dialog.findtext("message"), error=dialog.get("level") == "error")
-
-    def connected(self):
-        """Auto reply to confirmations requests"""
-        self.need_loop = True
-        super(CommandAnswering, self).connected()
-        self.host.bridge.register_signal("actionNew", self.onActionNew)
-        actions = self.host.bridge.actionsGet(self.profile)
-        for action_data, action_id, security_limit in actions:
-            self.onActionNew(action_data, action_id, security_limit, self.profile)

--- a/frontends/src/jp/cmd_account.py	Mon Apr 02 08:56:24 2018 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,132 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-
-# jp: a SAT command line tool
-# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-"""This module permits to manage XMPP accounts using in-band registration (XEP-0077)"""
-
-from sat_frontends.jp.constants import Const as C
-from sat.core.log import getLogger
-log = getLogger(__name__)
-from sat.core.i18n import _
-from sat_frontends.jp import base
-from sat_frontends.tools import jid
-
-__commands__ = ["Account"]
-
-
-class AccountCreate(base.CommandBase):
-
-    def __init__(self, host):
-        super(AccountCreate, self).__init__(host, 'create', use_profile=False, use_verbose=True, help=_(u'create a XMPP account'))
-        self.need_loop = True
-
-    def add_parser_options(self):
-        self.parser.add_argument('jid', type=base.unicode_decoder, help=_(u'jid to create'))
-        self.parser.add_argument('password', type=base.unicode_decoder, help=_(u'password of the account'))
-        self.parser.add_argument('-p', '--profile', type=base.unicode_decoder, help=_(u"create a profile to use this account (default: don't create profile)"))
-        self.parser.add_argument('-e', '--email', type=base.unicode_decoder, default="", help=_(u"email (usage depends of XMPP server)"))
-        self.parser.add_argument('-H', '--host', type=base.unicode_decoder, default="", help=_(u"server host (IP address or domain, default: use localhost)"))
-        self.parser.add_argument('-P', '--port', type=int, default=0, help=_(u"server port (IP address or domain, default: use localhost)"))
-
-    def _setParamCb(self):
-        self.host.bridge.setParam("Password", self.args.password, "Connection", profile_key=self.args.profile, callback=self.host.quit, errback=self.errback)
-
-    def _session_started(self, dummy):
-        self.host.bridge.setParam("JabberID", self.args.jid, "Connection", profile_key=self.args.profile, callback=self._setParamCb, errback=self.errback)
-
-    def _profileCreateCb(self):
-        self.disp(_(u"profile created"), 1)
-        self.host.bridge.profileStartSession(self.args.password, self.args.profile, callback=self._session_started, errback=self.errback)
-
-    def _profileCreateEb(self, failure_):
-        self.disp(_(u"Can't create profile {profile} to associate with jid {jid}: {msg}").format(
-            profile = self.args.profile,
-            jid = self.args.jid,
-            msg = failure_), error=True)
-        self.host.quit(C.EXIT_BRIDGE_ERRBACK)
-
-    def accountNewCb(self):
-        self.disp(_(u"XMPP account created"), 1)
-        if self.args.profile is not None:
-            self.disp(_(u"creating profile"), 2)
-            self.host.bridge.profileCreate(self.args.profile, self.args.password, "", callback=self._profileCreateCb, errback=self._profileCreateEb)
-        else:
-            self.host.quit()
-
-    def accountNewEb(self, failure_):
-        self.disp(_(u"Can't create new account on server {host} with jid {jid}: {msg}").format(
-            host = self.args.host or u"localhost",
-            jid = self.args.jid,
-            msg = failure_), error=True)
-        self.host.quit(C.EXIT_BRIDGE_ERRBACK)
-
-    def start(self):
-        self.host.bridge.inBandAccountNew(self.args.jid, self.args.password, self.args.email, self.args.host, self.args.port,
-            callback=self.accountNewCb, errback=self.accountNewEb)
-
-
-
-class AccountModify(base.CommandBase):
-
-    def __init__(self, host):
-        super(AccountModify, self).__init__(host, 'modify', help=_(u'change password for XMPP account'))
-        self.need_loop = True
-
-    def add_parser_options(self):
-        self.parser.add_argument('password', type=base.unicode_decoder, help=_(u'new XMPP password'))
-
-    def start(self):
-        self.host.bridge.inBandPasswordChange(self.args.password, self.args.profile,
-            callback=self.host.quit, errback=self.errback)
-
-
-class AccountDelete(base.CommandBase):
-
-    def __init__(self, host):
-        super(AccountDelete, self).__init__(host, 'delete', help=_(u'delete a XMPP account'))
-        self.need_loop = True
-
-    def add_parser_options(self):
-        self.parser.add_argument('-f', '--force', action='store_true', help=_(u'delete account without confirmation'))
-
-    def _got_jid(self, jid_str):
-        jid_ = jid.JID(jid_str)
-        if not self.args.force:
-            message = (u"You are about to delete the XMPP account with jid {jid_}\n"
-                       u"This is the XMPP account of profile \"{profile}\"\n"
-                       u"Are you sure that you want to delete this account ?".format(
-                      jid_ = jid_,
-                      profile=self.profile
-                      ))
-            res = raw_input("{} (y/N)? ".format(message))
-            if res not in ("y", "Y"):
-                self.disp(_(u"Account deletion cancelled"))
-                self.host.quit(2)
-        self.host.bridge.inBandUnregister(jid_.domain, self.args.profile,
-            callback=self.host.quit, errback=self.errback)
-
-    def start(self):
-        self.host.bridge.asyncGetParamA("JabberID", "Connection", profile_key=self.profile,
-                                        callback=self._got_jid, errback=self.errback)
-
-
-class Account(base.CommandBase):
-    subcommands = (AccountCreate, AccountModify, AccountDelete)
-
-    def __init__(self, host):
-        super(Account, self).__init__(host, 'account', use_profile=False, help=(u'XMPP account management'))

--- a/frontends/src/jp/cmd_adhoc.py	Mon Apr 02 08:56:24 2018 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,138 +0,0 @@
-#!/usr/bin/env python2
-# -*- coding: utf-8 -*-
-
-# jp: a SAT command line tool
-# Copyright (C) 2009-2018 Jérôme Poisson (goffi@goffi.org)
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-import base
-from sat.core.i18n import _
-from functools import partial
-from sat_frontends.jp.constants import Const as C
-from sat_frontends.jp import xmlui_manager
-
-__commands__ = ["AdHoc"]
-
-FLAG_LOOP = 'LOOP'
-MAGIC_BAREJID = '@PROFILE_BAREJID@'
-
-
-class Remote(base.CommandBase):
-    def __init__(self, host):
-        super(Remote, self).__init__(host, 'remote', use_verbose=True, help=_(u'remote control a software'))
-
-    def add_parser_options(self):
-        self.parser.add_argument("software", type=str, help=_(u"software name"))
-        self.parser.add_argument("-j", "--jids", type=base.unicode_decoder, nargs='*', default=[], help=_(u"jids allowed to use the command"))
-        self.parser.add_argument("-g", "--groups", type=base.unicode_decoder, nargs='*', default=[], help=_(u"groups allowed to use the command"))
-        self.parser.add_argument("--forbidden-groups", type=base.unicode_decoder, nargs='*', default=[], help=_(u"groups that are *NOT* allowed to use the command"))
-        self.parser.add_argument("--forbidden-jids", type=base.unicode_decoder, nargs='*', default=[], help=_(u"jids that are *NOT* allowed to use the command"))
-        self.parser.add_argument("-l", "--loop", action="store_true", help=_(u"loop on the commands"))
-
-    def start(self):
-        name = self.args.software.lower()
-        flags = []
-        magics = {jid for jid in self.args.jids if jid.count('@')>1}
-        magics.add(MAGIC_BAREJID)
-        jids = set(self.args.jids).difference(magics)
-        if self.args.loop:
-            flags.append(FLAG_LOOP)
-        bus_name, methods = self.host.bridge.adHocDBusAddAuto(name, jids, self.args.groups, magics,
-                                                              self.args.forbidden_jids, self.args.forbidden_groups,
-                                                              flags, self.profile)
-        if not bus_name:
-            self.disp(_("No bus name found"), 1)
-            return
-        self.disp(_("Bus name found: [%s]" % bus_name), 1)
-        for method in methods:
-            path, iface, command = method
-            self.disp(_("Command found: (path:%(path)s, iface: %(iface)s) [%(command)s]" % {'path': path,
-                                                                                         'iface': iface,
-                                                                                         'command': command
-                                                                                         }),1)
-
-
-class Run(base.CommandBase):
-    """Run an Ad-Hoc command"""
-
-    def __init__(self, host):
-        super(Run, self).__init__(host, 'run', use_verbose=True, help=_(u'run an Ad-Hoc command'))
-        self.need_loop=True
-
-    def add_parser_options(self):
-        self.parser.add_argument('-j', '--jid', type=base.unicode_decoder, default=u'', help=_(u"jid of the service (default: profile's server"))
-        self.parser.add_argument("-S", "--submit", action='append_const', const=xmlui_manager.SUBMIT, dest='workflow', help=_(u"submit form/page"))
-        self.parser.add_argument("-f",
-            "--field",
-            type=base.unicode_decoder,
-            action='append',
-            nargs=2,
-            dest='workflow',
-            metavar=(u"KEY", u"VALUE"),
-            help=_(u"field value"))
-        self.parser.add_argument('node', type=base.unicode_decoder, nargs='?', default=u'', help=_(u"node of the command (default: list commands)"))
-
-    def adHocRunCb(self, xmlui_raw):
-        xmlui = xmlui_manager.create(self.host, xmlui_raw)
-        workflow = self.args.workflow
-        xmlui.show(workflow)
-        if not workflow:
-            if xmlui.type == 'form':
-                xmlui.submitForm()
-            else:
-                self.host.quit()
-
-    def start(self):
-        self.host.bridge.adHocRun(
-            self.args.jid,
-            self.args.node,
-            self.profile,
-            callback=self.adHocRunCb,
-            errback=partial(self.errback,
-                            msg=_(u"can't get ad-hoc commands list: {}"),
-                            exit_code=C.EXIT_BRIDGE_ERRBACK))
-
-
-class List(base.CommandBase):
-    """Run an Ad-Hoc command"""
-
-    def __init__(self, host):
-        super(List, self).__init__(host, 'list', use_verbose=True, help=_(u'list Ad-Hoc commands of a service'))
-        self.need_loop=True
-
-    def add_parser_options(self):
-        self.parser.add_argument('-j', '--jid', type=base.unicode_decoder, default=u'', help=_(u"jid of the service (default: profile's server"))
-
-    def adHocListCb(self, xmlui_raw):
-        xmlui = xmlui_manager.create(self.host, xmlui_raw)
-        xmlui.readonly = True
-        xmlui.show()
-        self.host.quit()
-
-    def start(self):
-        self.host.bridge.adHocList(
-            self.args.jid,
-            self.profile,
-            callback=self.adHocListCb,
-            errback=partial(self.errback,
-                            msg=_(u"can't get ad-hoc commands list: {}"),
-                            exit_code=C.EXIT_BRIDGE_ERRBACK))
-
-
-class AdHoc(base.CommandBase):
-    subcommands = (Run, List, Remote)
-
-    def __init__(self, host):
-        super(AdHoc, self).__init__(host, 'ad-hoc', use_profile=False, help=_('Ad-hoc commands'))