tassello 0.2.0 → 0.3.0

package/dist/server/http.js

@@ -17,13 +17,32 @@
 //   POST   /api/uploads                 an image or a behavior tree (the body) -> {name}
 //   GET    /api/uploads/<name>          an uploaded file
 //   GET    /api/plugins                 [PluginInfo] of the plugins loaded
+//   /api/fs/...                         the file manager's: any file of the
+//          robot (see src/shared/file_manager.ts), changed only by the
+//          dashboard's pages
+//     GET  places                       FsPlaces: home, the ROS workspaces
+//     GET  list?path=&known=            FsListing, 204 while still the known version
+//     GET  details?path=                FsDetails
+//     GET  disks                        [FsDisk] of the robot's file systems
+//     GET  analysis?path=               FsAnalysis: what takes a folder's space
+//     GET  text?path=&stamp=            FsText, 204 while still of that stamp
+//     PUT  text   {path, text, base, create}  -> FsSaved
+//     POST op     FsOperation           -> FsResult
+//     POST upload?path=&name=&conflict= the file (the body) -> FsResult
+//     GET  download?path=[&path=...]    a file, or folders and files as a .tar.gz
+//     GET  view?path=                   an image, PGM and PPM ones as PNG
 //   GET    /plugins/<name>/<path>       a file of the plugin's client folder
+import { spawn } from 'node:child_process';
 import { createReadStream, promises as fs } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { gzip } from 'node:zlib';
+import sharp from 'sharp';
 import { DASHBOARD_CLIENT_HEADER } from '../shared/protocol.js';
-import { fileKind, isUploadName, listDirectory, MAX_UPLOAD_BYTES, resolveImagePath, saveUpload } from './files.js';
+import { listDisks, spaceOf } from './disks.js';
+import { analyzeFolder, archiveArguments, changeMode, deleteEntries, entryDetails, fsError, listFolder, listPlaces, makeFile, makeFolder, readText, receiveFile, renameEntry, resolvePath, saveText, transfer, uploadTarget, } from './file_manager.js';
+import { fileKind, IMAGE_EXTENSIONS, isUploadName, listDirectory, MAX_UPLOAD_BYTES, resolveImagePath, saveUpload, } from './files.js';
+import { decodeNetpbm, NETPBM_EXTENSIONS } from './netpbm.js';
 import { HttpError } from './panels.js';
 import { errorMessage, packageShareDirectory } from './util.js';
 // By lowercase extension: meshes come as .STL as often as .stl
