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

package/dist/src/http-client.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuroraBlueHttpClient = exports.AuroraBlueHttpError = void 0;
+const node_zlib_1 = require("node:zlib");
+const version_1 = require("./version");
+const types_1 = require("./types");
+const defaultRuntimeConfiguration = () => ({
+    version: 0,
+    operating_mode: "active",
+    poll_after_seconds: 60,
+});
+const runtimeConfigurationFrom = (value) => {
+    if (value === undefined) {
+        return defaultRuntimeConfiguration();
+    }
+    const configuration = value;
+    if (typeof configuration.version !== "number" ||
+        !Number.isInteger(configuration.version) ||
+        configuration.version < 1 ||
+        !["active", "standby", "disabled"].includes(String(configuration.operating_mode)) ||
+        typeof configuration.poll_after_seconds !== "number" ||
+        !Number.isInteger(configuration.poll_after_seconds) ||
+        configuration.poll_after_seconds < 10 ||
+        configuration.poll_after_seconds > 3600) {
+        throw new Error("Aurora Blue runtime configuration is invalid.");
+    }
+    return configuration;
+};
+class AuroraBlueHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "AuroraBlueHttpError";
+    }
+}
+exports.AuroraBlueHttpError = AuroraBlueHttpError;
+class AuroraBlueHttpClient {
+    baseUrl;
+    timeoutMs;
+    fetchImplementation;
+    compressionThresholdBytes;
+    constructor(baseUrl, timeoutMs, fetchImplementation = fetch, compressionThresholdBytes = 1_024) {
+        this.baseUrl = baseUrl;
+        this.timeoutMs = timeoutMs;
+        this.fetchImplementation = fetchImplementation;
+        this.compressionThresholdBytes = compressionThresholdBytes;
+    }
+    async pair(pairingCode, deviceName, connectorVersion) {
+        const response = await this.request("/api/v1/pairings/exchange", {
+            method: "POST",
+            body: JSON.stringify({
+                pairing_code: pairingCode,
+                device_name: deviceName,
+                connector_version: connectorVersion,
+            }),
+        });
+        if (response.protocol_version !== types_1.PROTOCOL_VERSION ||
+            typeof response.device_id !== "string" ||
+            response.token_type !== "Bearer" ||
+            typeof response.access_token !== "string" ||
+            response.access_token === "") {
+            throw new Error("Aurora Blue pairing response is invalid.");
+        }
+        return {
+            ...response,
+            runtime_configuration: runtimeConfigurationFrom(response.runtime_configuration),
+        };
+    }
+    async sendBatch(batch, accessToken) {
+        const json = JSON.stringify(batch);
+        const compress = this.compressionThresholdBytes !== null &&
+            Buffer.byteLength(json) >= this.compressionThresholdBytes;
+        const response = await this.request("/api/v1/ingest/batches", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                ...(compress ? { "Content-Encoding": "gzip" } : {}),
+            },
+            body: compress ? new Uint8Array((0, node_zlib_1.gzipSync)(json)) : json,
+        });
+        if (typeof response.accepted_through !== "number" ||
+            !Number.isInteger(response.accepted_through) ||
+            typeof response.server_time !== "string" ||
+            Number.isNaN(Date.parse(response.server_time))) {
+            throw new Error("Aurora Blue ingest acknowledgement is invalid.");
+        }
+        return {
+            ...response,
+            runtime_configuration: runtimeConfigurationFrom(response.runtime_configuration),
+        };
+    }
+    async fetchRuntimeConfiguration(accessToken) {
+        const response = await this.request("/api/v1/devices/self/runtime-configuration", {
+            method: "GET",
+            headers: { Authorization: `Bearer ${accessToken}` },
+        });
+        if (typeof response.server_time !== "string" ||
+            Number.isNaN(Date.parse(response.server_time))) {
+            throw new Error("Aurora Blue runtime configuration response is invalid.");
+        }
+        return {
+            runtime_configuration: runtimeConfigurationFrom(response.runtime_configuration),
+            server_time: response.server_time,
+        };
+    }
+    async request(path, init) {
+        const abort = new AbortController();
+        const timeout = setTimeout(() => abort.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImplementation(new URL(path, `${this.baseUrl}/`), {
+                ...init,
+                signal: abort.signal,
+                headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                    "X-Aurora-Blue-Connector-Version": version_1.CONNECTOR_VERSION,
+                    ...init.headers,
+                },
+            });
+            const body = await this.readJson(response);
+            if (!response.ok) {
+                throw new AuroraBlueHttpError(response.status, `Aurora Blue request failed with HTTP ${response.status}.`);
+            }
+            return body;
+        }
+        catch (error) {
+            if (error instanceof AuroraBlueHttpError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error("Aurora Blue request timed out.");
+            }
+            throw new Error("Aurora Blue target is unavailable.", { cause: error });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async readJson(response) {
+        const text = await response.text();
+        if (text === "") {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(text);
+            return parsed !== null &&
+                typeof parsed === "object" &&
+                !Array.isArray(parsed)
+                ? parsed
+                : {};
+        }
+        catch {
+            return {};
+        }
+    }
+}
+exports.AuroraBlueHttpClient = AuroraBlueHttpClient;

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin, ServerAPI } from "@signalk/server-api";
+declare const createPlugin: (app: ServerAPI) => Plugin;
+export = createPlugin;

