cli: add OpenWrt CLI

This provides an easy to use modular CLI that can be used to interact with
OpenWrt services. It has full support for context sensitive tab completion
and help.
Extra modules can be provided by packages and can extend the existing node
structure in any place.

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

package/utils/cli/Makefile

@@ -0,0 +1,35 @@
+#
+# Copyright (C) 2025 OpenWrt.org
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=cli
+PKG_RELEASE:=$(AUTORELEASE)
+
+PKG_LICENSE:=GPL-2.0
+PKG_MAINTAINER:=Felix Fietkau <[email protected]>
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/cli
+  SECTION:=utils
+  CATEGORY:=Utilities
+  TITLE:=OpenWrt CLI
+  DEPENDS:=+ucode +ucode-mod-uline \
+	+ucode-mod-ubus +ucode-mod-uloop \
+	+ucode-mod-fs +ucode-mod-rtnl
+endef
+
+define Build/Compile
+	:
+endef
+
+define Package/cli/install
+	$(CP) ./files/* $(1)/
+endef
+
+$(eval $(call BuildPackage,cli))

package/utils/cli/docs/MODULE-API.md

@@ -0,0 +1,364 @@
+ Design of the `cli` module API
+
+## Structure:
+The cli is organized as a set of *nodes*, which are ucode objects objects describing *entries*.
+Each *entry* can either implement a *command*, or select another *node*, optionally with *parameters*.
+Additionally, it contains helptext and full *parameter* descriptions, including everything needed for tab completion.
+The initial *node* on startup is `Root`, representing the main menu.
+
+## Simple example:
+
+### Code:
+```
+const Example = {
+	hello: {
+		help: "Example command",
+		args: [
+			{
+				name: "name",
+				type: "string",
+				min: 3,
+				max: 16,
+				required: true,
+			}
+		],
+		call: function(ctx, argv, named) {
+			return ctx.ok("Hello, " + argv[0]);
+		},
+	},
+	hello2: {
+		help: "Example command (named_args version)",
+		named_args: {
+			name: {
+				required: true,
+				args: {
+					type: "string",
+					min: 3,
+					max: 16,
+				}
+			}
+		},
+		call: function(ctx, argv, named) {
+			return ctx.ok("Hello, " + named.name);
+		},
+	}
+};
+
+const Root = {
+	example: {
+		help: "Example node",
+		select_node: "Example",
+	}
+};
+
+model.add_nodes({ Root, Example });
+```
+### Example interaction:
+```
+root@OpenWrt:~# cli
+Welcome to the OpenWrt CLI. Press '?' for help on commands/arguments
+cli> example 
+cli example> hello
+Error: Missing argument 1: name
+cli example> hello foo
+Hello, foo
+cli example> hello2
+Error: Missing argument: name
+cli example> hello2 name foo2
+Hello, foo2
+cli example> 
+```
+
+## API documentation:
+
+Each module is placed in `/usr/share/ucode/cli/modules` on the root filesystem.
+When included by the cli code, the scope contains the `model` variable, which is the main cli API object. This variable is also present in the scope of the other callback functions described below.
+
+### `model` methods:
+- `model.warn(msg)`: Pass a warning to the user (similar to the ucode `warn` function).
+- `model.exception(e)`: Print an exception with stack trace.
+- `model.add_module(path)`: Load a single module from `path`
+- `model.add_modules(path)`: Load multiple modules from the `path` wildcard pattern
+- `model.add_node(name, obj)`: Add a single node under the given name
+- `model.add_nodes(nodes)`: Add multiple nodes with taking `name` and `obj` from the `nodes` object.
+- `model.add_type(name, info)`: Add a data type with validation information,
+- `model.add_types(types)`: Add multiple data types, taking `name` and `info` from the `types` object.
+- `model.status_msg(msg)`: Print an asynchronous status message (should not be used from within a node `call` or `select` function).
+
+### Properties of an `entry` inside a `node`:
+Each entry must have at least `help` and either `call` or `select_node` set. 
+- `help`: Helptext describing the command
+- `call: function(ctx, argv, named)`: main command handler function of the entry.
+	- `this`: pointer to the `entry`
+	- `ctx`: call context object (see below)
+	- `argv`: array of positional arguments after the command name
+	- `named`: object of named parameters passed to the command
+	- Return value: either `ctx.ok(msg)` for successfull calls, or the result of an error function (see below).
+- `select_node`: (string) name of the *node* that this entry points to. Mutually exclusive with implementing `call`.
+- `select: function(ctx, argv, named)`: function for selecting another node.
+	- `this`: pointer to the *entry*
+	- `ctx`: node context object (see below)
+	- `argv`, `named`: see `call`
+	- Return value: either `ctx.set(prompt, data)`, `true`, or the result of an error function (see below).
+- `args`: array of positional *arguments* (see *argument* property description)
+- `named_args`: object of named *parameters*  (see *parameter* property description)
+- `available: function(ctx)`: function indicating if the entry can be used (affects tab completion and running commands)
+	- `this`: pointer to the *entry*
+	- `ctx`: node context object (see below)
+	- Return value: `true` if available, `false` otherwise.
+- `validate: function (ctx, argv, named)`: validate command arguments
+	- Function parameters: see `call`
+
+### Named *parameter* properties:
+- `help`: Description of the named parameter's purpose
+- `args`: Either an array of *argument* objects, or an object with a single *argument* (see below). If not set, paramter will not take any arguments, and its value will be `true` if the parameter was specified on the command line.
+- `available: function(ctx, argv, named)`: function indicating if the named parameter can be used (affects tab completion and argument validation). May depend on *arguments*/*parameters* specified before this one.
+- `multiple` (bool): indicates if an argument may be specified multiple times. Turns the value in `named` into an array.
+- `required` (bool): Parameter must be specified for the command
+- `default`: default value for the parameter.
+- `allow_empty`: empty values are allowed and can be specified on the command line using `-param_name` instead of `param_name`. The value in the `named` object will be `null` in that case.
+
+### Positional *argument* properties:
+- `name`: Short name of the *argument*
+- `help`: Longer description of the *argument* (used in helptext/completion)
+- `type`: data type name (see below)
+- `required` (bool): Value must not be empty
+- `value`: possible values for tab completion, one of:
+	- array of objects with the following contents:
+		- `name`: value string
+		- `help`: help text for this value
+	- `function(ctx, argv, named)` returning the above.
+- extra properties specific to the data type (see below)
+
+### Default data types:
+- `int`: Integer value. The valid range can be specified using the `min` and `max` properties.
+- `string`: String value. The valid string length can be specified using the `min` and `max` properties.
+- `bool`: Boolean value. Converts `"1"` and `"0"` to `true` and `false`
+- `enum`: String value that must match one entry of the list provided via the `value` property. Case-insensitive match can be enabled using the `ignore_case` property.
+- `path`: Local filesystem path. When the `new_path` property is set, only match directories for a file to be created.
+- `host`: Host name or IP address
+- `macaddr`: MAC address
+- `ipv4`: IPv4 address
+- `ipv6`: IPv6 address
+- `cidr4`: IPv4 address with netmask size, e.g. 192.168.1.1/24. Allows `auto` as value if the `allow_auto` property is set.
+
+### `call` context:
+Passed as `ctx` argument to entry `call` functions.
+- `ctx.data`: Object containing any data passed via `ctx.set()` from a `select` context.
+- `ctx.ok(msg)`: Indicates successful call, passes the message `msg` to the user.
+- `ctx.select(...args)`: After completion, switch to a different *node* by running the command chain provided as function argument (only entries with `.select_node` are supported).
+- `ctx.string(name, val)`: Passes a string to the caller as return value.
+- `ctx.list(name, val)`: Passes a list of values to the caller as return value. `val` must be an array.
+- `ctx.table(name, val)`: Passes a table as value to the caller. `val` can be an array `[ column_1, column_2 ]`, where each member of the outer array describes a row in the table. It can also be an object, where the property name is the first column value, and the value the second column value.
+- `ctx.multi_table(name, val)`: Passes multiple tables to the caller. Can be an array of `[ title, table ]`, or an object.
+- Error functions (see below)
+
+### `select` context:
+- `ctx.data`: Object containing any data passed via parent `ctx.set` calls.
+- `ctx.set(prompt, data)`: Modify the prompt and `ctx.data` for the child context. The string given in `prompt` is appended to the existing prompt. The data given in the `data` object is merged with the previous `ctx.data` value.
+- Error functions (see below)
+
+### Error functions:
+All error messages accept a format string in `msg`, with arguments added after it.
+- `ctx.invalid_argument(msg, ...args)`: Indicates that invalid arguments were provided.
+- `ctx.missing_argument(msg, ...args)`: Indicates that an expected argument was missing.
+- `ctx.command_failed(msg, ...args)`: Indicates that the command failed.
+- `ctx.not_found(msg, ...args)`: Indicates that a given entry was not found.
+- `ctx.unknown_error(msg, ...args)`: Indicates that the command failed for unknown or unspecified reasons.
+- `ctx.error(id, msg, ...args)`: Generic error message with `id` specifying a machine readable error type string.
+
+## Editor API documentation
+The editor API provides a layer of abstraction above node entries/calls in order to make it easy to edit properties of an object based on an attribute list, as well as create/destroy/show object instances using a consistent user interface.
+
+### Simple example:
+```
+import * as editor from "cli.object-editor";
+
+let changed = false;
+let data = {
+	things: {
+		foo: {
+			label_str: [ "bar" ],
+			id: 31337,
+		}
+	},
+};
+
+const thing_editor = {
+	change_cb: function(ctx) {
+		changed = true;
+	},
+	named_args: {
+		label: {
+			help: "Thing label",
+			attribute: "label_str",
+			multiple: true,
+			args: {
+				type: "string",
+				min: 2,
+				max: 16
+			},
+		},
+		id: {
+			help: "Thing id",
+			required: true,
+			args: {
+				type: "int",
+				min: 1,
+			},
+		},
+	},
+};
+const ExampleThing = editor.new(thing_editor);
+
+let Example = {
+	dump: {
+		help: "Dump current data",
+		call: function(ctx, argv, named) {
+			return ctx.json("Data", {
+				changed,
+				data
+			});
+		},
+	}
+};
+const example_editor = {
+	change_cb: function(ctx) {
+		changed = true;
+	},
+	types: {
+		thing: {
+			node_name: "ExampleThing",
+			node: ExampleThing,
+			object: "things",
+		},
+	},
+};
+editor.edit_create_destroy(example_editor, Example);
+
+const Root = {
+	example: {
+		help: "Example node",
+		select_node: "Example",
+		select: function(ctx, argv, named) {
+			return ctx.set(null, {
+				object_edit: data,
+			});
+		}
+	}
+};
+
+model.add_nodes({ Root, Example, ExampleThing });
+```
+### Example interaction:
+```
+root@OpenWrt:~# cli
+Welcome to the OpenWrt CLI. Press '?' for help on commands/arguments
+cli> example
+cli example> dump
+Data: {
+        "changed": false,
+        "data": {
+                "things": {
+                        "foo": {
+                                "label_str": [
+                                        "bar"
+                                ],
+                                "id": 31337
+                        }
+                }
+        }
+}
+cli example> thing foo set id 1337
+cli example> create thing bar id 168 label l1 label l2
+Added thing 'bar'
+cli example> thing bar show
+Values: 
+    id:         168
+    label:      l1, l2
+cli example> thing bar remove label 1
+cli example> thing bar show
+Values: 
+    id:         168
+    label:      l2
+cli example> dump
+Data: {
+        "changed": true,
+        "data": {
+                "things": {
+                        "foo": {
+                                "label_str": [
+                                        "bar"
+                                ],
+                                "id": 1337
+                        },
+                        "bar": {
+                                "id": 168,
+                                "label_str": [
+                                        "l2"
+                                ]
+                        }
+                }
+        }
+}
+cli example> destroy thing foo 
+Deleted thing 'foo'
+cli example> 
+```
+### API documentation
+Prelude: `import * as editor from "cli.object-editor";`
+
+#### Object editor:
+For editing an object, the following user commands are defined:
+- `set`: Changes property values
+- `show` Show all values
+
+If properties with `multiple: true` are defined, the following commands are also defined:
+- `add`: Add values to properties
+- `remove` Remove specific values from properties
+
+##### Variant 1 (editor-only node):
+`const Node = editor.new(editor_data)`
+
+##### Variant 2 (merge with existing entries):
+`let Node = {};`
+`editor.new(editor_data, Node);`
+
+The editor code assumes that the *node* that selects the editor node uses `ctx.set()` to set the `edit` field in `ctx.data` to the object being edited.
+
+#### `editor_data` properties:
+- `change_cb: function(ctx)`: Called whenever a property is changed by the user
+- `named_args`: Parameters for editing properties (based on *entry* `named_args`, see below)
+- `add`, `set`, `show`, `remove`: Object for overriding fields of the commands defined by the editor. Primarily used to override the helptext.
+
+#### Instance editor `named_args` entry properties:
+All *entry* `named_args` properties are supported, but the meaning is extended slightly:
+- `multiple`: Property array values can be added/removed
+- `default`: Default value when creating the object
+- `allow_empty`: Property can be deleted
+- `required`: Property is mandatory in the object.
+
+#### Object instance editor:
+For managing object instances, the following user commands are defined:
+- `create <type> <name> <...>`: Create a new instance. Also takes parameter values to be set on the object.
+- `destroy <type> <name>`: Delete an instance.
+- `list <type>` List all instances of a given type.
+
+The instance editor code assumes that the *node* that selects the editor node uses `ctx.set()` to set the `object_edit` field in `ctx.data` to the object being edited.
+
+##### Variant 1 (editor-only node):
+`const Node = editor.edit_create_destroy(instance_data);`
+
+##### Variant 2 (merge with existing entries):
+`let Node = {};`
+`editor.edit_create_destroy(instance_data, Node);`
+
+#### `instance_data` properties:
+- `change_cb: function(ctx)`: Called whenever an instance is added or deleted
+- `types`: Metadata about instances types (see below)
+
+#### `instance_data.types` object properties:
+- `node_name`: name of the *editor node* belonging to the object instance.
+- `node`: The *editor node* itself.
+- `object`: Name of the type specific container object inside the object pointed to by `ctx.data.object_edit`. 
+

