tassello 0.4.0 → 0.6.0

package/CHANGELOG.md

@@ -5,6 +5,42 @@ change the plugin API (`tassello/sdk`, `tassello/server`, `tassello/vite`), as n
 
 ## Unreleased
 
+- Parameters widget: nodes' parameters, as rqt_reconfigure and `ros2 param` show them. A node's
+  parameters grouped by their prefixes, each edited in place (a switch, a slider within its range,
+  a field), with what the node refuses and why; changes made elsewhere followed live on
+  `/parameter_events`. Their descriptions, ranges and constraints (`describe`); new ones set and
+  undeclared ones deleted (`set`, `delete`); all of them dumped as YAML, downloaded, saved on the
+  robot or copied (`dump`), and loaded from a YAML file of the robot or of the page's device
+  (`load`), as `ros2 param` does, with Python's yaml. A widget can be for one node, or view only.
+- The file browser picks parameter files (YAML) too.
+- Plugins: `connection.subscribeParameters`, `setParameters`, `dumpParameters`, `loadParameters`,
+  and the types of `src/shared/parameters.ts`.
+- Navigation widget: the laser scan, put in the map frame by TF as each arrives (in 3D: a lidar
+  mounted upside down lands where it looks), the quickest check of the localization; and the
+  robot drawn with Nav2's footprint (`published_footprint`), moving with the robot. A scan no
+  longer coming turns gray; what cannot be shown is said over the map.
+- Plugins: `connection.subscribeOverlay`, a laser scan's points or a footprint's polygon in a
+  frame.
+- ROS Monitor widget: the ROS graph, as the `ros2` command line shows it, on three sheets: its
+  topics, services and actions, filtered by name or type, the hidden ones on demand. A topic's
+  messages (`ros2 topic echo`: a field of them, lists cut, the latest 100 kept while paused), their
+  rate, bandwidth and delay over a window (`hz`, `bw`, `delay`: from the serialized messages,
+  exact), its publishers and subscriptions with their QoS and those that cannot talk (`info -v`),
+  a message to publish, field by field or as JSON, once or at a rate (`pub`: QoS matching the
+  subscriptions, `now` stamps), going on while other topics are shown. A service to call, once
+  or at a rate (`ros2 service call`), its nodes (`info`) and its events (`echo`, since Jazzy).
+  Every goal of an action, whoever sent it, with its latest feedback, to cancel one or all; a
+  goal to send and follow to its result (`ros2 action send_goal`). Their types' definitions
+  (`ros2 interface show`).
+- rclnodejs's code of the ROS interfaces sourced since it was installed (a robot's own messages,
+  services and actions), or rebuilt with new ones, is made when the server starts: their topics,
+  services and actions work in every widget without `npx generate-ros-messages`. rclnodejs's own
+  fallback missed services' and actions' interfaces.
+- Plugins: `connection.subscribeGraph`, `subscribeTopicInfo`, `subscribeTopicMonitor`,
+  `publishTopic`, `interfaceInfo`, `subscribeAction`, `sendGoal`, `cancelGoal`, and `callService`'s
+  `checked` option, which makes the request from the service's definition: 64 bit integers, which
+  rclnodejs takes as BigInt only, now work. The types of `src/shared/monitor.ts`, and the
+  `MinusIcon`, `TopicIcon`, `ServiceIcon`, `ActionIcon`, `MonitorIcon` and `SendIcon` icons.
 - Behavior Tree Inspector widget: what a BT.CPP behavior tree is doing, from its
   `nav2_msgs/BehaviorTreeLog` (Nav2's `/behavior_tree_log`), on the tree of its XML file: the
   running branch, each node's status, last result, counts and ports, and the latest transitions,
@@ -81,6 +117,8 @@ change the plugin API (`tassello/sdk`, `tassello/server`, `tassello/vite`), as n
 - Plugins: `connection.subscribeNetwork`, `networkAction`, the `Network*`, `WifiNetwork`,
   `WifiSecurity` and `ConnectionKind` types, and the `NetworkIcon`, `WifiIcon`, `WifiOffIcon`,
   `EthernetIcon`, `HotspotIcon` and `ShieldIcon` icons.
+- Plugins: a `select` property's options can be known at run time, e.g. the robot's: `useOptions`,
+  a hook the properties panel calls. Its values are not checked against the options.
 
 ## 0.1.0
 

package/README.md

@@ -11,8 +11,9 @@ and plugins add more.
 - **Every device**: a desktop canvas, and layouts of their own for tablets and phones.
 - **Built in**: teleop pads, a Nav2 map with goals, the robot's URDF in 3D, an arm jogger, cameras,
   images, command buttons, a systemd application manager, a behavior tree inspector and
-  editor, the ROS log of every node, the robot's diagnostics, a file manager, a terminal, and
-  its networks: Wi-Fi joined, connections switched, the robot as an access point.
+  editor, the ROS log of every node, the robot's diagnostics, its topics, services and actions
+  as the `ros2` command line shows them, its nodes' parameters, a file manager, a terminal, and its networks: Wi-Fi
+  joined, connections switched, the robot as an access point.
 - **Plugins**: widgets of your own, with server-side code if they need it, as npm or ROS packages.
 - **One process**: a ROS 2 node in Node.js. Nothing to install on the robot but Node.js.
 
@@ -40,6 +41,14 @@ tassello
 and open `http://<robot>:8080`. The first start creates the panels directory with two example
 panels, Teleoperation and Navigation.
 
+Source the workspaces whose messages the widgets use too, a robot's own (`/opt/<vendor>/…`, a
+colcon workspace's `install/setup.bash`): rclnodejs needs JavaScript code of every interface it
+uses, which it makes when installed for the packages then sourced. Tassello makes that of the
+others when it starts, and again for a package rebuilt with new interfaces, in a fraction of a
+second; rclnodejs keeps it in its `generated` folder, which the server's user must be able to
+write (else, run `npx generate-ros-messages` in Tassello's folder, with them sourced, as a user who
+can).
+
 ```text
 tassello [options] [--ros-args ...]
 
@@ -110,7 +119,7 @@ after the others on the devices already arranged.
 | Widget | What it does |
 |---|---|
 | **Teleop** | Publishes velocity commands (`Twist` or `TwistStamped`) while its pads are held: one pad (x, z), or two in omnidirectional mode (x and y, z). Then one zero, and nothing, so that the lower priorities of a twist_mux, e.g. navigation, take over again |
-| **Navigation** | The map, optionally the global and local costmaps and the planned path, and the robot where TF puts it. Its tools set the pose estimate and send navigation goals, as RViz's do: press where the robot is or should go, drag towards where it faces. Pan, zoom, fit the map or follow the robot |
+| **Navigation** | The map, optionally the global and local costmaps and the planned path, the laser scan, and the robot where TF puts it, drawn with Nav2's footprint. Its tools set the pose estimate and send navigation goals, as RViz's do: press where the robot is or should go, drag towards where it faces. Pan, zoom, fit the map or follow the robot |
 | **Robot Model** | The robot in 3D, from its URDF and meshes, posed by the joint states. The links of moving joints turn orange, with an arrow at the joint in the direction of the motion |
 | **Arm Teleop** | Jogs an arm driven by ros2_control `JointTrajectoryController`s: a slider per joint, or pads moving the end effector in a straight line (damped least squares on the URDF's kinematics, collision checked by MoveIt's move_group when it runs) |
 | **Camera** | An image topic, raw (`sensor_msgs/Image`) or compressed (`sensor_msgs/CompressedImage`) |
@@ -121,6 +130,8 @@ after the others on the devices already arranged.
 | **Behavior Tree Editor** | Edits a BT.CPP behavior tree's XML file of the robot as a graph: nodes from a palette (BT.CPP's, Nav2's, your libraries'), dragged where they go, moved with their children, their names and ports edited in a side panel. Subtrees, undo and redo, copy and paste, an XML view. Saves only what changed, never over changes made meanwhile |
 | **Logs** | The ROS log (`/rosout`), as rqt_console and swri_console show it: every node's messages coloured by level, the nodes running and those that logged with their counts, filtered by node, by level and by text (terms or a regular expression, to show or to hide). Pause, follow the newest, clear, download, and a message's details: where it was logged |
 | **Diagnostics** | The robot's diagnostics (`/diagnostics`, or the aggregator's `/diagnostics_agg`), as rqt_robot_monitor shows them: each status's level, the groups with the worst under them, those with problems unfolded. As a tree, as a list (the worst first) or as the latest changes of level, filtered by level and by text; a widget can be for some statuses only. A status's details: its message, hardware ID, values and latest changes. Pause, download, and forget the statuses no longer published |
+| **ROS Monitor** | The ROS graph, as the `ros2` command line shows it, on three sheets: its topics, services and actions, filtered by name or type, the hidden ones on demand. A topic's messages, their rate, bandwidth and delay, its publishers and subscriptions with their QoS and those that cannot talk, a message to publish once or at a rate (`ros2 topic echo`, `hz`, `bw`, `delay`, `info -v`, `pub`); a service to call, once or at a rate (`ros2 service call`, `info`, `echo`); every goal of an action, whoever sent it, with its feedback, and a goal to send or cancel (`ros2 action send_goal`, `info`); their types' definitions (`ros2 interface show`) |
+| **Parameters** | Nodes' parameters, as rqt_reconfigure and `ros2 param` show them: the nodes of the graph, and the parameters of the one chosen grouped by their prefixes, each edited in place (a switch, a slider within its range, a field), live as they change wherever they are set. Their descriptions, ranges and constraints (`ros2 param describe`); new ones set and undeclared ones deleted (`set`, `delete`); all of them dumped as YAML, downloaded or saved on the robot (`dump`), and loaded from a YAML file of the robot or of the page's device (`load`) |
 | **File Manager** | The robot's files: folders unfolded in place, places (home, the ROS workspaces, bookmarks) and the disks' free space, an entry's details and permissions, what takes a folder's space. Make, rename, cut, copy, paste, drag onto folders, delete, download (folders as `.tar.gz`) and upload (drop files and folders onto it). Text files edited in tabs as gedit does: highlighting, search and replace, undo; images and PGM maps shown |
 | **Terminal** | A shell on the robot, or a command (`htop`, `tmux attach`), in a full terminal: colours, full screen programs, the mouse. It outlives the page: reloaded, reconnected or shown again, it is as it was. On touch screens, the keys phones lack, as Termux has them: Esc, Tab, Ctrl, Alt, Home, End, the arrows, Page Up and Down, and while typing the terminal fills the screen above the on-screen keyboard |
 | **Networking** | The robot's networks, through NetworkManager, as a phone's settings show them: the Wi-Fi networks in range, joined with their password; the connections saved, switched between, edited (their addresses by DHCP or static), forgotten; the robot as an access point, its network shared by a QR code; the interfaces, their state and addresses. Asks before a change that would cut the page off from the robot |
@@ -133,6 +144,16 @@ Notes on some of them:
   bt_navigator follows) and pose estimates as `geometry_msgs/PoseWithCovarianceStamped`
   (`/initialpose`, with RViz's covariance, which AMCL starts from). Layers in another frame, like
   Nav2's local costmap, are placed in the map frame by TF.
+
+  The laser scan (`sensor_msgs/LaserScan`, `/scan`) is the quickest check of the localization:
+  its points fall on the map's walls when the robot is where the map frame says. Each scan is put
+  in the map frame by TF as it arrives, on the server, in 3D (a lidar mounted upside down or
+  tilted lands where it looks), its points without a return left out, at most 5 a second; a scan
+  no longer coming turns gray after 1.5 s. The robot is drawn with the footprint Nav2's costmaps
+  use (`geometry_msgs/PolygonStamped`, `/local_costmap/published_footprint`), put in the robot's
+  frame as it arrives and drawn where the robot is now, so that it moves with it; a circle
+  without it, or zoomed out too far to see it. What cannot be shown, e.g. a scan whose frame TF
+  does not connect to the map, is said above the robot's pose.
 - **Robot Model** loads the meshes of the description from the robot's ROS packages
   (`package://` paths), which the server serves compressed. three.js is only fetched by the pages
   showing one.
@@ -234,6 +255,71 @@ Notes on some of them:
   filter and view it opens with. The server follows the diagnostics for every page, and for 10
   minutes after the last page closes, keeping the latest status of each name and their latest
   1,000 changes of level.
+- **ROS Monitor** lists the topics (`ros2 topic list -v`: their types, publishers and
+  subscribers), the services and the actions (with the nodes serving and using them, asked node
+  by node as `ros2 action info` does), read again every 2 s. The filter keeps those whose name or
+  type contain any of its terms, separated by `;` (`ros2 topic find`), or match a regular
+  expression; the eye shows the hidden ones: names with a part starting with `_` (an action's
+  topics and services), and every node's parameter services. A topic, service or action clicked
+  shows its details in tabs, beside the list or under it; the arrow keys go through the list. The
+  widget's properties set the sheet and filter it opens with, and a topic, service or action to
+  open (one widget for `/odom`'s messages).
+
+  A topic's **Echo** shows its messages as `ros2 topic echo` prints them, folding: the latest,
+  at most 10 a second, or only a *field* of them (`pose.position`, `ranges[0]`); lists and
+  strings longer than the widget's *length* are cut (`--truncate-length`), NaN and infinities
+  written `.nan`, `.inf`. Pausing keeps the latest 100 to go back through. Copy writes a message
+  as YAML; the pencil edits it in the Publish tab. **Rate** shows, over the latest messages (the
+  *window*, `--window`), their rate and the spread of the intervals between them (`ros2 topic
+  hz`), their bandwidth and sizes, serialized (`ros2 topic bw`), and for messages with a header,
+  the delay from its stamp to their arrival on the ROS clock (`ros2 topic delay`). The server
+  takes the messages serialized: their sizes are exact, the stamps read from their bytes, and
+  only those shown are deserialized. **Info** lists the publishers and subscriptions with their
+  QoS (`ros2 topic info -v`), the dashboard's own named so, and says which do not talk and why: a
+  best effort publisher and a reliable subscription, a volatile publisher and a transient local
+  (latched) one, deadlines and liveliness that do not match, other types. **Publish** fills in a
+  message field by field, made from its type's definition (lists of numbers on a line, nested
+  messages folding, constants suggested), or as JSON; a time may be *now*, made the time of each
+  message as `ros2 topic pub` does (`"now"` in JSON, `"auto"` for a header). It is published
+  once, or at a rate, a number of times or until stopped (`-r`, `-t`), with its QoS: by default
+  reliable, and transient local if one of the topic's subscriptions is, which every subscription
+  matches. A new publisher waits up to a second for the subscriptions to match it, as a first
+  message would be lost. Publishing goes on while other topics are shown, until stopped from the
+  status line or the widget goes. **Type** shows the type's definition as `ros2 interface show`
+  prints it.
+
+  A service's **Call** fills in its request as Publish does a message, and calls it once or at
+  a rate (`ros2 service call -r`), with a timeout, showing its response and how long it took.
+  **Echo** shows its requests and responses as they go (`ros2 service echo`), when its node
+  introspects them: since Jazzy, with `configure_introspection`. An action's **Goals** are those
+  its servers have, whoever sent them, from its status topic, with the latest feedback of each:
+  what Nav2 is doing, goals sent from RViz included. Those sent from the dashboard have their
+  result too. Any goal is canceled with its button, all of them with *Cancel all*. **Send** fills
+  in a goal and sends it (`ros2 action send_goal -f`), following it to its result. The server
+  follows an action for the pages, and for 10 minutes after the last one: a page opened later
+  finds the goals sent and their results. **Info** lists the nodes serving and using a service
+  or an action (`ros2 service info`, `ros2 action info`).
+
+  Messages, requests and goals are made from rclnodejs's code of their types, which Tassello
+  makes when it starts for the workspaces sourced (see Install).
+- **Parameters** lists the nodes of the graph (but the hidden ones, as `ros2 node list` does), or
+  shows one node only, its *node* (a panel to tune `/controller_server`). A node's parameters are
+  read through its parameter services (`rcl_interfaces`), grouped by the prefixes of their names
+  (the groups of read-only parameters only, such as `qos_overrides`, folded), and filtered by name
+  or description. Each is edited with its type's editor: a switch for a boolean, a slider and a
+  field for a number with a range, a field for the others (lists' items separated by commas),
+  applied on Enter or when left; what the node refuses (out of its range, of another type, read
+  only) is said under it, with the node's reason, and the value goes back. Changes made elsewhere
+  (`ros2 param set`, the node itself) show as they come: the server follows `/parameter_events`.
+  A parameter's details give its description, type, range and constraints, copy its value or its
+  `ros2 param set` command, and delete it (`ros2 param delete`, which only undeclared parameters
+  allow). *Add* sets a parameter the node did not declare, which nodes allow only if they say so;
+  its type is read from its value as `ros2 param set` reads it (`[1, 2.5]`: doubles), or chosen.
+  *Dump* writes the YAML `ros2 param dump` writes, downloaded, saved on the robot or copied; *Load*
+  reads a parameter file of the robot or of the page's device as `ros2 param load` does (the
+  node's section, and the `/**` one) and sets its parameters one by one, saying which the node
+  refused and why. Parameter files are read and written by Python's yaml, as `ros2 param` does. A
+  widget can be *view only*.
 - **File Manager** opens its *folder* (`~` by default; `/…`, `~/…`, `package://…`) and lists it
   with its entries' sizes and times, sorted by name (naturally: `run_2` before `run_10`), size or
   time, folders first; the chevrons unfold folders in place. Its places are home, the root, the
@@ -379,7 +465,9 @@ and ship example panels. See **[docs/plugins.md](docs/plugins.md)**.
 
 ## Security
 
-Tassello has no login. **Anyone who can open the page can drive the robot, run any command as
+Tassello has no login. **Anyone who can open the page can drive the robot, publish on any topic,
+call any service and send or cancel any goal (the ROS Monitor), change any node's parameters
+(Parameters), run any command as
 the server's user (the Terminal, a shell), read, write, upload, move and delete any of the
 files that user can (the File Manager), and change the robot's networks and read their passwords
 (Networking)**: keep it on a network you trust, or behind a reverse proxy

package/dist/server/actions.d.ts

@@ -0,0 +1,24 @@
+import rclnodejs from 'rclnodejs';
+import type { ActionGoal, CancelResult } from '../shared/monitor.ts';
+import type { StreamState } from './frame_stream.ts';
+import type { Interfaces } from './interfaces.ts';
+import { type Logger } from './util.ts';
+export interface ActionWatcher {
+    onStatus: (state: StreamState, message: string) => void;
+    onGoals: (goals: ActionGoal[]) => void;
+}
+export declare function uuidText(uuid: ArrayLike<number>): string;
+export declare function uuidBytes(text: string): number[];
+export declare class Actions {
+    private readonly node;
+    private readonly interfaces;
+    private readonly logger;
+    private readonly followed;
+    constructor(node: rclnodejs.Node, interfaces: Interfaces, logger: Logger);
+    watch(action: string, type: string, watcher: ActionWatcher): () => void;
+    send(action: string, type: string, goal: unknown): Promise<string>;
+    cancel(action: string, type: string, goal: string | null): Promise<CancelResult>;
+    stopAll(): void;
+    private follow;
+    private release;
+}

package/dist/server/actions.js

@@ -0,0 +1,331 @@
+// Actions for the monitor widgets: ros2 action send_goal, and what an
+// action's servers are doing, whoever sent them their goals: every goal of
+// the status topic (<action>/_action/status), with the latest feedback of
+// each (<action>/_action/feedback). The goals the dashboard sends have their
+// result too. Goals are canceled through the cancel service, one or all of
+// them, whoever sent them.
+//
+// One follower per action, shared by its pages. It outlives them while the
+// goals they sent run, and for LINGER_MS after: a page opened later finds
+// them, their results included.
+import { randomBytes } from 'node:crypto';
+import rclnodejs from 'rclnodejs';
+import { missingCodeHint } from './message_code.js';
+import { echoJson, parseType } from './message_format.js';
+import { absoluteTopic, errorMessage } from './util.js';
+const STATUS_TYPE = 'action_msgs/msg/GoalStatusArray';
+const CANCEL_TYPE = 'action_msgs/srv/CancelGoal';
+// action_msgs/msg/GoalStatus's values, in order
+const STATUSES = ['unknown', 'accepted', 'executing', 'canceling', 'succeeded', 'canceled', 'aborted'];
+const DONE = new Set(['succeeded', 'canceled', 'aborted']);
+// Kept, the latest accepted
+const MAX_GOALS = 20;
+// Of the goals and feedback sent, the results
+const TRUNCATE = 256;
+const RESULT_TRUNCATE = 10_000;
+const UPDATE_PERIOD_MS = 200;
+const LINGER_MS = 10 * 60_000;
+const SERVER_TIMEOUT_MS = 5000;
+const { HistoryPolicy, ReliabilityPolicy, DurabilityPolicy } = rclnodejs.QoS;
+// 8-4-4-4-12 hex digits
+export function uuidText(uuid) {
+    const hex = Array.from(uuid, (b) => b.toString(16).padStart(2, '0')).join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+export function uuidBytes(text) {
+    const hex = text.replace(/-/g, '');
+    if (!/^[0-9a-f]{32}$/i.test(hex)) {
+        throw new Error(`"${text}" is not a goal's UUID`);
+    }
+    return Array.from({ length: 16 }, (_, i) => parseInt(hex.slice(i * 2, i * 2 + 2), 16));
+}
+function milliseconds(stamp) {
+    return stamp.sec * 1000 + stamp.nanosec / 1e6;
+}
+class FollowedAction {
+    watchers = new Set();
+    // Of the dashboard's goals, running
+    running = 0;
+    lingerTimer = null;
+    node;
+    interfaces;
+    logger;
+    action;
+    type;
+    goals = new Map();
+    subscriptions = [];
+    client = null;
+    cancelClient = null;
+    updateTimer = null;
+    updatedAt = 0;
+    state = 'waiting';
+    message = '';
+    constructor(node, interfaces, logger, action, type) {
+        this.node = node;
+        this.interfaces = interfaces;
+        this.logger = logger;
+        this.action = action;
+        this.type = type;
+        try {
+            this.subscriptions.push(this.node.createSubscription(STATUS_TYPE, `${action}/_action/status`, {
+                // The servers' own: their latest statuses, latched
+                qos: new rclnodejs.QoS(HistoryPolicy.RMW_QOS_POLICY_HISTORY_KEEP_LAST, 1, ReliabilityPolicy.RMW_QOS_POLICY_RELIABILITY_RELIABLE, DurabilityPolicy.RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL),
+            }, (message) => this.onStatuses(message)), this.node.createSubscription(
+            // @ts-expect-error: the type is a runtime string, not one of the literal types
+            `${type}_FeedbackMessage`, `${action}/_action/feedback`, {}, (message) => this.onFeedback(message)));
+            this.setState('streaming', '');
+        }
+        catch (e) {
+            this.setState('error', `Cannot follow ${action}: ${missingCodeHint(errorMessage(e))}`);
+        }
+    }
+    add(watcher) {
+        this.watchers.add(watcher);
+        watcher.onStatus(this.state, this.message);
+        watcher.onGoals(this.list());
+    }
+    // Resolves with the goal's UUID once accepted
+    async send(goal) {
+        const message = this.interfaces.message(`${this.type}_Goal`, goal);
+        this.client ??= new rclnodejs.ActionClient(this.node, 
+        // @ts-expect-error: as above
+        this.type, this.action);
+        if (!(await this.client.waitForServer(SERVER_TIMEOUT_MS))) {
+            throw new Error(`No server of ${this.action}`);
+        }
+        const bytes = Array.from(randomBytes(16));
+        const id = uuidText(bytes);
+        const handle = await this.client.sendGoal(message, undefined, { uuid: bytes });
+        if (!handle.accepted) {
+            throw new Error(`${this.action} rejected the goal`);
+        }
+        const now = Date.now();
+        const sent = { goal: echoJson(message, TRUNCATE), at: now, result: null, error: null };
+        const known = this.goals.get(id);
+        this.goals.set(id, {
+            id,
+            status: known?.status ?? 'accepted',
+            acceptedAt: known?.acceptedAt ?? now,
+            feedback: known?.feedback ?? null,
+            feedbacks: known?.feedbacks ?? 0,
+            updatedAt: now,
+            sent,
+        });
+        this.running++;
+        this.changed();
+        handle
+            .getResult()
+            .then((result) => {
+            sent.result = echoJson(result, RESULT_TRUNCATE);
+            this.update(id, STATUSES[handle.status] ?? 'unknown');
+        }, (e) => {
+            sent.error = `No result: ${errorMessage(e)}`;
+            this.update(id, null);
+        })
+            .finally(() => {
+            this.running--;
+            this.onIdle?.();
+        });
+        return id;
+    }
+    // Cancels the goal, or all of them (null)
+    async cancel(goal) {
+        this.cancelClient ??= this.node.createClient(CANCEL_TYPE, `${this.action}/_action/cancel_goal`);
+        const client = this.cancelClient;
+        if (!(await client.waitForService(SERVER_TIMEOUT_MS))) {
+            throw new Error(`No server of ${this.action}`);
+        }
+        const response = await client.sendRequestAsync({
+            goal_info: {
+                goal_id: { uuid: goal === null ? new Array(16).fill(0) : uuidBytes(goal) },
+                stamp: { sec: 0, nanosec: 0 },
+            },
+        }, { timeout: SERVER_TIMEOUT_MS });
+        return {
+            code: response.return_code,
+            canceling: Array.from(response.goals_canceling, (info) => uuidText(info.goal_id.uuid)),
+        };
+    }
+    // Called when its last page went and no goal of the dashboard's runs
+    onIdle = null;
+    destroy() {
+        if (this.updateTimer) {
+            clearTimeout(this.updateTimer);
+        }
+        if (this.lingerTimer) {
+            clearTimeout(this.lingerTimer);
+        }
+        for (const subscription of this.subscriptions) {
+            this.node.destroySubscription(subscription);
+        }
+        if (this.cancelClient) {
+            this.node.destroyClient(this.cancelClient);
+        }
+        this.client?.destroy();
+    }
+    onStatuses(message) {
+        const now = Date.now();
+        for (const { goal_info, status } of message.status_list) {
+            const id = uuidText(goal_info.goal_id.uuid);
+            const known = this.goals.get(id);
+            const value = STATUSES[status] ?? 'unknown';
+            if (!known) {
+                this.goals.set(id, {
+                    id,
+                    status: value,
+                    acceptedAt: milliseconds(goal_info.stamp),
+                    feedback: null,
+                    feedbacks: 0,
+                    updatedAt: now,
+                    sent: null,
+                });
+            }
+            else if (known.status !== value && !(DONE.has(known.status) && known.sent?.result)) {
+                known.status = value;
+                known.acceptedAt = milliseconds(goal_info.stamp);
+                known.updatedAt = now;
+            }
+            else {
+                known.acceptedAt = milliseconds(goal_info.stamp);
+            }
+        }
+        this.changed();
+    }
+    onFeedback(message) {
+        const id = uuidText(message.goal_id.uuid);
+        const now = Date.now();
+        let goal = this.goals.get(id);
+        if (!goal) {
+            // Before its status
+            goal = { id, status: 'executing', acceptedAt: now, feedback: null, feedbacks: 0, updatedAt: now, sent: null };
+            this.goals.set(id, goal);
+        }
+        goal.feedback = echoJson(message.feedback, TRUNCATE);
+        goal.feedbacks++;
+        goal.updatedAt = now;
+        this.changed();
+    }
+    update(id, status) {
+        const goal = this.goals.get(id);
+        if (goal) {
+            if (status) {
+                goal.status = status;
+            }
+            goal.updatedAt = Date.now();
+            this.changed();
+        }
+    }
+    // The latest accepted first
+    list() {
+        return [...this.goals.values()].sort((a, b) => b.acceptedAt - a.acceptedAt).slice(0, MAX_GOALS);
+    }
+    // To the pages, at most every UPDATE_PERIOD_MS
+    changed() {
+        // Those beyond the latest MAX_GOALS go, but those still running
+        if (this.goals.size > MAX_GOALS) {
+            const kept = new Set(this.list().map((g) => g.id));
+            for (const [id, goal] of this.goals) {
+                if (!kept.has(id) && DONE.has(goal.status)) {
+                    this.goals.delete(id);
+                }
+            }
+        }
+        if (this.updateTimer) {
+            return;
+        }
+        const send = () => {
+            this.updateTimer = null;
+            this.updatedAt = Date.now();
+            const goals = this.list();
+            for (const watcher of this.watchers) {
+                watcher.onGoals(goals);
+            }
+        };
+        const wait = this.updatedAt + UPDATE_PERIOD_MS - Date.now();
+        if (wait > 0) {
+            this.updateTimer = setTimeout(send, wait);
+        }
+        else {
+            send();
+        }
+    }
+    setState(state, message) {
+        if (state === 'error') {
+            this.logger.warn(message);
+        }
+        this.state = state;
+        this.message = message;
+        for (const watcher of this.watchers) {
+            watcher.onStatus(state, message);
+        }
+    }
+}
+export class Actions {
+    node;
+    interfaces;
+    logger;
+    followed = new Map();
+    constructor(node, interfaces, logger) {
+        this.node = node;
+        this.interfaces = interfaces;
+        this.logger = logger;
+    }
+    // The action's goals, now and whenever they change, until the returned
+    // function is called
+    watch(action, type, watcher) {
+        const followed = this.follow(action, type);
+        followed.add(watcher);
+        return () => {
+            followed.watchers.delete(watcher);
+            this.release(followed);
+        };
+    }
+    // ros2 action send_goal: resolves with the goal's UUID once accepted
+    send(action, type, goal) {
+        const followed = this.follow(action, type);
+        return followed.send(goal).finally(() => this.release(followed));
+    }
+    cancel(action, type, goal) {
+        const followed = this.follow(action, type);
+        return followed.cancel(goal).finally(() => this.release(followed));
+    }
+    stopAll() {
+        for (const followed of this.followed.values()) {
+            followed.destroy();
+        }
+        this.followed.clear();
+    }
+    follow(action, type) {
+        const name = absoluteTopic(action);
+        if (parseType(type).kind !== 'action') {
+            throw new Error(`${type} is not an action type (package/action/Name)`);
+        }
+        const key = `${name} ${type}`;
+        let followed = this.followed.get(key);
+        if (!followed) {
+            const created = new FollowedAction(this.node, this.interfaces, this.logger, name, type);
+            created.onIdle = () => this.release(created);
+            this.followed.set(key, created);
+            followed = created;
+        }
+        if (followed.lingerTimer) {
+            clearTimeout(followed.lingerTimer);
+            followed.lingerTimer = null;
+        }
+        return followed;
+    }
+    // Once nothing needs it: for LINGER_MS more
+    release(followed) {
+        if (followed.watchers.size > 0 || followed.running > 0 || followed.lingerTimer) {
+            return;
+        }
+        followed.lingerTimer = setTimeout(() => {
+            for (const [key, f] of this.followed) {
+                if (f === followed) {
+                    this.followed.delete(key);
+                }
+            }
+            followed.destroy();
+        }, LINGER_MS);
+    }
+}

package/dist/server/files.d.ts

@@ -1,5 +1,5 @@
 export declare const IMAGE_EXTENSIONS: Set<string>;
-export type FileKind = 'image' | 'behavior-tree' | 'bag' | 'folder';
+export type FileKind = 'image' | 'behavior-tree' | 'bag' | 'yaml' | 'folder';
 export declare const MAX_UPLOAD_BYTES: number;
 export declare function fileKind(value: string | null): FileKind;
 export declare function resolveImagePath(input: string, home?: string): string;

package/dist/server/files.js

@@ -2,7 +2,8 @@
 // behavior tree inspectors: files of the robot, which a page picks by
 // browsing its directories, and files uploaded from a page, kept by the
 // server next to the panels. Only those: the dashboard does not hand out any
-// file of the robot. A page also browses for rosbags, and for folders.
+// file of the robot. A page also browses for rosbags, parameter files (YAML),
+// and folders.
 import { createHash } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
@@ -13,6 +14,8 @@ const EXTENSIONS = {
     image: IMAGE_EXTENSIONS,
     'behavior-tree': new Set(['.xml']),
     bag: new Set(['.mcap', '.db3']),
+    // Parameter files
+    yaml: new Set(['.yaml', '.yml']),
     folder: new Set(),
 };
 const FILE_KINDS = new Set(Object.keys(EXTENSIONS));

package/dist/server/interfaces.d.ts

@@ -0,0 +1,16 @@
+import rclnodejs from 'rclnodejs';
+import type { InterfaceInfo, MessageSchema } from '../shared/monitor.ts';
+import { type RosTime } from './message_format.ts';
+export declare class Interfaces {
+    private readonly node;
+    private readonly schemas;
+    private readonly infos;
+    constructor(node: rclnodejs.Node);
+    schemasOf(type: string, into?: Record<string, MessageSchema>): Record<string, MessageSchema>;
+    info(type: string): InterfaceInfo;
+    message(type: string, value: unknown): Record<string, unknown>;
+    hasHeader(type: string): boolean;
+    now(): RosTime;
+    private schema;
+    private definition;
+}