tassello 0.2.0 → 0.4.0

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,7 +15,9 @@ 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 { Networking } from './networking.js';
 import { PanelStore } from './panels.js';
 import { Paths } from './paths.js';
 import { findPlugins, PluginHost, readPlugin } from './plugins.js';
@@ -26,9 +28,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 +91,9 @@ 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);
+    const networking = new Networking(logger);
     // Next to the panels
     const uploadsDir = path.join(path.dirname(panelsDir), 'images');
     const behaviorTrees = new BehaviorTrees(node, logger, uploadsDir);
@@ -133,11 +139,14 @@ export async function startServer(options) {
             arm,
             ros,
             rosout,
+            diagnostics,
+            terminals,
+            networking,
             behaviorTrees,
             behaviorTreeFiles,
             plugins: host,
             hostname: os.hostname(),
-        });
+        }, ownPage(req.headers), req.socket.localAddress ?? null);
         sessions.add(session);
         logger.debug(`Page connected from ${req.socket.remoteAddress}`);
         let alive = true;
@@ -169,6 +178,8 @@ export async function startServer(options) {
         stopping = true;
         commands.stopAll();
         systemd.stopAll();
+        terminals.stopAll();
+        networking.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,7 +5,9 @@ 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 { Networking } from './networking.ts';
 import type { Poses } from './poses.ts';
 import type { Paths } from './paths.ts';
 import type { PluginHost } from './plugins.ts';
@@ -14,6 +16,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 +31,9 @@ export interface SessionServices {
     arm: Arm;
     ros: Ros;
     rosout: Rosout;
+    diagnostics: Diagnostics;
+    terminals: Terminals;
+    networking: Networking;
     behaviorTrees: BehaviorTrees;
     behaviorTreeFiles: BehaviorTreeFiles;
     plugins: PluginHost;
@@ -41,8 +47,11 @@ export declare class Session implements FrameSink, PluginSession {
     private readonly consumers;
     private readonly arms;
     private readonly playbacks;
+    private readonly terminals;
+    private readonly ownPage;
+    private readonly localAddress;
     private lastError;
-    constructor(ws: WebSocket, services: SessionServices);
+    constructor(ws: WebSocket, services: SessionServices, ownPage: boolean, localAddress: string | null);
     send(message: ServerMessage): void;
     sendStreamStatus(id: number, state: StreamState, message: string): void;
     sendFrame(id: number, frame: EncodedFrame): void;

package/dist/server/session.js

@@ -4,6 +4,7 @@
 import { randomUUID } from 'node:crypto';
 import { WebSocket } from 'ws';
 import { FRAME_HEADER_BYTES, } from '../shared/protocol.js';
+import { checkRequest, deviceOfAddress } from './networking_format.js';
 import { errorMessage, toJson } from './util.js';
 // The same error is reported to the page at most this often: a teleop widget
 // publishing on an invalid topic would otherwise report it 10 times a second
@@ -37,6 +38,8 @@ function strings(value, field) {
     }
     return value.map((v) => v.trim()).filter(Boolean);
 }
+// A terminal's name, chosen by the page
+const TERMINAL_NAME = /^[\w-]{1,64}$/;
 function subscriptionId(value) {
     if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 0xffffffff) {
         throw new Error('Invalid subscription id');
@@ -55,10 +58,19 @@ export class Session {
     arms = new Map();
     // The behavior tree playbacks, for their controls
     playbacks = new Map();
+    // The terminals, for what is typed in them
+    terminals = new Map();
+    // The page is one of the dashboard's own (see ownPage): only those open
+    // terminals and change the networks
+    ownPage;
+    // The server's address the page reached: the interface it comes through
+    localAddress;
     lastError = { message: '', at: 0 };
-    constructor(ws, services) {
+    constructor(ws, services, ownPage, localAddress) {
         this.ws = ws;
         this.services = services;
+        this.ownPage = ownPage;
+        this.localAddress = localAddress;
         ws.on('message', (data, isBinary) => {
             if (!isBinary) {
                 this.onMessage(data.toString());
@@ -98,6 +110,7 @@ export class Session {
         this.consumers.clear();
         this.arms.clear();
         this.playbacks.clear();
+        this.terminals.clear();
     }
     reportError(message) {
         const now = Date.now();
@@ -237,6 +250,79 @@ export class Session {
                 }));
                 return;
             }
+            case 'diagnostics.subscribe': {
+                const id = subscriptionId(message.id);
+                this.unsubscribe(id);
+                this.subscriptions.set(id, services.diagnostics.watch(string(message.topic, 'topic'), {
+                    onStatus: (state, text) => this.sendStreamStatus(id, state, text),
+                    onUpdate: (update) => this.send({ type: 'diagnostics', id, ...update }),
+                }));
+                return;
+            }
+            case 'terminal.open': {
+                const id = subscriptionId(message.id);
+                this.unsubscribe(id);
+                if (!this.ownPage) {
+                    // e.g. another site's page, which a browser lets reach the robot
+                    this.sendStreamStatus(id, 'error', 'Terminals open in the dashboard’s own pages only');
+                    return;
+                }
+                if (typeof message.terminal !== 'string' || !TERMINAL_NAME.test(message.terminal)) {
+                    throw new Error('Invalid terminal name');
+                }
+                const point = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : null);
+                const view = services.terminals.open({
+                    terminal: message.terminal,
+                    command: optionalString(message.command),
+                    folder: optionalString(message.folder) || '~',
+                    cols: number(message.cols, 2, 1000, 80),
+                    rows: number(message.rows, 1, 500, 24),
+                    started: point(message.started),
+                    offset: point(message.offset),
+                }, {
+                    onOutput: (output) => this.send({ type: 'terminal.output', id, ...output }),
+                    onExit: (exit) => this.send({ type: 'terminal.exit', id, ...exit }),
+                    onStatus: (state, text) => this.sendStreamStatus(id, state, text),
+                });
+                this.terminals.set(id, view);
+                this.subscriptions.set(id, () => view.close());
+                return;
+            }
+            case 'terminal.input':
+                if (typeof message.data === 'string') {
+                    this.terminals.get(subscriptionId(message.id))?.input(message.data);
+                }
+                return;
+            case 'terminal.resize':
+                this.terminals
+                    .get(subscriptionId(message.id))
+                    ?.resize(number(message.cols, 2, 1000, 80), number(message.rows, 1, 500, 24));
+                return;
+            case 'terminal.ack':
+                if (typeof message.started === 'number' && typeof message.offset === 'number') {
+                    this.terminals.get(subscriptionId(message.id))?.ack(message.started, message.offset);
+                }
+                return;
+            case 'terminal.restart':
+                this.terminals.get(subscriptionId(message.id))?.restart();
+                return;
+            case 'network.subscribe': {
+                const id = subscriptionId(message.id);
+                this.unsubscribe(id);
+                this.subscriptions.set(id, services.networking.watch((state) => this.send({
+                    type: 'network',
+                    id,
+                    ...state,
+                    via: deviceOfAddress(state.devices, this.localAddress),
+                    canChange: this.ownPage,
+                })));
+                return;
+            }
+            case 'network.action':
+                this.answer(message.id, this.ownPage
+                    ? Promise.resolve(message.request).then((request) => services.networking.act(checkRequest(request)))
+                    : Promise.reject(new Error('The networks are changed from the dashboard’s own pages only')));
+                return;
             case 'arm.subscribe': {
                 const id = subscriptionId(message.id);
                 this.unsubscribe(id);
@@ -375,5 +461,6 @@ export class Session {
         this.consumers.delete(id);
         this.arms.delete(id);
         this.playbacks.delete(id);
+        this.terminals.delete(id);
     }
 }

package/dist/server/terminal_output.d.ts

@@ -0,0 +1,25 @@
+export declare class OutputLog {
+    private readonly limit;
+    private readonly chunks;
+    private first;
+    private length;
+    constructor(limit: number);
+    get start(): number;
+    get end(): number;
+    append(text: string): void;
+    since(offset: number): string | null;
+}
+export type NextOutput = {
+    data: string;
+    offset: number;
+} | 'snapshot' | null;
+export declare class Delivery {
+    offset: number;
+    private readonly sent;
+    private size;
+    constructor(offset: number);
+    get pending(): number;
+    next(log: OutputLog, window: number): NextOutput;
+    record(offset: number, size: number): void;
+    ack(offset: number): void;
+}

package/dist/server/terminal_output.js

@@ -0,0 +1,108 @@
+// A terminal's output as its pages get it (see terminals.ts): numbered by
+// offset, in characters (UTF-16 code units) since its program started, the
+// latest kept for the pages that missed some; and for each page, what it was
+// sent and has not written yet.
+// Small chunks (echoes of what is typed) are joined into the last one, up to
+// this many characters
+const JOIN_BELOW = 16 * 1024;
+export class OutputLog {
+    // At least `limit` characters, the latest, in whole chunks
+    limit;
+    chunks = [];
+    // Of the first chunk
+    first = 0;
+    length = 0;
+    constructor(limit) {
+        this.limit = limit;
+    }
+    // The oldest output kept
+    get start() {
+        return this.first;
+    }
+    get end() {
+        return this.first + this.length;
+    }
+    append(text) {
+        if (!text) {
+            return;
+        }
+        const last = this.chunks.length - 1;
+        if (last >= 0 && this.chunks[last].length < JOIN_BELOW) {
+            this.chunks[last] += text;
+        }
+        else {
+            this.chunks.push(text);
+        }
+        this.length += text.length;
+        while (this.chunks.length > 1 && this.length - this.chunks[0].length >= this.limit) {
+            const dropped = this.chunks.shift();
+            this.first += dropped.length;
+            this.length -= dropped.length;
+        }
+    }
+    // The output from offset on; null if it is no longer kept, or not yet
+    since(offset) {
+        if (offset < this.first || offset > this.end) {
+            return null;
+        }
+        let skip = offset - this.first;
+        let index = 0;
+        while (index < this.chunks.length && skip >= this.chunks[index].length) {
+            skip -= this.chunks[index].length;
+            index++;
+        }
+        return index === this.chunks.length ? '' : this.chunks[index].slice(skip) + this.chunks.slice(index + 1).join('');
+    }
+}
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+// What a page was sent of the output, and has not written yet: at most a
+// window of characters, so that a slow page (or one hidden, which writes
+// nothing) does not pile output up on the way, and gets the screen instead
+// once it lacks too much
+export class Delivery {
+    // Where the page's output goes once it wrote what it was sent
+    offset;
+    // What it was sent: the offset after each message, and its size
+    sent = [];
+    size = 0;
+    constructor(offset) {
+        this.offset = offset;
+    }
+    // Characters sent and not written yet
+    get pending() {
+        return this.size;
+    }
+    // What the page should get next: the output it lacks, as much as the window
+    // leaves; the screen instead if it lacks more than a window of it, or what
+    // it lacks is no longer kept; null if up to date, or its window is full
+    next(log, window) {
+        const room = window - this.size;
+        if (this.offset === log.end || room <= 0) {
+            return null;
+        }
+        const data = log.end - this.offset > window ? null : log.since(this.offset);
+        if (data === null) {
+            return 'snapshot';
+        }
+        let part = data.length > room ? data.slice(0, room) : data;
+        if (part.length < data.length && isHighSurrogate(part.charCodeAt(part.length - 1))) {
+            part = part.slice(0, -1);
+        }
+        return part ? { data: part, offset: this.offset + part.length } : null;
+    }
+    // Sent: the output up to offset, in a message of size characters
+    record(offset, size) {
+        this.offset = offset;
+        this.sent.push({ offset, size });
+        this.size += size;
+    }
+    // The page wrote the output up to offset: its messages are acknowledged in
+    // the order they were sent, whose offsets never go back
+    ack(offset) {
+        while (this.sent.length > 0 && this.sent[0].offset <= offset) {
+            this.size -= this.sent.shift().size;
+        }
+    }
+}

package/dist/server/terminals.d.ts

@@ -0,0 +1,32 @@
+import { type TerminalExit, type TerminalOutput } from '../shared/protocol.ts';
+import type { StreamState } from './frame_stream.ts';
+import { type Logger } from './util.ts';
+export interface TerminalRequest {
+    terminal: string;
+    command: string;
+    folder: string;
+    cols: number;
+    rows: number;
+    started: number | null;
+    offset: number | null;
+}
+export interface TerminalWatcher {
+    onOutput: (output: Omit<TerminalOutput, 'type' | 'id'>) => void;
+    onExit: (exit: Omit<TerminalExit, 'type' | 'id'>) => void;
+    onStatus: (state: StreamState, message: string) => void;
+}
+export interface TerminalView {
+    input(data: string): void;
+    resize(cols: number, rows: number): void;
+    ack(started: number, offset: number): void;
+    restart(): void;
+    close(): void;
+}
+export declare class Terminals {
+    private readonly logger;
+    private readonly terminals;
+    constructor(logger: Logger);
+    open(request: TerminalRequest, watcher: TerminalWatcher): TerminalView;
+    stopAll(): void;
+    private hangUpUnseen;
+}