ucode-mod-uline: add package for ucode terminal line editing

It provides a ucode module with similar functionality as libreadline,
however with much smaller code and no dependencies aside from ucode and
libubox.
It also provides shell-style parsing/escaping code useful for building
a CLI.

Signed-off-by: Felix Fietkau <[email protected]>

package/utils/ucode-mod-uline/Makefile

@@ -0,0 +1,32 @@
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=ucode-mod-uline
+PKG_RELEASE:=$(AUTORELEASE)
+PKG_LICENSE:=GPL-2.0-or-later
+PKG_MAINTAINER:=Felix Fietkau <[email protected]>
+
+include $(INCLUDE_DIR)/package.mk
+include $(INCLUDE_DIR)/cmake.mk
+
+CMAKE_INSTALL := 1
+
+define Package/ucode-mod-uline
+  SECTION:=utils
+  CATEGORY:=Utilities
+  TITLE:=ucode module for terminal line editing
+  DEPENDS:=+libucode +libubox
+endef
+
+CMAKE_OPTIONS += -DUSE_SYSTEM_WCHAR=ON
+
+define Package/ucode-mod-uline/description
+This module provides similar functionality as libreadline for ucode, without
+depending on other libraries like ncurses.
+endef
+
+define Package/ucode-mod-uline/install
+	$(INSTALL_DIR) $(1)/usr/lib/ucode
+	$(CP) $(PKG_INSTALL_DIR)/usr/lib/ucode/uline.so $(1)/usr/lib/ucode/
+endef
+
+$(eval $(call BuildPackage,ucode-mod-uline))

package/utils/ucode-mod-uline/src/CMakeLists.txt

@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.13)
+
+PROJECT(uline C)
+ADD_DEFINITIONS(-Os -ggdb -Wall -Werror --std=gnu99 -ffunction-sections -fwrapv -D_GNU_SOURCE -Wno-error=unused-function -Wno-parentheses -Wno-sign-compare)
+
+OPTION(USE_SYSTEM_WCHAR "Use system multibyte implementation for UTF-8" OFF)
+IF(CMAKE_C_COMPILER_VERSION VERSION_GREATER 6)
+	ADD_DEFINITIONS(-Wextra -Werror=implicit-function-declaration)
+	ADD_DEFINITIONS(-Wformat -Werror=format-security -Werror=format-nonliteral)
+ENDIF()
+ADD_DEFINITIONS(-Wmissing-declarations -Wno-error=unused-variable -Wno-unused-parameter)
+
+IF(APPLE)
+  SET(UCODE_MODULE_LINK_OPTIONS "LINKER:-undefined,dynamic_lookup")
+ELSE()
+  SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "-Wl,--gc-sections")
+ENDIF()
+
+IF(DEBUG)
+  ADD_DEFINITIONS(-DDEBUG -g3 -O0)
+ELSE()
+  ADD_DEFINITIONS(-DNDEBUG)
+ENDIF()
+
+FIND_LIBRARY(ucode NAMES ucode)
+FIND_LIBRARY(libubox NAMES ubox)
+FIND_PATH(uloop_include_dir NAMES libubox/uloop.h)
+FIND_PATH(ucode_include_dir NAMES ucode/module.h)
+INCLUDE_DIRECTORIES(${ucode_include_dir} ${uloop_include_dir})
+
+ADD_LIBRARY(uline STATIC uline.c utf8.c vt100.c)
+set_property(TARGET uline PROPERTY POSITION_INDEPENDENT_CODE ON)
+IF(USE_SYSTEM_WCHAR)
+  TARGET_COMPILE_DEFINITIONS(uline PUBLIC USE_SYSTEM_WCHAR)
+ENDIF()
+
+ADD_LIBRARY(uline_lib MODULE ucode.c)
+SET_TARGET_PROPERTIES(uline_lib PROPERTIES OUTPUT_NAME uline PREFIX "")
+TARGET_LINK_OPTIONS(uline_lib PRIVATE ${UCODE_MODULE_LINK_OPTIONS})
+TARGET_LINK_LIBRARIES(uline_lib uline ${libubox})
+
+install(FILES uline.h DESTINATION include)
+INSTALL(TARGETS uline LIBRARY DESTINATION lib)
+INSTALL(TARGETS uline_lib LIBRARY DESTINATION lib/ucode)

package/utils/ucode-mod-uline/src/private.h

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: ISC
+/*
+ * Copyright (C) 2025 Felix Fietkau <[email protected]>
+ */
+#ifndef __EDITLINE_PRIVATE_H
+#define __EDITLINE_PRIVATE_H
+
+#include <stdio.h>
+
+#define KEY_NUL	0	// ^@ Null character
+#define KEY_SOH	1	// ^A Start of heading, = console interrupt
+#define KEY_STX	2	// ^B Start of text, maintenance mode on HP console
+#define KEY_ETX	3	// ^C End of text
+#define KEY_EOT	4	// ^D End of transmission, not the same as ETB
+#define KEY_ENQ	5	// ^E Enquiry, goes with ACK; old HP flow control
+#define KEY_ACK	6	// ^F Acknowledge, clears ENQ logon hand
+#define KEY_BEL	7	// ^G Bell, rings the bell
+#define KEY_BS	8	// ^H Backspace, works on HP terminals/computers
+#define KEY_HT	9	// ^I Horizontal tab, move to next tab stop
+#define KEY_LF	10	// ^J Line Feed
+#define KEY_VT	11	// ^K Vertical tab
+#define KEY_FF	12	// ^L Form Feed, page eject
+#define KEY_CR	13	// ^M Carriage Return
+#define KEY_SO	14	// ^N Shift Out, alternate character set
+#define KEY_SI	15	// ^O Shift In, resume defaultn character set
+#define KEY_DLE	16	// ^P Data link escape
+#define KEY_DC1	17	// ^Q XON, with XOFF to pause listings; "okay to send"
+#define KEY_DC2	18	// ^R Device control 2, block-mode flow control
+#define KEY_DC3	19	// ^S XOFF, with XON is TERM=18 flow control
+#define KEY_DC4	20	// ^T Device control 4
+#define KEY_NAK	21	// ^U Negative acknowledge
+#define KEY_SYN	22	// ^V Synchronous idle
+#define KEY_ETB	23	// ^W End transmission block, not the same as EOT
+#define KEY_CAN	24	// ^X Cancel line, MPE echoes !!!
+#define KEY_EM	25	// ^Y End of medium, Control-Y interrupt
+#define KEY_SUB	26	// ^Z Substitute
+#define KEY_ESC	27	// ^[ Escape, next character is not echoed
+#define KEY_FS	28	// ^\ File separator
+#define KEY_GS	29	// ^] Group separator
+#define KEY_RS	30	// ^^ Record separator, block-mode terminator
+#define KEY_US	31	// ^_ Unit separator
+#define KEY_DEL	127	// Delete (not a real control character)
+
+// Types of escape code
+enum vt100_escape {
+	VT100_INCOMPLETE,
+	VT100_UNKNOWN,
+	VT100_IGNORE,
+	VT100_CURSOR_UP,
+	VT100_CURSOR_DOWN,
+	VT100_CURSOR_LEFT,
+	VT100_CURSOR_WORD_LEFT,
+	VT100_CURSOR_RIGHT,
+	VT100_CURSOR_WORD_RIGHT,
+	VT100_HOME,
+	VT100_END,
+	VT100_INSERT,
+	VT100_DELETE,
+	VT100_DELETE_LEFT,
+	VT100_DELETE_LEFT_WORD,
+	VT100_PAGE_UP,
+	VT100_PAGE_DOWN,
+};
+
+ssize_t utf8_nsyms(const char *str, size_t len);
+enum vt100_escape vt100_esc_decode(const char *str);
+
+// helpers:
+void __vt100_csi_num(FILE *out, int num, char code);
+void __vt100_csi2(FILE *out, char c1, char c2);
+void __vt100_esc(FILE *out, char c);
+static inline void __vt100_sgr(FILE *out, int code)
+{
+	__vt100_csi2(out, code + '0', 'm');
+}
+
+
+static inline void vt100_attr_reset(FILE *out)
+{
+	__vt100_sgr(out, 0);
+}
+
+static inline void vt100_attr_bright(FILE *out)
+{
+	__vt100_sgr(out, 1);
+}
+
+static inline void vt100_attr_dim(FILE *out)
+{
+	__vt100_sgr(out, 2);
+}
+
+static inline void vt100_attr_underscore(FILE *out)
+{
+	__vt100_sgr(out, 4);
+}
+
+static inline void vt100_attr_blink(FILE *out)
+{
+	__vt100_sgr(out, 5);
+}
+
+static inline void vt100_attr_reverse(FILE *out)
+{
+	__vt100_sgr(out, 7);
+}
+
+static inline void vt100_attr_hidden(FILE *out)
+{
+	__vt100_sgr(out, 8);
+}
+
+static inline void vt100_erase_line(FILE *out)
+{
+	__vt100_csi2(out, '2', 'K');
+}
+
+static inline void vt100_clear_screen(FILE *out)
+{
+	__vt100_csi2(out, '2', 'J');
+}
+
+static inline void vt100_cursor_save(FILE *out)
+{
+	__vt100_esc(out, '7');
+}
+
+static inline void vt100_cursor_restore(FILE *out)
+{
+	__vt100_esc(out, '8');
+}
+
+static inline void vt100_scroll_up(FILE *out)
+{
+	__vt100_esc(out, 'D');
+}
+
+static inline void vt100_scroll_down(FILE *out)
+{
+	__vt100_esc(out, 'M');
+}
+
+static inline void vt100_next_line(FILE *out)
+{
+	__vt100_esc(out, 'E');
+}
+
+static inline void vt100_cursor_up(FILE *out, int count)
+{
+	__vt100_csi_num(out, count, 'A');
+}
+
+static inline void vt100_cursor_down(FILE *out, int count)
+{
+	__vt100_csi_num(out, count, 'B');
+}
+
+static inline void vt100_cursor_forward(FILE *out, int count)
+{
+	__vt100_csi_num(out, count, 'C');
+}
+
+static inline void vt100_cursor_back(FILE *out, int count)
+{
+	__vt100_csi_num(out, count, 'D');
+}
+
+static inline void vt100_cursor_home(FILE *out)
+{
+	__vt100_csi2(out, 'H', 0);
+}
+
+static inline void vt100_erase(FILE *out, int count)
+{
+	__vt100_csi_num(out, count, 'P');
+}
+
+static inline void vt100_erase_down(FILE *out)
+{
+	__vt100_csi2(out, 'J', 0);
+}
+
+static inline void vt100_erase_right(FILE *out)
+{
+	__vt100_csi2(out, 'K', 0);
+}
+
+static inline void vt100_ding(FILE *out)
+{
+	fputc(7, out);
+	fflush(out);
+}
+
+#endif

