Merge remote-tracking branch 'ofw/dev' into mntm-dev

applications/services/cli/shell/cli_shell.c

@@ -4,6 +4,7 @@
 #include "../cli_i.h"
 #include "../cli_commands.h"
 #include "cli_shell_line.h"
+#include "cli_shell_completions.h"
 #include <stdio.h>
 #include <furi_hal_version.h>
 #include <m-array.h>
@@ -11,21 +12,29 @@
 #include <toolbox/pipe.h>
 #include <flipper_application/plugins/plugin_manager.h>
 #include <loader/firmware_api/firmware_api.h>
+#include <storage/storage.h>
 
 #define TAG "CliShell"
 
 #define ANSI_TIMEOUT_MS 10
 
 typedef enum {
+    CliShellComponentCompletions,
     CliShellComponentLine,
     CliShellComponentMAX, //<! do not use
 } CliShellComponent;
 
 CliShellKeyComboSet* component_key_combo_sets[] = {
+    [CliShellComponentCompletions] = &cli_shell_completions_key_combo_set,
     [CliShellComponentLine] = &cli_shell_line_key_combo_set,
 };
 static_assert(CliShellComponentMAX == COUNT_OF(component_key_combo_sets));
 
+typedef enum {
+    CliShellStorageEventMount,
+    CliShellStorageEventUnmount,
+} CliShellStorageEvent;
+
 struct CliShell {
     Cli* cli;
     FuriEventLoop* event_loop;
@@ -34,6 +43,10 @@ struct CliShell {
     CliAnsiParser* ansi_parser;
     FuriEventLoopTimer* ansi_parsing_timer;
 
+    Storage* storage;
+    FuriPubSubSubscription* storage_subscription;
+    FuriMessageQueue* storage_event_queue;
+
     void* components[CliShellComponentMAX];
 };
 
@@ -43,10 +56,73 @@ typedef struct {
     FuriString* args;
 } CliCommandThreadData;
 
+static void cli_shell_data_available(PipeSide* pipe, void* context);
+static void cli_shell_pipe_broken(PipeSide* pipe, void* context);
+
+static void cli_shell_install_pipe(CliShell* cli_shell) {
+    pipe_install_as_stdio(cli_shell->pipe);
+    pipe_attach_to_event_loop(cli_shell->pipe, cli_shell->event_loop);
+    pipe_set_callback_context(cli_shell->pipe, cli_shell);
+    pipe_set_data_arrived_callback(cli_shell->pipe, cli_shell_data_available, 0);
+    pipe_set_broken_callback(cli_shell->pipe, cli_shell_pipe_broken, 0);
+}
+
+static void cli_shell_detach_pipe(CliShell* cli_shell) {
+    pipe_detach_from_event_loop(cli_shell->pipe);
+    furi_thread_set_stdin_callback(NULL, NULL);
+    furi_thread_set_stdout_callback(NULL, NULL);
+}
+
 // =========
 // Execution
 // =========
 
+static int32_t cli_command_thread(void* context) {
+    CliCommandThreadData* thread_data = context;
+    if(!(thread_data->command->flags & CliCommandFlagDontAttachStdio))
+        pipe_install_as_stdio(thread_data->pipe);
+
+    thread_data->command->execute_callback(
+        thread_data->pipe, thread_data->args, thread_data->command->context);
+
+    fflush(stdout);
+    return 0;
+}
+
+static size_t cli_shell_string_distance(const char* s1, const char* s2) {
+    size_t distance = 0;
+
+    while(*s1 && *s2) {
+        if(*s1++ != *s2++) distance++;
+    }
+    while(*s1++)
+        distance++;
+    while(*s2++)
+        distance++;
+
+    return distance;
+}
+
+static void
+    cli_shell_find_similar_command(CliShell* cli_shell, const char* input, FuriString* suggestion) {
+    size_t min_distance = (size_t)-1;
+    const size_t max_allowed = (strlen(input) + 1) / 2;
+    furi_string_reset(suggestion);
+
+    cli_lock_commands(cli_shell->cli);
+    CliCommandTree_t* commands = cli_get_commands(cli_shell->cli);
+    for
+        M_EACH(registered_command, *commands, CliCommandTree_t) {
+            const char* command_name = furi_string_get_cstr(*registered_command->key_ptr);
+            const size_t distance = cli_shell_string_distance(input, command_name);
+            if(distance < min_distance && distance <= max_allowed) {
+                min_distance = distance;
+                furi_string_set(suggestion, command_name);
+            }
+        }
+    cli_unlock_commands(cli_shell->cli);
+}
+
 void cli_shell_execute_command(CliShell* cli_shell, FuriString* command) {
     // split command into command and args
     size_t space = furi_string_search_char(command, ' ');
@@ -56,18 +132,59 @@ void cli_shell_execute_command(CliShell* cli_shell, FuriString* command) {
     FuriString* args = furi_string_alloc_set(command);
     furi_string_right(args, space + 1);
 
+    PluginManager* plugin_manager = NULL;
     Loader* loader = NULL;
     CliCommand command_data;
 
     do {
         // find handler
         if(!cli_get_command(cli_shell->cli, command_name, &command_data)) {
-            printf(
-                ANSI_FG_RED "could not find command `%s`, try `help`" ANSI_RESET,
-                furi_string_get_cstr(command_name));
+            FuriString* suggestion = furi_string_alloc();
+            cli_shell_find_similar_command(
+                cli_shell, furi_string_get_cstr(command_name), suggestion);
+            if(furi_string_empty(suggestion)) {
+                printf(
+                    ANSI_FG_RED "could not find command `%s`, try `help`" ANSI_RESET,
+                    furi_string_get_cstr(command_name));
+            } else {
+                printf(
+                    ANSI_FG_RED
+                    "could not find command `%s`, did you mean `%s`? Use `help` to list all available commands" ANSI_RESET,
+                    furi_string_get_cstr(command_name),
+                    furi_string_get_cstr(suggestion));
+            }
+            furi_string_free(suggestion);
             break;
         }
 
+        // load external command
+        if(command_data.flags & CliCommandFlagExternal) {
+            plugin_manager =
+                plugin_manager_alloc(PLUGIN_APP_ID, PLUGIN_API_VERSION, firmware_api_interface);
+            FuriString* path = furi_string_alloc_printf(
+                "%s/cli_%s.fal", CLI_COMMANDS_PATH, furi_string_get_cstr(command_name));
+            uint32_t plugin_cnt_last = plugin_manager_get_count(plugin_manager);
+            PluginManagerError error =
+                plugin_manager_load_single(plugin_manager, furi_string_get_cstr(path));
+            furi_string_free(path);
+
+            if(error != PluginManagerErrorNone) {
+                printf(ANSI_FG_RED "failed to load external command" ANSI_RESET);
+                break;
+            }
+
+            const CliCommandDescriptor* plugin =
+                plugin_manager_get_ep(plugin_manager, plugin_cnt_last);
+            furi_assert(plugin);
+            furi_check(furi_string_cmp_str(command_name, plugin->name) == 0);
+            command_data.execute_callback = plugin->execute_callback;
+            command_data.flags = plugin->flags | CliCommandFlagExternal;
+            command_data.stack_depth = plugin->stack_depth;
+
+            // external commands have to run in an external thread
+            furi_check(!(command_data.flags & CliCommandFlagUseShellThread));
+        }
+
         // lock loader
         if(!(command_data.flags & CliCommandFlagParallelSafe)) {
             loader = furi_record_open(RECORD_LOADER);
@@ -79,7 +196,27 @@ void cli_shell_execute_command(CliShell* cli_shell, FuriString* command) {
             }
         }
 
-        command_data.execute_callback(cli_shell->pipe, args, command_data.context);
+        if(command_data.flags & CliCommandFlagUseShellThread) {
+            // run command in this thread
+            command_data.execute_callback(cli_shell->pipe, args, command_data.context);
+        } else {
+            // run command in separate thread
+            cli_shell_detach_pipe(cli_shell);
+            CliCommandThreadData thread_data = {
+                .command = &command_data,
+                .pipe = cli_shell->pipe,
+                .args = args,
+            };
+            FuriThread* thread = furi_thread_alloc_ex(
+                furi_string_get_cstr(command_name),
+                command_data.stack_depth,
+                cli_command_thread,
+                &thread_data);
+            furi_thread_start(thread);
+            furi_thread_join(thread);
+            furi_thread_free(thread);
+            cli_shell_install_pipe(cli_shell);
+        }
     } while(0);
 
     furi_string_free(command_name);
@@ -88,13 +225,51 @@ void cli_shell_execute_command(CliShell* cli_shell, FuriString* command) {
     // unlock loader
     if(loader) loader_unlock(loader);
     furi_record_close(RECORD_LOADER);
+
+    // unload external command
+    if(plugin_manager) plugin_manager_free(plugin_manager);
 }
 
 // ==============
 // Event handlers
 // ==============
 
-static void cli_shell_process_key(CliShell* cli_shell, CliKeyCombo key_combo) {
+static void cli_shell_storage_event(const void* message, void* context) {
+    CliShell* cli_shell = context;
+    const StorageEvent* event = message;
+
+    if(event->type == StorageEventTypeCardMount) {
+        CliShellStorageEvent cli_event = CliShellStorageEventMount;
+        furi_check(
+            furi_message_queue_put(cli_shell->storage_event_queue, &cli_event, 0) == FuriStatusOk);
+    } else if(event->type == StorageEventTypeCardUnmount) {
+        CliShellStorageEvent cli_event = CliShellStorageEventUnmount;
+        furi_check(
+            furi_message_queue_put(cli_shell->storage_event_queue, &cli_event, 0) == FuriStatusOk);
+    }
+}
+
+static void cli_shell_storage_internal_event(FuriEventLoopObject* object, void* context) {
+    CliShell* cli_shell = context;
+    FuriMessageQueue* queue = object;
+    CliShellStorageEvent event;
+    furi_check(furi_message_queue_get(queue, &event, 0) == FuriStatusOk);
+
+    if(event == CliShellStorageEventMount) {
+        cli_enumerate_external_commands(cli_shell->cli);
+    } else if(event == CliShellStorageEventUnmount) {
+        cli_remove_external_commands(cli_shell->cli);
+    } else {
+        furi_crash();
+    }
+}
+
+static void
+    cli_shell_process_parser_result(CliShell* cli_shell, CliAnsiParserResult parse_result) {
+    if(!parse_result.is_done) return;
+    CliKeyCombo key_combo = parse_result.result;
+    if(key_combo.key == CliKeyUnrecognized) return;
+
     for(size_t i = 0; i < CliShellComponentMAX; i++) { // -V1008
         CliShellKeyComboSet* set = component_key_combo_sets[i];
         void* component_context = cli_shell->components[i];
@@ -127,22 +302,13 @@ static void cli_shell_data_available(PipeSide* pipe, void* context) {
     // process ANSI escape sequences
     int c = getchar();
     furi_assert(c >= 0);
-    CliAnsiParserResult parse_result = cli_ansi_parser_feed(cli_shell->ansi_parser, c);
-    if(!parse_result.is_done) return;
-    CliKeyCombo key_combo = parse_result.result;
-    if(key_combo.key == CliKeyUnrecognized) return;
-
-    cli_shell_process_key(cli_shell, key_combo);
+    cli_shell_process_parser_result(cli_shell, cli_ansi_parser_feed(cli_shell->ansi_parser, c));
 }
 
 static void cli_shell_timer_expired(void* context) {
     CliShell* cli_shell = context;
-    CliAnsiParserResult parse_result = cli_ansi_parser_feed_timeout(cli_shell->ansi_parser);
-    if(!parse_result.is_done) return;
-    CliKeyCombo key_combo = parse_result.result;
-    if(key_combo.key == CliKeyUnrecognized) return;
-
-    cli_shell_process_key(cli_shell, key_combo);
+    cli_shell_process_parser_result(
+        cli_shell, cli_ansi_parser_feed_timeout(cli_shell->ansi_parser));
 }
 
 // =======
@@ -155,26 +321,42 @@ static CliShell* cli_shell_alloc(PipeSide* pipe) {
     cli_shell->cli = furi_record_open(RECORD_CLI);
     cli_shell->ansi_parser = cli_ansi_parser_alloc();
     cli_shell->pipe = pipe;
-    pipe_install_as_stdio(cli_shell->pipe);
 
     cli_shell->components[CliShellComponentLine] = cli_shell_line_alloc(cli_shell);
+    cli_shell->components[CliShellComponentCompletions] = cli_shell_completions_alloc(
+        cli_shell->cli, cli_shell, cli_shell->components[CliShellComponentLine]);
 
     cli_shell->event_loop = furi_event_loop_alloc();
     cli_shell->ansi_parsing_timer = furi_event_loop_timer_alloc(
         cli_shell->event_loop, cli_shell_timer_expired, FuriEventLoopTimerTypeOnce, cli_shell);
-    pipe_attach_to_event_loop(cli_shell->pipe, cli_shell->event_loop);
 
-    pipe_set_callback_context(cli_shell->pipe, cli_shell);
-    pipe_set_data_arrived_callback(cli_shell->pipe, cli_shell_data_available, 0);
-    pipe_set_broken_callback(cli_shell->pipe, cli_shell_pipe_broken, 0);
+    cli_shell_install_pipe(cli_shell);
+
+    cli_shell->storage_event_queue = furi_message_queue_alloc(1, sizeof(CliShellStorageEvent));
+    furi_event_loop_subscribe_message_queue(
+        cli_shell->event_loop,
+        cli_shell->storage_event_queue,
+        FuriEventLoopEventIn,
+        cli_shell_storage_internal_event,
+        cli_shell);
+    cli_shell->storage = furi_record_open(RECORD_STORAGE);
+    cli_shell->storage_subscription = furi_pubsub_subscribe(
+        storage_get_pubsub(cli_shell->storage), cli_shell_storage_event, cli_shell);
 
     return cli_shell;
 }
 
 static void cli_shell_free(CliShell* cli_shell) {
+    furi_pubsub_unsubscribe(
+        storage_get_pubsub(cli_shell->storage), cli_shell->storage_subscription);
+    furi_record_close(RECORD_STORAGE);
+    furi_event_loop_unsubscribe(cli_shell->event_loop, cli_shell->storage_event_queue);
+    furi_message_queue_free(cli_shell->storage_event_queue);
+
+    cli_shell_completions_free(cli_shell->components[CliShellComponentCompletions]);
     cli_shell_line_free(cli_shell->components[CliShellComponentLine]);
 
-    pipe_detach_from_event_loop(cli_shell->pipe);
+    cli_shell_detach_pipe(cli_shell);
     furi_event_loop_timer_free(cli_shell->ansi_parsing_timer);
     furi_event_loop_free(cli_shell->event_loop);
     pipe_free(cli_shell->pipe);