tassello 0.5.0 → 0.7.0

package/dist/server/behavior_trees.d.ts

@@ -1,8 +1,10 @@
 import type rclnodejs from 'rclnodejs';
 import { type BehaviorTreeRecording, type BehaviorTreeUpdate } from '../shared/protocol.ts';
+import { type RecordOptions } from '../shared/rosbag.ts';
 import { type TreeInfo } from './behavior_tree_file.ts';
 import { BehaviorTreePlayback, type PlaybackWatcher } from './behavior_tree_playback.ts';
 import type { StreamState } from './frame_stream.ts';
+import type { Rosbags } from './rosbags.ts';
 import { type Logger } from './util.ts';
 export type RecordingInfo = BehaviorTreeRecording['recording'];
 export interface BehaviorTreeWatcher {
@@ -17,12 +19,12 @@ export declare class BehaviorTrees {
     private readonly uploadsDir;
     private readonly topics;
     private readonly monitors;
+    private readonly rosbags;
     private readonly recordings;
-    constructor(node: rclnodejs.Node, logger: Logger, uploadsDir: string);
+    constructor(node: rclnodejs.Node, logger: Logger, uploadsDir: string, rosbags: Rosbags);
     watch(topic: string, tree: string, watcher: BehaviorTreeWatcher): () => void;
-    record(topic: string, path: string | null): Promise<string | null>;
+    record(topic: string, path: string | null, options?: RecordOptions): Promise<string | null>;
     play(bag: string, topic: string, tree: string, watcher: PlaybackWatcher): BehaviorTreePlayback;
-    stopAll(): Promise<void>;
     private recordingOf;
     private announce;
     private forget;

package/dist/server/behavior_trees.js

@@ -9,17 +9,19 @@
 // outlives its last page for LINGER_MS: a page reloaded, or a panel shown
 // again, finds the nodes as they are, which the log only says when they change.
 //
-// A topic is recorded into a rosbag (ros2 bag record) when a page asks, until
-// one asks to stop: every page following it is told. A bag is played back for
-// the page that opens it (behavior_tree_playback.ts).
+// A topic is recorded into a rosbag when a page asks, until one asks to stop
+// (or a Rosbags widget stops it): every page following it is told. The
+// recording is the server's rosbags' (rosbags.ts), as the Rosbags widgets'
+// are. A bag is played back for the page that opens it
+// (behavior_tree_playback.ts).
 import { promises as fs } from 'node:fs';
 import { BT_RATE } from '../shared/protocol.js';
+import { DEFAULT_RECORD_OPTIONS } from '../shared/rosbag.js';
 import { readTree } from './behavior_tree_file.js';
 import { logTransitions } from './behavior_tree_log.js';
 import { BehaviorTreePlayback } from './behavior_tree_playback.js';
 import { BehaviorTreeState } from './behavior_tree_state.js';
 import { publishersQos } from './qos.js';
-import { BagRecorder, newBagFolder } from './rosbag.js';
 import { absoluteTopic, errorMessage } from './util.js';
 // How often the graph is checked for the topic's publishers, until it has one
 const RETRY_PERIOD_MS = 1000;
@@ -252,12 +254,23 @@ export class BehaviorTrees {
     topics = new Map();
     // By topic, then tree source
     monitors = new Map();
-    // By topic
+    rosbags;
+    // By topic: the folder it is recorded into, '' while it starts
     recordings = new Map();
-    constructor(node, logger, uploadsDir) {
+    constructor(node, logger, uploadsDir, rosbags) {
         this.node = node;
         this.logger = logger;
         this.uploadsDir = uploadsDir;
+        this.rosbags = rosbags;
+        // A recording stopped elsewhere, or by itself
+        rosbags.onChange(() => {
+            for (const [topic, folder] of this.recordings) {
+                if (folder && !rosbags.recording(folder)) {
+                    this.recordings.delete(topic);
+                    this.announce(topic);
+                }
+            }
+        });
     }
     // Until the returned function is called
     watch(topic, tree, watcher) {
@@ -290,57 +303,42 @@ export class BehaviorTrees {
     }
     // Records the topic into a new folder, or stops (path null): resolves with
     // the bag's folder, null if it was not recording
-    async record(topic, path) {
+    async record(topic, path, options = DEFAULT_RECORD_OPTIONS) {
         const name = absoluteTopic(topic);
         const current = this.recordings.get(name);
         if (path === null) {
-            if (!current?.recorder) {
+            if (!current) {
                 return null;
             }
             this.recordings.delete(name);
             this.announce(name);
-            await current.recorder.stop();
-            this.logger.info(`Recorded ${name} into ${current.path}`);
-            return current.path;
+            return this.rosbags.stop(current);
         }
-        if (current) {
-            throw new Error(`${name} is being recorded already, into ${current.path}`);
+        if (current !== undefined) {
+            throw new Error(`${name} is being recorded already${current ? `, into ${current}` : ''}`);
         }
-        const recording = { path: '', since: 0, recorder: null };
-        this.recordings.set(name, recording);
+        this.recordings.set(name, '');
+        let folder;
         try {
-            recording.path = await newBagFolder(path);
-            recording.recorder = await BagRecorder.start(recording.path, [name]);
+            const request = { path, topics: [name], all: false, regex: '', exclude: '', options };
+            folder = (await this.rosbags.record(request, 'behavior-tree')).path;
         }
         catch (e) {
             this.recordings.delete(name);
             throw new Error(`Cannot record ${name}: ${errorMessage(e)}`);
         }
-        recording.since = Date.now();
-        recording.recorder.onExit = (reason) => {
-            if (this.recordings.get(name) === recording) {
-                this.recordings.delete(name);
-                this.announce(name);
-                this.logger.warn(`Recording ${name} stopped: ${reason}`);
-            }
-        };
-        this.logger.info(`Recording ${name} into ${recording.path}`);
+        this.recordings.set(name, folder);
         this.announce(name);
-        return recording.path;
+        return folder;
     }
     // A bag played back for a page, until closed
     play(bag, topic, tree, watcher) {
         return new BehaviorTreePlayback({ bag, topic, tree: tree.trim(), uploadsDir: this.uploadsDir, logger: this.logger }, watcher);
     }
-    // The recordings completed, as the server stops
-    async stopAll() {
-        const recorders = [...this.recordings.values()].flatMap((recording) => recording.recorder ?? []);
-        this.recordings.clear();
-        await Promise.all(recorders.map((recorder) => recorder.stop()));
-    }
     recordingOf(topic) {
-        const recording = this.recordings.get(topic);
-        return recording?.recorder ? { path: recording.path, since: recording.since } : null;
+        const folder = this.recordings.get(topic);
+        const recording = folder ? this.rosbags.recording(folder) : null;
+        return recording ? { path: recording.path, since: recording.since } : null;
     }
     announce(topic) {
         for (const monitor of this.monitors.get(topic)?.values() ?? []) {

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;
+}

package/dist/server/interfaces.js

@@ -0,0 +1,145 @@
+// The ROS interfaces (messages, services, actions) for the monitor widgets:
+// their definitions as ros2 interface show prints them, from the files of
+// their packages; their schemas and default values, from rclnodejs's code of
+// them; and the JSON of the pages made into their messages.
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import rclnodejs from 'rclnodejs';
+import { defaultMessage, expandDefinition, HEADER_TYPE, parseType, partTypes, toRosMessage, } from './message_format.js';
+import { missingCodeHint } from './message_code.js';
+import { errorMessage, packageShareDirectory } from './util.js';
+function load(type) {
+    let typeClass;
+    try {
+        typeClass = rclnodejs.require(type);
+    }
+    catch (e) {
+        throw new Error(missingCodeHint(errorMessage(e)));
+    }
+    if (!typeClass?.ROSMessageDef) {
+        throw new Error(`${type} is not a message type`);
+    }
+    return typeClass;
+}
+// A field's message type, pkg/<msg|srv|action>/Name: rclnodejs tells only
+// its package and name, which the parts of services and actions share
+function nestedType(pkg, name) {
+    const kinds = /_(Request|Response|Event)$/.test(name)
+        ? ['srv', 'msg', 'action']
+        : /_(Goal|Result|Feedback|FeedbackMessage|SendGoal_Request|SendGoal_Response|GetResult_Request|GetResult_Response)$/.test(name)
+            ? ['action', 'msg', 'srv']
+            : ['msg', 'action', 'srv'];
+    for (const kind of kinds) {
+        try {
+            if (rclnodejs.require(`${pkg}/${kind}/${name}`)?.ROSMessageDef) {
+                return `${pkg}/${kind}/${name}`;
+            }
+        }
+        catch {
+            // Not of this kind
+        }
+    }
+    return `${pkg}/msg/${name}`;
+}
+function plain(value) {
+    if (ArrayBuffer.isView(value)) {
+        return Array.from(value, (v) => (typeof v === 'bigint' ? Number(v) : v));
+    }
+    return typeof value === 'bigint' ? Number(value) : value;
+}
+export class Interfaces {
+    node;
+    schemas = new Map();
+    infos = new Map();
+    constructor(node) {
+        this.node = node;
+    }
+    // The schema of a message type, and of those it nests
+    schemasOf(type, into = {}) {
+        if (into[type]) {
+            return into;
+        }
+        const schema = this.schema(type);
+        into[type] = schema;
+        for (const field of schema.fields) {
+            if (!field.primitive) {
+                this.schemasOf(field.type, into);
+            }
+        }
+        return into;
+    }
+    // ros2 interface show, and the schemas and default values of its parts
+    info(type) {
+        const known = this.infos.get(type);
+        if (known) {
+            return known;
+        }
+        const { pkg, kind, name } = parseType(type);
+        const schemas = {};
+        const parts = partTypes(type).map((part) => {
+            this.schemasOf(part.type, schemas);
+            return { ...part, default: defaultMessage(part.type, schemas) };
+        });
+        const info = { type, kind, text: this.definition(pkg, kind, name), parts, schemas };
+        this.infos.set(type, info);
+        return info;
+    }
+    // The message of type the page's JSON describes (see toRosMessage)
+    message(type, value) {
+        return toRosMessage(value, type, this.schemasOf(type), () => this.now());
+    }
+    // Its messages begin with a std_msgs/msg/Header, whose stamp ros2 topic
+    // delay compares with their arrival
+    hasHeader(type) {
+        try {
+            const first = this.schema(type).fields[0];
+            return first?.name === 'header' && first.type === HEADER_TYPE;
+        }
+        catch {
+            return false;
+        }
+    }
+    // On the ROS clock: the simulation's with use_sim_time
+    now() {
+        const { seconds, nanoseconds } = this.node.getClock().now().secondsAndNanoseconds;
+        return { sec: Number(seconds), nanosec: Number(nanoseconds) };
+    }
+    schema(type) {
+        const known = this.schemas.get(type);
+        if (known) {
+            return known;
+        }
+        const { ROSMessageDef: def } = load(type);
+        const schema = {
+            fields: def.fields.map(({ name, type: t, default_value }) => ({
+                name,
+                type: t.isPrimitiveType ? t.type : nestedType(t.pkgName ?? '', t.type),
+                primitive: t.isPrimitiveType,
+                array: !t.isArray ? 'none' : t.isFixedSizeArray ? 'fixed' : t.isUpperBound ? 'bounded' : 'dynamic',
+                size: t.isArray && (t.isFixedSizeArray || t.isUpperBound) ? t.arraySize : null,
+                stringBound: t.stringUpperBound ?? null,
+                default: plain(default_value) ?? null,
+            })),
+            constants: def.constants.map(({ name, type: t, value }) => ({ name, type: t, value: plain(value) })),
+        };
+        this.schemas.set(type, schema);
+        return schema;
+    }
+    // Its file's text, expanded; null if not found
+    definition(pkg, kind, name) {
+        const text = readDefinition(pkg, kind, name);
+        return text === null ? null : expandDefinition(text, pkg, (p, n) => readDefinition(p, 'msg', n));
+    }
+}
+function readDefinition(pkg, kind, name) {
+    const share = packageShareDirectory(pkg);
+    if (!share) {
+        return null;
+    }
+    try {
+        return readFileSync(path.join(share, kind, `${name}.${kind}`), 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/message_code.d.ts

@@ -0,0 +1,12 @@
+import { type Logger } from './util.ts';
+export interface MissingPackage {
+    name: string;
+    prefix: string;
+}
+export declare function expectedFiles(pkg: string, index: string, blocked?: (name: string) => boolean): string[];
+export declare function missingPackages(prefixes: string[], generatedRoot: string, blocklist?: {
+    pkgName?: string;
+    interfaceName?: string;
+}[]): Promise<MissingPackage[]>;
+export declare function missingCodeHint(message: string): string;
+export declare function makeMessageCode(logger: Logger): Promise<void>;

package/dist/server/message_code.js

@@ -0,0 +1,165 @@
+// rclnodejs's JavaScript code of the ROS interfaces, without which it cannot
+// use them: rclnodejs makes it when installed, for the packages sourced then.
+// Those sourced since (a robot's own installation, a workspace), or rebuilt
+// with new interfaces, are made here at start, before anything uses them: by
+// rclnodejs's own generator, as it makes them when installed, run on a prefix
+// of their own (their ament index entries, their share folders linked). Its
+// own fallback misses the interfaces of services and actions, and makes a
+// whole prefix's while the server waits.
+import { spawn } from 'node:child_process';
+import { existsSync, promises as fs } from 'node:fs';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { errorMessage, tasselloRoot } from './util.js';
+// Where the ament index lists each package's interfaces
+const INDEX = path.join('share', 'ament_index', 'resource_index', 'rosidl_interfaces');
+const GENERATION_TIMEOUT_MS = 5 * 60_000;
+// The files rclnodejs makes of a package's interfaces, from its entry in the
+// ament index: msg/Pose.msg, msg/Pose.idl give <pkg>__msg__Pose.js. The
+// services' and actions' parts are made with them.
+export function expectedFiles(pkg, index, blocked = () => false) {
+    const files = new Set();
+    for (const line of index.split('\n')) {
+        const match = /^([\w-]+)\/(\w+)\.(msg|srv|action|idl)$/.exec(line.trim());
+        if (match && !blocked(match[2])) {
+            // msg-common: msg, as rclnodejs names them
+            files.add(`${pkg}__${match[1].split('-')[0]}__${match[2]}.js`);
+        }
+    }
+    return [...files];
+}
+// The packages of the prefixes whose code is not all made: the first of each
+// name, as the prefixes overlay those after them
+export async function missingPackages(prefixes, generatedRoot, blocklist = []) {
+    const seen = new Set();
+    const missing = [];
+    const filters = blocklist.map((f) => ({
+        pkg: f.pkgName ? new RegExp(f.pkgName) : null,
+        name: f.interfaceName ? new RegExp(f.interfaceName) : null,
+    }));
+    for (const prefix of prefixes) {
+        let packages;
+        try {
+            packages = await fs.readdir(path.join(prefix, INDEX));
+        }
+        catch {
+            continue;
+        }
+        for (const name of packages.sort()) {
+            if (seen.has(name)) {
+                continue;
+            }
+            seen.add(name);
+            const applying = filters.filter((f) => !f.pkg || f.pkg.test(name));
+            if (applying.some((f) => !f.name)) {
+                continue;
+            }
+            let index;
+            try {
+                index = await fs.readFile(path.join(prefix, INDEX, name), 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const expected = expectedFiles(name, index, (interfaceName) => applying.some((f) => f.name?.test(interfaceName)));
+            const made = new Set(await fs.readdir(path.join(generatedRoot, name)).catch(() => []));
+            if (expected.some((file) => !made.has(file))) {
+                missing.push({ name, prefix });
+            }
+        }
+    }
+    return missing;
+}
+// What to do when rclnodejs has no code of an interface, after its error
+export function missingCodeHint(message) {
+    return /message required does not exist/i.test(message)
+        ? `${message}. Tassello makes the code of the interfaces sourced when it starts: restart it with their workspace sourced, or run npx generate-ros-messages in ${tasselloRoot()}`
+        : message;
+}
+function rclnodejsRoot() {
+    return path.dirname(createRequire(import.meta.url).resolve('rclnodejs/package.json'));
+}
+// Runs rclnodejs's generator on the prefix: rejects with its error output if
+// it fails
+function generate(worker, prefix) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [worker], {
+            env: { ...process.env, WORKER_TARGET_PATH: prefix },
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr.on('data', (data) => {
+            stderr = (stderr + data.toString()).slice(-2000);
+        });
+        const timer = setTimeout(() => child.kill('SIGKILL'), GENERATION_TIMEOUT_MS);
+        child.on('error', (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(stderr.trim() || (signal ? `killed by ${signal}` : `exit code ${code}`)));
+            }
+        });
+    });
+}
+// Makes the code of the packages sourced whose code is missing; says what it
+// did, or why it could not, and goes on: those packages stay unusable then
+export async function makeMessageCode(logger) {
+    const prefixes = (process.env.AMENT_PREFIX_PATH ?? '').split(path.delimiter).filter(Boolean);
+    let root;
+    try {
+        root = rclnodejsRoot();
+    }
+    catch (e) {
+        logger.warn(`Cannot find rclnodejs to check its code of the ROS interfaces: ${errorMessage(e)}`);
+        return;
+    }
+    const generatedRoot = path.join(root, 'generated');
+    let blocklist = [];
+    try {
+        blocklist = JSON.parse(await fs.readFile(path.join(root, 'rosidl_gen', 'blocklist.json'), 'utf8'));
+    }
+    catch {
+        // None
+    }
+    const missing = await missingPackages(prefixes, generatedRoot, blocklist);
+    if (missing.length === 0) {
+        return;
+    }
+    const names = missing.map((p) => p.name).join(', ');
+    const worker = path.join(root, 'rosidl_gen', 'generate_worker.cjs');
+    if (!existsSync(worker)) {
+        logger.warn(`rclnodejs has no code of the interfaces of ${names}: run npx generate-ros-messages in ${tasselloRoot()} with them sourced`);
+        return;
+    }
+    logger.info(`Making rclnodejs's code of the ROS interfaces it has not, of ${missing.length} package(s): ${names}`);
+    const started = Date.now();
+    const prefix = await fs.mkdtemp(path.join(os.tmpdir(), 'tassello-interfaces-'));
+    try {
+        await fs.mkdir(path.join(prefix, INDEX), { recursive: true });
+        for (const pkg of missing) {
+            await fs.copyFile(path.join(pkg.prefix, INDEX, pkg.name), path.join(prefix, INDEX, pkg.name));
+            await fs.symlink(path.join(pkg.prefix, 'share', pkg.name), path.join(prefix, 'share', pkg.name));
+        }
+        await generate(worker, prefix);
+    }
+    catch (e) {
+        logger.warn(`Could not make rclnodejs's code of the interfaces of ${names} (${errorMessage(e)}): run npx generate-ros-messages in ${tasselloRoot()} with them sourced, as a user who may write in ${generatedRoot}`);
+        return;
+    }
+    finally {
+        await fs.rm(prefix, { recursive: true, force: true });
+    }
+    const left = await missingPackages(missing.map((p) => p.prefix).filter((p, i, all) => all.indexOf(p) === i), generatedRoot, blocklist);
+    const still = left.filter((p) => missing.some((m) => m.name === p.name));
+    if (still.length > 0) {
+        logger.warn(`rclnodejs's code of some interfaces of ${still.map((p) => p.name).join(', ')} could not be made`);
+    }
+    logger.info(`Made in ${((Date.now() - started) / 1000).toFixed(1)} s`);
+}

package/dist/server/message_format.d.ts

@@ -0,0 +1,24 @@
+import type { InterfaceKind, MessageSchema } from '../shared/monitor.ts';
+export declare const TIME_TYPE = "builtin_interfaces/msg/Time";
+export declare const HEADER_TYPE = "std_msgs/msg/Header";
+export declare function isPrimitive(type: string): boolean;
+export declare function parseType(type: string): {
+    pkg: string;
+    kind: InterfaceKind;
+    name: string;
+};
+export declare function partTypes(type: string): {
+    name: string;
+    type: string;
+}[];
+export type DefinitionReader = (pkg: string, name: string) => string | null;
+export declare function nestedFieldType(line: string, pkg: string): [string, string] | null;
+export declare function expandDefinition(text: string, pkg: string, read: DefinitionReader, depth?: number): string;
+export declare function defaultMessage(type: string, schemas: Record<string, MessageSchema>): Record<string, unknown>;
+export interface RosTime {
+    sec: number;
+    nanosec: number;
+}
+export declare function toRosMessage(value: unknown, type: string, schemas: Record<string, MessageSchema>, now: () => RosTime, path?: string): Record<string, unknown>;
+export declare function fieldAt(message: unknown, path: string): unknown;
+export declare function echoJson(value: unknown, limit: number): unknown;