package/utils/ucode-mod-uline/src/ucode.c

@@ -0,0 +1,905 @@
+// SPDX-License-Identifier: ISC
+/*
+ * Copyright (C) 2025 Felix Fietkau <[email protected]>
+ */
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <poll.h>
+
+#include <ucode/module.h>
+#include <libubox/list.h>
+#include <libubox/uloop.h>
+
+#include "uline.h"
+
+static uc_value_t *registry;
+static uc_resource_type_t *state_type, *argp_type;
+
+enum {
+	STATE_RES,
+	STATE_CB,
+	STATE_INPUT,
+	STATE_OUTPUT,
+	STATE_POLL_CB,
+};
+
+struct uc_uline_state {
+	struct uloop_fd fd;
+
+	struct uline_state s;
+	int registry_index;
+
+	uc_vm_t *vm;
+	uc_value_t *state, *cb, *res, *poll_cb;
+
+	uc_value_t *line;
+
+	uint32_t input_mask[256 / 32];
+};
+
+struct uc_arg_parser {
+	char line_sep;
+};
+
+static unsigned int
+registry_set(uc_vm_t *vm, uc_value_t *val)
+{
+	uc_value_t *registry;
+	size_t i, len;
+
+	registry = uc_vm_registry_get(vm, "uline.registry");
+	len = ucv_array_length(registry);
+	for (i = 0; i < len; i++)
+		if (ucv_array_get(registry, i) == NULL)
+			break;
+
+	ucv_array_set(registry, i, ucv_get(val));
+	return i;
+}
+
+static uc_value_t *
+uc_uline_poll(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+	uc_value_t *val;
+
+	if (!us)
+		return NULL;
+
+	uline_poll(&us->s);
+	val = us->line;
+	us->line = NULL;
+
+	return val;
+}
+
+static uc_value_t *
+uc_uline_poll_key(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+	uc_value_t *timeout_arg = uc_fn_arg(0);
+	struct pollfd pfd = {};
+	int timeout, len;
+	char c;
+
+	if (!us)
+		return NULL;
+
+	if (ucv_type(timeout_arg) == UC_INTEGER)
+		timeout = ucv_int64_get(timeout_arg);
+	else
+		timeout = -1;
+
+	pfd.fd = us->s.input;
+	pfd.events = POLLIN;
+	poll(&pfd, 1, timeout);
+	if (!(pfd.revents & POLLIN))
+		return NULL;
+
+	do {
+		len = read(pfd.fd, &c, 1);
+	} while (len < 0 && errno == EINTR);
+
+	if (len != 1)
+		return NULL;
+
+	return ucv_string_new_length(&c, 1);
+}
+
+static uc_value_t *
+uc_uline_poll_stop(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+
+	if (!us)
+		return NULL;
+
+	us->s.stop = true;
+
+	return NULL;
+}
+
+static uc_value_t *
+uc_uline_get_window(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+	uc_value_t *val;
+
+	if (!us)
+		return NULL;
+
+	val = ucv_object_new(vm);
+	ucv_object_add(val, "x", ucv_int64_new(us->s.cols));
+	ucv_object_add(val, "y", ucv_int64_new(us->s.rows));
+	return val;
+}
+
+static uc_value_t *
+uc_uline_get_line(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+	uc_value_t *line2 = uc_fn_arg(0);
+	uc_value_t *state, *val;
+	const char *line;
+	size_t len;
+
+	if (!us)
+		return NULL;
+
+	state = ucv_object_new(vm);
+	if (ucv_is_truish(line2))
+		uline_get_line2(&us->s, &line, &len);
+	else
+		uline_get_line(&us->s, &line, &len);
+	val = ucv_string_new_length(line, len);
+	ucv_object_add(state, "line", ucv_get(val));
+	ucv_object_add(state, "pos", ucv_int64_new(us->s.line.pos));
+
+	return state;
+}
+
+static uc_value_t *
+uc_uline_set_state(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+	uc_value_t *state = uc_fn_arg(0);
+	uc_value_t *arg;
+	bool found;
+
+	if (!us || ucv_type(state) != UC_OBJECT)
+		return NULL;
+
+	if ((arg = ucv_object_get(state, "prompt", NULL)) != NULL) {
+	    if (ucv_type(arg) != UC_STRING)
+			return NULL;
+
+		uline_set_prompt(&us->s, ucv_string_get(arg));
+	}
+
+	if ((arg = ucv_object_get(state, "line", NULL)) != NULL) {
+	    if (ucv_type(arg) != UC_STRING)
+			return NULL;
+
+		uline_set_line(&us->s, ucv_string_get(arg), ucv_string_length(arg));
+	}
+
+	if ((arg = ucv_object_get(state, "pos", NULL)) != NULL) {
+		if (ucv_type(arg) != UC_INTEGER)
+			return NULL;
+
+		uline_set_cursor(&us->s, ucv_int64_get(arg));
+	}
+
+	arg = ucv_object_get(state, "line2_prompt", &found);
+	if (found) {
+		if (!arg)
+			uline_set_line2_prompt(&us->s, NULL);
+		else if (ucv_type(arg) == UC_STRING)
+			uline_set_line2_prompt(&us->s, ucv_string_get(arg));
+		else
+			return NULL;
+	}
+
+	if ((arg = ucv_object_get(state, "line2", NULL)) != NULL) {
+	    if (ucv_type(arg) != UC_STRING)
+			return NULL;
+
+		uline_set_line2(&us->s, ucv_string_get(arg), ucv_string_length(arg));
+	}
+
+	if ((arg = ucv_object_get(state, "line2_pos", NULL)) != NULL) {
+		if (ucv_type(arg) != UC_INTEGER)
+			return NULL;
+
+		uline_set_line2_cursor(&us->s, ucv_int64_get(arg));
+	}
+
+	return ucv_boolean_new(true);
+}
+
+static uc_value_t *
+uc_uline_set_hint(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+	uc_value_t *arg = uc_fn_arg(0);
+
+	if (!us || ucv_type(arg) != UC_STRING)
+		return NULL;
+
+	uline_set_hint(&us->s, ucv_string_get(arg), ucv_string_length(arg));
+
+	return ucv_boolean_new(true);
+}
+
+static uc_value_t *
+uc_uline_set_uloop(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+	uc_value_t *cb = uc_fn_arg(0);
+
+	if (!us || (cb && !ucv_is_callable(cb)))
+		return NULL;
+
+	us->poll_cb = cb;
+	ucv_array_set(us->state, STATE_POLL_CB, ucv_get(cb));
+	if (cb) {
+		uloop_fd_add(&us->fd, ULOOP_READ);
+		us->fd.cb(&us->fd, 0);
+	} else {
+		uloop_fd_delete(&us->fd);
+	}
+
+	return ucv_boolean_new(true);
+}
+
+static uc_value_t *
+uc_uline_reset_key_input(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+
+	us->s.repeat_char = 0;
+
+	return ucv_boolean_new(true);
+}
+
+static uc_value_t *
+uc_uline_hide_prompt(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+
+	if (!us)
+		return NULL;
+
+	uline_hide_prompt(&us->s);
+
+	return ucv_boolean_new(true);
+}
+
+static uc_value_t *
+uc_uline_refresh_prompt(uc_vm_t *vm, size_t nargs)
+{
+	struct uc_uline_state *us = uc_fn_thisval("uline.state");
+
+	if (!us)
+		return NULL;
+
+	uline_refresh_prompt(&us->s);
+
+	return ucv_boolean_new(true);
+}
+
+static bool
+cb_prepare(struct uc_uline_state *us, const char *name)
+{
+	uc_value_t *func;
+
+	func = ucv_object_get(us->cb, name, NULL);
+	if (!func)
+		return false;
+
+	uc_vm_stack_push(us->vm, ucv_get(us->res));
+	uc_vm_stack_push(us->vm, ucv_get(func));
+	return true;
+}
+
+static uc_value_t *
+cb_call_ret(struct uc_uline_state *us, size_t args, ...)
+{
+	va_list ap;
+
+	va_start(ap, args);
+	for (size_t i = 0; i < args; i++)
+		uc_vm_stack_push(us->vm, ucv_get(va_arg(ap, void *)));
+	va_end(ap);
+
+	if (uc_vm_call(us->vm, true, args) == EXCEPTION_NONE)
+		return uc_vm_stack_pop(us->vm);
+
+	return NULL;
+}
+#define cb_call(...) ucv_put(cb_call_ret(__VA_ARGS__))
+
+static bool
+uc_uline_cb_line(struct uline_state *s, const char *str, size_t len)
+{
+	struct uc_uline_state *us = container_of(s, struct uc_uline_state, s);
+	bool complete = true;
+	uc_value_t *ret;
+
+	if (cb_prepare(us, "line_check")) {
+		ret = cb_call_ret(us, 1, ucv_string_new_length(str, len));
+		complete = ucv_is_truish(ret);
+		ucv_put(ret);
+	}
+
+	s->stop = complete;
+	if (complete)
+		us->line = ucv_string_new_length(str, len);
+
+	return complete;
+}
+
+static void
+uc_uline_cb_event(struct uline_state *s, enum uline_event ev)
+{
+	struct uc_uline_state *us = container_of(s, struct uc_uline_state, s);
+	static const char * const ev_types[] = {
+		[EDITLINE_EV_CURSOR_UP] = "cursor_up",
+		[EDITLINE_EV_CURSOR_DOWN] = "cursor_down",
+		[EDITLINE_EV_WINDOW_CHANGED] = "window_changed",
+		[EDITLINE_EV_EOF] = "eof",
+		[EDITLINE_EV_INTERRUPT] = "interrupt",
+	};
+
+	if (ev > ARRAY_SIZE(ev_types) || !ev_types[ev])
+		return;
+
+	if (!cb_prepare(us, ev_types[ev]))
+		return;
+
+	if (ev == EDITLINE_EV_WINDOW_CHANGED)
+		cb_call(us, 2, ucv_int64_new(s->cols), ucv_int64_new(s->rows));
+	else
+		cb_call(us, 0);
+}
+
+static void uc_uline_poll_cb(struct uloop_fd *fd, unsigned int events)
+{
+	struct uc_uline_state *us = container_of(fd, struct uc_uline_state, fd);
+	uc_value_t *val;
+
+	while (!uloop_cancelled && us->poll_cb) {
+		uline_poll(&us->s);
+
+		val = us->line;
+		if (!val)
+			break;
+
+		us->line = NULL;
+		if (!ucv_is_callable(us->poll_cb))
+			return;
+
+		uc_vm_stack_push(us->vm, ucv_get(us->res));
+		uc_vm_stack_push(us->vm, ucv_get(us->poll_cb));
+		cb_call(us, 1, val);
+	}
+}
+
+static bool
+uc_uline_cb_key_input(struct uline_state *s, unsigned char c, unsigned int count)
+{
+	struct uc_uline_state *us = container_of(s, struct uc_uline_state, s);
+	uc_value_t *ret;
+	bool retval;
+
+	if (!(us->input_mask[c / 32] & (1 << (c % 32))))
+		return false;
+
+	if (!cb_prepare(us, "key_input"))
+		return false;
+
+	ret = cb_call_ret(us, 2, ucv_string_new_length((char *)&c, 1), ucv_int64_new(count));
+	retval = ucv_is_truish(ret);
+	ucv_put(ret);
+
+	return retval;
+}
+
+static void
+uc_uline_cb_line2_update(struct uline_state *s, const char *str, size_t len)
+{
+	struct uc_uline_state *us = container_of(s, struct uc_uline_state, s);
+
+	if (cb_prepare(us, "line2_update"))
+		cb_call(us, 1, ucv_string_new_length(str, len));
+}
+
+static bool
+uc_uline_cb_line2_cursor(struct uline_state *s)
+{
+	struct uc_uline_state *us = container_of(s, struct uc_uline_state, s);
+	uc_value_t *retval;
+	bool ret = true;
+
+	if (cb_prepare(us, "line2_cursor")) {
+		retval = cb_call_ret(us, 0);
+		ret = ucv_is_truish(retval);
+		ucv_put(retval);
+	}
+
+	return ret;
+}
+
+static bool
+uc_uline_cb_line2_newline(struct uline_state *s, const char *str, size_t len)
+{
+	struct uc_uline_state *us = container_of(s, struct uc_uline_state, s);
+	uc_value_t *retval;
+	bool ret = false;
+
+	if (cb_prepare(us, "line2_newline")) {
+		retval = cb_call_ret(us, 1, ucv_string_new_length(str, len));
+		ret = ucv_is_truish(retval);
+		ucv_put(retval);
+	}
+
+	return ret;
+}
+
+static uc_value_t *
+uc_uline_new(uc_vm_t *vm, size_t nargs)
+{
+	static const struct uline_cb uline_cb = {
+#define _CB(_type) ._type = uc_uline_cb_##_type
+		_CB(key_input),
+		_CB(line),
+		_CB(event),
+		_CB(line2_update),
+		_CB(line2_cursor),
+		_CB(line2_newline),
+#undef _CB
+	};
+	uc_value_t *data = uc_fn_arg(0);
+	struct uc_uline_state *us;
+	FILE *input, *output;
+	uc_value_t *arg, *cb, *state, *res;
+
+	if (ucv_type(data) != UC_OBJECT)
+		return NULL;
+
+	cb = ucv_object_get(data, "cb", NULL);
+	if (ucv_type(cb) != UC_OBJECT)
+		return NULL;
+
+	state = ucv_array_new(vm);
+	ucv_array_set(state, 0, ucv_get(cb));
+	if ((arg = ucv_object_get(data, "input", NULL)) != NULL) {
+		input = ucv_resource_data(arg, "fs.file");
+		ucv_array_set(state, STATE_INPUT, ucv_get(arg));
+	} else {
+		input = stdin;
+	}
+
+	if ((arg = ucv_object_get(data, "output", NULL)) != NULL) {
+		output = ucv_resource_data(arg, "fs.file");
+		ucv_array_set(state, STATE_OUTPUT, ucv_get(arg));
+	} else {
+		output = stdout;
+	}
+
+	if (!input || !output) {
+		input = output = NULL;
+		return NULL;
+	}
+
+	us = calloc(1, sizeof(*us));
+	us->vm = vm;
+	us->state = ucv_array_new(vm);
+	ucv_array_set(us->state, STATE_CB, ucv_get(cb));
+	us->cb = cb;
+	us->registry_index = registry_set(vm, state);
+
+	if ((arg = ucv_object_get(data, "key_input_list", NULL)) != NULL) {
+		uc_value_t *val;
+		size_t len;
+
+		if (ucv_type(arg) != UC_ARRAY)
+			goto free;
+
+		len = ucv_array_length(arg);
+		for (size_t i = 0; i < len; i++) {
+			unsigned char c;
+
+			val = ucv_array_get(arg, i);
+			if (ucv_type(val) != UC_STRING || ucv_string_length(val) != 1)
+				goto free;
+
+			c = ucv_string_get(val)[0];
+			us->input_mask[c / 32] |= 1 << (c % 32);
+		}
+	}
+
+	res = ucv_resource_new(state_type, us);
+	ucv_array_set(us->state, STATE_RES, ucv_get(res));
+	us->res = res;
+	us->fd.fd = fileno(input);
+	us->fd.cb = uc_uline_poll_cb;
+
+	uline_init(&us->s, &uline_cb, us->fd.fd, output, true);
+
+	return res;
+
+free:
+	free(us);
+	return NULL;
+}
+
+static void free_state(void *ptr)
+{
+	struct uc_uline_state *us = ptr;
+	uc_value_t *registry;
+
+	if (!us)
+		return;
+
+	registry = uc_vm_registry_get(us->vm, "uline.registry");
+	ucv_array_set(registry, us->registry_index, NULL);
+	uline_free(&us->s);
+	free(us);
+}
+
+static uc_value_t *
+uc_uline_close(uc_vm_t *vm, size_t nargs)
+{
+	struct uline_state **s = uc_fn_this("uline.state");
+
+	if (!s || !*s)
+		return NULL;
+
+	free_state(*s);
+	*s = NULL;
+
+	return NULL;
+}
+
+static bool
+skip_space(const char **str, const char *end)
+{
+	while (*str < end && isspace(**str))
+		(*str)++;
+	return *str < end;
+}
+
+static void
+add_str(uc_stringbuf_t **buf, const char *str, const char *next)
+{
+	if (str == next)
+		return;
+
+	if (!*buf)
+		*buf = ucv_stringbuf_new();
+	ucv_stringbuf_addstr(*buf, str, next - str);
+}
+
+static void
+uc_uline_add_pos(uc_vm_t *vm, uc_value_t *list, ssize_t start, ssize_t end)
+{
+	uc_value_t *val = ucv_array_new(vm);
+	ucv_array_push(val, ucv_int64_new(start));
+	ucv_array_push(val, ucv_int64_new(end));
+	ucv_array_push(list, ucv_get(val));
+}
+
+static uc_value_t *
+uc_uline_parse_args(uc_vm_t *vm, size_t nargs, bool check)
+{
+	struct uc_arg_parser *argp = uc_fn_thisval("uline.argp");
+	uc_value_t *list = NULL, *pos_list = NULL;
+	uc_value_t *args = NULL, *pos_args = NULL;
+	uc_value_t *str_arg = uc_fn_arg(0);
+	uc_stringbuf_t *buf = NULL;
+	uc_value_t *missing = NULL;
+	uc_value_t *ret;
+	const char *start, *str, *end;
+	ssize_t start_idx = -1, end_idx = 0;
+	enum {
+		UNQUOTED,
+		BACKSLASH,
+		SINGLE_QUOTE,
+		DOUBLE_QUOTE,
+		DOUBLE_QUOTE_BACKSLASH,
+	} state = UNQUOTED;
+	static const char * const state_str[] = {
+		[BACKSLASH] = "\\",
+		[SINGLE_QUOTE] = "'",
+		[DOUBLE_QUOTE] = "\"",
+		[DOUBLE_QUOTE_BACKSLASH] = "\\\"",
+	};
+#define UNQUOTE_TOKENS " \t\r\n'\"\\"
+	char unquote_tok[] = UNQUOTE_TOKENS "\x00";
+	unquote_tok[strlen(UNQUOTE_TOKENS)] = argp->line_sep;
+
+	if (!argp || ucv_type(str_arg) != UC_STRING)
+		return NULL;
+
+	if (!check) {
+		list = ucv_array_new(vm);
+		pos_list = ucv_array_new(vm);
+		if (argp->line_sep) {
+			args = ucv_array_new(vm);
+			pos_args = ucv_array_new(vm);
+			ucv_array_push(args, ucv_get(list));
+			ucv_array_push(pos_args, ucv_get(pos_list));
+		} else {
+			args = list;
+			pos_args = pos_list;
+		}
+	}
+
+	start = str = ucv_string_get(str_arg);
+	end = str + ucv_string_length(str_arg);
+	skip_space(&str, end);
+
+	while (*str && str < end) {
+		const char *next;
+
+		switch (state) {
+		case UNQUOTED:
+			if (isspace(*str)) {
+				skip_space(&str, end);
+				if (!buf)
+					continue;
+
+				ucv_array_push(list, ucv_stringbuf_finish(buf));
+				uc_uline_add_pos(vm, pos_list, start_idx, end_idx);
+				start_idx = -1;
+				buf = NULL;
+				continue;
+			}
+
+			if (start_idx < 0)
+				start_idx = str - start;
+			next = str + strcspn(str, unquote_tok);
+			if (list)
+				add_str(&buf, str, next);
+			str = next;
+			end_idx = str - start;
+
+			switch (*str) {
+			case 0:
+				continue;
+			case '\'':
+				state = SINGLE_QUOTE;
+				break;
+			case '"':
+				state = DOUBLE_QUOTE;
+				break;
+			case '\\':
+				state = BACKSLASH;
+				break;
+			default:
+				if (argp->line_sep &&
+				    *str == argp->line_sep) {
+					str++;
+					if (list) {
+						if (buf) {
+							ucv_array_push(list, ucv_stringbuf_finish(buf));
+							uc_uline_add_pos(vm, pos_list, start_idx, end_idx);
+							start_idx = -1;
+						}
+
+						buf = NULL;
+						list = ucv_array_new(vm);
+						ucv_array_push(args, ucv_get(list));
+
+						pos_list = ucv_array_new(vm);
+						ucv_array_push(pos_args, ucv_get(pos_list));
+					}
+				}
+				continue;
+			}
+			if (!buf)
+				buf = ucv_stringbuf_new();
+			str++;
+			break;
+
+		case BACKSLASH:
+		case DOUBLE_QUOTE_BACKSLASH:
+			if (start_idx < 0)
+				start_idx = str - start;
+			if (list && *str != '\n')
+				add_str(&buf, str, str + 1);
+			str++;
+			state--;
+			end_idx = str - start;
+			break;
+
+		case SINGLE_QUOTE:
+			if (start_idx < 0)
+				start_idx = str - start;
+			next = str + strcspn(str, "'");
+			if (list)
+				add_str(&buf, str, next);
+			str = next;
+
+			if (*str == '\'') {
+				state = UNQUOTED;
+				str++;
+			}
+			end_idx = str - start;
+			break;
+
+		case DOUBLE_QUOTE:
+			if (start_idx < 0)
+				start_idx = str - start;
+			next = str + strcspn(str, "\"\\");
+			if (list)
+				add_str(&buf, str, next);
+			str = next;
+
+			if (*str == '"') {
+				state = UNQUOTED;
+				str++;
+			} else if (*str == '\\') {
+				state = DOUBLE_QUOTE_BACKSLASH;
+				str++;
+			}
+			end_idx = str - start;
+		}
+	}
+
+	if (buf) {
+		ucv_array_push(list, ucv_get(ucv_stringbuf_finish(buf)));
+		uc_uline_add_pos(vm, pos_list, start_idx, end_idx);
+	}
+
+	if (state_str[state])
+		missing = ucv_string_new(state_str[state]);
+
+	if (!list)
+		return missing;
+
+	ret = ucv_object_new(vm);
+	ucv_object_add(ret, "args", ucv_get(args));
+	ucv_object_add(ret, "pos", ucv_get(pos_args));
+	if (missing)
+		ucv_object_add(ret, "missing", ucv_get(missing));
+
+	return ret;
+}
+
+static uc_value_t *
+uc_uline_arg_parser(uc_vm_t *vm, size_t nargs)
+{
+	uc_value_t *opts = uc_fn_arg(0);
+	struct uc_arg_parser *argp;
+	uc_value_t *a;
+	char sep = 0;
+
+	if ((a = ucv_object_get(opts, "line_separator", NULL)) != NULL) {
+		if (ucv_type(a) != UC_STRING || ucv_string_length(a) != 1)
+			return NULL;
+
+		sep = ucv_string_get(a)[0];
+	}
+
+	argp = calloc(1, sizeof(*argp));
+	argp->line_sep = sep;
+
+	return ucv_resource_new(argp_type, argp);
+}
+
+static uc_value_t *
+uc_uline_argp_parse(uc_vm_t *vm, size_t nargs)
+{
+	return uc_uline_parse_args(vm, nargs, false);
+}
+
+static uc_value_t *
+uc_uline_argp_check(uc_vm_t *vm, size_t nargs)
+{
+	return uc_uline_parse_args(vm, nargs, true);
+}
+
+static uc_value_t *
+uc_uline_argp_escape(uc_vm_t *vm, size_t nargs)
+{
+	uc_value_t *arg = uc_fn_arg(0);
+	uc_value_t *ref_arg = uc_fn_arg(1);
+	const char *str, *next;
+	uc_stringbuf_t *buf;
+	char ref = 0;
+
+	if (ucv_type(arg) != UC_STRING)
+		return NULL;
+
+	if (ucv_type(ref_arg) == UC_STRING)
+		ref = ucv_string_get(ref_arg)[0];
+
+	str = ucv_string_get(arg);
+	if (ref != '"' && ref != '\'') {
+		next = str + strcspn(str, "\n\t '\"");
+		if (*next)
+			ref = '"';
+	}
+	if (ref != '"' && ref != '\'')
+		return ucv_string_new(str);
+
+	buf = ucv_stringbuf_new();
+	ucv_stringbuf_addstr(buf, &ref, 1);
+
+	while (*str) {
+		next = strchr(str, ref);
+		if (!next) {
+			ucv_stringbuf_addstr(buf, str, strlen(str));
+			break;
+		}
+
+		if (next - str)
+			ucv_stringbuf_addstr(buf, str, next - str);
+		if (ref == '\'')
+			ucv_stringbuf_addstr(buf, "'\\''", 4);
+		else
+			ucv_stringbuf_addstr(buf, "\\\"", 2);
+		str = next + 1;
+	}
+
+	ucv_stringbuf_addstr(buf, &ref, 1);
+
+	return ucv_stringbuf_finish(buf);
+}
+
+static uc_value_t *
+uc_uline_getpass(uc_vm_t *vm, size_t nargs)
+{
+	uc_value_t *prompt = uc_fn_arg(0);
+	char *pw;
+
+	if (ucv_type(prompt) != UC_STRING)
+		return NULL;
+
+	pw = getpass(ucv_string_get(prompt));
+	if (!pw)
+		return NULL;
+
+	return ucv_string_new(pw);
+}
+
+static const uc_function_list_t argp_fns[] = {
+	{ "parse", uc_uline_argp_parse },
+	{ "check", uc_uline_argp_check },
+	{ "escape", uc_uline_argp_escape },
+};
+
+static const uc_function_list_t state_fns[] = {
+	{ "close", uc_uline_close },
+	{ "poll", uc_uline_poll },
+	{ "poll_stop", uc_uline_poll_stop },
+	{ "poll_key", uc_uline_poll_key },
+	{ "reset_key_input", uc_uline_reset_key_input },
+	{ "get_line", uc_uline_get_line },
+	{ "get_window", uc_uline_get_window },
+	{ "set_hint", uc_uline_set_hint },
+	{ "set_state", uc_uline_set_state },
+	{ "set_uloop", uc_uline_set_uloop },
+	{ "hide_prompt", uc_uline_hide_prompt },
+	{ "refresh_prompt", uc_uline_refresh_prompt },
+};
+
+static const uc_function_list_t global_fns[] = {
+	{ "new", uc_uline_new },
+	{ "arg_parser", uc_uline_arg_parser },
+	{ "getpass", uc_uline_getpass },
+};
+
+void uc_module_init(uc_vm_t *vm, uc_value_t *scope)
+{
+	uc_function_list_register(scope, global_fns);
+
+	state_type = uc_type_declare(vm, "uline.state", state_fns, free_state);
+	argp_type = uc_type_declare(vm, "uline.argp", argp_fns, free);
+	registry = ucv_array_new(vm);
+	uc_vm_registry_set(vm, "uline.registry", registry);
+}

