tassello 0.2.0 → 0.4.0

package/dist/shared/networking.d.ts

@@ -0,0 +1,178 @@
+export type WifiSecurity = 'open' | 'owe' | 'wep' | 'wpa-psk' | 'sae' | 'wpa-eap';
+export type ConnectionKind = 'wifi' | 'hotspot' | 'ethernet' | 'vpn' | 'other';
+export type EditableKind = 'wifi' | 'hotspot' | 'ethernet';
+export type Ipv4Method = 'auto' | 'manual' | 'shared' | 'disabled';
+export declare const DEVICE_UNMANAGED = 10;
+export declare const DEVICE_UNAVAILABLE = 20;
+export declare const DEVICE_DISCONNECTED = 30;
+export declare const DEVICE_ACTIVATED = 100;
+export declare const DEVICE_DEACTIVATING = 110;
+export declare const DEVICE_FAILED = 120;
+export interface NetworkDevice {
+    name: string;
+    type: string;
+    state: number;
+    stateText: string;
+    reason: string;
+    connection: string | null;
+    connectionName: string;
+    external: boolean;
+    software: boolean;
+    hwaddr: string;
+    mtu: number | null;
+    carrier: boolean | null;
+    speed: string;
+    driver: string;
+    vendor: string;
+    product: string;
+    accessPoint: boolean;
+    band24: boolean;
+    band5: boolean;
+    ipv4: string[];
+    ipv6: string[];
+    gateway: string;
+    dns: string[];
+}
+export interface NetworkConnection {
+    uuid: string;
+    name: string;
+    type: string;
+    kind: ConnectionKind;
+    interface: string;
+    autoconnect: boolean;
+    priority: number;
+    lastUsed: number | null;
+    readOnly: boolean;
+    file: string;
+    device: string | null;
+    activeState: string | null;
+    external: boolean;
+    ssid: string;
+    security: WifiSecurity | null;
+    hidden: boolean;
+    band: '' | 'a' | 'bg';
+    channel: number;
+    identity: string;
+    vpnService: string;
+    ipv4Method: string;
+    addresses: string[];
+    gateway: string;
+    dns: string[];
+}
+export interface WifiNetwork {
+    ssid: string;
+    device: string;
+    bssid: string;
+    signal: number;
+    frequency: number;
+    channel: number;
+    rate: string;
+    securityText: string;
+    security: WifiSecurity;
+    mode: string;
+    active: boolean;
+    points: number;
+}
+export interface NetworkActivity {
+    id: number;
+    action: NetworkRequest['action'];
+    label: string;
+    uuid: string | null;
+    ssid: string | null;
+    device: string | null;
+    started: number;
+    finished: number | null;
+    error: string | null;
+}
+export interface NetworkPermissions {
+    control: boolean;
+    modify: boolean;
+    wifi: boolean;
+    scan: boolean;
+    share: boolean;
+}
+export interface NetworkState {
+    error: string | null;
+    version: string;
+    state: string;
+    connectivity: string;
+    wifi: boolean;
+    wifiHardware: boolean;
+    permissions: NetworkPermissions;
+    devices: NetworkDevice[];
+    connections: NetworkConnection[];
+    networks: WifiNetwork[];
+    scanning: boolean;
+    activity: NetworkActivity[];
+}
+export interface NetworkSettings {
+    kind: EditableKind;
+    name: string;
+    interface: string;
+    autoconnect: boolean;
+    priority: number;
+    ssid: string;
+    hidden: boolean;
+    security: WifiSecurity;
+    password: string | null;
+    identity: string;
+    band: '' | 'a' | 'bg';
+    channel: number;
+    ipv4: Ipv4Method;
+    addresses: string[];
+    gateway: string;
+    dns: string[];
+}
+export type NetworkRequest = {
+    action: 'connect';
+    uuid: string;
+    device: string | null;
+    password: string | null;
+} | {
+    action: 'disconnect';
+    uuid: string;
+} | {
+    action: 'create';
+    settings: NetworkSettings;
+    connect: boolean;
+    device: string | null;
+} | {
+    action: 'modify';
+    uuid: string;
+    settings: NetworkSettings;
+} | {
+    action: 'delete';
+    uuid: string;
+} | {
+    action: 'wifi';
+    enabled: boolean;
+} | {
+    action: 'rescan';
+    device: string | null;
+} | {
+    action: 'secrets';
+    uuid: string;
+};
+export interface NetworkSecrets {
+    ssid: string;
+    security: WifiSecurity | null;
+    password: string;
+    hidden: boolean;
+}
+export interface NetworkResult {
+    uuid: string | null;
+    message: string | null;
+}
+export declare const WRONG_PASSWORD = "Wrong password, or none given";
+export declare const SECURITY_LABELS: Record<WifiSecurity, string>;
+export declare function needsPassword(security: WifiSecurity): boolean;
+export declare function isInterfaceName(name: string): boolean;
+export declare function isUuid(uuid: string): boolean;
+export declare function isIpv4(address: string): boolean;
+export declare function isIpv6(address: string): boolean;
+export declare function cidrProblem(cidr: string): string | null;
+export declare function splitList(text: string): string[];
+export declare function passwordProblem(security: WifiSecurity, password: string, hotspot?: boolean): string | null;
+export declare function settingsProblems(settings: NetworkSettings, creating: boolean): Partial<Record<keyof NetworkSettings, string>>;
+export declare function settingsOf(connection: NetworkConnection): NetworkSettings | null;
+export declare function defaultSettings(kind: EditableKind): NetworkSettings;