package/utils/cli/files/usr/sbin/cli

@@ -0,0 +1,741 @@
+#!/usr/bin/env ucode
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+import * as datamodel from "cli.datamodel";
+import { bold, color_fg } from "cli.color";
+import * as uline from "uline";
+import { basename, stdin } from "fs";
+
+let history = [];
+let history_edit;
+let history_idx = -1;
+let cur_line;
+let interactive;
+let script_mode;
+
+let el;
+let model = datamodel.new({
+	getpass: uline.getpass,
+	poll_key: (timeout) => el.poll_key(timeout),
+	status_msg: (msg) => {
+		el.hide_prompt();
+		warn(msg + "\n");
+		el.refresh_prompt();
+	},
+});
+let uloop = model.uloop;
+model.add_modules();
+let ctx = model.context();
+let parser = uline.arg_parser({
+	line_separator: ";"
+});
+let base_prompt = [ "cli" ];
+
+model.add_nodes({
+	Root: {
+		exit: {
+			help: "Exit the CLI",
+			call: function(ctx) {
+				el.close();
+				uloop.end();
+				interactive = false;
+			}
+		}
+	}
+});
+
+model.init();
+
+function update_prompt() {
+	el.set_state({
+		prompt: bold(join(" ", [ ...base_prompt, ...ctx.prompt ]) + "> "),
+	});
+}
+
+let cur_completion, tab_arg, tab_arg_len, tab_prefix, tab_suffix, tab_prefix_len, tab_quote, tab_ctx;
+
+function max_len(list, len)
+{
+	for (let entry in list)
+		if (length(entry) > len)
+			len = length(entry);
+	return len + 3;
+}
+
+function sort_completion(data)
+{
+	let categories = {};
+	for (let entry in data) {
+		let cat = entry.category ?? " ";
+		categories[cat] ??= [];
+		push(categories[cat], entry);
+	}
+	return categories;
+}
+
+function val_str(val)
+{
+	if (type(val) == "array")
+		return join(", ", val);
+	return val;
+}
+
+function helptext_list_str(cur, str)
+{
+	let data = cur.value;
+	let categories = sort_completion(data);
+	let cat_len = max_len(keys(categories));
+	let has_categories = length(categories) > 1 || !categories[" "];
+	let len = max_len(map(data, (v) => v.name), 10);
+
+	if (has_categories || str == null)
+		str = "";
+
+	for (let cat, cdata in categories) {
+		if (has_categories && cat != " ") {
+			if (length(str) > 0)
+				str += "\n";
+			str += `${cat}:\n`;
+		}
+
+		for (let val in cdata) {
+			let name = val.name;
+			let help = val.help ?? "";
+			let extra = [];
+			if (val.multiple)
+				push(extra, "multiple");
+			if (val.required)
+				push(extra, "required");
+			if (val.default)
+				push(extra, "default: " + val_str(val.default));
+			if (length(extra) > 0)
+				help += " (" + join(", ", extra) + ")";
+			if (length(help) > 0)
+				name += ":";
+			str += sprintf("  %-" + len + "s %s\n", name, help);
+		}
+	}
+
+	return str;
+}
+
+function helptext(cur) {
+	if (!cur) {
+		el.set_hint(`\n  No help information available\n`);
+		return true;
+	}
+
+	let str = `${cur.help}: `;
+	let data = cur.value;
+	if (type(data) != "array") {
+		str += `<${cur.type}>\n`;
+	} else if (length(data) > 0) {
+		str += "\n";
+		str = helptext_list_str(cur, str);
+	} else {
+		str += " (no match)\n";
+	}
+	el.set_hint(str);
+	return true;
+}
+
+function completion_ctx(arg_info)
+{
+	let cur_ctx = ctx;
+	for (let args in arg_info.args) {
+		let sel = cur_ctx.select(args, true);
+		if (!length(args))
+			cur_ctx = sel;
+		if (type(sel) != "object" || sel.errors)
+			return;
+	}
+
+	return cur_ctx;
+}
+
+function completion_replace_arg(val, incomplete, skip_space)
+{
+	let ref = substr(tab_prefix, -tab_prefix_len);
+	val = parser.escape(val, ref);
+
+	if (incomplete) {
+		let last = substr(val, -1);
+		if (last == '"' || last == "'")
+			val = substr(val, 0, -1);
+	} else if (!skip_space) {
+		val += " ";
+	}
+
+	let line = tab_prefix;
+	if (tab_prefix_len)
+		line = substr(tab_prefix, 0, -tab_prefix_len);
+	line += val;
+	let pos = length(line);
+	line += tab_suffix;
+	el.set_state({ line, pos });
+}
+
+function completion_check_prefix(data)
+{
+	let prefix = data[0].name;
+	let prefix_len = length(prefix);
+
+	for (let entry in data) {
+		entry = entry.name;
+		if (prefix_len > length(entry))
+			prefix_len = length(entry);
+	}
+	prefix = substr(prefix, 0, prefix_len);
+
+	for (let entry in data) {
+		entry = substr(entry.name, 0, prefix_len);
+		while (entry != prefix) {
+			prefix_len--;
+			prefix = substr(prefix, 0, prefix_len);
+			entry = substr(entry, 0, prefix_len);
+		}
+	}
+
+	completion_replace_arg(prefix, true);
+}
+
+function completion(count) {
+	if (count < 2) {
+		let line_data = el.get_line();
+		let line = line_data.line;
+		let pos = line_data.pos;
+		tab_suffix = substr(line, pos);
+		if (length(tab_suffix) > 0 &&
+			substr(tab_suffix, 0, 1) != " ") {
+			let idx = index(tab_suffix, " ");
+			if (idx < 0 || !idx)
+				pos += length(tab_suffix);
+			else
+				pos += idx;
+
+			tab_suffix = substr(line, pos);
+		}
+		tab_prefix = substr(line, 0, pos);
+
+		let arg_info = parser.parse(tab_prefix);
+		let is_open = arg_info.missing != null;
+		if (arg_info.missing == "\\\"")
+			tab_quote = "\"";
+		else
+			tab_quote = arg_info.missing ?? "";
+		let args = pop(arg_info.args);
+		let arg_pos = pop(arg_info.pos);
+
+		if (!is_open && substr(tab_prefix, -1) == " ")
+			push(args, "");
+		let tab_arg_pos = arg_pos[length(args) - 1];
+		tab_arg = args[length(args) - 1];
+		if (tab_arg_pos)
+			tab_prefix_len = tab_arg_pos[1] - tab_arg_pos[0];
+		else
+			tab_prefix_len = 0;
+
+		tab_ctx = completion_ctx(arg_info);
+		if (!tab_ctx)
+			return;
+
+		cur_completion = tab_ctx.complete([...args]);
+	}
+
+	if (!tab_ctx)
+		return;
+
+	if (count < 0 || (cur_completion && cur_completion.force_helptext))
+		return helptext(cur_completion);
+
+	let cur = cur_completion;
+	if (!cur || !cur.value) {
+		if (!tab_prefix_len) {
+			el.set_hint("");
+			return;
+		}
+
+		cur = {
+			value: [{
+				name: tab_arg,
+			}]
+		};
+	}
+
+	let data = cur.value;
+	if (length(data) == 0) {
+		el.set_hint(`  (no match)`);
+		return;
+	}
+
+	if (length(data) == 1) {
+		completion_replace_arg(data[0].name, data[0].incomplete);
+		el.set_hint("");
+		el.reset_key_input();
+		return;
+	}
+
+	if (count == 1)
+		completion_check_prefix(data);
+
+	if (count > 1) {
+		let idx = (count - 2) % length(data);
+		completion_replace_arg(data[idx].name, false, true);
+	}
+
+	let win = el.get_window();
+	let str = "";
+	let x = 0;
+
+	let categories = sort_completion(data);
+	let cat_len = max_len(keys(categories));
+	let len = max_len(map(data, (v) => v.name));
+	let has_categories = length(categories) > 1 || !categories[" "];
+
+	for (let cat, cdata in categories) {
+		let cat_start = cat != " ";
+		if (cat_start)
+			cat += ": ";
+
+		if (x) {
+			str += "\n";
+			x = 0;
+		}
+		for (let entry in cdata) {
+			let add;
+
+			if (!x && has_categories)
+				add = sprintf("  %-"+cat_len+"s", cat);
+			else
+				add = "    ";
+			cat = "";
+
+			add += sprintf("%-"+len+"s", entry.name);
+			str += add;
+			x += length(add);
+
+			if (x + length(add) < win.x)
+				continue;
+
+			str += "\n";
+			x = 0;
+		}
+	}
+	el.set_hint(str);
+}
+
+function format_entry(val)
+{
+	if (type(val) == "bool")
+		val = val ? "yes" : "no";
+	return val;
+}
+
+function format_multiline(prefix, val)
+{
+	let prefix2 = replace(prefix, /./g, " ");
+	let prefix_len = length(prefix);
+	let win = el.get_window();
+	let x = 0;
+
+	if (type(val) != "array")
+		val = [ val ];
+
+	for (let cur in val) {
+		cur = format_entry(cur);
+		let cur_lines = split(cur, "\n");
+		if (length(cur_lines) > 1) {
+			if (x) {
+				warn(',\n');
+				x = 0;
+			}
+
+			cur = join("\n" + prefix2, cur_lines);
+			warn(cur);
+			x = win.x;
+			prefix = null;
+			continue;
+		}
+
+		if (x && (x + length(cur) > win.x - 3)) {
+			warn(',\n');
+			x = 0;
+		}
+
+		if (!x) {
+			warn(prefix ?? prefix2);
+			prefix = null;
+			x = prefix_len;
+		} else {
+			warn(', ');
+			x += 2;
+		}
+
+		warn(cur);
+		x += length(cur);
+	}
+	warn('\n');
+}
+
+function format_table(table)
+{
+	let data = table;
+
+	let len = max_len(map(data, (v) => v[0]), 8);
+	for (let line in data) {
+		let name = line[0];
+		let val = line[1];
+		let prefix = sprintf("    %-" + len + "s ", name + ":");
+		format_multiline(prefix, val);
+	}
+}
+
+function convert_table(val)
+{
+	if (type(val) == "array")
+		return val;
+
+	let data = [];
+	for (let name in sort(keys(val)))
+		push(data, [ name, val[name] ]);
+
+	return data;
+}
+
+function convert_multi_table(val)
+{
+	if (type(val) != "array") {
+		let data = [];
+		for (let name in sort(keys(val)))
+			push(data, [ val[name], name ]);
+		val = data;
+	}
+
+	for (let line in val)
+		line[0] = convert_table(line[0]);
+
+	return val;
+}
+
+function format_result(res)
+{
+	if (!res) {
+		warn(color_fg("red", "Unknown command") + "\n");
+		return;
+	}
+	if (!res.ok) {
+		for (let err in res.errors) {
+			warn(color_fg("red", "Error: "+ err.msg) + "\n");
+		}
+		if (!length(res.errors))
+			warn(color_fg("red", "Failed") + "\n");
+		return;
+	}
+
+	if (res.status_msg)
+		warn(color_fg("green", res.status_msg) + "\n");
+
+	if (res.name)
+		warn(res.name + ": ");
+
+	let data = res.data;
+	switch (res.type) {
+	case "multi_table":
+		data = convert_multi_table(data);
+		warn("\n");
+		for (let table in data) {
+			if (table[1])
+				warn("\n" + table[1] + ":\n");
+			format_table(table[0]);
+			warn("\n");
+		}
+		break;
+	case "table":
+		data = convert_table(data);
+		warn("\n");
+		format_table(data);
+		break;
+	case "list":
+		warn("\n");
+		for (let entry in data)
+			warn("  - " + entry + "\n");
+		break;
+	case "string":
+		warn(res.data + "\n");
+		break;
+	case "json":
+		warn(sprintf("%.J\n", res.data));
+		break;
+	}
+}
+
+function line_history_reset()
+{
+	history_idx = -1;
+	history_edit = null;
+	cur_line = null;
+}
+
+function line_history(dir)
+{
+	let min_idx = cur_line == null ? 0 : -1;
+	let new_idx = history_idx + dir;
+
+	if (new_idx < min_idx || new_idx >= length(history))
+		return;
+
+	let line = el.get_line().line;
+	let cur_history = history_edit ?? history;
+	if (history_idx == -1)
+		cur_line = line;
+	else if (cur_history[history_idx] != line) {
+		history_edit ??= [ ...history ];
+		history_edit[history_idx] = line;
+		cur_history = history_edit;
+	}
+
+	history_idx = new_idx;
+	if (history_idx < 0)
+		line = cur_line;
+	else
+		line = cur_history[history_idx];
+	let pos = length(line);
+	el.set_state({ line, pos });
+
+}
+let rev_search, rev_search_results, rev_search_index;
+
+function reverse_search_update(line)
+{
+	if (line) {
+		rev_search = line;
+		rev_search_results = filter(history, (l) => index(l, line) >= 0);
+		rev_search_index = 0;
+	}
+
+	let prompt = "reverse-search: ";
+	if (line && !length(rev_search_results))
+		prompt = "failing " + prompt;
+
+	el.set_state({
+		line2_prompt: prompt,
+	});
+
+	if (line && length(rev_search_results)) {
+		line = rev_search_results[0];
+		let pos = length(line);
+		el.set_state({ line, pos });
+	}
+}
+
+function reverse_search_reset() {
+	if (rev_search == null)
+		return;
+	rev_search = null;
+	rev_search_results = null;
+	rev_search_index = 0;
+	el.set_state({
+		line2_prompt: null
+	});
+}
+
+function reverse_search()
+{
+	if (rev_search == null) {
+		reverse_search_update("");
+		return;
+	}
+
+	if (!length(rev_search_results))
+		return;
+
+	rev_search_index = (rev_search_index + 1) % length(rev_search_results);
+	let line = rev_search_results[rev_search_index];
+	let pos = length(line);
+	el.set_state({ line, pos });
+}
+
+function line_cb(line)
+{
+	reverse_search_reset();
+	line_history_reset();
+	unshift(history, line);
+
+	let arg_info = parser.parse(line);
+	if (!arg_info)
+		return;
+	for (let cmd in arg_info.args) {
+		let orig_cmd = [ ...cmd ];
+
+		// convenience hack
+		if (cmd[0] == "cd" && cmd[1] == "..") {
+			shift(cmd);
+			cmd[0] = "up";
+		} else if (cmd[0] == "ls") {
+			let compl = ctx.complete([""]);
+			if (!compl)
+				continue;
+
+			warn(helptext_list_str(compl));
+			continue;
+		}
+
+		let cur_ctx = ctx.select(cmd);
+		if (type(cur_ctx) != "object" || cur_ctx.errors) {
+			format_result(cur_ctx);
+			break;
+		}
+
+		if (!length(cmd)) {
+			ctx = cur_ctx;
+			update_prompt();
+			continue;
+		}
+
+		try {
+			let res = cur_ctx.call(cmd);
+			format_result(res);
+			if (res && res.ctx) {
+				ctx = res.ctx;
+				update_prompt();
+			}
+		} catch (e) {
+			model.exception(e);
+		}
+	}
+}
+
+const cb = {
+	eof: () => { warn(`\n`); uloop.end(); },
+	line_check: (line) => parser.check(line) == null,
+	line2_cursor: () => {
+		reverse_search_reset();
+		return false;
+	},
+	line2_update: reverse_search_update,
+	key_input: (c, count) => {
+		try {
+			switch(c) {
+			case "?":
+				if (parser.check(el.get_line().line) != null)
+					return false;
+				completion(-1);
+				return true;
+			case "\t":
+				reverse_search_reset();
+				completion(count);
+				return true;
+			case '\x03':
+				if (count < 2) {
+					el.set_state({ line: "", pos: 0 });
+				} else if (ctx.prev) {
+					warn(`\n`);
+					let cur_ctx = ctx.select([ "main" ]);
+					if (cur_ctx && !cur_ctx.errors)
+						ctx = cur_ctx;
+					update_prompt();
+				} else {
+					warn(`\n`);
+					el.poll_stop();
+					uloop.end();
+				}
+				return true;
+			case "\x12":
+				reverse_search();
+				return true;
+			}
+		} catch (e) {
+			warn(`${e}\n${e.stacktrace[0].context}`);
+		}
+	},
+	cursor_up: () => {
+		try {
+			line_history(1);
+		} catch (e) {
+			el.set_hint(`${e}\n${e.stacktrace[0].context}`);
+		}
+	},
+	cursor_down: () => {
+		try {
+			line_history(-1);
+		} catch (e) {
+			el.set_hint(`${e}\n${e.stacktrace[0].context}`);
+		}
+	},
+};
+el = uline.new({
+	utf8: true,
+	cb,
+	key_input_list: [ "?", "\t", "\x03", "\x12" ]
+});
+
+while (length(ARGV) > 0) {
+	let cmd = ARGV[0];
+	if (substr(cmd, 0, 1) != "-")
+		break;
+
+	shift(ARGV);
+	switch (cmd) {
+	case '-i':
+		interactive = true;
+		break;
+	case '-s':
+		script_mode = true;
+		break;
+	}
+}
+
+if (SCRIPT_NAME != "cli") {
+	let cur_ctx = ctx.select([ basename(SCRIPT_NAME) ]);
+	if (cur_ctx && cur_ctx != ctx && !cur_ctx.errors) {
+		ctx = cur_ctx;
+		delete ctx.prev;
+		ctx.node.exit = model.node.Root.exit;
+		base_prompt = [];
+	}
+}
+
+while (length(ARGV) > 0) {
+	let cmd = ARGV;
+	let idx = index(ARGV, ":");
+	if (idx >= 0) {
+		cmd = slice(ARGV, 0, idx);
+		ARGV = slice(ARGV, idx + 1);
+	} else {
+		ARGV = [];
+	}
+	interactive ??= false;
+
+	let orig_cmd = [ ...cmd ];
+	let cur_ctx = ctx.select(cmd);
+	if (type(cur_ctx) != "object" || cur_ctx.errors) {
+		format_result(cur_ctx);
+		break;
+	}
+
+	if (!length(cmd)) {
+		ctx = cur_ctx;
+		continue;
+	}
+
+	let res = cur_ctx.call(cmd);
+	format_result(res);
+}
+
+if (script_mode) {
+	el.close();
+	while (!stdin.error()) {
+		let line = stdin.read("line");
+		line_cb(line);
+	}
+	exit(0);
+}
+
+if (interactive != false) {
+	warn("Welcome to the OpenWrt CLI. Press '?' for help on commands/arguments\n");
+	update_prompt();
+	el.set_uloop(line_cb);
+	uloop.run();
+	exit(0);
+}