package/utils/ucode-mod-uline/src/uline.c

@@ -0,0 +1,919 @@
+// SPDX-License-Identifier: ISC
+/*
+ * Copyright (C) 2025 Felix Fietkau <[email protected]>
+ */
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <errno.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <locale.h>
+
+#include <libubox/list.h>
+
+#include "uline.h"
+#include "private.h"
+
+#define LINEBUF_CHUNK 64
+
+static int sigwinch_count;
+
+static size_t
+nsyms(struct uline_state *s, const char *buf, size_t len)
+{
+	if (!s->utf8)
+		return len;
+	return utf8_nsyms(buf, len);
+}
+
+static inline bool
+is_utf8_cont(unsigned char c)
+{
+	return (c & 0xc0) == 0x80;
+}
+
+static size_t
+utf8_move_left(const char *line, size_t pos)
+{
+	if (!pos)
+		return 0;
+	do {
+		pos--;
+	} while (pos > 0 && is_utf8_cont(line[pos]));
+
+	return pos;
+}
+
+static size_t
+utf8_move_right(const char *line, size_t pos, size_t len)
+{
+	if (pos == len)
+		return pos;
+
+	do {
+		pos++;
+	} while (pos < len && is_utf8_cont(line[pos]));
+
+	return pos;
+}
+
+static char *
+linebuf_extend(struct linebuf *l, size_t size)
+{
+	size_t tailroom = l->bufsize - l->len;
+	char *buf;
+
+	if (l->buf && tailroom > size)
+		goto out;
+
+	size -= tailroom;
+	size += LINEBUF_CHUNK - 1;
+	size -= size % LINEBUF_CHUNK;
+
+	buf = realloc(l->buf, l->bufsize + size);
+	if (!buf)
+		return NULL;
+
+	l->buf = buf;
+	l->bufsize += size;
+
+out:
+	return l->buf + l->len;
+}
+
+static void
+linebuf_free(struct linebuf *line)
+{
+	free(line->buf);
+	free(line->prompt);
+}
+
+static void
+update_window_size(struct uline_state *s, bool init)
+{
+	unsigned int cols = 80, rows = 25;
+#ifdef TIOCGWINSZ
+	struct winsize ws = {};
+
+	if (!ioctl(fileno(s->output), TIOCGWINSZ, &ws)) {
+		if (ws.ws_col)
+			cols = ws.ws_col;
+		if (ws.ws_row)
+			rows = ws.ws_row;
+	}
+#endif
+
+	s->sigwinch_count = sigwinch_count;
+	if (s->cols == cols && s->rows == rows)
+		return;
+
+	s->cols = cols;
+	s->rows = rows;
+	s->full_update = true;
+	s->cb->event(s, EDITLINE_EV_WINDOW_CHANGED);
+}
+
+static void
+handle_sigwinch(int signal)
+{
+	sigwinch_count++;
+}
+
+static void
+reset_input_state(struct uline_state *s)
+{
+	s->utf8_cont = 0;
+	s->esc_idx = -1;
+}
+
+static void
+termios_set_native_mode(struct uline_state *s)
+{
+	struct termios t = s->orig_termios;
+
+	if (!s->has_termios)
+		return;
+
+	t.c_iflag = 0;
+	t.c_oflag = OPOST | ONLCR;
+	t.c_lflag = 0;
+	t.c_cc[VMIN] = 1;
+	t.c_cc[VTIME] = 0;
+
+	tcsetattr(s->input, TCSADRAIN, &t);
+}
+
+static void
+termios_set_orig_mode(struct uline_state *s)
+{
+	if (!s->has_termios)
+		return;
+
+	tcsetattr(s->input, TCSADRAIN, &s->orig_termios);
+}
+
+static bool
+check_utf8(struct uline_state *s, unsigned char c)
+{
+	if (!s->utf8)
+		return false;
+	if (s->utf8_cont)
+		return true;
+	return (c & 0xc0) == 0xc0;
+}
+
+static bool
+handle_utf8(struct uline_state *s, unsigned char c)
+{
+	if (!s->utf8)
+		return false;
+
+	if (!s->utf8_cont) {
+		if ((c & 0xc0) != 0xc0)
+			return false;
+
+		c &= 0xf0;
+		c <<= 1;
+		while (c & 0x80) {
+			c <<= 1;
+			s->utf8_cont++;
+		}
+
+		return true;
+	}
+
+	if ((c & 0xc0) != 0x80) {
+		// invalid utf-8
+		s->utf8_cont = 0;
+		return false;
+	}
+
+	s->utf8_cont--;
+
+	return s->utf8_cont;
+}
+
+static bool
+linebuf_insert(struct linebuf *line, char *c, size_t len)
+{
+	char *dest;
+	ssize_t tail;
+
+	if (!linebuf_extend(line, len + 1))
+		return false;
+
+	dest = &line->buf[line->pos];
+	tail = line->len - line->pos;
+	if (tail > 0)
+		memmove(dest + len, dest, tail);
+	else
+		dest[len] = 0;
+
+	if (line->update_pos > line->pos)
+		line->update_pos = line->pos;
+
+	memcpy(dest, c, len);
+	line->len += len;
+	line->pos += len;
+	line->buf[line->len] = 0;
+
+	return true;
+}
+
+static void
+linebuf_delete(struct linebuf *line, size_t len)
+{
+	char *dest = &line->buf[line->pos];
+	ssize_t tail = line->len - line->pos;
+	size_t max_len = line->len - line->pos;
+
+	if (line->update_pos > line->pos)
+		line->update_pos = line->pos;
+
+	if (len > max_len)
+		len = max_len;
+
+	memmove(dest, dest + len, tail + 1);
+	line->len -= len;
+}
+
+static struct pos
+pos_convert(struct uline_state *s, ssize_t offset)
+{
+	struct pos pos;
+	pos.y = offset / s->cols;
+	pos.x = offset - (pos.y * s->cols);
+	return pos;
+}
+
+static void
+pos_add(struct uline_state *s, struct pos *pos, struct pos add)
+{
+	pos->x += add.x;
+	pos->y += add.y;
+	if (pos->x >= (int16_t)s->cols) {
+		pos->x -= s->cols;
+		pos->y++;
+	}
+	if (pos->x < 0) {
+		pos->x += s->cols;
+		pos->y--;
+	}
+	if (pos->y < 0)
+		pos->y = 0;
+}
+
+static void
+pos_add_ofs(struct uline_state *s, struct pos *pos, size_t offset)
+{
+	pos_add(s, pos, pos_convert(s, offset));
+}
+
+static void
+pos_add_newline(struct uline_state *s, struct pos *pos)
+{
+	pos->x = 0;
+	pos->y++;
+}
+
+static void
+__pos_add_string(struct uline_state *s, struct pos *pos, const char *str, size_t len)
+{
+	const char *next;
+
+	while ((next = memchr(str, KEY_ESC, len)) != NULL) {
+		size_t cur_len = next - str;
+
+		pos_add_ofs(s, pos, nsyms(s, str, cur_len));
+		next++;
+
+		if (*next == '[' || *next == 'O') {
+			next++;
+			while (*next <= 63)
+				next++;
+		}
+		next++;
+		len -= next - str;
+		str = next;
+	}
+
+	pos_add_ofs(s, pos, nsyms(s, str, len));
+}
+
+static void
+pos_add_string(struct uline_state *s, struct pos *pos, const char *str, size_t len)
+{
+	const char *next;
+
+	if (!len)
+		return;
+
+	while ((next = memchr(str, '\n', len)) != NULL) {
+		size_t cur_len = next - str;
+		if (cur_len)
+			__pos_add_string(s, pos, str, cur_len);
+		pos_add_newline(s, pos);
+		len -= cur_len + 1;
+		str = next + 1;
+	}
+
+	if (len)
+		__pos_add_string(s, pos, str, len);
+}
+
+static struct pos
+pos_diff(struct pos start, struct pos end)
+{
+	struct pos diff = {
+		.x = end.x - start.x,
+		.y = end.y - start.y
+	};
+
+	return diff;
+}
+
+static void
+set_cursor(struct uline_state *s, struct pos pos)
+{
+	struct pos diff = pos_diff(s->cursor_pos, pos);
+
+	if (diff.x > 0)
+		vt100_cursor_forward(s->output, diff.x);
+	else if (diff.x < 0)
+		vt100_cursor_back(s->output, -diff.x);
+
+	if (diff.y > 0)
+		vt100_cursor_down(s->output, diff.y);
+	else if (diff.y < 0)
+		vt100_cursor_up(s->output, -diff.y);
+
+	s->cursor_pos = pos;
+}
+
+static void
+display_output_string(struct uline_state *s, const char *str,
+		      size_t len)
+{
+	fwrite(str, len, 1, s->output);
+	pos_add_string(s, &s->cursor_pos, str, len);
+}
+
+static void
+display_update_line(struct uline_state *s, struct linebuf *line,
+		    struct pos *pos)
+{
+	char *start = line->buf;
+	char *end = line->buf + line->len;
+	struct pos update_pos;
+	size_t prompt_len = 0;
+
+	if (line->prompt)
+		prompt_len = strlen(line->prompt);
+
+	if (s->full_update) {
+		display_output_string(s, line->prompt, prompt_len);
+		*pos = s->cursor_pos;
+		line->update_pos = 0;
+	} else {
+		pos_add_string(s, pos, line->prompt, prompt_len);
+	}
+
+	update_pos = *pos;
+	if (line->update_pos) {
+		start += line->update_pos;
+		pos_add_string(s, &update_pos, line->buf, line->update_pos);
+	}
+	set_cursor(s, update_pos);
+	vt100_erase_right(s->output);
+	line->update_pos = line->len;
+
+	if (end - start <= 0)
+		return;
+
+	display_output_string(s, start, end - start);
+	if (s->cursor_pos.x == 0 && end[-1] != '\n')
+		vt100_next_line(s->output);
+}
+
+static void
+display_update(struct uline_state *s)
+{
+	struct pos edit_pos, end_diff;
+	struct pos base_pos = {};
+	struct linebuf *line = &s->line;
+
+	if (s->full_update) {
+		set_cursor(s, (struct pos){});
+		fputc(KEY_CR, s->output);
+		vt100_erase_down(s->output);
+	}
+
+	display_update_line(s, line, &base_pos);
+
+	if (s->line2) {
+		line = s->line2;
+
+		if (s->cursor_pos.x != 0) {
+			vt100_next_line(s->output);
+			pos_add_newline(s, &s->cursor_pos);
+		}
+
+		base_pos = s->cursor_pos;
+		display_update_line(s, s->line2, &base_pos);
+	}
+
+	edit_pos = base_pos;
+	pos_add_string(s, &edit_pos, line->buf, line->pos);
+
+	end_diff = pos_diff(s->end_pos, s->cursor_pos);
+	s->end_pos = s->cursor_pos;
+
+	if (end_diff.y != 0)
+		vt100_erase_down(s->output);
+	else
+		vt100_erase_right(s->output);
+
+	set_cursor(s, edit_pos);
+	fflush(s->output);
+
+	s->full_update = false;
+}
+
+static bool
+delete_symbol(struct uline_state *s, struct linebuf *line)
+{
+	size_t len = 1;
+
+	if (line->pos == line->len)
+		return false;
+
+	if (s->utf8) {
+		len = utf8_move_right(line->buf, line->pos, line->len);
+		len -= line->pos;
+	}
+
+	linebuf_delete(line, len);
+	return true;
+}
+
+static bool
+move_left(struct uline_state *s, struct linebuf *line)
+{
+	if (!line->pos)
+		return false;
+	if (s->utf8)
+		line->pos = utf8_move_left(line->buf, line->pos);
+	else
+		line->pos--;
+	return true;
+}
+
+static bool
+move_word_left(struct uline_state *s, struct linebuf *line)
+{
+	char *buf = line->buf;
+	size_t pos;
+
+	if (!move_left(s, line))
+		return false;
+
+	pos = line->pos;
+	// remove trailing spaces
+	while (pos > 0 && isspace(buf[pos]))
+		pos--;
+
+	// skip word
+	while (pos > 0 && !isspace(buf[pos]))
+		pos--;
+	if (isspace(buf[pos]))
+		pos++;
+
+	line->pos = pos;
+
+	return true;
+}
+
+static bool
+move_right(struct uline_state *s, struct linebuf *line)
+{
+	if (line->pos >= line->len)
+		return false;
+	if (s->utf8)
+		line->pos = utf8_move_right(line->buf, line->pos, line->len);
+	else
+		line->pos++;
+	return true;
+}
+
+static bool
+move_word_right(struct uline_state *s, struct linebuf *line)
+{
+	char *buf = line->buf;
+	size_t pos = line->pos;
+
+	if (pos == line->len)
+		return false;
+
+	// skip word
+	while (!isspace(buf[pos]) && pos < line->len)
+		pos++;
+
+	// skip trailing whitespace
+	while (isspace(buf[pos]) && pos < line->len)
+		pos++;
+
+	line->pos = pos;
+
+	return true;
+}
+
+static bool
+process_esc(struct uline_state *s, enum vt100_escape esc)
+{
+	struct linebuf *line = &s->line;
+
+	if (s->line2 &&
+	    (esc == VT100_DELETE ||
+	     (s->cb->line2_cursor && s->cb->line2_cursor(s))))
+		line = s->line2;
+
+	switch (esc) {
+	case VT100_CURSOR_LEFT:
+		return move_left(s, line);
+	case VT100_CURSOR_WORD_LEFT:
+		return move_word_left(s, line);
+	case VT100_CURSOR_RIGHT:
+		return move_right(s, line);
+	case VT100_CURSOR_WORD_RIGHT:
+		return move_word_right(s, line);
+	case VT100_HOME:
+		line->pos = 0;
+		return true;
+	case VT100_END:
+		line->pos = line->len;
+		return true;
+	case VT100_CURSOR_UP:
+		s->cb->event(s, EDITLINE_EV_CURSOR_UP);
+		return true;
+	case VT100_CURSOR_DOWN:
+		s->cb->event(s, EDITLINE_EV_CURSOR_DOWN);
+		return true;
+	case VT100_DELETE:
+		return delete_symbol(s, line);
+	default:
+		vt100_ding(s->output);
+		return false;
+	}
+}
+
+static bool
+process_backword(struct uline_state *s, struct linebuf *line)
+{
+	size_t pos, len;
+
+	pos = line->pos - 1;
+	if (!move_word_left(s, line))
+		return false;
+
+	len = pos + 1 - line->pos;
+	linebuf_delete(line, len);
+
+	return true;
+}
+
+static void
+linebuf_reset(struct linebuf *line)
+{
+	line->pos = 0;
+	line->len = 0;
+	line->buf[0] = 0;
+	line->update_pos = 0;
+}
+
+static void
+free_line2(struct uline_state *s)
+{
+	if (!s->line2)
+		return;
+
+	linebuf_free(s->line2);
+	free(s->line2);
+	s->line2 = NULL;
+}
+
+static bool
+process_newline(struct uline_state *s, bool drop)
+{
+	bool ret;
+
+	if (drop)
+		goto reset;
+
+	termios_set_orig_mode(s);
+	if (s->line2 && s->cb->line2_newline &&
+	    s->cb->line2_newline(s, s->line2->buf, s->line2->len)) {
+		termios_set_native_mode(s);
+		return true;
+	}
+
+	free_line2(s);
+	ret = s->cb->line(s, s->line.buf, s->line.len);
+	termios_set_native_mode(s);
+	if (!ret) {
+		linebuf_insert(&s->line, "\n", 1);
+		return true;
+	}
+
+reset:
+	vt100_next_line(s->output);
+	vt100_erase_down(s->output);
+	s->cursor_pos = (struct pos) {};
+	s->full_update = true;
+	fflush(s->output);
+	if (!s->line.len)
+		return true;
+
+	linebuf_reset(&s->line);
+
+	return true;
+}
+
+static bool
+process_ctrl(struct uline_state *s, char c)
+{
+	struct linebuf *line = s->line2 ? s->line2 : &s->line;
+
+	switch (c) {
+	case KEY_LF:
+	case KEY_CR:
+		return process_newline(s, false);
+	case KEY_ETX:
+		s->cb->event(s, EDITLINE_EV_INTERRUPT);
+		process_newline(s, true);
+		s->stop = true;
+		return true;
+	case KEY_EOT:
+		if (s->line.len)
+			return false;
+		s->cb->event(s, EDITLINE_EV_EOF);
+		s->stop = true;
+		return true;
+	case KEY_BS:
+	case KEY_DEL:
+		if (!move_left(s, line))
+			return false;
+
+		delete_symbol(s, line);
+		if (s->line2 && s->cb->line2_update)
+			s->cb->line2_update(s, line->buf, line->len);
+		return true;
+	case KEY_FF:
+		vt100_cursor_home(s->output);
+		vt100_erase_down(s->output);
+		s->full_update = true;
+		return true;
+	case KEY_NAK:
+		linebuf_reset(line);
+		return true;
+	case KEY_SOH:
+		return process_esc(s, VT100_HOME);
+	case KEY_ENQ:
+		return process_esc(s, VT100_END);
+	case KEY_VT:
+		// TODO: kill
+		return false;
+	case KEY_EM:
+		// TODO: yank
+		return false;
+	case KEY_ETB:
+		return process_backword(s, line);
+	case KEY_ESC:
+		s->esc_idx = 0;
+		return false;
+	case KEY_SUB:
+		kill(getpid(), SIGTSTP);
+		return false;
+	default:
+		return false;
+	}
+}
+
+static void
+check_key_repeat(struct uline_state *s, char c)
+{
+	if (s->repeat_char != c)
+		s->repeat_count = 0;
+
+	s->repeat_char = c;
+	s->repeat_count++;
+}
+
+static void
+process_char(struct uline_state *s, char c)
+{
+	enum vt100_escape esc;
+
+	check_key_repeat(s, c);
+	if (s->esc_idx >= 0) {
+		s->esc_seq[s->esc_idx++] = c;
+		s->esc_seq[s->esc_idx] = 0;
+		esc = vt100_esc_decode(s->esc_seq);
+		if (esc == VT100_INCOMPLETE &&
+		    s->esc_idx < (int)sizeof(s->esc_seq) - 1)
+			return;
+
+		s->esc_idx = -1;
+		if (!process_esc(s, esc))
+			return;
+	} else if (s->cb->key_input &&
+	           !check_utf8(s, (unsigned char )c) &&
+	           s->cb->key_input(s, c, s->repeat_count)) {
+		goto out;
+	} else if ((unsigned char)c < 32 || c == 127) {
+		if (!process_ctrl(s, c))
+			return;
+	} else {
+		struct linebuf *line = s->line2 ? s->line2 : &s->line;
+
+		if (!linebuf_insert(line, &c, 1) ||
+		    handle_utf8(s, (unsigned char )c))
+			return;
+
+		if (s->line2 && s->cb->line2_update)
+			s->cb->line2_update(s, line->buf, line->len);
+	}
+
+out:
+	if (s->stop)
+		return;
+
+	display_update(s);
+}
+
+void uline_poll(struct uline_state *s)
+{
+	int ret;
+	char c;
+
+	uline_refresh_prompt(s);
+	s->stop = false;
+	while (!s->stop) {
+		ret = read(s->input, &c, 1);
+		if (ret < 0) {
+			if (errno == EINTR)
+				continue;
+			if (errno == EAGAIN)
+				return;
+			ret = 0;
+		}
+
+		if (!ret) {
+			s->cb->event(s, EDITLINE_EV_EOF);
+			termios_set_orig_mode(s);
+			return;
+		}
+
+		if (s->sigwinch_count != sigwinch_count)
+			update_window_size(s, false);
+
+		process_char(s, c);
+	}
+}
+
+void uline_set_prompt(struct uline_state *s, const char *str)
+{
+	if (s->line.prompt && !strcmp(s->line.prompt, str))
+		return;
+
+	free(s->line.prompt);
+	s->line.prompt = strdup(str);
+	s->full_update = true;
+}
+
+void uline_set_line2_prompt(struct uline_state *s, const char *str)
+{
+	if (!!str != !!s->line2) {
+		if (!str)
+			free_line2(s);
+		else
+			s->line2 = calloc(1, sizeof(*s->line2));
+	}
+
+	if (!str || (s->line2->prompt && !strcmp(s->line2->prompt, str)))
+		return;
+
+	free(s->line2->prompt);
+	s->line2->prompt = strdup(str);
+	s->full_update = true;
+}
+
+static void
+__uline_set_line(struct uline_state *s, struct linebuf *line, const char *str, size_t len)
+{
+	size_t i, prev_len = line->len;
+
+	line->len = 0;
+		linebuf_extend(line, len);
+	for (i = 0; i < prev_len && i < len; i++) {
+		if (line->buf[i] != str[i])
+			break;
+	}
+	if (i > prev_len)
+		i--;
+	if (s->utf8) {
+		// move back to the beginning of the utf-8 symbol
+		while (i > 0 && (str[i] & 0xc0) == 0x80)
+			i--;
+	}
+	line->update_pos = i;
+
+	memcpy(line->buf, str, len);
+	line->len = len;
+	if (line->pos > line->len)
+		line->pos = line->len;
+}
+
+void uline_set_line(struct uline_state *s, const char *str, size_t len)
+{
+	__uline_set_line(s, &s->line, str, len);
+}
+
+void uline_set_line2(struct uline_state *s, const char *str, size_t len)
+{
+	if (!s->line2)
+		return;
+	__uline_set_line(s, s->line2, str, len);
+}
+
+void uline_hide_prompt(struct uline_state *s)
+{
+	set_cursor(s, (struct pos){});
+	vt100_erase_down(s->output);
+	s->full_update = true;
+	fflush(s->output);
+}
+
+void uline_refresh_prompt(struct uline_state *s)
+{
+	termios_set_native_mode(s);
+	display_update(s);
+}
+
+void uline_set_hint(struct uline_state *s, const char *str, size_t len)
+{
+	struct pos prev_pos = s->cursor_pos;
+
+	if (len) {
+		vt100_next_line(s->output);
+		pos_add_newline(s, &s->cursor_pos);
+	}
+	vt100_erase_down(s->output);
+
+	if (len) {
+		fwrite(str, len, 1, s->output);
+		pos_add_string(s, &s->cursor_pos, str, len);
+	}
+
+	set_cursor(s, prev_pos);
+	fflush(s->output);
+}
+
+void uline_init(struct uline_state *s, const struct uline_cb *cb,
+                int in_fd, FILE *out_stream, bool utf8)
+{
+	struct sigaction sa = {
+		.sa_handler = handle_sigwinch,
+	};
+	s->cb = cb;
+	s->utf8 = utf8;
+	s->input = in_fd;
+	s->output = out_stream;
+	update_window_size(s, true);
+	reset_input_state(s);
+
+#ifdef USE_SYSTEM_WCHAR
+	if (utf8)
+		setlocale(LC_CTYPE, "C.UTF-8");
+#endif
+
+	sigaction(SIGWINCH, &sa, NULL);
+	s->full_update = true;
+
+	if (!tcgetattr(s->input, &s->orig_termios)) {
+		s->has_termios = true;
+		termios_set_native_mode(s);
+	}
+}
+
+void uline_free(struct uline_state *s)
+{
+	free_line2(s);
+	termios_set_orig_mode(s);
+	linebuf_free(&s->line);
+}

