@rhizomatics/signalk-einklabel-plugin 1.3.0-beta6 → 1.3.0-beta8

package/dist/devices/bleBackend.js

@@ -168,6 +168,8 @@ async function ensureDeviceVisible(bleApi, pluginId, address, timeoutMs) {
         throw new Error(`device ${address} isn't visible to the SignalK BLE Manager yet (out of range, asleep, or never seen) after waiting ${timeoutMs}ms`);
     }
 }
+/** Upper bound on how long a timed-out `bleApi.connectGATT()` is given to settle server-side before a retry - see `bleApiBackend`. */
+const CONNECT_SETTLE_GRACE_MS = 30000;
 let bleManagerQueue = Promise.resolve();
 /**
  * Runs `fn` only once every earlier caller has finished, so paints to different devices never hold
@@ -205,11 +207,24 @@ function bleApiBackend(bleApi, pluginId) {
                 // whatever the claim currently is, connected or still connecting, regardless of how the
                 // original `connectGATT()` promise eventually settles - disconnecting it too if it does still
                 // resolve afterwards, harmlessly, since a connection the server already released is a no-op to
-                // disconnect again.
-                void bleApi
-                    .releaseGATTDevice(address, pluginId)
-                    .catch(() => { })
-                    .then(() => connecting.then((c) => c.disconnect()).catch(() => { }));
+                // disconnect again. The release is awaited (only the late disconnect is left in the
+                // background) so a caller retrying straight away - `withRetries` - can't race it with a new
+                // `connectGATT()` and get rejected with "has a GATT claim in progress" for its trouble.
+                await bleApi.releaseGATTDevice(address, pluginId).catch(() => { });
+                // ...except a claim still *connecting* isn't in the server's claim table yet, only its pending
+                // set, which `releaseGATTDevice` doesn't touch - so while the server's own connect is still in
+                // flight, a retry's `connectGATT()` is rejected outright with "has a GATT claim in progress".
+                // Give that connect a bounded chance to settle first, so the retry gets a clean slate.
+                const late = await Promise.race([
+                    connecting.catch(() => undefined),
+                    (0, bleDiscovery_1.sleep)(Math.min(timeoutMs, CONNECT_SETTLE_GRACE_MS)).then(() => undefined),
+                ]);
+                if (late) {
+                    await Promise.allSettled([bleApi.releaseGATTDevice(address, pluginId), late.disconnect()]);
+                }
+                else {
+                    void connecting.then((c) => c.disconnect()).catch(() => { });
+                }
                 throw new Error(`connecting to device timed out after ${timeoutMs}ms`);
             }
             return withSessionWatchdog(conn, GATT_SESSION_WATCHDOG_MS, async () => {

package/dist/devices/bleDiscovery.d.ts

@@ -34,9 +34,16 @@ export declare function forEachAdvertisedDevice(adapter: Adapter, fn: (advertise
 /**
  * Retries `fn` up to `attempts` times (including the first try), returning on the first success -
  * shared by the repaint scheduler and the CLI's `paint` command so one flaky BLE connection
- * doesn't fail a whole repaint after a single bad attempt.
+ * doesn't fail a whole repaint after a single bad attempt. `delayMs` pauses between attempts, giving
+ * the adapter (and any BLE Manager claim the failed attempt held) a moment to settle rather than
+ * hitting the device again in the same tick. `onError` sees every failed attempt's error, not just the
+ * last one that's eventually thrown - an early attempt's error is often the real cause, with later
+ * ones just fallout from it.
  */
-export declare function withRetries<T>(attempts: number, fn: (attempt: number) => Promise<T>): Promise<T>;
+export declare function withRetries<T>(attempts: number, fn: (attempt: number) => Promise<T>, { delayMs, onError }?: {
+    delayMs?: number;
+    onError?: (err: unknown, attempt: number) => void;
+}): Promise<T>;
 /**
  * Opens exactly one BLE discovery window and one D-Bus/BlueZ session, then hands the adapter to
  * `fn` - shared by `plugin.ts`'s startup scan and the CLI's `scan` command so scanning across

package/dist/devices/bleDiscovery.js

@@ -68,16 +68,25 @@ async function forEachAdvertisedDevice(adapter, fn) {
 /**
  * Retries `fn` up to `attempts` times (including the first try), returning on the first success -
  * shared by the repaint scheduler and the CLI's `paint` command so one flaky BLE connection
- * doesn't fail a whole repaint after a single bad attempt.
+ * doesn't fail a whole repaint after a single bad attempt. `delayMs` pauses between attempts, giving
+ * the adapter (and any BLE Manager claim the failed attempt held) a moment to settle rather than
+ * hitting the device again in the same tick. `onError` sees every failed attempt's error, not just the
+ * last one that's eventually thrown - an early attempt's error is often the real cause, with later
+ * ones just fallout from it.
  */