package/utils/cli/files/usr/share/ucode/cli/cache.uc

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+const CACHE_DEFAULT_TIMEOUT = 5;
+
+function cache_get(key, fn, timeout)
+{
+	let now = time();
+	let entry = this.entries[key];
+	if (entry) {
+		if (now < entry.timeout)
+			return entry.data;
+
+		if (!fn)
+			delete this.entries[key];
+	}
+
+	if (!fn)
+		return;
+
+	let data = fn();
+	if (!entry)
+		this.entries[key] = entry = {};
+	timeout ??= CACHE_DEFAULT_TIMEOUT;
+	entry.timeout = now + timeout;
+	entry.data = data;
+
+	return data;
+}
+
+function cache_remove(key)
+{
+	delete this.entries[key];
+}
+
+function cache_gc() {
+	let now = time();
+	for (let key, entry in this.entries)
+		if (now > entry.timeout)
+			delete this.entries[key];
+}
+
+const cache_proto = {
+	get: cache_get,
+	remove: cache_remove,
+	gc: cache_gc,
+};
+
+export function new(model) {
+	model.cache_proto ??= { model, ...cache_proto };
+	let cache = proto({
+		entries: {},
+	}, model.cache_proto);
+	cache.gc_interval = model.uloop.interval(10000, () => {
+		cache.gc();
+	});
+
+	return cache;
+};