package/utils/ucode-mod-uline/src/uline.h

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: ISC
+/*
+ * Copyright (C) 2025 Felix Fietkau <[email protected]>
+ */
+#ifndef __EDITLINE_H
+#define __EDITLINE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <termios.h>
+#include <stdio.h>
+
+#include <libubox/utils.h>
+
+struct uline_state;
+
+struct linebuf {
+	char *buf;
+	size_t len;
+	size_t bufsize;
+
+	char *prompt;
+	size_t pos;
+	size_t update_pos;
+};
+
+struct pos {
+	int16_t x;
+	int16_t y;
+};
+
+enum uline_event {
+	EDITLINE_EV_CURSOR_UP,
+	EDITLINE_EV_CURSOR_DOWN,
+
+	EDITLINE_EV_WINDOW_CHANGED,
+	EDITLINE_EV_LINE_INPUT,
+
+	EDITLINE_EV_INTERRUPT,
+	EDITLINE_EV_EOF,
+};
+
+struct uline_cb {
+	// called on every key input. return true if handled by callback
+	bool (*key_input)(struct uline_state *s, unsigned char c, unsigned int count);
+
+	void (*event)(struct uline_state *s, enum uline_event ev);
+
+	// line: called on newline, returns true to accept the line, false to keep
+	// editing a multi-line string
+	bool (*line)(struct uline_state *s, const char *str, size_t len);
+
+	// called on any changes to the buffer of the secondary line editor
+	void (*line2_update)(struct uline_state *s, const char *str, size_t len);
+
+	// called on cursor button press during line2 editing
+	// return true to handle in line2, false to handle in primary line
+	bool (*line2_cursor)(struct uline_state *s);
+
+	// called on newline on the secondary line editor
+	// return true to ignore, false to process as primary line newline event
+	bool (*line2_newline)(struct uline_state *s, const char *str, size_t len);
+};
+
+struct uline_state {
+	const struct uline_cb *cb;
+
+	int input;
+	FILE *output;
+
+	int sigwinch_count;
+
+	struct termios orig_termios;
+	bool has_termios;
+
+	struct linebuf line;
+	struct linebuf *line2;
+
+	unsigned int repeat_count;
+	char repeat_char;
+
+	unsigned int rows, cols;
+	struct pos cursor_pos;
+	struct pos end_pos;
+	bool full_update;
+	bool stop;
+
+	bool utf8;
+
+	char esc_seq[8];
+	int8_t esc_idx;
+	uint8_t utf8_cont;
+};
+
+void uline_init(struct uline_state *s, const struct uline_cb *cb,
+                int in_fd, FILE *out_stream, bool utf8);
+void uline_poll(struct uline_state *s);
+
+void uline_set_line(struct uline_state *s, const char *str, size_t len);
+void uline_set_prompt(struct uline_state *s, const char *str);
+static inline void
+uline_set_cursor(struct uline_state *s, size_t pos)
+{
+	s->line.pos = pos;
+	if (s->line.pos > s->line.len)
+		s->line.pos = s->line.len;
+}
+static inline void
+uline_get_line(struct uline_state *s, const char **str, size_t *len)
+{
+	if (s->line.buf) {
+		*str = s->line.buf;
+		*len = s->line.len;
+	} else{
+		*str = "";
+		*len = 0;
+	}
+}
+
+
+
+void uline_set_line2(struct uline_state *s, const char *str, size_t len);
+void uline_set_line2_prompt(struct uline_state *s, const char *str);
+static inline void
+uline_set_line2_cursor(struct uline_state *s, size_t pos)
+{
+	if (!s->line2)
+		return;
+
+	s->line2->pos = pos;
+	if (s->line2->pos > s->line2->len)
+		s->line2->pos = s->line2->len;
+}
+static inline void
+uline_get_line2(struct uline_state *s, const char **str, size_t *len)
+{
+	if (s->line2 && s->line2->buf) {
+		*str = s->line2->buf;
+		*len = s->line2->len;
+	} else{
+		*str = "";
+		*len = 0;
+	}
+}
+
+void uline_set_hint(struct uline_state *s, const char *str, size_t len);
+void uline_hide_prompt(struct uline_state *s);
+void uline_refresh_prompt(struct uline_state *s);
+void uline_free(struct uline_state *s);
+
+#endif