@@ -50,12 +69,24 @@ const CONTENT_TYPES = {
 // Worth compressing: text, and meshes, often tens of MB of CAD exports
 const COMPRESSIBLE = new Set(['.html', '.js', '.css', '.json', '.map', '.svg', '.stl', '.dae', '.obj']);
 const MAX_BODY_BYTES = 1024 * 1024;
+// A text file saved by the file manager, 5 MB, as JSON
+const MAX_TEXT_BODY_BYTES = 12 * 1024 * 1024;
+// Of a file uploaded by the file manager: rosbags are large
+const MAX_FS_UPLOAD_BYTES = 64 * 1024 ** 3;
+// PGM and PPM images converted to PNG
+const MAX_PREVIEW_BYTES = 256 * 1024 * 1024;
+// Analyses at once: each reads a whole tree of folders
+const MAX_ANALYSES = 2;
+const CONFLICTS = ['ask', 'skip', 'keep-both', 'replace'];
 // Compressed files are kept, the most recent first, within this size
 const GZIP_CACHE_BYTES = 64 * 1024 * 1024;
 const PACKAGE_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
 // For the images of the robot and of the users: an SVG opened by itself must
 // not run scripts in the dashboard's origin
-const SANDBOXED = { 'Content-Security-Policy': "default-src 'none'; style-src 'unsafe-inline'; sandbox" };
+const SANDBOXED = {
+    'Content-Security-Policy': "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    'X-Content-Type-Options': 'nosniff',
+};
 export function createRequestHandler(services) {
     return (req, res) => {
         handle(services, req, res).catch((e) => {
@@ -93,7 +124,7 @@ async function handle(services, req, res) {
         await serveFile(services.wwwDir, pathname === '/' ? 'index.html' : decodeURIComponent(pathname), req, res);
     }
 }
-async function api({ store, topics, uploadsDir, plugins }, req, res, route) {
+async function api({ store, topics, uploadsDir, plugins, logger }, req, res, route) {
     const origin = req.headers[DASHBOARD_CLIENT_HEADER.toLowerCase()];
     const author = typeof origin === 'string' && origin ? origin : null;
     const [resource, id, ...rest] = route;
@@ -149,6 +180,9 @@ async function api({ store, topics, uploadsDir, plugins }, req, res, route) {
         }
         throw new HttpError(404, `No API at ${req.url}`);
     }
+    else if (resource === 'fs' && id && rest.length === 0) {
+        return fsApi(req, res, `${method} ${id}`, logger);
+    }
     else if (resource === 'uploads' && id === undefined && method === 'POST') {
         return sendJson(res, 201, { name: await saveUpload(uploadsDir, await readBody(req, MAX_UPLOAD_BYTES)) });
     }
@@ -184,8 +218,217 @@ async function readBody(req, limit) {
     }
     return Buffer.concat(chunks);
 }
-async function readJson(req) {
-    return JSON.parse((await readBody(req, MAX_BODY_BYTES)).toString('utf8'));
+async function readJson(req, limit = MAX_BODY_BYTES) {
+    return JSON.parse((await readBody(req, limit)).toString('utf8'));
+}
+let analyses = 0;
+// The file manager's API (see file_manager.ts): route is the method and the
+// action, "GET list"
+async function fsApi(req, res, route, logger) {
+    const query = new URL(req.url ?? '/', 'http://localhost').searchParams;
+    if (!route.startsWith('GET ') && typeof req.headers[DASHBOARD_CLIENT_HEADER.toLowerCase()] !== 'string') {
+        // Another site's page cannot send the header: its browser would first
+        // ask the server, which does not allow it
+        throw new HttpError(403, 'The robot’s files are changed by the dashboard’s pages only');
+    }
+    switch (route) {
+        case 'GET places':
+            return sendJson(res, 200, listPlaces());
+        case 'GET list': {
+            const listing = await listFolder(resolvePath(query.get('path') ?? '~'));
+            return listing.version === query.get('known') ? sendNothing(res) : sendJson(res, 200, listing);
+        }
+        case 'GET details':
+            return sendJson(res, 200, await entryDetails(resolvePath(query.get('path'))));
+        case 'GET disks':
+            return sendJson(res, 200, await listDisks());
+        case 'GET analysis': {
+            if (analyses >= MAX_ANALYSES) {
+                throw new HttpError(429, 'Other folders are being analyzed: try again in a moment');
+            }
+            analyses++;
+            try {
+                return sendJson(res, 200, await analyzeFolder(resolvePath(query.get('path'))));
+            }
+            finally {
+                analyses--;
+            }
+        }
+        case 'GET text': {
+            const text = await readText(resolvePath(query.get('path')), query.get('stamp'));
+            return text ? sendJson(res, 200, text) : sendNothing(res);
+        }
+        case 'PUT text': {
+            const body = (await readJson(req, MAX_TEXT_BODY_BYTES));
+            if (typeof body.text !== 'string') {
+                throw new HttpError(400, 'text must be a string');
+            }
+            const file = resolvePath(body.path);
+            const saved = await saveText(file, body.text, typeof body.base === 'string' ? body.base : null, body.create === true);
+            if (!saved.conflict) {
+                logger.info(`File saved: ${file}`);
+            }
+            return sendJson(res, 200, saved);
+        }
+        case 'POST op': {
+            const result = await operate((await readJson(req)), logger);
+            return sendJson(res, 200, result);
+        }
+        case 'POST upload': {
+            const folder = resolvePath(query.get('path'));
+            const name = query.get('name') ?? '';
+            const conflict = CONFLICTS.find((value) => value === query.get('conflict')) ?? 'ask';
+            const length = Number(req.headers['content-length']);
+            const space = Number.isFinite(length) ? await spaceOf(folder) : null;
+            if (space && length > space.free) {
+                throw new HttpError(507, `Not enough space on ${space.mount}: ${(space.free / 1e9).toFixed(1)} GB free`);
+            }
+            const target = await uploadTarget(folder, name, conflict);
+            if (!target) {
+                req.resume();
+                return sendJson(res, 200, { paths: [], conflicts: [name] });
+            }
+            const size = await receiveFile(req, target, MAX_FS_UPLOAD_BYTES);
+            logger.info(`File uploaded: ${target} (${size} bytes)`);
+            return sendJson(res, 201, { paths: [target], conflicts: [] });
+        }
+        case 'GET download': {
+            const files = query.getAll('path').map((value) => resolvePath(value));
+            if (files.length === 0) {
+                throw new HttpError(400, 'No path');
+            }
+            const stat = files.length === 1
+                ? await fs.stat(files[0]).catch((e) => {
+                    throw fsError(e, `Cannot download ${path.basename(files[0])}`);
+                })
+                : null;
+            return stat?.isFile() ? sendDownload(res, files[0], stat) : sendArchive(res, files, logger);
+        }
+        case 'GET view': {
+            const file = resolvePath(query.get('path'));
+            const extension = path.extname(file).toLowerCase();
+            if (!NETPBM_EXTENSIONS.has(extension)) {
+                if (!IMAGE_EXTENSIONS.has(extension) && extension !== '.ico') {
+                    throw new HttpError(415, `Not an image: ${path.basename(file)}`);
+                }
+                return serveFile(path.dirname(file), path.basename(file), req, res, SANDBOXED);
+            }
+            const stat = await fs.stat(file).catch((e) => {
+                throw fsError(e, `Cannot read ${path.basename(file)}`);
+            });
+            if (stat.size > MAX_PREVIEW_BYTES) {
+                throw new HttpError(413, `Too large to preview: ${path.basename(file)}`);
+            }
+            let pixels;
+            try {
+                pixels = decodeNetpbm(await fs.readFile(file));
+            }
+            catch (e) {
+                throw e instanceof Error && !('code' in e) ? new HttpError(415, e.message) : fsError(e, `Cannot read ${path.basename(file)}`);
+            }
+            const { data, width, height, channels } = pixels;
+            const png = await sharp(data, { raw: { width, height, channels } }).png().toBuffer();
+            res.writeHead(200, {
+                ...SANDBOXED,
+                'Content-Type': 'image/png',
+                'Content-Length': png.length,
+                'Cache-Control': 'no-cache',
+            });
+            res.end(png);
+            return;
+        }
+    }
+    throw new HttpError(404, `No API at ${req.url}`);
+}
+async function operate(body, logger) {
+    const paths = () => {
+        if (!Array.isArray(body.paths) || body.paths.length === 0) {
+            throw new HttpError(400, 'paths must be a list of paths');
+        }
+        return body.paths.map((value) => resolvePath(value));
+    };
+    const log = (what, files) => logger.info(`File manager: ${what} ${files.length === 1 ? files[0] : `${files.length} entries (${files[0]}, …)`}`);
+    switch (body.op) {
+        case 'mkdir':
+            return makeFolder(resolvePath(body.path));
+        case 'create':
+            return makeFile(resolvePath(body.path));
+        case 'rename': {
+            const file = resolvePath(body.path);
+            const result = await renameEntry(file, body.name);
+            log(`renamed to ${body.name}:`, [file]);
+            return result;
+        }
+        case 'move':
+        case 'copy': {
+            const sources = paths();
+            const conflict = CONFLICTS.find((value) => value === body.conflict) ?? 'ask';
+            const result = await transfer(body.op, sources, resolvePath(body.to), conflict);
+            if (result.paths.length > 0) {
+                log(`${body.op === 'move' ? 'moved' : 'copied'} into ${resolvePath(body.to)}:`, sources);
+            }
+            return result;
+        }
+        case 'delete': {
+            const files = paths();
+            const result = await deleteEntries(files);
+            log('deleted', files);
+            return result;
+        }
+        case 'chmod':
+            return changeMode(resolvePath(body.path), body.mode);
+        default:
+            throw new HttpError(400, `Unknown operation ${JSON.stringify(body.op)}`);
+    }
+}
+function sendNothing(res) {
+    res.writeHead(204, { 'Cache-Control': 'no-store' }).end();
+}
+// attachment; filename="…": an ASCII name for old browsers, the name whole
+// for the others (RFC 6266)
+function contentDisposition(name) {
+    const ascii = name.replace(/[^\x20-\x7e]|["\\]/g, '_');
+    const encoded = encodeURIComponent(name).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+    return `attachment; filename="${ascii}"; filename*=UTF-8''${encoded}`;
+}
+// A file of any size, streamed as it is
+function sendDownload(res, file, stat) {
+    res.writeHead(200, {
+        ...SANDBOXED,
+        'Content-Type': CONTENT_TYPES[path.extname(file).toLowerCase()] ?? 'application/octet-stream',
+        'Content-Length': stat.size,
+        'Content-Disposition': contentDisposition(path.basename(file)),
+        'Cache-Control': 'no-store',
+    });
+    createReadStream(file)
+        .on('error', () => res.destroy())
+        .pipe(res);
+}
+// Entries of one folder, as tar archives them, gzipped, as it goes
+async function sendArchive(res, files, logger) {
+    const folder = path.dirname(files[0]);
+    const name = files.length === 1 ? path.basename(files[0]) : `${path.basename(folder) || 'root'}-${files.length}-items`;
+    const tar = spawn('tar', archiveArguments(files), { stdio: ['ignore', 'pipe', 'pipe'] });
+    await new Promise((resolve, reject) => {
+        tar.once('spawn', resolve);
+        tar.once('error', (e) => reject(new HttpError(500, `Cannot archive: tar ${e.code ?? errorMessage(e)}`)));
+    });
+    let errors = '';
+    tar.stderr.on('data', (data) => (errors = (errors + data.toString()).slice(-2000)));
+    tar.on('close', (code) => {
+        if (code !== 0 && errors.trim()) {
+            logger.warn(`Download of ${files.length === 1 ? files[0] : folder}: ${errors.trim()}`);
+        }
+    });
+    // The page gave up: so does tar
+    res.on('close', () => tar.exitCode === null && tar.kill());
+    res.writeHead(200, {
+        ...SANDBOXED,
+        'Content-Type': 'application/gzip',
+        'Content-Disposition': contentDisposition(`${name}.tar.gz`),
+        'Cache-Control': 'no-store',
+    });
+    tar.stdout.pipe(res);
 }
 const gzipAsync = promisify(gzip);
 // By file path: the compressed content of the file at that size and time

package/dist/server/netpbm.d.ts

@@ -0,0 +1,3 @@
+import type { Pixels } from './image_encoding.ts';
+export declare const NETPBM_EXTENSIONS: Set<string>;
+export declare function decodeNetpbm(data: Buffer): Pixels;

package/dist/server/netpbm.js

@@ -0,0 +1,69 @@
+// Netpbm images, PGM and PPM, which browsers do not show: the maps of
+// nav2_map_server and map_server are PGM. Decoded into pixels for sharp to
+// make PNGs of, for the file manager's previews.
+export const NETPBM_EXTENSIONS = new Set(['.pgm', '.ppm', '.pnm']);
+// 10,000 × 10,000: a map of a km² at 10 cm
+const MAX_PIXELS = 100_000_000;
+// P2 and P5 gray, P3 and P6 colour; text (P2, P3) or binary (P5, P6), 8 or
+// 16 bit (big endian), scaled to 8 bit
+export function decodeNetpbm(data) {
+    const magic = data.subarray(0, 2).toString('latin1');
+    if (!['P2', 'P3', 'P5', 'P6'].includes(magic)) {
+        throw new Error(`Not a PGM nor PPM image (${JSON.stringify(magic)})`);
+    }
+    const channels = magic === 'P3' || magic === 'P6' ? 3 : 1;
+    const binary = magic === 'P5' || magic === 'P6';
+    // The header's numbers, after comments (# to the end of the line)
+    let offset = 2;
+    const number = () => {
+        for (;;) {
+            // Tab, line feed, vertical tab, form feed, carriage return, space
+            while (offset < data.length && (data[offset] === 0x20 || (data[offset] >= 0x09 && data[offset] <= 0x0d))) {
+                offset++;
+            }
+            if (data[offset] !== 0x23) {
+                break;
+            }
+            while (offset < data.length && data[offset] !== 0x0a) {
+                offset++;
+            }
+        }
+        const start = offset;
+        while (offset < data.length && data[offset] >= 0x30 && data[offset] <= 0x39) {
+            offset++;
+        }
+        if (offset === start) {
+            throw new Error('Malformed PGM or PPM header');
+        }
+        return Number(data.subarray(start, offset).toString('latin1'));
+    };
+    const width = number();
+    const height = number();
+    const max = number();
+    if (width < 1 || height < 1 || max < 1 || max > 65535) {
+        throw new Error(`Malformed PGM or PPM header: ${width}×${height}, max ${max}`);
+    }
+    if (width * height > MAX_PIXELS) {
+        throw new Error(`Too large to preview: ${width}×${height}`);
+    }
+    const count = width * height * channels;
+    const pixels = Buffer.alloc(count);
+    const scale = (value) => (max === 255 ? value : Math.round((Math.min(value, max) * 255) / max));
+    if (binary) {
+        // One whitespace after the header
+        offset++;
+        const bytes = max > 255 ? 2 : 1;
+        if (data.length - offset < count * bytes) {
+            throw new Error('Truncated PGM or PPM image');
+        }
+        for (let i = 0; i < count; i++) {
+            pixels[i] = scale(bytes === 2 ? data.readUInt16BE(offset + i * 2) : data[offset + i]);
+        }
+    }
+    else {
+        for (let i = 0; i < count; i++) {
+            pixels[i] = scale(number());
+        }
+    }
+    return { data: pixels, width, height, channels };
+}

package/dist/server/pty.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from 'node:events';
+export interface PtyOptions {
+    file: string;
+    args: string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    cols: number;
+    rows: number;
+}
+interface PtyEvents {
+    data: [string];
+    exit: [number | null];
+    error: [Error];
+}
+export declare class Pty extends EventEmitter<PtyEvents> {
+    private readonly child;
+    private exited;
+    constructor(options: PtyOptions);
+    get pid(): number | undefined;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    pause(): void;
+    resume(): void;
+    hangUp(): void;
+}
+export {};

package/dist/server/pty.js

@@ -0,0 +1,150 @@
+// Pseudo-terminals for the terminal widgets, without a native module: Node
+// cannot open one, the Python 3 that ROS 2 ships with can. A small bridge
+// (BRIDGE) opens it, starts the program on it as the session leader, and
+// relays its standard input to the terminal and the terminal's output to its
+// standard output; lines on fd 3 resize it. When the bridge goes, the
+// terminal hangs up, as when a terminal window is closed.
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+// argv: columns, rows, then the program and its arguments. Exits with the
+// program's exit code, 128 + the signal that killed it.
+const BRIDGE = `
+import fcntl, os, select, signal, struct, sys, termios
+
+CONTROL = 3
+
+def size(fd, cols, rows):
+    fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack('HHHH', rows, cols, 0, 0))
+
+def send(data):
+    while data:
+        data = data[os.write(1, data):]
+
+cols, rows, argv = int(sys.argv[1]), int(sys.argv[2]), sys.argv[3:]
+master, slave = os.openpty()
+size(slave, cols, rows)
+attrs = termios.tcgetattr(slave)
+attrs[0] |= getattr(termios, 'IUTF8', 0o40000)
+termios.tcsetattr(slave, termios.TCSANOW, attrs)
+pid = os.fork()
+if pid == 0:
+    try:
+        os.setsid()
+        fcntl.ioctl(slave, termios.TIOCSCTTY, 0)
+        for fd in (0, 1, 2):
+            os.dup2(slave, fd)
+        for fd in (master, slave, CONTROL):
+            os.close(fd)
+        # Python ignores them, and what it ignores stays ignored after exec
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+        signal.signal(signal.SIGXFSZ, signal.SIG_DFL)
+        os.execvp(argv[0], argv)
+    except BaseException as e:
+        os.write(2, ('tassello: cannot run %s: %s\\n' % (argv[0], e)).encode())
+    os._exit(127)
+
+os.close(slave)
+os.set_blocking(master, False)
+inputs = [master, 0, CONTROL]
+pending = b''
+control = b''
+status = None
+while status is None:
+    readable, writable, _ = select.select(inputs, [master] if pending else [], [], 0.5)
+    if master in readable:
+        try:
+            data = os.read(master, 65536)
+        except BlockingIOError:
+            data = None
+        except OSError:
+            data = b''
+        if data == b'':
+            break
+        if data:
+            send(data)
+    if writable:
+        try:
+            pending = pending[os.write(master, pending):]
+        except BlockingIOError:
+            pass
+    if 0 in readable:
+        data = os.read(0, 65536)
+        if not data:
+            sys.exit(0)
+        pending += data
+    if CONTROL in readable:
+        data = os.read(CONTROL, 4096)
+        if not data:
+            inputs.remove(CONTROL)
+        control += data
+        while b'\\n' in control:
+            line, control = control.split(b'\\n', 1)
+            size(master, *map(int, line.split()))
+    # Gone, while what it left in the background keeps the terminal open:
+    # the rest of its output, then done
+    done, result = os.waitpid(pid, os.WNOHANG)
+    if done:
+        status = result
+        try:
+            data = os.read(master, 65536)
+            while data:
+                send(data)
+                data = os.read(master, 65536)
+        except OSError:
+            pass
+
+if status is None:
+    status = os.waitpid(pid, 0)[1]
+sys.exit(os.WEXITSTATUS(status) if os.WIFEXITED(status) else 128 + os.WTERMSIG(status))
+`;
+export class Pty extends EventEmitter {
+    child;
+    exited = false;
+    constructor(options) {
+        super();
+        // -I: none of the robot's PYTHONPATH and the like, which the program
+        // still gets
+        this.child = spawn('python3', ['-I', '-c', BRIDGE, String(options.cols), String(options.rows), options.file, ...options.args], { cwd: options.cwd, env: options.env, stdio: ['pipe', 'pipe', 'inherit', 'pipe'] });
+        this.child.stdout?.setEncoding('utf8').on('data', (chunk) => this.emit('data', chunk));
+        // Writes after the program is gone
+        this.child.stdin?.on('error', () => { });
+        this.child.stdio[3]?.on('error', () => { });
+        this.child.on('error', (e) => {
+            this.exited = true;
+            this.emit('error', e);
+        });
+        // 'close': after the last of its output
+        this.child.on('close', (code) => {
+            if (!this.exited) {
+                this.exited = true;
+                this.emit('exit', code);
+            }
+        });
+    }
+    get pid() {
+        return this.child.pid;
+    }
+    write(data) {
+        if (!this.exited) {
+            this.child.stdin?.write(data);
+        }
+    }
+    resize(cols, rows) {
+        if (!this.exited) {
+            this.child.stdio[3]?.write(`${cols} ${rows}\n`);
+        }
+    }
+    // Backpressure: the program blocks on its output while paused
+    pause() {
+        this.child.stdout?.pause();
+    }
+    resume() {
+        this.child.stdout?.resume();
+    }
+    // As a terminal window closed: the program gets SIGHUP
+    hangUp() {
+        if (!this.exited) {
+            this.child.kill('SIGHUP');
+        }
+    }
+}

package/dist/server/server.js

@@ -15,6 +15,7 @@ import { Arm } from './arm.js';
 import { BehaviorTreeFiles } from './behavior_tree_files.js';
 import { BehaviorTrees } from './behavior_trees.js';
 import { CommandRunner } from './commands.js';
+import { Diagnostics } from './diagnostics.js';
 import { createRequestHandler } from './http.js';
 import { PanelStore } from './panels.js';
 import { Paths } from './paths.js';
@@ -26,9 +27,10 @@ import { Session } from './session.js';
 import { FrameStreams } from './streams.js';
 import { SystemdServices } from './systemd.js';
 import { Teleop } from './teleop.js';
+import { Terminals } from './terminals.js';
 import { Tf } from './tf.js';
 import { Topics } from './topics.js';
-import { defaultPanelsDirectory, errorMessage, tasselloRoot } from './util.js';
+import { defaultPanelsDirectory, errorMessage, ownPage, tasselloRoot } from './util.js';
 // Connections that miss a ping for this long are dropped: a page whose
 // network vanished never closes its socket by itself
 const HEARTBEAT_MS = 10_000;
@@ -88,6 +90,8 @@ export async function startServer(options) {
     const arm = new Arm(node, topics, logger);
     const ros = new Ros(node);
     const rosout = new Rosout(node, logger);
+    const diagnostics = new Diagnostics(node, logger);
+    const terminals = new Terminals(logger);
     // Next to the panels
     const uploadsDir = path.join(path.dirname(panelsDir), 'images');
     const behaviorTrees = new BehaviorTrees(node, logger, uploadsDir);
@@ -133,11 +137,13 @@ export async function startServer(options) {
             arm,
             ros,
             rosout,
+            diagnostics,
+            terminals,
             behaviorTrees,
             behaviorTreeFiles,
             plugins: host,
             hostname: os.hostname(),
-        });
+        }, ownPage(req.headers));
         sessions.add(session);
         logger.debug(`Page connected from ${req.socket.remoteAddress}`);
         let alive = true;
@@ -169,6 +175,7 @@ export async function startServer(options) {
         stopping = true;
         commands.stopAll();
         systemd.stopAll();
+        terminals.stopAll();
         // Stops the robot if a page was driving it, while the node still runs
         for (const session of sessions) {
             session.close();

package/dist/server/session.d.ts

@@ -5,6 +5,7 @@ import type { Arm } from './arm.ts';
 import type { BehaviorTreeFiles } from './behavior_tree_files.ts';
 import type { BehaviorTrees } from './behavior_trees.ts';
 import type { CommandRunner } from './commands.ts';
+import type { Diagnostics } from './diagnostics.ts';
 import type { EncodedFrame, FrameSink, StreamState } from './frame_stream.ts';
 import type { Poses } from './poses.ts';
 import type { Paths } from './paths.ts';
@@ -14,6 +15,7 @@ import type { Rosout } from './rosout.ts';
 import type { FrameStreams } from './streams.ts';
 import type { SystemdServices } from './systemd.ts';
 import type { Teleop } from './teleop.ts';
+import type { Terminals } from './terminals.ts';
 import type { Tf } from './tf.ts';
 import type { Topics } from './topics.ts';
 export interface SessionServices {
@@ -28,6 +30,8 @@ export interface SessionServices {
     arm: Arm;
     ros: Ros;
     rosout: Rosout;
+    diagnostics: Diagnostics;
+    terminals: Terminals;
     behaviorTrees: BehaviorTrees;
     behaviorTreeFiles: BehaviorTreeFiles;
     plugins: PluginHost;
@@ -41,8 +45,10 @@ export declare class Session implements FrameSink, PluginSession {
     private readonly consumers;
     private readonly arms;
     private readonly playbacks;
+    private readonly terminals;
+    private readonly ownPage;
     private lastError;
-    constructor(ws: WebSocket, services: SessionServices);
+    constructor(ws: WebSocket, services: SessionServices, ownPage: boolean);
     send(message: ServerMessage): void;
     sendStreamStatus(id: number, state: StreamState, message: string): void;
     sendFrame(id: number, frame: EncodedFrame): void;