-async function withRetries(attempts, fn) {
+async function withRetries(attempts, fn, { delayMs = 0, onError } = {}) {
+    const total = Math.max(1, attempts);
     let lastErr;
-    for (let attempt = 1; attempt <= Math.max(1, attempts); attempt++) {
+    for (let attempt = 1; attempt <= total; attempt++) {
         try {
             return await fn(attempt);
         }
         catch (err) {
             lastErr = err;
+            onError?.(err, attempt);
+            if (attempt < total && delayMs > 0) {
+                await sleep(delayMs);
+            }
         }
     }
     throw lastErr;

package/dist/devices/gicisky/index.js

@@ -53,19 +53,23 @@ class GiciskyDriver {
          */
         const manufacturerData = await backend.waitForManufacturerData(config.address, protocol_1.GICISKY_MANUFACTURER_ID, MANUFACTURER_DATA_RESCAN_TIMEOUT_MS);
         const info = manufacturerData ? (0, protocol_1.decodeAdvertisedInfo)(manufacturerData) : undefined;
+        // A device that's quiet right now (e.g. still refreshing from the last paint) can still be painted
+        // when its PID is already known from config/a previous scan - the connect below doesn't need the
+        // advertisement, only this lookup does.
+        const pid = info?.deviceId ?? config.pid;
         const metadata = config.modelOverride
-            ? { pid: info?.deviceId ?? 0, ...config.modelOverride }
-            : info
-                ? this.metadataForPid(info.deviceId)
+            ? { pid: pid ?? 0, ...config.modelOverride }
+            : pid !== undefined
+                ? this.metadataForPid(pid)
                 : undefined;
         if (!metadata) {
-            throw new Error(info === undefined
+            throw new Error(pid === undefined
                 ? "gicisky device isn't advertising - rescanned but got nothing back (out of range, asleep, or already connected " +
                     "elsewhere) - pass --width/--height/--voffset/--colours to describe it manually"
-                : `gicisky device reports unrecognised deviceId 0x${info.deviceId.toString(16).padStart(4, "0")} - ` +
+                : `gicisky device reports unrecognised deviceId 0x${pid.toString(16).padStart(4, "0")} - ` +
                     "pass --width/--height/--voffset/--colours to describe it manually");
         }
-        const layout = (info && layout_1.GICISKY_PID_LAYOUT[info.deviceId]) || (0, layout_1.defaultLayoutFor)(metadata.colours);
+        const layout = (pid !== undefined && layout_1.GICISKY_PID_LAYOUT[pid]) || (0, layout_1.defaultLayoutFor)(metadata.colours);
         const framed = (0, reframe_1.reframeBitmap)(bitmap, metadata.width, metadata.height, config.reframe ?? "crop");
         const payload = (0, encode_1.encodeBitmap)(framed, metadata, layout);
         const conn = await backend.connectGatt(config.address, config.connectTimeoutMs ?? DEFAULT_PAINT_CONNECT_TIMEOUT_MS);
@@ -89,6 +93,12 @@ class GiciskyDriver {
                     const chunk = payload.subarray(part * chunkSize, Math.min(part * chunkSize + chunkSize, payload.length));
                     const ackData = await writeAndAwaitAck(conn, imgServiceUuid, imgUuid, (0, protocol_1.imageChunkPacket)(part, chunk), ack);
                     const decoded = (0, protocol_1.decodeTransferAck)(ackData);
+                    if (decoded && !decoded.ok && part * chunkSize + chunk.length >= payload.length) {
+                        // The device answers the final chunk with a non-zero status (seen: `05 08 00000000`) once
+                        // it has the whole image and starts refreshing - the transfer's done, not failed. Matches
+                        // hass-gicisky's writer, which ends the transfer on any non-zero status rather than erroring.
+                        break;
+                    }
                     if (!decoded?.ok) {
                         throw new Error(`gicisky device reported an error transferring image part ${part}: ${ackData.toString("hex")}`);
                     }

package/dist/devices/types.d.ts

@@ -53,6 +53,13 @@ export type DeviceModelOverride = Omit<DeviceMetadata, "pid">;
 /** Per-device settings the user supplies when registering a device, beyond what's in DeviceMetadata. */
 export interface VendorDeviceConfig {
     address: string;
+    /**
+     * The PID already known for this device (from the configured `"<vendor>:<pid>@<address>"` or a
+     * previous scan) - a fallback for drivers that otherwise only learn it from a fresh advertisement
+     * (gicisky), so a device that's quiet at paint time can still be painted. A live advertised PID
+     * takes precedence when there is one.
+     */
+    pid?: number;
     /** AES key for vendors that need it, entered by the user. If omitted, vendors that have one may fall back to a stock/manufacturer-default key instead of failing. */
     aesKey?: string;
     /** Forces the device model facts instead of looking up the advertised PID - for hardware not yet in the driver's table. */

package/dist/repaintScheduler.js

@@ -23,6 +23,8 @@ const pluginVersion_1 = require("./pluginVersion");
 const httpJson_1 = require("./httpJson");
 const INTERVAL_POLL_MS = 60000;
 const SUBSCRIPTION_DEBOUNCE_MS = 2000;
+/** Pause between paint attempts - see `withRetries`' `delayMs`. */
+const PAINT_RETRY_DELAY_MS = 5000;
 const RESOURCES_API_PATH = "/signalk/v2/api/resources";
 /**
  * The most recent wall-clock instant at or before `now` that an `interval`-triggered device's own
@@ -346,13 +348,22 @@ async function considerRepaint(app, config, device, target, state, getApiUrl) {
     }
     const connectTimeoutMs = config.paintConnectTimeoutSeconds * 1000;
     const gattBackend = config.useBleApi && app.bleApi ? (0, bleBackend_1.bleApiBackend)(app.bleApi, pluginVersion_1.PLUGIN_NAME) : undefined;
-    const paintWithRetries = () => (0, bleDiscovery_1.withRetries)(config.paintRetries, async (attempt) => {
-        if (attempt > 1) {
-            app.debug(`${label}: attempting paint ${attempt}/${config.paintRetries}`);
-        }
+    const attempts = Math.max(1, config.paintRetries);
+    const paintWithRetries = () => (0, bleDiscovery_1.withRetries)(attempts, async (attempt) => {
+        app.debug(`${label}: attempting paint ${attempt}/${attempts}`);
         const startedAt = Date.now();
-        await driver.paint(bitmap, { address, aesKey: device.aesKey, connectTimeoutMs, reframe: device.reframe, gattBackend });
+        await driver.paint(bitmap, {
+            address,
+            pid: target.pid,
+            aesKey: device.aesKey,
+            connectTimeoutMs,
+            reframe: device.reframe,
+            gattBackend,
+        });
         paintDurationMs = Date.now() - startedAt;
+    }, {
+        delayMs: PAINT_RETRY_DELAY_MS,
+        onError: (err, attempt) => app.debug(`${label}: paint attempt ${attempt}/${attempts} failed: ${err.message}`),
     });
     await (gattBackend ? (0, bleBackend_1.exclusiveBleManagerAccess)(paintWithRetries) : paintWithRetries());
     (0, discoveredDevicesStore_1.touchDiscoveredDevice)(app, { address, vendor: target.vendor, pid: target.pid, hwVersion: target.hwVersion, metadata });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhizomatics/signalk-einklabel-plugin",
-  "version": "1.3.0-beta6",
+  "version": "1.3.0-beta8",
   "description": "Display SignalK data on eInk Electronic Shelf Labels, includes working examples for tide clock and watch schedule.",
   "keywords": [
     "ble",
@@ -75,7 +75,7 @@
     "typescript": "^5.5.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "signalk": {
     "displayName": "eInk Label Displays",