package/utils/ucode-mod-uline/src/utf8.c

@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: ISC
+/*
+ * Copyright (C) 2025 Felix Fietkau <[email protected]>
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <wchar.h>
+
+#include "private.h"
+
+#ifndef USE_SYSTEM_WCHAR
+/*
+ * adapted from musl code:
+ *
+ * Copyright © 2005-2020 Rich Felker, et al.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#undef MB_CUR_MAX
+#define MB_CUR_MAX 4
+
+static const unsigned char table[] = {
+16,16,16,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,16,33,16,16,16,34,35,36,
+37,38,39,40,16,16,41,16,16,16,16,16,16,16,16,16,16,16,42,43,16,16,44,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,45,16,46,47,48,49,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,50,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,51,16,16,52,
+53,16,54,55,56,16,16,16,16,16,16,57,16,16,58,16,59,60,61,62,63,64,65,66,67,68,
+69,70,16,71,72,73,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,74,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,75,76,16,16,16,77,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,78,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,79,80,16,16,16,16,16,16,16,81,16,16,16,16,16,82,83,84,16,16,16,16,16,85,
+86,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,254,255,255,255,255,191,182,0,0,0,0,0,0,0,63,0,255,23,0,0,0,0,0,248,255,
+255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,159,61,0,0,0,128,2,0,0,0,255,255,255,
+7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,0,0,0,0,0,248,15,32,0,0,192,251,239,62,0,0,
+0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,
+255,7,0,0,0,0,0,0,20,254,33,254,0,12,0,0,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,
+64,6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,190,33,0,0,12,0,0,
+252,2,0,0,0,0,0,0,144,30,32,64,0,12,0,0,0,4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,
+0,0,0,0,0,0,192,193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,3,0,
+0,0,0,0,0,24,30,32,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,4,92,0,0,0,0,0,0,0,0,0,0,0,
+242,7,128,127,0,0,0,0,0,0,0,0,0,0,0,0,242,31,0,63,0,0,0,0,0,0,0,0,0,3,0,0,160,
+2,0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,0,0,0,0,
+0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,
+15,32,0,0,0,0,0,120,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+128,9,0,0,0,0,0,0,64,127,229,31,248,159,0,0,0,0,0,0,255,127,0,0,0,0,0,0,0,0,
+15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,0,0,0,0,64,163,3,0,0,
+0,0,0,0,240,207,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,
+3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,
+251,0,248,0,0,0,124,0,0,0,0,0,0,223,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,
+255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,0,0,0,0,
+0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,128,247,63,0,0,0,192,0,0,0,0,0,0,0,0,0,0,3,0,68,8,0,0,96,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,128,255,3,0,
+0,0,0,0,7,0,0,0,0,0,200,51,0,0,0,0,32,0,0,
+0,0,0,0,0,0,126,102,0,8,16,0,0,0,0,0,16,0,0,0,0,0,0,157,193,2,0,0,0,0,48,64,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,0,0,0,
+64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,0,0,255,
+255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,
+0,0,0,0,135,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,0,0,0,0,240,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,
+3,0,0,0,0,0,120,38,0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,3,0,
+0,0,0,0,192,127,0,30,0,0,0,0,0,0,0,0,0,0,0,128,211,64,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,128,248,7,0,0,3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,0,0,0,0,0,0,
+248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,0,252,
+127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,0,0,0,0,0,0,0,0,0,0,252,255,
+255,252,109,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,128,7,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,0,
+0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,240,7,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,};
+
+static const unsigned char wtable[] = {
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,18,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,19,16,20,21,22,16,16,16,23,16,16,24,25,26,27,28,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,29,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,30,16,16,16,16,31,16,16,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,32,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,16,16,16,33,
+34,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,35,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,36,17,17,37,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,38,39,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,40,41,42,43,44,45,46,47,16,48,49,16,16,16,16,
+16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,6,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,48,0,0,0,0,0,0,255,15,0,0,0,0,128,0,0,8,
+0,2,12,0,96,48,64,16,0,0,4,44,36,32,12,0,0,0,1,0,0,0,80,184,0,0,0,0,0,0,0,224,
+0,0,0,1,128,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,251,255,255,255,255,255,255,255,
+255,255,255,15,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,255,15,255,255,255,255,
+255,255,255,127,254,255,255,255,255,255,255,255,255,255,127,254,255,255,255,
+255,255,255,255,255,255,255,255,255,224,255,255,255,255,255,254,255,255,255,
+255,255,255,255,255,255,255,127,255,255,255,255,255,7,255,255,255,255,15,0,
+255,255,255,255,255,127,255,255,255,255,255,0,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,
+0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,31,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,
+255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3,0,0,255,255,255,255,247,255,127,15,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,255,255,255,255,255,255,255,255,
+255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,7,0,255,255,255,127,0,0,0,0,0,
+0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+15,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,64,254,7,0,0,0,0,0,0,0,0,0,0,0,0,7,0,255,255,255,
+255,255,15,255,1,3,0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,
+1,224,191,255,255,255,255,255,255,255,255,223,255,255,15,0,255,255,255,255,
+255,135,15,0,255,255,17,255,255,255,255,255,255,255,255,127,253,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+159,255,255,255,255,255,255,255,63,0,120,255,255,255,0,0,4,0,0,96,0,16,0,0,0,
+0,0,0,0,0,0,0,248,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,63,16,39,0,0,24,240,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,255,15,0,
+0,0,224,255,255,255,255,255,255,255,255,255,255,255,255,123,252,255,255,255,
+255,231,199,255,255,255,231,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,15,7,7,0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,
+};
+
+/* Upper 6 state bits are a negative integer offset to bound-check next byte */
+/*    equivalent to: ( (b-0x80) | (b+offset) ) & ~0x3f      */
+#define OOB(c,b) (((((b)>>3)-0x10)|(((b)>>3)+((int32_t)(c)>>26))) & ~7)
+
+/* Interval [a,b). Either a must be 80 or b must be c0, lower 3 bits clear. */
+#define R(a,b) ((uint32_t)((a==0x80 ? 0x40u-b : 0u-a) << 23))
+#define FAILSTATE R(0x80,0x80)
+
+#define SA 0xc2u
+#define SB 0xf4u
+
+/* Arbitrary encoding for representing code units instead of characters. */
+#define CODEUNIT(c) (0xdfff & (signed char)(c))
+#define IS_CODEUNIT(c) ((unsigned)(c)-0xdf80 < 0x80)
+
+static int
+internal_mbtowc(wchar_t *restrict wc, const char *restrict src, size_t n)
+{
+#define C(x) ( x<2 ? -1 : ( R(0x80,0xc0) | x ) )
+#define D(x) C((x+16))
+#define E(x) ( ( x==0 ? R(0xa0,0xc0) : \
+                 x==0xd ? R(0x80,0xa0) : \
+                 R(0x80,0xc0) ) \
+             | ( R(0x80,0xc0) >> 6 ) \
+             | x )
+#define F(x) ( ( x>=5 ? 0 : \
+                 x==0 ? R(0x90,0xc0) : \
+                 x==4 ? R(0x80,0x90) : \
+                 R(0x80,0xc0) ) \
+             | ( R(0x80,0xc0) >> 6 ) \
+             | ( R(0x80,0xc0) >> 12 ) \
+             | x )
+
+	static const uint32_t bittab[] = {
+					  C(0x2),C(0x3),C(0x4),C(0x5),C(0x6),C(0x7),
+		C(0x8),C(0x9),C(0xa),C(0xb),C(0xc),C(0xd),C(0xe),C(0xf),
+		D(0x0),D(0x1),D(0x2),D(0x3),D(0x4),D(0x5),D(0x6),D(0x7),
+		D(0x8),D(0x9),D(0xa),D(0xb),D(0xc),D(0xd),D(0xe),D(0xf),
+		E(0x0),E(0x1),E(0x2),E(0x3),E(0x4),E(0x5),E(0x6),E(0x7),
+		E(0x8),E(0x9),E(0xa),E(0xb),E(0xc),E(0xd),E(0xe),E(0xf),
+		F(0x0),F(0x1),F(0x2),F(0x3),F(0x4)
+	};
+	unsigned c;
+	const unsigned char *s = (const void *)src;
+	wchar_t dummy;
+
+	if (!s) return 0;
+	if (!n) goto ilseq;
+	if (!wc) wc = &dummy;
+
+	if (*s < 0x80) return !!(*wc = *s);
+	if (MB_CUR_MAX==1) return (*wc = CODEUNIT(*s)), 1;
+	if (*s-SA > SB-SA) goto ilseq;
+	c = bittab[*s++-SA];
+
+	/* Avoid excessive checks against n: If shifting the state n-1
+	 * times does not clear the high bit, then the value of n is
+	 * insufficient to read a character */
+	if (n<4 && ((c<<(6*n-6)) & (1U<<31))) goto ilseq;
+
+	if (OOB(c,*s)) goto ilseq;
+	c = c<<6 | *s++-0x80;
+	if (!(c&(1U<<31))) {
+		*wc = c;
+		return 2;
+	}
+
+	if (*s-0x80u >= 0x40) goto ilseq;
+	c = c<<6 | *s++-0x80;
+	if (!(c&(1U<<31))) {
+		*wc = c;
+		return 3;
+	}
+
+	if (*s-0x80u >= 0x40) goto ilseq;
+	*wc = c<<6 | *s++-0x80;
+	return 4;
+
+ilseq:
+	errno = EILSEQ;
+	return -1;
+}
+
+static int internal_wcwidth(wchar_t wc)
+{
+	if (wc < 0xff)
+		return (wc+1 & 0x7f) >= 0x21 ? 1 : wc ? -1 : 0;
+	if ((wc & 0xfffeffffU) < 0xfffe) {
+		if ((table[table[wc>>8]*32+((wc&255)>>3)]>>(wc&7))&1)
+			return 0;
+		if ((wtable[wtable[wc>>8]*32+((wc&255)>>3)]>>(wc&7))&1)
+			return 2;
+		return 1;
+	}
+	if ((wc & 0xfffe) == 0xfffe)
+		return -1;
+	if (wc-0x20000U < 0x20000)
+		return 2;
+	if (wc == 0xe0001 || wc-0xe0020U < 0x5f || wc-0xe0100U < 0xef)
+		return 0;
+	return 1;
+}
+
+#define mbtowc internal_mbtowc
+#define wcwidth internal_wcwidth
+
+#endif
+
+ssize_t utf8_nsyms(const char *str, size_t len)
+{
+	size_t nsyms = 0;
+	size_t ofs = 0;
+
+	while (ofs < len) {
+		wchar_t sym;
+		int ret;
+
+		ret = mbtowc(&sym, str + ofs, len - ofs);
+		if (ret <= 0) {
+			ret = 1;
+			sym = 'A';
+		} else if ((size_t)ret > len) {
+			ret = len;
+		}
+
+		ofs += ret;
+		ret = wcwidth(sym);
+		if (ret < 0)
+			continue;
+
+		nsyms += ret;
+	}
+
+	return nsyms;
+}