package/utils/cli/files/usr/share/ucode/cli/color.uc

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+const color_codes = {
+	black: 30,
+	red: 31,
+	green: 32,
+	yellow: 33,
+	blue: 34,
+	magenta: 35,
+	cyan: 36,
+	white: 37,
+	default: 39
+};
+
+function color_str(n)
+{
+	return "\e["+n+"m";
+}
+
+function color_code(str)
+{
+	let n = 0;
+	if (substr(str, 0, 7) == "bright_") {
+		str = substr(str, 7);
+		n += 60;
+	}
+	if (!color_codes[str])
+		return;
+
+	n += color_codes[str];
+	return n;
+}
+
+export function color_fg(name, str)
+{
+	let n = color_code(name);
+	if (!n)
+		return str;
+
+	let ret = color_str(n);
+	if (str != null)
+		ret += str + color_str(39);
+
+	return ret;
+};
+
+export function color_bg(name, str)
+{
+	let n = color_code(name);
+	if (!n)
+		return str;
+
+	let ret = color_str(n + 10);
+	if (str != null)
+		ret += str + color_str(49);
+
+	return ret;
+};
+
+export function bold(str)
+{
+	return color_str(1) + str + color_str(0);
+};

package/utils/cli/files/usr/share/ucode/cli/context-call.uc

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+function default_result()
+{
+	return {
+		errors: [],
+		ok: false
+	};
+}
+
+function context_clone()
+{
+	let ret = { ...this };
+	ret.result = default_result();
+	ret.data = { ...ret.data };
+	return proto(ret, proto(this));
+}
+
+function call_select(...args)
+{
+	this.result.ctx = this.node_ctx.select(args);
+}
+
+function call_ok(msg)
+{
+	this.result.ok = true;
+	if (msg)
+		this.result.status_msg = msg;
+	return true;
+}
+
+function call_error(code, msg, ...args)
+{
+	msg ??= "Unknown error";
+	msg = sprintf(msg, ...args);
+	let error = {
+		code, msg, args
+	};
+	push(this.result.errors, error);
+}
+
+function call_generic(ctx, name, type, val)
+{
+	ctx.result.type = type;
+	ctx.result.name = name;
+	ctx.result.data = val;
+	return ctx.ok();
+}
+
+function call_multi_table(name, val)
+{
+	return call_generic(this, name, "multi_table", val);
+}
+
+function call_table(name, val)
+{
+	return call_generic(this, name, "table", val);
+}
+
+function call_list(name, val)
+{
+	return call_generic(this, name, "list", val);
+}
+
+function call_string(name, val)
+{
+	return call_generic(this, name, "string", val);
+}
+
+function call_json(name, val)
+{
+	return call_generic(this, name, "json", val);
+}
+
+function call_apply_defaults(named_args, args)
+{
+	let entry = this.entry;
+	named_args ??= entry.named_args;
+	args ??= this.named_args;
+	for (let name, arg in named_args)
+		if (arg.default != null && !(name in args))
+			args[name] ??= arg.default;
+}
+
+export const callctx_error_proto = {
+	missing_argument: function(msg, ...args) {
+		return this.error("MISSING_ARGUMENT", msg ?? "Missing argument", ...args);
+	},
+	invalid_argument: function(msg, ...args) {
+		return this.error("INVALID_ARGUMENT", msg ?? "Invalid argument", ...args);
+	},
+	unknown_error: function(msg, ...args) {
+		return this.error("UNKNOWN_ERROR", msg ?? "Unknown error", ...args);
+	},
+	not_found: function(msg, ...args) {
+		return this.error("NOT_FOUND", msg ?? "Not found", ...args);
+	},
+	command_failed: function(msg, ...args) {
+		return this.error("COMMAND_FAILEDu", msg ?? "Command failed", ...args);
+	},
+};
+
+const callctx_proto = {
+	clone: context_clone,
+	select: call_select,
+	apply_defaults: call_apply_defaults,
+	ok: call_ok,
+	list: call_list,
+	table: call_table,
+	multi_table: call_multi_table,
+	string: call_string,
+	json: call_json,
+
+	error: call_error,
+	...callctx_error_proto,
+};
+
+export function new(model, ctx) {
+	let node_ctx = ctx;
+	let data = ctx.data;
+	model.callctx_proto ??= { model, ...callctx_proto };
+	let result = default_result();
+	return proto({ node_ctx, data, result }, model.callctx_proto);
+};

package/utils/cli/files/usr/share/ucode/cli/context.uc

