feat(console): add support for running commands on separate tasks

Add asynchronous command execution with I/O redirection:
- New esp_console_run_on_task() API to execute commands on FreeRTOS tasks
- Support for custom stdin/stdout/stderr file pointers
- Configurable stack size and priority per command
- Task lifecycle management functions (wait, query status, cleanup)
- Optional CONSOLE_COMMAND_ON_TASK config to enable feature

This enables non-blocking command execution, pipelines, and better
resource management for long-running console commands.

Author: jimmyw

components/console/Kconfig

@@ -7,4 +7,25 @@ menu "Console Library"
             Instead of listing the commands in the order of registration, the help command lists
             the available commands in sorted order, if this option is enabled.
 
+    config CONSOLE_COMMAND_ON_TASK
+        bool "Enable command on task"
+        default n
+        help
+            In addition to run the command on current task, the console can also run commands on a dedicated
+            task. This allows for longer running commands without blocking the console input, pipelines, and
+            keeping the original task stack smaller.
+
+    config CONSOLE_COMMAND_DEFAULT_TASK_STACK_SIZE
+        int "Console default task stack size"
+        default 4096
+        depends on CONSOLE_COMMAND_ON_TASK
+        help
+            Default stack size for the console command task, unless overridden.
+
+    config CONSOLE_COMMAND_DEFAULT_TASK_PRIORITY
+        int "Console default task priority"
+        default 5
+        depends on CONSOLE_COMMAND_ON_TASK
+        help
+            Default priority for the console command task, unless overridden.
 endmenu

components/console/commands.c

@@ -8,10 +8,12 @@
 #include <string.h>
 #include <stdlib.h>
 #include <sys/param.h>
+#include <unistd.h>
 #include "esp_heap_caps.h"
 #include "esp_log.h"
 #include "esp_console.h"
 #include "esp_system.h"
+#include "freertos/idf_additions.h"
 #include "linenoise/linenoise.h"
 #include "argtable3/argtable3.h"
 #include "sys/queue.h"
@@ -41,6 +43,8 @@ static const cmd_item_t *find_command_by_name(const char *name);
 
 static esp_console_help_verbose_level_e s_verbose_level = ESP_CONSOLE_HELP_VERBOSE_LEVEL_1;
 
+
+
 const esp_console_cmd_t *esp_console_get_by_name(const char *name)
 {
     const cmd_item_t *cmd =  find_command_by_name(name);
@@ -262,6 +266,178 @@ esp_err_t esp_console_run(const char *cmdline, int *cmd_ret)
     return ESP_OK;
 }
 