package/utils/ucode-mod-uline/src/vt100.c

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: ISC
+/*
+ * Copyright (C) 2025 Felix Fietkau <[email protected]>
+ */
+#include <string.h>
+#include <stdlib.h>
+#include "uline.h"
+#include "private.h"
+
+enum vt100_escape vt100_esc_decode(const char *str)
+{
+	unsigned long code;
+	size_t idx;
+
+	switch (*(str++)) {
+	case 0:
+		return VT100_INCOMPLETE;
+	case '[':
+	case 'O':
+		switch (*(str++)) {
+		case 0:
+			return VT100_INCOMPLETE;
+		case 'A':
+			return VT100_CURSOR_UP;
+		case 'B':
+			return VT100_CURSOR_DOWN;
+		case 'C':
+			return VT100_CURSOR_RIGHT;
+		case 'D':
+			return VT100_CURSOR_LEFT;
+		case 'F':
+			return VT100_END;
+		case 'H':
+			return VT100_HOME;
+		case '5':
+			switch (*str) {
+			case 'C':
+				return VT100_CURSOR_WORD_RIGHT;
+			case 'D':
+				return VT100_CURSOR_WORD_LEFT;
+			default:
+				break;
+			}
+			/* fallthrough */
+		case '0' ... '4':
+		case '6' ... '9':
+			str--;
+			idx = strspn(str, "0123456789");
+			if (!str[idx])
+				return VT100_INCOMPLETE;
+			if (str[idx] != '~')
+				return VT100_UNKNOWN;
+			code = strtoul(str, NULL, 10);
+			switch (code) {
+			case 1:
+				return VT100_HOME;
+			case 3:
+				return VT100_DELETE;
+			case 4:
+				return VT100_END;
+			case 200:
+			case 201:
+				// paste start/end
+				return VT100_IGNORE;
+			default:
+				return VT100_UNKNOWN;
+			}
+		default:
+			return VT100_UNKNOWN;
+		}
+	default:
+		return VT100_UNKNOWN;
+	}
+}
+
+void __vt100_csi_num(FILE *out, int num, char code)
+{
+	fprintf(out, "\e[%d%c", num, code);
+}
+
+void __vt100_esc(FILE *out, char c)
+{
+	char seq[] = "\eX";
+	seq[1] = c;
+	fputs(seq, out);
+}
+
+void __vt100_csi2(FILE *out, char c1, char c2)
+{
+	char seq[] = "\e[XX";
+
+	seq[2] = c1;
+	seq[3] = c2;
+	fputs(seq, out);
+}