tassello 0.3.0 → 0.4.0

package/dist/server/session.d.ts

@@ -7,6 +7,7 @@ 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';
@@ -32,6 +33,7 @@ export interface SessionServices {
     rosout: Rosout;
     diagnostics: Diagnostics;
     terminals: Terminals;
+    networking: Networking;
     behaviorTrees: BehaviorTrees;
     behaviorTreeFiles: BehaviorTreeFiles;
     plugins: PluginHost;
@@ -47,8 +49,9 @@ export declare class Session implements FrameSink, PluginSession {
     private readonly playbacks;
     private readonly terminals;
     private readonly ownPage;
+    private readonly localAddress;
     private lastError;
-    constructor(ws: WebSocket, services: SessionServices, ownPage: boolean);
+    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
@@ -60,13 +61,16 @@ export class Session {
     // 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
+    // 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, ownPage) {
+    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());
@@ -302,6 +306,23 @@ export class Session {
             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);

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 {
@@ -229,7 +230,16 @@ export interface TerminalRestart {
     type: 'terminal.restart';
     id: number;
 }
-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;
+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;
@@ -510,7 +520,13 @@ export interface TerminalExit {
     started: number;
     exitCode: number | null;
 }
-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 | PanelsChanged | ErrorMessage;
+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 {

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 DiagnosticsSubscribe, type DiagnosticsUpdate, 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 TerminalExit, type TerminalOpen, type TerminalOutput, 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'>;
@@ -102,6 +103,13 @@ export declare class Connection {
     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>;

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

@@ -83,3 +83,9 @@ export declare const MinimizeIcon: (props: SVGProps<SVGSVGElement>) => import("r
 export declare const ClipboardIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
 export declare const TextSmallerIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
 export declare const TextLargerIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
+export declare const NetworkIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
+export declare const WifiIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
+export declare const WifiOffIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
+export declare const EthernetIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
+export declare const HotspotIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;
+export declare const ShieldIcon: (props: SVGProps<SVGSVGElement>) => import("react").JSX.Element;

package/dist/types/client/sdk/index.d.ts

@@ -5,7 +5,8 @@ export { useDialogs, Modal, type Dialogs, type ConfirmOptions, type PromptOption
 export { notify } from '../notifications.tsx';
 export { Joystick, type JoystickProps } from '../widgets/Joystick.tsx';
 export * from '../icons.tsx';
-export type { BehaviorTreeFile, BehaviorTreeInfo, BehaviorTreeModels, BehaviorTreePlaybackState, BehaviorTreeRecording, BehaviorTreeSaved, BehaviorTreeUpdate, BtNode, BtNodeLibrary, BtNodeState, BtTransition, CommandState, ClientMessage, DiagnosticChange, DiagnosticEntry, DiagnosticsUpdate, LogEntry, RosoutUpdate, ServerMessage, StreamStatus, TerminalExit, TerminalOutput, TfUpdate, Transform2D, } from '../../shared/protocol.ts';
+export type { BehaviorTreeFile, BehaviorTreeInfo, BehaviorTreeModels, BehaviorTreePlaybackState, BehaviorTreeRecording, BehaviorTreeSaved, BehaviorTreeUpdate, BtNode, BtNodeLibrary, BtNodeState, BtTransition, CommandState, ClientMessage, DiagnosticChange, DiagnosticEntry, DiagnosticsUpdate, LogEntry, NetworkUpdate, RosoutUpdate, ServerMessage, StreamStatus, TerminalExit, TerminalOutput, TfUpdate, Transform2D, } from '../../shared/protocol.ts';
 export type { BtNodeModel, BtPortModel } from '../../shared/bt_nodes.ts';
+export type { ConnectionKind, NetworkActivity, NetworkConnection, NetworkDevice, NetworkPermissions, NetworkRequest, NetworkResult, NetworkSecrets, NetworkSettings, NetworkState, WifiNetwork, WifiSecurity, } from '../../shared/networking.ts';
 export type { FsAnalysis, FsConflict, FsDetails, FsDisk, FsEntry, FsListing, FsOperation, FsPlaces, FsResult, FsSaved, FsSpace, FsText, } from '../../shared/file_manager.ts';
 export type { Panel, WidgetInstance } from '../../shared/panel.ts';