+
+#ifdef CONFIG_CONSOLE_COMMAND_ON_TASK
+
+typedef struct esp_console_task_handle {
+    const cmd_item_t *cmd;       //!< Pointer to the command definition
+    TaskHandle_t task_handle;    //!< Handle of the created task (protected by lock)
+    FILE *_stdin;                //!< Pipe for command input
+    FILE *_stdout;               //!< Pipe for command output
+    FILE *_stderr;               //!< Pipe for command error output
+    int exit_code;               //!< Exit code of the command (protected by lock)
+    _lock_t lock;                //!< Lock to protect task_handle and exit_code
+    size_t argc;                 //!< Number of command line arguments
+    char *argv[0];               //!< Command line arguments (flexible array member)
+} esp_console_task_handle_t;
+
+
+static void task_cmd(void *arg) {
+    esp_console_task_handle_t *task = (esp_console_task_handle_t *)arg;
+
+
+    FILE *old_stdin = __getreent()->_stdin;
+    FILE *old_stdout = __getreent()->_stdout;
+    FILE *old_stderr = __getreent()->_stderr;
+
+    if (task->_stdin)
+        __getreent()->_stdin = task->_stdin;
+    if (task->_stdout)
+        __getreent()->_stdout = task->_stdout;
+    if (task->_stderr)
+        __getreent()->_stderr = task->_stderr;
+
+    int exit_code = -1;
+    if (task->cmd->def.func) {
+        exit_code = task->cmd->def.func(task->argc, task->argv);
+    }
+    if (task->cmd->def.func_w_context) {
+        exit_code = (*task->cmd->def.func_w_context)(task->cmd->def.context, task->argc, task->argv);
+    }
+
+    // Close sockets only if not pointing to standard fds
+    if (task->_stdin) {
+        fclose(task->_stdin);
+        __getreent()->_stdin = old_stdin;
+    }
+    if (task->_stdout) {
+        fclose(task->_stdout);
+        __getreent()->_stdout = old_stdout;
+    }
+    if (task->_stderr) {
+        fclose(task->_stderr);
+        __getreent()->_stderr = old_stderr;
+    }
+
+    __lock_acquire(task->lock);
+    task->exit_code = exit_code;
+    task->task_handle = NULL;
+    __lock_release(task->lock);
+
+    vTaskDelete(NULL);
+}
+
+esp_err_t esp_console_run_on_task(const char *cmdline, FILE *_stdin, FILE *_stdout, FILE *_stderr, esp_console_task_handle_t **out_task)
+{
+    const size_t cmd_len = strlen(cmdline);
+    if (!cmd_len || cmd_len >= s_config.max_cmdline_length) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    // Try to do all memory allocations in one go
+    // Calculate the size of each component for clarity and maintainability
+    const size_t task_struct_size = sizeof(esp_console_task_handle_t); // Size of the task struct
+    const size_t argv_array_size = sizeof(char *) * s_config.max_cmdline_args; // Size of argv array
+    const size_t cmdline_buf_size = cmd_len + 1; // Size of command line buffer (including null terminator)
+    const size_t total_size = task_struct_size + argv_array_size + cmdline_buf_size;
+
+    esp_console_task_handle_t *task = (esp_console_task_handle_t *) heap_caps_calloc(1, total_size, s_config.heap_alloc_caps);
+    if (task == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    // The line buffer is placed after the struct and argv array
+    char *line_buf = (char *) (((char *)task) + task_struct_size + argv_array_size);
+    strlcpy(line_buf, cmdline, cmd_len+1);
+
+    task->argc = esp_console_split_argv(line_buf, task->argv,
+                                         s_config.max_cmdline_args);
+    if (task->argc == 0) {
+        free(task);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    task->exit_code = -1;
+    task->cmd = find_command_by_name(task->argv[0]);
+    if (task->cmd == NULL) {
+        free(task);
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    task->_stdin = _stdin;
+    task->_stdout = _stdout;
+    task->_stderr = _stderr;
+    __lock_init(task->lock);
+
+    uint32_t stack_size = task->cmd->def.stack_size ? task->cmd->def.stack_size : (CONFIG_CONSOLE_COMMAND_DEFAULT_TASK_STACK_SIZE);
+    UBaseType_t priority = task->cmd->def.priority ? task->cmd->def.priority : (CONFIG_CONSOLE_COMMAND_DEFAULT_TASK_PRIORITY);
+    BaseType_t handle = xTaskCreate(&task_cmd, task->argv[0], stack_size, task, priority, &task->task_handle);
+
+    if (handle != pdPASS) {
+        __lock_close(task->lock);
+        free(task);
+        return ESP_ERR_NO_MEM;
+    }
+    *out_task = task;
+
+    return ESP_OK;
+}
+
+void esp_console_task_free(esp_console_task_handle_t *task)
+{
+    __lock_acquire(task->lock);
+    TaskHandle_t handle = task->task_handle;
+    __lock_release(task->lock);
+
+    if (handle) {
+        // Wait for the task to finish before deleting
+        esp_console_wait_task(task, NULL);
+        vTaskDelete(handle);
+
+        __lock_acquire(task->lock);
+        task->task_handle = NULL;
+        __lock_release(task->lock);
+    }
+    __lock_close(task->lock);
+    free(task);
+}
+
+bool esp_console_task_is_running(esp_console_task_handle_t *task)
+{
+    __lock_acquire(task->lock);
+    TaskHandle_t handle = task->task_handle;
+    __lock_release(task->lock);
+
+    if (handle) {
+        return eTaskGetState(handle) != eDeleted;
+    }
+    return false;
+}
+
+void esp_console_wait_task(esp_console_task_handle_t *task, int *cmd_ret)
+{
+    TaskHandle_t handle;
+
+    __lock_acquire(task->lock);
+    handle = task->task_handle;
+    __lock_release(task->lock);
+
+    if (handle) {
+        // Wait until task is done
+        while (eTaskGetState(handle) != eDeleted) {
+            vTaskDelay(10 / portTICK_PERIOD_MS);
+        }
+    }
+
+    if (cmd_ret) {
+        __lock_acquire(task->lock);
+        *cmd_ret = task->exit_code;
+        __lock_release(task->lock);
+    }
+}
+
+#endif // CONFIG_CONSOLE_COMMAND_ON_TASK
+
 static struct {
     struct arg_str *help_cmd;
     struct arg_int *verbose_level;

components/console/esp_console.h

@@ -190,6 +190,18 @@ typedef struct {
      * If not set, the command will not be listed in 'help' output.
      */
     const char *help;
+
+#ifdef CONFIG_CONSOLE_COMMAND_ON_TASK
+    /**
+     * Stack size, if command is run on a separate task
+     */
+    size_t stack_size;
+    /**
+     * Task priority, if command is run on a separate task
+     */
+    UBaseType_t priority;
+#endif
+
     /**
      * Hint text, usually lists possible arguments.
      * If set to NULL, and 'argtable' field is non-NULL, hint will be generated
@@ -491,6 +503,93 @@ esp_err_t esp_console_start_repl(esp_console_repl_t *repl);
  */
 esp_err_t esp_console_stop_repl(esp_console_repl_t *repl);
 
+
+#ifdef CONFIG_CONSOLE_COMMAND_ON_TASK
+
+/**
+ * @brief Opaque handle for a console task
+ */
+typedef struct esp_console_task_handle esp_console_task_handle_t;
+
+/**
+ * @brief Run a console command on a separate FreeRTOS task
+ *
+ * This function executes a console command in a new FreeRTOS task, allowing
+ * asynchronous execution with I/O redirection via file pointers.
+ *
+ * @param[in] cmdline Command line string (command name followed by arguments)
+ * @param[in] _stdin FILE pointer for standard input (or NULL to use default)
+ * @param[in] _stdout FILE pointer for standard output (or NULL to use default)
+ * @param[in] _stderr FILE pointer for standard error (or NULL to use default)
+ * @param[out] out_task Pointer to receive the task handle. Use this handle with
+ *                      esp_console_task_is_running() and esp_console_wait_task().
+ *                      Must be freed with esp_console_task_free() when done.
+ *
+ * @note The task will run with the stack size and priority specified in the
+ *       command's esp_console_cmd_t structure, or defaults if not specified.
+ * @note The provided file pointers will be closed when the task completes,
+ *       allowing callers to be notified of task completion (e.g., via pipe EOF).
+ * @note The caller is responsible for creating any pipes and managing file descriptors.
+ *
+ * @return
+ *      - ESP_OK on success (task created successfully)
+ *      - ESP_ERR_INVALID_STATE if esp_console_init wasn't called
+ *      - ESP_ERR_INVALID_ARG if the command line is empty or only whitespace
+ *      - ESP_ERR_NOT_FOUND if command with given name wasn't registered
+ *      - ESP_ERR_NO_MEM if out of memory
+ */
+esp_err_t esp_console_run_on_task(const char *cmdline, FILE *_stdin, FILE *_stdout, FILE *_stderr, esp_console_task_handle_t **out_task);
+
+/**
+ * @brief Free resources associated with a console task
+ *
+ * This function frees the memory allocated for the task handle and associated
+ * resources. If the task is still running, it will be deleted.
+ *
+ * @param[in] task Task handle returned by esp_console_run_on_task()
+ *
+ * @note Always call this function after you're done with a task handle to
+ *       prevent memory leaks.
+ * @note It's safe to call this on a task that has already finished.
+ */
+void esp_console_task_free(esp_console_task_handle_t *task);
+
+/**
+ * @brief Wait for a console task to complete
+ *
+ * This function blocks until the specified console task has finished execution.
+ *
+ * @param[in] task Task handle returned by esp_console_run_on_task()
+ * @param[out] cmd_ret Pointer to store the command's return code. Can be NULL
+ *                     if return code is not needed.
+ *
+ * @note This function will block until the task completes. Use
+ *       esp_console_task_is_running() for non-blocking status checks.
+ * @note The task handle is not freed by this function, so call
+ *       esp_console_task_free() afterwards.
+ */
+void esp_console_wait_task(esp_console_task_handle_t *task, int *cmd_ret);
+
+/**
+ * @brief Check if a console task is still running
+ *
+ * This function provides a non-blocking way to check the status of a console task.
+ *
+ * @param[in] task Task handle returned by esp_console_run_on_task()
+ *
+ * @return
+ *      - true if the task is still running
+ *      - false if the task has completed or the handle is invalid
+ *
+ * @note This function does not block and returns immediately.
+ * @note Use this in a loop with vTaskDelay() to poll for task completion, or
+ *       use esp_console_wait_task() for blocking wait.
+ */
+bool esp_console_task_is_running(esp_console_task_handle_t *task);
+
+#endif // CONFIG_CONSOLE_COMMAND_ON_TASK
+
+
 #ifdef __cplusplus
 }
 #endif