@@ -0,0 +1,679 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+import * as callctx from "cli.context-call";
+
+function prefix_match(prefix, str, icase)
+{
+	if (icase) {
+		str = lc(str);
+		prefix = lc(prefix);
+	}
+	return substr(str, 0, length(prefix)) == prefix;
+}
+
+function context_clone()
+{
+	let ret = { ...this };
+	ret.prompt = [ ...ret.prompt ];
+	ret.data = { ...ret.data };
+	ret.hooks = {};
+	return proto(ret, proto(this));
+}
+
+function context_entries()
+{
+	return keys(this.node)
+}
+
+function context_help(entry)
+{
+	if (entry)
+		return this.node[entry].help;
+
+	let ret = {};
+	for (let name, val in this.node)
+		ret[name] = val.help ?? "";
+
+	return ret;
+}
+
+function context_add_hook(type, cb)
+{
+	this.hooks[type] ??= [];
+	push(this.hooks[type], cb);
+}
+
+function context_select_error(code, msg, ...args)
+{
+	msg ??= "Unknown error";
+	msg = sprintf(msg, ...args);
+	let error = {
+		code, msg, args
+	};
+	this.errors ??= [];
+	push(this.errors, error);
+}
+
+function context_set(prompt, data)
+{
+	if (prompt)
+		this.cur_prompt = prompt;
+	if (data)
+		this.data = { ...this.data, ...data };
+	return true;
+}
+
+const context_select_proto = {
+	add_hook: context_add_hook,
+	error: context_select_error,
+	set: context_set,
+	...callctx.callctx_error_proto,
+};
+
+function __context_select(ctx, name, args)
+{
+	let entry = ctx.node[name];
+	if (!entry || !entry.select_node)
+		return;
+
+	let node = ctx.model.node[entry.select_node];
+	if (!node)
+		return;
+
+	let ret = proto(ctx.clone(), ctx.model.context_select_proto);
+	ret.cur_prompt = name;
+	ret.node = node;
+	try {
+		if (entry.select &&
+		    !call(entry.select, entry, ctx.model.scope, ret, args))
+			ret.errors ??= [];
+	} catch (e) {
+		ctx.model.exception(e);
+		return;
+	}
+
+	push(ret.prompt, ret.cur_prompt);
+	ret.prev = ctx;
+	proto(ret, proto(ctx));
+
+	return ret;
+}
+
+function context_run_hooks(ctx, name)
+{
+	try {
+		while (length(ctx.hooks[name]) > 0) {
+			let hook = ctx.hooks[name][0];
+
+			let ret = call(hook, ctx, ctx.model.scope);
+			if (!ret)
+				return false;
+
+			shift(ctx.hooks.exit);
+		}
+	} catch (e) {
+		ctx.model.exception(e);
+		return false;
+	}
+
+	return true;
+}
+
+function context_prev(ctx, skip_hooks)
+{
+	if (!skip_hooks && !context_run_hooks(ctx, "exit"))
+		return;
+	return ctx.prev;
+}
+
+function context_top(ctx, skip_hooks)
+{
+	while (ctx && ctx.prev)
+		ctx = context_prev(ctx, skip_hooks);
+	return ctx;
+}
+
+function prepare_spec(e, ctx, spec, argv)
+{
+	if (type(spec) != "function")
+		return spec;
+
+	return call(spec, e, ctx.model.scope, ctx, argv);
+}
+
+function prepare_default(e, ctx, spec, argv, named_args)
+{
+	if (type(spec) != "object" || type(spec.default) != "function")
+		return;
+
+	try {
+		spec.default = call(spec.default, e, ctx.model.scope, ctx, argv, named_args, spec);
+	} catch (e) {
+		model.exception(e);
+	}
+}
+
+function prepare_attr_spec(e, ctx, spec, argv, named_args)
+{
+	if (type(spec) != "object")
+		return spec;
+
+	let t = ctx.model.types[spec.type];
+	if (t)
+		spec = { ...t, ...spec };
+	else
+		spec = { ...spec };
+
+	prepare_default(e, ctx, spec, argv, named_args, spec);
+	if (type(spec.value) == "function")
+		try {
+			spec.value = call(spec.value, e, ctx.model.scope, ctx, argv, named_args, spec);
+		} catch (e) {
+			ctx.model.exception(e);
+			spec.value = [];
+		}
+
+	return spec;
+}
+
+function parse_arg(ctx, name, spec, val)
+{
+	let t;
+
+	if (val == null) {
+		ctx.invalid_argument("Missing argument %s", name);
+		return;
+	}
+
+	if (type(spec) == "object" && spec.type)
+		t = ctx.model.types[spec.type];
+	if (!t) {
+		ctx.invalid_argument("Invalid type in argument: %s", name);
+		return;
+	}
+
+	if (!t.parse)
+		return val;
+
+	return call(t.parse, spec, ctx.model.scope, ctx, name, val);
+}
+
+const context_defaults = {
+	up: [ "Return to previous node", context_prev ],
+	exit: [ "Return to previous node", context_prev ],
+	main: [ "Return to main node", context_top ],
+};
+
+const context_default_order = [ "up", "exit", "main" ];
+
+function context_select(args, completion)
+{
+	let ctx = this;
+
+	while (length(args) > completion ? 1 : 0) {
+		let name = args[0];
+		let entry = ctx.node[name];
+
+		if (!entry) {
+			let e = context_defaults[name];
+			if (!e)
+				return ctx;
+
+			shift(args);
+			ctx = e[1](ctx, completion);
+			if (!ctx)
+				return;
+
+			continue;
+		}
+
+		if (!entry.select_node)
+			return ctx;
+
+		let num_args = length(entry.args);
+		if (completion && num_args + 1 >= length(args))
+			return ctx;
+
+		shift(args);
+		let argv = [];
+		let parse_ctx = callctx.new(this.model, ctx);
+		if (num_args > 0) {
+			let cur_argv = slice(args, 0, num_args);
+			for (let i = 0; i < num_args; i++) {
+				let arg = shift(args);
+				let spec = entry.args[i];
+
+				spec = prepare_attr_spec(entry, ctx, spec, cur_argv, {});
+				if (arg != null)
+					arg = parse_arg(parse_ctx, spec.name, spec, arg);
+
+				if (arg != null)
+					push(argv, arg);
+			}
+
+		}
+
+		if (entry.no_subcommands && length(args) > 0)
+			parse_ctx.invalid_argument("command %s does not support subcommands", name);
+
+		if (length(parse_ctx.result.errors) > 0) {
+			ctx = ctx.clone();
+			ctx.errors = parse_ctx.result.errors;
+			return ctx;
+		}
+
+		ctx = __context_select(ctx, name, argv);
+		if (type(ctx) != "object" || ctx.errors)
+			break;
+	}
+
+	return ctx;
+}
+
+function complete_named_params(ctx, entry, obj, name, argv, named_params)
+{
+	let data = [];
+	let empty = "";
+
+	if (substr(name, 0, 1) == "-") {
+		empty = "-";
+		name = substr(name, 1);
+	}
+
+	let defaults = {};
+	callctx.new(ctx.model, ctx).apply_defaults(obj, defaults);
+	for (let cur_name in sort(keys(obj))) {
+		let val = obj[cur_name];
+
+		if (!prefix_match(name, cur_name) || val.no_complete)
+			continue;
+
+		if (empty && !(val.allow_empty ?? entry.allow_empty))
+			continue;
+
+		if (!val.multiple && named_params[cur_name] != null)
+			continue;
+
+		if (type(val.available) == "function" &&
+		    !call(val.available, val, ctx.model.scope, ctx, argv, named_params))
+			continue;
+
+		val = {
+			name: empty + cur_name,
+			...val,
+		};
+		push(data, val);
+	}
+
+	return {
+		type: "keywords",
+		name: "parameter",
+		help: "Parameter name",
+		value: data
+	};
+}
+
+function complete_param(e, ctx, cur, val, args, named_args)
+{
+	cur = prepare_attr_spec(e, ctx, cur, args, named_args);
+
+	if (type(cur.value) == "object") {
+		let ret = [];
+		for (let key in sort(keys(cur.value)))
+			if (prefix_match(val, key, cur.ignore_case))
+				push(ret, {
+					name: key,
+					help: cur.value[key]
+				});
+
+		cur.value = ret;
+		return cur;
+	}
+
+	if (type(cur.value) == "array") {
+		cur.value = map(sort(filter(cur.value, (v) => prefix_match(val, v, cur.ignore_case))), (v) => ({ name: v }));
+		return cur;
+	}
+
+	let type_info = ctx.model.types[cur.type];
+	if (!type_info || !type_info.complete)
+		return cur;
+
+	cur.value = call(type_info.complete, cur, ctx.model.scope, ctx, val);
+
+	return cur;
+}
+
+function complete_arg_list(e, ctx, arg_info, args, base_args, named_args)
+{
+	let cur_idx = length(args) - 1;
+	let cur = arg_info[cur_idx];
+	let val;
+
+	for (let i = 0; i <= cur_idx; i++)
+		val = shift(args);
+
+	return complete_param(e, ctx, cur, val, base_args, named_args);
+}
+
+function handle_empty_param(entry, spec, name, argv, named_args)
+{
+	if (substr(name, 0, 1) != "-")
+		return;
+
+	name = substr(name, 1);
+	let cur = spec[name];
+	if (!cur)
+		return;
+
+	if (cur.default == null &&
+	    !(cur.allow_empty ?? entry.allow_empty))
+		return;
+
+	if (cur.required) {
+		cur = { ...cur };
+		prepare_default(e, ctx, cur, argv, named_args, cur);
+		named_args[name] = cur.default;
+	} else {
+		named_args[name] = null;
+	}
+	return true;
+}
+
+
+function default_complete(ctx, args)
+{
+	let num_args = length(this.args);
+	let named_args = {};
+	let cur_args;
+
+	if (length(args) <= num_args)
+		return complete_arg_list(this, ctx, this.args, args, [ ...args ], named_args);
+
+	let spec = prepare_spec(this, ctx, this.named_args, args);
+	if (!spec)
+		return;
+
+	let base_args = slice(args, 0, num_args);
+	for (let i = 0; i < num_args; i++)
+		shift(args);
+
+	while (length(args) > 0) {
+		let name = args[0];
+
+		if (length(args) == 1)
+			return complete_named_params(ctx, this, spec, name, base_args, named_args);
+
+		shift(args);
+		let cur = spec[name];
+		if (!cur) {
+			if (handle_empty_param(this, spec, name, base_args, named_args))
+				continue;
+			return;
+		}
+
+		if (!cur.args) {
+			named_args[name] = true;
+			continue;
+		}
+
+		let val;
+		let cur_spec = cur.args;
+		if (type(cur_spec) != "array") {
+			cur_spec = [{
+				name,
+				help: cur.help,
+				...cur_spec
+			}];
+			named_args[name] = shift(args);
+			val = [ named_args[name] ];
+		} else {
+			let num_args = length(cur_spec);
+			let val = [];
+			for (let i = 0; i < num_args; i++)
+				push(val, shift(args));
+			named_args[name] = val;
+		}
+
+		if (!length(args))
+			return complete_arg_list(this, ctx, cur_spec, val, base_args, named_args);
+	}
+}
+
+function context_complete(args)
+{
+	let ctx = this.select(args, true);
+	if (!ctx || ctx.errors)
+		return;
+
+	if (ctx != this) {
+		ctx = ctx.clone();
+		ctx.skip_default_complete = true;
+	}
+
+	if (length(args) > 1) {
+		let name = shift(args);
+		let entry = ctx.node[name];
+		if (!entry)
+			return;
+
+		try {
+			if (!entry.available || call(entry.available, entry, ctx.model.scope, ctx, args))
+				return call(entry.complete ?? default_complete, entry, ctx.model.scope, ctx, args);
+		} catch (e) {
+			this.model.exception(e);
+		}
+		return;
+	}
+
+	let name = shift(args) ?? "";
+	let prefix_len = length(name);
+	let data = [];
+	let default_data = {};
+	for (let cur_name in sort(keys(ctx.node))) {
+		let val = ctx.node[cur_name];
+
+		if (substr(cur_name, 0, prefix_len) != name)
+			continue;
+
+		if (val.available && !call(val.available, val, ctx.model.scope, ctx, args))
+			continue;
+
+		let cur = {
+			name: cur_name,
+			help: val.help,
+			category: val.select_node ? "Object" : "Action",
+		};
+		if (context_defaults[cur_name])
+			default_data[cur_name] = cur;
+		else
+			push(data, cur);
+	}
+
+	for (let cur_name in context_default_order) {
+		if (substr(cur_name, 0, prefix_len) != name)
+			continue;
+
+		let val = default_data[cur_name];
+		if (!val) {
+			if (!ctx.prev || ctx.skip_default_complete)
+				continue;
+			val = {
+				name: cur_name,
+				help: context_defaults[cur_name][0],
+				category: "Navigation",
+			};
+		}
+
+		push(data, val);
+	}
+
+	return {
+		type: "enum",
+		name: "command",
+		help: "Command",
+		value: data
+	};
+}
+
+function context_call(args)
+{
+	let ctx = this.select(args);
+	if (!ctx || !length(args))
+		return;
+
+	let name = shift(args);
+	let entry = ctx.node[name];
+	if (!entry)
+		return;
+
+	if (!entry.call)
+		return;
+
+	let named_args = {};
+	let num_args = length(entry.args);
+	let cur_argv = slice(args, 0, num_args);
+	let argv = [];
+	let skip = {};
+
+	ctx = callctx.new(this.model, ctx);
+	ctx.entry = entry;
+	ctx.named_args = named_args;
+
+	for (let i = 0; i < num_args; i++) {
+		let arg = shift(args);
+		let spec = entry.args[i];
+
+		spec = prepare_attr_spec(entry, ctx, spec, cur_argv, named_args);
+		if (arg != null)
+			arg = parse_arg(ctx, spec.name, spec, arg);
+
+		if (spec.required && !length(arg)) {
+			if (spec.default)
+				arg = spec.default;
+			else
+				ctx.missing_argument("Missing argument %d: %s", i + 1, spec.name);
+		}
+
+		if (arg != null)
+			push(argv, arg);
+	}
+
+	let spec = prepare_spec(entry, ctx, entry.named_args, argv) ?? {};
+	let defaults = {};
+	ctx.apply_defaults(spec, defaults);
+	while (length(args) > 0) {
+		let name = shift(args);
+		let cur = spec[name];
+		try {
+			if (cur && type(cur.available) == "function" &&
+				!call(cur.available, cur, ctx.model.scope, ctx, argv, { ...defaults, ...named_args }))
+					cur = null;
+		} catch (e) {
+			ctx.model.exception(e);
+			continue;
+		}
+
+		if (!cur) {
+			if (handle_empty_param(entry, spec, name, argv, named_args))
+				continue;
+			ctx.invalid_argument("Invalid argument: %s", name);
+			return ctx.result;
+		}
+
+		if (!cur.args) {
+			named_args[name] = true;
+			continue;
+		}
+
+		let val;
+		let cur_spec = cur.args;
+		if (type(cur.args) == "array") {
+			val = [];
+			for (let spec in cur.args) {
+				spec = prepare_attr_spec(entry, ctx, spec, argv, named_args);
+				let cur = parse_arg(ctx, name, spec, shift(args));
+				if (cur == null)
+					return ctx.result;
+
+				push(val, cur);
+			}
+		} else {
+			let spec = prepare_attr_spec(entry, ctx, cur.args, argv, named_args);
+			val = parse_arg(ctx, name, spec, shift(args));
+			if (val == null)
+				return ctx.result;
+		}
+		if (cur.multiple) {
+			named_args[name] ??= [];
+			push(named_args[name], val);
+		} else {
+			named_args[name] = val;
+		}
+	}
+
+	for (let name, arg in spec) {
+		if (!arg.required || named_args[name] != null)
+			continue;
+
+		try {
+			if (type(arg.available) == "function" &&
+				!call(arg.available, arg, ctx.model.scope, ctx, argv, named_args))
+				continue;
+		} catch (e) {
+			ctx.model.exception(e);
+			continue;
+		}
+
+		let spec = { ...arg };
+		prepare_default(entry, ctx, spec, argv, named_args);
+		if (spec.default != null)
+			named_args[name] = spec.default;
+		else
+			ctx.missing_argument("Missing argument: %s", name);
+	}
+
+	if (length(ctx.result.errors) > 0)
+		return ctx.result;
+
+	if (entry.available && !call(entry.available, entry, ctx.model.scope, ctx))
+		return ctx.result;
+
+	try {
+		if (!entry.validate || call(entry.validate, entry, ctx.model.scope, ctx, argv, named_args))
+			call(entry.call, entry, ctx.model.scope, ctx, argv, named_args);
+	} catch (e) {
+		this.model.exception(e);
+		return;
+	}
+	return ctx.result;
+}
+
+const context_proto = {
+	clone: context_clone,
+	entries: context_entries,
+	help: context_help,
+	select: context_select,
+	call: context_call,
+	complete: context_complete,
+	add_hook: context_add_hook,
+};
+
+export function new(model) {
+	model.context_proto ??= {
+		model,
+		...context_proto
+	};
+	model.context_select_proto ??= {
+		model,
+		...context_select_proto
+	};
+	return proto({
+		prompt: [],
+		node: model.node.Root,
+		hooks: {},
+		data: {}
+	}, model.context_proto);
+};

