@aurora-blue/signalk-connector 0.2.0-dev.20 → 0.2.0-dev.22

package/README.md

@@ -49,7 +49,7 @@ Configure the plugin in the Signal K administration interface:
 
 Select Aurora Blue ABOARD Connector Status under Signal K Webapps for the cross-version runtime view. The page refreshes every five seconds and reads a plugin-local endpoint governed by the Signal K server's access controls. The response omits device identity and credentials, and the page does not send data to another host.
 
-The connector exchanges the pairing code once and clears it from the Signal K plugin configuration after successful pairing. The returned device token is stored only in the protected connector state file and is never written to logs.
+The connector exchanges the pairing code once and clears it from the Signal K plugin configuration after successful pairing. The returned device token is stored only in the protected connector state file and is never written to logs. The pairing is bound to the configured target URL. Changing that URL requires a new pairing code and pauses collection and transfer until the replacement pairing succeeds. The configuration and status page warn that a successful replacement permanently discards telemetry buffered for the previous server. A failed pairing attempt retains the existing pairing and buffer.
 
 The default configuration sends up to 250 events per batch, waits up to five seconds to combine normal telemetry, samples selected own-vessel Signal K paths every second, samples selected AIS paths every five seconds, and enables the preliminary underway change-or-heartbeat profile. AIS can be disabled independently. The `auto` storage profile selects a constrained, standard, or extended byte budget from filesystem capacity while preserving a free-space reserve. Its effective event limit is derived from measured journal bytes per event instead of a fixed 10,000-event default. Protocol 1.1 permits no more than 500 events per batch, and the server continues to accept exact protocol 1.0 backlog batches during upgrades.
 

package/VERSION

@@ -1 +1 @@
-0.2.0-dev.20
+0.2.0-dev.22

package/dist/src/config.d.ts

