@robotical/webapp-types 3.18.13 → 3.19.1

package/dist-types/src/utils/helpers/wifi-configuration-subtitle-gen.js

@@ -1,31 +1,35 @@
-import isVersionGreater from "./compare-version";
 import { RaftWifiConnState } from "@robdobsn/raftjs";
-export var FW_VERSION_RSSI_WIFI = "1.2.0"; // greater versions than this (1.1.17) have the wifi rssi logic
-export default function wifiConfigSub(raft, cachedStatus) {
+// Retained for signal-strength consumers; provisioning support is now probed
+// from NetMan instead of inferred from this version.
+export var FW_VERSION_RSSI_WIFI = "1.2.0";
+export default function wifiConfigSub(raft, cachedStatus, capability) {
+    if (capability === void 0) { capability = "supported"; }
     if (!raft) {
-        return "No raft connected";
+        return "No device connected";
     }
-    if (!isVersionGreater(raft.getRaftVersion(), FW_VERSION_RSSI_WIFI)) {
-        return "Currently, wifi configuration only works in the phone application.";
+    if (capability === "checking") {
+        return "Checking Wi-Fi support...";
+    }
+    if (capability === "unsupported") {
+        return "Wi-Fi requires compatible ".concat(raft.type, " firmware.");
     }
     var isPaused = cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.isPaused;
-    var conInfo = (cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.connState) === RaftWifiConnState.WIFI_CONN_CONNECTED ||
-        (cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.ssid)
-        ? cachedStatus.ipAddress + (isPaused ? "" : " on " + cachedStatus.ssid)
-        : null;
-    var isConnected = (cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.connState) === RaftWifiConnState.WIFI_CONN_CONNECTED && (cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.ipAddress);
-    var subtitle;
+    var isConnected = (cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.connState) === RaftWifiConnState.WIFI_CONN_CONNECTED;
+    var connectionDetails = [
+        cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.ipAddress,
+        (cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.ssid) ? "on ".concat(cachedStatus.ssid) : "",
+    ].filter(Boolean).join(" ");
     if (isConnected) {
-        subtitle = "Connected";
-    }
-    if (isConnected && isPaused) {
-        subtitle = "Connected (Paused for BLE)";
-    }
-    if (!isConnected) {
-        subtitle = "Not Connected";
+        var state = isPaused ? "Configured (paused for Bluetooth)" : "Connected";
+        return connectionDetails ? "".concat(state, " | ").concat(connectionDetails) : state;
     }
-    if (conInfo) {
-        subtitle += " | " + conInfo;
+    if ((cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.ssid) || (cachedStatus === null || cachedStatus === void 0 ? void 0 : cachedStatus.ipAddress)) {
+        var state = isPaused
+            ? "Configured (paused for Bluetooth)"
+            : "Configured (not connected)";
+        return cachedStatus.ssid ? "".concat(state, " | ").concat(cachedStatus.ssid) : state;
     }
-    return subtitle;
+    return isPaused
+        ? "Not connected (Wi-Fi paused for Bluetooth)"
+        : "Not connected";
 }

package/dist-types/src/utils/wifi-connection.d.ts

@@ -0,0 +1,18 @@
+import { ConnectableRaftType } from "../types/raft";
+/**
+ * Wi-Fi robot connections are deliberately limited to the local network. This
+ * is also the trust boundary used by the native wrapper when allowing
+ * cleartext ws:// traffic to robot firmware.
+ */
+export declare const isLocalWifiHostname: (hostname: string) => boolean;
+/**
+ * Turn a user-entered IP address, hostname, or URL into the complete WebSocket
+ * locator expected by the browser and native wrapper bridge.
+ *
+ * The selected robot type is authoritative for the path. This prevents a
+ * copied Marty URL from silently being used to connect to a Cog (or vice
+ * versa), while still allowing an advanced user to choose ws:// or wss:// and
+ * a custom port.
+ */
+export declare const normalizeWifiLocator: (input: string, raftType: ConnectableRaftType) => string;
+export declare const getWifiPathForRaftType: (raftType: ConnectableRaftType) => string;

package/dist-types/src/utils/wifi-connection.js

@@ -0,0 +1,97 @@
+var _a;
+import { RaftTypeE } from "../types/raft";
+var WEBSOCKET_PATHS = (_a = {},
+    _a[RaftTypeE.MARTY] = "/ws",
+    _a[RaftTypeE.COG] = "/wsjson",
+    _a);
+var isPrivateOrLocalIpv4 = function (hostname) {
+    var parts = hostname.split(".");
+    if (parts.length !== 4 || parts.some(function (part) { return !/^\d{1,3}$/.test(part); })) {
+        return false;
+    }
+    var octets = parts.map(Number);
+    if (octets.some(function (octet) { return octet > 255; })) {
+        return false;
+    }
+    return (octets[0] === 10 ||
+        octets[0] === 127 ||
+        (octets[0] === 169 && octets[1] === 254) ||
+        (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) ||
+        (octets[0] === 192 && octets[1] === 168));
+};
+var isPrivateOrLocalIpv6 = function (hostname) {
+    var unwrappedHostname = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    if (!unwrappedHostname.includes(":")) {
+        return false;
+    }
+    if (unwrappedHostname === "::1") {
+        return true;
+    }
+    var firstSegment = unwrappedHostname.split(":")[0];
+    var firstValue = Number.parseInt(firstSegment, 16);
+    return (Number.isFinite(firstValue) &&
+        // Unique local addresses (fc00::/7).
+        (firstValue >= 0xfc00 && firstValue <= 0xfdff ||
+            // Link-local addresses (fe80::/10).
+            firstValue >= 0xfe80 && firstValue <= 0xfebf));
+};
+/**
+ * Wi-Fi robot connections are deliberately limited to the local network. This
+ * is also the trust boundary used by the native wrapper when allowing
+ * cleartext ws:// traffic to robot firmware.
+ */
+export var isLocalWifiHostname = function (hostname) {
+    var normalizedHostname = hostname.toLowerCase().replace(/\.$/, "");
+    if (normalizedHostname === "localhost" ||
+        normalizedHostname.endsWith(".local") ||
+        (!normalizedHostname.includes(".") && !normalizedHostname.includes(":"))) {
+        return true;
+    }
+    return (isPrivateOrLocalIpv4(normalizedHostname) ||
+        isPrivateOrLocalIpv6(normalizedHostname));
+};
+/**
+ * Turn a user-entered IP address, hostname, or URL into the complete WebSocket
+ * locator expected by the browser and native wrapper bridge.
+ *
+ * The selected robot type is authoritative for the path. This prevents a
+ * copied Marty URL from silently being used to connect to a Cog (or vice
+ * versa), while still allowing an advanced user to choose ws:// or wss:// and
+ * a custom port.
+ */
+export var normalizeWifiLocator = function (input, raftType) {
+    var value = input.trim();
+    if (!value) {
+        throw new Error("Enter a robot IP address or hostname.");
+    }
+    var candidate = value;
+    if (/^https?:\/\//i.test(candidate)) {
+        candidate = candidate.replace(/^http/i, "ws");
+    }
+    else if (!/^wss?:\/\//i.test(candidate)) {
+        candidate = "ws://".concat(candidate);
+    }
+    var url;
+    try {
+        url = new URL(candidate);
+    }
+    catch (_a) {
+        throw new Error("Enter a valid IP address or hostname.");
+    }
+    if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+        throw new Error("The connection must use ws:// or wss://.");
+    }
+    if (!url.hostname || url.username || url.password) {
+        throw new Error("Enter a valid robot IP address or hostname.");
+    }
+    if (!isLocalWifiHostname(url.hostname)) {
+        throw new Error("Wi-Fi connections must use a local-network address.");
+    }
+    url.pathname = WEBSOCKET_PATHS[raftType];
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+};
+export var getWifiPathForRaftType = function (raftType) {
+    return WEBSOCKET_PATHS[raftType];
+};

package/dist-types/src/wrapper-app/WrapperAppManager.d.ts

@@ -1,6 +1,6 @@
 import { RaftInfoEvents } from "../types/events/raft-info";
 import type { RestMessageOptions } from "../types/communication-between-apps/wrapper-communication";
-import { ConnectionAttemptResults, RaftConnectionMethod } from "../types/raft";
+import { ConnectableRaftType, ConnectionAttemptResults, RaftConnectionMethod } from "../types/raft";
 import Connector from "./connectors/Connector";
 import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
 import { RICLedLcdColours } from "@robotical/roboticaljs";
@@ -27,6 +27,7 @@ export declare class WrapperAppManager {
     *
     */
     connect(method: RaftConnectionMethod, uuids: string[]): Promise<ConnectionAttemptResults>;
+    connect(method: RaftConnectionMethod, locator: string, uuids: string[], expectedRaftType?: ConnectableRaftType): Promise<ConnectionAttemptResults>;
     private _connect;
     /**
      * Gets user's device info
@@ -73,7 +74,7 @@ export declare class WrapperAppManager {
     disconnect(raftId: string): Promise<boolean>;
     /**
      * Best-effort terminal cleanup. Page lifecycle events cannot reliably await
-     * async Bluetooth work, so each connector forwards to RaftJS synchronously.
+     * async transport work, so each connector forwards to RaftJS synchronously.
      */
     disconnectAllForPageUnload(): void;
     private _disconnectConnManagerForPageUnload;

package/dist-types/src/wrapper-app/WrapperAppManager.js

@@ -44,6 +44,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { WrapperSentMessage } from "../types/communication-between-apps/wrapper-communication";
+import { RaftConnectionMethod, } from "../types/raft";
 import Logger from "../services/logger/Logger";
 import { RaftConnEvent } from "@robdobsn/raftjs";
 import { ConnManager } from "@robotical/roboticaljs";
@@ -52,6 +53,7 @@ import ColourSensorManualCalibratorMarty from "./utils/ColourSensorManualCalibra
 import { getBrowserVersion, getOrGenerateDeviceId, getOSName, isTablet } from "./utils/device-info";
 var SHOW_LOGS = true;
 var TAG = "WrapperAppManager";
+var WEBSOCKET_CONNECT_TIMEOUT_MS = 20000;
 var WrapperAppManager = /** @class */ (function () {
     function WrapperAppManager() {
         // Connectors 
@@ -69,16 +71,11 @@ var WrapperAppManager = /** @class */ (function () {
     WrapperAppManager.prototype.getConnector = function (raftId) {
         return this.connectors[raftId];
     };
-    /**
-    * Connect to a RAFT
-    *
-    * @param {string} method - can be "WebBLE" or "WebSocket"
-    * @param {string | object} locator - either a string (WebSocket URL) or an object (WebBLE)
-    * @returns Promise<ConnectionAttemptResults>
-    *
-    */
-    WrapperAppManager.prototype.connect = function (method, uuids) {
+    WrapperAppManager.prototype.connect = function (method, locatorOrUuids, requestUuids, expectedRaftType) {
         var _this = this;
+        if (requestUuids === void 0) { requestUuids = []; }
+        var locator = Array.isArray(locatorOrUuids) ? "" : locatorOrUuids;
+        var uuids = Array.isArray(locatorOrUuids) ? locatorOrUuids : requestUuids;
         if (this._pageUnloadStarted) {
             return Promise.resolve({ success: false, reason: "failed" });
         }
@@ -86,10 +83,10 @@ var WrapperAppManager = /** @class */ (function () {
             return this._connectPromise;
         }
         if (Object.values(this._disconnectOperations).some(Boolean)) {
-            Logger.warn(SHOW_LOGS, TAG, "Refusing to start a connection while Bluetooth teardown is in progress");
+            Logger.warn(SHOW_LOGS, TAG, "Refusing to start a connection while device teardown is in progress");
             return Promise.resolve({ success: false, reason: "failed" });
         }
-        var connectPromise = this._connect(method, uuids);
+        var connectPromise = this._connect(method, locator, uuids, expectedRaftType);
         this._connectPromise = connectPromise;
         var clearConnectPromise = function () {
             if (_this._connectPromise === connectPromise) {
@@ -99,9 +96,9 @@ var WrapperAppManager = /** @class */ (function () {
         void connectPromise.then(clearConnectPromise, clearConnectPromise);
         return connectPromise;
     };
-    WrapperAppManager.prototype._connect = function (method, uuids) {
+    WrapperAppManager.prototype._connect = function (method, locator, uuids, expectedRaftType) {
         return __awaiter(this, void 0, void 0, function () {
-            var connector, pendingConnManager, committed, disconnectedBeforeCommit, ownedConnector_1, connectionResults, existingConnector, raftSystemUtils, systemInfo, raftName, error_1;
+            var connector, pendingConnManager, committed, disconnectedBeforeCommit, websocketTimedOut, websocketDeadline, connectorPromise, timeoutHandle_1, didTimeOut_1, timeoutPromise, ownedConnector_1, connectorConnectionPromise, connectionResults, setupTimeoutHandle_1, setupTimeout, setupResult, existingConnector, raftSystemUtils, systemInfo, raftName, error_1;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -110,22 +107,89 @@ var WrapperAppManager = /** @class */ (function () {
                         pendingConnManager = null;
                         committed = false;
                         disconnectedBeforeCommit = false;
+                        websocketTimedOut = false;
+                        websocketDeadline = method === RaftConnectionMethod.WEB_SOCKET
+                            ? Date.now() + WEBSOCKET_CONNECT_TIMEOUT_MS
+                            : null;
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, , 4, 11]);
-                        return [4 /*yield*/, ConnectorFactory.connectToRaftHelper(method, uuids, function (connManager) {
-                                pendingConnManager = connManager;
-                                _this._pendingConnManagers.add(connManager);
-                                if (_this._pageUnloadStarted) {
-                                    _this._disconnectConnManagerForPageUnload(connManager);
+                        _a.trys.push([1, , 16, 23]);
+                        connectorPromise = ConnectorFactory.connectToRaftHelper(method, locator, uuids, function (connManager) {
+                            pendingConnManager = connManager;
+                            _this._pendingConnManagers.add(connManager);
+                            if (_this._pageUnloadStarted) {
+                                _this._disconnectConnManagerForPageUnload(connManager);
+                            }
+                        });
+                        if (!(method === RaftConnectionMethod.WEB_SOCKET)) return [3 /*break*/, 6];
+                        didTimeOut_1 = false;
+                        timeoutPromise = new Promise(function (resolve) {
+                            timeoutHandle_1 = setTimeout(function () {
+                                didTimeOut_1 = true;
+                                websocketTimedOut = true;
+                                if (pendingConnManager) {
+                                    _this._disconnectConnManagerForPageUnload(pendingConnManager);
                                 }
-                            })];
+                                resolve(null);
+                            }, Math.max(0, (websocketDeadline || Date.now()) - Date.now()));
+                        });
+                        _a.label = 2;
                     case 2:
+                        _a.trys.push([2, , 4, 5]);
+                        return [4 /*yield*/, Promise.race([connectorPromise, timeoutPromise])];
+                    case 3:
                         connector = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        if (timeoutHandle_1) {
+                            clearTimeout(timeoutHandle_1);
+                        }
+                        return [7 /*endfinally*/];
+                    case 5:
+                        if (didTimeOut_1) {
+                            // A channel can settle after its transport has been closed.
+                            // ConnectorFactory still owns it until it returns; if it
+                            // nevertheless creates a Connector, release that late owner.
+                            void connectorPromise.then(function (lateConnector) { return __awaiter(_this, void 0, void 0, function () {
+                                var error_2;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (!lateConnector) return [3 /*break*/, 4];
+                                            _a.label = 1;
+                                        case 1:
+                                            _a.trys.push([1, 3, , 4]);
+                                            return [4 /*yield*/, lateConnector.disconnect()];
+                                        case 2:
+                                            _a.sent();
+                                            return [3 /*break*/, 4];
+                                        case 3:
+                                            error_2 = _a.sent();
+                                            Logger.warn(SHOW_LOGS, TAG, "Failed late WebSocket cleanup: ".concat(error_2));
+                                            return [3 /*break*/, 4];
+                                        case 4: return [2 /*return*/];
+                                    }
+                                });
+                            }); }).catch(function (error) {
+                                Logger.warn(SHOW_LOGS, TAG, "WebSocket connection settled after timeout: ".concat(error));
+                            });
+                            Logger.warn(SHOW_LOGS, TAG, "WebSocket connection timed out after ".concat(WEBSOCKET_CONNECT_TIMEOUT_MS, "ms"));
+                            return [2 /*return*/, { success: false, reason: "failed" }];
+                        }
+                        return [3 /*break*/, 8];
+                    case 6: return [4 /*yield*/, connectorPromise];
+                    case 7:
+                        connector = _a.sent();
+                        _a.label = 8;
+                    case 8:
                         if (!connector || this._pageUnloadStarted) {
                             Logger.warn(SHOW_LOGS, TAG, "Failed to connect to RAFT with method: ".concat(method));
                             return [2 /*return*/, { success: false, reason: "failed" }];
                         }
+                        if (expectedRaftType && connector.type !== expectedRaftType) {
+                            Logger.warn(SHOW_LOGS, TAG, "Connected RAFT type ".concat(connector.type, " did not match expected type ").concat(expectedRaftType));
+                            return [2 /*return*/, { success: false, reason: "invalid_raft_type" }];
+                        }
                         ownedConnector_1 = connector;
                         connector.setOnDisconnected(function () {
                             if (!committed) {
@@ -136,9 +200,47 @@ var WrapperAppManager = /** @class */ (function () {
                         if (disconnectedBeforeCommit || !connector.connManager.isConnected()) {
                             return [2 /*return*/, { success: false, reason: "failed" }];
                         }
-                        return [4 /*yield*/, connector.connect()];
-                    case 3:
+                        connectorConnectionPromise = connector.connect();
+                        connectionResults = void 0;
+                        if (!(websocketDeadline !== null)) return [3 /*break*/, 13];
+                        setupTimeout = new Promise(function (resolve) {
+                            setupTimeoutHandle_1 = setTimeout(function () {
+                                websocketTimedOut = true;
+                                connector === null || connector === void 0 ? void 0 : connector.disconnectForPageUnload();
+                                resolve(null);
+                            }, Math.max(0, websocketDeadline - Date.now()));
+                        });
+                        setupResult = void 0;
+                        _a.label = 9;
+                    case 9:
+                        _a.trys.push([9, , 11, 12]);
+                        return [4 /*yield*/, Promise.race([
+                                connectorConnectionPromise,
+                                setupTimeout,
+                            ])];
+                    case 10:
+                        setupResult = _a.sent();
+                        return [3 /*break*/, 12];
+                    case 11:
+                        if (setupTimeoutHandle_1) {
+                            clearTimeout(setupTimeoutHandle_1);
+                        }
+                        return [7 /*endfinally*/];
+                    case 12:
+                        if (!setupResult) {
+                            void connectorConnectionPromise.catch(function (error) {
+                                Logger.warn(SHOW_LOGS, TAG, "WebSocket setup settled after timeout: ".concat(error));
+                            });
+                            Logger.warn(SHOW_LOGS, TAG, "WebSocket setup timed out after ".concat(WEBSOCKET_CONNECT_TIMEOUT_MS, "ms"));
+                            return [2 /*return*/, { success: false, reason: "failed" }];
+                        }
+                        connectionResults = setupResult;
+                        return [3 /*break*/, 15];
+                    case 13: return [4 /*yield*/, connectorConnectionPromise];
+                    case 14:
                         connectionResults = _a.sent();
+                        _a.label = 15;
+                    case 15:
                         if (!connectionResults.success) {
                             Logger.warn(SHOW_LOGS, TAG, "Failed to connect to RAFT with id: ".concat(connector.id, " and type: ").concat(connector.type));
                             return [2 /*return*/, connectionResults];
@@ -170,28 +272,30 @@ var WrapperAppManager = /** @class */ (function () {
                         committed = true;
                         Logger.info(SHOW_LOGS, TAG, "Connected to RAFT with id: ".concat(connector.id, " and type: ").concat(connector.type));
                         return [2 /*return*/, connectionResults];
-                    case 4:
-                        _a.trys.push([4, , 9, 10]);
-                        if (!(connector && !committed)) return [3 /*break*/, 8];
-                        _a.label = 5;
-                    case 5:
-                        _a.trys.push([5, 7, , 8]);
+                    case 16:
+                        _a.trys.push([16, , 21, 22]);
+                        if (!(connector && !committed)) return [3 /*break*/, 20];
+                        if (!websocketTimedOut) return [3 /*break*/, 17];
+                        connector.disconnectForPageUnload();
+                        return [3 /*break*/, 20];
+                    case 17:
+                        _a.trys.push([17, 19, , 20]);
                         return [4 /*yield*/, connector.disconnect()];
-                    case 6:
+                    case 18:
                         _a.sent();
-                        return [3 /*break*/, 8];
-                    case 7:
+                        return [3 /*break*/, 20];
+                    case 19:
                         error_1 = _a.sent();
                         Logger.warn(SHOW_LOGS, TAG, "Failed to clean up uncommitted connector ".concat(connector.id, ": ").concat(error_1));
-                        return [3 /*break*/, 8];
-                    case 8: return [3 /*break*/, 10];
-                    case 9:
+                        return [3 /*break*/, 20];
+                    case 20: return [3 /*break*/, 22];
+                    case 21:
                         if (pendingConnManager) {
                             this._pendingConnManagers.delete(pendingConnManager);
                         }
                         return [7 /*endfinally*/];
-                    case 10: return [7 /*endfinally*/];
-                    case 11: return [2 /*return*/];
+                    case 22: return [7 /*endfinally*/];
+                    case 23: return [2 /*return*/];
                 }
             });
         });
@@ -402,7 +506,7 @@ var WrapperAppManager = /** @class */ (function () {
     };
     /**
      * Best-effort terminal cleanup. Page lifecycle events cannot reliably await
-     * async Bluetooth work, so each connector forwards to RaftJS synchronously.
+     * async transport work, so each connector forwards to RaftJS synchronously.
      */
     WrapperAppManager.prototype.disconnectAllForPageUnload = function () {
         this._pageUnloadStarted = true;
@@ -490,7 +594,7 @@ var WrapperAppManager = /** @class */ (function () {
      */
     WrapperAppManager.prototype.scanForPotentialWarrantyDevice = function (existingDevices) {
         return __awaiter(this, void 0, void 0, function () {
-            var namesToIgnore, warrantyConnManager, ownsTemporaryConnection, device_1, isConnected, connector, ricSystem, systemInfo, serialNumber, raftType, newDevice, error_2, error_3;
+            var namesToIgnore, warrantyConnManager, ownsTemporaryConnection, device_1, isConnected, connector, ricSystem, systemInfo, serialNumber, raftType, newDevice, error_3, error_4;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -543,8 +647,8 @@ var WrapperAppManager = /** @class */ (function () {
                         _a.label = 6;
                     case 6: return [3 /*break*/, 14];
                     case 7:
-                        error_2 = _a.sent();
-                        Logger.error(SHOW_LOGS, TAG, JSON.stringify(error_2));
+                        error_3 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, JSON.stringify(error_3));
                         return [2 /*return*/, existingDevices];
                     case 8:
                         if (!ownsTemporaryConnection) return [3 /*break*/, 13];
@@ -556,8 +660,8 @@ var WrapperAppManager = /** @class */ (function () {
                         _a.sent();
                         return [3 /*break*/, 13];
                     case 11:
-                        error_3 = _a.sent();
-                        Logger.warn(SHOW_LOGS, TAG, "Failed warranty connection cleanup: ".concat(error_3));
+                        error_4 = _a.sent();
+                        Logger.warn(SHOW_LOGS, TAG, "Failed warranty connection cleanup: ".concat(error_4));
                         return [3 /*break*/, 13];
                     case 12:
                         this._pendingConnManagers.delete(warrantyConnManager);
@@ -573,7 +677,7 @@ var WrapperAppManager = /** @class */ (function () {
      */
     WrapperAppManager.prototype.sendAtomicReadOperationToMarty = function (raftId) {
         return __awaiter(this, void 0, void 0, function () {
-            var raftConnector, systemType, error_4;
+            var raftConnector, systemType, error_5;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -589,8 +693,8 @@ var WrapperAppManager = /** @class */ (function () {
                         _a.sent();
                         return [2 /*return*/, true];
                     case 3:
-                        error_4 = _a.sent();
-                        Logger.error(SHOW_LOGS, TAG, "Failed to send atomic read operation to Marty: ".concat(error_4));
+                        error_5 = _a.sent();
+                        Logger.error(SHOW_LOGS, TAG, "Failed to send atomic read operation to Marty: ".concat(error_5));
                         return [3 /*break*/, 4];
                     case 4: return [3 /*break*/, 6];
                     case 5:

package/dist-types/src/wrapper-app/communicators/WebAppCommunicator.js

@@ -155,7 +155,7 @@ var receivedMessageHandler = function (receivedMessage, data, messagePromiseId)
                 return [3 /*break*/, 55];
             case 2:
                 _b.trys.push([2, 4, , 5]);
-                return [4 /*yield*/, wrapperAppManager.connect(data.method, data.uuids)];
+                return [4 /*yield*/, wrapperAppManager.connect(data.method, data.locator, data.uuids, data.expectedRaftType)];
             case 3:
                 connectionResults = _b.sent();
                 window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: connectionResults, messagePromiseId: messagePromiseId });

package/dist-types/src/wrapper-app/connectors/ConnectorFactory.d.ts

@@ -11,5 +11,6 @@ export default class ConnectorFactory {
      *
      */
     static connectToRaftHelper(method: RaftConnectionMethod, uuids: string[], onConnManagerCreated?: (connManager: ConnManager) => void): Promise<Connector | null>;
+    static connectToRaftHelper(method: RaftConnectionMethod, locator: string, uuids: string[], onConnManagerCreated?: (connManager: ConnManager) => void): Promise<Connector | null>;
     static createConnector(raftType: string | undefined, connManager: ConnManager, connectionMethod: RaftConnectionMethod): Connector;
 }

package/dist-types/src/wrapper-app/connectors/ConnectorFactory.js

@@ -44,20 +44,24 @@ var TAG = "ConnectorFactory";
 var ConnectorFactory = /** @class */ (function () {
     function ConnectorFactory() {
     }
-    /**
-     * Connect to a RAFT
-     *
-     * @param {string} method - can be "WebBLE" or "WebSocket"
-     * @param {string | object} locator - either a string (WebSocket URL) or an object (WebBLE)
-     * @returns Promise<ConnectionAttemptResults>
-     *
-     */
-    ConnectorFactory.connectToRaftHelper = function (method, uuids, onConnManagerCreated) {
+    ConnectorFactory.connectToRaftHelper = function (method, locatorOrUuids, requestUuidsOrCallback, requestCallback) {
         return __awaiter(this, void 0, void 0, function () {
-            var connManager, connectorWasCreated, lowLevelConnectionSucceeded, connectionResult, systemInfo, raftType, connector, error_1;
+            var usesLegacySignature, locator, uuids, onConnManagerCreated, connManager, connectorWasCreated, lowLevelConnectionSucceeded, connectionResult, systemInfo, raftType, connector, error_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        usesLegacySignature = Array.isArray(locatorOrUuids);
+                        locator = usesLegacySignature ? "" : locatorOrUuids;
+                        uuids = usesLegacySignature
+                            ? locatorOrUuids
+                            : Array.isArray(requestUuidsOrCallback)
+                                ? requestUuidsOrCallback
+                                : [];
+                        onConnManagerCreated = usesLegacySignature
+                            ? typeof requestUuidsOrCallback === "function"
+                                ? requestUuidsOrCallback
+                                : undefined
+                            : requestCallback;
                         connManager = new ConnManager();
                         connectorWasCreated = false;
                         lowLevelConnectionSucceeded = false;
@@ -66,7 +70,7 @@ var ConnectorFactory = /** @class */ (function () {
                         _a.trys.push([1, , 3, 8]);
                         onConnManagerCreated === null || onConnManagerCreated === void 0 ? void 0 : onConnManagerCreated(connManager);
                         Logger.info(SHOW_LOGS, TAG, "Connecting to RAFT with method: ".concat(method));
-                        return [4 /*yield*/, connManager.connectDetailed(method, "", uuids)];
+                        return [4 /*yield*/, connManager.connectDetailed(method, locator, uuids)];
                     case 2:
                         connectionResult = _a.sent();
                         lowLevelConnectionSucceeded = connectionResult.status === "success";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robotical/webapp-types",
-  "version": "3.18.13",
+  "version": "3.19.1",
   "description": "Type definitions for the Application Manager",
   "main": "dist/application-manager.d.ts",
   "types": "dist/application-manager.d.ts",