diff --git a/inc/lektor/commands.h b/inc/lektor/commands.h
index ed1ec82f99299fac807c4b29a9d29d161c101bc3..aa6681bc32d12049d1f5bfc554ff7fa911c442a2 100644
--- a/inc/lektor/commands.h
+++ b/inc/lektor/commands.h
@@ -1,5 +1,4 @@
-#if !defined(LKT_COMMANDS_H__)
-#define LKT_COMMANDS_H__
+#pragma once
 
 #if defined(__cplusplus)
 extern "C" {
@@ -11,6 +10,8 @@ extern "C" {
 
 /* NOTE: Not a callable command */
 bool command_set_pos(struct lkt_state *srv, int index);
+bool command_add(struct lkt_state *srv, char *[LKT_MESSAGE_ARGS_MAX], int priority);
+bool command_rescan(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int forced);
 
 // clang-format off
 
@@ -20,71 +21,70 @@ bool command_set_pos(struct lkt_state *srv, int index);
  * <https://www.musicpd.org/doc/html/protocol.html> */
 
 /* Querying lektor's status */
-bool command_currentsong(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_status     (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_stats      (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_currentsong(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_status     (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_stats      (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 /* Controlling playback */
-bool command_next    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_pause   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_previous(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_play    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_playid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_stop    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_next    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_pause   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_previous(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_play    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_playid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_stop    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
-bool command_seek    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_seekid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_seekcur (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_seek    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_seekid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_seekcur (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 /* The queue */
-bool command_add    (struct lkt_state *srv, char *[LKT_MESSAGE_ARGS_MAX], int priority);
-bool command_addid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_del    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_delid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_clear  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_crop   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_move   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_shuffle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_dump   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_swap   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_swapid (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_flat   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_addid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_del    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_delid  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_clear  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_crop   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_move   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_shuffle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_dump   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_swap   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_swapid (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_flat   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 PRIVATE_FUNCTION bool
-command_add_1(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_add_1(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     return command_add(srv, args, 1);
 }
 
 PRIVATE_FUNCTION bool
-command_add_5(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_add_5(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     return command_add(srv, args, 5);
 }
 
-bool command_queue_list  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_queue_listid(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_queue_list  (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_queue_listid(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 /* The playlists */
-bool command_plt_create (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_plt_remove (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_plt_clear  (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_plt_rename (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_plt_export (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_plt_import (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_plt_add    (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_plt_add_uri(struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_plt_create (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_plt_remove (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_plt_clear  (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_plt_rename (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_plt_export (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_plt_import (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_plt_add    (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
+bool command_plt_add_uri(struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 bool command_plt_list   (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 bool command_plt_ctx    (struct lkt_state *srv, size_t, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 /* The help */
-bool command_help(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_help(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 /* Respond to the idle command */
-bool command_idle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_idle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 /* Cancel the call to the `idle` command. */
-bool command_noidle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_noidle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int cont);
 
 /* Find and send karas in the db that match the search expression */
 bool command_find(struct lkt_state *srv, size_t c, char *cmd_args[LKT_MESSAGE_ARGS_MAX],
@@ -104,57 +104,56 @@ typedef enum {
 bool command_set_playback_option(struct lkt_state *, size_t, LKT_PLAYBACK_OPTION, char *[LKT_MESSAGE_ARGS_MAX]);
 
 PRIVATE_FUNCTION bool
-command_set_playback_option_random(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_set_playback_option_random(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     return command_set_playback_option(srv, c, LKT_PLAYBACK_OPTION_RANDOM, args);
 }
 
 PRIVATE_FUNCTION bool
-command_set_playback_option_repeat(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_set_playback_option_repeat(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     return command_set_playback_option(srv, c, LKT_PLAYBACK_OPTION_REPEAT, args);
 }
 
 PRIVATE_FUNCTION bool
-command_set_playback_option_volume(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_set_playback_option_volume(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     return command_set_playback_option(srv, c, LKT_PLAYBACK_OPTION_VOLUME, args);
 }
 
 PRIVATE_FUNCTION bool
-command_set_playback_option_single(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_set_playback_option_single(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     return command_set_playback_option(srv, c, LKT_PLAYBACK_OPTION_SINGLE, args);
 }
 
 PRIVATE_FUNCTION bool
-command_set_playback_option_consume(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_set_playback_option_consume(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     return command_set_playback_option(srv, c, LKT_PLAYBACK_OPTION_CONSUME, args);
 }
 
 /* Authentificate users */
-bool command_password(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_user_add(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_password(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
+bool command_user_add(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
 
 /* Program management control */
-bool command_restart   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_kill      (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_dry_update(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_import    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_update    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
-bool command_rescan    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int forced);
-bool command_config    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_restart   (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
+bool command_kill      (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
+bool command_dry_update(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
+bool command_import    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
+bool command_update    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
+bool command_config    (struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
 
 PRIVATE_FUNCTION bool
-command_rescan_true(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX])
+command_rescan_true(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     /* Force the rescan, don't check timestamps */
     return command_rescan(srv, c, argv, true);
 }
 
 PRIVATE_FUNCTION bool
-command_rescan_false(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX])
+command_rescan_false(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     /* Don't force the rescan, check timestamps */
     return command_rescan(srv, c, argv, false);
@@ -162,11 +161,10 @@ command_rescan_false(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARG
 
 /* Sticker management. Handle all the sticker commands, the sticker command in
  * MPD is has a lot of subcommands... */
-bool command_sticker_handle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX]);
+bool command_sticker_handle(struct lkt_state *srv, size_t c, char *[LKT_MESSAGE_ARGS_MAX], int UNUSED cont);
 
 // clang-format on
 
 #if defined(__cplusplus)
 }
 #endif
-#endif /* LKT_COMMANDS_H__ */
diff --git a/inc/lektor/internal/commands.def b/inc/lektor/internal/commands.def
index 5999becbeedbbb75b1ba143552cbbf66f888c4fb..6828306de22e5e51cac8e59cfb41bf3e40284685 100644
--- a/inc/lektor/internal/commands.def
+++ b/inc/lektor/internal/commands.def
@@ -1,64 +1,64 @@
-mpd_command("currentsong",       command_currentsong,      SIMPLE)
-mpd_command("status",            command_status,           SIMPLE)
-mpd_command("stats",             command_stats,            SIMPLE)
-mpd_command("help",              command_help,             SIMPLE)
+mpd_command("currentsong",       command_currentsong)
+mpd_command("status",            command_status)
+mpd_command("stats",             command_stats)
+mpd_command("help",              command_help)
 
-mpd_command("next",              command_next,             SIMPLE)
-mpd_command("previous",          command_previous,         SIMPLE)
-mpd_command("pause",             command_pause,            SIMPLE)
-mpd_command("play",              command_play,             SIMPLE)
-mpd_command("playid",            command_playid,           SIMPLE)
-mpd_command("stop",              command_stop,             SIMPLE)
-mpd_command("seek",              command_seek,             SIMPLE)
-mpd_command("seekid",            command_seekid,           SIMPLE)
-mpd_command("seekcur",           command_seekcur,          SIMPLE)
+mpd_command("next",              command_next)
+mpd_command("previous",          command_previous)
+mpd_command("pause",             command_pause)
+mpd_command("play",              command_play)
+mpd_command("playid",            command_playid)
+mpd_command("stop",              command_stop)
+mpd_command("seek",              command_seek)
+mpd_command("seekid",            command_seekid)
+mpd_command("seekcur",           command_seekcur)
 
-mpd_command("__insert",          command_add_5,            SIMPLE)
-mpd_command("add",               command_add_1,            SIMPLE)
-mpd_command("searchadd",         command_add_1,            SIMPLE)
-mpd_command("findadd",           command_add_1,            SIMPLE)
-mpd_command("addid",             command_addid,            SIMPLE)
-mpd_command("delete",            command_del,              SIMPLE)
-mpd_command("deleteid",          command_delid,            SIMPLE)
-mpd_command("clear",             command_clear,            SIMPLE)
-mpd_command("crop",              command_crop,             SIMPLE)
-mpd_command("move",              command_move,             SIMPLE)
-mpd_command("shuffle",           command_shuffle,          SIMPLE)
-mpd_command("swap",              command_swap,             SIMPLE)
-mpd_command("swapid",            command_swapid,           SIMPLE)
-mpd_command("__flat",            command_flat,             SIMPLE)
+mpd_command("__insert",          command_add_5)
+mpd_command("add",               command_add_1)
+mpd_command("searchadd",         command_add_1)
+mpd_command("findadd",           command_add_1)
+mpd_command("addid",             command_addid)
+mpd_command("delete",            command_del)
+mpd_command("deleteid",          command_delid)
+mpd_command("clear",             command_clear)
+mpd_command("crop",              command_crop)
+mpd_command("move",              command_move)
+mpd_command("shuffle",           command_shuffle)
+mpd_command("swap",              command_swap)
+mpd_command("swapid",            command_swapid)
+mpd_command("__flat",            command_flat)
 
-mpd_command("playlistid",        command_queue_listid,     SIMPLE)
-mpd_command("playlist",          command_queue_list,       SIMPLE)
-mpd_command("playlistinfo",      command_queue_list,       SIMPLE)
+mpd_command("playlistid",        command_queue_listid)
+mpd_command("playlist",          command_queue_list)
+mpd_command("playlistinfo",      command_queue_list)
 
-mpd_command("playlistclear",     command_plt_clear,        SIMPLE)
-mpd_command("rename",            command_plt_rename,       SIMPLE)
-mpd_command("playlistdelete",    command_plt_remove,       SIMPLE)
-mpd_command("rm",                command_plt_remove,       SIMPLE)
-mpd_command("playlistadd",       command_plt_add,          SIMPLE)
-mpd_command("save",              command_plt_export,       SIMPLE)
-mpd_command("__plt_import",      command_plt_import,       SIMPLE)
-mpd_command("__dump",            command_dump,             SIMPLE)
-mpd_command("listplaylists",     command_plt_list,         CONTINUATION)
-mpd_command("listplaylist",      command_plt_ctx,          CONTINUATION)
-mpd_command("sticker",           command_sticker_handle,   SIMPLE)
+mpd_command("playlistclear",     command_plt_clear)
+mpd_command("rename",            command_plt_rename)
+mpd_command("playlistdelete",    command_plt_remove)
+mpd_command("rm",                command_plt_remove)
+mpd_command("playlistadd",       command_plt_add)
+mpd_command("save",              command_plt_export)
+mpd_command("__plt_import",      command_plt_import)
+mpd_command("__dump",            command_dump)
+mpd_command("listplaylists",     command_plt_list)
+mpd_command("listplaylist",      command_plt_ctx)
+mpd_command("sticker",           command_sticker_handle)
 
-mpd_command("password",          command_password,         SIMPLE)
-mpd_command("__adduser",         command_user_add,         SIMPLE)
-mpd_command("__restart",         command_restart,          SIMPLE)
-mpd_command("kill",              command_kill,             SIMPLE)
-mpd_command("__import",          command_import,           SIMPLE)
-mpd_command("__rescan",          command_rescan_true,      SIMPLE)
-mpd_command("update",            command_update,           SIMPLE)
-mpd_command("__dry_update",      command_dry_update,       SIMPLE)
-mpd_command("rescan",            command_rescan_false,     SIMPLE)
-mpd_command("config",            command_config,           SIMPLE)
+mpd_command("password",          command_password)
+mpd_command("__adduser",         command_user_add)
+mpd_command("__restart",         command_restart)
+mpd_command("kill",              command_kill)
+mpd_command("__import",          command_import)
+mpd_command("__rescan",          command_rescan_true)
+mpd_command("update",            command_update)
+mpd_command("__dry_update",      command_dry_update)
+mpd_command("rescan",            command_rescan_false)
+mpd_command("config",            command_config)
 
-mpd_command("random",            command_set_playback_option_random,  SIMPLE)
-mpd_command("repeat",            command_set_playback_option_repeat,  SIMPLE)
-mpd_command("setvol",            command_set_playback_option_volume,  SIMPLE)
-mpd_command("single",            command_set_playback_option_single,  SIMPLE)
-mpd_command("consume",           command_set_playback_option_consume, SIMPLE)
+mpd_command("random",            command_set_playback_option_random)
+mpd_command("repeat",            command_set_playback_option_repeat)
+mpd_command("setvol",            command_set_playback_option_volume)
+mpd_command("single",            command_set_playback_option_single)
+mpd_command("consume",           command_set_playback_option_consume)
 
 // vi:syntax=c
diff --git a/src/base/commands.c b/src/base/commands.c
index cdfabdbb24a8159bf65a4a5bdee6320d8ff60347..54ac40dd9935427e1155d81a08b133303e4f2bf4 100644
--- a/src/base/commands.c
+++ b/src/base/commands.c
@@ -8,7 +8,8 @@
 #include <poll.h>
 
 bool
-command_restart(struct lkt_state *srv, size_t c, char UNUSED *__argv[LKT_MESSAGE_ARGS_MAX])
+command_restart(struct lkt_state *srv, size_t c, char UNUSED *__argv[LKT_MESSAGE_ARGS_MAX],
+                int UNUSED cont)
 {
     const char *const argv[] = { cmd_get_executable_name(), NULL };
     struct lkt_queue_state sta;
@@ -39,7 +40,7 @@ command_restart(struct lkt_state *srv, size_t c, char UNUSED *__argv[LKT_MESSAGE
 }
 
 bool
-command_update(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX])
+command_update(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     RETURN_UNLESS(lkt_client_auth(srv, c, false), "Failed to authentificate user", false);
     srv->mpd_idle_events |= MPD_IDLE_UPDATE;
@@ -56,7 +57,8 @@ command_update(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX]
 }
 
 bool
-command_dry_update(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX])
+command_dry_update(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX],
+                   int UNUSED cont)
 {
     RETURN_UNLESS(lkt_client_auth(srv, c, false), "Failed to authentificate user", false);
     srv->mpd_idle_events |= MPD_IDLE_UPDATE;
@@ -65,7 +67,8 @@ command_dry_update(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAG
 }
 
 bool
-command_import(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX])
+command_import(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX],
+               int UNUSED cont)
 {
     RETURN_UNLESS(lkt_client_auth(srv, c, false), "Failed to authentificate user", false);
     srv->mpd_idle_events |= MPD_IDLE_UPDATE;
@@ -84,7 +87,8 @@ command_rescan(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_AR
 }
 
 bool
-command_kill(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX])
+command_kill(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     RETURN_UNLESS(lkt_client_auth(srv, c, false), "Failed to authentificate user", false);
     srv->___signal_INT(srv);
@@ -92,7 +96,8 @@ command_kill(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS
 }
 
 bool
-command_config(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX])
+command_config(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_ARGS_MAX],
+               int UNUSED cont)
 {
     RETURN_UNLESS(lkt_client_auth(srv, c, false), "Failed to authentificate user", false);
     struct lkt_message *out;
@@ -108,7 +113,8 @@ command_config(struct lkt_state *srv, size_t c, char UNUSED *argv[LKT_MESSAGE_AR
 }
 
 bool
-command_currentsong(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_currentsong(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+                    int UNUSED cont)
 {
     struct lkt_message *out;
     struct kara_metadata kara;
@@ -131,7 +137,8 @@ command_currentsong(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSA
 }
 
 bool
-command_stats(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_stats(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+              int UNUSED cont)
 {
     int artists = 0, albums = 0, songs = 0;
     long ts_update          = 0;
@@ -161,7 +168,8 @@ command_stats(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARG
 }
 
 bool
-command_status(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_status(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+               int UNUSED cont)
 {
     struct lkt_queue_state queue_state;
     int elapsed, duration, songid = 0;
@@ -198,13 +206,13 @@ command_status(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_AR
 }
 
 bool
-command_next(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_next(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX], int cont)
 {
     srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     char filepath[PATH_MAX];
     if (!database_queue_next(srv->db, filepath)) {
         LOG_DEBUG("COMMAND", "Failed to get next, stop the player for end of queue");
-        command_stop(srv, c, NULL);
+        command_stop(srv, c, NULL, cont);
         return false;
     }
     if (MOD_CALL(srv->window_mod, "load", filepath))
@@ -217,7 +225,7 @@ command_next(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSA
 }
 
 bool
-command_pause(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_pause(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int cont)
 {
     /* The simple toggle version */
     if ((!args) || (args && !args[0])) {
@@ -241,7 +249,7 @@ command_pause(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARG
         /* Play! */
         if (queue.current < 0) {
             LOG_DEBUG("COMMAND", "Not playing anything, force play from begening of the queue");
-            return command_play(srv, c, NULL);
+            return command_play(srv, c, NULL, cont);
         }
 
         /* Set play/unpause or the pause */
@@ -261,7 +269,8 @@ command_pause(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARG
 }
 
 bool
-command_previous(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_previous(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+                 int UNUSED cont)
 {
     srv->mpd_idle_events |= MPD_IDLE_PLAYER;
     char filepath[PATH_MAX];
@@ -291,7 +300,8 @@ __play_that_file(struct lkt_state *win, int pos)
 }
 
 bool
-command_play(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_play(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     char *endptr = NULL, err;
     long pos     = 1;
@@ -326,7 +336,8 @@ command_play(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS
 }
 
 bool
-command_dump(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_dump(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     RETURN_UNLESS(args[0], "Invalid argument", false);
     srv->mpd_idle_events |= MPD_IDLE_PLAYER;
@@ -334,7 +345,8 @@ command_dump(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS
 }
 
 bool
-command_playid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_playid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+               int UNUSED cont)
 {
     char *endptr = NULL;
     int pos      = 0;
@@ -362,7 +374,8 @@ command_playid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_AR
 }
 
 bool
-command_stop(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_stop(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     RETURN_UNLESS(database_queue_stop(srv->db), "DB error on stop", false);
     MOD_PROC(srv->window_mod, "close");
@@ -385,7 +398,8 @@ command_add(struct lkt_state *srv, char *args[LKT_MESSAGE_ARGS_MAX], int priorit
 }
 
 bool
-command_addid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_addid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+              int UNUSED cont)
 {
     RETURN_UNLESS(args, "Invalid argument", false);
     bool error  = false;
@@ -422,21 +436,23 @@ end_of_function:
 }
 
 bool
-command_clear(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_clear(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX], int cont)
 {
     srv->mpd_idle_events |= MPD_IDLE_PLAYLIST;
-    return command_stop(srv, c, args) && database_queue_clear(srv->db);
+    return command_stop(srv, c, args, cont) && database_queue_clear(srv->db);
 }
 
 bool
-command_crop(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_crop(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     srv->mpd_idle_events |= MPD_IDLE_PLAYLIST;
     return database_queue_crop(srv->db);
 }
 
 bool
-command_flat(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_flat(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     srv->mpd_idle_events |= MPD_IDLE_PLAYLIST;
     return database_queue_flat(srv->db);
@@ -466,7 +482,8 @@ skip_current_kara__(struct lkt_state *srv)
 }
 
 bool
-command_del(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_del(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+            int UNUSED cont)
 {
     struct lkt_queue_state queue = { .current = -2 /* Really need this field only */ };
     long pos                     = -1;
@@ -486,7 +503,8 @@ command_del(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_
 }
 
 bool
-command_delid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_delid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+              int UNUSED cont)
 {
     long id;
     char *endptr = NULL, err = 0;
@@ -504,7 +522,8 @@ command_delid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARG
 }
 
 bool
-command_move(struct lkt_state UNUSED *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_move(struct lkt_state UNUSED *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     long from, to;
     char *endptr = NULL, err;
@@ -524,7 +543,7 @@ command_move(struct lkt_state UNUSED *srv, UNUSED size_t c, char *args[LKT_MESSA
 }
 
 static bool
-__swap_positions(struct lkt_state *srv, int from, int to)
+swap_positions__(struct lkt_state *srv, int from, int to)
 {
     RETURN_IF(to == from, "Can't swap with two identic positions", false);
 
@@ -542,7 +561,7 @@ __swap_positions(struct lkt_state *srv, int from, int to)
         LOG_ERROR("COMMAND", "Failed to set current index to new location");
         if (!database_queue_swap(srv->db, from, to)) {
             LOG_ERROR("COMMAND", "Reswap failed, uncertain state! Stopping the playback");
-            command_stop(srv, 0, NULL);
+            command_stop(srv, 0, NULL, 0);
         }
         return false;
     }
@@ -551,16 +570,18 @@ __swap_positions(struct lkt_state *srv, int from, int to)
 }
 
 bool
-command_swapid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_swapid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+               int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     int from = database_queue_probe_id(srv->db, (int)strtol(args[0], NULL, 0));
     int to   = database_queue_probe_id(srv->db, (int)strtol(args[1], NULL, 0));
-    return __swap_positions(srv, from, to);
+    return swap_positions__(srv, from, to);
 }
 
 bool
-command_swap(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_swap(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     long from, to;
     char *endptr = NULL, err = 0;
@@ -575,18 +596,19 @@ command_swap(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS
     STRTOL(to, args[1], endptr, err);
     RETURN_IF(err, "STRTOL failed", false);
 
-    return __swap_positions(srv, (int)from, (int)to);
+    return swap_positions__(srv, (int)from, (int)to);
 }
 
 bool
-command_help(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_help(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     lkt_state_send(srv, c, lkt_message_new_fmt("HELP\n"));
     return true;
 }
 
 bool
-command_idle(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_idle(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     bool once;
     size_t i;
@@ -618,7 +640,8 @@ command_idle(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
 }
 
 bool
-command_noidle(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_noidle(struct lkt_state *srv, size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+               int UNUSED cont)
 {
     lkt_client_clear_mask(srv, c);
     return true;
@@ -842,7 +865,8 @@ command_set_pos(struct lkt_state *srv, int index)
 }
 
 bool
-command_seek(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_seek(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+             int UNUSED cont)
 {
     long pos, seconds, err_flag = 0;
     char *endptr = NULL;
@@ -860,7 +884,8 @@ command_seek(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS
 }
 
 bool
-command_seekid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_seekid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+               int UNUSED cont)
 {
     long id, seconds, err_flag = 0;
     char *endptr = NULL;
@@ -883,7 +908,8 @@ command_seekid(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_AR
 }
 
 bool
-command_seekcur(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_seekcur(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+                int UNUSED cont)
 {
     long seconds, err_flag = 0;
     char *endptr = NULL;
@@ -897,7 +923,8 @@ command_seekcur(struct lkt_state *srv, UNUSED size_t c, char *args[LKT_MESSAGE_A
 }
 
 bool
-command_plt_add(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_plt_add(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX],
+                int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
     bool ret = false;
@@ -929,7 +956,8 @@ command_plt_add(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_A
 }
 
 bool
-command_plt_remove(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_plt_remove(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX],
+                   int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
     char *endptr = NULL, err;
@@ -947,7 +975,8 @@ command_plt_remove(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAG
 }
 
 bool
-command_plt_clear(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_plt_clear(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX],
+                  int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0], "Invalid argument", false);
     RETURN_UNLESS(database_plt_clear(srv->db, args[0]), "Failed to clear playlist", false);
@@ -956,7 +985,8 @@ command_plt_clear(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE
 }
 
 bool
-command_plt_rename(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_plt_rename(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX],
+                   int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_plt_rename(srv->db, args[0], args[1]), "Failed to rename playlist",
@@ -966,7 +996,8 @@ command_plt_rename(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAG
 }
 
 bool
-command_plt_export(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_plt_export(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX],
+                   int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_attach(srv->db, args[0], args[1]), "Failed to attach database", false);
@@ -978,7 +1009,8 @@ command_plt_export(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAG
 }
 
 bool
-command_plt_import(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_plt_import(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX],
+                   int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     RETURN_UNLESS(database_attach(srv->db, args[0], args[1]), "Failed to attach database", false);
@@ -990,7 +1022,8 @@ command_plt_import(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAG
 }
 
 bool
-command_plt_add_uri(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_plt_add_uri(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSAGE_ARGS_MAX],
+                    int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0] && args[1], "Invalid argument", false);
     struct lkt_uri *uri = lkt_uri_new();
@@ -1003,7 +1036,8 @@ command_plt_add_uri(struct lkt_state *srv, size_t UNUSED c, char *args[LKT_MESSA
 }
 
 bool
-command_shuffle(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX])
+command_shuffle(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_MESSAGE_ARGS_MAX],
+                int UNUSED cont)
 {
     RETURN_UNLESS(database_queue_shuffle(srv->db), "Failed to shuffle", false);
     srv->mpd_idle_events |= MPD_IDLE_PLAYLIST;
@@ -1011,7 +1045,8 @@ command_shuffle(struct lkt_state *srv, UNUSED size_t c, char UNUSED *args[LKT_ME
 }
 
 bool
-command_queue_listid(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_queue_listid(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+                     int UNUSED cont)
 {
     RETURN_UNLESS(args && args[0], "Invalid arguments", false);
     long id = strtol(args[0], NULL, 0);
@@ -1019,7 +1054,8 @@ command_queue_listid(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARG
 }
 
 bool
-command_queue_list(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_queue_list(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+                   int UNUSED cont)
 {
     unsigned int from, to, tmp_switch;
     long val;
@@ -1081,7 +1117,7 @@ is_a_range:
 }
 
 bool
-command_password(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX])
+command_password(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     RETURN_UNLESS(argv[0], "Invalid argument", false);
     RETURN_UNLESS(database_user_authentificate(srv->db, argv[0]), "Failed to auth user", false);
@@ -1090,7 +1126,7 @@ command_password(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MA
 }
 
 bool
-command_user_add(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX])
+command_user_add(struct lkt_state *srv, size_t c, char *argv[LKT_MESSAGE_ARGS_MAX], int UNUSED cont)
 {
     RETURN_UNLESS(argv[0] && argv[1], "Invalid argument", false);
     RETURN_UNLESS(lkt_client_auth(srv, c, false), "Failed to authentificate user", false);
@@ -1122,7 +1158,8 @@ command_sticker_null(struct lkt_state UNUSED *srv, size_t UNUSED c,
 }
 
 bool
-command_sticker_handle(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX])
+command_sticker_handle(struct lkt_state *srv, size_t c, char *args[LKT_MESSAGE_ARGS_MAX],
+                       int UNUSED cont)
 {
     typedef enum {
         LKT_STICKER_HANDLER_NULL  = 0,
diff --git a/src/net/listen.c b/src/net/listen.c
index a0d73da9b3af9d1495e6d3535abb082c29027384..10e0e5a2120f0d1b75de9304da309777810fe643 100644
--- a/src/net/listen.c
+++ b/src/net/listen.c
@@ -23,16 +23,12 @@
 
 #define CHARS_MAX (sizeof(char) * 256)
 
-typedef enum {
-    LKT_COMMAND_NULL,         /* Not a terminal node, so no commands  */
-    LKT_COMMAND_SIMPLE,       /* srv, c, args                         */
-    LKT_COMMAND_CONTINUATION, /* srv, c, args, int                    */
-} LKT_COMMAND_TYPE;
-
 struct cmd_trie_node {
-    LKT_COMMAND_TYPE type; /* The type of the command, to reinterpret the function pointer */
-    void (*cmd_ptr)(void); /* The function pointer of the command                          */
-    struct cmd_trie_node *children[CHARS_MAX]; /* Childrens, a byte is 256 possible values  */
+    /* The function pointer of the command */
+    bool (*cmd_ptr)(struct lkt_state *, size_t, char *[LKT_MESSAGE_ARGS_MAX], int);
+
+    /* Childrens, a byte is 256 possible values */
+    struct cmd_trie_node *children[CHARS_MAX];
 };
 
 /* The cmd_trie root for all the liblektor, it's OK because we have only one
@@ -50,7 +46,6 @@ cmd_trie_new(void)
 
     /* cmd_ptr == NULL && type == NULL => invalid node, for empty tries. */
     ret->cmd_ptr = NULL;
-    ret->type    = LKT_COMMAND_NULL;
 
     return ret;
 }
@@ -68,8 +63,7 @@ cmd_trie_free(struct cmd_trie_node *root)
 }
 
 PRIVATE_FUNCTION void
-cmd_trie_insert(struct cmd_trie_node *root, const char *signed_cmd_name, void (*cmd_ptr)(void),
-                LKT_COMMAND_TYPE cmd_type)
+cmd_trie_insert(struct cmd_trie_node *root, const char *signed_cmd_name, bool (*cmd_ptr)(struct lkt_state*, size_t, char *[LKT_MESSAGE_ARGS_MAX], int))
 {
     FAIL_UNLESS(root, "Passing an empty trie root");
     unsigned const char *cmd_name = (unsigned const char *)signed_cmd_name;
@@ -89,15 +83,10 @@ cmd_trie_insert(struct cmd_trie_node *root, const char *signed_cmd_name, void (*
     }
 
     /* Insert the new command */
-    if (root->type == LKT_COMMAND_NULL) {
-        root->type    = cmd_type;
+    if (root->cmd_ptr == NULL)
         root->cmd_ptr = cmd_ptr;
-    }
-
-    /* The command was already inserted */
-    else {
+    else
         LOG_FATAL("The command '%s' was already present in the cmd_trie", signed_cmd_name);
-    }
 }
 
 PRIVATE_FUNCTION struct cmd_trie_node *
@@ -120,7 +109,7 @@ cmd_trie_find(struct cmd_trie_node *root, const char *signed_cmd_name)
         current_char = cmd_name[cmd_name_index];
     }
 
-    if (root->type == LKT_COMMAND_NULL) {
+    if (root->cmd_ptr == NULL) {
         LOG_WARN("CMD_TRIE", "Failed to find the command: %s", signed_cmd_name);
         return NULL;
     }
@@ -136,18 +125,7 @@ ___cmd_trie_print(struct cmd_trie_node *root, char *old_prefix, const size_t len
     memcpy(prefix, old_prefix, sizeof(char) * length);
     prefix[length + 1] = '\0';
     prefix[length]     = '\0';
-
-    switch (root->type) {
-    /* Not a terminal node */
-    case LKT_COMMAND_NULL: break;
-
-    /* A terminal node */
-    case LKT_COMMAND_SIMPLE:
-    case LKT_COMMAND_CONTINUATION:
-        LKT_OUTPUT("CMD_TRIE", "Got function of type %d in trie '%s'", root->type, prefix);
-        break;
-    }
-
+    LKT_OUTPUT("CMD_TRIE", "Got function in trie '%s'", prefix);
     for (size_t i = 0; i < CHARS_MAX; ++i) {
         /* Rec-call with new children */
         if (root->children[i] != NULL) {
@@ -170,8 +148,8 @@ ___cmd_trie_init(void)
     LOG_INFO("CMD_TRIE", "Init the command trie");
     cmd_trie_root = cmd_trie_new();
 
-#define mpd_command(str_name, c_func, command_type) \
-    cmd_trie_insert(cmd_trie_root, str_name, FUNCTION_POINTER(c_func), LKT_COMMAND_##command_type);
+#define mpd_command(str_name, c_func) \
+    cmd_trie_insert(cmd_trie_root, (str_name), (c_func));
 #include "lektor/internal/commands.def"
 #undef mpd_command
 
@@ -304,32 +282,13 @@ handle_simple_command(struct lkt_state *srv, size_t c, struct lkt_command cmd)
     int err                        = 0;
     int continuation               = 0;
     struct cmd_trie_node *cmd_node = NULL;
-    union {
-        bool (*anon)(struct lkt_state *, char *[LKT_MESSAGE_ARGS_MAX]);
-        bool (*simple)(struct lkt_state *, size_t, char *[LKT_MESSAGE_ARGS_MAX]);
-        bool (*integer)(struct lkt_state *, size_t, char *[LKT_MESSAGE_ARGS_MAX], int);
-        void (*base_pointer)(void);
-    } handle_function;
 
     /* Commands that are available only if you are not in IDLE mode */
     if (lkt_client_get_mask(srv, c) == MPD_IDLE_NONE) {
         /* First try the 'fast' search with the trie structure */
         cmd_node = cmd_trie_find(cmd_trie_root, cmd.name);
         if (cmd_node != NULL) {
-            handle_function.base_pointer = cmd_node->cmd_ptr;
-
-            switch (cmd_node->type) {
-            /* Basic command */
-            case LKT_COMMAND_SIMPLE: err = !handle_function.simple(srv, c, cmd.args); break;
-
-            /* Need the continuation */
-            case LKT_COMMAND_CONTINUATION:
-                err = (int)(!handle_function.integer(srv, c, cmd.args, (int)cmd.cont));
-                break;
-
-            /* Unreachable */
-            case LKT_COMMAND_NULL: LOG_UNREACHABLE;
-            }
+            err = (int)(!cmd_node->cmd_ptr(srv, c, cmd.args, (int)cmd.cont));
         }
 
         /* Some commands are not in the structure because they have a unique
@@ -353,7 +312,7 @@ handle_simple_command(struct lkt_state *srv, size_t c, struct lkt_command cmd)
 
         else if (STR_MATCH(cmd.name, "idle")) {
             LOG_DEBUG("CMD-DEBUG", "Try to do the 'idle' command even if not found in trie");
-            err = !command_idle(srv, c, cmd.args);
+            err = !command_idle(srv, c, cmd.args, 0);
             goto end_no_send_status;
         }
 
@@ -373,12 +332,12 @@ handle_simple_command(struct lkt_state *srv, size_t c, struct lkt_command cmd)
     /* commands available only in IDLE mode */
     else {
         if (STR_MATCH(cmd.name, "idle")) {
-            err = !command_idle(srv, c, cmd.args);
+            err = !command_idle(srv, c, cmd.args, 0);
             goto end_no_send_status;
         }
 
         else if (STR_MATCH(cmd.name, "noidle")) {
-            err = !command_noidle(srv, c, NULL);
+            err = !command_noidle(srv, c, NULL, 0);
         }
 
         /* Not found! */
@@ -949,12 +908,12 @@ redo:
         safe_snprintf(string, BUFFER_MAX, "%ld", (size_t)evt.attr);
         arguments_to_pass[0] = string;
         arguments_to_pass[1] = NULL;
-        command_play(srv, 0, arguments_to_pass);
+        command_play(srv, 0, arguments_to_pass, 0);
         free(string);
     })
 
-    CASE(PLAY_NEXT, command_next(srv, 0, NULL))
-    CASE(PLAY_PREV, command_previous(srv, 0, NULL))
+    CASE(PLAY_NEXT, command_next    (srv, 0, NULL, 0))
+    CASE(PLAY_PREV, command_previous(srv, 0, NULL, 0))
 
     CASE(PLAY_TOGGLE, {
         ATTR_IS_STATE(PAUSE,  database_queue_set_paused(srv->db, 1))