Merge remote-tracking branch 'flipperdevices/dev' into ulcdict

2026-05-22 05:14:46 -07:00 · 2025-08-17 17:54:56 -04:00
parent 948dffadcc d1c3b0bc68
commit 1b88b86a11
575 changed files with 16041 additions and 4749 deletions
--- a/applications/main/application.fam
+++ b/applications/main/application.fam
@@ -21,11 +21,6 @@ App(
    name="On start hooks",
    apptype=FlipperAppType.METAPACKAGE,
    provides=[
-        "ibutton_start",
-        "onewire_start",
-        "subghz_start",
-        "infrared_start",
-        "lfrfid_start",
-        "nfc_start",
+        "cli",
    ],
 )
--- a/applications/main/archive/application.fam
+++ b/applications/main/archive/application.fam
@@ -7,5 +7,5 @@ App(
    requires=["gui"],
    stack_size=4 * 1024,
    icon="A_FileManager_14",
-    order=0,
+    order=10,
 )
--- a/applications/main/archive/helpers/archive_apps.c
+++ b/applications/main/archive/helpers/archive_apps.c
@@ -1,8 +1,9 @@
 #include "archive_apps.h"
 #include "archive_browser.h"

-static const char* known_apps[] = {
+static const char* const known_apps[] = {
    [ArchiveAppTypeU2f] = "u2f",
+    [ArchiveAppTypeSetting] = "setting",
 };

 ArchiveAppTypeEnum archive_get_app_type(const char* path) {
@@ -36,6 +37,8 @@ bool archive_app_is_available(void* context, const char* path) {

        furi_record_close(RECORD_STORAGE);
        return file_exists;
+    } else if(app == ArchiveAppTypeSetting) {
+        return true;
    } else {
        return false;
    }
@@ -53,6 +56,9 @@ bool archive_app_read_dir(void* context, const char* path) {
    if(app == ArchiveAppTypeU2f) {
        archive_add_app_item(browser, "/app:u2f/U2F Token");
        return true;
+    } else if(app == ArchiveAppTypeSetting) {
+        archive_add_app_item(browser, path);
+        return true;
    } else {
        return false;
    }
@@ -75,6 +81,8 @@ void archive_app_delete_file(void* context, const char* path) {
        if(archive_is_favorite("/app:u2f/U2F Token")) {
            archive_favorites_delete("/app:u2f/U2F Token");
        }
+    } else if(app == ArchiveAppTypeSetting) {
+        // can't delete a setting!
    }

    if(res) {
--- a/applications/main/archive/helpers/archive_apps.h
+++ b/applications/main/archive/helpers/archive_apps.h
@@ -4,12 +4,14 @@

 typedef enum {
    ArchiveAppTypeU2f,
+    ArchiveAppTypeSetting,
    ArchiveAppTypeUnknown,
    ArchiveAppsTotal,
 } ArchiveAppTypeEnum;

 static const ArchiveFileTypeEnum app_file_types[] = {
    [ArchiveAppTypeU2f] = ArchiveFileTypeU2f,
+    [ArchiveAppTypeSetting] = ArchiveFileTypeSetting,
    [ArchiveAppTypeUnknown] = ArchiveFileTypeUnknown,
 };

--- a/applications/main/archive/helpers/archive_browser.h
+++ b/applications/main/archive/helpers/archive_browser.h
@@ -7,7 +7,7 @@
 #define TAB_DEFAULT       ArchiveTabFavorites // Start tab
 #define FILE_LIST_BUF_LEN 50

-static const char* tab_default_paths[] = {
+static const char* const tab_default_paths[] = {
    [ArchiveTabFavorites] = "/app:favorites",
    [ArchiveTabIButton] = EXT_PATH("ibutton"),
    [ArchiveTabNFC] = EXT_PATH("nfc"),
@@ -20,7 +20,7 @@ static const char* tab_default_paths[] = {
    [ArchiveTabBrowser] = STORAGE_EXT_PATH_PREFIX,
 };

-static const char* known_ext[] = {
+static const char* const known_ext[] = {
    [ArchiveFileTypeIButton] = ".ibtn",
    [ArchiveFileTypeNFC] = ".nfc",
    [ArchiveFileTypeSubGhz] = ".sub",
@@ -34,6 +34,7 @@ static const char* known_ext[] = {
    [ArchiveFileTypeFolder] = "?",
    [ArchiveFileTypeUnknown] = "*",
    [ArchiveFileTypeAppOrJs] = ".fap|.js",
+    [ArchiveFileTypeSetting] = "?",
 };

 static const ArchiveFileTypeEnum known_type[] = {
--- a/applications/main/archive/helpers/archive_favorites.c
+++ b/applications/main/archive/helpers/archive_favorites.c
@@ -1,9 +1,10 @@
-
 #include "archive_favorites.h"
 #include "archive_files.h"
 #include "archive_apps.h"
 #include "archive_browser.h"

+#include <dialogs/dialogs.h>
+
 #define ARCHIVE_FAV_FILE_BUF_LEN 32

 static bool archive_favorites_read_line(File* file, FuriString* str_result) {
@@ -337,3 +338,46 @@ void archive_favorites_save(void* context) {
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);
 }
+
+void archive_favorites_handle_setting_pin_unpin(const char* app_name, const char* setting) {
+    DialogMessage* message = dialog_message_alloc();
+
+    FuriString* setting_path = furi_string_alloc_set_str(app_name);
+    if(setting) {
+        furi_string_push_back(setting_path, '/');
+        furi_string_cat_str(setting_path, setting);
+    }
+    const char* setting_path_str = furi_string_get_cstr(setting_path);
+
+    bool is_favorite = archive_is_favorite("/app:setting/%s", setting_path_str);
+    dialog_message_set_header(
+        message,
+        is_favorite ? "Unpin This Setting?" : "Pin This Setting?",
+        64,
+        0,
+        AlignCenter,
+        AlignTop);
+    dialog_message_set_text(
+        message,
+        is_favorite ? "It will no longer be\naccessible from the\nFavorites menu" :
+                      "It will be accessible from the\nFavorites menu",
+        64,
+        32,
+        AlignCenter,
+        AlignCenter);
+    dialog_message_set_buttons(
+        message, is_favorite ? "Unpin" : "Go back", NULL, is_favorite ? "Keep pinned" : "Pin");
+
+    DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
+    DialogMessageButton button = dialog_message_show(dialogs, message);
+    furi_record_close(RECORD_DIALOGS);
+
+    if(is_favorite && button == DialogMessageButtonLeft) {
+        archive_favorites_delete("/app:setting/%s", setting_path_str);
+    } else if(!is_favorite && button == DialogMessageButtonRight) {
+        archive_file_append(ARCHIVE_FAV_PATH, "/app:setting/%s\n", setting_path_str);
+    }
+
+    furi_string_free(setting_path);
+    dialog_message_free(message);
+}
--- a/applications/main/archive/helpers/archive_favorites.h
+++ b/applications/main/archive/helpers/archive_favorites.h
@@ -12,3 +12,13 @@ bool archive_is_favorite(const char* format, ...) _ATTRIBUTE((__format__(__print
 bool archive_favorites_rename(const char* src, const char* dst);
 void archive_add_to_favorites(const char* file_path);
 void archive_favorites_save(void* context);
+
+/**
+ * Intended to be called by settings apps to handle long presses, as well as
+ * internally from within the archive
+ * 
+ * @param app_name name of the referring application
+ * @param setting  name of the setting, which will be both displayed to the user
+ *                 and passed to the application as an argument upon recall
+ */
+void archive_favorites_handle_setting_pin_unpin(const char* app_name, const char* setting);
--- a/applications/main/archive/helpers/archive_files.h
+++ b/applications/main/archive/helpers/archive_files.h
@@ -20,6 +20,7 @@ typedef enum {
    ArchiveFileTypeFolder,
    ArchiveFileTypeUnknown,
    ArchiveFileTypeAppOrJs,
+    ArchiveFileTypeSetting,
    ArchiveFileTypeLoading,
 } ArchiveFileTypeEnum;

--- a/applications/main/archive/scenes/archive_scene_browser.c
+++ b/applications/main/archive/scenes/archive_scene_browser.c
@@ -42,7 +42,7 @@ static void archive_loader_callback(const void* message, void* context) {
    const LoaderEvent* event = message;
    ArchiveApp* archive = (ArchiveApp*)context;

-    if(event->type == LoaderEventTypeApplicationStopped) {
+    if(event->type == LoaderEventTypeNoMoreAppsInQueue) {
        view_dispatcher_send_custom_event(
            archive->view_dispatcher, ArchiveBrowserEventListRefresh);
    }
@@ -52,20 +52,37 @@ static void archive_run_in_app(ArchiveBrowserView* browser, ArchiveFile_t* selec
    UNUSED(browser);
    Loader* loader = furi_record_open(RECORD_LOADER);

-    const char* app_name = archive_get_flipper_app_name(selected->type);
-
-    if(app_name) {
-        if(selected->is_app) {
-            char* param = strrchr(furi_string_get_cstr(selected->path), '/');
-            if(param != NULL) {
-                param++;
-            }
-            loader_start_with_gui_error(loader, app_name, param);
+    if(selected->type == ArchiveFileTypeSetting) {
+        FuriString* app_name = furi_string_alloc_set(selected->path);
+        furi_string_right(app_name, furi_string_search_char(app_name, '/', 1) + 1);
+        size_t slash = furi_string_search_char(app_name, '/', 1);
+        if(slash != FURI_STRING_FAILURE) {
+            furi_string_left(app_name, slash);
+            FuriString* app_args =
+                furi_string_alloc_set_str(furi_string_get_cstr(app_name) + slash + 1);
+            loader_start_with_gui_error(
+                loader, furi_string_get_cstr(app_name), furi_string_get_cstr(app_args));
+            furi_string_free(app_args);
        } else {
-            loader_start_with_gui_error(loader, app_name, furi_string_get_cstr(selected->path));
+            loader_start_with_gui_error(loader, furi_string_get_cstr(app_name), NULL);
        }
+        furi_string_free(app_name);
    } else {
-        loader_start_with_gui_error(loader, furi_string_get_cstr(selected->path), NULL);
+        const char* app_name = archive_get_flipper_app_name(selected->type);
+        if(app_name) {
+            if(selected->is_app) {
+                char* param = strrchr(furi_string_get_cstr(selected->path), '/');
+                if(param != NULL) {
+                    param++;
+                }
+                loader_start_with_gui_error(loader, app_name, param);
+            } else {
+                loader_start_with_gui_error(
+                    loader, app_name, furi_string_get_cstr(selected->path));
+            }
+        } else {
+            loader_start_with_gui_error(loader, furi_string_get_cstr(selected->path), NULL);
+        }
    }

    furi_record_close(RECORD_LOADER);
--- a/applications/main/archive/views/archive_browser_view.c
+++ b/applications/main/archive/views/archive_browser_view.c
@@ -28,6 +28,7 @@ static const Icon* ArchiveItemIcons[] = {
    [ArchiveFileTypeInfrared] = &I_ir_10px,
    [ArchiveFileTypeBadUsb] = &I_badusb_10px,
    [ArchiveFileTypeU2f] = &I_u2f_10px,
+    [ArchiveFileTypeSetting] = &I_settings_10px,
    [ArchiveFileTypeUpdateManifest] = &I_update_10px,
    [ArchiveFileTypeFolder] = &I_dir_10px,
    [ArchiveFileTypeUnknown] = &I_unknown_10px,
--- a/applications/main/bad_usb/helpers/bad_usb_hid.c
+++ b/applications/main/bad_usb/helpers/bad_usb_hid.c
@@ -37,6 +37,31 @@ bool hid_usb_kb_release(void* inst, uint16_t button) {
    return furi_hal_hid_kb_release(button);
 }

+bool hid_usb_mouse_press(void* inst, uint8_t button) {
+    UNUSED(inst);
+    return furi_hal_hid_mouse_press(button);
+}
+
+bool hid_usb_mouse_release(void* inst, uint8_t button) {
+    UNUSED(inst);
+    return furi_hal_hid_mouse_release(button);
+}
+
+bool hid_usb_mouse_scroll(void* inst, int8_t delta) {
+    UNUSED(inst);
+    return furi_hal_hid_mouse_scroll(delta);
+}
+
+bool hid_usb_mouse_move(void* inst, int8_t dx, int8_t dy) {
+    UNUSED(inst);
+    return furi_hal_hid_mouse_move(dx, dy);
+}
+
+bool hid_usb_mouse_release_all(void* inst) {
+    UNUSED(inst);
+    return furi_hal_hid_mouse_release(0);
+}
+
 bool hid_usb_consumer_press(void* inst, uint16_t button) {
    UNUSED(inst);
    return furi_hal_hid_consumer_key_press(button);
@@ -51,6 +76,7 @@ bool hid_usb_release_all(void* inst) {
    UNUSED(inst);
    bool state = furi_hal_hid_kb_release_all();
    state &= furi_hal_hid_consumer_key_release_all();
+    state &= hid_usb_mouse_release_all(inst);
    return state;
 }

@@ -67,6 +93,10 @@ static const BadUsbHidApi hid_api_usb = {

    .kb_press = hid_usb_kb_press,
    .kb_release = hid_usb_kb_release,
+    .mouse_press = hid_usb_mouse_press,
+    .mouse_release = hid_usb_mouse_release,
+    .mouse_scroll = hid_usb_mouse_scroll,
+    .mouse_move = hid_usb_mouse_move,
    .consumer_press = hid_usb_consumer_press,
    .consumer_release = hid_usb_consumer_release,
    .release_all = hid_usb_release_all,
@@ -157,6 +187,27 @@ bool hid_ble_kb_release(void* inst, uint16_t button) {
    return ble_profile_hid_kb_release(ble_hid->profile, button);
 }

+bool hid_ble_mouse_press(void* inst, uint8_t button) {
+    BleHidInstance* ble_hid = inst;
+    furi_assert(ble_hid);
+    return ble_profile_hid_mouse_press(ble_hid->profile, button);
+}
+bool hid_ble_mouse_release(void* inst, uint8_t button) {
+    BleHidInstance* ble_hid = inst;
+    furi_assert(ble_hid);
+    return ble_profile_hid_mouse_release(ble_hid->profile, button);
+}
+bool hid_ble_mouse_scroll(void* inst, int8_t delta) {
+    BleHidInstance* ble_hid = inst;
+    furi_assert(ble_hid);
+    return ble_profile_hid_mouse_scroll(ble_hid->profile, delta);
+}
+bool hid_ble_mouse_move(void* inst, int8_t dx, int8_t dy) {
+    BleHidInstance* ble_hid = inst;
+    furi_assert(ble_hid);
+    return ble_profile_hid_mouse_move(ble_hid->profile, dx, dy);
+}
+
 bool hid_ble_consumer_press(void* inst, uint16_t button) {
    BleHidInstance* ble_hid = inst;
    furi_assert(ble_hid);
@@ -174,6 +225,7 @@ bool hid_ble_release_all(void* inst) {
    furi_assert(ble_hid);
    bool state = ble_profile_hid_kb_release_all(ble_hid->profile);
    state &= ble_profile_hid_consumer_key_release_all(ble_hid->profile);
+    state &= ble_profile_hid_mouse_release_all(ble_hid->profile);
    return state;
 }

@@ -191,6 +243,10 @@ static const BadUsbHidApi hid_api_ble = {

    .kb_press = hid_ble_kb_press,
    .kb_release = hid_ble_kb_release,
+    .mouse_press = hid_ble_mouse_press,
+    .mouse_release = hid_ble_mouse_release,
+    .mouse_scroll = hid_ble_mouse_scroll,
+    .mouse_move = hid_ble_mouse_move,
    .consumer_press = hid_ble_consumer_press,
    .consumer_release = hid_ble_consumer_release,
    .release_all = hid_ble_release_all,
--- a/applications/main/bad_usb/helpers/bad_usb_hid.h
+++ b/applications/main/bad_usb/helpers/bad_usb_hid.h
@@ -20,6 +20,10 @@ typedef struct {

    bool (*kb_press)(void* inst, uint16_t button);
    bool (*kb_release)(void* inst, uint16_t button);
+    bool (*mouse_press)(void* inst, uint8_t button);
+    bool (*mouse_release)(void* inst, uint8_t button);
+    bool (*mouse_scroll)(void* inst, int8_t delta);
+    bool (*mouse_move)(void* inst, int8_t dx, int8_t dy);
    bool (*consumer_press)(void* inst, uint16_t button);
    bool (*consumer_release)(void* inst, uint16_t button);
    bool (*release_all)(void* inst);
--- a/applications/main/bad_usb/helpers/ducky_script.c
+++ b/applications/main/bad_usb/helpers/ducky_script.c
@@ -40,11 +40,8 @@ static const uint8_t numpad_keys[10] = {
 };

 uint32_t ducky_get_command_len(const char* line) {
-    uint32_t len = strlen(line);
-    for(uint32_t i = 0; i < len; i++) {
-        if(line[i] == ' ') return i;
-    }
-    return 0;
+    char* first_space = strchr(line, ' ');
+    return first_space ? (first_space - line) : 0;
 }

 bool ducky_is_line_end(const char chr) {
@@ -180,29 +177,46 @@ static bool ducky_string_next(BadUsbScript* bad_usb) {

 static int32_t ducky_parse_line(BadUsbScript* bad_usb, FuriString* line) {
    uint32_t line_len = furi_string_size(line);
-    const char* line_tmp = furi_string_get_cstr(line);
+    const char* line_cstr = furi_string_get_cstr(line);

    if(line_len == 0) {
        return SCRIPT_STATE_NEXT_LINE; // Skip empty lines
    }
-    FURI_LOG_D(WORKER_TAG, "line:%s", line_tmp);
+    FURI_LOG_D(WORKER_TAG, "line:%s", line_cstr);

    // Ducky Lang Functions
-    int32_t cmd_result = ducky_execute_cmd(bad_usb, line_tmp);
+    int32_t cmd_result = ducky_execute_cmd(bad_usb, line_cstr);
    if(cmd_result != SCRIPT_STATE_CMD_UNKNOWN) {
        return cmd_result;
    }

-    // Special keys + modifiers
-    uint16_t key = ducky_get_keycode(bad_usb, line_tmp, false);
-    if(key == HID_KEYBOARD_NONE) {
-        return ducky_error(bad_usb, "No keycode defined for %s", line_tmp);
+    // Mouse Keys
+    uint16_t key = ducky_get_mouse_keycode_by_name(line_cstr);
+    if(key != HID_MOUSE_INVALID) {
+        bad_usb->hid->mouse_press(bad_usb->hid_inst, key);
+        bad_usb->hid->mouse_release(bad_usb->hid_inst, key);
+        return 0;
    }
-    if((key & 0xFF00) != 0) {
-        // It's a modifier key
-        line_tmp = &line_tmp[ducky_get_command_len(line_tmp) + 1];
-        key |= ducky_get_keycode(bad_usb, line_tmp, true);
+
+    // Parse chain of modifiers linked by spaces and hyphens
+    uint16_t modifiers = 0;
+    while(1) {
+        key = ducky_get_next_modifier_keycode_by_name(&line_cstr);
+        if(key == HID_KEYBOARD_NONE) break;
+
+        modifiers |= key;
+        char next_char = *line_cstr;
+        if(next_char == ' ' || next_char == '-') line_cstr++;
    }
+
+    // Main key
+    char next_char = *line_cstr;
+    uint16_t main_key = ducky_get_keycode_by_name(line_cstr);
+    if(!main_key && next_char) main_key = BADUSB_ASCII_TO_KEY(bad_usb, next_char);
+    key = modifiers | main_key;
+
+    if(key == 0 && next_char) ducky_error(bad_usb, "No keycode defined for %s", line_cstr);
+
    bad_usb->hid->kb_press(bad_usb->hid_inst, key);
    bad_usb->hid->kb_release(bad_usb->hid_inst, key);
    return 0;
--- a/applications/main/bad_usb/helpers/ducky_script_commands.c
+++ b/applications/main/bad_usb/helpers/ducky_script_commands.c
@@ -1,4 +1,5 @@
 #include <furi_hal.h>
+#include <lib/toolbox/strint.h>
 #include "ducky_script.h"
 #include "ducky_script_i.h"

@@ -124,34 +125,58 @@ static int32_t ducky_fnc_altstring(BadUsbScript* bad_usb, const char* line, int3

 static int32_t ducky_fnc_hold(BadUsbScript* bad_usb, const char* line, int32_t param) {
    UNUSED(param);
-
    line = &line[ducky_get_command_len(line) + 1];
-    uint16_t key = ducky_get_keycode(bad_usb, line, true);
-    if(key == HID_KEYBOARD_NONE) {
-        return ducky_error(bad_usb, "No keycode defined for %s", line);
-    }
-    bad_usb->key_hold_nb++;
+
    if(bad_usb->key_hold_nb > (HID_KB_MAX_KEYS - 1)) {
-        return ducky_error(bad_usb, "Too many keys are hold");
+        return ducky_error(bad_usb, "Too many keys are held");
    }
-    bad_usb->hid->kb_press(bad_usb->hid_inst, key);
-    return 0;
+
+    // Handle Mouse Keys here
+    uint16_t key = ducky_get_mouse_keycode_by_name(line);
+    if(key != HID_MOUSE_NONE) {
+        bad_usb->key_hold_nb++;
+        bad_usb->hid->mouse_press(bad_usb->hid_inst, key);
+        return 0;
+    }
+
+    // Handle Keyboard keys here
+    key = ducky_get_keycode(bad_usb, line, true);
+    if(key != HID_KEYBOARD_NONE) {
+        bad_usb->key_hold_nb++;
+        bad_usb->hid->kb_press(bad_usb->hid_inst, key);
+        return 0;
+    }
+
+    // keyboard and mouse were none
+    return ducky_error(bad_usb, "Unknown keycode for %s", line);
 }

 static int32_t ducky_fnc_release(BadUsbScript* bad_usb, const char* line, int32_t param) {
    UNUSED(param);
-
    line = &line[ducky_get_command_len(line) + 1];
-    uint16_t key = ducky_get_keycode(bad_usb, line, true);
-    if(key == HID_KEYBOARD_NONE) {
-        return ducky_error(bad_usb, "No keycode defined for %s", line);
-    }
+
    if(bad_usb->key_hold_nb == 0) {
-        return ducky_error(bad_usb, "No keys are hold");
+        return ducky_error(bad_usb, "No keys are held");
    }
-    bad_usb->key_hold_nb--;
-    bad_usb->hid->kb_release(bad_usb->hid_inst, key);
-    return 0;
+
+    // Handle Mouse Keys here
+    uint16_t key = ducky_get_mouse_keycode_by_name(line);
+    if(key != HID_MOUSE_NONE) {
+        bad_usb->key_hold_nb--;
+        bad_usb->hid->mouse_release(bad_usb->hid_inst, key);
+        return 0;
+    }
+
+    //Handle Keyboard Keys here
+    key = ducky_get_keycode(bad_usb, line, true);
+    if(key != HID_KEYBOARD_NONE) {
+        bad_usb->key_hold_nb--;
+        bad_usb->hid->kb_release(bad_usb->hid_inst, key);
+        return 0;
+    }
+
+    // keyboard and mouse were none
+    return ducky_error(bad_usb, "No keycode defined for %s", line);
 }

 static int32_t ducky_fnc_media(BadUsbScript* bad_usb, const char* line, int32_t param) {
@@ -191,6 +216,43 @@ static int32_t ducky_fnc_waitforbutton(BadUsbScript* bad_usb, const char* line,
    return SCRIPT_STATE_WAIT_FOR_BTN;
 }

+static int32_t ducky_fnc_mouse_scroll(BadUsbScript* bad_usb, const char* line, int32_t param) {
+    UNUSED(param);
+
+    line = &line[strcspn(line, " ") + 1];
+    int32_t mouse_scroll_dist = 0;
+
+    if(strint_to_int32(line, NULL, &mouse_scroll_dist, 10) != StrintParseNoError) {
+        return ducky_error(bad_usb, "Invalid Number %s", line);
+    }
+
+    bad_usb->hid->mouse_scroll(bad_usb->hid_inst, mouse_scroll_dist);
+
+    return 0;
+}
+
+static int32_t ducky_fnc_mouse_move(BadUsbScript* bad_usb, const char* line, int32_t param) {
+    UNUSED(param);
+
+    line = &line[strcspn(line, " ") + 1];
+    int32_t mouse_move_x = 0;
+    int32_t mouse_move_y = 0;
+
+    if(strint_to_int32(line, NULL, &mouse_move_x, 10) != StrintParseNoError) {
+        return ducky_error(bad_usb, "Invalid Number %s", line);
+    }
+
+    line = &line[strcspn(line, " ") + 1];
+
+    if(strint_to_int32(line, NULL, &mouse_move_y, 10) != StrintParseNoError) {
+        return ducky_error(bad_usb, "Invalid Number %s", line);
+    }
+
+    bad_usb->hid->mouse_move(bad_usb->hid_inst, mouse_move_x, mouse_move_y);
+
+    return 0;
+}
+
 static const DuckyCmd ducky_commands[] = {
    {"REM", NULL, -1},
    {"ID", NULL, -1},
@@ -213,6 +275,10 @@ static const DuckyCmd ducky_commands[] = {
    {"WAIT_FOR_BUTTON_PRESS", ducky_fnc_waitforbutton, -1},
    {"MEDIA", ducky_fnc_media, -1},
    {"GLOBE", ducky_fnc_globe, -1},
+    {"MOUSEMOVE", ducky_fnc_mouse_move, -1},
+    {"MOUSE_MOVE", ducky_fnc_mouse_move, -1},
+    {"MOUSESCROLL", ducky_fnc_mouse_scroll, -1},
+    {"MOUSE_SCROLL", ducky_fnc_mouse_scroll, -1},
 };

 #define TAG "BadUsb"
--- a/applications/main/bad_usb/helpers/ducky_script_i.h
+++ b/applications/main/bad_usb/helpers/ducky_script_i.h
@@ -18,6 +18,9 @@ extern "C" {

 #define FILE_BUFFER_LEN 16

+#define HID_MOUSE_INVALID 0
+#define HID_MOUSE_NONE    0
+
 struct BadUsbScript {
    FuriHalUsbHidConfig hid_cfg;
    const BadUsbHidApi* hid;
@@ -51,10 +54,14 @@ uint32_t ducky_get_command_len(const char* line);

 bool ducky_is_line_end(const char chr);

+uint16_t ducky_get_next_modifier_keycode_by_name(const char** param);
+
 uint16_t ducky_get_keycode_by_name(const char* param);

 uint16_t ducky_get_media_keycode_by_name(const char* param);

+uint8_t ducky_get_mouse_keycode_by_name(const char* param);
+
 bool ducky_get_number(const char* param, uint32_t* val);

 void ducky_numlock_on(BadUsbScript* bad_usb);
--- a/applications/main/bad_usb/helpers/ducky_script_keycodes.c
+++ b/applications/main/bad_usb/helpers/ducky_script_keycodes.c
@@ -6,21 +6,16 @@ typedef struct {
    uint16_t keycode;
 } DuckyKey;

-static const DuckyKey ducky_keys[] = {
-    {"CTRL-ALT", KEY_MOD_LEFT_CTRL | KEY_MOD_LEFT_ALT},
-    {"CTRL-SHIFT", KEY_MOD_LEFT_CTRL | KEY_MOD_LEFT_SHIFT},
-    {"ALT-SHIFT", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_SHIFT},
-    {"ALT-GUI", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_GUI},
-    {"GUI-SHIFT", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_SHIFT},
-    {"GUI-CTRL", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_CTRL},
-
+static const DuckyKey ducky_modifier_keys[] = {
    {"CTRL", KEY_MOD_LEFT_CTRL},
    {"CONTROL", KEY_MOD_LEFT_CTRL},
    {"SHIFT", KEY_MOD_LEFT_SHIFT},
    {"ALT", KEY_MOD_LEFT_ALT},
    {"GUI", KEY_MOD_LEFT_GUI},
    {"WINDOWS", KEY_MOD_LEFT_GUI},
+};

+static const DuckyKey ducky_keys[] = {
    {"DOWNARROW", HID_KEYBOARD_DOWN_ARROW},
    {"DOWN", HID_KEYBOARD_DOWN_ARROW},
    {"LEFTARROW", HID_KEYBOARD_LEFT_ARROW},
@@ -108,6 +103,34 @@ static const DuckyKey ducky_media_keys[] = {
    {"BRIGHT_DOWN", HID_CONSUMER_BRIGHTNESS_DECREMENT},
 };

+static const DuckyKey ducky_mouse_keys[] = {
+    {"LEFTCLICK", HID_MOUSE_BTN_LEFT},
+    {"LEFT_CLICK", HID_MOUSE_BTN_LEFT},
+    {"RIGHTCLICK", HID_MOUSE_BTN_RIGHT},
+    {"RIGHT_CLICK", HID_MOUSE_BTN_RIGHT},
+    {"MIDDLECLICK", HID_MOUSE_BTN_WHEEL},
+    {"MIDDLE_CLICK", HID_MOUSE_BTN_WHEEL},
+    {"WHEELCLICK", HID_MOUSE_BTN_WHEEL},
+    {"WHEEL_CLICK", HID_MOUSE_BTN_WHEEL},
+};
+
+uint16_t ducky_get_next_modifier_keycode_by_name(const char** param) {
+    const char* input_str = *param;
+
+    for(size_t i = 0; i < COUNT_OF(ducky_modifier_keys); i++) {
+        size_t key_cmd_len = strlen(ducky_modifier_keys[i].name);
+        if((strncmp(input_str, ducky_modifier_keys[i].name, key_cmd_len) == 0)) {
+            char next_char_after_key = input_str[key_cmd_len];
+            if(ducky_is_line_end(next_char_after_key) || (next_char_after_key == '-')) {
+                *param = &input_str[key_cmd_len];
+                return ducky_modifier_keys[i].keycode;
+            }
+        }
+    }
+
+    return HID_KEYBOARD_NONE;
+}
+
 uint16_t ducky_get_keycode_by_name(const char* param) {
    for(size_t i = 0; i < COUNT_OF(ducky_keys); i++) {
        size_t key_cmd_len = strlen(ducky_keys[i].name);
@@ -131,3 +154,15 @@ uint16_t ducky_get_media_keycode_by_name(const char* param) {

    return HID_CONSUMER_UNASSIGNED;
 }
+
+uint8_t ducky_get_mouse_keycode_by_name(const char* param) {
+    for(size_t i = 0; i < COUNT_OF(ducky_mouse_keys); i++) {
+        size_t key_cmd_len = strlen(ducky_mouse_keys[i].name);
+        if((strncmp(param, ducky_mouse_keys[i].name, key_cmd_len) == 0) &&
+           (ducky_is_line_end(param[key_cmd_len]))) {
+            return ducky_mouse_keys[i].keycode;
+        }
+    }
+
+    return HID_MOUSE_INVALID;
+}
--- a/applications/main/bad_usb/resources/badusb/test_mouse.txt
+++ b/applications/main/bad_usb/resources/badusb/test_mouse.txt
@@ -0,0 +1,46 @@
+ID 1234:abcd Generic:USB Keyboard
+REM Declare ourselves as a generic usb keyboard
+REM You can override this to use something else
+REM Check the `lsusb` command to know your own devices IDs
+
+DEFAULT_DELAY 200
+DEFAULT_STRING_DELAY 100
+
+DELAY 1000
+
+REM Test all mouse functions
+LEFTCLICK
+RIGHTCLICK
+MIDDLECLICK
+
+DELAY 1000
+
+MOUSEMOVE -10 0
+REPEAT 20
+MOUSEMOVE 0 10
+REPEAT 20
+MOUSEMOVE 10 0
+REPEAT 20
+MOUSEMOVE 0 -10
+REPEAT 20
+
+DELAY 1000
+
+MOUSESCROLL -50
+MOUSESCROLL 50
+
+DELAY 1000
+
+REM Verify Mouse hold working
+HOLD LEFTCLICK
+DELAY 2000
+RELEASE LEFTCLICK
+
+DELAY 1000
+
+REM Verify KB hold working
+HOLD M
+DELAY 2000
+RELEASE M
+
+ENTER
--- a/applications/main/gpio/gpio_app.c
+++ b/applications/main/gpio/gpio_app.c
@@ -30,6 +30,8 @@ GpioApp* gpio_app_alloc(void) {
    app->gui = furi_record_open(RECORD_GUI);
    app->gpio_items = gpio_items_alloc();

+    app->power = furi_record_open(RECORD_POWER);
+
    app->view_dispatcher = view_dispatcher_alloc();
    app->scene_manager = scene_manager_alloc(&gpio_scene_handlers, app);
    view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
@@ -100,6 +102,7 @@ void gpio_app_free(GpioApp* app) {
    // Close records
    furi_record_close(RECORD_GUI);
    furi_record_close(RECORD_NOTIFICATION);
+    furi_record_close(RECORD_POWER);

    expansion_enable(app->expansion);
    furi_record_close(RECORD_EXPANSION);
--- a/applications/main/gpio/gpio_app_i.h
+++ b/applications/main/gpio/gpio_app_i.h
@@ -5,6 +5,7 @@
 #include "scenes/gpio_scene.h"
 #include "gpio_custom_event.h"
 #include "usb_uart_bridge.h"
+#include <power/power_service/power.h>

 #include <gui/gui.h>
 #include <gui/view_dispatcher.h>
@@ -27,6 +28,7 @@ struct GpioApp {
    SceneManager* scene_manager;
    Widget* widget;
    DialogEx* dialog;
+    Power* power;

    VariableItemList* var_item_list;
    VariableItem* var_item_flow;
--- a/applications/main/gpio/scenes/gpio_scene_start.c
+++ b/applications/main/gpio/scenes/gpio_scene_start.c
@@ -60,7 +60,7 @@ void gpio_scene_start_on_enter(void* context) {
        GpioOtgSettingsNum,
        gpio_scene_start_var_list_change_callback,
        app);
-    if(furi_hal_power_is_otg_enabled()) {
+    if(power_is_otg_enabled(app->power)) {
        variable_item_set_current_value_index(item, GpioOtgOn);
        variable_item_set_current_value_text(item, gpio_otg_text[GpioOtgOn]);
    } else {
@@ -80,9 +80,9 @@ bool gpio_scene_start_on_event(void* context, SceneManagerEvent event) {

    if(event.type == SceneManagerEventTypeCustom) {
        if(event.event == GpioStartEventOtgOn) {
-            furi_hal_power_enable_otg();
+            power_enable_otg(app->power, true);
        } else if(event.event == GpioStartEventOtgOff) {
-            furi_hal_power_disable_otg();
+            power_enable_otg(app->power, false);
        } else if(event.event == GpioStartEventManualControl) {
            scene_manager_set_scene_state(app->scene_manager, GpioSceneStart, GpioItemTest);
            scene_manager_next_scene(app->scene_manager, GpioSceneTest);
--- a/applications/main/gpio/usb_uart_bridge.c
+++ b/applications/main/gpio/usb_uart_bridge.c
@@ -1,7 +1,6 @@
 #include "usb_uart_bridge.h"
 #include "usb_cdc.h"
 #include <cli/cli_vcp.h>
-#include <cli/cli.h>
 #include <toolbox/api_lock.h>
 #include <furi_hal.h>
 #include <furi_hal_usb_cdc.h>
@@ -61,6 +60,8 @@ struct UsbUartBridge {

    FuriApiLock cfg_lock;

+    CliVcp* cli_vcp;
+
    uint8_t rx_buf[USB_CDC_PKT_LEN];
 };

@@ -106,15 +107,11 @@ static void usb_uart_on_irq_rx_dma_cb(
 static void usb_uart_vcp_init(UsbUartBridge* usb_uart, uint8_t vcp_ch) {
    furi_hal_usb_unlock();
    if(vcp_ch == 0) {
-        Cli* cli = furi_record_open(RECORD_CLI);
-        cli_session_close(cli);
-        furi_record_close(RECORD_CLI);
+        cli_vcp_disable(usb_uart->cli_vcp);
        furi_check(furi_hal_usb_set_config(&usb_cdc_single, NULL) == true);
    } else {
        furi_check(furi_hal_usb_set_config(&usb_cdc_dual, NULL) == true);
-        Cli* cli = furi_record_open(RECORD_CLI);
-        cli_session_open(cli, &cli_vcp);
-        furi_record_close(RECORD_CLI);
+        cli_vcp_enable(usb_uart->cli_vcp);
    }
    furi_hal_cdc_set_callbacks(vcp_ch, (CdcCallbacks*)&cdc_cb, usb_uart);
 }
@@ -123,9 +120,7 @@ static void usb_uart_vcp_deinit(UsbUartBridge* usb_uart, uint8_t vcp_ch) {
    UNUSED(usb_uart);
    furi_hal_cdc_set_callbacks(vcp_ch, NULL, NULL);
    if(vcp_ch != 0) {
-        Cli* cli = furi_record_open(RECORD_CLI);
-        cli_session_close(cli);
-        furi_record_close(RECORD_CLI);
+        cli_vcp_disable(usb_uart->cli_vcp);
    }
 }

@@ -177,13 +172,15 @@ static int32_t usb_uart_worker(void* context) {

    memcpy(&usb_uart->cfg, &usb_uart->cfg_new, sizeof(UsbUartConfig));

+    usb_uart->cli_vcp = furi_record_open(RECORD_CLI_VCP);
+
    usb_uart->rx_stream = furi_stream_buffer_alloc(USB_UART_RX_BUF_SIZE, 1);

    usb_uart->tx_sem = furi_semaphore_alloc(1, 1);
    usb_uart->usb_mutex = furi_mutex_alloc(FuriMutexTypeNormal);

    usb_uart->tx_thread =
-        furi_thread_alloc_ex("UsbUartTxWorker", 512, usb_uart_tx_thread, usb_uart);
+        furi_thread_alloc_ex("UsbUartTxWorker", 768, usb_uart_tx_thread, usb_uart);

    usb_uart_vcp_init(usb_uart, usb_uart->cfg.vcp_ch);
    usb_uart_serial_init(usb_uart, usb_uart->cfg.uart_ch);
@@ -288,8 +285,6 @@ static int32_t usb_uart_worker(void* context) {
            usb_uart_update_ctrl_lines(usb_uart);
        }
    }
-    usb_uart_vcp_deinit(usb_uart, usb_uart->cfg.vcp_ch);
-    usb_uart_serial_deinit(usb_uart);

    furi_hal_gpio_init(USB_USART_DE_RE_PIN, GpioModeAnalog, GpioPullNo, GpioSpeedLow);

@@ -302,15 +297,18 @@ static int32_t usb_uart_worker(void* context) {
    furi_thread_join(usb_uart->tx_thread);
    furi_thread_free(usb_uart->tx_thread);

+    usb_uart_vcp_deinit(usb_uart, usb_uart->cfg.vcp_ch);
+    usb_uart_serial_deinit(usb_uart);
+
    furi_stream_buffer_free(usb_uart->rx_stream);
    furi_mutex_free(usb_uart->usb_mutex);
    furi_semaphore_free(usb_uart->tx_sem);

    furi_hal_usb_unlock();
    furi_check(furi_hal_usb_set_config(&usb_cdc_single, NULL) == true);
-    Cli* cli = furi_record_open(RECORD_CLI);
-    cli_session_open(cli, &cli_vcp);
-    furi_record_close(RECORD_CLI);
+    cli_vcp_enable(usb_uart->cli_vcp);
+
+    furi_record_close(RECORD_CLI_VCP);

    return 0;
 }
--- a/applications/main/ibutton/application.fam
+++ b/applications/main/ibutton/application.fam
@@ -13,10 +13,10 @@ App(
 )

 App(
-    appid="ibutton_start",
-    apptype=FlipperAppType.STARTUP,
+    appid="cli_ikey",
    targets=["f7"],
-    entry_point="ibutton_on_system_start",
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="cli_ikey_ep",
+    requires=["cli"],
    sources=["ibutton_cli.c"],
-    order=60,
 )
--- a/applications/main/ibutton/ibutton_cli.c
+++ b/applications/main/ibutton/ibutton_cli.c
@@ -1,26 +1,14 @@
 #include <furi.h>
 #include <furi_hal.h>

-#include <cli/cli.h>
+#include <cli/cli_main_commands.h>
 #include <toolbox/args.h>
+#include <toolbox/pipe.h>

 #include <ibutton/ibutton_key.h>
 #include <ibutton/ibutton_worker.h>
 #include <ibutton/ibutton_protocols.h>

-static void ibutton_cli(Cli* cli, FuriString* args, void* context);
-
-// app cli function
-void ibutton_on_system_start(void) {
-#ifdef SRV_CLI
-    Cli* cli = furi_record_open(RECORD_CLI);
-    cli_add_command(cli, "ikey", CliCommandFlagDefault, ibutton_cli, cli);
-    furi_record_close(RECORD_CLI);
-#else
-    UNUSED(ibutton_cli);
-#endif
-}
-
 static void ibutton_cli_print_usage(void) {
    printf("Usage:\r\n");
    printf("ikey read\r\n");
@@ -92,7 +80,7 @@ static void ibutton_cli_worker_read_cb(void* context) {
    furi_event_flag_set(event, EVENT_FLAG_IBUTTON_COMPLETE);
 }

-static void ibutton_cli_read(Cli* cli) {
+static void ibutton_cli_read(PipeSide* pipe) {
    iButtonProtocols* protocols = ibutton_protocols_alloc();
    iButtonWorker* worker = ibutton_worker_alloc(protocols);
    iButtonKey* key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(protocols));
@@ -113,7 +101,7 @@ static void ibutton_cli_read(Cli* cli) {
            break;
        }

-        if(cli_cmd_interrupt_received(cli)) break;
+        if(cli_is_pipe_broken_or_is_etx_next_char(pipe)) break;
    }

    ibutton_worker_stop(worker);
@@ -138,7 +126,7 @@ static void ibutton_cli_worker_write_cb(void* context, iButtonWorkerWriteResult
    furi_event_flag_set(write_context->event, EVENT_FLAG_IBUTTON_COMPLETE);
 }

-void ibutton_cli_write(Cli* cli, FuriString* args) {
+void ibutton_cli_write(PipeSide* pipe, FuriString* args) {
    iButtonProtocols* protocols = ibutton_protocols_alloc();
    iButtonWorker* worker = ibutton_worker_alloc(protocols);
    iButtonKey* key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(protocols));
@@ -181,7 +169,7 @@ void ibutton_cli_write(Cli* cli, FuriString* args) {
                }
            }

-            if(cli_cmd_interrupt_received(cli)) break;
+            if(cli_is_pipe_broken_or_is_etx_next_char(pipe)) break;
        }
    } while(false);

@@ -195,7 +183,7 @@ void ibutton_cli_write(Cli* cli, FuriString* args) {
    furi_event_flag_free(write_context.event);
 }

-void ibutton_cli_emulate(Cli* cli, FuriString* args) {
+void ibutton_cli_emulate(PipeSide* pipe, FuriString* args) {
    iButtonProtocols* protocols = ibutton_protocols_alloc();
    iButtonWorker* worker = ibutton_worker_alloc(protocols);
    iButtonKey* key = ibutton_key_alloc(ibutton_protocols_get_max_data_size(protocols));
@@ -214,7 +202,7 @@ void ibutton_cli_emulate(Cli* cli, FuriString* args) {

        ibutton_worker_emulate_start(worker, key);

-        while(!cli_cmd_interrupt_received(cli)) {
+        while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
            furi_delay_ms(100);
        };

@@ -228,8 +216,7 @@ void ibutton_cli_emulate(Cli* cli, FuriString* args) {
    ibutton_protocols_free(protocols);
 }

-void ibutton_cli(Cli* cli, FuriString* args, void* context) {
-    UNUSED(cli);
+static void execute(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    FuriString* cmd;
    cmd = furi_string_alloc();
@@ -241,14 +228,16 @@ void ibutton_cli(Cli* cli, FuriString* args, void* context) {
    }

    if(furi_string_cmp_str(cmd, "read") == 0) {
-        ibutton_cli_read(cli);
+        ibutton_cli_read(pipe);
    } else if(furi_string_cmp_str(cmd, "write") == 0) {
-        ibutton_cli_write(cli, args);
+        ibutton_cli_write(pipe, args);
    } else if(furi_string_cmp_str(cmd, "emulate") == 0) {
-        ibutton_cli_emulate(cli, args);
+        ibutton_cli_emulate(pipe, args);
    } else {
        ibutton_cli_print_usage();
    }

    furi_string_free(cmd);
 }
+
+CLI_COMMAND_INTERFACE(ikey, execute, CliCommandFlagDefault, 1024, CLI_APPID);
--- a/applications/main/infrared/application.fam
+++ b/applications/main/infrared/application.fam
@@ -15,14 +15,14 @@ App(
 )

 App(
-    appid="infrared_start",
-    apptype=FlipperAppType.STARTUP,
+    appid="cli_ir",
    targets=["f7"],
-    entry_point="infrared_on_system_start",
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="cli_ir_ep",
+    requires=["cli"],
    sources=[
        "infrared_cli.c",
        "infrared_brute_force.c",
        "infrared_signal.c",
    ],
-    order=20,
 )
--- a/applications/main/infrared/infrared_app.c
+++ b/applications/main/infrared/infrared_app.c
@@ -1,6 +1,6 @@
 #include "infrared_app_i.h"

-#include <furi_hal_power.h>
+#include <power/power_service/power.h>

 #include <string.h>
 #include <toolbox/path.h>
@@ -88,6 +88,19 @@ static void infrared_rpc_command_callback(const RpcAppSystemEvent* event, void*
            view_dispatcher_send_custom_event(
                infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonPressIndex);
        }
+    } else if(event->type == RpcAppEventTypeButtonPressRelease) {
+        furi_assert(
+            event->data.type == RpcAppSystemEventDataTypeString ||
+            event->data.type == RpcAppSystemEventDataTypeInt32);
+        if(event->data.type == RpcAppSystemEventDataTypeString) {
+            furi_string_set(infrared->button_name, event->data.string);
+            view_dispatcher_send_custom_event(
+                infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonPressReleaseName);
+        } else {
+            infrared->app_state.current_button_index = event->data.i32;
+            view_dispatcher_send_custom_event(
+                infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonPressReleaseIndex);
+        }
    } else if(event->type == RpcAppEventTypeButtonRelease) {
        view_dispatcher_send_custom_event(
            infrared->view_dispatcher, InfraredCustomEventTypeRpcButtonRelease);
@@ -411,6 +424,26 @@ void infrared_tx_stop(InfraredApp* infrared) {
    infrared->app_state.last_transmit_time = furi_get_tick();
 }

+void infrared_tx_send_once(InfraredApp* infrared) {
+    if(infrared->app_state.is_transmitting) {
+        return;
+    }
+
+    dolphin_deed(DolphinDeedIrSend);
+    infrared_signal_transmit(infrared->current_signal);
+}
+
+InfraredErrorCode infrared_tx_send_once_button_index(InfraredApp* infrared, size_t button_index) {
+    furi_assert(button_index < infrared_remote_get_signal_count(infrared->remote));
+
+    InfraredErrorCode error = infrared_remote_load_signal(
+        infrared->remote, infrared->current_signal, infrared->app_state.current_button_index);
+    if(!INFRARED_ERROR_PRESENT(error)) {
+        infrared_tx_send_once(infrared);
+    }
+
+    return error;
+}
 void infrared_blocking_task_start(InfraredApp* infrared, FuriThreadCallback callback) {
    view_dispatcher_switch_to_view(infrared->view_dispatcher, InfraredViewLoading);
    furi_thread_set_callback(infrared->task_thread, callback);
@@ -468,12 +501,12 @@ void infrared_set_tx_pin(InfraredApp* infrared, FuriHalInfraredTxPin tx_pin) {
 }

 void infrared_enable_otg(InfraredApp* infrared, bool enable) {
-    if(enable) {
-        furi_hal_power_enable_otg();
-    } else {
-        furi_hal_power_disable_otg();
-    }
+    Power* power = furi_record_open(RECORD_POWER);
+
+    power_enable_otg(power, enable);
    infrared->app_state.is_otg_enabled = enable;
+
+    furi_record_close(RECORD_POWER);
 }

 static void infrared_load_settings(InfraredApp* infrared) {
--- a/applications/main/infrared/infrared_app_i.h
+++ b/applications/main/infrared/infrared_app_i.h
@@ -218,6 +218,20 @@ InfraredErrorCode infrared_tx_start_button_index(InfraredApp* infrared, size_t b
 */
 void infrared_tx_stop(InfraredApp* infrared);

+/**
+ * @brief Transmit the currently loaded signal once.
+ * 
+ * @param[in,out] infrared pointer to the application instance.
+ */
+void infrared_tx_send_once(InfraredApp* infrared);
+
+/**
+ * @brief Load the signal under the given index and transmit it once.
+ *
+ * @param[in,out] infrared pointer to the application instance.
+ */
+InfraredErrorCode infrared_tx_send_once_button_index(InfraredApp* infrared, size_t button_index);
+
 /**
 * @brief Start a blocking task in a separate thread.
 *
--- a/applications/main/infrared/infrared_brute_force.c
+++ b/applications/main/infrared/infrared_brute_force.c
@@ -2,26 +2,61 @@

 #include <stdlib.h>
 #include <m-dict.h>
+#include <m-array.h>
 #include <flipper_format/flipper_format.h>

 #include "infrared_signal.h"

+ARRAY_DEF(SignalPositionArray, size_t, M_DEFAULT_OPLIST);
+
 typedef struct {
-    uint32_t index;
-    uint32_t count;
+    size_t index;
+    SignalPositionArray_t signals;
 } InfraredBruteForceRecord;

+static inline void ir_bf_record_init(InfraredBruteForceRecord* record) {
+    record->index = 0;
+    SignalPositionArray_init(record->signals);
+}
+#define IR_BF_RECORD_INIT(r) (ir_bf_record_init(&(r)))
+
+static inline void
+    ir_bf_record_init_set(InfraredBruteForceRecord* dest, const InfraredBruteForceRecord* src) {
+    dest->index = src->index;
+    SignalPositionArray_init_set(dest->signals, src->signals);
+}
+#define IR_BF_RECORD_INIT_SET(d, s) (ir_bf_record_init_set(&(d), &(s)))
+
+static inline void
+    ir_bf_record_set(InfraredBruteForceRecord* dest, const InfraredBruteForceRecord* src) {
+    dest->index = src->index;
+    SignalPositionArray_set(dest->signals, src->signals);
+}
+#define IR_BF_RECORD_SET(d, s) (ir_bf_record_set(&(d), &(s)))
+
+static inline void ir_bf_record_clear(InfraredBruteForceRecord* record) {
+    SignalPositionArray_clear(record->signals);
+}
+#define IR_BF_RECORD_CLEAR(r) (ir_bf_record_clear(&(r)))
+
+#define IR_BF_RECORD_OPLIST           \
+    (INIT(IR_BF_RECORD_INIT),         \
+     INIT_SET(IR_BF_RECORD_INIT_SET), \
+     SET(IR_BF_RECORD_SET),           \
+     CLEAR(IR_BF_RECORD_CLEAR))
+
 DICT_DEF2(
    InfraredBruteForceRecordDict,
    FuriString*,
    FURI_STRING_OPLIST,
    InfraredBruteForceRecord,
-    M_POD_OPLIST);
+    IR_BF_RECORD_OPLIST);

 struct InfraredBruteForce {
    FlipperFormat* ff;
    const char* db_filename;
    FuriString* current_record_name;
+    InfraredBruteForceRecord current_record;
    InfraredSignal* current_signal;
    InfraredBruteForceRecordDict_t records;
    bool is_started;
@@ -39,6 +74,7 @@ InfraredBruteForce* infrared_brute_force_alloc(void) {
 }

 void infrared_brute_force_free(InfraredBruteForce* brute_force) {
+    furi_check(brute_force);
    furi_assert(!brute_force->is_started);
    InfraredBruteForceRecordDict_clear(brute_force->records);
    furi_string_free(brute_force->current_record_name);
@@ -46,11 +82,13 @@ void infrared_brute_force_free(InfraredBruteForce* brute_force) {
 }

 void infrared_brute_force_set_db_filename(InfraredBruteForce* brute_force, const char* db_filename) {
+    furi_check(brute_force);
    furi_assert(!brute_force->is_started);
    brute_force->db_filename = db_filename;
 }

 InfraredErrorCode infrared_brute_force_calculate_messages(InfraredBruteForce* brute_force) {
+    furi_check(brute_force);
    furi_assert(!brute_force->is_started);
    furi_assert(brute_force->db_filename);
    InfraredErrorCode error = InfraredErrorCodeNone;
@@ -66,19 +104,19 @@ InfraredErrorCode infrared_brute_force_calculate_messages(InfraredBruteForce* br
            break;
        }

-        bool signals_valid = false;
+        bool signal_valid = false;
        while(infrared_signal_read_name(ff, signal_name) == InfraredErrorCodeNone) {
+            size_t signal_start = flipper_format_tell(ff);
            error = infrared_signal_read_body(signal, ff);
-            signals_valid = (!INFRARED_ERROR_PRESENT(error)) && infrared_signal_is_valid(signal);
-            if(!signals_valid) break;
+            signal_valid = (!INFRARED_ERROR_PRESENT(error)) && infrared_signal_is_valid(signal);
+            if(!signal_valid) break;

            InfraredBruteForceRecord* record =
                InfraredBruteForceRecordDict_get(brute_force->records, signal_name);
-            if(record) { //-V547
-                ++(record->count);
-            }
+            furi_assert(record);
+            SignalPositionArray_push_back(record->signals, signal_start);
        }
-        if(!signals_valid) break;
+        if(!signal_valid) break;
    } while(false);

    infrared_signal_free(signal);
@@ -93,6 +131,7 @@ bool infrared_brute_force_start(
    InfraredBruteForce* brute_force,
    uint32_t index,
    uint32_t* record_count) {
+    furi_check(brute_force);
    furi_assert(!brute_force->is_started);
    bool success = false;
    *record_count = 0;
@@ -103,9 +142,10 @@ bool infrared_brute_force_start(
        InfraredBruteForceRecordDict_next(it)) {
        const InfraredBruteForceRecordDict_itref_t* record = InfraredBruteForceRecordDict_cref(it);
        if(record->value.index == index) {
-            *record_count = record->value.count;
+            *record_count = SignalPositionArray_size(record->value.signals);
            if(*record_count) {
                furi_string_set(brute_force->current_record_name, record->key);
+                brute_force->current_record = record->value;
            }
            break;
        }
@@ -124,10 +164,12 @@ bool infrared_brute_force_start(
 }

 bool infrared_brute_force_is_started(const InfraredBruteForce* brute_force) {
+    furi_check(brute_force);
    return brute_force->is_started;
 }

 void infrared_brute_force_stop(InfraredBruteForce* brute_force) {
+    furi_check(brute_force);
    furi_assert(brute_force->is_started);
    furi_string_reset(brute_force->current_record_name);
    infrared_signal_free(brute_force->current_signal);
@@ -138,25 +180,32 @@ void infrared_brute_force_stop(InfraredBruteForce* brute_force) {
    furi_record_close(RECORD_STORAGE);
 }

-bool infrared_brute_force_send_next(InfraredBruteForce* brute_force) {
+bool infrared_brute_force_send(InfraredBruteForce* brute_force, uint32_t signal_index) {
+    furi_check(brute_force);
    furi_assert(brute_force->is_started);

-    const bool success = infrared_signal_search_by_name_and_read(
-                             brute_force->current_signal,
-                             brute_force->ff,
-                             furi_string_get_cstr(brute_force->current_record_name)) ==
-                         InfraredErrorCodeNone;
-    if(success) {
-        infrared_signal_transmit(brute_force->current_signal);
-    }
-    return success;
+    if(signal_index >= SignalPositionArray_size(brute_force->current_record.signals)) return false;
+
+    size_t signal_start =
+        *SignalPositionArray_cget(brute_force->current_record.signals, signal_index);
+    if(!flipper_format_seek(brute_force->ff, signal_start, FlipperFormatOffsetFromStart))
+        return false;
+
+    if(INFRARED_ERROR_PRESENT(
+           infrared_signal_read_body(brute_force->current_signal, brute_force->ff)))
+        return false;
+
+    infrared_signal_transmit(brute_force->current_signal);
+    return true;
 }

 void infrared_brute_force_add_record(
    InfraredBruteForce* brute_force,
    uint32_t index,
    const char* name) {
-    InfraredBruteForceRecord value = {.index = index, .count = 0};
+    InfraredBruteForceRecord value;
+    ir_bf_record_init(&value);
+    value.index = index;
    FuriString* key;
    key = furi_string_alloc_set(name);
    InfraredBruteForceRecordDict_set_at(brute_force->records, key, value);
--- a/applications/main/infrared/infrared_brute_force.h
+++ b/applications/main/infrared/infrared_brute_force.h
@@ -78,18 +78,16 @@ bool infrared_brute_force_is_started(const InfraredBruteForce* brute_force);
 void infrared_brute_force_stop(InfraredBruteForce* brute_force);

 /**
- * @brief Send the next signal from the chosen category.
- *
- * This function is called repeatedly until no more signals are left
- * in the chosen signal category.
- *
- * @warning Transmission must be started first by calling infrared_brute_force_start()
- * before calling this function.
- *
- * @param[in,out] brute_force pointer to the instance to be used.
- * @returns true if the next signal existed and could be transmitted, false otherwise.
+ * @brief Send an arbitrary signal from the chosen category.
+ * 
+ * @param[in] brute_force pointer to the instance
+ * @param signal_index the index of the signal within the category, must be
+ *                     between 0 and `record_count` as told by
+ *                     `infrared_brute_force_start`
+ * 
+ * @returns true on success, false otherwise
 */
-bool infrared_brute_force_send_next(InfraredBruteForce* brute_force);
+bool infrared_brute_force_send(InfraredBruteForce* brute_force, uint32_t signal_index);

 /**
 * @brief Add a signal category to an InfraredBruteForce instance's dictionary.
--- a/applications/main/infrared/infrared_cli.c
+++ b/applications/main/infrared/infrared_cli.c
@@ -1,11 +1,11 @@
-#include <cli/cli.h>
-#include <cli/cli_i.h>
+#include <cli/cli_main_commands.h>
 #include <infrared.h>
 #include <infrared_worker.h>
 #include <furi_hal_infrared.h>
 #include <flipper_format.h>
 #include <toolbox/args.h>
 #include <toolbox/strint.h>
+#include <toolbox/pipe.h>
 #include <m-dict.h>

 #include "infrared_signal.h"
@@ -19,14 +19,14 @@

 DICT_DEF2(dict_signals, FuriString*, FURI_STRING_OPLIST, int, M_DEFAULT_OPLIST)

-static void infrared_cli_start_ir_rx(Cli* cli, FuriString* args);
-static void infrared_cli_start_ir_tx(Cli* cli, FuriString* args);
-static void infrared_cli_process_decode(Cli* cli, FuriString* args);
-static void infrared_cli_process_universal(Cli* cli, FuriString* args);
+static void infrared_cli_start_ir_rx(PipeSide* pipe, FuriString* args);
+static void infrared_cli_start_ir_tx(PipeSide* pipe, FuriString* args);
+static void infrared_cli_process_decode(PipeSide* pipe, FuriString* args);
+static void infrared_cli_process_universal(PipeSide* pipe, FuriString* args);

 static const struct {
    const char* cmd;
-    void (*process_function)(Cli* cli, FuriString* args);
+    void (*process_function)(PipeSide* pipe, FuriString* args);
 } infrared_cli_commands[] = {
    {.cmd = "rx", .process_function = infrared_cli_start_ir_rx},
    {.cmd = "tx", .process_function = infrared_cli_start_ir_tx},
@@ -38,7 +38,7 @@ static void signal_received_callback(void* context, InfraredWorkerSignal* receiv
    furi_assert(received_signal);
    char buf[100];
    size_t buf_cnt;
-    Cli* cli = (Cli*)context;
+    PipeSide* pipe = (PipeSide*)context;

    if(infrared_worker_signal_is_decoded(received_signal)) {
        const InfraredMessage* message = infrared_worker_get_decoded_signal(received_signal);
@@ -52,20 +52,20 @@ static void signal_received_callback(void* context, InfraredWorkerSignal* receiv
            ROUND_UP_TO(infrared_get_protocol_command_length(message->protocol), 4),
            message->command,
            message->repeat ? " R" : "");
-        cli_write(cli, (uint8_t*)buf, buf_cnt);
+        pipe_send(pipe, buf, buf_cnt);
    } else {
        const uint32_t* timings;
        size_t timings_cnt;
        infrared_worker_get_raw_signal(received_signal, &timings, &timings_cnt);

        buf_cnt = snprintf(buf, sizeof(buf), "RAW, %zu samples:\r\n", timings_cnt);
-        cli_write(cli, (uint8_t*)buf, buf_cnt);
+        pipe_send(pipe, buf, buf_cnt);
        for(size_t i = 0; i < timings_cnt; ++i) {
            buf_cnt = snprintf(buf, sizeof(buf), "%lu ", timings[i]);
-            cli_write(cli, (uint8_t*)buf, buf_cnt);
+            pipe_send(pipe, buf, buf_cnt);
        }
        buf_cnt = snprintf(buf, sizeof(buf), "\r\n");
-        cli_write(cli, (uint8_t*)buf, buf_cnt);
+        pipe_send(pipe, buf, buf_cnt);
    }
 }

@@ -124,9 +124,7 @@ static void infrared_cli_print_usage(void) {
    infrared_cli_print_universal_remotes();
 }

-static void infrared_cli_start_ir_rx(Cli* cli, FuriString* args) {
-    UNUSED(cli);
-
+static void infrared_cli_start_ir_rx(PipeSide* pipe, FuriString* args) {
    bool enable_decoding = true;

    if(!furi_string_empty(args)) {
@@ -142,10 +140,10 @@ static void infrared_cli_start_ir_rx(Cli* cli, FuriString* args) {
    InfraredWorker* worker = infrared_worker_alloc();
    infrared_worker_rx_enable_signal_decoding(worker, enable_decoding);
    infrared_worker_rx_start(worker);
-    infrared_worker_rx_set_received_signal_callback(worker, signal_received_callback, cli);
+    infrared_worker_rx_set_received_signal_callback(worker, signal_received_callback, pipe);

    printf("Receiving %s INFRARED...\r\nPress Ctrl+C to abort\r\n", enable_decoding ? "" : "RAW");
-    while(!cli_cmd_interrupt_received(cli)) {
+    while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
        furi_delay_ms(50);
    }

@@ -214,8 +212,8 @@ static bool infrared_cli_parse_raw(const char* str, InfraredSignal* signal) {
    return infrared_signal_is_valid(signal);
 }

-static void infrared_cli_start_ir_tx(Cli* cli, FuriString* args) {
-    UNUSED(cli);
+static void infrared_cli_start_ir_tx(PipeSide* pipe, FuriString* args) {
+    UNUSED(pipe);
    const char* str = furi_string_get_cstr(args);
    InfraredSignal* signal = infrared_signal_alloc();

@@ -335,8 +333,8 @@ static bool infrared_cli_decode_file(FlipperFormat* input_file, FlipperFormat* o
    return ret;
 }

-static void infrared_cli_process_decode(Cli* cli, FuriString* args) {
-    UNUSED(cli);
+static void infrared_cli_process_decode(PipeSide* pipe, FuriString* args) {
+    UNUSED(pipe);
    Storage* storage = furi_record_open(RECORD_STORAGE);
    FlipperFormat* input_file = flipper_format_buffered_file_alloc(storage);
    FlipperFormat* output_file = NULL;
@@ -455,8 +453,10 @@ static void infrared_cli_list_remote_signals(FuriString* remote_name) {
    furi_record_close(RECORD_STORAGE);
 }

-static void
-    infrared_cli_brute_force_signals(Cli* cli, FuriString* remote_name, FuriString* signal_name) {
+static void infrared_cli_brute_force_signals(
+    PipeSide* pipe,
+    FuriString* remote_name,
+    FuriString* signal_name) {
    InfraredBruteForce* brute_force = infrared_brute_force_alloc();
    FuriString* remote_path = furi_string_alloc_printf(
        "%s/%s.ir", INFRARED_ASSETS_FOLDER, furi_string_get_cstr(remote_name));
@@ -475,25 +475,24 @@ static void
            break;
        }

-        uint32_t record_count;
+        uint32_t signal_count, current_signal = 0;
        bool running = infrared_brute_force_start(
-            brute_force, INFRARED_BRUTE_FORCE_DUMMY_INDEX, &record_count);
+            brute_force, INFRARED_BRUTE_FORCE_DUMMY_INDEX, &signal_count);

-        if(record_count <= 0) {
+        if(signal_count <= 0) {
            printf("Invalid signal name.\r\n");
            break;
        }

-        printf("Sending %lu signal(s)...\r\n", record_count);
+        printf("Sending %lu signal(s)...\r\n", signal_count);
        printf("Press Ctrl-C to stop.\r\n");

-        int records_sent = 0;
        while(running) {
-            running = infrared_brute_force_send_next(brute_force);
+            running = infrared_brute_force_send(brute_force, current_signal);

-            if(cli_cmd_interrupt_received(cli)) break;
+            if(cli_is_pipe_broken_or_is_etx_next_char(pipe)) break;

-            printf("\r%d%% complete.", (int)((float)records_sent++ / (float)record_count * 100));
+            printf("\r%d%% complete.", (int)((float)current_signal++ / (float)signal_count * 100));
            fflush(stdout);
        }

@@ -505,7 +504,7 @@ static void
    infrared_brute_force_free(brute_force);
 }

-static void infrared_cli_process_universal(Cli* cli, FuriString* args) {
+static void infrared_cli_process_universal(PipeSide* pipe, FuriString* args) {
    FuriString* arg1 = furi_string_alloc();
    FuriString* arg2 = furi_string_alloc();

@@ -520,14 +519,14 @@ static void infrared_cli_process_universal(Cli* cli, FuriString* args) {
    } else if(furi_string_equal_str(arg1, "list")) {
        infrared_cli_list_remote_signals(arg2);
    } else {
-        infrared_cli_brute_force_signals(cli, arg1, arg2);
+        infrared_cli_brute_force_signals(pipe, arg1, arg2);
    }

    furi_string_free(arg1);
    furi_string_free(arg2);
 }

-static void infrared_cli_start_ir(Cli* cli, FuriString* args, void* context) {
+static void execute(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    if(furi_hal_infrared_is_busy()) {
        printf("INFRARED is busy. Exiting.");
@@ -547,19 +546,12 @@ static void infrared_cli_start_ir(Cli* cli, FuriString* args, void* context) {
    }

    if(i < COUNT_OF(infrared_cli_commands)) {
-        infrared_cli_commands[i].process_function(cli, args);
+        infrared_cli_commands[i].process_function(pipe, args);
    } else {
        infrared_cli_print_usage();
    }

    furi_string_free(command);
 }
-void infrared_on_system_start(void) {
-#ifdef SRV_CLI
-    Cli* cli = (Cli*)furi_record_open(RECORD_CLI);
-    cli_add_command(cli, "ir", CliCommandFlagDefault, infrared_cli_start_ir, NULL);
-    furi_record_close(RECORD_CLI);
-#else
-    UNUSED(infrared_cli_start_ir);
-#endif
-}
+
+CLI_COMMAND_INTERFACE(ir, execute, CliCommandFlagDefault, 2048, CLI_APPID);
--- a/applications/main/infrared/infrared_custom_event.h
+++ b/applications/main/infrared/infrared_custom_event.h
@@ -3,7 +3,7 @@
 #include <stdint.h>
 #include <stddef.h>

-enum InfraredCustomEventType {
+typedef enum {
    // Reserve first 100 events for button types and indexes, starting from 0
    InfraredCustomEventTypeReserved = 100,
    InfraredCustomEventTypeMenuSelected,
@@ -13,7 +13,7 @@ enum InfraredCustomEventType {
    InfraredCustomEventTypeTextEditDone,
    InfraredCustomEventTypePopupClosed,
    InfraredCustomEventTypeButtonSelected,
-    InfraredCustomEventTypeBackPressed,
+    InfraredCustomEventTypePopupInput,
    InfraredCustomEventTypeTaskFinished,

    InfraredCustomEventTypeRpcLoadFile,
@@ -21,11 +21,13 @@ enum InfraredCustomEventType {
    InfraredCustomEventTypeRpcButtonPressName,
    InfraredCustomEventTypeRpcButtonPressIndex,
    InfraredCustomEventTypeRpcButtonRelease,
+    InfraredCustomEventTypeRpcButtonPressReleaseName,
+    InfraredCustomEventTypeRpcButtonPressReleaseIndex,
    InfraredCustomEventTypeRpcSessionClose,

    InfraredCustomEventTypeGpioTxPinChanged,
    InfraredCustomEventTypeGpioOtgChanged,
-};
+} InfraredCustomEventType;

 #pragma pack(push, 1)
 typedef union {
--- a/applications/main/infrared/resources/infrared/assets/ac.ir
+++ b/applications/main/infrared/resources/infrared/assets/ac.ir
@@ -1896,3 +1896,42 @@ type: raw
 frequency: 38000
 duty_cycle: 0.330000
 data: 9024 4481 655 551 655 1653 654 550 656 1652 655 1652 656 550 656 550 656 550 656 550 656 551 655 1652 655 551 655 1652 655 550 656 551 655 1654 654 550 656 550 656 551 655 1652 655 550 656 551 654 550 656 1652 655 1651 657 550 655 551 655 550 656 1654 654 550 656 1653 654 551 654 551 655 1651 656 551 655 19984 655 550 656 551 655 550 656 551 655 550 655 551 655 551 655 550 656 1654 653 1653 655 1653 655 550 655 551 655 550 656 551 655 551 655 550 656 551 655 551 655 551 655 551 655 551 655 550 656 550 656 550 656 551 655 551 655 551 655 1652 656 550 656 551 655 550 656 39996 8999 4479 656 551 655 1652 656 550 656 1653 655 1653 655 550 656 551 655 550 656 551 655 551 655 1652 655 551 655 1652 655 550 656 551 655 1653 655 551 655 550 656 550 656 1652 655 551 654 551 655 551 655 1652 655 1652 656 551 655 551 655 552 654 551 655 1653 655 1653 655 551 655 549 656 1653 655 552 654 19984 655 1652 655 551 655 550 656 1652 656 551 655 551 655 551 655 1652 655 1652 655 551 656 1652 656 1653 655 1653 655 551 655 1652 655 551 655 551 655 551 654 551 654 551 655 551 655 1653 655 550 656 551 655 1652 656 1653 654 551 655 551 655 551 655 550 655 550 656 551 655
+#
+# Model: Fujitsu ASTG12LVCC
+#
+name: Off
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 3258 1573 427 404 426 404 425 1180 428 403 427 1183 425 402 427 402 428 402 427 1180 428 1181 427 404 426 403 427 402 428 1181 427 1181 427 402 427 405 425 402 427 402 427 403 427 402 428 402 428 403 426 401 429 403 427 402 428 403 427 403 427 1180 428 401 428 404 425 401 428 402 427 402 427 402 427 402 428 1180 427 401 428 403 427 402 427 401 428 1180 427 401 428 402 427 402 428 402 427 401 428 403 427 1180 427 402 427 1180 427 1180 427 1177 429 1179 427 1179 427 1178 428
+# 
+name: Dh
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 39677 99167 3233 1570 425 405 425 404 425 1184 424 405 425 1182 426 405 424 404 426 404 425 1181 427 1182 426 403 427 403 426 404 426 1183 425 1183 425 403 426 404 426 406 424 404 425 405 425 402 427 405 425 404 425 403 426 404 426 404 425 402 427 405 424 1182 425 402 427 404 426 403 426 404 425 404 426 404 425 404 425 1183 424 406 423 404 426 403 426 404 425 1181 427 1182 426 1181 426 1181 426 1181 425 1182 425 1181 426 1182 426 403 426 404 425 1182 426 404 425 404 425 405 425 404 426 403 426 403 427 404 426 404 426 1182 426 1182 426 403 426 404 426 1182 426 405 424 404 426 403 426 1182 426 405 425 403 426 1182 426 404 426 1183 425 403 426 403 426 404 425 403 426 405 425 403 426 1182 425 1182 425 403 427 404 425 1181 426 403 427 403 426 404 425 406 424 404 426 404 425 404 426 404 425 404 426 404 426 404 426 404 426 404 425 404 426 404 426 403 426 403 427 404 425 402 427 405 425 403 426 404 425 404 425 404 425 405 425 404 425 404 425 404 426 403 426 402 427 403 427 403 426 1182 425 404 426 404 425 403 426 1182 425 403 426 1181 426 403 427 403 426 404 425 405 425
+# 
+name: Cool_hi
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 39674 99137 3228 1573 422 407 421 408 422 1185 423 408 422 1187 421 410 419 409 421 408 421 1186 422 1187 421 408 421 408 422 409 421 1187 420 1186 422 408 421 410 419 407 424 408 421 407 421 410 420 409 421 408 422 408 421 408 422 407 422 410 419 408 422 1187 420 408 421 408 422 408 421 408 421 408 421 408 420 409 421 1187 444 382 422 408 422 408 421 408 445 1162 419 1187 420 1184 423 1185 421 1184 423 1186 421 1186 421 1187 422 409 419 409 420 1186 422 407 420 409 422 409 420 407 422 407 422 411 419 406 421 409 422 1185 446 1162 420 409 421 409 421 1189 418 407 421 408 422 407 422 409 420 409 421 408 420 412 417 1187 421 407 422 408 420 410 421 408 421 409 421 409 445 384 420 410 421 407 421 407 422 409 421 1187 420 409 419 409 421 408 422 408 421 410 419 409 420 410 419 410 420 407 422 409 420 408 421 407 422 408 421 408 421 410 419 409 420 407 423 407 422 409 421 410 419 411 418 408 421 408 422 410 420 407 421 409 419 409 421 409 419 408 422 407 422 407 422 409 420 1188 419 409 421 409 420 409 419 1189 419 1186 421 1188 419 1187 420 408 421 407 422 1188 419
+# 
+name: Cool_lo
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 39689 99188 3229 1576 421 407 422 409 420 1188 419 409 421 1187 422 408 422 409 419 410 419 1187 422 1186 423 410 419 409 421 409 420 1187 420 1188 420 410 447 382 420 409 422 410 446 383 422 409 420 407 422 410 395 435 420 408 422 407 422 410 420 409 445 1162 420 410 420 409 420 410 420 409 421 410 419 409 421 409 419 1189 420 407 422 409 395 437 419 410 418 1186 422 1186 423 1187 420 1185 422 1188 420 1184 421 1188 419 1188 419 408 420 410 419 1186 421 408 420 410 419 410 419 409 419 411 418 409 421 410 419 409 420 1187 445 1163 419 412 417 409 420 1188 419 409 419 410 420 409 444 1164 418 1187 419 1189 419 409 419 1187 420 408 422 409 419 410 420 409 419 410 419 434 393 411 420 409 421 408 421 409 419 409 421 1188 418 410 419 410 420 410 418 412 417 409 445 385 419 409 420 410 420 408 419 409 421 410 419 411 419 408 446 382 421 409 420 409 420 410 418 409 420 409 419 410 419 412 442 384 419 411 416 412 419 409 420 410 419 410 419 410 418 410 420 409 420 409 420 434 394 1187 419 412 417 410 418 410 420 1188 419 1187 420 1188 419 410 419 1188 419 411 418 434 396
+# 
+name: Heat_hi
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 39692 99118 3226 1571 423 406 423 405 423 1185 421 405 424 1183 423 406 422 408 422 405 423 1184 446 1160 422 409 420 406 424 405 424 1185 422 1183 424 404 425 406 422 408 421 406 423 407 422 406 423 407 421 406 424 407 422 407 422 404 425 407 421 409 420 1185 422 406 423 408 421 404 424 405 424 407 447 383 421 406 424 1184 447 380 424 406 422 409 421 407 423 1183 447 1159 424 1185 422 1185 421 1184 422 1185 422 1185 421 1185 423 407 423 406 423 1185 423 406 424 406 423 408 446 381 424 406 423 408 421 406 424 406 423 1185 423 1184 422 407 423 407 422 1187 421 408 421 407 423 407 423 405 424 1185 422 1186 421 1184 423 407 422 407 422 1186 422 407 422 406 423 408 422 405 423 408 447 383 420 409 421 406 423 407 423 1184 423 407 423 407 422 408 421 408 423 406 424 406 422 409 422 406 423 408 421 408 421 406 422 406 424 407 422 406 423 409 421 407 422 408 423 406 423 406 423 409 446 382 447 384 420 407 423 405 424 406 423 406 423 407 423 407 422 406 423 405 422 407 424 406 422 1185 422 406 423 407 422 1183 423 1184 422 407 422 1185 423 1186 421 1184 424 407 422 1185 422
+# 
+name: Heat_lo
+type: raw
+frequency: 38000
+duty_cycle: 0.330000
+data: 39670 99106 3227 1570 424 406 422 407 422 1183 424 405 424 1184 448 380 423 407 421 406 424 1183 424 1185 421 406 423 404 424 405 424 1184 423 1182 425 407 448 380 423 407 422 405 423 406 422 406 424 405 423 407 421 406 423 407 422 405 424 405 423 406 423 1184 422 408 421 408 422 405 424 406 421 407 422 406 423 405 423 1183 424 406 423 405 423 405 423 405 423 1186 421 1184 422 1184 422 1185 422 1184 447 1159 423 1184 422 1184 422 408 421 407 423 1184 421 407 448 381 422 405 423 409 421 406 422 406 422 407 422 406 423 1183 423 1185 422 406 423 405 424 1184 423 408 421 405 424 405 424 1184 422 1185 422 1184 422 407 423 408 420 409 420 1185 447 382 423 405 423 408 421 406 423 407 422 406 423 406 423 408 421 406 423 1183 424 407 422 406 424 405 424 406 423 407 423 406 423 408 422 407 422 405 424 408 421 407 422 407 422 406 423 406 423 407 422 406 423 406 422 408 421 407 422 408 421 407 422 406 423 408 422 406 423 405 423 409 422 406 422 406 423 406 423 407 422 407 423 405 424 1184 423 407 421 406 424 1184 423 1184 422 407 423 1183 423 405 424 1184 423 409 420 407 422
+#
--- a/applications/main/infrared/resources/infrared/assets/audio.ir
+++ b/applications/main/infrared/resources/infrared/assets/audio.ir
@@ -4650,3 +4650,42 @@ type: parsed
 protocol: NECext
 address: 7F 01 00 00
 command: 69 96 00 00
+#
+# Model : NAD DR2 remote for NAD D7050 and D3020
+#
+name: Power
+type: parsed
+protocol: NECext
+address: 87 7C 00 00
+command: 25 DA 00 00
+#
+name: Vol_up
+type: parsed
+protocol: NECext
+address: 87 7C 00 00
+command: 88 77 00 00
+#
+name: Vol_dn
+type: parsed
+protocol: NECext
+address: 87 7C 00 00
+command: 8C 73 00 00
+#
+name: Mute
+type: parsed
+protocol: NECext
+address: 87 7C 00 00
+command: 94 6B 00 00
+#
+name: Next
+type: parsed
+protocol: NECext
+address: 87 7C 00 00
+command: 1A E5 00 00
+#
+name: Prev
+type: parsed
+protocol: NECext
+address: 87 7C 00 00
+command: 1D E2 00 00
+#
--- a/applications/main/infrared/resources/infrared/assets/tv.ir
+++ b/applications/main/infrared/resources/infrared/assets/tv.ir
--- a/applications/main/infrared/scenes/common/infrared_scene_universal_common.c
+++ b/applications/main/infrared/scenes/common/infrared_scene_universal_common.c
@@ -2,15 +2,30 @@

 #include <dolphin/dolphin.h>

-void infrared_scene_universal_common_item_callback(void* context, uint32_t index) {
+#pragma pack(push, 1)
+typedef union {
+    uint32_t packed_value;
+    struct {
+        bool is_paused;
+        uint8_t padding;
+        uint16_t signal_index;
+    };
+} InfraredSceneState;
+#pragma pack(pop)
+
+void infrared_scene_universal_common_item_callback(void* context, uint32_t index, InputType type) {
    InfraredApp* infrared = context;
-    uint32_t event = infrared_custom_event_pack(InfraredCustomEventTypeButtonSelected, index);
-    view_dispatcher_send_custom_event(infrared->view_dispatcher, event);
+    if(type == InputTypeShort) {
+        uint32_t event = infrared_custom_event_pack(InfraredCustomEventTypeButtonSelected, index);
+        view_dispatcher_send_custom_event(infrared->view_dispatcher, event);
+    }
 }

-static void infrared_scene_universal_common_progress_back_callback(void* context) {
+static void infrared_scene_universal_common_progress_input_callback(
+    void* context,
+    InfraredProgressViewInput input) {
    InfraredApp* infrared = context;
-    uint32_t event = infrared_custom_event_pack(InfraredCustomEventTypeBackPressed, -1);
+    uint32_t event = infrared_custom_event_pack(InfraredCustomEventTypePopupInput, input);
    view_dispatcher_send_custom_event(infrared->view_dispatcher, event);
 }

@@ -19,8 +34,8 @@ static void
    ViewStack* view_stack = infrared->view_stack;
    InfraredProgressView* progress = infrared->progress;
    infrared_progress_view_set_progress_total(progress, record_count);
-    infrared_progress_view_set_back_callback(
-        progress, infrared_scene_universal_common_progress_back_callback, infrared);
+    infrared_progress_view_set_input_callback(
+        progress, infrared_scene_universal_common_progress_input_callback, infrared);
    view_stack_add_view(view_stack, infrared_progress_view_get_view(progress));
    infrared_play_notification_message(infrared, InfraredNotificationMessageBlinkStartSend);
 }
@@ -51,29 +66,111 @@ void infrared_scene_universal_common_on_enter(void* context) {
    infrared_blocking_task_start(infrared, infrared_scene_universal_common_task_callback);
 }

+static void infrared_scene_universal_common_handle_popup_input(
+    InfraredApp* infrared,
+    InfraredProgressViewInput input) {
+    InfraredBruteForce* brute_force = infrared->brute_force;
+    SceneManager* scene_manager = infrared->scene_manager;
+    uint32_t scene_id = scene_manager_get_current_scene(infrared->scene_manager);
+    switch(input) {
+    case InfraredProgressViewInputStop: {
+        infrared_brute_force_stop(brute_force);
+        infrared_scene_universal_common_hide_popup(infrared);
+        break;
+    }
+
+    case InfraredProgressViewInputPause: {
+        infrared_play_notification_message(infrared, InfraredNotificationMessageBlinkStop);
+        infrared_progress_view_set_paused(infrared->progress, true);
+        InfraredSceneState scene_state = {
+            .packed_value = scene_manager_get_scene_state(scene_manager, scene_id)};
+        scene_state.is_paused = true;
+        if(scene_state.signal_index)
+            scene_state.signal_index--; // when running, the state stores the next index
+        scene_manager_set_scene_state(scene_manager, scene_id, scene_state.packed_value);
+        break;
+    }
+
+    case InfraredProgressViewInputResume: {
+        infrared_play_notification_message(infrared, InfraredNotificationMessageBlinkStartSend);
+        infrared_progress_view_set_paused(infrared->progress, false);
+        InfraredSceneState scene_state = {
+            .packed_value = scene_manager_get_scene_state(scene_manager, scene_id)};
+        scene_state.is_paused = false;
+        scene_manager_set_scene_state(scene_manager, scene_id, scene_state.packed_value);
+        break;
+    }
+
+    case InfraredProgressViewInputNextSignal: {
+        InfraredSceneState scene_state = {
+            .packed_value = scene_manager_get_scene_state(scene_manager, scene_id)};
+        scene_state.signal_index++;
+        if(infrared_progress_view_set_progress(infrared->progress, scene_state.signal_index + 1))
+            scene_manager_set_scene_state(scene_manager, scene_id, scene_state.packed_value);
+        break;
+    }
+
+    case InfraredProgressViewInputPreviousSignal: {
+        InfraredSceneState scene_state = {
+            .packed_value = scene_manager_get_scene_state(scene_manager, scene_id)};
+        if(scene_state.signal_index) {
+            scene_state.signal_index--;
+            if(infrared_progress_view_set_progress(
+                   infrared->progress, scene_state.signal_index + 1))
+                scene_manager_set_scene_state(scene_manager, scene_id, scene_state.packed_value);
+        }
+        break;
+    }
+
+    case InfraredProgressViewInputSendSingle: {
+        InfraredSceneState scene_state = {
+            .packed_value = scene_manager_get_scene_state(scene_manager, scene_id)};
+        infrared_play_notification_message(infrared, InfraredNotificationMessageBlinkStartSend);
+        infrared_brute_force_send(infrared->brute_force, scene_state.signal_index);
+        infrared_play_notification_message(infrared, InfraredNotificationMessageBlinkStop);
+        break;
+    }
+
+    default:
+        furi_crash();
+    }
+}
+
 bool infrared_scene_universal_common_on_event(void* context, SceneManagerEvent event) {
    InfraredApp* infrared = context;
    SceneManager* scene_manager = infrared->scene_manager;
    InfraredBruteForce* brute_force = infrared->brute_force;
+    uint32_t scene_id = scene_manager_get_current_scene(infrared->scene_manager);
    bool consumed = false;

    if(infrared_brute_force_is_started(brute_force)) {
        if(event.type == SceneManagerEventTypeTick) {
-            bool success = infrared_brute_force_send_next(brute_force);
-            if(success) {
-                success = infrared_progress_view_increase_progress(infrared->progress);
+            InfraredSceneState scene_state = {
+                .packed_value = scene_manager_get_scene_state(scene_manager, scene_id)};
+
+            if(!scene_state.is_paused) {
+                bool success = infrared_brute_force_send(brute_force, scene_state.signal_index);
+                if(success) {
+                    success = infrared_progress_view_set_progress(
+                        infrared->progress, scene_state.signal_index + 1);
+                    scene_state.signal_index++;
+                    scene_manager_set_scene_state(
+                        scene_manager, scene_id, scene_state.packed_value);
+                }
+                if(!success) {
+                    infrared_brute_force_stop(brute_force);
+                    infrared_scene_universal_common_hide_popup(infrared);
+                }
+                consumed = true;
            }
-            if(!success) {
-                infrared_brute_force_stop(brute_force);
-                infrared_scene_universal_common_hide_popup(infrared);
-            }
-            consumed = true;
        } else if(event.type == SceneManagerEventTypeCustom) {
-            if(infrared_custom_event_get_type(event.event) == InfraredCustomEventTypeBackPressed) {
-                infrared_brute_force_stop(brute_force);
-                infrared_scene_universal_common_hide_popup(infrared);
+            uint16_t event_type;
+            int16_t event_value;
+            infrared_custom_event_unpack(event.event, &event_type, &event_value);
+            if(event_type == InfraredCustomEventTypePopupInput) {
+                infrared_scene_universal_common_handle_popup_input(infrared, event_value);
+                consumed = true;
            }
-            consumed = true;
        }
    } else {
        if(event.type == SceneManagerEventTypeBack) {
@@ -87,6 +184,7 @@ bool infrared_scene_universal_common_on_event(void* context, SceneManagerEvent e
            if(event_type == InfraredCustomEventTypeButtonSelected) {
                uint32_t record_count;
                if(infrared_brute_force_start(brute_force, event_value, &record_count)) {
+                    scene_manager_set_scene_state(infrared->scene_manager, scene_id, 0);
                    dolphin_deed(DolphinDeedIrSend);
                    infrared_scene_universal_common_show_popup(infrared, record_count);
                } else {
--- a/applications/main/infrared/scenes/common/infrared_scene_universal_common.h
+++ b/applications/main/infrared/scenes/common/infrared_scene_universal_common.h
@@ -5,4 +5,4 @@
 void infrared_scene_universal_common_on_enter(void* context);
 bool infrared_scene_universal_common_on_event(void* context, SceneManagerEvent event);
 void infrared_scene_universal_common_on_exit(void* context);
-void infrared_scene_universal_common_item_callback(void* context, uint32_t index);
+void infrared_scene_universal_common_item_callback(void* context, uint32_t index, InputType type);
--- a/applications/main/infrared/scenes/infrared_scene_rpc.c
+++ b/applications/main/infrared/scenes/infrared_scene_rpc.c
@@ -124,6 +124,49 @@ bool infrared_scene_rpc_on_event(void* context, SceneManagerEvent event) {

            rpc_system_app_confirm(infrared->rpc_ctx, result);

+        } else if(
+            event.event == InfraredCustomEventTypeRpcButtonPressReleaseName ||
+            event.event == InfraredCustomEventTypeRpcButtonPressReleaseIndex) {
+            bool result = false;
+
+            // Send the signal once and stop
+            if(rpc_state == InfraredRpcStateLoaded) {
+                if(event.event == InfraredCustomEventTypeRpcButtonPressReleaseName) {
+                    const char* button_name = furi_string_get_cstr(infrared->button_name);
+                    size_t index;
+                    const bool index_found =
+                        infrared_remote_get_signal_index(infrared->remote, button_name, &index);
+                    app_state->current_button_index = index_found ? (signed)index :
+                                                                    InfraredButtonIndexNone;
+                    FURI_LOG_D(TAG, "Sending signal with name \"%s\"", button_name);
+                } else {
+                    FURI_LOG_D(
+                        TAG, "Sending signal with index \"%ld\"", app_state->current_button_index);
+                }
+                if(infrared->app_state.current_button_index != InfraredButtonIndexNone) {
+                    InfraredErrorCode error = infrared_tx_send_once_button_index(
+                        infrared, app_state->current_button_index);
+                    if(!INFRARED_ERROR_PRESENT(error)) {
+                        const char* remote_name = infrared_remote_get_name(infrared->remote);
+                        infrared_text_store_set(infrared, 0, "emulating\n%s", remote_name);
+
+                        infrared_scene_rpc_show(infrared);
+                        result = true;
+                    } else {
+                        rpc_system_app_set_error_code(
+                            infrared->rpc_ctx, RpcAppSystemErrorCodeInternalParse);
+                        rpc_system_app_set_error_text(
+                            infrared->rpc_ctx, "Cannot load button data");
+                        result = false;
+                    }
+                }
+            }
+
+            if(result) {
+                scene_manager_set_scene_state(
+                    infrared->scene_manager, InfraredSceneRpc, InfraredRpcStateLoaded);
+            }
+            rpc_system_app_confirm(infrared->rpc_ctx, result);
        } else if(
            event.event == InfraredCustomEventTypeRpcExit ||
            event.event == InfraredCustomEventTypeRpcSessionClose ||
--- a/applications/main/infrared/scenes/infrared_scene_universal_ac.c
+++ b/applications/main/infrared/scenes/infrared_scene_universal_ac.c
@@ -118,7 +118,7 @@ void infrared_scene_universal_ac_on_enter(void* context) {
    button_panel_add_icon(button_panel, 0, 60, &I_cool_30x51);
    button_panel_add_icon(button_panel, 34, 60, &I_heat_30x51);

-    button_panel_add_label(button_panel, 4, 10, FontPrimary, "AC remote");
+    button_panel_add_label(button_panel, 24, 10, FontPrimary, "AC");

    infrared_scene_universal_common_on_enter(context);
 }
--- a/applications/main/infrared/scenes/infrared_scene_universal_audio.c
+++ b/applications/main/infrared/scenes/infrared_scene_universal_audio.c
@@ -114,7 +114,7 @@ void infrared_scene_universal_audio_on_enter(void* context) {
        context);
    infrared_brute_force_add_record(brute_force, i++, "Vol_up");

-    button_panel_add_label(button_panel, 1, 10, FontPrimary, "Mus. remote");
+    button_panel_add_label(button_panel, 1, 10, FontPrimary, "Audio player");
    button_panel_add_icon(button_panel, 34, 56, &I_vol_ac_text_30x30);

    infrared_scene_universal_common_on_enter(context);
--- a/applications/main/infrared/scenes/infrared_scene_universal_projector.c
+++ b/applications/main/infrared/scenes/infrared_scene_universal_projector.c
@@ -63,7 +63,7 @@ void infrared_scene_universal_projector_on_enter(void* context) {
        context);
    infrared_brute_force_add_record(brute_force, i++, "Vol_dn");

-    button_panel_add_label(button_panel, 3, 11, FontPrimary, "Proj. remote");
+    button_panel_add_label(button_panel, 10, 11, FontPrimary, "Projector");
    button_panel_add_icon(button_panel, 17, 72, &I_vol_ac_text_30x30);

    infrared_scene_universal_common_on_enter(context);
--- a/applications/main/infrared/scenes/infrared_scene_universal_tv.c
+++ b/applications/main/infrared/scenes/infrared_scene_universal_tv.c
@@ -91,7 +91,7 @@ void infrared_scene_universal_tv_on_enter(void* context) {
        context);
    infrared_brute_force_add_record(brute_force, i++, "Ch_prev");

-    button_panel_add_label(button_panel, 5, 10, FontPrimary, "TV remote");
+    button_panel_add_label(button_panel, 25, 10, FontPrimary, "TV");

    infrared_scene_universal_common_on_enter(context);
 }
--- a/applications/main/infrared/views/infrared_progress_view.c
+++ b/applications/main/infrared/views/infrared_progress_view.c
@@ -14,54 +14,80 @@

 struct InfraredProgressView {
    View* view;
-    InfraredProgressViewBackCallback back_callback;
+    InfraredProgressViewInputCallback input_callback;
    void* context;
 };

 typedef struct {
    size_t progress;
    size_t progress_total;
+    bool is_paused;
 } InfraredProgressViewModel;

-bool infrared_progress_view_increase_progress(InfraredProgressView* progress) {
-    furi_assert(progress);
-    bool result = false;
-
-    InfraredProgressViewModel* model = view_get_model(progress->view);
-    if(model->progress < model->progress_total) {
-        ++model->progress;
-        result = model->progress < model->progress_total;
-    }
-    view_commit_model(progress->view, true);
-
-    return result;
-}
-
 static void infrared_progress_view_draw_callback(Canvas* canvas, void* _model) {
    InfraredProgressViewModel* model = (InfraredProgressViewModel*)_model;

    uint8_t x = 0;
-    uint8_t y = 36;
+    uint8_t y = 25;
    uint8_t width = 63;
-    uint8_t height = 59;
+    uint8_t height = 81;

    elements_bold_rounded_frame(canvas, x, y, width, height);

    canvas_set_font(canvas, FontSecondary);
    elements_multiline_text_aligned(
-        canvas, x + 34, y + 9, AlignCenter, AlignCenter, "Sending ...");
+        canvas,
+        x + 32,
+        y + 9,
+        AlignCenter,
+        AlignCenter,
+        model->is_paused ? "Paused" : "Sending...");

    float progress_value = (float)model->progress / model->progress_total;
    elements_progress_bar(canvas, x + 4, y + 19, width - 7, progress_value);

-    uint8_t percent_value = 100 * model->progress / model->progress_total;
-    char percents_string[10] = {0};
-    snprintf(percents_string, sizeof(percents_string), "%d%%", percent_value);
+    char progress_string[16] = {0};
+    if(model->is_paused) {
+        snprintf(
+            progress_string,
+            sizeof(progress_string),
+            "%zu/%zu",
+            model->progress,
+            model->progress_total);
+    } else {
+        uint8_t percent_value = 100 * model->progress / model->progress_total;
+        snprintf(progress_string, sizeof(progress_string), "%d%%", percent_value);
+    }
    elements_multiline_text_aligned(
-        canvas, x + 33, y + 37, AlignCenter, AlignCenter, percents_string);
+        canvas, x + 33, y + 37, AlignCenter, AlignCenter, progress_string);

-    canvas_draw_icon(canvas, x + 14, y + height - 14, &I_Pin_back_arrow_10x8);
-    canvas_draw_str(canvas, x + 30, y + height - 6, "= stop");
+    uint8_t buttons_x = x + (model->is_paused ? 10 : 14);
+    uint8_t buttons_y = y + (model->is_paused ? 46 : 50);
+
+    canvas_draw_icon(canvas, buttons_x + 0, buttons_y + 0, &I_Pin_back_arrow_10x8);
+    canvas_draw_str(canvas, buttons_x + 14, buttons_y + 8, model->is_paused ? "resume" : "stop");
+
+    canvas_draw_icon(canvas, buttons_x + 1, buttons_y + 10, &I_Ok_btn_9x9);
+    canvas_draw_str(canvas, buttons_x + 14, buttons_y + 17, model->is_paused ? "send 1" : "pause");
+
+    if(model->is_paused) {
+        canvas_draw_icon(canvas, buttons_x + 2, buttons_y + 21, &I_ButtonLeftSmall_3x5);
+        canvas_draw_icon(canvas, buttons_x + 7, buttons_y + 21, &I_ButtonRightSmall_3x5);
+        canvas_draw_str(canvas, buttons_x + 14, buttons_y + 26, "select");
+    }
+}
+
+bool infrared_progress_view_set_progress(InfraredProgressView* instance, uint16_t progress) {
+    bool result;
+    with_view_model(
+        instance->view,
+        InfraredProgressViewModel * model,
+        {
+            result = progress <= model->progress_total;
+            if(result) model->progress = progress;
+        },
+        true);
+    return result;
 }

 void infrared_progress_view_set_progress_total(
@@ -74,15 +100,45 @@ void infrared_progress_view_set_progress_total(
    view_commit_model(progress->view, false);
 }

+void infrared_progress_view_set_paused(InfraredProgressView* instance, bool is_paused) {
+    with_view_model(
+        instance->view, InfraredProgressViewModel * model, { model->is_paused = is_paused; }, true);
+}
+
 bool infrared_progress_view_input_callback(InputEvent* event, void* context) {
    InfraredProgressView* instance = context;

-    if((event->type == InputTypeShort) && (event->key == InputKeyBack)) {
-        if(instance->back_callback) {
-            instance->back_callback(instance->context);
-        }
+    if(event->type == InputTypePress || event->type == InputTypeRelease) {
+        return false;
    }

+    if(!instance->input_callback) return false;
+
+    with_view_model(
+        instance->view,
+        InfraredProgressViewModel * model,
+        {
+            if(model->is_paused) {
+                if(event->key == InputKeyLeft)
+                    instance->input_callback(
+                        instance->context, InfraredProgressViewInputPreviousSignal);
+                else if(event->key == InputKeyRight)
+                    instance->input_callback(
+                        instance->context, InfraredProgressViewInputNextSignal);
+                else if(event->key == InputKeyOk)
+                    instance->input_callback(
+                        instance->context, InfraredProgressViewInputSendSingle);
+                else if(event->key == InputKeyBack)
+                    instance->input_callback(instance->context, InfraredProgressViewInputResume);
+            } else {
+                if(event->key == InputKeyOk)
+                    instance->input_callback(instance->context, InfraredProgressViewInputPause);
+                else if(event->key == InputKeyBack)
+                    instance->input_callback(instance->context, InfraredProgressViewInputStop);
+            }
+        },
+        false);
+
    return true;
 }

@@ -106,12 +162,12 @@ void infrared_progress_view_free(InfraredProgressView* progress) {
    free(progress);
 }

-void infrared_progress_view_set_back_callback(
+void infrared_progress_view_set_input_callback(
    InfraredProgressView* instance,
-    InfraredProgressViewBackCallback callback,
+    InfraredProgressViewInputCallback callback,
    void* context) {
    furi_assert(instance);
-    instance->back_callback = callback;
+    instance->input_callback = callback;
    instance->context = context;
 }

--- a/applications/main/infrared/views/infrared_progress_view.h
+++ b/applications/main/infrared/views/infrared_progress_view.h
@@ -10,11 +10,20 @@
 extern "C" {
 #endif

-/** Anonumous instance */
+/** Anonymous instance */
 typedef struct InfraredProgressView InfraredProgressView;

-/** Callback for back button handling */
-typedef void (*InfraredProgressViewBackCallback)(void*);
+typedef enum {
+    InfraredProgressViewInputStop,
+    InfraredProgressViewInputPause,
+    InfraredProgressViewInputResume,
+    InfraredProgressViewInputPreviousSignal,
+    InfraredProgressViewInputNextSignal,
+    InfraredProgressViewInputSendSingle,
+} InfraredProgressViewInput;
+
+/** Callback for input handling */
+typedef void (*InfraredProgressViewInputCallback)(void* context, InfraredProgressViewInput event);

 /** Allocate and initialize Infrared view
 *
@@ -35,13 +44,12 @@ void infrared_progress_view_free(InfraredProgressView* instance);
 */
 View* infrared_progress_view_get_view(InfraredProgressView* instance);

-/** Increase progress on progress view module
+/** Set progress of progress view module
 *
 * @param instance view module
- * @retval true - value is incremented and maximum is reached,
- *      false - value is incremented and maximum is not reached
+ * @param progress progress value
 */
-bool infrared_progress_view_increase_progress(InfraredProgressView* instance);
+bool infrared_progress_view_set_progress(InfraredProgressView* instance, uint16_t progress);

 /** Set maximum progress value
 *
@@ -52,15 +60,22 @@ void infrared_progress_view_set_progress_total(
    InfraredProgressView* instance,
    uint16_t progress_max);

-/** Set back button callback
+/** Selects the variant of the View
+ * 
+ * @param instance view instance
+ * @param is_paused the "paused" variant is displayed if true; the "sending" one if false
+ */
+void infrared_progress_view_set_paused(InfraredProgressView* instance, bool is_paused);
+
+/** Set input callback
 *
 * @param instance - view module
- * @param callback - callback to call for back button
+ * @param callback - callback to call for input
 * @param context - context to pass to callback
 */
-void infrared_progress_view_set_back_callback(
+void infrared_progress_view_set_input_callback(
    InfraredProgressView* instance,
-    InfraredProgressViewBackCallback callback,
+    InfraredProgressViewInputCallback callback,
    void* context);

 #ifdef __cplusplus
--- a/applications/main/lfrfid/application.fam
+++ b/applications/main/lfrfid/application.fam
@@ -13,10 +13,10 @@ App(
 )

 App(
-    appid="lfrfid_start",
+    appid="cli_rfid",
    targets=["f7"],
-    apptype=FlipperAppType.STARTUP,
-    entry_point="lfrfid_on_system_start",
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="cli_rfid_ep",
+    requires=["cli"],
    sources=["lfrfid_cli.c"],
-    order=50,
 )
--- a/applications/main/lfrfid/lfrfid_cli.c
+++ b/applications/main/lfrfid/lfrfid_cli.c
@@ -1,11 +1,12 @@
 #include <furi.h>
 #include <furi_hal.h>
 #include <stdarg.h>
-#include <cli/cli.h>
+#include <cli/cli_main_commands.h>
 #include <lib/toolbox/args.h>
 #include <lib/lfrfid/lfrfid_worker.h>
 #include <storage/storage.h>
 #include <toolbox/stream/file_stream.h>
+#include <toolbox/pipe.h>

 #include <toolbox/varint.h>

@@ -14,15 +15,6 @@
 #include <lfrfid/lfrfid_raw_file.h>
 #include <toolbox/pulse_protocols/pulse_glue.h>

-static void lfrfid_cli(Cli* cli, FuriString* args, void* context);
-
-// app cli function
-void lfrfid_on_system_start(void) {
-    Cli* cli = furi_record_open(RECORD_CLI);
-    cli_add_command(cli, "rfid", CliCommandFlagDefault, lfrfid_cli, NULL);
-    furi_record_close(RECORD_CLI);
-}
-
 static void lfrfid_cli_print_usage(void) {
    printf("Usage:\r\n");
    printf("rfid read <optional: normal | indala>         - read in ASK/PSK mode\r\n");
@@ -49,7 +41,7 @@ static void lfrfid_cli_read_callback(LFRFIDWorkerReadResult result, ProtocolId p
    furi_event_flag_set(context->event, 1 << result);
 }

-static void lfrfid_cli_read(Cli* cli, FuriString* args) {
+static void lfrfid_cli_read(PipeSide* pipe, FuriString* args) {
    FuriString* type_string;
    type_string = furi_string_alloc();
    LFRFIDWorkerReadType type = LFRFIDWorkerReadTypeAuto;
@@ -96,7 +88,7 @@ static void lfrfid_cli_read(Cli* cli, FuriString* args) {
            }
        }

-        if(cli_cmd_interrupt_received(cli)) break;
+        if(cli_is_pipe_broken_or_is_etx_next_char(pipe)) break;
    }

    lfrfid_worker_stop(worker);
@@ -192,7 +184,7 @@ static void lfrfid_cli_write_callback(LFRFIDWorkerWriteResult result, void* ctx)
    furi_event_flag_set(events, 1 << result);
 }

-static void lfrfid_cli_write(Cli* cli, FuriString* args) {
+static void lfrfid_cli_write(PipeSide* pipe, FuriString* args) {
    ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
    ProtocolId protocol;

@@ -212,7 +204,7 @@ static void lfrfid_cli_write(Cli* cli, FuriString* args) {
                                     (1 << LFRFIDWorkerWriteProtocolCannotBeWritten) |
                                     (1 << LFRFIDWorkerWriteFobCannotBeWritten);

-    while(!cli_cmd_interrupt_received(cli)) {
+    while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
        uint32_t flags = furi_event_flag_wait(event, available_flags, FuriFlagWaitAny, 100);
        if(flags != (unsigned)FuriFlagErrorTimeout) {
            if(FURI_BIT(flags, LFRFIDWorkerWriteOK)) {
@@ -239,7 +231,7 @@ static void lfrfid_cli_write(Cli* cli, FuriString* args) {
    furi_event_flag_free(event);
 }

-static void lfrfid_cli_emulate(Cli* cli, FuriString* args) {
+static void lfrfid_cli_emulate(PipeSide* pipe, FuriString* args) {
    ProtocolDict* dict = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
    ProtocolId protocol;

@@ -254,7 +246,7 @@ static void lfrfid_cli_emulate(Cli* cli, FuriString* args) {
    lfrfid_worker_emulate_start(worker, protocol);

    printf("Emulating RFID...\r\nPress Ctrl+C to abort\r\n");
-    while(!cli_cmd_interrupt_received(cli)) {
+    while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
        furi_delay_ms(100);
    }
    printf("Emulation stopped\r\n");
@@ -265,8 +257,8 @@ static void lfrfid_cli_emulate(Cli* cli, FuriString* args) {
    protocol_dict_free(dict);
 }

-static void lfrfid_cli_raw_analyze(Cli* cli, FuriString* args) {
-    UNUSED(cli);
+static void lfrfid_cli_raw_analyze(PipeSide* pipe, FuriString* args) {
+    UNUSED(pipe);
    FuriString *filepath, *info_string;
    filepath = furi_string_alloc();
    info_string = furi_string_alloc();
@@ -392,9 +384,7 @@ static void lfrfid_cli_raw_read_callback(LFRFIDWorkerReadRawResult result, void*
    furi_event_flag_set(event, 1 << result);
 }

-static void lfrfid_cli_raw_read(Cli* cli, FuriString* args) {
-    UNUSED(cli);
-
+static void lfrfid_cli_raw_read(PipeSide* pipe, FuriString* args) {
    FuriString *filepath, *type_string;
    filepath = furi_string_alloc();
    type_string = furi_string_alloc();
@@ -452,7 +442,7 @@ static void lfrfid_cli_raw_read(Cli* cli, FuriString* args) {
                }
            }

-            if(cli_cmd_interrupt_received(cli)) break;
+            if(cli_is_pipe_broken_or_is_etx_next_char(pipe)) break;
        }

        if(overrun) {
@@ -479,9 +469,7 @@ static void lfrfid_cli_raw_emulate_callback(LFRFIDWorkerEmulateRawResult result,
    furi_event_flag_set(event, 1 << result);
 }

-static void lfrfid_cli_raw_emulate(Cli* cli, FuriString* args) {
-    UNUSED(cli);
-
+static void lfrfid_cli_raw_emulate(PipeSide* pipe, FuriString* args) {
    FuriString* filepath;
    filepath = furi_string_alloc();
    Storage* storage = furi_record_open(RECORD_STORAGE);
@@ -527,7 +515,7 @@ static void lfrfid_cli_raw_emulate(Cli* cli, FuriString* args) {
                }
            }

-            if(cli_cmd_interrupt_received(cli)) break;
+            if(cli_is_pipe_broken_or_is_etx_next_char(pipe)) break;
        }

        if(overrun) {
@@ -548,7 +536,7 @@ static void lfrfid_cli_raw_emulate(Cli* cli, FuriString* args) {
    furi_string_free(filepath);
 }

-static void lfrfid_cli(Cli* cli, FuriString* args, void* context) {
+static void execute(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    FuriString* cmd;
    cmd = furi_string_alloc();
@@ -560,20 +548,22 @@ static void lfrfid_cli(Cli* cli, FuriString* args, void* context) {
    }

    if(furi_string_cmp_str(cmd, "read") == 0) {
-        lfrfid_cli_read(cli, args);
+        lfrfid_cli_read(pipe, args);
    } else if(furi_string_cmp_str(cmd, "write") == 0) {
-        lfrfid_cli_write(cli, args);
+        lfrfid_cli_write(pipe, args);
    } else if(furi_string_cmp_str(cmd, "emulate") == 0) {
-        lfrfid_cli_emulate(cli, args);
+        lfrfid_cli_emulate(pipe, args);
    } else if(furi_string_cmp_str(cmd, "raw_read") == 0) {
-        lfrfid_cli_raw_read(cli, args);
+        lfrfid_cli_raw_read(pipe, args);
    } else if(furi_string_cmp_str(cmd, "raw_emulate") == 0) {
-        lfrfid_cli_raw_emulate(cli, args);
+        lfrfid_cli_raw_emulate(pipe, args);
    } else if(furi_string_cmp_str(cmd, "raw_analyze") == 0) {
-        lfrfid_cli_raw_analyze(cli, args);
+        lfrfid_cli_raw_analyze(pipe, args);
    } else {
        lfrfid_cli_print_usage();
    }

    furi_string_free(cmd);
 }
+
+CLI_COMMAND_INTERFACE(rfid, execute, CliCommandFlagDefault, 2048, CLI_APPID);
--- a/applications/main/lfrfid/lfrfid_i.h
+++ b/applications/main/lfrfid/lfrfid_i.h
@@ -8,7 +8,6 @@
 #include <assets_icons.h>
 #include <gui/view_dispatcher.h>
 #include <gui/scene_manager.h>
-#include <cli/cli.h>
 #include <notification/notification_messages.h>

 #include <gui/modules/submenu.h>
--- a/applications/main/nfc/application.fam
+++ b/applications/main/nfc/application.fam
@@ -248,10 +248,20 @@ App(
 )

 App(
-    appid="nfc_start",
+    appid="disney_infinity_parser",
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="disney_infinity_plugin_ep",
    targets=["f7"],
-    apptype=FlipperAppType.STARTUP,
-    entry_point="nfc_on_system_start",
-    sources=["nfc_cli.c"],
-    order=30,
+    requires=["nfc"],
+    fap_libs=["mbedtls"],
+    sources=["plugins/supported_cards/disney_infinity.c"],
+)
+
+App(
+    appid="cli_nfc",
+    targets=["f7"],
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="cli_nfc_ep",
+    requires=["cli"],
+    sources=["nfc_cli.c"],
 )
--- a/applications/main/nfc/helpers/mf_classic_key_cache.c
+++ b/applications/main/nfc/helpers/mf_classic_key_cache.c
@@ -166,7 +166,7 @@ void mf_classic_key_cache_load_from_data(MfClassicKeyCache* instance, const MfCl
    }
 }

-bool mf_classic_key_cahce_get_next_key(
+bool mf_classic_key_cache_get_next_key(
    MfClassicKeyCache* instance,
    uint8_t* sector_num,
    MfClassicKey* key,
--- a/applications/main/nfc/helpers/mf_classic_key_cache.h
+++ b/applications/main/nfc/helpers/mf_classic_key_cache.h
@@ -16,7 +16,7 @@ bool mf_classic_key_cache_load(MfClassicKeyCache* instance, const uint8_t* uid,

 void mf_classic_key_cache_load_from_data(MfClassicKeyCache* instance, const MfClassicData* data);

-bool mf_classic_key_cahce_get_next_key(
+bool mf_classic_key_cache_get_next_key(
    MfClassicKeyCache* instance,
    uint8_t* sector_num,
    MfClassicKey* key,
--- a/applications/main/nfc/helpers/protocol_support/iso15693_3/iso15693_3_render.c
+++ b/applications/main/nfc/helpers/protocol_support/iso15693_3/iso15693_3_render.c
@@ -37,11 +37,13 @@ void nfc_render_iso15693_3_brief(const Iso15693_3Data* data, FuriString* str) {
 }

 void nfc_render_iso15693_3_system_info(const Iso15693_3Data* data, FuriString* str) {
-    if(data->system_info.flags & ISO15693_3_SYSINFO_FLAG_MEMORY) {
+    const uint16_t block_count = iso15693_3_get_block_count(data);
+    const uint8_t block_size = iso15693_3_get_block_size(data);
+
+    if((data->system_info.flags & ISO15693_3_SYSINFO_FLAG_MEMORY) &&
+       (block_count > 0 && block_size > 0)) {
        furi_string_cat(str, "\e#Memory data\n\e*--------------------\n");

-        const uint16_t block_count = iso15693_3_get_block_count(data);
-        const uint8_t block_size = iso15693_3_get_block_size(data);
        const uint16_t display_block_count =
            MIN(NFC_RENDER_ISO15693_3_MAX_BYTES / block_size, block_count);

--- a/applications/main/nfc/helpers/protocol_support/mf_classic/mf_classic.c
+++ b/applications/main/nfc/helpers/protocol_support/mf_classic/mf_classic.c
@@ -14,7 +14,8 @@ enum {
    SubmenuIndexDetectReader = SubmenuIndexCommonMax,
    SubmenuIndexWrite,
    SubmenuIndexUpdate,
-    SubmenuIndexDictAttack
+    SubmenuIndexDictAttack,
+    SubmenuIndexCrackNonces,
 };

 static void nfc_scene_info_on_enter_mf_classic(NfcApp* instance) {
@@ -72,7 +73,7 @@ static NfcCommand nfc_scene_read_poller_callback_mf_classic(NfcGenericEvent even
        uint8_t sector_num = 0;
        MfClassicKey key = {};
        MfClassicKeyType key_type = MfClassicKeyTypeA;
-        if(mf_classic_key_cahce_get_next_key(
+        if(mf_classic_key_cache_get_next_key(
               instance->mfc_key_cache, &sector_num, &key, &key_type)) {
            mfc_event->data->read_sector_request_data.sector_num = sector_num;
            mfc_event->data->read_sector_request_data.key = key;
@@ -128,6 +129,13 @@ static void nfc_scene_read_menu_on_enter_mf_classic(NfcApp* instance) {
            SubmenuIndexDictAttack,
            nfc_protocol_support_common_submenu_callback,
            instance);
+
+        submenu_add_item(
+            submenu,
+            "Crack nonces in MFKey32",
+            SubmenuIndexCrackNonces,
+            nfc_protocol_support_common_submenu_callback,
+            instance);
    }
 }

@@ -193,6 +201,11 @@ static bool nfc_scene_read_menu_on_event_mf_classic(NfcApp* instance, SceneManag

    if(event.type == SceneManagerEventTypeCustom) {
        if(event.event == SubmenuIndexDetectReader) {
+            scene_manager_set_scene_state(
+                instance->scene_manager,
+                NfcSceneSaveConfirm,
+                NfcSceneSaveConfirmStateDetectReader);
+
            scene_manager_next_scene(instance->scene_manager, NfcSceneSaveConfirm);
            dolphin_deed(DolphinDeedNfcDetectReader);
            consumed = true;
@@ -205,6 +218,11 @@ static bool nfc_scene_read_menu_on_event_mf_classic(NfcApp* instance, SceneManag
        } else if(event.event == SubmenuIndexCommonEdit) {
            scene_manager_next_scene(instance->scene_manager, NfcSceneSetUid);
            consumed = true;
+        } else if(event.event == SubmenuIndexCrackNonces) {
+            scene_manager_set_scene_state(
+                instance->scene_manager, NfcSceneSaveConfirm, NfcSceneSaveConfirmStateCrackNonces);
+            scene_manager_next_scene(instance->scene_manager, NfcSceneSaveConfirm);
+            consumed = true;
        }
    }

--- a/applications/main/nfc/helpers/protocol_support/mf_desfire/mf_desfire_render.c
+++ b/applications/main/nfc/helpers/protocol_support/mf_desfire/mf_desfire_render.c
@@ -180,6 +180,9 @@ void nfc_render_mf_desfire_file_settings_data(
    case MfDesfireFileTypeCyclicRecord:
        type = "cyclic";
        break;
+    case MfDesfireFileTypeTransactionMac:
+        type = "txn-mac";
+        break;
    default:
        type = "unknown";
    }
@@ -237,6 +240,15 @@ void nfc_render_mf_desfire_file_settings_data(
        furi_string_cat_printf(str, "size %lu\n", record_size);
        furi_string_cat_printf(str, "num %lu max %lu\n", record_count, settings->record.max);
        break;
+    case MfDesfireFileTypeTransactionMac:
+        record_count = 0;
+        furi_string_cat_printf(
+            str,
+            "key opt %02X ver %02X\n",
+            settings->transaction_mac.key_option,
+            settings->transaction_mac.key_version);
+        furi_string_cat_printf(str, "cnt limit %lu\n", settings->transaction_mac.counter_limit);
+        break;
    }

    bool is_auth_required = true;
--- a/applications/main/nfc/nfc_app.c
+++ b/applications/main/nfc/nfc_app.c
@@ -470,6 +470,26 @@ static void nfc_show_initial_scene_for_device(NfcApp* nfc) {
    scene_manager_next_scene(nfc->scene_manager, scene);
 }

+void nfc_app_run_external(NfcApp* nfc, const char* app_path) {
+    furi_assert(nfc);
+    furi_assert(app_path);
+
+    Loader* loader = furi_record_open(RECORD_LOADER);
+
+    loader_enqueue_launch(loader, app_path, NULL, LoaderDeferredLaunchFlagGui);
+
+    FuriString* self_path = furi_string_alloc();
+    furi_check(loader_get_application_launch_path(loader, self_path));
+
+    loader_enqueue_launch(
+        loader, furi_string_get_cstr(self_path), NULL, LoaderDeferredLaunchFlagGui);
+    furi_string_free(self_path);
+
+    furi_record_close(RECORD_LOADER);
+
+    view_dispatcher_stop(nfc->view_dispatcher);
+}
+
 int32_t nfc_app(void* p) {
    if(!nfc_is_hal_ready()) return 0;

--- a/applications/main/nfc/nfc_app_i.h
+++ b/applications/main/nfc/nfc_app_i.h
@@ -10,7 +10,6 @@
 #include <assets_icons.h>
 #include <gui/view_dispatcher.h>
 #include <gui/scene_manager.h>
-#include <cli/cli.h>
 #include <notification/notification_messages.h>

 #include <gui/modules/submenu.h>
@@ -36,6 +35,7 @@
 #include "helpers/felica_auth.h"
 #include "helpers/slix_unlock.h"

+#include <loader/loader.h>
 #include <dialogs/dialogs.h>
 #include <storage/storage.h>
 #include <toolbox/path.h>
@@ -86,6 +86,8 @@
 #define NFC_APP_MF_ULTRALIGHT_C_DICT_SYSTEM_PATH \
    (NFC_APP_FOLDER "/assets/mf_ultralight_c_dict.nfc")

+#define NFC_MFKEY32_APP_PATH (EXT_PATH("apps/NFC/mfkey.fap"))
+
 typedef enum {
    NfcRpcStateIdle,
    NfcRpcStateEmulating,
@@ -182,6 +184,11 @@ typedef enum {
    NfcViewDetectReader,
 } NfcView;

+typedef enum {
+    NfcSceneSaveConfirmStateDetectReader,
+    NfcSceneSaveConfirmStateCrackNonces,
+} NfcSceneSaveConfirmState;
+
 int32_t nfc_task(void* p);

 void nfc_text_store_set(NfcApp* nfc, const char* text, ...);
@@ -217,3 +224,5 @@ bool nfc_save_file(NfcApp* instance, FuriString* path);
 void nfc_make_app_folder(NfcApp* instance);

 void nfc_append_filename_string_when_present(NfcApp* instance, FuriString* string);
+
+void nfc_app_run_external(NfcApp* nfc, const char* app_path);
--- a/applications/main/nfc/nfc_cli.c
+++ b/applications/main/nfc/nfc_cli.c
@@ -1,8 +1,9 @@
 #include <furi.h>
 #include <furi_hal.h>
-#include <cli/cli.h>
+#include <cli/cli_main_commands.h>
 #include <lib/toolbox/args.h>
 #include <lib/toolbox/hex.h>
+#include <toolbox/pipe.h>

 #include <furi_hal_nfc.h>

@@ -17,7 +18,7 @@ static void nfc_cli_print_usage(void) {
    }
 }

-static void nfc_cli_field(Cli* cli, FuriString* args) {
+static void nfc_cli_field(PipeSide* pipe, FuriString* args) {
    UNUSED(args);
    // Check if nfc worker is not busy
    if(furi_hal_nfc_is_hal_ready() != FuriHalNfcErrorNone) {
@@ -32,7 +33,7 @@ static void nfc_cli_field(Cli* cli, FuriString* args) {
    printf("Field is on. Don't leave device in this mode for too long.\r\n");
    printf("Press Ctrl+C to abort\r\n");

-    while(!cli_cmd_interrupt_received(cli)) {
+    while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
        furi_delay_ms(50);
    }

@@ -40,7 +41,7 @@ static void nfc_cli_field(Cli* cli, FuriString* args) {
    furi_hal_nfc_release();
 }

-static void nfc_cli(Cli* cli, FuriString* args, void* context) {
+static void execute(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    FuriString* cmd;
    cmd = furi_string_alloc();
@@ -52,7 +53,7 @@ static void nfc_cli(Cli* cli, FuriString* args, void* context) {
        }
        if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
            if(furi_string_cmp_str(cmd, "field") == 0) {
-                nfc_cli_field(cli, args);
+                nfc_cli_field(pipe, args);
                break;
            }
        }
@@ -63,12 +64,4 @@ static void nfc_cli(Cli* cli, FuriString* args, void* context) {
    furi_string_free(cmd);
 }

-void nfc_on_system_start(void) {
-#ifdef SRV_CLI
-    Cli* cli = furi_record_open(RECORD_CLI);
-    cli_add_command(cli, "nfc", CliCommandFlagDefault, nfc_cli, NULL);
-    furi_record_close(RECORD_CLI);
-#else
-    UNUSED(nfc_cli);
-#endif
-}
+CLI_COMMAND_INTERFACE(nfc, execute, CliCommandFlagDefault, 1024, CLI_APPID);
--- a/applications/main/nfc/plugins/supported_cards/clipper.c
+++ b/applications/main/nfc/plugins/supported_cards/clipper.c
@@ -101,7 +101,8 @@ static const IdMapping bart_zones[] = {
    {.id = 0x001d, .name = "Lake Merrit"},
    {.id = 0x001e, .name = "Fruitvale"},
    {.id = 0x001f, .name = "Coliseum"},
-    {.id = 0x0021, .name = "San Leandro"},
+    {.id = 0x0020, .name = "San Leandro"},
+    {.id = 0x0021, .name = "Bay Fair"},
    {.id = 0x0022, .name = "Hayward"},
    {.id = 0x0023, .name = "South Hayward"},
    {.id = 0x0024, .name = "Union City"},
@@ -131,6 +132,9 @@ static const IdMapping muni_zones[] = {
    {.id = 0x000b, .name = "Castro"},
    {.id = 0x000c, .name = "Forest Hill"}, // Guessed
    {.id = 0x000d, .name = "West Portal"},
+    {.id = 0x0019, .name = "Union Square/Market Street"},
+    {.id = 0x001a, .name = "Chinatown - Rose Pak"},
+    {.id = 0x001b, .name = "Yerba Buena/Moscone"},
 };
 static const size_t kNumMUNIZones = COUNT(muni_zones);

--- a/applications/main/nfc/plugins/supported_cards/disney_infinity.c
+++ b/applications/main/nfc/plugins/supported_cards/disney_infinity.c
@@ -0,0 +1,121 @@
+#include <mbedtls/sha1.h>
+#include "nfc_supported_card_plugin.h"
+
+#include <flipper_application/flipper_application.h>
+
+#include <nfc/nfc_device.h>
+#include <bit_lib/bit_lib.h>
+#include <nfc/protocols/mf_classic/mf_classic_poller_sync.h>
+#include <flipper_format/flipper_format.h>
+
+#define TAG     "DisneyInfinity"
+#define UID_LEN 7
+
+// Derived from https://nfc.toys/#new-interoperability-for-infinity
+static uint8_t seed[38] = {0x0A, 0x14, 0xFD, 0x05, 0x07, 0xFF, 0x4B, 0xCD, 0x02, 0x6B,
+                           0xA8, 0x3F, 0x0A, 0x3B, 0x89, 0xA9, 0x00, 0x00, 0x00, 0x00,
+                           0x00, 0x00, 0x00, 0x28, 0x63, 0x29, 0x20, 0x44, 0x69, 0x73,
+                           0x6E, 0x65, 0x79, 0x20, 0x32, 0x30, 0x31, 0x33};
+
+void di_key(const uint8_t* uid, MfClassicKey* key) {
+    uint8_t hash[20];
+    memcpy(seed + 16, uid, UID_LEN);
+    mbedtls_sha1(seed, sizeof(seed), hash);
+    key->data[0] = hash[3];
+    key->data[1] = hash[2];
+    key->data[2] = hash[1];
+    key->data[3] = hash[0];
+    key->data[4] = hash[7];
+    key->data[5] = hash[6];
+}
+
+static bool disney_infinity_read(Nfc* nfc, NfcDevice* device) {
+    furi_assert(nfc);
+    furi_assert(device);
+    size_t* uid_len = 0;
+    bool is_read = false;
+    MfClassicData* data = mf_classic_alloc();
+
+    nfc_device_copy_data(device, NfcProtocolMfClassic, data);
+    const uint8_t* uid_bytes = mf_classic_get_uid(data, uid_len);
+    MfClassicDeviceKeys keys = {};
+
+    do {
+        MfClassicType type = MfClassicTypeMini;
+        MfClassicError error = mf_classic_poller_sync_detect_type(nfc, &type);
+        if(error != MfClassicErrorNone) break;
+
+        data->type = type;
+        for(size_t i = 0; i < mf_classic_get_total_sectors_num(data->type); i++) {
+            di_key(uid_bytes, &keys.key_a[i]);
+            di_key(uid_bytes, &keys.key_b[i]);
+            FURI_BIT_SET(keys.key_a_mask, i);
+            FURI_BIT_SET(keys.key_b_mask, i);
+        }
+
+        error = mf_classic_poller_sync_read(nfc, &keys, data);
+        if(error != MfClassicErrorNone) {
+            FURI_LOG_W(TAG, "Failed to read data: %d", error);
+            break;
+        }
+
+        nfc_device_set_data(device, NfcProtocolMfClassic, data);
+
+        is_read = mf_classic_is_card_read(data);
+    } while(false);
+
+    mf_classic_free(data);
+
+    return is_read;
+}
+
+static bool disney_infinity_parse(const NfcDevice* device, FuriString* parsed_data) {
+    furi_assert(device);
+    size_t* uid_len = 0;
+    bool parsed = false;
+    FuriString* name = furi_string_alloc();
+    const uint8_t verify_sector = 0;
+    MfClassicKey key = {};
+
+    const MfClassicData* data = nfc_device_get_data(device, NfcProtocolMfClassic);
+    const uint8_t* uid_bytes = mf_classic_get_uid(data, uid_len);
+
+    do {
+        // verify key
+        MfClassicSectorTrailer* sec_tr =
+            mf_classic_get_sector_trailer_by_sector(data, verify_sector);
+
+        di_key(uid_bytes, &key);
+        if(memcmp(key.data, sec_tr->key_a.data, 6) != 0) break;
+
+        // At some point I'd like to add name lookup like Skylanders
+        furi_string_printf(parsed_data, "\e#Disney Infinity\n");
+
+        parsed = true;
+
+    } while(false);
+
+    furi_string_free(name);
+
+    return parsed;
+}
+
+/* Actual implementation of app<>plugin interface */
+static const NfcSupportedCardsPlugin disney_infinity_plugin = {
+    .protocol = NfcProtocolMfClassic,
+    .verify = NULL, // Need UID to verify key(s)
+    .read = disney_infinity_read,
+    .parse = disney_infinity_parse,
+};
+
+/* Plugin descriptor to comply with basic plugin specification */
+static const FlipperAppPluginDescriptor disney_infinity_plugin_descriptor = {
+    .appid = NFC_SUPPORTED_CARD_PLUGIN_APP_ID,
+    .ep_api_version = NFC_SUPPORTED_CARD_PLUGIN_API_VERSION,
+    .entry_point = &disney_infinity_plugin,
+};
+
+/* Plugin entry point - must return a pointer to const descriptor  */
+const FlipperAppPluginDescriptor* disney_infinity_plugin_ep(void) {
+    return &disney_infinity_plugin_descriptor;
+}
--- a/applications/main/nfc/plugins/supported_cards/ndef.c
+++ b/applications/main/nfc/plugins/supported_cards/ndef.c
@@ -22,6 +22,7 @@
 #include <nfc/protocols/slix/slix.h>

 #include <bit_lib.h>
+#include <toolbox/pretty_format.h>

 #define TAG "NDEF"

@@ -181,30 +182,34 @@ static bool ndef_get(Ndef* ndef, size_t pos, size_t len, void* buf) {
    // So the first 93 (31*3) data blocks correspond to 128 real blocks.
    // Last 128 blocks are 8 sectors: 15 data blocks, 1 sector trailer.
    // So the last 120 (8*15) data blocks correspond to 128 real blocks.
-    div_t small_sector_data_blocks = div(pos, MF_CLASSIC_BLOCK_SIZE);
+    const size_t real_block_data_offset = pos % MF_CLASSIC_BLOCK_SIZE;
+    size_t small_sector_data_blocks = pos / MF_CLASSIC_BLOCK_SIZE;
    size_t large_sector_data_blocks = 0;
-    if(small_sector_data_blocks.quot > 93) {
-        large_sector_data_blocks = small_sector_data_blocks.quot - 93;
-        small_sector_data_blocks.quot = 93;
+    if(small_sector_data_blocks > 93) {
+        large_sector_data_blocks = small_sector_data_blocks - 93;
+        small_sector_data_blocks = 93;
    }

-    div_t small_sectors = div(small_sector_data_blocks.quot, 3);
-    size_t real_block = small_sectors.quot * 4 + small_sectors.rem;
-    if(small_sectors.quot >= 16) {
+    const size_t small_sector_block_offset = small_sector_data_blocks % 3;
+    const size_t small_sectors = small_sector_data_blocks / 3;
+    size_t real_block = small_sectors * 4 + small_sector_block_offset;
+    if(small_sectors >= 16) {
        real_block += 4; // Skip MAD2
    }
    if(large_sector_data_blocks) {
-        div_t large_sectors = div(large_sector_data_blocks, 15);
-        real_block += large_sectors.quot * 16 + large_sectors.rem;
+        const size_t large_sector_block_offset = large_sector_data_blocks % 15;
+        const size_t large_sectors = large_sector_data_blocks / 15;
+        real_block += large_sectors * 16 + large_sector_block_offset;
    }

-    const uint8_t* cur = &ndef->mfc.blocks[real_block].data[small_sector_data_blocks.rem];
+    const uint8_t* cur = &ndef->mfc.blocks[real_block].data[real_block_data_offset];
    while(len) {
        size_t sector_trailer = mf_classic_get_sector_trailer_num_by_block(real_block);
        const uint8_t* end = &ndef->mfc.blocks[sector_trailer].data[0];

-        size_t chunk_len = MIN((size_t)(end - cur), len);
+        const size_t chunk_len = MIN((size_t)(end - cur), len);
        memcpy(buf, cur, chunk_len);
+        buf += chunk_len;
        len -= chunk_len;

        if(len) {
@@ -244,7 +249,9 @@ static inline bool is_printable(char c) {

 static bool is_text(const uint8_t* buf, size_t len) {
    for(size_t i = 0; i < len; i++) {
-        if(!is_printable(buf[i])) return false;
+        if(!is_printable(buf[i]) && !(buf[i] == '\0' && i == len - 1)) {
+            return false;
+        }
    }
    return true;
 }
@@ -260,7 +267,7 @@ static bool ndef_dump(Ndef* ndef, const char* prefix, size_t pos, size_t len, bo
        for(size_t i = 0; i < len; i++) {
            char c;
            if(!ndef_get(ndef, pos + i, 1, &c)) return false;
-            if(!is_printable(c)) {
+            if(!is_printable(c) && !(c == '\0' && i == len - 1)) {
                furi_string_left(ndef->output, string_prev);
                force_hex = true;
                break;
@@ -268,14 +275,18 @@ static bool ndef_dump(Ndef* ndef, const char* prefix, size_t pos, size_t len, bo
            furi_string_push_back(ndef->output, c);
        }
    }
-    if(force_hex) {
-        for(size_t i = 0; i < len; i++) {
-            uint8_t b;
-            if(!ndef_get(ndef, pos + i, 1, &b)) return false;
-            furi_string_cat_printf(ndef->output, "%02X ", b);
+    if(!force_hex) {
+        furi_string_cat(ndef->output, "\n");
+    } else {
+        uint8_t buf[4];
+        for(size_t i = 0; i < len; i += sizeof(buf)) {
+            uint8_t buf_len = MIN(sizeof(buf), len - i);
+            if(!ndef_get(ndef, pos + i, buf_len, &buf)) return false;
+            pretty_format_bytes_hex_canonical(
+                ndef->output, 4, PRETTY_FORMAT_FONT_MONOSPACE, buf, buf_len);
+            furi_string_cat(ndef->output, "\n");
        }
    }
-    furi_string_cat(ndef->output, "\n");
    return true;
 }

@@ -285,9 +296,7 @@ static void
    if(!force_hex && is_text(buf, len)) {
        furi_string_cat_printf(ndef->output, "%.*s", len, (const char*)buf);
    } else {
-        for(size_t i = 0; i < len; i++) {
-            furi_string_cat_printf(ndef->output, "%02X ", ((const uint8_t*)buf)[i]);
-        }
+        pretty_format_bytes_hex_canonical(ndef->output, 4, PRETTY_FORMAT_FONT_MONOSPACE, buf, len);
    }
    furi_string_cat(ndef->output, "\n");
 }
@@ -582,7 +591,7 @@ bool ndef_parse_record(
    NdefTnf tnf,
    const char* type,
    uint8_t type_len) {
-    FURI_LOG_D(TAG, "payload type: %.*s len: %hu", type_len, type, len);
+    FURI_LOG_D(TAG, "payload type: %.*s len: %hu pos: %zu", type_len, type, len, pos);
    if(!len) {
        furi_string_cat(ndef->output, "Empty\n");
        return true;
@@ -887,13 +896,13 @@ static bool ndef_mfc_parse(const NfcDevice* device, FuriString* parsed_data) {
    for(uint8_t mad = 0; mad < COUNT_OF(mads); mad++) {
        const size_t block = mads[mad].block;
        const size_t sector = mf_classic_get_sector_by_block(block);
-        if(sector_count <= sector) break; // Skip this MAD if not present
+        if(sector_count <= sector) continue; // Skip this MAD if not present
        // Check MAD key
        const MfClassicSectorTrailer* sector_trailer =
            mf_classic_get_sector_trailer_by_sector(data, sector);
        const uint64_t sector_key_a = bit_lib_bytes_to_num_be(
            sector_trailer->key_a.data, COUNT_OF(sector_trailer->key_a.data));
-        if(sector_key_a != mad_key) return false;
+        if(sector_key_a != mad_key) continue;
        // Find NDEF AIDs
        for(uint8_t aid_index = 0; aid_index < mads[mad].aid_count; aid_index++) {
            const uint8_t* aid = &data->block[block].data[2 + aid_index * AID_SIZE];
@@ -917,7 +926,7 @@ static bool ndef_mfc_parse(const NfcDevice* device, FuriString* parsed_data) {
        data_size = 93 + (sector_count - 32) * 15;
    } else {
        data_size = sector_count * 3;
-        if(sector_count >= 16) {
+        if(sector_count > 16) {
            data_size -= 3; // Skip MAD2
        }
    }
--- a/applications/main/nfc/plugins/supported_cards/plantain.c
+++ b/applications/main/nfc/plugins/supported_cards/plantain.c
@@ -310,9 +310,11 @@ static bool plantain_parse(const NfcDevice* device, FuriString* parsed_data) {
                last_payment_date.year,
                last_payment_date.hour,
                last_payment_date.minute);
-            //payment amount. This needs to be investigated more, currently it shows incorrect amount on some cards.
-            uint16_t last_payment = (data->block[18].data[9] << 8) | data->block[18].data[8];
-            furi_string_cat_printf(parsed_data, "Amount: %d rub", last_payment / 100);
+            //Last payment amount.
+            uint16_t last_payment = ((data->block[18].data[10] << 16) |
+                                     (data->block[18].data[9] << 8) | (data->block[18].data[8])) /
+                                    100;
+            furi_string_cat_printf(parsed_data, "Amount: %d rub", last_payment);
            furi_string_free(card_number_s);
            furi_string_free(tmp_s);
            //This is for 4K Plantains.
@@ -369,9 +371,11 @@ static bool plantain_parse(const NfcDevice* device, FuriString* parsed_data) {
                last_payment_date.year,
                last_payment_date.hour,
                last_payment_date.minute);
-            //payment amount
-            uint16_t last_payment = (data->block[18].data[9] << 8) | data->block[18].data[8];
-            furi_string_cat_printf(parsed_data, "Amount: %d rub", last_payment / 100);
+            //Last payment amount
+            uint16_t last_payment = ((data->block[18].data[10] << 16) |
+                                     (data->block[18].data[9] << 8) | (data->block[18].data[8])) /
+                                    100;
+            furi_string_cat_printf(parsed_data, "Amount: %d rub", last_payment);
            furi_string_free(card_number_s);
            furi_string_free(tmp_s);
        }
--- a/applications/main/nfc/plugins/supported_cards/skylanders.c
+++ b/applications/main/nfc/plugins/supported_cards/skylanders.c
@@ -7,13 +7,36 @@
 #include <nfc/protocols/mf_classic/mf_classic_poller_sync.h>
 #include <flipper_format/flipper_format.h>

-#define TAG "Skylanders"
+#define TAG      "Skylanders"
+#define POLY     UINT64_C(0x42f0e1eba9ea3693)
+#define TOP      UINT64_C(0x800000000000)
+#define UID_LEN  4
+#define KEY_MASK 0xFFFFFFFFFFFF

 static const uint64_t skylanders_key = 0x4b0b20107ccb;

 static const char* nfc_resources_header = "Flipper NFC resources";
 static const uint32_t nfc_resources_file_version = 1;

+uint64_t crc64_like(uint64_t result, uint8_t sector) {
+    result ^= (uint64_t)sector << 40;
+    for(int i = 0; i < 8; i++) {
+        result = (result & TOP) ? (result << 1) ^ POLY : result << 1;
+    }
+    return result;
+}
+
+uint64_t taghash(uint32_t uid) {
+    uint64_t result = 0x9AE903260CC4;
+    uint8_t uidBytes[UID_LEN] = {0};
+    memcpy(uidBytes, &uid, UID_LEN);
+
+    for(int i = 0; i < UID_LEN; i++) {
+        result = crc64_like(result, uidBytes[i]);
+    }
+    return result;
+}
+
 static bool skylanders_search_data(
    Storage* storage,
    const char* file_name,
@@ -88,6 +111,12 @@ static bool skylanders_read(Nfc* nfc, NfcDevice* device) {
    MfClassicData* data = mf_classic_alloc();
    nfc_device_copy_data(device, NfcProtocolMfClassic, data);

+    size_t* uid_len = 0;
+    const uint8_t* uid_bytes = mf_classic_get_uid(data, uid_len);
+    uint32_t uid = 0;
+    memcpy(&uid, uid_bytes, sizeof(uid));
+    uint64_t hash = taghash(uid);
+
    do {
        MfClassicType type = MfClassicType1k;
        MfClassicError error = mf_classic_poller_sync_detect_type(nfc, &type);
@@ -96,10 +125,18 @@ static bool skylanders_read(Nfc* nfc, NfcDevice* device) {
        data->type = type;
        MfClassicDeviceKeys keys = {};
        for(size_t i = 0; i < mf_classic_get_total_sectors_num(data->type); i++) {
-            bit_lib_num_to_bytes_be(skylanders_key, sizeof(MfClassicKey), keys.key_a[i].data);
-            FURI_BIT_SET(keys.key_a_mask, i);
-            bit_lib_num_to_bytes_be(skylanders_key, sizeof(MfClassicKey), keys.key_b[i].data);
-            FURI_BIT_SET(keys.key_b_mask, i);
+            if(i == 0) {
+                bit_lib_num_to_bytes_be(skylanders_key, sizeof(MfClassicKey), keys.key_a[i].data);
+                FURI_BIT_SET(keys.key_a_mask, i);
+            } else {
+                uint64_t sectorhash = crc64_like(hash, i);
+                uint64_t key = sectorhash & KEY_MASK;
+                uint8_t* keyBytes = (uint8_t*)&key;
+                memcpy(keys.key_a[i].data, keyBytes, sizeof(MfClassicKey));
+                FURI_BIT_SET(keys.key_a_mask, i);
+                memset(keys.key_b[i].data, 0, sizeof(MfClassicKey));
+                FURI_BIT_SET(keys.key_b_mask, i);
+            }
        }

        error = mf_classic_poller_sync_read(nfc, &keys, data);
@@ -134,7 +171,7 @@ static bool skylanders_parse(const NfcDevice* device, FuriString* parsed_data) {
        uint64_t key = bit_lib_bytes_to_num_be(sec_tr->key_a.data, 6);
        if(key != skylanders_key) break;

-        const uint16_t id = (uint16_t)*data->block[1].data;
+        const uint16_t id = data->block[1].data[1] << 8 | data->block[1].data[0];
        if(id == 0) break;

        Storage* storage = furi_record_open(RECORD_STORAGE);
--- a/applications/main/nfc/resources/nfc/assets/mf_classic_dict.nfc
+++ b/applications/main/nfc/resources/nfc/assets/mf_classic_dict.nfc
@@ -1285,7 +1285,11 @@ ABFEDC124578
 5E594208EF02
 AF9E38D36582
 10DF4D1859C8
+#
+# Key B
 B5244E79B0C8
+#
+# Ukraine hotel
 F5C1C4C5DE34
 BB7923232725
 A95BD5BB4FC5
--- a/applications/main/nfc/scenes/nfc_scene_mf_classic_mfkey_complete.c
+++ b/applications/main/nfc/scenes/nfc_scene_mf_classic_mfkey_complete.c
@@ -1,4 +1,10 @@
 #include "../nfc_app_i.h"
+#include "loader/loader.h"
+
+typedef enum {
+    NfcSceneMfClassicMfKeyCompleteStateAppMissing,
+    NfcSceneMfClassicMfKeyCompleteStateAppPresent,
+} NfcSceneMfClassicMfKeyCompleteState;

 void nfc_scene_mf_classic_mfkey_complete_callback(
    GuiButtonType result,
@@ -15,22 +21,47 @@ void nfc_scene_mf_classic_mfkey_complete_on_enter(void* context) {

    widget_add_string_element(
        instance->widget, 64, 0, AlignCenter, AlignTop, FontPrimary, "Completed!");
-    widget_add_string_multiline_element(
-        instance->widget,
-        64,
-        13,
-        AlignCenter,
-        AlignTop,
-        FontSecondary,
-        "Now use Mfkey32 to extract \nkeys: r.flipper.net/nfc-tools");
-    widget_add_icon_element(instance->widget, 50, 39, &I_MFKey_qr_25x25);
-    widget_add_button_element(
-        instance->widget,
-        GuiButtonTypeRight,
-        "Finish",
-        nfc_scene_mf_classic_mfkey_complete_callback,
-        instance);

+    NfcSceneMfClassicMfKeyCompleteState scene_state =
+        storage_common_exists(instance->storage, NFC_MFKEY32_APP_PATH) ?
+            NfcSceneMfClassicMfKeyCompleteStateAppPresent :
+            NfcSceneMfClassicMfKeyCompleteStateAppMissing;
+    scene_manager_set_scene_state(
+        instance->scene_manager, NfcSceneMfClassicMfkeyComplete, scene_state);
+
+    if(scene_state == NfcSceneMfClassicMfKeyCompleteStateAppMissing) {
+        widget_add_string_multiline_element(
+            instance->widget,
+            64,
+            13,
+            AlignCenter,
+            AlignTop,
+            FontSecondary,
+            "Now use Mfkey32 to extract \nkeys: r.flipper.net/nfc-tools");
+        widget_add_icon_element(instance->widget, 50, 39, &I_MFKey_qr_25x25);
+        widget_add_button_element(
+            instance->widget,
+            GuiButtonTypeRight,
+            "Finish",
+            nfc_scene_mf_classic_mfkey_complete_callback,
+            instance);
+    } else {
+        widget_add_string_multiline_element(
+            instance->widget,
+            60,
+            16,
+            AlignLeft,
+            AlignTop,
+            FontSecondary,
+            "Now run Mfkey32\n to extract \nkeys");
+        widget_add_icon_element(instance->widget, 5, 18, &I_WarningDolphin_45x42);
+        widget_add_button_element(
+            instance->widget,
+            GuiButtonTypeRight,
+            "Run",
+            nfc_scene_mf_classic_mfkey_complete_callback,
+            instance);
+    }
    view_dispatcher_switch_to_view(instance->view_dispatcher, NfcViewWidget);
 }

@@ -40,8 +71,14 @@ bool nfc_scene_mf_classic_mfkey_complete_on_event(void* context, SceneManagerEve

    if(event.type == SceneManagerEventTypeCustom) {
        if(event.event == GuiButtonTypeRight) {
-            consumed = scene_manager_search_and_switch_to_previous_scene(
-                instance->scene_manager, NfcSceneStart);
+            NfcSceneMfClassicMfKeyCompleteState scene_state = scene_manager_get_scene_state(
+                instance->scene_manager, NfcSceneMfClassicMfkeyComplete);
+            if(scene_state == NfcSceneMfClassicMfKeyCompleteStateAppMissing) {
+                consumed = scene_manager_search_and_switch_to_previous_scene(
+                    instance->scene_manager, NfcSceneStart);
+            } else {
+                nfc_app_run_external(instance, NFC_MFKEY32_APP_PATH);
+            }
        }
    } else if(event.type == SceneManagerEventTypeBack) {
        const uint32_t prev_scenes[] = {NfcSceneSavedMenu, NfcSceneStart};
--- a/applications/main/nfc/scenes/nfc_scene_mf_classic_update_initial.c
+++ b/applications/main/nfc/scenes/nfc_scene_mf_classic_update_initial.c
@@ -34,7 +34,7 @@ NfcCommand nfc_mf_classic_update_initial_worker_callback(NfcGenericEvent event,
        uint8_t sector_num = 0;
        MfClassicKey key = {};
        MfClassicKeyType key_type = MfClassicKeyTypeA;
-        if(mf_classic_key_cahce_get_next_key(
+        if(mf_classic_key_cache_get_next_key(
               instance->mfc_key_cache, &sector_num, &key, &key_type)) {
            mfc_event->data->read_sector_request_data.sector_num = sector_num;
            mfc_event->data->read_sector_request_data.key = key;
--- a/applications/main/nfc/scenes/nfc_scene_save_confirm.c
+++ b/applications/main/nfc/scenes/nfc_scene_save_confirm.c
@@ -29,7 +29,14 @@ bool nfc_scene_save_confirm_on_event(void* context, SceneManagerEvent event) {
            scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
            consumed = true;
        } else if(event.event == DialogExResultLeft) {
-            scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicDetectReader);
+            NfcSceneSaveConfirmState scene_state =
+                scene_manager_get_scene_state(nfc->scene_manager, NfcSceneSaveConfirm);
+
+            NfcScene scene = scene_state == NfcSceneSaveConfirmStateCrackNonces ?
+                                 NfcSceneMfClassicMfkeyComplete :
+                                 NfcSceneMfClassicDetectReader;
+
+            scene_manager_next_scene(nfc->scene_manager, scene);
            consumed = true;
        }
    }
--- a/applications/main/nfc/scenes/nfc_scene_save_success.c
+++ b/applications/main/nfc/scenes/nfc_scene_save_success.c
@@ -33,7 +33,13 @@ bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
                consumed = scene_manager_search_and_switch_to_previous_scene(
                    nfc->scene_manager, NfcSceneMfUltralightCKeys);
            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSaveConfirm)) {
-                scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicDetectReader);
+                NfcSceneSaveConfirmState scene_state =
+                    scene_manager_get_scene_state(nfc->scene_manager, NfcSceneSaveConfirm);
+
+                NfcScene scene = scene_state == NfcSceneSaveConfirmStateCrackNonces ?
+                                     NfcSceneMfClassicMfkeyComplete :
+                                     NfcSceneMfClassicDetectReader;
+                scene_manager_next_scene(nfc->scene_manager, scene);
                consumed = true;
            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
                consumed = scene_manager_search_and_switch_to_another_scene(
--- a/applications/main/onewire/application.fam
+++ b/applications/main/onewire/application.fam
@@ -1,6 +1,8 @@
 App(
-    appid="onewire_start",
-    apptype=FlipperAppType.STARTUP,
-    entry_point="onewire_on_system_start",
-    order=60,
+    appid="cli_onewire",
+    targets=["f7"],
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="cli_onewire_ep",
+    requires=["cli"],
+    sources=["onewire_cli.c"],
 )
--- a/applications/main/onewire/onewire_cli.c
+++ b/applications/main/onewire/onewire_cli.c
@@ -1,38 +1,29 @@
 #include <furi.h>
 #include <furi_hal.h>

-#include <cli/cli.h>
+#include <cli/cli_main_commands.h>
+#include <power/power_service/power.h>
+#include <toolbox/cli/cli_command.h>
 #include <toolbox/args.h>

 #include <one_wire/one_wire_host.h>

-static void onewire_cli(Cli* cli, FuriString* args, void* context);
-
-void onewire_on_system_start(void) {
-#ifdef SRV_CLI
-    Cli* cli = furi_record_open(RECORD_CLI);
-    cli_add_command(cli, "onewire", CliCommandFlagDefault, onewire_cli, cli);
-    furi_record_close(RECORD_CLI);
-#else
-    UNUSED(onewire_cli);
-#endif
-}
-
 static void onewire_cli_print_usage(void) {
    printf("Usage:\r\n");
    printf("onewire search\r\n");
 }

-static void onewire_cli_search(Cli* cli) {
-    UNUSED(cli);
+static void onewire_cli_search(PipeSide* pipe) {
+    UNUSED(pipe);
    OneWireHost* onewire = onewire_host_alloc(&gpio_ibutton);
+    Power* power = furi_record_open(RECORD_POWER);
    uint8_t address[8];
    bool done = false;

    printf("Search started\r\n");

    onewire_host_start(onewire);
-    furi_hal_power_enable_otg();
+    power_enable_otg(power, true);

    while(!done) {
        if(onewire_host_search(onewire, address, OneWireHostSearchModeNormal) != 1) {
@@ -49,11 +40,13 @@ static void onewire_cli_search(Cli* cli) {
        furi_delay_ms(100);
    }

-    furi_hal_power_disable_otg();
+    power_enable_otg(power, false);
+
    onewire_host_free(onewire);
+    furi_record_close(RECORD_POWER);
 }

-void onewire_cli(Cli* cli, FuriString* args, void* context) {
+static void execute(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    FuriString* cmd;
    cmd = furi_string_alloc();
@@ -65,8 +58,10 @@ void onewire_cli(Cli* cli, FuriString* args, void* context) {
    }

    if(furi_string_cmp_str(cmd, "search") == 0) {
-        onewire_cli_search(cli);
+        onewire_cli_search(pipe);
    }

    furi_string_free(cmd);
 }
+
+CLI_COMMAND_INTERFACE(onewire, execute, CliCommandFlagDefault, 1024, CLI_APPID);
--- a/applications/main/subghz/application.fam
+++ b/applications/main/subghz/application.fam
@@ -20,10 +20,10 @@ App(
 )

 App(
-    appid="subghz_start",
+    appid="cli_subghz",
    targets=["f7"],
-    apptype=FlipperAppType.STARTUP,
-    entry_point="subghz_on_system_start",
+    apptype=FlipperAppType.PLUGIN,
+    entry_point="cli_subghz_ep",
+    requires=["cli"],
    sources=["subghz_cli.c", "helpers/subghz_chat.c"],
-    order=40,
 )
--- a/applications/main/subghz/helpers/subghz_chat.c
+++ b/applications/main/subghz/helpers/subghz_chat.c
@@ -1,5 +1,6 @@
 #include "subghz_chat.h"
 #include <lib/subghz/subghz_tx_rx_worker.h>
+#include <toolbox/pipe.h>

 #define TAG "SubGhzChat"

@@ -14,7 +15,7 @@ struct SubGhzChatWorker {
    FuriMessageQueue* event_queue;
    uint32_t last_time_rx_data;

-    Cli* cli;
+    PipeSide* pipe;
 };

 /** Worker thread
@@ -30,7 +31,7 @@ static int32_t subghz_chat_worker_thread(void* context) {
    event.event = SubGhzChatEventUserEntrance;
    furi_message_queue_put(instance->event_queue, &event, 0);
    while(instance->worker_running) {
-        if(cli_read_timeout(instance->cli, (uint8_t*)&c, 1, 1000) == 1) {
+        if(pipe_receive(instance->pipe, (uint8_t*)&c, 1) == 1) {
            event.event = SubGhzChatEventInputData;
            event.c = c;
            furi_message_queue_put(instance->event_queue, &event, FuriWaitForever);
@@ -55,10 +56,10 @@ static void subghz_chat_worker_update_rx_event_chat(void* context) {
    furi_message_queue_put(instance->event_queue, &event, FuriWaitForever);
 }

-SubGhzChatWorker* subghz_chat_worker_alloc(Cli* cli) {
+SubGhzChatWorker* subghz_chat_worker_alloc(PipeSide* pipe) {
    SubGhzChatWorker* instance = malloc(sizeof(SubGhzChatWorker));

-    instance->cli = cli;
+    instance->pipe = pipe;

    instance->thread =
        furi_thread_alloc_ex("SubGhzChat", 2048, subghz_chat_worker_thread, instance);
--- a/applications/main/subghz/helpers/subghz_chat.h
+++ b/applications/main/subghz/helpers/subghz_chat.h
@@ -1,7 +1,7 @@
 #pragma once
 #include "../subghz_i.h"
 #include <lib/subghz/devices/devices.h>
-#include <cli/cli.h>
+#include <toolbox/pipe.h>

 typedef struct SubGhzChatWorker SubGhzChatWorker;

@@ -19,7 +19,7 @@ typedef struct {
    char c;
 } SubGhzChatEvent;

-SubGhzChatWorker* subghz_chat_worker_alloc(Cli* cli);
+SubGhzChatWorker* subghz_chat_worker_alloc(PipeSide* pipe);
 void subghz_chat_worker_free(SubGhzChatWorker* instance);
 bool subghz_chat_worker_start(
    SubGhzChatWorker* instance,
--- a/applications/main/subghz/helpers/subghz_custom_event.h
+++ b/applications/main/subghz/helpers/subghz_custom_event.h
@@ -49,6 +49,7 @@ typedef enum {
    SubGhzCustomEventSceneRpcLoad,
    SubGhzCustomEventSceneRpcButtonPress,
    SubGhzCustomEventSceneRpcButtonRelease,
+    SubGhzCustomEventSceneRpcButtonPressRelease,
    SubGhzCustomEventSceneRpcSessionClose,

    SubGhzCustomEventViewReceiverOK,
--- a/applications/main/subghz/helpers/subghz_txrx.c
+++ b/applications/main/subghz/helpers/subghz_txrx.c
@@ -4,27 +4,22 @@
 #include <applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h>
 #include <lib/subghz/devices/cc1101_int/cc1101_int_interconnect.h>

+#include <power/power_service/power.h>
+
 #define TAG "SubGhz"

 static void subghz_txrx_radio_device_power_on(SubGhzTxRx* instance) {
    UNUSED(instance);
-    uint8_t attempts = 5;
-    while(--attempts > 0) {
-        if(furi_hal_power_enable_otg()) break;
-    }
-    if(attempts == 0) {
-        if(furi_hal_power_get_usb_voltage() < 4.5f) {
-            FURI_LOG_E(
-                TAG,
-                "Error power otg enable. BQ2589 check otg fault = %d",
-                furi_hal_power_check_otg_fault() ? 1 : 0);
-        }
-    }
+    Power* power = furi_record_open(RECORD_POWER);
+    power_enable_otg(power, true);
+    furi_record_close(RECORD_POWER);
 }

 static void subghz_txrx_radio_device_power_off(SubGhzTxRx* instance) {
    UNUSED(instance);
-    if(furi_hal_power_is_otg_enabled()) furi_hal_power_disable_otg();
+    Power* power = furi_record_open(RECORD_POWER);
+    power_enable_otg(power, false);
+    furi_record_close(RECORD_POWER);
 }

 SubGhzTxRx* subghz_txrx_alloc(void) {
--- a/applications/main/subghz/scenes/subghz_scene_rpc.c
+++ b/applications/main/subghz/scenes/subghz_scene_rpc.c
@@ -85,6 +85,43 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
            scene_manager_set_scene_state(
                subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateIdle);
            rpc_system_app_confirm(subghz->rpc_ctx, result);
+        } else if(event.event == SubGhzCustomEventSceneRpcButtonPressRelease) {
+            bool result = false;
+            if(state == SubGhzRpcStateLoaded) {
+                switch(
+                    subghz_txrx_tx_start(subghz->txrx, subghz_txrx_get_fff_data(subghz->txrx))) {
+                case SubGhzTxRxStartTxStateErrorOnlyRx:
+                    rpc_system_app_set_error_code(
+                        subghz->rpc_ctx, RpcAppSystemErrorCodeRegionLock);
+                    rpc_system_app_set_error_text(
+                        subghz->rpc_ctx,
+                        "Transmission on this frequency is restricted in your region");
+                    break;
+                case SubGhzTxRxStartTxStateErrorParserOthers:
+                    rpc_system_app_set_error_code(
+                        subghz->rpc_ctx, RpcAppSystemErrorCodeInternalParse);
+                    rpc_system_app_set_error_text(
+                        subghz->rpc_ctx, "Error in protocol parameters description");
+                    break;
+
+                default: //if(SubGhzTxRxStartTxStateOk)
+                    result = true;
+                    subghz_blink_start(subghz);
+                    scene_manager_set_scene_state(
+                        subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateTx);
+                    break;
+                }
+            }
+
+            // Stop transmission
+            if(state == SubGhzRpcStateTx) {
+                subghz_txrx_stop(subghz->txrx);
+                subghz_blink_stop(subghz);
+                result = true;
+            }
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateIdle);
+            rpc_system_app_confirm(subghz->rpc_ctx, result);
        } else if(event.event == SubGhzCustomEventSceneRpcLoad) {
            bool result = false;
            if(state == SubGhzRpcStateIdle) {
--- a/applications/main/subghz/subghz.c
+++ b/applications/main/subghz/subghz.c
@@ -43,6 +43,9 @@ static void subghz_rpc_command_callback(const RpcAppSystemEvent* event, void* co
    } else if(event->type == RpcAppEventTypeButtonRelease) {
        view_dispatcher_send_custom_event(
            subghz->view_dispatcher, SubGhzCustomEventSceneRpcButtonRelease);
+    } else if(event->type == RpcAppEventTypeButtonPressRelease) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneRpcButtonPressRelease);
    } else {
        rpc_system_app_confirm(subghz->rpc_ctx, false);
    }
--- a/applications/main/subghz/subghz_cli.c
+++ b/applications/main/subghz/subghz_cli.c
@@ -4,6 +4,8 @@
 #include <furi_hal.h>

 #include <applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h>
+#include <cli/cli_main_commands.h>
+#include <toolbox/cli/cli_ansi.h>

 #include <lib/subghz/subghz_keystore.h>
 #include <lib/subghz/receiver.h>
@@ -16,6 +18,7 @@

 #include <lib/toolbox/args.h>
 #include <lib/toolbox/strint.h>
+#include <toolbox/pipe.h>

 #include "helpers/subghz_chat.h"

@@ -28,22 +31,15 @@
 #define TAG "SubGhzCli"

 static void subghz_cli_radio_device_power_on(void) {
-    uint8_t attempts = 5;
-    while(--attempts > 0) {
-        if(furi_hal_power_enable_otg()) break;
-    }
-    if(attempts == 0) {
-        if(furi_hal_power_get_usb_voltage() < 4.5f) {
-            FURI_LOG_E(
-                "TAG",
-                "Error power otg enable. BQ2589 check otg fault = %d",
-                furi_hal_power_check_otg_fault() ? 1 : 0);
-        }
-    }
+    Power* power = furi_record_open(RECORD_POWER);
+    power_enable_otg(power, true);
+    furi_record_close(RECORD_POWER);
 }

 static void subghz_cli_radio_device_power_off(void) {
-    if(furi_hal_power_is_otg_enabled()) furi_hal_power_disable_otg();
+    Power* power = furi_record_open(RECORD_POWER);
+    power_enable_otg(power, false);
+    furi_record_close(RECORD_POWER);
 }

 static SubGhzEnvironment* subghz_cli_environment_init(void) {
@@ -68,7 +64,7 @@ static SubGhzEnvironment* subghz_cli_environment_init(void) {
    return environment;
 }

-void subghz_cli_command_tx_carrier(Cli* cli, FuriString* args, void* context) {
+void subghz_cli_command_tx_carrier(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    uint32_t frequency = 433920000;

@@ -98,7 +94,7 @@ void subghz_cli_command_tx_carrier(Cli* cli, FuriString* args, void* context) {
    if(furi_hal_subghz_tx()) {
        printf("Transmitting at frequency %lu Hz\r\n", frequency);
        printf("Press CTRL+C to stop\r\n");
-        while(!cli_cmd_interrupt_received(cli)) {
+        while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
            furi_delay_ms(250);
        }
    } else {
@@ -111,7 +107,7 @@ void subghz_cli_command_tx_carrier(Cli* cli, FuriString* args, void* context) {
    furi_hal_power_suppress_charge_exit();
 }

-void subghz_cli_command_rx_carrier(Cli* cli, FuriString* args, void* context) {
+void subghz_cli_command_rx_carrier(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    uint32_t frequency = 433920000;

@@ -139,7 +135,7 @@ void subghz_cli_command_rx_carrier(Cli* cli, FuriString* args, void* context) {

    furi_hal_subghz_rx();

-    while(!cli_cmd_interrupt_received(cli)) {
+    while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
        furi_delay_ms(250);
        printf("RSSI: %03.1fdbm\r", (double)furi_hal_subghz_get_rssi());
        fflush(stdout);
@@ -172,7 +168,7 @@ static const SubGhzDevice* subghz_cli_command_get_device(uint32_t* device_ind) {
    return device;
 }

-void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
+void subghz_cli_command_tx(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    uint32_t frequency = 433920000;
    uint32_t key = 0x0074BADE;
@@ -242,7 +238,9 @@ void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {

    furi_hal_power_suppress_charge_enter();
    if(subghz_devices_start_async_tx(device, subghz_transmitter_yield, transmitter)) {
-        while(!(subghz_devices_is_async_complete_tx(device) || cli_cmd_interrupt_received(cli))) {
+        while(
+            !(subghz_devices_is_async_complete_tx(device) ||
+              cli_is_pipe_broken_or_is_etx_next_char(pipe))) {
            printf(".");
            fflush(stdout);
            furi_delay_ms(333);
@@ -299,7 +297,7 @@ static void subghz_cli_command_rx_callback(
    furi_string_free(text);
 }

-void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
+void subghz_cli_command_rx(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    uint32_t frequency = 433920000;
    uint32_t device_ind = 0; // 0 - CC1101_INT, 1 - CC1101_EXT
@@ -355,7 +353,7 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
        frequency,
        device_ind);
    LevelDuration level_duration;
-    while(!cli_cmd_interrupt_received(cli)) {
+    while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
        int ret = furi_stream_buffer_receive(
            instance->stream, &level_duration, sizeof(LevelDuration), 10);
        if(ret == sizeof(LevelDuration)) {
@@ -388,7 +386,7 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
    free(instance);
 }

-void subghz_cli_command_rx_raw(Cli* cli, FuriString* args, void* context) {
+void subghz_cli_command_rx_raw(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    uint32_t frequency = 433920000;

@@ -426,7 +424,7 @@ void subghz_cli_command_rx_raw(Cli* cli, FuriString* args, void* context) {
    printf("Listening at %lu. Press CTRL+C to stop\r\n", frequency);
    LevelDuration level_duration;
    size_t counter = 0;
-    while(!cli_cmd_interrupt_received(cli)) {
+    while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
        int ret = furi_stream_buffer_receive(
            instance->stream, &level_duration, sizeof(LevelDuration), 10);
        if(ret == 0) {
@@ -462,7 +460,7 @@ void subghz_cli_command_rx_raw(Cli* cli, FuriString* args, void* context) {
    free(instance);
 }

-void subghz_cli_command_decode_raw(Cli* cli, FuriString* args, void* context) {
+void subghz_cli_command_decode_raw(PipeSide* pipe, FuriString* args, void* context) {
    UNUSED(context);
    FuriString* file_name;
    file_name = furi_string_alloc();
@@ -532,7 +530,7 @@ void subghz_cli_command_decode_raw(Cli* cli, FuriString* args, void* context) {
            furi_string_get_cstr(file_name));

        LevelDuration level_duration;
-        while(!cli_cmd_interrupt_received(cli)) {
+        while(!cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
            furi_delay_us(500); //you need to have time to read from the file from the SD card
            level_duration = subghz_file_encoder_worker_get_level_duration(file_worker_encoder);
            if(!level_duration_is_reset(level_duration)) {
@@ -577,7 +575,7 @@ static FuriHalSubGhzPreset subghz_cli_get_preset_name(const char* preset_name) {
    return preset;
 }

-void subghz_cli_command_tx_from_file(Cli* cli, FuriString* args, void* context) { // -V524
+void subghz_cli_command_tx_from_file(PipeSide* pipe, FuriString* args, void* context) { // -V524
    UNUSED(context);
    FuriString* file_name;
    file_name = furi_string_alloc();
@@ -615,7 +613,7 @@ void subghz_cli_command_tx_from_file(Cli* cli, FuriString* args, void* context)
        if(furi_string_size(args)) {
            char* args_cstr = (char*)furi_string_get_cstr(args);
            StrintParseError parse_err = StrintParseNoError;
-            parse_err |= strint_to_uint32(args_cstr, &args_cstr, &frequency, 10);
+            parse_err |= strint_to_uint32(args_cstr, &args_cstr, &repeat, 10);
            parse_err |= strint_to_uint32(args_cstr, &args_cstr, &device_ind, 10);
            if(parse_err) {
                cli_print_usage(
@@ -781,7 +779,7 @@ void subghz_cli_command_tx_from_file(Cli* cli, FuriString* args, void* context)
            if(subghz_devices_start_async_tx(device, subghz_transmitter_yield, transmitter)) {
                while(
                    !(subghz_devices_is_async_complete_tx(device) ||
-                      cli_cmd_interrupt_received(cli))) {
+                      cli_is_pipe_broken_or_is_etx_next_char(pipe))) {
                    printf(".");
                    fflush(stdout);
                    furi_delay_ms(333);
@@ -795,11 +793,11 @@ void subghz_cli_command_tx_from_file(Cli* cli, FuriString* args, void* context)
            if(!strcmp(furi_string_get_cstr(temp_str), "RAW")) {
                subghz_transmitter_stop(transmitter);
                repeat--;
-                if(!cli_cmd_interrupt_received(cli) && repeat)
+                if(!cli_is_pipe_broken_or_is_etx_next_char(pipe) && repeat)
                    subghz_transmitter_deserialize(transmitter, fff_data_raw);
            }

-        } while(!cli_cmd_interrupt_received(cli) &&
+        } while(!cli_is_pipe_broken_or_is_etx_next_char(pipe) &&
                (repeat && !strcmp(furi_string_get_cstr(temp_str), "RAW")));

        subghz_devices_sleep(device);
@@ -844,8 +842,8 @@ static void subghz_cli_command_print_usage(void) {
    }
 }

-static void subghz_cli_command_encrypt_keeloq(Cli* cli, FuriString* args) {
-    UNUSED(cli);
+static void subghz_cli_command_encrypt_keeloq(PipeSide* pipe, FuriString* args) {
+    UNUSED(pipe);
    uint8_t iv[16];

    FuriString* source;
@@ -887,8 +885,8 @@ static void subghz_cli_command_encrypt_keeloq(Cli* cli, FuriString* args) {
    furi_string_free(source);
 }

-static void subghz_cli_command_encrypt_raw(Cli* cli, FuriString* args) {
-    UNUSED(cli);
+static void subghz_cli_command_encrypt_raw(PipeSide* pipe, FuriString* args) {
+    UNUSED(pipe);
    uint8_t iv[16];

    FuriString* source;
@@ -924,7 +922,7 @@ static void subghz_cli_command_encrypt_raw(Cli* cli, FuriString* args) {
    furi_string_free(source);
 }

-static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
+static void subghz_cli_command_chat(PipeSide* pipe, FuriString* args) {
    uint32_t frequency = 433920000;
    uint32_t device_ind = 0; // 0 - CC1101_INT, 1 - CC1101_EXT

@@ -958,7 +956,7 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
        return;
    }

-    SubGhzChatWorker* subghz_chat = subghz_chat_worker_alloc(cli);
+    SubGhzChatWorker* subghz_chat = subghz_chat_worker_alloc(pipe);

    if(!subghz_chat_worker_start(subghz_chat, device, frequency)) {
        printf("Startup error SubGhzChatWorker\r\n");
@@ -999,13 +997,12 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
        chat_event = subghz_chat_worker_get_event_chat(subghz_chat);
        switch(chat_event.event) {
        case SubGhzChatEventInputData:
-            if(chat_event.c == CliSymbolAsciiETX) {
+            if(chat_event.c == CliKeyETX) {
                printf("\r\n");
                chat_event.event = SubGhzChatEventUserExit;
                subghz_chat_worker_put_event_chat(subghz_chat, &chat_event);
                break;
-            } else if(
-                (chat_event.c == CliSymbolAsciiBackspace) || (chat_event.c == CliSymbolAsciiDel)) {
+            } else if((chat_event.c == CliKeyBackspace) || (chat_event.c == CliKeyDEL)) {
                size_t len = furi_string_utf8_length(input);
                if(len > furi_string_utf8_length(name)) {
                    printf("%s", "\e[D\e[1P");
@@ -1027,7 +1024,7 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
                    }
                    furi_string_set(input, sysmsg);
                }
-            } else if(chat_event.c == CliSymbolAsciiCR) {
+            } else if(chat_event.c == CliKeyCR) {
                printf("\r\n");
                furi_string_push_back(input, '\r');
                furi_string_push_back(input, '\n');
@@ -1041,7 +1038,7 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
                furi_string_printf(input, "%s", furi_string_get_cstr(name));
                printf("%s", furi_string_get_cstr(input));
                fflush(stdout);
-            } else if(chat_event.c == CliSymbolAsciiLF) {
+            } else if(chat_event.c == CliKeyLF) {
                //cut out the symbol \n
            } else {
                putc(chat_event.c, stdout);
@@ -1095,7 +1092,7 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
                break;
            }
        }
-        if(!cli_is_connected(cli)) {
+        if(cli_is_pipe_broken_or_is_etx_next_char(pipe)) {
            printf("\r\n");
            chat_event.event = SubGhzChatEventUserExit;
            subghz_chat_worker_put_event_chat(subghz_chat, &chat_event);
@@ -1120,7 +1117,7 @@ static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
    printf("\r\nExit chat\r\n");
 }

-static void subghz_cli_command(Cli* cli, FuriString* args, void* context) {
+static void execute(PipeSide* pipe, FuriString* args, void* context) {
    FuriString* cmd;
    cmd = furi_string_alloc();

@@ -1131,53 +1128,53 @@ static void subghz_cli_command(Cli* cli, FuriString* args, void* context) {
        }

        if(furi_string_cmp_str(cmd, "chat") == 0) {
-            subghz_cli_command_chat(cli, args);
+            subghz_cli_command_chat(pipe, args);
            break;
        }

        if(furi_string_cmp_str(cmd, "tx") == 0) {
-            subghz_cli_command_tx(cli, args, context);
+            subghz_cli_command_tx(pipe, args, context);
            break;
        }

        if(furi_string_cmp_str(cmd, "rx") == 0) {
-            subghz_cli_command_rx(cli, args, context);
+            subghz_cli_command_rx(pipe, args, context);
            break;
        }

        if(furi_string_cmp_str(cmd, "rx_raw") == 0) {
-            subghz_cli_command_rx_raw(cli, args, context);
+            subghz_cli_command_rx_raw(pipe, args, context);
            break;
        }

        if(furi_string_cmp_str(cmd, "decode_raw") == 0) {
-            subghz_cli_command_decode_raw(cli, args, context);
+            subghz_cli_command_decode_raw(pipe, args, context);
            break;
        }

        if(furi_string_cmp_str(cmd, "tx_from_file") == 0) {
-            subghz_cli_command_tx_from_file(cli, args, context);
+            subghz_cli_command_tx_from_file(pipe, args, context);
            break;
        }

        if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
            if(furi_string_cmp_str(cmd, "encrypt_keeloq") == 0) {
-                subghz_cli_command_encrypt_keeloq(cli, args);
+                subghz_cli_command_encrypt_keeloq(pipe, args);
                break;
            }

            if(furi_string_cmp_str(cmd, "encrypt_raw") == 0) {
-                subghz_cli_command_encrypt_raw(cli, args);
+                subghz_cli_command_encrypt_raw(pipe, args);
                break;
            }

            if(furi_string_cmp_str(cmd, "tx_carrier") == 0) {
-                subghz_cli_command_tx_carrier(cli, args, context);
+                subghz_cli_command_tx_carrier(pipe, args, context);
                break;
            }

            if(furi_string_cmp_str(cmd, "rx_carrier") == 0) {
-                subghz_cli_command_rx_carrier(cli, args, context);
+                subghz_cli_command_rx_carrier(pipe, args, context);
                break;
            }
        }
@@ -1188,14 +1185,4 @@ static void subghz_cli_command(Cli* cli, FuriString* args, void* context) {
    furi_string_free(cmd);
 }

-void subghz_on_system_start(void) {
-#ifdef SRV_CLI
-    Cli* cli = furi_record_open(RECORD_CLI);
-
-    cli_add_command(cli, "subghz", CliCommandFlagDefault, subghz_cli_command, NULL);
-
-    furi_record_close(RECORD_CLI);
-#else
-    UNUSED(subghz_cli_command);
-#endif
-}
+CLI_COMMAND_INTERFACE(subghz, execute, CliCommandFlagDefault, 2048, CLI_APPID);
--- a/applications/main/subghz/subghz_cli.h
+++ b/applications/main/subghz/subghz_cli.h
@@ -1,5 +1,3 @@
 #pragma once

-#include <cli/cli.h>
-
 void subghz_on_system_start(void);
--- a/applications/main/subghz/subghz_i.h
+++ b/applications/main/subghz/subghz_i.h
@@ -28,6 +28,8 @@

 #include "rpc/rpc_app.h"

+#include <power/power_service/power.h>
+
 #include "helpers/subghz_threshold_rssi.h"

 #include "helpers/subghz_txrx.h"
--- a/applications/main/u2f/u2f.c
+++ b/applications/main/u2f/u2f.c
@@ -280,6 +280,8 @@ static uint16_t u2f_register(U2fData* U2F, uint8_t* buf) {
        MCHECK(mbedtls_md_hmac_update(&hmac_ctx, private, sizeof(private)));
        MCHECK(mbedtls_md_hmac_update(&hmac_ctx, req->app_id, sizeof(req->app_id)));
        MCHECK(mbedtls_md_hmac_finish(&hmac_ctx, handle.hash));
+
+        mbedtls_md_free(&hmac_ctx);
    }

    // Generate public key
@@ -387,6 +389,8 @@ static uint16_t u2f_authenticate(U2fData* U2F, uint8_t* buf) {
        MCHECK(mbedtls_md_hmac_update(&hmac_ctx, priv_key, sizeof(priv_key)));
        MCHECK(mbedtls_md_hmac_update(&hmac_ctx, req->app_id, sizeof(req->app_id)));
        MCHECK(mbedtls_md_hmac_finish(&hmac_ctx, mac_control));
+
+        mbedtls_md_free(&hmac_ctx);
    }

    if(memcmp(req->key_handle.hash, mac_control, sizeof(mac_control)) != 0) {