@@ -35,7 +35,7 @@ export declare const pluginSchema: {
         readonly targetUrl: {
             readonly type: "string";
             readonly title: "Aurora Blue target URL";
-            readonly description: "Base URL of Aurora Blue Server or Aurora Blue Cloud. [Open connector status](/aurora-blue-signalk-connector/).";
+            readonly description: "Base URL of Aurora Blue ABOARD Server or Aurora Blue ABOARD Cloud. Changing this address requires a new pairing code. [Open connector status](/@aurora-blue/signalk-connector/).";
         };
         readonly deviceName: {
             readonly type: "string";
@@ -45,7 +45,7 @@ export declare const pluginSchema: {
         readonly pairingCode: {
             readonly type: "string";
             readonly title: "Pairing code";
-            readonly description: "Short-lived code from Aurora Blue. Cleared after successful pairing.";
+            readonly description: "Short-lived code from Aurora Blue ABOARD. Entering a code while already paired changes the server pairing. After the new code is accepted, all data buffered for the previous pairing is permanently discarded. The code is cleared after successful pairing.";
         };
         readonly allowInsecureHttp: {
             readonly type: "boolean";

package/dist/src/config.js

@@ -154,7 +154,7 @@ exports.pluginSchema = {
         targetUrl: {
             type: "string",
             title: "Aurora Blue target URL",
-            description: "Base URL of Aurora Blue Server or Aurora Blue Cloud. [Open connector status](/aurora-blue-signalk-connector/).",
+            description: "Base URL of Aurora Blue ABOARD Server or Aurora Blue ABOARD Cloud. Changing this address requires a new pairing code. [Open connector status](/@aurora-blue/signalk-connector/).",
         },
         deviceName: {
             type: "string",
@@ -164,7 +164,7 @@ exports.pluginSchema = {
         pairingCode: {
             type: "string",
             title: "Pairing code",
-            description: "Short-lived code from Aurora Blue. Cleared after successful pairing.",
+            description: "Short-lived code from Aurora Blue ABOARD. Entering a code while already paired changes the server pairing. After the new code is accepted, all data buffered for the previous pairing is permanently discarded. The code is cleared after successful pairing.",
         },
         allowInsecureHttp: {
             type: "boolean",

package/dist/src/connector.d.ts

@@ -29,6 +29,7 @@ export declare class ConnectorRuntime {
     private droppedEvents;
     private suppressedEvents;
     private transferNotice;
+    private pairingState;
     private operatingMode;
     private runtimeConfigurationPollMs;
     private runtimeConfigurationState;
@@ -60,6 +61,7 @@ export declare class ConnectorRuntime {
     private schedule;
     private scheduleRuntimeConfigurationPoll;
     private pollRuntimeConfiguration;
+    private requirePairing;
     private applyRuntimeConfiguration;
     private updateStatus;
     private storageBudgetPolicy;

package/dist/src/connector.js

@@ -39,6 +39,7 @@ class ConnectorRuntime {
     droppedEvents = 0;
     suppressedEvents = 0;
     transferNotice = null;
+    pairingState = "unpaired";
     operatingMode = "active";
     runtimeConfigurationPollMs = 60_000;
     runtimeConfigurationState = "cached";
@@ -77,15 +78,53 @@ class ConnectorRuntime {
             ? this.config.compressionThresholdBytes
             : null);
         let state = await this.store.summary();
-        if (state.device_id === null && this.config.pairingCode !== undefined) {
+        if (this.config.pairingCode !== undefined) {
             const pairing = await this.client.pair(this.config.pairingCode, this.config.deviceName, version_1.CONNECTOR_VERSION);
-            await this.store.setPairing(pairing);
+            if (state.device_id === null && state.bufferedEvents === 0) {
+                await this.store.setPairing(pairing, this.config.targetUrl);
+            }
+            else {
+                await this.store.replacePairing(pairing, this.config.targetUrl);
+            }
             state = await this.store.summary();
         }
         if (state.device_id === null) {
+            this.pairingState = "unpaired";
             this.app.setPluginStatus("Unpaired - enter an Aurora Blue pairing code in plugin settings.");
             return;
         }
+        if (state.target_url !== null &&
+            state.target_url !== this.config.targetUrl) {
+            this.pairingState = "pairing-required";
+            this.configureSubscriptions();
+            this.publishAnchorState(this.anchorAlarm.snapshot());
+            this.startSafetyTimer();
+            await this.updateStatus();
+            return;
+        }
+        if (state.target_url === null) {
+            this.pairingState = "verifying";
+            try {
+                const response = await this.client.fetchRuntimeConfiguration(state.access_token);
+                await this.store.bindTarget(this.config.targetUrl);
+                this.pairingState = "paired";
+                this.operatingMode = state.operating_mode;
+                await this.applyRuntimeConfiguration(response.runtime_configuration);
+                state = await this.store.summary();
+            }
+            catch (error) {
+                this.runtimeConfigurationState = "unavailable";
+                if (error instanceof http_client_1.AuroraBlueHttpError && error.status === 401) {
+                    this.pairingState = "pairing-required";
+                }
+                else {
+                    this.scheduleRuntimeConfigurationPoll(this.config.retryMinimumMs);
+                }
+                await this.updateStatus();
+                return;
+            }
+        }
+        this.pairingState = "paired";
         this.operatingMode = state.operating_mode;
         this.configureSubscriptions();
         this.publishAnchorState(this.anchorAlarm.snapshot());
@@ -134,7 +173,9 @@ class ConnectorRuntime {
                 this.publishAnchorTransition(transition);
             }
         }
-        if (this.operatingMode !== "active" || events.length === 0) {
+        if (this.pairingState !== "paired" ||
+            this.operatingMode !== "active" ||
+            events.length === 0) {
             return;
         }
         const admitted = events.slice(0, MAXIMUM_PENDING_CAPTURE_EVENTS - this.pendingCaptureEvents);
@@ -183,8 +224,12 @@ class ConnectorRuntime {
         const state = await this.store.summary();
         const emittedPerHour = this.emittedPerHour();
         return {
-            paired: state.device_id !== null,
+            paired: state.device_id !== null && this.pairingState === "paired",
+            pairingState: this.pairingState,
             deviceId: state.device_id,
+            pairedTargetUrl: state.target_url,
+            lastPairingChangeAt: state.last_pairing_change_at,
+            discardedEventsOnLastPairing: state.last_pairing_discarded_events,
             bufferedEvents: state.bufferedEvents,
             acceptedThrough: state.accepted_through,
             lastSuccessAt: state.last_success_at,
@@ -203,11 +248,13 @@ class ConnectorRuntime {
                 ? null
                 : budget.remainingEvents / emittedPerHour,
             operatingMode: state.operating_mode,
-            transferState: this.transferNotice !== null
-                ? "delayed"
-                : state.last_success_at === null
-                    ? "waiting"
-                    : "healthy",
+            transferState: this.pairingState !== "paired"
+                ? "waiting"
+                : this.transferNotice !== null
+                    ? "delayed"
+                    : state.last_success_at === null
+                        ? "waiting"
+                        : "healthy",
             transferMessage: this.transferNotice,
             runtimeConfigurationState: this.runtimeConfigurationState,
             runtimeConfigurationUpdatedAt: this.runtimeConfigurationUpdatedAt,
@@ -249,6 +296,10 @@ class ConnectorRuntime {
             }
         }
         catch (error) {
+            if (error instanceof http_client_1.AuroraBlueHttpError && error.status === 401) {
+                await this.requirePairing();
+                return;
+            }
             this.retryAttempt += 1;
             const delay = (0, backoff_1.retryDelay)(this.retryAttempt, this.config.retryMinimumMs, this.config.retryMaximumMs, this.random);
             const reason = error instanceof http_client_1.AuroraBlueHttpError
@@ -266,6 +317,12 @@ class ConnectorRuntime {
         if (this.operatingMode === "disabled") {
             return;
         }
+        if (this.pairingState !== "paired") {
+            if (this.config.anchorAlarm.enabled) {
+                this.subscribeToContext("vessels.self", ["navigation.position"], this.config.safetySamplePeriodMs);
+            }
+            return;
+        }
         if (this.operatingMode === "standby") {
             if (this.config.anchorAlarm.enabled) {
                 this.subscribeToContext("vessels.self", ["navigation.position"], this.config.safetySamplePeriodMs);
@@ -390,16 +447,62 @@ class ConnectorRuntime {
         if (state.access_token === null) {
             return;
         }
+        if (state.target_url !== null &&
+            state.target_url !== this.config.targetUrl) {
+            await this.requirePairing();
+            return;
+        }
         try {
             const response = await this.client.fetchRuntimeConfiguration(state.access_token);
+            if (state.target_url === null) {
+                await this.store.bindTarget(this.config.targetUrl);
+            }
+            this.pairingState = "paired";
             await this.applyRuntimeConfiguration(response.runtime_configuration);
+            if (this.unsubscribes.length === 0) {
+                this.operatingMode = response.runtime_configuration.operating_mode;
+                this.configureSubscriptions();
+                this.publishAnchorState(this.anchorAlarm.snapshot());
+                this.startSafetyTimer();
+                if (this.operatingMode !== "disabled") {
+                    this.schedule(0);
+                }
+            }
         }
-        catch {
+        catch (error) {
             this.runtimeConfigurationState = "unavailable";
+            if (error instanceof http_client_1.AuroraBlueHttpError && error.status === 401) {
+                await this.requirePairing();
+                return;
+            }
         }
         await this.updateStatus();
         this.scheduleRuntimeConfigurationPoll(this.runtimeConfigurationPollMs);
     }
+    async requirePairing() {
+        this.pairingState = "pairing-required";
+        this.transferNotice = null;
+        this.runtimeConfigurationState = "unavailable";
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.runtimeConfigurationTimer !== null) {
+            clearTimeout(this.runtimeConfigurationTimer);
+            this.runtimeConfigurationTimer = null;
+        }
+        if (this.safetyTimer !== null) {
+            clearInterval(this.safetyTimer);
+            this.safetyTimer = null;
+        }
+        for (const unsubscribe of this.unsubscribes.splice(0)) {
+            unsubscribe();
+        }
+        this.configureSubscriptions();
+        this.publishAnchorState(this.anchorAlarm.snapshot());
+        this.startSafetyTimer();
+        await this.updateStatus();
+    }
     async applyRuntimeConfiguration(configuration) {
         const previousMode = this.operatingMode;
         this.runtimeConfigurationPollMs = configuration.poll_after_seconds * 1_000;
@@ -431,7 +534,13 @@ class ConnectorRuntime {
             ? `, suppressed ${status.suppressedEvents}`
             : "";
         const lastSuccess = status.lastSuccessAt ?? "never";
-        const prefix = this.transferNotice ?? "Paired";
+        const prefix = this.pairingState === "pairing-required"
+            ? "Pairing required - enter a new code; buffered data is discarded after successful pairing"
+            : this.pairingState === "verifying"
+                ? "Verifying pairing"
+                : this.pairingState === "unpaired"
+                    ? "Unpaired"
+                    : (this.transferNotice ?? "Paired");
         const utilization = (status.bufferUtilization * 100).toFixed(1);
         const remaining = status.estimatedRemainingBufferHours === null
             ? "estimating remaining time"

package/dist/src/state-store.d.ts

@@ -25,7 +25,9 @@ export declare class StateStore {
     }>;
     journalMetrics(): Promise<JournalMetrics>;
     filesystemCapacity(): Promise<FilesystemCapacity | null>;
-    setPairing(pairing: PairingResponse): Promise<void>;
+    setPairing(pairing: PairingResponse, targetUrl: string): Promise<void>;
+    bindTarget(targetUrl: string): Promise<void>;
+    replacePairing(pairing: PairingResponse, targetUrl: string): Promise<number>;
     setOperatingMode(operatingMode: OperatingMode): Promise<void>;
     append(event: EventInput, eventLimit: number, byteLimit?: number): Promise<BufferedEvent | null>;
     pendingBatch(maximumEvents: number): Promise<IngestBatch | null>;
@@ -39,6 +41,8 @@ export declare class StateStore {
     private migrateLegacy;
     private preserveLegacyBackup;
     private removeStaleTemporaryFiles;
+    private journalDirectory;
+    private removeObsoleteJournals;
     private persistMetadata;
     private exists;
     private readFilesystemCapacity;

package/dist/src/state-store.js

@@ -10,16 +10,21 @@ const METADATA_FILE = "metadata.json";
 const LEGACY_STATE_FILE = "state.json";
 const LEGACY_BACKUP_FILE = "state.v1.backup.json";
 const SEGMENT_PATTERN = /^segment-(\d{12})\.jsonl$/;
+const JOURNAL_DIRECTORY_PATTERN = /^journal-([a-zA-Z0-9-]+)$/;
 const initialState = () => ({
-    version: 2,
+    version: 3,
     protocol_version: types_1.PROTOCOL_VERSION,
     device_id: null,
     access_token: null,
+    target_url: null,
+    journal_generation: null,
     next_sequence: 1,
     accepted_through: 0,
     events: [],
     pending_batch: null,
     last_success_at: null,
+    last_pairing_change_at: null,
+    last_pairing_discarded_events: 0,
     operating_mode: "active",
 });
 const isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
@@ -27,12 +32,18 @@ const isSupportedProtocolVersion = (value) => typeof value === "string" &&
     types_1.SUPPORTED_PROTOCOL_VERSIONS.some((version) => version === value);
 const isOperatingMode = (value) => value === "active" || value === "standby" || value === "disabled";
 const assertState = (state) => {
-    if (state.version !== 2 ||
+    if (state.version !== 3 ||
         !isSupportedProtocolVersion(state.protocol_version) ||
         !isPositiveInteger(state.accepted_through) ||
         !isPositiveInteger(state.next_sequence) ||
         state.next_sequence < 1 ||
         !Array.isArray(state.events) ||
+        (state.target_url !== null && typeof state.target_url !== "string") ||
+        (state.journal_generation !== null &&
+            !/^[a-zA-Z0-9-]+$/.test(state.journal_generation)) ||
+        (state.last_pairing_change_at !== null &&
+            typeof state.last_pairing_change_at !== "string") ||
+        !isPositiveInteger(state.last_pairing_discarded_events) ||
         !isOperatingMode(state.operating_mode) ||
         (state.device_id === null) !== (state.access_token === null)) {
         throw new Error("Aurora Blue connector state is invalid.");
@@ -63,7 +74,11 @@ const assertState = (state) => {
 const assertLegacyState = (state) => {
     assertState({
         ...state,
-        version: 2,
+        version: 3,
+        target_url: null,
+        journal_generation: null,
+        last_pairing_change_at: null,
+        last_pairing_discarded_events: 0,
         operating_mode: isOperatingMode(state.operating_mode)
             ? state.operating_mode
             : "active",
@@ -72,14 +87,18 @@ const assertLegacyState = (state) => {
 const checksum = (event) => (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(event)).digest("hex");
 const encodeRecord = (event) => `${JSON.stringify({ checksum: checksum(event), event })}\n`;
 const metadataFrom = (state) => ({
-    version: 2,
+    version: 3,
     protocol_version: state.protocol_version,
     device_id: state.device_id,
     access_token: state.access_token,
+    target_url: state.target_url,
+    journal_generation: state.journal_generation,
     next_sequence: state.next_sequence,
     accepted_through: state.accepted_through,
     pending_batch: state.pending_batch,
     last_success_at: state.last_success_at,
+    last_pairing_change_at: state.last_pairing_change_at,
+    last_pairing_discarded_events: state.last_pairing_discarded_events,
     operating_mode: state.operating_mode,
 });
 class StateStore {
@@ -116,7 +135,7 @@ class StateStore {
             }
         }
         const metadata = await this.readMetadata();
-        const journal = await this.readJournal(metadata.accepted_through);
+        const journal = await this.readJournal(metadata.accepted_through, metadata.journal_generation);
         this.state = {
             ...metadata,
             protocol_version: types_1.PROTOCOL_VERSION,
@@ -128,9 +147,8 @@ class StateStore {
         await this.removeAcknowledgedSegments(this.state.accepted_through);
         await this.preserveLegacyBackup();
         await this.removeStaleTemporaryFiles();
-        if (metadata.protocol_version !== types_1.PROTOCOL_VERSION) {
-            await this.persistMetadata();
-        }
+        await this.removeObsoleteJournals(metadata.journal_generation);
+        await this.persistMetadata();
     }
     async snapshot() {
         await this.tail;
@@ -155,17 +173,56 @@ class StateStore {
         await this.tail;
         return this.capacityProvider();
     }
-    async setPairing(pairing) {
+    async setPairing(pairing, targetUrl) {
         await this.serialized(async () => {
             if (this.state.device_id !== null || this.state.events.length > 0) {
                 throw new Error("Connector is already paired or contains buffered events.");
             }
             this.state.device_id = pairing.device_id;
             this.state.access_token = pairing.access_token;
+            this.state.target_url = targetUrl;
+            this.state.last_pairing_change_at = this.now();
+            this.state.last_pairing_discarded_events = 0;
             this.state.operating_mode = pairing.runtime_configuration.operating_mode;
             await this.persistMetadata();
         });
     }
+    async bindTarget(targetUrl) {
+        await this.serialized(async () => {
+            if (this.state.device_id === null ||
+                this.state.access_token === null ||
+                this.state.target_url !== null) {
+                throw new Error("Connector target binding is not available.");
+            }
+            this.state.target_url = targetUrl;
+            await this.persistMetadata();
+        });
+    }
+    async replacePairing(pairing, targetUrl) {
+        let discardedEvents = 0;
+        await this.serialized(async () => {
+            discardedEvents = this.state.events.length;
+            const journalGeneration = this.uuid();
+            const nextJournalDirectory = this.journalDirectory(journalGeneration);
+            await (0, promises_1.mkdir)(nextJournalDirectory, { recursive: false, mode: 0o700 });
+            await (0, promises_1.chmod)(nextJournalDirectory, 0o700);
+            this.state = {
+                ...initialState(),
+                device_id: pairing.device_id,
+                access_token: pairing.access_token,
+                target_url: targetUrl,
+                journal_generation: journalGeneration,
+                last_pairing_change_at: this.now(),
+                last_pairing_discarded_events: discardedEvents,
+                operating_mode: pairing.runtime_configuration.operating_mode,
+            };
+            this.segments = [];
+            this.journalBytes = 0;
+            await this.persistMetadata();
+            await this.removeObsoleteJournals(journalGeneration).catch(() => undefined);
+        });
+        return discardedEvents;
+    }
     async setOperatingMode(operatingMode) {
         await this.serialized(async () => {
             this.state.operating_mode = operatingMode;
@@ -262,7 +319,7 @@ class StateStore {
         if (segment === undefined ||
             (segment.bytes > 0 &&
                 segment.bytes + payloadBytes > this.segmentMaximumBytes)) {
-            const path = (0, node_path_1.join)(this.directory, `segment-${String(event.sequence).padStart(12, "0")}.jsonl`);
+            const path = (0, node_path_1.join)(this.journalDirectory(this.state.journal_generation), `segment-${String(event.sequence).padStart(12, "0")}.jsonl`);
             segment = {
                 path,
                 firstSequence: event.sequence,
@@ -297,22 +354,41 @@ class StateStore {
         const parsedMetadata = parsed;
         const metadata = {
             ...parsedMetadata,
+            version: 3,
+            target_url: parsedMetadata.version === 3 ? parsedMetadata.target_url : null,
+            journal_generation: parsedMetadata.version === 3 ? parsedMetadata.journal_generation : null,
+            last_pairing_change_at: parsedMetadata.version === 3
+                ? parsedMetadata.last_pairing_change_at
+                : null,
+            last_pairing_discarded_events: parsedMetadata.version === 3
+                ? parsedMetadata.last_pairing_discarded_events
+                : 0,
             operating_mode: isOperatingMode(parsedMetadata.operating_mode)
                 ? parsedMetadata.operating_mode
                 : "active",
         };
-        if (metadata.version !== 2 ||
+        if (![2, 3].includes(parsedMetadata.version) ||
             !isSupportedProtocolVersion(metadata.protocol_version) ||
             !isPositiveInteger(metadata.accepted_through) ||
             !isPositiveInteger(metadata.next_sequence) ||
             !isOperatingMode(metadata.operating_mode) ||
+            (metadata.target_url !== null &&
+                typeof metadata.target_url !== "string") ||
+            (metadata.journal_generation !== null &&
+                !/^[a-zA-Z0-9-]+$/.test(metadata.journal_generation)) ||
+            (metadata.last_pairing_change_at !== null &&
+                typeof metadata.last_pairing_change_at !== "string") ||
+            !isPositiveInteger(metadata.last_pairing_discarded_events) ||
             (metadata.device_id === null) !== (metadata.access_token === null)) {
             throw new Error("Aurora Blue connector metadata is invalid.");
         }
         return metadata;
     }
-    async readJournal(acceptedThrough) {
-        const names = (await (0, promises_1.readdir)(this.directory))
+    async readJournal(acceptedThrough, journalGeneration) {
+        const directory = this.journalDirectory(journalGeneration);
+        await (0, promises_1.mkdir)(directory, { recursive: true, mode: 0o700 });
+        await (0, promises_1.chmod)(directory, 0o700);
+        const names = (await (0, promises_1.readdir)(directory))
             .filter((name) => SEGMENT_PATTERN.test(name))
             .sort();
         const events = [];
@@ -323,7 +399,7 @@ class StateStore {
             if (match === null) {
                 continue;
             }
-            const path = (0, node_path_1.join)(this.directory, name);
+            const path = (0, node_path_1.join)(directory, name);
             const segmentEvents = await this.readSegment(path);
             const details = await (0, promises_1.stat)(path);
             const firstSequence = Number(match[1]);
@@ -404,8 +480,12 @@ class StateStore {
         this.journalBytes = 0;
         this.state = {
             ...legacy,
-            version: 2,
+            version: 3,
             protocol_version: types_1.PROTOCOL_VERSION,
+            target_url: null,
+            journal_generation: null,
+            last_pairing_change_at: null,
+            last_pairing_discarded_events: 0,
             operating_mode: isOperatingMode(legacy.operating_mode)
                 ? legacy.operating_mode
                 : "active",
@@ -431,6 +511,23 @@ class StateStore {
             }
         }
     }
+    journalDirectory(generation) {
+        return generation === null
+            ? this.directory
+            : (0, node_path_1.join)(this.directory, `journal-${generation}`);
+    }
+    async removeObsoleteJournals(currentGeneration) {
+        const currentDirectory = currentGeneration === null ? null : `journal-${currentGeneration}`;
+        for (const name of await (0, promises_1.readdir)(this.directory)) {
+            if (SEGMENT_PATTERN.test(name) && currentGeneration !== null) {
+                await (0, promises_1.unlink)((0, node_path_1.join)(this.directory, name));
+                continue;
+            }
+            if (JOURNAL_DIRECTORY_PATTERN.test(name) && name !== currentDirectory) {
+                await (0, promises_1.rm)((0, node_path_1.join)(this.directory, name), { recursive: true, force: true });
+            }
+        }
+    }
     async persistMetadata() {
         const temporaryPath = (0, node_path_1.join)(this.directory, `.metadata-${this.uuid()}.tmp`);
         const payload = `${JSON.stringify(metadataFrom(this.state))}\n`;

package/dist/src/types.d.ts

@@ -3,6 +3,7 @@ export declare const PROTOCOL_VERSION: "1.1";
 export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly ["1.0", "1.1"];
 export type ProtocolVersion = (typeof SUPPORTED_PROTOCOL_VERSIONS)[number];
 export type OperatingMode = "active" | "standby" | "disabled";
+export type PairingState = "unpaired" | "verifying" | "paired" | "pairing-required";
 export interface RuntimeConfiguration {
     version: number;
     operating_mode: OperatingMode;
@@ -67,31 +68,43 @@ export interface RuntimeConfigurationResponse {
     server_time: string;
 }
 export interface PersistedState {
-    version: 2;
+    version: 3;
     protocol_version: ProtocolVersion;
     device_id: string | null;
     access_token: string | null;
+    target_url: string | null;
+    journal_generation: string | null;
     next_sequence: number;
     accepted_through: number;
     events: BufferedEvent[];
     pending_batch: IngestBatch | null;
     last_success_at: string | null;
+    last_pairing_change_at: string | null;
+    last_pairing_discarded_events: number;
     operating_mode: OperatingMode;
 }
 export interface PersistedMetadata {
-    version: 2;
+    version: 3;
     protocol_version: ProtocolVersion;
     device_id: string | null;
     access_token: string | null;
+    target_url: string | null;
+    journal_generation: string | null;
     next_sequence: number;
     accepted_through: number;
     pending_batch: IngestBatch | null;
     last_success_at: string | null;
+    last_pairing_change_at: string | null;
+    last_pairing_discarded_events: number;
     operating_mode: OperatingMode;
 }
 export interface ConnectorStatus {
     paired: boolean;
+    pairingState: PairingState;
     deviceId: string | null;
+    pairedTargetUrl: string | null;
+    lastPairingChangeAt: string | null;
+    discardedEventsOnLastPairing: number;
     bufferedEvents: number;
     acceptedThrough: number;
     lastSuccessAt: string | null;

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const CONNECTOR_VERSION = "0.2.0-dev.20";
+export declare const CONNECTOR_VERSION = "0.2.0-dev.22";

package/dist/src/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONNECTOR_VERSION = void 0;
-exports.CONNECTOR_VERSION = "0.2.0-dev.20";
+exports.CONNECTOR_VERSION = "0.2.0-dev.22";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurora-blue/signalk-connector",
-  "version": "0.2.0-dev.20",
+  "version": "0.2.0-dev.22",
   "description": "Signal K edge connector for the Aurora Blue ABOARD ingest protocol",
   "private": false,
   "main": "dist/src/index.js",

package/public/index.html

@@ -72,7 +72,7 @@
         aria-label="Connector summary"
         data-i18n-aria-label="summary.label"
       >
-        <article class="card">
+        <article id="pairing-card" class="card">
           <span class="label" data-i18n="summary.pairing">Pairing</span>
           <strong id="pairing" data-i18n="status.unknown">Unknown</strong>
           <span

package/public/locales/de.json

@@ -38,6 +38,9 @@
   "status.updated": "Aktualisiert {time}",
   "status.paired": "Gekoppelt",
   "status.unpaired": "Nicht gekoppelt",
+  "status.pairing_required_detail": "Geben Sie in der Konfiguration einen neuen Kopplungscode ein. Nach erfolgreicher Kopplung wird der Offline-Puffer des vorherigen Servers dauerhaft gelöscht.",
+  "status.pairing_verifying_detail": "Die bestehende Kopplung wird für diesen Server geprüft.",
+  "status.pairing_discarded": "Beim letzten Serverwechsel wurden {count} gepufferte Ereignisse gelöscht.",
   "status.runtime_configuration": "Laufzeitkonfiguration {state}",
   "status.last_success": "Letzter Erfolg: {time}",
   "status.events": "{current} / {limit} Ereignisse",
@@ -57,6 +60,10 @@
   "value.configuration.cached": "zwischengespeichert",
   "value.configuration.current": "aktuell",
   "value.configuration.unavailable": "nicht verfügbar",
+  "value.pairing.unpaired": "Nicht gekoppelt",
+  "value.pairing.verifying": "Wird geprüft",
+  "value.pairing.paired": "Gekoppelt",
+  "value.pairing.pairing_required": "Kopplung erforderlich",
   "value.transfer.waiting": "Wartet",
   "value.transfer.healthy": "Fehlerfrei",
   "value.transfer.delayed": "Verzögert",

package/public/locales/en.json

@@ -38,6 +38,9 @@
   "status.updated": "Updated {time}",
   "status.paired": "Paired",
   "status.unpaired": "Unpaired",
+  "status.pairing_required_detail": "Enter a new pairing code in the configuration. After successful pairing, the offline buffer for the previous server is permanently discarded.",
+  "status.pairing_verifying_detail": "The existing pairing is being verified for this server.",
+  "status.pairing_discarded": "The last server change discarded {count} buffered events.",
   "status.runtime_configuration": "Runtime configuration {state}",
   "status.last_success": "Last success: {time}",
   "status.events": "{current} / {limit} events",
@@ -57,6 +60,10 @@
   "value.configuration.cached": "cached",
   "value.configuration.current": "current",
   "value.configuration.unavailable": "unavailable",
+  "value.pairing.unpaired": "Unpaired",
+  "value.pairing.verifying": "Verifying",
+  "value.pairing.paired": "Paired",
+  "value.pairing.pairing_required": "Pairing Required",
   "value.transfer.waiting": "Waiting",
   "value.transfer.healthy": "Healthy",
   "value.transfer.delayed": "Delayed",

package/public/locales/es.json

@@ -38,6 +38,9 @@
   "status.updated": "Actualizado {time}",
   "status.paired": "Emparejado",
   "status.unpaired": "No emparejado",
+  "status.pairing_required_detail": "Introduzca un nuevo código de emparejamiento en la configuración. Después de emparejar correctamente, el búfer sin conexión del servidor anterior se elimina de forma permanente.",
+  "status.pairing_verifying_detail": "Se está verificando el emparejamiento existente para este servidor.",
+  "status.pairing_discarded": "El último cambio de servidor eliminó {count} eventos almacenados en el búfer.",
   "status.runtime_configuration": "Configuración de ejecución {state}",
   "status.last_success": "Último éxito: {time}",
   "status.events": "{current} / {limit} eventos",
@@ -57,6 +60,10 @@
   "value.configuration.cached": "en caché",
   "value.configuration.current": "actual",
   "value.configuration.unavailable": "no disponible",
+  "value.pairing.unpaired": "No emparejado",
+  "value.pairing.verifying": "Verificando",
+  "value.pairing.paired": "Emparejado",
+  "value.pairing.pairing_required": "Emparejamiento necesario",
   "value.transfer.waiting": "Esperando",
   "value.transfer.healthy": "Correcta",
   "value.transfer.delayed": "Retrasada",

package/public/locales/fr.json

@@ -38,6 +38,9 @@
   "status.updated": "Mis à jour {time}",
   "status.paired": "Appairé",
   "status.unpaired": "Non appairé",
+  "status.pairing_required_detail": "Saisissez un nouveau code d'appairage dans la configuration. Après un appairage réussi, le tampon hors ligne de l'ancien serveur est définitivement supprimé.",
+  "status.pairing_verifying_detail": "L'appairage existant est en cours de vérification pour ce serveur.",
+  "status.pairing_discarded": "Le dernier changement de serveur a supprimé {count} événements mis en mémoire tampon.",
   "status.runtime_configuration": "Configuration d'exécution {state}",
   "status.last_success": "Dernier succès : {time}",
   "status.events": "{current} / {limit} événements",
@@ -57,6 +60,10 @@
   "value.configuration.cached": "en cache",
   "value.configuration.current": "actuelle",
   "value.configuration.unavailable": "indisponible",
+  "value.pairing.unpaired": "Non appairé",
+  "value.pairing.verifying": "Vérification",
+  "value.pairing.paired": "Appairé",
+  "value.pairing.pairing_required": "Appairage requis",
   "value.transfer.waiting": "En attente",
   "value.transfer.healthy": "Opérationnel",
   "value.transfer.delayed": "Retardé",

package/public/status.css

@@ -154,6 +154,10 @@ h2 {
   min-height: 9.5rem;
   padding: 1.5rem;
 }
+
+.card.attention {
+  border-color: var(--aboard-warning);
+}
 .card strong {
   margin-top: 1.15rem;
   font-size: var(--aboard-font-section);

package/public/status.js

@@ -119,13 +119,37 @@ const render = (payload) => {
     translatedValue("mode", status.operatingMode),
     toneForMode(status.operatingMode),
   );
-  setText("pairing", t(status.paired ? "status.paired" : "status.unpaired"));
-  setText(
-    "configuration-state",
-    t("status.runtime_configuration", {
-      state: translatedValue("configuration", status.runtimeConfigurationState),
-    }),
+  const pairingState =
+    status.pairingState ?? (status.paired ? "paired" : "unpaired");
+  const pairingCard = element("pairing-card");
+  pairingCard.classList.toggle(
+    "attention",
+    pairingState === "pairing-required",
   );
+  setText("pairing", translatedValue("pairing", pairingState));
+
+  if (pairingState === "pairing-required") {
+    setText("configuration-state", t("status.pairing_required_detail"));
+  } else if (pairingState === "verifying") {
+    setText("configuration-state", t("status.pairing_verifying_detail"));
+  } else if (status.discardedEventsOnLastPairing > 0) {
+    setText(
+      "configuration-state",
+      t("status.pairing_discarded", {
+        count: number.format(status.discardedEventsOnLastPairing),
+      }),
+    );
+  } else {
+    setText(
+      "configuration-state",
+      t("status.runtime_configuration", {
+        state: translatedValue(
+          "configuration",
+          status.runtimeConfigurationState,
+        ),
+      }),
+    );
+  }
   setText("transfer", translatedValue("transfer", status.transferState));
   const delayed = status.transferMessage?.match(
     /^Transfer delayed \((HTTP (\d+)|target unavailable)\) - retry in (\d+)s$/,