package/dist/shared/networking.js

@@ -0,0 +1,248 @@
+// The robot's networks, as NetworkManager has them: what the Networking
+// widget shows and changes (see src/server/networking.ts), and the checks of
+// the settings it sends, which the page makes as they are typed and the
+// server again before it passes them to nmcli.
+// NetworkManager's device states (NMDeviceState)
+export const DEVICE_UNMANAGED = 10;
+export const DEVICE_UNAVAILABLE = 20;
+export const DEVICE_DISCONNECTED = 30;
+export const DEVICE_ACTIVATED = 100;
+export const DEVICE_DEACTIVATING = 110;
+export const DEVICE_FAILED = 120;
+// The reason a connection fails with when its password is wrong: the page
+// asks for it again
+export const WRONG_PASSWORD = 'Wrong password, or none given';
+export const SECURITY_LABELS = {
+    open: 'None (open)',
+    owe: 'Enhanced Open (OWE)',
+    wep: 'WEP',
+    'wpa-psk': 'WPA/WPA2 Personal',
+    sae: 'WPA3 Personal',
+    'wpa-eap': 'WPA/WPA2 Enterprise',
+};
+export function needsPassword(security) {
+    return security !== 'open' && security !== 'owe';
+}
+// Linux's: at most 15 characters, no slashes, spaces or colons
+const INTERFACE = /^[\w.@-]{1,15}$/;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+// Of the 2.4 GHz band, and of the 5 GHz one (20 MHz channels)
+const CHANNELS_24 = Array.from({ length: 14 }, (_, i) => i + 1);
+const CHANNELS_5 = [
+    36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 149, 153, 157, 161, 165,
+    169, 173, 177,
+];
+export function isInterfaceName(name) {
+    return INTERFACE.test(name);
+}
+export function isUuid(uuid) {
+    return UUID.test(uuid);
+}
+export function isIpv4(address) {
+    const parts = address.split('.');
+    return parts.length === 4 && parts.every((part) => /^(0|[1-9]\d{0,2})$/.test(part) && Number(part) <= 255);
+}
+export function isIpv6(address) {
+    if (!/^[0-9a-f:.]+$/i.test(address) || !address.includes(':')) {
+        return false;
+    }
+    const halves = address.split('::');
+    if (halves.length > 2) {
+        return false;
+    }
+    const groups = halves.flatMap((half) => (half ? half.split(':') : []));
+    // An IPv4 tail counts as two groups
+    const last = groups.at(-1) ?? '';
+    const ipv4Tail = last.includes('.');
+    if (ipv4Tail && !isIpv4(last)) {
+        return false;
+    }
+    const hex = ipv4Tail ? groups.slice(0, -1) : groups;
+    if (!hex.every((group) => /^[0-9a-f]{1,4}$/i.test(group))) {
+        return false;
+    }
+    const count = hex.length + (ipv4Tail ? 2 : 0);
+    return halves.length === 2 ? count < 8 : count === 8;
+}
+// 192.168.1.20/24: an address of a network, not the network itself
+export function cidrProblem(cidr) {
+    const [address, prefix, ...rest] = cidr.trim().split('/');
+    if (rest.length > 0 || !isIpv4(address)) {
+        return `“${cidr.trim()}” is not an IPv4 address`;
+    }
+    if (prefix === undefined) {
+        return `Give its network's size: ${address}/24`;
+    }
+    if (!/^\d{1,2}$/.test(prefix) || Number(prefix) < 1 || Number(prefix) > 32) {
+        return `/${prefix} is not a network's size: /1 to /32 (/24: 255.255.255.0)`;
+    }
+    return null;
+}
+// Separated by commas, spaces or new lines
+export function splitList(text) {
+    return text
+        .split(/[\s,;]+/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function utf8Length(text) {
+    return new TextEncoder().encode(text).length;
+}
+// Of a Wi-Fi network or an access point, by its security; null if fine
+export function passwordProblem(security, password, hotspot = false) {
+    switch (security) {
+        case 'open':
+        case 'owe':
+            return null;
+        case 'wpa-psk':
+            if (/^[0-9a-f]{64}$/i.test(password)) {
+                return null;
+            }
+            if (!/^[\x20-\x7e]*$/.test(password)) {
+                return 'Letters, digits and symbols of the keyboard only: no accents';
+            }
+            if (password.length < 8 || password.length > 63) {
+                return hotspot ? '8 to 63 characters' : 'WPA passwords have 8 to 63 characters';
+            }
+            return null;
+        case 'sae':
+            return password.length === 0 ? 'The network’s password' : password.length > 128 ? 'At most 128 characters' : null;
+        case 'wep':
+            return /^([\x20-\x7e]{5}|[\x20-\x7e]{13}|[0-9a-f]{10}|[0-9a-f]{26})$/i.test(password)
+                ? null
+                : 'WEP keys have 5 or 13 characters, or 10 or 26 hexadecimal digits';
+        case 'wpa-eap':
+            return password.length === 0 ? 'Your password on the network' : null;
+    }
+}
+// What is wrong with the settings, by field: empty if nothing. creating: a
+// new connection, whose password is required.
+export function settingsProblems(settings, creating) {
+    const problems = {};
+    const { kind } = settings;
+    const name = settings.name.trim();
+    if (!name) {
+        problems.name = 'A name for the connection';
+    }
+    else if (name.length > 255 || /[\x00-\x1f]/.test(name)) {
+        problems.name = 'At most 255 characters, on one line';
+    }
+    if (settings.interface && !isInterfaceName(settings.interface)) {
+        problems.interface = `“${settings.interface}” is not an interface's name`;
+    }
+    else if (kind === 'hotspot' && !settings.interface) {
+        problems.interface = 'The Wi-Fi interface of the access point';
+    }
+    if (!Number.isInteger(settings.priority) || settings.priority < -999 || settings.priority > 999) {
+        problems.priority = 'A whole number, from -999 to 999';
+    }
+    if (kind !== 'ethernet') {
+        const bytes = utf8Length(settings.ssid);
+        if (bytes === 0) {
+            problems.ssid = kind === 'hotspot' ? 'The name the access point shows' : 'The network’s name';
+        }
+        else if (bytes > 32) {
+            problems.ssid = 'At most 32 bytes (fewer with accents and symbols)';
+        }
+        else if (/[\x00-\x1f]/.test(settings.ssid)) {
+            problems.ssid = 'No control characters';
+        }
+        if (kind === 'hotspot' && settings.security !== 'open' && settings.security !== 'wpa-psk') {
+            problems.security = 'An access point is open, or secured by a WPA2 password';
+        }
+        if (settings.security === 'wpa-eap') {
+            if (!settings.identity.trim()) {
+                problems.identity = 'Your user name on the network';
+            }
+            else if (/[\x00-\x1f]/.test(settings.identity)) {
+                problems.identity = 'No control characters';
+            }
+        }
+        if (settings.password !== null) {
+            const problem = passwordProblem(settings.security, settings.password, kind === 'hotspot');
+            if (problem) {
+                problems.password = problem;
+            }
+        }
+        else if (creating && needsPassword(settings.security)) {
+            problems.password = 'The network’s password';
+        }
+        if (kind === 'hotspot') {
+            const channels = settings.band === 'a' ? CHANNELS_5 : settings.band === 'bg' ? CHANNELS_24 : [];
+            if (settings.channel !== 0 && !channels.includes(settings.channel)) {
+                problems.channel = settings.band
+                    ? `Not a channel of ${settings.band === 'a' ? '5' : '2.4'} GHz`
+                    : 'Choose the band of the channel';
+            }
+        }
+    }
+    const methods = kind === 'hotspot' ? ['shared'] : ['auto', 'manual', 'shared', 'disabled'];
+    if (!methods.includes(settings.ipv4)) {
+        problems.ipv4 = kind === 'hotspot' ? 'An access point gives the addresses (shared)' : 'Not a way to get an address';
+    }
+    const addressProblem = settings.addresses.map(cidrProblem).find((problem) => problem !== null);
+    if (addressProblem) {
+        problems.addresses = addressProblem;
+    }
+    else if (settings.ipv4 === 'manual' && settings.addresses.length === 0) {
+        problems.addresses = 'The robot’s address on this network: 192.168.1.20/24';
+    }
+    else if (settings.ipv4 === 'shared' && settings.addresses.length > 1) {
+        problems.addresses = 'One address: the robot’s, on the network it gives';
+    }
+    if (settings.gateway && !isIpv4(settings.gateway)) {
+        problems.gateway = `“${settings.gateway}” is not an IPv4 address`;
+    }
+    const badDns = settings.dns.find((server) => !isIpv4(server) && !isIpv6(server));
+    if (badDns !== undefined) {
+        problems.dns = `“${badDns}” is not an IP address`;
+    }
+    return problems;
+}
+// The settings of a saved connection, to edit them (its password unchanged)
+export function settingsOf(connection) {
+    const kind = connection.kind;
+    if (kind !== 'wifi' && kind !== 'hotspot' && kind !== 'ethernet') {
+        return null;
+    }
+    const methods = ['auto', 'manual', 'shared', 'disabled'];
+    return {
+        kind,
+        name: connection.name,
+        interface: connection.interface,
+        autoconnect: connection.autoconnect,
+        priority: connection.priority,
+        ssid: connection.ssid,
+        hidden: connection.hidden,
+        security: connection.security ?? 'open',
+        password: null,
+        identity: connection.identity,
+        band: connection.band,
+        channel: connection.channel,
+        ipv4: methods.includes(connection.ipv4Method) ? connection.ipv4Method : 'auto',
+        addresses: connection.addresses,
+        gateway: connection.gateway,
+        dns: connection.dns,
+    };
+}
+// A new connection's, of a kind
+export function defaultSettings(kind) {
+    return {
+        kind,
+        name: '',
+        interface: '',
+        autoconnect: true,
+        priority: 0,
+        ssid: '',
+        hidden: false,
+        security: kind === 'ethernet' ? 'open' : 'wpa-psk',
+        password: kind === 'ethernet' ? null : '',
+        identity: '',
+        band: '',
+        channel: 0,
+        ipv4: kind === 'hotspot' ? 'shared' : 'auto',
+        addresses: [],
+        gateway: '',
+        dns: [],
+    };
+}

package/dist/shared/protocol.d.ts

@@ -1,4 +1,5 @@
 import type { BtNodeModel } from './bt_nodes.ts';
+import type { NetworkRequest, NetworkState } from './networking.ts';
 export type ImageTransport = 'auto' | 'raw' | 'compressed';
 export type GridStyle = 'map' | 'costmap';
 export interface TwistCommand {
@@ -192,7 +193,53 @@ export interface RosoutSubscribe {
     id: number;
     topic: string;
 }
-export type ClientMessage = TwistCommand | ImageSubscribe | GridSubscribe | TfSubscribe | PathSubscribe | TopicSubscribe | ServicesSubscribe | ServiceAction | LogsSubscribe | Unsubscribe | FrameAck | PosePublish | CommandRun | CommandStop | ArmSubscribe | ArmJog | RosPublish | RosCall | PluginRequest | PluginSubscribe | BehaviorTreeSubscribe | BehaviorTreeRecord | BehaviorTreePlaybackSubscribe | BehaviorTreePlaybackControl | BehaviorTreeFileSubscribe | BehaviorTreeFileSave | RosoutSubscribe;
+export interface DiagnosticsSubscribe {
+    type: 'diagnostics.subscribe';
+    id: number;
+    topic: string;
+}
+export interface TerminalOpen {
+    type: 'terminal.open';
+    id: number;
+    terminal: string;
+    command: string;
+    folder: string;
+    cols: number;
+    rows: number;
+    started: number | null;
+    offset: number | null;
+}
+export interface TerminalInput {
+    type: 'terminal.input';
+    id: number;
+    data: string;
+}
+export interface TerminalResize {
+    type: 'terminal.resize';
+    id: number;
+    cols: number;
+    rows: number;
+}
+export interface TerminalAck {
+    type: 'terminal.ack';
+    id: number;
+    started: number;
+    offset: number;
+}
+export interface TerminalRestart {
+    type: 'terminal.restart';
+    id: number;
+}
+export interface NetworkSubscribe {
+    type: 'network.subscribe';
+    id: number;
+}
+export interface NetworkAction {
+    type: 'network.action';
+    id: number;
+    request: NetworkRequest;
+}
+export type ClientMessage = TwistCommand | ImageSubscribe | GridSubscribe | TfSubscribe | PathSubscribe | TopicSubscribe | ServicesSubscribe | ServiceAction | LogsSubscribe | Unsubscribe | FrameAck | PosePublish | CommandRun | CommandStop | ArmSubscribe | ArmJog | RosPublish | RosCall | PluginRequest | PluginSubscribe | BehaviorTreeSubscribe | BehaviorTreeRecord | BehaviorTreePlaybackSubscribe | BehaviorTreePlaybackControl | BehaviorTreeFileSubscribe | BehaviorTreeFileSave | RosoutSubscribe | DiagnosticsSubscribe | TerminalOpen | TerminalInput | TerminalResize | TerminalAck | TerminalRestart | NetworkSubscribe | NetworkAction;
 export interface Hello {
     type: 'hello';
     clientId: string;
@@ -429,7 +476,57 @@ export interface RosoutUpdate {
     skipped: number;
     nodes: string[] | null;
 }
-export type ServerMessage = Hello | CommandStates | CommandUpdate | StreamStatus | TfUpdate | PathUpdate | TopicMessage | ServicesUpdate | ServiceResult | LogsUpdate | ArmUpdate | Result | PluginData | BehaviorTreeInfo | BehaviorTreeUpdate | BehaviorTreeRecording | BehaviorTreePlaybackState | BehaviorTreeFile | BehaviorTreeModels | RosoutUpdate | PanelsChanged | ErrorMessage;
+export interface DiagnosticEntry {
+    id: number;
+    name: string;
+    level: number;
+    message: string;
+    hardwareId: string;
+    values: {
+        key: string;
+        value: string;
+    }[];
+    stale: boolean;
+    updated: number;
+    since: number;
+}
+export interface DiagnosticChange {
+    seq: number;
+    time: number;
+    status: number;
+    level: number;
+    message: string;
+}
+export interface DiagnosticsUpdate {
+    type: 'diagnostics';
+    id: number;
+    reset: boolean;
+    started: number;
+    statuses: DiagnosticEntry[];
+    changes: DiagnosticChange[];
+}
+export interface TerminalOutput {
+    type: 'terminal.output';
+    id: number;
+    started: number;
+    offset: number;
+    reset: boolean;
+    data: string;
+    title: string | null;
+}
+export interface TerminalExit {
+    type: 'terminal.exit';
+    id: number;
+    started: number;
+    exitCode: number | null;
+}
+export interface NetworkUpdate extends NetworkState {
+    type: 'network';
+    id: number;
+    via: string | null;
+    canChange: boolean;
+}
+export type ServerMessage = Hello | CommandStates | CommandUpdate | StreamStatus | TfUpdate | PathUpdate | TopicMessage | ServicesUpdate | ServiceResult | LogsUpdate | ArmUpdate | Result | PluginData | BehaviorTreeInfo | BehaviorTreeUpdate | BehaviorTreeRecording | BehaviorTreePlaybackState | BehaviorTreeFile | BehaviorTreeModels | RosoutUpdate | DiagnosticsUpdate | TerminalOutput | TerminalExit | NetworkUpdate | PanelsChanged | ErrorMessage;
 export declare const FRAME_HEADER_BYTES = 11;
 export declare const IMAGE_FORMATS: readonly ['image/jpeg', 'image/png'];
 export interface GridInfo {
@@ -452,6 +549,10 @@ export declare const ARM_STATE_RATE = 10;
 export declare const BT_RATE = 10;
 export declare const ROSOUT_RATE = 10;
 export declare const ROSOUT_HISTORY = 10000;
+export declare const DIAGNOSTICS_RATE = 4;
+export declare const DIAGNOSTICS_CHANGES = 1000;
+export declare const TERMINAL_SCROLLBACK = 2000;
+export declare const TERMINAL_WINDOW: number;
 export declare const DASHBOARD_CLIENT_HEADER = "X-Dashboard-Client";
 export interface PluginInfo {
     name: string;

package/dist/shared/protocol.js

@@ -19,4 +19,12 @@ export const BT_RATE = 10;
 export const ROSOUT_RATE = 10;
 // Messages of the ROS log kept by the server, and by the page
 export const ROSOUT_HISTORY = 10_000;
+// Diagnostics come about once a second
+export const DIAGNOSTICS_RATE = 4;
+// Changes of level kept by the server, and by the page
+export const DIAGNOSTICS_CHANGES = 1000;
+// Lines of a terminal kept above its screen, by the server and by the page
+export const TERMINAL_SCROLLBACK = 2000;
+// Characters of a terminal's output sent to a page and not yet written by it
+export const TERMINAL_WINDOW = 256 * 1024;
 export const DASHBOARD_CLIENT_HEADER = 'X-Dashboard-Client';

package/dist/types/client/api.d.ts

@@ -1,5 +1,10 @@
+import type { FsAnalysis, FsConflict, FsDetails, FsDisk, FsListing, FsOperation, FsPlaces, FsResult, FsSaved, FsText } from '../shared/file_manager.ts';
 import type { Panel, PanelSummary, TopicInfo } from '../shared/panel.ts';
 import { type PluginInfo } from '../shared/protocol.ts';
+export declare class ApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
 export type FileKind = 'image' | 'behavior-tree' | 'bag' | 'folder';
 export interface DirectoryListing {
     dir: string;
@@ -21,3 +26,20 @@ export declare const api: {
     listFiles: (dir: string, kind?: FileKind) => Promise<DirectoryListing>;
     uploadFile: (file: Blob) => Promise<string>;
 };
+export interface Upload {
+    result: Promise<FsResult>;
+    abort: () => void;
+}
+export declare const fsApi: {
+    places: () => Promise<FsPlaces>;
+    list: (path: string, known?: string) => Promise<FsListing | undefined>;
+    details: (path: string) => Promise<FsDetails>;
+    disks: () => Promise<FsDisk[]>;
+    analyze: (path: string) => Promise<FsAnalysis>;
+    readText: (path: string, stamp?: string) => Promise<FsText | undefined>;
+    saveText: (path: string, text: string, base: string | null, create?: boolean) => Promise<FsSaved>;
+    operate: (operation: FsOperation) => Promise<FsResult>;
+    downloadUrl: (paths: string[]) => string;
+    viewUrl: (path: string, stamp?: string) => string;
+    upload(folder: string, name: string, file: Blob, conflict: FsConflict, onProgress: (sent: number) => void): Upload;
+};

package/dist/types/client/connection.d.ts

@@ -1,4 +1,5 @@
-import { type ArmSubscribe, type ArmUpdate, type BehaviorTreeFile, type BehaviorTreeFileSubscribe, type BehaviorTreeInfo, type BehaviorTreeModels, type BehaviorTreePlaybackControl, type BehaviorTreePlaybackState, type BehaviorTreePlaybackSubscribe, type BehaviorTreeRecording, type BehaviorTreeSaved, type BehaviorTreeSubscribe, type BehaviorTreeUpdate, type ClientMessage, type CommandState, type GridSubscribe, type ImageSubscribe, type LogsSubscribe, type LogsUpdate, type PathSubscribe, type PathUpdate, type RosoutSubscribe, type RosoutUpdate, type ServerMessage, type ServiceScope, type ServicesSubscribe, type ServicesUpdate, type ServiceVerb, type StreamStatus, type TfSubscribe, type TfUpdate, type TopicSubscribe } from '../shared/protocol.ts';
+import type { NetworkRequest, NetworkResult, NetworkSecrets } from '../shared/networking.ts';
+import { type ArmSubscribe, type ArmUpdate, type BehaviorTreeFile, type BehaviorTreeFileSubscribe, type BehaviorTreeInfo, type BehaviorTreeModels, type BehaviorTreePlaybackControl, type BehaviorTreePlaybackState, type BehaviorTreePlaybackSubscribe, type BehaviorTreeRecording, type BehaviorTreeSaved, type BehaviorTreeSubscribe, type BehaviorTreeUpdate, type ClientMessage, type CommandState, type DiagnosticsSubscribe, type DiagnosticsUpdate, type GridSubscribe, type ImageSubscribe, type LogsSubscribe, type LogsUpdate, type NetworkUpdate, type PathSubscribe, type PathUpdate, type RosoutSubscribe, type RosoutUpdate, type ServerMessage, type ServiceScope, type ServicesSubscribe, type ServicesUpdate, type ServiceVerb, type StreamStatus, type TerminalExit, type TerminalOpen, type TerminalOutput, type TfSubscribe, type TfUpdate, type TopicSubscribe } from '../shared/protocol.ts';
 export type ConnectionStatus = 'connecting' | 'open' | 'closed';
 export type ImageOptions = Omit<ImageSubscribe, 'type' | 'id'>;
 export type GridOptions = Omit<GridSubscribe, 'type' | 'id'>;
@@ -13,6 +14,8 @@ export type BehaviorTreePlaybackOptions = Omit<BehaviorTreePlaybackSubscribe, 't
 export type BehaviorTreePlaybackRequest = Omit<BehaviorTreePlaybackControl, 'type' | 'id'>;
 export type BehaviorTreeFileOptions = Omit<BehaviorTreeFileSubscribe, 'type' | 'id'>;
 export type RosoutOptions = Omit<RosoutSubscribe, 'type' | 'id'>;
+export type DiagnosticsOptions = Omit<DiagnosticsSubscribe, 'type' | 'id'>;
+export type TerminalOptions = Pick<TerminalOpen, 'terminal' | 'command' | 'folder'>;
 export interface TopicHandlers {
     status: (state: StreamStatus['state'], message: string) => void;
     message: (messageType: string, message: unknown) => void;
@@ -32,6 +35,16 @@ export interface RosoutHandlers {
     status: (state: StreamStatus['state'], message: string) => void;
     update: (update: RosoutUpdate) => void;
 }
+export interface DiagnosticsHandlers {
+    status: (state: StreamStatus['state'], message: string) => void;
+    update: (update: DiagnosticsUpdate) => void;
+}
+export interface TerminalHandlers {
+    status: (state: StreamStatus['state'], message: string) => void;
+    output: (output: TerminalOutput) => void;
+    exit: (exit: TerminalExit) => void;
+    shown: () => Pick<TerminalOpen, 'cols' | 'rows' | 'started' | 'offset'>;
+}
 export interface FrameInfo {
     width: number;
     height: number;
@@ -81,6 +94,22 @@ export declare class Connection {
     subscribeBehaviorTreeFile(options: BehaviorTreeFileOptions, handlers: BehaviorTreeFileHandlers): () => void;
     saveBehaviorTreeFile(path: string, text: string, base: string | null, create?: boolean): Promise<BehaviorTreeSaved>;
     subscribeRosout(options: RosoutOptions, handlers: RosoutHandlers): () => void;
+    subscribeDiagnostics(options: DiagnosticsOptions, handlers: DiagnosticsHandlers): () => void;
+    subscribeTerminal(options: TerminalOptions, handlers: TerminalHandlers): {
+        id: number;
+        unsubscribe: () => void;
+    };
+    terminalInput(id: number, data: string): boolean;
+    resizeTerminal(id: number, cols: number, rows: number): boolean;
+    ackTerminal(id: number, started: number, offset: number): boolean;
+    restartTerminal(id: number): boolean;
+    subscribeNetwork(callback: (update: NetworkUpdate) => void): () => void;
+    networkAction(request: Exclude<NetworkRequest, {
+        action: 'secrets';
+    }>): Promise<NetworkResult>;
+    networkAction(request: Extract<NetworkRequest, {
+        action: 'secrets';
+    }>): Promise<NetworkSecrets>;
     serviceAction(unit: string, scope: ServiceScope, verb: ServiceVerb): Promise<string | null>;
     publish(topic: string, messageType: string, message: unknown): boolean;
     callService<T = unknown>(service: string, serviceType: string, request?: unknown, timeoutMs?: number): Promise<T>;