package/utils/cli/files/usr/share/ucode/cli/datamodel.uc

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+import * as context from "cli.context";
+import * as cache from "cli.cache";
+import * as libubus from "ubus";
+import * as uloop from "uloop";
+import { glob, dirname } from "fs";
+let types = require("cli.types");
+
+uloop.init();
+let ubus = libubus.connect();
+
+function status_msg(msg)
+{
+	if (this.cb.status_msg)
+		call(this.cb.status_msg, this, this.scope, msg);
+}
+
+function poll_key(keys, prompt)
+{
+	if (!model.cb.poll_key)
+		return;
+
+	if (prompt)
+		warn(prompt);
+
+    while (1) {
+        let key = lc(model.cb.poll_key());
+		if (!key || key == "\x03")
+			return;
+
+		if (index(keys, key) >= 0)
+			return key;
+	}
+}
+
+function merge_object(obj, add)
+{
+	for (let name, entry in add)
+		obj[name] = entry;
+}
+
+function add_node(name, node)
+{
+	let obj = this.node;
+
+	if (obj[name])
+		merge_object(obj[name], node);
+	else
+		obj[name] = { ...node };
+
+	return obj[name];
+}
+
+function add_nodes(add)
+{
+	for (let name, val in add)
+		this.add_node(name, val);
+}
+
+function add_hook(name, val)
+{
+	let obj = this.hooks;
+
+	if (type(val) == "function")
+		val = [ val ];
+	obj[name] ??= [];
+	push(obj[name], ...val);
+}
+
+function add_hooks(add)
+{
+	for (let name, val in add)
+		this.add_hook(name, val);
+}
+
+function add_type(name, val)
+{
+	this.type[name] = val;
+}
+
+function add_types(add)
+{
+	for (let name, val in add)
+		this.add_type(name, val);
+}
+
+function add_module(path)
+{
+	if (substr(path, 0, 1) != "/")
+		path = dirname(sourcepath()) + "/modules/" + path;
+
+	let mod;
+	try {
+		let fn = loadfile(path, {
+			raw_mode: true,
+			strict_declarations: true,
+		});
+		mod = call(fn, this, this.scope);
+	} catch (e) {
+		this.warn(`${e}\n${e.stacktrace[0].context}\nFailed to open module ${path}.\n`);
+		return;
+	}
+}
+
+function add_modules(path)
+{
+	path ??= "*.uc";
+	if (substr(path, 0, 1) != "/")
+		path = dirname(sourcepath()) + "/modules/" + path;
+
+	for (let mod in glob(path))
+		this.add_module(mod);
+}
+
+function run_hook(name, ...args)
+{
+	let hooks = this.hooks[name];
+	if (!hooks)
+		return;
+
+	for (let hook in hooks)
+		call(hook, this, {}, ...args);
+}
+
+function init()
+{
+	this.run_hook("init");
+}
+
+function context_new()
+{
+	return context.new(this);
+}
+
+function exception(e)
+{
+	this.warn(`${e}\n${e.stacktrace[0].context}`);
+}
+
+const data_proto = {
+	warn, exception,
+	poll_key,
+	add_module,
+	add_modules,
+	add_node,
+	add_nodes,
+	add_type,
+	add_types,
+	add_hook,
+	add_hooks,
+	run_hook,
+	init,
+	status_msg,
+	context: context_new,
+};
+
+export function new(cb) {
+	cb ??= {};
+	let model = proto({
+		libubus, ubus, uloop,
+		cb,
+		hooks: {},
+		node: {
+			Root: {}
+		},
+		warnings: {},
+		types: { ...types },
+	}, data_proto);
+	model.scope = proto({ model }, global);
+	model.cache = cache.new(model);
+	return model;
+};

package/utils/cli/files/usr/share/ucode/cli/modules/network.uc

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+import { time_format } from "cli.utils";
+
+function get_interfaces()
+{
+	let data = model.ubus.call("network.interface", "dump");
+	if (!data)
+		return {};
+
+	let ret = {};
+	for (let iface in data.interface)
+		ret[iface.interface] = iface;
+
+	return ret;
+}
+
+function interface_validate(ctx, argv)
+{
+	let name = argv[0];
+	if (!name)
+		return ctx.missing_argument("Missing argument: %s", "name");
+
+	if (index(get_interfaces(), name) < 0)
+		return ctx.not_found("Interface not found: %s", name);
+
+	return true;
+}
+
+const interface_args = [
+	{
+		name: "interface",
+		help: "Interface name",
+		type: "enum",
+		value: (ctx) => keys(get_interfaces())
+	}
+];
+
+function interface_status(data)
+{
+	if (data.up)
+		return "up";
+	if (!data.autostart)
+		return "down";
+	if (!data.available)
+		return "unavailable";
+	return "pending";
+}
+
+const Network = {
+	list: {
+		help: "List interfaces",
+		call: function(ctx, argv) {
+			return ctx.list("Interfaces", keys(get_interfaces()));
+		}
+	},
+	reload: {
+		help: "Reload network config",
+		call: function(ctx, argv) {
+			model.ubus.call("network", "reload");
+			return ctx.ok("Configuration reloaded");
+		}
+	},
+	restart: {
+		help: "Restart interface",
+		validate: interface_validate,
+		args: interface_args,
+		call: function(ctx, argv) {
+			let name = shift(argv);
+			model.ubus.call("network.interface."+name, "down");
+			model.ubus.call("network.interface."+name, "up");
+			return ctx.ok("Interface restarted");
+		}
+	},
+	start: {
+		help: "Start interface",
+		validate: interface_validate,
+		args: interface_args,
+		call: function(ctx, argv) {
+			let name = shift(argv);
+			model.ubus.call("network.interface."+name, "up");
+			return ctx.ok("Interface started");
+		}
+	},
+	stop: {
+		help: "Stop interface",
+		validate: interface_validate,
+		args: interface_args,
+		call: function(ctx, argv) {
+			let name = shift(argv);
+			model.ubus.call("network.interface."+name, "down");
+			return ctx.ok("Interface stopped");
+		}
+	},
+	status: {
+		help: "Interface status",
+		args: interface_args,
+		call: function(ctx, argv) {
+			let name = shift(argv);
+			let status = get_interfaces();
+			if (!name) {
+				let data = {};
+				for (let iface, ifdata in status)
+					data[iface] = interface_status(ifdata);
+
+				return ctx.table("Status", data);
+			}
+
+			let ifdata = status[name];
+			let data = {
+				Status: interface_status(ifdata),
+			};
+			if (ifdata.up)
+				data.Uptime = time_format(ifdata.uptime);
+
+			if (length(ifdata["ipv4-address"]) > 0)
+				data.IPv4 = join(", ", map(ifdata["ipv4-address"], (v) => v.address + "/" + v.mask));
+			if (length(ifdata["ipv6-address"]) > 0)
+				data.IPv6 = join(", ", map(ifdata["ipv6-address"], (v) => v.address + "/" + v.mask));
+			if (length(ifdata["dns-server"]) > 0)
+				data.DNS = join(", ", ifdata["dns-server"]);
+			if (length(ifdata["route"]) > 0)
+				data.Routes = join(", ", map(ifdata["route"], (v) => (v.mask == 0 ? "Default" : `${v.target}/${v.mask}`) + ": " + v.nexthop));
+			return ctx.table("Status", data);
+		}
+	}
+};
+
+const Root = {
+	network: {
+		help: "Network interface configuration",
+		select_node: "Network",
+	}
+};
+
+model.add_nodes({ Root, Network });