package/dist/src/index.js

@@ -0,0 +1,93 @@
+"use strict";
+const config_1 = require("./config");
+const connector_1 = require("./connector");
+const state_store_1 = require("./state-store");
+const createPlugin = (app) => {
+    let runtime = null;
+    let startup = null;
+    let lifecycle = "stopped";
+    let lastError = null;
+    const recordError = (message) => {
+        lifecycle = "error";
+        lastError = {
+            message,
+            occurred_at: new Date().toISOString(),
+        };
+    };
+    const statusResponse = async () => {
+        let status = null;
+        if (runtime !== null) {
+            const { deviceId, ...publicStatus } = await runtime.status();
+            void deviceId;
+            status = publicStatus;
+        }
+        return {
+            connector_version: connector_1.CONNECTOR_VERSION,
+            lifecycle,
+            generated_at: new Date().toISOString(),
+            last_error: lastError,
+            status,
+        };
+    };
+    return {
+        id: "aurora-blue-signalk-connector",
+        name: "Aurora Blue ABOARD Connector",
+        description: "Buffers selected Signal K data and transfers it to Aurora Blue ABOARD.",
+        schema: config_1.pluginSchema,
+        uiSchema: config_1.pluginUiSchema,
+        registerWithRouter: (router) => {
+            const compatibleRouter = router;
+            compatibleRouter.get("/status", (_request, response) => {
+                void statusResponse()
+                    .then((status) => response.json(status))
+                    .catch(() => response.status(500).json({
+                    message: "Aurora Blue ABOARD connector status is unavailable.",
+                }));
+            });
+        },
+        start: (input) => {
+            lifecycle = "starting";
+            lastError = null;
+            try {
+                const config = (0, config_1.resolveConfig)(input);
+                const store = new state_store_1.StateStore(app.getDataDirPath(), {
+                    segmentMaximumBytes: config.bufferSegmentBytes,
+                });
+                runtime = new connector_1.ConnectorRuntime(app, store, config);
+                startup = runtime.start().then(() => {
+                    lifecycle = "running";
+                    if (config.pairingCode === undefined) {
+                        return;
+                    }
+                    const sanitized = { ...input };
+                    delete sanitized.pairingCode;
+                    app.savePluginOptions(sanitized, (error) => {
+                        if (error !== null) {
+                            app.error("Paired successfully, but the short-lived pairing code could not be cleared.");
+                        }
+                    });
+                });
+                void startup.catch((error) => {
+                    recordError("Connector startup failed.");
+                    app.setPluginError(error instanceof Error
+                        ? error.message
+                        : "Connector startup failed.");
+                });
+            }
+            catch (error) {
+                recordError("Connector configuration is invalid.");
+                app.setPluginError(error instanceof Error
+                    ? error.message
+                    : "Connector configuration is invalid.");
+            }
+        },
+        stop: async () => {
+            await startup?.catch(() => undefined);
+            await runtime?.stop();
+            startup = null;
+            runtime = null;
+            lifecycle = "stopped";
+        },
+    };
+};
+module.exports = createPlugin;

package/dist/src/safety/anchor-alarm.d.ts

@@ -0,0 +1,33 @@
+import type { PositionValue } from "../types";
+export type AnchorAlarmState = "inactive" | "armed" | "warning" | "alarm" | "position-lost";
+export interface AnchorAlarmConfig {
+    enabled: boolean;
+    anchor: PositionValue | null;
+    radiusMeters: number;
+    hysteresisMeters: number;
+    confirmationMs: number;
+    stalePositionMs: number;
+}
+export interface AnchorAlarmSnapshot {
+    state: AnchorAlarmState;
+    changedAt: string;
+    distanceMeters: number | null;
+    lastPositionAt: string | null;
+}
+export interface AnchorAlarmTransition extends AnchorAlarmSnapshot {
+    previousState: AnchorAlarmState;
+}
+export declare class AnchorAlarmEngine {
+    private readonly config;
+    private state;
+    private stateChangedAt;
+    private outsideSince;
+    private lastPositionAt;
+    private lastDistanceMeters;
+    constructor(config: AnchorAlarmConfig, startedAt: number);
+    observe(position: PositionValue, observedAt: number): AnchorAlarmTransition | null;
+    checkStale(now: number): AnchorAlarmTransition | null;
+    snapshot(): AnchorAlarmSnapshot;
+    private isConfigured;
+    private transition;
+}