package/utils/cli/files/usr/share/ucode/cli/modules/service.uc

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+import { glob, access, basename } from "fs";
+
+function get_services()
+{
+	return model.cache.get("init_service_list", () => {
+		let services = glob("/etc/init.d/*");
+		services = filter(services, (v) => !system([ "grep", "-q", "start_service()", v ]));
+		services = map(services, basename);
+		return sort(services);
+	});
+}
+
+function get_service_status( name)
+{
+	return model.ubus.call("service", "list", (name ? { name } : null));
+}
+
+function service_running(name)
+{
+	let status = get_service_status(name);
+	return !!(status && status[name]);
+}
+
+function __service_cmd(name, cmd)
+{
+	return system([ "/etc/init.d/" + name, cmd ]) == 0;
+}
+
+function service_cmd(ctx, name, cmd, msg)
+{
+	if (__service_cmd(name, cmd))
+		return ctx.ok(msg);
+	else
+		return ctx.command_failed("Command failed");
+}
+
+function service_validate(ctx, argv)
+{
+	let name = argv[0];
+	if (!name)
+		return ctx.missing_argument("Missing argument: %s", "name");
+
+	if (index(get_services(), name) < 0)
+		return ctx.not_found("Service not found: %s", name);
+
+	return true;
+}
+
+const service_args = [
+	{
+		name: "name",
+		help: "Service name",
+		type: "enum",
+		value: (ctx) => get_services()
+	}
+];
+
+const service_settings = {
+	enabled: {
+		help: "Service enabled at system boot",
+	},
+	disabled: {
+		help: "Service disabled at system boot",
+	}
+};
+
+const SystemService = {
+	list: {
+		help: "List services",
+		call: function(ctx, argv) {
+			return ctx.list("Services", get_services());
+		}
+	},
+	reload: {
+		help: "Reload service",
+		validate: service_validate,
+		args: service_args,
+		call: function(ctx, argv) {
+			return service_cmd(ctx, shift(argv), "reload", "Service reloaded");
+		}
+	},
+	restart: {
+		help: "Restart service",
+		validate: service_validate,
+		args: service_args,
+		call: function(ctx, argv) {
+			return service_cmd(ctx, shift(argv), "restart", "Service restarted");
+		}
+	},
+	set: {
+		help: "Change service settings",
+		validate: service_validate,
+		args: service_args,
+		named_args: service_settings,
+		call: function(ctx, argv, param) {
+			if (!length(param))
+				return ctx.invalid_argument("No settings provided");
+
+			if (param.enabled && param.disabled)
+				return ctx.invalid_argument("enabled and disabled cannot be set at the same time");
+
+			if (param.enabled && !__service_cmd(name, "enable"))
+				ctx.command_failed("Command failed: %s", "enable");
+
+			if (param.disabled && !__service_cmd(name, "disable"))
+				ctx.command_failed("Command failed: %s", "disable");
+
+			return ctx.ok("Settings changed");
+		}
+	},
+	start: {
+		help: "Start service",
+		validate: service_validate,
+		args: service_args,
+		call: function(ctx, argv) {
+			let name = shift(argv);
+
+			if (service_running(name))
+				return ctx.invalid_argument("Service already running", name);
+
+			return service_cmd(ctx, name, "start", "Service started");
+		}
+	},
+	stop: {
+		help: "Stop service",
+		validate: service_validate,
+		args: service_args,
+		call: function(ctx, argv) {
+			let name = shift(argv);
+
+			if (!service_running(name))
+				return ctx.invalid_argument("Service not running", name);
+
+			return service_cmd(ctx, name, "stop", "Service stopped");
+		}
+	},
+	status: {
+		help: "Service status",
+		args: service_args,
+		call: function(ctx, argv) {
+			let name = shift(argv);
+			if (!name) {
+				let data = {};
+				for (let service in get_services()) {
+					let running = service_running(service);
+					data[service] = running ? "running" : "not running";
+				}
+				return ctx.table("Status", data);
+			}
+
+			if (index(get_services(), name) < 0)
+				return ctx.not_found("Service not found: %s", name);
+
+			let data = {
+				"Running": service_running(name),
+				"Enabled": __service_cmd(name, "enabled"),
+			};
+			return ctx.table("Status", data);
+		}
+	}
+};
+
+const Root = {
+	service: {
+		help: "System service configuration",
+		select_node: "SystemService",
+	}
+};
+
+model.add_nodes({ Root, SystemService });

package/utils/cli/files/usr/share/ucode/cli/object-editor.uc

@@ -0,0 +1,546 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+function __get_edit_object(ctx, entry, argv, name)
+{
+	if (type(entry.edit_object) == "function")
+		return call(entry.edit_object, entry, ctx.model.scope, ctx, argv);
+
+	if (name)
+		return ctx.data.edit[name];
+
+	return ctx.data.edit;
+}
+
+function get_edit_object(ctx, entry, argv, name)
+{
+	let obj = __get_edit_object(ctx, entry, argv, name);
+	if (!obj)
+		ctx.invalid_argument();
+
+	return obj;
+}
+
+function get_param_object(ctx, obj, spec, argv)
+{
+	if (type(spec.get_object) != "function")
+		return obj;
+
+	return call(spec.get_object, spec, ctx.model.scope, ctx, spec, obj, argv);
+}
+
+function call_change_cb(ctx, entry, argv, named)
+{
+	if (!length(named) || type(entry.change_cb) != "function")
+		return;
+
+	call(entry.change_cb, entry, ctx.model.scope, ctx, argv);
+}
+
+function check_duplicate(ctx, val, new_val)
+{
+	for (let i = 0; i < length(new_val); i++) {
+		let v = new_val[i];
+		if ((val && index(val, v) >= 0) ||
+			(i && index(slice(new_val, 0, i), v) >= 0)) {
+			ctx.invalid_argument("Duplicate value: %s", v);
+			return true;
+		}
+	}
+}
+
+export function add_call(ctx, argv, named)
+{
+	let spec = this.named_args;
+	let obj = get_edit_object(ctx, this, argv);
+	if (!obj)
+		return;
+
+	for (let name, val in named) {
+		let cur = spec[name];
+		if (type(cur.add) == "function") {
+			call(cur.add, cur, ctx.model.scope, ctx, val);
+			continue;
+		}
+
+		if (cur.attribute)
+			name = cur.attribute;
+
+		let cur_obj = get_param_object(ctx, obj, cur, argv);
+		cur_obj[name] ??= [];
+		if (!cur.allow_duplicate &&
+		    check_duplicate(ctx, obj[name], val))
+			return;
+		push(cur_obj[name], ...val);
+	}
+	call_change_cb(ctx, this, argv, named);
+	return ctx.ok();
+};
+
+export function set_call(ctx, argv, named)
+{
+	let spec = this.named_args;
+	let obj = get_edit_object(ctx, this, argv);
+	if (!obj)
+		return;
+
+	for (let name, val in named) {
+		let cur = spec[name];
+		if (!cur)
+			continue;
+
+		if (type(cur.set) == "function") {
+			call(cur.set, cur, ctx.model.scope, ctx, val);
+			continue;
+		}
+
+		if (cur.attribute)
+			name = cur.attribute;
+
+		let cur_obj = get_param_object(ctx, obj, cur, argv);
+		if (val == null) {
+			delete cur_obj[name];
+			continue;
+		}
+
+		if (cur.multiple && !cur.allow_duplicate &&
+		    check_duplicate(ctx, obj[name], val))
+			return;
+		cur_obj[name] = val;
+	}
+	call_change_cb(ctx, this, argv, named);
+	return ctx.ok();
+};
+
+export function remove_call(ctx, argv, named)
+{
+	let spec = this.named_args;
+	let obj = get_edit_object(ctx, this, argv);
+	if (!obj)
+		return;
+
+	for (let name, val in named) {
+		let cur = spec[name];
+		if (type(cur.remove) == "function") {
+			call(cur.remove, cur, ctx.model.scope, ctx, val);
+			continue;
+		}
+
+		if (cur.attribute)
+			name = cur.attribute;
+
+		let cur_obj = get_param_object(ctx, obj, cur, argv);
+		let data = cur_obj[name];
+		if (!data)
+			continue;
+
+		for (let idx in val)
+			data[+idx - 1] = null;
+
+		cur_obj[name] = filter(data, (v) => v != null);
+		if (cur.attribute_allow_empty && !length(cur_obj[name]))
+			delete cur_obj[name];
+	}
+	call_change_cb(ctx, this, argv, named);
+	return ctx.ok();
+};
+
+export function show_call(ctx, argv, named)
+{
+	let obj = get_edit_object(ctx, this, argv);
+	if (!obj)
+		return;
+
+	let data = {};
+	for (let name, spec in this.attribute_info) {
+		let val;
+		if (type(spec.get) == "function") {
+			val = call(spec.get, spec, ctx.model.scope, ctx);
+		} else {
+			let cur_obj = get_param_object(ctx, obj, spec, argv);
+			val = cur_obj[spec.attribute ?? name];
+		}
+		val ??= spec.default;
+
+		if (val != null)
+			data[name] = val;
+	}
+
+	return ctx.table("Values", data);
+};
+
+function param_values(ctx, argv, named_args, spec)
+{
+	let obj = get_edit_object(ctx, this, argv);
+	if (!obj)
+		return;
+
+	let values;
+	if (type(spec.get) == "function")
+		values = call(spec.get, spec, ctx.model.scope, ctx);
+	else {
+		let cur_obj = get_param_object(ctx, obj, spec, argv);
+		values = cur_obj[spec.attribute];
+	}
+
+	let ret = {};
+	let idx = 0;
+	for (let value in values)
+		ret["" + (++idx)] = value;
+
+	return ret;
+}
+
+function add_params(orig_params)
+{
+	let params = {};
+
+	for (let name, val in orig_params) {
+		if (!val.multiple)
+			continue;
+
+		val = { ...val };
+		delete val.required;
+		delete val.allow_empty;
+		params[name] = val;
+	}
+
+	return params;
+}
+
+function set_params(orig_params)
+{
+	let params = {};
+
+	for (let name, val in orig_params) {
+		val = { ...val };
+		if (!val.required)
+			val.allow_empty = true;
+		else
+			delete val.allow_empty;
+
+		delete val.required;
+		params[name] = val;
+	}
+
+	return params;
+}
+
+function remove_params(orig_params)
+{
+	let params = {};
+
+	for (let name, val in orig_params) {
+		if (!val.multiple)
+			continue;
+
+		val = { ...val };
+		val.attribute_allow_empty = val.allow_empty;
+		delete val.required;
+		delete val.allow_empty;
+		val.args = {
+			type: "enum",
+			attribute: val.attribute ?? name,
+			value: param_values,
+			force_helptext: true,
+		};
+
+		params[name] = val;
+	}
+
+	return params;
+}
+
+export function new(info, node)
+{
+	let params = info.named_args;
+	let ret = {
+		add: {
+			help: "Add list parameter entries",
+			args: info.args,
+			named_args: add_params(params),
+			call: add_call,
+			edit_object: info.edit_object,
+			change_cb: info.change_cb,
+			...(info.add ?? {}),
+		},
+		show: {
+			help: "Show parameter values",
+			args: info.args,
+			call: show_call,
+			attribute_info: params,
+			...(info.show ?? {}),
+		},
+		set: {
+			help: "Set parameter values",
+			args: info.args,
+			named_args: set_params(params),
+			call: set_call,
+			edit_object: info.edit_object,
+			change_cb: info.change_cb,
+			...(info.set ?? {}),
+		},
+		remove: {
+			help: "Remove parameter values",
+			args: info.args,
+			named_args: remove_params(params),
+			call: remove_call,
+			edit_object: info.edit_object,
+			change_cb: info.change_cb,
+			...(info.remove ?? {}),
+		}
+	};
+
+	if (!length(ret.add.named_args)) {
+		delete ret.add;
+		delete ret.remove;
+	}
+
+	if (node)
+		for (let cmd, val in ret)
+			node[cmd] = val;
+
+	return ret;
+};
+
+export function object_destroy_call(ctx, argv, named)
+{
+	let type_name = argv[0];
+	if (!type_name)
+		return ctx.invalid_argument();
+
+	let info = this.object_info;
+	let type_info = info.types[type_name];
+	if (!type_info)
+		return ctx.invalid_argument();
+
+	let obj_name = type_info.object ?? type_name;
+
+	let name = argv[1];
+	if (type_info.delete)
+		return call(type_info.delete, info, ctx.model.scope, ctx, type, name);
+
+	let obj = ctx.data.object_edit[obj_name];
+	if (!obj)
+		return ctx.unknown_error();
+
+	if (!obj[name])
+		return ctx.not_found();
+
+	delete obj[name];
+
+	if (info.change_cb)
+		call(info.change_cb, info, ctx.model.scope, ctx, argv);
+
+	return ctx.ok(`Deleted ${argv[0]} '${name}'`);
+};
+
+const create_edit_param = {
+	help: "Edit object after creating",
+};
+
+export function object_create_params(node)
+{
+	if (!node.show)
+		return {};
+
+	let orig_params = node.show.attribute_info;
+	let params = {};
+
+	for (let name, val in orig_params) {
+		if (val.change_only)
+			continue;
+
+		params[name] = val;
+	}
+	params.edit ??= create_edit_param;
+
+	return params;
+};
+
+export function object_create_call(ctx, argv, named)
+{
+	let type_name = argv[0];
+	if (!type_name)
+		return ctx.invalid_argument();
+
+	let info = this.object_info;
+	let type_info = info.types[type_name];
+	if (!type_info)
+		return ctx.invalid_argument();
+
+	let obj_name = type_info.object ?? type_name;
+
+	let name = argv[1];
+	let obj, data;
+	if (type_info.add) {
+		data = call(type_info.add, info, ctx.model.scope, ctx, type, name);
+		if (!data)
+			return;
+	} else {
+		data = {};
+	}
+
+	ctx.data.object_edit[obj_name] ??= {};
+	obj = ctx.data.object_edit[obj_name];
+
+	let entry = type_info.node.set;
+	if (entry) {
+		ctx.apply_defaults();
+		let subctx = ctx.clone();
+		subctx.data.edit = data;
+
+		try {
+			call(entry.call, entry, ctx.model.scope, subctx, argv, named);
+		} catch (e) {
+			ctx.model.exception(e);
+			return ctx.unknown_error();
+		}
+
+		if (!subctx.result.ok) {
+			ctx.result = subctx.result;
+			return;
+		}
+	}
+
+	obj[name] = data;
+
+	if (named.edit)
+		ctx.select(type_name, name);
+
+	return ctx.ok(`Added ${type_name} '${name}'`);
+};
+
+function object_lookup(ctx, entry, type_name)
+{
+	let info = entry.object_info;
+	let type_info = info.types[type_name];
+	if (!type_info)
+		return [];
+
+	let obj_name = type_info.object ?? type_name;
+
+	return ctx.data.object_edit[obj_name];
+}
+
+function object_values(ctx, entry, type_name)
+{
+	let obj = object_lookup(ctx, entry, type_name);
+	if (!obj)
+		return [];
+
+	return keys(obj);
+}
+
+export function object_list_call(ctx, argv, named)
+{
+	return ctx.list(argv[0] + " list", object_values(ctx, this, argv[0]));
+};
+
+export function edit_create_destroy(info, node)
+{
+	let type_arg = {
+		name: "type",
+		help: "Type",
+		type: "enum",
+		required: true,
+		value: keys(info.types),
+	};
+	let name_arg = {
+		name: "name",
+		help: "Name",
+		type: "string",
+		required: true,
+	};
+	let delete_name_arg = {
+		...name_arg,
+		type: "enum",
+		value: function(ctx, argv) {
+			return object_values(ctx, this, argv[0]);
+		}
+	};
+
+	let create_params = {};
+	for (let name, val in info.types)
+		create_params[name] = object_create_params(val.node);
+
+	let types_info = " (" + join(", ", keys(info.types)) + ")";
+	let cmds = {
+		destroy: {
+			object_info: info,
+			help: "Delete object" + types_info,
+			args: [ type_arg, delete_name_arg ],
+			call: object_destroy_call,
+		},
+		list: {
+			object_info: info,
+			help: "List objects" + types_info,
+			args: [ type_arg ],
+			call: object_list_call,
+		},
+		create: {
+			object_info: info,
+			help: "Create object" + types_info,
+			args: [ type_arg, name_arg ],
+			type_params: create_params,
+			named_args: function(ctx, argv) {
+				if (!argv[0])
+					return;
+				return this.type_params[argv[0]];
+			},
+			call: object_create_call,
+		},
+	};
+
+	for (let name, val in info.types) {
+		cmds[name] = {
+			object_name: name,
+			object_info: info,
+			help: "Edit " + name,
+			args: [
+				{
+					...name_arg,
+					type: "enum",
+					value: function(ctx, argv) {
+						return object_values(ctx, this, this.object_name);
+					}
+				}
+			],
+			select_node: val.node_name,
+			select: function(ctx, argv) {
+				let name = argv[0];
+				if (!name) {
+					warn(`Missing argument\n`);
+					return;
+				}
+
+				let obj = object_lookup(ctx, this, this.object_name);
+				if (!obj) {
+					warn(`Object not found\n`);
+					return;
+				}
+
+				let entry = obj[name];
+				if (!entry) {
+					warn(`${name} not found\n`);
+					return;
+				}
+
+				let info = this.object_info;
+				let type_info = info.types[this.object_name];
+				return ctx.set(`${this.object_name} "${name}"`, {
+					name,
+					edit: entry,
+					object_edit: entry,
+				});
+			}
+		};
+	}
+
+	if (node)
+		for (let cmd, val in cmds)
+			node[cmd] = val;
+
+	return cmds;
+};

package/utils/cli/files/usr/share/ucode/cli/types.uc

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+import { access, basename, dirname, opendir, stat } from "fs";
+
+function is_directory(path)
+{
+	let s = stat(path);
+	return s && s.type == "directory";
+}
+
+const types = {
+	bool: {
+		value: [ "0", "1" ],
+		parse: function(ctx, name, val) {
+			if (val == "1")
+				return true;
+			if (val == "0")
+				return false;
+			ctx.invalid_argument("value for %s must be 0 or 1", name);
+			return;
+		},
+	},
+	int: {
+		parse: function(ctx, name, strval) {
+			let val = +strval;
+			if (substr(strval, 0, 1) == "-")
+				strval = substr(strval, 1);
+			if (match(strval, /[^0-9]/)) {
+				ctx.invalid_argument("value for %s is not a number", name);
+				return;
+			}
+			if ((this.min == null || val >= this.min) &&
+			    (this.max == null || val <= this.max))
+				return val;
+			if (this.min != null && this.max != null)
+				ctx.invalid_argument(`value for %s must be between ${this.min} and ${this.max}`, name);
+			else if (this.min != null)
+				ctx.invalid_argument(`value for %s must be at least ${this.min}`, name);
+			else
+				ctx.invalid_argument(`value for %s must not be bigger than ${this.max}`, name);
+			return;
+		}
+	},
+	string: {
+		parse: function(ctx, name, val) {
+			let len = length(val);
+			if ((this.min == null || len >= this.min) &&
+			    (this.max == null || len <= this.max))
+				return val;
+			if (this.min != null && this.max != null)
+				ctx.invalid_argument(`String value %s must be between ${this.min} and ${this.max} characters`, name);
+			else if (this.min != null)
+				ctx.invalid_argument(`String value %s must be at least ${this.min} characters long`, name);
+			else
+				ctx.invalid_argument(`String value %s must not be longer than ${this.max} characters`, name);
+			return;
+		}
+	},
+	enum: {
+		parse: function(ctx, name, val) {
+			if (this.no_validate)
+				return val;
+
+			let list = this.value;
+			if (this.ignore_case) {
+				val = lc(val);
+				val = filter(list, (v) => val == lc(v))[0];
+			} else {
+				if (index(list, val) < 0)
+					val = null;
+			}
+
+			if (val == null)
+				ctx.invalid_argument("Invalid value for %s", name);
+
+			return val;
+		}
+	},
+	path: {
+		complete: function(ctx, val) {
+			let ret = [];
+
+			let dir = split(val, "/");
+			let prefix = pop(dir);
+			push(dir, "");
+			dir = join("/", dir);
+			let prefix_len = length(prefix);
+			let d = opendir(length(dir) ? dir : ".");
+			if (!d)
+				return ret;
+
+			let cur;
+			while (cur = d.read()) {
+				if (cur == "." || cur == "..")
+					continue;
+
+				if (substr(cur, 0, prefix_len) != prefix)
+					continue;
+
+				let path = dir + cur;
+				let incomplete = false;
+				if (is_directory(path)) {
+					path += "/";
+					incomplete = true;
+				}
+
+				push(ret, { name: path, incomplete });
+			}
+
+			return ret;
+		},
+		parse: function(ctx, name, val) {
+			if (this.new_path) {
+				let dir = dirname(val);
+				let s = stat(dir);
+				if (!is_directory(dir)) {
+					ctx.invalid_argument("Path '%s' is not a directory", dir);
+					return;
+				}
+			} else {
+				if (!access(val, "r")) {
+					ctx.invalid_argument("Path '%s' does not exist", val);
+					return;
+				}
+			}
+			return val;
+		}
+	},
+	host: {
+		parse: function(ctx, name, val) {
+			if (length(iptoarr(val)) != 0)
+				return val;
+			if (length(val) > 255)
+				return;
+			let labels = split(val, ".");
+			if (length(filter(labels, label => !match(label, /^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/))) == 0 && length(labels) > 0)
+				return val;
+			ctx.invalid_argument("value for %s is not an valid IP or hostname", name);
+			return;
+		}
+	},
+	macaddr: {
+		parse: function(ctx, name, val) {
+			val = lc(val);
+			let arr = split(val, ":");
+			if (length(arr) != 6 || length(filter(arr, (v) => !match(v, /^[0-9a-f][0-9a-f]$/))))
+				return ctx.invalid_argument("value for %s is not an MAC address", name);
+			return val;
+		}
+	},
+	ipv4: {
+		parse: function(ctx, name, val) {
+			if (length(iptoarr(val)) == 4)
+				return val;
+			ctx.invalid_argument("value for %s is not an IPv4", name);
+			return;
+		}
+	},
+	ipv6: {
+		parse: function(ctx, name, val) {
+			if (length(iptoarr(val)) == 16)
+				return val;
+			ctx.invalid_argument("value for %s is not an IPv6", name);
+			return;
+		}
+	},
+	cidr4: {
+		parse: function(ctx, name, val) {
+			let m = split(val, '/', 2);
+			if (m && +m[1] <= 32 &&
+			    ((m[0] == "auto" && this.allow_auto) ||
+			     length(iptoarr(m[0])) == 4))
+				return val;
+			ctx.invalid_argument("value for %s is not cidr4 (e.g. 192.168.1.1/24)", name);
+			return;
+		}
+	},
+};
+
+return types;

package/utils/cli/files/usr/share/ucode/cli/utils.uc

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+// Copyright (C) 2025 Felix Fietkau <[email protected]>
+'use strict';
+
+export function time_format(val)
+{
+	let ret = `${val % 60}s`;
+
+	val /= 60;
+	if (!val)
+		return ret;
+
+	ret = `${val % 60}m ${ret}`;
+
+	val /= 60;
+	if (!val)
+		return ret;
+
+	ret = `${val % 24 }h ${ret}`;
+
+	val /= 24;
+	if (!val)
+		return ret;
+
+	return `${val}d ${ret}`;
+};