package/dist/src/safety/anchor-alarm.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnchorAlarmEngine = void 0;
+const geometry_1 = require("../geometry");
+class AnchorAlarmEngine {
+    config;
+    state;
+    stateChangedAt;
+    outsideSince = null;
+    lastPositionAt = null;
+    lastDistanceMeters = null;
+    constructor(config, startedAt) {
+        this.config = config;
+        this.state = this.isConfigured() ? "armed" : "inactive";
+        this.stateChangedAt = startedAt;
+    }
+    observe(position, observedAt) {
+        if (!this.isConfigured()) {
+            return null;
+        }
+        this.lastPositionAt = observedAt;
+        const anchor = this.config.anchor;
+        const distance = (0, geometry_1.distanceMeters)(anchor, position);
+        this.lastDistanceMeters = distance;
+        if (this.state === "alarm") {
+            const clearThreshold = Math.max(0, this.config.radiusMeters - this.config.hysteresisMeters);
+            if (distance > clearThreshold) {
+                return null;
+            }
+            this.outsideSince = null;
+            return this.transition("armed", observedAt);
+        }
+        if (distance <= this.config.radiusMeters) {
+            this.outsideSince = null;
+            return this.transition("armed", observedAt);
+        }
+        if (this.outsideSince === null) {
+            this.outsideSince = observedAt;
+        }
+        if (observedAt - this.outsideSince >= this.config.confirmationMs) {
+            return this.transition("alarm", observedAt);
+        }
+        return this.transition("warning", observedAt);
+    }
+    checkStale(now) {
+        if (!this.isConfigured()) {
+            return null;
+        }
+        const reference = this.lastPositionAt ?? this.stateChangedAt;
+        if (now - reference < this.config.stalePositionMs) {
+            return null;
+        }
+        this.outsideSince = null;
+        return this.transition("position-lost", now);
+    }
+    snapshot() {
+        return {
+            state: this.state,
+            changedAt: new Date(this.stateChangedAt).toISOString(),
+            distanceMeters: this.lastDistanceMeters,
+            lastPositionAt: this.lastPositionAt === null
+                ? null
+                : new Date(this.lastPositionAt).toISOString(),
+        };
+    }
+    isConfigured() {
+        return this.config.enabled && this.config.anchor !== null;
+    }
+    transition(next, changedAt) {
+        if (next === this.state) {
+            return null;
+        }
+        const previousState = this.state;
+        this.state = next;
+        this.stateChangedAt = changedAt;
+        return { previousState, ...this.snapshot() };
+    }
+}
+exports.AnchorAlarmEngine = AnchorAlarmEngine;

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

@@ -0,0 +1,45 @@
+import { type BufferedEvent, type EventInput, type IngestBatch, type PairingResponse, type OperatingMode, type PersistedMetadata, type PersistedState } from "./types";
+import type { FilesystemCapacity, JournalMetrics } from "./storage-budget";
+export interface StateStoreOptions {
+    now?: () => string;
+    uuid?: () => string;
+    segmentMaximumBytes?: number;
+    filesystemCapacity?: () => Promise<FilesystemCapacity | null>;
+}
+export declare class StateStore {
+    private readonly directory;
+    private readonly metadataPath;
+    private readonly now;
+    private readonly uuid;
+    private readonly segmentMaximumBytes;
+    private readonly capacityProvider;
+    private state;
+    private segments;
+    private journalBytes;
+    private tail;
+    constructor(directory: string, options?: StateStoreOptions);
+    load(): Promise<void>;
+    snapshot(): Promise<PersistedState>;
+    summary(): Promise<Omit<PersistedMetadata, "pending_batch"> & {
+        bufferedEvents: number;
+    }>;
+    journalMetrics(): Promise<JournalMetrics>;
+    filesystemCapacity(): Promise<FilesystemCapacity | null>;
+    setPairing(pairing: PairingResponse): Promise<void>;
+    setOperatingMode(operatingMode: OperatingMode): Promise<void>;
+    append(event: EventInput, eventLimit: number, byteLimit?: number): Promise<BufferedEvent | null>;
+    pendingBatch(maximumEvents: number): Promise<IngestBatch | null>;
+    acknowledge(acceptedThrough: number): Promise<void>;
+    private serialized;
+    private appendRecord;
+    private readMetadata;
+    private readJournal;
+    private readSegment;
+    private removeAcknowledgedSegments;
+    private migrateLegacy;
+    private preserveLegacyBackup;
+    private removeStaleTemporaryFiles;
+    private persistMetadata;
+    private exists;
+    private readFilesystemCapacity;
+}